1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
|
// Copyright 2016 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "net/base/parse_number.h"
#include "base/logging.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_util.h"
namespace net {
namespace {
// The string to number conversion functions in //base include the type in the
// name (like StringToInt64()). The following wrapper methods create a
// consistent interface to StringToXXX() that calls the appropriate //base
// version. This simplifies writing generic code with a template.
bool StringToNumber(const base::StringPiece& input, int32_t* output) {
// This assumes ints are 32-bits (will fail compile if that ever changes).
return base::StringToInt(input, output);
}
bool StringToNumber(const base::StringPiece& input, uint32_t* output) {
// This assumes ints are 32-bits (will fail compile if that ever changes).
return base::StringToUint(input, output);
}
bool StringToNumber(const base::StringPiece& input, int64_t* output) {
return base::StringToInt64(input, output);
}
bool StringToNumber(const base::StringPiece& input, uint64_t* output) {
return base::StringToUint64(input, output);
}
bool SetError(ParseIntError error, ParseIntError* optional_error) {
if (optional_error)
*optional_error = error;
return false;
}
template <typename T>
bool ParseIntHelper(const base::StringPiece& input,
ParseIntFormat format,
T* output,
ParseIntError* optional_error) {
// Check that the input matches the format before calling StringToNumber().
// Numbers must start with either a digit or a negative sign.
if (input.empty())
return SetError(ParseIntError::FAILED_PARSE, optional_error);
bool starts_with_negative = input[0] == '-';
bool starts_with_digit = base::IsAsciiDigit(input[0]);
if (!starts_with_digit) {
if (format == ParseIntFormat::NON_NEGATIVE || !starts_with_negative)
return SetError(ParseIntError::FAILED_PARSE, optional_error);
}
// Dispatch to the appropriate flavor of base::StringToXXX() by calling one of
// the type-specific overloads.
T result;
if (StringToNumber(input, &result)) {
*output = result;
return true;
}
// Optimization: If the error is not going to be inspected, don't bother
// calculating it.
if (!optional_error)
return false;
// Set an error that distinguishes between parsing/underflow/overflow errors.
//
// Note that the output set by base::StringToXXX() on failure cannot be used
// as it has ambiguity with parse errors.
// Strip any leading negative sign off the number.
base::StringPiece numeric_portion =
starts_with_negative ? input.substr(1) : input;
// Test if |numeric_portion| is a valid non-negative integer.
if (!numeric_portion.empty() &&
numeric_portion.find_first_not_of("0123456789") == std::string::npos) {
// If it was, the failure must have been due to underflow/overflow.
return SetError(starts_with_negative ? ParseIntError::FAILED_UNDERFLOW
: ParseIntError::FAILED_OVERFLOW,
optional_error);
}
// Otherwise it was a mundane parsing error.
return SetError(ParseIntError::FAILED_PARSE, optional_error);
}
} // namespace
bool ParseInt32(const base::StringPiece& input,
ParseIntFormat format,
int32_t* output,
ParseIntError* optional_error) {
return ParseIntHelper(input, format, output, optional_error);
}
bool ParseInt64(const base::StringPiece& input,
ParseIntFormat format,
int64_t* output,
ParseIntError* optional_error) {
return ParseIntHelper(input, format, output, optional_error);
}
bool ParseUint32(const base::StringPiece& input,
uint32_t* output,
ParseIntError* optional_error) {
return ParseIntHelper(input, ParseIntFormat::NON_NEGATIVE, output,
optional_error);
}
bool ParseUint64(const base::StringPiece& input,
uint64_t* output,
ParseIntError* optional_error) {
return ParseIntHelper(input, ParseIntFormat::NON_NEGATIVE, output,
optional_error);
}
} // namespace net
|
