JSSpecCompiler: Parse arbitrarily large rational numbers in xspec mode

Meta/Lagom/Tools/CodeGenerators/JSSpecCompiler/AST/AST.h

@@ -10,6 +10,7 @@
 #include <AK/RefCounted.h>
 #include <AK/RefPtr.h>
 #include <AK/Vector.h>
+#include <LibCrypto/BigFraction/BigFraction.h>
 
 #include "Forward.h"
 
@@ -208,16 +209,16 @@ protected:
 
 class MathematicalConstant : public Expression {
 public:
-    MathematicalConstant(i64 number)
+    MathematicalConstant(Crypto::BigFraction number)
         : m_number(number)
     {
     }
 
-    // TODO: This should be able to hold arbitrary number
-    i64 m_number;
-
 protected:
     void dump_tree(StringBuilder& builder) override;
+
+private:
+    Crypto::BigFraction m_number;
 };
 
 class StringLiteral : public Expression {

Meta/Lagom/Tools/CodeGenerators/JSSpecCompiler/AST/ASTPrinting.cpp

@@ -62,7 +62,12 @@ void ControlFlowBranch::dump_tree(StringBuilder& builder)
 
 void MathematicalConstant::dump_tree(StringBuilder& builder)
 {
-    dump_node(builder, "MathematicalConstant {}", m_number);
+    String representation;
+    if (Crypto::UnsignedBigInteger { 1000 }.divided_by(m_number.denominator()).remainder == 0)
+        representation = MUST(String::from_byte_string(m_number.to_byte_string(3)));
+    else
+        representation = MUST(String::formatted("{}/{}", MUST(m_number.numerator().to_base(10)), MUST(m_number.denominator().to_base(10))));
+    dump_node(builder, "MathematicalConstant {}", representation);
 }
 
 void StringLiteral::dump_tree(StringBuilder& builder)

Meta/Lagom/Tools/CodeGenerators/JSSpecCompiler/CMakeLists.txt

@@ -21,6 +21,6 @@ set(SOURCES
     main.cpp
 )
 
-lagom_tool(JSSpecCompiler LIBS LibCpp LibMain LibXML)
+lagom_tool(JSSpecCompiler LIBS LibCpp LibMain LibXML LibCrypto)
 target_include_directories(JSSpecCompiler PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
 target_compile_options(JSSpecCompiler PRIVATE -Wno-missing-field-initializers)

Meta/Lagom/Tools/CodeGenerators/JSSpecCompiler/Parser/CppASTConverter.cpp

@@ -126,7 +126,8 @@ template<>
 NullableTree CppASTConverter::convert_node(Cpp::NumericLiteral const& literal)
 {
     // TODO: Numerical literals are not limited to i64.
-    return make_ref_counted<MathematicalConstant>(literal.value().to_number<i64>().value());
+    VERIFY(literal.value().to_number<i64>().has_value());
+    return make_ref_counted<MathematicalConstant>(MUST(Crypto::BigFraction::from_string(literal.value())));
 }
 
 template<>

Meta/Lagom/Tools/CodeGenerators/JSSpecCompiler/Parser/TextParser.cpp

@@ -299,7 +299,7 @@ TextParseErrorOr<Tree> TextParser::parse_expression()
             if (token.type == TokenType::Identifier) {
                 expression = make_ref_counted<UnresolvedReference>(token.data);
             } else if (token.type == TokenType::Number) {
-                expression = make_ref_counted<MathematicalConstant>(token.data.to_number<i64>().value());
+                expression = make_ref_counted<MathematicalConstant>(MUST(Crypto::BigFraction::from_string(token.data)));
             } else if (token.type == TokenType::String) {
                 expression = make_ref_counted<StringLiteral>(token.data);
             } else {

Meta/Lagom/Tools/CodeGenerators/JSSpecCompiler/Tests/spec-parsing.xml

@@ -0,0 +1,16 @@
+<!DOCTYPE inline_dtd[<!ENTITY nbsp " ">]>
+<specification>
+   <emu-clause id="1" aoid="ArbitrarilyLargeNumbers">
+      <h1><span class="secnum">1</span> ArbitrarilyLargeNumbers ( <var>a</var> )</h1>
+      <emu-alg>
+         <ol>
+            <li>Let <var>a</var> be 1.</li>
+            <li>Let <var>b</var> be 3.6.</li>
+            <li>Let <var>c</var> be -3.6.</li>
+            <li>Let <var>d</var> be -1000000000000000000000.</li>
+            <li>Let <var>e</var> be 1.0000001.</li>
+            <li>Return <var>a</var>+<var>b</var>+<var>c</var>+<var>d</var>+<var>e</var>.</li>
+         </ol>
+      </emu-alg>
+   </emu-clause>
+</specification>

Meta/Lagom/Tools/CodeGenerators/JSSpecCompiler/Tests/spec-parsing.xml.expectation

@@ -0,0 +1,29 @@
+===== AST after reference-resolving =====
+ArbitrarilyLargeNumbers(a):
+TreeList
+  BinaryOperation Assignment
+    Var a
+    MathematicalConstant 1
+  BinaryOperation Assignment
+    Var b
+    MathematicalConstant 3.6
+  BinaryOperation Assignment
+    Var c
+    MathematicalConstant -3.6
+  BinaryOperation Assignment
+    Var d
+    MathematicalConstant -1000000000000000000000
+  BinaryOperation Assignment
+    Var e
+    MathematicalConstant 10000001/10000000
+  ReturnNode
+    BinaryOperation Plus
+      Var a
+      BinaryOperation Plus
+        Var b
+        BinaryOperation Plus
+          Var c
+          BinaryOperation Plus
+            Var d
+            Var e
+

Tests/JSSpecCompiler/test-runner.cpp

@@ -50,6 +50,7 @@ const Array regression_tests = {
     TestDescription {
         .sources = {
             "spec-no-new-line-after-dot.xml"sv,
+            "spec-parsing.xml"sv,
             "spec-single-function-simple.xml"sv,
         },
         .flags = { dump_after_frontend },

Userland/Libraries/LibCrypto/BigFraction/BigFraction.h

@@ -58,6 +58,9 @@ public:
     ByteString to_byte_string(unsigned rounding_threshold) const;
     double to_double() const;
 
+    Crypto::SignedBigInteger const& numerator() const& { return m_numerator; }
+    Crypto::UnsignedBigInteger const& denominator() const& { return m_denominator; }
+
 private:
     void reduce();