roughly parsing infix operators

ziglang · Dec 17, 2017 · ab44939 · ab44939
1 parent 39e96d9
commit ab44939
Show file tree

Hide file tree

Showing 3 changed files with 274 additions and 144 deletions.
diff --git a/src-self-hosted/ast.zig b/src-self-hosted/ast.zig
@@ -13,9 +13,9 @@ pub const Node = struct {
         Identifier,
         FnProto,
         ParamDecl,
-        AddrOfExpr,
         Block,
-        Return,
+        InfixOp,
+        PrefixOp,
         IntegerLiteral,
         FloatLiteral,
     };
@@ -27,9 +27,9 @@ pub const Node = struct {
             Id.Identifier => @fieldParentPtr(NodeIdentifier, "base", base).iterate(index),
             Id.FnProto => @fieldParentPtr(NodeFnProto, "base", base).iterate(index),
             Id.ParamDecl => @fieldParentPtr(NodeParamDecl, "base", base).iterate(index),
-            Id.AddrOfExpr => @fieldParentPtr(NodeAddrOfExpr, "base", base).iterate(index),
             Id.Block => @fieldParentPtr(NodeBlock, "base", base).iterate(index),
-            Id.Return => @fieldParentPtr(NodeReturn, "base", base).iterate(index),
+            Id.InfixOp => @fieldParentPtr(NodeInfixOp, "base", base).iterate(index),
+            Id.PrefixOp => @fieldParentPtr(NodePrefixOp, "base", base).iterate(index),
             Id.IntegerLiteral => @fieldParentPtr(NodeIntegerLiteral, "base", base).iterate(index),
             Id.FloatLiteral => @fieldParentPtr(NodeFloatLiteral, "base", base).iterate(index),
         };
@@ -42,9 +42,9 @@ pub const Node = struct {
             Id.Identifier => allocator.destroy(@fieldParentPtr(NodeIdentifier, "base", base)),
             Id.FnProto => allocator.destroy(@fieldParentPtr(NodeFnProto, "base", base)),
             Id.ParamDecl => allocator.destroy(@fieldParentPtr(NodeParamDecl, "base", base)),
-            Id.AddrOfExpr => allocator.destroy(@fieldParentPtr(NodeAddrOfExpr, "base", base)),
             Id.Block => allocator.destroy(@fieldParentPtr(NodeBlock, "base", base)),
-            Id.Return => allocator.destroy(@fieldParentPtr(NodeReturn, "base", base)),
+            Id.InfixOp => allocator.destroy(@fieldParentPtr(NodeInfixOp, "base", base)),
+            Id.PrefixOp => allocator.destroy(@fieldParentPtr(NodePrefixOp, "base", base)),
             Id.IntegerLiteral => allocator.destroy(@fieldParentPtr(NodeIntegerLiteral, "base", base)),
             Id.FloatLiteral => allocator.destroy(@fieldParentPtr(NodeFloatLiteral, "base", base)),
         };
@@ -170,56 +170,84 @@ pub const NodeParamDecl = struct {
     }
 };
 
-pub const NodeAddrOfExpr = struct {
+pub const NodeBlock = struct {
     base: Node,
-    op_token: Token,
-    align_expr: ?&Node,
-    bit_offset_start_token: ?Token,
-    bit_offset_end_token: ?Token,
-    const_token: ?Token,
-    volatile_token: ?Token,
-    op_expr: &Node,
-
-    pub fn iterate(self: &NodeAddrOfExpr, index: usize) -> ?&Node {
-        var i = index;
+    begin_token: Token,
+    end_token: Token,
+    statements: ArrayList(&Node),
 
-        if (self.align_expr) |align_expr| {
-            if (i < 1) return align_expr;
-            i -= 1;
-        }
+    pub fn iterate(self: &NodeBlock, index: usize) -> ?&Node {
+        var i = index;
 
-        if (i < 1) return self.op_expr;
-        i -= 1;
+        if (i < self.statements.len) return self.statements.items[i];
+        i -= self.statements.len;
 
         return null;
     }
 };
 
-pub const NodeBlock = struct {
+pub const NodeInfixOp = struct {
     base: Node,
-    begin_token: Token,
-    end_token: Token,
-    statements: ArrayList(&Node),
+    op_token: Token,
+    lhs: &Node,
+    op: InfixOp,
+    rhs: &Node,
 
-    pub fn iterate(self: &NodeBlock, index: usize) -> ?&Node {
+    const InfixOp = enum {
+        EqualEqual,
+        BangEqual,
+    };
+
+    pub fn iterate(self: &NodeInfixOp, index: usize) -> ?&Node {
         var i = index;
 
-        if (i < self.statements.len) return self.statements.items[i];
-        i -= self.statements.len;
+        if (i < 1) return self.lhs;
+        i -= 1;
+
+        switch (self.op) {
+            InfixOp.EqualEqual => {},
+            InfixOp.BangEqual => {},
+        }
+
+        if (i < 1) return self.rhs;
+        i -= 1;
 
         return null;
     }
 };
 
-pub const NodeReturn = struct {
+pub const NodePrefixOp = struct {
     base: Node,
-    return_token: Token,
-    expr: &Node,
+    op_token: Token,
+    op: PrefixOp,
+    rhs: &Node,
 
-    pub fn iterate(self: &NodeReturn, index: usize) -> ?&Node {
+    const PrefixOp = union(enum) {
+        Return,
+        AddrOf: AddrOfInfo,
+    };
+    const AddrOfInfo = struct {
+        align_expr: ?&Node,
+        bit_offset_start_token: ?Token,
+        bit_offset_end_token: ?Token,
+        const_token: ?Token,
+        volatile_token: ?Token,
+    };
+
+    pub fn iterate(self: &NodePrefixOp, index: usize) -> ?&Node {
         var i = index;
 
-        if (i < 1) return self.expr;
+        switch (self.op) {
+            PrefixOp.Return => {},
+            PrefixOp.AddrOf => |addr_of_info| {
+                if (addr_of_info.align_expr) |align_expr| {
+                    if (i < 1) return align_expr;
+                    i -= 1;
+                }
+            },
+        }
+
+        if (i < 1) return self.rhs;
         i -= 1;
 
         return null;