js/src/jsdtoa.h@a63d609f5ebe (annotated)
js/src/jsdtoa.h
Thu, 15 Jan 2015 15:55:04 +0100
- author
- Michael Schloh von Bennewitz <michael@schloh.com>
- date
- Thu, 15 Jan 2015 15:55:04 +0100
- branch
- TOR_BUG_9701
- changeset 9
- a63d609f5ebe
- permissions
- -rw-r--r--
Back out 97036ab72558 which inappropriately compared turds to third parties.
| michael@0 | 1 | /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- |
| michael@0 | 2 | * vim: set ts=8 sts=4 et sw=4 tw=99: |
| michael@0 | 3 | * This Source Code Form is subject to the terms of the Mozilla Public |
| michael@0 | 4 | * License, v. 2.0. If a copy of the MPL was not distributed with this |
| michael@0 | 5 | * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ |
| michael@0 | 6 | |
| michael@0 | 7 | #ifndef jsdtoa_h |
| michael@0 | 8 | #define jsdtoa_h |
| michael@0 | 9 | |
| michael@0 | 10 | /* |
| michael@0 | 11 | * Public interface to portable double-precision floating point to string |
| michael@0 | 12 | * and back conversion package. |
| michael@0 | 13 | */ |
| michael@0 | 14 | |
| michael@0 | 15 | #include <stddef.h> |
| michael@0 | 16 | |
| michael@0 | 17 | struct DtoaState; |
| michael@0 | 18 | |
| michael@0 | 19 | DtoaState * |
| michael@0 | 20 | js_NewDtoaState(); |
| michael@0 | 21 | |
| michael@0 | 22 | void |
| michael@0 | 23 | js_DestroyDtoaState(DtoaState *state); |
| michael@0 | 24 | |
| michael@0 | 25 | /* |
| michael@0 | 26 | * js_strtod_harder() returns as a double-precision floating-point number the |
| michael@0 | 27 | * value represented by the character string pointed to by s00. The string is |
| michael@0 | 28 | * scanned up to the first unrecognized character. |
| michael@0 | 29 | * |
| michael@0 | 30 | * If se is not nullptr, *se receives a pointer to the character terminating |
| michael@0 | 31 | * the scan. If no number can be formed, *se receives a pointer to the first |
| michael@0 | 32 | * unparseable character in s00, and zero is returned. |
| michael@0 | 33 | * |
| michael@0 | 34 | * On overflow, this function returns infinity and does not indicate an error. |
| michael@0 | 35 | * |
| michael@0 | 36 | * *err is set to zero on success; it's set to JS_DTOA_ENOMEM on memory failure. |
| michael@0 | 37 | */ |
| michael@0 | 38 | #define JS_DTOA_ENOMEM 2 |
| michael@0 | 39 | double |
| michael@0 | 40 | js_strtod_harder(DtoaState *state, const char *s00, char **se, int *err); |
| michael@0 | 41 | |
| michael@0 | 42 | /* |
| michael@0 | 43 | * Modes for converting floating-point numbers to strings. |
| michael@0 | 44 | * |
| michael@0 | 45 | * Some of the modes can round-trip; this means that if the number is converted to |
| michael@0 | 46 | * a string using one of these mode and then converted back to a number, the result |
| michael@0 | 47 | * will be identical to the original number (except that, due to ECMA, -0 will get converted |
| michael@0 | 48 | * to +0). These round-trip modes return the minimum number of significand digits that |
| michael@0 | 49 | * permit the round trip. |
| michael@0 | 50 | * |
| michael@0 | 51 | * Some of the modes take an integer parameter <precision>. |
| michael@0 | 52 | */ |
| michael@0 | 53 | /* NB: Keep this in sync with number_constants[]. */ |
| michael@0 | 54 | typedef enum JSDToStrMode { |
| michael@0 | 55 | DTOSTR_STANDARD, /* Either fixed or exponential format; round-trip */ |
| michael@0 | 56 | DTOSTR_STANDARD_EXPONENTIAL, /* Always exponential format; round-trip */ |
| michael@0 | 57 | DTOSTR_FIXED, /* Round to <precision> digits after the decimal point; exponential if number is large */ |
| michael@0 | 58 | DTOSTR_EXPONENTIAL, /* Always exponential format; <precision> significant digits */ |
| michael@0 | 59 | DTOSTR_PRECISION /* Either fixed or exponential format; <precision> significant digits */ |
| michael@0 | 60 | } JSDToStrMode; |
| michael@0 | 61 | |
| michael@0 | 62 | |
| michael@0 | 63 | /* Maximum number of characters (including trailing null) that a DTOSTR_STANDARD or DTOSTR_STANDARD_EXPONENTIAL |
| michael@0 | 64 | * conversion can produce. This maximum is reached for a number like -0.0000012345678901234567. */ |
| michael@0 | 65 | #define DTOSTR_STANDARD_BUFFER_SIZE 26 |
| michael@0 | 66 | |
| michael@0 | 67 | /* Maximum number of characters (including trailing null) that one of the other conversions |
| michael@0 | 68 | * can produce. This maximum is reached for TO_FIXED, which can generate up to 21 digits before the decimal point. */ |
| michael@0 | 69 | #define DTOSTR_VARIABLE_BUFFER_SIZE(precision) ((precision)+24 > DTOSTR_STANDARD_BUFFER_SIZE ? (precision)+24 : DTOSTR_STANDARD_BUFFER_SIZE) |
| michael@0 | 70 | |
| michael@0 | 71 | /* |
| michael@0 | 72 | * DO NOT USE THIS FUNCTION IF YOU CAN AVOID IT. js::NumberToCString() is a |
| michael@0 | 73 | * better function to use. |
| michael@0 | 74 | * |
| michael@0 | 75 | * Convert dval according to the given mode and return a pointer to the |
| michael@0 | 76 | * resulting ASCII string. If mode == DTOSTR_STANDARD and precision == 0 it's |
| michael@0 | 77 | * equivalent to ToString() as specified by ECMA-262-5 section 9.8.1, but it |
| michael@0 | 78 | * doesn't handle integers specially so should be avoided in that case (that's |
| michael@0 | 79 | * why js::NumberToCString() is better). |
| michael@0 | 80 | * |
| michael@0 | 81 | * The result is held somewhere in buffer, but not necessarily at the |
| michael@0 | 82 | * beginning. The size of buffer is given in bufferSize, and must be at least |
| michael@0 | 83 | * as large as given by the above macros. |
| michael@0 | 84 | * |
| michael@0 | 85 | * Return nullptr if out of memory. |
| michael@0 | 86 | */ |
| michael@0 | 87 | char * |
| michael@0 | 88 | js_dtostr(DtoaState *state, char *buffer, size_t bufferSize, JSDToStrMode mode, int precision, |
| michael@0 | 89 | double dval); |
| michael@0 | 90 | |
| michael@0 | 91 | /* |
| michael@0 | 92 | * DO NOT USE THIS FUNCTION IF YOU CAN AVOID IT. js::NumberToCString() is a |
| michael@0 | 93 | * better function to use. |
| michael@0 | 94 | * |
| michael@0 | 95 | * Convert d to a string in the given base. The integral part of d will be |
| michael@0 | 96 | * printed exactly in that base, regardless of how large it is, because there |
| michael@0 | 97 | * is no exponential notation for non-base-ten numbers. The fractional part |
| michael@0 | 98 | * will be rounded to as few digits as possible while still preserving the |
| michael@0 | 99 | * round-trip property (analogous to that of printing decimal numbers). In |
| michael@0 | 100 | * other words, if one were to read the resulting string in via a hypothetical |
| michael@0 | 101 | * base-number-reading routine that rounds to the nearest IEEE double (and to |
| michael@0 | 102 | * an even significand if there are two equally near doubles), then the result |
| michael@0 | 103 | * would equal d (except for -0.0, which converts to "0", and NaN, which is |
| michael@0 | 104 | * not equal to itself). |
| michael@0 | 105 | * |
| michael@0 | 106 | * Return nullptr if out of memory. If the result is not nullptr, it must be |
| michael@0 | 107 | * released via js_free(). |
| michael@0 | 108 | */ |
| michael@0 | 109 | char * |
| michael@0 | 110 | js_dtobasestr(DtoaState *state, int base, double d); |
| michael@0 | 111 | |
| michael@0 | 112 | #endif /* jsdtoa_h */ |
