| | 1 | // jslint.js |
| | 2 | // 2012-02-23 |
| | 3 | |
| | 4 | // Copyright (c) 2002 Douglas Crockford (www.JSLint.com) |
| | 5 | |
| | 6 | // Permission is hereby granted, free of charge, to any person obtaining a copy |
| | 7 | // of this software and associated documentation files (the "Software"), to deal |
| | 8 | // in the Software without restriction, including without limitation the rights |
| | 9 | // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
| | 10 | // copies of the Software, and to permit persons to whom the Software is |
| | 11 | // furnished to do so, subject to the following conditions: |
| | 12 | |
| | 13 | // The above copyright notice and this permission notice shall be included in |
| | 14 | // all copies or substantial portions of the Software. |
| | 15 | |
| | 16 | // The Software shall be used for Good, not Evil. |
| | 17 | |
| | 18 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| | 19 | // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| | 20 | // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| | 21 | // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| | 22 | // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| | 23 | // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
| | 24 | // SOFTWARE. |
| | 25 | |
| | 26 | // WARNING: JSLint will hurt your feelings. |
| | 27 | |
| | 28 | // JSLINT is a global function. It takes two parameters. |
| | 29 | |
| | 30 | // var myResult = JSLINT(source, option); |
| | 31 | |
| | 32 | // The first parameter is either a string or an array of strings. If it is a |
| | 33 | // string, it will be split on '\n' or '\r'. If it is an array of strings, it |
| | 34 | // is assumed that each string represents one line. The source can be a |
| | 35 | // JavaScript text, or HTML text, or a JSON text, or a CSS text. |
| | 36 | |
| | 37 | // The second parameter is an optional object of options that control the |
| | 38 | // operation of JSLINT. Most of the options are booleans: They are all |
| | 39 | // optional and have a default value of false. One of the options, predef, |
| | 40 | // can be an array of names, which will be used to declare global variables, |
| | 41 | // or an object whose keys are used as global names, with a boolean value |
| | 42 | // that determines if they are assignable. |
| | 43 | |
| | 44 | // If it checks out, JSLINT returns true. Otherwise, it returns false. |
| | 45 | |
| | 46 | // If false, you can inspect JSLINT.errors to find out the problems. |
| | 47 | // JSLINT.errors is an array of objects containing these properties: |
| | 48 | |
| | 49 | // { |
| | 50 | // line : The line (relative to 0) at which the lint was found |
| | 51 | // character : The character (relative to 0) at which the lint was found |
| | 52 | // reason : The problem |
| | 53 | // evidence : The text line in which the problem occurred |
| | 54 | // raw : The raw message before the details were inserted |
| | 55 | // a : The first detail |
| | 56 | // b : The second detail |
| | 57 | // c : The third detail |
| | 58 | // d : The fourth detail |
| | 59 | // } |
| | 60 | |
| | 61 | // If a stopping error was found, a null will be the last element of the |
| | 62 | // JSLINT.errors array. A stopping error means that JSLint was not confident |
| | 63 | // enough to continue. It does not necessarily mean that the error was |
| | 64 | // especially heinous. |
| | 65 | |
| | 66 | // You can request a Function Report, which shows all of the functions |
| | 67 | // and the parameters and vars that they use. This can be used to find |
| | 68 | // implied global variables and other problems. The report is in HTML and |
| | 69 | // can be inserted in an HTML <body>. |
| | 70 | |
| | 71 | // var myReport = JSLINT.report(errors_only); |
| | 72 | |
| | 73 | // If errors_only is true, then the report will be limited to only errors. |
| | 74 | |
| | 75 | // You can request a data structure that contains JSLint's results. |
| | 76 | |
| | 77 | // var myData = JSLINT.data(); |
| | 78 | |
| | 79 | // It returns a structure with this form: |
| | 80 | |
| | 81 | // { |
| | 82 | // errors: [ |
| | 83 | // { |
| | 84 | // line: NUMBER, |
| | 85 | // character: NUMBER, |
| | 86 | // reason: STRING, |
| | 87 | // evidence: STRING |
| | 88 | // } |
| | 89 | // ], |
| | 90 | // functions: [ |
| | 91 | // { |
| | 92 | // name: STRING, |
| | 93 | // line: NUMBER, |
| | 94 | // last: NUMBER, |
| | 95 | // params: [ |
| | 96 | // { |
| | 97 | // string: STRING |
| | 98 | // } |
| | 99 | // ], |
| | 100 | // closure: [ |
| | 101 | // STRING |
| | 102 | // ], |
| | 103 | // var: [ |
| | 104 | // STRING |
| | 105 | // ], |
| | 106 | // exception: [ |
| | 107 | // STRING |
| | 108 | // ], |
| | 109 | // outer: [ |
| | 110 | // STRING |
| | 111 | // ], |
| | 112 | // unused: [ |
| | 113 | // STRING |
| | 114 | // ], |
| | 115 | // undef: [ |
| | 116 | // STRING |
| | 117 | // ], |
| | 118 | // global: [ |
| | 119 | // STRING |
| | 120 | // ], |
| | 121 | // label: [ |
| | 122 | // STRING |
| | 123 | // ] |
| | 124 | // } |
| | 125 | // ], |
| | 126 | // globals: [ |
| | 127 | // STRING |
| | 128 | // ], |
| | 129 | // member: { |
| | 130 | // STRING: NUMBER |
| | 131 | // }, |
| | 132 | // urls: [ |
| | 133 | // STRING |
| | 134 | // ], |
| | 135 | // json: BOOLEAN |
| | 136 | // } |
| | 137 | |
| | 138 | // Empty arrays will not be included. |
| | 139 | |
| | 140 | // You can obtain the parse tree that JSLint constructed while parsing. The |
| | 141 | // latest tree is kept in JSLINT.tree. A nice stringication can be produced |
| | 142 | // with |
| | 143 | |
| | 144 | // JSON.stringify(JSLINT.tree, [ |
| | 145 | // 'string', 'arity', 'name', 'first', |
| | 146 | // 'second', 'third', 'block', 'else' |
| | 147 | // ], 4)); |
| | 148 | |
| | 149 | // JSLint provides three directives. They look like slashstar comments, and |
| | 150 | // allow for setting options, declaring global variables, and establishing a |
| | 151 | // set of allowed property names. |
| | 152 | |
| | 153 | // These directives respect function scope. |
| | 154 | |
| | 155 | // The jslint directive is a special comment that can set one or more options. |
| | 156 | // The current option set is |
| | 157 | |
| | 158 | // anon true, if the space may be omitted in anonymous function declarations |
| | 159 | // bitwise true, if bitwise operators should be allowed |
| | 160 | // browser true, if the standard browser globals should be predefined |
| | 161 | // cap true, if upper case HTML should be allowed |
| | 162 | // 'continue' true, if the continuation statement should be tolerated |
| | 163 | // css true, if CSS workarounds should be tolerated |
| | 164 | // debug true, if debugger statements should be allowed |
| | 165 | // devel true, if logging should be allowed (console, alert, etc.) |
| | 166 | // eqeq true, if == should be allowed |
| | 167 | // es5 true, if ES5 syntax should be allowed |
| | 168 | // evil true, if eval should be allowed |
| | 169 | // forin true, if for in statements need not filter |
| | 170 | // fragment true, if HTML fragments should be allowed |
| | 171 | // indent the indentation factor |
| | 172 | // maxerr the maximum number of errors to allow |
| | 173 | // maxlen the maximum length of a source line |
| | 174 | // newcap true, if constructor names capitalization is ignored |
| | 175 | // node true, if Node.js globals should be predefined |
| | 176 | // nomen true, if names may have dangling _ |
| | 177 | // on true, if HTML event handlers should be allowed |
| | 178 | // passfail true, if the scan should stop on first error |
| | 179 | // plusplus true, if increment/decrement should be allowed |
| | 180 | // properties true, if all property names must be declared with /*properties*/ |
| | 181 | // regexp true, if the . should be allowed in regexp literals |
| | 182 | // rhino true, if the Rhino environment globals should be predefined |
| | 183 | // undef true, if variables can be declared out of order |
| | 184 | // unparam true, if unused parameters should be tolerated |
| | 185 | // sloppy true, if the 'use strict'; pragma is optional |
| | 186 | // sub true, if all forms of subscript notation are tolerated |
| | 187 | // vars true, if multiple var statements per function should be allowed |
| | 188 | // white true, if sloppy whitespace is tolerated |
| | 189 | // widget true if the Yahoo Widgets globals should be predefined |
| | 190 | // windows true, if MS Windows-specific globals should be predefined |
| | 191 | |
| | 192 | // For example: |
| | 193 | |
| | 194 | /*jslint |
| | 195 | evil: true, nomen: true, regexp: true |
| | 196 | */ |
| | 197 | |
| | 198 | // The properties directive declares an exclusive list of property names. |
| | 199 | // Any properties named in the program that are not in the list will |
| | 200 | // produce a warning. |
| | 201 | |
| | 202 | // For example: |
| | 203 | |
| | 204 | /*properties |
| | 205 | '\b', '\t', '\n', '\f', '\r', '!=', '!==', '"', '%', '\'', '(arguments)', |
| | 206 | '(begin)', '(breakage)', '(context)', '(error)', '(identifier)', '(line)', |
| | 207 | '(loopage)', '(name)', '(params)', '(scope)', '(token)', '(vars)', '(verb)', |
| | 208 | '*', '+', '-', '/', '<', '<=', '==', '===', '>', '>=', ADSAFE, |
| | 209 | Array, Date, Function, Object, '\\', a, a_label, a_not_allowed, |
| | 210 | a_not_defined, a_scope, abbr, acronym, address, adsafe, adsafe_a, |
| | 211 | adsafe_autocomplete, adsafe_bad_id, adsafe_div, adsafe_fragment, adsafe_go, |
| | 212 | adsafe_html, adsafe_id, adsafe_id_go, adsafe_lib, adsafe_lib_second, |
| | 213 | adsafe_missing_id, adsafe_name_a, adsafe_placement, adsafe_prefix_a, |
| | 214 | adsafe_script, adsafe_source, adsafe_subscript_a, adsafe_tag, all, |
| | 215 | already_defined, and, anon, applet, apply, approved, area, arity, article, |
| | 216 | aside, assign, assign_exception, assignment_function_expression, at, |
| | 217 | attribute_case_a, audio, autocomplete, avoid_a, b, background, |
| | 218 | 'background-attachment', 'background-color', 'background-image', |
| | 219 | 'background-position', 'background-repeat', bad_assignment, bad_color_a, |
| | 220 | bad_constructor, bad_entity, bad_html, bad_id_a, bad_in_a, bad_invocation, |
| | 221 | bad_name_a, bad_new, bad_number, bad_operand, bad_style, bad_type, bad_url_a, |
| | 222 | bad_wrap, base, bdo, big, bitwise, block, blockquote, body, border, |
| | 223 | 'border-bottom', 'border-bottom-color', 'border-bottom-left-radius', |
| | 224 | 'border-bottom-right-radius', 'border-bottom-style', 'border-bottom-width', |
| | 225 | 'border-collapse', 'border-color', 'border-left', 'border-left-color', |
| | 226 | 'border-left-style', 'border-left-width', 'border-radius', 'border-right', |
| | 227 | 'border-right-color', 'border-right-style', 'border-right-width', |
| | 228 | 'border-spacing', 'border-style', 'border-top', 'border-top-color', |
| | 229 | 'border-top-left-radius', 'border-top-right-radius', 'border-top-style', |
| | 230 | 'border-top-width', 'border-width', bottom, br, braille, browser, button, c, |
| | 231 | call, canvas, cap, caption, 'caption-side', center, charAt, charCodeAt, |
| | 232 | character, cite, clear, clip, closure, cm, code, col, colgroup, color, |
| | 233 | combine_var, command, conditional_assignment, confusing_a, confusing_regexp, |
| | 234 | constructor_name_a, content, continue, control_a, 'counter-increment', |
| | 235 | 'counter-reset', create, css, cursor, d, dangerous_comment, dangling_a, data, |
| | 236 | datalist, dd, debug, del, deleted, details, devel, dfn, dialog, dir, |
| | 237 | direction, display, disrupt, div, dl, dt, duplicate_a, edge, edition, else, |
| | 238 | em, embed, embossed, empty, 'empty-cells', empty_block, empty_case, |
| | 239 | empty_class, entityify, eqeq, errors, es5, eval, evidence, evil, ex, |
| | 240 | exception, exec, expected_a, expected_a_at_b_c, expected_a_b, |
| | 241 | expected_a_b_from_c_d, expected_at_a, expected_attribute_a, |
| | 242 | expected_attribute_value_a, expected_class_a, expected_fraction_a, |
| | 243 | expected_id_a, expected_identifier_a, expected_identifier_a_reserved, |
| | 244 | expected_lang_a, expected_linear_a, expected_media_a, expected_name_a, |
| | 245 | expected_nonstandard_style_attribute, expected_number_a, expected_operator_a, |
| | 246 | expected_percent_a, expected_positive_a, expected_pseudo_a, |
| | 247 | expected_selector_a, expected_small_a, expected_space_a_b, expected_string_a, |
| | 248 | expected_style_attribute, expected_style_pattern, expected_tagname_a, |
| | 249 | expected_type_a, f, fieldset, figure, filter, first, flag, float, floor, |
| | 250 | font, 'font-family', 'font-size', 'font-size-adjust', 'font-stretch', |
| | 251 | 'font-style', 'font-variant', 'font-weight', footer, forEach, for_if, forin, |
| | 252 | form, fragment, frame, frameset, from, fromCharCode, fud, funct, function, |
| | 253 | function_block, function_eval, function_loop, function_statement, |
| | 254 | function_strict, functions, global, globals, h1, h2, h3, h4, h5, h6, |
| | 255 | handheld, hasOwnProperty, head, header, height, hgroup, hr, |
| | 256 | 'hta:application', html, html_confusion_a, html_handlers, i, id, identifier, |
| | 257 | identifier_function, iframe, img, immed, implied_evil, in, indent, indexOf, |
| | 258 | infix_in, init, input, ins, insecure_a, isAlpha, isArray, isDigit, isNaN, |
| | 259 | join, jslint, json, kbd, keygen, keys, label, label_a_b, labeled, lang, lbp, |
| | 260 | leading_decimal_a, led, left, legend, length, 'letter-spacing', li, lib, |
| | 261 | line, 'line-height', link, 'list-style', 'list-style-image', |
| | 262 | 'list-style-position', 'list-style-type', map, margin, 'margin-bottom', |
| | 263 | 'margin-left', 'margin-right', 'margin-top', mark, 'marker-offset', match, |
| | 264 | 'max-height', 'max-width', maxerr, maxlen, member, menu, message, meta, |
| | 265 | meter, 'min-height', 'min-width', missing_a, missing_a_after_b, |
| | 266 | missing_option, missing_property, missing_space_a_b, missing_url, |
| | 267 | missing_use_strict, mixed, mm, mode, move_invocation, move_var, n, name, |
| | 268 | name_function, nav, nested_comment, newcap, node, noframes, nomen, noscript, |
| | 269 | not, not_a_constructor, not_a_defined, not_a_function, not_a_label, |
| | 270 | not_a_scope, not_greater, nud, number, object, octal_a, ol, on, opacity, |
| | 271 | open, optgroup, option, outer, outline, 'outline-color', 'outline-style', |
| | 272 | 'outline-width', output, overflow, 'overflow-x', 'overflow-y', p, padding, |
| | 273 | 'padding-bottom', 'padding-left', 'padding-right', 'padding-top', |
| | 274 | 'page-break-after', 'page-break-before', param, parameter_a_get_b, |
| | 275 | parameter_arguments_a, parameter_set_a, params, paren, parent, passfail, pc, |
| | 276 | plusplus, pop, position, postscript, pre, predef, print, progress, |
| | 277 | projection, properties, prototype, pt, push, px, q, quote, quotes, r, radix, |
| | 278 | range, raw, read_only, reason, redefinition_a, regexp, replace, report, |
| | 279 | reserved, reserved_a, rhino, right, rp, rt, ruby, safe, samp, scanned_a_b, |
| | 280 | screen, script, search, second, section, select, shift, slash_equal, slice, |
| | 281 | sloppy, small, sort, source, span, speech, split, src, statement_block, |
| | 282 | stopping, strange_loop, strict, string, strong, style, styleproperty, sub, |
| | 283 | subscript, substr, sup, supplant, t, table, 'table-layout', tag_a_in_b, |
| | 284 | tbody, td, test, 'text-align', 'text-decoration', 'text-indent', |
| | 285 | 'text-shadow', 'text-transform', textarea, tfoot, th, thead, third, thru, |
| | 286 | time, title, toLowerCase, toString, toUpperCase, token, too_long, too_many, |
| | 287 | top, tr, trailing_decimal_a, tree, tt, tty, tv, type, u, ul, unclosed, |
| | 288 | unclosed_comment, unclosed_regexp, undef, undefined, unescaped_a, |
| | 289 | unexpected_a, unexpected_char_a_b, unexpected_comment, unexpected_else, |
| | 290 | unexpected_property_a, unexpected_space_a_b, 'unicode-bidi', |
| | 291 | unnecessary_initialize, unnecessary_use, unparam, unreachable_a_b, |
| | 292 | unrecognized_style_attribute_a, unrecognized_tag_a, unsafe, unused, url, |
| | 293 | urls, use_array, use_braces, use_charAt, use_object, use_or, use_param, |
| | 294 | used_before_a, var, var_a_not, vars, 'vertical-align', video, visibility, |
| | 295 | was, weird_assignment, weird_condition, weird_new, weird_program, |
| | 296 | weird_relation, weird_ternary, white, 'white-space', widget, width, windows, |
| | 297 | 'word-spacing', 'word-wrap', wrap, wrap_immediate, wrap_regexp, |
| | 298 | write_is_wrong, writeable, 'z-index' |
| | 299 | */ |
| | 300 | |
| | 301 | // The global directive is used to declare global variables that can |
| | 302 | // be accessed by the program. If a declaration is true, then the variable |
| | 303 | // is writeable. Otherwise, it is read-only. |
| | 304 | |
| | 305 | // We build the application inside a function so that we produce only a single |
| | 306 | // global variable. That function will be invoked immediately, and its return |
| | 307 | // value is the JSLINT function itself. That function is also an object that |
| | 308 | // can contain data and other functions. |
| | 309 | |
| | 310 | var JSLINT = (function () { |
| | 311 | 'use strict'; |
| | 312 | |
| | 313 | function array_to_object(array, value) { |
| | 314 | |
| | 315 | // Make an object from an array of keys and a common value. |
| | 316 | |
| | 317 | var i, length = array.length, object = {}; |
| | 318 | for (i = 0; i < length; i += 1) { |
| | 319 | object[array[i]] = value; |
| | 320 | } |
| | 321 | return object; |
| | 322 | } |
| | 323 | |
| | 324 | |
| | 325 | var adsafe_id, // The widget's ADsafe id. |
| | 326 | adsafe_may, // The widget may load approved scripts. |
| | 327 | adsafe_top, // At the top of the widget script. |
| | 328 | adsafe_went, // ADSAFE.go has been called. |
| | 329 | allowed_option = { |
| | 330 | anon : true, |
| | 331 | bitwise : true, |
| | 332 | browser : true, |
| | 333 | cap : true, |
| | 334 | 'continue': true, |
| | 335 | css : true, |
| | 336 | debug : true, |
| | 337 | devel : true, |
| | 338 | eqeq : true, |
| | 339 | es5 : true, |
| | 340 | evil : true, |
| | 341 | forin : true, |
| | 342 | fragment : true, |
| | 343 | indent : 10, |
| | 344 | maxerr : 1000, |
| | 345 | maxlen : 256, |
| | 346 | newcap : true, |
| | 347 | node : true, |
| | 348 | nomen : true, |
| | 349 | on : true, |
| | 350 | passfail : true, |
| | 351 | plusplus : true, |
| | 352 | properties: true, |
| | 353 | regexp : true, |
| | 354 | rhino : true, |
| | 355 | undef : true, |
| | 356 | unparam : true, |
| | 357 | sloppy : true, |
| | 358 | sub : true, |
| | 359 | vars : true, |
| | 360 | white : true, |
| | 361 | widget : true, |
| | 362 | windows : true |
| | 363 | }, |
| | 364 | anonname, // The guessed name for anonymous functions. |
| | 365 | approved, // ADsafe approved urls. |
| | 366 | |
| | 367 | // These are operators that should not be used with the ! operator. |
| | 368 | |
| | 369 | bang = { |
| | 370 | '<' : true, |
| | 371 | '<=' : true, |
| | 372 | '==' : true, |
| | 373 | '===': true, |
| | 374 | '!==': true, |
| | 375 | '!=' : true, |
| | 376 | '>' : true, |
| | 377 | '>=' : true, |
| | 378 | '+' : true, |
| | 379 | '-' : true, |
| | 380 | '*' : true, |
| | 381 | '/' : true, |
| | 382 | '%' : true |
| | 383 | }, |
| | 384 | |
| | 385 | // These are property names that should not be permitted in the safe subset. |
| | 386 | |
| | 387 | banned = array_to_object([ |
| | 388 | 'arguments', 'callee', 'caller', 'constructor', 'eval', 'prototype', |
| | 389 | 'stack', 'unwatch', 'valueOf', 'watch' |
| | 390 | ], true), |
| | 391 | begin, // The root token |
| | 392 | |
| | 393 | // browser contains a set of global names that are commonly provided by a |
| | 394 | // web browser environment. |
| | 395 | |
| | 396 | browser = array_to_object([ |
| | 397 | 'clearInterval', 'clearTimeout', 'document', 'event', 'frames', |
| | 398 | 'history', 'Image', 'localStorage', 'location', 'name', 'navigator', |
| | 399 | 'Option', 'parent', 'screen', 'sessionStorage', 'setInterval', |
| | 400 | 'setTimeout', 'Storage', 'window', 'XMLHttpRequest' |
| | 401 | ], false), |
| | 402 | |
| | 403 | // bundle contains the text messages. |
| | 404 | |
| | 405 | bundle = { |
| | 406 | a_label: "'{a}' is a statement label.", |
| | 407 | a_not_allowed: "'{a}' is not allowed.", |
| | 408 | a_not_defined: "'{a}' is not defined.", |
| | 409 | a_scope: "'{a}' used out of scope.", |
| | 410 | adsafe_a: "ADsafe violation: '{a}'.", |
| | 411 | adsafe_autocomplete: "ADsafe autocomplete violation.", |
| | 412 | adsafe_bad_id: "ADSAFE violation: bad id.", |
| | 413 | adsafe_div: "ADsafe violation: Wrap the widget in a div.", |
| | 414 | adsafe_fragment: "ADSAFE: Use the fragment option.", |
| | 415 | adsafe_go: "ADsafe violation: Misformed ADSAFE.go.", |
| | 416 | adsafe_html: "Currently, ADsafe does not operate on whole HTML " + |
| | 417 | "documents. It operates on <div> fragments and .js files.", |
| | 418 | adsafe_id: "ADsafe violation: id does not match.", |
| | 419 | adsafe_id_go: "ADsafe violation: Missing ADSAFE.id or ADSAFE.go.", |
| | 420 | adsafe_lib: "ADsafe lib violation.", |
| | 421 | adsafe_lib_second: "ADsafe: The second argument to lib must be a function.", |
| | 422 | adsafe_missing_id: "ADSAFE violation: missing ID_.", |
| | 423 | adsafe_name_a: "ADsafe name violation: '{a}'.", |
| | 424 | adsafe_placement: "ADsafe script placement violation.", |
| | 425 | adsafe_prefix_a: "ADsafe violation: An id must have a '{a}' prefix", |
| | 426 | adsafe_script: "ADsafe script violation.", |
| | 427 | adsafe_source: "ADsafe unapproved script source.", |
| | 428 | adsafe_subscript_a: "ADsafe subscript '{a}'.", |
| | 429 | adsafe_tag: "ADsafe violation: Disallowed tag '{a}'.", |
| | 430 | already_defined: "'{a}' is already defined.", |
| | 431 | and: "The '&&' subexpression should be wrapped in parens.", |
| | 432 | assign_exception: "Do not assign to the exception parameter.", |
| | 433 | assignment_function_expression: "Expected an assignment or " + |
| | 434 | "function call and instead saw an expression.", |
| | 435 | attribute_case_a: "Attribute '{a}' not all lower case.", |
| | 436 | avoid_a: "Avoid '{a}'.", |
| | 437 | bad_assignment: "Bad assignment.", |
| | 438 | bad_color_a: "Bad hex color '{a}'.", |
| | 439 | bad_constructor: "Bad constructor.", |
| | 440 | bad_entity: "Bad entity.", |
| | 441 | bad_html: "Bad HTML string", |
| | 442 | bad_id_a: "Bad id: '{a}'.", |
| | 443 | bad_in_a: "Bad for in variable '{a}'.", |
| | 444 | bad_invocation: "Bad invocation.", |
| | 445 | bad_name_a: "Bad name: '{a}'.", |
| | 446 | bad_new: "Do not use 'new' for side effects.", |
| | 447 | bad_number: "Bad number '{a}'.", |
| | 448 | bad_operand: "Bad operand.", |
| | 449 | bad_style: "Bad style.", |
| | 450 | bad_type: "Bad type.", |
| | 451 | bad_url_a: "Bad url '{a}'.", |
| | 452 | bad_wrap: "Do not wrap function literals in parens unless they " + |
| | 453 | "are to be immediately invoked.", |
| | 454 | combine_var: "Combine this with the previous 'var' statement.", |
| | 455 | conditional_assignment: "Expected a conditional expression and " + |
| | 456 | "instead saw an assignment.", |
| | 457 | confusing_a: "Confusing use of '{a}'.", |
| | 458 | confusing_regexp: "Confusing regular expression.", |
| | 459 | constructor_name_a: "A constructor name '{a}' should start with " + |
| | 460 | "an uppercase letter.", |
| | 461 | control_a: "Unexpected control character '{a}'.", |
| | 462 | css: "A css file should begin with @charset 'UTF-8';", |
| | 463 | dangling_a: "Unexpected dangling '_' in '{a}'.", |
| | 464 | dangerous_comment: "Dangerous comment.", |
| | 465 | deleted: "Only properties should be deleted.", |
| | 466 | duplicate_a: "Duplicate '{a}'.", |
| | 467 | empty_block: "Empty block.", |
| | 468 | empty_case: "Empty case.", |
| | 469 | empty_class: "Empty class.", |
| | 470 | es5: "This is an ES5 feature.", |
| | 471 | evil: "eval is evil.", |
| | 472 | expected_a: "Expected '{a}'.", |
| | 473 | expected_a_b: "Expected '{a}' and instead saw '{b}'.", |
| | 474 | expected_a_b_from_c_d: "Expected '{a}' to match '{b}' from line " + |
| | 475 | "{c} and instead saw '{d}'.", |
| | 476 | expected_at_a: "Expected an at-rule, and instead saw @{a}.", |
| | 477 | expected_a_at_b_c: "Expected '{a}' at column {b}, not column {c}.", |
| | 478 | expected_attribute_a: "Expected an attribute, and instead saw [{a}].", |
| | 479 | expected_attribute_value_a: "Expected an attribute value and " + |
| | 480 | "instead saw '{a}'.", |
| | 481 | expected_class_a: "Expected a class, and instead saw .{a}.", |
| | 482 | expected_fraction_a: "Expected a number between 0 and 1 and " + |
| | 483 | "instead saw '{a}'", |
| | 484 | expected_id_a: "Expected an id, and instead saw #{a}.", |
| | 485 | expected_identifier_a: "Expected an identifier and instead saw '{a}'.", |
| | 486 | expected_identifier_a_reserved: "Expected an identifier and " + |
| | 487 | "instead saw '{a}' (a reserved word).", |
| | 488 | expected_linear_a: "Expected a linear unit and instead saw '{a}'.", |
| | 489 | expected_lang_a: "Expected a lang code, and instead saw :{a}.", |
| | 490 | expected_media_a: "Expected a CSS media type, and instead saw '{a}'.", |
| | 491 | expected_name_a: "Expected a name and instead saw '{a}'.", |
| | 492 | expected_nonstandard_style_attribute: "Expected a non-standard " + |
| | 493 | "style attribute and instead saw '{a}'.", |
| | 494 | expected_number_a: "Expected a number and instead saw '{a}'.", |
| | 495 | expected_operator_a: "Expected an operator and instead saw '{a}'.", |
| | 496 | expected_percent_a: "Expected a percentage and instead saw '{a}'", |
| | 497 | expected_positive_a: "Expected a positive number and instead saw '{a}'", |
| | 498 | expected_pseudo_a: "Expected a pseudo, and instead saw :{a}.", |
| | 499 | expected_selector_a: "Expected a CSS selector, and instead saw {a}.", |
| | 500 | expected_small_a: "Expected a small positive integer and instead saw '{a}'", |
| | 501 | expected_space_a_b: "Expected exactly one space between '{a}' and '{b}'.", |
| | 502 | expected_string_a: "Expected a string and instead saw {a}.", |
| | 503 | expected_style_attribute: "Excepted a style attribute, and instead saw '{a}'.", |
| | 504 | expected_style_pattern: "Expected a style pattern, and instead saw '{a}'.", |
| | 505 | expected_tagname_a: "Expected a tagName, and instead saw {a}.", |
| | 506 | expected_type_a: "Expected a type, and instead saw {a}.", |
| | 507 | for_if: "The body of a for in should be wrapped in an if " + |
| | 508 | "statement to filter unwanted properties from the prototype.", |
| | 509 | function_block: "Function statements should not be placed in blocks. " + |
| | 510 | "Use a function expression or move the statement to the top of " + |
| | 511 | "the outer function.", |
| | 512 | function_eval: "The Function constructor is eval.", |
| | 513 | function_loop: "Don't make functions within a loop.", |
| | 514 | function_statement: "Function statements are not invocable. " + |
| | 515 | "Wrap the whole function invocation in parens.", |
| | 516 | function_strict: "Use the function form of 'use strict'.", |
| | 517 | html_confusion_a: "HTML confusion in regular expression '<{a}'.", |
| | 518 | html_handlers: "Avoid HTML event handlers.", |
| | 519 | identifier_function: "Expected an identifier in an assignment " + |
| | 520 | "and instead saw a function invocation.", |
| | 521 | implied_evil: "Implied eval is evil. Pass a function instead of a string.", |
| | 522 | infix_in: "Unexpected 'in'. Compare with undefined, or use the " + |
| | 523 | "hasOwnProperty method instead.", |
| | 524 | insecure_a: "Insecure '{a}'.", |
| | 525 | isNaN: "Use the isNaN function to compare with NaN.", |
| | 526 | label_a_b: "Label '{a}' on '{b}' statement.", |
| | 527 | lang: "lang is deprecated.", |
| | 528 | leading_decimal_a: "A leading decimal point can be confused with a dot: '.{a}'.", |
| | 529 | missing_a: "Missing '{a}'.", |
| | 530 | missing_a_after_b: "Missing '{a}' after '{b}'.", |
| | 531 | missing_option: "Missing option value.", |
| | 532 | missing_property: "Missing property name.", |
| | 533 | missing_space_a_b: "Missing space between '{a}' and '{b}'.", |
| | 534 | missing_url: "Missing url.", |
| | 535 | missing_use_strict: "Missing 'use strict' statement.", |
| | 536 | mixed: "Mixed spaces and tabs.", |
| | 537 | move_invocation: "Move the invocation into the parens that " + |
| | 538 | "contain the function.", |
| | 539 | move_var: "Move 'var' declarations to the top of the function.", |
| | 540 | name_function: "Missing name in function statement.", |
| | 541 | nested_comment: "Nested comment.", |
| | 542 | not: "Nested not.", |
| | 543 | not_a_constructor: "Do not use {a} as a constructor.", |
| | 544 | not_a_defined: "'{a}' has not been fully defined yet.", |
| | 545 | not_a_function: "'{a}' is not a function.", |
| | 546 | not_a_label: "'{a}' is not a label.", |
| | 547 | not_a_scope: "'{a}' is out of scope.", |
| | 548 | not_greater: "'{a}' should not be greater than '{b}'.", |
| | 549 | octal_a: "Don't use octal: '{a}'. Use '\\u....' instead.", |
| | 550 | parameter_arguments_a: "Do not mutate parameter '{a}' when using 'arguments'.", |
| | 551 | parameter_a_get_b: "Unexpected parameter '{a}' in get {b} function.", |
| | 552 | parameter_set_a: "Expected parameter (value) in set {a} function.", |
| | 553 | radix: "Missing radix parameter.", |
| | 554 | read_only: "Read only.", |
| | 555 | redefinition_a: "Redefinition of '{a}'.", |
| | 556 | reserved_a: "Reserved name '{a}'.", |
| | 557 | scanned_a_b: "{a} ({b}% scanned).", |
| | 558 | slash_equal: "A regular expression literal can be confused with '/='.", |
| | 559 | statement_block: "Expected to see a statement and instead saw a block.", |
| | 560 | stopping: "Stopping. ", |
| | 561 | strange_loop: "Strange loop.", |
| | 562 | strict: "Strict violation.", |
| | 563 | subscript: "['{a}'] is better written in dot notation.", |
| | 564 | tag_a_in_b: "A '<{a}>' must be within '<{b}>'.", |
| | 565 | too_long: "Line too long.", |
| | 566 | too_many: "Too many errors.", |
| | 567 | trailing_decimal_a: "A trailing decimal point can be confused " + |
| | 568 | "with a dot: '.{a}'.", |
| | 569 | type: "type is unnecessary.", |
| | 570 | unclosed: "Unclosed string.", |
| | 571 | unclosed_comment: "Unclosed comment.", |
| | 572 | unclosed_regexp: "Unclosed regular expression.", |
| | 573 | unescaped_a: "Unescaped '{a}'.", |
| | 574 | unexpected_a: "Unexpected '{a}'.", |
| | 575 | unexpected_char_a_b: "Unexpected character '{a}' in {b}.", |
| | 576 | unexpected_comment: "Unexpected comment.", |
| | 577 | unexpected_else: "Unexpected 'else' after 'return'.", |
| | 578 | unexpected_property_a: "Unexpected /*property*/ '{a}'.", |
| | 579 | unexpected_space_a_b: "Unexpected space between '{a}' and '{b}'.", |
| | 580 | unnecessary_initialize: "It is not necessary to initialize '{a}' " + |
| | 581 | "to 'undefined'.", |
| | 582 | unnecessary_use: "Unnecessary 'use strict'.", |
| | 583 | unreachable_a_b: "Unreachable '{a}' after '{b}'.", |
| | 584 | unrecognized_style_attribute_a: "Unrecognized style attribute '{a}'.", |
| | 585 | unrecognized_tag_a: "Unrecognized tag '<{a}>'.", |
| | 586 | unsafe: "Unsafe character.", |
| | 587 | url: "JavaScript URL.", |
| | 588 | use_array: "Use the array literal notation [].", |
| | 589 | use_braces: "Spaces are hard to count. Use {{a}}.", |
| | 590 | use_charAt: "Use the charAt method.", |
| | 591 | use_object: "Use the object literal notation {}.", |
| | 592 | use_or: "Use the || operator.", |
| | 593 | use_param: "Use a named parameter.", |
| | 594 | used_before_a: "'{a}' was used before it was defined.", |
| | 595 | var_a_not: "Variable {a} was not declared correctly.", |
| | 596 | weird_assignment: "Weird assignment.", |
| | 597 | weird_condition: "Weird condition.", |
| | 598 | weird_new: "Weird construction. Delete 'new'.", |
| | 599 | weird_program: "Weird program.", |
| | 600 | weird_relation: "Weird relation.", |
| | 601 | weird_ternary: "Weird ternary.", |
| | 602 | wrap_immediate: "Wrap an immediate function invocation in parentheses " + |
| | 603 | "to assist the reader in understanding that the expression " + |
| | 604 | "is the result of a function, and not the function itself.", |
| | 605 | wrap_regexp: "Wrap the /regexp/ literal in parens to " + |
| | 606 | "disambiguate the slash operator.", |
| | 607 | write_is_wrong: "document.write can be a form of eval." |
| | 608 | }, |
| | 609 | comments_off, |
| | 610 | css_attribute_data, |
| | 611 | css_any, |
| | 612 | |
| | 613 | css_colorData = array_to_object([ |
| | 614 | "aliceblue", "antiquewhite", "aqua", "aquamarine", "azure", "beige", |
| | 615 | "bisque", "black", "blanchedalmond", "blue", "blueviolet", "brown", |
| | 616 | "burlywood", "cadetblue", "chartreuse", "chocolate", "coral", |
| | 617 | "cornflowerblue", "cornsilk", "crimson", "cyan", "darkblue", |
| | 618 | "darkcyan", "darkgoldenrod", "darkgray", "darkgreen", "darkkhaki", |
| | 619 | "darkmagenta", "darkolivegreen", "darkorange", "darkorchid", |
| | 620 | "darkred", "darksalmon", "darkseagreen", "darkslateblue", |
| | 621 | "darkslategray", "darkturquoise", "darkviolet", "deeppink", |
| | 622 | "deepskyblue", "dimgray", "dodgerblue", "firebrick", "floralwhite", |
| | 623 | "forestgreen", "fuchsia", "gainsboro", "ghostwhite", "gold", |
| | 624 | "goldenrod", "gray", "green", "greenyellow", "honeydew", "hotpink", |
| | 625 | "indianred", "indigo", "ivory", "khaki", "lavender", |
| | 626 | "lavenderblush", "lawngreen", "lemonchiffon", "lightblue", |
| | 627 | "lightcoral", "lightcyan", "lightgoldenrodyellow", "lightgreen", |
| | 628 | "lightpink", "lightsalmon", "lightseagreen", "lightskyblue", |
| | 629 | "lightslategray", "lightsteelblue", "lightyellow", "lime", |
| | 630 | "limegreen", "linen", "magenta", "maroon", "mediumaquamarine", |
| | 631 | "mediumblue", "mediumorchid", "mediumpurple", "mediumseagreen", |
| | 632 | "mediumslateblue", "mediumspringgreen", "mediumturquoise", |
| | 633 | "mediumvioletred", "midnightblue", "mintcream", "mistyrose", |
| | 634 | "moccasin", "navajowhite", "navy", "oldlace", "olive", "olivedrab", |
| | 635 | "orange", "orangered", "orchid", "palegoldenrod", "palegreen", |
| | 636 | "paleturquoise", "palevioletred", "papayawhip", "peachpuff", |
| | 637 | "peru", "pink", "plum", "powderblue", "purple", "red", "rosybrown", |
| | 638 | "royalblue", "saddlebrown", "salmon", "sandybrown", "seagreen", |
| | 639 | "seashell", "sienna", "silver", "skyblue", "slateblue", "slategray", |
| | 640 | "snow", "springgreen", "steelblue", "tan", "teal", "thistle", |
| | 641 | "tomato", "turquoise", "violet", "wheat", "white", "whitesmoke", |
| | 642 | "yellow", "yellowgreen", |
| | 643 | |
| | 644 | "activeborder", "activecaption", "appworkspace", "background", |
| | 645 | "buttonface", "buttonhighlight", "buttonshadow", "buttontext", |
| | 646 | "captiontext", "graytext", "highlight", "highlighttext", |
| | 647 | "inactiveborder", "inactivecaption", "inactivecaptiontext", |
| | 648 | "infobackground", "infotext", "menu", "menutext", "scrollbar", |
| | 649 | "threeddarkshadow", "threedface", "threedhighlight", |
| | 650 | "threedlightshadow", "threedshadow", "window", "windowframe", |
| | 651 | "windowtext" |
| | 652 | ], true), |
| | 653 | |
| | 654 | css_border_style, |
| | 655 | css_break, |
| | 656 | |
| | 657 | css_lengthData = { |
| | 658 | '%': true, |
| | 659 | 'cm': true, |
| | 660 | 'em': true, |
| | 661 | 'ex': true, |
| | 662 | 'in': true, |
| | 663 | 'mm': true, |
| | 664 | 'pc': true, |
| | 665 | 'pt': true, |
| | 666 | 'px': true |
| | 667 | }, |
| | 668 | |
| | 669 | css_media, |
| | 670 | css_overflow, |
| | 671 | |
| | 672 | descapes = { |
| | 673 | 'b': '\b', |
| | 674 | 't': '\t', |
| | 675 | 'n': '\n', |
| | 676 | 'f': '\f', |
| | 677 | 'r': '\r', |
| | 678 | '"': '"', |
| | 679 | '/': '/', |
| | 680 | '\\': '\\' |
| | 681 | }, |
| | 682 | |
| | 683 | devel = array_to_object([ |
| | 684 | 'alert', 'confirm', 'console', 'Debug', 'opera', 'prompt', 'WSH' |
| | 685 | ], false), |
| | 686 | directive, |
| | 687 | escapes = { |
| | 688 | '\b': '\\b', |
| | 689 | '\t': '\\t', |
| | 690 | '\n': '\\n', |
| | 691 | '\f': '\\f', |
| | 692 | '\r': '\\r', |
| | 693 | '\'': '\\\'', |
| | 694 | '"' : '\\"', |
| | 695 | '/' : '\\/', |
| | 696 | '\\': '\\\\' |
| | 697 | }, |
| | 698 | |
| | 699 | funct, // The current function, including the labels used in |
| | 700 | // the function, as well as (breakage), |
| | 701 | // (context), (loopage), (name), (params), (token), |
| | 702 | // (vars), (verb) |
| | 703 | |
| | 704 | functionicity = [ |
| | 705 | 'closure', 'exception', 'global', 'label', 'outer', 'undef', |
| | 706 | 'unused', 'var' |
| | 707 | ], |
| | 708 | |
| | 709 | functions, // All of the functions |
| | 710 | global_funct, // The global body |
| | 711 | global_scope, // The global scope |
| | 712 | html_tag = { |
| | 713 | a: {}, |
| | 714 | abbr: {}, |
| | 715 | acronym: {}, |
| | 716 | address: {}, |
| | 717 | applet: {}, |
| | 718 | area: {empty: true, parent: ' map '}, |
| | 719 | article: {}, |
| | 720 | aside: {}, |
| | 721 | audio: {}, |
| | 722 | b: {}, |
| | 723 | base: {empty: true, parent: ' head '}, |
| | 724 | bdo: {}, |
| | 725 | big: {}, |
| | 726 | blockquote: {}, |
| | 727 | body: {parent: ' html noframes '}, |
| | 728 | br: {empty: true}, |
| | 729 | button: {}, |
| | 730 | canvas: {parent: ' body p div th td '}, |
| | 731 | caption: {parent: ' table '}, |
| | 732 | center: {}, |
| | 733 | cite: {}, |
| | 734 | code: {}, |
| | 735 | col: {empty: true, parent: ' table colgroup '}, |
| | 736 | colgroup: {parent: ' table '}, |
| | 737 | command: {parent: ' menu '}, |
| | 738 | datalist: {}, |
| | 739 | dd: {parent: ' dl '}, |
| | 740 | del: {}, |
| | 741 | details: {}, |
| | 742 | dialog: {}, |
| | 743 | dfn: {}, |
| | 744 | dir: {}, |
| | 745 | div: {}, |
| | 746 | dl: {}, |
| | 747 | dt: {parent: ' dl '}, |
| | 748 | em: {}, |
| | 749 | embed: {}, |
| | 750 | fieldset: {}, |
| | 751 | figure: {}, |
| | 752 | font: {}, |
| | 753 | footer: {}, |
| | 754 | form: {}, |
| | 755 | frame: {empty: true, parent: ' frameset '}, |
| | 756 | frameset: {parent: ' html frameset '}, |
| | 757 | h1: {}, |
| | 758 | h2: {}, |
| | 759 | h3: {}, |
| | 760 | h4: {}, |
| | 761 | h5: {}, |
| | 762 | h6: {}, |
| | 763 | head: {parent: ' html '}, |
| | 764 | header: {}, |
| | 765 | hgroup: {}, |
| | 766 | hr: {empty: true}, |
| | 767 | 'hta:application': |
| | 768 | {empty: true, parent: ' head '}, |
| | 769 | html: {parent: '*'}, |
| | 770 | i: {}, |
| | 771 | iframe: {}, |
| | 772 | img: {empty: true}, |
| | 773 | input: {empty: true}, |
| | 774 | ins: {}, |
| | 775 | kbd: {}, |
| | 776 | keygen: {}, |
| | 777 | label: {}, |
| | 778 | legend: {parent: ' details fieldset figure '}, |
| | 779 | li: {parent: ' dir menu ol ul '}, |
| | 780 | link: {empty: true, parent: ' head '}, |
| | 781 | map: {}, |
| | 782 | mark: {}, |
| | 783 | menu: {}, |
| | 784 | meta: {empty: true, parent: ' head noframes noscript '}, |
| | 785 | meter: {}, |
| | 786 | nav: {}, |
| | 787 | noframes: {parent: ' html body '}, |
| | 788 | noscript: {parent: ' body head noframes '}, |
| | 789 | object: {}, |
| | 790 | ol: {}, |
| | 791 | optgroup: {parent: ' select '}, |
| | 792 | option: {parent: ' optgroup select '}, |
| | 793 | output: {}, |
| | 794 | p: {}, |
| | 795 | param: {empty: true, parent: ' applet object '}, |
| | 796 | pre: {}, |
| | 797 | progress: {}, |
| | 798 | q: {}, |
| | 799 | rp: {}, |
| | 800 | rt: {}, |
| | 801 | ruby: {}, |
| | 802 | samp: {}, |
| | 803 | script: {empty: true, parent: ' body div frame head iframe p pre span '}, |
| | 804 | section: {}, |
| | 805 | select: {}, |
| | 806 | small: {}, |
| | 807 | span: {}, |
| | 808 | source: {}, |
| | 809 | strong: {}, |
| | 810 | style: {parent: ' head ', empty: true}, |
| | 811 | sub: {}, |
| | 812 | sup: {}, |
| | 813 | table: {}, |
| | 814 | tbody: {parent: ' table '}, |
| | 815 | td: {parent: ' tr '}, |
| | 816 | textarea: {}, |
| | 817 | tfoot: {parent: ' table '}, |
| | 818 | th: {parent: ' tr '}, |
| | 819 | thead: {parent: ' table '}, |
| | 820 | time: {}, |
| | 821 | title: {parent: ' head '}, |
| | 822 | tr: {parent: ' table tbody thead tfoot '}, |
| | 823 | tt: {}, |
| | 824 | u: {}, |
| | 825 | ul: {}, |
| | 826 | 'var': {}, |
| | 827 | video: {} |
| | 828 | }, |
| | 829 | |
| | 830 | ids, // HTML ids |
| | 831 | in_block, |
| | 832 | indent, |
| | 833 | itself, // JSLint itself |
| | 834 | json_mode, |
| | 835 | lex, // the tokenizer |
| | 836 | lines, |
| | 837 | lookahead, |
| | 838 | node = array_to_object([ |
| | 839 | 'Buffer', 'clearInterval', 'clearTimeout', 'console', 'exports', |
| | 840 | 'global', 'module', 'process', 'querystring', 'require', |
| | 841 | 'setInterval', 'setTimeout', '__dirname', '__filename' |
| | 842 | ], false), |
| | 843 | node_js, |
| | 844 | numbery = array_to_object(['indexOf', 'lastIndexOf', 'search'], true), |
| | 845 | next_token, |
| | 846 | option, |
| | 847 | predefined, // Global variables defined by option |
| | 848 | prereg, |
| | 849 | prev_token, |
| | 850 | property, |
| | 851 | regexp_flag = array_to_object(['g', 'i', 'm'], true), |
| | 852 | return_this = function return_this() { |
| | 853 | return this; |
| | 854 | }, |
| | 855 | rhino = array_to_object([ |
| | 856 | 'defineClass', 'deserialize', 'gc', 'help', 'load', 'loadClass', |
| | 857 | 'print', 'quit', 'readFile', 'readUrl', 'runCommand', 'seal', |
| | 858 | 'serialize', 'spawn', 'sync', 'toint32', 'version' |
| | 859 | ], false), |
| | 860 | |
| | 861 | scope, // An object containing an object for each variable in scope |
| | 862 | semicolon_coda = array_to_object([';', '"', '\'', ')'], true), |
| | 863 | src, |
| | 864 | stack, |
| | 865 | |
| | 866 | // standard contains the global names that are provided by the |
| | 867 | // ECMAScript standard. |
| | 868 | |
| | 869 | standard = array_to_object([ |
| | 870 | 'Array', 'Boolean', 'Date', 'decodeURI', 'decodeURIComponent', |
| | 871 | 'encodeURI', 'encodeURIComponent', 'Error', 'eval', 'EvalError', |
| | 872 | 'Function', 'isFinite', 'isNaN', 'JSON', 'Math', 'Number', |
| | 873 | 'Object', 'parseInt', 'parseFloat', 'RangeError', 'ReferenceError', |
| | 874 | 'RegExp', 'String', 'SyntaxError', 'TypeError', 'URIError' |
| | 875 | ], false), |
| | 876 | |
| | 877 | strict_mode, |
| | 878 | syntax = {}, |
| | 879 | tab, |
| | 880 | token, |
| | 881 | urls, |
| | 882 | var_mode, |
| | 883 | warnings, |
| | 884 | |
| | 885 | // widget contains the global names which are provided to a Yahoo |
| | 886 | // (fna Konfabulator) widget. |
| | 887 | |
| | 888 | widget = array_to_object([ |
| | 889 | 'alert', 'animator', 'appleScript', 'beep', 'bytesToUIString', |
| | 890 | 'Canvas', 'chooseColor', 'chooseFile', 'chooseFolder', |
| | 891 | 'closeWidget', 'COM', 'convertPathToHFS', 'convertPathToPlatform', |
| | 892 | 'CustomAnimation', 'escape', 'FadeAnimation', 'filesystem', 'Flash', |
| | 893 | 'focusWidget', 'form', 'FormField', 'Frame', 'HotKey', 'Image', |
| | 894 | 'include', 'isApplicationRunning', 'iTunes', 'konfabulatorVersion', |
| | 895 | 'log', 'md5', 'MenuItem', 'MoveAnimation', 'openURL', 'play', |
| | 896 | 'Point', 'popupMenu', 'preferenceGroups', 'preferences', 'print', |
| | 897 | 'prompt', 'random', 'Rectangle', 'reloadWidget', 'ResizeAnimation', |
| | 898 | 'resolvePath', 'resumeUpdates', 'RotateAnimation', 'runCommand', |
| | 899 | 'runCommandInBg', 'saveAs', 'savePreferences', 'screen', |
| | 900 | 'ScrollBar', 'showWidgetPreferences', 'sleep', 'speak', 'Style', |
| | 901 | 'suppressUpdates', 'system', 'tellWidget', 'Text', 'TextArea', |
| | 902 | 'Timer', 'unescape', 'updateNow', 'URL', 'Web', 'widget', 'Window', |
| | 903 | 'XMLDOM', 'XMLHttpRequest', 'yahooCheckLogin', 'yahooLogin', |
| | 904 | 'yahooLogout' |
| | 905 | ], true), |
| | 906 | |
| | 907 | windows = array_to_object([ |
| | 908 | 'ActiveXObject', 'CScript', 'Debug', 'Enumerator', 'System', |
| | 909 | 'VBArray', 'WScript', 'WSH' |
| | 910 | ], false), |
| | 911 | |
| | 912 | // xmode is used to adapt to the exceptions in html parsing. |
| | 913 | // It can have these states: |
| | 914 | // '' .js script file |
| | 915 | // 'html' |
| | 916 | // 'outer' |
| | 917 | // 'script' |
| | 918 | // 'style' |
| | 919 | // 'scriptstring' |
| | 920 | // 'styleproperty' |
| | 921 | |
| | 922 | xmode, |
| | 923 | xquote, |
| | 924 | |
| | 925 | // Regular expressions. Some of these are stupidly long. |
| | 926 | |
| | 927 | // unsafe comment or string |
| | 928 | ax = /@cc|<\/?|script|\]\s*\]|<\s*!|</i, |
| | 929 | // carriage return, carriage return linefeed, or linefeed |
| | 930 | crlfx = /\r\n?|\n/, |
| | 931 | // unsafe characters that are silently deleted by one or more browsers |
| | 932 | cx = /[\u0000-\u001f\u007f-\u009f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/, |
| | 933 | // query characters for ids |
| | 934 | dx = /[\[\]\/\\"'*<>.&:(){}+=#]/, |
| | 935 | // html token |
| | 936 | hx = /^\s*(['"=>\/&#]|<(?:\/|\!(?:--)?)?|[a-zA-Z][a-zA-Z0-9_\-:]*|[0-9]+|--)/, |
| | 937 | // identifier |
| | 938 | ix = /^([a-zA-Z_$][a-zA-Z0-9_$]*)$/, |
| | 939 | // javascript url |
| | 940 | jx = /^(?:javascript|jscript|ecmascript|vbscript|mocha|livescript)\s*:/i, |
| | 941 | // star slash |
| | 942 | lx = /\*\/|\/\*/, |
| | 943 | // characters in strings that need escapement |
| | 944 | nx = /[\u0000-\u001f'\\\u007f-\u009f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g, |
| | 945 | // outer html token |
| | 946 | ox = /[>&]|<[\/!]?|--/, |
| | 947 | // attributes characters |
| | 948 | qx = /[^a-zA-Z0-9+\-_\/ ]/, |
| | 949 | // style |
| | 950 | sx = /^\s*([{}:#%.=,>+\[\]@()"';]|[*$\^~]=|[a-zA-Z_][a-zA-Z0-9_\-]*|[0-9]+|<\/|\/\*)/, |
| | 951 | ssx = /^\s*([@#!"'};:\-%.=,+\[\]()*_]|[a-zA-Z][a-zA-Z0-9._\-]*|\/\*?|\d+(?:\.\d+)?|<\/)/, |
| | 952 | // token |
| | 953 | tx = /^\s*([(){}\[\]\?.,:;'"~#@`]|={1,3}|\/(\*(jslint|properties|property|members?|globals?)?|=|\/)?|\*[\/=]?|\+(?:=|\++)?|-(?:=|-+)?|[\^%]=?|&[&=]?|\|[|=]?|>{1,3}=?|<(?:[\/=!]|\!(\[|--)?|<=?)?|\!={0,2}|[a-zA-Z_$][a-zA-Z0-9_$]*|[0-9]+(?:[xX][0-9a-fA-F]+|\.[0-9]*)?(?:[eE][+\-]?[0-9]+)?)/, |
| | 954 | // url badness |
| | 955 | ux = /&|\+|\u00AD|\.\.|\/\*|%[^;]|base64|url|expression|data|mailto|script/i, |
| | 956 | |
| | 957 | rx = { |
| | 958 | outer: hx, |
| | 959 | html: hx, |
| | 960 | style: sx, |
| | 961 | styleproperty: ssx |
| | 962 | }; |
| | 963 | |
| | 964 | |
| | 965 | function F() {} // Used by Object.create |
| | 966 | |
| | 967 | // Provide critical ES5 functions to ES3. |
| | 968 | |
| | 969 | if (typeof Array.prototype.filter !== 'function') { |
| | 970 | Array.prototype.filter = function (f) { |
| | 971 | var i, length = this.length, result = [], value; |
| | 972 | for (i = 0; i < length; i += 1) { |
| | 973 | try { |
| | 974 | value = this[i]; |
| | 975 | if (f(value)) { |
| | 976 | result.push(value); |
| | 977 | } |
| | 978 | } catch (ignore) { |
| | 979 | } |
| | 980 | } |
| | 981 | return result; |
| | 982 | }; |
| | 983 | } |
| | 984 | |
| | 985 | if (typeof Array.prototype.forEach !== 'function') { |
| | 986 | Array.prototype.forEach = function (f) { |
| | 987 | var i, length = this.length; |
| | 988 | for (i = 0; i < length; i += 1) { |
| | 989 | try { |
| | 990 | f(this[i]); |
| | 991 | } catch (ignore) { |
| | 992 | } |
| | 993 | } |
| | 994 | }; |
| | 995 | } |
| | 996 | |
| | 997 | if (typeof Array.isArray !== 'function') { |
| | 998 | Array.isArray = function (o) { |
| | 999 | return Object.prototype.toString.apply(o) === '[object Array]'; |
| | 1000 | }; |
| | 1001 | } |
| | 1002 | |
| | 1003 | if (!Object.prototype.hasOwnProperty.call(Object, 'create')) { |
| | 1004 | Object.create = function (o) { |
| | 1005 | F.prototype = o; |
| | 1006 | return new F(); |
| | 1007 | }; |
| | 1008 | } |
| | 1009 | |
| | 1010 | if (typeof Object.keys !== 'function') { |
| | 1011 | Object.keys = function (o) { |
| | 1012 | var array = [], key; |
| | 1013 | for (key in o) { |
| | 1014 | if (Object.prototype.hasOwnProperty.call(o, key)) { |
| | 1015 | array.push(key); |
| | 1016 | } |
| | 1017 | } |
| | 1018 | return array; |
| | 1019 | }; |
| | 1020 | } |
| | 1021 | |
| | 1022 | if (typeof String.prototype.entityify !== 'function') { |
| | 1023 | String.prototype.entityify = function () { |
| | 1024 | return this |
| | 1025 | .replace(/&/g, '&') |
| | 1026 | .replace(/</g, '<') |
| | 1027 | .replace(/>/g, '>'); |
| | 1028 | }; |
| | 1029 | } |
| | 1030 | |
| | 1031 | if (typeof String.prototype.isAlpha !== 'function') { |
| | 1032 | String.prototype.isAlpha = function () { |
| | 1033 | return (this >= 'a' && this <= 'z\uffff') || |
| | 1034 | (this >= 'A' && this <= 'Z\uffff'); |
| | 1035 | }; |
| | 1036 | } |
| | 1037 | |
| | 1038 | if (typeof String.prototype.isDigit !== 'function') { |
| | 1039 | String.prototype.isDigit = function () { |
| | 1040 | return (this >= '0' && this <= '9'); |
| | 1041 | }; |
| | 1042 | } |
| | 1043 | |
| | 1044 | if (typeof String.prototype.supplant !== 'function') { |
| | 1045 | String.prototype.supplant = function (o) { |
| | 1046 | return this.replace(/\{([^{}]*)\}/g, function (a, b) { |
| | 1047 | var replacement = o[b]; |
| | 1048 | return typeof replacement === 'string' || |
| | 1049 | typeof replacement === 'number' ? replacement : a; |
| | 1050 | }); |
| | 1051 | }; |
| | 1052 | } |
| | 1053 | |
| | 1054 | |
| | 1055 | function sanitize(a) { |
| | 1056 | |
| | 1057 | // Escapify a troublesome character. |
| | 1058 | |
| | 1059 | return escapes[a] || |
| | 1060 | '\\u' + ('0000' + a.charCodeAt().toString(16)).slice(-4); |
| | 1061 | } |
| | 1062 | |
| | 1063 | |
| | 1064 | function add_to_predefined(group) { |
| | 1065 | Object.keys(group).forEach(function (name) { |
| | 1066 | predefined[name] = group[name]; |
| | 1067 | }); |
| | 1068 | } |
| | 1069 | |
| | 1070 | |
| | 1071 | function assume() { |
| | 1072 | if (!option.safe) { |
| | 1073 | if (option.rhino) { |
| | 1074 | add_to_predefined(rhino); |
| | 1075 | option.rhino = false; |
| | 1076 | } |
| | 1077 | if (option.devel) { |
| | 1078 | add_to_predefined(devel); |
| | 1079 | option.devel = false; |
| | 1080 | } |
| | 1081 | if (option.browser) { |
| | 1082 | add_to_predefined(browser); |
| | 1083 | option.browser = false; |
| | 1084 | } |
| | 1085 | if (option.windows) { |
| | 1086 | add_to_predefined(windows); |
| | 1087 | option.windows = false; |
| | 1088 | } |
| | 1089 | if (option.node) { |
| | 1090 | add_to_predefined(node); |
| | 1091 | option.node = false; |
| | 1092 | node_js = true; |
| | 1093 | } |
| | 1094 | if (option.widget) { |
| | 1095 | add_to_predefined(widget); |
| | 1096 | option.widget = false; |
| | 1097 | } |
| | 1098 | } |
| | 1099 | } |
| | 1100 | |
| | 1101 | |
| | 1102 | // Produce an error warning. |
| | 1103 | |
| | 1104 | function artifact(tok) { |
| | 1105 | if (!tok) { |
| | 1106 | tok = next_token; |
| | 1107 | } |
| | 1108 | return tok.number || tok.string; |
| | 1109 | } |
| | 1110 | |
| | 1111 | function quit(message, line, character) { |
| | 1112 | throw { |
| | 1113 | name: 'JSLintError', |
| | 1114 | line: line, |
| | 1115 | character: character, |
| | 1116 | message: bundle.scanned_a_b.supplant({ |
| | 1117 | a: message, |
| | 1118 | b: Math.floor((line / lines.length) * 100) |
| | 1119 | }) |
| | 1120 | }; |
| | 1121 | } |
| | 1122 | |
| | 1123 | function warn(message, offender, a, b, c, d) { |
| | 1124 | var character, line, warning; |
| | 1125 | offender = offender || next_token; // ~~ |
| | 1126 | line = offender.line || 0; |
| | 1127 | character = offender.from || 0; |
| | 1128 | warning = { |
| | 1129 | id: '(error)', |
| | 1130 | raw: bundle[message] || message, |
| | 1131 | evidence: lines[line - 1] || '', |
| | 1132 | line: line, |
| | 1133 | character: character, |
| | 1134 | a: a || (offender.id === '(number)' |
| | 1135 | ? String(offender.number) |
| | 1136 | : offender.string), |
| | 1137 | b: b, |
| | 1138 | c: c, |
| | 1139 | d: d |
| | 1140 | }; |
| | 1141 | warning.reason = warning.raw.supplant(warning); |
| | 1142 | JSLINT.errors.push(warning); |
| | 1143 | if (option.passfail) { |
| | 1144 | quit(bundle.stopping, line, character); |
| | 1145 | } |
| | 1146 | warnings += 1; |
| | 1147 | if (warnings >= option.maxerr) { |
| | 1148 | quit(bundle.too_many, line, character); |
| | 1149 | } |
| | 1150 | return warning; |
| | 1151 | } |
| | 1152 | |
| | 1153 | function warn_at(message, line, character, a, b, c, d) { |
| | 1154 | return warn(message, { |
| | 1155 | line: line, |
| | 1156 | from: character |
| | 1157 | }, a, b, c, d); |
| | 1158 | } |
| | 1159 | |
| | 1160 | function stop(message, offender, a, b, c, d) { |
| | 1161 | var warning = warn(message, offender, a, b, c, d); |
| | 1162 | quit(bundle.stopping, warning.line, warning.character); |
| | 1163 | } |
| | 1164 | |
| | 1165 | function stop_at(message, line, character, a, b, c, d) { |
| | 1166 | return stop(message, { |
| | 1167 | line: line, |
| | 1168 | from: character |
| | 1169 | }, a, b, c, d); |
| | 1170 | } |
| | 1171 | |
| | 1172 | function expected_at(at) { |
| | 1173 | if (!option.white && next_token.from !== at) { |
| | 1174 | warn('expected_a_at_b_c', next_token, '', at, |
| | 1175 | next_token.from); |
| | 1176 | } |
| | 1177 | } |
| | 1178 | |
| | 1179 | function aint(it, name, expected) { |
| | 1180 | if (it[name] !== expected) { |
| | 1181 | warn('expected_a_b', it, expected, it[name]); |
| | 1182 | return true; |
| | 1183 | } |
| | 1184 | return false; |
| | 1185 | } |
| | 1186 | |
| | 1187 | |
| | 1188 | // lexical analysis and token construction |
| | 1189 | |
| | 1190 | lex = (function lex() { |
| | 1191 | var character, c, from, length, line, pos, source_row; |
| | 1192 | |
| | 1193 | // Private lex methods |
| | 1194 | |
| | 1195 | function next_line() { |
| | 1196 | var at; |
| | 1197 | if (line >= lines.length) { |
| | 1198 | return false; |
| | 1199 | } |
| | 1200 | character = 1; |
| | 1201 | source_row = lines[line]; |
| | 1202 | line += 1; |
| | 1203 | at = source_row.search(/ \t/); |
| | 1204 | if (at >= 0) { |
| | 1205 | warn_at('mixed', line, at + 1); |
| | 1206 | } |
| | 1207 | source_row = source_row.replace(/\t/g, tab); |
| | 1208 | at = source_row.search(cx); |
| | 1209 | if (at >= 0) { |
| | 1210 | warn_at('unsafe', line, at); |
| | 1211 | } |
| | 1212 | if (option.maxlen && option.maxlen < source_row.length) { |
| | 1213 | warn_at('too_long', line, source_row.length); |
| | 1214 | } |
| | 1215 | return true; |
| | 1216 | } |
| | 1217 | |
| | 1218 | // Produce a token object. The token inherits from a syntax symbol. |
| | 1219 | |
| | 1220 | function it(type, value) { |
| | 1221 | var id, the_token; |
| | 1222 | if (type === '(string)' || type === '(range)') { |
| | 1223 | if (jx.test(value)) { |
| | 1224 | warn_at('url', line, from); |
| | 1225 | } |
| | 1226 | } |
| | 1227 | the_token = Object.create(syntax[( |
| | 1228 | type === '(punctuator)' || (type === '(identifier)' && |
| | 1229 | Object.prototype.hasOwnProperty.call(syntax, value)) |
| | 1230 | ? value |
| | 1231 | : type |
| | 1232 | )] || syntax['(error)']); |
| | 1233 | if (type === '(identifier)') { |
| | 1234 | the_token.identifier = true; |
| | 1235 | if (value === '__iterator__' || value === '__proto__') { |
| | 1236 | stop_at('reserved_a', line, from, value); |
| | 1237 | } else if (!option.nomen && |
| | 1238 | (value.charAt(0) === '_' || |
| | 1239 | value.charAt(value.length - 1) === '_')) { |
| | 1240 | warn_at('dangling_a', line, from, value); |
| | 1241 | } |
| | 1242 | } |
| | 1243 | if (type === '(number)') { |
| | 1244 | the_token.number = +value; |
| | 1245 | } else if (value !== undefined) { |
| | 1246 | the_token.string = String(value); |
| | 1247 | } |
| | 1248 | the_token.line = line; |
| | 1249 | the_token.from = from; |
| | 1250 | the_token.thru = character; |
| | 1251 | id = the_token.id; |
| | 1252 | prereg = id && ( |
| | 1253 | ('(,=:[!&|?{};'.indexOf(id.charAt(id.length - 1)) >= 0) || |
| | 1254 | id === 'return' || id === 'case' |
| | 1255 | ); |
| | 1256 | return the_token; |
| | 1257 | } |
| | 1258 | |
| | 1259 | function match(x) { |
| | 1260 | var exec = x.exec(source_row), first; |
| | 1261 | if (exec) { |
| | 1262 | length = exec[0].length; |
| | 1263 | first = exec[1]; |
| | 1264 | c = first.charAt(0); |
| | 1265 | source_row = source_row.slice(length); |
| | 1266 | from = character + length - first.length; |
| | 1267 | character += length; |
| | 1268 | return first; |
| | 1269 | } |
| | 1270 | } |
| | 1271 | |
| | 1272 | function string(x) { |
| | 1273 | var c, pos = 0, r = '', result; |
| | 1274 | |
| | 1275 | function hex(n) { |
| | 1276 | var i = parseInt(source_row.substr(pos + 1, n), 16); |
| | 1277 | pos += n; |
| | 1278 | if (i >= 32 && i <= 126 && |
| | 1279 | i !== 34 && i !== 92 && i !== 39) { |
| | 1280 | warn_at('unexpected_a', line, character, '\\'); |
| | 1281 | } |
| | 1282 | character += n; |
| | 1283 | c = String.fromCharCode(i); |
| | 1284 | } |
| | 1285 | |
| | 1286 | if (json_mode && x !== '"') { |
| | 1287 | warn_at('expected_a', line, character, '"'); |
| | 1288 | } |
| | 1289 | |
| | 1290 | if (xquote === x || (xmode === 'scriptstring' && !xquote)) { |
| | 1291 | return it('(punctuator)', x); |
| | 1292 | } |
| | 1293 | |
| | 1294 | for (;;) { |
| | 1295 | while (pos >= source_row.length) { |
| | 1296 | pos = 0; |
| | 1297 | if (xmode !== 'html' || !next_line()) { |
| | 1298 | stop_at('unclosed', line, from); |
| | 1299 | } |
| | 1300 | } |
| | 1301 | c = source_row.charAt(pos); |
| | 1302 | if (c === x) { |
| | 1303 | character += 1; |
| | 1304 | source_row = source_row.slice(pos + 1); |
| | 1305 | result = it('(string)', r); |
| | 1306 | result.quote = x; |
| | 1307 | return result; |
| | 1308 | } |
| | 1309 | if (c < ' ') { |
| | 1310 | if (c === '\n' || c === '\r') { |
| | 1311 | break; |
| | 1312 | } |
| | 1313 | warn_at('control_a', line, character + pos, |
| | 1314 | source_row.slice(0, pos)); |
| | 1315 | } else if (c === xquote) { |
| | 1316 | warn_at('bad_html', line, character + pos); |
| | 1317 | } else if (c === '<') { |
| | 1318 | if (option.safe && xmode === 'html') { |
| | 1319 | warn_at('adsafe_a', line, character + pos, c); |
| | 1320 | } else if (source_row.charAt(pos + 1) === '/' && (xmode || option.safe)) { |
| | 1321 | warn_at('expected_a_b', line, character, |
| | 1322 | '<\\/', '</'); |
| | 1323 | } else if (source_row.charAt(pos + 1) === '!' && (xmode || option.safe)) { |
| | 1324 | warn_at('unexpected_a', line, character, '<!'); |
| | 1325 | } |
| | 1326 | } else if (c === '\\') { |
| | 1327 | if (xmode === 'html') { |
| | 1328 | if (option.safe) { |
| | 1329 | warn_at('adsafe_a', line, character + pos, c); |
| | 1330 | } |
| | 1331 | } else if (xmode === 'styleproperty') { |
| | 1332 | pos += 1; |
| | 1333 | character += 1; |
| | 1334 | c = source_row.charAt(pos); |
| | 1335 | if (c !== x) { |
| | 1336 | warn_at('unexpected_a', line, character, '\\'); |
| | 1337 | } |
| | 1338 | } else { |
| | 1339 | pos += 1; |
| | 1340 | character += 1; |
| | 1341 | c = source_row.charAt(pos); |
| | 1342 | switch (c) { |
| | 1343 | case '': |
| | 1344 | if (!option.es5) { |
| | 1345 | warn_at('es5', line, character); |
| | 1346 | } |
| | 1347 | next_line(); |
| | 1348 | pos = -1; |
| | 1349 | break; |
| | 1350 | case xquote: |
| | 1351 | warn_at('bad_html', line, character + pos); |
| | 1352 | break; |
| | 1353 | case '\'': |
| | 1354 | if (json_mode) { |
| | 1355 | warn_at('unexpected_a', line, character, '\\\''); |
| | 1356 | } |
| | 1357 | break; |
| | 1358 | case 'u': |
| | 1359 | hex(4); |
| | 1360 | break; |
| | 1361 | case 'v': |
| | 1362 | if (json_mode) { |
| | 1363 | warn_at('unexpected_a', line, character, '\\v'); |
| | 1364 | } |
| | 1365 | c = '\v'; |
| | 1366 | break; |
| | 1367 | case 'x': |
| | 1368 | if (json_mode) { |
| | 1369 | warn_at('unexpected_a', line, character, '\\x'); |
| | 1370 | } |
| | 1371 | hex(2); |
| | 1372 | break; |
| | 1373 | default: |
| | 1374 | if (typeof descapes[c] !== 'string') { |
| | 1375 | warn_at(c >= '0' && c <= '7' ? 'octal_a' : 'unexpected_a', |
| | 1376 | line, character, '\\' + c); |
| | 1377 | } else { |
| | 1378 | c = descapes[c]; |
| | 1379 | } |
| | 1380 | } |
| | 1381 | } |
| | 1382 | } |
| | 1383 | r += c; |
| | 1384 | character += 1; |
| | 1385 | pos += 1; |
| | 1386 | } |
| | 1387 | } |
| | 1388 | |
| | 1389 | function number(snippet) { |
| | 1390 | var digit; |
| | 1391 | if (xmode !== 'style' && xmode !== 'styleproperty' && |
| | 1392 | source_row.charAt(0).isAlpha()) { |
| | 1393 | warn_at('expected_space_a_b', |
| | 1394 | line, character, c, source_row.charAt(0)); |
| | 1395 | } |
| | 1396 | if (c === '0') { |
| | 1397 | digit = snippet.charAt(1); |
| | 1398 | if (digit.isDigit()) { |
| | 1399 | if (token.id !== '.' && xmode !== 'styleproperty') { |
| | 1400 | warn_at('unexpected_a', line, character, snippet); |
| | 1401 | } |
| | 1402 | } else if (json_mode && (digit === 'x' || digit === 'X')) { |
| | 1403 | warn_at('unexpected_a', line, character, '0x'); |
| | 1404 | } |
| | 1405 | } |
| | 1406 | if (snippet.slice(snippet.length - 1) === '.') { |
| | 1407 | warn_at('trailing_decimal_a', line, character, snippet); |
| | 1408 | } |
| | 1409 | if (xmode !== 'style') { |
| | 1410 | digit = +snippet; |
| | 1411 | if (!isFinite(digit)) { |
| | 1412 | warn_at('bad_number', line, character, snippet); |
| | 1413 | } |
| | 1414 | snippet = digit; |
| | 1415 | } |
| | 1416 | return it('(number)', snippet); |
| | 1417 | } |
| | 1418 | |
| | 1419 | function comment(snippet) { |
| | 1420 | if (comments_off || src || (xmode && xmode !== 'script' && |
| | 1421 | xmode !== 'style' && xmode !== 'styleproperty')) { |
| | 1422 | warn_at('unexpected_comment', line, character); |
| | 1423 | } else if (xmode === 'script' && /<\//i.test(source_row)) { |
| | 1424 | warn_at('unexpected_a', line, character, '<\/'); |
| | 1425 | } else if (option.safe && ax.test(snippet)) { |
| | 1426 | warn_at('dangerous_comment', line, character); |
| | 1427 | } |
| | 1428 | } |
| | 1429 | |
| | 1430 | function regexp() { |
| | 1431 | var b, |
| | 1432 | bit, |
| | 1433 | captures = 0, |
| | 1434 | depth = 0, |
| | 1435 | flag = '', |
| | 1436 | high, |
| | 1437 | letter, |
| | 1438 | length = 0, |
| | 1439 | low, |
| | 1440 | potential, |
| | 1441 | quote, |
| | 1442 | result; |
| | 1443 | for (;;) { |
| | 1444 | b = true; |
| | 1445 | c = source_row.charAt(length); |
| | 1446 | length += 1; |
| | 1447 | switch (c) { |
| | 1448 | case '': |
| | 1449 | stop_at('unclosed_regexp', line, from); |
| | 1450 | return; |
| | 1451 | case '/': |
| | 1452 | if (depth > 0) { |
| | 1453 | warn_at('unescaped_a', line, from + length, '/'); |
| | 1454 | } |
| | 1455 | c = source_row.slice(0, length - 1); |
| | 1456 | potential = Object.create(regexp_flag); |
| | 1457 | for (;;) { |
| | 1458 | letter = source_row.charAt(length); |
| | 1459 | if (potential[letter] !== true) { |
| | 1460 | break; |
| | 1461 | } |
| | 1462 | potential[letter] = false; |
| | 1463 | length += 1; |
| | 1464 | flag += letter; |
| | 1465 | } |
| | 1466 | if (source_row.charAt(length).isAlpha()) { |
| | 1467 | stop_at('unexpected_a', line, from, source_row.charAt(length)); |
| | 1468 | } |
| | 1469 | character += length; |
| | 1470 | source_row = source_row.slice(length); |
| | 1471 | quote = source_row.charAt(0); |
| | 1472 | if (quote === '/' || quote === '*') { |
| | 1473 | stop_at('confusing_regexp', line, from); |
| | 1474 | } |
| | 1475 | result = it('(regexp)', c); |
| | 1476 | result.flag = flag; |
| | 1477 | return result; |
| | 1478 | case '\\': |
| | 1479 | c = source_row.charAt(length); |
| | 1480 | if (c < ' ') { |
| | 1481 | warn_at('control_a', line, from + length, String(c)); |
| | 1482 | } else if (c === '<') { |
| | 1483 | warn_at(bundle.unexpected_a, line, from + length, '\\'); |
| | 1484 | } |
| | 1485 | length += 1; |
| | 1486 | break; |
| | 1487 | case '(': |
| | 1488 | depth += 1; |
| | 1489 | b = false; |
| | 1490 | if (source_row.charAt(length) === '?') { |
| | 1491 | length += 1; |
| | 1492 | switch (source_row.charAt(length)) { |
| | 1493 | case ':': |
| | 1494 | case '=': |
| | 1495 | case '!': |
| | 1496 | length += 1; |
| | 1497 | break; |
| | 1498 | default: |
| | 1499 | warn_at(bundle.expected_a_b, line, from + length, |
| | 1500 | ':', source_row.charAt(length)); |
| | 1501 | } |
| | 1502 | } else { |
| | 1503 | captures += 1; |
| | 1504 | } |
| | 1505 | break; |
| | 1506 | case '|': |
| | 1507 | b = false; |
| | 1508 | break; |
| | 1509 | case ')': |
| | 1510 | if (depth === 0) { |
| | 1511 | warn_at('unescaped_a', line, from + length, ')'); |
| | 1512 | } else { |
| | 1513 | depth -= 1; |
| | 1514 | } |
| | 1515 | break; |
| | 1516 | case ' ': |
| | 1517 | pos = 1; |
| | 1518 | while (source_row.charAt(length) === ' ') { |
| | 1519 | length += 1; |
| | 1520 | pos += 1; |
| | 1521 | } |
| | 1522 | if (pos > 1) { |
| | 1523 | warn_at('use_braces', line, from + length, pos); |
| | 1524 | } |
| | 1525 | break; |
| | 1526 | case '[': |
| | 1527 | c = source_row.charAt(length); |
| | 1528 | if (c === '^') { |
| | 1529 | length += 1; |
| | 1530 | if (!option.regexp) { |
| | 1531 | warn_at('insecure_a', line, from + length, c); |
| | 1532 | } else if (source_row.charAt(length) === ']') { |
| | 1533 | stop_at('unescaped_a', line, from + length, '^'); |
| | 1534 | } |
| | 1535 | } |
| | 1536 | bit = false; |
| | 1537 | if (c === ']') { |
| | 1538 | warn_at('empty_class', line, from + length - 1); |
| | 1539 | bit = true; |
| | 1540 | } |
| | 1541 | klass: do { |
| | 1542 | c = source_row.charAt(length); |
| | 1543 | length += 1; |
| | 1544 | switch (c) { |
| | 1545 | case '[': |
| | 1546 | case '^': |
| | 1547 | warn_at('unescaped_a', line, from + length, c); |
| | 1548 | bit = true; |
| | 1549 | break; |
| | 1550 | case '-': |
| | 1551 | if (bit) { |
| | 1552 | bit = false; |
| | 1553 | } else { |
| | 1554 | warn_at('unescaped_a', line, from + length, '-'); |
| | 1555 | bit = true; |
| | 1556 | } |
| | 1557 | break; |
| | 1558 | case ']': |
| | 1559 | if (!bit) { |
| | 1560 | warn_at('unescaped_a', line, from + length - 1, '-'); |
| | 1561 | } |
| | 1562 | break klass; |
| | 1563 | case '\\': |
| | 1564 | c = source_row.charAt(length); |
| | 1565 | if (c < ' ') { |
| | 1566 | warn_at(bundle.control_a, line, from + length, String(c)); |
| | 1567 | } else if (c === '<') { |
| | 1568 | warn_at(bundle.unexpected_a, line, from + length, '\\'); |
| | 1569 | } |
| | 1570 | length += 1; |
| | 1571 | bit = true; |
| | 1572 | break; |
| | 1573 | case '/': |
| | 1574 | warn_at('unescaped_a', line, from + length - 1, '/'); |
| | 1575 | bit = true; |
| | 1576 | break; |
| | 1577 | case '<': |
| | 1578 | if (xmode === 'script') { |
| | 1579 | c = source_row.charAt(length); |
| | 1580 | if (c === '!' || c === '/') { |
| | 1581 | warn_at(bundle.html_confusion_a, line, |
| | 1582 | from + length, c); |
| | 1583 | } |
| | 1584 | } |
| | 1585 | bit = true; |
| | 1586 | break; |
| | 1587 | default: |
| | 1588 | bit = true; |
| | 1589 | } |
| | 1590 | } while (c); |
| | 1591 | break; |
| | 1592 | case '.': |
| | 1593 | if (!option.regexp) { |
| | 1594 | warn_at('insecure_a', line, from + length, c); |
| | 1595 | } |
| | 1596 | break; |
| | 1597 | case ']': |
| | 1598 | case '?': |
| | 1599 | case '{': |
| | 1600 | case '}': |
| | 1601 | case '+': |
| | 1602 | case '*': |
| | 1603 | warn_at('unescaped_a', line, from + length, c); |
| | 1604 | break; |
| | 1605 | case '<': |
| | 1606 | if (xmode === 'script') { |
| | 1607 | c = source_row.charAt(length); |
| | 1608 | if (c === '!' || c === '/') { |
| | 1609 | warn_at(bundle.html_confusion_a, line, from + length, c); |
| | 1610 | } |
| | 1611 | } |
| | 1612 | break; |
| | 1613 | } |
| | 1614 | if (b) { |
| | 1615 | switch (source_row.charAt(length)) { |
| | 1616 | case '?': |
| | 1617 | case '+': |
| | 1618 | case '*': |
| | 1619 | length += 1; |
| | 1620 | if (source_row.charAt(length) === '?') { |
| | 1621 | length += 1; |
| | 1622 | } |
| | 1623 | break; |
| | 1624 | case '{': |
| | 1625 | length += 1; |
| | 1626 | c = source_row.charAt(length); |
| | 1627 | if (c < '0' || c > '9') { |
| | 1628 | warn_at(bundle.expected_number_a, line, |
| | 1629 | from + length, c); |
| | 1630 | } |
| | 1631 | length += 1; |
| | 1632 | low = +c; |
| | 1633 | for (;;) { |
| | 1634 | c = source_row.charAt(length); |
| | 1635 | if (c < '0' || c > '9') { |
| | 1636 | break; |
| | 1637 | } |
| | 1638 | length += 1; |
| | 1639 | low = +c + (low * 10); |
| | 1640 | } |
| | 1641 | high = low; |
| | 1642 | if (c === ',') { |
| | 1643 | length += 1; |
| | 1644 | high = Infinity; |
| | 1645 | c = source_row.charAt(length); |
| | 1646 | if (c >= '0' && c <= '9') { |
| | 1647 | length += 1; |
| | 1648 | high = +c; |
| | 1649 | for (;;) { |
| | 1650 | c = source_row.charAt(length); |
| | 1651 | if (c < '0' || c > '9') { |
| | 1652 | break; |
| | 1653 | } |
| | 1654 | length += 1; |
| | 1655 | high = +c + (high * 10); |
| | 1656 | } |
| | 1657 | } |
| | 1658 | } |
| | 1659 | if (source_row.charAt(length) !== '}') { |
| | 1660 | warn_at(bundle.expected_a_b, line, from + length, |
| | 1661 | '}', c); |
| | 1662 | } else { |
| | 1663 | length += 1; |
| | 1664 | } |
| | 1665 | if (source_row.charAt(length) === '?') { |
| | 1666 | length += 1; |
| | 1667 | } |
| | 1668 | if (low > high) { |
| | 1669 | warn_at(bundle.not_greater, line, from + length, |
| | 1670 | low, high); |
| | 1671 | } |
| | 1672 | break; |
| | 1673 | } |
| | 1674 | } |
| | 1675 | } |
| | 1676 | c = source_row.slice(0, length - 1); |
| | 1677 | character += length; |
| | 1678 | source_row = source_row.slice(length); |
| | 1679 | return it('(regexp)', c); |
| | 1680 | } |
| | 1681 | |
| | 1682 | // Public lex methods |
| | 1683 | |
| | 1684 | return { |
| | 1685 | init: function (source) { |
| | 1686 | if (typeof source === 'string') { |
| | 1687 | lines = source.split(crlfx); |
| | 1688 | } else { |
| | 1689 | lines = source; |
| | 1690 | } |
| | 1691 | line = 0; |
| | 1692 | next_line(); |
| | 1693 | from = 1; |
| | 1694 | }, |
| | 1695 | |
| | 1696 | range: function (begin, end) { |
| | 1697 | var c, value = ''; |
| | 1698 | from = character; |
| | 1699 | if (source_row.charAt(0) !== begin) { |
| | 1700 | stop_at('expected_a_b', line, character, begin, |
| | 1701 | source_row.charAt(0)); |
| | 1702 | } |
| | 1703 | for (;;) { |
| | 1704 | source_row = source_row.slice(1); |
| | 1705 | character += 1; |
| | 1706 | c = source_row.charAt(0); |
| | 1707 | switch (c) { |
| | 1708 | case '': |
| | 1709 | stop_at('missing_a', line, character, c); |
| | 1710 | break; |
| | 1711 | case end: |
| | 1712 | source_row = source_row.slice(1); |
| | 1713 | character += 1; |
| | 1714 | return it('(range)', value); |
| | 1715 | case xquote: |
| | 1716 | case '\\': |
| | 1717 | warn_at('unexpected_a', line, character, c); |
| | 1718 | break; |
| | 1719 | } |
| | 1720 | value += c; |
| | 1721 | } |
| | 1722 | }, |
| | 1723 | |
| | 1724 | // token -- this is called by advance to get the next token. |
| | 1725 | |
| | 1726 | token: function () { |
| | 1727 | var c, i, snippet; |
| | 1728 | |
| | 1729 | for (;;) { |
| | 1730 | while (!source_row) { |
| | 1731 | if (!next_line()) { |
| | 1732 | return it('(end)'); |
| | 1733 | } |
| | 1734 | } |
| | 1735 | while (xmode === 'outer') { |
| | 1736 | i = source_row.search(ox); |
| | 1737 | if (i === 0) { |
| | 1738 | break; |
| | 1739 | } else if (i > 0) { |
| | 1740 | character += 1; |
| | 1741 | source_row = source_row.slice(i); |
| | 1742 | break; |
| | 1743 | } else { |
| | 1744 | if (!next_line()) { |
| | 1745 | return it('(end)', ''); |
| | 1746 | } |
| | 1747 | } |
| | 1748 | } |
| | 1749 | snippet = match(rx[xmode] || tx); |
| | 1750 | if (!snippet) { |
| | 1751 | if (source_row) { |
| | 1752 | if (source_row.charAt(0) === ' ') { |
| | 1753 | if (!option.white) { |
| | 1754 | warn_at('unexpected_a', line, character, |
| | 1755 | '(space)'); |
| | 1756 | } |
| | 1757 | character += 1; |
| | 1758 | source_row = ''; |
| | 1759 | } else { |
| | 1760 | stop_at('unexpected_a', line, character, |
| | 1761 | source_row.charAt(0)); |
| | 1762 | } |
| | 1763 | } |
| | 1764 | } else { |
| | 1765 | |
| | 1766 | // identifier |
| | 1767 | |
| | 1768 | c = snippet.charAt(0); |
| | 1769 | if (c.isAlpha() || c === '_' || c === '$') { |
| | 1770 | return it('(identifier)', snippet); |
| | 1771 | } |
| | 1772 | |
| | 1773 | // number |
| | 1774 | |
| | 1775 | if (c.isDigit()) { |
| | 1776 | return number(snippet); |
| | 1777 | } |
| | 1778 | switch (snippet) { |
| | 1779 | |
| | 1780 | // string |
| | 1781 | |
| | 1782 | case '"': |
| | 1783 | case "'": |
| | 1784 | return string(snippet); |
| | 1785 | |
| | 1786 | // // comment |
| | 1787 | |
| | 1788 | case '//': |
| | 1789 | comment(source_row); |
| | 1790 | source_row = ''; |
| | 1791 | break; |
| | 1792 | |
| | 1793 | // /* comment |
| | 1794 | |
| | 1795 | case '/*': |
| | 1796 | for (;;) { |
| | 1797 | i = source_row.search(lx); |
| | 1798 | if (i >= 0) { |
| | 1799 | break; |
| | 1800 | } |
| | 1801 | comment(source_row); |
| | 1802 | if (!next_line()) { |
| | 1803 | stop_at('unclosed_comment', line, character); |
| | 1804 | } |
| | 1805 | } |
| | 1806 | comment(source_row.slice(0, i)); |
| | 1807 | character += i + 2; |
| | 1808 | if (source_row.charAt(i) === '/') { |
| | 1809 | stop_at('nested_comment', line, character); |
| | 1810 | } |
| | 1811 | source_row = source_row.slice(i + 2); |
| | 1812 | break; |
| | 1813 | |
| | 1814 | case '': |
| | 1815 | break; |
| | 1816 | // / |
| | 1817 | case '/': |
| | 1818 | if (token.id === '/=') { |
| | 1819 | stop_at( |
| | 1820 | bundle.slash_equal, |
| | 1821 | line, |
| | 1822 | from |
| | 1823 | ); |
| | 1824 | } |
| | 1825 | return prereg |
| | 1826 | ? regexp() |
| | 1827 | : it('(punctuator)', snippet); |
| | 1828 | |
| | 1829 | // punctuator |
| | 1830 | |
| | 1831 | case '<!--': |
| | 1832 | length = line; |
| | 1833 | // c = character; |
| | 1834 | for (;;) { |
| | 1835 | i = source_row.indexOf('--'); |
| | 1836 | if (i >= 0) { |
| | 1837 | break; |
| | 1838 | } |
| | 1839 | i = source_row.indexOf('<!'); |
| | 1840 | if (i >= 0) { |
| | 1841 | stop_at('nested_comment', |
| | 1842 | line, character + i); |
| | 1843 | } |
| | 1844 | if (!next_line()) { |
| | 1845 | stop_at('unclosed_comment', length, c); |
| | 1846 | } |
| | 1847 | } |
| | 1848 | length = source_row.indexOf('<!'); |
| | 1849 | if (length >= 0 && length < i) { |
| | 1850 | stop_at('nested_comment', |
| | 1851 | line, character + length); |
| | 1852 | } |
| | 1853 | character += i; |
| | 1854 | if (source_row.charAt(i + 2) !== '>') { |
| | 1855 | stop_at('expected_a', line, character, '-->'); |
| | 1856 | } |
| | 1857 | character += 3; |
| | 1858 | source_row = source_row.slice(i + 3); |
| | 1859 | break; |
| | 1860 | case '#': |
| | 1861 | if (xmode === 'html' || xmode === 'styleproperty') { |
| | 1862 | for (;;) { |
| | 1863 | c = source_row.charAt(0); |
| | 1864 | if ((c < '0' || c > '9') && |
| | 1865 | (c < 'a' || c > 'f') && |
| | 1866 | (c < 'A' || c > 'F')) { |
| | 1867 | break; |
| | 1868 | } |
| | 1869 | character += 1; |
| | 1870 | source_row = source_row.slice(1); |
| | 1871 | snippet += c; |
| | 1872 | } |
| | 1873 | if (snippet.length !== 4 && snippet.length !== 7) { |
| | 1874 | warn_at('bad_color_a', line, |
| | 1875 | from + length, snippet); |
| | 1876 | } |
| | 1877 | return it('(color)', snippet); |
| | 1878 | } |
| | 1879 | return it('(punctuator)', snippet); |
| | 1880 | |
| | 1881 | default: |
| | 1882 | if (xmode === 'outer' && c === '&') { |
| | 1883 | character += 1; |
| | 1884 | source_row = source_row.slice(1); |
| | 1885 | for (;;) { |
| | 1886 | c = source_row.charAt(0); |
| | 1887 | character += 1; |
| | 1888 | source_row = source_row.slice(1); |
| | 1889 | if (c === ';') { |
| | 1890 | break; |
| | 1891 | } |
| | 1892 | if (!((c >= '0' && c <= '9') || |
| | 1893 | (c >= 'a' && c <= 'z') || |
| | 1894 | c === '#')) { |
| | 1895 | stop_at('bad_entity', line, from + length, |
| | 1896 | character); |
| | 1897 | } |
| | 1898 | } |
| | 1899 | break; |
| | 1900 | } |
| | 1901 | return it('(punctuator)', snippet); |
| | 1902 | } |
| | 1903 | } |
| | 1904 | } |
| | 1905 | } |
| | 1906 | }; |
| | 1907 | }()); |
| | 1908 | |
| | 1909 | |
| | 1910 | function add_label(token, kind, name) { |
| | 1911 | |
| | 1912 | // Define the symbol in the current function in the current scope. |
| | 1913 | |
| | 1914 | name = name || token.string; |
| | 1915 | |
| | 1916 | // Global variables cannot be created in the safe subset. If a global variable |
| | 1917 | // already exists, do nothing. If it is predefined, define it. |
| | 1918 | |
| | 1919 | if (funct === global_funct) { |
| | 1920 | if (option.safe) { |
| | 1921 | warn('adsafe_a', token, name); |
| | 1922 | } |
| | 1923 | if (typeof global_funct[name] !== 'string') { |
| | 1924 | token.writeable = typeof predefined[name] === 'boolean' |
| | 1925 | ? predefined[name] |
| | 1926 | : true; |
| | 1927 | token.funct = funct; |
| | 1928 | global_scope[name] = token; |
| | 1929 | } |
| | 1930 | if (kind === 'becoming') { |
| | 1931 | kind = 'var'; |
| | 1932 | } |
| | 1933 | |
| | 1934 | // Ordinary variables. |
| | 1935 | |
| | 1936 | } else { |
| | 1937 | |
| | 1938 | // Warn if the variable already exists. |
| | 1939 | |
| | 1940 | if (typeof funct[name] === 'string') { |
| | 1941 | if (funct[name] === 'undef') { |
| | 1942 | if (!option.undef) { |
| | 1943 | warn('used_before_a', token, name); |
| | 1944 | } |
| | 1945 | kind = 'var'; |
| | 1946 | } else { |
| | 1947 | warn('already_defined', token, name); |
| | 1948 | } |
| | 1949 | } else { |
| | 1950 | |
| | 1951 | // Add the symbol to the current function. |
| | 1952 | |
| | 1953 | token.funct = funct; |
| | 1954 | token.writeable = true; |
| | 1955 | scope[name] = token; |
| | 1956 | } |
| | 1957 | } |
| | 1958 | funct[name] = kind; |
| | 1959 | } |
| | 1960 | |
| | 1961 | |
| | 1962 | function peek(distance) { |
| | 1963 | |
| | 1964 | // Peek ahead to a future token. The distance is how far ahead to look. The |
| | 1965 | // default is the next token. |
| | 1966 | |
| | 1967 | var found, slot = 0; |
| | 1968 | |
| | 1969 | distance = distance || 0; |
| | 1970 | while (slot <= distance) { |
| | 1971 | found = lookahead[slot]; |
| | 1972 | if (!found) { |
| | 1973 | found = lookahead[slot] = lex.token(); |
| | 1974 | } |
| | 1975 | slot += 1; |
| | 1976 | } |
| | 1977 | return found; |
| | 1978 | } |
| | 1979 | |
| | 1980 | |
| | 1981 | function advance(id, match) { |
| | 1982 | |
| | 1983 | // Produce the next token, also looking for programming errors. |
| | 1984 | |
| | 1985 | if (indent) { |
| | 1986 | |
| | 1987 | // If indentation checking was requested, then inspect all of the line breakings. |
| | 1988 | // The var statement is tricky because the names might be aligned or not. We |
| | 1989 | // look at the first line break after the var to determine the programmer's |
| | 1990 | // intention. |
| | 1991 | |
| | 1992 | if (var_mode && next_token.line !== token.line) { |
| | 1993 | if ((var_mode !== indent || !next_token.edge) && |
| | 1994 | next_token.from === indent.at - |
| | 1995 | (next_token.edge ? option.indent : 0)) { |
| | 1996 | var dent = indent; |
| | 1997 | for (;;) { |
| | 1998 | dent.at -= option.indent; |
| | 1999 | if (dent === var_mode) { |
| | 2000 | break; |
| | 2001 | } |
| | 2002 | dent = dent.was; |
| | 2003 | } |
| | 2004 | dent.open = false; |
| | 2005 | } |
| | 2006 | var_mode = null; |
| | 2007 | } |
| | 2008 | if (next_token.id === '?' && indent.mode === ':' && |
| | 2009 | token.line !== next_token.line) { |
| | 2010 | indent.at -= option.indent; |
| | 2011 | } |
| | 2012 | if (indent.open) { |
| | 2013 | |
| | 2014 | // If the token is an edge. |
| | 2015 | |
| | 2016 | if (next_token.edge) { |
| | 2017 | if (next_token.edge === 'label') { |
| | 2018 | expected_at(1); |
| | 2019 | } else if (next_token.edge === 'case' || indent.mode === 'statement') { |
| | 2020 | expected_at(indent.at - option.indent); |
| | 2021 | } else if (indent.mode !== 'array' || next_token.line !== token.line) { |
| | 2022 | expected_at(indent.at); |
| | 2023 | } |
| | 2024 | |
| | 2025 | // If the token is not an edge, but is the first token on the line. |
| | 2026 | |
| | 2027 | } else if (next_token.line !== token.line) { |
| | 2028 | if (next_token.from < indent.at + (indent.mode === |
| | 2029 | 'expression' ? 0 : option.indent)) { |
| | 2030 | expected_at(indent.at + option.indent); |
| | 2031 | } |
| | 2032 | indent.wrap = true; |
| | 2033 | } |
| | 2034 | } else if (next_token.line !== token.line) { |
| | 2035 | if (next_token.edge) { |
| | 2036 | expected_at(indent.at); |
| | 2037 | } else { |
| | 2038 | indent.wrap = true; |
| | 2039 | if (indent.mode === 'statement' || indent.mode === 'var') { |
| | 2040 | expected_at(indent.at + option.indent); |
| | 2041 | } else if (next_token.from < indent.at + (indent.mode === |
| | 2042 | 'expression' ? 0 : option.indent)) { |
| | 2043 | expected_at(indent.at + option.indent); |
| | 2044 | } |
| | 2045 | } |
| | 2046 | } |
| | 2047 | } |
| | 2048 | |
| | 2049 | switch (token.id) { |
| | 2050 | case '(number)': |
| | 2051 | if (next_token.id === '.') { |
| | 2052 | warn('trailing_decimal_a'); |
| | 2053 | } |
| | 2054 | break; |
| | 2055 | case '-': |
| | 2056 | if (next_token.id === '-' || next_token.id === '--') { |
| | 2057 | warn('confusing_a'); |
| | 2058 | } |
| | 2059 | break; |
| | 2060 | case '+': |
| | 2061 | if (next_token.id === '+' || next_token.id === '++') { |
| | 2062 | warn('confusing_a'); |
| | 2063 | } |
| | 2064 | break; |
| | 2065 | } |
| | 2066 | if (token.id === '(string)' || token.identifier) { |
| | 2067 | anonname = token.string; |
| | 2068 | } |
| | 2069 | |
| | 2070 | if (id && next_token.id !== id) { |
| | 2071 | if (match) { |
| | 2072 | warn('expected_a_b_from_c_d', next_token, id, |
| | 2073 | match.id, match.line, artifact()); |
| | 2074 | } else if (!next_token.identifier || next_token.string !== id) { |
| | 2075 | warn('expected_a_b', next_token, id, artifact()); |
| | 2076 | } |
| | 2077 | } |
| | 2078 | prev_token = token; |
| | 2079 | token = next_token; |
| | 2080 | next_token = lookahead.shift() || lex.token(); |
| | 2081 | } |
| | 2082 | |
| | 2083 | |
| | 2084 | function advance_identifier(string) { |
| | 2085 | if (next_token.identifier && next_token.string === string) { |
| | 2086 | advance(); |
| | 2087 | } else { |
| | 2088 | warn('expected_a_b', next_token, string, artifact()); |
| | 2089 | } |
| | 2090 | } |
| | 2091 | |
| | 2092 | |
| | 2093 | function do_safe() { |
| | 2094 | if (option.adsafe) { |
| | 2095 | option.safe = true; |
| | 2096 | } |
| | 2097 | if (option.safe) { |
| | 2098 | option.browser = |
| | 2099 | option['continue'] = |
| | 2100 | option.css = |
| | 2101 | option.debug = |
| | 2102 | option.devel = |
| | 2103 | option.evil = |
| | 2104 | option.forin = |
| | 2105 | option.newcap = |
| | 2106 | option.nomen = |
| | 2107 | option.on = |
| | 2108 | option.rhino = |
| | 2109 | option.sloppy = |
| | 2110 | option.sub = |
| | 2111 | option.undef = |
| | 2112 | option.widget = |
| | 2113 | option.windows = false; |
| | 2114 | |
| | 2115 | |
| | 2116 | delete predefined.Array; |
| | 2117 | delete predefined.Date; |
| | 2118 | delete predefined.Function; |
| | 2119 | delete predefined.Object; |
| | 2120 | delete predefined['eval']; |
| | 2121 | |
| | 2122 | add_to_predefined({ |
| | 2123 | ADSAFE: false, |
| | 2124 | lib: false |
| | 2125 | }); |
| | 2126 | } |
| | 2127 | } |
| | 2128 | |
| | 2129 | |
| | 2130 | function do_globals() { |
| | 2131 | var name, writeable; |
| | 2132 | for (;;) { |
| | 2133 | if (next_token.id !== '(string)' && !next_token.identifier) { |
| | 2134 | return; |
| | 2135 | } |
| | 2136 | name = next_token.string; |
| | 2137 | advance(); |
| | 2138 | writeable = false; |
| | 2139 | if (next_token.id === ':') { |
| | 2140 | advance(':'); |
| | 2141 | switch (next_token.id) { |
| | 2142 | case 'true': |
| | 2143 | writeable = predefined[name] !== false; |
| | 2144 | advance('true'); |
| | 2145 | break; |
| | 2146 | case 'false': |
| | 2147 | advance('false'); |
| | 2148 | break; |
| | 2149 | default: |
| | 2150 | stop('unexpected_a'); |
| | 2151 | } |
| | 2152 | } |
| | 2153 | predefined[name] = writeable; |
| | 2154 | if (next_token.id !== ',') { |
| | 2155 | return; |
| | 2156 | } |
| | 2157 | advance(','); |
| | 2158 | } |
| | 2159 | } |
| | 2160 | |
| | 2161 | |
| | 2162 | function do_jslint() { |
| | 2163 | var name, value; |
| | 2164 | while (next_token.id === '(string)' || next_token.identifier) { |
| | 2165 | name = next_token.string; |
| | 2166 | if (!allowed_option[name]) { |
| | 2167 | stop('unexpected_a'); |
| | 2168 | } |
| | 2169 | advance(); |
| | 2170 | if (next_token.id !== ':') { |
| | 2171 | stop('expected_a_b', next_token, ':', artifact()); |
| | 2172 | } |
| | 2173 | advance(':'); |
| | 2174 | if (typeof allowed_option[name] === 'number') { |
| | 2175 | value = next_token.number; |
| | 2176 | if (value > allowed_option[name] || value <= 0 || |
| | 2177 | Math.floor(value) !== value) { |
| | 2178 | stop('expected_small_a'); |
| | 2179 | } |
| | 2180 | option[name] = value; |
| | 2181 | } else { |
| | 2182 | if (next_token.id === 'true') { |
| | 2183 | option[name] = true; |
| | 2184 | } else if (next_token.id === 'false') { |
| | 2185 | option[name] = false; |
| | 2186 | } else { |
| | 2187 | stop('unexpected_a'); |
| | 2188 | } |
| | 2189 | } |
| | 2190 | advance(); |
| | 2191 | if (next_token.id === ',') { |
| | 2192 | advance(','); |
| | 2193 | } |
| | 2194 | } |
| | 2195 | assume(); |
| | 2196 | } |
| | 2197 | |
| | 2198 | |
| | 2199 | function do_properties() { |
| | 2200 | var name; |
| | 2201 | option.properties = true; |
| | 2202 | for (;;) { |
| | 2203 | if (next_token.id !== '(string)' && !next_token.identifier) { |
| | 2204 | return; |
| | 2205 | } |
| | 2206 | name = next_token.string; |
| | 2207 | advance(); |
| | 2208 | if (next_token.id === ':') { |
| | 2209 | for (;;) { |
| | 2210 | advance(); |
| | 2211 | if (next_token.id !== '(string)' && !next_token.identifier) { |
| | 2212 | break; |
| | 2213 | } |
| | 2214 | } |
| | 2215 | } |
| | 2216 | property[name] = 0; |
| | 2217 | if (next_token.id !== ',') { |
| | 2218 | return; |
| | 2219 | } |
| | 2220 | advance(','); |
| | 2221 | } |
| | 2222 | } |
| | 2223 | |
| | 2224 | |
| | 2225 | directive = function directive() { |
| | 2226 | var command = this.id, |
| | 2227 | old_comments_off = comments_off, |
| | 2228 | old_indent = indent; |
| | 2229 | comments_off = true; |
| | 2230 | indent = null; |
| | 2231 | if (next_token.line === token.line && next_token.from === token.thru) { |
| | 2232 | warn('missing_space_a_b', next_token, artifact(token), artifact()); |
| | 2233 | } |
| | 2234 | if (lookahead.length > 0) { |
| | 2235 | warn('unexpected_a', this); |
| | 2236 | } |
| | 2237 | switch (command) { |
| | 2238 | case '/*properties': |
| | 2239 | case '/*property': |
| | 2240 | case '/*members': |
| | 2241 | case '/*member': |
| | 2242 | do_properties(); |
| | 2243 | break; |
| | 2244 | case '/*jslint': |
| | 2245 | if (option.safe) { |
| | 2246 | warn('adsafe_a', this); |
| | 2247 | } |
| | 2248 | do_jslint(); |
| | 2249 | break; |
| | 2250 | case '/*globals': |
| | 2251 | case '/*global': |
| | 2252 | if (option.safe) { |
| | 2253 | warn('adsafe_a', this); |
| | 2254 | } |
| | 2255 | do_globals(); |
| | 2256 | break; |
| | 2257 | default: |
| | 2258 | stop('unexpected_a', this); |
| | 2259 | } |
| | 2260 | comments_off = old_comments_off; |
| | 2261 | advance('*/'); |
| | 2262 | indent = old_indent; |
| | 2263 | }; |
| | 2264 | |
| | 2265 | |
| | 2266 | // Indentation intention |
| | 2267 | |
| | 2268 | function edge(mode) { |
| | 2269 | next_token.edge = indent ? indent.open && (mode || 'edge') : ''; |
| | 2270 | } |
| | 2271 | |
| | 2272 | |
| | 2273 | function step_in(mode) { |
| | 2274 | var open; |
| | 2275 | if (typeof mode === 'number') { |
| | 2276 | indent = { |
| | 2277 | at: +mode, |
| | 2278 | open: true, |
| | 2279 | was: indent |
| | 2280 | }; |
| | 2281 | } else if (!indent) { |
| | 2282 | indent = { |
| | 2283 | at: 1, |
| | 2284 | mode: 'statement', |
| | 2285 | open: true |
| | 2286 | }; |
| | 2287 | } else if (mode === 'statement') { |
| | 2288 | indent = { |
| | 2289 | at: indent.at, |
| | 2290 | open: true, |
| | 2291 | was: indent |
| | 2292 | }; |
| | 2293 | } else { |
| | 2294 | open = mode === 'var' || next_token.line !== token.line; |
| | 2295 | indent = { |
| | 2296 | at: (open || mode === 'control' |
| | 2297 | ? indent.at + option.indent |
| | 2298 | : indent.at) + (indent.wrap ? option.indent : 0), |
| | 2299 | mode: mode, |
| | 2300 | open: open, |
| | 2301 | was: indent |
| | 2302 | }; |
| | 2303 | if (mode === 'var' && open) { |
| | 2304 | var_mode = indent; |
| | 2305 | } |
| | 2306 | } |
| | 2307 | } |
| | 2308 | |
| | 2309 | function step_out(id, symbol) { |
| | 2310 | if (id) { |
| | 2311 | if (indent && indent.open) { |
| | 2312 | indent.at -= option.indent; |
| | 2313 | edge(); |
| | 2314 | } |
| | 2315 | advance(id, symbol); |
| | 2316 | } |
| | 2317 | if (indent) { |
| | 2318 | indent = indent.was; |
| | 2319 | } |
| | 2320 | } |
| | 2321 | |
| | 2322 | // Functions for conformance of whitespace. |
| | 2323 | |
| | 2324 | function one_space(left, right) { |
| | 2325 | left = left || token; |
| | 2326 | right = right || next_token; |
| | 2327 | if (right.id !== '(end)' && !option.white && |
| | 2328 | (token.line !== right.line || |
| | 2329 | token.thru + 1 !== right.from)) { |
| | 2330 | warn('expected_space_a_b', right, artifact(token), artifact(right)); |
| | 2331 | } |
| | 2332 | } |
| | 2333 | |
| | 2334 | function one_space_only(left, right) { |
| | 2335 | left = left || token; |
| | 2336 | right = right || next_token; |
| | 2337 | if (right.id !== '(end)' && (left.line !== right.line || |
| | 2338 | (!option.white && left.thru + 1 !== right.from))) { |
| | 2339 | warn('expected_space_a_b', right, artifact(left), artifact(right)); |
| | 2340 | } |
| | 2341 | } |
| | 2342 | |
| | 2343 | function no_space(left, right) { |
| | 2344 | left = left || token; |
| | 2345 | right = right || next_token; |
| | 2346 | if ((!option.white || xmode === 'styleproperty' || xmode === 'style') && |
| | 2347 | left.thru !== right.from && left.line === right.line) { |
| | 2348 | warn('unexpected_space_a_b', right, artifact(left), artifact(right)); |
| | 2349 | } |
| | 2350 | } |
| | 2351 | |
| | 2352 | function no_space_only(left, right) { |
| | 2353 | left = left || token; |
| | 2354 | right = right || next_token; |
| | 2355 | if (right.id !== '(end)' && (left.line !== right.line || |
| | 2356 | (!option.white && left.thru !== right.from))) { |
| | 2357 | warn('unexpected_space_a_b', right, artifact(left), artifact(right)); |
| | 2358 | } |
| | 2359 | } |
| | 2360 | |
| | 2361 | function spaces(left, right) { |
| | 2362 | if (!option.white) { |
| | 2363 | left = left || token; |
| | 2364 | right = right || next_token; |
| | 2365 | if (left.thru === right.from && left.line === right.line) { |
| | 2366 | warn('missing_space_a_b', right, artifact(left), artifact(right)); |
| | 2367 | } |
| | 2368 | } |
| | 2369 | } |
| | 2370 | |
| | 2371 | function comma() { |
| | 2372 | if (next_token.id !== ',') { |
| | 2373 | warn_at('expected_a_b', token.line, token.thru, ',', artifact()); |
| | 2374 | } else { |
| | 2375 | if (!option.white) { |
| | 2376 | no_space_only(); |
| | 2377 | } |
| | 2378 | advance(','); |
| | 2379 | spaces(); |
| | 2380 | } |
| | 2381 | } |
| | 2382 | |
| | 2383 | |
| | 2384 | function semicolon() { |
| | 2385 | if (next_token.id !== ';') { |
| | 2386 | warn_at('expected_a_b', token.line, token.thru, ';', artifact()); |
| | 2387 | } else { |
| | 2388 | if (!option.white) { |
| | 2389 | no_space_only(); |
| | 2390 | } |
| | 2391 | advance(';'); |
| | 2392 | if (semicolon_coda[next_token.id] !== true) { |
| | 2393 | spaces(); |
| | 2394 | } |
| | 2395 | } |
| | 2396 | } |
| | 2397 | |
| | 2398 | function use_strict() { |
| | 2399 | if (next_token.string === 'use strict') { |
| | 2400 | if (strict_mode) { |
| | 2401 | warn('unnecessary_use'); |
| | 2402 | } |
| | 2403 | edge(); |
| | 2404 | advance(); |
| | 2405 | semicolon(); |
| | 2406 | strict_mode = true; |
| | 2407 | option.newcap = false; |
| | 2408 | option.undef = false; |
| | 2409 | return true; |
| | 2410 | } |
| | 2411 | return false; |
| | 2412 | } |
| | 2413 | |
| | 2414 | |
| | 2415 | function are_similar(a, b) { |
| | 2416 | if (a === b) { |
| | 2417 | return true; |
| | 2418 | } |
| | 2419 | if (Array.isArray(a)) { |
| | 2420 | if (Array.isArray(b) && a.length === b.length) { |
| | 2421 | var i; |
| | 2422 | for (i = 0; i < a.length; i += 1) { |
| | 2423 | if (!are_similar(a[i], b[i])) { |
| | 2424 | return false; |
| | 2425 | } |
| | 2426 | } |
| | 2427 | return true; |
| | 2428 | } |
| | 2429 | return false; |
| | 2430 | } |
| | 2431 | if (Array.isArray(b)) { |
| | 2432 | return false; |
| | 2433 | } |
| | 2434 | if (a.id === '(number)' && b.id === '(number)') { |
| | 2435 | return a.number === b.number; |
| | 2436 | } |
| | 2437 | if (a.arity === b.arity && a.string === b.string) { |
| | 2438 | switch (a.arity) { |
| | 2439 | case 'prefix': |
| | 2440 | case 'suffix': |
| | 2441 | case undefined: |
| | 2442 | return a.id === b.id && are_similar(a.first, b.first); |
| | 2443 | case 'infix': |
| | 2444 | return are_similar(a.first, b.first) && |
| | 2445 | are_similar(a.second, b.second); |
| | 2446 | case 'ternary': |
| | 2447 | return are_similar(a.first, b.first) && |
| | 2448 | are_similar(a.second, b.second) && |
| | 2449 | are_similar(a.third, b.third); |
| | 2450 | case 'function': |
| | 2451 | case 'regexp': |
| | 2452 | return false; |
| | 2453 | default: |
| | 2454 | return true; |
| | 2455 | } |
| | 2456 | } else { |
| | 2457 | if (a.id === '.' && b.id === '[' && b.arity === 'infix') { |
| | 2458 | return a.second.string === b.second.string && b.second.id === '(string)'; |
| | 2459 | } |
| | 2460 | if (a.id === '[' && a.arity === 'infix' && b.id === '.') { |
| | 2461 | return a.second.string === b.second.string && a.second.id === '(string)'; |
| | 2462 | } |
| | 2463 | } |
| | 2464 | return false; |
| | 2465 | } |
| | 2466 | |
| | 2467 | |
| | 2468 | // This is the heart of JSLINT, the Pratt parser. In addition to parsing, it |
| | 2469 | // is looking for ad hoc lint patterns. We add .fud to Pratt's model, which is |
| | 2470 | // like .nud except that it is only used on the first token of a statement. |
| | 2471 | // Having .fud makes it much easier to define statement-oriented languages like |
| | 2472 | // JavaScript. I retained Pratt's nomenclature. |
| | 2473 | |
| | 2474 | // .nud Null denotation |
| | 2475 | // .fud First null denotation |
| | 2476 | // .led Left denotation |
| | 2477 | // lbp Left binding power |
| | 2478 | // rbp Right binding power |
| | 2479 | |
| | 2480 | // They are elements of the parsing method called Top Down Operator Precedence. |
| | 2481 | |
| | 2482 | function expression(rbp, initial) { |
| | 2483 | |
| | 2484 | // rbp is the right binding power. |
| | 2485 | // initial indicates that this is the first expression of a statement. |
| | 2486 | |
| | 2487 | var left; |
| | 2488 | if (next_token.id === '(end)') { |
| | 2489 | stop('unexpected_a', token, next_token.id); |
| | 2490 | } |
| | 2491 | advance(); |
| | 2492 | if (option.safe && scope[token.string] && |
| | 2493 | scope[token.string] === global_scope[token.string] && |
| | 2494 | (next_token.id !== '(' && next_token.id !== '.')) { |
| | 2495 | warn('adsafe_a', token); |
| | 2496 | } |
| | 2497 | if (initial) { |
| | 2498 | anonname = 'anonymous'; |
| | 2499 | funct['(verb)'] = token.string; |
| | 2500 | } |
| | 2501 | if (initial === true && token.fud) { |
| | 2502 | left = token.fud(); |
| | 2503 | } else { |
| | 2504 | if (token.nud) { |
| | 2505 | left = token.nud(); |
| | 2506 | } else { |
| | 2507 | if (next_token.id === '(number)' && token.id === '.') { |
| | 2508 | warn('leading_decimal_a', token, artifact()); |
| | 2509 | advance(); |
| | 2510 | return token; |
| | 2511 | } |
| | 2512 | stop('expected_identifier_a', token, token.id); |
| | 2513 | } |
| | 2514 | while (rbp < next_token.lbp) { |
| | 2515 | advance(); |
| | 2516 | if (token.led) { |
| | 2517 | left = token.led(left); |
| | 2518 | } else { |
| | 2519 | stop('expected_operator_a', token, token.id); |
| | 2520 | } |
| | 2521 | } |
| | 2522 | } |
| | 2523 | return left; |
| | 2524 | } |
| | 2525 | |
| | 2526 | |
| | 2527 | // Functional constructors for making the symbols that will be inherited by |
| | 2528 | // tokens. |
| | 2529 | |
| | 2530 | function symbol(s, p) { |
| | 2531 | var x = syntax[s]; |
| | 2532 | if (!x || typeof x !== 'object') { |
| | 2533 | syntax[s] = x = { |
| | 2534 | id: s, |
| | 2535 | lbp: p || 0, |
| | 2536 | string: s |
| | 2537 | }; |
| | 2538 | } |
| | 2539 | return x; |
| | 2540 | } |
| | 2541 | |
| | 2542 | function postscript(x) { |
| | 2543 | x.postscript = true; |
| | 2544 | return x; |
| | 2545 | } |
| | 2546 | |
| | 2547 | function ultimate(s) { |
| | 2548 | var x = symbol(s, 0); |
| | 2549 | x.from = 1; |
| | 2550 | x.thru = 1; |
| | 2551 | x.line = 0; |
| | 2552 | x.edge = 'edge'; |
| | 2553 | s.string = s; |
| | 2554 | return postscript(x); |
| | 2555 | } |
| | 2556 | |
| | 2557 | |
| | 2558 | function stmt(s, f) { |
| | 2559 | var x = symbol(s); |
| | 2560 | x.identifier = x.reserved = true; |
| | 2561 | x.fud = f; |
| | 2562 | return x; |
| | 2563 | } |
| | 2564 | |
| | 2565 | function labeled_stmt(s, f) { |
| | 2566 | var x = stmt(s, f); |
| | 2567 | x.labeled = true; |
| | 2568 | } |
| | 2569 | |
| | 2570 | function disrupt_stmt(s, f) { |
| | 2571 | var x = stmt(s, f); |
| | 2572 | x.disrupt = true; |
| | 2573 | } |
| | 2574 | |
| | 2575 | |
| | 2576 | function reserve_name(x) { |
| | 2577 | var c = x.id.charAt(0); |
| | 2578 | if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')) { |
| | 2579 | x.identifier = x.reserved = true; |
| | 2580 | } |
| | 2581 | return x; |
| | 2582 | } |
| | 2583 | |
| | 2584 | |
| | 2585 | function prefix(s, f) { |
| | 2586 | var x = symbol(s, 150); |
| | 2587 | reserve_name(x); |
| | 2588 | x.nud = typeof f === 'function' |
| | 2589 | ? f |
| | 2590 | : function () { |
| | 2591 | if (s === 'typeof') { |
| | 2592 | one_space(); |
| | 2593 | } else { |
| | 2594 | no_space_only(); |
| | 2595 | } |
| | 2596 | this.first = expression(150); |
| | 2597 | this.arity = 'prefix'; |
| | 2598 | if (this.id === '++' || this.id === '--') { |
| | 2599 | if (!option.plusplus) { |
| | 2600 | warn('unexpected_a', this); |
| | 2601 | } else if ((!this.first.identifier || this.first.reserved) && |
| | 2602 | this.first.id !== '.' && this.first.id !== '[') { |
| | 2603 | warn('bad_operand', this); |
| | 2604 | } |
| | 2605 | } |
| | 2606 | return this; |
| | 2607 | }; |
| | 2608 | return x; |
| | 2609 | } |
| | 2610 | |
| | 2611 | |
| | 2612 | function type(s, t, nud) { |
| | 2613 | var x = symbol(s); |
| | 2614 | x.arity = t; |
| | 2615 | if (nud) { |
| | 2616 | x.nud = nud; |
| | 2617 | } |
| | 2618 | return x; |
| | 2619 | } |
| | 2620 | |
| | 2621 | |
| | 2622 | function reserve(s, f) { |
| | 2623 | var x = symbol(s); |
| | 2624 | x.identifier = x.reserved = true; |
| | 2625 | if (typeof f === 'function') { |
| | 2626 | x.nud = f; |
| | 2627 | } |
| | 2628 | return x; |
| | 2629 | } |
| | 2630 | |
| | 2631 | |
| | 2632 | function constant(name) { |
| | 2633 | var x = reserve(name); |
| | 2634 | x.string = name; |
| | 2635 | x.nud = return_this; |
| | 2636 | return x; |
| | 2637 | } |
| | 2638 | |
| | 2639 | |
| | 2640 | function reservevar(s, v) { |
| | 2641 | return reserve(s, function () { |
| | 2642 | if (typeof v === 'function') { |
| | 2643 | v(this); |
| | 2644 | } |
| | 2645 | return this; |
| | 2646 | }); |
| | 2647 | } |
| | 2648 | |
| | 2649 | |
| | 2650 | function infix(s, p, f, w) { |
| | 2651 | var x = symbol(s, p); |
| | 2652 | reserve_name(x); |
| | 2653 | x.led = function (left) { |
| | 2654 | this.arity = 'infix'; |
| | 2655 | if (!w) { |
| | 2656 | spaces(prev_token, token); |
| | 2657 | spaces(); |
| | 2658 | } |
| | 2659 | if (!option.bitwise && this.bitwise) { |
| | 2660 | warn('unexpected_a', this); |
| | 2661 | } |
| | 2662 | if (typeof f === 'function') { |
| | 2663 | return f(left, this); |
| | 2664 | } |
| | 2665 | this.first = left; |
| | 2666 | this.second = expression(p); |
| | 2667 | return this; |
| | 2668 | }; |
| | 2669 | return x; |
| | 2670 | } |
| | 2671 | |
| | 2672 | function expected_relation(node, message) { |
| | 2673 | if (node.assign) { |
| | 2674 | warn(message || bundle.conditional_assignment, node); |
| | 2675 | } |
| | 2676 | return node; |
| | 2677 | } |
| | 2678 | |
| | 2679 | function expected_condition(node, message) { |
| | 2680 | switch (node.id) { |
| | 2681 | case '[': |
| | 2682 | case '-': |
| | 2683 | if (node.arity !== 'infix') { |
| | 2684 | warn(message || bundle.weird_condition, node); |
| | 2685 | } |
| | 2686 | break; |
| | 2687 | case 'false': |
| | 2688 | case 'function': |
| | 2689 | case 'Infinity': |
| | 2690 | case 'NaN': |
| | 2691 | case 'null': |
| | 2692 | case 'true': |
| | 2693 | case 'undefined': |
| | 2694 | case 'void': |
| | 2695 | case '(number)': |
| | 2696 | case '(regexp)': |
| | 2697 | case '(string)': |
| | 2698 | case '{': |
| | 2699 | warn(message || bundle.weird_condition, node); |
| | 2700 | break; |
| | 2701 | case '(': |
| | 2702 | if (node.first.id === '.' && numbery[node.first.second.string] === true) { |
| | 2703 | warn(message || bundle.weird_condition, node); |
| | 2704 | } |
| | 2705 | break; |
| | 2706 | } |
| | 2707 | return node; |
| | 2708 | } |
| | 2709 | |
| | 2710 | function check_relation(node) { |
| | 2711 | switch (node.arity) { |
| | 2712 | case 'prefix': |
| | 2713 | switch (node.id) { |
| | 2714 | case '{': |
| | 2715 | case '[': |
| | 2716 | warn('unexpected_a', node); |
| | 2717 | break; |
| | 2718 | case '!': |
| | 2719 | warn('confusing_a', node); |
| | 2720 | break; |
| | 2721 | } |
| | 2722 | break; |
| | 2723 | case 'function': |
| | 2724 | case 'regexp': |
| | 2725 | warn('unexpected_a', node); |
| | 2726 | break; |
| | 2727 | default: |
| | 2728 | if (node.id === 'NaN') { |
| | 2729 | warn('isNaN', node); |
| | 2730 | } |
| | 2731 | } |
| | 2732 | return node; |
| | 2733 | } |
| | 2734 | |
| | 2735 | |
| | 2736 | function relation(s, eqeq) { |
| | 2737 | return infix(s, 100, function (left, that) { |
| | 2738 | check_relation(left); |
| | 2739 | if (eqeq && !option.eqeq) { |
| | 2740 | warn('expected_a_b', that, eqeq, that.id); |
| | 2741 | } |
| | 2742 | var right = expression(100); |
| | 2743 | if (are_similar(left, right) || |
| | 2744 | ((left.id === '(string)' || left.id === '(number)') && |
| | 2745 | (right.id === '(string)' || right.id === '(number)'))) { |
| | 2746 | warn('weird_relation', that); |
| | 2747 | } |
| | 2748 | that.first = left; |
| | 2749 | that.second = check_relation(right); |
| | 2750 | return that; |
| | 2751 | }); |
| | 2752 | } |
| | 2753 | |
| | 2754 | |
| | 2755 | function assignop(s, op) { |
| | 2756 | var x = infix(s, 20, function (left, that) { |
| | 2757 | var l; |
| | 2758 | that.first = left; |
| | 2759 | if (left.identifier) { |
| | 2760 | if (scope[left.string]) { |
| | 2761 | if (scope[left.string].writeable === false) { |
| | 2762 | warn('read_only', left); |
| | 2763 | } |
| | 2764 | } else { |
| | 2765 | stop('read_only'); |
| | 2766 | } |
| | 2767 | if (funct['(params)']) { |
| | 2768 | funct['(params)'].forEach(function (value) { |
| | 2769 | if (value.string === left.string) { |
| | 2770 | value.assign = true; |
| | 2771 | } |
| | 2772 | }); |
| | 2773 | } |
| | 2774 | } else if (option.safe) { |
| | 2775 | l = left; |
| | 2776 | do { |
| | 2777 | if (typeof predefined[l.string] === 'boolean') { |
| | 2778 | warn('adsafe_a', l); |
| | 2779 | } |
| | 2780 | l = l.first; |
| | 2781 | } while (l); |
| | 2782 | } |
| | 2783 | if (left === syntax['function']) { |
| | 2784 | warn('identifier_function', token); |
| | 2785 | } |
| | 2786 | if (left.id === '.' || left.id === '[') { |
| | 2787 | if (!left.first || left.first.string === 'arguments') { |
| | 2788 | warn('bad_assignment', that); |
| | 2789 | } |
| | 2790 | } else if (left.identifier) { |
| | 2791 | if (!left.reserved && funct[left.string] === 'exception') { |
| | 2792 | warn('assign_exception', left); |
| | 2793 | } |
| | 2794 | } else { |
| | 2795 | warn('bad_assignment', that); |
| | 2796 | } |
| | 2797 | that.second = expression(19); |
| | 2798 | if (that.id === '=' && are_similar(that.first, that.second)) { |
| | 2799 | warn('weird_assignment', that); |
| | 2800 | } |
| | 2801 | return that; |
| | 2802 | }); |
| | 2803 | x.assign = true; |
| | 2804 | if (op) { |
| | 2805 | if (syntax[op].bitwise) { |
| | 2806 | x.bitwise = true; |
| | 2807 | } |
| | 2808 | } |
| | 2809 | return x; |
| | 2810 | } |
| | 2811 | |
| | 2812 | |
| | 2813 | function bitwise(s, p) { |
| | 2814 | var x = infix(s, p, 'number'); |
| | 2815 | x.bitwise = true; |
| | 2816 | return x; |
| | 2817 | } |
| | 2818 | |
| | 2819 | |
| | 2820 | function suffix(s) { |
| | 2821 | var x = symbol(s, 150); |
| | 2822 | x.led = function (left) { |
| | 2823 | no_space_only(prev_token, token); |
| | 2824 | if (!option.plusplus) { |
| | 2825 | warn('unexpected_a', this); |
| | 2826 | } else if ((!left.identifier || left.reserved) && |
| | 2827 | left.id !== '.' && left.id !== '[') { |
| | 2828 | warn('bad_operand', this); |
| | 2829 | } |
| | 2830 | this.first = left; |
| | 2831 | this.arity = 'suffix'; |
| | 2832 | return this; |
| | 2833 | }; |
| | 2834 | return x; |
| | 2835 | } |
| | 2836 | |
| | 2837 | |
| | 2838 | function optional_identifier() { |
| | 2839 | if (next_token.identifier) { |
| | 2840 | advance(); |
| | 2841 | if (option.safe && banned[token.string]) { |
| | 2842 | warn('adsafe_a', token); |
| | 2843 | } else if (token.reserved && !option.es5) { |
| | 2844 | warn('expected_identifier_a_reserved', token); |
| | 2845 | } |
| | 2846 | return token.string; |
| | 2847 | } |
| | 2848 | } |
| | 2849 | |
| | 2850 | |
| | 2851 | function identifier() { |
| | 2852 | var i = optional_identifier(); |
| | 2853 | if (!i) { |
| | 2854 | stop(token.id === 'function' && next_token.id === '(' |
| | 2855 | ? 'name_function' |
| | 2856 | : 'expected_identifier_a'); |
| | 2857 | } |
| | 2858 | return i; |
| | 2859 | } |
| | 2860 | |
| | 2861 | |
| | 2862 | function statement() { |
| | 2863 | |
| | 2864 | var label, old_scope = scope, the_statement; |
| | 2865 | |
| | 2866 | // We don't like the empty statement. |
| | 2867 | |
| | 2868 | if (next_token.id === ';') { |
| | 2869 | warn('unexpected_a'); |
| | 2870 | semicolon(); |
| | 2871 | return; |
| | 2872 | } |
| | 2873 | |
| | 2874 | // Is this a labeled statement? |
| | 2875 | |
| | 2876 | if (next_token.identifier && !next_token.reserved && peek().id === ':') { |
| | 2877 | edge('label'); |
| | 2878 | label = next_token; |
| | 2879 | advance(); |
| | 2880 | advance(':'); |
| | 2881 | scope = Object.create(old_scope); |
| | 2882 | add_label(label, 'label'); |
| | 2883 | if (next_token.labeled !== true) { |
| | 2884 | warn('label_a_b', next_token, label.string, artifact()); |
| | 2885 | } else if (jx.test(label.string + ':')) { |
| | 2886 | warn('url', label); |
| | 2887 | } else if (funct === global_funct) { |
| | 2888 | stop('unexpected_a', token); |
| | 2889 | } |
| | 2890 | next_token.label = label; |
| | 2891 | } |
| | 2892 | |
| | 2893 | // Parse the statement. |
| | 2894 | |
| | 2895 | if (token.id !== 'else') { |
| | 2896 | edge(); |
| | 2897 | } |
| | 2898 | step_in('statement'); |
| | 2899 | the_statement = expression(0, true); |
| | 2900 | if (the_statement) { |
| | 2901 | |
| | 2902 | // Look for the final semicolon. |
| | 2903 | |
| | 2904 | if (the_statement.arity === 'statement') { |
| | 2905 | if (the_statement.id === 'switch' || |
| | 2906 | (the_statement.block && the_statement.id !== 'do')) { |
| | 2907 | spaces(); |
| | 2908 | } else { |
| | 2909 | semicolon(); |
| | 2910 | } |
| | 2911 | } else { |
| | 2912 | |
| | 2913 | // If this is an expression statement, determine if it is acceptable. |
| | 2914 | // We do not like |
| | 2915 | // new Blah(); |
| | 2916 | // statments. If it is to be used at all, new should only be used to make |
| | 2917 | // objects, not side effects. The expression statements we do like do |
| | 2918 | // assignment or invocation or delete. |
| | 2919 | |
| | 2920 | if (the_statement.id === '(') { |
| | 2921 | if (the_statement.first.id === 'new') { |
| | 2922 | warn('bad_new'); |
| | 2923 | } |
| | 2924 | } else if (!the_statement.assign && |
| | 2925 | the_statement.id !== 'delete' && |
| | 2926 | the_statement.id !== '++' && |
| | 2927 | the_statement.id !== '--') { |
| | 2928 | warn('assignment_function_expression', token); |
| | 2929 | } |
| | 2930 | semicolon(); |
| | 2931 | } |
| | 2932 | } |
| | 2933 | step_out(); |
| | 2934 | scope = old_scope; |
| | 2935 | return the_statement; |
| | 2936 | } |
| | 2937 | |
| | 2938 | |
| | 2939 | function statements() { |
| | 2940 | var array = [], disruptor, the_statement; |
| | 2941 | |
| | 2942 | // A disrupt statement may not be followed by any other statement. |
| | 2943 | // If the last statement is disrupt, then the sequence is disrupt. |
| | 2944 | |
| | 2945 | while (next_token.postscript !== true) { |
| | 2946 | if (next_token.id === ';') { |
| | 2947 | warn('unexpected_a', next_token); |
| | 2948 | semicolon(); |
| | 2949 | } else { |
| | 2950 | if (next_token.string === 'use strict') { |
| | 2951 | if ((!node_js && xmode !== 'script') || funct !== global_funct || array.length > 0) { |
| | 2952 | warn('function_strict'); |
| | 2953 | } |
| | 2954 | use_strict(); |
| | 2955 | } |
| | 2956 | if (disruptor) { |
| | 2957 | warn('unreachable_a_b', next_token, next_token.string, |
| | 2958 | disruptor.string); |
| | 2959 | disruptor = null; |
| | 2960 | } |
| | 2961 | the_statement = statement(); |
| | 2962 | if (the_statement) { |
| | 2963 | array.push(the_statement); |
| | 2964 | if (the_statement.disrupt) { |
| | 2965 | disruptor = the_statement; |
| | 2966 | array.disrupt = true; |
| | 2967 | } |
| | 2968 | } |
| | 2969 | } |
| | 2970 | } |
| | 2971 | return array; |
| | 2972 | } |
| | 2973 | |
| | 2974 | |
| | 2975 | function block(ordinary) { |
| | 2976 | |
| | 2977 | // array block is array sequence of statements wrapped in braces. |
| | 2978 | // ordinary is false for function bodies and try blocks. |
| | 2979 | // ordinary is true for if statements, while, etc. |
| | 2980 | |
| | 2981 | var array, |
| | 2982 | curly = next_token, |
| | 2983 | old_in_block = in_block, |
| | 2984 | old_scope = scope, |
| | 2985 | old_strict_mode = strict_mode; |
| | 2986 | |
| | 2987 | in_block = ordinary; |
| | 2988 | scope = Object.create(scope); |
| | 2989 | spaces(); |
| | 2990 | if (next_token.id === '{') { |
| | 2991 | advance('{'); |
| | 2992 | step_in(); |
| | 2993 | if (!ordinary && !use_strict() && !old_strict_mode && |
| | 2994 | !option.sloppy && funct['(context)'] === global_funct) { |
| | 2995 | warn('missing_use_strict'); |
| | 2996 | } |
| | 2997 | array = statements(); |
| | 2998 | strict_mode = old_strict_mode; |
| | 2999 | step_out('}', curly); |
| | 3000 | } else if (!ordinary) { |
| | 3001 | stop('expected_a_b', next_token, '{', artifact()); |
| | 3002 | } else { |
| | 3003 | warn('expected_a_b', next_token, '{', artifact()); |
| | 3004 | array = [statement()]; |
| | 3005 | array.disrupt = array[0].disrupt; |
| | 3006 | } |
| | 3007 | funct['(verb)'] = null; |
| | 3008 | scope = old_scope; |
| | 3009 | in_block = old_in_block; |
| | 3010 | if (ordinary && array.length === 0) { |
| | 3011 | warn('empty_block'); |
| | 3012 | } |
| | 3013 | return array; |
| | 3014 | } |
| | 3015 | |
| | 3016 | |
| | 3017 | function tally_property(name) { |
| | 3018 | if (option.properties && typeof property[name] !== 'number') { |
| | 3019 | warn('unexpected_property_a', token, name); |
| | 3020 | } |
| | 3021 | if (typeof property[name] === 'number') { |
| | 3022 | property[name] += 1; |
| | 3023 | } else { |
| | 3024 | property[name] = 1; |
| | 3025 | } |
| | 3026 | } |
| | 3027 | |
| | 3028 | |
| | 3029 | // ECMAScript parser |
| | 3030 | |
| | 3031 | syntax['(identifier)'] = { |
| | 3032 | id: '(identifier)', |
| | 3033 | lbp: 0, |
| | 3034 | identifier: true, |
| | 3035 | nud: function () { |
| | 3036 | var name = this.string, |
| | 3037 | variable = scope[name], |
| | 3038 | site, |
| | 3039 | writeable; |
| | 3040 | |
| | 3041 | // If the variable is not in scope, then we may have an undeclared variable. |
| | 3042 | // Check the predefined list. If it was predefined, create the global |
| | 3043 | // variable. |
| | 3044 | |
| | 3045 | if (typeof variable !== 'object') { |
| | 3046 | writeable = predefined[name]; |
| | 3047 | if (typeof writeable === 'boolean') { |
| | 3048 | global_scope[name] = variable = { |
| | 3049 | string: name, |
| | 3050 | writeable: writeable, |
| | 3051 | funct: global_funct |
| | 3052 | }; |
| | 3053 | global_funct[name] = 'var'; |
| | 3054 | |
| | 3055 | // But if the variable is not in scope, and is not predefined, and if we are not |
| | 3056 | // in the global scope, then we have an undefined variable error. |
| | 3057 | |
| | 3058 | } else { |
| | 3059 | if (!option.undef) { |
| | 3060 | warn('used_before_a', token); |
| | 3061 | } |
| | 3062 | scope[name] = variable = { |
| | 3063 | string: name, |
| | 3064 | writeable: true, |
| | 3065 | funct: funct |
| | 3066 | }; |
| | 3067 | funct[name] = 'undef'; |
| | 3068 | } |
| | 3069 | |
| | 3070 | } |
| | 3071 | site = variable.funct; |
| | 3072 | |
| | 3073 | // The name is in scope and defined in the current function. |
| | 3074 | |
| | 3075 | if (funct === site) { |
| | 3076 | |
| | 3077 | // Change 'unused' to 'var', and reject labels. |
| | 3078 | |
| | 3079 | switch (funct[name]) { |
| | 3080 | case 'becoming': |
| | 3081 | warn('unexpected_a', token); |
| | 3082 | funct[name] = 'var'; |
| | 3083 | break; |
| | 3084 | case 'unused': |
| | 3085 | funct[name] = 'var'; |
| | 3086 | break; |
| | 3087 | case 'unparam': |
| | 3088 | funct[name] = 'parameter'; |
| | 3089 | break; |
| | 3090 | case 'unction': |
| | 3091 | funct[name] = 'function'; |
| | 3092 | break; |
| | 3093 | case 'label': |
| | 3094 | warn('a_label', token, name); |
| | 3095 | break; |
| | 3096 | } |
| | 3097 | |
| | 3098 | // If the name is already defined in the current |
| | 3099 | // function, but not as outer, then there is a scope error. |
| | 3100 | |
| | 3101 | } else { |
| | 3102 | switch (funct[name]) { |
| | 3103 | case 'closure': |
| | 3104 | case 'function': |
| | 3105 | case 'var': |
| | 3106 | case 'unused': |
| | 3107 | warn('a_scope', token, name); |
| | 3108 | break; |
| | 3109 | case 'label': |
| | 3110 | warn('a_label', token, name); |
| | 3111 | break; |
| | 3112 | case 'outer': |
| | 3113 | case 'global': |
| | 3114 | break; |
| | 3115 | default: |
| | 3116 | |
| | 3117 | // If the name is defined in an outer function, make an outer entry, and if |
| | 3118 | // it was unused, make it var. |
| | 3119 | |
| | 3120 | switch (site[name]) { |
| | 3121 | case 'becoming': |
| | 3122 | case 'closure': |
| | 3123 | case 'function': |
| | 3124 | case 'parameter': |
| | 3125 | case 'unction': |
| | 3126 | case 'unused': |
| | 3127 | case 'var': |
| | 3128 | site[name] = 'closure'; |
| | 3129 | funct[name] = site === global_funct |
| | 3130 | ? 'global' |
| | 3131 | : 'outer'; |
| | 3132 | break; |
| | 3133 | case 'unparam': |
| | 3134 | site[name] = 'parameter'; |
| | 3135 | funct[name] = 'outer'; |
| | 3136 | break; |
| | 3137 | case 'undef': |
| | 3138 | funct[name] = 'undef'; |
| | 3139 | break; |
| | 3140 | case 'label': |
| | 3141 | warn('a_label', token, name); |
| | 3142 | break; |
| | 3143 | } |
| | 3144 | } |
| | 3145 | } |
| | 3146 | return this; |
| | 3147 | }, |
| | 3148 | led: function () { |
| | 3149 | stop('expected_operator_a'); |
| | 3150 | } |
| | 3151 | }; |
| | 3152 | |
| | 3153 | // Build the syntax table by declaring the syntactic elements. |
| | 3154 | |
| | 3155 | type('(array)', 'array'); |
| | 3156 | type('(color)', 'color'); |
| | 3157 | type('(function)', 'function'); |
| | 3158 | type('(number)', 'number', return_this); |
| | 3159 | type('(object)', 'object'); |
| | 3160 | type('(string)', 'string', return_this); |
| | 3161 | type('(boolean)', 'boolean', return_this); |
| | 3162 | type('(range)', 'range'); |
| | 3163 | type('(regexp)', 'regexp', return_this); |
| | 3164 | |
| | 3165 | ultimate('(begin)'); |
| | 3166 | ultimate('(end)'); |
| | 3167 | ultimate('(error)'); |
| | 3168 | postscript(symbol('</')); |
| | 3169 | symbol('<!'); |
| | 3170 | symbol('<!--'); |
| | 3171 | symbol('-->'); |
| | 3172 | postscript(symbol('}')); |
| | 3173 | symbol(')'); |
| | 3174 | symbol(']'); |
| | 3175 | postscript(symbol('"')); |
| | 3176 | postscript(symbol('\'')); |
| | 3177 | symbol(';'); |
| | 3178 | symbol(':'); |
| | 3179 | symbol(','); |
| | 3180 | symbol('#'); |
| | 3181 | symbol('@'); |
| | 3182 | symbol('*/'); |
| | 3183 | postscript(reserve('case')); |
| | 3184 | reserve('catch'); |
| | 3185 | postscript(reserve('default')); |
| | 3186 | reserve('else'); |
| | 3187 | reserve('finally'); |
| | 3188 | |
| | 3189 | reservevar('arguments', function (x) { |
| | 3190 | if (strict_mode && funct === global_funct) { |
| | 3191 | warn('strict', x); |
| | 3192 | } else if (option.safe) { |
| | 3193 | warn('adsafe_a', x); |
| | 3194 | } |
| | 3195 | funct['(arguments)'] = true; |
| | 3196 | }); |
| | 3197 | reservevar('eval', function (x) { |
| | 3198 | if (option.safe) { |
| | 3199 | warn('adsafe_a', x); |
| | 3200 | } |
| | 3201 | }); |
| | 3202 | constant('false', 'boolean'); |
| | 3203 | constant('Infinity', 'number'); |
| | 3204 | constant('NaN', 'number'); |
| | 3205 | constant('null', ''); |
| | 3206 | reservevar('this', function (x) { |
| | 3207 | if (option.safe) { |
| | 3208 | warn('adsafe_a', x); |
| | 3209 | } else if (strict_mode && funct['(token)'].arity === 'statement' && |
| | 3210 | funct['(name)'].charAt(0) > 'Z') { |
| | 3211 | warn('strict', x); |
| | 3212 | } |
| | 3213 | }); |
| | 3214 | constant('true', 'boolean'); |
| | 3215 | constant('undefined', ''); |
| | 3216 | |
| | 3217 | infix('?', 30, function (left, that) { |
| | 3218 | step_in('?'); |
| | 3219 | that.first = expected_condition(expected_relation(left)); |
| | 3220 | that.second = expression(0); |
| | 3221 | spaces(); |
| | 3222 | step_out(); |
| | 3223 | var colon = next_token; |
| | 3224 | advance(':'); |
| | 3225 | step_in(':'); |
| | 3226 | spaces(); |
| | 3227 | that.third = expression(10); |
| | 3228 | that.arity = 'ternary'; |
| | 3229 | if (are_similar(that.second, that.third)) { |
| | 3230 | warn('weird_ternary', colon); |
| | 3231 | } else if (are_similar(that.first, that.second)) { |
| | 3232 | warn('use_or', that); |
| | 3233 | } |
| | 3234 | step_out(); |
| | 3235 | return that; |
| | 3236 | }); |
| | 3237 | |
| | 3238 | infix('||', 40, function (left, that) { |
| | 3239 | function paren_check(that) { |
| | 3240 | if (that.id === '&&' && !that.paren) { |
| | 3241 | warn('and', that); |
| | 3242 | } |
| | 3243 | return that; |
| | 3244 | } |
| | 3245 | |
| | 3246 | that.first = paren_check(expected_condition(expected_relation(left))); |
| | 3247 | that.second = paren_check(expected_relation(expression(40))); |
| | 3248 | if (are_similar(that.first, that.second)) { |
| | 3249 | warn('weird_condition', that); |
| | 3250 | } |
| | 3251 | return that; |
| | 3252 | }); |
| | 3253 | |
| | 3254 | infix('&&', 50, function (left, that) { |
| | 3255 | that.first = expected_condition(expected_relation(left)); |
| | 3256 | that.second = expected_relation(expression(50)); |
| | 3257 | if (are_similar(that.first, that.second)) { |
| | 3258 | warn('weird_condition', that); |
| | 3259 | } |
| | 3260 | return that; |
| | 3261 | }); |
| | 3262 | |
| | 3263 | prefix('void', function () { |
| | 3264 | this.first = expression(0); |
| | 3265 | this.arity = 'prefix'; |
| | 3266 | if (option.es5) { |
| | 3267 | warn('expected_a_b', this, 'undefined', 'void'); |
| | 3268 | } else if (this.first.number !== 0) { |
| | 3269 | warn('expected_a_b', this.first, '0', artifact(this.first)); |
| | 3270 | } |
| | 3271 | return this; |
| | 3272 | }); |
| | 3273 | |
| | 3274 | bitwise('|', 70); |
| | 3275 | bitwise('^', 80); |
| | 3276 | bitwise('&', 90); |
| | 3277 | |
| | 3278 | relation('==', '==='); |
| | 3279 | relation('==='); |
| | 3280 | relation('!=', '!=='); |
| | 3281 | relation('!=='); |
| | 3282 | relation('<'); |
| | 3283 | relation('>'); |
| | 3284 | relation('<='); |
| | 3285 | relation('>='); |
| | 3286 | |
| | 3287 | bitwise('<<', 120); |
| | 3288 | bitwise('>>', 120); |
| | 3289 | bitwise('>>>', 120); |
| | 3290 | |
| | 3291 | infix('in', 120, function (left, that) { |
| | 3292 | warn('infix_in', that); |
| | 3293 | that.left = left; |
| | 3294 | that.right = expression(130); |
| | 3295 | return that; |
| | 3296 | }); |
| | 3297 | infix('instanceof', 120); |
| | 3298 | infix('+', 130, function (left, that) { |
| | 3299 | if (left.id === '(number)') { |
| | 3300 | if (left.number === 0) { |
| | 3301 | warn('unexpected_a', left, '0'); |
| | 3302 | } |
| | 3303 | } else if (left.id === '(string)') { |
| | 3304 | if (left.string === '') { |
| | 3305 | warn('expected_a_b', left, 'String', '\'\''); |
| | 3306 | } |
| | 3307 | } |
| | 3308 | var right = expression(130); |
| | 3309 | if (right.id === '(number)') { |
| | 3310 | if (right.number === 0) { |
| | 3311 | warn('unexpected_a', right, '0'); |
| | 3312 | } |
| | 3313 | } else if (right.id === '(string)') { |
| | 3314 | if (right.string === '') { |
| | 3315 | warn('expected_a_b', right, 'String', '\'\''); |
| | 3316 | } |
| | 3317 | } |
| | 3318 | if (left.id === right.id) { |
| | 3319 | if (left.id === '(string)' || left.id === '(number)') { |
| | 3320 | if (left.id === '(string)') { |
| | 3321 | left.string += right.string; |
| | 3322 | if (jx.test(left.string)) { |
| | 3323 | warn('url', left); |
| | 3324 | } |
| | 3325 | } else { |
| | 3326 | left.number += right.number; |
| | 3327 | } |
| | 3328 | left.thru = right.thru; |
| | 3329 | return left; |
| | 3330 | } |
| | 3331 | } |
| | 3332 | that.first = left; |
| | 3333 | that.second = right; |
| | 3334 | return that; |
| | 3335 | }); |
| | 3336 | prefix('+', 'num'); |
| | 3337 | prefix('+++', function () { |
| | 3338 | warn('confusing_a', token); |
| | 3339 | this.first = expression(150); |
| | 3340 | this.arity = 'prefix'; |
| | 3341 | return this; |
| | 3342 | }); |
| | 3343 | infix('+++', 130, function (left) { |
| | 3344 | warn('confusing_a', token); |
| | 3345 | this.first = left; |
| | 3346 | this.second = expression(130); |
| | 3347 | return this; |
| | 3348 | }); |
| | 3349 | infix('-', 130, function (left, that) { |
| | 3350 | if ((left.id === '(number)' && left.number === 0) || left.id === '(string)') { |
| | 3351 | warn('unexpected_a', left); |
| | 3352 | } |
| | 3353 | var right = expression(130); |
| | 3354 | if ((right.id === '(number)' && right.number === 0) || right.id === '(string)') { |
| | 3355 | warn('unexpected_a', right); |
| | 3356 | } |
| | 3357 | if (left.id === right.id && left.id === '(number)') { |
| | 3358 | left.number -= right.number; |
| | 3359 | left.thru = right.thru; |
| | 3360 | return left; |
| | 3361 | } |
| | 3362 | that.first = left; |
| | 3363 | that.second = right; |
| | 3364 | return that; |
| | 3365 | }); |
| | 3366 | prefix('-'); |
| | 3367 | prefix('---', function () { |
| | 3368 | warn('confusing_a', token); |
| | 3369 | this.first = expression(150); |
| | 3370 | this.arity = 'prefix'; |
| | 3371 | return this; |
| | 3372 | }); |
| | 3373 | infix('---', 130, function (left) { |
| | 3374 | warn('confusing_a', token); |
| | 3375 | this.first = left; |
| | 3376 | this.second = expression(130); |
| | 3377 | return this; |
| | 3378 | }); |
| | 3379 | infix('*', 140, function (left, that) { |
| | 3380 | if ((left.id === '(number)' && (left.number === 0 || left.number === 1)) || left.id === '(string)') { |
| | 3381 | warn('unexpected_a', left); |
| | 3382 | } |
| | 3383 | var right = expression(140); |
| | 3384 | if ((right.id === '(number)' && (right.number === 0 || right.number === 1)) || right.id === '(string)') { |
| | 3385 | warn('unexpected_a', right); |
| | 3386 | } |
| | 3387 | if (left.id === right.id && left.id === '(number)') { |
| | 3388 | left.number *= right.number; |
| | 3389 | left.thru = right.thru; |
| | 3390 | return left; |
| | 3391 | } |
| | 3392 | that.first = left; |
| | 3393 | that.second = right; |
| | 3394 | return that; |
| | 3395 | }); |
| | 3396 | infix('/', 140, function (left, that) { |
| | 3397 | if ((left.id === '(number)' && left.number === 0) || left.id === '(string)') { |
| | 3398 | warn('unexpected_a', left); |
| | 3399 | } |
| | 3400 | var right = expression(140); |
| | 3401 | if ((right.id === '(number)' && (right.number === 0 || right.number === 1)) || right.id === '(string)') { |
| | 3402 | warn('unexpected_a', right); |
| | 3403 | } |
| | 3404 | if (left.id === right.id && left.id === '(number)') { |
| | 3405 | left.number /= right.number; |
| | 3406 | left.thru = right.thru; |
| | 3407 | return left; |
| | 3408 | } |
| | 3409 | that.first = left; |
| | 3410 | that.second = right; |
| | 3411 | return that; |
| | 3412 | }); |
| | 3413 | infix('%', 140, function (left, that) { |
| | 3414 | if ((left.id === '(number)' && (left.number === 0 || left.number === 1)) || left.id === '(string)') { |
| | 3415 | warn('unexpected_a', left); |
| | 3416 | } |
| | 3417 | var right = expression(140); |
| | 3418 | if ((right.id === '(number)' && right.number === 0) || right.id === '(string)') { |
| | 3419 | warn('unexpected_a', right); |
| | 3420 | } |
| | 3421 | if (left.id === right.id && left.id === '(number)') { |
| | 3422 | left.number %= right.number; |
| | 3423 | left.thru = right.thru; |
| | 3424 | return left; |
| | 3425 | } |
| | 3426 | that.first = left; |
| | 3427 | that.second = right; |
| | 3428 | return that; |
| | 3429 | }); |
| | 3430 | |
| | 3431 | suffix('++'); |
| | 3432 | prefix('++'); |
| | 3433 | |
| | 3434 | suffix('--'); |
| | 3435 | prefix('--'); |
| | 3436 | prefix('delete', function () { |
| | 3437 | one_space(); |
| | 3438 | var p = expression(0); |
| | 3439 | if (!p || (p.id !== '.' && p.id !== '[')) { |
| | 3440 | warn('deleted'); |
| | 3441 | } |
| | 3442 | this.first = p; |
| | 3443 | return this; |
| | 3444 | }); |
| | 3445 | |
| | 3446 | |
| | 3447 | prefix('~', function () { |
| | 3448 | no_space_only(); |
| | 3449 | if (!option.bitwise) { |
| | 3450 | warn('unexpected_a', this); |
| | 3451 | } |
| | 3452 | expression(150); |
| | 3453 | return this; |
| | 3454 | }); |
| | 3455 | prefix('!', function () { |
| | 3456 | no_space_only(); |
| | 3457 | this.first = expected_condition(expression(150)); |
| | 3458 | this.arity = 'prefix'; |
| | 3459 | if (bang[this.first.id] === true || this.first.assign) { |
| | 3460 | warn('confusing_a', this); |
| | 3461 | } |
| | 3462 | return this; |
| | 3463 | }); |
| | 3464 | prefix('typeof', null); |
| | 3465 | prefix('new', function () { |
| | 3466 | one_space(); |
| | 3467 | var c = expression(160), n, p, v; |
| | 3468 | this.first = c; |
| | 3469 | if (c.id !== 'function') { |
| | 3470 | if (c.identifier) { |
| | 3471 | switch (c.string) { |
| | 3472 | case 'Object': |
| | 3473 | warn('use_object', token); |
| | 3474 | break; |
| | 3475 | case 'Array': |
| | 3476 | if (next_token.id === '(') { |
| | 3477 | p = next_token; |
| | 3478 | p.first = this; |
| | 3479 | advance('('); |
| | 3480 | if (next_token.id !== ')') { |
| | 3481 | n = expression(0); |
| | 3482 | p.second = [n]; |
| | 3483 | if (n.id !== '(number)' || next_token.id === ',') { |
| | 3484 | warn('use_array', p); |
| | 3485 | } |
| | 3486 | while (next_token.id === ',') { |
| | 3487 | advance(','); |
| | 3488 | p.second.push(expression(0)); |
| | 3489 | } |
| | 3490 | } else { |
| | 3491 | warn('use_array', token); |
| | 3492 | } |
| | 3493 | advance(')', p); |
| | 3494 | return p; |
| | 3495 | } |
| | 3496 | warn('use_array', token); |
| | 3497 | break; |
| | 3498 | case 'Number': |
| | 3499 | case 'String': |
| | 3500 | case 'Boolean': |
| | 3501 | case 'Math': |
| | 3502 | case 'JSON': |
| | 3503 | warn('not_a_constructor', c); |
| | 3504 | break; |
| | 3505 | case 'Function': |
| | 3506 | if (!option.evil) { |
| | 3507 | warn('function_eval'); |
| | 3508 | } |
| | 3509 | break; |
| | 3510 | case 'Date': |
| | 3511 | case 'RegExp': |
| | 3512 | case 'this': |
| | 3513 | break; |
| | 3514 | default: |
| | 3515 | if (c.id !== 'function') { |
| | 3516 | v = c.string.charAt(0); |
| | 3517 | if (!option.newcap && (v < 'A' || v > 'Z')) { |
| | 3518 | warn('constructor_name_a', token); |
| | 3519 | } |
| | 3520 | } |
| | 3521 | } |
| | 3522 | } else { |
| | 3523 | if (c.id !== '.' && c.id !== '[' && c.id !== '(') { |
| | 3524 | warn('bad_constructor', token); |
| | 3525 | } |
| | 3526 | } |
| | 3527 | } else { |
| | 3528 | warn('weird_new', this); |
| | 3529 | } |
| | 3530 | if (next_token.id !== '(') { |
| | 3531 | warn('missing_a', next_token, '()'); |
| | 3532 | } |
| | 3533 | return this; |
| | 3534 | }); |
| | 3535 | |
| | 3536 | infix('(', 160, function (left, that) { |
| | 3537 | var p; |
| | 3538 | if (indent && indent.mode === 'expression') { |
| | 3539 | no_space(prev_token, token); |
| | 3540 | } else { |
| | 3541 | no_space_only(prev_token, token); |
| | 3542 | } |
| | 3543 | if (!left.immed && left.id === 'function') { |
| | 3544 | warn('wrap_immediate'); |
| | 3545 | } |
| | 3546 | p = []; |
| | 3547 | if (left.identifier) { |
| | 3548 | if (left.string.match(/^[A-Z]([A-Z0-9_$]*[a-z][A-Za-z0-9_$]*)?$/)) { |
| | 3549 | if (left.string !== 'Number' && left.string !== 'String' && |
| | 3550 | left.string !== 'Boolean' && left.string !== 'Date') { |
| | 3551 | if (left.string === 'Math' || left.string === 'JSON') { |
| | 3552 | warn('not_a_function', left); |
| | 3553 | } else if (left.string === 'Object') { |
| | 3554 | warn('use_object', token); |
| | 3555 | } else if (left.string === 'Array' || !option.newcap) { |
| | 3556 | warn('missing_a', left, 'new'); |
| | 3557 | } |
| | 3558 | } |
| | 3559 | } |
| | 3560 | } else if (left.id === '.') { |
| | 3561 | if (option.safe && left.first.string === 'Math' && |
| | 3562 | left.second === 'random') { |
| | 3563 | warn('adsafe_a', left); |
| | 3564 | } else if (left.second.string === 'split' && |
| | 3565 | left.first.id === '(string)') { |
| | 3566 | warn('use_array', left.second); |
| | 3567 | } |
| | 3568 | } |
| | 3569 | step_in(); |
| | 3570 | if (next_token.id !== ')') { |
| | 3571 | no_space(); |
| | 3572 | for (;;) { |
| | 3573 | edge(); |
| | 3574 | p.push(expression(10)); |
| | 3575 | if (next_token.id !== ',') { |
| | 3576 | break; |
| | 3577 | } |
| | 3578 | comma(); |
| | 3579 | } |
| | 3580 | } |
| | 3581 | no_space(); |
| | 3582 | step_out(')', that); |
| | 3583 | if (typeof left === 'object') { |
| | 3584 | if (left.string === 'parseInt' && p.length === 1) { |
| | 3585 | warn('radix', left); |
| | 3586 | } |
| | 3587 | if (!option.evil) { |
| | 3588 | if (left.string === 'eval' || left.string === 'Function' || |
| | 3589 | left.string === 'execScript') { |
| | 3590 | warn('evil', left); |
| | 3591 | } else if (p[0] && p[0].id === '(string)' && |
| | 3592 | (left.string === 'setTimeout' || |
| | 3593 | left.string === 'setInterval')) { |
| | 3594 | warn('implied_evil', left); |
| | 3595 | } |
| | 3596 | } |
| | 3597 | if (!left.identifier && left.id !== '.' && left.id !== '[' && |
| | 3598 | left.id !== '(' && left.id !== '&&' && left.id !== '||' && |
| | 3599 | left.id !== '?') { |
| | 3600 | warn('bad_invocation', left); |
| | 3601 | } |
| | 3602 | } |
| | 3603 | that.first = left; |
| | 3604 | that.second = p; |
| | 3605 | return that; |
| | 3606 | }, true); |
| | 3607 | |
| | 3608 | prefix('(', function () { |
| | 3609 | step_in('expression'); |
| | 3610 | no_space(); |
| | 3611 | edge(); |
| | 3612 | if (next_token.id === 'function') { |
| | 3613 | next_token.immed = true; |
| | 3614 | } |
| | 3615 | var value = expression(0); |
| | 3616 | value.paren = true; |
| | 3617 | no_space(); |
| | 3618 | step_out(')', this); |
| | 3619 | if (value.id === 'function') { |
| | 3620 | switch (next_token.id) { |
| | 3621 | case '(': |
| | 3622 | warn('move_invocation'); |
| | 3623 | break; |
| | 3624 | case '.': |
| | 3625 | case '[': |
| | 3626 | warn('unexpected_a'); |
| | 3627 | break; |
| | 3628 | default: |
| | 3629 | warn('bad_wrap', this); |
| | 3630 | } |
| | 3631 | } |
| | 3632 | return value; |
| | 3633 | }); |
| | 3634 | |
| | 3635 | infix('.', 170, function (left, that) { |
| | 3636 | no_space(prev_token, token); |
| | 3637 | no_space(); |
| | 3638 | var name = identifier(); |
| | 3639 | if (typeof name === 'string') { |
| | 3640 | tally_property(name); |
| | 3641 | } |
| | 3642 | that.first = left; |
| | 3643 | that.second = token; |
| | 3644 | if (left && left.string === 'arguments' && |
| | 3645 | (name === 'callee' || name === 'caller')) { |
| | 3646 | warn('avoid_a', left, 'arguments.' + name); |
| | 3647 | } else if (!option.evil && left && left.string === 'document' && |
| | 3648 | (name === 'write' || name === 'writeln')) { |
| | 3649 | warn('write_is_wrong', left); |
| | 3650 | } else if (option.adsafe) { |
| | 3651 | if (!adsafe_top && left.string === 'ADSAFE') { |
| | 3652 | if (name === 'id' || name === 'lib') { |
| | 3653 | warn('adsafe_a', that); |
| | 3654 | } else if (name === 'go') { |
| | 3655 | if (xmode !== 'script') { |
| | 3656 | warn('adsafe_a', that); |
| | 3657 | } else if (adsafe_went || next_token.id !== '(' || |
| | 3658 | peek(0).id !== '(string)' || |
| | 3659 | peek(0).string !== adsafe_id || |
| | 3660 | peek(1).id !== ',') { |
| | 3661 | stop('adsafe_a', that, 'go'); |
| | 3662 | } |
| | 3663 | adsafe_went = true; |
| | 3664 | adsafe_may = false; |
| | 3665 | } |
| | 3666 | } |
| | 3667 | adsafe_top = false; |
| | 3668 | } |
| | 3669 | if (!option.evil && (name === 'eval' || name === 'execScript')) { |
| | 3670 | warn('evil'); |
| | 3671 | } else if (option.safe) { |
| | 3672 | for (;;) { |
| | 3673 | if (banned[name] === true) { |
| | 3674 | warn('adsafe_a', token, name); |
| | 3675 | } |
| | 3676 | if (typeof predefined[left.string] !== 'boolean' || //// check for writeable |
| | 3677 | next_token.id === '(') { |
| | 3678 | break; |
| | 3679 | } |
| | 3680 | if (next_token.id !== '.') { |
| | 3681 | warn('adsafe_a', that); |
| | 3682 | break; |
| | 3683 | } |
| | 3684 | advance('.'); |
| | 3685 | token.first = that; |
| | 3686 | token.second = name; |
| | 3687 | that = token; |
| | 3688 | name = identifier(); |
| | 3689 | if (typeof name === 'string') { |
| | 3690 | tally_property(name); |
| | 3691 | } |
| | 3692 | } |
| | 3693 | } |
| | 3694 | return that; |
| | 3695 | }, true); |
| | 3696 | |
| | 3697 | infix('[', 170, function (left, that) { |
| | 3698 | var e, s; |
| | 3699 | no_space_only(prev_token, token); |
| | 3700 | no_space(); |
| | 3701 | step_in(); |
| | 3702 | edge(); |
| | 3703 | e = expression(0); |
| | 3704 | switch (e.id) { |
| | 3705 | case '(number)': |
| | 3706 | if (e.id === '(number)' && left.id === 'arguments') { |
| | 3707 | warn('use_param', left); |
| | 3708 | } |
| | 3709 | break; |
| | 3710 | case '(string)': |
| | 3711 | if (option.safe && (banned[e.string] || |
| | 3712 | e.string.charAt(0) === '_' || e.string.slice(-1) === '_')) { |
| | 3713 | warn('adsafe_subscript_a', e); |
| | 3714 | } else if (!option.evil && |
| | 3715 | (e.string === 'eval' || e.string === 'execScript')) { |
| | 3716 | warn('evil', e); |
| | 3717 | } else if (!option.sub && ix.test(e.string)) { |
| | 3718 | s = syntax[e.string]; |
| | 3719 | if (!s || !s.reserved) { |
| | 3720 | warn('subscript', e); |
| | 3721 | } |
| | 3722 | } |
| | 3723 | tally_property(e.string); |
| | 3724 | break; |
| | 3725 | default: |
| | 3726 | if (option.safe) { |
| | 3727 | warn('adsafe_subscript_a', e); |
| | 3728 | } |
| | 3729 | } |
| | 3730 | step_out(']', that); |
| | 3731 | no_space(prev_token, token); |
| | 3732 | that.first = left; |
| | 3733 | that.second = e; |
| | 3734 | return that; |
| | 3735 | }, true); |
| | 3736 | |
| | 3737 | prefix('[', function () { |
| | 3738 | this.arity = 'prefix'; |
| | 3739 | this.first = []; |
| | 3740 | step_in('array'); |
| | 3741 | while (next_token.id !== '(end)') { |
| | 3742 | while (next_token.id === ',') { |
| | 3743 | warn('unexpected_a', next_token); |
| | 3744 | advance(','); |
| | 3745 | } |
| | 3746 | if (next_token.id === ']') { |
| | 3747 | break; |
| | 3748 | } |
| | 3749 | indent.wrap = false; |
| | 3750 | edge(); |
| | 3751 | this.first.push(expression(10)); |
| | 3752 | if (next_token.id === ',') { |
| | 3753 | comma(); |
| | 3754 | if (next_token.id === ']' && !option.es5) { |
| | 3755 | warn('unexpected_a', token); |
| | 3756 | break; |
| | 3757 | } |
| | 3758 | } else { |
| | 3759 | break; |
| | 3760 | } |
| | 3761 | } |
| | 3762 | step_out(']', this); |
| | 3763 | return this; |
| | 3764 | }, 170); |
| | 3765 | |
| | 3766 | |
| | 3767 | function property_name() { |
| | 3768 | var id = optional_identifier(true); |
| | 3769 | if (!id) { |
| | 3770 | if (next_token.id === '(string)') { |
| | 3771 | id = next_token.string; |
| | 3772 | if (option.safe) { |
| | 3773 | if (banned[id]) { |
| | 3774 | warn('adsafe_a'); |
| | 3775 | } else if (id.charAt(0) === '_' || |
| | 3776 | id.charAt(id.length - 1) === '_') { |
| | 3777 | warn('dangling_a'); |
| | 3778 | } |
| | 3779 | } |
| | 3780 | advance(); |
| | 3781 | } else if (next_token.id === '(number)') { |
| | 3782 | id = next_token.number.toString(); |
| | 3783 | advance(); |
| | 3784 | } |
| | 3785 | } |
| | 3786 | return id; |
| | 3787 | } |
| | 3788 | |
| | 3789 | |
| | 3790 | function function_params() { |
| | 3791 | var id, paren = next_token, params = []; |
| | 3792 | advance('('); |
| | 3793 | step_in(); |
| | 3794 | no_space(); |
| | 3795 | if (next_token.id === ')') { |
| | 3796 | no_space(); |
| | 3797 | step_out(')', paren); |
| | 3798 | return params; |
| | 3799 | } |
| | 3800 | for (;;) { |
| | 3801 | edge(); |
| | 3802 | id = identifier(); |
| | 3803 | params.push(token); |
| | 3804 | add_label(token, option.unparam ? 'parameter' : 'unparam'); |
| | 3805 | if (next_token.id === ',') { |
| | 3806 | comma(); |
| | 3807 | } else { |
| | 3808 | no_space(); |
| | 3809 | step_out(')', paren); |
| | 3810 | return params; |
| | 3811 | } |
| | 3812 | } |
| | 3813 | } |
| | 3814 | |
| | 3815 | |
| | 3816 | |
| | 3817 | function do_function(func, name) { |
| | 3818 | var old_funct = funct, |
| | 3819 | old_option = option, |
| | 3820 | old_scope = scope; |
| | 3821 | funct = { |
| | 3822 | '(name)' : name || '\'' + (anonname || '').replace(nx, sanitize) + '\'', |
| | 3823 | '(line)' : next_token.line, |
| | 3824 | '(context)' : old_funct, |
| | 3825 | '(breakage)' : 0, |
| | 3826 | '(loopage)' : 0, |
| | 3827 | '(scope)' : scope, |
| | 3828 | '(token)' : func |
| | 3829 | }; |
| | 3830 | option = Object.create(old_option); |
| | 3831 | scope = Object.create(old_scope); |
| | 3832 | functions.push(funct); |
| | 3833 | func.name = name; |
| | 3834 | if (name) { |
| | 3835 | add_label(func, 'function', name); |
| | 3836 | } |
| | 3837 | func.writeable = false; |
| | 3838 | func.first = funct['(params)'] = function_params(); |
| | 3839 | one_space(); |
| | 3840 | func.block = block(false); |
| | 3841 | if (funct['(arguments)']) { |
| | 3842 | func.first.forEach(function (value) { |
| | 3843 | if (value.assign) { |
| | 3844 | warn('parameter_arguments_a', value, value.string); |
| | 3845 | } |
| | 3846 | }); |
| | 3847 | } |
| | 3848 | funct = old_funct; |
| | 3849 | option = old_option; |
| | 3850 | scope = old_scope; |
| | 3851 | } |
| | 3852 | |
| | 3853 | |
| | 3854 | assignop('='); |
| | 3855 | assignop('+=', '+'); |
| | 3856 | assignop('-=', '-'); |
| | 3857 | assignop('*=', '*'); |
| | 3858 | assignop('/=', '/').nud = function () { |
| | 3859 | stop('slash_equal'); |
| | 3860 | }; |
| | 3861 | assignop('%=', '%'); |
| | 3862 | assignop('&=', '&'); |
| | 3863 | assignop('|=', '|'); |
| | 3864 | assignop('^=', '^'); |
| | 3865 | assignop('<<=', '<<'); |
| | 3866 | assignop('>>=', '>>'); |
| | 3867 | assignop('>>>=', '>>>'); |
| | 3868 | |
| | 3869 | |
| | 3870 | prefix('{', function () { |
| | 3871 | var get, i, j, name, p, set, seen = {}; |
| | 3872 | this.arity = 'prefix'; |
| | 3873 | this.first = []; |
| | 3874 | step_in(); |
| | 3875 | while (next_token.id !== '}') { |
| | 3876 | indent.wrap = false; |
| | 3877 | |
| | 3878 | // JSLint recognizes the ES5 extension for get/set in object literals, |
| | 3879 | // but requires that they be used in pairs. |
| | 3880 | |
| | 3881 | edge(); |
| | 3882 | if (next_token.string === 'get' && peek().id !== ':') { |
| | 3883 | if (!option.es5) { |
| | 3884 | warn('es5'); |
| | 3885 | } |
| | 3886 | get = next_token; |
| | 3887 | advance('get'); |
| | 3888 | one_space_only(); |
| | 3889 | name = next_token; |
| | 3890 | i = property_name(); |
| | 3891 | if (!i) { |
| | 3892 | stop('missing_property'); |
| | 3893 | } |
| | 3894 | get.string = ''; |
| | 3895 | do_function(get); |
| | 3896 | if (funct['(loopage)']) { |
| | 3897 | warn('function_loop', get); |
| | 3898 | } |
| | 3899 | p = get.first; |
| | 3900 | if (p) { |
| | 3901 | warn('parameter_a_get_b', p[0], p[0].string, i); |
| | 3902 | } |
| | 3903 | comma(); |
| | 3904 | set = next_token; |
| | 3905 | spaces(); |
| | 3906 | edge(); |
| | 3907 | advance('set'); |
| | 3908 | set.string = ''; |
| | 3909 | one_space_only(); |
| | 3910 | j = property_name(); |
| | 3911 | if (i !== j) { |
| | 3912 | stop('expected_a_b', token, i, j || next_token.string); |
| | 3913 | } |
| | 3914 | do_function(set); |
| | 3915 | if (set.block.length === 0) { |
| | 3916 | warn('missing_a', token, 'throw'); |
| | 3917 | } |
| | 3918 | p = set.first; |
| | 3919 | if (!p || p.length !== 1) { |
| | 3920 | stop('parameter_set_a', set, 'value'); |
| | 3921 | } else if (p[0].string !== 'value') { |
| | 3922 | stop('expected_a_b', p[0], 'value', p[0].string); |
| | 3923 | } |
| | 3924 | name.first = [get, set]; |
| | 3925 | } else { |
| | 3926 | name = next_token; |
| | 3927 | i = property_name(); |
| | 3928 | if (typeof i !== 'string') { |
| | 3929 | stop('missing_property'); |
| | 3930 | } |
| | 3931 | advance(':'); |
| | 3932 | spaces(); |
| | 3933 | name.first = expression(10); |
| | 3934 | } |
| | 3935 | this.first.push(name); |
| | 3936 | if (seen[i] === true) { |
| | 3937 | warn('duplicate_a', next_token, i); |
| | 3938 | } |
| | 3939 | seen[i] = true; |
| | 3940 | tally_property(i); |
| | 3941 | if (next_token.id !== ',') { |
| | 3942 | break; |
| | 3943 | } |
| | 3944 | for (;;) { |
| | 3945 | comma(); |
| | 3946 | if (next_token.id !== ',') { |
| | 3947 | break; |
| | 3948 | } |
| | 3949 | warn('unexpected_a', next_token); |
| | 3950 | } |
| | 3951 | if (next_token.id === '}' && !option.es5) { |
| | 3952 | warn('unexpected_a', token); |
| | 3953 | } |
| | 3954 | } |
| | 3955 | step_out('}', this); |
| | 3956 | return this; |
| | 3957 | }); |
| | 3958 | |
| | 3959 | stmt('{', function () { |
| | 3960 | warn('statement_block'); |
| | 3961 | this.arity = 'statement'; |
| | 3962 | this.block = statements(); |
| | 3963 | this.disrupt = this.block.disrupt; |
| | 3964 | advance('}', this); |
| | 3965 | return this; |
| | 3966 | }); |
| | 3967 | |
| | 3968 | stmt('/*global', directive); |
| | 3969 | stmt('/*globals', directive); |
| | 3970 | stmt('/*jslint', directive); |
| | 3971 | stmt('/*member', directive); |
| | 3972 | stmt('/*members', directive); |
| | 3973 | stmt('/*property', directive); |
| | 3974 | stmt('/*properties', directive); |
| | 3975 | |
| | 3976 | stmt('var', function () { |
| | 3977 | |
| | 3978 | // JavaScript does not have block scope. It only has function scope. So, |
| | 3979 | // declaring a variable in a block can have unexpected consequences. |
| | 3980 | |
| | 3981 | // var.first will contain an array, the array containing name tokens |
| | 3982 | // and assignment tokens. |
| | 3983 | |
| | 3984 | var assign, id, name; |
| | 3985 | |
| | 3986 | if (funct['(vars)'] && !option.vars) { |
| | 3987 | warn('combine_var'); |
| | 3988 | } else if (funct !== global_funct) { |
| | 3989 | funct['(vars)'] = true; |
| | 3990 | } |
| | 3991 | this.arity = 'statement'; |
| | 3992 | this.first = []; |
| | 3993 | step_in('var'); |
| | 3994 | for (;;) { |
| | 3995 | name = next_token; |
| | 3996 | id = identifier(); |
| | 3997 | add_label(name, 'becoming'); |
| | 3998 | |
| | 3999 | if (next_token.id === '=') { |
| | 4000 | assign = next_token; |
| | 4001 | assign.first = name; |
| | 4002 | spaces(); |
| | 4003 | advance('='); |
| | 4004 | spaces(); |
| | 4005 | if (next_token.id === 'undefined') { |
| | 4006 | warn('unnecessary_initialize', token, id); |
| | 4007 | } |
| | 4008 | if (peek(0).id === '=' && next_token.identifier) { |
| | 4009 | stop('var_a_not'); |
| | 4010 | } |
| | 4011 | assign.second = expression(0); |
| | 4012 | assign.arity = 'infix'; |
| | 4013 | this.first.push(assign); |
| | 4014 | } else { |
| | 4015 | this.first.push(name); |
| | 4016 | } |
| | 4017 | if (funct[id] === 'becoming') { |
| | 4018 | funct[id] = 'unused'; |
| | 4019 | } |
| | 4020 | if (next_token.id !== ',') { |
| | 4021 | break; |
| | 4022 | } |
| | 4023 | comma(); |
| | 4024 | indent.wrap = false; |
| | 4025 | if (var_mode && next_token.line === token.line && |
| | 4026 | this.first.length === 1) { |
| | 4027 | var_mode = null; |
| | 4028 | indent.open = false; |
| | 4029 | indent.at -= option.indent; |
| | 4030 | } |
| | 4031 | spaces(); |
| | 4032 | edge(); |
| | 4033 | } |
| | 4034 | var_mode = null; |
| | 4035 | step_out(); |
| | 4036 | return this; |
| | 4037 | }); |
| | 4038 | |
| | 4039 | stmt('function', function () { |
| | 4040 | one_space(); |
| | 4041 | if (in_block) { |
| | 4042 | warn('function_block', token); |
| | 4043 | } |
| | 4044 | var name = next_token, id = identifier(); |
| | 4045 | add_label(name, 'unction'); |
| | 4046 | no_space(); |
| | 4047 | this.arity = 'statement'; |
| | 4048 | do_function(this, id); |
| | 4049 | if (next_token.id === '(' && next_token.line === token.line) { |
| | 4050 | stop('function_statement'); |
| | 4051 | } |
| | 4052 | return this; |
| | 4053 | }); |
| | 4054 | |
| | 4055 | prefix('function', function () { |
| | 4056 | if (!option.anon) { |
| | 4057 | one_space(); |
| | 4058 | } |
| | 4059 | var id = optional_identifier(); |
| | 4060 | if (id) { |
| | 4061 | no_space(); |
| | 4062 | } else { |
| | 4063 | id = ''; |
| | 4064 | } |
| | 4065 | do_function(this, id); |
| | 4066 | if (funct['(loopage)']) { |
| | 4067 | warn('function_loop'); |
| | 4068 | } |
| | 4069 | switch (next_token.id) { |
| | 4070 | case ';': |
| | 4071 | case '(': |
| | 4072 | case ')': |
| | 4073 | case ',': |
| | 4074 | case ']': |
| | 4075 | case '}': |
| | 4076 | case ':': |
| | 4077 | break; |
| | 4078 | case '.': |
| | 4079 | if (peek().string !== 'bind' || peek(1).id !== '(') { |
| | 4080 | warn('unexpected_a'); |
| | 4081 | } |
| | 4082 | break; |
| | 4083 | default: |
| | 4084 | stop('unexpected_a'); |
| | 4085 | } |
| | 4086 | this.arity = 'function'; |
| | 4087 | return this; |
| | 4088 | }); |
| | 4089 | |
| | 4090 | stmt('if', function () { |
| | 4091 | var paren = next_token; |
| | 4092 | one_space(); |
| | 4093 | advance('('); |
| | 4094 | step_in('control'); |
| | 4095 | no_space(); |
| | 4096 | edge(); |
| | 4097 | this.arity = 'statement'; |
| | 4098 | this.first = expected_condition(expected_relation(expression(0))); |
| | 4099 | no_space(); |
| | 4100 | step_out(')', paren); |
| | 4101 | one_space(); |
| | 4102 | this.block = block(true); |
| | 4103 | if (next_token.id === 'else') { |
| | 4104 | one_space(); |
| | 4105 | advance('else'); |
| | 4106 | one_space(); |
| | 4107 | this['else'] = next_token.id === 'if' || next_token.id === 'switch' |
| | 4108 | ? statement(true) |
| | 4109 | : block(true); |
| | 4110 | if (this['else'].disrupt && this.block.disrupt) { |
| | 4111 | this.disrupt = true; |
| | 4112 | } |
| | 4113 | } |
| | 4114 | return this; |
| | 4115 | }); |
| | 4116 | |
| | 4117 | stmt('try', function () { |
| | 4118 | |
| | 4119 | // try.first The catch variable |
| | 4120 | // try.second The catch clause |
| | 4121 | // try.third The finally clause |
| | 4122 | // try.block The try block |
| | 4123 | |
| | 4124 | var exception_variable, old_scope, paren; |
| | 4125 | if (option.adsafe) { |
| | 4126 | warn('adsafe_a', this); |
| | 4127 | } |
| | 4128 | one_space(); |
| | 4129 | this.arity = 'statement'; |
| | 4130 | this.block = block(false); |
| | 4131 | if (next_token.id === 'catch') { |
| | 4132 | one_space(); |
| | 4133 | advance('catch'); |
| | 4134 | one_space(); |
| | 4135 | paren = next_token; |
| | 4136 | advance('('); |
| | 4137 | step_in('control'); |
| | 4138 | no_space(); |
| | 4139 | edge(); |
| | 4140 | old_scope = scope; |
| | 4141 | scope = Object.create(old_scope); |
| | 4142 | exception_variable = next_token.string; |
| | 4143 | this.first = exception_variable; |
| | 4144 | if (!next_token.identifier) { |
| | 4145 | warn('expected_identifier_a', next_token); |
| | 4146 | } else { |
| | 4147 | add_label(next_token, 'exception'); |
| | 4148 | } |
| | 4149 | advance(); |
| | 4150 | no_space(); |
| | 4151 | step_out(')', paren); |
| | 4152 | one_space(); |
| | 4153 | this.second = block(false); |
| | 4154 | scope = old_scope; |
| | 4155 | } |
| | 4156 | if (next_token.id === 'finally') { |
| | 4157 | one_space(); |
| | 4158 | advance('finally'); |
| | 4159 | one_space(); |
| | 4160 | this.third = block(false); |
| | 4161 | } else if (!this.second) { |
| | 4162 | stop('expected_a_b', next_token, 'catch', artifact()); |
| | 4163 | } |
| | 4164 | return this; |
| | 4165 | }); |
| | 4166 | |
| | 4167 | labeled_stmt('while', function () { |
| | 4168 | one_space(); |
| | 4169 | var paren = next_token; |
| | 4170 | funct['(breakage)'] += 1; |
| | 4171 | funct['(loopage)'] += 1; |
| | 4172 | advance('('); |
| | 4173 | step_in('control'); |
| | 4174 | no_space(); |
| | 4175 | edge(); |
| | 4176 | this.arity = 'statement'; |
| | 4177 | this.first = expected_relation(expression(0)); |
| | 4178 | if (this.first.id !== 'true') { |
| | 4179 | expected_condition(this.first, bundle.unexpected_a); |
| | 4180 | } |
| | 4181 | no_space(); |
| | 4182 | step_out(')', paren); |
| | 4183 | one_space(); |
| | 4184 | this.block = block(true); |
| | 4185 | if (this.block.disrupt) { |
| | 4186 | warn('strange_loop', prev_token); |
| | 4187 | } |
| | 4188 | funct['(breakage)'] -= 1; |
| | 4189 | funct['(loopage)'] -= 1; |
| | 4190 | return this; |
| | 4191 | }); |
| | 4192 | |
| | 4193 | reserve('with'); |
| | 4194 | |
| | 4195 | labeled_stmt('switch', function () { |
| | 4196 | |
| | 4197 | // switch.first the switch expression |
| | 4198 | // switch.second the array of cases. A case is 'case' or 'default' token: |
| | 4199 | // case.first the array of case expressions |
| | 4200 | // case.second the array of statements |
| | 4201 | // If all of the arrays of statements are disrupt, then the switch is disrupt. |
| | 4202 | |
| | 4203 | var cases = [], |
| | 4204 | old_in_block = in_block, |
| | 4205 | particular, |
| | 4206 | the_case = next_token, |
| | 4207 | unbroken = true; |
| | 4208 | |
| | 4209 | function find_duplicate_case(value) { |
| | 4210 | if (are_similar(particular, value)) { |
| | 4211 | warn('duplicate_a', value); |
| | 4212 | } |
| | 4213 | } |
| | 4214 | |
| | 4215 | funct['(breakage)'] += 1; |
| | 4216 | one_space(); |
| | 4217 | advance('('); |
| | 4218 | no_space(); |
| | 4219 | step_in(); |
| | 4220 | this.arity = 'statement'; |
| | 4221 | this.first = expected_condition(expected_relation(expression(0))); |
| | 4222 | no_space(); |
| | 4223 | step_out(')', the_case); |
| | 4224 | one_space(); |
| | 4225 | advance('{'); |
| | 4226 | step_in(); |
| | 4227 | in_block = true; |
| | 4228 | this.second = []; |
| | 4229 | while (next_token.id === 'case') { |
| | 4230 | the_case = next_token; |
| | 4231 | cases.forEach(find_duplicate_case); |
| | 4232 | the_case.first = []; |
| | 4233 | the_case.arity = 'case'; |
| | 4234 | spaces(); |
| | 4235 | edge('case'); |
| | 4236 | advance('case'); |
| | 4237 | for (;;) { |
| | 4238 | one_space(); |
| | 4239 | particular = expression(0); |
| | 4240 | cases.forEach(find_duplicate_case); |
| | 4241 | cases.push(particular); |
| | 4242 | the_case.first.push(particular); |
| | 4243 | if (particular.id === 'NaN') { |
| | 4244 | warn('unexpected_a', particular); |
| | 4245 | } |
| | 4246 | no_space_only(); |
| | 4247 | advance(':'); |
| | 4248 | if (next_token.id !== 'case') { |
| | 4249 | break; |
| | 4250 | } |
| | 4251 | spaces(); |
| | 4252 | edge('case'); |
| | 4253 | advance('case'); |
| | 4254 | } |
| | 4255 | spaces(); |
| | 4256 | the_case.second = statements(); |
| | 4257 | if (the_case.second && the_case.second.length > 0) { |
| | 4258 | particular = the_case.second[the_case.second.length - 1]; |
| | 4259 | if (particular.disrupt) { |
| | 4260 | if (particular.id === 'break') { |
| | 4261 | unbroken = false; |
| | 4262 | } |
| | 4263 | } else { |
| | 4264 | warn('missing_a_after_b', next_token, 'break', 'case'); |
| | 4265 | } |
| | 4266 | } else { |
| | 4267 | warn('empty_case'); |
| | 4268 | } |
| | 4269 | this.second.push(the_case); |
| | 4270 | } |
| | 4271 | if (this.second.length === 0) { |
| | 4272 | warn('missing_a', next_token, 'case'); |
| | 4273 | } |
| | 4274 | if (next_token.id === 'default') { |
| | 4275 | spaces(); |
| | 4276 | the_case = next_token; |
| | 4277 | the_case.arity = 'case'; |
| | 4278 | edge('case'); |
| | 4279 | advance('default'); |
| | 4280 | no_space_only(); |
| | 4281 | advance(':'); |
| | 4282 | spaces(); |
| | 4283 | the_case.second = statements(); |
| | 4284 | if (the_case.second && the_case.second.length > 0) { |
| | 4285 | particular = the_case.second[the_case.second.length - 1]; |
| | 4286 | if (unbroken && particular.disrupt && particular.id !== 'break') { |
| | 4287 | this.disrupt = true; |
| | 4288 | } |
| | 4289 | } |
| | 4290 | this.second.push(the_case); |
| | 4291 | } |
| | 4292 | funct['(breakage)'] -= 1; |
| | 4293 | spaces(); |
| | 4294 | step_out('}', this); |
| | 4295 | in_block = old_in_block; |
| | 4296 | return this; |
| | 4297 | }); |
| | 4298 | |
| | 4299 | stmt('debugger', function () { |
| | 4300 | if (!option.debug) { |
| | 4301 | warn('unexpected_a', this); |
| | 4302 | } |
| | 4303 | this.arity = 'statement'; |
| | 4304 | return this; |
| | 4305 | }); |
| | 4306 | |
| | 4307 | labeled_stmt('do', function () { |
| | 4308 | funct['(breakage)'] += 1; |
| | 4309 | funct['(loopage)'] += 1; |
| | 4310 | one_space(); |
| | 4311 | this.arity = 'statement'; |
| | 4312 | this.block = block(true); |
| | 4313 | if (this.block.disrupt) { |
| | 4314 | warn('strange_loop', prev_token); |
| | 4315 | } |
| | 4316 | one_space(); |
| | 4317 | advance('while'); |
| | 4318 | var paren = next_token; |
| | 4319 | one_space(); |
| | 4320 | advance('('); |
| | 4321 | step_in(); |
| | 4322 | no_space(); |
| | 4323 | edge(); |
| | 4324 | this.first = expected_condition(expected_relation(expression(0)), bundle.unexpected_a); |
| | 4325 | no_space(); |
| | 4326 | step_out(')', paren); |
| | 4327 | funct['(breakage)'] -= 1; |
| | 4328 | funct['(loopage)'] -= 1; |
| | 4329 | return this; |
| | 4330 | }); |
| | 4331 | |
| | 4332 | labeled_stmt('for', function () { |
| | 4333 | |
| | 4334 | var blok, filter, ok = false, paren = next_token, value; |
| | 4335 | this.arity = 'statement'; |
| | 4336 | funct['(breakage)'] += 1; |
| | 4337 | funct['(loopage)'] += 1; |
| | 4338 | advance('('); |
| | 4339 | if (next_token.id === ';') { |
| | 4340 | no_space(); |
| | 4341 | advance(';'); |
| | 4342 | no_space(); |
| | 4343 | advance(';'); |
| | 4344 | no_space(); |
| | 4345 | advance(')'); |
| | 4346 | blok = block(true); |
| | 4347 | } else { |
| | 4348 | step_in('control'); |
| | 4349 | spaces(this, paren); |
| | 4350 | no_space(); |
| | 4351 | if (next_token.id === 'var') { |
| | 4352 | stop('move_var'); |
| | 4353 | } |
| | 4354 | edge(); |
| | 4355 | if (peek(0).id === 'in') { |
| | 4356 | this.forin = true; |
| | 4357 | value = next_token; |
| | 4358 | switch (funct[value.string]) { |
| | 4359 | case 'unused': |
| | 4360 | funct[value.string] = 'var'; |
| | 4361 | break; |
| | 4362 | case 'closure': |
| | 4363 | case 'var': |
| | 4364 | break; |
| | 4365 | default: |
| | 4366 | warn('bad_in_a', value); |
| | 4367 | } |
| | 4368 | advance(); |
| | 4369 | advance('in'); |
| | 4370 | this.first = value; |
| | 4371 | this.second = expression(20); |
| | 4372 | step_out(')', paren); |
| | 4373 | blok = block(true); |
| | 4374 | if (!option.forin) { |
| | 4375 | if (blok.length === 1 && typeof blok[0] === 'object' && |
| | 4376 | blok[0].string === 'if' && !blok[0]['else']) { |
| | 4377 | filter = blok[0].first; |
| | 4378 | while (filter.id === '&&') { |
| | 4379 | filter = filter.first; |
| | 4380 | } |
| | 4381 | switch (filter.id) { |
| | 4382 | case '===': |
| | 4383 | case '!==': |
| | 4384 | ok = filter.first.id === '[' |
| | 4385 | ? filter.first.first.string === this.second.string && |
| | 4386 | filter.first.second.string === this.first.string |
| | 4387 | : filter.first.id === 'typeof' && |
| | 4388 | filter.first.first.id === '[' && |
| | 4389 | filter.first.first.first.string === this.second.string && |
| | 4390 | filter.first.first.second.string === this.first.string; |
| | 4391 | break; |
| | 4392 | case '(': |
| | 4393 | ok = filter.first.id === '.' && (( |
| | 4394 | filter.first.first.string === this.second.string && |
| | 4395 | filter.first.second.string === 'hasOwnProperty' && |
| | 4396 | filter.second[0].string === this.first.string |
| | 4397 | ) || ( |
| | 4398 | filter.first.first.string === 'ADSAFE' && |
| | 4399 | filter.first.second.string === 'has' && |
| | 4400 | filter.second[0].string === this.second.string && |
| | 4401 | filter.second[1].string === this.first.string |
| | 4402 | ) || ( |
| | 4403 | filter.first.first.id === '.' && |
| | 4404 | filter.first.first.first.id === '.' && |
| | 4405 | filter.first.first.first.first.string === 'Object' && |
| | 4406 | filter.first.first.first.second.string === 'prototype' && |
| | 4407 | filter.first.first.second.string === 'hasOwnProperty' && |
| | 4408 | filter.first.second.string === 'call' && |
| | 4409 | filter.second[0].string === this.second.string && |
| | 4410 | filter.second[1].string === this.first.string |
| | 4411 | )); |
| | 4412 | break; |
| | 4413 | } |
| | 4414 | } |
| | 4415 | if (!ok) { |
| | 4416 | warn('for_if', this); |
| | 4417 | } |
| | 4418 | } |
| | 4419 | } else { |
| | 4420 | edge(); |
| | 4421 | this.first = []; |
| | 4422 | for (;;) { |
| | 4423 | this.first.push(expression(0, 'for')); |
| | 4424 | if (next_token.id !== ',') { |
| | 4425 | break; |
| | 4426 | } |
| | 4427 | comma(); |
| | 4428 | } |
| | 4429 | semicolon(); |
| | 4430 | edge(); |
| | 4431 | this.second = expected_relation(expression(0)); |
| | 4432 | if (this.second.id !== 'true') { |
| | 4433 | expected_condition(this.second, bundle.unexpected_a); |
| | 4434 | } |
| | 4435 | semicolon(token); |
| | 4436 | if (next_token.id === ';') { |
| | 4437 | stop('expected_a_b', next_token, ')', ';'); |
| | 4438 | } |
| | 4439 | this.third = []; |
| | 4440 | edge(); |
| | 4441 | for (;;) { |
| | 4442 | this.third.push(expression(0, 'for')); |
| | 4443 | if (next_token.id !== ',') { |
| | 4444 | break; |
| | 4445 | } |
| | 4446 | comma(); |
| | 4447 | } |
| | 4448 | no_space(); |
| | 4449 | step_out(')', paren); |
| | 4450 | one_space(); |
| | 4451 | blok = block(true); |
| | 4452 | } |
| | 4453 | } |
| | 4454 | if (blok.disrupt) { |
| | 4455 | warn('strange_loop', prev_token); |
| | 4456 | } |
| | 4457 | this.block = blok; |
| | 4458 | funct['(breakage)'] -= 1; |
| | 4459 | funct['(loopage)'] -= 1; |
| | 4460 | return this; |
| | 4461 | }); |
| | 4462 | |
| | 4463 | disrupt_stmt('break', function () { |
| | 4464 | var label = next_token.string; |
| | 4465 | this.arity = 'statement'; |
| | 4466 | if (funct['(breakage)'] === 0) { |
| | 4467 | warn('unexpected_a', this); |
| | 4468 | } |
| | 4469 | if (next_token.identifier && token.line === next_token.line) { |
| | 4470 | one_space_only(); |
| | 4471 | if (funct[label] !== 'label') { |
| | 4472 | warn('not_a_label', next_token); |
| | 4473 | } else if (scope[label].funct !== funct) { |
| | 4474 | warn('not_a_scope', next_token); |
| | 4475 | } |
| | 4476 | this.first = next_token; |
| | 4477 | advance(); |
| | 4478 | } |
| | 4479 | return this; |
| | 4480 | }); |
| | 4481 | |
| | 4482 | disrupt_stmt('continue', function () { |
| | 4483 | if (!option['continue']) { |
| | 4484 | warn('unexpected_a', this); |
| | 4485 | } |
| | 4486 | var label = next_token.string; |
| | 4487 | this.arity = 'statement'; |
| | 4488 | if (funct['(breakage)'] === 0) { |
| | 4489 | warn('unexpected_a', this); |
| | 4490 | } |
| | 4491 | if (next_token.identifier && token.line === next_token.line) { |
| | 4492 | one_space_only(); |
| | 4493 | if (funct[label] !== 'label') { |
| | 4494 | warn('not_a_label', next_token); |
| | 4495 | } else if (scope[label].funct !== funct) { |
| | 4496 | warn('not_a_scope', next_token); |
| | 4497 | } |
| | 4498 | this.first = next_token; |
| | 4499 | advance(); |
| | 4500 | } |
| | 4501 | return this; |
| | 4502 | }); |
| | 4503 | |
| | 4504 | disrupt_stmt('return', function () { |
| | 4505 | if (funct === global_funct && xmode !== 'scriptstring') { |
| | 4506 | warn('unexpected_a', this); |
| | 4507 | } |
| | 4508 | this.arity = 'statement'; |
| | 4509 | if (next_token.id !== ';' && next_token.line === token.line) { |
| | 4510 | one_space_only(); |
| | 4511 | if (next_token.id === '/' || next_token.id === '(regexp)') { |
| | 4512 | warn('wrap_regexp'); |
| | 4513 | } |
| | 4514 | this.first = expression(20); |
| | 4515 | } |
| | 4516 | if (peek(0).id === '}' && peek(1).id === 'else') { |
| | 4517 | warn('unexpected_else', this); |
| | 4518 | } |
| | 4519 | return this; |
| | 4520 | }); |
| | 4521 | |
| | 4522 | disrupt_stmt('throw', function () { |
| | 4523 | this.arity = 'statement'; |
| | 4524 | one_space_only(); |
| | 4525 | this.first = expression(20); |
| | 4526 | return this; |
| | 4527 | }); |
| | 4528 | |
| | 4529 | |
| | 4530 | // Superfluous reserved words |
| | 4531 | |
| | 4532 | reserve('class'); |
| | 4533 | reserve('const'); |
| | 4534 | reserve('enum'); |
| | 4535 | reserve('export'); |
| | 4536 | reserve('extends'); |
| | 4537 | reserve('import'); |
| | 4538 | reserve('super'); |
| | 4539 | |
| | 4540 | // Harmony reserved words |
| | 4541 | |
| | 4542 | reserve('implements'); |
| | 4543 | reserve('interface'); |
| | 4544 | reserve('let'); |
| | 4545 | reserve('package'); |
| | 4546 | reserve('private'); |
| | 4547 | reserve('protected'); |
| | 4548 | reserve('public'); |
| | 4549 | reserve('static'); |
| | 4550 | reserve('yield'); |
| | 4551 | |
| | 4552 | |
| | 4553 | // Parse JSON |
| | 4554 | |
| | 4555 | function json_value() { |
| | 4556 | |
| | 4557 | function json_object() { |
| | 4558 | var brace = next_token, object = {}; |
| | 4559 | advance('{'); |
| | 4560 | if (next_token.id !== '}') { |
| | 4561 | while (next_token.id !== '(end)') { |
| | 4562 | while (next_token.id === ',') { |
| | 4563 | warn('unexpected_a', next_token); |
| | 4564 | advance(','); |
| | 4565 | } |
| | 4566 | if (next_token.id !== '(string)') { |
| | 4567 | warn('expected_string_a'); |
| | 4568 | } |
| | 4569 | if (object[next_token.string] === true) { |
| | 4570 | warn('duplicate_a'); |
| | 4571 | } else if (next_token.string === '__proto__') { |
| | 4572 | warn('dangling_a'); |
| | 4573 | } else { |
| | 4574 | object[next_token.string] = true; |
| | 4575 | } |
| | 4576 | advance(); |
| | 4577 | advance(':'); |
| | 4578 | json_value(); |
| | 4579 | if (next_token.id !== ',') { |
| | 4580 | break; |
| | 4581 | } |
| | 4582 | advance(','); |
| | 4583 | if (next_token.id === '}') { |
| | 4584 | warn('unexpected_a', token); |
| | 4585 | break; |
| | 4586 | } |
| | 4587 | } |
| | 4588 | } |
| | 4589 | advance('}', brace); |
| | 4590 | } |
| | 4591 | |
| | 4592 | function json_array() { |
| | 4593 | var bracket = next_token; |
| | 4594 | advance('['); |
| | 4595 | if (next_token.id !== ']') { |
| | 4596 | while (next_token.id !== '(end)') { |
| | 4597 | while (next_token.id === ',') { |
| | 4598 | warn('unexpected_a', next_token); |
| | 4599 | advance(','); |
| | 4600 | } |
| | 4601 | json_value(); |
| | 4602 | if (next_token.id !== ',') { |
| | 4603 | break; |
| | 4604 | } |
| | 4605 | advance(','); |
| | 4606 | if (next_token.id === ']') { |
| | 4607 | warn('unexpected_a', token); |
| | 4608 | break; |
| | 4609 | } |
| | 4610 | } |
| | 4611 | } |
| | 4612 | advance(']', bracket); |
| | 4613 | } |
| | 4614 | |
| | 4615 | switch (next_token.id) { |
| | 4616 | case '{': |
| | 4617 | json_object(); |
| | 4618 | break; |
| | 4619 | case '[': |
| | 4620 | json_array(); |
| | 4621 | break; |
| | 4622 | case 'true': |
| | 4623 | case 'false': |
| | 4624 | case 'null': |
| | 4625 | case '(number)': |
| | 4626 | case '(string)': |
| | 4627 | advance(); |
| | 4628 | break; |
| | 4629 | case '-': |
| | 4630 | advance('-'); |
| | 4631 | no_space_only(); |
| | 4632 | advance('(number)'); |
| | 4633 | break; |
| | 4634 | default: |
| | 4635 | stop('unexpected_a'); |
| | 4636 | } |
| | 4637 | } |
| | 4638 | |
| | 4639 | |
| | 4640 | // CSS parsing. |
| | 4641 | |
| | 4642 | function css_name() { |
| | 4643 | if (next_token.identifier) { |
| | 4644 | advance(); |
| | 4645 | return true; |
| | 4646 | } |
| | 4647 | } |
| | 4648 | |
| | 4649 | |
| | 4650 | function css_number() { |
| | 4651 | if (next_token.id === '-') { |
| | 4652 | advance('-'); |
| | 4653 | no_space_only(); |
| | 4654 | } |
| | 4655 | if (next_token.id === '(number)') { |
| | 4656 | advance('(number)'); |
| | 4657 | return true; |
| | 4658 | } |
| | 4659 | } |
| | 4660 | |
| | 4661 | |
| | 4662 | function css_string() { |
| | 4663 | if (next_token.id === '(string)') { |
| | 4664 | advance(); |
| | 4665 | return true; |
| | 4666 | } |
| | 4667 | } |
| | 4668 | |
| | 4669 | function css_color() { |
| | 4670 | var i, number, paren, value; |
| | 4671 | if (next_token.identifier) { |
| | 4672 | value = next_token.string; |
| | 4673 | if (value === 'rgb' || value === 'rgba') { |
| | 4674 | advance(); |
| | 4675 | paren = next_token; |
| | 4676 | advance('('); |
| | 4677 | for (i = 0; i < 3; i += 1) { |
| | 4678 | if (i) { |
| | 4679 | comma(); |
| | 4680 | } |
| | 4681 | number = next_token.number; |
| | 4682 | if (next_token.id !== '(number)' || number < 0) { |
| | 4683 | warn('expected_positive_a', next_token); |
| | 4684 | advance(); |
| | 4685 | } else { |
| | 4686 | advance(); |
| | 4687 | if (next_token.id === '%') { |
| | 4688 | advance('%'); |
| | 4689 | if (number > 100) { |
| | 4690 | warn('expected_percent_a', token, number); |
| | 4691 | } |
| | 4692 | } else { |
| | 4693 | if (number > 255) { |
| | 4694 | warn('expected_small_a', token, number); |
| | 4695 | } |
| | 4696 | } |
| | 4697 | } |
| | 4698 | } |
| | 4699 | if (value === 'rgba') { |
| | 4700 | comma(); |
| | 4701 | number = next_token.number; |
| | 4702 | if (next_token.id !== '(number)' || number < 0 || number > 1) { |
| | 4703 | warn('expected_fraction_a', next_token); |
| | 4704 | } |
| | 4705 | advance(); |
| | 4706 | if (next_token.id === '%') { |
| | 4707 | warn('unexpected_a'); |
| | 4708 | advance('%'); |
| | 4709 | } |
| | 4710 | } |
| | 4711 | advance(')', paren); |
| | 4712 | return true; |
| | 4713 | } |
| | 4714 | if (css_colorData[next_token.string] === true) { |
| | 4715 | advance(); |
| | 4716 | return true; |
| | 4717 | } |
| | 4718 | } else if (next_token.id === '(color)') { |
| | 4719 | advance(); |
| | 4720 | return true; |
| | 4721 | } |
| | 4722 | return false; |
| | 4723 | } |
| | 4724 | |
| | 4725 | |
| | 4726 | function css_length() { |
| | 4727 | if (next_token.id === '-') { |
| | 4728 | advance('-'); |
| | 4729 | no_space_only(); |
| | 4730 | } |
| | 4731 | if (next_token.id === '(number)') { |
| | 4732 | advance(); |
| | 4733 | if (next_token.id !== '(string)' && |
| | 4734 | css_lengthData[next_token.string] === true) { |
| | 4735 | no_space_only(); |
| | 4736 | advance(); |
| | 4737 | } else if (+token.number !== 0) { |
| | 4738 | warn('expected_linear_a'); |
| | 4739 | } |
| | 4740 | return true; |
| | 4741 | } |
| | 4742 | return false; |
| | 4743 | } |
| | 4744 | |
| | 4745 | |
| | 4746 | function css_line_height() { |
| | 4747 | if (next_token.id === '-') { |
| | 4748 | advance('-'); |
| | 4749 | no_space_only(); |
| | 4750 | } |
| | 4751 | if (next_token.id === '(number)') { |
| | 4752 | advance(); |
| | 4753 | if (next_token.id !== '(string)' && |
| | 4754 | css_lengthData[next_token.string] === true) { |
| | 4755 | no_space_only(); |
| | 4756 | advance(); |
| | 4757 | } |
| | 4758 | return true; |
| | 4759 | } |
| | 4760 | return false; |
| | 4761 | } |
| | 4762 | |
| | 4763 | |
| | 4764 | function css_width() { |
| | 4765 | if (next_token.identifier) { |
| | 4766 | switch (next_token.string) { |
| | 4767 | case 'thin': |
| | 4768 | case 'medium': |
| | 4769 | case 'thick': |
| | 4770 | advance(); |
| | 4771 | return true; |
| | 4772 | } |
| | 4773 | } else { |
| | 4774 | return css_length(); |
| | 4775 | } |
| | 4776 | } |
| | 4777 | |
| | 4778 | |
| | 4779 | function css_margin() { |
| | 4780 | if (next_token.identifier) { |
| | 4781 | if (next_token.string === 'auto') { |
| | 4782 | advance(); |
| | 4783 | return true; |
| | 4784 | } |
| | 4785 | } else { |
| | 4786 | return css_length(); |
| | 4787 | } |
| | 4788 | } |
| | 4789 | |
| | 4790 | function css_attr() { |
| | 4791 | if (next_token.identifier && next_token.string === 'attr') { |
| | 4792 | advance(); |
| | 4793 | advance('('); |
| | 4794 | if (!next_token.identifier) { |
| | 4795 | warn('expected_name_a'); |
| | 4796 | } |
| | 4797 | advance(); |
| | 4798 | advance(')'); |
| | 4799 | return true; |
| | 4800 | } |
| | 4801 | return false; |
| | 4802 | } |
| | 4803 | |
| | 4804 | |
| | 4805 | function css_comma_list() { |
| | 4806 | while (next_token.id !== ';') { |
| | 4807 | if (!css_name() && !css_string()) { |
| | 4808 | warn('expected_name_a'); |
| | 4809 | } |
| | 4810 | if (next_token.id !== ',') { |
| | 4811 | return true; |
| | 4812 | } |
| | 4813 | comma(); |
| | 4814 | } |
| | 4815 | } |
| | 4816 | |
| | 4817 | |
| | 4818 | function css_counter() { |
| | 4819 | if (next_token.identifier && next_token.string === 'counter') { |
| | 4820 | advance(); |
| | 4821 | advance('('); |
| | 4822 | advance(); |
| | 4823 | if (next_token.id === ',') { |
| | 4824 | comma(); |
| | 4825 | if (next_token.id !== '(string)') { |
| | 4826 | warn('expected_string_a'); |
| | 4827 | } |
| | 4828 | advance(); |
| | 4829 | } |
| | 4830 | advance(')'); |
| | 4831 | return true; |
| | 4832 | } |
| | 4833 | if (next_token.identifier && next_token.string === 'counters') { |
| | 4834 | advance(); |
| | 4835 | advance('('); |
| | 4836 | if (!next_token.identifier) { |
| | 4837 | warn('expected_name_a'); |
| | 4838 | } |
| | 4839 | advance(); |
| | 4840 | if (next_token.id === ',') { |
| | 4841 | comma(); |
| | 4842 | if (next_token.id !== '(string)') { |
| | 4843 | warn('expected_string_a'); |
| | 4844 | } |
| | 4845 | advance(); |
| | 4846 | } |
| | 4847 | if (next_token.id === ',') { |
| | 4848 | comma(); |
| | 4849 | if (next_token.id !== '(string)') { |
| | 4850 | warn('expected_string_a'); |
| | 4851 | } |
| | 4852 | advance(); |
| | 4853 | } |
| | 4854 | advance(')'); |
| | 4855 | return true; |
| | 4856 | } |
| | 4857 | return false; |
| | 4858 | } |
| | 4859 | |
| | 4860 | |
| | 4861 | function css_radius() { |
| | 4862 | return css_length() && (next_token.id !== '(number)' || css_length()); |
| | 4863 | } |
| | 4864 | |
| | 4865 | |
| | 4866 | function css_shape() { |
| | 4867 | var i; |
| | 4868 | if (next_token.identifier && next_token.string === 'rect') { |
| | 4869 | advance(); |
| | 4870 | advance('('); |
| | 4871 | for (i = 0; i < 4; i += 1) { |
| | 4872 | if (!css_length()) { |
| | 4873 | warn('expected_number_a'); |
| | 4874 | break; |
| | 4875 | } |
| | 4876 | } |
| | 4877 | advance(')'); |
| | 4878 | return true; |
| | 4879 | } |
| | 4880 | return false; |
| | 4881 | } |
| | 4882 | |
| | 4883 | |
| | 4884 | function css_url() { |
| | 4885 | var c, url; |
| | 4886 | if (next_token.identifier && next_token.string === 'url') { |
| | 4887 | next_token = lex.range('(', ')'); |
| | 4888 | url = next_token.string; |
| | 4889 | c = url.charAt(0); |
| | 4890 | if (c === '"' || c === '\'') { |
| | 4891 | if (url.slice(-1) !== c) { |
| | 4892 | warn('bad_url_a'); |
| | 4893 | } else { |
| | 4894 | url = url.slice(1, -1); |
| | 4895 | if (url.indexOf(c) >= 0) { |
| | 4896 | warn('bad_url_a'); |
| | 4897 | } |
| | 4898 | } |
| | 4899 | } |
| | 4900 | if (!url) { |
| | 4901 | warn('missing_url'); |
| | 4902 | } |
| | 4903 | if (ux.test(url)) { |
| | 4904 | stop('bad_url_a'); |
| | 4905 | } |
| | 4906 | urls.push(url); |
| | 4907 | advance(); |
| | 4908 | return true; |
| | 4909 | } |
| | 4910 | return false; |
| | 4911 | } |
| | 4912 | |
| | 4913 | |
| | 4914 | css_any = [css_url, function () { |
| | 4915 | for (;;) { |
| | 4916 | if (next_token.identifier) { |
| | 4917 | switch (next_token.string.toLowerCase()) { |
| | 4918 | case 'url': |
| | 4919 | css_url(); |
| | 4920 | break; |
| | 4921 | case 'expression': |
| | 4922 | warn('unexpected_a'); |
| | 4923 | advance(); |
| | 4924 | break; |
| | 4925 | default: |
| | 4926 | advance(); |
| | 4927 | } |
| | 4928 | } else { |
| | 4929 | if (next_token.id === ';' || next_token.id === '!' || |
| | 4930 | next_token.id === '(end)' || next_token.id === '}') { |
| | 4931 | return true; |
| | 4932 | } |
| | 4933 | advance(); |
| | 4934 | } |
| | 4935 | } |
| | 4936 | }]; |
| | 4937 | |
| | 4938 | |
| | 4939 | function font_face() { |
| | 4940 | advance_identifier('font-family'); |
| | 4941 | advance(':'); |
| | 4942 | if (!css_name() && !css_string()) { |
| | 4943 | stop('expected_name_a'); |
| | 4944 | } |
| | 4945 | semicolon(); |
| | 4946 | advance_identifier('src'); |
| | 4947 | advance(':'); |
| | 4948 | while (true) { |
| | 4949 | if (next_token.string === 'local') { |
| | 4950 | advance_identifier('local'); |
| | 4951 | advance('('); |
| | 4952 | if (ux.test(next_token.string)) { |
| | 4953 | stop('bad_url_a'); |
| | 4954 | } |
| | 4955 | |
| | 4956 | if (!css_name() && !css_string()) { |
| | 4957 | stop('expected_name_a'); |
| | 4958 | } |
| | 4959 | advance(')'); |
| | 4960 | } else if (!css_url()) { |
| | 4961 | stop('expected_a_b', next_token, 'url', artifact()); |
| | 4962 | } |
| | 4963 | if (next_token.id !== ',') { |
| | 4964 | break; |
| | 4965 | } |
| | 4966 | comma(); |
| | 4967 | } |
| | 4968 | semicolon(); |
| | 4969 | } |
| | 4970 | |
| | 4971 | |
| | 4972 | css_border_style = [ |
| | 4973 | 'none', 'dashed', 'dotted', 'double', 'groove', |
| | 4974 | 'hidden', 'inset', 'outset', 'ridge', 'solid' |
| | 4975 | ]; |
| | 4976 | |
| | 4977 | css_break = [ |
| | 4978 | 'auto', 'always', 'avoid', 'left', 'right' |
| | 4979 | ]; |
| | 4980 | |
| | 4981 | css_media = { |
| | 4982 | 'all': true, |
| | 4983 | 'braille': true, |
| | 4984 | 'embossed': true, |
| | 4985 | 'handheld': true, |
| | 4986 | 'print': true, |
| | 4987 | 'projection': true, |
| | 4988 | 'screen': true, |
| | 4989 | 'speech': true, |
| | 4990 | 'tty': true, |
| | 4991 | 'tv': true |
| | 4992 | }; |
| | 4993 | |
| | 4994 | css_overflow = [ |
| | 4995 | 'auto', 'hidden', 'scroll', 'visible' |
| | 4996 | ]; |
| | 4997 | |
| | 4998 | css_attribute_data = { |
| | 4999 | background: [ |
| | 5000 | true, 'background-attachment', 'background-color', |
| | 5001 | 'background-image', 'background-position', 'background-repeat' |
| | 5002 | ], |
| | 5003 | 'background-attachment': ['scroll', 'fixed'], |
| | 5004 | 'background-color': ['transparent', css_color], |
| | 5005 | 'background-image': ['none', css_url], |
| | 5006 | 'background-position': [ |
| | 5007 | 2, [css_length, 'top', 'bottom', 'left', 'right', 'center'] |
| | 5008 | ], |
| | 5009 | 'background-repeat': [ |
| | 5010 | 'repeat', 'repeat-x', 'repeat-y', 'no-repeat' |
| | 5011 | ], |
| | 5012 | 'border': [true, 'border-color', 'border-style', 'border-width'], |
| | 5013 | 'border-bottom': [ |
| | 5014 | true, 'border-bottom-color', 'border-bottom-style', |
| | 5015 | 'border-bottom-width' |
| | 5016 | ], |
| | 5017 | 'border-bottom-color': css_color, |
| | 5018 | 'border-bottom-left-radius': css_radius, |
| | 5019 | 'border-bottom-right-radius': css_radius, |
| | 5020 | 'border-bottom-style': css_border_style, |
| | 5021 | 'border-bottom-width': css_width, |
| | 5022 | 'border-collapse': ['collapse', 'separate'], |
| | 5023 | 'border-color': ['transparent', 4, css_color], |
| | 5024 | 'border-left': [ |
| | 5025 | true, 'border-left-color', 'border-left-style', 'border-left-width' |
| | 5026 | ], |
| | 5027 | 'border-left-color': css_color, |
| | 5028 | 'border-left-style': css_border_style, |
| | 5029 | 'border-left-width': css_width, |
| | 5030 | 'border-radius': function () { |
| | 5031 | function count(separator) { |
| | 5032 | var n = 1; |
| | 5033 | if (separator) { |
| | 5034 | advance(separator); |
| | 5035 | } |
| | 5036 | if (!css_length()) { |
| | 5037 | return false; |
| | 5038 | } |
| | 5039 | while (next_token.id === '(number)') { |
| | 5040 | if (!css_length()) { |
| | 5041 | return false; |
| | 5042 | } |
| | 5043 | n += 1; |
| | 5044 | } |
| | 5045 | if (n > 4) { |
| | 5046 | warn('bad_style'); |
| | 5047 | } |
| | 5048 | return true; |
| | 5049 | } |
| | 5050 | |
| | 5051 | return count() && (next_token.id !== '/' || count('/')); |
| | 5052 | }, |
| | 5053 | 'border-right': [ |
| | 5054 | true, 'border-right-color', 'border-right-style', |
| | 5055 | 'border-right-width' |
| | 5056 | ], |
| | 5057 | 'border-right-color': css_color, |
| | 5058 | 'border-right-style': css_border_style, |
| | 5059 | 'border-right-width': css_width, |
| | 5060 | 'border-spacing': [2, css_length], |
| | 5061 | 'border-style': [4, css_border_style], |
| | 5062 | 'border-top': [ |
| | 5063 | true, 'border-top-color', 'border-top-style', 'border-top-width' |
| | 5064 | ], |
| | 5065 | 'border-top-color': css_color, |
| | 5066 | 'border-top-left-radius': css_radius, |
| | 5067 | 'border-top-right-radius': css_radius, |
| | 5068 | 'border-top-style': css_border_style, |
| | 5069 | 'border-top-width': css_width, |
| | 5070 | 'border-width': [4, css_width], |
| | 5071 | bottom: [css_length, 'auto'], |
| | 5072 | 'caption-side' : ['bottom', 'left', 'right', 'top'], |
| | 5073 | clear: ['both', 'left', 'none', 'right'], |
| | 5074 | clip: [css_shape, 'auto'], |
| | 5075 | color: css_color, |
| | 5076 | content: [ |
| | 5077 | 'open-quote', 'close-quote', 'no-open-quote', 'no-close-quote', |
| | 5078 | css_string, css_url, css_counter, css_attr |
| | 5079 | ], |
| | 5080 | 'counter-increment': [ |
| | 5081 | css_name, 'none' |
| | 5082 | ], |
| | 5083 | 'counter-reset': [ |
| | 5084 | css_name, 'none' |
| | 5085 | ], |
| | 5086 | cursor: [ |
| | 5087 | css_url, 'auto', 'crosshair', 'default', 'e-resize', 'help', 'move', |
| | 5088 | 'n-resize', 'ne-resize', 'nw-resize', 'pointer', 's-resize', |
| | 5089 | 'se-resize', 'sw-resize', 'w-resize', 'text', 'wait' |
| | 5090 | ], |
| | 5091 | direction: ['ltr', 'rtl'], |
| | 5092 | display: [ |
| | 5093 | 'block', 'compact', 'inline', 'inline-block', 'inline-table', |
| | 5094 | 'list-item', 'marker', 'none', 'run-in', 'table', 'table-caption', |
| | 5095 | 'table-cell', 'table-column', 'table-column-group', |
| | 5096 | 'table-footer-group', 'table-header-group', 'table-row', |
| | 5097 | 'table-row-group' |
| | 5098 | ], |
| | 5099 | 'empty-cells': ['show', 'hide'], |
| | 5100 | 'float': ['left', 'none', 'right'], |
| | 5101 | font: [ |
| | 5102 | 'caption', 'icon', 'menu', 'message-box', 'small-caption', |
| | 5103 | 'status-bar', true, 'font-size', 'font-style', 'font-weight', |
| | 5104 | 'font-family' |
| | 5105 | ], |
| | 5106 | 'font-family': css_comma_list, |
| | 5107 | 'font-size': [ |
| | 5108 | 'xx-small', 'x-small', 'small', 'medium', 'large', 'x-large', |
| | 5109 | 'xx-large', 'larger', 'smaller', css_length |
| | 5110 | ], |
| | 5111 | 'font-size-adjust': ['none', css_number], |
| | 5112 | 'font-stretch': [ |
| | 5113 | 'normal', 'wider', 'narrower', 'ultra-condensed', |
| | 5114 | 'extra-condensed', 'condensed', 'semi-condensed', |
| | 5115 | 'semi-expanded', 'expanded', 'extra-expanded' |
| | 5116 | ], |
| | 5117 | 'font-style': [ |
| | 5118 | 'normal', 'italic', 'oblique' |
| | 5119 | ], |
| | 5120 | 'font-variant': [ |
| | 5121 | 'normal', 'small-caps' |
| | 5122 | ], |
| | 5123 | 'font-weight': [ |
| | 5124 | 'normal', 'bold', 'bolder', 'lighter', css_number |
| | 5125 | ], |
| | 5126 | height: [css_length, 'auto'], |
| | 5127 | left: [css_length, 'auto'], |
| | 5128 | 'letter-spacing': ['normal', css_length], |
| | 5129 | 'line-height': ['normal', css_line_height], |
| | 5130 | 'list-style': [ |
| | 5131 | true, 'list-style-image', 'list-style-position', 'list-style-type' |
| | 5132 | ], |
| | 5133 | 'list-style-image': ['none', css_url], |
| | 5134 | 'list-style-position': ['inside', 'outside'], |
| | 5135 | 'list-style-type': [ |
| | 5136 | 'circle', 'disc', 'square', 'decimal', 'decimal-leading-zero', |
| | 5137 | 'lower-roman', 'upper-roman', 'lower-greek', 'lower-alpha', |
| | 5138 | 'lower-latin', 'upper-alpha', 'upper-latin', 'hebrew', 'katakana', |
| | 5139 | 'hiragana-iroha', 'katakana-oroha', 'none' |
| | 5140 | ], |
| | 5141 | margin: [4, css_margin], |
| | 5142 | 'margin-bottom': css_margin, |
| | 5143 | 'margin-left': css_margin, |
| | 5144 | 'margin-right': css_margin, |
| | 5145 | 'margin-top': css_margin, |
| | 5146 | 'marker-offset': [css_length, 'auto'], |
| | 5147 | 'max-height': [css_length, 'none'], |
| | 5148 | 'max-width': [css_length, 'none'], |
| | 5149 | 'min-height': css_length, |
| | 5150 | 'min-width': css_length, |
| | 5151 | opacity: css_number, |
| | 5152 | outline: [true, 'outline-color', 'outline-style', 'outline-width'], |
| | 5153 | 'outline-color': ['invert', css_color], |
| | 5154 | 'outline-style': [ |
| | 5155 | 'dashed', 'dotted', 'double', 'groove', 'inset', 'none', |
| | 5156 | 'outset', 'ridge', 'solid' |
| | 5157 | ], |
| | 5158 | 'outline-width': css_width, |
| | 5159 | overflow: css_overflow, |
| | 5160 | 'overflow-x': css_overflow, |
| | 5161 | 'overflow-y': css_overflow, |
| | 5162 | padding: [4, css_length], |
| | 5163 | 'padding-bottom': css_length, |
| | 5164 | 'padding-left': css_length, |
| | 5165 | 'padding-right': css_length, |
| | 5166 | 'padding-top': css_length, |
| | 5167 | 'page-break-after': css_break, |
| | 5168 | 'page-break-before': css_break, |
| | 5169 | position: ['absolute', 'fixed', 'relative', 'static'], |
| | 5170 | quotes: [8, css_string], |
| | 5171 | right: [css_length, 'auto'], |
| | 5172 | 'table-layout': ['auto', 'fixed'], |
| | 5173 | 'text-align': ['center', 'justify', 'left', 'right'], |
| | 5174 | 'text-decoration': [ |
| | 5175 | 'none', 'underline', 'overline', 'line-through', 'blink' |
| | 5176 | ], |
| | 5177 | 'text-indent': css_length, |
| | 5178 | 'text-shadow': ['none', 4, [css_color, css_length]], |
| | 5179 | 'text-transform': ['capitalize', 'uppercase', 'lowercase', 'none'], |
| | 5180 | top: [css_length, 'auto'], |
| | 5181 | 'unicode-bidi': ['normal', 'embed', 'bidi-override'], |
| | 5182 | 'vertical-align': [ |
| | 5183 | 'baseline', 'bottom', 'sub', 'super', 'top', 'text-top', 'middle', |
| | 5184 | 'text-bottom', css_length |
| | 5185 | ], |
| | 5186 | visibility: ['visible', 'hidden', 'collapse'], |
| | 5187 | 'white-space': [ |
| | 5188 | 'normal', 'nowrap', 'pre', 'pre-line', 'pre-wrap', 'inherit' |
| | 5189 | ], |
| | 5190 | width: [css_length, 'auto'], |
| | 5191 | 'word-spacing': ['normal', css_length], |
| | 5192 | 'word-wrap': ['break-word', 'normal'], |
| | 5193 | 'z-index': ['auto', css_number] |
| | 5194 | }; |
| | 5195 | |
| | 5196 | function style_attribute() { |
| | 5197 | var v; |
| | 5198 | while (next_token.id === '*' || next_token.id === '#' || |
| | 5199 | next_token.string === '_') { |
| | 5200 | if (!option.css) { |
| | 5201 | warn('unexpected_a'); |
| | 5202 | } |
| | 5203 | advance(); |
| | 5204 | } |
| | 5205 | if (next_token.id === '-') { |
| | 5206 | if (!option.css) { |
| | 5207 | warn('unexpected_a'); |
| | 5208 | } |
| | 5209 | advance('-'); |
| | 5210 | if (!next_token.identifier) { |
| | 5211 | warn('expected_nonstandard_style_attribute'); |
| | 5212 | } |
| | 5213 | advance(); |
| | 5214 | return css_any; |
| | 5215 | } |
| | 5216 | if (!next_token.identifier) { |
| | 5217 | warn('expected_style_attribute'); |
| | 5218 | } else { |
| | 5219 | if (Object.prototype.hasOwnProperty.call(css_attribute_data, |
| | 5220 | next_token.string)) { |
| | 5221 | v = css_attribute_data[next_token.string]; |
| | 5222 | } else { |
| | 5223 | v = css_any; |
| | 5224 | if (!option.css) { |
| | 5225 | warn('unrecognized_style_attribute_a'); |
| | 5226 | } |
| | 5227 | } |
| | 5228 | } |
| | 5229 | advance(); |
| | 5230 | return v; |
| | 5231 | } |
| | 5232 | |
| | 5233 | |
| | 5234 | function style_value(v) { |
| | 5235 | var i = 0, |
| | 5236 | n, |
| | 5237 | once, |
| | 5238 | match, |
| | 5239 | round, |
| | 5240 | start = 0, |
| | 5241 | vi; |
| | 5242 | switch (typeof v) { |
| | 5243 | case 'function': |
| | 5244 | return v(); |
| | 5245 | case 'string': |
| | 5246 | if (next_token.identifier && next_token.string === v) { |
| | 5247 | advance(); |
| | 5248 | return true; |
| | 5249 | } |
| | 5250 | return false; |
| | 5251 | } |
| | 5252 | for (;;) { |
| | 5253 | if (i >= v.length) { |
| | 5254 | return false; |
| | 5255 | } |
| | 5256 | vi = v[i]; |
| | 5257 | i += 1; |
| | 5258 | if (typeof vi === 'boolean') { |
| | 5259 | break; |
| | 5260 | } else if (typeof vi === 'number') { |
| | 5261 | n = vi; |
| | 5262 | vi = v[i]; |
| | 5263 | i += 1; |
| | 5264 | } else { |
| | 5265 | n = 1; |
| | 5266 | } |
| | 5267 | match = false; |
| | 5268 | while (n > 0) { |
| | 5269 | if (style_value(vi)) { |
| | 5270 | match = true; |
| | 5271 | n -= 1; |
| | 5272 | } else { |
| | 5273 | break; |
| | 5274 | } |
| | 5275 | } |
| | 5276 | if (match) { |
| | 5277 | return true; |
| | 5278 | } |
| | 5279 | } |
| | 5280 | start = i; |
| | 5281 | once = []; |
| | 5282 | for (;;) { |
| | 5283 | round = false; |
| | 5284 | for (i = start; i < v.length; i += 1) { |
| | 5285 | if (!once[i]) { |
| | 5286 | if (style_value(css_attribute_data[v[i]])) { |
| | 5287 | match = true; |
| | 5288 | round = true; |
| | 5289 | once[i] = true; |
| | 5290 | break; |
| | 5291 | } |
| | 5292 | } |
| | 5293 | } |
| | 5294 | if (!round) { |
| | 5295 | return match; |
| | 5296 | } |
| | 5297 | } |
| | 5298 | } |
| | 5299 | |
| | 5300 | function style_child() { |
| | 5301 | if (next_token.id === '(number)') { |
| | 5302 | advance(); |
| | 5303 | if (next_token.string === 'n' && next_token.identifier) { |
| | 5304 | no_space_only(); |
| | 5305 | advance(); |
| | 5306 | if (next_token.id === '+') { |
| | 5307 | no_space_only(); |
| | 5308 | advance('+'); |
| | 5309 | no_space_only(); |
| | 5310 | advance('(number)'); |
| | 5311 | } |
| | 5312 | } |
| | 5313 | return; |
| | 5314 | } |
| | 5315 | if (next_token.identifier && |
| | 5316 | (next_token.string === 'odd' || next_token.string === 'even')) { |
| | 5317 | advance(); |
| | 5318 | return; |
| | 5319 | } |
| | 5320 | warn('unexpected_a'); |
| | 5321 | } |
| | 5322 | |
| | 5323 | function substyle() { |
| | 5324 | var v; |
| | 5325 | for (;;) { |
| | 5326 | if (next_token.id === '}' || next_token.id === '(end)' || |
| | 5327 | (xquote && next_token.id === xquote)) { |
| | 5328 | return; |
| | 5329 | } |
| | 5330 | v = style_attribute(); |
| | 5331 | advance(':'); |
| | 5332 | if (next_token.identifier && next_token.string === 'inherit') { |
| | 5333 | advance(); |
| | 5334 | } else { |
| | 5335 | if (!style_value(v)) { |
| | 5336 | warn('unexpected_a'); |
| | 5337 | advance(); |
| | 5338 | } |
| | 5339 | } |
| | 5340 | if (next_token.id === '!') { |
| | 5341 | advance('!'); |
| | 5342 | no_space_only(); |
| | 5343 | if (next_token.identifier && next_token.string === 'important') { |
| | 5344 | advance(); |
| | 5345 | } else { |
| | 5346 | warn('expected_a_b', |
| | 5347 | next_token, 'important', artifact()); |
| | 5348 | } |
| | 5349 | } |
| | 5350 | if (next_token.id === '}' || next_token.id === xquote) { |
| | 5351 | warn('expected_a_b', next_token, ';', artifact()); |
| | 5352 | } else { |
| | 5353 | semicolon(); |
| | 5354 | } |
| | 5355 | } |
| | 5356 | } |
| | 5357 | |
| | 5358 | function style_selector() { |
| | 5359 | if (next_token.identifier) { |
| | 5360 | if (!Object.prototype.hasOwnProperty.call(html_tag, option.cap |
| | 5361 | ? next_token.string.toLowerCase() |
| | 5362 | : next_token.string)) { |
| | 5363 | warn('expected_tagname_a'); |
| | 5364 | } |
| | 5365 | advance(); |
| | 5366 | } else { |
| | 5367 | switch (next_token.id) { |
| | 5368 | case '>': |
| | 5369 | case '+': |
| | 5370 | advance(); |
| | 5371 | style_selector(); |
| | 5372 | break; |
| | 5373 | case ':': |
| | 5374 | advance(':'); |
| | 5375 | switch (next_token.string) { |
| | 5376 | case 'active': |
| | 5377 | case 'after': |
| | 5378 | case 'before': |
| | 5379 | case 'checked': |
| | 5380 | case 'disabled': |
| | 5381 | case 'empty': |
| | 5382 | case 'enabled': |
| | 5383 | case 'first-child': |
| | 5384 | case 'first-letter': |
| | 5385 | case 'first-line': |
| | 5386 | case 'first-of-type': |
| | 5387 | case 'focus': |
| | 5388 | case 'hover': |
| | 5389 | case 'last-child': |
| | 5390 | case 'last-of-type': |
| | 5391 | case 'link': |
| | 5392 | case 'only-of-type': |
| | 5393 | case 'root': |
| | 5394 | case 'target': |
| | 5395 | case 'visited': |
| | 5396 | advance_identifier(next_token.string); |
| | 5397 | break; |
| | 5398 | case 'lang': |
| | 5399 | advance_identifier('lang'); |
| | 5400 | advance('('); |
| | 5401 | if (!next_token.identifier) { |
| | 5402 | warn('expected_lang_a'); |
| | 5403 | } |
| | 5404 | advance(')'); |
| | 5405 | break; |
| | 5406 | case 'nth-child': |
| | 5407 | case 'nth-last-child': |
| | 5408 | case 'nth-last-of-type': |
| | 5409 | case 'nth-of-type': |
| | 5410 | advance_identifier(next_token.string); |
| | 5411 | advance('('); |
| | 5412 | style_child(); |
| | 5413 | advance(')'); |
| | 5414 | break; |
| | 5415 | case 'not': |
| | 5416 | advance_identifier('not'); |
| | 5417 | advance('('); |
| | 5418 | if (next_token.id === ':' && peek(0).string === 'not') { |
| | 5419 | warn('not'); |
| | 5420 | } |
| | 5421 | style_selector(); |
| | 5422 | advance(')'); |
| | 5423 | break; |
| | 5424 | default: |
| | 5425 | warn('expected_pseudo_a'); |
| | 5426 | } |
| | 5427 | break; |
| | 5428 | case '#': |
| | 5429 | advance('#'); |
| | 5430 | if (!next_token.identifier) { |
| | 5431 | warn('expected_id_a'); |
| | 5432 | } |
| | 5433 | advance(); |
| | 5434 | break; |
| | 5435 | case '*': |
| | 5436 | advance('*'); |
| | 5437 | break; |
| | 5438 | case '.': |
| | 5439 | advance('.'); |
| | 5440 | if (!next_token.identifier) { |
| | 5441 | warn('expected_class_a'); |
| | 5442 | } |
| | 5443 | advance(); |
| | 5444 | break; |
| | 5445 | case '[': |
| | 5446 | advance('['); |
| | 5447 | if (!next_token.identifier) { |
| | 5448 | warn('expected_attribute_a'); |
| | 5449 | } |
| | 5450 | advance(); |
| | 5451 | if (next_token.id === '=' || next_token.string === '~=' || |
| | 5452 | next_token.string === '$=' || |
| | 5453 | next_token.string === '|=' || |
| | 5454 | next_token.id === '*=' || |
| | 5455 | next_token.id === '^=') { |
| | 5456 | advance(); |
| | 5457 | if (next_token.id !== '(string)') { |
| | 5458 | warn('expected_string_a'); |
| | 5459 | } |
| | 5460 | advance(); |
| | 5461 | } |
| | 5462 | advance(']'); |
| | 5463 | break; |
| | 5464 | default: |
| | 5465 | stop('expected_selector_a'); |
| | 5466 | } |
| | 5467 | } |
| | 5468 | } |
| | 5469 | |
| | 5470 | function style_pattern() { |
| | 5471 | if (next_token.id === '{') { |
| | 5472 | warn('expected_style_pattern'); |
| | 5473 | } |
| | 5474 | for (;;) { |
| | 5475 | style_selector(); |
| | 5476 | if (next_token.id === '</' || next_token.id === '{' || |
| | 5477 | next_token.id === '}' || next_token.id === '(end)') { |
| | 5478 | return ''; |
| | 5479 | } |
| | 5480 | if (next_token.id === ',') { |
| | 5481 | comma(); |
| | 5482 | } |
| | 5483 | } |
| | 5484 | } |
| | 5485 | |
| | 5486 | function style_list() { |
| | 5487 | while (next_token.id !== '}' && next_token.id !== '</' && |
| | 5488 | next_token.id !== '(end)') { |
| | 5489 | style_pattern(); |
| | 5490 | xmode = 'styleproperty'; |
| | 5491 | if (next_token.id === ';') { |
| | 5492 | semicolon(); |
| | 5493 | } else { |
| | 5494 | advance('{'); |
| | 5495 | substyle(); |
| | 5496 | xmode = 'style'; |
| | 5497 | advance('}'); |
| | 5498 | } |
| | 5499 | } |
| | 5500 | } |
| | 5501 | |
| | 5502 | function styles() { |
| | 5503 | var i; |
| | 5504 | while (next_token.id === '@') { |
| | 5505 | i = peek(); |
| | 5506 | advance('@'); |
| | 5507 | switch (next_token.string) { |
| | 5508 | case 'import': |
| | 5509 | advance_identifier('import'); |
| | 5510 | if (!css_url()) { |
| | 5511 | warn('expected_a_b', |
| | 5512 | next_token, 'url', artifact()); |
| | 5513 | advance(); |
| | 5514 | } |
| | 5515 | semicolon(); |
| | 5516 | break; |
| | 5517 | case 'media': |
| | 5518 | advance_identifier('media'); |
| | 5519 | for (;;) { |
| | 5520 | if (!next_token.identifier || css_media[next_token.string] !== true) { |
| | 5521 | stop('expected_media_a'); |
| | 5522 | } |
| | 5523 | advance(); |
| | 5524 | if (next_token.id !== ',') { |
| | 5525 | break; |
| | 5526 | } |
| | 5527 | comma(); |
| | 5528 | } |
| | 5529 | advance('{'); |
| | 5530 | style_list(); |
| | 5531 | advance('}'); |
| | 5532 | break; |
| | 5533 | case 'font-face': |
| | 5534 | advance_identifier('font-face'); |
| | 5535 | advance('{'); |
| | 5536 | font_face(); |
| | 5537 | advance('}'); |
| | 5538 | break; |
| | 5539 | default: |
| | 5540 | stop('expected_at_a'); |
| | 5541 | } |
| | 5542 | } |
| | 5543 | style_list(); |
| | 5544 | } |
| | 5545 | |
| | 5546 | |
| | 5547 | // Parse HTML |
| | 5548 | |
| | 5549 | function do_begin(n) { |
| | 5550 | if (n !== 'html' && !option.fragment) { |
| | 5551 | if (n === 'div' && option.adsafe) { |
| | 5552 | stop('adsafe_fragment'); |
| | 5553 | } else { |
| | 5554 | stop('expected_a_b', token, 'html', n); |
| | 5555 | } |
| | 5556 | } |
| | 5557 | if (option.adsafe) { |
| | 5558 | if (n === 'html') { |
| | 5559 | stop('adsafe_html', token); |
| | 5560 | } |
| | 5561 | if (option.fragment) { |
| | 5562 | if (n !== 'div') { |
| | 5563 | stop('adsafe_div', token); |
| | 5564 | } |
| | 5565 | } else { |
| | 5566 | stop('adsafe_fragment', token); |
| | 5567 | } |
| | 5568 | } |
| | 5569 | option.browser = true; |
| | 5570 | } |
| | 5571 | |
| | 5572 | function do_attribute(a, v) { |
| | 5573 | var u, x; |
| | 5574 | if (a === 'id') { |
| | 5575 | u = typeof v === 'string' ? v.toUpperCase() : ''; |
| | 5576 | if (ids[u] === true) { |
| | 5577 | warn('duplicate_a', next_token, v); |
| | 5578 | } |
| | 5579 | if (!/^[A-Za-z][A-Za-z0-9._:\-]*$/.test(v)) { |
| | 5580 | warn('bad_id_a', next_token, v); |
| | 5581 | } else if (option.adsafe) { |
| | 5582 | if (adsafe_id) { |
| | 5583 | if (v.slice(0, adsafe_id.length) !== adsafe_id) { |
| | 5584 | warn('adsafe_prefix_a', next_token, adsafe_id); |
| | 5585 | } else if (!/^[A-Z]+_[A-Z]+$/.test(v)) { |
| | 5586 | warn('adsafe_bad_id'); |
| | 5587 | } |
| | 5588 | } else { |
| | 5589 | adsafe_id = v; |
| | 5590 | if (!/^[A-Z]+_$/.test(v)) { |
| | 5591 | warn('adsafe_bad_id'); |
| | 5592 | } |
| | 5593 | } |
| | 5594 | } |
| | 5595 | x = v.search(dx); |
| | 5596 | if (x >= 0) { |
| | 5597 | warn('unexpected_char_a_b', token, v.charAt(x), a); |
| | 5598 | } |
| | 5599 | ids[u] = true; |
| | 5600 | } else if (a === 'class' || a === 'type' || a === 'name') { |
| | 5601 | x = v.search(qx); |
| | 5602 | if (x >= 0) { |
| | 5603 | warn('unexpected_char_a_b', token, v.charAt(x), a); |
| | 5604 | } |
| | 5605 | ids[u] = true; |
| | 5606 | } else if (a === 'href' || a === 'background' || |
| | 5607 | a === 'content' || a === 'data' || |
| | 5608 | a.indexOf('src') >= 0 || a.indexOf('url') >= 0) { |
| | 5609 | if (option.safe && ux.test(v)) { |
| | 5610 | stop('bad_url_a', next_token, v); |
| | 5611 | } |
| | 5612 | urls.push(v); |
| | 5613 | } else if (a === 'for') { |
| | 5614 | if (option.adsafe) { |
| | 5615 | if (adsafe_id) { |
| | 5616 | if (v.slice(0, adsafe_id.length) !== adsafe_id) { |
| | 5617 | warn('adsafe_prefix_a', next_token, adsafe_id); |
| | 5618 | } else if (!/^[A-Z]+_[A-Z]+$/.test(v)) { |
| | 5619 | warn('adsafe_bad_id'); |
| | 5620 | } |
| | 5621 | } else { |
| | 5622 | warn('adsafe_bad_id'); |
| | 5623 | } |
| | 5624 | } |
| | 5625 | } else if (a === 'name') { |
| | 5626 | if (option.adsafe && v.indexOf('_') >= 0) { |
| | 5627 | warn('adsafe_name_a', next_token, v); |
| | 5628 | } |
| | 5629 | } |
| | 5630 | } |
| | 5631 | |
| | 5632 | function do_tag(name, attribute) { |
| | 5633 | var i, tag = html_tag[name], script, x; |
| | 5634 | src = false; |
| | 5635 | if (!tag) { |
| | 5636 | stop( |
| | 5637 | bundle.unrecognized_tag_a, |
| | 5638 | next_token, |
| | 5639 | name === name.toLowerCase() |
| | 5640 | ? name |
| | 5641 | : name + ' (capitalization error)' |
| | 5642 | ); |
| | 5643 | } |
| | 5644 | if (stack.length > 0) { |
| | 5645 | if (name === 'html') { |
| | 5646 | stop('unexpected_a', token, name); |
| | 5647 | } |
| | 5648 | x = tag.parent; |
| | 5649 | if (x) { |
| | 5650 | if (x.indexOf(' ' + stack[stack.length - 1].name + ' ') < 0) { |
| | 5651 | stop('tag_a_in_b', token, name, x); |
| | 5652 | } |
| | 5653 | } else if (!option.adsafe && !option.fragment) { |
| | 5654 | i = stack.length; |
| | 5655 | do { |
| | 5656 | if (i <= 0) { |
| | 5657 | stop('tag_a_in_b', token, name, 'body'); |
| | 5658 | } |
| | 5659 | i -= 1; |
| | 5660 | } while (stack[i].name !== 'body'); |
| | 5661 | } |
| | 5662 | } |
| | 5663 | switch (name) { |
| | 5664 | case 'div': |
| | 5665 | if (option.adsafe && stack.length === 1 && !adsafe_id) { |
| | 5666 | warn('adsafe_missing_id'); |
| | 5667 | } |
| | 5668 | break; |
| | 5669 | case 'script': |
| | 5670 | xmode = 'script'; |
| | 5671 | advance('>'); |
| | 5672 | if (attribute.lang) { |
| | 5673 | warn('lang', token); |
| | 5674 | } |
| | 5675 | if (option.adsafe && stack.length !== 1) { |
| | 5676 | warn('adsafe_placement', token); |
| | 5677 | } |
| | 5678 | if (attribute.src) { |
| | 5679 | if (option.adsafe && (!adsafe_may || !approved[attribute.src])) { |
| | 5680 | warn('adsafe_source', token); |
| | 5681 | } |
| | 5682 | } else { |
| | 5683 | step_in(next_token.from); |
| | 5684 | edge(); |
| | 5685 | use_strict(); |
| | 5686 | adsafe_top = true; |
| | 5687 | script = statements(); |
| | 5688 | |
| | 5689 | // JSLint is also the static analyzer for ADsafe. See www.ADsafe.org. |
| | 5690 | |
| | 5691 | if (option.adsafe) { |
| | 5692 | if (adsafe_went) { |
| | 5693 | stop('adsafe_script', token); |
| | 5694 | } |
| | 5695 | if (script.length !== 1 || |
| | 5696 | aint(script[0], 'id', '(') || |
| | 5697 | aint(script[0].first, 'id', '.') || |
| | 5698 | aint(script[0].first.first, 'string', 'ADSAFE') || |
| | 5699 | aint(script[0].second[0], 'string', adsafe_id)) { |
| | 5700 | stop('adsafe_id_go'); |
| | 5701 | } |
| | 5702 | switch (script[0].first.second.string) { |
| | 5703 | case 'id': |
| | 5704 | if (adsafe_may || adsafe_went || |
| | 5705 | script[0].second.length !== 1) { |
| | 5706 | stop('adsafe_id', next_token); |
| | 5707 | } |
| | 5708 | adsafe_may = true; |
| | 5709 | break; |
| | 5710 | case 'go': |
| | 5711 | if (adsafe_went) { |
| | 5712 | stop('adsafe_go'); |
| | 5713 | } |
| | 5714 | if (script[0].second.length !== 2 || |
| | 5715 | aint(script[0].second[1], 'id', 'function') || |
| | 5716 | !script[0].second[1].first || |
| | 5717 | aint(script[0].second[1].first[0], 'string', 'dom') || |
| | 5718 | script[0].second[1].first.length > 2 || |
| | 5719 | (script[0].second[1].first.length === 2 && |
| | 5720 | aint(script[0].second[1].first[1], 'string', 'lib'))) { |
| | 5721 | stop('adsafe_go', next_token); |
| | 5722 | } |
| | 5723 | adsafe_went = true; |
| | 5724 | break; |
| | 5725 | default: |
| | 5726 | stop('adsafe_id_go'); |
| | 5727 | } |
| | 5728 | } |
| | 5729 | indent = null; |
| | 5730 | } |
| | 5731 | xmode = 'html'; |
| | 5732 | advance('</'); |
| | 5733 | advance_identifier('script'); |
| | 5734 | xmode = 'outer'; |
| | 5735 | break; |
| | 5736 | case 'style': |
| | 5737 | xmode = 'style'; |
| | 5738 | advance('>'); |
| | 5739 | styles(); |
| | 5740 | xmode = 'html'; |
| | 5741 | advance('</'); |
| | 5742 | advance_identifier('style'); |
| | 5743 | break; |
| | 5744 | case 'input': |
| | 5745 | switch (attribute.type) { |
| | 5746 | case 'button': |
| | 5747 | case 'checkbox': |
| | 5748 | case 'radio': |
| | 5749 | case 'reset': |
| | 5750 | case 'submit': |
| | 5751 | break; |
| | 5752 | case 'file': |
| | 5753 | case 'hidden': |
| | 5754 | case 'image': |
| | 5755 | case 'password': |
| | 5756 | case 'text': |
| | 5757 | if (option.adsafe && attribute.autocomplete !== 'off') { |
| | 5758 | warn('adsafe_autocomplete'); |
| | 5759 | } |
| | 5760 | break; |
| | 5761 | default: |
| | 5762 | warn('bad_type'); |
| | 5763 | } |
| | 5764 | break; |
| | 5765 | case 'applet': |
| | 5766 | case 'body': |
| | 5767 | case 'embed': |
| | 5768 | case 'frame': |
| | 5769 | case 'frameset': |
| | 5770 | case 'head': |
| | 5771 | case 'iframe': |
| | 5772 | case 'noembed': |
| | 5773 | case 'noframes': |
| | 5774 | case 'object': |
| | 5775 | case 'param': |
| | 5776 | if (option.adsafe) { |
| | 5777 | warn('adsafe_tag', next_token, name); |
| | 5778 | } |
| | 5779 | break; |
| | 5780 | } |
| | 5781 | } |
| | 5782 | |
| | 5783 | |
| | 5784 | function closetag(name) { |
| | 5785 | return '</' + name + '>'; |
| | 5786 | } |
| | 5787 | |
| | 5788 | function html() { |
| | 5789 | var attribute, attributes, is_empty, name, old_white = option.white, |
| | 5790 | quote, tag_name, tag, wmode; |
| | 5791 | xmode = 'html'; |
| | 5792 | xquote = ''; |
| | 5793 | stack = null; |
| | 5794 | for (;;) { |
| | 5795 | switch (next_token.string) { |
| | 5796 | case '<': |
| | 5797 | xmode = 'html'; |
| | 5798 | advance('<'); |
| | 5799 | attributes = {}; |
| | 5800 | tag_name = next_token; |
| | 5801 | name = tag_name.string; |
| | 5802 | advance_identifier(name); |
| | 5803 | if (option.cap) { |
| | 5804 | name = name.toLowerCase(); |
| | 5805 | } |
| | 5806 | tag_name.name = name; |
| | 5807 | if (!stack) { |
| | 5808 | stack = []; |
| | 5809 | do_begin(name); |
| | 5810 | } |
| | 5811 | tag = html_tag[name]; |
| | 5812 | if (typeof tag !== 'object') { |
| | 5813 | stop('unrecognized_tag_a', tag_name, name); |
| | 5814 | } |
| | 5815 | is_empty = tag.empty; |
| | 5816 | tag_name.type = name; |
| | 5817 | for (;;) { |
| | 5818 | if (next_token.id === '/') { |
| | 5819 | advance('/'); |
| | 5820 | if (next_token.id !== '>') { |
| | 5821 | warn('expected_a_b', next_token, '>', artifact()); |
| | 5822 | } |
| | 5823 | break; |
| | 5824 | } |
| | 5825 | if (next_token.id && next_token.id.charAt(0) === '>') { |
| | 5826 | break; |
| | 5827 | } |
| | 5828 | if (!next_token.identifier) { |
| | 5829 | if (next_token.id === '(end)' || next_token.id === '(error)') { |
| | 5830 | warn('expected_a_b', next_token, '>', artifact()); |
| | 5831 | } |
| | 5832 | warn('bad_name_a'); |
| | 5833 | } |
| | 5834 | option.white = false; |
| | 5835 | spaces(); |
| | 5836 | attribute = next_token.string; |
| | 5837 | option.white = old_white; |
| | 5838 | advance(); |
| | 5839 | if (!option.cap && attribute !== attribute.toLowerCase()) { |
| | 5840 | warn('attribute_case_a', token); |
| | 5841 | } |
| | 5842 | attribute = attribute.toLowerCase(); |
| | 5843 | xquote = ''; |
| | 5844 | if (Object.prototype.hasOwnProperty.call(attributes, attribute)) { |
| | 5845 | warn('duplicate_a', token, attribute); |
| | 5846 | } |
| | 5847 | if (attribute.slice(0, 2) === 'on') { |
| | 5848 | if (!option.on) { |
| | 5849 | warn('html_handlers'); |
| | 5850 | } |
| | 5851 | xmode = 'scriptstring'; |
| | 5852 | advance('='); |
| | 5853 | quote = next_token.id; |
| | 5854 | if (quote !== '"' && quote !== '\'') { |
| | 5855 | stop('expected_a_b', next_token, '"', artifact()); |
| | 5856 | } |
| | 5857 | xquote = quote; |
| | 5858 | wmode = option.white; |
| | 5859 | option.white = true; |
| | 5860 | advance(quote); |
| | 5861 | use_strict(); |
| | 5862 | statements(); |
| | 5863 | option.white = wmode; |
| | 5864 | if (next_token.id !== quote) { |
| | 5865 | stop('expected_a_b', next_token, quote, artifact()); |
| | 5866 | } |
| | 5867 | xmode = 'html'; |
| | 5868 | xquote = ''; |
| | 5869 | advance(quote); |
| | 5870 | tag = false; |
| | 5871 | } else if (attribute === 'style') { |
| | 5872 | xmode = 'scriptstring'; |
| | 5873 | advance('='); |
| | 5874 | quote = next_token.id; |
| | 5875 | if (quote !== '"' && quote !== '\'') { |
| | 5876 | stop('expected_a_b', next_token, '"', artifact()); |
| | 5877 | } |
| | 5878 | xmode = 'styleproperty'; |
| | 5879 | xquote = quote; |
| | 5880 | advance(quote); |
| | 5881 | substyle(); |
| | 5882 | xmode = 'html'; |
| | 5883 | xquote = ''; |
| | 5884 | advance(quote); |
| | 5885 | tag = false; |
| | 5886 | } else { |
| | 5887 | if (next_token.id === '=') { |
| | 5888 | advance('='); |
| | 5889 | tag = next_token.string; |
| | 5890 | if (!next_token.identifier && |
| | 5891 | next_token.id !== '"' && |
| | 5892 | next_token.id !== '\'' && |
| | 5893 | next_token.id !== '(string)' && |
| | 5894 | next_token.id !== '(string)' && |
| | 5895 | next_token.id !== '(color)') { |
| | 5896 | warn('expected_attribute_value_a', token, attribute); |
| | 5897 | } |
| | 5898 | advance(); |
| | 5899 | } else { |
| | 5900 | tag = true; |
| | 5901 | } |
| | 5902 | } |
| | 5903 | attributes[attribute] = tag; |
| | 5904 | do_attribute(attribute, tag); |
| | 5905 | } |
| | 5906 | do_tag(name, attributes); |
| | 5907 | if (!is_empty) { |
| | 5908 | stack.push(tag_name); |
| | 5909 | } |
| | 5910 | xmode = 'outer'; |
| | 5911 | advance('>'); |
| | 5912 | break; |
| | 5913 | case '</': |
| | 5914 | xmode = 'html'; |
| | 5915 | advance('</'); |
| | 5916 | if (!next_token.identifier) { |
| | 5917 | warn('bad_name_a'); |
| | 5918 | } |
| | 5919 | name = next_token.string; |
| | 5920 | if (option.cap) { |
| | 5921 | name = name.toLowerCase(); |
| | 5922 | } |
| | 5923 | advance(); |
| | 5924 | if (!stack) { |
| | 5925 | stop('unexpected_a', next_token, closetag(name)); |
| | 5926 | } |
| | 5927 | tag_name = stack.pop(); |
| | 5928 | if (!tag_name) { |
| | 5929 | stop('unexpected_a', next_token, closetag(name)); |
| | 5930 | } |
| | 5931 | if (tag_name.name !== name) { |
| | 5932 | stop('expected_a_b', |
| | 5933 | next_token, closetag(tag_name.name), closetag(name)); |
| | 5934 | } |
| | 5935 | if (next_token.id !== '>') { |
| | 5936 | stop('expected_a_b', next_token, '>', artifact()); |
| | 5937 | } |
| | 5938 | xmode = 'outer'; |
| | 5939 | advance('>'); |
| | 5940 | break; |
| | 5941 | case '<!': |
| | 5942 | if (option.safe) { |
| | 5943 | warn('adsafe_a'); |
| | 5944 | } |
| | 5945 | xmode = 'html'; |
| | 5946 | for (;;) { |
| | 5947 | advance(); |
| | 5948 | if (next_token.id === '>' || next_token.id === '(end)') { |
| | 5949 | break; |
| | 5950 | } |
| | 5951 | if (next_token.string.indexOf('--') >= 0) { |
| | 5952 | stop('unexpected_a', next_token, '--'); |
| | 5953 | } |
| | 5954 | if (next_token.string.indexOf('<') >= 0) { |
| | 5955 | stop('unexpected_a', next_token, '<'); |
| | 5956 | } |
| | 5957 | if (next_token.string.indexOf('>') >= 0) { |
| | 5958 | stop('unexpected_a', next_token, '>'); |
| | 5959 | } |
| | 5960 | } |
| | 5961 | xmode = 'outer'; |
| | 5962 | advance('>'); |
| | 5963 | break; |
| | 5964 | case '(end)': |
| | 5965 | return; |
| | 5966 | default: |
| | 5967 | if (next_token.id === '(end)') { |
| | 5968 | stop('missing_a', next_token, |
| | 5969 | '</' + stack[stack.length - 1].string + '>'); |
| | 5970 | } else { |
| | 5971 | advance(); |
| | 5972 | } |
| | 5973 | } |
| | 5974 | if (stack && stack.length === 0 && (option.adsafe || |
| | 5975 | !option.fragment || next_token.id === '(end)')) { |
| | 5976 | break; |
| | 5977 | } |
| | 5978 | } |
| | 5979 | if (next_token.id !== '(end)') { |
| | 5980 | stop('unexpected_a'); |
| | 5981 | } |
| | 5982 | } |
| | 5983 | |
| | 5984 | |
| | 5985 | // The actual JSLINT function itself. |
| | 5986 | |
| | 5987 | itself = function JSLint(the_source, the_option) { |
| | 5988 | |
| | 5989 | var i, predef, tree; |
| | 5990 | JSLINT.errors = []; |
| | 5991 | JSLINT.tree = ''; |
| | 5992 | begin = prev_token = token = next_token = |
| | 5993 | Object.create(syntax['(begin)']); |
| | 5994 | predefined = {}; |
| | 5995 | add_to_predefined(standard); |
| | 5996 | property = {}; |
| | 5997 | if (the_option) { |
| | 5998 | option = Object.create(the_option); |
| | 5999 | predef = option.predef; |
| | 6000 | if (predef) { |
| | 6001 | if (Array.isArray(predef)) { |
| | 6002 | for (i = 0; i < predef.length; i += 1) { |
| | 6003 | predefined[predef[i]] = true; |
| | 6004 | } |
| | 6005 | } else if (typeof predef === 'object') { |
| | 6006 | add_to_predefined(predef); |
| | 6007 | } |
| | 6008 | } |
| | 6009 | do_safe(); |
| | 6010 | } else { |
| | 6011 | option = {}; |
| | 6012 | } |
| | 6013 | option.indent = +option.indent || 4; |
| | 6014 | option.maxerr = +option.maxerr || 50; |
| | 6015 | adsafe_id = ''; |
| | 6016 | adsafe_may = adsafe_top = adsafe_went = false; |
| | 6017 | approved = {}; |
| | 6018 | if (option.approved) { |
| | 6019 | for (i = 0; i < option.approved.length; i += 1) { |
| | 6020 | approved[option.approved[i]] = option.approved[i]; |
| | 6021 | } |
| | 6022 | } else { |
| | 6023 | approved.test = 'test'; |
| | 6024 | } |
| | 6025 | tab = ''; |
| | 6026 | for (i = 0; i < option.indent; i += 1) { |
| | 6027 | tab += ' '; |
| | 6028 | } |
| | 6029 | global_scope = scope = {}; |
| | 6030 | global_funct = funct = { |
| | 6031 | '(scope)': scope, |
| | 6032 | '(breakage)': 0, |
| | 6033 | '(loopage)': 0 |
| | 6034 | }; |
| | 6035 | functions = [funct]; |
| | 6036 | |
| | 6037 | comments_off = false; |
| | 6038 | ids = {}; |
| | 6039 | in_block = false; |
| | 6040 | indent = null; |
| | 6041 | json_mode = false; |
| | 6042 | lookahead = []; |
| | 6043 | node_js = false; |
| | 6044 | prereg = true; |
| | 6045 | src = false; |
| | 6046 | stack = null; |
| | 6047 | strict_mode = false; |
| | 6048 | urls = []; |
| | 6049 | var_mode = null; |
| | 6050 | warnings = 0; |
| | 6051 | xmode = ''; |
| | 6052 | lex.init(the_source); |
| | 6053 | |
| | 6054 | assume(); |
| | 6055 | |
| | 6056 | try { |
| | 6057 | advance(); |
| | 6058 | if (next_token.id === '(number)') { |
| | 6059 | stop('unexpected_a'); |
| | 6060 | } else if (next_token.string.charAt(0) === '<') { |
| | 6061 | html(); |
| | 6062 | if (option.adsafe && !adsafe_went) { |
| | 6063 | warn('adsafe_go', this); |
| | 6064 | } |
| | 6065 | } else { |
| | 6066 | switch (next_token.id) { |
| | 6067 | case '{': |
| | 6068 | case '[': |
| | 6069 | json_mode = true; |
| | 6070 | json_value(); |
| | 6071 | break; |
| | 6072 | case '@': |
| | 6073 | case '*': |
| | 6074 | case '#': |
| | 6075 | case '.': |
| | 6076 | case ':': |
| | 6077 | xmode = 'style'; |
| | 6078 | advance(); |
| | 6079 | if (token.id !== '@' || !next_token.identifier || |
| | 6080 | next_token.string !== 'charset' || token.line !== 1 || |
| | 6081 | token.from !== 1) { |
| | 6082 | stop('css'); |
| | 6083 | } |
| | 6084 | advance(); |
| | 6085 | if (next_token.id !== '(string)' && |
| | 6086 | next_token.string !== 'UTF-8') { |
| | 6087 | stop('css'); |
| | 6088 | } |
| | 6089 | advance(); |
| | 6090 | semicolon(); |
| | 6091 | styles(); |
| | 6092 | break; |
| | 6093 | |
| | 6094 | default: |
| | 6095 | if (option.adsafe && option.fragment) { |
| | 6096 | stop('expected_a_b', |
| | 6097 | next_token, '<div>', artifact()); |
| | 6098 | } |
| | 6099 | |
| | 6100 | // If the first token is a semicolon, ignore it. This is sometimes used when |
| | 6101 | // files are intended to be appended to files that may be sloppy. A sloppy |
| | 6102 | // file may be depending on semicolon insertion on its last line. |
| | 6103 | |
| | 6104 | step_in(1); |
| | 6105 | if (next_token.id === ';' && !node_js) { |
| | 6106 | semicolon(); |
| | 6107 | } |
| | 6108 | adsafe_top = true; |
| | 6109 | tree = statements(); |
| | 6110 | begin.first = tree; |
| | 6111 | JSLINT.tree = begin; |
| | 6112 | // infer_types(tree); |
| | 6113 | if (option.adsafe && (tree.length !== 1 || |
| | 6114 | aint(tree[0], 'id', '(') || |
| | 6115 | aint(tree[0].first, 'id', '.') || |
| | 6116 | aint(tree[0].first.first, 'string', 'ADSAFE') || |
| | 6117 | aint(tree[0].first.second, 'string', 'lib') || |
| | 6118 | tree[0].second.length !== 2 || |
| | 6119 | tree[0].second[0].id !== '(string)' || |
| | 6120 | aint(tree[0].second[1], 'id', 'function'))) { |
| | 6121 | stop('adsafe_lib'); |
| | 6122 | } |
| | 6123 | if (tree.disrupt) { |
| | 6124 | warn('weird_program', prev_token); |
| | 6125 | } |
| | 6126 | } |
| | 6127 | } |
| | 6128 | indent = null; |
| | 6129 | advance('(end)'); |
| | 6130 | } catch (e) { |
| | 6131 | if (e) { // ~~ |
| | 6132 | JSLINT.errors.push({ |
| | 6133 | reason : e.message, |
| | 6134 | line : e.line || next_token.line, |
| | 6135 | character : e.character || next_token.from |
| | 6136 | }, null); |
| | 6137 | } |
| | 6138 | } |
| | 6139 | return JSLINT.errors.length === 0; |
| | 6140 | }; |
| | 6141 | |
| | 6142 | |
| | 6143 | // Data summary. |
| | 6144 | |
| | 6145 | itself.data = function () { |
| | 6146 | var data = {functions: []}, |
| | 6147 | function_data, |
| | 6148 | globals, |
| | 6149 | i, |
| | 6150 | j, |
| | 6151 | kind, |
| | 6152 | members = [], |
| | 6153 | name, |
| | 6154 | the_function, |
| | 6155 | undef = [], |
| | 6156 | unused = []; |
| | 6157 | if (itself.errors.length) { |
| | 6158 | data.errors = itself.errors; |
| | 6159 | } |
| | 6160 | |
| | 6161 | if (json_mode) { |
| | 6162 | data.json = true; |
| | 6163 | } |
| | 6164 | |
| | 6165 | if (urls.length > 0) { |
| | 6166 | data.urls = urls; |
| | 6167 | } |
| | 6168 | |
| | 6169 | globals = Object.keys(global_scope).filter(function (value) { |
| | 6170 | return value.charAt(0) !== '(' && typeof standard[value] !== 'boolean'; |
| | 6171 | }); |
| | 6172 | if (globals.length > 0) { |
| | 6173 | data.globals = globals; |
| | 6174 | } |
| | 6175 | |
| | 6176 | for (i = 1; i < functions.length; i += 1) { |
| | 6177 | the_function = functions[i]; |
| | 6178 | function_data = {}; |
| | 6179 | for (j = 0; j < functionicity.length; j += 1) { |
| | 6180 | function_data[functionicity[j]] = []; |
| | 6181 | } |
| | 6182 | for (name in the_function) { |
| | 6183 | if (Object.prototype.hasOwnProperty.call(the_function, name)) { |
| | 6184 | if (name.charAt(0) !== '(') { |
| | 6185 | kind = the_function[name]; |
| | 6186 | if (kind === 'unction' || kind === 'unparam') { |
| | 6187 | kind = 'unused'; |
| | 6188 | } |
| | 6189 | if (Array.isArray(function_data[kind])) { |
| | 6190 | function_data[kind].push(name); |
| | 6191 | if (kind === 'unused') { |
| | 6192 | unused.push({ |
| | 6193 | name: name, |
| | 6194 | line: the_function['(line)'], |
| | 6195 | 'function': the_function['(name)'] |
| | 6196 | }); |
| | 6197 | } else if (kind === 'undef') { |
| | 6198 | undef.push({ |
| | 6199 | name: name, |
| | 6200 | line: the_function['(line)'], |
| | 6201 | 'function': the_function['(name)'] |
| | 6202 | }); |
| | 6203 | } |
| | 6204 | } |
| | 6205 | } |
| | 6206 | } |
| | 6207 | } |
| | 6208 | for (j = 0; j < functionicity.length; j += 1) { |
| | 6209 | if (function_data[functionicity[j]].length === 0) { |
| | 6210 | delete function_data[functionicity[j]]; |
| | 6211 | } |
| | 6212 | } |
| | 6213 | function_data.name = the_function['(name)']; |
| | 6214 | function_data.params = the_function['(params)']; |
| | 6215 | function_data.line = the_function['(line)']; |
| | 6216 | data.functions.push(function_data); |
| | 6217 | } |
| | 6218 | |
| | 6219 | if (unused.length > 0) { |
| | 6220 | data.unused = unused; |
| | 6221 | } |
| | 6222 | if (undef.length > 0) { |
| | 6223 | data['undefined'] = undef; |
| | 6224 | } |
| | 6225 | |
| | 6226 | members = []; |
| | 6227 | for (name in property) { |
| | 6228 | if (typeof property[name] === 'number') { |
| | 6229 | data.member = property; |
| | 6230 | break; |
| | 6231 | } |
| | 6232 | } |
| | 6233 | |
| | 6234 | return data; |
| | 6235 | }; |
| | 6236 | |
| | 6237 | |
| | 6238 | itself.report = function (errors_only) { |
| | 6239 | var data = itself.data(), err, evidence, i, italics, j, key, keys, |
| | 6240 | length, mem = '', name, names, not_first, output = [], snippets, |
| | 6241 | the_function, warning; |
| | 6242 | |
| | 6243 | function detail(h, value) { |
| | 6244 | var comma_needed, singularity; |
| | 6245 | if (Array.isArray(value)) { |
| | 6246 | output.push('<div><i>' + h + '</i> '); |
| | 6247 | value.sort().forEach(function (item) { |
| | 6248 | if (item !== singularity) { |
| | 6249 | singularity = item; |
| | 6250 | output.push((comma_needed ? ', ' : '') + singularity); |
| | 6251 | comma_needed = true; |
| | 6252 | } |
| | 6253 | }); |
| | 6254 | output.push('</div>'); |
| | 6255 | } else if (value) { |
| | 6256 | output.push('<div><i>' + h + '</i> ' + value + '</div>'); |
| | 6257 | } |
| | 6258 | } |
| | 6259 | |
| | 6260 | if (data.errors || data.unused || data['undefined']) { |
| | 6261 | err = true; |
| | 6262 | output.push('<div id=errors><i>Error:</i>'); |
| | 6263 | if (data.errors) { |
| | 6264 | for (i = 0; i < data.errors.length; i += 1) { |
| | 6265 | warning = data.errors[i]; |
| | 6266 | if (warning) { |
| | 6267 | evidence = warning.evidence || ''; |
| | 6268 | output.push('<p>Problem' + (isFinite(warning.line) |
| | 6269 | ? ' at line ' + String(warning.line) + |
| | 6270 | ' character ' + String(warning.character) |
| | 6271 | : '') + |
| | 6272 | ': ' + warning.reason.entityify() + |
| | 6273 | '</p><p class=evidence>' + |
| | 6274 | (evidence && (evidence.length > 80 |
| | 6275 | ? evidence.slice(0, 77) + '...' |
| | 6276 | : evidence).entityify()) + '</p>'); |
| | 6277 | } |
| | 6278 | } |
| | 6279 | } |
| | 6280 | |
| | 6281 | if (data['undefined']) { |
| | 6282 | snippets = []; |
| | 6283 | for (i = 0; i < data['undefined'].length; i += 1) { |
| | 6284 | snippets[i] = '<code><u>' + data['undefined'][i].name + '</u></code> <i>' + |
| | 6285 | String(data['undefined'][i].line) + ' </i> <small>' + |
| | 6286 | data['undefined'][i]['function'] + '</small>'; |
| | 6287 | } |
| | 6288 | output.push('<p><i>Undefined variable:</i> ' + snippets.join(', ') + '</p>'); |
| | 6289 | } |
| | 6290 | if (data.unused) { |
| | 6291 | snippets = []; |
| | 6292 | for (i = 0; i < data.unused.length; i += 1) { |
| | 6293 | snippets[i] = '<code><u>' + data.unused[i].name + '</u></code> <i>' + |
| | 6294 | String(data.unused[i].line) + ' </i> <small>' + |
| | 6295 | data.unused[i]['function'] + '</small>'; |
| | 6296 | } |
| | 6297 | output.push('<p><i>Unused variable:</i> ' + snippets.join(', ') + '</p>'); |
| | 6298 | } |
| | 6299 | if (data.json) { |
| | 6300 | output.push('<p>JSON: bad.</p>'); |
| | 6301 | } |
| | 6302 | output.push('</div>'); |
| | 6303 | } |
| | 6304 | |
| | 6305 | if (!errors_only) { |
| | 6306 | |
| | 6307 | output.push('<br><div id=functions>'); |
| | 6308 | |
| | 6309 | if (data.urls) { |
| | 6310 | detail("URLs<br>", data.urls, '<br>'); |
| | 6311 | } |
| | 6312 | |
| | 6313 | if (xmode === 'style') { |
| | 6314 | output.push('<p>CSS.</p>'); |
| | 6315 | } else if (data.json && !err) { |
| | 6316 | output.push('<p>JSON: good.</p>'); |
| | 6317 | } else if (data.globals) { |
| | 6318 | output.push('<div><i>Global</i> ' + |
| | 6319 | data.globals.sort().join(', ') + '</div>'); |
| | 6320 | } else { |
| | 6321 | output.push('<div><i>No new global variables introduced.</i></div>'); |
| | 6322 | } |
| | 6323 | |
| | 6324 | for (i = 0; i < data.functions.length; i += 1) { |
| | 6325 | the_function = data.functions[i]; |
| | 6326 | names = []; |
| | 6327 | if (the_function.params) { |
| | 6328 | for (j = 0; j < the_function.params.length; j += 1) { |
| | 6329 | names[j] = the_function.params[j].string; |
| | 6330 | } |
| | 6331 | } |
| | 6332 | output.push('<br><div class=function><i>' + |
| | 6333 | String(the_function.line) + '</i> ' + |
| | 6334 | the_function.name.entityify() + |
| | 6335 | '(' + names.join(', ') + ')</div>'); |
| | 6336 | detail('<big><b>Undefined</b></big>', the_function['undefined']); |
| | 6337 | detail('<big><b>Unused</b></big>', the_function.unused); |
| | 6338 | detail('Closure', the_function.closure); |
| | 6339 | detail('Variable', the_function['var']); |
| | 6340 | detail('Exception', the_function.exception); |
| | 6341 | detail('Outer', the_function.outer); |
| | 6342 | detail('Global', the_function.global); |
| | 6343 | detail('Label', the_function.label); |
| | 6344 | } |
| | 6345 | |
| | 6346 | if (data.member) { |
| | 6347 | keys = Object.keys(data.member); |
| | 6348 | if (keys.length) { |
| | 6349 | keys = keys.sort(); |
| | 6350 | output.push('<br><pre id=properties>/*properties<br>'); |
| | 6351 | mem = ' '; |
| | 6352 | italics = 0; |
| | 6353 | j = 0; |
| | 6354 | not_first = false; |
| | 6355 | for (i = 0; i < keys.length; i += 1) { |
| | 6356 | key = keys[i]; |
| | 6357 | if (data.member[key] > 0) { |
| | 6358 | if (not_first) { |
| | 6359 | mem += ', '; |
| | 6360 | } |
| | 6361 | name = ix.test(key) |
| | 6362 | ? key |
| | 6363 | : '\'' + key.entityify().replace(nx, sanitize) + '\''; |
| | 6364 | length += name.length + 2; |
| | 6365 | if (data.member[key] === 1) { |
| | 6366 | name = '<i>' + name + '</i>'; |
| | 6367 | italics += 1; |
| | 6368 | j = 1; |
| | 6369 | } |
| | 6370 | if (mem.length + name.length - (italics * 7) > 80) { |
| | 6371 | output.push(mem + '<br>'); |
| | 6372 | mem = ' '; |
| | 6373 | italics = j; |
| | 6374 | } |
| | 6375 | mem += name; |
| | 6376 | j = 0; |
| | 6377 | not_first = true; |
| | 6378 | } |
| | 6379 | } |
| | 6380 | output.push(mem + '<br>*/</pre>'); |
| | 6381 | } |
| | 6382 | output.push('</div>'); |
| | 6383 | } |
| | 6384 | } |
| | 6385 | return output.join(''); |
| | 6386 | }; |
| | 6387 | itself.jslint = itself; |
| | 6388 | |
| | 6389 | itself.edition = '2012-02-23'; |
| | 6390 | |
| | 6391 | return itself; |
| | 6392 | }()); |
git.r.bdr.sh / rbdr / dotfiles / blame_incremental