summaryrefslogtreecommitdiffstats
path: root/third_party/rust/phf_codegen
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 01:47:29 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 01:47:29 +0000
commit0ebf5bdf043a27fd3dfb7f92e0cb63d88954c44d (patch)
treea31f07c9bcca9d56ce61e9a1ffd30ef350d513aa /third_party/rust/phf_codegen
parentInitial commit. (diff)
downloadfirefox-esr-0ebf5bdf043a27fd3dfb7f92e0cb63d88954c44d.tar.xz
firefox-esr-0ebf5bdf043a27fd3dfb7f92e0cb63d88954c44d.zip
Adding upstream version 115.8.0esr.upstream/115.8.0esr
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'third_party/rust/phf_codegen')
-rw-r--r--third_party/rust/phf_codegen/.cargo-checksum.json1
-rw-r--r--third_party/rust/phf_codegen/Cargo.toml25
-rw-r--r--third_party/rust/phf_codegen/src/lib.rs486
3 files changed, 512 insertions, 0 deletions
diff --git a/third_party/rust/phf_codegen/.cargo-checksum.json b/third_party/rust/phf_codegen/.cargo-checksum.json
new file mode 100644
index 0000000000..1f6ffe9fcf
--- /dev/null
+++ b/third_party/rust/phf_codegen/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"f6fd52523100ca5655e0326407e2e4b7c9df947ab55a2d1079b424ada242e9cc","src/lib.rs":"26542892e9f9aac772fe1c37b5f5d8119ec64db91bf8c4f8b018c30cdff33ee8"},"package":"4fb1c3a8bc4dd4e5cfce29b44ffc14bedd2ee294559a294e2a4d4c9e9a6a13cd"} \ No newline at end of file
diff --git a/third_party/rust/phf_codegen/Cargo.toml b/third_party/rust/phf_codegen/Cargo.toml
new file mode 100644
index 0000000000..c22369fb27
--- /dev/null
+++ b/third_party/rust/phf_codegen/Cargo.toml
@@ -0,0 +1,25 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2018"
+name = "phf_codegen"
+version = "0.10.0"
+authors = ["Steven Fackler <sfackler@gmail.com>"]
+description = "Codegen library for PHF types"
+readme = "../README.md"
+license = "MIT"
+repository = "https://github.com/sfackler/rust-phf"
+[dependencies.phf_generator]
+version = "0.10.0"
+
+[dependencies.phf_shared]
+version = "0.10.0"
diff --git a/third_party/rust/phf_codegen/src/lib.rs b/third_party/rust/phf_codegen/src/lib.rs
new file mode 100644
index 0000000000..dfcf6ed0ec
--- /dev/null
+++ b/third_party/rust/phf_codegen/src/lib.rs
@@ -0,0 +1,486 @@
+//! A set of builders to generate Rust source for PHF data structures at
+//! compile time.
+//!
+//! The provided builders are intended to be used in a Cargo build script to
+//! generate a Rust source file that will be included in a library at build
+//! time.
+//!
+//! # Examples
+//!
+//! build.rs:
+//!
+//! ```rust,no_run
+//! use std::env;
+//! use std::fs::File;
+//! use std::io::{BufWriter, Write};
+//! use std::path::Path;
+//!
+//! fn main() {
+//! let path = Path::new(&env::var("OUT_DIR").unwrap()).join("codegen.rs");
+//! let mut file = BufWriter::new(File::create(&path).unwrap());
+//!
+//! writeln!(
+//! &mut file,
+//! "static KEYWORDS: phf::Map<&'static str, Keyword> = \n{};\n",
+//! phf_codegen::Map::new()
+//! .entry("loop", "Keyword::Loop")
+//! .entry("continue", "Keyword::Continue")
+//! .entry("break", "Keyword::Break")
+//! .entry("fn", "Keyword::Fn")
+//! .entry("extern", "Keyword::Extern")
+//! .build()
+//! ).unwrap();
+//! }
+//! ```
+//!
+//! lib.rs:
+//!
+//! ```ignore
+//! #[derive(Clone)]
+//! enum Keyword {
+//! Loop,
+//! Continue,
+//! Break,
+//! Fn,
+//! Extern,
+//! }
+//!
+//! include!(concat!(env!("OUT_DIR"), "/codegen.rs"));
+//!
+//! pub fn parse_keyword(keyword: &str) -> Option<Keyword> {
+//! KEYWORDS.get(keyword).cloned()
+//! }
+//! ```
+//!
+//! ##### Byte-String Keys
+//! Byte strings by default produce references to fixed-size arrays; the compiler needs a hint
+//! to coerce them to slices:
+//!
+//! build.rs:
+//!
+//! ```rust,no_run
+//! use std::env;
+//! use std::fs::File;
+//! use std::io::{BufWriter, Write};
+//! use std::path::Path;
+//!
+//! fn main() {
+//! let path = Path::new(&env::var("OUT_DIR").unwrap()).join("codegen.rs");
+//! let mut file = BufWriter::new(File::create(&path).unwrap());
+//!
+//! writeln!(
+//! &mut file,
+//! "static KEYWORDS: phf::Map<&'static [u8], Keyword> = \n{};\n",
+//! phf_codegen::Map::<&[u8]>::new()
+//! .entry(b"loop", "Keyword::Loop")
+//! .entry(b"continue", "Keyword::Continue")
+//! .entry(b"break", "Keyword::Break")
+//! .entry(b"fn", "Keyword::Fn")
+//! .entry(b"extern", "Keyword::Extern")
+//! .build()
+//! ).unwrap();
+//! }
+//! ```
+//!
+//! lib.rs:
+//!
+//! ```rust,ignore
+//! #[derive(Clone)]
+//! enum Keyword {
+//! Loop,
+//! Continue,
+//! Break,
+//! Fn,
+//! Extern,
+//! }
+//!
+//! include!(concat!(env!("OUT_DIR"), "/codegen.rs"));
+//!
+//! pub fn parse_keyword(keyword: &[u8]) -> Option<Keyword> {
+//! KEYWORDS.get(keyword).cloned()
+//! }
+//! ```
+//!
+//! # Note
+//!
+//! The compiler's stack will overflow when processing extremely long method
+//! chains (500+ calls). When generating large PHF data structures, consider
+//! looping over the entries or making each call a separate statement:
+//!
+//! ```rust
+//! let entries = [("hello", "1"), ("world", "2")];
+//!
+//! let mut builder = phf_codegen::Map::new();
+//! for &(key, value) in &entries {
+//! builder.entry(key, value);
+//! }
+//! // ...
+//! ```
+//!
+//! ```rust
+//! let mut builder = phf_codegen::Map::new();
+//! builder.entry("hello", "1");
+//! builder.entry("world", "2");
+//! // ...
+//! ```
+#![doc(html_root_url = "https://docs.rs/phf_codegen/0.9")]
+
+use phf_shared::{FmtConst, PhfHash};
+use std::collections::HashSet;
+use std::fmt;
+use std::hash::Hash;
+
+use phf_generator::HashState;
+
+struct Delegate<T>(T);
+
+impl<T: FmtConst> fmt::Display for Delegate<T> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ self.0.fmt_const(f)
+ }
+}
+
+/// A builder for the `phf::Map` type.
+pub struct Map<K> {
+ keys: Vec<K>,
+ values: Vec<String>,
+ path: String,
+}
+
+impl<K: Hash + PhfHash + Eq + FmtConst> Map<K> {
+ /// Creates a new `phf::Map` builder.
+ pub fn new() -> Map<K> {
+ // FIXME rust#27438
+ //
+ // On Windows/MSVC there are major problems with the handling of dllimport.
+ // Here, because downstream build scripts only invoke generics from phf_codegen,
+ // the linker ends up throwing a way a bunch of static symbols we actually need.
+ // This works around the problem, assuming that all clients call `Map::new` by
+ // calling a non-generic function.
+ fn noop_fix_for_27438() {}
+ noop_fix_for_27438();
+
+ Map {
+ keys: vec![],
+ values: vec![],
+ path: String::from("::phf"),
+ }
+ }
+
+ /// Set the path to the `phf` crate from the global namespace
+ pub fn phf_path(&mut self, path: &str) -> &mut Map<K> {
+ self.path = path.to_owned();
+ self
+ }
+
+ /// Adds an entry to the builder.
+ ///
+ /// `value` will be written exactly as provided in the constructed source.
+ pub fn entry(&mut self, key: K, value: &str) -> &mut Map<K> {
+ self.keys.push(key);
+ self.values.push(value.to_owned());
+ self
+ }
+
+ /// Calculate the hash parameters and return a struct implementing
+ /// [`Display`](::std::fmt::Display) which will print the constructed `phf::Map`.
+ ///
+ /// # Panics
+ ///
+ /// Panics if there are any duplicate keys.
+ pub fn build(&self) -> DisplayMap<'_, K> {
+ let mut set = HashSet::new();
+ for key in &self.keys {
+ if !set.insert(key) {
+ panic!("duplicate key `{}`", Delegate(key));
+ }
+ }
+
+ let state = phf_generator::generate_hash(&self.keys);
+
+ DisplayMap {
+ path: &self.path,
+ keys: &self.keys,
+ values: &self.values,
+ state,
+ }
+ }
+}
+
+/// An adapter for printing a [`Map`](Map).
+pub struct DisplayMap<'a, K> {
+ path: &'a str,
+ state: HashState,
+ keys: &'a [K],
+ values: &'a [String],
+}
+
+impl<'a, K: FmtConst + 'a> fmt::Display for DisplayMap<'a, K> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ // funky formatting here for nice output
+ write!(
+ f,
+ "{}::Map {{
+ key: {:?},
+ disps: &[",
+ self.path, self.state.key
+ )?;
+
+ // write map displacements
+ for &(d1, d2) in &self.state.disps {
+ write!(
+ f,
+ "
+ ({}, {}),",
+ d1, d2
+ )?;
+ }
+
+ write!(
+ f,
+ "
+ ],
+ entries: &[",
+ )?;
+
+ // write map entries
+ for &idx in &self.state.map {
+ write!(
+ f,
+ "
+ ({}, {}),",
+ Delegate(&self.keys[idx]),
+ &self.values[idx]
+ )?;
+ }
+
+ write!(
+ f,
+ "
+ ],
+}}"
+ )
+ }
+}
+
+/// A builder for the `phf::Set` type.
+pub struct Set<T> {
+ map: Map<T>,
+}
+
+impl<T: Hash + PhfHash + Eq + FmtConst> Set<T> {
+ /// Constructs a new `phf::Set` builder.
+ pub fn new() -> Set<T> {
+ Set { map: Map::new() }
+ }
+
+ /// Set the path to the `phf` crate from the global namespace
+ pub fn phf_path(&mut self, path: &str) -> &mut Set<T> {
+ self.map.phf_path(path);
+ self
+ }
+
+ /// Adds an entry to the builder.
+ pub fn entry(&mut self, entry: T) -> &mut Set<T> {
+ self.map.entry(entry, "()");
+ self
+ }
+
+ /// Calculate the hash parameters and return a struct implementing
+ /// [`Display`](::std::fmt::Display) which will print the constructed `phf::Set`.
+ ///
+ /// # Panics
+ ///
+ /// Panics if there are any duplicate keys.
+ pub fn build(&self) -> DisplaySet<'_, T> {
+ DisplaySet {
+ inner: self.map.build(),
+ }
+ }
+}
+
+/// An adapter for printing a [`Set`](Set).
+pub struct DisplaySet<'a, T> {
+ inner: DisplayMap<'a, T>,
+}
+
+impl<'a, T: FmtConst + 'a> fmt::Display for DisplaySet<'a, T> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(f, "{}::Set {{ map: {} }}", self.inner.path, self.inner)
+ }
+}
+
+/// A builder for the `phf::OrderedMap` type.
+pub struct OrderedMap<K> {
+ keys: Vec<K>,
+ values: Vec<String>,
+ path: String,
+}
+
+impl<K: Hash + PhfHash + Eq + FmtConst> OrderedMap<K> {
+ /// Constructs a enw `phf::OrderedMap` builder.
+ pub fn new() -> OrderedMap<K> {
+ OrderedMap {
+ keys: vec![],
+ values: vec![],
+ path: String::from("::phf"),
+ }
+ }
+
+ /// Set the path to the `phf` crate from the global namespace
+ pub fn phf_path(&mut self, path: &str) -> &mut OrderedMap<K> {
+ self.path = path.to_owned();
+ self
+ }
+
+ /// Adds an entry to the builder.
+ ///
+ /// `value` will be written exactly as provided in the constructed source.
+ pub fn entry(&mut self, key: K, value: &str) -> &mut OrderedMap<K> {
+ self.keys.push(key);
+ self.values.push(value.to_owned());
+ self
+ }
+
+ /// Calculate the hash parameters and return a struct implementing
+ /// [`Display`](::std::fmt::Display) which will print the constructed
+ /// `phf::OrderedMap`.
+ ///
+ /// # Panics
+ ///
+ /// Panics if there are any duplicate keys.
+ pub fn build(&self) -> DisplayOrderedMap<'_, K> {
+ let mut set = HashSet::new();
+ for key in &self.keys {
+ if !set.insert(key) {
+ panic!("duplicate key `{}`", Delegate(key));
+ }
+ }
+
+ let state = phf_generator::generate_hash(&self.keys);
+
+ DisplayOrderedMap {
+ path: &self.path,
+ state,
+ keys: &self.keys,
+ values: &self.values,
+ }
+ }
+}
+
+/// An adapter for printing a [`OrderedMap`](OrderedMap).
+pub struct DisplayOrderedMap<'a, K> {
+ path: &'a str,
+ state: HashState,
+ keys: &'a [K],
+ values: &'a [String],
+}
+
+impl<'a, K: FmtConst + 'a> fmt::Display for DisplayOrderedMap<'a, K> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(
+ f,
+ "{}::OrderedMap {{
+ key: {:?},
+ disps: &[",
+ self.path, self.state.key
+ )?;
+ for &(d1, d2) in &self.state.disps {
+ write!(
+ f,
+ "
+ ({}, {}),",
+ d1, d2
+ )?;
+ }
+ write!(
+ f,
+ "
+ ],
+ idxs: &[",
+ )?;
+ for &idx in &self.state.map {
+ write!(
+ f,
+ "
+ {},",
+ idx
+ )?;
+ }
+ write!(
+ f,
+ "
+ ],
+ entries: &[",
+ )?;
+ for (key, value) in self.keys.iter().zip(self.values.iter()) {
+ write!(
+ f,
+ "
+ ({}, {}),",
+ Delegate(key),
+ value
+ )?;
+ }
+ write!(
+ f,
+ "
+ ],
+}}"
+ )
+ }
+}
+
+/// A builder for the `phf::OrderedSet` type.
+pub struct OrderedSet<T> {
+ map: OrderedMap<T>,
+}
+
+impl<T: Hash + PhfHash + Eq + FmtConst> OrderedSet<T> {
+ /// Constructs a new `phf::OrderedSet` builder.
+ pub fn new() -> OrderedSet<T> {
+ OrderedSet {
+ map: OrderedMap::new(),
+ }
+ }
+
+ /// Set the path to the `phf` crate from the global namespace
+ pub fn phf_path(&mut self, path: &str) -> &mut OrderedSet<T> {
+ self.map.phf_path(path);
+ self
+ }
+
+ /// Adds an entry to the builder.
+ pub fn entry(&mut self, entry: T) -> &mut OrderedSet<T> {
+ self.map.entry(entry, "()");
+ self
+ }
+
+ /// Calculate the hash parameters and return a struct implementing
+ /// [`Display`](::std::fmt::Display) which will print the constructed
+ /// `phf::OrderedSet`.
+ ///
+ /// # Panics
+ ///
+ /// Panics if there are any duplicate keys.
+ pub fn build(&self) -> DisplayOrderedSet<'_, T> {
+ DisplayOrderedSet {
+ inner: self.map.build(),
+ }
+ }
+}
+
+/// An adapter for printing a [`OrderedSet`](OrderedSet).
+pub struct DisplayOrderedSet<'a, T> {
+ inner: DisplayOrderedMap<'a, T>,
+}
+
+impl<'a, T: FmtConst + 'a> fmt::Display for DisplayOrderedSet<'a, T> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(
+ f,
+ "{}::OrderedSet {{ map: {} }}",
+ self.inner.path, self.inner
+ )
+ }
+}