Update FVM bytecode

Bump bytecode format version to 2.
Replace dialect of stack elements with stack words.
Add unary dereference opcode.
Replace print opcode with put character opcode.
Remove print keyword token.
Remove print statement AST node.
Add intrinsic expression token.
Add intrinsic expression AST node.
Add put character intrinsic.
Add standard library.
Update example scripts.
Update grammar.
Update readme.
Add Python files to gitattributes.

Author: krobbi

.gitattributes

@@ -4,3 +4,6 @@
 # Mark FVM bytecode files as binary:
 *.fvm binary
 *.fyc binary
+
+# Assert that Python is Python:
+*.py linguist-language=Python

funcy/ast/nodes.py

@@ -292,6 +292,25 @@ def get_info(self) -> str:
         return self.op.name
 
 
+class IntrinsicExprNode(ExprNode):
+    """ An intrinsic expression node of an abstract syntax tree. """
+    
+    name: IdentifierExprNode
+    """ The intrinsic expression's name. """
+    
+    exprs: list[ExprNode]
+    """ The intrinsic expression's expressions. """
+    
+    def __init__(self, name: IdentifierExprNode) -> None:
+        """
+        Initialize the intrinsic expression's name and expressions.
+        """
+        
+        super().__init__()
+        self.name = name
+        self.exprs = []
+
+
 class DeclNode(Node):
     """ A declaration node of an abstract syntax tree. """
 
@@ -476,19 +495,6 @@ def __init__(self, expr: ExprNode) -> None:
         self.expr = expr
 
 
-class PrintStmtNode(StmtNode):
-    """ A print statement node of an abstract syntax tree. """
-    
-    expr: ExprNode
-    """ The print statement's expression. """
-    
-    def __init__(self, expr: ExprNode) -> None:
-        """ Initialize the print statement's expression. """
-        
-        super().__init__()
-        self.expr = expr
-
-
 class ScopedJumpStmt(StmtNode):
     """ A scoped jump statement node of an abstract syntax tree. """
 

funcy/ast/utils.py

@@ -24,8 +24,6 @@ def get_node_children(node: Node) -> list[Node]:
         return [node.decl, node.expr]
     elif isinstance(node, ReturnExprStmtNode):
         return [node.expr]
-    elif isinstance(node, PrintStmtNode):
-        return [node.expr]
     elif isinstance(node, ExprStmtNode):
         return [node.expr]
     elif isinstance(node, CallExprNode):
@@ -42,6 +40,10 @@ def get_node_children(node: Node) -> list[Node]:
         return [node.expr]
     elif isinstance(node, BinExprNode):
         return [node.lhs_expr, node.rhs_expr]
+    elif isinstance(node, IntrinsicExprNode):
+        result: list[ExprNode] = [node.name]
+        result.extend(node.exprs)
+        return result
 
     return []
 

funcy/ast/visitor.py

@@ -82,8 +82,6 @@ def visit(self, node: Node, code: Code) -> None:
             self.visit_return_stmt(node, code)
         elif isinstance(node, ReturnExprStmtNode):
             self.visit_return_expr_stmt(node, code)
-        elif isinstance(node, PrintStmtNode):
-            self.visit_print_stmt(node, code)
         elif isinstance(node, ScopedJumpStmt):
             self.visit_scoped_jump_stmt(node, code)
         elif isinstance(node, ExprStmtNode):
@@ -106,6 +104,8 @@ def visit(self, node: Node, code: Code) -> None:
             self.visit_un_expr(node, code)
         elif isinstance(node, BinExprNode):
             self.visit_bin_expr(node, code)
+        elif isinstance(node, IntrinsicExprNode):
+            self.visit_intrinsic_expr(node, code)
         else:
             self.log_error(f"Bug: Unimplemented visitor for '{node}'!", node)
 
