Upload ChatIPC.cpp

ChatIPC.cpp

@@ -495,63 +495,105 @@ static const char* const scales[] = {"", "thousand", "million", "billion", "tril
                                      "quattuordecillion", "quindecillion", "sexdecillion", "septendecillion",
                                      "octodecillion", "novemdecillion", "vigintillion", "googol"};
 
-static std::vector<std::string> digit_to_words(const std::string& s) {
+static std::vector<std::string> digit_to_words(const std::string& input_s) {
     std::vector<std::string> words;
-    if (s.empty()) return words;
+    if (input_s.empty()) return words;
 
-    // Strip leading zeros
-    size_t first_non_zero = s.find_first_not_of('0');
-    if (first_non_zero == std::string::npos) {
-        words.push_back("zero");
-        return words;
+    // Split the number into integer and fractional parts
+    std::string int_part = input_s;
+    std::string frac_part = "";
+    size_t dot_pos = input_s.find('.');
+    if (dot_pos != std::string::npos) {
+        int_part = input_s.substr(0, dot_pos);
+        frac_part = input_s.substr(dot_pos + 1);
     }
-    std::string num = s.substr(first_non_zero);
 
-    // If it's very large (e.g. googolplex logic), fall back to single digits to prevent overflow
-    // and maintain semantic definitions of the numbers.
-    if (num.length() > 69) {
-        for (char c : num) {
-            words.push_back(ones[c - '0']);
+    // Clean the integer part by removing commas
+    std::string s;
+    for (char c : int_part) {
+        if (std::isdigit(static_cast<unsigned char>(c))) {
+            s.push_back(c);
         }
-        return words;
     }
 
-    int scale_idx = 0;
-    while (!num.empty()) {
-        int chunk_len = std::min<int>(3, num.length());
-        std::string chunk_str = num.substr(num.length() - chunk_len);
-        num = num.substr(0, num.length() - chunk_len);
+    // Process the integer part
+    if (s.empty()) {
+        // If there are no integer digits, ensure there are fractional digits before parsing
+        bool has_frac_digits = false;
+        for (char c : frac_part) {
+            if (std::isdigit(static_cast<unsigned char>(c))) has_frac_digits = true;
+        }
+        if (!has_frac_digits) return words;
+        words.push_back("zero");
+    } else {
+        size_t first_non_zero = s.find_first_not_of('0');
+        if (first_non_zero == std::string::npos) {
+            words.push_back("zero");
+        } else {
+            std::string num = s.substr(first_non_zero);
 
-        int chunk = std::stoi(chunk_str);
-        if (chunk > 0) {
-            std::vector<std::string> chunk_words;
-            int h = chunk / 100;
-            int remainder = chunk % 100;
+            // Fallback for extremely large numbers to prevent overflow
+            if (num.length() > 69) {
+                for (char c : num) {
+                    words.push_back(ones[c - '0']);
+                }
+            } else {
+                int scale_idx = 0;
+                while (!num.empty()) {
+                    int chunk_len = std::min<int>(3, num.length());
+                    std::string chunk_str = num.substr(num.length() - chunk_len);
+                    num = num.substr(0, num.length() - chunk_len);
+
+                    int chunk = std::stoi(chunk_str);
+                    if (chunk > 0) {
+                        std::vector<std::string> chunk_words;
+                        int h = chunk / 100;
+                        int remainder = chunk % 100;
+
+                        if (h > 0) {
+                            chunk_words.push_back(ones[h]);
+                            chunk_words.push_back("hundred");
+                        }
 
-            if (h > 0) {
-                chunk_words.push_back(ones[h]);
-                chunk_words.push_back("hundred");
-            }
+                        if (remainder > 0) {
+                            if (remainder < 20) {
+                                chunk_words.push_back(ones[remainder]);
+                            } else {
+                                chunk_words.push_back(tens[remainder / 10]);
+                                if (remainder % 10 > 0) {
+                                    chunk_words.push_back(ones[remainder % 10]);
+                                }
+                            }
+                        }
 
-            if (remainder > 0) {
-                if (remainder < 20) {
-                    chunk_words.push_back(ones[remainder]);
-                } else {
-                    chunk_words.push_back(tens[remainder / 10]);
-                    if (remainder % 10 > 0) {
-                        chunk_words.push_back(ones[remainder % 10]);
+                        if (scale_idx > 0 && scale_idx < static_cast<int>(sizeof(scales)/sizeof(scales[0]))) {
+                            chunk_words.push_back(scales[scale_idx]);
+                        }
+
+                        words.insert(words.begin(), chunk_words.begin(), chunk_words.end());
                     }
+                    scale_idx++;
                 }
             }
+        }
+    }
 
-            if (scale_idx > 0 && scale_idx < static_cast<int>(sizeof(scales)/sizeof(scales[0]))) {
-                chunk_words.push_back(scales[scale_idx]);
+    // Process the fractional part
+    if (!frac_part.empty()) {
+        bool has_frac_digits = false;
+        for (char c : frac_part) {
+            if (std::isdigit(static_cast<unsigned char>(c))) has_frac_digits = true;
+        }
+        if (has_frac_digits) {
+            words.push_back("point");
+            for (char c : frac_part) {
+                if (std::isdigit(static_cast<unsigned char>(c))) {
+                    words.push_back(ones[c - '0']);
+                }
             }
-
-            words.insert(words.begin(), chunk_words.begin(), chunk_words.end());
         }
-        scale_idx++;
     }
+
     return words;
 }
 
@@ -565,10 +607,13 @@ static std::vector<std::string> tokenize_others(const std::string &s) {
         return { lower_s };
     }
 
-    // Convert pure digits to words
-    bool is_all_digits = !s.empty() && std::all_of(s.begin(), s.end(), [](unsigned char c) {
-        return std::isdigit(c) != 0;
-    });
+    // Check if the entire string is a formatted number (pure digits, commas, and dots)
+    auto is_num_char = [](unsigned char c) {
+        return std::isdigit(c) != 0 || c == ',' || c == '.';
+    };
+    bool is_all_digits = !s.empty() && std::all_of(s.begin(), s.end(), is_num_char) &&
+                         std::any_of(s.begin(), s.end(), [](unsigned char c) { return std::isdigit(c) != 0; });
+
     if (is_all_digits) {
         return digit_to_words(s);
     }
@@ -578,9 +623,15 @@ static std::vector<std::string> tokenize_others(const std::string &s) {
 
     auto flush = [&]() {
         if (!cur.empty()) {
-            // Check numbers inside mixed tokens (e.g. "word123")
-            bool cur_all_digits = std::all_of(cur.begin(), cur.end(), [](unsigned char c) { return std::isdigit(c) != 0; });
-            if (cur_all_digits) {
+            // Check numbers inside mixed tokens (e.g. "word1,234.56")
+            bool cur_all_digits = std::all_of(cur.begin(), cur.end(), [](unsigned char c) {
+                return std::isdigit(c) != 0 || c == ',' || c == '.';
+            });
+            bool has_digits = std::any_of(cur.begin(), cur.end(), [](unsigned char c) {
+                return std::isdigit(c) != 0;
+            });
+
+            if (cur_all_digits && has_digits) {
                 auto words = digit_to_words(cur);
                 out.insert(out.end(), words.begin(), words.end());
             } else {
@@ -598,13 +649,25 @@ static std::vector<std::string> tokenize_others(const std::string &s) {
         char ch = static_cast<char>(uc);
 
         // Check for Operator/Symbol extraction
-        if (std::ispunct(uc) || (std::isprint(uc) && !std::isalnum(uc) && !std::isspace(uc))) {            flush();
+        if (std::ispunct(uc) || (std::isprint(uc) && !std::isalnum(uc) && !std::isspace(uc))) {
+
+            // Bypass regular punctuation extraction inside a formatted number
+            if ((ch == ',' || ch == '.') &&
+                !cur.empty() &&
+                (std::isdigit(static_cast<unsigned char>(cur.back())) != 0 || cur.back() == ',' || cur.back() == '.') &&
+                (i + 1 < s.size()) && std::isdigit(static_cast<unsigned char>(s[i+1])) != 0) {
+                cur.push_back(ch);
+                continue;
+            }
+
+            flush();
             std::string sym(1, ch);
 
-            // Check for double-character operators (==, <=, >=, !=, ++, --, &&, ||, <<, >>)
+            // Check for double-character operators
             if (i + 1 < s.size()) {
                 unsigned char nxt_uc = static_cast<unsigned char>(s[i+1]);
-                if (std::ispunct(nxt_uc) || (std::isprint(nxt_uc) && !std::isalnum(nxt_uc) && !std::isspace(nxt_uc))) {                    std::string sym2 = sym + static_cast<char>(nxt_uc);
+                if (std::ispunct(nxt_uc) || (std::isprint(nxt_uc) && !std::isalnum(nxt_uc) && !std::isspace(nxt_uc))) {
+                    std::string sym2 = sym + static_cast<char>(nxt_uc);
                     if (check_dictionary(sym2)) {
                         out.push_back(sym2);
                         ++i;
@@ -636,7 +699,7 @@ static std::vector<std::string> tokenize_others(const std::string &s) {
         bool digit_boundary = false;
         if (!cur.empty()) {
             unsigned char prev = static_cast<unsigned char>(s[i - 1]);
-            bool prev_digit = std::isdigit(prev) != 0;
+            bool prev_digit = (std::isdigit(prev) != 0) || prev == ',' || prev == '.';
             bool curr_digit = std::isdigit(uc) != 0;
             if (prev_digit != curr_digit) {
                 digit_boundary = true;