summaryrefslogtreecommitdiffstatshomepage
path: root/py/parsenum.c
Commit message (Collapse)AuthorAge
* py/parsenum: Fix parsing complex literals with negative real part.Jeff Epler2025-06-10
| | | | | | | | | | | If a complex literal had a negative real part and a positive imaginary part, it was not parsed properly because the imaginary part also came out negative. Includes a test of complex parsing, which fails without this fix. Co-authored-by: ComplexSymbol <141301057+ComplexSymbol@users.noreply.github.com> Signed-off-by: Jeff Epler <jepler@gmail.com>
* py/parsenum: Further reduce code size in check for inf/nan.Jeff Epler2025-06-10
| | | | | | | | | | A few more bytes can be saved by not using nested `if`s (4 bytes for `build-MICROBIT/py/parsenum.o`, 8 bytes for RPI_PICO firmware). This commit is better viewed with whitespace changes hidden, because two blocks were reindented (e.g., `git show -b`). Signed-off-by: Jeff Epler <jepler@gmail.com>
* py/parsenum: Reduce code size in check for inf/nan.Jeff Epler2025-06-10
| | | | | | | | | | | | | By avoiding two different checks of the string length, code size is reduced without changing behavior: Some invalid float/complex strings like "ix" will get handled just like "xx" in the main number literal parsing code instead. The optimizer alone couldn't remove the reundant comparisons because it couldn't make a transformation that let an invalid string like "ix" pass into the generic number parsing code. Signed-off-by: Jeff Epler <jepler@gmail.com>
* all: Rename the "NORETURN" macro to "MP_NORETURN".Alessandro Gatti2025-05-13
| | | | | | | | | | | | | | | | This commit renames the NORETURN macro, indicating to the compiler that a function does not return, into MP_NORETURN to maintain the same naming convention of other similar macros. To maintain compaitiblity with existing code NORETURN is aliased to MP_NORETURN, but it is also deprecated for MicroPython v2. This changeset was created using a similar process to decf8e6a8bb940d5829ca3296790631fcece7b21 ("all: Remove the "STATIC" macro and just use "static" instead."), with no documentation or python scripts to change to reflect the new macro name. Signed-off-by: Alessandro Gatti <a.gatti@frob.it>
* py/parsenum: Reduce code footprint of mp_parse_num_float.Yoctopuce dev2025-02-28
| | | | | | | | | | | | | The mantissa parsing code uses a floating point variable to accumulate digits. Using an `mp_float_uint_t` variable instead and casting to `mp_float_t` at the very end reduces code size. In some cases, it also improves the rounding behaviour as extra digits are taken into account by the int-to-float conversion code. An extra test case handles the special case where mantissa overflow occurs while processing deferred trailing zeros. Signed-off-by: Yoctopuce dev <dev@yoctopuce.com>
* py/parsenum: Throw an exception for invalid int literals like "01".Jeff Epler2025-01-26
| | | | | | | | | | | | | | | This includes making int("01") parse in base 10 like standard Python. When a base of 0 is specified it means auto-detect based on the prefix, and literals begining with 0 (except when the literal is all 0's) like "01" are then invalid and now throw an exception. The new error message is different from CPython. It says e.g., `SyntaxError: invalid syntax for integer with base 0: '09'` Additional test cases were added to cover the changed & added code. Co-authored-by: Damien George <damien@micropython.org> Signed-off-by: Jeff Epler <jepler@gmail.com>
* all: Remove the "STATIC" macro and just use "static" instead.Angus Gratton2024-03-07
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | The STATIC macro was introduced a very long time ago in commit d5df6cd44a433d6253a61cb0f987835fbc06b2de. The original reason for this was to have the option to define it to nothing so that all static functions become global functions and therefore visible to certain debug tools, so one could do function size comparison and other things. This STATIC feature is rarely (if ever) used. And with the use of LTO and heavy inline optimisation, analysing the size of individual functions when they are not static is not a good representation of the size of code when fully optimised. So the macro does not have much use and it's simpler to just remove it. Then you know exactly what it's doing. For example, newcomers don't have to learn what the STATIC macro is and why it exists. Reading the code is also less "loud" with a lowercase static. One other minor point in favour of removing it, is that it stops bugs with `STATIC inline`, which should always be `static inline`. Methodology for this commit was: 1) git ls-files | egrep '\.[ch]$' | \ xargs sed -Ei "s/(^| )STATIC($| )/\1static\2/" 2) Do some manual cleanup in the diff by searching for the word STATIC in comments and changing those back. 3) "git-grep STATIC docs/", manually fixed those cases. 4) "rg -t python STATIC", manually fixed codegen lines that used STATIC. This work was funded through GitHub Sponsors. Signed-off-by: Angus Gratton <angus@redyak.com.au>
* py/parsenum: Fix typo in #endif comment.David Lechner2023-06-14
| | | | | | This fixes a `#endif` comment to exactly match the `#if`. Signed-off-by: David Lechner <david@pybricks.com>
* py/objstr: Optimise mp_obj_new_str_from_vstr for known-safe strings.Jim Mussared2022-08-26
| | | | | | | The new `mp_obj_new_str_from_utf8_vstr` can be used when you know you already have a unicode-safe string. Signed-off-by: Jim Mussared <jim.mussared@gmail.com>
* py/objstr: Split mp_obj_str_from_vstr into bytes/str versions.Jim Mussared2022-08-26
| | | | | | | | | | | | | | Previously the desired output type was specified. Now make the type part of the function name. Because this function is used in a few places this saves code size due to smaller call-site. This makes `mp_obj_new_str_type_from_vstr` a private function of objstr.c (which is almost the only place where the output type isn't a compile-time constant). This saves ~140 bytes on PYBV11. Signed-off-by: Jim Mussared <jim.mussared@gmail.com>
* py/parsenum: Ensure that trailing zeros lead to identical results.Dan Ellis2022-08-12
| | | | | | | | | | Prior to this commit, parsenum would calculate "1e-20" as 1.0*pow(10, -20), and "1.000e-20" as 1000.0*pow(10, -23); in certain cases, this could make seemingly-identical values compare as not equal. This commit watches for trailing zeros as a special case, and ignores them when appropriate, so "1.000e-20" is also calculated as 1.0*pow(10, -20). Fixes issue #5831.
* py/parsenum: Optimise when building with complex disabled.Damien George2022-06-23
| | | | | | To reduce code size when MICROPY_PY_BUILTINS_COMPLEX is disabled. Signed-off-by: Damien George <damien@micropython.org>
* py/parsenum: Fix parsing of complex "j" and also "nanj", "infj".Damien George2022-06-23
| | | | | | | | | Prior to this commit, complex("j") would return 0j, and complex("nanj") would return nan+0j. This commit makes sure "j" is tested for after parsing the number (nan, inf or a decimal), and also supports the case of "j" on its own. Signed-off-by: Damien George <damien@micropython.org>
* py/parsenum: Support parsing complex numbers of the form "a+bj".Jim Mussared2022-06-23
| | | | | | To conform with CPython. Signed-off-by: Jim Mussared <jim.mussared@gmail.com>
* py: Add option to compile without any error messages at all.Damien George2021-04-27
| | | | | | | | This introduces a new option, MICROPY_ERROR_REPORTING_NONE, which completely disables all error messages. To be used in cases where MicroPython needs to fit in very limited systems. Signed-off-by: Damien George <damien@micropython.org>
* all: Fix implicit floating point promotion.stijn2020-04-18
| | | | | | | | | | | | | Initially some of these were found building the unix coverage variant on MacOS because that build uses clang and has -Wdouble-promotion enabled, and clang performs more vigorous promotion checks than gcc. Additionally the codebase has been compiled with clang and msvc (the latter with warning level 3), and with MICROPY_FLOAT_IMPL_FLOAT to find the rest of the conversions. Fixes are implemented either as explicit casts, or by using the correct type, or by using one of the utility functions to handle floating point casting; these have been moved from nativeglue.c to the public API.
* Revert "all: Fix implicit casts of float/double, and signed comparison."stijn2020-04-18
| | | | | | This reverts commit a2110bd3fca59df8b16a2b5fe4645a4af30b06ed. There's nothing inherently wrong with it, but upcoming commits will apply similar fixes in a slightly different way.
* all: Use MP_ERROR_TEXT for all error messages.Jim Mussared2020-04-05
|
* py: Use preprocessor to detect error reporting level (terse/detailed).Jim Mussared2020-04-05
| | | | | | Instead of compiler-level if-logic. This is necessary to know what error strings are included in the build at the preprocessor stage, so that string compression can be implemented.
* all: Fix implicit casts of float/double, and signed comparison.David Lechner2020-03-30
| | | | | | | These were found by buiding the unix coverage variant on macOS (so clang compiler). Mostly, these are fixing implicit cast of float/double to mp_float_t which is one of those two and one mp_int_t to size_t fix for good measure.
* all: Reformat C and Python source code with tools/codeformat.py.Damien George2020-02-28
| | | | This is run with uncrustify 0.70.1, and black 19.10b0.
* py: Rename MP_QSTR_NULL to MP_QSTRnull to avoid intern collisions.Josh Lloyd2019-09-26
| | | | Fixes #5140.
* py/parsenum: Avoid rounding errors with negative powers-of-10.Romain Goyet2018-09-20
| | | | | | | | | | | | | | | | This patches avoids multiplying with negative powers-of-10 when parsing floating-point values, when those powers-of-10 can be exactly represented as a positive power. When represented as a positive power and used to divide, the resulting float will not have any rounding errors. The issue is that mp_parse_num_decimal will sometimes not give the closest floating representation of the input string. Eg for "0.3", which can't be represented exactly in floating point, mp_parse_num_decimal gives a slightly high (by 1LSB) result. This is because it computes the answer as 3 * 0.1, and since 0.1 also can't be represented exactly, multiplying by 3 multiplies up the rounding error in the 0.1. Computing it as 3 / 10, as now done by the change in this commit, gives an answer which is as close to the true value of "0.3" as possible.
* py/lexer: Add support for underscores in numeric literals.Damien George2018-06-12
| | | | This is a very convenient feature introduced in Python 3.6 by PEP 515.
* py/parsenum: Adjust braces so they are balanced.Damien George2018-05-22
|
* py/parsenum: Avoid undefined behavior parsing floats with large exponents.Jeff Epler2018-05-21
| | | | | | | Fuzz testing combined with the undefined behavior sanitizer found that parsing unreasonable float literals like 1e+9999999999999 resulted in undefined behavior due to overflow in signed integer arithmetic, and a wrong result being returned.
* py/parsenum: Use int instead of mp_int_t for parsing float exponent.Damien George2018-05-21
| | | | | | | There is no need to use the mp_int_t type which may be 64-bits wide, there is enough bit-width in a normal int to parse reasonable exponents. Using int helps to reduce code size for 64-bit ports, especially nan-boxing builds. (Similarly for the "dig" variable which is now an unsigned int.)
* py/parsenum: Fix parsing of floats that are close to subnormal.Damien George2018-02-08
| | | | | | Prior to this patch, a float literal that was close to subnormal would have a loss of precision when parsed. The worst case was something like float('10000000000000000000e-326') which returned 0.0.
* py/parsenum: Improve parsing of floating point numbers.Damien George2017-11-27
| | | | | | | | | | | | | This patch improves parsing of floating point numbers by converting all the digits (integer and fractional) together into a number 1 or greater, and then applying the correct power of 10 at the very end. In particular the multiple "multiply by 0.1" operations to build a fraction are now combined together and applied at the same time as the exponent, at the very end. This helps to retain precision during parsing of floats, and also includes a check that the number doesn't overflow during the parsing. One benefit is that a float will have the same value no matter where the decimal point is located, eg 1.23 == 123e-2.
* all: Use the name MicroPython consistently in commentsAlexander Steffen2017-07-31
| | | | | There were several different spellings of MicroPython present in comments, when there should be only one.
* py: Use mp_raise_TypeError/mp_raise_ValueError helpers where possible.Damien George2017-03-28
| | | | Saves 168 bytes on bare-arm.
* py/parsenum: Fix warning for signed/unsigned comparison.Damien George2016-12-28
|
* py/parsenum: Simplify and generalise decoding of digit values.Damien George2016-12-28
| | | | | This function should be able to parse integers with any value for the base, because it is called by int('xxx', base).
* py: Add MICROPY_FLOAT_CONST macro for defining float constants.Damien George2016-11-03
| | | | | | All float constants in the core should use this macro to prevent unnecessary creation of double-precision floats, which makes code less efficient.
* py: Use mp_raise_msg helper function where appropriate.Damien George2016-10-17
| | | | | Saves the following number of bytes of code space: 176 for bare-arm, 352 for minimal, 272 for unix x86-64, 140 for stmhal, 120 for esp8266.
* py/parsenum: Use pow function to apply exponent to decimal number.Damien George2016-03-29
| | | | | | Pow is already a dependency when compiling with floats, so may as well use it here to reduce code size and speed up the conversion for most cases.
* py/parsenum: Fix compiler warnings for no decl and signed comparison.Damien George2016-03-14
|
* py/parsenum: Use size_t to count bytes, and int for type of base arg.Damien George2016-03-14
| | | | | size_t is the proper type to count number of bytes in a string. The base argument does not need to be a full mp_uint_t, int is enough.
* py: Wrap all obj-ptr conversions in MP_OBJ_TO_PTR/MP_OBJ_FROM_PTR.Damien George2015-11-29
| | | | | | | | | This allows the mp_obj_t type to be configured to something other than a pointer-sized primitive type. This patch also includes additional changes to allow the code to compile when sizeof(mp_uint_t) != sizeof(void*), such as using size_t instead of mp_uint_t, and various casts.
* py/parsenum: Provide detailed error for int parsing with escaped bytes.Damien George2015-10-01
| | | | | | | This patch adds more fine grained error message control for errors when parsing integers (now has terse, normal and detailed). When detailed is enabled, the error now escapes bytes when printing them so they can be more easily seen.
* py: Clarify comment in parsenum.c about ValueError vs SyntaxError.Damien George2015-06-23
|
* py: Change exception type to ValueError when error reporting is terse.Daniel Campora2015-06-23
| | | | Addresses issue #1347
* py/parsenum.c: Rename "raise" func to "raise_exc" to avoid name clash.Damien George2015-05-30
| | | | "raise" is a common word that was found to exist in a vendor's stdlib.
* py: Fix printing of error message when parsing malformed integer.Damien George2015-03-16
|
* py: Parse big-int/float/imag constants directly in parser.Damien George2015-02-08
| | | | | | | | | Previous to this patch, a big-int, float or imag constant was interned (made into a qstr) and then parsed at runtime to create an object each time it was needed. This is wasteful in RAM and not efficient. Now, these constants are parsed straight away in the parser and turned into objects. This allows constants with large numbers of digits (so addresses issue #1103) and takes us a step closer to #722.
* py: Move to guarded includes, everywhere in py/ core.Damien George2015-01-01
| | | | Addresses issue #1022.
* py: Use shorter, static error msgs when ERROR_REPORTING_TERSE enabled.Damien George2014-11-06
| | | | | | | | Going from MICROPY_ERROR_REPORTING_NORMAL to MICROPY_ERROR_REPORTING_TERSE now saves 2020 bytes ROM for ARM Thumb2, and 2200 bytes ROM for 32-bit x86. This is about a 2.5% code size reduction for bare-arm.
* parser: Convert (u)int to mp_(u)int_t.Damien George2014-07-03
|
* Rename machine_(u)int_t to mp_(u)int_t.Damien George2014-07-03
| | | | See discussion in issue #50.
* py: Include mpconfig.h before all other includes.Paul Sokolovsky2014-06-21
| | | | | | It defines types used by all other headers. Fixes #691.
generated by cgit v1.2.3 (git 2.39.1) at 2025-06-30 15:51:14 +0000