@@ -170,7 +170,7 @@ def visit_func_stmt(self, node: FuncStmtNode, code: Code) -> None:
         self.scope_stack.pop()
 
         self.scope_stack.pop() # End parameter scope.
-        self.scope_stack.pop() # End body scope.
+        self.scope_stack.pop() # End buffer scope.
         code.set_label(parent_label)
 
 
@@ -288,13 +288,6 @@ def visit_return_expr_stmt(
         code.make_return()
 
 
-    def visit_print_stmt(self, node: PrintStmtNode, code: Code) -> None:
-        """ Visit a print statement node. """
-        
-        self.visit(node.expr, code)
-        code.make_print()
-    
-    
     def visit_scoped_jump_stmt(self, node: ScopedJumpStmt, code: Code) -> None:
         """ Visit a scoped jump statement node. """
 
@@ -590,3 +583,21 @@ def visit_bin_expr(self, node: BinExprNode, code: Code) -> None:
                     f"Bug: Unimplemented binary operator '{node.op.name}'!",
                     node)
             code.make_drop() # Preserve stack size.
+    
+    
+    def visit_intrinsic_expr(
+            self, node: IntrinsicExprNode, code: Code) -> None:
+        """ Visit an intrinsic expression node. """
+        
+        if node.name.name == "putChr":
+            if len(node.exprs) != 1:
+                self.log_error("Intrinsic 'putChr' expects 1 argument!", node)
+                code.make_push_int(0)
+                return
+            
+            self.visit(node.exprs[0], code)
+            code.make_put_chr()
+        else:
+            self.log_error(
+                    f"Intrinsic '{node.name.name}' does not exist!", node.name)
+            code.make_push_int(0)

funcy/fvm.py

@@ -1,3 +1,5 @@
+import sys
+
 from enum import Enum
 
 class Opcode(Enum):
@@ -20,22 +22,23 @@ class Opcode(Enum):
     PUSH_S32 = 0x0e
     LOAD_LOCAL = 0x0f
     STORE_LOCAL = 0x10
-    UNARY_NEGATE = 0x11
-    UNARY_NOT = 0x12
-    BINARY_ADD = 0x13
-    BINARY_SUBTRACT = 0x14
-    BINARY_MULTIPLY = 0x15
-    BINARY_DIVIDE = 0x16
-    BINARY_MODULO = 0x17
-    BINARY_EQUALS = 0x18
-    BINARY_NOT_EQUALS = 0x19
-    BINARY_GREATER = 0x1a
-    BINARY_GREATER_EQUALS = 0x1b
-    BINARY_LESS = 0x1c
-    BINARY_LESS_EQUALS = 0x1d
-    BINARY_AND = 0x1e
-    BINARY_OR = 0x1f
-    PRINT = 0x20
+    UNARY_DEREFERENCE = 0x11
+    UNARY_NEGATE = 0x12
+    UNARY_NOT = 0x13
+    BINARY_ADD = 0x14
+    BINARY_SUBTRACT = 0x15
+    BINARY_MULTIPLY = 0x16
+    BINARY_DIVIDE = 0x17
+    BINARY_MODULO = 0x18
+    BINARY_EQUALS = 0x19
+    BINARY_NOT_EQUALS = 0x1a
+    BINARY_GREATER = 0x1b
+    BINARY_GREATER_EQUALS = 0x1c
+    BINARY_LESS = 0x1d
+    BINARY_LESS_EQUALS = 0x1e
+    BINARY_AND = 0x1f
+    BINARY_OR = 0x20
+    PUT_CHR = 0x21
 
 
 class FVM:
@@ -44,7 +47,7 @@ class FVM:
     HEADER: bytes = bytes([0x83, 0x46, 0x56, 0x4d, 0x0d, 0x0a, 0x1a, 0x0a])
     """ An FVM bytecode file's header. """
 
