std: Remove extfmt. Has been moved to core. Closes #1600
This commit is contained in:
Brian Anderson
parent
fc2ae08b9c
commit
52b1623089
|
|
@ -1,453 +0,0 @@
|
|||
/*
|
||||
Syntax Extension: fmt
|
||||
|
||||
Format a string
|
||||
|
||||
The 'fmt' extension is modeled on the posix printf system.
|
||||
|
||||
A posix conversion ostensibly looks like this
|
||||
|
||||
> %[parameter][flags][width][.precision][length]type
|
||||
|
||||
Given the different numeric type bestiary we have, we omit the 'length'
|
||||
parameter and support slightly different conversions for 'type'
|
||||
|
||||
> %[parameter][flags][width][.precision]type
|
||||
|
||||
we also only support translating-to-rust a tiny subset of the possible
|
||||
combinations at the moment.
|
||||
|
||||
Example:
|
||||
|
||||
#debug("hello, %s!", "world");
|
||||
|
||||
*/
|
||||
|
||||
import option::{some, none};
|
||||
|
||||
|
||||
/*
|
||||
* 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
|
||||
* description that specifies how to format its output.
|
||||
*
|
||||
* The building of the AST is currently done in a module inside the compiler,
|
||||
* but should migrate over here as the plugin interface is defined.
|
||||
*/
|
||||
|
||||
// Functions used by the fmt extension at compile time
|
||||
mod ct {
|
||||
enum signedness { signed, unsigned }
|
||||
enum caseness { case_upper, case_lower }
|
||||
enum ty {
|
||||
ty_bool,
|
||||
ty_str,
|
||||
ty_char,
|
||||
ty_int(signedness),
|
||||
ty_bits,
|
||||
ty_hex(caseness),
|
||||
ty_octal,
|
||||
ty_float,
|
||||
// FIXME: More types
|
||||
}
|
||||
enum flag {
|
||||
flag_left_justify,
|
||||
flag_left_zero_pad,
|
||||
flag_space_for_sign,
|
||||
flag_sign_always,
|
||||
flag_alternate,
|
||||
}
|
||||
enum count {
|
||||
count_is(int),
|
||||
count_is_param(int),
|
||||
count_is_next_param,
|
||||
count_implied,
|
||||
}
|
||||
|
||||
// A formatted conversion from an expression to a string
|
||||
type conv =
|
||||
{param: option::t<int>,
|
||||
flags: [flag],
|
||||
width: count,
|
||||
precision: count,
|
||||
ty: ty};
|
||||
|
||||
|
||||
// A fragment of the output sequence
|
||||
enum piece { piece_string(str), piece_conv(conv), }
|
||||
type error_fn = fn@(str) -> ! ;
|
||||
|
||||
fn parse_fmt_string(s: str, error: error_fn) -> [piece] {
|
||||
let pieces: [piece] = [];
|
||||
let lim = str::byte_len(s);
|
||||
let buf = "";
|
||||
fn flush_buf(buf: str, &pieces: [piece]) -> str {
|
||||
if str::byte_len(buf) > 0u {
|
||||
let piece = piece_string(buf);
|
||||
pieces += [piece];
|
||||
}
|
||||
ret "";
|
||||
}
|
||||
let i = 0u;
|
||||
while i < lim {
|
||||
let curr = str::substr(s, i, 1u);
|
||||
if str::eq(curr, "%") {
|
||||
i += 1u;
|
||||
if i >= lim {
|
||||
error("unterminated conversion at end of string");
|
||||
}
|
||||
let curr2 = str::substr(s, i, 1u);
|
||||
if str::eq(curr2, "%") {
|
||||
i += 1u;
|
||||
} else {
|
||||
buf = flush_buf(buf, pieces);
|
||||
let rs = parse_conversion(s, i, lim, error);
|
||||
pieces += [rs.piece];
|
||||
i = rs.next;
|
||||
}
|
||||
} else { buf += curr; i += 1u; }
|
||||
}
|
||||
buf = flush_buf(buf, pieces);
|
||||
ret pieces;
|
||||
}
|
||||
fn peek_num(s: str, i: uint, lim: uint) ->
|
||||
option::t<{num: uint, next: uint}> {
|
||||
if i >= lim { ret none; }
|
||||
let c = s[i];
|
||||
if !('0' as u8 <= c && c <= '9' as u8) { ret option::none; }
|
||||
let n = c - ('0' as u8) as uint;
|
||||
ret alt peek_num(s, i + 1u, lim) {
|
||||
none { some({num: n, next: i + 1u}) }
|
||||
some(next) {
|
||||
let m = next.num;
|
||||
let j = next.next;
|
||||
some({num: n * 10u + m, next: j})
|
||||
}
|
||||
};
|
||||
}
|
||||
fn parse_conversion(s: str, i: uint, lim: uint, error: error_fn) ->
|
||||
{piece: piece, next: uint} {
|
||||
let parm = parse_parameter(s, i, lim);
|
||||
let flags = parse_flags(s, parm.next, lim);
|
||||
let width = parse_count(s, flags.next, lim);
|
||||
let prec = parse_precision(s, width.next, lim);
|
||||
let ty = parse_type(s, prec.next, lim, error);
|
||||
ret {piece:
|
||||
piece_conv({param: parm.param,
|
||||
flags: flags.flags,
|
||||
width: width.count,
|
||||
precision: prec.count,
|
||||
ty: ty.ty}),
|
||||
next: ty.next};
|
||||
}
|
||||
fn parse_parameter(s: str, i: uint, lim: uint) ->
|
||||
{param: option::t<int>, next: uint} {
|
||||
if i >= lim { ret {param: none, next: i}; }
|
||||
let num = peek_num(s, i, lim);
|
||||
ret alt num {
|
||||
none { {param: none, next: i} }
|
||||
some(t) {
|
||||
let n = t.num;
|
||||
let j = t.next;
|
||||
if j < lim && s[j] == '$' as u8 {
|
||||
{param: some(n as int), next: j + 1u}
|
||||
} else { {param: none, next: i} }
|
||||
}
|
||||
};
|
||||
}
|
||||
fn parse_flags(s: str, i: uint, lim: uint) ->
|
||||
{flags: [flag], next: uint} {
|
||||
let noflags: [flag] = [];
|
||||
if i >= lim { ret {flags: noflags, next: i}; }
|
||||
|
||||
// FIXME: This recursion generates illegal instructions if the return
|
||||
// value isn't boxed. Only started happening after the ivec conversion
|
||||
fn more_(f: flag, s: str, i: uint, lim: uint) ->
|
||||
@{flags: [flag], next: uint} {
|
||||
let next = parse_flags(s, i + 1u, lim);
|
||||
let rest = next.flags;
|
||||
let j = next.next;
|
||||
let curr: [flag] = [f];
|
||||
ret @{flags: curr + rest, next: j};
|
||||
}
|
||||
let more = bind more_(_, s, i, lim);
|
||||
let f = s[i];
|
||||
ret if f == '-' as u8 {
|
||||
*more(flag_left_justify)
|
||||
} else if f == '0' as u8 {
|
||||
*more(flag_left_zero_pad)
|
||||
} else if f == ' ' as u8 {
|
||||
*more(flag_space_for_sign)
|
||||
} else if f == '+' as u8 {
|
||||
*more(flag_sign_always)
|
||||
} else if f == '#' as u8 {
|
||||
*more(flag_alternate)
|
||||
} else { {flags: noflags, next: i} };
|
||||
}
|
||||
fn parse_count(s: str, i: uint, lim: uint) -> {count: count, next: uint} {
|
||||
ret if i >= lim {
|
||||
{count: count_implied, next: i}
|
||||
} else if s[i] == '*' as u8 {
|
||||
let param = parse_parameter(s, i + 1u, lim);
|
||||
let j = param.next;
|
||||
alt param.param {
|
||||
none { {count: count_is_next_param, next: j} }
|
||||
some(n) { {count: count_is_param(n), next: j} }
|
||||
}
|
||||
} else {
|
||||
let num = peek_num(s, i, lim);
|
||||
alt num {
|
||||
none { {count: count_implied, next: i} }
|
||||
some(num) {
|
||||
{count: count_is(num.num as int), next: num.next}
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
fn parse_precision(s: str, i: uint, lim: uint) ->
|
||||
{count: count, next: uint} {
|
||||
ret if i >= lim {
|
||||
{count: count_implied, next: i}
|
||||
} else if s[i] == '.' as u8 {
|
||||
let count = parse_count(s, i + 1u, lim);
|
||||
|
||||
|
||||
// If there were no digits specified, i.e. the precision
|
||||
// was ".", then the precision is 0
|
||||
alt count.count {
|
||||
count_implied { {count: count_is(0), next: count.next} }
|
||||
_ { count }
|
||||
}
|
||||
} else { {count: count_implied, next: i} };
|
||||
}
|
||||
fn parse_type(s: str, i: uint, lim: uint, error: error_fn) ->
|
||||
{ty: ty, next: uint} {
|
||||
if i >= lim { error("missing type in conversion"); }
|
||||
let tstr = str::substr(s, i, 1u);
|
||||
// TODO: Do we really want two signed types here?
|
||||
// How important is it to be printf compatible?
|
||||
let t =
|
||||
if str::eq(tstr, "b") {
|
||||
ty_bool
|
||||
} else if str::eq(tstr, "s") {
|
||||
ty_str
|
||||
} else if str::eq(tstr, "c") {
|
||||
ty_char
|
||||
} else if str::eq(tstr, "d") || str::eq(tstr, "i") {
|
||||
ty_int(signed)
|
||||
} else if str::eq(tstr, "u") {
|
||||
ty_int(unsigned)
|
||||
} else if str::eq(tstr, "x") {
|
||||
ty_hex(case_lower)
|
||||
} else if str::eq(tstr, "X") {
|
||||
ty_hex(case_upper)
|
||||
} else if str::eq(tstr, "t") {
|
||||
ty_bits
|
||||
} else if str::eq(tstr, "o") {
|
||||
ty_octal
|
||||
} else if str::eq(tstr, "f") {
|
||||
ty_float
|
||||
} else { error("unknown type in conversion: " + tstr) };
|
||||
ret {ty: t, next: i + 1u};
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// Functions used by the fmt extension at runtime. For now there are a lot of
|
||||
// decisions made a runtime. If it proves worthwhile then some of these
|
||||
// conditions can be evaluated at compile-time. For now though it's cleaner to
|
||||
// implement it this way, I think.
|
||||
mod rt {
|
||||
enum 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,
|
||||
}
|
||||
enum count { count_is(int), count_implied, }
|
||||
enum 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 = {flags: [flag], width: count, precision: count, ty: ty};
|
||||
|
||||
fn conv_int(cv: conv, i: int) -> str {
|
||||
let radix = 10u;
|
||||
let prec = get_int_precision(cv);
|
||||
let 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(cv: conv, u: uint) -> str {
|
||||
let prec = get_int_precision(cv);
|
||||
let rs =
|
||||
alt cv.ty {
|
||||
ty_default { uint_to_str_prec(u, 10u, prec) }
|
||||
ty_hex_lower { uint_to_str_prec(u, 16u, prec) }
|
||||
ty_hex_upper { str::to_upper(uint_to_str_prec(u, 16u, prec)) }
|
||||
ty_bits { uint_to_str_prec(u, 2u, prec) }
|
||||
ty_octal { uint_to_str_prec(u, 8u, prec) }
|
||||
};
|
||||
ret pad(cv, rs, pad_unsigned);
|
||||
}
|
||||
fn conv_bool(cv: conv, b: bool) -> str {
|
||||
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 {
|
||||
ret pad(cv, str::from_char(c), pad_nozero);
|
||||
}
|
||||
fn conv_str(cv: conv, s: str) -> str {
|
||||
// For strings, precision is the maximum characters
|
||||
// displayed
|
||||
|
||||
// FIXME: substr works on bytes, not chars!
|
||||
let unpadded =
|
||||
alt cv.precision {
|
||||
count_implied { s }
|
||||
count_is(max) {
|
||||
if max as uint < str::char_len(s) {
|
||||
str::substr(s, 0u, max as uint)
|
||||
} else { s }
|
||||
}
|
||||
};
|
||||
ret pad(cv, unpadded, pad_nozero);
|
||||
}
|
||||
fn conv_float(cv: conv, f: float) -> str {
|
||||
let (to_str, digits) = alt cv.precision {
|
||||
count_is(c) { (float::to_str_exact, c as uint) }
|
||||
count_implied { (float::to_str, 6u) }
|
||||
};
|
||||
let s = to_str(f, digits);
|
||||
if 0.0 <= f {
|
||||
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);
|
||||
}
|
||||
|
||||
// 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(num: int, radix: uint, prec: uint) -> str {
|
||||
ret if num < 0 {
|
||||
"-" + uint_to_str_prec(-num as uint, radix, prec)
|
||||
} else { 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(num: uint, radix: uint, prec: uint) -> str {
|
||||
ret if prec == 0u && num == 0u {
|
||||
""
|
||||
} else {
|
||||
let s = uint::to_str(num, radix);
|
||||
let len = str::char_len(s);
|
||||
if len < prec {
|
||||
let diff = prec - len;
|
||||
let pad = str_init_elt(diff, '0');
|
||||
pad + s
|
||||
} else { s }
|
||||
};
|
||||
}
|
||||
fn get_int_precision(cv: conv) -> uint {
|
||||
ret alt cv.precision {
|
||||
count_is(c) { c as uint }
|
||||
count_implied { 1u }
|
||||
};
|
||||
}
|
||||
|
||||
// FIXME: This might be useful in str: but needs to be utf8 safe first
|
||||
fn str_init_elt(n_elts: uint, c: char) -> str {
|
||||
let svec = vec::init_elt::<u8>(n_elts, c as u8);
|
||||
|
||||
ret str::unsafe_from_bytes(svec);
|
||||
}
|
||||
enum pad_mode { pad_signed, pad_unsigned, pad_nozero, }
|
||||
fn pad(cv: conv, s: str, mode: pad_mode) -> str {
|
||||
let uwidth;
|
||||
alt cv.width {
|
||||
count_implied { ret s; }
|
||||
count_is(width) {
|
||||
// FIXME: Maybe width should be uint
|
||||
|
||||
uwidth = width as uint;
|
||||
}
|
||||
}
|
||||
let strlen = str::char_len(s);
|
||||
if uwidth <= strlen { ret s; }
|
||||
let padchar = ' ';
|
||||
let diff = uwidth - strlen;
|
||||
if have_flag(cv.flags, flag_left_justify) {
|
||||
let padstr = str_init_elt(diff, padchar);
|
||||
ret s + padstr;
|
||||
}
|
||||
let might_zero_pad = false;
|
||||
let signed = false;
|
||||
alt mode {
|
||||
pad_nozero {
|
||||
// fallthrough
|
||||
|
||||
}
|
||||
pad_signed { might_zero_pad = true; signed = true; }
|
||||
pad_unsigned { might_zero_pad = true; }
|
||||
}
|
||||
fn have_precision(cv: conv) -> bool {
|
||||
ret alt cv.precision { count_implied { false } _ { true } };
|
||||
}
|
||||
let zero_padding = false;
|
||||
if might_zero_pad && have_flag(cv.flags, flag_left_zero_pad) &&
|
||||
!have_precision(cv) {
|
||||
padchar = '0';
|
||||
zero_padding = true;
|
||||
}
|
||||
let padstr = str_init_elt(diff, padchar);
|
||||
// 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 {
|
||||
let head = s[0];
|
||||
if head == '+' as u8 || head == '-' as u8 || head == ' ' as u8 {
|
||||
let headstr = str::unsafe_from_bytes([head]);
|
||||
let bytelen = str::byte_len(s);
|
||||
let numpart = str::substr(s, 1u, bytelen - 1u);
|
||||
ret headstr + padstr + numpart;
|
||||
}
|
||||
}
|
||||
ret padstr + s;
|
||||
}
|
||||
fn have_flag(flags: [flag], f: flag) -> bool {
|
||||
for candidate: flag in flags { if candidate == f { ret true; } }
|
||||
ret false;
|
||||
}
|
||||
}
|
||||
// Local Variables:
|
||||
// mode: rust;
|
||||
// fill-column: 78;
|
||||
// indent-tabs-mode: nil
|
||||
// c-basic-offset: 4
|
||||
// buffer-file-coding-system: utf-8-unix
|
||||
// End:
|
||||
|
|
@ -12,7 +12,7 @@ export c_vec, four, tri, util;
|
|||
export bitv, deque, fun_treemap, list, map, smallintmap, sort, treemap, ufind;
|
||||
export rope;
|
||||
export ebml, dbg, getopts, json, rand, sha1, term, time;
|
||||
export extfmt, test, tempfile;
|
||||
export test, tempfile;
|
||||
// FIXME: generic_os and os_fs shouldn't be exported
|
||||
export generic_os, os, os_fs;
|
||||
|
||||
|
|
@ -68,7 +68,6 @@ mod unicode;
|
|||
|
||||
// Compiler support modules
|
||||
|
||||
mod extfmt;
|
||||
mod test;
|
||||
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue