---

yaml
---
r: 2915
b: refs/heads/master
c: c515ed1
h: refs/heads/master
i:
  2913: b8a6781
  2911: ac61320
v: v3

Author: pcwalton

[refs]

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

trunk/src/comp/front/lexer.rs

@@ -20,6 +20,7 @@ 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;
@@ -48,6 +49,9 @@ 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; }
 
@@ -101,8 +105,7 @@ 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;
@@ -888,11 +891,29 @@ fn consume_comment(&reader rdr, bool code_to_the_left,
     log "<<< consume comment";
 }
 
-fn gather_comments(session sess, str path) -> vec[cmnt] {
+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) {
     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;
@@ -907,9 +928,12 @@ fn gather_comments(session sess, str path) -> vec[cmnt] {
             }
             break;
         }
-        next_token(rdr);
+        if (is_lit(next_token(rdr))) {
+            vec::push[lit](literals, rec(lit=rdr.get_mark_str(),
+                                         pos=rdr.get_mark_chpos()));
+        }
     }
-    ret comments;
+    ret rec(cmnts=comments, lits=literals);
  }
 
 

trunk/src/comp/middle/trans.rs

@@ -2410,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_integral_values(scx,
-                                        vec_fill(scx, lhs),
-                                        vec_fill(scx, rhs),
-                                        false,
-                                        llop);
+            r = compare_numerical_values(scx,
+                                         vec_fill(scx, lhs),
+                                         vec_fill(scx, rhs),
+                                         unsigned_int,
+                                         llop);
             r.bcx.build.Store(r.val, flag);
 
         } else {
@@ -2500,88 +2500,111 @@ 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) {
-    if (ty::type_is_fp(cx.fcx.lcx.ccx.tcx, t)) {
-        make_fp_cmp_glue(cx, lhs, rhs, t, llop);
-        ret;
-    }
+    // assert ty::type_is_scalar(cx.fcx.lcx.ccx.tcx, t);
 
-    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;
-    }
+    // 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_nil(cx.fcx.lcx.ccx.tcx, t)) {
-        cx.build.Store(C_bool(true), cx.fcx.llretptr);
-        cx.build.RetVoid();
-        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;
+        }
     }
-
-    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 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;
+// 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;
     }
 
     auto last_cx = new_sub_block_ctxt(cx, "last");
 
     auto eq_cx = new_sub_block_ctxt(cx, "eq");
-    auto eq_result = eq_cx.build.ICmp(lib::llvm::LLVMIntEQ, lhs, rhs);
+    auto eq_result = generic_cmp(eq_cx, nt, eq_cmp, lhs, rhs);
     eq_cx.build.Br(last_cx.llbb);
 
     auto lt_cx = new_sub_block_ctxt(cx, "lt");
-    auto lt_result = lt_cx.build.ICmp(lt_cmp, lhs, rhs);
+    auto lt_result = generic_cmp(lt_cx, nt, lt_cmp, lhs, rhs);
     lt_cx.build.Br(last_cx.llbb);
 
     auto le_cx = new_sub_block_ctxt(cx, "le");
-    auto le_result = le_cx.build.ICmp(le_cmp, lhs, rhs);
+    auto le_result = generic_cmp(le_cx, nt, le_cmp, lhs, rhs);
     le_cx.build.Br(last_cx.llbb);
 
     auto unreach_cx = new_sub_block_ctxt(cx, "unreach");
@@ -2598,11 +2621,10 @@ fn compare_integral_values(&@block_ctxt cx, ValueRef lhs, ValueRef rhs,
     ret res(last_cx, last_result);
 }
 
-// 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);
+// 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);
     r.bcx.build.Store(r.val, r.bcx.fcx.llretptr);
     r.bcx.build.RetVoid();
 }