-    FORMAT_VERSION: int = 1
+    FORMAT_VERSION: int = 2
     """ The FVM's format version. """
 
     LEGAL_OPCODES: set[int] = set(opcode.value for opcode in Opcode)
@@ -195,6 +198,14 @@ def step(self) -> None:
         elif opcode == Opcode.STORE_LOCAL and self.validate_pop(2):
             store_offset: int = self.sm.pop()
             self.sm[self.fp + store_offset] = self.sm[-1]
+        elif opcode == Opcode.UNARY_DEREFERENCE and self.validate_pop(1):
+            address: int = self.sm.pop()
+            
+            if address < 0 or address >= len(self.pm):
+                self.crash()
+                return
+            
+            self.sm.append(self.pm[address])
         elif opcode == Opcode.UNARY_NEGATE and self.validate_pop(1):
             self.sm.append(-self.sm.pop())
         elif opcode == Opcode.UNARY_NOT and self.validate_pop(1):
@@ -261,8 +272,8 @@ def step(self) -> None:
             y: int = self.sm.pop()
             x: int = self.sm.pop()
             self.sm.append(int(x != 0 or y != 0))
-        elif opcode == Opcode.PRINT and self.validate_pop(1):
-            print(self.sm.pop())
+        elif opcode == Opcode.PUT_CHR and self.validate_pop(1):
+            sys.stdout.write(chr(self.sm[-1]))
         else:
             self.crash()
 

funcy/ir/code.py

@@ -4,28 +4,28 @@ class OpType(Enum):
     """ The type of an IR operation. """
 
     HALT = auto()
-    """ Pop and halt element. """
+    """ Pop and halt with exit code word. """
 
     JUMP_LABEL = auto()
-    """ Pop and jump element with label. """
+    """ Pop and jump to word with label. """
 
     JUMP_NOT_ZERO_LABEL = auto()
-    """ Pop and jump element if pop element not zero with label. """
+    """ Pop and jump to word if popped word is not zero with label. """
 
     JUMP_ZERO_LABEL = auto()
-    """ Pop and jump element if pop element zero with label. """
+    """ Pop and jump to word if popped word is zero with label. """
 
     CALL_PARAMC = auto()
     """ Call with parameter count. """
 
     RETURN = auto()
-    """ Pop and return element. """
+    """ Pop and return word. """
 
     DROP = auto()
-    """ Pop and discard element. """
+    """ Pop and discard word. """
 
     DUPLICATE = auto()
-    """ Peek and push element. """
+    """ Peek and push word. """
 
     PUSH_LABEL = auto()
     """ Push labeled address. """
@@ -39,53 +39,56 @@ class OpType(Enum):
     STORE_LOCAL_OFFSET = auto()
     """ Store local with offset. """
 
+    UNARY_DEREFERENCE = auto()
+    """ Pop, dereference, and push word. """ 
+    
     UNARY_NEGATE = auto()
-    """ Pop, negate, and push element. """
+    """ Pop, negate, and push word. """
 
     UNARY_NOT = auto()
-    """ Pop, logical not, and push element. """
+    """ Pop, logical not, and push word. """
 
     BINARY_ADD = auto()
-    """ Pop, add, and push elements. """
+    """ Pop, add, and push words. """
 
     BINARY_SUBTRACT = auto()
-    """ Pop, subtract, and push elements. """
+    """ Pop, subtract, and push words. """
 
     BINARY_MULTIPLY = auto()
-    """ Pop, multiply, and push elements. """
+    """ Pop, multiply, and push words. """
 
     BINARY_DIVIDE = auto()
-    """ Pop, divide, and push elements. """
+    """ Pop, divide, and push words. """
 
     BINARY_MODULO = auto()
-    """ Pop, modulo, and push elements. """
+    """ Pop, modulo, and push words. """
 
     BINARY_EQUALS = auto()
-    """ Pop, compare equals, and push elements. """
+    """ Pop, compare equals, and push words. """
 
     BINARY_NOT_EQUALS = auto()
