Update testharness.js and friends (and duplicate copies)

third_party/WebKit/LayoutTests/http/tests/w3c/resources/WebIDLParser.js

 
 
 (function () {
     var tokenise = function (str) {
         var tokens = []
         ,   re = {
                 "float":        /^-?(([0-9]+\.[0-9]*|[0-9]*\.[0-9]+)([Ee][-+]?[0-9]+)?|[0-9]+[Ee][-+]?[0-9]+)/
             ,   "integer":      /^-?(0([Xx][0-9A-Fa-f]+|[0-7]*)|[1-9][0-9]*)/
             ,   "identifier":   /^[A-Z_a-z][0-9A-Z_a-z]*/
             ,   "string":       /^"[^"]*"/
@@ skipping 196 matching lines @@
                 // Generic types
                 if (consume(OTHER, "<")) {
                     // backwards compat
                     if (value === "sequence") {
                         ret.sequence = true;
                     }
                     ret.generic = value;
                     ret.idlType = type() || error("Error parsing generic type " + value);
                     all_ws();
                     if (!consume(OTHER, ">")) error("Unterminated generic type " + value);
-                    all_ws();
-                    if (consume(OTHER, "?")) ret.nullable = true;
+                    type_suffix(ret);
                     return ret;
                 }
                 else {
                     ret.idlType = value;
                 }
             }
             else {
                 return;
             }
             type_suffix(ret);
@@ skipping 95 matching lines @@
             all_ws();
             var name = consume(ID);
             if (!name) return;
             var ret = {
                 name: name.value
             ,   "arguments": null
             };
             all_ws();
             var eq = consume(OTHER, "=");
             if (eq) {
+                var rhs;
                 all_ws();
-                ret.rhs = consume(ID);
+                if (rhs = consume(ID)) {
+                  ret.rhs = rhs
+                }
+                else if (consume(OTHER, "(")) {
+                    // [Exposed=(Window,Worker)]
+                    rhs = [];
+                    var id = consume(ID);
+                    if (id) {
+                      rhs = [id.value];
+                    }
+                    identifiers(rhs);
+                    consume(OTHER, ")") || error("Unexpected token in extended attribute argument list or type pair");
+                    ret.rhs = {
+                        type: "identifier-list",
+                        value: rhs
+                    };
+                }
                 if (!ret.rhs) return error("No right hand side to extended attribute assignment");
             }
             all_ws();
             if (consume(OTHER, "(")) {
                 var args, pair;
                 // [Constructor(DOMString str)]
                 if (args = argument_list(store)) {
                     ret["arguments"] = args;
                 }
                 // [MapClass(DOMString, DOMString)]
@@ skipping 27 matching lines @@
         };
 
         var default_ = function () {
             all_ws();
             if (consume(OTHER, "=")) {
                 all_ws();
                 var def = const_value();
                 if (def) {
                     return def;
                 }
+                else if (consume(OTHER, "[")) {
+                    if (!consume(OTHER, "]")) error("Default sequence value must be empty");
+                    return { type: "sequence", value: [] };
+                }
                 else {
                     var str = consume(STR) || error("No value for default");
                     str.value = str.value.replace(/^"/, "").replace(/"$/, "");
                     return str;
                 }
             }
         };
 
         var const_ = function (store) {
             all_ws(store, "pea");
@@ skipping 162 matching lines @@
                 operation_rest(ret, store);
                 return ret;
             }
             if (consume(ID, "static")) {
                 ret["static"] = true;
                 ret.idlType = return_type();
                 operation_rest(ret, store);
                 return ret;
             }
             else if (consume(ID, "stringifier")) {
-                ret.stringifier = true;
+                ret.stringifier = true;-
                 all_ws();
                 if (consume(OTHER, ";")) return ret;
                 ret.idlType = return_type();
                 operation_rest(ret, store);
                 return ret;
             }
             ret.idlType = return_type();
             all_ws();
             if (consume(ID, "iterator")) {
                 all_ws();
@@ skipping 85 matching lines @@
                 // noop, just parsing
             }
             else {
                 ret.idlType = return_type();
                 all_ws();
                 ret.operation = operation_rest(null, store);
             }
             return ret;
         };
 
+        var iterable_type = function() {
+            if (consume(ID, "iterable")) return "iterable";
+            else if (consume(ID, "legacyiterable")) return "legacyiterable";
+            else if (consume(ID, "maplike")) return "maplike";
+            else if (consume(ID, "setlike")) return "setlike";
+            else return;
+        }
+
+        var readonly_iterable_type = function() {
+            if (consume(ID, "maplike")) return "maplike";
+            else if (consume(ID, "setlike")) return "setlike";
+            else return;
+        }
+
+        var iterable = function (store) {
+            all_ws(store, "pea");
+            var grabbed = [],
+                ret = {type: null, idlType: null, readonly: false};
+            if (consume(ID, "readonly")) {
+                ret.readonly = true;
+                grabbed.push(last_token);
+                var w = all_ws();
+                if (w) grabbed.push(w);
+            }
+            var consumeItType = ret.readonly ? readonly_iterable_type : iterable_type;
+
+            var ittype = consumeItType();
+            if (!ittype) {
+                tokens = grabbed.concat(tokens);
+                return;
+            }
+
+            var secondTypeRequired = ittype === "maplike";
+            var secondTypeAllowed = secondTypeRequired || ittype === "iterable";
+            ret.type = ittype;
+            if (ret.type !== 'maplike' && ret.type !== 'setlike')
+                delete ret.readonly;
+            all_ws();
+            if (consume(OTHER, "<")) {
+                ret.idlType = type() || error("Error parsing " + ittype + " declaration");
+                all_ws();
+                if (secondTypeAllowed) {
+                    var type2 = null;
+                    if (consume(OTHER, ",")) {
+                        all_ws();
+                        type2 = type();
+                        all_ws();
+                    }
+                    if (type2)
+                        ret.idlType = [ret.idlType, type2];
+                    else if (secondTypeRequired)
+                        error("Missing second type argument in " + ittype + " declaration");
+                }
+                if (!consume(OTHER, ">")) error("Unterminated " + ittype + " declaration");
+                all_ws();
+                if (!consume(OTHER, ";")) error("Missing semicolon after " + ittype + " declaration");
+            }
+            else
+                error("Error parsing " + ittype + " declaration");
+
+            return ret;
+        }
+
         var interface_ = function (isPartial, store) {
             all_ws(isPartial ? null : store, "pea");
             if (!consume(ID, "interface")) return;
             all_ws();
             var name = consume(ID) || error("No name for interface");
             var mems = []
             ,   ret = {
                 type:   "interface"
             ,   name:   name.value
             ,   partial:    false
@@ skipping 10 matching lines @@
                     return ret;
                 }
                 var ea = extended_attrs(store ? mems : null);
                 all_ws();
                 var cnt = const_(store ? mems : null);
                 if (cnt) {
                     cnt.extAttrs = ea;
                     ret.members.push(cnt);
                     continue;
                 }
-                var mem = serialiser(store ? mems : null) ||
+                var mem = (opt.allowNestedTypedefs && typedef(store ? mems : null)) ||
+                          iterable(store ? mems : null) ||
+                          serialiser(store ? mems : null) ||
                           attribute(store ? mems : null) ||
                           operation(store ? mems : null) ||
                           error("Unknown member");
                 mem.extAttrs = ea;
                 ret.members.push(mem);
             }
         };
 
         var partial = function (store) {
             all_ws(store, "pea");
@@ skipping 22 matching lines @@
             consume(OTHER, "{") || error("Bodyless dictionary");
             while (true) {
                 all_ws(store ? mems : null);
                 if (consume(OTHER, "}")) {
                     all_ws();
                     consume(OTHER, ";") || error("Missing semicolon after dictionary");
                     return ret;
                 }
                 var ea = extended_attrs(store ? mems : null);
                 all_ws(store ? mems : null, "pea");
+                var required = consume(ID, "required");
                 var typ = type() || error("No type for dictionary member");
                 all_ws();
                 var name = consume(ID) || error("No name for dictionary member");
+                var dflt = default_();
+                if (required && dflt) error("Required member must not have a default");
                 ret.members.push({
                     type:       "field"
                 ,   name:       name.value
+                ,   required:   !!required
                 ,   idlType:    typ
                 ,   extAttrs:   ea
-                ,   "default":  default_()
+                ,   "default":  dflt
                 });
                 all_ws();
                 consume(OTHER, ";") || error("Unterminated dictionary member");
             }
         };
 
         var exception = function (store) {
             all_ws(store, "pea");
             if (!consume(ID, "exception")) return;
             all_ws();
@@ skipping 48 matching lines @@
             ,   name:   name.value
             ,   values: vals
             };
             all_ws();
             consume(OTHER, "{") || error("No curly for enum");
             var saw_comma = false;
             while (true) {
                 all_ws(store ? vals : null);
                 if (consume(OTHER, "}")) {
                     all_ws();
-                    if (saw_comma) error("Trailing comma in enum");
                     consume(OTHER, ";") || error("No semicolon after enum");
                     return ret;
                 }
                 var val = consume(STR) || error("Unexpected value in enum");
                 ret.values.push(val.value.replace(/"/g, ""));
                 all_ws(store ? vals : null);
                 if (consume(OTHER, ",")) {
                     if (store) vals.push({ type: "," });
                     all_ws(store ? vals : null);
                     saw_comma = true;
@@ skipping 83 matching lines @@
             parse:  function (str, opt) {
                 if (!opt) opt = {};
                 var tokens = tokenise(str);
                 return parse(tokens, opt);
             }
     };
 
     if (inNode) module.exports = obj;
     else        self.WebIDL2 = obj;
 }());