extern crate syn;
use std::env;
use std::fs::File;
use std::io::Read;
use std::io::Write;
use std::path::Path;
pub const KDB_SYM_FILE: &'static str = "symbols.rs";
fn parse_fns(fns: &syn::ItemForeignMod) -> Vec<String> {
let mut functions = vec![];
for item in &fns.items {
match item {
syn::ForeignItem::Fn(ref item_fn) => {
let mut sym: String = "_".to_owned();
let ident = item_fn.ident.to_string();
sym.push_str(&ident);
functions.push(sym);
}
_ => (),
}
}
functions
}
fn ksyms(fname: &str) -> Vec<String> {
let mut src = String::new();
let mut file = File::open(&fname).expect("Unable to open file");
file.read_to_string(&mut src).expect("Unable to read file");
let syntax = syn::parse_file(&src).expect("Unable to parse file");
syntax.items.iter().map(|item| match item {
syn::Item::ForeignMod(ref item_fn) => parse_fns(item_fn),
_ => vec![],
})
.flat_map(|x| x)
.collect()
}
fn sym_file() -> std::path::PathBuf {
let out_dir = env::var("OUT_DIR").expect("OUT_DIR environment variable not provided");
Path::new(&out_dir).join(KDB_SYM_FILE)
}
fn main() {
let base = env::current_dir().unwrap();
let src = base.join("src").join("k.rs");
let syms = ksyms(src.to_str().unwrap());
let dest_path = sym_file();
let mut f = File::create(&dest_path)
.expect("Could not create file to store external KDB symbols");
writeln!(f, "#[allow(dead_code)]")
.expect("Could not write to KDB symbol file header");
writeln!(f, "pub const SYMBOLS: [&'static str; {}] = {:?};", syms.len(), syms)
.expect("Could not write to KDB symbol file");
f.flush()
.expect("Could not flush write to KDB symbol");
let dir = base.join("src").join("c");
println!("cargo:rustc-link-search={}", dir.to_str().unwrap());
}