From 3f91646ab0d0934cd33e60112fa3ac33dd95191a Mon Sep 17 00:00:00 2001
From: Kata Choi <kata.choi@gmail.com>
Date: Thu, 24 Oct 2024 14:53:48 +0800
Subject: [PATCH] Add u16/32/64 (#206)

* add uint16/32/64
* allow [0][0]
---
 src/parser/expr.rs       |   6 ++-
 src/stdlib/native/int.no | 108 +++++++++++++++++++++++++++++++++++++++
 2 files changed, 112 insertions(+), 2 deletions(-)
 create mode 100644 src/stdlib/native/int.no

diff --git a/src/parser/expr.rs b/src/parser/expr.rs
index d070290bb..db68f2eba 100644
--- a/src/parser/expr.rs
+++ b/src/parser/expr.rs
@@ -545,9 +545,11 @@ impl Expr {
                 // sanity check
                 if !matches!(
                     self.kind,
-                    ExprKind::Variable { .. } | ExprKind::FieldAccess { .. }
+                    ExprKind::Variable { .. }
+                        | ExprKind::FieldAccess { .. }
+                        | ExprKind::ArrayAccess { .. }
                 ) {
-                    panic!("an array access can only follow a variable");
+                    panic!("an array access can only follow a variable or another array access");
                 }
 
                 // array[idx]
diff --git a/src/stdlib/native/int.no b/src/stdlib/native/int.no
new file mode 100644
index 000000000..4390c3db6
--- /dev/null
+++ b/src/stdlib/native/int.no
@@ -0,0 +1,108 @@
+use std::bits;
+use std::comparator;
+
+// u8
+struct Uint8 {
+    inner: Field,
+    bit_len: Field,
+}
+
+fn Uint8.new(val: Field) -> Uint8 {
+    let bit_len = 8;
+
+    // range check
+    let ignore_ = bits::to_bits(bit_len, val);
+
+    return Uint8 {
+        inner: val,
+        bit_len: bit_len
+    };
+}
+
+// u16
+struct Uint16 {
+    inner: Field,
+    bit_len: Field,
+}
+
+fn Uint16.new(val: Field) -> Uint16 {
+    let bit_len = 16;
+
+    // range check
+    let ignore_ = bits::to_bits(bit_len, val);
+
+    return Uint16 {
+        inner: val,
+        bit_len: bit_len
+    };
+}
+
+// u32
+struct Uint32 {
+    inner: Field,
+    bit_len: Field,
+}
+
+fn Uint32.new(val: Field) -> Uint32 {
+    let bit_len = 32;
+
+    // range check
+    let ignore_ = bits::to_bits(bit_len, val);
+
+    return Uint32 {
+        inner: val,
+        bit_len: bit_len
+    };
+}
+
+// u64
+struct Uint64 {
+    inner: Field,
+    bit_len: Field,
+}
+
+fn Uint64.new(val: Field) -> Uint64 {
+    let bit_len = 64;
+
+    // range check
+    let ignore_ = bits::to_bits(bit_len, val);
+
+    return Uint64 {
+        inner: val,
+        bit_len: bit_len
+    };
+}
+
+// implement comparator
+
+fn Uint8.less_than(self, rhs: Uint8) -> Bool {
+    return comparator::less_than(self.bit_len, self.inner, rhs.inner);
+}
+
+fn Uint8.less_eq_than(self, rhs: Uint8) -> Bool {
+    return comparator::less_eq_than(self.bit_len, self.inner, rhs.inner);
+}
+
+fn Uint16.less_than(self, rhs: Uint16) -> Bool {
+    return comparator::less_than(self.bit_len, self.inner, rhs.inner);
+}
+
+fn Uint16.less_eq_than(self, rhs: Uint16) -> Bool {
+    return comparator::less_eq_than(self.bit_len, self.inner, rhs.inner);
+}
+
+fn Uint32.less_than(self, rhs: Uint32) -> Bool {
+    return comparator::less_than(self.bit_len, self.inner, rhs.inner);
+}
+
+fn Uint32.less_eq_than(self, rhs: Uint32) -> Bool {
+    return comparator::less_eq_than(self.bit_len, self.inner, rhs.inner);
+}
+
+fn Uint64.less_than(self, rhs: Uint64) -> Bool {
+    return comparator::less_than(self.bit_len, self.inner, rhs.inner);
+}
+
+fn Uint64.less_eq_than(self, rhs: Uint64) -> Bool {
+    return comparator::less_eq_than(self.bit_len, self.inner, rhs.inner);
+}
\ No newline at end of file