| 1 | | |
| 2 | | |
| 3 | 1 | (function () { |
| 4 | 1 | var tokenise = function (str) { |
| 5 | 47 | var tokens = [] |
| 6 | | , re = { |
| 7 | | "float": /^-?(([0-9]+\.[0-9]*|[0-9]*\.[0-9]+)([Ee][-+]?[0-9]+)?|[0-9]+[Ee][-+]?[0-9]+)/ |
| 8 | | , "integer": /^-?(0([Xx][0-9A-Fa-f]+|[0-7]*)|[1-9][0-9]*)/ |
| 9 | | , "identifier": /^[A-Z_a-z][0-9A-Z_a-z]*/ |
| 10 | | , "string": /^"[^"]*"/ |
| 11 | | , "whitespace": /^(?:[\t\n\r ]+|[\t\n\r ]*((\/\/.*|\/\*(.|\n|\r)*?\*\/)[\t\n\r ]*))+/ |
| 12 | | , "other": /^[^\t\n\r 0-9A-Z_a-z]/ |
| 13 | | } |
| 14 | | , types = [] |
| 15 | | ; |
| 16 | 329 | for (var k in re) types.push(k); |
| 17 | 47 | while (str.length > 0) { |
| 18 | 2914 | var matched = false; |
| 19 | 2914 | for (var i = 0, n = types.length; i < n; i++) { |
| 20 | 13325 | var type = types[i]; |
| 21 | 13325 | str = str.replace(re[type], function (tok) { |
| 22 | 2914 | tokens.push({ type: type, value: tok }); |
| 23 | 2914 | matched = true; |
| 24 | 2914 | return ""; |
| 25 | | }); |
| 26 | 16239 | if (matched) break; |
| 27 | | } |
| 28 | 5828 | if (matched) continue; |
| 29 | 0 | throw new Error("Token stream not progressing"); |
| 30 | | } |
| 31 | 47 | return tokens; |
| 32 | | }; |
| 33 | | |
| 34 | 1 | var parse = function (tokens) { |
| 35 | 47 | var line = 1; |
| 36 | 47 | tokens = tokens.slice(); |
| 37 | | |
| 38 | 47 | var FLOAT = "float" |
| 39 | | , INT = "integer" |
| 40 | | , ID = "identifier" |
| 41 | | , STR = "string" |
| 42 | | , OTHER = "other" |
| 43 | | ; |
| 44 | | |
| 45 | 47 | var WebIDLParseError = function (str, line, input, tokens) { |
| 46 | 0 | this.message = str; |
| 47 | 0 | this.line = line; |
| 48 | 0 | this.input = input; |
| 49 | 0 | this.tokens = tokens; |
| 50 | | }; |
| 51 | 47 | WebIDLParseError.prototype.toString = function () { |
| 52 | 0 | return this.message + ", line " + this.line + " (tokens: '" + this.input + "')\n" + |
| 53 | | JSON.stringify(this.tokens, null, 4); |
| 54 | | }; |
| 55 | | |
| 56 | 47 | var error = function (str) { |
| 57 | 0 | var tok = "", numTokens = 0, maxTokens = 5; |
| 58 | 0 | while (numTokens < maxTokens && tokens.length > numTokens) { |
| 59 | 0 | tok += tokens[numTokens].value; |
| 60 | 0 | numTokens++; |
| 61 | | } |
| 62 | 0 | throw new WebIDLParseError(str, line, tok, tokens.slice(0, 5)); |
| 63 | | }; |
| 64 | | |
| 65 | 47 | var last_token = null; |
| 66 | | |
| 67 | 47 | var consume = function (type, value) { |
| 68 | 8778 | if (!tokens.length || tokens[0].type !== type) return; |
| 69 | 5470 | if (typeof value === "undefined" || tokens[0].value === value) { |
| 70 | 1738 | last_token = tokens.shift(); |
| 71 | 1738 | return last_token; |
| 72 | | } |
| 73 | | }; |
| 74 | | |
| 75 | 47 | var ws = function () { |
| 76 | 6961 | if (!tokens.length) return; |
| 77 | | // console.log("tokens.length", tokens.length, tokens[0]); |
| 78 | 6115 | if (tokens[0].type === "whitespace") { |
| 79 | 1172 | var t = tokens.shift(); |
| 80 | 2294 | t.value.replace(/\n/g, function (m) { line++; return m; }); |
| 81 | 1172 | return t; |
| 82 | | } |
| 83 | | }; |
| 84 | | |
| 85 | 47 | var all_ws = function () { |
| 86 | 5366 | var t = { type: "whitespace", value: "" }; |
| 87 | 5366 | while (true) { |
| 88 | 6538 | var w = ws(); |
| 89 | 11904 | if (!w) break; |
| 90 | 1172 | t.value += w.value; |
| 91 | | } |
| 92 | 6538 | if (t.value.length > 0) return t; |
| 93 | | }; |
| 94 | | |
| 95 | 47 | var integer_type = function () { |
| 96 | 273 | var ret = ""; |
| 97 | 273 | all_ws(); |
| 98 | 312 | if (consume(ID, "unsigned")) ret = "unsigned "; |
| 99 | 273 | all_ws(); |
| 100 | 287 | if (consume(ID, "short")) return ret + "short"; |
| 101 | 259 | if (consume(ID, "long")) { |
| 102 | 41 | ret += "long"; |
| 103 | 41 | all_ws(); |
| 104 | 43 | if (consume(ID, "long")) return ret + " long"; |
| 105 | 39 | return ret; |
| 106 | | } |
| 107 | 218 | if (ret) error("Failed to parse integer type"); |
| 108 | | }; |
| 109 | | |
| 110 | 47 | var float_type = function () { |
| 111 | 218 | var ret = ""; |
| 112 | 218 | all_ws(); |
| 113 | 222 | if (consume(ID, "unrestricted")) ret = "unrestricted "; |
| 114 | 218 | all_ws(); |
| 115 | 257 | if (consume(ID, "float")) return ret + "float"; |
| 116 | 182 | if (consume(ID, "double")) return ret + "double"; |
| 117 | 176 | if (ret) error("Failed to parse float type"); |
| 118 | | }; |
| 119 | | |
| 120 | 47 | var primitive_type = function () { |
| 121 | 273 | var num_type = integer_type() || float_type(); |
| 122 | 370 | if (num_type) return num_type; |
| 123 | 176 | all_ws(); |
| 124 | 186 | if (consume(ID, "boolean")) return "boolean"; |
| 125 | 167 | if (consume(ID, "byte")) return "byte"; |
| 126 | 168 | if (consume(ID, "octet")) return "octet"; |
| 127 | | }; |
| 128 | | |
| 129 | 47 | var const_value = function () { |
| 130 | 17 | if (consume(ID, "true")) return true; |
| 131 | 19 | if (consume(ID, "false")) return false; |
| 132 | 17 | if (consume(ID, "null")) return null; |
| 133 | 14 | if (consume(ID, "Infinity")) return Infinity; |
| 134 | 13 | if (consume(ID, "NaN")) return NaN; |
| 135 | 11 | var ret = consume(FLOAT) || consume(INT); |
| 136 | 19 | if (ret) return 1 * ret.value; |
| 137 | 3 | var tok = consume(OTHER, "-"); |
| 138 | 3 | if (tok) { |
| 139 | 2 | if (consume(ID, "Infinity")) return -Infinity; |
| 140 | 0 | else tokens.unshift(tok); |
| 141 | | } |
| 142 | | }; |
| 143 | | |
| 144 | 47 | var type_suffix = function (obj) { |
| 145 | 249 | while (true) { |
| 146 | 263 | all_ws(); |
| 147 | 263 | if (consume(OTHER, "?")) { |
| 148 | 11 | if (obj.nullable) error("Can't nullable more than once"); |
| 149 | 11 | obj.nullable = true; |
| 150 | | } |
| 151 | 252 | else if (consume(OTHER, "[")) { |
| 152 | 3 | all_ws(); |
| 153 | 3 | consume(OTHER, "]") || error("Unterminated array type"); |
| 154 | 5 | if (!obj.array) obj.array = 1; |
| 155 | 1 | else obj.array++; |
| 156 | | } |
| 157 | 249 | else return; |
| 158 | | } |
| 159 | | }; |
| 160 | | |
| 161 | 47 | var single_type = function () { |
| 162 | 261 | var prim = primitive_type() |
| 163 | | , ret = { sequence: false, nullable: false, array: false, union: false } |
| 164 | | ; |
| 165 | 261 | if (prim) { |
| 166 | 99 | ret.idlType = prim; |
| 167 | | } |
| 168 | 162 | else if (consume(ID, "sequence")) { |
| 169 | 4 | all_ws(); |
| 170 | 4 | if (!consume(OTHER, "<")) { |
| 171 | 0 | ret.idlType = "sequence"; |
| 172 | | } |
| 173 | | else { |
| 174 | 4 | ret.sequence = true; |
| 175 | 4 | ret.idlType = type() || error("Error parsing sequence type"); |
| 176 | 4 | all_ws(); |
| 177 | 4 | if (!consume(OTHER, ">")) error("Unterminated sequence"); |
| 178 | 4 | all_ws(); |
| 179 | 5 | if (consume(OTHER, "?")) ret.nullable = true; |
| 180 | 4 | return ret; |
| 181 | | } |
| 182 | | } |
| 183 | | else { |
| 184 | 158 | var name = consume(ID); |
| 185 | 169 | if (!name) return; |
| 186 | 147 | ret.idlType = name.value; |
| 187 | | } |
| 188 | 246 | type_suffix(ret); |
| 189 | 246 | if (ret.nullable && ret.idlType === "any") error("Type any cannot be made nullable"); |
| 190 | 246 | return ret; |
| 191 | | }; |
| 192 | | |
| 193 | 47 | var union_type = function () { |
| 194 | 11 | all_ws(); |
| 195 | 19 | if (!consume(OTHER, "(")) return; |
| 196 | 3 | var ret = { sequence: false, nullable: false, array: false, union: true, idlType: [] }; |
| 197 | 3 | var fst = type() || error("Union type with no content"); |
| 198 | 3 | ret.idlType.push(fst); |
| 199 | 3 | while (true) { |
| 200 | 7 | all_ws(); |
| 201 | 10 | if (!consume(ID, "or")) break; |
| 202 | 4 | var typ = type() || error("No type after 'or' in union type"); |
| 203 | 4 | ret.idlType.push(typ); |
| 204 | | } |
| 205 | 3 | if (!consume(OTHER, ")")) error("Unterminated union type"); |
| 206 | 3 | type_suffix(ret); |
| 207 | 3 | return ret; |
| 208 | | }; |
| 209 | | |
| 210 | 47 | var type = function () { |
| 211 | 261 | return single_type() || union_type(); |
| 212 | | }; |
| 213 | | |
| 214 | 47 | var argument = function () { |
| 215 | 79 | var ret = { optional: false, variadic: false }; |
| 216 | 79 | ret.extAttrs = extended_attrs(); |
| 217 | 79 | all_ws(); |
| 218 | 79 | if (consume(ID, "optional")) { |
| 219 | 2 | ret.optional = true; |
| 220 | 2 | all_ws(); |
| 221 | | } |
| 222 | 79 | ret.type = type(); |
| 223 | 87 | if (!ret.type) return; |
| 224 | 71 | if (!ret.optional) { |
| 225 | 69 | all_ws(); |
| 226 | 69 | if (tokens.length >= 3 && |
| 227 | | tokens[0].type === "other" && tokens[0].value === "." && |
| 228 | | tokens[1].type === "other" && tokens[1].value === "." && |
| 229 | | tokens[2].type === "other" && tokens[2].value === "." |
| 230 | | ) { |
| 231 | 4 | tokens.shift(); |
| 232 | 4 | tokens.shift(); |
| 233 | 4 | tokens.shift(); |
| 234 | 4 | ret.variadic = true; |
| 235 | | } |
| 236 | | } |
| 237 | 71 | all_ws(); |
| 238 | 71 | var name = consume(ID) || error("No name in argument"); |
| 239 | 71 | ret.name = name.value; |
| 240 | 71 | if (ret.optional) { |
| 241 | 2 | all_ws(); |
| 242 | 2 | ret["default"] = default_(); |
| 243 | | } |
| 244 | 71 | return ret; |
| 245 | | }; |
| 246 | | |
| 247 | 47 | var argument_list = function () { |
| 248 | 59 | var arg = argument(), ret = []; |
| 249 | 67 | if (!arg) return ret; |
| 250 | 51 | ret.push(arg); |
| 251 | 51 | while (true) { |
| 252 | 71 | all_ws(); |
| 253 | 122 | if (!consume(OTHER, ",")) return ret; |
| 254 | 20 | all_ws(); |
| 255 | 20 | var nxt = argument() || error("Trailing comma in arguments list"); |
| 256 | 20 | ret.push(nxt); |
| 257 | | } |
| 258 | | }; |
| 259 | | |
| 260 | 47 | var simple_extended_attr = function () { |
| 261 | 17 | all_ws(); |
| 262 | 17 | var name = consume(ID); |
| 263 | 17 | if (!name) return; |
| 264 | 17 | var ret = { |
| 265 | | name: name.value |
| 266 | | , "arguments": null |
| 267 | | }; |
| 268 | 17 | all_ws(); |
| 269 | 17 | var eq = consume(OTHER, "="); |
| 270 | 17 | if (eq) { |
| 271 | 5 | all_ws(); |
| 272 | 5 | ret.rhs = consume(ID); |
| 273 | 5 | if (!ret.rhs) return error("No right hand side to extended attribute assignment"); |
| 274 | | } |
| 275 | 17 | all_ws(); |
| 276 | 17 | if (consume(OTHER, "(")) { |
| 277 | 2 | ret["arguments"] = argument_list(); |
| 278 | 2 | all_ws(); |
| 279 | 2 | consume(OTHER, ")") || error("Unclosed argument in extended attribute"); |
| 280 | | } |
| 281 | 17 | return ret; |
| 282 | | }; |
| 283 | | |
| 284 | | // Note: we parse something simpler than the official syntax. It's all that ever |
| 285 | | // seems to be used |
| 286 | 47 | var extended_attrs = function () { |
| 287 | 415 | var eas = []; |
| 288 | 415 | all_ws(); |
| 289 | 815 | if (!consume(OTHER, "[")) return eas; |
| 290 | 15 | eas[0] = simple_extended_attr() || error("Extended attribute with not content"); |
| 291 | 15 | all_ws(); |
| 292 | 15 | while (consume(OTHER, ",")) { |
| 293 | 2 | all_ws(); |
| 294 | 2 | eas.push(simple_extended_attr() || error("Trailing comma in extended attribute")); |
| 295 | 2 | all_ws(); |
| 296 | | } |
| 297 | 15 | consume(OTHER, "]") || error("No end of extended attribute"); |
| 298 | 15 | return eas; |
| 299 | | }; |
| 300 | | |
| 301 | 47 | var default_ = function () { |
| 302 | 11 | all_ws(); |
| 303 | 11 | if (consume(OTHER, "=")) { |
| 304 | 5 | all_ws(); |
| 305 | 5 | var def = const_value(); |
| 306 | 5 | if (typeof def !== "undefined") { |
| 307 | 3 | return def; |
| 308 | | } |
| 309 | | else { |
| 310 | 2 | var str = consume(STR) || error("No value for default"); |
| 311 | 2 | return str; |
| 312 | | } |
| 313 | | } |
| 314 | | }; |
| 315 | | |
| 316 | 47 | var const_ = function () { |
| 317 | 180 | all_ws(); |
| 318 | 348 | if (!consume(ID, "const")) return; |
| 319 | 12 | var ret = { type: "const", nullable: false }; |
| 320 | 12 | all_ws(); |
| 321 | 12 | var typ = primitive_type(); |
| 322 | 12 | if (!typ) { |
| 323 | 0 | typ = consume(ID) || error("No type for const"); |
| 324 | 0 | typ = typ.value; |
| 325 | | } |
| 326 | 12 | ret.idlType = typ; |
| 327 | 12 | all_ws(); |
| 328 | 12 | if (consume(OTHER, "?")) { |
| 329 | 1 | ret.nullable = true; |
| 330 | 1 | all_ws(); |
| 331 | | } |
| 332 | 12 | var name = consume(ID) || error("No name for const"); |
| 333 | 12 | ret.name = name.value; |
| 334 | 12 | all_ws(); |
| 335 | 12 | consume(OTHER, "=") || error("No value assignment for const"); |
| 336 | 12 | all_ws(); |
| 337 | 12 | var cnt = const_value(); |
| 338 | 24 | if (typeof cnt !== "undefined") ret.value = cnt; |
| 339 | 0 | else error("No value for const"); |
| 340 | 12 | all_ws(); |
| 341 | 12 | consume(OTHER, ";") || error("Unterminated const"); |
| 342 | 12 | return ret; |
| 343 | | }; |
| 344 | | |
| 345 | 47 | var inheritance = function () { |
| 346 | 89 | all_ws(); |
| 347 | 89 | if (consume(OTHER, ":")) { |
| 348 | 9 | all_ws(); |
| 349 | 9 | var inh = consume(ID) || error ("No type in inheritance"); |
| 350 | 9 | return inh.value; |
| 351 | | } |
| 352 | | }; |
| 353 | | |
| 354 | 47 | var operation_rest = function (ret) { |
| 355 | 56 | all_ws(); |
| 356 | 57 | if (!ret) ret = {}; |
| 357 | 56 | var name = consume(ID); |
| 358 | 56 | ret.name = name ? name.value : null; |
| 359 | 56 | all_ws(); |
| 360 | 56 | consume(OTHER, "(") || error("Invalid operation"); |
| 361 | 56 | ret["arguments"] = argument_list(); |
| 362 | 56 | all_ws(); |
| 363 | 56 | consume(OTHER, ")") || error("Unterminated operation"); |
| 364 | 56 | all_ws(); |
| 365 | 56 | consume(OTHER, ";") || error("Unterminated operation"); |
| 366 | 56 | return ret; |
| 367 | | }; |
| 368 | | |
| 369 | 47 | var callback = function () { |
| 370 | 144 | all_ws(); |
| 371 | 144 | var ret; |
| 372 | 286 | if (!consume(ID, "callback")) return; |
| 373 | 2 | all_ws(); |
| 374 | 2 | var tok = consume(ID, "interface"); |
| 375 | 2 | if (tok) { |
| 376 | 1 | tokens.unshift(tok); |
| 377 | 1 | ret = interface_(); |
| 378 | 1 | ret.type = "callback interface"; |
| 379 | 1 | return ret; |
| 380 | | } |
| 381 | 1 | var name = consume(ID) || error("No name for callback"); |
| 382 | 1 | ret = { type: "callback", name: name.value }; |
| 383 | 1 | all_ws(); |
| 384 | 1 | consume(OTHER, "=") || error("No assignment in callback"); |
| 385 | 1 | all_ws(); |
| 386 | 1 | ret.idlType = return_type(); |
| 387 | 1 | all_ws(); |
| 388 | 1 | consume(OTHER, "(") || error("No arguments in callback"); |
| 389 | 1 | ret["arguments"] = argument_list(); |
| 390 | 1 | all_ws(); |
| 391 | 1 | consume(OTHER, ")") || error("Unterminated callback"); |
| 392 | 1 | all_ws(); |
| 393 | 1 | consume(OTHER, ";") || error("Unterminated callback"); |
| 394 | 1 | return ret; |
| 395 | | }; |
| 396 | | |
| 397 | 47 | var attribute = function () { |
| 398 | 154 | all_ws(); |
| 399 | 154 | var grabbed = [] |
| 400 | | , ret = { |
| 401 | | type: "attribute" |
| 402 | | , "static": false |
| 403 | | , stringifier: false |
| 404 | | , inherit: false |
| 405 | | , readonly: false |
| 406 | | }; |
| 407 | 154 | if (consume(ID, "static")) { |
| 408 | 2 | ret["static"] = true; |
| 409 | 2 | grabbed.push(last_token); |
| 410 | | } |
| 411 | 152 | else if (consume(ID, "stringifier")) { |
| 412 | 4 | ret.stringifier = true; |
| 413 | 4 | grabbed.push(last_token); |
| 414 | | } |
| 415 | 154 | var w = all_ws(); |
| 416 | 159 | if (w) grabbed.push(w); |
| 417 | 154 | if (consume(ID, "inherit")) { |
| 418 | 1 | if (ret["static"] || ret.stringifier) error("Cannot have a static or stringifier inherit"); |
| 419 | 1 | ret.inherit = true; |
| 420 | 1 | grabbed.push(last_token); |
| 421 | 1 | var w = all_ws(); |
| 422 | 2 | if (w) grabbed.push(w); |
| 423 | | } |
| 424 | 154 | if (consume(ID, "readonly")) { |
| 425 | 32 | ret.readonly = true; |
| 426 | 32 | grabbed.push(last_token); |
| 427 | 32 | var w = all_ws(); |
| 428 | 64 | if (w) grabbed.push(w); |
| 429 | | } |
| 430 | 154 | if (!consume(ID, "attribute")) { |
| 431 | 60 | tokens = grabbed.concat(tokens); |
| 432 | 60 | return; |
| 433 | | } |
| 434 | 94 | all_ws(); |
| 435 | 94 | ret.idlType = type() || error("No type in attribute"); |
| 436 | 94 | if (ret.idlType.sequence) error("Attributes cannot accept sequence types"); |
| 437 | 94 | all_ws(); |
| 438 | 94 | var name = consume(ID) || error("No name in attribute"); |
| 439 | 94 | ret.name = name.value; |
| 440 | 94 | all_ws(); |
| 441 | 94 | consume(OTHER, ";") || error("Unterminated attribute"); |
| 442 | 94 | return ret; |
| 443 | | }; |
| 444 | | |
| 445 | 47 | var return_type = function () { |
| 446 | 61 | var typ = type(); |
| 447 | 61 | if (!typ) { |
| 448 | 0 | if (consume(ID, "void")) { |
| 449 | 0 | return "void"; |
| 450 | | } |
| 451 | 0 | else error("No return type"); |
| 452 | | } |
| 453 | 61 | return typ; |
| 454 | | }; |
| 455 | | |
| 456 | 47 | var operation = function () { |
| 457 | 60 | all_ws(); |
| 458 | 60 | var ret = { |
| 459 | | type: "operation" |
| 460 | | , getter: false |
| 461 | | , setter: false |
| 462 | | , creator: false |
| 463 | | , deleter: false |
| 464 | | , legacycaller: false |
| 465 | | , "static": false |
| 466 | | , stringifier: false |
| 467 | | }; |
| 468 | 60 | while (true) { |
| 469 | 78 | all_ws(); |
| 470 | 87 | if (consume(ID, "getter")) ret.getter = true; |
| 471 | 74 | else if (consume(ID, "setter")) ret.setter = true; |
| 472 | 65 | else if (consume(ID, "creator")) ret.creator = true; |
| 473 | 65 | else if (consume(ID, "deleter")) ret.deleter = true; |
| 474 | 62 | else if (consume(ID, "legacycaller")) ret.legacycaller = true; |
| 475 | 60 | else break; |
| 476 | | } |
| 477 | 60 | if (ret.getter || ret.setter || ret.creator || ret.deleter || ret.legacycaller) { |
| 478 | 17 | all_ws(); |
| 479 | 17 | ret.idlType = return_type(); |
| 480 | 17 | operation_rest(ret); |
| 481 | 17 | return ret; |
| 482 | | } |
| 483 | 43 | if (consume(ID, "static")) { |
| 484 | 1 | ret["static"] = true; |
| 485 | 1 | ret.idlType = return_type(); |
| 486 | 1 | operation_rest(ret); |
| 487 | 1 | return ret; |
| 488 | | } |
| 489 | 42 | else if (consume(ID, "stringifier")) { |
| 490 | 3 | ret.stringifier = true; |
| 491 | 3 | all_ws(); |
| 492 | 4 | if (consume(OTHER, ";")) return ret; |
| 493 | 2 | ret.idlType = return_type(); |
| 494 | 2 | operation_rest(ret); |
| 495 | 2 | return ret; |
| 496 | | } |
| 497 | 39 | ret.idlType = return_type(); |
| 498 | 39 | all_ws(); |
| 499 | 39 | if (consume(ID, "iterator")) { |
| 500 | 4 | all_ws(); |
| 501 | 4 | ret.type = "iterator"; |
| 502 | 4 | if (consume(ID, "object")) { |
| 503 | 1 | ret.iteratorObject = "object"; |
| 504 | | } |
| 505 | 3 | else if (consume(OTHER, "=")) { |
| 506 | 2 | all_ws(); |
| 507 | 2 | var name = consume(ID) || error("No right hand side in iterator"); |
| 508 | 2 | ret.iteratorObject = name.value; |
| 509 | | } |
| 510 | 4 | all_ws(); |
| 511 | 4 | consume(OTHER, ";") || error("Unterminated iterator"); |
| 512 | 4 | return ret; |
| 513 | | } |
| 514 | | else { |
| 515 | 35 | operation_rest(ret); |
| 516 | 35 | return ret; |
| 517 | | } |
| 518 | | }; |
| 519 | | |
| 520 | 47 | var identifiers = function (arr) { |
| 521 | 5 | while (true) { |
| 522 | 11 | all_ws(); |
| 523 | 11 | if (consume(OTHER, ",")) { |
| 524 | 6 | all_ws(); |
| 525 | 6 | var name = consume(ID) || error("Trailing comma in identifiers list"); |
| 526 | 6 | arr.push(name.value); |
| 527 | | } |
| 528 | 5 | else break; |
| 529 | | } |
| 530 | | }; |
| 531 | | |
| 532 | 47 | var serialiser = function () { |
| 533 | 164 | all_ws(); |
| 534 | 318 | if (!consume(ID, "serializer")) return; |
| 535 | 10 | var ret = { type: "serializer" }; |
| 536 | 10 | all_ws(); |
| 537 | 10 | if (consume(OTHER, "=")) { |
| 538 | 8 | all_ws(); |
| 539 | 8 | if (consume(OTHER, "{")) { |
| 540 | 5 | ret.patternMap = true; |
| 541 | 5 | all_ws(); |
| 542 | 5 | var id = consume(ID); |
| 543 | 5 | if (id && id.value === "getter") { |
| 544 | 1 | ret.names = ["getter"]; |
| 545 | | } |
| 546 | 4 | else if (id && id.value === "inherit") { |
| 547 | 2 | ret.names = ["inherit"]; |
| 548 | 2 | identifiers(ret.names); |
| 549 | | } |
| 550 | 2 | else if (id) { |
| 551 | 2 | ret.names = [id.value]; |
| 552 | 2 | identifiers(ret.names); |
| 553 | | } |
| 554 | | else { |
| 555 | 0 | ret.names = []; |
| 556 | | } |
| 557 | 5 | all_ws(); |
| 558 | 5 | consume(OTHER, "}") || error("Unterminated serializer pattern map"); |
| 559 | | } |
| 560 | 3 | else if (consume(OTHER, "[")) { |
| 561 | 2 | ret.patternList = true; |
| 562 | 2 | all_ws(); |
| 563 | 2 | var id = consume(ID); |
| 564 | 2 | if (id && id.value === "getter") { |
| 565 | 1 | ret.names = ["getter"]; |
| 566 | | } |
| 567 | 1 | else if (id) { |
| 568 | 1 | ret.names = [id.value]; |
| 569 | 1 | identifiers(ret.names); |
| 570 | | } |
| 571 | | else { |
| 572 | 0 | ret.names = []; |
| 573 | | } |
| 574 | 2 | all_ws(); |
| 575 | 2 | consume(OTHER, "]") || error("Unterminated serializer pattern list"); |
| 576 | | } |
| 577 | | else { |
| 578 | 1 | var name = consume(ID) || error("Invalid serializer"); |
| 579 | 1 | ret.name = name.value; |
| 580 | | } |
| 581 | 8 | all_ws(); |
| 582 | 8 | consume(OTHER, ";") || error("Unterminated serializer"); |
| 583 | 8 | return ret; |
| 584 | | } |
| 585 | 2 | else if (consume(OTHER, ";")) { |
| 586 | | // noop, just parsing |
| 587 | | } |
| 588 | | else { |
| 589 | 1 | ret.idlType = return_type(); |
| 590 | 1 | all_ws(); |
| 591 | 1 | ret.operation = operation_rest(); |
| 592 | | } |
| 593 | 2 | return ret; |
| 594 | | }; |
| 595 | | |
| 596 | 47 | var interface_ = function (isPartial) { |
| 597 | 144 | all_ws(); |
| 598 | 210 | if (!consume(ID, "interface")) return; |
| 599 | 78 | all_ws(); |
| 600 | 78 | var name = consume(ID) || error("No name for interface"); |
| 601 | 78 | var ret = { |
| 602 | | type: "interface" |
| 603 | | , name: name.value |
| 604 | | , partial: false |
| 605 | | , members: [] |
| 606 | | }; |
| 607 | 155 | if (!isPartial) ret.inheritance = inheritance() || null; |
| 608 | 78 | all_ws(); |
| 609 | 78 | consume(OTHER, "{") || error("Bodyless interface"); |
| 610 | 78 | while (true) { |
| 611 | 251 | all_ws(); |
| 612 | 251 | if (consume(OTHER, "}")) { |
| 613 | 78 | all_ws(); |
| 614 | 78 | consume(OTHER, ";") || error("Missing semicolon after interface"); |
| 615 | 78 | return ret; |
| 616 | | } |
| 617 | 173 | var ea = extended_attrs(); |
| 618 | 173 | all_ws(); |
| 619 | 173 | var cnt = const_(); |
| 620 | 173 | if (cnt) { |
| 621 | 9 | cnt.extAttrs = ea; |
| 622 | 9 | ret.members.push(cnt); |
| 623 | 9 | continue; |
| 624 | | } |
| 625 | 164 | var mem = serialiser() || attribute() || operation() || error("Unknown member"); |
| 626 | 164 | mem.extAttrs = ea; |
| 627 | 164 | ret.members.push(mem); |
| 628 | | } |
| 629 | | }; |
| 630 | | |
| 631 | 47 | var partial = function () { |
| 632 | 66 | all_ws(); |
| 633 | 130 | if (!consume(ID, "partial")) return; |
| 634 | 2 | var thing = dictionary(true) || interface_(true) || error("Partial doesn't apply to anything"); |
| 635 | 2 | thing.partial = true; |
| 636 | 2 | return thing; |
| 637 | | }; |
| 638 | | |
| 639 | 47 | var dictionary = function (isPartial) { |
| 640 | 66 | all_ws(); |
| 641 | 128 | if (!consume(ID, "dictionary")) return; |
| 642 | 4 | all_ws(); |
| 643 | 4 | var name = consume(ID) || error("No name for dictionary"); |
| 644 | 4 | var ret = { |
| 645 | | type: "dictionary" |
| 646 | | , name: name.value |
| 647 | | , partial: false |
| 648 | | , members: [] |
| 649 | | }; |
| 650 | 7 | if (!isPartial) ret.inheritance = inheritance() || null; |
| 651 | 4 | all_ws(); |
| 652 | 4 | consume(OTHER, "{") || error("Bodyless dictionary"); |
| 653 | 4 | while (true) { |
| 654 | 13 | all_ws(); |
| 655 | 13 | if (consume(OTHER, "}")) { |
| 656 | 4 | all_ws(); |
| 657 | 4 | consume(OTHER, ";") || error("Missing semicolon after dictionary"); |
| 658 | 4 | return ret; |
| 659 | | } |
| 660 | 9 | var ea = extended_attrs(); |
| 661 | 9 | all_ws(); |
| 662 | 9 | var typ = type() || error("No type for dictionary member"); |
| 663 | 9 | all_ws(); |
| 664 | 9 | var name = consume(ID) || error("No name for dictionary member"); |
| 665 | 9 | ret.members.push({ |
| 666 | | type: "field" |
| 667 | | , name: name.value |
| 668 | | , idlType: typ |
| 669 | | , extAttrs: ea |
| 670 | | , "default": default_() |
| 671 | | }); |
| 672 | 9 | all_ws(); |
| 673 | 9 | consume(OTHER, ";") || error("Unterminated dictionary member"); |
| 674 | | } |
| 675 | | }; |
| 676 | | |
| 677 | 47 | var exception = function () { |
| 678 | 61 | all_ws(); |
| 679 | 113 | if (!consume(ID, "exception")) return; |
| 680 | 9 | all_ws(); |
| 681 | 9 | var name = consume(ID) || error("No name for exception"); |
| 682 | 9 | var ret = { |
| 683 | | type: "exception" |
| 684 | | , name: name.value |
| 685 | | , members: [] |
| 686 | | }; |
| 687 | 9 | ret.inheritance = inheritance() || null; |
| 688 | 9 | all_ws(); |
| 689 | 9 | consume(OTHER, "{") || error("Bodyless exception"); |
| 690 | 9 | while (true) { |
| 691 | 16 | all_ws(); |
| 692 | 16 | if (consume(OTHER, "}")) { |
| 693 | 9 | all_ws(); |
| 694 | 9 | consume(OTHER, ";") || error("Missing semicolon after exception"); |
| 695 | 9 | return ret; |
| 696 | | } |
| 697 | 7 | var ea = extended_attrs(); |
| 698 | 7 | all_ws(); |
| 699 | 7 | var cnt = const_(); |
| 700 | 7 | if (cnt) { |
| 701 | 3 | cnt.extAttrs = ea; |
| 702 | 3 | ret.members.push(cnt); |
| 703 | | } |
| 704 | | else { |
| 705 | 4 | var typ = type(); |
| 706 | 4 | all_ws(); |
| 707 | 4 | var name = consume(ID); |
| 708 | 4 | all_ws(); |
| 709 | 4 | if (!typ || !name || !consume(OTHER, ";")) error("Unknown member in exception body"); |
| 710 | 4 | ret.members.push({ |
| 711 | | type: "field" |
| 712 | | , name: name.value |
| 713 | | , idlType: typ |
| 714 | | , extAttrs: ea |
| 715 | | }); |
| 716 | | } |
| 717 | | } |
| 718 | | }; |
| 719 | | |
| 720 | 47 | var enum_ = function () { |
| 721 | 52 | all_ws(); |
| 722 | 103 | if (!consume(ID, "enum")) return; |
| 723 | 1 | all_ws(); |
| 724 | 1 | var name = consume(ID) || error("No name for enum"); |
| 725 | 1 | var ret = { |
| 726 | | type: "enum" |
| 727 | | , name: name.value |
| 728 | | , values: [] |
| 729 | | }; |
| 730 | 1 | all_ws(); |
| 731 | 1 | consume(OTHER, "{") || error("No curly for enum"); |
| 732 | 1 | var saw_comma = false; |
| 733 | 1 | while (true) { |
| 734 | 4 | all_ws(); |
| 735 | 4 | if (consume(OTHER, "}")) { |
| 736 | 1 | all_ws(); |
| 737 | 1 | if (saw_comma) error("Trailing comma in enum"); |
| 738 | 1 | consume(OTHER, ";") || error("No semicolon after enum"); |
| 739 | 1 | return ret; |
| 740 | | } |
| 741 | 3 | var val = consume(STR) || error("Unexpected value in enum"); |
| 742 | 3 | ret.values.push(val.value.replace(/"/g, "")); |
| 743 | 3 | all_ws(); |
| 744 | 3 | if (consume(OTHER, ",")) { |
| 745 | 2 | all_ws(); |
| 746 | 2 | saw_comma = true; |
| 747 | | } |
| 748 | | else { |
| 749 | 1 | saw_comma = false; |
| 750 | | } |
| 751 | | } |
| 752 | | }; |
| 753 | | |
| 754 | 47 | var typedef = function () { |
| 755 | 51 | all_ws(); |
| 756 | 99 | if (!consume(ID, "typedef")) return; |
| 757 | 3 | var ret = { |
| 758 | | type: "typedef" |
| 759 | | }; |
| 760 | 3 | all_ws(); |
| 761 | 3 | ret.extAttrs = extended_attrs(); |
| 762 | 3 | all_ws(); |
| 763 | 3 | ret.idlType = type() || error("No type in typedef"); |
| 764 | 3 | all_ws(); |
| 765 | 3 | var name = consume(ID) || error("No name in typedef"); |
| 766 | 3 | ret.name = name.value; |
| 767 | 3 | all_ws(); |
| 768 | 3 | consume(OTHER, ";") || error("Unterminated typedef"); |
| 769 | 3 | return ret; |
| 770 | | }; |
| 771 | | |
| 772 | 47 | var implements_ = function () { |
| 773 | 48 | all_ws(); |
| 774 | 48 | var target = consume(ID); |
| 775 | 95 | if (!target) return; |
| 776 | 1 | var w = all_ws(); |
| 777 | 1 | if (consume(ID, "implements")) { |
| 778 | 1 | var ret = { |
| 779 | | type: "implements" |
| 780 | | , target: target.value |
| 781 | | }; |
| 782 | 1 | all_ws(); |
| 783 | 1 | var imp = consume(ID) || error("Incomplete implements statement"); |
| 784 | 1 | ret["implements"] = imp.value; |
| 785 | 1 | all_ws(); |
| 786 | 1 | consume(OTHER, ";") || error("No terminating ; for implements statement"); |
| 787 | 1 | return ret; |
| 788 | | } |
| 789 | | else { |
| 790 | | // rollback |
| 791 | 0 | tokens.unshift(w); |
| 792 | 0 | tokens.unshift(target); |
| 793 | | } |
| 794 | | }; |
| 795 | | |
| 796 | 47 | var definition = function () { |
| 797 | 144 | return callback() || |
| 798 | | interface_() || |
| 799 | | partial() || |
| 800 | | dictionary() || |
| 801 | | exception() || |
| 802 | | enum_() || |
| 803 | | typedef() || |
| 804 | | implements_() |
| 805 | | ; |
| 806 | | }; |
| 807 | | |
| 808 | 47 | var definitions = function () { |
| 809 | 47 | if (!tokens.length) return []; |
| 810 | 47 | var defs = []; |
| 811 | 47 | while (true) { |
| 812 | 144 | var ea = extended_attrs() |
| 813 | | , def = definition(); |
| 814 | 144 | if (!def) { |
| 815 | 47 | if (ea.length) error("Stray extended attributes"); |
| 816 | 47 | break; |
| 817 | | } |
| 818 | 97 | def.extAttrs = ea; |
| 819 | 97 | defs.push(def); |
| 820 | | } |
| 821 | 47 | return defs; |
| 822 | | }; |
| 823 | 47 | var res = definitions(); |
| 824 | 47 | if (tokens.length) error("Unrecognised tokens"); |
| 825 | 47 | return res; |
| 826 | | }; |
| 827 | | |
| 828 | 1 | var obj = { |
| 829 | | parse: function (str) { |
| 830 | 47 | var tokens = tokenise(str); |
| 831 | | // console.log(tokens); |
| 832 | 47 | return parse(tokens); |
| 833 | | } |
| 834 | | }; |
| 835 | 1 | if (typeof module !== "undefined" && module.exports) { |
| 836 | 1 | module.exports = obj; |
| 837 | | } |
| 838 | | else { |
| 839 | 0 | window.WebIDL2 = obj; |
| 840 | | } |
| 841 | | }()); |