[libc][NFC] Fix typo and unused variable

[michaelrj]

Thank you for fixing this

libc/src/__support/high_precision_decimal.h

 struct LShiftTableEntry {
   uint32_t newDigits;
   char const *powerOfFive;
 };
 
 // This is based on the HPD data structure described as part of the Simple
 // Decimal Conversion algorithm by Nigel Tao, described at this link:
 // https://nigeltao.github.io/blog/2020/parse-number-f64-simple.html
-class HighPrecsisionDecimal {
+class HighPrecisionDecimal {
 
   // This precomputed table speeds up left shifts by having the number of new
   // digits that will be added by multiplying 5^i by 2^i. If the number is less
   // than 5^i then it will add one fewer digit. There are only 60 entries since
   // that's the max shift amount.
   // This table was generated by the script at
   // libc/utils/mathtools/GenerateHPDConstants.py
   static constexpr LShiftTableEntry LEFT_SHIFT_DIGIT_TABLE[] = {
void leftShift(uint32_t shiftAmount) {
     }
     this->decimalPoint += newDigits;
     this->trimTrailingZeroes();
   }
 
 public:
   // numString is assumed to be a string of numeric characters. It doesn't
   // handle leading spaces.
-  HighPrecsisionDecimal(const char *__restrict numString) {
+  HighPrecisionDecimal(const char *__restrict numString) {
     bool sawDot = false;
-    bool sawDigit = false;
     while (isdigit(*numString) || *numString == '.') {
       if (*numString == '.') {
         if (sawDot) {
           break;
         }
         this->decimalPoint = this->numDigits;
         sawDot = true;
       } else {
-        sawDigit = true;
         if (*numString == '0' && this->numDigits == 0) {
           --this->decimalPoint;
           ++numString;
           continue;
         }
         if (this->numDigits < MAX_NUM_DIGITS) {
           this->digits[this->numDigits] = *numString - '0';
           ++this->numDigits;

libc/src/__support/str_to_float.h

 // link: https://nigeltao.github.io/blog/2020/parse-number-f64-simple.html
 template <class T>
 static inline void
 simpleDecimalConversion(const char *__restrict numStart,
                         typename fputil::FPBits<T>::UIntType *outputMantissa,
                         uint32_t *outputExp2) {
 
   int32_t exp2 = 0;
-  HighPrecsisionDecimal hpd = HighPrecsisionDecimal(numStart);
+  HighPrecisionDecimal hpd = HighPrecisionDecimal(numStart);
 
   if (hpd.getNumDigits() == 0) {
     *outputMantissa = 0;
     *outputExp2 = 0;
     return;
   }
 
   // If the exponent is too large and can't be represented in this size of

libc/test/src/__support/high_precision_decimal_test.cpp

 //===-- Unittests for high_precision_decimal ------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/__support/high_precision_decimal.h"
 
 #include "utils/UnitTest/Test.h"
 
 TEST(LlvmLibcHighPrecisionDecimalTest, BasicInit) {
-  __llvm_libc::internal::HighPrecsisionDecimal hpd =
-      __llvm_libc::internal::HighPrecsisionDecimal("1.2345");
+  __llvm_libc::internal::HighPrecisionDecimal hpd =
+      __llvm_libc::internal::HighPrecisionDecimal("1.2345");
   uint8_t *digits = hpd.getDigits();
 
   EXPECT_EQ(digits[0], uint8_t(1));
   EXPECT_EQ(digits[1], uint8_t(2));
   EXPECT_EQ(digits[2], uint8_t(3));
   EXPECT_EQ(digits[3], uint8_t(4));
   EXPECT_EQ(digits[4], uint8_t(5));
   EXPECT_EQ(hpd.getNumDigits(), 5u);
   EXPECT_EQ(hpd.getDecimalPoint(), 1);
 }
 
 TEST(LlvmLibcHighPrecisionDecimalTest, BasicShift) {
-  __llvm_libc::internal::HighPrecsisionDecimal hpd =
-      __llvm_libc::internal::HighPrecsisionDecimal("1");
+  __llvm_libc::internal::HighPrecisionDecimal hpd =
+      __llvm_libc::internal::HighPrecisionDecimal("1");
   uint8_t *digits = hpd.getDigits();
 
   hpd.shift(1); // shift left 1, equal to multiplying by 2.
 
   EXPECT_EQ(digits[0], uint8_t(2));
   EXPECT_EQ(hpd.getNumDigits(), 1u);
   EXPECT_EQ(hpd.getDecimalPoint(), 1);
 }
 
 TEST(LlvmLibcHighPrecisionDecimalTest, SmallShift) {
-  __llvm_libc::internal::HighPrecsisionDecimal hpd =
-      __llvm_libc::internal::HighPrecsisionDecimal("1.2345");
+  __llvm_libc::internal::HighPrecisionDecimal hpd =
+      __llvm_libc::internal::HighPrecisionDecimal("1.2345");
   uint8_t *digits = hpd.getDigits();
 
   hpd.shift(-1); // shift right one, equal to dividing by 2
   // result should be 0.61725
 
   EXPECT_EQ(digits[0], uint8_t(6));
   EXPECT_EQ(digits[1], uint8_t(1));
   EXPECT_EQ(digits[2], uint8_t(7));
TEST(LlvmLibcHighPrecisionDecimalTest, SmallShift) {
   EXPECT_EQ(digits[2], uint8_t(3));
   EXPECT_EQ(digits[3], uint8_t(4));
   EXPECT_EQ(digits[4], uint8_t(5));
   EXPECT_EQ(hpd.getNumDigits(), 5u);
   EXPECT_EQ(hpd.getDecimalPoint(), 1);
 }
 
 TEST(LlvmLibcHighPrecisionDecimalTest, MediumShift) {
-  __llvm_libc::internal::HighPrecsisionDecimal hpd =
-      __llvm_libc::internal::HighPrecsisionDecimal(".299792458");
+  __llvm_libc::internal::HighPrecisionDecimal hpd =
+      __llvm_libc::internal::HighPrecisionDecimal(".299792458");
   uint8_t *digits = hpd.getDigits();
 
   hpd.shift(-3); // shift right three, equal to dividing by 8
   // result should be 0.03747405725
 
   EXPECT_EQ(digits[0], uint8_t(3));
   EXPECT_EQ(digits[1], uint8_t(7));
   EXPECT_EQ(digits[2], uint8_t(4));
TEST(LlvmLibcHighPrecisionDecimalTest, MediumShift) {
   EXPECT_EQ(digits[6], uint8_t(4));
   EXPECT_EQ(digits[7], uint8_t(5));
   EXPECT_EQ(digits[8], uint8_t(8));
   EXPECT_EQ(hpd.getNumDigits(), 9u);
   EXPECT_EQ(hpd.getDecimalPoint(), 0);
 }
 
 TEST(LlvmLibcHighPrecisionDecimalTest, BigShift) {
-  __llvm_libc::internal::HighPrecsisionDecimal hpd =
-      __llvm_libc::internal::HighPrecsisionDecimal(".299792458");
+  __llvm_libc::internal::HighPrecisionDecimal hpd =
+      __llvm_libc::internal::HighPrecisionDecimal(".299792458");
   uint8_t *digits = hpd.getDigits();
 
   hpd.shift(-29); // shift right 29, equal to dividing by 536,870,912
   // result should be 0.0000000005584069676697254180908203125
 
   EXPECT_EQ(digits[0], uint8_t(5));
   EXPECT_EQ(digits[1], uint8_t(5));
   EXPECT_EQ(digits[2], uint8_t(8));
TEST(LlvmLibcHighPrecisionDecimalTest, BigShift) {
   EXPECT_EQ(digits[6], uint8_t(4));
   EXPECT_EQ(digits[7], uint8_t(5));
   EXPECT_EQ(digits[8], uint8_t(8));
   EXPECT_EQ(hpd.getNumDigits(), 9u);
   EXPECT_EQ(hpd.getDecimalPoint(), 0);
 }
 
 TEST(LlvmLibcHighPrecisionDecimalTest, BigShiftInSteps) {
-  __llvm_libc::internal::HighPrecsisionDecimal hpd =
-      __llvm_libc::internal::HighPrecsisionDecimal("1");
+  __llvm_libc::internal::HighPrecisionDecimal hpd =
+      __llvm_libc::internal::HighPrecisionDecimal("1");
   uint8_t *digits = hpd.getDigits();
 
   hpd.shift(60); // shift left 60, equal to multiplying by
                  // 1152921504606846976.
 
   EXPECT_EQ(digits[0], uint8_t(1));
   EXPECT_EQ(digits[1], uint8_t(1));
   EXPECT_EQ(digits[2], uint8_t(5));
TEST(LlvmLibcHighPrecisionDecimalTest, BigShiftInSteps) {
 
   EXPECT_EQ(digits[0], uint8_t(1));
 
   EXPECT_EQ(hpd.getNumDigits(), 1u);
   EXPECT_EQ(hpd.getDecimalPoint(), 1);
 }
 
 TEST(LlvmLibcHighPrecisionDecimalTest, VeryBigShift) {
-  __llvm_libc::internal::HighPrecsisionDecimal hpd =
-      __llvm_libc::internal::HighPrecsisionDecimal("1");
+  __llvm_libc::internal::HighPrecisionDecimal hpd =
+      __llvm_libc::internal::HighPrecisionDecimal("1");
   uint8_t *digits = hpd.getDigits();
 
   hpd.shift(100); // shift left 100, equal to multiplying by
                   // 1267650600228229401496703205376.
   // result should be 2^100
 
   EXPECT_EQ(digits[0], uint8_t(1));
   EXPECT_EQ(digits[1], uint8_t(2));
TEST(LlvmLibcHighPrecisionDecimalTest, VeryBigShift) {
   // result should be 1
 
   EXPECT_EQ(digits[0], uint8_t(1));
   EXPECT_EQ(hpd.getNumDigits(), 1u);
   EXPECT_EQ(hpd.getDecimalPoint(), 1);
 }
 
 TEST(LlvmLibcHighPrecisionDecimalTest, RoundingTest) {
-  __llvm_libc::internal::HighPrecsisionDecimal hpd =
-      __llvm_libc::internal::HighPrecsisionDecimal("1.2345");
+  __llvm_libc::internal::HighPrecisionDecimal hpd =
+      __llvm_libc::internal::HighPrecisionDecimal("1.2345");
 
   EXPECT_EQ(hpd.roundToIntegerType<uint32_t>(), uint32_t(1));
   EXPECT_EQ(hpd.roundToIntegerType<uint64_t>(), uint64_t(1));
   EXPECT_EQ(hpd.roundToIntegerType<__uint128_t>(), __uint128_t(1));
 
   hpd.shift(1); // shift left 1 to get 2.469 (rounds to 2)
 
   EXPECT_EQ(hpd.roundToIntegerType<uint32_t>(), uint32_t(2));
   EXPECT_EQ(hpd.roundToIntegerType<uint64_t>(), uint64_t(2));
   EXPECT_EQ(hpd.roundToIntegerType<__uint128_t>(), __uint128_t(2));
 
   hpd.shift(1); // shift left 1 to get 4.938 (rounds to 5)
 
   EXPECT_EQ(hpd.roundToIntegerType<uint32_t>(), uint32_t(5));
   EXPECT_EQ(hpd.roundToIntegerType<uint64_t>(), uint64_t(5));
   EXPECT_EQ(hpd.roundToIntegerType<__uint128_t>(), __uint128_t(5));
 
   // 2.5 is right between two integers, so we round to even (2)
-  hpd = __llvm_libc::internal::HighPrecsisionDecimal("2.5");
+  hpd = __llvm_libc::internal::HighPrecisionDecimal("2.5");
 
   EXPECT_EQ(hpd.roundToIntegerType<uint32_t>(), uint32_t(2));
   EXPECT_EQ(hpd.roundToIntegerType<uint64_t>(), uint64_t(2));
   EXPECT_EQ(hpd.roundToIntegerType<__uint128_t>(), __uint128_t(2));
 
   // unless it's marked as having truncated, which means it's actually slightly
   // higher, forcing a round up (3)
   hpd.setTruncated(true);
 
   EXPECT_EQ(hpd.roundToIntegerType<uint32_t>(), uint32_t(3));
   EXPECT_EQ(hpd.roundToIntegerType<uint64_t>(), uint64_t(3));
   EXPECT_EQ(hpd.roundToIntegerType<__uint128_t>(), __uint128_t(3));
 
   // Check that the larger int types are being handled properly (overflow is not
   // handled, so int types that are too small are ignored for this test.)
 
   // 1099511627776 = 2^40
-  hpd = __llvm_libc::internal::HighPrecsisionDecimal("1099511627776");
+  hpd = __llvm_libc::internal::HighPrecisionDecimal("1099511627776");
 
   EXPECT_EQ(hpd.roundToIntegerType<uint64_t>(), uint64_t(1099511627776));
   EXPECT_EQ(hpd.roundToIntegerType<__uint128_t>(), __uint128_t(1099511627776));
 
   // 1267650600228229401496703205376 = 2^100
-  hpd = __llvm_libc::internal::HighPrecsisionDecimal(
+  hpd = __llvm_libc::internal::HighPrecisionDecimal(
       "1267650600228229401496703205376");
 
   __uint128_t result = __uint128_t(1) << 100;
 
   EXPECT_EQ(hpd.roundToIntegerType<__uint128_t>(), result);
 }