Expand Standard Library

Author: python-processing-unit

asmln.exe

@@ -65,32 +65,37 @@ def __init__(self, text: str, filename: str) -> None:
         self.column = 1
     def tokenize(self) -> List[Token]:
         tokens: List[Token] = []
-        while(not self._eof):
-            ch:str = self._peek()
+        # Cache frequently used methods/values locally for speed.
+        _peek = self._peek
+        _advance = self._advance
+        _is_identifier_start = self._is_identifier_start
+        symbols = SYMBOLS
+        while not self._eof:
+            ch: str = _peek()
             if(ch in " \t"):
-                self._advance()
+                _advance()
                 continue
             if(ch == "\r"):
-                self._advance()
+                _advance()
                 continue
             if(ch == "\n"):
                 tokens.append(Token("NEWLINE","\n",self.line,self.column))
-                self._advance()
+                _advance()
                 continue
             if(ch == "#"):
                 self._consume_comment()
                 continue
             if(ch in SYMBOLS):
-                tokens.append(Token(SYMBOLS[ch],ch,self.line,self.column))
-                self._advance()
+                tokens.append(Token(symbols[ch], ch, self.line, self.column))
+                _advance()
                 continue
             if(ch == "-"):
                 tokens.append(self._consume_signed_number())
                 continue
             if(ch in "01"):
                 tokens.append(self._consume_unsigned_number())
                 continue
-            if(self._is_identifier_start(ch)):
+            if _is_identifier_start(ch):
                 tokens.append(self._consume_identifier())
                 continue
             raise ASMParseError(f"Unexpected character '{ch}' at {self.filename}:{self.line}:{self.column}")
@@ -321,8 +326,16 @@ def _parse_expression(self) -> Expression:
         token = self._peek()
         if(token.type == "NUMBER"):
             number:Token = self._consume("NUMBER")
-            value:int = int(number.value,2)
-            return(Literal(location=self._location_from_token(number),value=value))
+            # NUMBER token may be prefixed with '-' for negative literals.
+            sval = number.value
+            if sval.startswith("-"):
+                # safe parse of negative binary literal
+                if len(sval) == 1:
+                    raise ASMParseError(f"Invalid numeric literal at line {number.line}")
+                value = -int(sval[1:], 2)
+            else:
+                value = int(sval, 2)
+            return Literal(location=self._location_from_token(number), value=value)
         if(token.type == "IDENT"):
             ident:Token = self._consume("IDENT")
             location:SourceLocation = self._location_from_token(ident)
@@ -503,6 +516,8 @@ def __init__(self) -> None:
         self._register_fixed("BOR", 2, lambda a, b: a | b)
         self._register_fixed("BXOR", 2, lambda a, b: a ^ b)
         self._register_fixed("BNOT", 1, lambda a: ~a)
+        self._register_fixed("SHL", 2, self._shift_left)
+        self._register_fixed("SHR", 2, self._shift_right)
         # Return the inclusive bit-slice [hi:lo] of `a` as an unsigned integer.
         # Bits are numbered starting at 0 for the least-significant bit.
         # Implementation note: uses masking so negative values yield their
