src/libsyntax/ext/source_util.rs

   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.
   4 //
   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.
  10
  11 use ast;
  12 use codemap;
  13 use codemap::{Pos, Span};
  14 use codemap::{ExpnInfo, NameAndSpan};
  15 use ext::base::*;
  16 use ext::base;
  17 use ext::build::AstBuilder;
  18 use parse;
  19 use parse::token;
  20 use print::pprust;
  21
  22 use std::io::File;
  23 use std::rc::Rc;
  24 use std::str;
  25
  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.
  29
  30 /* line!(): expands to the current line number */
  31 pub fn expand_line(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
  32     -> base::MacResult {
  33     base::check_zero_tts(cx, sp, tts, "line!");
  34
  35     let topmost = topmost_expn_info(cx.backtrace().unwrap());
  36     let loc = cx.codemap().lookup_char_pos(topmost.call_site.lo);
  37
  38     base::MRExpr(cx.expr_uint(topmost.call_site, loc.line))
  39 }
  40
  41 /* col!(): expands to the current column number */
  42 pub fn expand_col(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
  43     -> base::MacResult {
  44     base::check_zero_tts(cx, sp, tts, "col!");
  45
  46     let topmost = topmost_expn_info(cx.backtrace().unwrap());
  47     let loc = cx.codemap().lookup_char_pos(topmost.call_site.lo);
  48     base::MRExpr(cx.expr_uint(topmost.call_site, loc.col.to_uint()))
  49 }
  50
  51 /* file!(): expands to the current filename */
  52 /* The filemap (`loc.file`) contains a bunch more information we could spit
  53  * out if we wanted. */
  54 pub fn expand_file(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
  55     -> base::MacResult {
  56     base::check_zero_tts(cx, sp, tts, "file!");
  57
  58     let topmost = topmost_expn_info(cx.backtrace().unwrap());
  59     let loc = cx.codemap().lookup_char_pos(topmost.call_site.lo);
  60     let filename = token::intern_and_get_ident(loc.file.name);
  61     base::MRExpr(cx.expr_str(topmost.call_site, filename))
  62 }
  63
  64 pub fn expand_stringify(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
  65     -> base::MacResult {
  66     let s = pprust::tts_to_str(tts);
  67     base::MRExpr(cx.expr_str(sp, token::intern_and_get_ident(s)))
  68 }
  69
  70 pub fn expand_mod(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
  71     -> base::MacResult {
  72     base::check_zero_tts(cx, sp, tts, "module_path!");
  73     let string = cx.mod_path()
  74                    .map(|x| token::get_ident(*x).get().to_str())
  75                    .connect("::");
  76     base::MRExpr(cx.expr_str(sp, token::intern_and_get_ident(string)))
  77 }
  78
  79 // include! : parse the given file as an expr
  80 // This is generally a bad idea because it's going to behave
  81 // unhygienically.
  82 pub fn expand_include(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
  83     -> base::MacResult {
  84     let file = match get_single_str_from_tts(cx, sp, tts, "include!") {
  85         Some(f) => f,
  86         None => return MacResult::dummy_expr(sp),
  87     };
  88     // The file will be added to the code map by the parser
  89     let mut p =
  90         parse::new_sub_parser_from_file(cx.parse_sess(),
  91                                         cx.cfg(),
  92                                         &res_rel_file(cx,
  93                                                       sp,
  94                                                       &Path::new(file)),
  95                                         sp);
  96     base::MRExpr(p.parse_expr())
  97 }
  98
  99 // include_str! : read the given file, insert it as a literal string expr
 100 pub fn expand_include_str(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
 101     -> base::MacResult {
 102     let file = match get_single_str_from_tts(cx, sp, tts, "include_str!") {
 103         Some(f) => f,
 104         None => return MacResult::dummy_expr(sp)
 105     };
 106     let file = res_rel_file(cx, sp, &Path::new(file));
 107     let bytes = match File::open(&file).read_to_end() {
 108         Err(e) => {
 109             cx.span_err(sp, format!("couldn't read {}: {}", file.display(), e));
 110             return MacResult::dummy_expr(sp);
 111         }
 112         Ok(bytes) => bytes,
 113     };
 114     match str::from_utf8_owned(bytes) {
 115         Some(src) => {
 116             // Add this input file to the code map to make it available as
 117             // dependency information
 118             let filename = file.display().to_str();
 119             let interned = token::intern_and_get_ident(src);
 120             cx.parse_sess.cm.new_filemap(filename, src);
 121
 122             base::MRExpr(cx.expr_str(sp, interned))
 123         }
 124         None => {
 125             cx.span_err(sp, format!("{} wasn't a utf-8 file", file.display()));
 126             return MacResult::dummy_expr(sp);
 127         }
 128     }
 129 }
 130
 131 pub fn expand_include_bin(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
 132         -> base::MacResult
 133 {
 134     let file = match get_single_str_from_tts(cx, sp, tts, "include_bin!") {
 135         Some(f) => f,
 136         None => return MacResult::dummy_expr(sp)
 137     };
 138     let file = res_rel_file(cx, sp, &Path::new(file));
 139     match File::open(&file).read_to_end() {
 140         Err(e) => {
 141             cx.span_err(sp, format!("couldn't read {}: {}", file.display(), e));
 142             return MacResult::dummy_expr(sp);
 143         }
 144         Ok(bytes) => {
 145             let bytes = bytes.iter().map(|x| *x).collect();
 146             base::MRExpr(cx.expr_lit(sp, ast::LitBinary(Rc::new(bytes))))
 147         }
 148     }
 149 }
 150
 151 // recur along an ExpnInfo chain to find the original expression
 152 fn topmost_expn_info(expn_info: @codemap::ExpnInfo) -> @codemap::ExpnInfo {
 153     match *expn_info {
 154         ExpnInfo { call_site: ref call_site, .. } => {
 155             match call_site.expn_info {
 156                 Some(next_expn_info) => {
 157                     match *next_expn_info {
 158                         ExpnInfo {
 159                             callee: NameAndSpan { name: ref name, .. },
 160                             ..
 161                         } => {
 162                             // Don't recurse into file using "include!"
 163                             if "include" == *name  {
 164                                 expn_info
 165                             } else {
 166                                 topmost_expn_info(next_expn_info)
 167                             }
 168                         }
 169                     }
 170                 },
 171                 None => expn_info
 172             }
 173         }
 174     }
 175 }
 176
 177 // resolve a file-system path to an absolute file-system path (if it
 178 // isn't already)
 179 fn res_rel_file(cx: &mut ExtCtxt, sp: codemap::Span, arg: &Path) -> Path {
 180     // NB: relative paths are resolved relative to the compilation unit
 181     if !arg.is_absolute() {
 182         let mut cu = Path::new(cx.codemap().span_to_filename(sp));
 183         cu.pop();
 184         cu.push(arg);
 185         cu
 186     } else {
 187         arg.clone()
 188     }
 189 }