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::gc::Gc;
  23 use std::io::File;
  24 use std::rc::Rc;
  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                    -> Box<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::MacExpr::new(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                   -> Box<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::MacExpr::new(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                    -> Box<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.as_slice());
  61     base::MacExpr::new(cx.expr_str(topmost.call_site, filename))
  62 }
  63
  64 pub fn expand_stringify(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
  65                         -> Box<base::MacResult> {
  66     let s = pprust::tts_to_string(tts);
  67     base::MacExpr::new(cx.expr_str(sp,
  68                                    token::intern_and_get_ident(s.as_slice())))
  69 }
  70
  71 pub fn expand_mod(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
  72                   -> Box<base::MacResult> {
  73     base::check_zero_tts(cx, sp, tts, "module_path!");
  74     let string = cx.mod_path()
  75                    .iter()
  76                    .map(|x| token::get_ident(*x).get().to_string())
  77                    .collect::<Vec<String>>()
  78                    .connect("::");
  79     base::MacExpr::new(cx.expr_str(
  80             sp,
  81             token::intern_and_get_ident(string.as_slice())))
  82 }
  83
  84 /// include! : parse the given file as an expr
  85 /// This is generally a bad idea because it's going to behave
  86 /// unhygienically.
  87 pub fn expand_include(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
  88                       -> Box<base::MacResult> {
  89     let file = match get_single_str_from_tts(cx, sp, tts, "include!") {
  90         Some(f) => f,
  91         None => return DummyResult::expr(sp),
  92     };
  93     // The file will be added to the code map by the parser
  94     let mut p =
  95         parse::new_sub_parser_from_file(cx.parse_sess(),
  96                                         cx.cfg(),
  97                                         &res_rel_file(cx,
  98                                                       sp,
  99                                                       &Path::new(file)),
 100                                         true,
 101                                         None,
 102                                         sp);
 103     base::MacExpr::new(p.parse_expr())
 104 }
 105
 106 // include_str! : read the given file, insert it as a literal string expr
 107 pub fn expand_include_str(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
 108                           -> Box<base::MacResult> {
 109     let file = match get_single_str_from_tts(cx, sp, tts, "include_str!") {
 110         Some(f) => f,
 111         None => return DummyResult::expr(sp)
 112     };
 113     let file = res_rel_file(cx, sp, &Path::new(file));
 114     let bytes = match File::open(&file).read_to_end() {
 115         Err(e) => {
 116             cx.span_err(sp,
 117                         format!("couldn't read {}: {}",
 118                                 file.display(),
 119                                 e).as_slice());
 120             return DummyResult::expr(sp);
 121         }
 122         Ok(bytes) => bytes,
 123     };
 124     match String::from_utf8(bytes) {
 125         Ok(src) => {
 126             // Add this input file to the code map to make it available as
 127             // dependency information
 128             let filename = file.display().to_string();
 129             let interned = token::intern_and_get_ident(src.as_slice());
 130             cx.codemap().new_filemap(filename, src);
 131
 132             base::MacExpr::new(cx.expr_str(sp, interned))
 133         }
 134         Err(_) => {
 135             cx.span_err(sp,
 136                         format!("{} wasn't a utf-8 file",
 137                                 file.display()).as_slice());
 138             return DummyResult::expr(sp);
 139         }
 140     }
 141 }
 142
 143 pub fn expand_include_bin(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
 144                           -> Box<base::MacResult> {
 145     let file = match get_single_str_from_tts(cx, sp, tts, "include_bin!") {
 146         Some(f) => f,
 147         None => return DummyResult::expr(sp)
 148     };
 149     let file = res_rel_file(cx, sp, &Path::new(file));
 150     match File::open(&file).read_to_end() {
 151         Err(e) => {
 152             cx.span_err(sp,
 153                         format!("couldn't read {}: {}",
 154                                 file.display(),
 155                                 e).as_slice());
 156             return DummyResult::expr(sp);
 157         }
 158         Ok(bytes) => {
 159             let bytes = bytes.iter().map(|x| *x).collect();
 160             base::MacExpr::new(cx.expr_lit(sp, ast::LitBinary(Rc::new(bytes))))
 161         }
 162     }
 163 }
 164
 165 // recur along an ExpnInfo chain to find the original expression
 166 fn topmost_expn_info(expn_info: Gc<codemap::ExpnInfo>) -> Gc<codemap::ExpnInfo> {
 167     match *expn_info {
 168         ExpnInfo { call_site: ref call_site, .. } => {
 169             match call_site.expn_info {
 170                 Some(next_expn_info) => {
 171                     match *next_expn_info {
 172                         ExpnInfo {
 173                             callee: NameAndSpan { name: ref name, .. },
 174                             ..
 175                         } => {
 176                             // Don't recurse into file using "include!"
 177                             if "include" == name.as_slice() {
 178                                 expn_info
 179                             } else {
 180                                 topmost_expn_info(next_expn_info)
 181                             }
 182                         }
 183                     }
 184                 },
 185                 None => expn_info
 186             }
 187         }
 188     }
 189 }
 190
 191 // resolve a file-system path to an absolute file-system path (if it
 192 // isn't already)
 193 fn res_rel_file(cx: &mut ExtCtxt, sp: codemap::Span, arg: &Path) -> Path {
 194     // NB: relative paths are resolved relative to the compilation unit
 195     if !arg.is_absolute() {
 196         let mut cu = Path::new(cx.codemap().span_to_filename(sp));
 197         cu.pop();
 198         cu.push(arg);
 199         cu
 200     } else {
 201         arg.clone()
 202     }
 203 }