---

yaml
---
r: 2916
b: refs/heads/master
c: 20bd927
h: refs/heads/master
v: v3

Author: paulstansifer

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: cb61d7b38ed1fdccad4f9fb0046df598775451ac
+refs/heads/master: 20bd927c3f42aef2068c3c1b745efb7cba3b22a8

trunk/src/comp/front/lexer.rs

@@ -20,7 +20,6 @@ state type reader = state obj {
     fn bump();
     fn mark();
     fn get_mark_chpos() -> uint;
-    fn get_mark_str() -> str;
     fn get_interner() -> @interner::interner[str];
     fn get_chpos() -> uint;
     fn get_col() -> uint;
@@ -49,9 +48,6 @@ fn new_reader(session sess, io::reader rdr,
         }
 
         fn mark() { mark_chpos = chpos; }
-        fn get_mark_str() -> str {
-            ret str::slice(file, mark_chpos, chpos);
-        }
         fn get_mark_chpos() -> uint { ret mark_chpos; }
         fn get_chpos() -> uint { ret chpos; }
 
@@ -105,7 +101,8 @@ fn new_reader(session sess, io::reader rdr,
     auto file = str::unsafe_from_bytes(rdr.read_whole_stream());
     let vec[str] strs = [];
     auto rd = reader(sess, file, str::byte_len(file), 0u, 0u,
-                     -1 as char, filemap.start_pos, filemap.start_pos,
+                     -1 as char,
+                     filemap.start_pos, filemap.start_pos,
                      strs, filemap, itr);
     rd.init();
     ret rd;
@@ -891,29 +888,11 @@ fn consume_comment(&reader rdr, bool code_to_the_left,
     log "<<< consume comment";
 }
 
-fn is_lit(&token::token t) -> bool {
-    ret alt (t) {
-        case (token::LIT_INT(_)) { true }
-        case (token::LIT_UINT(_)) { true }
-        case (token::LIT_MACH_INT(_,_)) { true }
-        case (token::LIT_FLOAT(_)) { true }
-        case (token::LIT_MACH_FLOAT(_,_)) { true }
-        case (token::LIT_STR(_)) { true }
-        case (token::LIT_CHAR(_)) { true }
-        case (token::LIT_BOOL(_)) { true }
-        case (_) { false }
-    }
-}
-
-type lit = rec(str lit, uint pos);
-
-fn gather_comments_and_literals(session sess, str path)
-    -> rec(vec[cmnt] cmnts, vec[lit] lits) {
+fn gather_comments(session sess, str path) -> vec[cmnt] {
     auto srdr = io::file_reader(path);
     auto itr = @interner::mk[str](str::hash, str::eq);
     auto rdr = new_reader(sess, srdr, codemap::new_filemap(path, 0u), itr);
     let vec[cmnt] comments = [];
-    let vec[lit] literals = [];
     while (!rdr.is_eof()) {
         while (true) {
             auto code_to_the_left = true;
@@ -928,12 +907,9 @@ fn gather_comments_and_literals(session sess, str path)
             }
             break;
         }
-        if (is_lit(next_token(rdr))) {
-            vec::push[lit](literals, rec(lit=rdr.get_mark_str(),
-                                         pos=rdr.get_mark_chpos()));
-        }
+        next_token(rdr);
     }
-    ret rec(cmnts=comments, lits=literals);
+    ret comments;
  }
 
 

trunk/src/comp/middle/trans.rs

@@ -1293,6 +1293,20 @@ fn simplify_type(&@crate_ctxt ccx, &ty::t typ) -> ty::t {
             case (ty::ty_vec(_)) {
                 ret ty::mk_imm_vec(ccx.tcx, ty::mk_nil(ccx.tcx));
             }
+            case (ty::ty_fn(_,_,_,_)) {
+                ret ty::mk_imm_tup(ccx.tcx, 
+                                   [ty::mk_imm_box(ccx.tcx, 
+                                                   ty::mk_nil(ccx.tcx)),
+                                    ty::mk_imm_box(ccx.tcx, 
+                                                   ty::mk_nil(ccx.tcx))]);
+            }
+            case (ty::ty_obj(_)) {
+                ret ty::mk_imm_tup(ccx.tcx, 
+                                   [ty::mk_imm_box(ccx.tcx, 
+                                                   ty::mk_nil(ccx.tcx)),
+                                    ty::mk_imm_box(ccx.tcx, 
+                                                   ty::mk_nil(ccx.tcx))]);
+            }
             case (_) { ret typ; }
         }
     }
@@ -2396,11 +2410,11 @@ fn make_cmp_glue(&@block_ctxt cx,
 
             // If we hit == all the way through the minimum-shared-length
             // section, default to judging the relative sequence lengths.
-            r = compare_numerical_values(scx,
-                                         vec_fill(scx, lhs),
-                                         vec_fill(scx, rhs),
-                                         unsigned_int,
-                                         llop);
+            r = compare_integral_values(scx,
+                                        vec_fill(scx, lhs),
+                                        vec_fill(scx, rhs),
+                                        false,
+                                        llop);
             r.bcx.build.Store(r.val, flag);
 
         } else {
@@ -2486,111 +2500,88 @@ fn make_cmp_glue(&@block_ctxt cx,
     }
 }
 
-// Used only for creating scalar comparsion glue.
-tag numerical_type {
-    signed_int;
-    unsigned_int;
-    floating_point;
-}
-
 // A helper function to create scalar comparison glue.
 fn make_scalar_cmp_glue(&@block_ctxt cx, ValueRef lhs, ValueRef rhs,
                         &ty::t t, ValueRef llop) {
-    // assert ty::type_is_scalar(cx.fcx.lcx.ccx.tcx, t);
+    if (ty::type_is_fp(cx.fcx.lcx.ccx.tcx, t)) {
+        make_fp_cmp_glue(cx, lhs, rhs, t, llop);
+        ret;
+    }
 
-    // In most cases, we need to know whether to do signed, unsigned, or float
-    // comparison.
-    auto f = bind make_numerical_cmp_glue(cx, lhs, rhs, _, llop);
+    if (ty::type_is_integral(cx.fcx.lcx.ccx.tcx, t) ||
+            ty::type_is_bool(cx.fcx.lcx.ccx.tcx, t)) {
+        make_integral_cmp_glue(cx, lhs, rhs, t, llop);
+        ret;
+    }
 
-    // FIXME: this could be a lot shorter if we could combine multiple cases
-    // of alt expressions (issue #449).
-    alt (ty::struct(cx.fcx.lcx.ccx.tcx, t)) {
-        case (ty::ty_nil) { 
-            cx.build.Store(C_bool(true), cx.fcx.llretptr);
-            cx.build.RetVoid();
-        }
-        case (ty::ty_bool) { f(unsigned_int); }
-        case (ty::ty_int) { f(signed_int); }
-        case (ty::ty_float) { f(floating_point); }
-        case (ty::ty_uint) { f(unsigned_int); }
-        case (ty::ty_machine(_)) {
-            // Floating point machine types
-            if (ty::type_is_fp(cx.fcx.lcx.ccx.tcx, t)) {
-                f(floating_point);
-            } 
-            // Signed, integral machine types
-            else if (ty::type_is_signed(cx.fcx.lcx.ccx.tcx, t)) {
-                f(signed_int);
-            }
-            // Unsigned, integral machine types
-            else { f(unsigned_int); }
-        }
-        case (ty::ty_char)  { f(unsigned_int); }
-        case (ty::ty_type)  {
-            trans_fail(cx, none[common::span],
-                       "attempt to compare values of type type");
-        }
-        case (ty::ty_native) {
-            trans_fail(cx, none[common::span],
-                       "attempt to compare values of type native");
-        }
-        case (_) {
-            // Should never get here, because t is scalar.
-            fail;
-        }
+    if (ty::type_is_nil(cx.fcx.lcx.ccx.tcx, t)) {
+        cx.build.Store(C_bool(true), cx.fcx.llretptr);
+        cx.build.RetVoid();
+        ret;
     }
+
+    trans_fail(cx, none[common::span],
+               "attempt to compare values of type " +
+               ty::ty_to_str(cx.fcx.lcx.ccx.tcx, t));
 }
 
-// A helper function to compare numerical values.
-fn compare_numerical_values(&@block_ctxt cx, ValueRef lhs, ValueRef rhs,
-                            numerical_type nt, ValueRef llop) -> result {
-    auto eq_cmp; auto lt_cmp; auto le_cmp;
-    alt (nt) {
-        case (floating_point) {
-            eq_cmp = lib::llvm::LLVMRealUEQ;
-            lt_cmp = lib::llvm::LLVMRealULT;
-            le_cmp = lib::llvm::LLVMRealULE;
-        }
-        case (signed_int) {
-            eq_cmp = lib::llvm::LLVMIntEQ;
-            lt_cmp = lib::llvm::LLVMIntSLT;
-            le_cmp = lib::llvm::LLVMIntSLE;
-        }
-        case (unsigned_int) {
-            eq_cmp = lib::llvm::LLVMIntEQ;
-            lt_cmp = lib::llvm::LLVMIntULT;
-            le_cmp = lib::llvm::LLVMIntULE;
-        }
-    }
-    
-    // FIXME: This wouldn't be necessary if we could bind methods off of
-    // objects and therefore abstract over FCmp and ICmp (issue #435).  Then
-    // we could just write, e.g., "cmp_fn = bind cx.build.FCmp(_, _, _);" in
-    // the above, and "auto eq_result = cmp_fn(eq_cmp, lhs, rhs);" in the
-    // below.
-    fn generic_cmp(&@block_ctxt cx, numerical_type nt,
-                   uint op, ValueRef lhs, ValueRef rhs) -> ValueRef {
-        let ValueRef r;
-        if (nt == floating_point) {
-            r = cx.build.FCmp(op, lhs, rhs);
-        } else {
-            r = cx.build.ICmp(op, lhs, rhs);
-        }
-        ret r;
+// A helper function to create floating point comparison glue.
+fn make_fp_cmp_glue(&@block_ctxt cx, ValueRef lhs, ValueRef rhs,
+                    &ty::t fptype, ValueRef llop) {
+    auto last_cx = new_sub_block_ctxt(cx, "last");
+
+    auto eq_cx = new_sub_block_ctxt(cx, "eq");
+    auto eq_result = eq_cx.build.FCmp(lib::llvm::LLVMRealUEQ, lhs, rhs);
+    eq_cx.build.Br(last_cx.llbb);
+
+    auto lt_cx = new_sub_block_ctxt(cx, "lt");
+    auto lt_result = lt_cx.build.FCmp(lib::llvm::LLVMRealULT, lhs, rhs);
+    lt_cx.build.Br(last_cx.llbb);
+
+    auto le_cx = new_sub_block_ctxt(cx, "le");
+    auto le_result = le_cx.build.FCmp(lib::llvm::LLVMRealULE, lhs, rhs);
+    le_cx.build.Br(last_cx.llbb);
+
+    auto unreach_cx = new_sub_block_ctxt(cx, "unreach");
+    unreach_cx.build.Unreachable();
+
+    auto llswitch = cx.build.Switch(llop, unreach_cx.llbb, 3u);
+    llvm::LLVMAddCase(llswitch, C_u8(abi::cmp_glue_op_eq), eq_cx.llbb);
+    llvm::LLVMAddCase(llswitch, C_u8(abi::cmp_glue_op_lt), lt_cx.llbb);
+    llvm::LLVMAddCase(llswitch, C_u8(abi::cmp_glue_op_le), le_cx.llbb);
+
+    auto last_result =
+        last_cx.build.Phi(T_i1(), [eq_result, lt_result, le_result],
+                          [eq_cx.llbb, lt_cx.llbb, le_cx.llbb]);
+    last_cx.build.Store(last_result, cx.fcx.llretptr);
+    last_cx.build.RetVoid();
+}
+
+// A helper function to compare integral values. This is used by both
+// `make_integral_cmp_glue` and `make_cmp_glue`.
+fn compare_integral_values(&@block_ctxt cx, ValueRef lhs, ValueRef rhs,
+                           bool signed, ValueRef llop) -> result {
+    auto lt_cmp; auto le_cmp;
+    if (signed) {
+        lt_cmp = lib::llvm::LLVMIntSLT;
+        le_cmp = lib::llvm::LLVMIntSLE;
+    } else {
+        lt_cmp = lib::llvm::LLVMIntULT;
+        le_cmp = lib::llvm::LLVMIntULE;
     }
 
     auto last_cx = new_sub_block_ctxt(cx, "last");
 
     auto eq_cx = new_sub_block_ctxt(cx, "eq");
-    auto eq_result = generic_cmp(eq_cx, nt, eq_cmp, lhs, rhs);
+    auto eq_result = eq_cx.build.ICmp(lib::llvm::LLVMIntEQ, lhs, rhs);
     eq_cx.build.Br(last_cx.llbb);
 
     auto lt_cx = new_sub_block_ctxt(cx, "lt");
-    auto lt_result = generic_cmp(lt_cx, nt, lt_cmp, lhs, rhs);
+    auto lt_result = lt_cx.build.ICmp(lt_cmp, lhs, rhs);
     lt_cx.build.Br(last_cx.llbb);
 
     auto le_cx = new_sub_block_ctxt(cx, "le");
-    auto le_result = generic_cmp(le_cx, nt, le_cmp, lhs, rhs);
+    auto le_result = le_cx.build.ICmp(le_cmp, lhs, rhs);
     le_cx.build.Br(last_cx.llbb);
 
     auto unreach_cx = new_sub_block_ctxt(cx, "unreach");
@@ -2607,10 +2598,11 @@ fn compare_numerical_values(&@block_ctxt cx, ValueRef lhs, ValueRef rhs,
     ret res(last_cx, last_result);
 }
 
-// A helper function to create numerical comparison glue.
-fn make_numerical_cmp_glue(&@block_ctxt cx, ValueRef lhs, ValueRef rhs,
-                          numerical_type nt, ValueRef llop) {
-    auto r = compare_numerical_values(cx, lhs, rhs, nt, llop);
+// A helper function to create integral comparison glue.
+fn make_integral_cmp_glue(&@block_ctxt cx, ValueRef lhs, ValueRef rhs,
+                          &ty::t intype, ValueRef llop) {
+    auto r = compare_integral_values(cx, lhs, rhs,
+        ty::type_is_signed(cx.fcx.lcx.ccx.tcx, intype), llop);
     r.bcx.build.Store(r.val, r.bcx.fcx.llretptr);
     r.bcx.build.RetVoid();
 }