| // Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT |
| // file at the top-level directory of this distribution and at |
| // http://rust-lang.org/COPYRIGHT. |
| // |
| // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or |
| // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license |
| // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your |
| // option. This file may not be copied, modified, or distributed |
| // except according to those terms. |
| |
| /* |
| * The compiler code necessary to support the fmt! extension. Eventually this |
| * should all get sucked into either the standard library extfmt module or the |
| * compiler syntax extension plugin interface. |
| */ |
| |
| use ast; |
| use codemap::Span; |
| use ext::base::*; |
| use ext::base; |
| use ext::build::AstBuilder; |
| |
| use std::option; |
| use std::unstable::extfmt::ct::*; |
| use parse::token::{str_to_ident}; |
| |
| pub fn expand_syntax_ext(cx: @ExtCtxt, sp: Span, tts: &[ast::token_tree]) |
| -> base::MacResult { |
| let args = get_exprs_from_tts(cx, sp, tts); |
| if args.len() == 0 { |
| cx.span_fatal(sp, "fmt! takes at least 1 argument."); |
| } |
| let fmt = |
| expr_to_str(cx, args[0], |
| "first argument to fmt! must be a string literal."); |
| let fmtspan = args[0].span; |
| debug!("Format string: %s", fmt); |
| fn parse_fmt_err_(cx: @ExtCtxt, sp: Span, msg: &str) -> ! { |
| cx.span_fatal(sp, msg); |
| } |
| let parse_fmt_err: &fn(&str) -> ! = |s| parse_fmt_err_(cx, fmtspan, s); |
| let pieces = parse_fmt_string(fmt, parse_fmt_err); |
| MRExpr(pieces_to_expr(cx, sp, pieces, args)) |
| } |
| |
| // FIXME (#2249): A lot of these functions for producing expressions can |
| // probably be factored out in common with other code that builds |
| // expressions. Also: Cleanup the naming of these functions. |
| // Note: Moved many of the common ones to build.rs --kevina |
| fn pieces_to_expr(cx: @ExtCtxt, sp: Span, |
| pieces: ~[Piece], args: ~[@ast::Expr]) |
| -> @ast::Expr { |
| fn make_path_vec(ident: &str) -> ~[ast::Ident] { |
| return ~[str_to_ident("std"), |
| str_to_ident("unstable"), |
| str_to_ident("extfmt"), |
| str_to_ident("rt"), |
| str_to_ident(ident)]; |
| } |
| fn make_rt_path_expr(cx: @ExtCtxt, sp: Span, nm: &str) -> @ast::Expr { |
| let path = make_path_vec(nm); |
| cx.expr_path(cx.path_global(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(cx: @ExtCtxt, sp: Span, cnv: &Conv) -> @ast::Expr { |
| fn make_flags(cx: @ExtCtxt, sp: Span, flags: &[Flag]) -> @ast::Expr { |
| let mut tmp_expr = make_rt_path_expr(cx, sp, "flag_none"); |
| for f in flags.iter() { |
| let fstr = match *f { |
| FlagLeftJustify => "flag_left_justify", |
| FlagLeftZeroPad => "flag_left_zero_pad", |
| FlagSpaceForSign => "flag_space_for_sign", |
| FlagSignAlways => "flag_sign_always", |
| FlagAlternate => "flag_alternate" |
| }; |
| tmp_expr = cx.expr_binary(sp, ast::BiBitOr, tmp_expr, |
| make_rt_path_expr(cx, sp, fstr)); |
| } |
| return tmp_expr; |
| } |
| fn make_count(cx: @ExtCtxt, sp: Span, cnt: Count) -> @ast::Expr { |
| match cnt { |
| CountImplied => { |
| return make_rt_path_expr(cx, sp, "CountImplied"); |
| } |
| CountIs(c) => { |
| let count_lit = cx.expr_uint(sp, c as uint); |
| let count_is_path = make_path_vec("CountIs"); |
| let count_is_args = ~[count_lit]; |
| return cx.expr_call_global(sp, count_is_path, count_is_args); |
| } |
| _ => cx.span_unimpl(sp, "unimplemented fmt! conversion") |
| } |
| } |
| fn make_ty(cx: @ExtCtxt, sp: Span, t: Ty) -> @ast::Expr { |
| let rt_type = match t { |
| TyHex(c) => match c { |
| CaseUpper => "TyHexUpper", |
| CaseLower => "TyHexLower" |
| }, |
| TyBits => "TyBits", |
| TyOctal => "TyOctal", |
| _ => "TyDefault" |
| }; |
| return make_rt_path_expr(cx, sp, rt_type); |
| } |
| fn make_conv_struct(cx: @ExtCtxt, sp: Span, flags_expr: @ast::Expr, |
| width_expr: @ast::Expr, precision_expr: @ast::Expr, |
| ty_expr: @ast::Expr) -> @ast::Expr { |
| cx.expr_struct( |
| sp, |
| cx.path_global(sp, make_path_vec("Conv")), |
| ~[ |
| cx.field_imm(sp, str_to_ident("flags"), flags_expr), |
| cx.field_imm(sp, str_to_ident("width"), width_expr), |
| cx.field_imm(sp, str_to_ident("precision"), precision_expr), |
| cx.field_imm(sp, str_to_ident("ty"), ty_expr) |
| ] |
| ) |
| } |
| let rt_conv_flags = make_flags(cx, sp, cnv.flags); |
| let rt_conv_width = make_count(cx, sp, cnv.width); |
| let rt_conv_precision = make_count(cx, sp, cnv.precision); |
| let rt_conv_ty = make_ty(cx, sp, cnv.ty); |
| make_conv_struct(cx, sp, rt_conv_flags, rt_conv_width, |
| rt_conv_precision, rt_conv_ty) |
| } |
| fn make_conv_call(cx: @ExtCtxt, sp: Span, conv_type: &str, cnv: &Conv, |
| arg: @ast::Expr, buf: @ast::Expr) -> @ast::Expr { |
| let fname = ~"conv_" + conv_type; |
| let path = make_path_vec(fname); |
| let cnv_expr = make_rt_conv_expr(cx, sp, cnv); |
| let args = ~[cnv_expr, arg, buf]; |
| cx.expr_call_global(arg.span, path, args) |
| } |
| |
| fn make_new_conv(cx: @ExtCtxt, sp: Span, cnv: &Conv, |
| arg: @ast::Expr, buf: @ast::Expr) -> @ast::Expr { |
| fn is_signed_type(cnv: &Conv) -> bool { |
| match cnv.ty { |
| TyInt(s) => match s { |
| Signed => return true, |
| Unsigned => return false |
| }, |
| TyFloat => return true, |
| _ => return false |
| } |
| } |
| let unsupported = ~"conversion not supported in fmt! string"; |
| match cnv.param { |
| option::None => (), |
| _ => cx.span_unimpl(sp, unsupported) |
| } |
| for f in cnv.flags.iter() { |
| match *f { |
| FlagLeftJustify => (), |
| FlagSignAlways => { |
| if !is_signed_type(cnv) { |
| cx.span_fatal(sp, |
| "+ flag only valid in \ |
| signed fmt! conversion"); |
| } |
| } |
| FlagSpaceForSign => { |
| if !is_signed_type(cnv) { |
| cx.span_fatal(sp, |
| "space flag only valid in \ |
| signed fmt! conversions"); |
| } |
| } |
| FlagLeftZeroPad => (), |
| _ => cx.span_unimpl(sp, unsupported) |
| } |
| } |
| match cnv.width { |
| CountImplied => (), |
| CountIs(_) => (), |
| _ => cx.span_unimpl(sp, unsupported) |
| } |
| match cnv.precision { |
| CountImplied => (), |
| CountIs(_) => (), |
| _ => cx.span_unimpl(sp, unsupported) |
| } |
| let (name, actual_arg) = match cnv.ty { |
| TyStr => ("str", arg), |
| TyInt(Signed) => ("int", arg), |
| TyBool => ("bool", arg), |
| TyChar => ("char", arg), |
| TyBits | TyOctal | TyHex(_) | TyInt(Unsigned) => ("uint", arg), |
| TyFloat => ("float", arg), |
| TyPointer => ("pointer", arg), |
| TyPoly => ("poly", cx.expr_addr_of(sp, arg)) |
| }; |
| return make_conv_call(cx, arg.span, name, cnv, actual_arg, |
| cx.expr_mut_addr_of(arg.span, buf)); |
| } |
| fn log_conv(c: &Conv) { |
| debug!("Building conversion:"); |
| match c.param { |
| Some(p) => { debug!("param: %s", p.to_str()); } |
| _ => debug!("param: none") |
| } |
| for f in c.flags.iter() { |
| match *f { |
| FlagLeftJustify => debug!("flag: left justify"), |
| FlagLeftZeroPad => debug!("flag: left zero pad"), |
| FlagSpaceForSign => debug!("flag: left space pad"), |
| FlagSignAlways => debug!("flag: sign always"), |
| FlagAlternate => debug!("flag: alternate") |
| } |
| } |
| match c.width { |
| CountIs(i) => |
| debug!("width: count is %s", i.to_str()), |
| CountIsParam(i) => |
| debug!("width: count is param %s", i.to_str()), |
| CountIsNextParam => debug!("width: count is next param"), |
| CountImplied => debug!("width: count is implied") |
| } |
| match c.precision { |
| CountIs(i) => |
| debug!("prec: count is %s", i.to_str()), |
| CountIsParam(i) => |
| debug!("prec: count is param %s", i.to_str()), |
| CountIsNextParam => debug!("prec: count is next param"), |
| CountImplied => debug!("prec: count is implied") |
| } |
| match c.ty { |
| TyBool => debug!("type: bool"), |
| TyStr => debug!("type: str"), |
| TyChar => debug!("type: char"), |
| TyInt(s) => match s { |
| Signed => debug!("type: signed"), |
| Unsigned => debug!("type: unsigned") |
| }, |
| TyBits => debug!("type: bits"), |
| TyHex(cs) => match cs { |
| CaseUpper => debug!("type: uhex"), |
| CaseLower => debug!("type: lhex"), |
| }, |
| TyOctal => debug!("type: octal"), |
| TyFloat => debug!("type: float"), |
| TyPointer => debug!("type: pointer"), |
| TyPoly => debug!("type: poly") |
| } |
| } |
| |
| /* Short circuit an easy case up front (won't work otherwise) */ |
| if pieces.len() == 0 { |
| return cx.expr_str_uniq(args[0].span, @""); |
| } |
| |
| let fmt_sp = args[0].span; |
| let mut n = 0u; |
| let nargs = args.len(); |
| |
| /* 'ident' is the local buffer building up the result of fmt! */ |
| let ident = str_to_ident("__fmtbuf"); |
| let buf = || cx.expr_ident(fmt_sp, ident); |
| let core_ident = str_to_ident("std"); |
| let str_ident = str_to_ident("str"); |
| let push_ident = str_to_ident("push_str"); |
| let mut stms = ~[]; |
| |
| /* Translate each piece (portion of the fmt expression) by invoking the |
| corresponding function in std::unstable::extfmt. Each function takes a |
| buffer to insert data into along with the data being formatted. */ |
| let npieces = pieces.len(); |
| for (i, pc) in pieces.move_iter().enumerate() { |
| match pc { |
| /* Raw strings get appended via str::push_str */ |
| PieceString(s) => { |
| /* If this is the first portion, then initialize the local |
| buffer with it directly. If it's actually the only piece, |
| then there's no need for it to be mutable */ |
| if i == 0 { |
| stms.push(cx.stmt_let(fmt_sp, npieces > 1, |
| ident, cx.expr_str_uniq(fmt_sp, s.to_managed()))); |
| } else { |
| // we call the push_str function because the |
| // bootstrap doesnt't seem to work if we call the |
| // method. |
| let args = ~[cx.expr_mut_addr_of(fmt_sp, buf()), |
| cx.expr_str(fmt_sp, s.to_managed())]; |
| let call = cx.expr_call_global(fmt_sp, |
| ~[core_ident, |
| str_ident, |
| push_ident], |
| args); |
| stms.push(cx.stmt_expr(call)); |
| } |
| } |
| |
| /* Invoke the correct conv function in extfmt */ |
| PieceConv(ref conv) => { |
| n += 1u; |
| if n >= nargs { |
| cx.span_fatal(sp, |
| "not enough arguments to fmt! \ |
| for the given format string"); |
| } |
| |
| log_conv(conv); |
| /* If the first portion is a conversion, then the local buffer |
| must be initialized as an empty string */ |
| if i == 0 { |
| stms.push(cx.stmt_let(fmt_sp, true, ident, |
| cx.expr_str_uniq(fmt_sp, @""))); |
| } |
| stms.push(cx.stmt_expr(make_new_conv(cx, fmt_sp, conv, |
| args[n], buf()))); |
| } |
| } |
| } |
| |
| let expected_nargs = n + 1u; // n conversions + the fmt string |
| if expected_nargs < nargs { |
| cx.span_fatal |
| (sp, fmt!("too many arguments to fmt!. found %u, expected %u", |
| nargs, expected_nargs)); |
| } |
| |
| cx.expr_block(cx.block(fmt_sp, stms, Some(buf()))) |
| } |