-    """ Pop, compare not equals, and push elements. """
+    """ Pop, compare not equals, and push words. """
 
     BINARY_GREATER = auto()
-    """ Pop, compare greater, and push elements. """
+    """ Pop, compare greater, and push words. """
 
     BINARY_GREATER_EQUALS = auto()
-    """ Pop, compare greater equals, and push elements. """
+    """ Pop, compare greater equals, and push words. """
 
     BINARY_LESS = auto()
-    """ Pop, compare less, and push elements. """
+    """ Pop, compare less, and push words. """
 
     BINARY_LESS_EQUALS = auto()
-    """ Pop, compare less equals, and push elements. """
+    """ Pop, compare less equals, and push words. """
 
     BINARY_AND = auto()
-    """ Pop, logical and, and push elements. """
+    """ Pop, logical and, and push words. """
 
     BINARY_OR = auto()
-    """ Pop, logicl or, and push elements. """
+    """ Pop, logical or, and push words. """
 
-    PRINT = auto()
-    """ Pop and print element. """
+    PUT_CHR = auto()
+    """ Peek and put character with value of word. """
 
 
 class Op:
@@ -280,6 +283,12 @@ def make_store_local_offset(self, offset: int) -> None:
         self.append_op_int(OpType.STORE_LOCAL_OFFSET, offset)
 
 
+    def make_unary_dereference(self) -> None:
+        """ Make a unary dereference IR operation. """
+        
+        self.append_op_standalone(OpType.UNARY_DEREFERENCE)
+    
+    
     def make_unary_negate(self) -> None:
         """ Make a unary negate IR operation. """
 
@@ -370,10 +379,10 @@ def make_binary_or(self) -> None:
         self.append_op_standalone(OpType.BINARY_OR)
 
 
-    def make_print(self) -> None:
-        """ Make a print IR operation. """
+    def make_put_chr(self) -> None:
+        """ Make a put chr IR operation. """
 
-        self.append_op_standalone(OpType.PRINT)
+        self.append_op_standalone(OpType.PUT_CHR)
 
 
     def append_op(self, op: Op) -> None:

funcy/ir/serializer.py

@@ -7,7 +7,7 @@ class Serializer:
     """ Serializes FVM bytecode from IR code. """
 
     FRAME_HEADER_SIZE: int = 2
-    """ The size of a stack frame header in elements. """
+    """ The size of a stack frame header in words. """
 
     def get_op_size(self, op: Op) -> int:
         """ Get the compiled size of an IR operation in bytes. """
@@ -86,6 +86,8 @@ def serialize(self, code: Code, is_flat: bool) -> bytes:
                     self.append_u32(
                             bytecode, op.int_value + self.FRAME_HEADER_SIZE)
                     self.append_opcode(bytecode, Opcode.STORE_LOCAL)
+                elif op.type == OpType.UNARY_DEREFERENCE:
+                    self.append_opcode(bytecode, Opcode.UNARY_DEREFERENCE)
                 elif op.type == OpType.UNARY_NEGATE:
                     self.append_opcode(bytecode, Opcode.UNARY_NEGATE)
                 elif op.type == OpType.UNARY_NOT:
@@ -116,8 +118,8 @@ def serialize(self, code: Code, is_flat: bool) -> bytes:
                     self.append_opcode(bytecode, Opcode.BINARY_AND)
                 elif op.type == OpType.BINARY_OR:
                     self.append_opcode(bytecode, Opcode.BINARY_OR)
-                elif op.type == OpType.PRINT:
-                    self.append_opcode(bytecode, Opcode.PRINT)
+                elif op.type == OpType.PUT_CHR:
+                    self.append_opcode(bytecode, Opcode.PUT_CHR)
                 else:
                     print(f"Unimplemented IR op type '{op}'!")
                     self.append_opcode(bytecode, Opcode.NO_OPERATION)