Init repo

Author: calixteman

.gitignore

@@ -0,0 +1,3 @@
+target
+enums/target
+*~

Cargo.lock

@@ -0,0 +1,46 @@
+[package]
+name = "rust-code-analysis"
+version = "0.0.1"
+authors = ["Calixte Denizet <[email protected]>"]
+edition = "2018"
+build = "build.rs"
+
+[build-dependencies]
+cc = "^1.0.37"
+phf_codegen = "^0.7"
+
+[dependencies]
+actix-http = "^0.2"
+actix-rt = "^0.2"
+actix-web = {version = "^1.0", features = ["ssl"]}
+aho-corasick = "^0.7"
+bytes = "^0.4"
+clap = "^2.33"
+enum-iterator = "^0.3"
+futures = "^0.1"
+globset = "^0.4"
+json = "^0.11"
+libc = "^0.2"
+tree-sitter = "^0.3.10"
+termcolor = "^1.0"
+crossbeam = "^0.7"
+lazy_static = "^1.3"
+num_cpus = "^1.10"
+openssl = "^0.10"
+petgraph = "^0.4.13"
+phf = { version = "0.7.24", features = ["macros"] }
+regex = "^1.1"
+serde = "^1.0"
+serde_json = "^1.0"
+walkdir = "^2.2"
+
+[profile.release]
+opt-level = 3
+debug = false
+rpath = false
+lto = true
+debug-assertions = false
+codegen-units = 1
+panic = 'unwind'
+incremental = false
+overflow-checks = false

Cargo.toml

@@ -0,0 +1,137 @@
+extern crate cc;
+extern crate phf_codegen;
+
+use std::{env, fs};
+use std::io::{BufWriter, Read, Write};
+use std::path::{Path, PathBuf};
+
+const TREE_SITTER: &str = "tree-sitter-";
+
+fn get_opt_level() -> u32 {
+    env::var("OPT_LEVEL").unwrap().parse::<u32>().unwrap()
+}
+
+fn get_cwd() -> &'static str {
+    if is_enums() {
+        ".."
+    } else {
+        "."
+    }
+}
+
+fn is_enums() -> bool {
+    let path = env::current_dir().unwrap();
+    path.ends_with("enums")
+}
+
+fn mk_predef(data_name: &str, set_name: &str) {
+    let mut set = phf_codegen::Set::new();
+    let mut file = fs::File::open(PathBuf::from(format!("./data/{}.txt", data_name))).unwrap();
+    let mut data = Vec::new();
+    file.read_to_end(&mut data).unwrap();
+    for tok in data.split(|c| *c == b'\n') {
+        let tok = std::str::from_utf8(tok).unwrap().trim();
+        if !tok.is_empty() {
+            set.entry(tok);
+        }
+    }
+    let path = Path::new(&env::var("OUT_DIR").unwrap()).join(format!("gen_{}.rs", data_name));
+    let mut file = BufWriter::new(fs::File::create(&path).unwrap());
+    writeln!(&mut file, "static {}: phf::Set<&'static str> =", set_name).unwrap();
+    set.build(&mut file).unwrap();
+    writeln!(&mut file, ";").unwrap();
+}
+
+fn collect_tree_sitter_dirs(ignore: Vec<String>) -> Vec<String> {
+    let mut dirs = Vec::new();
+    for entry in fs::read_dir(get_cwd()).unwrap() {
+        if let Ok(entry) = entry {
+            let path = entry.path();
+            let dir = path.file_name().unwrap().to_str().unwrap().to_string();
+            if dir.starts_with(TREE_SITTER) && !ignore.contains(&dir) {
+                dirs.push(dir);
+            }
+        }
+    }
+    dirs
+}
+
+fn collect_src_files(dir: &str) -> (Vec<String>, Vec<String>) {
+    eprintln!("Collect files for {}", dir);
+
+    let mut c_files = Vec::new();
+    let mut cpp_files = Vec::new();
+    let path = PathBuf::from(get_cwd()).join(&dir).join("src");
+    for entry in fs::read_dir(path).unwrap() {
+        if let Ok(entry) = entry {
+            let path = entry.path();
+            if path
+                .file_stem()
+                .unwrap()
+                .to_str()
+                .unwrap()
+                .starts_with("binding")
+            {
+                continue;
+            }
+            if let Some(ext) = path.extension() {
+                if ext == "c" {
+                    c_files.push(path.to_str().unwrap().to_string());
+                } else if ext == "cc" || ext == "cpp" || ext == "cxx" {
+                    cpp_files.push(path.to_str().unwrap().to_string());
+                }
+            }
+        }
+    }
+    (c_files, cpp_files)
+}
+
+fn build_c(files: Vec<String>, language: &str) {
+    let mut build = cc::Build::new();
+    for file in files {
+        build
+            .file(&file)
+            .include(PathBuf::from(file).parent().unwrap())
+            .pic(true)
+            .opt_level(get_opt_level())
+            .debug(true)
+            .flag("-std=c99");
+    }
+    build.compile(&format!("tree-sitter-{}-c", language));
+}
+
+fn build_cpp(files: Vec<String>, language: &str) {
+    let mut build = cc::Build::new();
+    for file in files {
+        build
+            .file(&file)
+            .include(PathBuf::from(file).parent().unwrap())
+            .pic(true)
+            .opt_level(get_opt_level())
+            .debug(true)
+            .cpp(true);
+    }
+    build.compile(&format!("tree-sitter-{}-cpp", language));
+}
+
+fn build_dir(dir: &str, language: &str) {
+    eprintln!("Build language {}", language);
+    let (c, cpp) = collect_src_files(&dir);
+    build_c(c, &language);
+    build_cpp(cpp, &language);
+}
+
+fn main() {
+    if !is_enums() {
+        mk_predef("c_macros", "PREDEFINED_MACROS");
+        mk_predef("c_specials", "SPECIALS");
+    }
+    let ignore = vec!["tree-sitter-typescript".to_string()];
+    let dirs = collect_tree_sitter_dirs(ignore);
+    for dir in dirs {
+        let language = &dir[TREE_SITTER.len()..];
+        build_dir(&dir, &language);
+    }
+    build_dir("tree-sitter-typescript/tsx", "tsx");
+    build_dir("tree-sitter-typescript/typescript", "typescript");
+}