Start building up the expression tower.

3 files changed, 92 insertions, 20 deletions

diff --git a/src/comp/front/ast.rs b/src/comp/front/ast.rs
index 327570d6..d4e8aaaf 100644
--- a/src/comp/front/ast.rs
+++ b/src/comp/front/ast.rs
@@ -9,14 +9,41 @@ type crate = rec(_mod module);
 
 type block = vec[@stmt];
 
+tag binop {
+    plus;
+    minus;
+    star;
+    slash;
+    percent;
+    caret;
+    bitand;
+    bitor;
+    lsl;
+    lsr;
+    asr;
+    eq;
+    lt;
+    le;
+    ne;
+    ge;
+    gt;
+}
+
+tag unop {
+    bitnot;
+    not;
+    neg;
+    deref;
+    cast(@ty);
+}
+
 tag stmt {
     stmt_block(block);
     stmt_decl(@decl);
-    stmt_ret(option[@lval]);
-    stmt_log(@atom);
+    stmt_ret(option[@expr]);
+    stmt_log(@expr);
 }
 
-
 tag decl {
     decl_local(ident, option[ty]);
     decl_item(ident, @item);
@@ -25,15 +52,23 @@ tag decl {
 tag lval {
     lval_ident(ident);
     lval_ext(@lval, ident);
-    lval_idx(@lval, @atom);
+    lval_idx(@lval, @expr);
 }
 
-tag atom {
-    atom_lit(@lit);
-    atom_lval(@lval);
+tag expr {
+    expr_box(@expr);
+    expr_vec(vec[@expr]);
+    expr_tup(vec[@expr]);
+    expr_rec(vec[tup(ident,@expr)]);
+    expr_call(@expr, vec[@expr]);
+    expr_binary(binop, @expr, @expr);
+    expr_unary(unop, @expr);
+    expr_lit(@lit);
+    expr_lval(@lval);
 }
 
 tag lit {
+    lit_str(str);
     lit_char(char);
     lit_int(int);
     lit_uint(uint);
diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs
index ab2e15e3..0dc4e50e 100644
--- a/src/comp/front/parser.rs
+++ b/src/comp/front/parser.rs
@@ -132,40 +132,77 @@ state fn parse_seq[T](token.token bra,
     ret v;
 }
 
-state fn parse_lit(parser p) -> ast.lit {
+state fn parse_lit(parser p) -> @ast.lit {
     alt (p.peek()) {
         case (token.LIT_INT(?i)) {
             p.bump();
-            ret ast.lit_int(i);
+            ret @ast.lit_int(i);
         }
         case (token.LIT_UINT(?u)) {
             p.bump();
-            ret ast.lit_uint(u);
+            ret @ast.lit_uint(u);
         }
         case (token.LIT_CHAR(?c)) {
             p.bump();
-            ret ast.lit_char(c);
+            ret @ast.lit_char(c);
         }
         case (token.LIT_BOOL(?b)) {
             p.bump();
-            ret ast.lit_bool(b);
+            ret @ast.lit_bool(b);
         }
     }
     p.err("expected literal");
     fail;
 }
 
-state fn parse_atom(parser p) -> ast.atom {
-    ret ast.atom_lit(@parse_lit(p));
+
+
+state fn parse_bottom_expr(parser p) -> @ast.expr {
+    alt (p.peek()) {
+        case (token.LPAREN) {
+            p.bump();
+            auto e = parse_expr(p);
+            expect(p, token.RPAREN);
+            ret e;
+        }
+
+        case (_) {
+            ret @ast.expr_lit(parse_lit(p));
+        }
+    }
+}
+
+
+state fn parse_negation_expr(parser p) -> @ast.expr {
+    alt (p.peek()) {
+
+        case (token.NOT) {
+            auto e = parse_negation_expr(p);
+            ret @ast.expr_unary(ast.not, e);
+        }
+
+        case (token.TILDE) {
+            auto e = parse_negation_expr(p);
+            ret @ast.expr_unary(ast.bitnot, e);
+        }
+
+        case (_) {
+            ret parse_bottom_expr(p);
+        }
+    }
+}
+
+state fn parse_expr(parser p) -> @ast.expr {
+    ret parse_negation_expr(p);
 }
 
 state fn parse_stmt(parser p) -> @ast.stmt {
     alt (p.peek()) {
         case (token.LOG) {
             p.bump();
-            auto a = @parse_atom(p);
+            auto e = parse_expr(p);
             expect(p, token.SEMI);
-            ret @ast.stmt_log(a);
+            ret @ast.stmt_log(e);
         }
     }
     p.err("expected statement");
diff --git a/src/comp/middle/trans.rs b/src/comp/middle/trans.rs
index 81b471c2..b9b3f4d2 100644
--- a/src/comp/middle/trans.rs
+++ b/src/comp/middle/trans.rs
@@ -202,9 +202,9 @@ fn trans_upcall(@block_ctxt cx, str name, vec[ValueRef] args) -> ValueRef {
     ret cx.build.Call(llglue, call_args);
 }
 
-fn trans_log(@block_ctxt cx, &ast.atom a) {
-    alt (a) {
-        case (ast.atom_lit(?lit)) {
+fn trans_log(@block_ctxt cx, &ast.expr e) {
+    alt (e) {
+        case (ast.expr_lit(?lit)) {
             alt (*lit) {
                 case (ast.lit_int(?i)) {
                     trans_upcall(cx, "upcall_log_int", vec(C_int(i)));
@@ -215,7 +215,7 @@ fn trans_log(@block_ctxt cx, &ast.atom a) {
             }
         }
         case (_) {
-            cx.fcx.tcx.sess.unimpl("atom variant in trans_log");
+            cx.fcx.tcx.sess.unimpl("expr variant in trans_log");
         }
     }
 }