diff options
Diffstat (limited to '')
| -rw-r--r-- | third_party/rust/weedle2/src/term.rs | 699 |
1 files changed, 699 insertions, 0 deletions
diff --git a/third_party/rust/weedle2/src/term.rs b/third_party/rust/weedle2/src/term.rs new file mode 100644 index 0000000000..d73de79847 --- /dev/null +++ b/third_party/rust/weedle2/src/term.rs @@ -0,0 +1,699 @@ +macro_rules! generate_terms { + ($( $(#[$attr:meta])* $typ:ident => $tok:expr ),*) => { + $( + $(#[$attr])* + #[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] + pub struct $typ; + + impl<'a> $crate::Parse<'a> for $typ { + parser!(nom::combinator::value( + $typ, + crate::whitespace::ws( + nom::bytes::complete::tag($tok) + ) + )); + } + )* + }; +} + +struct AlphaNumUnderscoreDash; + +impl nom::FindToken<char> for AlphaNumUnderscoreDash { + fn find_token(&self, token: char) -> bool { + crate::common::is_alphanum_underscore_dash(token) + } +} + +pub(crate) fn ident_tag(tag: &'static str) -> impl FnMut(&str) -> nom::IResult<&str, &str> { + move |input| { + nom::sequence::terminated( + nom::bytes::complete::tag(tag), + nom::combinator::not(nom::combinator::map_parser( + nom::bytes::complete::take(1usize), + nom::bytes::complete::is_a(AlphaNumUnderscoreDash), + )), + )(input) + } +} + +macro_rules! generate_terms_for_names { + ($( $(#[$attr:meta])* $typ:ident => $tok:expr,)*) => { + $( + $(#[$attr])* + #[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] + pub struct $typ; + + impl<'a> $crate::Parse<'a> for $typ { + parser!(nom::combinator::value( + $typ, + $crate::whitespace::ws($crate::term::ident_tag($tok)) + )); + } + )* + }; +} + +generate_terms! { + /// Represents the terminal symbol `(` + OpenParen => "(", + + /// Represents the terminal symbol `)` + CloseParen => ")", + + /// Represents the terminal symbol `[` + OpenBracket => "[", + + /// Represents the terminal symbol `]` + CloseBracket => "]", + + /// Represents the terminal symbol `{` + OpenBrace => "{", + + /// Represents the terminal symbol `}` + CloseBrace => "}", + + /// Represents the terminal symbol `,` + Comma => ",", + + /// Represents the terminal symbol `-` + Minus => "-", + + /// Represents the terminal symbol `.` + Dot => ".", + + /// Represents the terminal symbol `...` + Ellipsis => "...", + + /// Represents the terminal symbol `:` + Colon => ":", + + /// Represents the terminal symbol `;` + SemiColon => ";", + + /// Represents the terminal symbol `<` + LessThan => "<", + + /// Represents the terminal symbol `=` + Assign => "=", + + /// Represents the terminal symbol `>` + GreaterThan => ">", + + /// Represents the terminal symbol `?` + QMark => "?" +} + +generate_terms_for_names! { + /// Represents the terminal symbol `or` + Or => "or", + + /// Represents the terminal symbol `optional` + Optional => "optional", + + /// Represents the terminal symbol `async` + Async => "async", + + /// Represents the terminal symbol `attribute` + Attribute => "attribute", + + /// Represents the terminal symbol `callback` + Callback => "callback", + + /// Represents the terminal symbol `const` + Const => "const", + + /// Represents the terminal symbol `deleter` + Deleter => "deleter", + + /// Represents the terminal symbol `dictionary` + Dictionary => "dictionary", + + /// Represents the terminal symbol `enum` + Enum => "enum", + + /// Represents the terminal symbol `getter` + Getter => "getter", + + /// Represents the terminal symbol `includes` + Includes => "includes", + + /// Represents the terminal symbol `inherit` + Inherit => "inherit", + + /// Represents the terminal symbol `interface` + Interface => "interface", + + /// Represents the terminal symbol `iterable` + Iterable => "iterable", + + /// Represents the terminal symbol `maplike` + Maplike => "maplike", + + /// Represents the terminal symbol `namespace` + Namespace => "namespace", + + /// Represents the terminal symbol `partial` + Partial => "partial", + + /// Represents the terminal symbol `required` + Required => "required", + + /// Represents the terminal symbol `setlike` + Setlike => "setlike", + + /// Represents the terminal symbol `setter` + Setter => "setter", + + /// Represents the terminal symbol `static` + Static => "static", + + /// Represents the terminal symbol `stringifier` + Stringifier => "stringifier", + + /// Represents the terminal symbol `typedef` + Typedef => "typedef", + + /// Represents the terminal symbol `unrestricted` + Unrestricted => "unrestricted", + + /// Represents the terminal symbol `symbol` + Symbol => "symbol", + + /// Represents the terminal symbol `Infinity` + NegInfinity => "-Infinity", + + /// Represents the terminal symbol `ByteString` + ByteString => "ByteString", + + /// Represents the terminal symbol `DOMString` + DOMString => "DOMString", + + /// Represents the terminal symbol `FrozenArray` + FrozenArray => "FrozenArray", + + /// Represents the terminal symbol `Infinity` + Infinity => "Infinity", + + /// Represents the terminal symbol `NaN` + NaN => "NaN", + + /// Represents the terminal symbol `USVString` + USVString => "USVString", + + /// Represents the terminal symbol `any` + Any => "any", + + /// Represents the terminal symbol `boolean` + Boolean => "boolean", + + /// Represents the terminal symbol `byte` + Byte => "byte", + + /// Represents the terminal symbol `double` + Double => "double", + + /// Represents the terminal symbol `false` + False => "false", + + /// Represents the terminal symbol `float` + Float => "float", + + /// Represents the terminal symbol `long` + Long => "long", + + /// Represents the terminal symbol `null` + Null => "null", + + /// Represents the terminal symbol `object` + Object => "object", + + /// Represents the terminal symbol `octet` + Octet => "octet", + + /// Represents the terminal symbol `sequence` + Sequence => "sequence", + + /// Represents the terminal symbol `short` + Short => "short", + + /// Represents the terminal symbol `true` + True => "true", + + /// Represents the terminal symbol `unsigned` + Unsigned => "unsigned", + + /// Represents the terminal symbol `undefined` + Undefined => "undefined", + + /// Represents the terminal symbol `record` + Record => "record", + + /// Represents the terminal symbol `ArrayBuffer` + ArrayBuffer => "ArrayBuffer", + + /// Represents the terminal symbol `DataView` + DataView => "DataView", + + /// Represents the terminal symbol `Int8Array` + Int8Array => "Int8Array", + + /// Represents the terminal symbol `Int16Array` + Int16Array => "Int16Array", + + /// Represents the terminal symbol `Int32Array` + Int32Array => "Int32Array", + + /// Represents the terminal symbol `Uint8Array` + Uint8Array => "Uint8Array", + + /// Represents the terminal symbol `Uint16Array` + Uint16Array => "Uint16Array", + + /// Represents the terminal symbol `Uint32Array` + Uint32Array => "Uint32Array", + + /// Represents the terminal symbol `Uint8ClampedArray` + Uint8ClampedArray => "Uint8ClampedArray", + + /// Represents the terminal symbol `Float32Array` + Float32Array => "Float32Array", + + /// Represents the terminal symbol `Float64Array` + Float64Array => "Float64Array", + + /// Represents the terminal symbol `ArrayBufferView` + ArrayBufferView => "ArrayBufferView", + + /// Represents the terminal symbol `BufferSource + BufferSource => "BufferSource", + + /// Represents the terminal symbol `Promise` + Promise => "Promise", + + /// Represents the terminal symbol `Error` + Error => "Error", + + /// Represents the terminal symbol `readonly` + ReadOnly => "readonly", + + /// Represents the terminal symbol `mixin` + Mixin => "mixin", + + /// Represents the terminal symbol `implements` + Implements => "implements", + + /// Represents the terminal symbol `legacycaller` + LegacyCaller => "legacycaller", + + /// Represents the terminal symbol `constructor` + Constructor => "constructor", +} + +#[macro_export] +macro_rules! term { + (OpenParen) => { + $crate::term::OpenParen + }; + (CloseParen) => { + $crate::term::CloseParen + }; + (OpenBracket) => { + $crate::term::OpenBracket + }; + (CloseBracket) => { + $crate::term::CloseBracket + }; + (OpenBrace) => { + $crate::term::OpenBrace + }; + (CloseBrace) => { + $crate::term::CloseBrace + }; + (,) => { + $crate::term::Comma + }; + (-) => { + $crate::term::Minus + }; + (.) => { + $crate::term::Dot + }; + (...) => { + $crate::term::Ellipsis + }; + (:) => { + $crate::term::Colon + }; + (;) => { + $crate::term::SemiColon + }; + (<) => { + $crate::term::LessThan + }; + (=) => { + $crate::term::Assign + }; + (>) => { + $crate::term::GreaterThan + }; + (?) => { + $crate::term::QMark + }; + (or) => { + $crate::term::Or + }; + (optional) => { + $crate::term::Optional + }; + (async) => { + $crate::term::Async + }; + (attribute) => { + $crate::term::Attribute + }; + (callback) => { + $crate::term::Callback + }; + (const) => { + $crate::term::Const + }; + (deleter) => { + $crate::term::Deleter + }; + (dictionary) => { + $crate::term::Dictionary + }; + (enum) => { + $crate::term::Enum + }; + (getter) => { + $crate::term::Getter + }; + (includes) => { + $crate::term::Includes + }; + (inherit) => { + $crate::term::Inherit + }; + (interface) => { + $crate::term::Interface + }; + (iterable) => { + $crate::term::Iterable + }; + (maplike) => { + $crate::term::Maplike + }; + (namespace) => { + $crate::term::Namespace + }; + (partial) => { + $crate::term::Partial + }; + (required) => { + $crate::term::Required + }; + (setlike) => { + $crate::term::Setlike + }; + (setter) => { + $crate::term::Setter + }; + (static) => { + $crate::term::Static + }; + (stringifier) => { + $crate::term::Stringifier + }; + (typedef) => { + $crate::term::Typedef + }; + (unrestricted) => { + $crate::term::Unrestricted + }; + (symbol) => { + $crate::term::Symbol + }; + (- Infinity) => { + $crate::term::NegInfinity + }; + (ByteString) => { + $crate::term::ByteString + }; + (DOMString) => { + $crate::term::DOMString + }; + (FrozenArray) => { + $crate::term::FrozenArray + }; + (Infinity) => { + $crate::term::Infinity + }; + (NaN) => { + $crate::term::NaN + }; + (USVString) => { + $crate::term::USVString + }; + (any) => { + $crate::term::Any + }; + (boolean) => { + $crate::term::Boolean + }; + (byte) => { + $crate::term::Byte + }; + (double) => { + $crate::term::Double + }; + (false) => { + $crate::term::False + }; + (float) => { + $crate::term::Float + }; + (long) => { + $crate::term::Long + }; + (null) => { + $crate::term::Null + }; + (object) => { + $crate::term::Object + }; + (octet) => { + $crate::term::Octet + }; + (sequence) => { + $crate::term::Sequence + }; + (short) => { + $crate::term::Short + }; + (true) => { + $crate::term::True + }; + (unsigned) => { + $crate::term::Unsigned + }; + (undefined) => { + $crate::term::Undefined + }; + (record) => { + $crate::term::Record + }; + (ArrayBuffer) => { + $crate::term::ArrayBuffer + }; + (DataView) => { + $crate::term::DataView + }; + (Int8Array) => { + $crate::term::Int8Array + }; + (Int16Array) => { + $crate::term::Int16Array + }; + (Int32Array) => { + $crate::term::Int32Array + }; + (Uint8Array) => { + $crate::term::Uint8Array + }; + (Uint16Array) => { + $crate::term::Uint16Array + }; + (Uint32Array) => { + $crate::term::Uint32Array + }; + (Uint8ClampedArray) => { + $crate::term::Uint8ClampedArray + }; + (Float32Array) => { + $crate::term::Float32Array + }; + (Float64Array) => { + $crate::term::Float64Array + }; + (ArrayBufferView) => { + $crate::term::ArrayBufferView + }; + (BufferSource) => { + $crate::term::BufferSource + }; + (Promise) => { + $crate::term::Promise + }; + (Error) => { + $crate::term::Error + }; + (readonly) => { + $crate::term::ReadOnly + }; + (mixin) => { + $crate::term::Mixin + }; + (implements) => { + $crate::term::Implements + }; + (legacycaller) => { + $crate::term::LegacyCaller + }; + (constructor) => { + $crate::term::Constructor + }; +} + +#[cfg(test)] +mod test { + macro_rules! generate_tests { + ($($m:ident, $typ:ident, $string:expr;)*) => { + $( + mod $m { + use super::super::$typ; + use crate::Parse; + + #[test] + fn should_parse() { + let (rem, parsed) = $typ::parse(concat!($string)).unwrap(); + assert_eq!(rem, ""); + assert_eq!(parsed, $typ); + } + + #[test] + fn should_parse_with_preceding_spaces() { + let (rem, parsed) = $typ::parse(concat!(" ", $string)).unwrap(); + assert_eq!(rem, ""); + assert_eq!(parsed, $typ); + } + + #[test] + fn should_parse_with_succeeding_spaces() { + let (rem, parsed) = $typ::parse(concat!($string, " ")).unwrap(); + assert_eq!(rem, ""); + assert_eq!(parsed, $typ); + } + + #[test] + fn should_parse_with_surrounding_spaces() { + let (rem, parsed) = $typ::parse(concat!(" ", $string, " ")).unwrap(); + assert_eq!(rem, ""); + assert_eq!(parsed, $typ); + } + + #[test] + fn should_parse_if_anything_next() { + let (rem, parsed) = $typ::parse(concat!($string, " anything")).unwrap(); + assert_eq!(rem, "anything"); + assert_eq!(parsed, $typ); + } + } + )* + }; + } + + generate_tests![ + openparen, OpenParen, "("; + closeparen, CloseParen, ")"; + openbracket, OpenBracket, "["; + closebracket, CloseBracket, "]"; + openbrace, OpenBrace, "{"; + closebrace, CloseBrace, "}"; + comma, Comma, ","; + minus, Minus, "-"; + dot, Dot, "."; + ellipsis, Ellipsis, "..."; + colon, Colon, ":"; + semicolon, SemiColon, ";"; + lessthan, LessThan, "<"; + assign, Assign, "="; + greaterthan, GreaterThan, ">"; + qmark, QMark, "?"; + or, Or, "or"; + optional, Optional, "optional"; + async_, Async, "async"; + attribute, Attribute, "attribute"; + callback, Callback, "callback"; + const_, Const, "const"; + deleter, Deleter, "deleter"; + dictionary, Dictionary, "dictionary"; + enum_, Enum, "enum"; + getter, Getter, "getter"; + includes, Includes, "includes"; + inherit, Inherit, "inherit"; + interface, Interface, "interface"; + iterable, Iterable, "iterable"; + maplike, Maplike, "maplike"; + namespace, Namespace, "namespace"; + partial, Partial, "partial"; + required, Required, "required"; + setlike, Setlike, "setlike"; + setter, Setter, "setter"; + static_, Static, "static"; + stringifier, Stringifier, "stringifier"; + typedef, Typedef, "typedef"; + unrestricted, Unrestricted, "unrestricted"; + symbol, Symbol, "symbol"; + neginfinity, NegInfinity, "-Infinity"; + bytestring, ByteString, "ByteString"; + domstring, DOMString, "DOMString"; + frozenarray, FrozenArray, "FrozenArray"; + infinity, Infinity, "Infinity"; + nan, NaN, "NaN"; + usvstring, USVString, "USVString"; + any, Any, "any"; + boolean, Boolean, "boolean"; + byte, Byte, "byte"; + double, Double, "double"; + false_, False, "false"; + float, Float, "float"; + long, Long, "long"; + null, Null, "null"; + object, Object, "object"; + octet, Octet, "octet"; + sequence, Sequence, "sequence"; + short, Short, "short"; + true_, True, "true"; + unsigned, Unsigned, "unsigned"; + undefined, Undefined, "undefined"; + record, Record, "record"; + arraybuffer, ArrayBuffer, "ArrayBuffer"; + dataview, DataView, "DataView"; + int8array, Int8Array, "Int8Array"; + int16array, Int16Array, "Int16Array"; + int32array, Int32Array, "Int32Array"; + uint8array, Uint8Array, "Uint8Array"; + uint16array, Uint16Array, "Uint16Array"; + uint32array, Uint32Array, "Uint32Array"; + uint8clampedarray, Uint8ClampedArray, "Uint8ClampedArray"; + float32array, Float32Array, "Float32Array"; + float64array, Float64Array, "Float64Array"; + promise, Promise, "Promise"; + error, Error, "Error"; + implements, Implements, "implements"; + legacycaller, LegacyCaller, "legacycaller"; + constructor, Constructor, "constructor"; + ]; +} |