@@ -563,7 +578,12 @@ def invoke(
         builtin = self.table.get(name)
         if builtin is None:
             raise ASMRuntimeError(f"Unknown function '{name}'", location=location)
-        builtin.validate(len(args))
+        # Inline validation to avoid a method call in hot path.
+        supplied = len(args)
+        if supplied < builtin.min_args:
+            raise ASMRuntimeError(f"{name} expects at least {builtin.min_args} arguments", rewrite_rule=name)
+        if builtin.max_args is not None and supplied > builtin.max_args:
+            raise ASMRuntimeError(f"{name} expects at most {builtin.max_args} arguments", rewrite_rule=name)
         return builtin.impl(interpreter, args, arg_nodes, env, location)
     def _safe_div(self, a: int, b: int) -> int:
         if b == 0:
@@ -587,6 +607,16 @@ def _safe_pow(self, a: int, b: int) -> int:
         if b < 0:
             raise ASMRuntimeError("Negative exponent not supported", rewrite_rule="POW")
         return pow(a, b)
+
+    def _shift_left(self, value: int, amount: int) -> int:
+        if amount < 0:
+            raise ASMRuntimeError("SHL amount must be non-negative", rewrite_rule="SHL")
+        return value << amount
+
+    def _shift_right(self, value: int, amount: int) -> int:
+        if amount < 0:
+            raise ASMRuntimeError("SHR amount must be non-negative", rewrite_rule="SHR")
+        return value >> amount
     def _lcm(self, a: int, b: int) -> int:
         if a == 0 or b == 0:
             return 0

asmln.py

@@ -2,10 +2,6 @@ FUNC POW2(k)[
   RETURN( POW(10, k) )
 ]
 
-FUNC SHL(x, k)[
-  RETURN( MUL(x, POW(10, k)) )
-]
-
 FUNC COL_EMPTY()[
   RETURN(0)
 ]
@@ -66,6 +62,7 @@ FUNC READ_ITEM_LEN_AT(payload, offset)[
 ]
 
 FUNC COL_GET(coll, index)[
+  # get item at index from collection coll
   count = GET_COUNT(coll)
   ASSERT( LT(index, count) )
   payload = GET_PAYLOAD(coll)
@@ -99,20 +96,26 @@ FUNC COL_GET(coll, index)[
 ]
 
 FUNC COL_PUSH(coll, v)[
+  # append item v to collection coll
   count = GET_COUNT(coll)
   pbl = GET_PBL(coll)
   payload = GET_PAYLOAD(coll)
 
   enc = ENCODE_ITEM(v)
-  enc_len = MOD(enc, POW(10, 100000))        # low 32 bits = length
+  enc_len = MOD(enc, POW(10, 100000))        # low 32 bits = m (header+sign+mag params)
   enc_code = DIV(enc, POW(10, 100000))       # high part = code
+
+  # compute actual encoded bit length: total_len = 2*m + 1  (note: MUL(10, enc_len) == 2*enc_len)
+  enc_bitlen = ADD( MUL(10, enc_len), 1 )
+
   new_payload = ADD( payload, MUL(enc_code, POW(10, pbl)) )  # append at LSB end
-  new_pbl = ADD(pbl, enc_len)
+  new_pbl = ADD(pbl, enc_bitlen)
   new_count = ADD(count, 1)
   RETURN( MAKE_COLL(new_payload, new_pbl, new_count) )
 ]
 
 FUNC COL_POP(coll)[
+  # remove and return last item from collection coll
   count = GET_COUNT(coll)
   ASSERT( GT(count, 0) )
   payload = GET_PAYLOAD(coll)
@@ -151,19 +154,47 @@ FUNC COL_POP(coll)[
   ]
 ]
 
-FUNC COL_SET(coll, index, v)[ # set item at index to v
+FUNC READ_ITEM_AT(payload, offset)[
+  pos = 0
+  WHILE(1)[
+    b = SLICE(payload, ADD(offset, pos), ADD(offset, pos))
+    IF(EQ(b, 1))[
+      pos = ADD(pos, 1)
+    ] ELSE [
+      header_count = pos
+      m = ADD(header_count, 1)
+      sign = SLICE(payload, ADD(offset, m), ADD(offset, m))
+      mag = SLICE(payload, ADD(offset, ADD(m, m)), ADD(offset, ADD(m, 1)))
+      IF(EQ(sign, 1))[
+        item = NEG(mag)
+      ] ELSE [
+        item = mag
+      ]
+      item_len = ADD( MUL(10, m), 1 )
+      next_offset = ADD(offset, item_len)
+      RETURN( ADD( MUL(next_offset, POW(10, 1000000)), item ) )
+    ]
+  ]
+]
+
+FUNC COL_SET(coll, index, v)[
+  # set item at index to v (non-recursive)
   count = GET_COUNT(coll)
   ASSERT( LT(index, count) )
-  new_coll = COL_EMPTY()
+  payload = GET_PAYLOAD(coll)
+  offset = 0
   i = 0
+  new_coll = COL_EMPTY()
   WHILE( LT(i, count) )[
-    cur = COL_GET(coll, i)
+    pair = READ_ITEM_AT(payload, offset)
+    item = MOD(pair, POW(10, 1000000))
+    offset = DIV(pair, POW(10, 1000000))
     IF(EQ(i, index))[
-      cur = v
+      item = v
     ] ELSE [
-      cur = cur
+      item = item
     ]
-    new_coll = COL_PUSH(new_coll, cur)
+    new_coll = COL_PUSH(new_coll, item)
     i = ADD(i, 1)
   ]
   RETURN(new_coll)