1 //
2 // Copyright 2019 The Abseil Authors.
3 //
4 // Licensed under the Apache License, Version 2.0 (the "License");
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
7 //
8 // https://www.apache.org/licenses/LICENSE-2.0
9 //
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
15
16 #include "absl/flags/marshalling.h"
17
18 #include <stddef.h>
19
20 #include <cmath>
21 #include <limits>
22 #include <string>
23 #include <type_traits>
24 #include <vector>
25
26 #include "absl/base/config.h"
27 #include "absl/base/log_severity.h"
28 #include "absl/base/macros.h"
29 #include "absl/strings/ascii.h"
30 #include "absl/strings/match.h"
31 #include "absl/strings/numbers.h"
32 #include "absl/strings/str_cat.h"
33 #include "absl/strings/str_format.h"
34 #include "absl/strings/str_join.h"
35 #include "absl/strings/str_split.h"
36 #include "absl/strings/string_view.h"
37
38 namespace absl {
39 ABSL_NAMESPACE_BEGIN
40 namespace flags_internal {
41
42 // --------------------------------------------------------------------
43 // AbslParseFlag specializations for boolean type.
44
AbslParseFlag(absl::string_view text,bool * dst,std::string *)45 bool AbslParseFlag(absl::string_view text, bool* dst, std::string*) {
46 const char* kTrue[] = {"1", "t", "true", "y", "yes"};
47 const char* kFalse[] = {"0", "f", "false", "n", "no"};
48 static_assert(sizeof(kTrue) == sizeof(kFalse), "true_false_equal");
49
50 text = absl::StripAsciiWhitespace(text);
51
52 for (size_t i = 0; i < ABSL_ARRAYSIZE(kTrue); ++i) {
53 if (absl::EqualsIgnoreCase(text, kTrue[i])) {
54 *dst = true;
55 return true;
56 } else if (absl::EqualsIgnoreCase(text, kFalse[i])) {
57 *dst = false;
58 return true;
59 }
60 }
61 return false; // didn't match a legal input
62 }
63
64 // --------------------------------------------------------------------
65 // AbslParseFlag for integral types.
66
67 // Return the base to use for parsing text as an integer. Leading 0x
68 // puts us in base 16. But leading 0 does not put us in base 8. It
69 // caused too many bugs when we had that behavior.
NumericBase(absl::string_view text)70 static int NumericBase(absl::string_view text) {
71 const bool hex = (text.size() >= 2 && text[0] == '0' &&
72 (text[1] == 'x' || text[1] == 'X'));
73 return hex ? 16 : 10;
74 }
75
76 template <typename IntType>
ParseFlagImpl(absl::string_view text,IntType * dst)77 inline bool ParseFlagImpl(absl::string_view text, IntType* dst) {
78 text = absl::StripAsciiWhitespace(text);
79
80 return absl::numbers_internal::safe_strtoi_base(text, dst, NumericBase(text));
81 }
82
AbslParseFlag(absl::string_view text,short * dst,std::string *)83 bool AbslParseFlag(absl::string_view text, short* dst, std::string*) {
84 int val;
85 if (!ParseFlagImpl(text, &val)) return false;
86 if (static_cast<short>(val) != val) // worked, but number out of range
87 return false;
88 *dst = static_cast<short>(val);
89 return true;
90 }
91
AbslParseFlag(absl::string_view text,unsigned short * dst,std::string *)92 bool AbslParseFlag(absl::string_view text, unsigned short* dst, std::string*) {
93 unsigned int val;
94 if (!ParseFlagImpl(text, &val)) return false;
95 if (static_cast<unsigned short>(val) !=
96 val) // worked, but number out of range
97 return false;
98 *dst = static_cast<unsigned short>(val);
99 return true;
100 }
101
AbslParseFlag(absl::string_view text,int * dst,std::string *)102 bool AbslParseFlag(absl::string_view text, int* dst, std::string*) {
103 return ParseFlagImpl(text, dst);
104 }
105
AbslParseFlag(absl::string_view text,unsigned int * dst,std::string *)106 bool AbslParseFlag(absl::string_view text, unsigned int* dst, std::string*) {
107 return ParseFlagImpl(text, dst);
108 }
109
AbslParseFlag(absl::string_view text,long * dst,std::string *)110 bool AbslParseFlag(absl::string_view text, long* dst, std::string*) {
111 return ParseFlagImpl(text, dst);
112 }
113
AbslParseFlag(absl::string_view text,unsigned long * dst,std::string *)114 bool AbslParseFlag(absl::string_view text, unsigned long* dst, std::string*) {
115 return ParseFlagImpl(text, dst);
116 }
117
AbslParseFlag(absl::string_view text,long long * dst,std::string *)118 bool AbslParseFlag(absl::string_view text, long long* dst, std::string*) {
119 return ParseFlagImpl(text, dst);
120 }
121
AbslParseFlag(absl::string_view text,unsigned long long * dst,std::string *)122 bool AbslParseFlag(absl::string_view text, unsigned long long* dst,
123 std::string*) {
124 return ParseFlagImpl(text, dst);
125 }
126
127 // --------------------------------------------------------------------
128 // AbslParseFlag for floating point types.
129
AbslParseFlag(absl::string_view text,float * dst,std::string *)130 bool AbslParseFlag(absl::string_view text, float* dst, std::string*) {
131 return absl::SimpleAtof(text, dst);
132 }
133
AbslParseFlag(absl::string_view text,double * dst,std::string *)134 bool AbslParseFlag(absl::string_view text, double* dst, std::string*) {
135 return absl::SimpleAtod(text, dst);
136 }
137
138 // --------------------------------------------------------------------
139 // AbslParseFlag for strings.
140
AbslParseFlag(absl::string_view text,std::string * dst,std::string *)141 bool AbslParseFlag(absl::string_view text, std::string* dst, std::string*) {
142 dst->assign(text.data(), text.size());
143 return true;
144 }
145
146 // --------------------------------------------------------------------
147 // AbslParseFlag for vector of strings.
148
AbslParseFlag(absl::string_view text,std::vector<std::string> * dst,std::string *)149 bool AbslParseFlag(absl::string_view text, std::vector<std::string>* dst,
150 std::string*) {
151 // An empty flag value corresponds to an empty vector, not a vector
152 // with a single, empty std::string.
153 if (text.empty()) {
154 dst->clear();
155 return true;
156 }
157 *dst = absl::StrSplit(text, ',', absl::AllowEmpty());
158 return true;
159 }
160
161 // --------------------------------------------------------------------
162 // AbslUnparseFlag specializations for various builtin flag types.
163
Unparse(bool v)164 std::string Unparse(bool v) { return v ? "true" : "false"; }
Unparse(short v)165 std::string Unparse(short v) { return absl::StrCat(v); }
Unparse(unsigned short v)166 std::string Unparse(unsigned short v) { return absl::StrCat(v); }
Unparse(int v)167 std::string Unparse(int v) { return absl::StrCat(v); }
Unparse(unsigned int v)168 std::string Unparse(unsigned int v) { return absl::StrCat(v); }
Unparse(long v)169 std::string Unparse(long v) { return absl::StrCat(v); }
Unparse(unsigned long v)170 std::string Unparse(unsigned long v) { return absl::StrCat(v); }
Unparse(long long v)171 std::string Unparse(long long v) { return absl::StrCat(v); }
Unparse(unsigned long long v)172 std::string Unparse(unsigned long long v) { return absl::StrCat(v); }
173 template <typename T>
UnparseFloatingPointVal(T v)174 std::string UnparseFloatingPointVal(T v) {
175 // digits10 is guaranteed to roundtrip correctly in string -> value -> string
176 // conversions, but may not be enough to represent all the values correctly.
177 std::string digit10_str =
178 absl::StrFormat("%.*g", std::numeric_limits<T>::digits10, v);
179 if (std::isnan(v) || std::isinf(v)) return digit10_str;
180
181 T roundtrip_val = 0;
182 std::string err;
183 if (absl::ParseFlag(digit10_str, &roundtrip_val, &err) &&
184 roundtrip_val == v) {
185 return digit10_str;
186 }
187
188 // max_digits10 is the number of base-10 digits that are necessary to uniquely
189 // represent all distinct values.
190 return absl::StrFormat("%.*g", std::numeric_limits<T>::max_digits10, v);
191 }
Unparse(float v)192 std::string Unparse(float v) { return UnparseFloatingPointVal(v); }
Unparse(double v)193 std::string Unparse(double v) { return UnparseFloatingPointVal(v); }
AbslUnparseFlag(absl::string_view v)194 std::string AbslUnparseFlag(absl::string_view v) { return std::string(v); }
AbslUnparseFlag(const std::vector<std::string> & v)195 std::string AbslUnparseFlag(const std::vector<std::string>& v) {
196 return absl::StrJoin(v, ",");
197 }
198
199 } // namespace flags_internal
200
AbslParseFlag(absl::string_view text,absl::LogSeverity * dst,std::string * err)201 bool AbslParseFlag(absl::string_view text, absl::LogSeverity* dst,
202 std::string* err) {
203 text = absl::StripAsciiWhitespace(text);
204 if (text.empty()) {
205 *err = "no value provided";
206 return false;
207 }
208 if (text.front() == 'k' || text.front() == 'K') text.remove_prefix(1);
209 if (absl::EqualsIgnoreCase(text, "info")) {
210 *dst = absl::LogSeverity::kInfo;
211 return true;
212 }
213 if (absl::EqualsIgnoreCase(text, "warning")) {
214 *dst = absl::LogSeverity::kWarning;
215 return true;
216 }
217 if (absl::EqualsIgnoreCase(text, "error")) {
218 *dst = absl::LogSeverity::kError;
219 return true;
220 }
221 if (absl::EqualsIgnoreCase(text, "fatal")) {
222 *dst = absl::LogSeverity::kFatal;
223 return true;
224 }
225 std::underlying_type<absl::LogSeverity>::type numeric_value;
226 if (absl::ParseFlag(text, &numeric_value, err)) {
227 *dst = static_cast<absl::LogSeverity>(numeric_value);
228 return true;
229 }
230 *err = "only integers and absl::LogSeverity enumerators are accepted";
231 return false;
232 }
233
AbslUnparseFlag(absl::LogSeverity v)234 std::string AbslUnparseFlag(absl::LogSeverity v) {
235 if (v == absl::NormalizeLogSeverity(v)) return absl::LogSeverityName(v);
236 return absl::UnparseFlag(static_cast<int>(v));
237 }
238
239 ABSL_NAMESPACE_END
240 } // namespace absl
241