Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

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";
+    ];
+}