From 08a49d3a41761a6cea3366c367b0efb88a8ad4bc Mon Sep 17 00:00:00 2001 From: Luni-4 Date: Wed, 22 Sep 2021 10:38:12 +0200 Subject: [PATCH 1/7] Move the c_macros generator in the enums crate In this way macros for the C language are not generated during rust-code-analysis build --- Cargo.lock | 11 ------- Cargo.toml | 4 --- build.rs | 33 --------------------- {data => enums/data}/c_macros.txt | 0 {data => enums/data}/c_specials.txt | 0 {data => enums/data}/mac.py | 0 {data => enums/data}/special.py | 0 enums/src/main.rs | 5 ++++ enums/src/rust.rs | 45 +++++++++++++++++++++++++++-- 9 files changed, 48 insertions(+), 50 deletions(-) delete mode 100644 build.rs rename {data => enums/data}/c_macros.txt (100%) rename {data => enums/data}/c_specials.txt (100%) rename {data => enums/data}/mac.py (100%) rename {data => enums/data}/special.py (100%) diff --git a/Cargo.lock b/Cargo.lock index b70f48666..403baa1c6 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1370,16 +1370,6 @@ dependencies = [ "proc-macro-hack", ] -[[package]] -name = "phf_codegen" -version = "0.10.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4fb1c3a8bc4dd4e5cfce29b44ffc14bedd2ee294559a294e2a4d4c9e9a6a13cd" -dependencies = [ - "phf_generator", - "phf_shared", -] - [[package]] name = "phf_generator" version = "0.10.0" @@ -1656,7 +1646,6 @@ dependencies = [ "num-traits", "petgraph", "phf", - "phf_codegen", "pretty_assertions", "regex", "serde", diff --git a/Cargo.toml b/Cargo.toml index 6909ae42f..810edba03 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -9,10 +9,6 @@ readme = "README.md" keywords = ["metrics"] description = "Tool to compute and export code metrics" license = "MPL-2.0" -build = "build.rs" - -[build-dependencies] -phf_codegen = "^0.10" [dependencies] aho-corasick = "^0.7" diff --git a/build.rs b/build.rs deleted file mode 100644 index 10142e090..000000000 --- a/build.rs +++ /dev/null @@ -1,33 +0,0 @@ -extern crate phf_codegen; - -use std::io::{BufWriter, Read, Write}; -use std::path::{Path, PathBuf}; -use std::{env, fs}; - -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, "#[allow(clippy::unreadable_literal)]").unwrap(); - writeln!( - &mut file, - "static {}: phf::Set<&'static str> =\n{};\n", - set_name, - set.build() - ) - .unwrap(); -} - -fn main() { - mk_predef("c_macros", "PREDEFINED_MACROS"); - mk_predef("c_specials", "SPECIALS"); -} diff --git a/data/c_macros.txt b/enums/data/c_macros.txt similarity index 100% rename from data/c_macros.txt rename to enums/data/c_macros.txt diff --git a/data/c_specials.txt b/enums/data/c_specials.txt similarity index 100% rename from data/c_specials.txt rename to enums/data/c_specials.txt diff --git a/data/mac.py b/enums/data/mac.py similarity index 100% rename from data/mac.py rename to enums/data/mac.py diff --git a/data/special.py b/enums/data/special.py similarity index 100% rename from data/special.py rename to enums/data/special.py diff --git a/enums/src/main.rs b/enums/src/main.rs index 01aa1476f..06e3a4b54 100644 --- a/enums/src/main.rs +++ b/enums/src/main.rs @@ -59,6 +59,11 @@ fn main() { eprintln!("{:?}", err); } } + "c_macros" => { + if let Some(err) = generate_macros(output).err() { + eprintln!("{:?}", err); + } + } _ => { eprintln!("Invalid target language: {}", language); } diff --git a/enums/src/rust.rs b/enums/src/rust.rs index 985e07654..ceeaf86d0 100644 --- a/enums/src/rust.rs +++ b/enums/src/rust.rs @@ -2,13 +2,16 @@ extern crate phf_codegen; use askama::Template; use enum_iterator::IntoEnumIterator; +use std::env; use std::fs::File; -use std::io::Write; -use std::path::PathBuf; +use std::io::{BufWriter, Read, Write}; +use std::path::{Path, PathBuf}; use crate::common::*; use crate::languages::*; +const MACROS_DEFINITION_DIR: &str = "data"; + #[derive(Template)] #[template(path = "rust.rs", escape = "none")] struct RustTemplate { @@ -35,3 +38,41 @@ pub fn generate_rust(output: &str, file_template: &str) -> std::io::Result<()> { Ok(()) } + +pub fn generate_macros(output: &str) -> std::io::Result<()> { + create_macros_file(output, "c_macros", "PREDEFINED_MACROS")?; + create_macros_file(output, "c_specials", "SPECIALS") +} + +fn create_macros_file(output: &str, data_name: &str, set_name: &str) -> std::io::Result<()> { + let mut set = phf_codegen::Set::new(); + let mut file = File::open(PathBuf::from(format!( + "{}/{}/{}.txt", + &env::var("CARGO_MANIFEST_DIR").unwrap(), + MACROS_DEFINITION_DIR, + data_name + )))?; + let mut data = Vec::new(); + file.read_to_end(&mut data)?; + 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(output).join(format!("{}.rs", data_name)); + let mut file = BufWriter::new(File::create(&path)?); + writeln!(&mut file, "#[allow(clippy::unreadable_literal)]").unwrap(); + writeln!( + &mut file, + "static {}: phf::Set<&'static str> =\n{};\n", + set_name, + set.build() + )?; + writeln!( + &mut file, + "pub fn is_{}(mac: &str) -> bool {{ {}.contains(mac) }}\n", + set_name.to_lowercase(), + set_name, + ) +} From d7da55600dd84484ce3ff300ad660800c24951b1 Mon Sep 17 00:00:00 2001 From: Luni-4 Date: Wed, 22 Sep 2021 17:21:35 +0200 Subject: [PATCH 2/7] Create macros file automatically --- recreate-grammars.sh | 3 + src/c_langs_macros/c_macros.rs | 274 +++++++++++++++++++++++++++++++ src/c_langs_macros/c_specials.rs | 83 ++++++++++ 3 files changed, 360 insertions(+) create mode 100644 src/c_langs_macros/c_macros.rs create mode 100644 src/c_langs_macros/c_specials.rs diff --git a/recreate-grammars.sh b/recreate-grammars.sh index 00dc10352..eb6196070 100755 --- a/recreate-grammars.sh +++ b/recreate-grammars.sh @@ -6,5 +6,8 @@ cargo clean --manifest-path ./enums/Cargo.toml # Recreate all grammars cargo run --manifest-path ./enums/Cargo.toml -- -lrust -o ./src/languages +# Recreate C macros +cargo run --manifest-path ./enums/Cargo.toml -- -lc_macros -o ./src/c_langs_macros + # Format the code of the recreated grammars cargo fmt diff --git a/src/c_langs_macros/c_macros.rs b/src/c_langs_macros/c_macros.rs new file mode 100644 index 000000000..6de67c0c9 --- /dev/null +++ b/src/c_langs_macros/c_macros.rs @@ -0,0 +1,274 @@ +#[allow(clippy::unreadable_literal)] +static PREDEFINED_MACROS: phf::Set<&'static str> = +::phf::Set { map: ::phf::Map { + key: 12913932095322966823, + disps: &[ + (0, 175), + (2, 124), + (0, 20), + (14, 199), + (0, 70), + (0, 0), + (0, 7), + (1, 3), + (0, 0), + (0, 5), + (1, 7), + (0, 110), + (0, 108), + (0, 85), + (0, 118), + (0, 0), + (0, 12), + (5, 65), + (5, 84), + (0, 0), + (0, 1), + (8, 103), + (4, 105), + (0, 31), + (0, 1), + (1, 95), + (0, 49), + (0, 9), + (1, 53), + (9, 130), + (0, 20), + (8, 163), + (0, 76), + (5, 215), + (4, 28), + (68, 86), + (9, 41), + (0, 0), + (6, 5), + (0, 136), + (9, 198), + (7, 48), + (0, 16), + (29, 79), + ], + entries: &[ + ("SCNuLEAST64", ()), + ("PRIiLEAST32", ()), + ("UINT16_MAX", ()), + ("UINT_FAST64_MIN", ()), + ("INT_LEAST8_MIN", ()), + ("PRIoFAST8", ()), + ("SCNd8", ()), + ("UINT16_C", ()), + ("PRIu64", ()), + ("SCNdFAST8", ()), + ("UINT_LEAST64_MIN", ()), + ("PRIx64", ()), + ("PRIx32", ()), + ("SCNiFAST64", ()), + ("PRIuFAST16", ()), + ("PRIXFAST64", ()), + ("SCNu32", ()), + ("SCNx64", ()), + ("INT16_MIN", ()), + ("SCNiLEAST32", ()), + ("PRIdFAST32", ()), + ("PRIiPTR", ()), + ("INT64_MAX", ()), + ("UINT_LEAST64_MAX", ()), + ("UINT32_C", ()), + ("INTMAX_MAX", ()), + ("UINT_LEAST16_MIN", ()), + ("SCNxPTR", ()), + ("SCNiLEAST8", ()), + ("PRIuLEAST64", ()), + ("PRIiLEAST64", ()), + ("SCNo32", ()), + ("SCNiLEAST64", ()), + ("PRIiLEAST16", ()), + ("PRIXFAST8", ()), + ("INT_FAST16_MIN", ()), + ("UINT_FAST16_MAX", ()), + ("PRIoLEAST16", ()), + ("UINT_LEAST32_MIN", ()), + ("SCNoPTR", ()), + ("PRIiFAST32", ()), + ("UINT64_C", ()), + ("PRIxLEAST8", ()), + ("PRId32", ()), + ("PRIiFAST16", ()), + ("INT_FAST16_MAX", ()), + ("PRIuMAX", ()), + ("UINT16_MIN", ()), + ("UINT_LEAST16_MAX", ()), + ("PRIXLEAST32", ()), + ("UINT8_C", ()), + ("PRIuPTR", ()), + ("UINTMAX_MIN", ()), + ("PRIXFAST32", ()), + ("UINT_LEAST32_MAX", ()), + ("SCNoLEAST8", ()), + ("SCNu64", ()), + ("SCNoLEAST16", ()), + ("INT_LEAST16_MIN", ()), + ("PRIuLEAST8", ()), + ("PRIi8", ()), + ("SCNuLEAST16", ()), + ("INT_FAST64_MAX", ()), + ("PRIdFAST16", ()), + ("PRIo16", ()), + ("SCNx8", ()), + ("INT_LEAST16_MAX", ()), + ("SCNoFAST64", ()), + ("PRIXMAX", ()), + ("SCNiFAST16", ()), + ("SCNdFAST64", ()), + ("PRIxLEAST32", ()), + ("INTPTR_MAX", ()), + ("INT16_MAX", ()), + ("PRIi16", ()), + ("SCNdLEAST16", ()), + ("PRIdLEAST64", ()), + ("SCNuLEAST32", ()), + ("SCNuFAST32", ()), + ("SCNi32", ()), + ("SCNdLEAST8", ()), + ("INT_LEAST32_MIN", ()), + ("UINT8_MIN", ()), + ("UINT8_MAX", ()), + ("SCNxLEAST16", ()), + ("PRIXFAST16", ()), + ("INT32_C", ()), + ("SCNiMAX", ()), + ("INT8_MIN", ()), + ("INT_FAST8_MAX", ()), + ("SCNi64", ()), + ("SCNdMAX", ()), + ("SCNxLEAST8", ()), + ("SCNxFAST32", ()), + ("PRIiFAST64", ()), + ("PRIdFAST64", ()), + ("PRIXPTR", ()), + ("INT_FAST8_MIN", ()), + ("INTPTR_MIN", ()), + ("SCNoMAX", ()), + ("SCNuMAX", ()), + ("PRIxPTR", ()), + ("PRIuFAST64", ()), + ("PRIoLEAST8", ()), + ("PRIi64", ()), + ("PRIXLEAST64", ()), + ("INT_FAST32_MAX", ()), + ("PRIdLEAST16", ()), + ("PRIdLEAST32", ()), + ("SCNdFAST16", ()), + ("PRIX64", ()), + ("PRIiFAST8", ()), + ("PRIo8", ()), + ("SCNiLEAST16", ()), + ("PRIdFAST8", ()), + ("PRIoLEAST32", ()), + ("PRIiLEAST8", ()), + ("SCNoFAST8", ()), + ("UINTMAX_MAX", ()), + ("SCNxLEAST32", ()), + ("INT8_C", ()), + ("PRIuLEAST16", ()), + ("SCNo64", ()), + ("PRId8", ()), + ("SCNu8", ()), + ("UINT_FAST16_MIN", ()), + ("UINT_LEAST8_MAX", ()), + ("SCNxFAST8", ()), + ("PRIuFAST8", ()), + ("SCNd32", ()), + ("PRIuFAST32", ()), + ("SCNx32", ()), + ("PRIx16", ()), + ("INT16_C", ()), + ("UINT_LEAST8_MIN", ()), + ("SCNuFAST8", ()), + ("UINTPTR_MAX", ()), + ("UINT_FAST8_MAX", ()), + ("PRIX16", ()), + ("PRIxFAST8", ()), + ("INT64_C", ()), + ("PRIiMAX", ()), + ("PRIoPTR", ()), + ("SCNd64", ()), + ("SCNiFAST8", ()), + ("INT_LEAST64_MAX", ()), + ("INT32_MAX", ()), + ("SCNdFAST32", ()), + ("SCNo8", ()), + ("INTMAX_MIN", ()), + ("SCNoFAST16", ()), + ("PRIxLEAST64", ()), + ("UINT_FAST32_MIN", ()), + ("SCNo16", ()), + ("PRIo64", ()), + ("SCNdLEAST32", ()), + ("SCNxFAST64", ()), + ("SCNi8", ()), + ("INT_FAST32_MIN", ()), + ("PRIu32", ()), + ("PRIX32", ()), + ("PRIdPTR", ()), + ("PRIoMAX", ()), + ("SCNoFAST32", ()), + ("PRIxLEAST16", ()), + ("INT_LEAST32_MAX", ()), + ("PRIoFAST32", ()), + ("PRId16", ()), + ("PRIxMAX", ()), + ("UINT_FAST8_MIN", ()), + ("UINT32_MAX", ()), + ("PRIdMAX", ()), + ("SCNuLEAST8", ()), + ("INT_LEAST8_MAX", ()), + ("SCNuFAST64", ()), + ("PRIuLEAST32", ()), + ("SCNxMAX", ()), + ("SCNiPTR", ()), + ("SCNuFAST16", ()), + ("UINTPTR_MIN", ()), + ("PRIXLEAST8", ()), + ("PRIoFAST64", ()), + ("INT8_MAX", ()), + ("PRIxFAST32", ()), + ("SCNdLEAST64", ()), + ("INT_FAST64_MIN", ()), + ("PRId64", ()), + ("INT64_MIN", ()), + ("UINT_FAST64_MAX", ()), + ("UINT64_MIN", ()), + ("UINT64_MAX", ()), + ("PRIx8", ()), + ("INT_LEAST64_MIN", ()), + ("INT32_MIN", ()), + ("PRIoFAST16", ()), + ("UINT32_MIN", ()), + ("SCNxFAST16", ()), + ("PRIXLEAST16", ()), + ("SCNoLEAST64", ()), + ("SCNuPTR", ()), + ("SCNxLEAST64", ()), + ("PRIu16", ()), + ("PRIX8", ()), + ("SCNx16", ()), + ("SCNi16", ()), + ("PRIxFAST16", ()), + ("SCNu16", ()), + ("PRIoLEAST64", ()), + ("PRIdLEAST8", ()), + ("SCNoLEAST32", ()), + ("SCNiFAST32", ()), + ("SCNdPTR", ()), + ("PRIo32", ()), + ("PRIu8", ()), + ("SCNd16", ()), + ("PRIxFAST64", ()), + ("PRIi32", ()), + ("UINT_FAST32_MAX", ()), + ], +} }; + +pub fn is_predefined_macros(mac: &str) -> bool { PREDEFINED_MACROS.contains(mac) } + diff --git a/src/c_langs_macros/c_specials.rs b/src/c_langs_macros/c_specials.rs new file mode 100644 index 000000000..307c3ca38 --- /dev/null +++ b/src/c_langs_macros/c_specials.rs @@ -0,0 +1,83 @@ +#[allow(clippy::unreadable_literal)] +static SPECIALS: phf::Set<&'static str> = +::phf::Set { map: ::phf::Map { + key: 7485420634051515786, + disps: &[ + (7, 45), + (0, 28), + (0, 56), + (0, 24), + (0, 0), + (0, 34), + (2, 19), + (10, 16), + (0, 1), + (2, 33), + (43, 24), + (0, 42), + ], + entries: &[ + ("explicit", ()), + ("inline", ()), + ("true", ()), + ("uint_fast64_t", ()), + ("int", ()), + ("char", ()), + ("uint_fast8_t", ()), + ("int32_t", ()), + ("uint_fast16_t", ()), + ("int64_t", ()), + ("charptr_t", ()), + ("bool", ()), + ("intptr_t", ()), + ("int_fast8_t", ()), + ("uint_least32_t", ()), + ("uint_fast32_t", ()), + ("size_t", ()), + ("NULL", ()), + ("uint_least8_t", ()), + ("false", ()), + ("static", ()), + ("uintptr_t", ()), + ("ssize_t", ()), + ("int_least64_t", ()), + ("max_align_t", ()), + ("uint32_t", ()), + ("float", ()), + ("double", ()), + ("uintmax_t", ()), + ("int_fast16_t", ()), + ("intmax_t", ()), + ("short", ()), + ("uint64_t", ()), + ("const", ()), + ("uint_least16_t", ()), + ("int_least32_t", ()), + ("uint_least64_t", ()), + ("char32_t", ()), + ("ptrdiff_t", ()), + ("nullptr", ()), + ("int_fast64_t", ()), + ("int_least8_t", ()), + ("restrict", ()), + ("wchar_t", ()), + ("uint16_t", ()), + ("char16_t", ()), + ("constexpr", ()), + ("namespace", ()), + ("char8_t", ()), + ("unsigned", ()), + ("int8_t", ()), + ("char64_t", ()), + ("int_least16_t", ()), + ("signed", ()), + ("int16_t", ()), + ("long", ()), + ("int_fast32_t", ()), + ("uint8_t", ()), + ("mutable", ()), + ], +} }; + +pub fn is_specials(mac: &str) -> bool { SPECIALS.contains(mac) } + From 0a13fec015fe15e7ccfb6cfb5c406c26d0830660 Mon Sep 17 00:00:00 2001 From: Luni-4 Date: Wed, 22 Sep 2021 17:04:06 +0200 Subject: [PATCH 3/7] Apply generated macros to the code --- src/c_langs_macros/mod.rs | 5 +++++ src/c_macro.rs | 5 +++-- src/lib.rs | 1 + src/preproc.rs | 5 ++--- 4 files changed, 11 insertions(+), 5 deletions(-) create mode 100644 src/c_langs_macros/mod.rs diff --git a/src/c_langs_macros/mod.rs b/src/c_langs_macros/mod.rs new file mode 100644 index 000000000..c2ae524c5 --- /dev/null +++ b/src/c_langs_macros/mod.rs @@ -0,0 +1,5 @@ +mod c_macros; +pub use c_macros::*; + +mod c_specials; +pub use c_specials::*; diff --git a/src/c_macro.rs b/src/c_macro.rs index 7005c119f..10714bd61 100644 --- a/src/c_macro.rs +++ b/src/c_macro.rs @@ -1,7 +1,8 @@ use std::collections::HashSet; +use crate::c_langs_macros::is_predefined_macros; + const DOLLARS: [u8; 2048] = [b'$'; 2048]; -include!(concat!(env!("OUT_DIR"), "/gen_c_macros.rs")); #[inline(always)] fn is_identifier_part(c: u8) -> bool { @@ -18,7 +19,7 @@ fn is_identifier_starter(c: u8) -> bool { #[inline(always)] fn is_macro(mac: &str, macros: &HashSet) -> bool { - macros.contains(mac) || PREDEFINED_MACROS.contains(mac) + macros.contains(mac) | is_predefined_macros(mac) } pub fn replace( diff --git a/src/lib.rs b/src/lib.rs index dc6bd7409..179ecd0e7 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -56,6 +56,7 @@ extern crate serde; #[macro_use] mod asttools; +mod c_langs_macros; mod c_macro; #[macro_use] mod macros; diff --git a/src/preproc.rs b/src/preproc.rs index 29cffe0c5..cd804d0da 100644 --- a/src/preproc.rs +++ b/src/preproc.rs @@ -4,6 +4,7 @@ use petgraph::{ use std::collections::{hash_map, HashMap, HashSet}; use std::path::{Path, PathBuf}; +use crate::c_langs_macros::is_specials; use crate::node::Node; use crate::langs::*; @@ -11,8 +12,6 @@ use crate::languages::language_preproc::*; use crate::tools::*; use crate::traits::*; -include!(concat!(env!("OUT_DIR"), "/gen_c_specials.rs")); - /// Preprocessor data of a `C/C++` file. #[derive(Debug, Default, Deserialize, Serialize)] pub struct PreprocFile { @@ -214,7 +213,7 @@ pub fn preprocess(parser: &PreprocParser, path: &Path, results: &mut PreprocResu if identifier.kind_id() == Preproc::Identifier { let r#macro = identifier.utf8_text(code).unwrap(); - if !SPECIALS.contains(r#macro) { + if !is_specials(r#macro) { file_result.macros.insert(r#macro.to_string()); } } From 6c9a0587b7dc5f1b574f6ae74732fa15df27ee4b Mon Sep 17 00:00:00 2001 From: Luni-4 Date: Wed, 22 Sep 2021 21:29:07 +0200 Subject: [PATCH 4/7] Format macros --- src/c_langs_macros/c_macros.rs | 546 ++++++++++++++++--------------- src/c_langs_macros/c_specials.rs | 164 +++++----- 2 files changed, 357 insertions(+), 353 deletions(-) diff --git a/src/c_langs_macros/c_macros.rs b/src/c_langs_macros/c_macros.rs index 6de67c0c9..3de955d87 100644 --- a/src/c_langs_macros/c_macros.rs +++ b/src/c_langs_macros/c_macros.rs @@ -1,274 +1,276 @@ #[allow(clippy::unreadable_literal)] -static PREDEFINED_MACROS: phf::Set<&'static str> = -::phf::Set { map: ::phf::Map { - key: 12913932095322966823, - disps: &[ - (0, 175), - (2, 124), - (0, 20), - (14, 199), - (0, 70), - (0, 0), - (0, 7), - (1, 3), - (0, 0), - (0, 5), - (1, 7), - (0, 110), - (0, 108), - (0, 85), - (0, 118), - (0, 0), - (0, 12), - (5, 65), - (5, 84), - (0, 0), - (0, 1), - (8, 103), - (4, 105), - (0, 31), - (0, 1), - (1, 95), - (0, 49), - (0, 9), - (1, 53), - (9, 130), - (0, 20), - (8, 163), - (0, 76), - (5, 215), - (4, 28), - (68, 86), - (9, 41), - (0, 0), - (6, 5), - (0, 136), - (9, 198), - (7, 48), - (0, 16), - (29, 79), - ], - entries: &[ - ("SCNuLEAST64", ()), - ("PRIiLEAST32", ()), - ("UINT16_MAX", ()), - ("UINT_FAST64_MIN", ()), - ("INT_LEAST8_MIN", ()), - ("PRIoFAST8", ()), - ("SCNd8", ()), - ("UINT16_C", ()), - ("PRIu64", ()), - ("SCNdFAST8", ()), - ("UINT_LEAST64_MIN", ()), - ("PRIx64", ()), - ("PRIx32", ()), - ("SCNiFAST64", ()), - ("PRIuFAST16", ()), - ("PRIXFAST64", ()), - ("SCNu32", ()), - ("SCNx64", ()), - ("INT16_MIN", ()), - ("SCNiLEAST32", ()), - ("PRIdFAST32", ()), - ("PRIiPTR", ()), - ("INT64_MAX", ()), - ("UINT_LEAST64_MAX", ()), - ("UINT32_C", ()), - ("INTMAX_MAX", ()), - ("UINT_LEAST16_MIN", ()), - ("SCNxPTR", ()), - ("SCNiLEAST8", ()), - ("PRIuLEAST64", ()), - ("PRIiLEAST64", ()), - ("SCNo32", ()), - ("SCNiLEAST64", ()), - ("PRIiLEAST16", ()), - ("PRIXFAST8", ()), - ("INT_FAST16_MIN", ()), - ("UINT_FAST16_MAX", ()), - ("PRIoLEAST16", ()), - ("UINT_LEAST32_MIN", ()), - ("SCNoPTR", ()), - ("PRIiFAST32", ()), - ("UINT64_C", ()), - ("PRIxLEAST8", ()), - ("PRId32", ()), - ("PRIiFAST16", ()), - ("INT_FAST16_MAX", ()), - ("PRIuMAX", ()), - ("UINT16_MIN", ()), - ("UINT_LEAST16_MAX", ()), - ("PRIXLEAST32", ()), - ("UINT8_C", ()), - ("PRIuPTR", ()), - ("UINTMAX_MIN", ()), - ("PRIXFAST32", ()), - ("UINT_LEAST32_MAX", ()), - ("SCNoLEAST8", ()), - ("SCNu64", ()), - ("SCNoLEAST16", ()), - ("INT_LEAST16_MIN", ()), - ("PRIuLEAST8", ()), - ("PRIi8", ()), - ("SCNuLEAST16", ()), - ("INT_FAST64_MAX", ()), - ("PRIdFAST16", ()), - ("PRIo16", ()), - ("SCNx8", ()), - ("INT_LEAST16_MAX", ()), - ("SCNoFAST64", ()), - ("PRIXMAX", ()), - ("SCNiFAST16", ()), - ("SCNdFAST64", ()), - ("PRIxLEAST32", ()), - ("INTPTR_MAX", ()), - ("INT16_MAX", ()), - ("PRIi16", ()), - ("SCNdLEAST16", ()), - ("PRIdLEAST64", ()), - ("SCNuLEAST32", ()), - ("SCNuFAST32", ()), - ("SCNi32", ()), - ("SCNdLEAST8", ()), - ("INT_LEAST32_MIN", ()), - ("UINT8_MIN", ()), - ("UINT8_MAX", ()), - ("SCNxLEAST16", ()), - ("PRIXFAST16", ()), - ("INT32_C", ()), - ("SCNiMAX", ()), - ("INT8_MIN", ()), - ("INT_FAST8_MAX", ()), - ("SCNi64", ()), - ("SCNdMAX", ()), - ("SCNxLEAST8", ()), - ("SCNxFAST32", ()), - ("PRIiFAST64", ()), - ("PRIdFAST64", ()), - ("PRIXPTR", ()), - ("INT_FAST8_MIN", ()), - ("INTPTR_MIN", ()), - ("SCNoMAX", ()), - ("SCNuMAX", ()), - ("PRIxPTR", ()), - ("PRIuFAST64", ()), - ("PRIoLEAST8", ()), - ("PRIi64", ()), - ("PRIXLEAST64", ()), - ("INT_FAST32_MAX", ()), - ("PRIdLEAST16", ()), - ("PRIdLEAST32", ()), - ("SCNdFAST16", ()), - ("PRIX64", ()), - ("PRIiFAST8", ()), - ("PRIo8", ()), - ("SCNiLEAST16", ()), - ("PRIdFAST8", ()), - ("PRIoLEAST32", ()), - ("PRIiLEAST8", ()), - ("SCNoFAST8", ()), - ("UINTMAX_MAX", ()), - ("SCNxLEAST32", ()), - ("INT8_C", ()), - ("PRIuLEAST16", ()), - ("SCNo64", ()), - ("PRId8", ()), - ("SCNu8", ()), - ("UINT_FAST16_MIN", ()), - ("UINT_LEAST8_MAX", ()), - ("SCNxFAST8", ()), - ("PRIuFAST8", ()), - ("SCNd32", ()), - ("PRIuFAST32", ()), - ("SCNx32", ()), - ("PRIx16", ()), - ("INT16_C", ()), - ("UINT_LEAST8_MIN", ()), - ("SCNuFAST8", ()), - ("UINTPTR_MAX", ()), - ("UINT_FAST8_MAX", ()), - ("PRIX16", ()), - ("PRIxFAST8", ()), - ("INT64_C", ()), - ("PRIiMAX", ()), - ("PRIoPTR", ()), - ("SCNd64", ()), - ("SCNiFAST8", ()), - ("INT_LEAST64_MAX", ()), - ("INT32_MAX", ()), - ("SCNdFAST32", ()), - ("SCNo8", ()), - ("INTMAX_MIN", ()), - ("SCNoFAST16", ()), - ("PRIxLEAST64", ()), - ("UINT_FAST32_MIN", ()), - ("SCNo16", ()), - ("PRIo64", ()), - ("SCNdLEAST32", ()), - ("SCNxFAST64", ()), - ("SCNi8", ()), - ("INT_FAST32_MIN", ()), - ("PRIu32", ()), - ("PRIX32", ()), - ("PRIdPTR", ()), - ("PRIoMAX", ()), - ("SCNoFAST32", ()), - ("PRIxLEAST16", ()), - ("INT_LEAST32_MAX", ()), - ("PRIoFAST32", ()), - ("PRId16", ()), - ("PRIxMAX", ()), - ("UINT_FAST8_MIN", ()), - ("UINT32_MAX", ()), - ("PRIdMAX", ()), - ("SCNuLEAST8", ()), - ("INT_LEAST8_MAX", ()), - ("SCNuFAST64", ()), - ("PRIuLEAST32", ()), - ("SCNxMAX", ()), - ("SCNiPTR", ()), - ("SCNuFAST16", ()), - ("UINTPTR_MIN", ()), - ("PRIXLEAST8", ()), - ("PRIoFAST64", ()), - ("INT8_MAX", ()), - ("PRIxFAST32", ()), - ("SCNdLEAST64", ()), - ("INT_FAST64_MIN", ()), - ("PRId64", ()), - ("INT64_MIN", ()), - ("UINT_FAST64_MAX", ()), - ("UINT64_MIN", ()), - ("UINT64_MAX", ()), - ("PRIx8", ()), - ("INT_LEAST64_MIN", ()), - ("INT32_MIN", ()), - ("PRIoFAST16", ()), - ("UINT32_MIN", ()), - ("SCNxFAST16", ()), - ("PRIXLEAST16", ()), - ("SCNoLEAST64", ()), - ("SCNuPTR", ()), - ("SCNxLEAST64", ()), - ("PRIu16", ()), - ("PRIX8", ()), - ("SCNx16", ()), - ("SCNi16", ()), - ("PRIxFAST16", ()), - ("SCNu16", ()), - ("PRIoLEAST64", ()), - ("PRIdLEAST8", ()), - ("SCNoLEAST32", ()), - ("SCNiFAST32", ()), - ("SCNdPTR", ()), - ("PRIo32", ()), - ("PRIu8", ()), - ("SCNd16", ()), - ("PRIxFAST64", ()), - ("PRIi32", ()), - ("UINT_FAST32_MAX", ()), - ], -} }; - -pub fn is_predefined_macros(mac: &str) -> bool { PREDEFINED_MACROS.contains(mac) } +static PREDEFINED_MACROS: phf::Set<&'static str> = ::phf::Set { + map: ::phf::Map { + key: 12913932095322966823, + disps: &[ + (0, 175), + (2, 124), + (0, 20), + (14, 199), + (0, 70), + (0, 0), + (0, 7), + (1, 3), + (0, 0), + (0, 5), + (1, 7), + (0, 110), + (0, 108), + (0, 85), + (0, 118), + (0, 0), + (0, 12), + (5, 65), + (5, 84), + (0, 0), + (0, 1), + (8, 103), + (4, 105), + (0, 31), + (0, 1), + (1, 95), + (0, 49), + (0, 9), + (1, 53), + (9, 130), + (0, 20), + (8, 163), + (0, 76), + (5, 215), + (4, 28), + (68, 86), + (9, 41), + (0, 0), + (6, 5), + (0, 136), + (9, 198), + (7, 48), + (0, 16), + (29, 79), + ], + entries: &[ + ("SCNuLEAST64", ()), + ("PRIiLEAST32", ()), + ("UINT16_MAX", ()), + ("UINT_FAST64_MIN", ()), + ("INT_LEAST8_MIN", ()), + ("PRIoFAST8", ()), + ("SCNd8", ()), + ("UINT16_C", ()), + ("PRIu64", ()), + ("SCNdFAST8", ()), + ("UINT_LEAST64_MIN", ()), + ("PRIx64", ()), + ("PRIx32", ()), + ("SCNiFAST64", ()), + ("PRIuFAST16", ()), + ("PRIXFAST64", ()), + ("SCNu32", ()), + ("SCNx64", ()), + ("INT16_MIN", ()), + ("SCNiLEAST32", ()), + ("PRIdFAST32", ()), + ("PRIiPTR", ()), + ("INT64_MAX", ()), + ("UINT_LEAST64_MAX", ()), + ("UINT32_C", ()), + ("INTMAX_MAX", ()), + ("UINT_LEAST16_MIN", ()), + ("SCNxPTR", ()), + ("SCNiLEAST8", ()), + ("PRIuLEAST64", ()), + ("PRIiLEAST64", ()), + ("SCNo32", ()), + ("SCNiLEAST64", ()), + ("PRIiLEAST16", ()), + ("PRIXFAST8", ()), + ("INT_FAST16_MIN", ()), + ("UINT_FAST16_MAX", ()), + ("PRIoLEAST16", ()), + ("UINT_LEAST32_MIN", ()), + ("SCNoPTR", ()), + ("PRIiFAST32", ()), + ("UINT64_C", ()), + ("PRIxLEAST8", ()), + ("PRId32", ()), + ("PRIiFAST16", ()), + ("INT_FAST16_MAX", ()), + ("PRIuMAX", ()), + ("UINT16_MIN", ()), + ("UINT_LEAST16_MAX", ()), + ("PRIXLEAST32", ()), + ("UINT8_C", ()), + ("PRIuPTR", ()), + ("UINTMAX_MIN", ()), + ("PRIXFAST32", ()), + ("UINT_LEAST32_MAX", ()), + ("SCNoLEAST8", ()), + ("SCNu64", ()), + ("SCNoLEAST16", ()), + ("INT_LEAST16_MIN", ()), + ("PRIuLEAST8", ()), + ("PRIi8", ()), + ("SCNuLEAST16", ()), + ("INT_FAST64_MAX", ()), + ("PRIdFAST16", ()), + ("PRIo16", ()), + ("SCNx8", ()), + ("INT_LEAST16_MAX", ()), + ("SCNoFAST64", ()), + ("PRIXMAX", ()), + ("SCNiFAST16", ()), + ("SCNdFAST64", ()), + ("PRIxLEAST32", ()), + ("INTPTR_MAX", ()), + ("INT16_MAX", ()), + ("PRIi16", ()), + ("SCNdLEAST16", ()), + ("PRIdLEAST64", ()), + ("SCNuLEAST32", ()), + ("SCNuFAST32", ()), + ("SCNi32", ()), + ("SCNdLEAST8", ()), + ("INT_LEAST32_MIN", ()), + ("UINT8_MIN", ()), + ("UINT8_MAX", ()), + ("SCNxLEAST16", ()), + ("PRIXFAST16", ()), + ("INT32_C", ()), + ("SCNiMAX", ()), + ("INT8_MIN", ()), + ("INT_FAST8_MAX", ()), + ("SCNi64", ()), + ("SCNdMAX", ()), + ("SCNxLEAST8", ()), + ("SCNxFAST32", ()), + ("PRIiFAST64", ()), + ("PRIdFAST64", ()), + ("PRIXPTR", ()), + ("INT_FAST8_MIN", ()), + ("INTPTR_MIN", ()), + ("SCNoMAX", ()), + ("SCNuMAX", ()), + ("PRIxPTR", ()), + ("PRIuFAST64", ()), + ("PRIoLEAST8", ()), + ("PRIi64", ()), + ("PRIXLEAST64", ()), + ("INT_FAST32_MAX", ()), + ("PRIdLEAST16", ()), + ("PRIdLEAST32", ()), + ("SCNdFAST16", ()), + ("PRIX64", ()), + ("PRIiFAST8", ()), + ("PRIo8", ()), + ("SCNiLEAST16", ()), + ("PRIdFAST8", ()), + ("PRIoLEAST32", ()), + ("PRIiLEAST8", ()), + ("SCNoFAST8", ()), + ("UINTMAX_MAX", ()), + ("SCNxLEAST32", ()), + ("INT8_C", ()), + ("PRIuLEAST16", ()), + ("SCNo64", ()), + ("PRId8", ()), + ("SCNu8", ()), + ("UINT_FAST16_MIN", ()), + ("UINT_LEAST8_MAX", ()), + ("SCNxFAST8", ()), + ("PRIuFAST8", ()), + ("SCNd32", ()), + ("PRIuFAST32", ()), + ("SCNx32", ()), + ("PRIx16", ()), + ("INT16_C", ()), + ("UINT_LEAST8_MIN", ()), + ("SCNuFAST8", ()), + ("UINTPTR_MAX", ()), + ("UINT_FAST8_MAX", ()), + ("PRIX16", ()), + ("PRIxFAST8", ()), + ("INT64_C", ()), + ("PRIiMAX", ()), + ("PRIoPTR", ()), + ("SCNd64", ()), + ("SCNiFAST8", ()), + ("INT_LEAST64_MAX", ()), + ("INT32_MAX", ()), + ("SCNdFAST32", ()), + ("SCNo8", ()), + ("INTMAX_MIN", ()), + ("SCNoFAST16", ()), + ("PRIxLEAST64", ()), + ("UINT_FAST32_MIN", ()), + ("SCNo16", ()), + ("PRIo64", ()), + ("SCNdLEAST32", ()), + ("SCNxFAST64", ()), + ("SCNi8", ()), + ("INT_FAST32_MIN", ()), + ("PRIu32", ()), + ("PRIX32", ()), + ("PRIdPTR", ()), + ("PRIoMAX", ()), + ("SCNoFAST32", ()), + ("PRIxLEAST16", ()), + ("INT_LEAST32_MAX", ()), + ("PRIoFAST32", ()), + ("PRId16", ()), + ("PRIxMAX", ()), + ("UINT_FAST8_MIN", ()), + ("UINT32_MAX", ()), + ("PRIdMAX", ()), + ("SCNuLEAST8", ()), + ("INT_LEAST8_MAX", ()), + ("SCNuFAST64", ()), + ("PRIuLEAST32", ()), + ("SCNxMAX", ()), + ("SCNiPTR", ()), + ("SCNuFAST16", ()), + ("UINTPTR_MIN", ()), + ("PRIXLEAST8", ()), + ("PRIoFAST64", ()), + ("INT8_MAX", ()), + ("PRIxFAST32", ()), + ("SCNdLEAST64", ()), + ("INT_FAST64_MIN", ()), + ("PRId64", ()), + ("INT64_MIN", ()), + ("UINT_FAST64_MAX", ()), + ("UINT64_MIN", ()), + ("UINT64_MAX", ()), + ("PRIx8", ()), + ("INT_LEAST64_MIN", ()), + ("INT32_MIN", ()), + ("PRIoFAST16", ()), + ("UINT32_MIN", ()), + ("SCNxFAST16", ()), + ("PRIXLEAST16", ()), + ("SCNoLEAST64", ()), + ("SCNuPTR", ()), + ("SCNxLEAST64", ()), + ("PRIu16", ()), + ("PRIX8", ()), + ("SCNx16", ()), + ("SCNi16", ()), + ("PRIxFAST16", ()), + ("SCNu16", ()), + ("PRIoLEAST64", ()), + ("PRIdLEAST8", ()), + ("SCNoLEAST32", ()), + ("SCNiFAST32", ()), + ("SCNdPTR", ()), + ("PRIo32", ()), + ("PRIu8", ()), + ("SCNd16", ()), + ("PRIxFAST64", ()), + ("PRIi32", ()), + ("UINT_FAST32_MAX", ()), + ], + }, +}; +pub fn is_predefined_macros(mac: &str) -> bool { + PREDEFINED_MACROS.contains(mac) +} diff --git a/src/c_langs_macros/c_specials.rs b/src/c_langs_macros/c_specials.rs index 307c3ca38..da41b51c4 100644 --- a/src/c_langs_macros/c_specials.rs +++ b/src/c_langs_macros/c_specials.rs @@ -1,83 +1,85 @@ #[allow(clippy::unreadable_literal)] -static SPECIALS: phf::Set<&'static str> = -::phf::Set { map: ::phf::Map { - key: 7485420634051515786, - disps: &[ - (7, 45), - (0, 28), - (0, 56), - (0, 24), - (0, 0), - (0, 34), - (2, 19), - (10, 16), - (0, 1), - (2, 33), - (43, 24), - (0, 42), - ], - entries: &[ - ("explicit", ()), - ("inline", ()), - ("true", ()), - ("uint_fast64_t", ()), - ("int", ()), - ("char", ()), - ("uint_fast8_t", ()), - ("int32_t", ()), - ("uint_fast16_t", ()), - ("int64_t", ()), - ("charptr_t", ()), - ("bool", ()), - ("intptr_t", ()), - ("int_fast8_t", ()), - ("uint_least32_t", ()), - ("uint_fast32_t", ()), - ("size_t", ()), - ("NULL", ()), - ("uint_least8_t", ()), - ("false", ()), - ("static", ()), - ("uintptr_t", ()), - ("ssize_t", ()), - ("int_least64_t", ()), - ("max_align_t", ()), - ("uint32_t", ()), - ("float", ()), - ("double", ()), - ("uintmax_t", ()), - ("int_fast16_t", ()), - ("intmax_t", ()), - ("short", ()), - ("uint64_t", ()), - ("const", ()), - ("uint_least16_t", ()), - ("int_least32_t", ()), - ("uint_least64_t", ()), - ("char32_t", ()), - ("ptrdiff_t", ()), - ("nullptr", ()), - ("int_fast64_t", ()), - ("int_least8_t", ()), - ("restrict", ()), - ("wchar_t", ()), - ("uint16_t", ()), - ("char16_t", ()), - ("constexpr", ()), - ("namespace", ()), - ("char8_t", ()), - ("unsigned", ()), - ("int8_t", ()), - ("char64_t", ()), - ("int_least16_t", ()), - ("signed", ()), - ("int16_t", ()), - ("long", ()), - ("int_fast32_t", ()), - ("uint8_t", ()), - ("mutable", ()), - ], -} }; - -pub fn is_specials(mac: &str) -> bool { SPECIALS.contains(mac) } +static SPECIALS: phf::Set<&'static str> = ::phf::Set { + map: ::phf::Map { + key: 7485420634051515786, + disps: &[ + (7, 45), + (0, 28), + (0, 56), + (0, 24), + (0, 0), + (0, 34), + (2, 19), + (10, 16), + (0, 1), + (2, 33), + (43, 24), + (0, 42), + ], + entries: &[ + ("explicit", ()), + ("inline", ()), + ("true", ()), + ("uint_fast64_t", ()), + ("int", ()), + ("char", ()), + ("uint_fast8_t", ()), + ("int32_t", ()), + ("uint_fast16_t", ()), + ("int64_t", ()), + ("charptr_t", ()), + ("bool", ()), + ("intptr_t", ()), + ("int_fast8_t", ()), + ("uint_least32_t", ()), + ("uint_fast32_t", ()), + ("size_t", ()), + ("NULL", ()), + ("uint_least8_t", ()), + ("false", ()), + ("static", ()), + ("uintptr_t", ()), + ("ssize_t", ()), + ("int_least64_t", ()), + ("max_align_t", ()), + ("uint32_t", ()), + ("float", ()), + ("double", ()), + ("uintmax_t", ()), + ("int_fast16_t", ()), + ("intmax_t", ()), + ("short", ()), + ("uint64_t", ()), + ("const", ()), + ("uint_least16_t", ()), + ("int_least32_t", ()), + ("uint_least64_t", ()), + ("char32_t", ()), + ("ptrdiff_t", ()), + ("nullptr", ()), + ("int_fast64_t", ()), + ("int_least8_t", ()), + ("restrict", ()), + ("wchar_t", ()), + ("uint16_t", ()), + ("char16_t", ()), + ("constexpr", ()), + ("namespace", ()), + ("char8_t", ()), + ("unsigned", ()), + ("int8_t", ()), + ("char64_t", ()), + ("int_least16_t", ()), + ("signed", ()), + ("int16_t", ()), + ("long", ()), + ("int_fast32_t", ()), + ("uint8_t", ()), + ("mutable", ()), + ], + }, +}; +pub fn is_specials(mac: &str) -> bool { + SPECIALS.contains(mac) +} From 1eef3cd74ddc9439c361551eb96418b18f24cb57 Mon Sep 17 00:00:00 2001 From: Luni-4 Date: Fri, 24 Sep 2021 21:33:21 +0200 Subject: [PATCH 5/7] Replace c_macros phf_sets with a const array --- enums/Cargo.toml | 1 - enums/src/rust.rs | 53 ++++++++++++++++++++----------------- enums/templates/c_macros.rs | 11 ++++++++ 3 files changed, 40 insertions(+), 25 deletions(-) create mode 100644 enums/templates/c_macros.rs diff --git a/enums/Cargo.toml b/enums/Cargo.toml index b534f8afd..d97032d82 100644 --- a/enums/Cargo.toml +++ b/enums/Cargo.toml @@ -8,7 +8,6 @@ edition = "2018" enum-iterator = "^0.7" clap = "^2.33" askama = "^0.10" -phf_codegen = "^0.10" tree-sitter = "0.19.3" tree-sitter-java = "0.19.0" diff --git a/enums/src/rust.rs b/enums/src/rust.rs index ceeaf86d0..ad13f6686 100644 --- a/enums/src/rust.rs +++ b/enums/src/rust.rs @@ -1,10 +1,8 @@ -extern crate phf_codegen; - use askama::Template; use enum_iterator::IntoEnumIterator; use std::env; use std::fs::File; -use std::io::{BufWriter, Read, Write}; +use std::io::{Read, Write}; use std::path::{Path, PathBuf}; use crate::common::*; @@ -39,40 +37,47 @@ pub fn generate_rust(output: &str, file_template: &str) -> std::io::Result<()> { Ok(()) } +#[derive(Template)] +#[template(path = "c_macros.rs", escape = "none")] +struct CMacrosTemplate { + u_name: String, + l_name: String, + names: Vec, +} + pub fn generate_macros(output: &str) -> std::io::Result<()> { create_macros_file(output, "c_macros", "PREDEFINED_MACROS")?; create_macros_file(output, "c_specials", "SPECIALS") } -fn create_macros_file(output: &str, data_name: &str, set_name: &str) -> std::io::Result<()> { - let mut set = phf_codegen::Set::new(); - let mut file = File::open(PathBuf::from(format!( +fn create_macros_file(output: &str, filename: &str, u_name: &str) -> std::io::Result<()> { + let mut macro_file = File::open(PathBuf::from(format!( "{}/{}/{}.txt", &env::var("CARGO_MANIFEST_DIR").unwrap(), MACROS_DEFINITION_DIR, - data_name + filename )))?; let mut data = Vec::new(); - file.read_to_end(&mut data)?; + macro_file.read_to_end(&mut data)?; + + let mut names = Vec::new(); 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); + names.push(tok.to_owned()); } } - let path = Path::new(output).join(format!("{}.rs", data_name)); - let mut file = BufWriter::new(File::create(&path)?); - writeln!(&mut file, "#[allow(clippy::unreadable_literal)]").unwrap(); - writeln!( - &mut file, - "static {}: phf::Set<&'static str> =\n{};\n", - set_name, - set.build() - )?; - writeln!( - &mut file, - "pub fn is_{}(mac: &str) -> bool {{ {}.contains(mac) }}\n", - set_name.to_lowercase(), - set_name, - ) + let l_name = u_name.to_lowercase(); + + let path = Path::new(output).join(format!("{}.rs", filename)); + + let mut file = File::create(&path)?; + + let args = CMacrosTemplate { + u_name: u_name.to_owned(), + l_name, + names, + }; + + file.write_all(args.render().unwrap().as_bytes()) } diff --git a/enums/templates/c_macros.rs b/enums/templates/c_macros.rs new file mode 100644 index 000000000..25b419e79 --- /dev/null +++ b/enums/templates/c_macros.rs @@ -0,0 +1,11 @@ +// Code generated; DO NOT EDIT. + +const {{ u_name }}: &[&str] = &[ + {% for name in names -%} + "{{ name }}", + {% endfor %} +]; + +pub fn is_{{ l_name }}(mac: &str) -> bool { + {{ u_name }}.contains(&mac) + } From 0a6e3f31b870268caedaca5655046cf307ded099 Mon Sep 17 00:00:00 2001 From: Luni-4 Date: Fri, 24 Sep 2021 21:47:37 +0200 Subject: [PATCH 6/7] Regenerate c_macros --- src/c_langs_macros/c_macros.rs | 496 ++++++++++++++----------------- src/c_langs_macros/c_specials.rs | 146 ++++----- 2 files changed, 287 insertions(+), 355 deletions(-) diff --git a/src/c_langs_macros/c_macros.rs b/src/c_langs_macros/c_macros.rs index 3de955d87..01aedcf27 100644 --- a/src/c_langs_macros/c_macros.rs +++ b/src/c_langs_macros/c_macros.rs @@ -1,276 +1,226 @@ -#[allow(clippy::unreadable_literal)] -static PREDEFINED_MACROS: phf::Set<&'static str> = ::phf::Set { - map: ::phf::Map { - key: 12913932095322966823, - disps: &[ - (0, 175), - (2, 124), - (0, 20), - (14, 199), - (0, 70), - (0, 0), - (0, 7), - (1, 3), - (0, 0), - (0, 5), - (1, 7), - (0, 110), - (0, 108), - (0, 85), - (0, 118), - (0, 0), - (0, 12), - (5, 65), - (5, 84), - (0, 0), - (0, 1), - (8, 103), - (4, 105), - (0, 31), - (0, 1), - (1, 95), - (0, 49), - (0, 9), - (1, 53), - (9, 130), - (0, 20), - (8, 163), - (0, 76), - (5, 215), - (4, 28), - (68, 86), - (9, 41), - (0, 0), - (6, 5), - (0, 136), - (9, 198), - (7, 48), - (0, 16), - (29, 79), - ], - entries: &[ - ("SCNuLEAST64", ()), - ("PRIiLEAST32", ()), - ("UINT16_MAX", ()), - ("UINT_FAST64_MIN", ()), - ("INT_LEAST8_MIN", ()), - ("PRIoFAST8", ()), - ("SCNd8", ()), - ("UINT16_C", ()), - ("PRIu64", ()), - ("SCNdFAST8", ()), - ("UINT_LEAST64_MIN", ()), - ("PRIx64", ()), - ("PRIx32", ()), - ("SCNiFAST64", ()), - ("PRIuFAST16", ()), - ("PRIXFAST64", ()), - ("SCNu32", ()), - ("SCNx64", ()), - ("INT16_MIN", ()), - ("SCNiLEAST32", ()), - ("PRIdFAST32", ()), - ("PRIiPTR", ()), - ("INT64_MAX", ()), - ("UINT_LEAST64_MAX", ()), - ("UINT32_C", ()), - ("INTMAX_MAX", ()), - ("UINT_LEAST16_MIN", ()), - ("SCNxPTR", ()), - ("SCNiLEAST8", ()), - ("PRIuLEAST64", ()), - ("PRIiLEAST64", ()), - ("SCNo32", ()), - ("SCNiLEAST64", ()), - ("PRIiLEAST16", ()), - ("PRIXFAST8", ()), - ("INT_FAST16_MIN", ()), - ("UINT_FAST16_MAX", ()), - ("PRIoLEAST16", ()), - ("UINT_LEAST32_MIN", ()), - ("SCNoPTR", ()), - ("PRIiFAST32", ()), - ("UINT64_C", ()), - ("PRIxLEAST8", ()), - ("PRId32", ()), - ("PRIiFAST16", ()), - ("INT_FAST16_MAX", ()), - ("PRIuMAX", ()), - ("UINT16_MIN", ()), - ("UINT_LEAST16_MAX", ()), - ("PRIXLEAST32", ()), - ("UINT8_C", ()), - ("PRIuPTR", ()), - ("UINTMAX_MIN", ()), - ("PRIXFAST32", ()), - ("UINT_LEAST32_MAX", ()), - ("SCNoLEAST8", ()), - ("SCNu64", ()), - ("SCNoLEAST16", ()), - ("INT_LEAST16_MIN", ()), - ("PRIuLEAST8", ()), - ("PRIi8", ()), - ("SCNuLEAST16", ()), - ("INT_FAST64_MAX", ()), - ("PRIdFAST16", ()), - ("PRIo16", ()), - ("SCNx8", ()), - ("INT_LEAST16_MAX", ()), - ("SCNoFAST64", ()), - ("PRIXMAX", ()), - ("SCNiFAST16", ()), - ("SCNdFAST64", ()), - ("PRIxLEAST32", ()), - ("INTPTR_MAX", ()), - ("INT16_MAX", ()), - ("PRIi16", ()), - ("SCNdLEAST16", ()), - ("PRIdLEAST64", ()), - ("SCNuLEAST32", ()), - ("SCNuFAST32", ()), - ("SCNi32", ()), - ("SCNdLEAST8", ()), - ("INT_LEAST32_MIN", ()), - ("UINT8_MIN", ()), - ("UINT8_MAX", ()), - ("SCNxLEAST16", ()), - ("PRIXFAST16", ()), - ("INT32_C", ()), - ("SCNiMAX", ()), - ("INT8_MIN", ()), - ("INT_FAST8_MAX", ()), - ("SCNi64", ()), - ("SCNdMAX", ()), - ("SCNxLEAST8", ()), - ("SCNxFAST32", ()), - ("PRIiFAST64", ()), - ("PRIdFAST64", ()), - ("PRIXPTR", ()), - ("INT_FAST8_MIN", ()), - ("INTPTR_MIN", ()), - ("SCNoMAX", ()), - ("SCNuMAX", ()), - ("PRIxPTR", ()), - ("PRIuFAST64", ()), - ("PRIoLEAST8", ()), - ("PRIi64", ()), - ("PRIXLEAST64", ()), - ("INT_FAST32_MAX", ()), - ("PRIdLEAST16", ()), - ("PRIdLEAST32", ()), - ("SCNdFAST16", ()), - ("PRIX64", ()), - ("PRIiFAST8", ()), - ("PRIo8", ()), - ("SCNiLEAST16", ()), - ("PRIdFAST8", ()), - ("PRIoLEAST32", ()), - ("PRIiLEAST8", ()), - ("SCNoFAST8", ()), - ("UINTMAX_MAX", ()), - ("SCNxLEAST32", ()), - ("INT8_C", ()), - ("PRIuLEAST16", ()), - ("SCNo64", ()), - ("PRId8", ()), - ("SCNu8", ()), - ("UINT_FAST16_MIN", ()), - ("UINT_LEAST8_MAX", ()), - ("SCNxFAST8", ()), - ("PRIuFAST8", ()), - ("SCNd32", ()), - ("PRIuFAST32", ()), - ("SCNx32", ()), - ("PRIx16", ()), - ("INT16_C", ()), - ("UINT_LEAST8_MIN", ()), - ("SCNuFAST8", ()), - ("UINTPTR_MAX", ()), - ("UINT_FAST8_MAX", ()), - ("PRIX16", ()), - ("PRIxFAST8", ()), - ("INT64_C", ()), - ("PRIiMAX", ()), - ("PRIoPTR", ()), - ("SCNd64", ()), - ("SCNiFAST8", ()), - ("INT_LEAST64_MAX", ()), - ("INT32_MAX", ()), - ("SCNdFAST32", ()), - ("SCNo8", ()), - ("INTMAX_MIN", ()), - ("SCNoFAST16", ()), - ("PRIxLEAST64", ()), - ("UINT_FAST32_MIN", ()), - ("SCNo16", ()), - ("PRIo64", ()), - ("SCNdLEAST32", ()), - ("SCNxFAST64", ()), - ("SCNi8", ()), - ("INT_FAST32_MIN", ()), - ("PRIu32", ()), - ("PRIX32", ()), - ("PRIdPTR", ()), - ("PRIoMAX", ()), - ("SCNoFAST32", ()), - ("PRIxLEAST16", ()), - ("INT_LEAST32_MAX", ()), - ("PRIoFAST32", ()), - ("PRId16", ()), - ("PRIxMAX", ()), - ("UINT_FAST8_MIN", ()), - ("UINT32_MAX", ()), - ("PRIdMAX", ()), - ("SCNuLEAST8", ()), - ("INT_LEAST8_MAX", ()), - ("SCNuFAST64", ()), - ("PRIuLEAST32", ()), - ("SCNxMAX", ()), - ("SCNiPTR", ()), - ("SCNuFAST16", ()), - ("UINTPTR_MIN", ()), - ("PRIXLEAST8", ()), - ("PRIoFAST64", ()), - ("INT8_MAX", ()), - ("PRIxFAST32", ()), - ("SCNdLEAST64", ()), - ("INT_FAST64_MIN", ()), - ("PRId64", ()), - ("INT64_MIN", ()), - ("UINT_FAST64_MAX", ()), - ("UINT64_MIN", ()), - ("UINT64_MAX", ()), - ("PRIx8", ()), - ("INT_LEAST64_MIN", ()), - ("INT32_MIN", ()), - ("PRIoFAST16", ()), - ("UINT32_MIN", ()), - ("SCNxFAST16", ()), - ("PRIXLEAST16", ()), - ("SCNoLEAST64", ()), - ("SCNuPTR", ()), - ("SCNxLEAST64", ()), - ("PRIu16", ()), - ("PRIX8", ()), - ("SCNx16", ()), - ("SCNi16", ()), - ("PRIxFAST16", ()), - ("SCNu16", ()), - ("PRIoLEAST64", ()), - ("PRIdLEAST8", ()), - ("SCNoLEAST32", ()), - ("SCNiFAST32", ()), - ("SCNdPTR", ()), - ("PRIo32", ()), - ("PRIu8", ()), - ("SCNd16", ()), - ("PRIxFAST64", ()), - ("PRIi32", ()), - ("UINT_FAST32_MAX", ()), - ], - }, -}; +// Code generated; DO NOT EDIT. + +const PREDEFINED_MACROS: &[&str] = &[ + "INT16_C", + "INT16_MAX", + "INT16_MIN", + "INT32_C", + "INT32_MAX", + "INT32_MIN", + "INT64_C", + "INT64_MAX", + "INT64_MIN", + "INT8_C", + "INT8_MAX", + "INT8_MIN", + "INTMAX_MAX", + "INTMAX_MIN", + "INTPTR_MAX", + "INTPTR_MIN", + "INT_FAST16_MAX", + "INT_FAST16_MIN", + "INT_FAST32_MAX", + "INT_FAST32_MIN", + "INT_FAST64_MAX", + "INT_FAST64_MIN", + "INT_FAST8_MAX", + "INT_FAST8_MIN", + "INT_LEAST16_MAX", + "INT_LEAST16_MIN", + "INT_LEAST32_MAX", + "INT_LEAST32_MIN", + "INT_LEAST64_MAX", + "INT_LEAST64_MIN", + "INT_LEAST8_MAX", + "INT_LEAST8_MIN", + "PRIX16", + "PRIX32", + "PRIX64", + "PRIX8", + "PRIXFAST16", + "PRIXFAST32", + "PRIXFAST64", + "PRIXFAST8", + "PRIXLEAST16", + "PRIXLEAST32", + "PRIXLEAST64", + "PRIXLEAST8", + "PRIXMAX", + "PRIXPTR", + "PRId16", + "PRId32", + "PRId64", + "PRId8", + "PRIdFAST16", + "PRIdFAST32", + "PRIdFAST64", + "PRIdFAST8", + "PRIdLEAST16", + "PRIdLEAST32", + "PRIdLEAST64", + "PRIdLEAST8", + "PRIdMAX", + "PRIdPTR", + "PRIi16", + "PRIi32", + "PRIi64", + "PRIi8", + "PRIiFAST16", + "PRIiFAST32", + "PRIiFAST64", + "PRIiFAST8", + "PRIiLEAST16", + "PRIiLEAST32", + "PRIiLEAST64", + "PRIiLEAST8", + "PRIiMAX", + "PRIiPTR", + "PRIo16", + "PRIo32", + "PRIo64", + "PRIo8", + "PRIoFAST16", + "PRIoFAST32", + "PRIoFAST64", + "PRIoFAST8", + "PRIoLEAST16", + "PRIoLEAST32", + "PRIoLEAST64", + "PRIoLEAST8", + "PRIoMAX", + "PRIoPTR", + "PRIu16", + "PRIu32", + "PRIu64", + "PRIu8", + "PRIuFAST16", + "PRIuFAST32", + "PRIuFAST64", + "PRIuFAST8", + "PRIuLEAST16", + "PRIuLEAST32", + "PRIuLEAST64", + "PRIuLEAST8", + "PRIuMAX", + "PRIuPTR", + "PRIx16", + "PRIx32", + "PRIx64", + "PRIx8", + "PRIxFAST16", + "PRIxFAST32", + "PRIxFAST64", + "PRIxFAST8", + "PRIxLEAST16", + "PRIxLEAST32", + "PRIxLEAST64", + "PRIxLEAST8", + "PRIxMAX", + "PRIxPTR", + "SCNd16", + "SCNd32", + "SCNd64", + "SCNd8", + "SCNdFAST16", + "SCNdFAST32", + "SCNdFAST64", + "SCNdFAST8", + "SCNdLEAST16", + "SCNdLEAST32", + "SCNdLEAST64", + "SCNdLEAST8", + "SCNdMAX", + "SCNdPTR", + "SCNi16", + "SCNi32", + "SCNi64", + "SCNi8", + "SCNiFAST16", + "SCNiFAST32", + "SCNiFAST64", + "SCNiFAST8", + "SCNiLEAST16", + "SCNiLEAST32", + "SCNiLEAST64", + "SCNiLEAST8", + "SCNiMAX", + "SCNiPTR", + "SCNo16", + "SCNo32", + "SCNo64", + "SCNo8", + "SCNoFAST16", + "SCNoFAST32", + "SCNoFAST64", + "SCNoFAST8", + "SCNoLEAST16", + "SCNoLEAST32", + "SCNoLEAST64", + "SCNoLEAST8", + "SCNoMAX", + "SCNoPTR", + "SCNu16", + "SCNu32", + "SCNu64", + "SCNu8", + "SCNuFAST16", + "SCNuFAST32", + "SCNuFAST64", + "SCNuFAST8", + "SCNuLEAST16", + "SCNuLEAST32", + "SCNuLEAST64", + "SCNuLEAST8", + "SCNuMAX", + "SCNuPTR", + "SCNx16", + "SCNx32", + "SCNx64", + "SCNx8", + "SCNxFAST16", + "SCNxFAST32", + "SCNxFAST64", + "SCNxFAST8", + "SCNxLEAST16", + "SCNxLEAST32", + "SCNxLEAST64", + "SCNxLEAST8", + "SCNxMAX", + "SCNxPTR", + "UINT16_C", + "UINT16_MAX", + "UINT16_MIN", + "UINT32_C", + "UINT32_MAX", + "UINT32_MIN", + "UINT64_C", + "UINT64_MAX", + "UINT64_MIN", + "UINT8_C", + "UINT8_MAX", + "UINT8_MIN", + "UINTMAX_MAX", + "UINTMAX_MIN", + "UINTPTR_MAX", + "UINTPTR_MIN", + "UINT_FAST16_MAX", + "UINT_FAST16_MIN", + "UINT_FAST32_MAX", + "UINT_FAST32_MIN", + "UINT_FAST64_MAX", + "UINT_FAST64_MIN", + "UINT_FAST8_MAX", + "UINT_FAST8_MIN", + "UINT_LEAST16_MAX", + "UINT_LEAST16_MIN", + "UINT_LEAST32_MAX", + "UINT_LEAST32_MIN", + "UINT_LEAST64_MAX", + "UINT_LEAST64_MIN", + "UINT_LEAST8_MAX", + "UINT_LEAST8_MIN", +]; pub fn is_predefined_macros(mac: &str) -> bool { - PREDEFINED_MACROS.contains(mac) + PREDEFINED_MACROS.contains(&mac) } diff --git a/src/c_langs_macros/c_specials.rs b/src/c_langs_macros/c_specials.rs index da41b51c4..3bc29317a 100644 --- a/src/c_langs_macros/c_specials.rs +++ b/src/c_langs_macros/c_specials.rs @@ -1,85 +1,67 @@ -#[allow(clippy::unreadable_literal)] -static SPECIALS: phf::Set<&'static str> = ::phf::Set { - map: ::phf::Map { - key: 7485420634051515786, - disps: &[ - (7, 45), - (0, 28), - (0, 56), - (0, 24), - (0, 0), - (0, 34), - (2, 19), - (10, 16), - (0, 1), - (2, 33), - (43, 24), - (0, 42), - ], - entries: &[ - ("explicit", ()), - ("inline", ()), - ("true", ()), - ("uint_fast64_t", ()), - ("int", ()), - ("char", ()), - ("uint_fast8_t", ()), - ("int32_t", ()), - ("uint_fast16_t", ()), - ("int64_t", ()), - ("charptr_t", ()), - ("bool", ()), - ("intptr_t", ()), - ("int_fast8_t", ()), - ("uint_least32_t", ()), - ("uint_fast32_t", ()), - ("size_t", ()), - ("NULL", ()), - ("uint_least8_t", ()), - ("false", ()), - ("static", ()), - ("uintptr_t", ()), - ("ssize_t", ()), - ("int_least64_t", ()), - ("max_align_t", ()), - ("uint32_t", ()), - ("float", ()), - ("double", ()), - ("uintmax_t", ()), - ("int_fast16_t", ()), - ("intmax_t", ()), - ("short", ()), - ("uint64_t", ()), - ("const", ()), - ("uint_least16_t", ()), - ("int_least32_t", ()), - ("uint_least64_t", ()), - ("char32_t", ()), - ("ptrdiff_t", ()), - ("nullptr", ()), - ("int_fast64_t", ()), - ("int_least8_t", ()), - ("restrict", ()), - ("wchar_t", ()), - ("uint16_t", ()), - ("char16_t", ()), - ("constexpr", ()), - ("namespace", ()), - ("char8_t", ()), - ("unsigned", ()), - ("int8_t", ()), - ("char64_t", ()), - ("int_least16_t", ()), - ("signed", ()), - ("int16_t", ()), - ("long", ()), - ("int_fast32_t", ()), - ("uint8_t", ()), - ("mutable", ()), - ], - }, -}; +// Code generated; DO NOT EDIT. + +const SPECIALS: &[&str] = &[ + "NULL", + "bool", + "char", + "char16_t", + "char32_t", + "char64_t", + "char8_t", + "charptr_t", + "const", + "constexpr", + "double", + "explicit", + "false", + "float", + "inline", + "int", + "int16_t", + "int32_t", + "int64_t", + "int8_t", + "int_fast16_t", + "int_fast32_t", + "int_fast64_t", + "int_fast8_t", + "int_least16_t", + "int_least32_t", + "int_least64_t", + "int_least8_t", + "intmax_t", + "intptr_t", + "long", + "max_align_t", + "mutable", + "namespace", + "nullptr", + "ptrdiff_t", + "restrict", + "short", + "signed", + "size_t", + "ssize_t", + "static", + "true", + "uint16_t", + "uint32_t", + "uint64_t", + "uint8_t", + "uint_fast16_t", + "uint_fast32_t", + "uint_fast64_t", + "uint_fast8_t", + "uint_least16_t", + "uint_least32_t", + "uint_least64_t", + "uint_least8_t", + "uintmax_t", + "uintptr_t", + "unsigned", + "wchar_t", +]; pub fn is_specials(mac: &str) -> bool { - SPECIALS.contains(mac) + SPECIALS.contains(&mac) } From 55c0ae9fdef0cffde6ac709c388d932ba2917373 Mon Sep 17 00:00:00 2001 From: Luni-4 Date: Fri, 24 Sep 2021 21:48:46 +0200 Subject: [PATCH 7/7] Remove phf dependency --- Cargo.lock | 130 +++++------------------------------------------------ Cargo.toml | 1 - 2 files changed, 11 insertions(+), 120 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 403baa1c6..da97970a4 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -74,7 +74,7 @@ dependencies = [ "mime", "percent-encoding", "pin-project 1.0.8", - "rand 0.7.3", + "rand", "regex", "serde", "serde_json", @@ -351,7 +351,7 @@ dependencies = [ "log", "mime", "percent-encoding", - "rand 0.7.3", + "rand", "serde", "serde_json", "serde_urlencoded", @@ -862,18 +862,7 @@ checksum = "8fc3cb4d91f53b50155bdcfd23f6a4c39ae1969c2ae85982b135750cccaf5fce" dependencies = [ "cfg-if 1.0.0", "libc", - "wasi 0.9.0+wasi-snapshot-preview1", -] - -[[package]] -name = "getrandom" -version = "0.2.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7fcd999463524c52659517fe2cea98493cfe485d10565e7b0fb07dbba7ad2753" -dependencies = [ - "cfg-if 1.0.0", - "libc", - "wasi 0.10.2+wasi-snapshot-preview1", + "wasi", ] [[package]] @@ -1359,50 +1348,6 @@ dependencies = [ "indexmap", ] -[[package]] -name = "phf" -version = "0.10.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b9fc3db1018c4b59d7d582a739436478b6035138b6aecbce989fc91c3e98409f" -dependencies = [ - "phf_macros", - "phf_shared", - "proc-macro-hack", -] - -[[package]] -name = "phf_generator" -version = "0.10.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5d5285893bb5eb82e6aaf5d59ee909a06a16737a8970984dd7746ba9283498d6" -dependencies = [ - "phf_shared", - "rand 0.8.4", -] - -[[package]] -name = "phf_macros" -version = "0.10.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "58fdf3184dd560f160dd73922bea2d5cd6e8f064bf4b13110abd81b03697b4e0" -dependencies = [ - "phf_generator", - "phf_shared", - "proc-macro-hack", - "proc-macro2", - "quote", - "syn", -] - -[[package]] -name = "phf_shared" -version = "0.10.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b6796ad771acdc0123d2a88dc428b5e38ef24456743ddb1744ed628f9815c096" -dependencies = [ - "siphasher", -] - [[package]] name = "pin-project" version = "0.4.28" @@ -1521,23 +1466,11 @@ version = "0.7.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6a6b1679d49b24bbfe0c803429aa1874472f50d9b363131f0e89fc356b544d03" dependencies = [ - "getrandom 0.1.16", + "getrandom", "libc", - "rand_chacha 0.2.2", - "rand_core 0.5.1", - "rand_hc 0.2.0", -] - -[[package]] -name = "rand" -version = "0.8.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2e7573632e6454cf6b99d7aac4ccca54be06da05aca2ef7423d22d27d4d4bcd8" -dependencies = [ - "libc", - "rand_chacha 0.3.1", - "rand_core 0.6.3", - "rand_hc 0.3.1", + "rand_chacha", + "rand_core", + "rand_hc", ] [[package]] @@ -1547,17 +1480,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f4c8ed856279c9737206bf725bf36935d8666ead7aa69b52be55af369d193402" dependencies = [ "ppv-lite86", - "rand_core 0.5.1", -] - -[[package]] -name = "rand_chacha" -version = "0.3.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88" -dependencies = [ - "ppv-lite86", - "rand_core 0.6.3", + "rand_core", ] [[package]] @@ -1566,16 +1489,7 @@ version = "0.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "90bde5296fc891b0cef12a6d03ddccc162ce7b2aff54160af9338f8d40df6d19" dependencies = [ - "getrandom 0.1.16", -] - -[[package]] -name = "rand_core" -version = "0.6.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d34f1408f55294453790c48b2f1ebbb1c5b4b7563eb1f418bcfcfdbb06ebb4e7" -dependencies = [ - "getrandom 0.2.3", + "getrandom", ] [[package]] @@ -1584,16 +1498,7 @@ version = "0.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ca3129af7b92a17112d59ad498c6f81eaf463253766b90396d39ea7a39d6613c" dependencies = [ - "rand_core 0.5.1", -] - -[[package]] -name = "rand_hc" -version = "0.3.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d51e9f596de227fda2ea6c84607f5558e196eeaf43c986b724ba4fb8fdf497e7" -dependencies = [ - "rand_core 0.6.3", + "rand_core", ] [[package]] @@ -1645,7 +1550,6 @@ dependencies = [ "num-format", "num-traits", "petgraph", - "phf", "pretty_assertions", "regex", "serde", @@ -1860,12 +1764,6 @@ dependencies = [ "libc", ] -[[package]] -name = "siphasher" -version = "0.3.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "533494a8f9b724d33625ab53c6c4800f7cc445895924a8ef649222dcb76e938b" - [[package]] name = "slab" version = "0.4.4" @@ -2255,7 +2153,7 @@ dependencies = [ "idna", "lazy_static", "log", - "rand 0.7.3", + "rand", "smallvec", "thiserror", "tokio", @@ -2367,12 +2265,6 @@ version = "0.9.0+wasi-snapshot-preview1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "cccddf32554fecc6acb585f82a32a72e28b48f8c4c1883ddfeeeaa96f7d8e519" -[[package]] -name = "wasi" -version = "0.10.2+wasi-snapshot-preview1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fd6fbd9a79829dd1ad0cc20627bf1ed606756a7f77edff7b66b7064f9cb327c6" - [[package]] name = "wasm-bindgen" version = "0.2.78" diff --git a/Cargo.toml b/Cargo.toml index 810edba03..a25730320 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -20,7 +20,6 @@ num = "^0.4" num-derive = "^0.3" num-traits = "^0.2" petgraph = "^0.6" -phf = { version = "^0.10", features = ["macros"] } regex = "^1.5" serde = { version = "^1.0", features = ["derive"] } termcolor = "^1.1"