[Tolk] Support binary number literals 0b1100

Along with hex 0x, 0b is also parsed.
Example: 0b1010101010101010 == 43690.

Author: tolk-vm

tolk-tester/tests/numbers-tests.tolk

@@ -0,0 +1,35 @@
+const x1 = 0xFF;
+const x2 = 0xAbcdEF01234561AC;
+const x3 = 0x00BEC;
+const x4 = -0xD70B;
+
+const d1 = 255;
+const d2 = 12379813738877116844;
+const d3 = 003052;
+const d4 = -55051;
+
+const b1 = 0b11111111;
+const b2 = 0b1010101111001101111011110000000100100011010001010110000110101100;
+const b3 = 0b00101111101100;
+const b4 = -0b1101011100001011;
+
+fun main() {
+    assert(x1 == d1 && x1 == b1, 100);
+    assert(x2 == d2 && x2 == b2, 100);
+    assert(x3 == d3 && x3 == b3, 100);
+    assert(x4 == d4 && x4 == b4, 100);
+    assert(x1 + x2 + x3 == b1 + b2 + b3, 100);
+    assert(-x2 == -d2 && -x2 == -b2, 100);
+
+    return (
+        0b1010101010101010+0b00 == 43690,
+        0b0 == 0,
+        -0b1010100001010101010-0b1+0b1 == -344746,
+        0b00001 == 1,
+        --0b00101111101100 == 3052
+    );
+}
+
+/**
+@testcase | 0 |     | -1 -1 -1 -1 -1
+ */

tolk/ast-from-tokens.cpp

@@ -123,6 +123,25 @@ static AnyExprV maybe_replace_eq_null_with_isNull_check(V<ast_binary_operator> v
   return createV<ast_is_null_check>(v->loc, v_nullable, v->tok == tok_neq);
 }
 
+// parse `123` / `0xFF` / `0b10001` to td::RefInt256
+static td::RefInt256 parse_tok_int_const(std::string_view text) {
+  bool bin = text[0] == '0' && text[1] == 'b';
+  if (!bin) {
+    // this function parses decimal and hex numbers
+    return td::string_to_int256(static_cast<std::string>(text));
+  }
+  // parse a binary number; to make it simpler, don't allow too long numbers, it's impractical
+  if (text.size() > 64 + 2) {
+    return {};
+  }
+  uint64_t result = 0;
+  for (char c : text.substr(2)) { // skip "0b"
+    result = (result << 1) | static_cast<uint64_t>(c - '0');
+  }
+  return td::make_refint(result);
+}
+
+
 
 /*
  *
@@ -313,7 +332,7 @@ static AnyExprV parse_expr100(Lexer& lex) {
     }
     case tok_int_const: {
       std::string_view orig_str = lex.cur_str();
-      td::RefInt256 intval = td::string_to_int256(static_cast<std::string>(orig_str));
+      td::RefInt256 intval = parse_tok_int_const(orig_str);
       if (intval.is_null() || !intval->signed_fits_bits(257)) {
         lex.error("invalid integer constant");
       }

tolk/lexer.cpp

@@ -238,27 +238,43 @@ struct ChunkAnnotation final : ChunkLexerBase {
 
 // A number, may be a hex one.
 struct ChunkNumber final : ChunkLexerBase {
-  bool parse(Lexer* lex) const override {
+  static bool parse_hex_or_bin(Lexer* lex, bool bin) {
     const char* str_begin = lex->c_str();
-    bool hex = false;
-    if (lex->char_at() == '0' && lex->char_at(1) == 'x') {
-      lex->skip_chars(2);
-      hex = true;
-    }
+    lex->skip_chars(2);     // 0x / 0b
     if (lex->is_eof()) {
       return false;
     }
+
     while (!lex->is_eof()) {
       char c = lex->char_at();
-      if (c >= '0' && c <= '9') {
-        lex->skip_chars(1);
-        continue;
-      }
-      if (!hex) {
+      bool ok = bin
+        ? c == '0' || c == '1'
+        : (c >= '0' && c <= '9') || ((c | 0x20) >= 'a' && (c | 0x20) <= 'f');
+      if (!ok) {
         break;
       }
-      c |= 0x20;
-      if (c < 'a' || c > 'f') {
+      lex->skip_chars(1);
+    }
+
+    std::string_view str_val(str_begin, lex->c_str() - str_begin);
+    lex->add_token(tok_int_const, str_val);
+    return true;
+  }
+
+  bool parse(Lexer* lex) const override {
+    if (lex->char_at() == '0') {
+      if (lex->char_at(1) == 'x') {
+        return parse_hex_or_bin(lex, false);
+      }
+      if (lex->char_at(1) == 'b') {
+        return parse_hex_or_bin(lex, true);
+      }
+    }
+
+    const char* str_begin = lex->c_str();
+    while (!lex->is_eof()) {
+      char c = lex->char_at();
+      if (c < '0' || c > '9') {
         break;
       }
       lex->skip_chars(1);