From 7aa43b2599b353dc3e26f5ecc2aef30bc1883145 Mon Sep 17 00:00:00 2001
From: Michael Sullivan <sully@msully.net>
Date: Thu, 28 Jun 2012 23:36:00 -0700
Subject: [PATCH] Make fmt use a bitmask instead of a vector of flags. Closes
 #1993.

---
 mk/target.mk             |  2 +-
 src/libcore/extfmt.rs    | 24 ++++++++++--------------
 src/libsyntax/ext/fmt.rs | 22 +++++++++++-----------
 3 files changed, 22 insertions(+), 26 deletions(-)

diff --git a/mk/target.mk b/mk/target.mk
index 5ddc825d335..7cfa44f52bd 100644
--- a/mk/target.mk
+++ b/mk/target.mk
@@ -9,7 +9,7 @@
 # the snapshot runtime (resp. corelib) rather than the runtime
 # (resp. corelib) from the working directory.
 USE_SNAPSHOT_RUNTIME=0
-USE_SNAPSHOT_CORELIB=0
+USE_SNAPSHOT_CORELIB=1
 USE_SNAPSHOT_STDLIB=0
 
 define TARGET_STAGE_N
diff --git a/src/libcore/extfmt.rs b/src/libcore/extfmt.rs
index d738b4f6615..e7263243323 100644
--- a/src/libcore/extfmt.rs
+++ b/src/libcore/extfmt.rs
@@ -264,19 +264,17 @@ mod ct {
 // conditions can be evaluated at compile-time. For now though it's cleaner to
 // implement it 0this way, I think.
 mod rt {
-    enum flag {
-        flag_left_justify,
-        flag_left_zero_pad,
-        flag_space_for_sign,
-        flag_sign_always,
-        flag_alternate,
-    }
+    const flag_none : u32 = 0u32;
+    const flag_left_justify   : u32 = 0b00000000000000000000000000000001u32;
+    const flag_left_zero_pad  : u32 = 0b00000000000000000000000000000010u32;
+    const flag_space_for_sign : u32 = 0b00000000000000000000000000000100u32;
+    const flag_sign_always    : u32 = 0b00000000000000000000000000001000u32;
+    const flag_alternate      : u32 = 0b00000000000000000000000000010000u32;
+
     enum count { count_is(int), count_implied, }
     enum ty { ty_default, ty_bits, ty_hex_upper, ty_hex_lower, ty_octal, }
 
-    // FIXME (#1993): May not want to use a vector here for flags; instead
-    // just use a bool per flag.
-    type conv = {flags: [flag]/~, width: count, precision: count, ty: ty};
+    type conv = {flags: u32, width: count, precision: count, ty: ty};
 
     fn conv_int(cv: conv, i: int) -> str {
         let radix = 10u;
@@ -307,7 +305,6 @@ mod rt {
         let s = if b { "true" } else { "false" };
         // run the boolean conversion through the string conversion logic,
         // giving it the same rules for precision, etc.
-
         ret conv_str(cv, s);
     }
     fn conv_char(cv: conv, c: char) -> str {
@@ -430,9 +427,8 @@ mod rt {
         }
         ret padstr + s;
     }
-    fn have_flag(flags: [flag]/~, f: flag) -> bool {
-        for vec::each(flags) {|candidate| if candidate == f { ret true; } }
-        ret false;
+    fn have_flag(flags: u32, f: u32) -> bool {
+        flags & f != 0
     }
 }
 
diff --git a/src/libsyntax/ext/fmt.rs b/src/libsyntax/ext/fmt.rs
index 09ebc0b79cd..bac880b60a8 100644
--- a/src/libsyntax/ext/fmt.rs
+++ b/src/libsyntax/ext/fmt.rs
@@ -50,19 +50,19 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span,
 
     fn make_rt_conv_expr(cx: ext_ctxt, sp: span, cnv: conv) -> @ast::expr {
         fn make_flags(cx: ext_ctxt, sp: span, flags: [flag]/~) -> @ast::expr {
-            let mut flagexprs: [@ast::expr]/~ = []/~;
+            let mut tmp_expr = make_rt_path_expr(cx, sp, @"flag_none");
             for flags.each {|f|
-                let mut fstr;
-                alt f {
-                  flag_left_justify { fstr = "flag_left_justify"; }
-                  flag_left_zero_pad { fstr = "flag_left_zero_pad"; }
-                  flag_space_for_sign { fstr = "flag_space_for_sign"; }
-                  flag_sign_always { fstr = "flag_sign_always"; }
-                  flag_alternate { fstr = "flag_alternate"; }
-                }
-                vec::push(flagexprs, make_rt_path_expr(cx, sp, @fstr));
+                let fstr = alt f {
+                  flag_left_justify { "flag_left_justify" }
+                  flag_left_zero_pad { "flag_left_zero_pad" }
+                  flag_space_for_sign { "flag_space_for_sign" }
+                  flag_sign_always { "flag_sign_always" }
+                  flag_alternate { "flag_alternate" }
+                };
+                tmp_expr = mk_binary(cx, sp, ast::bitor, tmp_expr,
+                                     make_rt_path_expr(cx, sp, @fstr));
             }
-            ret mk_uniq_vec_e(cx, sp, flagexprs);
+            ret tmp_expr;
         }
         fn make_count(cx: ext_ctxt, sp: span, cnt: count) -> @ast::expr {
             alt cnt {