diff --git a/src/lib/extfmt.rs b/src/lib/extfmt.rs index 04c823c7cf13..876bf1b7f904 100644 --- a/src/lib/extfmt.rs +++ b/src/lib/extfmt.rs @@ -17,10 +17,10 @@ import option::none; import option::some; /* - * We have a CT (compile-time) module that parses format strings into a + * We have a 'ct' (compile-time) module that parses format strings into a * sequence of conversions. From those conversions AST fragments are built - * that call into properly-typed functions in the RT (run-time) module. Each - * of those run-time conversion functions accepts another conversion + * that call into properly-typed functions in the 'rt' (run-time) module. + * Each of those run-time conversion functions accepts another conversion * description that specifies how to format its output. * * The building of the AST is currently done in a module inside the compiler, @@ -558,259 +558,6 @@ mod rt { } } -// FIXME: This is a temporary duplication of the rt mod that only -// needs to exist to accomodate the stage0 compiler until the next snapshot -mod RT { - tag flag { - flag_left_justify; - flag_left_zero_pad; - flag_space_for_sign; - flag_sign_always; - flag_alternate; - // FIXME: This is a hack to avoid creating 0-length vec exprs, - // which have some difficulty typechecking currently. See - // comments in front::extfmt::make_flags - flag_none; - } - - tag count { - count_is(int); - count_implied; - } - - tag ty { - ty_default; - ty_bits; - ty_hex_upper; - ty_hex_lower; - ty_octal; - } - - // FIXME: May not want to use a vector here for flags; - // instead just use a bool per flag - type conv = rec(vec[flag] flags, - count width, - count precision, - ty ty); - - fn conv_int(&conv cv, int i) -> str { - auto radix = 10u; - auto prec = get_int_precision(cv); - auto s = int_to_str_prec(i, radix, prec); - if (0 <= i) { - if (have_flag(cv.flags, flag_sign_always)) { - s = "+" + s; - } else if (have_flag(cv.flags, flag_space_for_sign)) { - s = " " + s; - } - } - ret pad(cv, s, pad_signed); - } - - fn conv_uint(&conv cv, uint u) -> str { - auto prec = get_int_precision(cv); - auto res; - alt (cv.ty) { - case (ty_default) { - res = uint_to_str_prec(u, 10u, prec); - } - case (ty_hex_lower) { - res = uint_to_str_prec(u, 16u, prec); - } - case (ty_hex_upper) { - res = _str::to_upper(uint_to_str_prec(u, 16u, prec)); - } - case (ty_bits) { - res = uint_to_str_prec(u, 2u, prec); - } - case (ty_octal) { - res = uint_to_str_prec(u, 8u, prec); - } - } - ret pad(cv, res, pad_unsigned); - } - - fn conv_bool(&conv cv, bool b) -> str { - auto s; - if (b) { - s = "true"; - } else { - s = "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(&conv cv, char c) -> str { - ret pad(cv, _str::from_char(c), pad_nozero); - } - - fn conv_str(&conv cv, str s) -> str { - auto unpadded = s; - alt (cv.precision) { - case (count_implied) { - } - case (count_is(?max)) { - // For strings, precision is the maximum characters displayed - if (max as uint < _str::char_len(s)) { - // FIXME: substr works on bytes, not chars! - unpadded = _str::substr(s, 0u, max as uint); - } - } - } - ret pad(cv, unpadded, pad_nozero); - } - - // Convert an int to string with minimum number of digits. If precision is - // 0 and num is 0 then the result is the empty string. - fn int_to_str_prec(int num, uint radix, uint prec) -> str { - if (num < 0) { - ret "-" + uint_to_str_prec((-num) as uint, radix, prec); - } else { - ret uint_to_str_prec(num as uint, radix, prec); - } - } - - // Convert a uint to string with a minimum number of digits. If precision - // is 0 and num is 0 then the result is the empty string. Could move this - // to _uint: but it doesn't seem all that useful. - fn uint_to_str_prec(uint num, uint radix, uint prec) -> str { - auto s; - - if (prec == 0u && num == 0u) { - s = ""; - } else { - s = _uint::to_str(num, radix); - auto len = _str::char_len(s); - if (len < prec) { - auto diff = prec - len; - auto pad = str_init_elt('0', diff); - s = pad + s; - } - } - - ret s; - } - - fn get_int_precision(&conv cv) -> uint { - alt (cv.precision) { - case (count_is(?c)) { - ret c as uint; - } - case (count_implied) { - ret 1u; - } - } - } - - // FIXME: This might be useful in _str: but needs to be utf8 safe first - fn str_init_elt(char c, uint n_elts) -> str { - auto svec = _vec::init_elt[u8](c as u8, n_elts); - // FIXME: Using unsafe_from_bytes because rustboot - // can't figure out the is_utf8 predicate on from_bytes? - ret _str::unsafe_from_bytes(svec); - } - - tag pad_mode { - pad_signed; - pad_unsigned; - pad_nozero; - } - - fn pad(&conv cv, str s, pad_mode mode) -> str { - auto uwidth; - alt (cv.width) { - case (count_implied) { - ret s; - } - case (count_is(?width)) { - // FIXME: Maybe width should be uint - uwidth = width as uint; - } - } - - auto strlen = _str::char_len(s); - if (uwidth <= strlen) { - ret s; - } - - auto padchar = ' '; - auto diff = uwidth - strlen; - if (have_flag(cv.flags, flag_left_justify)) { - auto padstr = str_init_elt(padchar, diff); - ret s + padstr; - } - - auto might_zero_pad = false; - auto signed = false; - - alt (mode) { - case (pad_nozero) { - // fallthrough - } - case (pad_signed) { - might_zero_pad = true; - signed = true; - } - case (pad_unsigned) { - might_zero_pad = true; - } - } - - fn have_precision(&conv cv) -> bool { - alt (cv.precision) { - case (count_implied) { - ret false; - } - case (_) { - ret true; - } - } - } - - auto zero_padding = false; - if (might_zero_pad - && have_flag(cv.flags, flag_left_zero_pad) - && !have_precision(cv)) { - - padchar = '0'; - zero_padding = true; - } - - auto padstr = str_init_elt(padchar, diff); - - // This is completely heinous. If we have a signed value then - // potentially rip apart the intermediate result and insert some - // zeros. It may make sense to convert zero padding to a precision - // instead. - if (signed - && zero_padding - && _str::byte_len(s) > 0u) { - - auto head = s.(0); - if (head == '+' as u8 - || head == '-' as u8 - || head == ' ' as u8) { - - auto headstr = _str::unsafe_from_bytes([head]); - auto bytelen = _str::byte_len(s); - auto numpart = _str::substr(s, 1u, bytelen - 1u); - ret headstr + padstr + numpart; - } - } - ret padstr + s; - } - - fn have_flag(vec[flag] flags, flag f) -> bool { - for (flag candidate in flags) { - if (candidate == f) { - ret true; - } - } - ret false; - } -} // Local Variables: // mode: rust;