]> git.r.bdr.sh - rbdr/dotfiles/blame - vim/ftplugin/javascript/jslint/jslint-core.js
Updates git submodules
[rbdr/dotfiles] / vim / ftplugin / javascript / jslint / jslint-core.js
CommitLineData
32081fee
BB
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
310var 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*!|&lt/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, '&amp;')
1026 .replace(/</g, '&lt;')
1027 .replace(/>/g, '&gt;');
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 }
1541klass: 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>&nbsp;<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>&nbsp;<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}());