py/parsenum: Ensure that trailing zeros lead to identical results.

dpwe · dpwe · commit f7828c9bf07d · 2022-07-28T23:50:15.000-04:00
diff --git a/py/parsenum.c b/py/parsenum.c
@@ -255,6 +255,8 @@ mp_obj_t mp_parse_num_float(const char *str, size_t len, bool allow_imag, mp_lex
         bool exp_neg = false;
         int exp_val = 0;
         int exp_extra = 0;
+        int trailing_zeros = 0;
+        int trailing_zeros_frac = 0;
         while (str < top) {
             unsigned int dig = *str++;
             if ('0' <= dig && dig <= '9') {
@@ -267,17 +269,40 @@ mp_obj_t mp_parse_num_float(const char *str, size_t len, bool allow_imag, mp_lex
                         exp_val = 10 * exp_val + dig;
                     }
                 } else {
-                    if (dec_val < DEC_VAL_MAX) {
-                        // dec_val won't overflow so keep accumulating
-                        dec_val = 10 * dec_val + dig;
+                    if (dig == 0) {
+                        // Defer treatment of zeros in fractional part.
+                        // If nothing comes afterwards, we will ignore them.
+                        ++trailing_zeros;
                         if (in == PARSE_DEC_IN_FRAC) {
-                            --exp_extra;
+                            ++trailing_zeros_frac;
                         }
                     } else {
-                        // dec_val might overflow and we anyway can't represent more digits
-                        // of precision, so ignore the digit and just adjust the exponent
-                        if (in == PARSE_DEC_IN_INTG) {
-                            ++exp_extra;
+                        // Un-defer any trailing zeros.
+                        if (trailing_zeros) {
+                            while (trailing_zeros) {
+                                if (dec_val < DEC_VAL_MAX) {
+                                    dec_val = 10 * dec_val;
+                                    if (trailing_zeros_frac) {
+                                        --exp_extra;
+                                        --trailing_zeros_frac;
+                                    }
+                                }
+                                --trailing_zeros;
+                            }
+                            trailing_zeros_frac = 0;
+                        }
+                        if (dec_val < DEC_VAL_MAX) {
+                            // dec_val won't overflow so keep accumulating
+                            dec_val = 10 * dec_val + dig;
+                            if (in == PARSE_DEC_IN_FRAC) {
+                                --exp_extra;
+                            }
+                        } else {
+                            // dec_val might overflow and we anyway can't represent more digits
+                            // of precision, so ignore the digit and just adjust the exponent
+                            if (in == PARSE_DEC_IN_INTG) {
+                                ++exp_extra;
+                            }
                         }
                     }
                 }
@@ -311,7 +336,7 @@ mp_obj_t mp_parse_num_float(const char *str, size_t len, bool allow_imag, mp_lex
         }
 
         // apply the exponent, making sure it's not a subnormal value
-        exp_val += exp_extra;
+        exp_val += (exp_extra + trailing_zeros - trailing_zeros_frac);
         if (exp_val < SMALL_NORMAL_EXP) {
             exp_val -= SMALL_NORMAL_EXP;
             dec_val *= SMALL_NORMAL_VAL;
