squiid/rust
1
0
Fork 0
Code Issues Pull requests Projects Activity

Convert rustc::syntax::ext::base to istrs. Issue #855

Browse source
This commit is contained in:
Brian Anderson 2011-08-27 16:52:00 -07:00
parent 9857048929
commit 7efbfea8d0
7 changed files with 87 additions and 82 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

37
src/comp/syntax/ext/base.rs
View file

@ -9,7 +9,7 @@ import codemap;
type syntax_expander =
fn(&ext_ctxt, span, @ast::expr, &option::t<istr>) -> @ast::expr;
type macro_def = {ident: str, ext: syntax_extension};
type macro_def = {ident: istr, ext: syntax_extension};
type macro_definer =
fn(&ext_ctxt, span, @ast::expr, &option::t<istr>) -> macro_def;
@ -36,9 +36,9 @@ fn syntax_expander_table() -> hashmap<istr, syntax_extension> {
}
obj ext_ctxt(sess: @session,
crate_file_name_hack: str,
crate_file_name_hack: istr,
mutable backtrace: codemap::opt_span) {
fn crate_file_name() -> str { ret crate_file_name_hack; }
fn crate_file_name() -> istr { ret crate_file_name_hack; }
fn session() -> @session { ret sess; }
@ -58,29 +58,29 @@ obj ext_ctxt(sess: @session,
let tmp = pre;
backtrace = tmp;
}
_ { self.bug("tried to pop without a push"); }
_ { self.bug(~"tried to pop without a push"); }
}
}
fn span_fatal(sp: span, msg: str) -> ! {
fn span_fatal(sp: span, msg: istr) -> ! {
self.print_backtrace();
sess.span_fatal(sp, istr::from_estr(msg));
sess.span_fatal(sp, msg);
}
fn span_err(sp: span, msg: str) {
fn span_err(sp: span, msg: istr) {
self.print_backtrace();
sess.span_err(sp, istr::from_estr(msg));
sess.span_err(sp, msg);
}
fn span_unimpl(sp: span, msg: str) -> ! {
fn span_unimpl(sp: span, msg: istr) -> ! {
self.print_backtrace();
sess.span_unimpl(sp, istr::from_estr(msg));
sess.span_unimpl(sp, msg);
}
fn span_bug(sp: span, msg: str) -> ! {
fn span_bug(sp: span, msg: istr) -> ! {
self.print_backtrace();
sess.span_bug(sp, istr::from_estr(msg));
sess.span_bug(sp, msg);
}
fn bug(msg: str) -> ! {
fn bug(msg: istr) -> ! {
self.print_backtrace();
sess.bug(istr::from_estr(msg));
sess.bug(msg);
}
fn next_id() -> ast::node_id { ret sess.next_node_id(); }
@ -96,15 +96,15 @@ fn mk_ctxt(sess: &session) -> ext_ctxt {
// super-ugly and needs a better solution.
let crate_file_name_hack = sess.get_codemap().files[0].name;
ret ext_ctxt(@sess, istr::to_estr(crate_file_name_hack),
ret ext_ctxt(@sess, crate_file_name_hack,
codemap::os_none);
}
fn expr_to_str(cx: &ext_ctxt, expr: @ast::expr, error: str) -> str {
fn expr_to_str(cx: &ext_ctxt, expr: @ast::expr, error: &istr) -> istr {
alt expr.node {
ast::expr_lit(l) {
alt l.node {
ast::lit_str(s, _) { ret istr::to_estr(s); }
ast::lit_str(s, _) { ret s; }
_ { cx.span_fatal(l.span, error); }
}
}
@ -112,7 +112,8 @@ fn expr_to_str(cx: &ext_ctxt, expr: @ast::expr, error: str) -> str {
}
}
fn expr_to_ident(cx: &ext_ctxt, expr: @ast::expr, error: str) -> ast::ident {
fn expr_to_ident(cx: &ext_ctxt, expr: @ast::expr,
error: &istr) -> ast::ident {
alt expr.node {
ast::expr_path(p) {
if vec::len(p.node.types) > 0u || vec::len(p.node.idents) != 1u {

4
src/comp/syntax/ext/concat_idents.rs
View file

@ -8,12 +8,12 @@ fn expand_syntax_ext(cx: &ext_ctxt, sp: codemap::span, arg: @ast::expr,
alt arg.node {
ast::expr_vec(elts, _) { elts }
_ {
cx.span_fatal(sp, "#concat_idents requires a vector argument .")
cx.span_fatal(sp, ~"#concat_idents requires a vector argument .")
}
};
let res: ast::ident = ~"";
for e: @ast::expr in args {
res += expr_to_ident(cx, e, "expected an ident");
res += expr_to_ident(cx, e, ~"expected an ident");
}
ret @{id: cx.next_id(),

8
src/comp/syntax/ext/env.rs
View file

@ -17,17 +17,17 @@ fn expand_syntax_ext(cx: &ext_ctxt, sp: codemap::span, arg: @ast::expr,
alt arg.node {
ast::expr_vec(elts, _) { elts }
_ {
cx.span_fatal(sp, "#env requires arguments of the form `[...]`.")
cx.span_fatal(sp, ~"#env requires arguments of the form `[...]`.")
}
};
if vec::len::<@ast::expr>(args) != 1u {
cx.span_fatal(sp, "malformed #env call");
cx.span_fatal(sp, ~"malformed #env call");
}
// FIXME: if this was more thorough it would manufacture an
// option::t<str> rather than just an maybe-empty string.
let var = expr_to_str(cx, args[0], "#env requires a string");
alt generic_os::getenv(istr::from_estr(var)) {
let var = expr_to_str(cx, args[0], ~"#env requires a string");
alt generic_os::getenv(var) {
option::none. { ret make_new_str(cx, sp, ""); }
option::some(s) {
ret make_new_str(cx, sp, istr::to_estr(s));

8
src/comp/syntax/ext/expand.rs
View file

@ -26,9 +26,9 @@ fn expand_expr(exts: &hashmap<istr, syntax_extension>, cx: &ext_ctxt,
let extname = pth.node.idents[0];
alt exts.find(extname) {
none. {
cx.span_fatal(pth.span,
cx.span_fatal(pth.span, istr::from_estr(
#fmt["macro undefined: '%s'",
istr::to_estr(extname)])
istr::to_estr(extname)]))
}
some(normal(ext)) {
let expanded = ext(cx, pth.span, args, body);
@ -43,13 +43,13 @@ fn expand_expr(exts: &hashmap<istr, syntax_extension>, cx: &ext_ctxt,
some(macro_defining(ext)) {
let named_extension = ext(cx, pth.span, args, body);
exts.insert(
istr::from_estr(named_extension.ident),
named_extension.ident,
named_extension.ext);
ast::expr_rec([], none)
}
}
}
_ { cx.span_bug(mac.span, "naked syntactic bit") }
_ { cx.span_bug(mac.span, ~"naked syntactic bit") }
}
}
_ { orig(e, fld) }

33
src/comp/syntax/ext/fmt.rs
View file

@ -22,23 +22,24 @@ fn expand_syntax_ext(cx: &ext_ctxt, sp: span, arg: @ast::expr,
alt arg.node {
ast::expr_vec(elts, _) { elts }
_ {
cx.span_fatal(sp, "#fmt requires arguments of the form `[...]`.")
cx.span_fatal(sp, ~"#fmt requires arguments of the form `[...]`.")
}
};
if vec::len::<@ast::expr>(args) == 0u {
cx.span_fatal(sp, "#fmt requires a format string");
cx.span_fatal(sp, ~"#fmt requires a format string");
}
let fmt =
expr_to_str(cx, args[0],
"first argument to #fmt must be a " + "string literal.");
~"first argument to #fmt must be a "
+ ~"string literal.");
let fmtspan = args[0].span;
log "Format string:";
log fmt;
fn parse_fmt_err_(cx: &ext_ctxt, sp: span, msg: str) -> ! {
cx.span_fatal(sp, msg);
cx.span_fatal(sp, istr::from_estr(msg));
}
let parse_fmt_err = bind parse_fmt_err_(cx, fmtspan, _);
let pieces = parse_fmt_string(fmt, parse_fmt_err);
let pieces = parse_fmt_string(istr::to_estr(fmt), parse_fmt_err);
ret pieces_to_expr(cx, sp, pieces, args);
}
@ -102,7 +103,7 @@ fn pieces_to_expr(cx: &ext_ctxt, sp: span, pieces: &[piece],
}
fn make_path_vec(cx: &ext_ctxt, ident: &ast::ident) -> [ast::ident] {
fn compiling_std(cx: &ext_ctxt) -> bool {
ret str::find(cx.crate_file_name(), "std.rc") >= 0;
ret istr::find(cx.crate_file_name(), ~"std.rc") >= 0;
}
if compiling_std(cx) {
ret [~"extfmt", ~"rt", ident];
@ -149,7 +150,7 @@ fn pieces_to_expr(cx: &ext_ctxt, sp: span, pieces: &[piece],
let count_is_args = [count_lit];
ret make_call(cx, sp, count_is_path, count_is_args);
}
_ { cx.span_unimpl(sp, "unimplemented #fmt conversion"); }
_ { cx.span_unimpl(sp, ~"unimplemented #fmt conversion"); }
}
}
fn make_ty(cx: &ext_ctxt, sp: span, t: &ty) -> @ast::expr {
@ -203,7 +204,7 @@ fn pieces_to_expr(cx: &ext_ctxt, sp: span, pieces: &[piece],
_ { ret false; }
}
}
let unsupported = "conversion not supported in #fmt string";
let unsupported = ~"conversion not supported in #fmt string";
alt cnv.param {
option::none. { }
_ { cx.span_unimpl(sp, unsupported); }
@ -214,15 +215,15 @@ fn pieces_to_expr(cx: &ext_ctxt, sp: span, pieces: &[piece],
flag_sign_always. {
if !is_signed_type(cnv) {
cx.span_fatal(sp,
"+ flag only valid in " +
"signed #fmt conversion");
~"+ flag only valid in " +
~"signed #fmt conversion");
}
}
flag_space_for_sign. {
if !is_signed_type(cnv) {
cx.span_fatal(sp,
"space flag only valid in " +
"signed #fmt conversions");
~"space flag only valid in " +
~"signed #fmt conversions");
}
}
flag_left_zero_pad. { }
@ -330,8 +331,8 @@ fn pieces_to_expr(cx: &ext_ctxt, sp: span, pieces: &[piece],
n += 1u;
if n >= nargs {
cx.span_fatal(sp,
"not enough arguments to #fmt " +
"for the given format string");
~"not enough arguments to #fmt " +
~"for the given format string");
}
log "Building conversion:";
log_conv(conv);
@ -345,9 +346,9 @@ fn pieces_to_expr(cx: &ext_ctxt, sp: span, pieces: &[piece],
if expected_nargs < nargs {
cx.span_fatal(
sp,
sp, istr::from_estr(
#fmt["too many arguments to #fmt. found %u, expected %u",
nargs, expected_nargs]);
nargs, expected_nargs]));
}
ret tmp_expr;
}

6
src/comp/syntax/ext/ident_to_str.rs
View file

@ -10,16 +10,16 @@ fn expand_syntax_ext(cx: &ext_ctxt, sp: codemap::span, arg: @ast::expr,
alt arg.node {
ast::expr_vec(elts, _) { elts }
_ {
cx.span_fatal(sp, "#ident_to_str requires a vector argument .")
cx.span_fatal(sp, ~"#ident_to_str requires a vector argument .")
}
};
if vec::len::<@ast::expr>(args) != 1u {
cx.span_fatal(sp, "malformed #ident_to_str call");
cx.span_fatal(sp, ~"malformed #ident_to_str call");
}
ret make_new_lit(cx, sp,
ast::lit_str(expr_to_ident(cx, args[0u],
"expected an ident"),
~"expected an ident"),
ast::sk_rc));
}

73
src/comp/syntax/ext/simplext.rs
View file

@ -58,28 +58,29 @@ tag matchable {
/* for when given an incompatible bit of AST */
fn match_error(cx: &ext_ctxt, m: &matchable, expected: &str) -> ! {
let expected = istr::from_estr(expected);
alt m {
match_expr(x) {
cx.span_fatal(x.span,
"this argument is an expr, expected " + expected);
~"this argument is an expr, expected " + expected);
}
match_path(x) {
cx.span_fatal(x.span,
"this argument is a path, expected " + expected);
~"this argument is a path, expected " + expected);
}
match_ident(x) {
cx.span_fatal(x.span,
"this argument is an ident, expected " + expected);
~"this argument is an ident, expected " + expected);
}
match_ty(x) {
cx.span_fatal(x.span,
"this argument is a type, expected " + expected);
~"this argument is a type, expected " + expected);
}
match_block(x) {
cx.span_fatal(x.span,
"this argument is a block, expected " + expected);
~"this argument is a block, expected " + expected);
}
match_exact. { cx.bug("what is a match_exact doing in a bindings?"); }
match_exact. { cx.bug(~"what is a match_exact doing in a bindings?"); }
}
}
@ -102,7 +103,7 @@ fn elts_to_ell(cx: &ext_ctxt, elts: &[@expr]) ->
alt m.node {
ast::mac_ellipsis. {
if res != none {
cx.span_fatal(m.span, "only one ellipsis allowed");
cx.span_fatal(m.span, ~"only one ellipsis allowed");
}
res =
some({pre: vec::slice(elts, 0u, idx - 1u),
@ -252,8 +253,8 @@ fn follow_for_trans(cx: &ext_ctxt, mmaybe: &option::t<arb_depth<matchable>>,
ret alt follow(m, idx_path) {
seq(_, sp) {
cx.span_fatal(sp,
"syntax matched under ... but not " +
"used that way.")
~"syntax matched under ... but not " +
~"used that way.")
}
leaf(m) { ret some(m) }
}
@ -314,7 +315,8 @@ fn transcribe_exprs(cx: &ext_ctxt, b: &bindings, idx_path: @mutable [uint],
#fmt["'%s' occurs %u times",
istr::to_estr(old_name),
old_len];
cx.span_fatal(repeat_me.span, msg);
cx.span_fatal(
repeat_me.span, istr::from_estr(msg));
}
}
}
@ -324,8 +326,8 @@ fn transcribe_exprs(cx: &ext_ctxt, b: &bindings, idx_path: @mutable [uint],
alt repeat {
none. {
cx.span_fatal(repeat_me.span,
"'...' surrounds an expression without any" +
" repeating syntax variables");
~"'...' surrounds an expression without any" +
~" repeating syntax variables");
}
some({rep_count: rc, _}) {
/* Whew, we now know how how many times to repeat */
@ -468,12 +470,12 @@ fn p_t_s_rec(cx: &ext_ctxt, m: &matchable, s: &selector, b: &binders) {
if vec::len(post) > 0u {
cx.span_unimpl(e.span,
"matching after `...` not yet supported");
~"matching after `...` not yet supported");
}
}
{pre: pre, rep: none., post: post} {
if post != [] {
cx.bug("elts_to_ell provided an invalid result");
cx.bug(~"elts_to_ell provided an invalid result");
}
p_t_s_r_length(cx, vec::len(pre), false, s, b);
p_t_s_r_actual_vector(cx, pre, false, s, b);
@ -493,7 +495,7 @@ fn p_t_s_rec(cx: &ext_ctxt, m: &matchable, s: &selector, b: &binders) {
match_expr(e) {
if e == pat { some(leaf(match_exact)) } else { none }
}
_ { cx.bug("broken traversal in p_t_s_r") }
_ { cx.bug(~"broken traversal in p_t_s_r") }
}
}
b.literal_ast_matchers += [bind select(cx, _, e)];
@ -529,11 +531,11 @@ fn p_t_s_r_path(cx: &ext_ctxt, p: &path, s: &selector, b: &binders) {
fn select(cx: &ext_ctxt, m: &matchable) -> match_result {
ret alt m {
match_expr(e) { some(leaf(specialize_match(m))) }
_ { cx.bug("broken traversal in p_t_s_r") }
_ { cx.bug(~"broken traversal in p_t_s_r") }
}
}
if b.real_binders.contains_key(p_id) {
cx.span_fatal(p.span, "duplicate binding identifier");
cx.span_fatal(p.span, ~"duplicate binding identifier");
}
b.real_binders.insert(p_id,
compose_sels(s, bind select(cx, _)));
@ -559,14 +561,15 @@ fn p_t_s_r_mac(cx: &ext_ctxt, mac: &ast::mac, s: &selector, b: &binders) {
match_expr(e) {
alt e.node { expr_mac(mac) { fn_m(mac) } _ { none } }
}
_ { cx.bug("broken traversal in p_t_s_r") }
_ { cx.bug(~"broken traversal in p_t_s_r") }
}
}
fn no_des(cx: &ext_ctxt, sp: &span, syn: &str) -> ! {
cx.span_fatal(sp, "destructuring " + syn + " is not yet supported");
cx.span_fatal(sp, ~"destructuring "
+ istr::from_estr(syn) + ~" is not yet supported");
}
alt mac.node {
ast::mac_ellipsis. { cx.span_fatal(mac.span, "misused `...`"); }
ast::mac_ellipsis. { cx.span_fatal(mac.span, ~"misused `...`"); }
ast::mac_invoc(_, _, _) { no_des(cx, mac.span, "macro calls"); }
ast::mac_embed_type(ty) {
alt ty.node {
@ -633,7 +636,7 @@ fn p_t_s_r_ellipses(cx: &ext_ctxt, repeat_me: @expr, offset: uint,
_ { none }
}
}
_ { cx.bug("broken traversal in p_t_s_r") }
_ { cx.bug(~"broken traversal in p_t_s_r") }
}
}
p_t_s_rec(cx, match_expr(repeat_me),
@ -678,7 +681,7 @@ fn p_t_s_r_actual_vector(cx: &ext_ctxt, elts: [@expr], _repeat_after: bool,
_ { none }
}
}
_ { cx.bug("broken traversal in p_t_s_r") }
_ { cx.bug(~"broken traversal in p_t_s_r") }
}
}
p_t_s_rec(cx, match_expr(elts[idx]),
@ -694,7 +697,7 @@ fn add_new_extension(cx: &ext_ctxt, sp: span, arg: @expr,
ast::expr_vec(elts, _) { elts }
_ {
cx.span_fatal(sp,
"#macro requires arguments of the form `[...]`.")
~"#macro requires arguments of the form `[...]`.")
}
};
@ -705,8 +708,8 @@ fn add_new_extension(cx: &ext_ctxt, sp: span, arg: @expr,
expr_vec(elts, mut) {
if vec::len(elts) != 2u {
cx.span_fatal((*arg).span,
"extension clause must consist of [" +
"macro invocation, expansion body]");
~"extension clause must consist of [" +
~"macro invocation, expansion body]");
}
@ -721,15 +724,15 @@ fn add_new_extension(cx: &ext_ctxt, sp: span, arg: @expr,
some(other_id) {
if id != other_id {
cx.span_fatal(pth.span,
"macro name must be " +
"consistent");
~"macro name must be " +
~"consistent");
}
}
}
}
none. {
cx.span_fatal(pth.span,
"macro name must not be a path");
~"macro name must not be a path");
}
}
clauses +=
@ -742,14 +745,14 @@ fn add_new_extension(cx: &ext_ctxt, sp: span, arg: @expr,
}
_ {
cx.span_fatal(elts[0u].span,
"extension clause must" +
" start with a macro invocation.");
~"extension clause must" +
~" start with a macro invocation.");
}
}
}
_ {
cx.span_fatal((*arg).span,
"extension must be [clause, " + " ...]");
~"extension must be [clause, " + ~" ...]");
}
}
}
@ -758,11 +761,11 @@ fn add_new_extension(cx: &ext_ctxt, sp: span, arg: @expr,
ret {ident:
alt macro_name {
some(id) { istr::to_estr(id) }
some(id) { id }
none. {
cx.span_fatal(sp,
"macro definition must have " +
"at least one clause")
~"macro definition must have " +
~"at least one clause")
}
},
ext: normal(ext)};
@ -776,7 +779,7 @@ fn add_new_extension(cx: &ext_ctxt, sp: span, arg: @expr,
none. { cont; }
}
}
cx.span_fatal(sp, "no clauses match macro invocation");
cx.span_fatal(sp, ~"no clauses match macro invocation");
}
}