Addr literal

tealish/base.py

@@ -7,7 +7,7 @@
 
 if TYPE_CHECKING:
     from . import TealWriter
-    from .nodes import Block, Node, Func
+    from .nodes import Block, Node, Func, Literal
 
 lang_spec = get_active_langspec()
 
@@ -154,10 +154,10 @@ def lookup_func(self, name: str) -> "Func":
     def lookup_var(self, name: str) -> Any:
         return self.get_scope().lookup_var(name)
 
-    def lookup_const(self, name: str) -> Tuple["AVMType", ConstValue]:
+    def lookup_const(self, name: str) -> Tuple["AVMType", Union["Literal", ConstValue]]:
         return self.get_scope().lookup_const(name)
 
-    def lookup_avm_constant(self, name: str) -> Tuple["AVMType", Any]:
+    def lookup_avm_constant(self, name: str) -> Tuple["AVMType", ConstValue]:
         return lang_spec.lookup_avm_constant(name)
 
     # TODO: these attributes are only available on Node and other children types

tealish/expression_nodes.py

@@ -4,11 +4,12 @@
 from .errors import CompileError
 from .tealish_builtins import AVMType, get_struct
 from .langspec import Op, type_lookup
+from .scope import ConstValue
 
 
 if TYPE_CHECKING:
     from . import TealWriter
-    from .nodes import Node, Func, GenericExpression
+    from .nodes import Node, Func, GenericExpression, Literal
 
 
 class Integer(BaseNode):
@@ -66,9 +67,11 @@ def __init__(self, name: str, parent: Optional[BaseNode] = None) -> None:
         self.name = name
         self.type: AVMType = AVMType.none
         self.parent = parent
+        self.value: Union[ConstValue, "Literal"]
 
     def process(self) -> None:
-        type, value = None, None
+        type: AVMType = AVMType.none
+        value: Union[ConstValue, "Literal"] = 0
         try:
             # user defined const
             type, value = self.lookup_const(self.name)
@@ -87,10 +90,14 @@ def process(self) -> None:
         self.value = value
 
     def write_teal(self, writer: "TealWriter") -> None:
-        if self.type == AVMType.int:
-            writer.write(self, f"pushint {self.value} // {self.name}")  # type: ignore
-        elif self.type == AVMType.bytes:
+        if isinstance(self.value, str) or isinstance(self.value, bytes):
+            assert self.type == AVMType.bytes
             writer.write(self, f"pushbytes {self.value} // {self.name}")  # type: ignore
+        elif isinstance(self.value, int):
+            assert self.type == AVMType.int
+            writer.write(self, f"pushint {self.value} // {self.name}")
+        else:
+            self.value.write_teal(writer)
 
     def _tealish(self) -> str:
         return f"{self.name}"

tealish/nodes.py

@@ -22,7 +22,9 @@
 from .scope import Scope, VarType
 
 LITERAL_INT = r"[0-9]+"
-LITERAL_BYTES = r'"(.+)"'
+LITERAL_BYTE_STRING = r'"(.+)"'
+LITERAL_BYTE_HEX = r"0x([a-fA-F0-9]+)"
+LITERAL_BYTE_ADDR = r"([A-Z2-7]+)"
 VARIABLE_NAME = r"[a-z_][a-zA-Z0-9_]*"
 
 if TYPE_CHECKING:
@@ -140,7 +142,12 @@ class Literal(Expression):
 
     @classmethod
     def parse(cls, line: str, parent: Node, compiler: "TealishCompiler") -> Node:
-        matchable: List[Type[Expression]] = [LiteralInt, LiteralBytes]
+        matchable: List[Type[Expression]] = [
+            LiteralAddr,
+            LiteralHex,
+            LiteralInt,
+            LiteralBytes,
+        ]
         for expr in matchable:
             if expr.match(line):
                 return expr(line, parent, compiler)
@@ -162,7 +169,35 @@ def _tealish(self) -> str:
 
 
 class LiteralBytes(Literal):
-    pattern = rf"(?P<value>{LITERAL_BYTES})$"
+    pattern = rf"(?P<value>{LITERAL_BYTE_STRING})$"
+    value: str
+
+    def write_teal(self, writer: "TealWriter") -> None:
+        writer.write(self, f"pushbytes {self.value}")
+
+    def type(self) -> AVMType:
+        return AVMType.bytes
+
+    def _tealish(self) -> str:
+        return f"{self.value}"
+
+
+class LiteralAddr(Literal):
+    pattern = rf"addr\((?P<value>{LITERAL_BYTE_ADDR})\)$"
+    value: str
+
+    def write_teal(self, writer: "TealWriter") -> None:
+        writer.write(self, f"addr {self.value}")
+
+    def type(self) -> AVMType:
+        return AVMType.bytes
+
+    def _tealish(self) -> str:
+        return f"addr({self.value})"
+
+
+class LiteralHex(Literal):
+    pattern = rf"(?P<value>{LITERAL_BYTE_HEX})$"
     value: str
 
     def write_teal(self, writer: "TealWriter") -> None:
@@ -379,7 +414,7 @@ class Const(LineStatement):
 
     def process(self) -> None:
         scope = self.get_current_scope()
-        scope.declare_const(self.name, (self.type, self.expression.value))
+        scope.declare_const(self.name, (self.type, self.expression))
 
     def write_teal(self, writer: "TealWriter") -> None:
         pass

tealish/scope.py

@@ -3,7 +3,7 @@
 
 if TYPE_CHECKING:
     from .tealish_builtins import AVMType
-    from .nodes import Func, Block
+    from .nodes import Func, Block, Literal
 
 
 VarType = Union["AVMType", Tuple[str, str]]
@@ -25,7 +25,7 @@ def __init__(
             slot_range if slot_range is not None else (0, 200)
         )
 
-        self.consts: Dict[str, Tuple["AVMType", ConstValue]] = {}
+        self.consts: Dict[str, Tuple["AVMType", Union[ConstValue, "Literal"]]] = {}
         self.blocks: Dict[str, "Block"] = {}
         self.functions: Dict[str, "Func"] = {}
 
@@ -63,11 +63,11 @@ def delete_var(self, name: str) -> None:
             del self.slots[name]
 
     def declare_const(
-        self, name: str, const_data: Tuple["AVMType", ConstValue]
+        self, name: str, const_data: Tuple["AVMType", Union["Literal", ConstValue]]
     ) -> None:
         self.consts[name] = const_data
 
-    def lookup_const(self, name: str) -> Tuple["AVMType", ConstValue]:
+    def lookup_const(self, name: str) -> Tuple["AVMType", Union["Literal", ConstValue]]:
         if name not in self.consts:
             raise KeyError(f'Const "{name}" not declared in current scope')
         return self.consts[name]

tealish/tealish_expressions.tx

@@ -35,4 +35,6 @@ GroupIndex: NegativeGroupIndex | PositiveGroupIndex | Expression;
 NegativeGroupIndex: '-' index=INT;
 PositiveGroupIndex: '+' index=INT;
 Integer: value=/[0-9_]+/;
-Bytes: value=STRING;
+HexBytes: value=/0x([a-fA-F0-9]+)/;
+AddrBytes:  value='addr('/([A-Z2-7]+)/ ')';
+Bytes: value=STRING | HexBytes | AddrBytes;