| |
| |
| (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": /^"[^"]*"/ |
| , "whitespace": /^(?:[\t\n\r ]+|[\t\n\r ]*((\/\/.*|\/\*(.|\n|\r)*?\*\/)[\t\n\r ]*))+/ |
| , "other": /^[^\t\n\r 0-9A-Z_a-z]/ |
| } |
| , types = [] |
| ; |
| for (var k in re) types.push(k); |
| while (str.length > 0) { |
| var matched = false; |
| for (var i = 0, n = types.length; i < n; i++) { |
| var type = types[i]; |
| str = str.replace(re[type], function (tok) { |
| tokens.push({ type: type, value: tok }); |
| matched = true; |
| return ""; |
| }); |
| if (matched) break; |
| } |
| if (matched) continue; |
| throw new Error("Token stream not progressing"); |
| } |
| return tokens; |
| }; |
| |
| var parse = function (tokens, opt) { |
| var line = 1; |
| tokens = tokens.slice(); |
| |
| var FLOAT = "float" |
| , INT = "integer" |
| , ID = "identifier" |
| , STR = "string" |
| , OTHER = "other" |
| ; |
| |
| var WebIDLParseError = function (str, line, input, tokens) { |
| this.message = str; |
| this.line = line; |
| this.input = input; |
| this.tokens = tokens; |
| }; |
| WebIDLParseError.prototype.toString = function () { |
| return this.message + ", line " + this.line + " (tokens: '" + this.input + "')\n" + |
| JSON.stringify(this.tokens, null, 4); |
| }; |
| |
| var error = function (str) { |
| var tok = "", numTokens = 0, maxTokens = 5; |
| while (numTokens < maxTokens && tokens.length > numTokens) { |
| tok += tokens[numTokens].value; |
| numTokens++; |
| } |
| throw new WebIDLParseError(str, line, tok, tokens.slice(0, 5)); |
| }; |
| |
| var last_token = null; |
| |
| var consume = function (type, value) { |
| if (!tokens.length || tokens[0].type !== type) return; |
| if (typeof value === "undefined" || tokens[0].value === value) { |
| last_token = tokens.shift(); |
| if (type === ID) last_token.value = last_token.value.replace(/^_/, ""); |
| return last_token; |
| } |
| }; |
| |
| var ws = function () { |
| if (!tokens.length) return; |
| if (tokens[0].type === "whitespace") { |
| var t = tokens.shift(); |
| t.value.replace(/\n/g, function (m) { line++; return m; }); |
| return t; |
| } |
| }; |
| |
| var all_ws = function (store, pea) { // pea == post extended attribute, tpea = same for types |
| var t = { type: "whitespace", value: "" }; |
| while (true) { |
| var w = ws(); |
| if (!w) break; |
| t.value += w.value; |
| } |
| if (t.value.length > 0) { |
| if (store) { |
| var w = t.value |
| , re = { |
| "ws": /^([\t\n\r ]+)/ |
| , "line-comment": /^\/\/(.*)\n?/m |
| , "multiline-comment": /^\/\*((?:.|\n|\r)*?)\*\// |
| } |
| , wsTypes = [] |
| ; |
| for (var k in re) wsTypes.push(k); |
| while (w.length) { |
| var matched = false; |
| for (var i = 0, n = wsTypes.length; i < n; i++) { |
| var type = wsTypes[i]; |
| w = w.replace(re[type], function (tok, m1) { |
| store.push({ type: type + (pea ? ("-" + pea) : ""), value: m1 }); |
| matched = true; |
| return ""; |
| }); |
| if (matched) break; |
| } |
| if (matched) continue; |
| throw new Error("Surprising white space construct."); // this shouldn't happen |
| } |
| } |
| return t; |
| } |
| }; |
| |
| var integer_type = function () { |
| var ret = ""; |
| all_ws(); |
| if (consume(ID, "unsigned")) ret = "unsigned "; |
| all_ws(); |
| if (consume(ID, "short")) return ret + "short"; |
| if (consume(ID, "long")) { |
| ret += "long"; |
| all_ws(); |
| if (consume(ID, "long")) return ret + " long"; |
| return ret; |
| } |
| if (ret) error("Failed to parse integer type"); |
| }; |
| |
| var float_type = function () { |
| var ret = ""; |
| all_ws(); |
| if (consume(ID, "unrestricted")) ret = "unrestricted "; |
| all_ws(); |
| if (consume(ID, "float")) return ret + "float"; |
| if (consume(ID, "double")) return ret + "double"; |
| if (ret) error("Failed to parse float type"); |
| }; |
| |
| var primitive_type = function () { |
| var num_type = integer_type() || float_type(); |
| if (num_type) return num_type; |
| all_ws(); |
| if (consume(ID, "boolean")) return "boolean"; |
| if (consume(ID, "byte")) return "byte"; |
| if (consume(ID, "octet")) return "octet"; |
| }; |
| |
| var const_value = function () { |
| if (consume(ID, "true")) return { type: "boolean", value: true }; |
| if (consume(ID, "false")) return { type: "boolean", value: false }; |
| if (consume(ID, "null")) return { type: "null" }; |
| if (consume(ID, "Infinity")) return { type: "Infinity", negative: false }; |
| if (consume(ID, "NaN")) return { type: "NaN" }; |
| var ret = consume(FLOAT) || consume(INT); |
| if (ret) return { type: "number", value: 1 * ret.value }; |
| var tok = consume(OTHER, "-"); |
| if (tok) { |
| if (consume(ID, "Infinity")) return { type: "Infinity", negative: true }; |
| else tokens.unshift(tok); |
| } |
| }; |
| |
| var type_suffix = function (obj) { |
| while (true) { |
| all_ws(); |
| if (consume(OTHER, "?")) { |
| if (obj.nullable) error("Can't nullable more than once"); |
| obj.nullable = true; |
| } |
| else if (consume(OTHER, "[")) { |
| all_ws(); |
| consume(OTHER, "]") || error("Unterminated array type"); |
| if (!obj.array) { |
| obj.array = 1; |
| obj.nullableArray = [obj.nullable]; |
| } |
| else { |
| obj.array++; |
| obj.nullableArray.push(obj.nullable); |
| } |
| obj.nullable = false; |
| } |
| else return; |
| } |
| }; |
| |
| var single_type = function () { |
| var prim = primitive_type() |
| , ret = { sequence: false, generic: null, nullable: false, array: false, union: false } |
| , name |
| , value |
| ; |
| if (prim) { |
| ret.idlType = prim; |
| } |
| else if (name = consume(ID)) { |
| value = name.value; |
| all_ws(); |
| // 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); |
| type_suffix(ret); |
| return ret; |
| } |
| else { |
| ret.idlType = value; |
| } |
| } |
| else { |
| return; |
| } |
| type_suffix(ret); |
| if (ret.nullable && !ret.array && ret.idlType === "any") error("Type any cannot be made nullable"); |
| return ret; |
| }; |
| |
| var union_type = function () { |
| all_ws(); |
| if (!consume(OTHER, "(")) return; |
| var ret = { sequence: false, generic: null, nullable: false, array: false, union: true, idlType: [] }; |
| var fst = type() || error("Union type with no content"); |
| ret.idlType.push(fst); |
| while (true) { |
| all_ws(); |
| if (!consume(ID, "or")) break; |
| var typ = type() || error("No type after 'or' in union type"); |
| ret.idlType.push(typ); |
| } |
| if (!consume(OTHER, ")")) error("Unterminated union type"); |
| type_suffix(ret); |
| return ret; |
| }; |
| |
| var type = function () { |
| return single_type() || union_type(); |
| }; |
| |
| var argument = function (store) { |
| var ret = { optional: false, variadic: false }; |
| ret.extAttrs = extended_attrs(store); |
| all_ws(store, "pea"); |
| var opt_token = consume(ID, "optional"); |
| if (opt_token) { |
| ret.optional = true; |
| all_ws(); |
| } |
| ret.idlType = type(); |
| if (!ret.idlType) { |
| if (opt_token) tokens.unshift(opt_token); |
| return; |
| } |
| var type_token = last_token; |
| if (!ret.optional) { |
| all_ws(); |
| if (tokens.length >= 3 && |
| tokens[0].type === "other" && tokens[0].value === "." && |
| tokens[1].type === "other" && tokens[1].value === "." && |
| tokens[2].type === "other" && tokens[2].value === "." |
| ) { |
| tokens.shift(); |
| tokens.shift(); |
| tokens.shift(); |
| ret.variadic = true; |
| } |
| } |
| all_ws(); |
| var name = consume(ID); |
| if (!name) { |
| if (opt_token) tokens.unshift(opt_token); |
| tokens.unshift(type_token); |
| return; |
| } |
| ret.name = name.value; |
| if (ret.optional) { |
| all_ws(); |
| ret["default"] = default_(); |
| } |
| return ret; |
| }; |
| |
| var argument_list = function (store) { |
| var ret = [] |
| , arg = argument(store ? ret : null) |
| ; |
| if (!arg) return; |
| ret.push(arg); |
| while (true) { |
| all_ws(store ? ret : null); |
| if (!consume(OTHER, ",")) return ret; |
| var nxt = argument(store ? ret : null) || error("Trailing comma in arguments list"); |
| ret.push(nxt); |
| } |
| }; |
| |
| var type_pair = function () { |
| all_ws(); |
| var k = type(); |
| if (!k) return; |
| all_ws() |
| if (!consume(OTHER, ",")) return; |
| all_ws(); |
| var v = type(); |
| if (!v) return; |
| return [k, v]; |
| }; |
| |
| var simple_extended_attr = function (store) { |
| 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(); |
| 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)] |
| else if (pair = type_pair()) { |
| ret.typePair = pair; |
| } |
| // [Constructor()] |
| else { |
| ret["arguments"] = []; |
| } |
| all_ws(); |
| consume(OTHER, ")") || error("Unexpected token in extended attribute argument list or type pair"); |
| } |
| return ret; |
| }; |
| |
| // Note: we parse something simpler than the official syntax. It's all that ever |
| // seems to be used |
| var extended_attrs = function (store) { |
| var eas = []; |
| all_ws(store); |
| if (!consume(OTHER, "[")) return eas; |
| eas[0] = simple_extended_attr(store) || error("Extended attribute with not content"); |
| all_ws(); |
| while (consume(OTHER, ",")) { |
| eas.push(simple_extended_attr(store) || error("Trailing comma in extended attribute")); |
| all_ws(); |
| } |
| consume(OTHER, "]") || error("No end of extended attribute"); |
| return eas; |
| }; |
| |
| 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"); |
| if (!consume(ID, "const")) return; |
| var ret = { type: "const", nullable: false }; |
| all_ws(); |
| var typ = primitive_type(); |
| if (!typ) { |
| typ = consume(ID) || error("No type for const"); |
| typ = typ.value; |
| } |
| ret.idlType = typ; |
| all_ws(); |
| if (consume(OTHER, "?")) { |
| ret.nullable = true; |
| all_ws(); |
| } |
| var name = consume(ID) || error("No name for const"); |
| ret.name = name.value; |
| all_ws(); |
| consume(OTHER, "=") || error("No value assignment for const"); |
| all_ws(); |
| var cnt = const_value(); |
| if (cnt) ret.value = cnt; |
| else error("No value for const"); |
| all_ws(); |
| consume(OTHER, ";") || error("Unterminated const"); |
| return ret; |
| }; |
| |
| var inheritance = function () { |
| all_ws(); |
| if (consume(OTHER, ":")) { |
| all_ws(); |
| var inh = consume(ID) || error ("No type in inheritance"); |
| return inh.value; |
| } |
| }; |
| |
| var operation_rest = function (ret, store) { |
| all_ws(); |
| if (!ret) ret = {}; |
| var name = consume(ID); |
| ret.name = name ? name.value : null; |
| all_ws(); |
| consume(OTHER, "(") || error("Invalid operation"); |
| ret["arguments"] = argument_list(store) || []; |
| all_ws(); |
| consume(OTHER, ")") || error("Unterminated operation"); |
| all_ws(); |
| consume(OTHER, ";") || error("Unterminated operation"); |
| return ret; |
| }; |
| |
| var callback = function (store) { |
| all_ws(store, "pea"); |
| var ret; |
| if (!consume(ID, "callback")) return; |
| all_ws(); |
| var tok = consume(ID, "interface"); |
| if (tok) { |
| tokens.unshift(tok); |
| ret = interface_(); |
| ret.type = "callback interface"; |
| return ret; |
| } |
| var name = consume(ID) || error("No name for callback"); |
| ret = { type: "callback", name: name.value }; |
| all_ws(); |
| consume(OTHER, "=") || error("No assignment in callback"); |
| all_ws(); |
| ret.idlType = return_type(); |
| all_ws(); |
| consume(OTHER, "(") || error("No arguments in callback"); |
| ret["arguments"] = argument_list(store) || []; |
| all_ws(); |
| consume(OTHER, ")") || error("Unterminated callback"); |
| all_ws(); |
| consume(OTHER, ";") || error("Unterminated callback"); |
| return ret; |
| }; |
| |
| var attribute = function (store) { |
| all_ws(store, "pea"); |
| var grabbed = [] |
| , ret = { |
| type: "attribute" |
| , "static": false |
| , stringifier: false |
| , inherit: false |
| , readonly: false |
| }; |
| if (consume(ID, "static")) { |
| ret["static"] = true; |
| grabbed.push(last_token); |
| } |
| else if (consume(ID, "stringifier")) { |
| ret.stringifier = true; |
| grabbed.push(last_token); |
| } |
| var w = all_ws(); |
| if (w) grabbed.push(w); |
| if (consume(ID, "inherit")) { |
| if (ret["static"] || ret.stringifier) error("Cannot have a static or stringifier inherit"); |
| ret.inherit = true; |
| grabbed.push(last_token); |
| var w = all_ws(); |
| if (w) grabbed.push(w); |
| } |
| if (consume(ID, "readonly")) { |
| ret.readonly = true; |
| grabbed.push(last_token); |
| var w = all_ws(); |
| if (w) grabbed.push(w); |
| } |
| if (!consume(ID, "attribute")) { |
| tokens = grabbed.concat(tokens); |
| return; |
| } |
| all_ws(); |
| ret.idlType = type() || error("No type in attribute"); |
| if (ret.idlType.sequence) error("Attributes cannot accept sequence types"); |
| all_ws(); |
| var name = consume(ID) || error("No name in attribute"); |
| ret.name = name.value; |
| all_ws(); |
| consume(OTHER, ";") || error("Unterminated attribute"); |
| return ret; |
| }; |
| |
| var return_type = function () { |
| var typ = type(); |
| if (!typ) { |
| if (consume(ID, "void")) { |
| return "void"; |
| } |
| else error("No return type"); |
| } |
| return typ; |
| }; |
| |
| var operation = function (store) { |
| all_ws(store, "pea"); |
| var ret = { |
| type: "operation" |
| , getter: false |
| , setter: false |
| , creator: false |
| , deleter: false |
| , legacycaller: false |
| , "static": false |
| , stringifier: false |
| }; |
| while (true) { |
| all_ws(); |
| if (consume(ID, "getter")) ret.getter = true; |
| else if (consume(ID, "setter")) ret.setter = true; |
| else if (consume(ID, "creator")) ret.creator = true; |
| else if (consume(ID, "deleter")) ret.deleter = true; |
| else if (consume(ID, "legacycaller")) ret.legacycaller = true; |
| else break; |
| } |
| if (ret.getter || ret.setter || ret.creator || ret.deleter || ret.legacycaller) { |
| all_ws(); |
| ret.idlType = return_type(); |
| 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;- |
| 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(); |
| ret.type = "iterator"; |
| if (consume(ID, "object")) { |
| ret.iteratorObject = "object"; |
| } |
| else if (consume(OTHER, "=")) { |
| all_ws(); |
| var name = consume(ID) || error("No right hand side in iterator"); |
| ret.iteratorObject = name.value; |
| } |
| all_ws(); |
| consume(OTHER, ";") || error("Unterminated iterator"); |
| return ret; |
| } |
| else { |
| operation_rest(ret, store); |
| return ret; |
| } |
| }; |
| |
| var identifiers = function (arr) { |
| while (true) { |
| all_ws(); |
| if (consume(OTHER, ",")) { |
| all_ws(); |
| var name = consume(ID) || error("Trailing comma in identifiers list"); |
| arr.push(name.value); |
| } |
| else break; |
| } |
| }; |
| |
| var serialiser = function (store) { |
| all_ws(store, "pea"); |
| if (!consume(ID, "serializer")) return; |
| var ret = { type: "serializer" }; |
| all_ws(); |
| if (consume(OTHER, "=")) { |
| all_ws(); |
| if (consume(OTHER, "{")) { |
| ret.patternMap = true; |
| all_ws(); |
| var id = consume(ID); |
| if (id && id.value === "getter") { |
| ret.names = ["getter"]; |
| } |
| else if (id && id.value === "inherit") { |
| ret.names = ["inherit"]; |
| identifiers(ret.names); |
| } |
| else if (id) { |
| ret.names = [id.value]; |
| identifiers(ret.names); |
| } |
| else { |
| ret.names = []; |
| } |
| all_ws(); |
| consume(OTHER, "}") || error("Unterminated serializer pattern map"); |
| } |
| else if (consume(OTHER, "[")) { |
| ret.patternList = true; |
| all_ws(); |
| var id = consume(ID); |
| if (id && id.value === "getter") { |
| ret.names = ["getter"]; |
| } |
| else if (id) { |
| ret.names = [id.value]; |
| identifiers(ret.names); |
| } |
| else { |
| ret.names = []; |
| } |
| all_ws(); |
| consume(OTHER, "]") || error("Unterminated serializer pattern list"); |
| } |
| else { |
| var name = consume(ID) || error("Invalid serializer"); |
| ret.name = name.value; |
| } |
| all_ws(); |
| consume(OTHER, ";") || error("Unterminated serializer"); |
| return ret; |
| } |
| else if (consume(OTHER, ";")) { |
| // 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 |
| , members: mems |
| }; |
| if (!isPartial) ret.inheritance = inheritance() || null; |
| all_ws(); |
| consume(OTHER, "{") || error("Bodyless interface"); |
| while (true) { |
| all_ws(store ? mems : null); |
| if (consume(OTHER, "}")) { |
| all_ws(); |
| consume(OTHER, ";") || error("Missing semicolon after interface"); |
| 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 = (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"); |
| if (!consume(ID, "partial")) return; |
| var thing = dictionary(true, store) || |
| interface_(true, store) || |
| error("Partial doesn't apply to anything"); |
| thing.partial = true; |
| return thing; |
| }; |
| |
| var dictionary = function (isPartial, store) { |
| all_ws(isPartial ? null : store, "pea"); |
| if (!consume(ID, "dictionary")) return; |
| all_ws(); |
| var name = consume(ID) || error("No name for dictionary"); |
| var mems = [] |
| , ret = { |
| type: "dictionary" |
| , name: name.value |
| , partial: false |
| , members: mems |
| }; |
| if (!isPartial) ret.inheritance = inheritance() || null; |
| all_ws(); |
| 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": dflt |
| }); |
| all_ws(); |
| consume(OTHER, ";") || error("Unterminated dictionary member"); |
| } |
| }; |
| |
| var exception = function (store) { |
| all_ws(store, "pea"); |
| if (!consume(ID, "exception")) return; |
| all_ws(); |
| var name = consume(ID) || error("No name for exception"); |
| var mems = [] |
| , ret = { |
| type: "exception" |
| , name: name.value |
| , members: mems |
| }; |
| ret.inheritance = inheritance() || null; |
| all_ws(); |
| consume(OTHER, "{") || error("Bodyless exception"); |
| while (true) { |
| all_ws(store ? mems : null); |
| if (consume(OTHER, "}")) { |
| all_ws(); |
| consume(OTHER, ";") || error("Missing semicolon after exception"); |
| return ret; |
| } |
| var ea = extended_attrs(store ? mems : null); |
| all_ws(store ? mems : null, "pea"); |
| var cnt = const_(); |
| if (cnt) { |
| cnt.extAttrs = ea; |
| ret.members.push(cnt); |
| } |
| else { |
| var typ = type(); |
| all_ws(); |
| var name = consume(ID); |
| all_ws(); |
| if (!typ || !name || !consume(OTHER, ";")) error("Unknown member in exception body"); |
| ret.members.push({ |
| type: "field" |
| , name: name.value |
| , idlType: typ |
| , extAttrs: ea |
| }); |
| } |
| } |
| }; |
| |
| var enum_ = function (store) { |
| all_ws(store, "pea"); |
| if (!consume(ID, "enum")) return; |
| all_ws(); |
| var name = consume(ID) || error("No name for enum"); |
| var vals = [] |
| , ret = { |
| type: "enum" |
| , 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(); |
| 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; |
| } |
| else { |
| saw_comma = false; |
| } |
| } |
| }; |
| |
| var typedef = function (store) { |
| all_ws(store, "pea"); |
| if (!consume(ID, "typedef")) return; |
| var ret = { |
| type: "typedef" |
| }; |
| all_ws(); |
| ret.typeExtAttrs = extended_attrs(); |
| all_ws(store, "tpea"); |
| ret.idlType = type() || error("No type in typedef"); |
| all_ws(); |
| var name = consume(ID) || error("No name in typedef"); |
| ret.name = name.value; |
| all_ws(); |
| consume(OTHER, ";") || error("Unterminated typedef"); |
| return ret; |
| }; |
| |
| var implements_ = function (store) { |
| all_ws(store, "pea"); |
| var target = consume(ID); |
| if (!target) return; |
| var w = all_ws(); |
| if (consume(ID, "implements")) { |
| var ret = { |
| type: "implements" |
| , target: target.value |
| }; |
| all_ws(); |
| var imp = consume(ID) || error("Incomplete implements statement"); |
| ret["implements"] = imp.value; |
| all_ws(); |
| consume(OTHER, ";") || error("No terminating ; for implements statement"); |
| return ret; |
| } |
| else { |
| // rollback |
| tokens.unshift(w); |
| tokens.unshift(target); |
| } |
| }; |
| |
| var definition = function (store) { |
| return callback(store) || |
| interface_(false, store) || |
| partial(store) || |
| dictionary(false, store) || |
| exception(store) || |
| enum_(store) || |
| typedef(store) || |
| implements_(store) |
| ; |
| }; |
| |
| var definitions = function (store) { |
| if (!tokens.length) return []; |
| var defs = []; |
| while (true) { |
| var ea = extended_attrs(store ? defs : null) |
| , def = definition(store ? defs : null); |
| if (!def) { |
| if (ea.length) error("Stray extended attributes"); |
| break; |
| } |
| def.extAttrs = ea; |
| defs.push(def); |
| } |
| return defs; |
| }; |
| var res = definitions(opt.ws); |
| if (tokens.length) error("Unrecognised tokens"); |
| return res; |
| }; |
| |
| var inNode = typeof module !== "undefined" && module.exports |
| , obj = { |
| parse: function (str, opt) { |
| if (!opt) opt = {}; |
| var tokens = tokenise(str); |
| return parse(tokens, opt); |
| } |
| }; |
| |
| if (inNode) module.exports = obj; |
| else self.WebIDL2 = obj; |
| }()); |
