new parser

6 files changed, 485 insertions, 0 deletions

diff --git a/_tests/antlr.bnf b/_tests/antlr.bnf
new file mode 100644
index 0000000..7b0cf83
--- /dev/null
+++ b/_tests/antlr.bnf
@@ -0,0 +1,99 @@
+grammar ExprLexer;
+
+LF      : '\n' ;
+SP      : ' ' ;
+WS_CC   : [\t\r\f] ;
+SEMI    : ';' ;
+DOT     : '.' ;
+COLON   : ':' ;
+PIPE    : '|' ;
+TILDE   : '~' ;
+BSLASH  : '\\' ;
+DQUOTE  : '"' ;
+HASH    : '#' ;
+LPAREN  : '(' ;
+RPAREN  : ')' ;
+LSQBR   : '[' ;
+RSQBR   : ']' ;
+LCURLY  : '{' ;
+RCURLY  : '}' ;
+EQUAL   : '=' ;
+APOS    : '\'' ;
+GRAVE   : '`' ;
+COMMA   : ',' ;
+
+    : [\u0000-\u0009\u000b-\u00ff] ;
+
+BARE_CHAR     : [a-zA-Z0-9!$%&*+/<=>?@^_~-] | '\\' BARE_ESC ;
+
+BARE_ESC      : [\u0021-\u007e] ;
+
+QUOTED_CHAR   : [^"\\] | '\\' QUOTED_ESC ;
+
+QUOTED_ESC    : [\\"abefnrtv]
+              | 'x' HEX_DIGIT HEX_DIGIT
+              | 'u' '{' HEX_DIGIT+ '}'
+              ;
+
+
+HEX_DIGIT  : [0-9a-fA-F] ;
+ALPHA      : [a-zA-Z] ;
+ALNUM      : [a-zA-Z0-9] ;
+
+
+
+parse_unit    : blank* datum blank? ;
+
+
+blank         : LF | SP | WS_CC | comment ;
+
+datum         : datum_one ( join_char? datum )? ;
+
+
+comment       : ';' ( skip_datum | skip_line ) ;
+
+
+datum_one     : bare_string | fancy_datum ;
+
+join_char     : '.' | ':' | '|' ;
+
+
+skip_datum    : '~' parse_unit ;
+
+skip_line     : ANY_BUT_LF* LF? ;
+
+
+bare_string   : BARE_CHAR+ ;
+
+fancy_datum   : '\\' bare_esc_str
+              | '"' quoted_str '"'
+              | '#' hash_expr
+              | '(' list_body ')'
+              | '[' list_body ']'
+              | '{' list_body '}'
+              | quote_expr
+              ;
+
+
+bare_esc_str  : '\\' BARE_ESC BARE_CHAR* ;
+
+quoted_str    : QUOTED_CHAR* ;
+
+hash_expr     : rune fancy_datum?
+              | label ( '=' fancy_datum )?
+              | fancy_datum
+              ;
+
+list_body     : blank* ( list_head list_tail? )? ;
+
+quote_expr    : ( '\'' | '`' | ',' ) datum ;
+
+
+rune          : ALPHA ALNUM* ;
+
+label         : '%' HEX_DIGIT+ ;
+
+
+list_head     : datum blank* list_head? ;
+            
+list_tail     : blank+ '.' blank+ datum blank* ;
diff --git a/_tests/string b/_tests/string
new file mode 100644
index 0000000..c365d58
--- /dev/null
+++ b/_tests/string
@@ -0,0 +1 @@
+\0\a\b\t\n\v\f\r\e\e\r\f\v\n\t\b\a\0
\ No newline at end of file
diff --git a/_tests/switchtable.zig b/_tests/switchtable.zig
new file mode 100644
index 0000000..722ecdd
--- /dev/null
+++ b/_tests/switchtable.zig
@@ -0,0 +1,93 @@
+const std = @import("std");
+
+const Reader = std.io.AnyReader;
+
+pub fn main() !u8 {
+    return f();
+}
+
+fn f() !u8 {
+    const file = try std.fs.cwd().openFile("string", .{});
+    defer file.close();
+
+    var br = std.io.bufferedReader(file.reader());
+    const r = br.reader().any();
+
+    var n: u8 = 0;
+    for (0..1_000_000) |i| {
+        _ = i;
+        while (r.readByte() catch null) |c| {
+            n +%= try f1(r, c);
+        }
+        br.start = 0;
+        br.end = 0;
+        try file.seekTo(0);
+    }
+    return n;
+}
+
+fn f1(r: Reader, c1: u8) !u8 {
+    if (c1 != '\\') return c1;
+    const c = try r.readByte();
+    if (c == 'u') return unknown1();
+    return switch (c) {
+        '\\', '"' => c,
+        '0' => 0,
+        'a' => 7,
+        'b' => 8,
+        't' => 9,
+        'n' => 10,
+        'v' => 11,
+        'f' => 12,
+        'r' => 13,
+        'e' => 27,
+        'x' => unknown2(),
+        else => unknown3(),
+    };
+}
+
+fn f2(r: Reader, c1: u8) !u8 {
+    if (c1 != '\\') return c1;
+    const c = try r.readByte();
+    if (c == 'u') return unknown1();
+    if (c == 'x') return unknown2();
+    if (c == '\\' or c == '"') return c;
+    const itable = .{ '0', 'a', 'b', 't', 'n', 'v', 'f', 'r', 'e' };
+    const ctable: []const u8 = &.{ 0, 7, 8, 9, 10, 11, 12, 13, 27 };
+    const i = std.mem.indexOfScalar(u8, &itable, c) orelse return unknown3();
+    return ctable[i];
+}
+
+fn f3(r: Reader, c1: u8) !u8 {
+    if (c1 != '\\') return c1;
+    const c = try r.readByte();
+    if (c == 'u') return unknown1();
+    if (c == 'x') return unknown2();
+    if (c == '\\' or c == '"') return c;
+    if (c == '0') return 0;
+    const table = comptime t: {
+        var table: [26]u8 = .{0} ** 26;
+        table['a' - 'a'] = 7;
+        table['b' - 'a'] = 8;
+        table['t' - 'a'] = 9;
+        table['n' - 'a'] = 10;
+        table['v' - 'a'] = 11;
+        table['f' - 'a'] = 12;
+        table['r' - 'a'] = 13;
+        table['e' - 'a'] = 27;
+        break :t table;
+    };
+    if (c < 'a') return unknown3();
+    const result = table[c - 'a'];
+    return if (result != 0) result else unknown3();
+}
+
+fn unknown1() u8 {
+    return 0;
+}
+fn unknown2() u8 {
+    return 0;
+}
+fn unknown3() u8 {
+    return 0;
+}
diff --git a/_tests/test.c b/_tests/test.c
new file mode 100644
index 0000000..0b0917e
--- /dev/null
+++ b/_tests/test.c
@@ -0,0 +1,119 @@
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+#include <math.h>
+
+union test {
+  double d;
+  uint64_t u;
+};
+
+int main(int argc, char** argv) {
+
+  volatile uint64_t mask;
+  volatile uint64_t min;
+  volatile uint64_t max;
+
+  volatile double d1;
+  volatile double d2;
+
+  volatile uint64_t pd1;
+  volatile uint64_t pd2;
+
+
+  // 0 .. 2^51
+
+  //       SE__________QP__
+  mask = 0b1111111111110111111111111111111111111111111111111111111111111111;
+  min  = 0b1111111111110111111111111111111111111111111111111111111111111111;
+  max  = 0b1111111111110000000000000000000000000000000000000000000000000001;
+
+  memcpy(&d1, &min, 8);
+  memcpy(&d2, &max, 8);
+
+  printf("%lf\n", d1);
+  printf("%lf\n", d2);
+
+  memcpy(&pd1, &d1, 8);
+  memcpy(&pd2, &d2, 8);
+  pd1 ^= mask;
+  pd2 ^= mask;
+
+  printf("%ld\n", pd1);
+  printf("%ld\n", pd2);
+
+  printf("\n");
+
+  // -2^51 + 1 .. -1
+
+  //       SE__________QP__
+  min  = 0b1111111111111000000000000000000000000000000000000000000000000001;
+  max  = 0b1111111111111111111111111111111111111111111111111111111111111111;
+
+  memcpy(&d1, &min, 8);
+  memcpy(&d2, &max, 8);
+
+  printf("%lf\n", d1);
+  printf("%lf\n", d2);
+
+  memcpy(&pd1, &d1, 8);
+  memcpy(&pd2, &d2, 8);
+
+  printf("%ld\n", pd1);
+  printf("%ld\n", pd2);
+
+  printf("\n");
+
+  return 0;
+
+  // -2^50 + 1 .. -1
+
+  //       SE__________QFP__
+  mask = 0b1111111111111100000000000000000000000000000000000000000000000000;
+  min  = 0b0000000000000000000000000000000000000000000000000000000000000001;
+  max  = 0b0000000000000011111111111111111111111111111111111111111111111111;
+
+  printf("%ld\n", (int64_t) (min | mask));
+  printf("%ld\n", (int64_t) (max | mask));
+
+
+  // 0 .. 2^50
+
+  //       SE__________QFP__
+  mask = 0b0000000000000011111111111111111111111111111111111111111111111111;
+  min  = 0b0000000000000100000000000000000000000000000000000000000000000000;
+  max  = 0b0000000000000111111111111111111111111111111111111111111111111111;
+
+  printf("%ld\n", (int64_t) (min & mask));
+  printf("%ld\n", (int64_t) (max & mask));
+
+
+
+
+  /* volatile union test x; */
+  /* volatile double f1; */
+  /* volatile double f2; */
+
+  /* f1 = 0.0; */
+  /* f2 = 0.0; */
+  /* x.d = f1 / f2; */
+  /* printf(" 0/0: %lx\n", x.u); */
+
+  /* f1 = -0.0; */
+  /* f2 = +0.0; */
+  /* x.d = f1 / f2; */
+  /* printf("-0/0: %lx\n", x.u); */
+
+  /* x.d = sqrt(-1); */
+  /* printf("sqrt(-1): %lx\n", x.u); */
+
+
+  /* double nan_value = fabs(sqrt(-1.0));  // Standard way to generate NaN */
+
+  /* uint64_t nan_bits; */
+  /* memcpy(&nan_bits, &nan_value, sizeof(nan_bits)); */
+
+  /* printf("NaN in hex: 0x%016lx\n", nan_bits); */
+    
+  /* return 0; */
+}
diff --git a/_tests/test.scm b/_tests/test.scm
new file mode 100644
index 0000000..d893c9f
--- /dev/null
+++ b/_tests/test.scm
@@ -0,0 +1,89 @@
+(import
+ (rnrs eval)
+ (rnrs hashtables))
+
+(define-syntax eval-when-compile
+  (lambda (stx)
+    (syntax-case stx ()
+      ((_ imports body ...)
+       (eval
+         (syntax->datum #'(begin body ...))
+         (apply environment (syntax->datum #'imports)))))))
+
+(eval-when-compile
+ ((rnrs))
+ (display "foo\n"))
+
+(define-syntax process-data
+  (lambda (stx)
+    (syntax-case stx ()
+      ((_ file)
+       (let ((ht (make-eqv-hashtable)))
+         (hashtable-set! ht 1 2)
+         ht)))))
+
+(define lookup-table (process-data "lookup-table.dat"))
+
+(define seconds-per-day (number->string (* 24 60 60)))
+
+(define (foo arg1:Num arg2:Record)
+  (do-stuff arg2.field ))
+
+
+
+(define-class Person
+  (fields
+   name date-of-birth sex
+   (age person-age set-person-age!))
+  (methods
+   ((jump height)
+    (if (string=? name "lebron")
+        (perform-jump height)))))
+
+
+
+(define-record (r1 a b))
+
+(define-record (r1 a b)
+  (fields a b)
+  (set-r1-a! a)
+  (set-r1-b! b))
+
+(define my-r1 (r1 1 2))
+
+
+(define-record (r2 a b c d)
+  (parent (r1 a b)))
+
+(define-record (r2 a b c d)
+  (parent (r1 a b))
+  (fields c d)
+  (set-r2-c! c)
+  (set-r2-d! d))
+
+(define-record (r2 a b c d)
+  (parent (r1 (* 2 c) (* 4 d)))
+  (fields x y z)
+  (set-r2-x! a)
+  (set-r2-y! b)
+  (set-r2-z! (/ a b)))
+
+(define my-r2 (r2 1 2 3 4))
+
+
+(define-record (r3 a b c d e f)
+  (parent r2))
+
+(define-record r3
+  (parent r2)
+  (fields e f))
+
+(define (init-r3! r a b c d e f)
+  (init-r2! r a b c d)
+  (set-r3-e! e)
+  (set-r3-f! f))
+
+
+(define r (make-r3))
+(init-r3! r 1 2 3 4 5 6)
+
diff --git a/_tests/test.zig b/_tests/test.zig
new file mode 100644
index 0000000..7b4a04c
--- /dev/null
+++ b/_tests/test.zig
@@ -0,0 +1,84 @@
+const std = @import("std");
+
+pub fn main() void {
+    // const y: [3]u64 = .{ 1, 2, 3 };
+    // const x: struct { u8, u64, u8 } = y;
+    // @import("std").debug.print("{}\n", .{x[0] + x[1] + x[2]});
+
+    std.debug.print("{}\n", .{@sizeOf(struct { a: u8, b: u64, c: u8, d: bool })});
+}
+
+// const x: ?u8 = 5;
+// if (x == null) {
+//     return 1;
+// } else |val| {
+//     return val;
+// }
+// var list = std.ArrayList(u8).init(std.heap.smp_allocator);
+// try parseUniHex("1f4a9", &list);
+// std.debug.print("{s}\n", .{list.items});
+
+// fn parseUniHex(
+//     str: []const u8,
+//     s: *std.ArrayList(u8),
+// ) !void {
+//     var uc: u21 = parseHexDigit1(str[0]);
+//     for (str[1..]) |c| {
+//         uc = try std.math.shlExact(u21, uc, 4);
+//         uc |= parseHexDigit1(c);
+//     }
+
+//     std.debug.print("{u}\n", .{uc});
+
+//     const n = try std.unicode.utf8CodepointSequenceLength(uc);
+//     const buf = try s.addManyAsSlice(n);
+//     _ = try std.unicode.utf8Encode(uc, buf);
+// }
+
+// fn parseHexByte1(h1: u8, h2: u8) u8 {
+//     const hi = parseHexDigit1(h1);
+//     const lo = parseHexDigit1(h2);
+//     return hi << 4 | lo;
+// }
+
+// fn parseHexDigit1(c: u8) u8 {
+//     return switch (c) {
+//         '0'...'9' => c - '0',
+//         'A'...'F' => c - 'A' + 10,
+//         'a'...'f' => c - 'a' + 10,
+//         else => @panic(""),
+//     };
+// }
+
+// fn parseHexByte2(h1: u8, h2: u8) u8 {
+//     const hi: u8 = parseHexDigit2(h1);
+//     const lo = parseHexDigit2(h2);
+//     return hi << 4 | lo;
+// }
+
+// fn parseHexDigit2(c: u8) u4 {
+//     return @intCast(switch (c) {
+//         '0'...'9' => c - '0',
+//         'A'...'F' => c - 'A' + 10,
+//         'a'...'f' => c - 'a' + 10,
+//         else => @panic(""),
+//     });
+// }
+
+// fn parseUniHex1(str: []const u8) !u21 {
+//     var uc: u21 = parseHexDigit1(str[0]);
+//     for (str[1..]) |c| {
+//         uc = try std.math.shlExact(u21, uc, 4);
+//         uc |= parseHexDigit1(c);
+//     }
+//     return uc;
+// }
+
+// fn parseUniHex2(str: []const u8) !u21 {
+//     var uc: u21 = parseHexDigit2(str[0]);
+//     for (str[1..]) |c| {
+//         uc = try std.math.shlExact(u21, uc, 4);
+//         uc |= parseHexDigit2(c);
+//     }
+//     return uc;
+// }