diff options
Diffstat (limited to 'src/comp/front/extfmt.rs')
| -rw-r--r-- | src/comp/front/extfmt.rs | 210 |
1 files changed, 105 insertions, 105 deletions
diff --git a/src/comp/front/extfmt.rs b/src/comp/front/extfmt.rs index 36050e1951e..085e5d98bf7 100644 --- a/src/comp/front/extfmt.rs +++ b/src/comp/front/extfmt.rs @@ -1,56 +1,56 @@ /* * The compiler code necessary to support the #fmt extension. Eventually this - * should all get sucked into either the standard library ExtFmt module or the + * should all get sucked into either the standard library extfmt module or the * compiler syntax extension plugin interface. */ -import front.parser.parser; -import util.common; - -import std.Str; -import std.Vec; -import std.Option; -import std.Option.none; -import std.Option.some; - -import std.ExtFmt.CT.signedness; -import std.ExtFmt.CT.signed; -import std.ExtFmt.CT.unsigned; -import std.ExtFmt.CT.caseness; -import std.ExtFmt.CT.case_upper; -import std.ExtFmt.CT.case_lower; -import std.ExtFmt.CT.ty; -import std.ExtFmt.CT.ty_bool; -import std.ExtFmt.CT.ty_str; -import std.ExtFmt.CT.ty_char; -import std.ExtFmt.CT.ty_int; -import std.ExtFmt.CT.ty_bits; -import std.ExtFmt.CT.ty_hex; -import std.ExtFmt.CT.ty_octal; -import std.ExtFmt.CT.flag; -import std.ExtFmt.CT.flag_left_justify; -import std.ExtFmt.CT.flag_left_zero_pad; -import std.ExtFmt.CT.flag_space_for_sign; -import std.ExtFmt.CT.flag_sign_always; -import std.ExtFmt.CT.flag_alternate; -import std.ExtFmt.CT.count; -import std.ExtFmt.CT.count_is; -import std.ExtFmt.CT.count_is_param; -import std.ExtFmt.CT.count_is_next_param; -import std.ExtFmt.CT.count_implied; -import std.ExtFmt.CT.conv; -import std.ExtFmt.CT.piece; -import std.ExtFmt.CT.piece_string; -import std.ExtFmt.CT.piece_conv; -import std.ExtFmt.CT.parse_fmt_string; +import front::parser::parser; +import util::common; + +import std::_str; +import std::_vec; +import std::option; +import std::option::none; +import std::option::some; + +import std::extfmt::CT::signedness; +import std::extfmt::CT::signed; +import std::extfmt::CT::unsigned; +import std::extfmt::CT::caseness; +import std::extfmt::CT::case_upper; +import std::extfmt::CT::case_lower; +import std::extfmt::CT::ty; +import std::extfmt::CT::ty_bool; +import std::extfmt::CT::ty_str; +import std::extfmt::CT::ty_char; +import std::extfmt::CT::ty_int; +import std::extfmt::CT::ty_bits; +import std::extfmt::CT::ty_hex; +import std::extfmt::CT::ty_octal; +import std::extfmt::CT::flag; +import std::extfmt::CT::flag_left_justify; +import std::extfmt::CT::flag_left_zero_pad; +import std::extfmt::CT::flag_space_for_sign; +import std::extfmt::CT::flag_sign_always; +import std::extfmt::CT::flag_alternate; +import std::extfmt::CT::count; +import std::extfmt::CT::count_is; +import std::extfmt::CT::count_is_param; +import std::extfmt::CT::count_is_next_param; +import std::extfmt::CT::count_implied; +import std::extfmt::CT::conv; +import std::extfmt::CT::piece; +import std::extfmt::CT::piece_string; +import std::extfmt::CT::piece_conv; +import std::extfmt::CT::parse_fmt_string; export expand_syntax_ext; fn expand_syntax_ext(parser p, - vec[@ast.expr] args, - Option.t[str] body) -> @ast.expr { + vec[@ast::expr] args, + option::t[str] body) -> @ast::expr { - if (Vec.len[@ast.expr](args) == 0u) { + if (_vec::len[@ast::expr](args) == 0u) { // FIXME: Handle error correctly. log_err "malformed #fmt call"; fail; @@ -62,16 +62,16 @@ fn expand_syntax_ext(parser p, // log fmt; auto pieces = parse_fmt_string(fmt); - auto args_len = Vec.len[@ast.expr](args); - auto fmt_args = Vec.slice[@ast.expr](args, 1u, args_len - 1u); + auto args_len = _vec::len[@ast::expr](args); + auto fmt_args = _vec::slice[@ast::expr](args, 1u, args_len - 1u); ret pieces_to_expr(p, pieces, args); } -fn expr_to_str(@ast.expr expr) -> str { +fn expr_to_str(@ast::expr expr) -> str { alt (expr.node) { - case (ast.expr_lit(?l, _)) { + case (ast::expr_lit(?l, _)) { alt (l.node) { - case (ast.lit_str(?s)) { + case (ast::lit_str(?s)) { ret s; } } @@ -86,75 +86,75 @@ fn expr_to_str(@ast.expr expr) -> str { // be factored out in common with other code that builds expressions. // FIXME: Probably should be using the parser's span functions // FIXME: Cleanup the naming of these functions -fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast.expr] args) - -> @ast.expr { +fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast::expr] args) + -> @ast::expr { - fn make_new_lit(parser p, common.span sp, ast.lit_ lit) -> @ast.expr { + fn make_new_lit(parser p, common::span sp, ast::lit_ lit) -> @ast::expr { auto sp_lit = @rec(node=lit, span=sp); - auto expr = ast.expr_lit(sp_lit, p.get_ann()); + auto expr = ast::expr_lit(sp_lit, p.get_ann()); ret @rec(node=expr, span=sp); } - fn make_new_str(parser p, common.span sp, str s) -> @ast.expr { - auto lit = ast.lit_str(s); + fn make_new_str(parser p, common::span sp, str s) -> @ast::expr { + auto lit = ast::lit_str(s); ret make_new_lit(p, sp, lit); } - fn make_new_int(parser p, common.span sp, int i) -> @ast.expr { - auto lit = ast.lit_int(i); + fn make_new_int(parser p, common::span sp, int i) -> @ast::expr { + auto lit = ast::lit_int(i); ret make_new_lit(p, sp, lit); } - fn make_new_uint(parser p, common.span sp, uint u) -> @ast.expr { - auto lit = ast.lit_uint(u); + fn make_new_uint(parser p, common::span sp, uint u) -> @ast::expr { + auto lit = ast::lit_uint(u); ret make_new_lit(p, sp, lit); } - fn make_add_expr(parser p, common.span sp, - @ast.expr lhs, @ast.expr rhs) -> @ast.expr { - auto binexpr = ast.expr_binary(ast.add, lhs, rhs, p.get_ann()); + fn make_add_expr(parser p, common::span sp, + @ast::expr lhs, @ast::expr rhs) -> @ast::expr { + auto binexpr = ast::expr_binary(ast::add, lhs, rhs, p.get_ann()); ret @rec(node=binexpr, span=sp); } - fn make_path_expr(parser p, common.span sp, vec[ast.ident] idents) - -> @ast.expr { - let vec[@ast.ty] types = vec(); + fn make_path_expr(parser p, common::span sp, vec[ast::ident] idents) + -> @ast::expr { + let vec[@ast::ty] types = vec(); auto path = rec(idents=idents, types=types); auto sp_path = rec(node=path, span=sp); - auto pathexpr = ast.expr_path(sp_path, p.get_ann()); + auto pathexpr = ast::expr_path(sp_path, p.get_ann()); auto sp_pathexpr = @rec(node=pathexpr, span=sp); ret sp_pathexpr; } - fn make_vec_expr(parser p, common.span sp, vec[@ast.expr] exprs) - -> @ast.expr { - auto vecexpr = ast.expr_vec(exprs, ast.imm, p.get_ann()); + fn make_vec_expr(parser p, common::span sp, vec[@ast::expr] exprs) + -> @ast::expr { + auto vecexpr = ast::expr_vec(exprs, ast::imm, p.get_ann()); auto sp_vecexpr = @rec(node=vecexpr, span=sp); ret sp_vecexpr; } - fn make_call(parser p, common.span sp, vec[ast.ident] fn_path, - vec[@ast.expr] args) -> @ast.expr { + fn make_call(parser p, common::span sp, vec[ast::ident] fn_path, + vec[@ast::expr] args) -> @ast::expr { auto pathexpr = make_path_expr(p, sp, fn_path); - auto callexpr = ast.expr_call(pathexpr, args, p.get_ann()); + auto callexpr = ast::expr_call(pathexpr, args, p.get_ann()); auto sp_callexpr = @rec(node=callexpr, span=sp); ret sp_callexpr; } - fn make_rec_expr(parser p, common.span sp, - vec[tup(ast.ident, @ast.expr)] fields) -> @ast.expr { - let vec[ast.field] astfields = vec(); - for (tup(ast.ident, @ast.expr) field in fields) { + fn make_rec_expr(parser p, common::span sp, + vec[tup(ast::ident, @ast::expr)] fields) -> @ast::expr { + let vec[ast::field] astfields = vec(); + for (tup(ast::ident, @ast::expr) field in fields) { auto ident = field._0; auto val = field._1; - auto astfield = rec(mut = ast.imm, + auto astfield = rec(mut = ast::imm, ident = ident, expr = val); astfields += vec(astfield); } - auto recexpr = ast.expr_rec(astfields, - Option.none[@ast.expr], + auto recexpr = ast::expr_rec(astfields, + option::none[@ast::expr], p.get_ann()); auto sp_recexpr = @rec(node=recexpr, span=sp); ret sp_recexpr; @@ -166,18 +166,18 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast.expr] args) ret vec("std", "extfmt", "RT", ident); } - fn make_rt_path_expr(parser p, common.span sp, str ident) -> @ast.expr { + fn make_rt_path_expr(parser p, common::span sp, str ident) -> @ast::expr { auto path = make_path_vec(ident); ret make_path_expr(p, sp, path); } - // Produces an AST expression that represents a RT.conv record, - // which tells the RT.conv* functions how to perform the conversion - fn make_rt_conv_expr(parser p, common.span sp, &conv cnv) -> @ast.expr { + // Produces an AST expression that represents a RT::conv record, + // which tells the RT::conv* functions how to perform the conversion + fn make_rt_conv_expr(parser p, common::span sp, &conv cnv) -> @ast::expr { - fn make_flags(parser p, common.span sp, vec[flag] flags) - -> @ast.expr { - let vec[@ast.expr] flagexprs = vec(); + fn make_flags(parser p, common::span sp, vec[flag] flags) + -> @ast::expr { + let vec[@ast::expr] flagexprs = vec(); for (flag f in flags) { auto fstr; alt (f) { @@ -203,14 +203,14 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast.expr] args) // FIXME: 0-length vectors can't have their type inferred // through the rec that these flags are a member of, so // this is a hack placeholder flag - if (Vec.len[@ast.expr](flagexprs) == 0u) { + if (_vec::len[@ast::expr](flagexprs) == 0u) { flagexprs += vec(make_rt_path_expr(p, sp, "flag_none")); } ret make_vec_expr(p, sp, flagexprs); } - fn make_count(parser p, common.span sp, &count cnt) -> @ast.expr { + fn make_count(parser p, common::span sp, &count cnt) -> @ast::expr { alt (cnt) { case (count_implied) { ret make_rt_path_expr(p, sp, "count_implied"); @@ -228,7 +228,7 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast.expr] args) } } - fn make_ty(parser p, common.span sp, &ty t) -> @ast.expr { + fn make_ty(parser p, common::span sp, &ty t) -> @ast::expr { auto rt_type; alt (t) { case (ty_hex(?c)) { @@ -256,11 +256,11 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast.expr] args) } fn make_conv_rec(parser p, - common.span sp, - @ast.expr flags_expr, - @ast.expr width_expr, - @ast.expr precision_expr, - @ast.expr ty_expr) -> @ast.expr { + common::span sp, + @ast::expr flags_expr, + @ast::expr width_expr, + @ast::expr precision_expr, + @ast::expr ty_expr) -> @ast::expr { ret make_rec_expr(p, sp, vec(tup("flags", flags_expr), tup("width", width_expr), tup("precision", precision_expr), @@ -279,8 +279,8 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast.expr] args) rt_conv_ty); } - fn make_conv_call(parser p, common.span sp, str conv_type, - &conv cnv, @ast.expr arg) -> @ast.expr { + fn make_conv_call(parser p, common::span sp, str conv_type, + &conv cnv, @ast::expr arg) -> @ast::expr { auto fname = "conv_" + conv_type; auto path = make_path_vec(fname); auto cnv_expr = make_rt_conv_expr(p, sp, cnv); @@ -288,9 +288,9 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast.expr] args) ret make_call(p, arg.span, path, args); } - fn make_new_conv(parser p, conv cnv, @ast.expr arg) -> @ast.expr { + fn make_new_conv(parser p, conv cnv, @ast::expr arg) -> @ast::expr { - // FIXME: Extract all this validation into ExtFmt.CT + // FIXME: Extract all this validation into extfmt::CT fn is_signed_type(conv cnv) -> bool { alt (cnv.ty) { case (ty_int(?s)) { @@ -312,7 +312,7 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast.expr] args) auto unsupported = "conversion not supported in #fmt string"; alt (cnv.param) { - case (Option.none[int]) { + case (option::none[int]) { } case (_) { log_err unsupported; @@ -407,7 +407,7 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast.expr] args) fn log_conv(conv c) { alt (c.param) { case (some[int](?p)) { - log "param: " + std.Int.to_str(p, 10u); + log "param: " + std::_int::to_str(p, 10u); } case (_) { log "param: none"; @@ -434,10 +434,10 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast.expr] args) } alt (c.width) { case (count_is(?i)) { - log "width: count is " + std.Int.to_str(i, 10u); + log "width: count is " + std::_int::to_str(i, 10u); } case (count_is_param(?i)) { - log "width: count is param " + std.Int.to_str(i, 10u); + log "width: count is param " + std::_int::to_str(i, 10u); } case (count_is_next_param) { log "width: count is next param"; @@ -448,10 +448,10 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast.expr] args) } alt (c.precision) { case (count_is(?i)) { - log "prec: count is " + std.Int.to_str(i, 10u); + log "prec: count is " + std::_int::to_str(i, 10u); } case (count_is_param(?i)) { - log "prec: count is param " + std.Int.to_str(i, 10u); + log "prec: count is param " + std::_int::to_str(i, 10u); } case (count_is_next_param) { log "prec: count is next param"; @@ -507,7 +507,7 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast.expr] args) tmp_expr = make_add_expr(p, sp, tmp_expr, s_expr); } case (piece_conv(?conv)) { - if (n >= Vec.len[@ast.expr](args)) { + if (n >= _vec::len[@ast::expr](args)) { log_err "too many conversions in #fmt string"; fail; } @@ -526,7 +526,7 @@ fn pieces_to_expr(parser p, vec[piece] pieces, vec[@ast.expr] args) // TODO: Remove this debug logging // log "dumping expanded ast:"; - // log pretty.print_expr(tmp_expr); + // log pretty::print_expr(tmp_expr); ret tmp_expr; } |