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 syntax_pos::{self, Pos, Span, FileName};
15 use ext::build::AstBuilder;
16 use parse::{token, DirectoryOwnership};
22 use util::small_vector::SmallVector;
25 use std::io::prelude::*;
26 use std::path::PathBuf;
27 use rustc_data_structures::sync::Lrc;
29 // These macros all relate to the file system; they either return
30 // the column/row/filename of the expression, or they include
31 // a given file into the current one.
33 /// line!(): expands to the current line number
34 pub fn expand_line(cx: &mut ExtCtxt, sp: Span, tts: &[tokenstream::TokenTree])
35 -> Box<base::MacResult+'static> {
36 base::check_zero_tts(cx, sp, tts, "line!");
38 let topmost = cx.expansion_cause().unwrap_or(sp);
39 let loc = cx.codemap().lookup_char_pos(topmost.lo());
41 base::MacEager::expr(cx.expr_u32(topmost, loc.line as u32))
44 /* column!(): expands to the current column number */
45 pub fn expand_column(cx: &mut ExtCtxt, sp: Span, tts: &[tokenstream::TokenTree])
46 -> Box<base::MacResult+'static> {
47 base::check_zero_tts(cx, sp, tts, "column!");
49 let topmost = cx.expansion_cause().unwrap_or(sp);
50 let loc = cx.codemap().lookup_char_pos(topmost.lo());
52 base::MacEager::expr(cx.expr_u32(topmost, loc.col.to_usize() as u32 + 1))
55 /* __rust_unstable_column!(): expands to the current column number */
56 pub fn expand_column_gated(cx: &mut ExtCtxt, sp: Span, tts: &[tokenstream::TokenTree])
57 -> Box<base::MacResult+'static> {
58 if sp.allows_unstable() {
59 expand_column(cx, sp, tts)
61 cx.span_fatal(sp, "the __rust_unstable_column macro is unstable");
65 /// file!(): expands to the current filename */
66 /// The filemap (`loc.file`) contains a bunch more information we could spit
68 pub fn expand_file(cx: &mut ExtCtxt, sp: Span, tts: &[tokenstream::TokenTree])
69 -> Box<base::MacResult+'static> {
70 base::check_zero_tts(cx, sp, tts, "file!");
72 let topmost = cx.expansion_cause().unwrap_or(sp);
73 let loc = cx.codemap().lookup_char_pos(topmost.lo());
74 base::MacEager::expr(cx.expr_str(topmost, Symbol::intern(&loc.file.name.to_string())))
77 pub fn expand_stringify(cx: &mut ExtCtxt, sp: Span, tts: &[tokenstream::TokenTree])
78 -> Box<base::MacResult+'static> {
79 let s = pprust::tts_to_string(tts);
80 base::MacEager::expr(cx.expr_str(sp, Symbol::intern(&s)))
83 pub fn expand_mod(cx: &mut ExtCtxt, sp: Span, tts: &[tokenstream::TokenTree])
84 -> Box<base::MacResult+'static> {
85 base::check_zero_tts(cx, sp, tts, "module_path!");
86 let mod_path = &cx.current_expansion.module.mod_path;
87 let string = mod_path.iter().map(|x| x.to_string()).collect::<Vec<String>>().join("::");
89 base::MacEager::expr(cx.expr_str(sp, Symbol::intern(&string)))
92 /// include! : parse the given file as an expr
93 /// This is generally a bad idea because it's going to behave
95 pub fn expand_include<'cx>(cx: &'cx mut ExtCtxt, sp: Span, tts: &[tokenstream::TokenTree])
96 -> Box<base::MacResult+'cx> {
97 let file = match get_single_str_from_tts(cx, sp, tts, "include!") {
99 None => return DummyResult::expr(sp),
101 // The file will be added to the code map by the parser
102 let path = res_rel_file(cx, sp, file);
103 let directory_ownership = DirectoryOwnership::Owned { relative: None };
104 let p = parse::new_sub_parser_from_file(cx.parse_sess(), &path, directory_ownership, None, sp);
106 struct ExpandResult<'a> {
107 p: parse::parser::Parser<'a>,
109 impl<'a> base::MacResult for ExpandResult<'a> {
110 fn make_expr(mut self: Box<ExpandResult<'a>>) -> Option<P<ast::Expr>> {
111 Some(panictry!(self.p.parse_expr()))
113 fn make_items(mut self: Box<ExpandResult<'a>>)
114 -> Option<SmallVector<P<ast::Item>>> {
115 let mut ret = SmallVector::new();
116 while self.p.token != token::Eof {
117 match panictry!(self.p.parse_item()) {
118 Some(item) => ret.push(item),
119 None => self.p.diagnostic().span_fatal(self.p.span,
120 &format!("expected item, found `{}`",
121 self.p.this_token_to_string()))
129 Box::new(ExpandResult { p: p })
132 // include_str! : read the given file, insert it as a literal string expr
133 pub fn expand_include_str(cx: &mut ExtCtxt, sp: Span, tts: &[tokenstream::TokenTree])
134 -> Box<base::MacResult+'static> {
135 let file = match get_single_str_from_tts(cx, sp, tts, "include_str!") {
137 None => return DummyResult::expr(sp)
139 let file = res_rel_file(cx, sp, file);
140 let mut bytes = Vec::new();
141 match File::open(&file).and_then(|mut f| f.read_to_end(&mut bytes)) {
145 &format!("couldn't read {}: {}",
148 return DummyResult::expr(sp);
151 match String::from_utf8(bytes) {
153 // Add this input file to the code map to make it available as
154 // dependency information
155 cx.codemap().new_filemap_and_lines(&file, &src);
157 base::MacEager::expr(cx.expr_str(sp, Symbol::intern(&src)))
161 &format!("{} wasn't a utf-8 file",
163 DummyResult::expr(sp)
168 pub fn expand_include_bytes(cx: &mut ExtCtxt, sp: Span, tts: &[tokenstream::TokenTree])
169 -> Box<base::MacResult+'static> {
170 let file = match get_single_str_from_tts(cx, sp, tts, "include_bytes!") {
172 None => return DummyResult::expr(sp)
174 let file = res_rel_file(cx, sp, file);
175 let mut bytes = Vec::new();
176 match File::open(&file).and_then(|mut f| f.read_to_end(&mut bytes)) {
179 &format!("couldn't read {}: {}", file.display(), e));
180 DummyResult::expr(sp)
183 // Add this input file to the code map to make it available as
184 // dependency information, but don't enter it's contents
185 cx.codemap().new_filemap_and_lines(&file, "");
187 base::MacEager::expr(cx.expr_lit(sp, ast::LitKind::ByteStr(Lrc::new(bytes))))
192 // resolve a file-system path to an absolute file-system path (if it
194 fn res_rel_file(cx: &mut ExtCtxt, sp: syntax_pos::Span, arg: String) -> PathBuf {
195 let arg = PathBuf::from(arg);
196 // Relative paths are resolved relative to the file in which they are found
197 // after macro expansion (that is, they are unhygienic).
198 if !arg.is_absolute() {
199 let callsite = sp.source_callsite();
200 let mut path = match cx.codemap().span_to_unmapped_path(callsite) {
201 FileName::Real(path) => path,
202 other => panic!("cannot resolve relative path in non-file source `{}`", other),