1 // Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
12 use codemap::{Pos, Span};
16 use ext::build::AstBuilder;
21 use util::small_vector::SmallVector;
26 // These macros all relate to the file system; they either return
27 // the column/row/filename of the expression, or they include
28 // a given file into the current one.
30 /// line!(): expands to the current line number
31 pub fn expand_line(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
32 -> Box<base::MacResult+'static> {
33 base::check_zero_tts(cx, sp, tts, "line!");
35 let topmost = cx.original_span_in_file();
36 let loc = cx.codemap().lookup_char_pos(topmost.lo);
38 base::MacExpr::new(cx.expr_uint(topmost, loc.line))
41 /* column!(): expands to the current column number */
42 pub fn expand_column(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
43 -> Box<base::MacResult+'static> {
44 base::check_zero_tts(cx, sp, tts, "column!");
46 let topmost = cx.original_span_in_file();
47 let loc = cx.codemap().lookup_char_pos(topmost.lo);
48 base::MacExpr::new(cx.expr_uint(topmost, loc.col.to_uint()))
51 /// file!(): expands to the current filename */
52 /// The filemap (`loc.file`) contains a bunch more information we could spit
54 pub fn expand_file(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
55 -> Box<base::MacResult+'static> {
56 base::check_zero_tts(cx, sp, tts, "file!");
58 let topmost = cx.original_span_in_file();
59 let loc = cx.codemap().lookup_char_pos(topmost.lo);
60 let filename = token::intern_and_get_ident(&loc.file.name[]);
61 base::MacExpr::new(cx.expr_str(topmost, filename))
64 pub fn expand_stringify(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
65 -> Box<base::MacResult+'static> {
66 let s = pprust::tts_to_string(tts);
67 base::MacExpr::new(cx.expr_str(sp,
68 token::intern_and_get_ident(&s[])))
71 pub fn expand_mod(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
72 -> Box<base::MacResult+'static> {
73 base::check_zero_tts(cx, sp, tts, "module_path!");
74 let string = cx.mod_path()
76 .map(|x| token::get_ident(*x).get().to_string())
77 .collect::<Vec<String>>()
79 base::MacExpr::new(cx.expr_str(
81 token::intern_and_get_ident(&string[])))
84 /// include! : parse the given file as an expr
85 /// This is generally a bad idea because it's going to behave
87 pub fn expand_include<'cx>(cx: &'cx mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
88 -> Box<base::MacResult+'cx> {
89 let file = match get_single_str_from_tts(cx, sp, tts, "include!") {
91 None => return DummyResult::expr(sp),
93 // The file will be added to the code map by the parser
95 parse::new_sub_parser_from_file(cx.parse_sess(),
104 struct ExpandResult<'a> {
105 p: parse::parser::Parser<'a>,
107 impl<'a> base::MacResult for ExpandResult<'a> {
108 fn make_expr(mut self: Box<ExpandResult<'a>>) -> Option<P<ast::Expr>> {
109 Some(self.p.parse_expr())
111 fn make_items(mut self: Box<ExpandResult<'a>>)
112 -> Option<SmallVector<P<ast::Item>>> {
113 let mut ret = SmallVector::zero();
115 match self.p.parse_item_with_outer_attributes() {
116 Some(item) => ret.push(item),
124 box ExpandResult { p: p }
127 // include_str! : read the given file, insert it as a literal string expr
128 pub fn expand_include_str(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
129 -> Box<base::MacResult+'static> {
130 let file = match get_single_str_from_tts(cx, sp, tts, "include_str!") {
132 None => return DummyResult::expr(sp)
134 let file = res_rel_file(cx, sp, &Path::new(file));
135 let bytes = match File::open(&file).read_to_end() {
138 &format!("couldn't read {:?}: {}",
141 return DummyResult::expr(sp);
145 match String::from_utf8(bytes) {
147 // Add this input file to the code map to make it available as
148 // dependency information
149 let filename = format!("{:?}", file.display());
150 let interned = token::intern_and_get_ident(&src[]);
151 cx.codemap().new_filemap(filename, src);
153 base::MacExpr::new(cx.expr_str(sp, interned))
157 &format!("{:?} wasn't a utf-8 file",
159 return DummyResult::expr(sp);
164 pub fn expand_include_bin(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
165 -> Box<base::MacResult+'static> {
166 cx.span_warn(sp, "include_bin! is deprecated; use include_bytes! instead");
167 expand_include_bytes(cx, sp, tts)
170 pub fn expand_include_bytes(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
171 -> Box<base::MacResult+'static> {
172 let file = match get_single_str_from_tts(cx, sp, tts, "include_bytes!") {
174 None => return DummyResult::expr(sp)
176 let file = res_rel_file(cx, sp, &Path::new(file));
177 match File::open(&file).read_to_end() {
180 &format!("couldn't read {:?}: {}", file.display(), e)[]);
181 return DummyResult::expr(sp);
184 let bytes = bytes.iter().map(|x| *x).collect();
185 base::MacExpr::new(cx.expr_lit(sp, ast::LitBinary(Rc::new(bytes))))
190 // resolve a file-system path to an absolute file-system path (if it
192 fn res_rel_file(cx: &mut ExtCtxt, sp: codemap::Span, arg: &Path) -> Path {
193 // NB: relative paths are resolved relative to the compilation unit
194 if !arg.is_absolute() {
195 let mut cu = Path::new(cx.codemap().span_to_filename(sp));