Flutter Engine
The Flutter Engine
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
double-to-string.h
Go to the documentation of this file.
1// Copyright 2012 the V8 project authors. All rights reserved.
2// Redistribution and use in source and binary forms, with or without
3// modification, are permitted provided that the following conditions are
4// met:
5//
6// * Redistributions of source code must retain the above copyright
7// notice, this list of conditions and the following disclaimer.
8// * Redistributions in binary form must reproduce the above
9// copyright notice, this list of conditions and the following
10// disclaimer in the documentation and/or other materials provided
11// with the distribution.
12// * Neither the name of Google Inc. nor the names of its
13// contributors may be used to endorse or promote products derived
14// from this software without specific prior written permission.
15//
16// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
28#ifndef DOUBLE_CONVERSION_DOUBLE_TO_STRING_H_
29#define DOUBLE_CONVERSION_DOUBLE_TO_STRING_H_
30
31#include "utils.h"
32
33namespace double_conversion {
34
36 public:
37 // When calling ToFixed with a double > 10^kMaxFixedDigitsBeforePoint
38 // or a requested_digits parameter > kMaxFixedDigitsAfterPoint then the
39 // function returns false.
40 static const int kMaxFixedDigitsBeforePoint = 60;
41 static const int kMaxFixedDigitsAfterPoint = 100;
42
43 // When calling ToExponential with a requested_digits
44 // parameter > kMaxExponentialDigits then the function returns false.
45 static const int kMaxExponentialDigits = 120;
46
47 // When calling ToPrecision with a requested_digits
48 // parameter < kMinPrecisionDigits or requested_digits > kMaxPrecisionDigits
49 // then the function returns false.
50 static const int kMinPrecisionDigits = 1;
51 static const int kMaxPrecisionDigits = 120;
52
53 // The maximal number of digits that are needed to emit a double in base 10.
54 // A higher precision can be achieved by using more digits, but the shortest
55 // accurate representation of any double will never use more digits than
56 // kBase10MaximalLength.
57 // Note that DoubleToAscii null-terminates its input. So the given buffer
58 // should be at least kBase10MaximalLength + 1 characters long.
59 static const int kBase10MaximalLength = 17;
60
61 // The maximal number of digits that are needed to emit a single in base 10.
62 // A higher precision can be achieved by using more digits, but the shortest
63 // accurate representation of any single will never use more digits than
64 // kBase10MaximalLengthSingle.
65 static const int kBase10MaximalLengthSingle = 9;
66
67 // The length of the longest string that 'ToShortest' can produce when the
68 // converter is instantiated with EcmaScript defaults (see
69 // 'EcmaScriptConverter')
70 // This value does not include the trailing '\0' character.
71 // This amount of characters is needed for negative values that hit the
72 // 'decimal_in_shortest_low' limit. For example: "-0.0000033333333333333333"
73 static const int kMaxCharsEcmaScriptShortest = 25;
74
75 enum Flags {
84 };
85
86 // Flags should be a bit-or combination of the possible Flags-enum.
87 // - NO_FLAGS: no special flags.
88 // - EMIT_POSITIVE_EXPONENT_SIGN: when the number is converted into exponent
89 // form, emits a '+' for positive exponents. Example: 1.2e+2.
90 // - EMIT_TRAILING_DECIMAL_POINT: when the input number is an integer and is
91 // converted into decimal format then a trailing decimal point is appended.
92 // Example: 2345.0 is converted to "2345.".
93 // - EMIT_TRAILING_ZERO_AFTER_POINT: in addition to a trailing decimal point
94 // emits a trailing '0'-character. This flag requires the
95 // EMIT_TRAILING_DECIMAL_POINT flag.
96 // Example: 2345.0 is converted to "2345.0".
97 // - UNIQUE_ZERO: "-0.0" is converted to "0.0".
98 // - NO_TRAILING_ZERO: Trailing zeros are removed from the fractional portion
99 // of the result in precision mode. Matches printf's %g.
100 // When EMIT_TRAILING_ZERO_AFTER_POINT is also given, one trailing zero is
101 // preserved.
102 // - EMIT_TRAILING_DECIMAL_POINT_IN_EXPONENTIAL: when the input number has
103 // exactly one significant digit and is converted into exponent form then a
104 // trailing decimal point is appended to the significand in shortest mode
105 // or in precision mode with one requested digit.
106 // - EMIT_TRAILING_ZERO_AFTER_POINT_IN_EXPONENTIAL: in addition to a trailing
107 // decimal point emits a trailing '0'-character. This flag requires the
108 // EMIT_TRAILING_DECIMAL_POINT_IN_EXPONENTIAL flag.
109 //
110 // Infinity symbol and nan_symbol provide the string representation for these
111 // special values. If the string is NULL and the special value is encountered
112 // then the conversion functions return false.
113 //
114 // The exponent_character is used in exponential representations. It is
115 // usually 'e' or 'E'.
116 //
117 // When converting to the shortest representation the converter will
118 // represent input numbers in decimal format if they are in the interval
119 // [10^decimal_in_shortest_low; 10^decimal_in_shortest_high[
120 // (lower boundary included, greater boundary excluded).
121 // Example: with decimal_in_shortest_low = -6 and
122 // decimal_in_shortest_high = 21:
123 // ToShortest(0.000001) -> "0.000001"
124 // ToShortest(0.0000001) -> "1e-7"
125 // ToShortest(111111111111111111111.0) -> "111111111111111110000"
126 // ToShortest(100000000000000000000.0) -> "100000000000000000000"
127 // ToShortest(1111111111111111111111.0) -> "1.1111111111111111e+21"
128 //
129 // When converting to precision mode the converter may add
130 // max_leading_padding_zeroes before returning the number in exponential
131 // format.
132 // Example with max_leading_padding_zeroes_in_precision_mode = 6.
133 // ToPrecision(0.0000012345, 2) -> "0.0000012"
134 // ToPrecision(0.00000012345, 2) -> "1.2e-7"
135 // Similarly the converter may add up to
136 // max_trailing_padding_zeroes_in_precision_mode in precision mode to avoid
137 // returning an exponential representation. A zero added by the
138 // EMIT_TRAILING_ZERO_AFTER_POINT flag is counted for this limit.
139 // Examples for max_trailing_padding_zeroes_in_precision_mode = 1:
140 // ToPrecision(230.0, 2) -> "230"
141 // ToPrecision(230.0, 2) -> "230." with EMIT_TRAILING_DECIMAL_POINT.
142 // ToPrecision(230.0, 2) -> "2.3e2" with EMIT_TRAILING_ZERO_AFTER_POINT.
143 //
144 // When converting numbers with exactly one significant digit to exponent
145 // form in shortest mode or in precision mode with one requested digit, the
146 // EMIT_TRAILING_DECIMAL_POINT and EMIT_TRAILING_ZERO_AFTER_POINT flags have
147 // no effect. Use the EMIT_TRAILING_DECIMAL_POINT_IN_EXPONENTIAL flag to
148 // append a decimal point in this case and the
149 // EMIT_TRAILING_ZERO_AFTER_POINT_IN_EXPONENTIAL flag to also append a
150 // '0'-character in this case.
151 // Example with decimal_in_shortest_low = 0:
152 // ToShortest(0.0009) -> "9e-4"
153 // with EMIT_TRAILING_DECIMAL_POINT_IN_EXPONENTIAL deactivated.
154 // ToShortest(0.0009) -> "9.e-4"
155 // with EMIT_TRAILING_DECIMAL_POINT_IN_EXPONENTIAL activated.
156 // ToShortest(0.0009) -> "9.0e-4"
157 // with EMIT_TRAILING_DECIMAL_POINT_IN_EXPONENTIAL activated and
158 // EMIT_TRAILING_ZERO_AFTER_POINT_IN_EXPONENTIAL activated.
159 //
160 // The min_exponent_width is used for exponential representations.
161 // The converter adds leading '0's to the exponent until the exponent
162 // is at least min_exponent_width digits long.
163 // The min_exponent_width is clamped to 5.
164 // As such, the exponent may never have more than 5 digits in total.
166 const char* infinity_symbol,
167 const char* nan_symbol,
168 char exponent_character,
169 int decimal_in_shortest_low,
170 int decimal_in_shortest_high,
171 int max_leading_padding_zeroes_in_precision_mode,
172 int max_trailing_padding_zeroes_in_precision_mode,
173 int min_exponent_width = 0)
174 : flags_(flags),
175 infinity_symbol_(infinity_symbol),
176 nan_symbol_(nan_symbol),
177 exponent_character_(exponent_character),
178 decimal_in_shortest_low_(decimal_in_shortest_low),
179 decimal_in_shortest_high_(decimal_in_shortest_high),
180 max_leading_padding_zeroes_in_precision_mode_(
181 max_leading_padding_zeroes_in_precision_mode),
182 max_trailing_padding_zeroes_in_precision_mode_(
183 max_trailing_padding_zeroes_in_precision_mode),
184 min_exponent_width_(min_exponent_width) {
185 // When 'trailing zero after the point' is set, then 'trailing point'
186 // must be set too.
189 }
190
191 // Returns a converter following the EcmaScript specification.
192 //
193 // Flags: UNIQUE_ZERO and EMIT_POSITIVE_EXPONENT_SIGN.
194 // Special values: "Infinity" and "NaN".
195 // Lower case 'e' for exponential values.
196 // decimal_in_shortest_low: -6
197 // decimal_in_shortest_high: 21
198 // max_leading_padding_zeroes_in_precision_mode: 6
199 // max_trailing_padding_zeroes_in_precision_mode: 0
201
202 // Computes the shortest string of digits that correctly represent the input
203 // number. Depending on decimal_in_shortest_low and decimal_in_shortest_high
204 // (see constructor) it then either returns a decimal representation, or an
205 // exponential representation.
206 // Example with decimal_in_shortest_low = -6,
207 // decimal_in_shortest_high = 21,
208 // EMIT_POSITIVE_EXPONENT_SIGN activated, and
209 // EMIT_TRAILING_DECIMAL_POINT deactivated:
210 // ToShortest(0.000001) -> "0.000001"
211 // ToShortest(0.0000001) -> "1e-7"
212 // ToShortest(111111111111111111111.0) -> "111111111111111110000"
213 // ToShortest(100000000000000000000.0) -> "100000000000000000000"
214 // ToShortest(1111111111111111111111.0) -> "1.1111111111111111e+21"
215 //
216 // Note: the conversion may round the output if the returned string
217 // is accurate enough to uniquely identify the input-number.
218 // For example the most precise representation of the double 9e59 equals
219 // "899999999999999918767229449717619953810131273674690656206848", but
220 // the converter will return the shorter (but still correct) "9e59".
221 //
222 // Returns true if the conversion succeeds. The conversion always succeeds
223 // except when the input value is special and no infinity_symbol or
224 // nan_symbol has been given to the constructor.
225 //
226 // The length of the longest result is the maximum of the length of the
227 // following string representations (each with possible examples):
228 // - NaN and negative infinity: "NaN", "-Infinity", "-inf".
229 // - -10^(decimal_in_shortest_high - 1):
230 // "-100000000000000000000", "-1000000000000000.0"
231 // - the longest string in range [0; -10^decimal_in_shortest_low]. Generally,
232 // this string is 3 + kBase10MaximalLength - decimal_in_shortest_low.
233 // (Sign, '0', decimal point, padding zeroes for decimal_in_shortest_low,
234 // and the significant digits).
235 // "-0.0000033333333333333333", "-0.0012345678901234567"
236 // - the longest exponential representation. (A negative number with
237 // kBase10MaximalLength significant digits).
238 // "-1.7976931348623157e+308", "-1.7976931348623157E308"
239 // In addition, the buffer must be able to hold the trailing '\0' character.
240 bool ToShortest(double value, StringBuilder* result_builder) const {
241 return ToShortestIeeeNumber(value, result_builder, SHORTEST);
242 }
243
244 // Same as ToShortest, but for single-precision floats.
245 bool ToShortestSingle(float value, StringBuilder* result_builder) const {
246 return ToShortestIeeeNumber(value, result_builder, SHORTEST_SINGLE);
247 }
248
249
250 // Computes a decimal representation with a fixed number of digits after the
251 // decimal point. The last emitted digit is rounded.
252 //
253 // Examples:
254 // ToFixed(3.12, 1) -> "3.1"
255 // ToFixed(3.1415, 3) -> "3.142"
256 // ToFixed(1234.56789, 4) -> "1234.5679"
257 // ToFixed(1.23, 5) -> "1.23000"
258 // ToFixed(0.1, 4) -> "0.1000"
259 // ToFixed(1e30, 2) -> "1000000000000000019884624838656.00"
260 // ToFixed(0.1, 30) -> "0.100000000000000005551115123126"
261 // ToFixed(0.1, 17) -> "0.10000000000000001"
262 //
263 // If requested_digits equals 0, then the tail of the result depends on
264 // the EMIT_TRAILING_DECIMAL_POINT and EMIT_TRAILING_ZERO_AFTER_POINT.
265 // Examples, for requested_digits == 0,
266 // let EMIT_TRAILING_DECIMAL_POINT and EMIT_TRAILING_ZERO_AFTER_POINT be
267 // - false and false: then 123.45 -> 123
268 // 0.678 -> 1
269 // - true and false: then 123.45 -> 123.
270 // 0.678 -> 1.
271 // - true and true: then 123.45 -> 123.0
272 // 0.678 -> 1.0
273 //
274 // Returns true if the conversion succeeds. The conversion always succeeds
275 // except for the following cases:
276 // - the input value is special and no infinity_symbol or nan_symbol has
277 // been provided to the constructor,
278 // - 'value' > 10^kMaxFixedDigitsBeforePoint, or
279 // - 'requested_digits' > kMaxFixedDigitsAfterPoint.
280 // The last two conditions imply that the result for non-special values never
281 // contains more than
282 // 1 + kMaxFixedDigitsBeforePoint + 1 + kMaxFixedDigitsAfterPoint characters
283 // (one additional character for the sign, and one for the decimal point).
284 // In addition, the buffer must be able to hold the trailing '\0' character.
285 bool ToFixed(double value,
286 int requested_digits,
287 StringBuilder* result_builder) const;
288
289 // Computes a representation in exponential format with requested_digits
290 // after the decimal point. The last emitted digit is rounded.
291 // If requested_digits equals -1, then the shortest exponential representation
292 // is computed.
293 //
294 // Examples with EMIT_POSITIVE_EXPONENT_SIGN deactivated, and
295 // exponent_character set to 'e'.
296 // ToExponential(3.12, 1) -> "3.1e0"
297 // ToExponential(5.0, 3) -> "5.000e0"
298 // ToExponential(0.001, 2) -> "1.00e-3"
299 // ToExponential(3.1415, -1) -> "3.1415e0"
300 // ToExponential(3.1415, 4) -> "3.1415e0"
301 // ToExponential(3.1415, 3) -> "3.142e0"
302 // ToExponential(123456789000000, 3) -> "1.235e14"
303 // ToExponential(1000000000000000019884624838656.0, -1) -> "1e30"
304 // ToExponential(1000000000000000019884624838656.0, 32) ->
305 // "1.00000000000000001988462483865600e30"
306 // ToExponential(1234, 0) -> "1e3"
307 //
308 // Returns true if the conversion succeeds. The conversion always succeeds
309 // except for the following cases:
310 // - the input value is special and no infinity_symbol or nan_symbol has
311 // been provided to the constructor,
312 // - 'requested_digits' > kMaxExponentialDigits.
313 //
314 // The last condition implies that the result never contains more than
315 // kMaxExponentialDigits + 8 characters (the sign, the digit before the
316 // decimal point, the decimal point, the exponent character, the
317 // exponent's sign, and at most 3 exponent digits).
318 // In addition, the buffer must be able to hold the trailing '\0' character.
319 bool ToExponential(double value,
320 int requested_digits,
321 StringBuilder* result_builder) const;
322
323
324 // Computes 'precision' leading digits of the given 'value' and returns them
325 // either in exponential or decimal format, depending on
326 // max_{leading|trailing}_padding_zeroes_in_precision_mode (given to the
327 // constructor).
328 // The last computed digit is rounded.
329 //
330 // Example with max_leading_padding_zeroes_in_precision_mode = 6.
331 // ToPrecision(0.0000012345, 2) -> "0.0000012"
332 // ToPrecision(0.00000012345, 2) -> "1.2e-7"
333 // Similarly the converter may add up to
334 // max_trailing_padding_zeroes_in_precision_mode in precision mode to avoid
335 // returning an exponential representation. A zero added by the
336 // EMIT_TRAILING_ZERO_AFTER_POINT flag is counted for this limit.
337 // Examples for max_trailing_padding_zeroes_in_precision_mode = 1:
338 // ToPrecision(230.0, 2) -> "230"
339 // ToPrecision(230.0, 2) -> "230." with EMIT_TRAILING_DECIMAL_POINT.
340 // ToPrecision(230.0, 2) -> "2.3e2" with EMIT_TRAILING_ZERO_AFTER_POINT.
341 // Examples for max_trailing_padding_zeroes_in_precision_mode = 3, and no
342 // EMIT_TRAILING_ZERO_AFTER_POINT:
343 // ToPrecision(123450.0, 6) -> "123450"
344 // ToPrecision(123450.0, 5) -> "123450"
345 // ToPrecision(123450.0, 4) -> "123500"
346 // ToPrecision(123450.0, 3) -> "123000"
347 // ToPrecision(123450.0, 2) -> "1.2e5"
348 //
349 // Returns true if the conversion succeeds. The conversion always succeeds
350 // except for the following cases:
351 // - the input value is special and no infinity_symbol or nan_symbol has
352 // been provided to the constructor,
353 // - precision < kMinPericisionDigits
354 // - precision > kMaxPrecisionDigits
355 //
356 // The last condition implies that the result never contains more than
357 // kMaxPrecisionDigits + 7 characters (the sign, the decimal point, the
358 // exponent character, the exponent's sign, and at most 3 exponent digits).
359 // In addition, the buffer must be able to hold the trailing '\0' character.
360 bool ToPrecision(double value,
361 int precision,
362 StringBuilder* result_builder) const;
363
364 enum DtoaMode {
365 // Produce the shortest correct representation.
366 // For example the output of 0.299999999999999988897 is (the less accurate
367 // but correct) 0.3.
369 // Same as SHORTEST, but for single-precision floats.
371 // Produce a fixed number of digits after the decimal point.
372 // For instance fixed(0.1, 4) becomes 0.1000
373 // If the input number is big, the output will be big.
375 // Fixed number of digits (independent of the decimal point).
377 };
378
379 // Converts the given double 'v' to digit characters. 'v' must not be NaN,
380 // +Infinity, or -Infinity. In SHORTEST_SINGLE-mode this restriction also
381 // applies to 'v' after it has been casted to a single-precision float. That
382 // is, in this mode static_cast<float>(v) must not be NaN, +Infinity or
383 // -Infinity.
384 //
385 // The result should be interpreted as buffer * 10^(point-length).
386 //
387 // The digits are written to the buffer in the platform's charset, which is
388 // often UTF-8 (with ASCII-range digits) but may be another charset, such
389 // as EBCDIC.
390 //
391 // The output depends on the given mode:
392 // - SHORTEST: produce the least amount of digits for which the internal
393 // identity requirement is still satisfied. If the digits are printed
394 // (together with the correct exponent) then reading this number will give
395 // 'v' again. The buffer will choose the representation that is closest to
396 // 'v'. If there are two at the same distance, than the one farther away
397 // from 0 is chosen (halfway cases - ending with 5 - are rounded up).
398 // In this mode the 'requested_digits' parameter is ignored.
399 // - SHORTEST_SINGLE: same as SHORTEST but with single-precision.
400 // - FIXED: produces digits necessary to print a given number with
401 // 'requested_digits' digits after the decimal point. The produced digits
402 // might be too short in which case the caller has to fill the remainder
403 // with '0's.
404 // Example: toFixed(0.001, 5) is allowed to return buffer="1", point=-2.
405 // Halfway cases are rounded towards +/-Infinity (away from 0). The call
406 // toFixed(0.15, 2) thus returns buffer="2", point=0.
407 // The returned buffer may contain digits that would be truncated from the
408 // shortest representation of the input.
409 // - PRECISION: produces 'requested_digits' where the first digit is not '0'.
410 // Even though the length of produced digits usually equals
411 // 'requested_digits', the function is allowed to return fewer digits, in
412 // which case the caller has to fill the missing digits with '0's.
413 // Halfway cases are again rounded away from 0.
414 // DoubleToAscii expects the given buffer to be big enough to hold all
415 // digits and a terminating null-character. In SHORTEST-mode it expects a
416 // buffer of at least kBase10MaximalLength + 1. In all other modes the
417 // requested_digits parameter and the padding-zeroes limit the size of the
418 // output. Don't forget the decimal point, the exponent character and the
419 // terminating null-character when computing the maximal output size.
420 // The given length is only used in debug mode to ensure the buffer is big
421 // enough.
422 static void DoubleToAscii(double v,
424 int requested_digits,
425 char* buffer,
426 int buffer_length,
427 bool* sign,
428 int* length,
429 int* point);
430
431 private:
432 // Implementation for ToShortest and ToShortestSingle.
433 bool ToShortestIeeeNumber(double value,
434 StringBuilder* result_builder,
435 DtoaMode mode) const;
436
437 // If the value is a special value (NaN or Infinity) constructs the
438 // corresponding string using the configured infinity/nan-symbol.
439 // If either of them is NULL or the value is not special then the
440 // function returns false.
441 bool HandleSpecialValues(double value, StringBuilder* result_builder) const;
442 // Constructs an exponential representation (i.e. 1.234e56).
443 // The given exponent assumes a decimal point after the first decimal digit.
444 void CreateExponentialRepresentation(const char* decimal_digits,
445 int length,
446 int exponent,
447 StringBuilder* result_builder) const;
448 // Creates a decimal representation (i.e 1234.5678).
449 void CreateDecimalRepresentation(const char* decimal_digits,
450 int length,
451 int decimal_point,
452 int digits_after_point,
453 StringBuilder* result_builder) const;
454
455 const int flags_;
456 const char* const infinity_symbol_;
457 const char* const nan_symbol_;
458 const char exponent_character_;
459 const int decimal_in_shortest_low_;
460 const int decimal_in_shortest_high_;
461 const int max_leading_padding_zeroes_in_precision_mode_;
462 const int max_trailing_padding_zeroes_in_precision_mode_;
463 const int min_exponent_width_;
464
465 DOUBLE_CONVERSION_DISALLOW_IMPLICIT_CONSTRUCTORS(DoubleToStringConverter);
466};
467
468} // namespace double_conversion
469
470#endif // DOUBLE_CONVERSION_DOUBLE_TO_STRING_H_
static int sign(SkScalar x)
Definition: SkPath.cpp:2205
bool ToShortestSingle(float value, StringBuilder *result_builder) const
bool ToFixed(double value, int requested_digits, StringBuilder *result_builder) const
static const DoubleToStringConverter & EcmaScriptConverter()
bool ToExponential(double value, int requested_digits, StringBuilder *result_builder) const
DoubleToStringConverter(int flags, const char *infinity_symbol, const char *nan_symbol, char exponent_character, int decimal_in_shortest_low, int decimal_in_shortest_high, int max_leading_padding_zeroes_in_precision_mode, int max_trailing_padding_zeroes_in_precision_mode, int min_exponent_width=0)
static void DoubleToAscii(double v, DtoaMode mode, int requested_digits, char *buffer, int buffer_length, bool *sign, int *length, int *point)
bool ToShortest(double value, StringBuilder *result_builder) const
bool ToPrecision(double value, int precision, StringBuilder *result_builder) const
FlutterSemanticsFlag flags
uint8_t value
size_t length
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate vm snapshot The VM snapshot data that will be memory mapped as read only SnapshotAssetPath must be present isolate snapshot The isolate snapshot data that will be memory mapped as read only SnapshotAssetPath must be present cache dir Path to the cache directory This is different from the persistent_cache_path in embedder which is used for Skia shader cache icu native lib Path to the library file that exports the ICU data vm service The hostname IP address on which the Dart VM Service should be served If not defaults to or::depending on whether ipv6 is specified vm service A custom Dart VM Service port The default is to pick a randomly available open port disable vm Disable the Dart VM Service The Dart VM Service is never available in release mode disable vm service Disable mDNS Dart VM Service publication Bind to the IPv6 localhost address for the Dart VM Service Ignored if vm service host is set endless trace buffer
Definition: switches.h:126
it will be possible to load the file into Perfetto s trace viewer disable asset Prevents usage of any non test fonts unless they were explicitly Loaded via prefetched default font Indicates whether the embedding started a prefetch of the default font manager before creating the engine run In non interactive mode
Definition: switches.h:228
#define DOUBLE_CONVERSION_ASSERT(condition)
Definition: utils.h:46