check from_chars result for integer literals in script parser (#1214)

Author: aysha-afrah26

src/script_parser.cpp

@@ -218,14 +218,19 @@ class ScriptParser
       int64_t val = 0;
       const char* first = tok.text.data();
       const char* last = first + tok.text.size();
-      if(tok.text.size() > 2 && tok.text[0] == '0' &&
-         (tok.text[1] == 'x' || tok.text[1] == 'X'))
+      const bool is_hex = tok.text.size() > 2 && tok.text[0] == '0' &&
+                          (tok.text[1] == 'x' || tok.text[1] == 'X');
+      const auto [ptr, ec] = is_hex ? std::from_chars(first + 2, last, val, 16) :
+                                      std::from_chars(first, last, val, 10);
+      // The tokenizer already guarantees the literal is made of (hex) digits, so
+      // the only remaining failure is result_out_of_range. from_chars leaves val
+      // untouched in that case, which would otherwise turn a literal like
+      // 0xFFFFFFFFFFFFFFFF into a silent 0.
+      if(ec != std::errc() || ptr != last)
       {
-        std::from_chars(first + 2, last, val, 16);
-      }
-      else
-      {
-        std::from_chars(first, last, val, 10);
+        throw RuntimeError(StrCat("Integer literal '", tok.text, "' at position ",
+                                  std::to_string(tok.pos),
+                                  " is out of range for a 64-bit integer"));
       }
       return std::make_shared<Ast::ExprLiteral>(Any(val));
     }

tests/script_parser_test.cpp

@@ -98,6 +98,29 @@ TEST(ParserTest, AnyTypes_Failing)
   EXPECT_FALSE(BT::ParseScriptAndExecute(env, "foo").has_value());
 }
 
+TEST(ParserTest, IntegerLiteralOutOfRangeIsRejected)
+{
+  BT::Ast::Environment env = { BT::Blackboard::create(), {} };
+
+  // These literals overflow int64_t. std::from_chars leaves its output untouched
+  // on result_out_of_range, so the parser used to accept them and silently
+  // evaluate the literal as 0 (e.g. the all-bits mask 0xFFFFFFFFFFFFFFFF).
+  EXPECT_FALSE(BT::ValidateScript("9223372036854775808"));  // INT64_MAX + 1
+  EXPECT_FALSE(BT::ValidateScript("99999999999999999999999"));
+  EXPECT_FALSE(BT::ValidateScript("0xFFFFFFFFFFFFFFFF"));
+  EXPECT_FALSE(BT::ValidateScript("0x8000000000000000"));
+  EXPECT_FALSE(BT::ParseScriptAndExecute(env, "0xFFFFFFFFFFFFFFFF").has_value());
+
+  // The boundary values that do fit must still parse and keep their value.
+  auto max_val = BT::ParseScriptAndExecute(env, "9223372036854775807");
+  ASSERT_TRUE(max_val.has_value());
+  EXPECT_EQ(max_val.value().cast<int64_t>(), 9223372036854775807LL);
+
+  auto hex_val = BT::ParseScriptAndExecute(env, "0x7FFFFFFFFFFFFFFF");
+  ASSERT_TRUE(hex_val.has_value());
+  EXPECT_EQ(hex_val.value().cast<int64_t>(), 9223372036854775807LL);
+}
+
 TEST(ParserTest, DeeplyNestedScriptIsRejected)
 {
   // A script with thousands of nested parentheses or unary prefixes used to add