Mercurial > hg > ismi-richfaces

comparison src/main/webapp/imageServer/resources/js/jquery-ui-1.10.4/external/jshint.js @ 7:764f47286679

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
(none)
author jurzua
date Wed, 29 Oct 2014 14:28:34 +0000
parents
children
comparison
equal deleted inserted replaced
6:ded3bccf2cf9 7:764f47286679
1 /*!
2 * JSHint, by JSHint Community.
3 *
4 * This file (and this file only) is licensed under the same slightly modified
5 * MIT license that JSLint is. It stops evil-doers everywhere.
6 *
7 * JSHint is a derivative work of JSLint:
8 *
9 * Copyright (c) 2002 Douglas Crockford (www.JSLint.com)
10 *
11 * Permission is hereby granted, free of charge, to any person obtaining
12 * a copy of this software and associated documentation files (the "Software"),
13 * to deal in the Software without restriction, including without limitation
14 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
15 * and/or sell copies of the Software, and to permit persons to whom
16 * the Software is furnished to do so, subject to the following conditions:
17 *
18 * The above copyright notice and this permission notice shall be included
19 * in all copies or substantial portions of the Software.
20 *
21 * The Software shall be used for Good, not Evil.
22 *
23 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
24 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
25 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
26 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
27 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
28 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
29 * DEALINGS IN THE SOFTWARE.
30 *
31 */
32
33 /*
34 JSHINT is a global function. It takes two parameters.
35
36 var myResult = JSHINT(source, option);
37
38 The first parameter is either a string or an array of strings. If it is a
39 string, it will be split on '\n' or '\r'. If it is an array of strings, it
40 is assumed that each string represents one line. The source can be a
41 JavaScript text or a JSON text.
42
43 The second parameter is an optional object of options which control the
44 operation of JSHINT. Most of the options are booleans: They are all
45 optional and have a default value of false. One of the options, predef,
46 can be an array of names, which will be used to declare global variables,
47 or an object whose keys are used as global names, with a boolean value
48 that determines if they are assignable.
49
50 If it checks out, JSHINT returns true. Otherwise, it returns false.
51
52 If false, you can inspect JSHINT.errors to find out the problems.
53 JSHINT.errors is an array of objects containing these members:
54
55 {
56 line : The line (relative to 1) at which the lint was found
57 character : The character (relative to 1) at which the lint was found
58 reason : The problem
59 evidence : The text line in which the problem occurred
60 raw : The raw message before the details were inserted
61 a : The first detail
62 b : The second detail
63 c : The third detail
64 d : The fourth detail
65 }
66
67 If a fatal error was found, a null will be the last element of the
68 JSHINT.errors array.
69
70 You can request a data structure which contains JSHint's results.
71
72 var myData = JSHINT.data();
73
74 It returns a structure with this form:
75
76 {
77 errors: [
78 {
79 line: NUMBER,
80 character: NUMBER,
81 reason: STRING,
82 evidence: STRING
83 }
84 ],
85 functions: [
86 name: STRING,
87 line: NUMBER,
88 character: NUMBER,
89 last: NUMBER,
90 lastcharacter: NUMBER,
91 param: [
92 STRING
93 ],
94 closure: [
95 STRING
96 ],
97 var: [
98 STRING
99 ],
100 exception: [
101 STRING
102 ],
103 outer: [
104 STRING
105 ],
106 unused: [
107 STRING
108 ],
109 global: [
110 STRING
111 ],
112 label: [
113 STRING
114 ]
115 ],
116 globals: [
117 STRING
118 ],
119 member: {
120 STRING: NUMBER
121 },
122 unused: [
123 {
124 name: STRING,
125 line: NUMBER
126 }
127 ],
128 implieds: [
129 {
130 name: STRING,
131 line: NUMBER
132 }
133 ],
134 urls: [
135 STRING
136 ],
137 json: BOOLEAN
138 }
139
140 Empty arrays will not be included.
141
142 */
143
144 /*jshint
145 evil: true, nomen: false, onevar: false, regexp: false, strict: true, boss: true,
146 undef: true, maxlen: 100, indent: 4, quotmark: double, unused: true
147 */
148
149 /*members "\b", "\t", "\n", "\f", "\r", "!=", "!==", "\"", "%", "(begin)",
150 "(breakage)", "(character)", "(context)", "(error)", "(explicitNewcap)", "(global)",
151 "(identifier)", "(last)", "(lastcharacter)", "(line)", "(loopage)", "(metrics)",
152 "(name)", "(onevar)", "(params)", "(scope)", "(statement)", "(verb)", "(tokens)", "(catch)",
153 "*", "+", "++", "-", "--", "\/", "<", "<=", "==",
154 "===", ">", ">=", $, $$, $A, $F, $H, $R, $break, $continue, $w, Abstract, Ajax,
155 __filename, __dirname, ActiveXObject, Array, ArrayBuffer, ArrayBufferView, Audio,
156 Autocompleter, Asset, Boolean, Builder, Buffer, Browser, Blob, COM, CScript, Canvas,
157 CustomAnimation, Class, Control, ComplexityCount, Chain, Color, Cookie, Core, DataView, Date,
158 Debug, Draggable, Draggables, Droppables, Document, DomReady, DOMEvent, DOMReady, DOMParser,
159 Drag, E, Enumerator, Enumerable, Element, Elements, Error, Effect, EvalError, Event,
160 Events, FadeAnimation, Field, Flash, Float32Array, Float64Array, Form,
161 FormField, Frame, FormData, Function, Fx, GetObject, Group, Hash, HotKey,
162 HTMLElement, HTMLAnchorElement, HTMLBaseElement, HTMLBlockquoteElement,
163 HTMLBodyElement, HTMLBRElement, HTMLButtonElement, HTMLCanvasElement, HTMLDirectoryElement,
164 HTMLDivElement, HTMLDListElement, HTMLFieldSetElement,
165 HTMLFontElement, HTMLFormElement, HTMLFrameElement, HTMLFrameSetElement,
166 HTMLHeadElement, HTMLHeadingElement, HTMLHRElement, HTMLHtmlElement,
167 HTMLIFrameElement, HTMLImageElement, HTMLInputElement, HTMLIsIndexElement,
168 HTMLLabelElement, HTMLLayerElement, HTMLLegendElement, HTMLLIElement,
169 HTMLLinkElement, HTMLMapElement, HTMLMenuElement, HTMLMetaElement,
170 HTMLModElement, HTMLObjectElement, HTMLOListElement, HTMLOptGroupElement,
171 HTMLOptionElement, HTMLParagraphElement, HTMLParamElement, HTMLPreElement,
172 HTMLQuoteElement, HTMLScriptElement, HTMLSelectElement, HTMLStyleElement,
173 HtmlTable, HTMLTableCaptionElement, HTMLTableCellElement, HTMLTableColElement,
174 HTMLTableElement, HTMLTableRowElement, HTMLTableSectionElement,
175 HTMLTextAreaElement, HTMLTitleElement, HTMLUListElement, HTMLVideoElement,
176 Iframe, IframeShim, Image, importScripts, Int16Array, Int32Array, Int8Array,
177 Insertion, InputValidator, JSON, Keyboard, Locale, LN10, LN2, LOG10E, LOG2E,
178 MAX_VALUE, MIN_VALUE, Map, Mask, Math, MenuItem, MessageChannel, MessageEvent, MessagePort,
179 MoveAnimation, MooTools, MutationObserver, NaN, Native, NEGATIVE_INFINITY, Node, NodeFilter,
180 Number, Object, ObjectRange,
181 Option, Options, OverText, PI, POSITIVE_INFINITY, PeriodicalExecuter, Point, Position, Prototype,
182 RangeError, Rectangle, ReferenceError, RegExp, ResizeAnimation, Request, RotateAnimation, Set,
183 SQRT1_2, SQRT2, ScrollBar, ScriptEngine, ScriptEngineBuildVersion,
184 ScriptEngineMajorVersion, ScriptEngineMinorVersion, Scriptaculous, Scroller,
185 Slick, Slider, Selector, SharedWorker, String, Style, SyntaxError, Sortable, Sortables,
186 SortableObserver, Sound, Spinner, System, Swiff, Text, TextArea, Template,
187 Timer, Tips, Type, TypeError, Toggle, Try, "use strict", unescape, URI, URIError, URL,
188 VBArray, WeakMap, WSH, WScript, XDomainRequest, Web, Window, XMLDOM, XMLHttpRequest, XMLSerializer,
189 XPathEvaluator, XPathException, XPathExpression, XPathNamespace, XPathNSResolver, XPathResult,
190 "\\", a, abs, addEventListener, address, alert, apply, applicationCache, arguments, arity,
191 asi, atob, b, basic, basicToken, bitwise, blacklist, block, blur, boolOptions, boss,
192 browser, btoa, c, call, callee, caller, camelcase, cases, charAt, charCodeAt, character,
193 clearInterval, clearTimeout, close, closed, closure, comment, complexityCount, condition,
194 confirm, console, constructor, content, couch, create, css, curly, d, data, datalist, dd, debug,
195 decodeURI, decodeURIComponent, defaultStatus, defineClass, deserialize, devel, document,
196 dojo, dijit, dojox, define, else, emit, encodeURI, encodeURIComponent, elem,
197 eqeq, eqeqeq, eqnull, errors, es5, escape, esnext, eval, event, evidence, evil,
198 ex, exception, exec, exps, expr, exports, FileReader, first, floor, focus, forEach,
199 forin, fragment, frames, from, fromCharCode, fud, funcscope, funct, function, functions,
200 g, gc, getComputedStyle, getRow, getter, getterToken, GLOBAL, global, globals, globalstrict,
201 hasOwnProperty, help, history, i, id, identifier, immed, implieds, importPackage, include,
202 indent, indexOf, init, ins, internals, instanceOf, isAlpha, isApplicationRunning, isArray,
203 isDigit, isFinite, isNaN, iterator, java, join, jshint,
204 JSHINT, json, jquery, jQuery, keys, label, labelled, last, lastcharacter, lastsemic, laxbreak,
205 laxcomma, latedef, lbp, led, left, length, line, load, loadClass, localStorage, location,
206 log, loopfunc, m, match, max, maxcomplexity, maxdepth, maxerr, maxlen, maxstatements, maxparams,
207 member, message, meta, module, moveBy, moveTo, mootools, multistr, name, navigator, new, newcap,
208 nestedBlockDepth, noarg, node, noempty, nomen, nonew, nonstandard, nud, onbeforeunload, onblur,
209 onerror, onevar, onecase, onfocus, onload, onresize, onunload, open, openDatabase, openURL,
210 opener, opera, options, outer, param, parent, parseFloat, parseInt, passfail, plusplus,
211 postMessage, pop, predef, print, process, prompt, proto, prototype, prototypejs, provides, push,
212 quit, quotmark, range, raw, reach, reason, regexp, readFile, readUrl, regexdash,
213 removeEventListener, replace, report, require, reserved, resizeBy, resizeTo, resolvePath,
214 resumeUpdates, respond, rhino, right, runCommand, scroll, scope, screen, scripturl, scrollBy,
215 scrollTo, scrollbar, search, seal, self, send, serialize, sessionStorage, setInterval, setTimeout,
216 setter, setterToken, shift, slice, smarttabs, sort, spawn, split, statement, statementCount, stack,
217 status, start, strict, sub, substr, supernew, shadow, supplant, sum, sync, test, toLowerCase,
218 toString, toUpperCase, toint32, token, tokens, top, trailing, type, typeOf, Uint16Array,
219 Uint32Array, Uint8Array, undef, undefs, unused, urls, validthis, value, valueOf, var, vars,
220 version, verifyMaxParametersPerFunction, verifyMaxStatementsPerFunction,
221 verifyMaxComplexityPerFunction, verifyMaxNestedBlockDepthPerFunction, WebSocket, withstmt, white,
222 window, windows, Worker, worker, wsh, yui, YUI, Y, YUI_config*/
223
224 /*global exports: false */
225
226 // We build the application inside a function so that we produce only a single
227 // global variable. That function will be invoked immediately, and its return
228 // value is the JSHINT function itself.
229
230 var JSHINT = (function () {
231 "use strict";
232
233 var anonname, // The guessed name for anonymous functions.
234
235 // These are operators that should not be used with the ! operator.
236
237 bang = {
238 "<" : true,
239 "<=" : true,
240 "==" : true,
241 "===": true,
242 "!==": true,
243 "!=" : true,
244 ">" : true,
245 ">=" : true,
246 "+" : true,
247 "-" : true,
248 "*" : true,
249 "/" : true,
250 "%" : true
251 },
252
253 // These are the JSHint boolean options.
254 boolOptions = {
255 asi : true, // if automatic semicolon insertion should be tolerated
256 bitwise : true, // if bitwise operators should not be allowed
257 boss : true, // if advanced usage of assignments should be allowed
258 browser : true, // if the standard browser globals should be predefined
259 camelcase : true, // if identifiers should be required in camel case
260 couch : true, // if CouchDB globals should be predefined
261 curly : true, // if curly braces around all blocks should be required
262 debug : true, // if debugger statements should be allowed
263 devel : true, // if logging globals should be predefined (console,
264 // alert, etc.)
265 dojo : true, // if Dojo Toolkit globals should be predefined
266 eqeqeq : true, // if === should be required
267 eqnull : true, // if == null comparisons should be tolerated
268 es5 : true, // if ES5 syntax should be allowed
269 esnext : true, // if es.next specific syntax should be allowed
270 evil : true, // if eval should be allowed
271 expr : true, // if ExpressionStatement should be allowed as Programs
272 forin : true, // if for in statements must filter
273 funcscope : true, // if only function scope should be used for scope tests
274 globalstrict: true, // if global "use strict"; should be allowed (also
275 // enables 'strict')
276 immed : true, // if immediate invocations must be wrapped in parens
277 iterator : true, // if the `__iterator__` property should be allowed
278 jquery : true, // if jQuery globals should be predefined
279 lastsemic : true, // if semicolons may be ommitted for the trailing
280 // statements inside of a one-line blocks.
281 latedef : true, // if the use before definition should not be tolerated
282 laxbreak : true, // if line breaks should not be checked
283 laxcomma : true, // if line breaks should not be checked around commas
284 loopfunc : true, // if functions should be allowed to be defined within
285 // loops
286 mootools : true, // if MooTools globals should be predefined
287 multistr : true, // allow multiline strings
288 newcap : true, // if constructor names must be capitalized
289 noarg : true, // if arguments.caller and arguments.callee should be
290 // disallowed
291 node : true, // if the Node.js environment globals should be
292 // predefined
293 noempty : true, // if empty blocks should be disallowed
294 nonew : true, // if using `new` for side-effects should be disallowed
295 nonstandard : true, // if non-standard (but widely adopted) globals should
296 // be predefined
297 nomen : true, // if names should be checked
298 onevar : true, // if only one var statement per function should be
299 // allowed
300 onecase : true, // if one case switch statements should be allowed
301 passfail : true, // if the scan should stop on first error
302 plusplus : true, // if increment/decrement should not be allowed
303 proto : true, // if the `__proto__` property should be allowed
304 prototypejs : true, // if Prototype and Scriptaculous globals should be
305 // predefined
306 regexdash : true, // if unescaped first/last dash (-) inside brackets
307 // should be tolerated
308 regexp : true, // if the . should not be allowed in regexp literals
309 rhino : true, // if the Rhino environment globals should be predefined
310 undef : true, // if variables should be declared before used
311 unused : true, // if variables should be always used
312 scripturl : true, // if script-targeted URLs should be tolerated
313 shadow : true, // if variable shadowing should be tolerated
314 smarttabs : true, // if smarttabs should be tolerated
315 // (http://www.emacswiki.org/emacs/SmartTabs)
316 strict : true, // require the "use strict"; pragma
317 sub : true, // if all forms of subscript notation are tolerated
318 supernew : true, // if `new function () { ... };` and `new Object;`
319 // should be tolerated
320 trailing : true, // if trailing whitespace rules apply
321 validthis : true, // if 'this' inside a non-constructor function is valid.
322 // This is a function scoped option only.
323 withstmt : true, // if with statements should be allowed
324 white : true, // if strict whitespace rules apply
325 worker : true, // if Web Worker script symbols should be allowed
326 wsh : true, // if the Windows Scripting Host environment globals
327 // should be predefined
328 yui : true // YUI variables should be predefined
329 },
330
331 // These are the JSHint options that can take any value
332 // (we use this object to detect invalid options)
333 valOptions = {
334 maxlen : false,
335 indent : false,
336 maxerr : false,
337 predef : false,
338 quotmark : false, //'single'|'double'|true
339 scope : false,
340 maxstatements: false, // {int} max statements per function
341 maxdepth : false, // {int} max nested block depth per function
342 maxparams : false, // {int} max params per function
343 maxcomplexity: false // {int} max cyclomatic complexity per function
344 },
345
346 // These are JSHint boolean options which are shared with JSLint
347 // where the definition in JSHint is opposite JSLint
348 invertedOptions = {
349 bitwise : true,
350 forin : true,
351 newcap : true,
352 nomen : true,
353 plusplus : true,
354 regexp : true,
355 undef : true,
356 white : true,
357
358 // Inverted and renamed, use JSHint name here
359 eqeqeq : true,
360 onevar : true
361 },
362
363 // These are JSHint boolean options which are shared with JSLint
364 // where the name has been changed but the effect is unchanged
365 renamedOptions = {
366 eqeq : "eqeqeq",
367 vars : "onevar",
368 windows : "wsh"
369 },
370
371
372 // browser contains a set of global names which are commonly provided by a
373 // web browser environment.
374 browser = {
375 ArrayBuffer : false,
376 ArrayBufferView : false,
377 Audio : false,
378 Blob : false,
379 addEventListener : false,
380 applicationCache : false,
381 atob : false,
382 blur : false,
383 btoa : false,
384 clearInterval : false,
385 clearTimeout : false,
386 close : false,
387 closed : false,
388 DataView : false,
389 DOMParser : false,
390 defaultStatus : false,
391 document : false,
392 event : false,
393 FileReader : false,
394 Float32Array : false,
395 Float64Array : false,
396 FormData : false,
397 focus : false,
398 frames : false,
399 getComputedStyle : false,
400 HTMLElement : false,
401 HTMLAnchorElement : false,
402 HTMLBaseElement : false,
403 HTMLBlockquoteElement : false,
404 HTMLBodyElement : false,
405 HTMLBRElement : false,
406 HTMLButtonElement : false,
407 HTMLCanvasElement : false,
408 HTMLDirectoryElement : false,
409 HTMLDivElement : false,
410 HTMLDListElement : false,
411 HTMLFieldSetElement : false,
412 HTMLFontElement : false,
413 HTMLFormElement : false,
414 HTMLFrameElement : false,
415 HTMLFrameSetElement : false,
416 HTMLHeadElement : false,
417 HTMLHeadingElement : false,
418 HTMLHRElement : false,
419 HTMLHtmlElement : false,
420 HTMLIFrameElement : false,
421 HTMLImageElement : false,
422 HTMLInputElement : false,
423 HTMLIsIndexElement : false,
424 HTMLLabelElement : false,
425 HTMLLayerElement : false,
426 HTMLLegendElement : false,
427 HTMLLIElement : false,
428 HTMLLinkElement : false,
429 HTMLMapElement : false,
430 HTMLMenuElement : false,
431 HTMLMetaElement : false,
432 HTMLModElement : false,
433 HTMLObjectElement : false,
434 HTMLOListElement : false,
435 HTMLOptGroupElement : false,
436 HTMLOptionElement : false,
437 HTMLParagraphElement : false,
438 HTMLParamElement : false,
439 HTMLPreElement : false,
440 HTMLQuoteElement : false,
441 HTMLScriptElement : false,
442 HTMLSelectElement : false,
443 HTMLStyleElement : false,
444 HTMLTableCaptionElement : false,
445 HTMLTableCellElement : false,
446 HTMLTableColElement : false,
447 HTMLTableElement : false,
448 HTMLTableRowElement : false,
449 HTMLTableSectionElement : false,
450 HTMLTextAreaElement : false,
451 HTMLTitleElement : false,
452 HTMLUListElement : false,
453 HTMLVideoElement : false,
454 history : false,
455 Int16Array : false,
456 Int32Array : false,
457 Int8Array : false,
458 Image : false,
459 length : false,
460 localStorage : false,
461 location : false,
462 MessageChannel : false,
463 MessageEvent : false,
464 MessagePort : false,
465 moveBy : false,
466 moveTo : false,
467 MutationObserver : false,
468 name : false,
469 Node : false,
470 NodeFilter : false,
471 navigator : false,
472 onbeforeunload : true,
473 onblur : true,
474 onerror : true,
475 onfocus : true,
476 onload : true,
477 onresize : true,
478 onunload : true,
479 open : false,
480 openDatabase : false,
481 opener : false,
482 Option : false,
483 parent : false,
484 print : false,
485 removeEventListener : false,
486 resizeBy : false,
487 resizeTo : false,
488 screen : false,
489 scroll : false,
490 scrollBy : false,
491 scrollTo : false,
492 sessionStorage : false,
493 setInterval : false,
494 setTimeout : false,
495 SharedWorker : false,
496 status : false,
497 top : false,
498 Uint16Array : false,
499 Uint32Array : false,
500 Uint8Array : false,
501 WebSocket : false,
502 window : false,
503 Worker : false,
504 XMLHttpRequest : false,
505 XMLSerializer : false,
506 XPathEvaluator : false,
507 XPathException : false,
508 XPathExpression : false,
509 XPathNamespace : false,
510 XPathNSResolver : false,
511 XPathResult : false
512 },
513
514 couch = {
515 "require" : false,
516 respond : false,
517 getRow : false,
518 emit : false,
519 send : false,
520 start : false,
521 sum : false,
522 log : false,
523 exports : false,
524 module : false,
525 provides : false
526 },
527
528 declared, // Globals that were declared using /*global ... */ syntax.
529
530 devel = {
531 alert : false,
532 confirm : false,
533 console : false,
534 Debug : false,
535 opera : false,
536 prompt : false
537 },
538
539 dojo = {
540 dojo : false,
541 dijit : false,
542 dojox : false,
543 define : false,
544 "require" : false
545 },
546
547 funct, // The current function
548
549 functionicity = [
550 "closure", "exception", "global", "label",
551 "outer", "unused", "var"
552 ],
553
554 functions, // All of the functions
555
556 global, // The global scope
557 implied, // Implied globals
558 inblock,
559 indent,
560 jsonmode,
561
562 jquery = {
563 "$" : false,
564 jQuery : false
565 },
566
567 lines,
568 lookahead,
569 member,
570 membersOnly,
571
572 mootools = {
573 "$" : false,
574 "$$" : false,
575 Asset : false,
576 Browser : false,
577 Chain : false,
578 Class : false,
579 Color : false,
580 Cookie : false,
581 Core : false,
582 Document : false,
583 DomReady : false,
584 DOMEvent : false,
585 DOMReady : false,
586 Drag : false,
587 Element : false,
588 Elements : false,
589 Event : false,
590 Events : false,
591 Fx : false,
592 Group : false,
593 Hash : false,
594 HtmlTable : false,
595 Iframe : false,
596 IframeShim : false,
597 InputValidator : false,
598 instanceOf : false,
599 Keyboard : false,
600 Locale : false,
601 Mask : false,
602 MooTools : false,
603 Native : false,
604 Options : false,
605 OverText : false,
606 Request : false,
607 Scroller : false,
608 Slick : false,
609 Slider : false,
610 Sortables : false,
611 Spinner : false,
612 Swiff : false,
613 Tips : false,
614 Type : false,
615 typeOf : false,
616 URI : false,
617 Window : false
618 },
619
620 nexttoken,
621
622 node = {
623 __filename : false,
624 __dirname : false,
625 Buffer : false,
626 console : false,
627 exports : true, // In Node it is ok to exports = module.exports = foo();
628 GLOBAL : false,
629 global : false,
630 module : false,
631 process : false,
632 require : false,
633 setTimeout : false,
634 clearTimeout : false,
635 setInterval : false,
636 clearInterval : false
637 },
638
639 noreach,
640 option,
641 predefined, // Global variables defined by option
642 prereg,
643 prevtoken,
644
645 prototypejs = {
646 "$" : false,
647 "$$" : false,
648 "$A" : false,
649 "$F" : false,
650 "$H" : false,
651 "$R" : false,
652 "$break" : false,
653 "$continue" : false,
654 "$w" : false,
655 Abstract : false,
656 Ajax : false,
657 Class : false,
658 Enumerable : false,
659 Element : false,
660 Event : false,
661 Field : false,
662 Form : false,
663 Hash : false,
664 Insertion : false,
665 ObjectRange : false,
666 PeriodicalExecuter: false,
667 Position : false,
668 Prototype : false,
669 Selector : false,
670 Template : false,
671 Toggle : false,
672 Try : false,
673 Autocompleter : false,
674 Builder : false,
675 Control : false,
676 Draggable : false,
677 Draggables : false,
678 Droppables : false,
679 Effect : false,
680 Sortable : false,
681 SortableObserver : false,
682 Sound : false,
683 Scriptaculous : false
684 },
685
686 quotmark,
687
688 rhino = {
689 defineClass : false,
690 deserialize : false,
691 gc : false,
692 help : false,
693 importPackage: false,
694 "java" : false,
695 load : false,
696 loadClass : false,
697 print : false,
698 quit : false,
699 readFile : false,
700 readUrl : false,
701 runCommand : false,
702 seal : false,
703 serialize : false,
704 spawn : false,
705 sync : false,
706 toint32 : false,
707 version : false
708 },
709
710 scope, // The current scope
711 stack,
712
713 // standard contains the global names that are provided by the
714 // ECMAScript standard.
715 standard = {
716 Array : false,
717 Boolean : false,
718 Date : false,
719 decodeURI : false,
720 decodeURIComponent : false,
721 encodeURI : false,
722 encodeURIComponent : false,
723 Error : false,
724 "eval" : false,
725 EvalError : false,
726 Function : false,
727 hasOwnProperty : false,
728 isFinite : false,
729 isNaN : false,
730 JSON : false,
731 Map : false,
732 Math : false,
733 NaN : false,
734 Number : false,
735 Object : false,
736 parseInt : false,
737 parseFloat : false,
738 RangeError : false,
739 ReferenceError : false,
740 RegExp : false,
741 Set : false,
742 String : false,
743 SyntaxError : false,
744 TypeError : false,
745 URIError : false,
746 WeakMap : false
747 },
748
749 // widely adopted global names that are not part of ECMAScript standard
750 nonstandard = {
751 escape : false,
752 unescape : false
753 },
754
755 directive,
756 syntax = {},
757 tab,
758 token,
759 unuseds,
760 urls,
761 useESNextSyntax,
762 warnings,
763
764 worker = {
765 importScripts : true,
766 postMessage : true,
767 self : true
768 },
769
770 wsh = {
771 ActiveXObject : true,
772 Enumerator : true,
773 GetObject : true,
774 ScriptEngine : true,
775 ScriptEngineBuildVersion : true,
776 ScriptEngineMajorVersion : true,
777 ScriptEngineMinorVersion : true,
778 VBArray : true,
779 WSH : true,
780 WScript : true,
781 XDomainRequest : true
782 },
783
784 yui = {
785 YUI : false,
786 Y : false,
787 YUI_config : false
788 };
789 // Regular expressions. Some of these are stupidly long.
790 var ax, cx, tx, nx, nxg, lx, ix, jx, ft;
791 (function () {
792 /*jshint maxlen:300 */
793
794 // unsafe comment or string
795 ax = /@cc|<\/?|script|\]\s*\]|<\s*!|&lt/i;
796
797 // unsafe characters that are silently deleted by one or more browsers
798 cx = /[\u0000-\u001f\u007f-\u009f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/;
799
800 // token
801 tx = /^\s*([(){}\[.,:;'"~\?\]#@]|==?=?|\/=(?!(\S*\/[gim]?))|\/(\*(jshint|jslint|members?|global)?|\/)?|\*[\/=]?|\+(?:=|\++)?|-(?:=|-+)?|%=?|&[&=]?|\|[|=]?|>>?>?=?|<([\/=!]|\!(\[|--)?|<=?)?|\^=?|\!=?=?|[a-zA-Z_$][a-zA-Z0-9_$]*|[0-9]+([xX][0-9a-fA-F]+|\.[0-9]*)?([eE][+\-]?[0-9]+)?)/;
802
803 // characters in strings that need escapement
804 nx = /[\u0000-\u001f&<"\/\\\u007f-\u009f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/;
805 nxg = /[\u0000-\u001f&<"\/\\\u007f-\u009f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g;
806
807 // star slash
808 lx = /\*\//;
809
810 // identifier
811 ix = /^([a-zA-Z_$][a-zA-Z0-9_$]*)$/;
812
813 // javascript url
814 jx = /^(?:javascript|jscript|ecmascript|vbscript|mocha|livescript)\s*:/i;
815
816 // catches /* falls through */ comments
817 ft = /^\s*\/\*\s*falls\sthrough\s*\*\/\s*$/;
818 }());
819
820 function F() {} // Used by Object.create
821
822 function is_own(object, name) {
823 // The object.hasOwnProperty method fails when the property under consideration
824 // is named 'hasOwnProperty'. So we have to use this more convoluted form.
825 return Object.prototype.hasOwnProperty.call(object, name);
826 }
827
828 function checkOption(name, t) {
829 if (valOptions[name] === undefined && boolOptions[name] === undefined) {
830 warning("Bad option: '" + name + "'.", t);
831 }
832 }
833
834 function isString(obj) {
835 return Object.prototype.toString.call(obj) === "[object String]";
836 }
837
838 // Provide critical ES5 functions to ES3.
839
840 if (typeof Array.isArray !== "function") {
841 Array.isArray = function (o) {
842 return Object.prototype.toString.apply(o) === "[object Array]";
843 };
844 }
845
846 if (!Array.prototype.forEach) {
847 Array.prototype.forEach = function (fn, scope) {
848 var len = this.length;
849
850 for (var i = 0; i < len; i++) {
851 fn.call(scope || this, this[i], i, this);
852 }
853 };
854 }
855
856 if (!Array.prototype.indexOf) {
857 Array.prototype.indexOf = function (searchElement /*, fromIndex */ ) {
858 if (this === null || this === undefined) {
859 throw new TypeError();
860 }
861
862 var t = new Object(this);
863 var len = t.length >>> 0;
864
865 if (len === 0) {
866 return -1;
867 }
868
869 var n = 0;
870 if (arguments.length > 0) {
871 n = Number(arguments[1]);
872 if (n != n) { // shortcut for verifying if it's NaN
873 n = 0;
874 } else if (n !== 0 && n != Infinity && n != -Infinity) {
875 n = (n > 0 || -1) * Math.floor(Math.abs(n));
876 }
877 }
878
879 if (n >= len) {
880 return -1;
881 }
882
883 var k = n >= 0 ? n : Math.max(len - Math.abs(n), 0);
884 for (; k < len; k++) {
885 if (k in t && t[k] === searchElement) {
886 return k;
887 }
888 }
889
890 return -1;
891 };
892 }
893
894 if (typeof Object.create !== "function") {
895 Object.create = function (o) {
896 F.prototype = o;
897 return new F();
898 };
899 }
900
901 if (typeof Object.keys !== "function") {
902 Object.keys = function (o) {
903 var a = [], k;
904 for (k in o) {
905 if (is_own(o, k)) {
906 a.push(k);
907 }
908 }
909 return a;
910 };
911 }
912
913 // Non standard methods
914
915 function isAlpha(str) {
916 return (str >= "a" && str <= "z\uffff") ||
917 (str >= "A" && str <= "Z\uffff");
918 }
919
920 function isDigit(str) {
921 return (str >= "0" && str <= "9");
922 }
923
924 function isIdentifier(token, value) {
925 if (!token)
926 return false;
927
928 if (!token.identifier || token.value !== value)
929 return false;
930
931 return true;
932 }
933
934 function supplant(str, data) {
935 return str.replace(/\{([^{}]*)\}/g, function (a, b) {
936 var r = data[b];
937 return typeof r === "string" || typeof r === "number" ? r : a;
938 });
939 }
940
941 function combine(t, o) {
942 var n;
943 for (n in o) {
944 if (is_own(o, n) && !is_own(JSHINT.blacklist, n)) {
945 t[n] = o[n];
946 }
947 }
948 }
949
950 function updatePredefined() {
951 Object.keys(JSHINT.blacklist).forEach(function (key) {
952 delete predefined[key];
953 });
954 }
955
956 function assume() {
957 if (option.couch) {
958 combine(predefined, couch);
959 }
960
961 if (option.rhino) {
962 combine(predefined, rhino);
963 }
964
965 if (option.prototypejs) {
966 combine(predefined, prototypejs);
967 }
968
969 if (option.node) {
970 combine(predefined, node);
971 option.globalstrict = true;
972 }
973
974 if (option.devel) {
975 combine(predefined, devel);
976 }
977
978 if (option.dojo) {
979 combine(predefined, dojo);
980 }
981
982 if (option.browser) {
983 combine(predefined, browser);
984 }
985
986 if (option.nonstandard) {
987 combine(predefined, nonstandard);
988 }
989
990 if (option.jquery) {
991 combine(predefined, jquery);
992 }
993
994 if (option.mootools) {
995 combine(predefined, mootools);
996 }
997
998 if (option.worker) {
999 combine(predefined, worker);
1000 }
1001
1002 if (option.wsh) {
1003 combine(predefined, wsh);
1004 }
1005
1006 if (option.esnext) {
1007 useESNextSyntax();
1008 }
1009
1010 if (option.globalstrict && option.strict !== false) {
1011 option.strict = true;
1012 }
1013
1014 if (option.yui) {
1015 combine(predefined, yui);
1016 }
1017 }
1018
1019
1020 // Produce an error warning.
1021 function quit(message, line, chr) {
1022 var percentage = Math.floor((line / lines.length) * 100);
1023
1024 throw {
1025 name: "JSHintError",
1026 line: line,
1027 character: chr,
1028 message: message + " (" + percentage + "% scanned).",
1029 raw: message
1030 };
1031 }
1032
1033 function isundef(scope, m, t, a) {
1034 return JSHINT.undefs.push([scope, m, t, a]);
1035 }
1036
1037 function warning(m, t, a, b, c, d) {
1038 var ch, l, w;
1039 t = t || nexttoken;
1040 if (t.id === "(end)") { // `~
1041 t = token;
1042 }
1043 l = t.line || 0;
1044 ch = t.from || 0;
1045 w = {
1046 id: "(error)",
1047 raw: m,
1048 evidence: lines[l - 1] || "",
1049 line: l,
1050 character: ch,
1051 scope: JSHINT.scope,
1052 a: a,
1053 b: b,
1054 c: c,
1055 d: d
1056 };
1057 w.reason = supplant(m, w);
1058 JSHINT.errors.push(w);
1059 if (option.passfail) {
1060 quit("Stopping. ", l, ch);
1061 }
1062 warnings += 1;
1063 if (warnings >= option.maxerr) {
1064 quit("Too many errors.", l, ch);
1065 }
1066 return w;
1067 }
1068
1069 function warningAt(m, l, ch, a, b, c, d) {
1070 return warning(m, {
1071 line: l,
1072 from: ch
1073 }, a, b, c, d);
1074 }
1075
1076 function error(m, t, a, b, c, d) {
1077 warning(m, t, a, b, c, d);
1078 }
1079
1080 function errorAt(m, l, ch, a, b, c, d) {
1081 return error(m, {
1082 line: l,
1083 from: ch
1084 }, a, b, c, d);
1085 }
1086
1087 // Tracking of "internal" scripts, like eval containing a static string
1088 function addInternalSrc(elem, src) {
1089 var i;
1090 i = {
1091 id: "(internal)",
1092 elem: elem,
1093 value: src
1094 };
1095 JSHINT.internals.push(i);
1096 return i;
1097 }
1098
1099
1100 // lexical analysis and token construction
1101
1102 var lex = (function lex() {
1103 var character, from, line, s;
1104
1105 // Private lex methods
1106
1107 function nextLine() {
1108 var at,
1109 match,
1110 tw; // trailing whitespace check
1111
1112 if (line >= lines.length)
1113 return false;
1114
1115 character = 1;
1116 s = lines[line];
1117 line += 1;
1118
1119 // If smarttabs option is used check for spaces followed by tabs only.
1120 // Otherwise check for any occurence of mixed tabs and spaces.
1121 // Tabs and one space followed by block comment is allowed.
1122 if (option.smarttabs) {
1123 // negative look-behind for "//"
1124 match = s.match(/(\/\/)? \t/);
1125 at = match && !match[1] ? 0 : -1;
1126 } else {
1127 at = s.search(/ \t|\t [^\*]/);
1128 }
1129
1130 if (at >= 0)
1131 warningAt("Mixed spaces and tabs.", line, at + 1);
1132
1133 s = s.replace(/\t/g, tab);
1134 at = s.search(cx);
1135
1136 if (at >= 0)
1137 warningAt("Unsafe character.", line, at);
1138
1139 if (option.maxlen && option.maxlen < s.length)
1140 warningAt("Line too long.", line, s.length);
1141
1142 // Check for trailing whitespaces
1143 tw = option.trailing && s.match(/^(.*?)\s+$/);
1144 if (tw && !/^\s+$/.test(s)) {
1145 warningAt("Trailing whitespace.", line, tw[1].length + 1);
1146 }
1147 return true;
1148 }
1149
1150 // Produce a token object. The token inherits from a syntax symbol.
1151
1152 function it(type, value) {
1153 var i, t;
1154
1155 function checkName(name) {
1156 if (!option.proto && name === "__proto__") {
1157 warningAt("The '{a}' property is deprecated.", line, from, name);
1158 return;
1159 }
1160
1161 if (!option.iterator && name === "__iterator__") {
1162 warningAt("'{a}' is only available in JavaScript 1.7.", line, from, name);
1163 return;
1164 }
1165
1166 // Check for dangling underscores unless we're in Node
1167 // environment and this identifier represents built-in
1168 // Node globals with underscores.
1169
1170 var hasDangling = /^(_+.*|.*_+)$/.test(name);
1171
1172 if (option.nomen && hasDangling && name !== "_") {
1173 if (option.node && token.id !== "." && /^(__dirname|__filename)$/.test(name))
1174 return;
1175
1176 warningAt("Unexpected {a} in '{b}'.", line, from, "dangling '_'", name);
1177 return;
1178 }
1179
1180 // Check for non-camelcase names. Names like MY_VAR and
1181 // _myVar are okay though.
1182
1183 if (option.camelcase) {
1184 if (name.replace(/^_+/, "").indexOf("_") > -1 && !name.match(/^[A-Z0-9_]*$/)) {
1185 warningAt("Identifier '{a}' is not in camel case.", line, from, value);
1186 }
1187 }
1188 }
1189
1190 if (type === "(color)" || type === "(range)") {
1191 t = {type: type};
1192 } else if (type === "(punctuator)" ||
1193 (type === "(identifier)" && is_own(syntax, value))) {
1194 t = syntax[value] || syntax["(error)"];
1195 } else {
1196 t = syntax[type];
1197 }
1198
1199 t = Object.create(t);
1200
1201 if (type === "(string)" || type === "(range)") {
1202 if (!option.scripturl && jx.test(value)) {
1203 warningAt("Script URL.", line, from);
1204 }
1205 }
1206
1207 if (type === "(identifier)") {
1208 t.identifier = true;
1209 checkName(value);
1210 }
1211
1212 t.value = value;
1213 t.line = line;
1214 t.character = character;
1215 t.from = from;
1216 i = t.id;
1217 if (i !== "(endline)") {
1218 prereg = i &&
1219 (("(,=:[!&|?{};".indexOf(i.charAt(i.length - 1)) >= 0) ||
1220 i === "return" ||
1221 i === "case");
1222 }
1223 return t;
1224 }
1225
1226 // Public lex methods
1227 return {
1228 init: function (source) {
1229 if (typeof source === "string") {
1230 lines = source
1231 .replace(/\r\n/g, "\n")
1232 .replace(/\r/g, "\n")
1233 .split("\n");
1234 } else {
1235 lines = source;
1236 }
1237
1238 // If the first line is a shebang (#!), make it a blank and move on.
1239 // Shebangs are used by Node scripts.
1240 if (lines[0] && lines[0].substr(0, 2) === "#!")
1241 lines[0] = "";
1242
1243 line = 0;
1244 nextLine();
1245 from = 1;
1246 },
1247
1248 range: function (begin, end) {
1249 var c, value = "";
1250 from = character;
1251 if (s.charAt(0) !== begin) {
1252 errorAt("Expected '{a}' and instead saw '{b}'.",
1253 line, character, begin, s.charAt(0));
1254 }
1255 for (;;) {
1256 s = s.slice(1);
1257 character += 1;
1258 c = s.charAt(0);
1259 switch (c) {
1260 case "":
1261 errorAt("Missing '{a}'.", line, character, c);
1262 break;
1263 case end:
1264 s = s.slice(1);
1265 character += 1;
1266 return it("(range)", value);
1267 case "\\":
1268 warningAt("Unexpected '{a}'.", line, character, c);
1269 }
1270 value += c;
1271 }
1272
1273 },
1274
1275
1276 // token -- this is called by advance to get the next token
1277 token: function () {
1278 var b, c, captures, d, depth, high, i, l, low, q, t, isLiteral, isInRange, n;
1279
1280 function match(x) {
1281 var r = x.exec(s), r1;
1282
1283 if (r) {
1284 l = r[0].length;
1285 r1 = r[1];
1286 c = r1.charAt(0);
1287 s = s.substr(l);
1288 from = character + l - r1.length;
1289 character += l;
1290 return r1;
1291 }
1292 }
1293
1294 function string(x) {
1295 var c, j, r = "", allowNewLine = false;
1296
1297 if (jsonmode && x !== "\"") {
1298 warningAt("Strings must use doublequote.",
1299 line, character);
1300 }
1301
1302 if (option.quotmark) {
1303 if (option.quotmark === "single" && x !== "'") {
1304 warningAt("Strings must use singlequote.",
1305 line, character);
1306 } else if (option.quotmark === "double" && x !== "\"") {
1307 warningAt("Strings must use doublequote.",
1308 line, character);
1309 } else if (option.quotmark === true) {
1310 quotmark = quotmark || x;
1311 if (quotmark !== x) {
1312 warningAt("Mixed double and single quotes.",
1313 line, character);
1314 }
1315 }
1316 }
1317
1318 function esc(n) {
1319 var i = parseInt(s.substr(j + 1, n), 16);
1320 j += n;
1321 if (i >= 32 && i <= 126 &&
1322 i !== 34 && i !== 92 && i !== 39) {
1323 warningAt("Unnecessary escapement.", line, character);
1324 }
1325 character += n;
1326 c = String.fromCharCode(i);
1327 }
1328
1329 j = 0;
1330
1331 unclosedString:
1332 for (;;) {
1333 while (j >= s.length) {
1334 j = 0;
1335
1336 var cl = line, cf = from;
1337 if (!nextLine()) {
1338 errorAt("Unclosed string.", cl, cf);
1339 break unclosedString;
1340 }
1341
1342 if (allowNewLine) {
1343 allowNewLine = false;
1344 } else {
1345 warningAt("Unclosed string.", cl, cf);
1346 }
1347 }
1348
1349 c = s.charAt(j);
1350 if (c === x) {
1351 character += 1;
1352 s = s.substr(j + 1);
1353 return it("(string)", r, x);
1354 }
1355
1356 if (c < " ") {
1357 if (c === "\n" || c === "\r") {
1358 break;
1359 }
1360 warningAt("Control character in string: {a}.",
1361 line, character + j, s.slice(0, j));
1362 } else if (c === "\\") {
1363 j += 1;
1364 character += 1;
1365 c = s.charAt(j);
1366 n = s.charAt(j + 1);
1367 switch (c) {
1368 case "\\":
1369 case "\"":
1370 case "/":
1371 break;
1372 case "\'":
1373 if (jsonmode) {
1374 warningAt("Avoid \\'.", line, character);
1375 }
1376 break;
1377 case "b":
1378 c = "\b";
1379 break;
1380 case "f":
1381 c = "\f";
1382 break;
1383 case "n":
1384 c = "\n";
1385 break;
1386 case "r":
1387 c = "\r";
1388 break;
1389 case "t":
1390 c = "\t";
1391 break;
1392 case "0":
1393 c = "\0";
1394 // Octal literals fail in strict mode
1395 // check if the number is between 00 and 07
1396 // where 'n' is the token next to 'c'
1397 if (n >= 0 && n <= 7 && directive["use strict"]) {
1398 warningAt(
1399 "Octal literals are not allowed in strict mode.",
1400 line, character);
1401 }
1402 break;
1403 case "u":
1404 esc(4);
1405 break;
1406 case "v":
1407 if (jsonmode) {
1408 warningAt("Avoid \\v.", line, character);
1409 }
1410 c = "\v";
1411 break;
1412 case "x":
1413 if (jsonmode) {
1414 warningAt("Avoid \\x-.", line, character);
1415 }
1416 esc(2);
1417 break;
1418 case "":
1419 // last character is escape character
1420 // always allow new line if escaped, but show
1421 // warning if option is not set
1422 allowNewLine = true;
1423 if (option.multistr) {
1424 if (jsonmode) {
1425 warningAt("Avoid EOL escapement.", line, character);
1426 }
1427 c = "";
1428 character -= 1;
1429 break;
1430 }
1431 warningAt("Bad escapement of EOL. Use option multistr if needed.",
1432 line, character);
1433 break;
1434 case "!":
1435 if (s.charAt(j - 2) === "<")
1436 break;
1437 /*falls through*/
1438 default:
1439 warningAt("Bad escapement.", line, character);
1440 }
1441 }
1442 r += c;
1443 character += 1;
1444 j += 1;
1445 }
1446 }
1447
1448 for (;;) {
1449 if (!s) {
1450 return it(nextLine() ? "(endline)" : "(end)", "");
1451 }
1452
1453 t = match(tx);
1454
1455 if (!t) {
1456 t = "";
1457 c = "";
1458 while (s && s < "!") {
1459 s = s.substr(1);
1460 }
1461 if (s) {
1462 errorAt("Unexpected '{a}'.", line, character, s.substr(0, 1));
1463 s = "";
1464 }
1465 } else {
1466
1467 // identifier
1468
1469 if (isAlpha(c) || c === "_" || c === "$") {
1470 return it("(identifier)", t);
1471 }
1472
1473 // number
1474
1475 if (isDigit(c)) {
1476 if (!isFinite(Number(t))) {
1477 warningAt("Bad number '{a}'.",
1478 line, character, t);
1479 }
1480 if (isAlpha(s.substr(0, 1))) {
1481 warningAt("Missing space after '{a}'.",
1482 line, character, t);
1483 }
1484 if (c === "0") {
1485 d = t.substr(1, 1);
1486 if (isDigit(d)) {
1487 if (token.id !== ".") {
1488 warningAt("Don't use extra leading zeros '{a}'.",
1489 line, character, t);
1490 }
1491 } else if (jsonmode && (d === "x" || d === "X")) {
1492 warningAt("Avoid 0x-. '{a}'.",
1493 line, character, t);
1494 }
1495 }
1496 if (t.substr(t.length - 1) === ".") {
1497 warningAt(
1498 "A trailing decimal point can be confused with a dot '{a}'.", line, character, t);
1499 }
1500 return it("(number)", t);
1501 }
1502 switch (t) {
1503
1504 // string
1505
1506 case "\"":
1507 case "'":
1508 return string(t);
1509
1510 // // comment
1511
1512 case "//":
1513 s = "";
1514 token.comment = true;
1515 break;
1516
1517 // /* comment
1518
1519 case "/*":
1520 for (;;) {
1521 i = s.search(lx);
1522 if (i >= 0) {
1523 break;
1524 }
1525 if (!nextLine()) {
1526 errorAt("Unclosed comment.", line, character);
1527 }
1528 }
1529 s = s.substr(i + 2);
1530 token.comment = true;
1531 break;
1532
1533 // /*members /*jshint /*global
1534
1535 case "/*members":
1536 case "/*member":
1537 case "/*jshint":
1538 case "/*jslint":
1539 case "/*global":
1540 case "*/":
1541 return {
1542 value: t,
1543 type: "special",
1544 line: line,
1545 character: character,
1546 from: from
1547 };
1548
1549 case "":
1550 break;
1551 // /
1552 case "/":
1553 if (s.charAt(0) === "=") {
1554 errorAt("A regular expression literal can be confused with '/='.",
1555 line, from);
1556 }
1557
1558 if (prereg) {
1559 depth = 0;
1560 captures = 0;
1561 l = 0;
1562 for (;;) {
1563 b = true;
1564 c = s.charAt(l);
1565 l += 1;
1566 switch (c) {
1567 case "":
1568 errorAt("Unclosed regular expression.", line, from);
1569 return quit("Stopping.", line, from);
1570 case "/":
1571 if (depth > 0) {
1572 warningAt("{a} unterminated regular expression " +
1573 "group(s).", line, from + l, depth);
1574 }
1575 c = s.substr(0, l - 1);
1576 q = {
1577 g: true,
1578 i: true,
1579 m: true
1580 };
1581 while (q[s.charAt(l)] === true) {
1582 q[s.charAt(l)] = false;
1583 l += 1;
1584 }
1585 character += l;
1586 s = s.substr(l);
1587 q = s.charAt(0);
1588 if (q === "/" || q === "*") {
1589 errorAt("Confusing regular expression.",
1590 line, from);
1591 }
1592 return it("(regexp)", c);
1593 case "\\":
1594 c = s.charAt(l);
1595 if (c < " ") {
1596 warningAt(
1597 "Unexpected control character in regular expression.", line, from + l);
1598 } else if (c === "<") {
1599 warningAt(
1600 "Unexpected escaped character '{a}' in regular expression.", line, from + l, c);
1601 }
1602 l += 1;
1603 break;
1604 case "(":
1605 depth += 1;
1606 b = false;
1607 if (s.charAt(l) === "?") {
1608 l += 1;
1609 switch (s.charAt(l)) {
1610 case ":":
1611 case "=":
1612 case "!":
1613 l += 1;
1614 break;
1615 default:
1616 warningAt(
1617 "Expected '{a}' and instead saw '{b}'.", line, from + l, ":", s.charAt(l));
1618 }
1619 } else {
1620 captures += 1;
1621 }
1622 break;
1623 case "|":
1624 b = false;
1625 break;
1626 case ")":
1627 if (depth === 0) {
1628 warningAt("Unescaped '{a}'.",
1629 line, from + l, ")");
1630 } else {
1631 depth -= 1;
1632 }
1633 break;
1634 case " ":
1635 q = 1;
1636 while (s.charAt(l) === " ") {
1637 l += 1;
1638 q += 1;
1639 }
1640 if (q > 1) {
1641 warningAt(
1642 "Spaces are hard to count. Use {{a}}.", line, from + l, q);
1643 }
1644 break;
1645 case "[":
1646 c = s.charAt(l);
1647 if (c === "^") {
1648 l += 1;
1649 if (s.charAt(l) === "]") {
1650 errorAt("Unescaped '{a}'.",
1651 line, from + l, "^");
1652 }
1653 }
1654 if (c === "]") {
1655 warningAt("Empty class.", line,
1656 from + l - 1);
1657 }
1658 isLiteral = false;
1659 isInRange = false;
1660 klass:
1661 do {
1662 c = s.charAt(l);
1663 l += 1;
1664 switch (c) {
1665 case "[":
1666 case "^":
1667 warningAt("Unescaped '{a}'.",
1668 line, from + l, c);
1669 if (isInRange) {
1670 isInRange = false;
1671 } else {
1672 isLiteral = true;
1673 }
1674 break;
1675 case "-":
1676 if (isLiteral && !isInRange) {
1677 isLiteral = false;
1678 isInRange = true;
1679 } else if (isInRange) {
1680 isInRange = false;
1681 } else if (s.charAt(l) === "]") {
1682 isInRange = true;
1683 } else {
1684 if (option.regexdash !== (l === 2 || (l === 3 &&
1685 s.charAt(1) === "^"))) {
1686 warningAt("Unescaped '{a}'.",
1687 line, from + l - 1, "-");
1688 }
1689 isLiteral = true;
1690 }
1691 break;
1692 case "]":
1693 if (isInRange && !option.regexdash) {
1694 warningAt("Unescaped '{a}'.",
1695 line, from + l - 1, "-");
1696 }
1697 break klass;
1698 case "\\":
1699 c = s.charAt(l);
1700 if (c < " ") {
1701 warningAt(
1702 "Unexpected control character in regular expression.", line, from + l);
1703 } else if (c === "<") {
1704 warningAt(
1705 "Unexpected escaped character '{a}' in regular expression.", line, from + l, c);
1706 }
1707 l += 1;
1708
1709 // \w, \s and \d are never part of a character range
1710 if (/[wsd]/i.test(c)) {
1711 if (isInRange) {
1712 warningAt("Unescaped '{a}'.",
1713 line, from + l, "-");
1714 isInRange = false;
1715 }
1716 isLiteral = false;
1717 } else if (isInRange) {
1718 isInRange = false;
1719 } else {
1720 isLiteral = true;
1721 }
1722 break;
1723 case "/":
1724 warningAt("Unescaped '{a}'.",
1725 line, from + l - 1, "/");
1726
1727 if (isInRange) {
1728 isInRange = false;
1729 } else {
1730 isLiteral = true;
1731 }
1732 break;
1733 case "<":
1734 if (isInRange) {
1735 isInRange = false;
1736 } else {
1737 isLiteral = true;
1738 }
1739 break;
1740 default:
1741 if (isInRange) {
1742 isInRange = false;
1743 } else {
1744 isLiteral = true;
1745 }
1746 }
1747 } while (c);
1748 break;
1749 case ".":
1750 if (option.regexp) {
1751 warningAt("Insecure '{a}'.", line,
1752 from + l, c);
1753 }
1754 break;
1755 case "]":
1756 case "?":
1757 case "{":
1758 case "}":
1759 case "+":
1760 case "*":
1761 warningAt("Unescaped '{a}'.", line,
1762 from + l, c);
1763 }
1764 if (b) {
1765 switch (s.charAt(l)) {
1766 case "?":
1767 case "+":
1768 case "*":
1769 l += 1;
1770 if (s.charAt(l) === "?") {
1771 l += 1;
1772 }
1773 break;
1774 case "{":
1775 l += 1;
1776 c = s.charAt(l);
1777 if (c < "0" || c > "9") {
1778 warningAt(
1779 "Expected a number and instead saw '{a}'.", line, from + l, c);
1780 break; // No reason to continue checking numbers.
1781 }
1782 l += 1;
1783 low = +c;
1784 for (;;) {
1785 c = s.charAt(l);
1786 if (c < "0" || c > "9") {
1787 break;
1788 }
1789 l += 1;
1790 low = +c + (low * 10);
1791 }
1792 high = low;
1793 if (c === ",") {
1794 l += 1;
1795 high = Infinity;
1796 c = s.charAt(l);
1797 if (c >= "0" && c <= "9") {
1798 l += 1;
1799 high = +c;
1800 for (;;) {
1801 c = s.charAt(l);
1802 if (c < "0" || c > "9") {
1803 break;
1804 }
1805 l += 1;
1806 high = +c + (high * 10);
1807 }
1808 }
1809 }
1810 if (s.charAt(l) !== "}") {
1811 warningAt(
1812 "Expected '{a}' and instead saw '{b}'.", line, from + l, "}", c);
1813 } else {
1814 l += 1;
1815 }
1816 if (s.charAt(l) === "?") {
1817 l += 1;
1818 }
1819 if (low > high) {
1820 warningAt(
1821 "'{a}' should not be greater than '{b}'.", line, from + l, low, high);
1822 }
1823 }
1824 }
1825 }
1826 c = s.substr(0, l - 1);
1827 character += l;
1828 s = s.substr(l);
1829 return it("(regexp)", c);
1830 }
1831 return it("(punctuator)", t);
1832
1833 // punctuator
1834
1835 case "#":
1836 return it("(punctuator)", t);
1837 default:
1838 return it("(punctuator)", t);
1839 }
1840 }
1841 }
1842 }
1843 };
1844 }());
1845
1846
1847 function addlabel(t, type, token) {
1848 if (t === "hasOwnProperty") {
1849 warning("'hasOwnProperty' is a really bad name.");
1850 }
1851
1852 // Define t in the current function in the current scope.
1853 if (type === "exception") {
1854 if (is_own(funct["(context)"], t)) {
1855 if (funct[t] !== true && !option.node) {
1856 warning("Value of '{a}' may be overwritten in IE.", nexttoken, t);
1857 }
1858 }
1859 }
1860
1861 if (is_own(funct, t) && !funct["(global)"]) {
1862 if (funct[t] === true) {
1863 if (option.latedef)
1864 warning("'{a}' was used before it was defined.", nexttoken, t);
1865 } else {
1866 if (!option.shadow && type !== "exception") {
1867 warning("'{a}' is already defined.", nexttoken, t);
1868 }
1869 }
1870 }
1871
1872 funct[t] = type;
1873
1874 if (token) {
1875 funct["(tokens)"][t] = token;
1876 }
1877
1878 if (funct["(global)"]) {
1879 global[t] = funct;
1880 if (is_own(implied, t)) {
1881 if (option.latedef)
1882 warning("'{a}' was used before it was defined.", nexttoken, t);
1883 delete implied[t];
1884 }
1885 } else {
1886 scope[t] = funct;
1887 }
1888 }
1889
1890
1891 function doOption() {
1892 var nt = nexttoken;
1893 var o = nt.value;
1894 var quotmarkValue = option.quotmark;
1895 var predef = {};
1896 var b, obj, filter, t, tn, v, minus;
1897
1898 switch (o) {
1899 case "*/":
1900 error("Unbegun comment.");
1901 break;
1902 case "/*members":
1903 case "/*member":
1904 o = "/*members";
1905 if (!membersOnly) {
1906 membersOnly = {};
1907 }
1908 obj = membersOnly;
1909 option.quotmark = false;
1910 break;
1911 case "/*jshint":
1912 case "/*jslint":
1913 obj = option;
1914 filter = boolOptions;
1915 break;
1916 case "/*global":
1917 obj = predef;
1918 break;
1919 default:
1920 error("What?");
1921 }
1922
1923 t = lex.token();
1924
1925 loop:
1926 for (;;) {
1927 minus = false;
1928 for (;;) {
1929 if (t.type === "special" && t.value === "*/") {
1930 break loop;
1931 }
1932 if (t.id !== "(endline)" && t.id !== ",") {
1933 break;
1934 }
1935 t = lex.token();
1936 }
1937
1938 if (o === "/*global" && t.value === "-") {
1939 minus = true;
1940 t = lex.token();
1941 }
1942
1943 if (t.type !== "(string)" && t.type !== "(identifier)" && o !== "/*members") {
1944 error("Bad option.", t);
1945 }
1946
1947 v = lex.token();
1948 if (v.id === ":") {
1949 v = lex.token();
1950
1951 if (obj === membersOnly) {
1952 error("Expected '{a}' and instead saw '{b}'.", t, "*/", ":");
1953 }
1954
1955 if (o === "/*jshint") {
1956 checkOption(t.value, t);
1957 }
1958
1959 var numericVals = [
1960 "maxstatements",
1961 "maxparams",
1962 "maxdepth",
1963 "maxcomplexity",
1964 "maxerr",
1965 "maxlen",
1966 "indent"
1967 ];
1968
1969 if (numericVals.indexOf(t.value) > -1 && (o === "/*jshint" || o === "/*jslint")) {
1970 b = +v.value;
1971
1972 if (typeof b !== "number" || !isFinite(b) || b <= 0 || Math.floor(b) !== b) {
1973 error("Expected a small integer and instead saw '{a}'.", v, v.value);
1974 }
1975
1976 if (t.value === "indent")
1977 obj.white = true;
1978
1979 obj[t.value] = b;
1980 } else if (t.value === "validthis") {
1981 if (funct["(global)"]) {
1982 error("Option 'validthis' can't be used in a global scope.");
1983 } else {
1984 if (v.value === "true" || v.value === "false")
1985 obj[t.value] = v.value === "true";
1986 else
1987 error("Bad option value.", v);
1988 }
1989 } else if (t.value === "quotmark" && (o === "/*jshint")) {
1990 switch (v.value) {
1991 case "true":
1992 obj.quotmark = true;
1993 break;
1994 case "false":
1995 obj.quotmark = false;
1996 break;
1997 case "double":
1998 case "single":
1999 obj.quotmark = v.value;
2000 break;
2001 default:
2002 error("Bad option value.", v);
2003 }
2004 } else if (v.value === "true" || v.value === "false") {
2005 if (o === "/*jslint") {
2006 tn = renamedOptions[t.value] || t.value;
2007 obj[tn] = v.value === "true";
2008 if (invertedOptions[tn] !== undefined) {
2009 obj[tn] = !obj[tn];
2010 }
2011 } else {
2012 obj[t.value] = v.value === "true";
2013 }
2014
2015 if (t.value === "newcap")
2016 obj["(explicitNewcap)"] = true;
2017 } else {
2018 error("Bad option value.", v);
2019 }
2020 t = lex.token();
2021 } else {
2022 if (o === "/*jshint" || o === "/*jslint") {
2023 error("Missing option value.", t);
2024 }
2025
2026 obj[t.value] = false;
2027
2028 if (o === "/*global" && minus === true) {
2029 JSHINT.blacklist[t.value] = t.value;
2030 updatePredefined();
2031 }
2032
2033 t = v;
2034 }
2035 }
2036
2037 if (o === "/*members") {
2038 option.quotmark = quotmarkValue;
2039 }
2040
2041 combine(predefined, predef);
2042
2043 for (var key in predef) {
2044 if (is_own(predef, key)) {
2045 declared[key] = nt;
2046 }
2047 }
2048
2049 if (filter) {
2050 assume();
2051 }
2052 }
2053
2054
2055 // We need a peek function. If it has an argument, it peeks that much farther
2056 // ahead. It is used to distinguish
2057 // for ( var i in ...
2058 // from
2059 // for ( var i = ...
2060
2061 function peek(p) {
2062 var i = p || 0, j = 0, t;
2063
2064 while (j <= i) {
2065 t = lookahead[j];
2066 if (!t) {
2067 t = lookahead[j] = lex.token();
2068 }
2069 j += 1;
2070 }
2071 return t;
2072 }
2073
2074
2075
2076 // Produce the next token. It looks for programming errors.
2077
2078 function advance(id, t) {
2079 switch (token.id) {
2080 case "(number)":
2081 if (nexttoken.id === ".") {
2082 warning("A dot following a number can be confused with a decimal point.", token);
2083 }
2084 break;
2085 case "-":
2086 if (nexttoken.id === "-" || nexttoken.id === "--") {
2087 warning("Confusing minusses.");
2088 }
2089 break;
2090 case "+":
2091 if (nexttoken.id === "+" || nexttoken.id === "++") {
2092 warning("Confusing plusses.");
2093 }
2094 break;
2095 }
2096
2097 if (token.type === "(string)" || token.identifier) {
2098 anonname = token.value;
2099 }
2100
2101 if (id && nexttoken.id !== id) {
2102 if (t) {
2103 if (nexttoken.id === "(end)") {
2104 warning("Unmatched '{a}'.", t, t.id);
2105 } else {
2106 warning("Expected '{a}' to match '{b}' from line {c} and instead saw '{d}'.",
2107 nexttoken, id, t.id, t.line, nexttoken.value);
2108 }
2109 } else if (nexttoken.type !== "(identifier)" ||
2110 nexttoken.value !== id) {
2111 warning("Expected '{a}' and instead saw '{b}'.",
2112 nexttoken, id, nexttoken.value);
2113 }
2114 }
2115
2116 prevtoken = token;
2117 token = nexttoken;
2118 for (;;) {
2119 nexttoken = lookahead.shift() || lex.token();
2120 if (nexttoken.id === "(end)" || nexttoken.id === "(error)") {
2121 return;
2122 }
2123 if (nexttoken.type === "special") {
2124 doOption();
2125 } else {
2126 if (nexttoken.id !== "(endline)") {
2127 break;
2128 }
2129 }
2130 }
2131 }
2132
2133
2134 // This is the heart of JSHINT, the Pratt parser. In addition to parsing, it
2135 // is looking for ad hoc lint patterns. We add .fud to Pratt's model, which is
2136 // like .nud except that it is only used on the first token of a statement.
2137 // Having .fud makes it much easier to define statement-oriented languages like
2138 // JavaScript. I retained Pratt's nomenclature.
2139
2140 // .nud Null denotation
2141 // .fud First null denotation
2142 // .led Left denotation
2143 // lbp Left binding power
2144 // rbp Right binding power
2145
2146 // They are elements of the parsing method called Top Down Operator Precedence.
2147
2148 function expression(rbp, initial) {
2149 var left, isArray = false, isObject = false;
2150
2151 if (nexttoken.id === "(end)")
2152 error("Unexpected early end of program.", token);
2153
2154 advance();
2155 if (initial) {
2156 anonname = "anonymous";
2157 funct["(verb)"] = token.value;
2158 }
2159 if (initial === true && token.fud) {
2160 left = token.fud();
2161 } else {
2162 if (token.nud) {
2163 left = token.nud();
2164 } else {
2165 if (nexttoken.type === "(number)" && token.id === ".") {
2166 warning("A leading decimal point can be confused with a dot: '.{a}'.",
2167 token, nexttoken.value);
2168 advance();
2169 return token;
2170 } else {
2171 error("Expected an identifier and instead saw '{a}'.",
2172 token, token.id);
2173 }
2174 }
2175 while (rbp < nexttoken.lbp) {
2176 isArray = token.value === "Array";
2177 isObject = token.value === "Object";
2178
2179 // #527, new Foo.Array(), Foo.Array(), new Foo.Object(), Foo.Object()
2180 // Line breaks in IfStatement heads exist to satisfy the checkJSHint
2181 // "Line too long." error.
2182 if (left && (left.value || (left.first && left.first.value))) {
2183 // If the left.value is not "new", or the left.first.value is a "."
2184 // then safely assume that this is not "new Array()" and possibly
2185 // not "new Object()"...
2186 if (left.value !== "new" ||
2187 (left.first && left.first.value && left.first.value === ".")) {
2188 isArray = false;
2189 // ...In the case of Object, if the left.value and token.value
2190 // are not equal, then safely assume that this not "new Object()"
2191 if (left.value !== token.value) {
2192 isObject = false;
2193 }
2194 }
2195 }
2196
2197 advance();
2198 if (isArray && token.id === "(" && nexttoken.id === ")")
2199 warning("Use the array literal notation [].", token);
2200 if (isObject && token.id === "(" && nexttoken.id === ")")
2201 warning("Use the object literal notation {}.", token);
2202 if (token.led) {
2203 left = token.led(left);
2204 } else {
2205 error("Expected an operator and instead saw '{a}'.",
2206 token, token.id);
2207 }
2208 }
2209 }
2210 return left;
2211 }
2212
2213
2214 // Functions for conformance of style.
2215
2216 function adjacent(left, right) {
2217 left = left || token;
2218 right = right || nexttoken;
2219 if (option.white) {
2220 if (left.character !== right.from && left.line === right.line) {
2221 left.from += (left.character - left.from);
2222 warning("Unexpected space after '{a}'.", left, left.value);
2223 }
2224 }
2225 }
2226
2227 function nobreak(left, right) {
2228 left = left || token;
2229 right = right || nexttoken;
2230 if (option.white && (left.character !== right.from || left.line !== right.line)) {
2231 warning("Unexpected space before '{a}'.", right, right.value);
2232 }
2233 }
2234
2235 function nospace(left, right) {
2236 left = left || token;
2237 right = right || nexttoken;
2238 if (option.white && !left.comment) {
2239 if (left.line === right.line) {
2240 adjacent(left, right);
2241 }
2242 }
2243 }
2244
2245 function nonadjacent(left, right) {
2246 if (option.white) {
2247 left = left || token;
2248 right = right || nexttoken;
2249 if (left.value === ";" && right.value === ";") {
2250 return;
2251 }
2252 if (left.line === right.line && left.character === right.from) {
2253 left.from += (left.character - left.from);
2254 warning("Missing space after '{a}'.",
2255 left, left.value);
2256 }
2257 }
2258 }
2259
2260 function nobreaknonadjacent(left, right) {
2261 left = left || token;
2262 right = right || nexttoken;
2263 if (!option.laxbreak && left.line !== right.line) {
2264 warning("Bad line breaking before '{a}'.", right, right.id);
2265 } else if (option.white) {
2266 left = left || token;
2267 right = right || nexttoken;
2268 if (left.character === right.from) {
2269 left.from += (left.character - left.from);
2270 warning("Missing space after '{a}'.",
2271 left, left.value);
2272 }
2273 }
2274 }
2275
2276 function indentation(bias) {
2277 var i;
2278 if (option.white && nexttoken.id !== "(end)") {
2279 i = indent + (bias || 0);
2280 if (nexttoken.from !== i) {
2281 warning(
2282 "Expected '{a}' to have an indentation at {b} instead at {c}.",
2283 nexttoken, nexttoken.value, i, nexttoken.from);
2284 }
2285 }
2286 }
2287
2288 function nolinebreak(t) {
2289 t = t || token;
2290 if (t.line !== nexttoken.line) {
2291 warning("Line breaking error '{a}'.", t, t.value);
2292 }
2293 }
2294
2295
2296 function comma() {
2297 if (token.line !== nexttoken.line) {
2298 if (!option.laxcomma) {
2299 if (comma.first) {
2300 warning("Comma warnings can be turned off with 'laxcomma'");
2301 comma.first = false;
2302 }
2303 warning("Bad line breaking before '{a}'.", token, nexttoken.id);
2304 }
2305 } else if (!token.comment && token.character !== nexttoken.from && option.white) {
2306 token.from += (token.character - token.from);
2307 warning("Unexpected space after '{a}'.", token, token.value);
2308 }
2309 advance(",");
2310 nonadjacent(token, nexttoken);
2311 }
2312
2313
2314 // Functional constructors for making the symbols that will be inherited by
2315 // tokens.
2316
2317 function symbol(s, p) {
2318 var x = syntax[s];
2319 if (!x || typeof x !== "object") {
2320 syntax[s] = x = {
2321 id: s,
2322 lbp: p,
2323 value: s
2324 };
2325 }
2326 return x;
2327 }
2328
2329
2330 function delim(s) {
2331 return symbol(s, 0);
2332 }
2333
2334
2335 function stmt(s, f) {
2336 var x = delim(s);
2337 x.identifier = x.reserved = true;
2338 x.fud = f;
2339 return x;
2340 }
2341
2342
2343 function blockstmt(s, f) {
2344 var x = stmt(s, f);
2345 x.block = true;
2346 return x;
2347 }
2348
2349
2350 function reserveName(x) {
2351 var c = x.id.charAt(0);
2352 if ((c >= "a" && c <= "z") || (c >= "A" && c <= "Z")) {
2353 x.identifier = x.reserved = true;
2354 }
2355 return x;
2356 }
2357
2358
2359 function prefix(s, f) {
2360 var x = symbol(s, 150);
2361 reserveName(x);
2362 x.nud = (typeof f === "function") ? f : function () {
2363 this.right = expression(150);
2364 this.arity = "unary";
2365 if (this.id === "++" || this.id === "--") {
2366 if (option.plusplus) {
2367 warning("Unexpected use of '{a}'.", this, this.id);
2368 } else if ((!this.right.identifier || this.right.reserved) &&
2369 this.right.id !== "." && this.right.id !== "[") {
2370 warning("Bad operand.", this);
2371 }
2372 }
2373 return this;
2374 };
2375 return x;
2376 }
2377
2378
2379 function type(s, f) {
2380 var x = delim(s);
2381 x.type = s;
2382 x.nud = f;
2383 return x;
2384 }
2385
2386
2387 function reserve(s, f) {
2388 var x = type(s, f);
2389 x.identifier = x.reserved = true;
2390 return x;
2391 }
2392
2393
2394 function reservevar(s, v) {
2395 return reserve(s, function () {
2396 if (typeof v === "function") {
2397 v(this);
2398 }
2399 return this;
2400 });
2401 }
2402
2403
2404 function infix(s, f, p, w) {
2405 var x = symbol(s, p);
2406 reserveName(x);
2407 x.led = function (left) {
2408 if (!w) {
2409 nobreaknonadjacent(prevtoken, token);
2410 nonadjacent(token, nexttoken);
2411 }
2412 if (s === "in" && left.id === "!") {
2413 warning("Confusing use of '{a}'.", left, "!");
2414 }
2415 if (typeof f === "function") {
2416 return f(left, this);
2417 } else {
2418 this.left = left;
2419 this.right = expression(p);
2420 return this;
2421 }
2422 };
2423 return x;
2424 }
2425
2426
2427 function relation(s, f) {
2428 var x = symbol(s, 100);
2429 x.led = function (left) {
2430 nobreaknonadjacent(prevtoken, token);
2431 nonadjacent(token, nexttoken);
2432 var right = expression(100);
2433
2434 if (isIdentifier(left, "NaN") || isIdentifier(right, "NaN")) {
2435 warning("Use the isNaN function to compare with NaN.", this);
2436 } else if (f) {
2437 f.apply(this, [left, right]);
2438 }
2439 if (left.id === "!") {
2440 warning("Confusing use of '{a}'.", left, "!");
2441 }
2442 if (right.id === "!") {
2443 warning("Confusing use of '{a}'.", right, "!");
2444 }
2445 this.left = left;
2446 this.right = right;
2447 return this;
2448 };
2449 return x;
2450 }
2451
2452
2453 function isPoorRelation(node) {
2454 return node &&
2455 ((node.type === "(number)" && +node.value === 0) ||
2456 (node.type === "(string)" && node.value === "") ||
2457 (node.type === "null" && !option.eqnull) ||
2458 node.type === "true" ||
2459 node.type === "false" ||
2460 node.type === "undefined");
2461 }
2462
2463
2464 function assignop(s) {
2465 symbol(s, 20).exps = true;
2466
2467 return infix(s, function (left, that) {
2468 that.left = left;
2469
2470 if (predefined[left.value] === false &&
2471 scope[left.value]["(global)"] === true) {
2472 warning("Read only.", left);
2473 } else if (left["function"]) {
2474 warning("'{a}' is a function.", left, left.value);
2475 }
2476
2477 if (left) {
2478 if (option.esnext && funct[left.value] === "const") {
2479 warning("Attempting to override '{a}' which is a constant", left, left.value);
2480 }
2481
2482 if (left.id === "." || left.id === "[") {
2483 if (!left.left || left.left.value === "arguments") {
2484 warning("Bad assignment.", that);
2485 }
2486 that.right = expression(19);
2487 return that;
2488 } else if (left.identifier && !left.reserved) {
2489 if (funct[left.value] === "exception") {
2490 warning("Do not assign to the exception parameter.", left);
2491 }
2492 that.right = expression(19);
2493 return that;
2494 }
2495
2496 if (left === syntax["function"]) {
2497 warning(
2498 "Expected an identifier in an assignment and instead saw a function invocation.",
2499 token);
2500 }
2501 }
2502
2503 error("Bad assignment.", that);
2504 }, 20);
2505 }
2506
2507
2508 function bitwise(s, f, p) {
2509 var x = symbol(s, p);
2510 reserveName(x);
2511 x.led = (typeof f === "function") ? f : function (left) {
2512 if (option.bitwise) {
2513 warning("Unexpected use of '{a}'.", this, this.id);
2514 }
2515 this.left = left;
2516 this.right = expression(p);
2517 return this;
2518 };
2519 return x;
2520 }
2521
2522
2523 function bitwiseassignop(s) {
2524 symbol(s, 20).exps = true;
2525 return infix(s, function (left, that) {
2526 if (option.bitwise) {
2527 warning("Unexpected use of '{a}'.", that, that.id);
2528 }
2529 nonadjacent(prevtoken, token);
2530 nonadjacent(token, nexttoken);
2531 if (left) {
2532 if (left.id === "." || left.id === "[" ||
2533 (left.identifier && !left.reserved)) {
2534 expression(19);
2535 return that;
2536 }
2537 if (left === syntax["function"]) {
2538 warning(
2539 "Expected an identifier in an assignment, and instead saw a function invocation.",
2540 token);
2541 }
2542 return that;
2543 }
2544 error("Bad assignment.", that);
2545 }, 20);
2546 }
2547
2548
2549 function suffix(s) {
2550 var x = symbol(s, 150);
2551 x.led = function (left) {
2552 if (option.plusplus) {
2553 warning("Unexpected use of '{a}'.", this, this.id);
2554 } else if ((!left.identifier || left.reserved) &&
2555 left.id !== "." && left.id !== "[") {
2556 warning("Bad operand.", this);
2557 }
2558 this.left = left;
2559 return this;
2560 };
2561 return x;
2562 }
2563
2564
2565 // fnparam means that this identifier is being defined as a function
2566 // argument (see identifier())
2567 function optionalidentifier(fnparam) {
2568 if (nexttoken.identifier) {
2569 advance();
2570 if (token.reserved && !option.es5) {
2571 // `undefined` as a function param is a common pattern to protect
2572 // against the case when somebody does `undefined = true` and
2573 // help with minification. More info: https://gist.github.com/315916
2574 if (!fnparam || token.value !== "undefined") {
2575 warning("Expected an identifier and instead saw '{a}' (a reserved word).",
2576 token, token.id);
2577 }
2578 }
2579 return token.value;
2580 }
2581 }
2582
2583 // fnparam means that this identifier is being defined as a function
2584 // argument
2585 function identifier(fnparam) {
2586 var i = optionalidentifier(fnparam);
2587 if (i) {
2588 return i;
2589 }
2590 if (token.id === "function" && nexttoken.id === "(") {
2591 warning("Missing name in function declaration.");
2592 } else {
2593 error("Expected an identifier and instead saw '{a}'.",
2594 nexttoken, nexttoken.value);
2595 }
2596 }
2597
2598
2599 function reachable(s) {
2600 var i = 0, t;
2601 if (nexttoken.id !== ";" || noreach) {
2602 return;
2603 }
2604 for (;;) {
2605 t = peek(i);
2606 if (t.reach) {
2607 return;
2608 }
2609 if (t.id !== "(endline)") {
2610 if (t.id === "function") {
2611 if (!option.latedef) {
2612 break;
2613 }
2614 warning(
2615 "Inner functions should be listed at the top of the outer function.", t);
2616 break;
2617 }
2618 warning("Unreachable '{a}' after '{b}'.", t, t.value, s);
2619 break;
2620 }
2621 i += 1;
2622 }
2623 }
2624
2625
2626 function statement(noindent) {
2627 var i = indent, r, s = scope, t = nexttoken;
2628
2629 if (t.id === ";") {
2630 advance(";");
2631 return;
2632 }
2633
2634 // Is this a labelled statement?
2635
2636 if (t.identifier && !t.reserved && peek().id === ":") {
2637 advance();
2638 advance(":");
2639 scope = Object.create(s);
2640 addlabel(t.value, "label");
2641
2642 if (!nexttoken.labelled && nexttoken.value !== "{") {
2643 warning("Label '{a}' on {b} statement.", nexttoken, t.value, nexttoken.value);
2644 }
2645
2646 if (jx.test(t.value + ":")) {
2647 warning("Label '{a}' looks like a javascript url.", t, t.value);
2648 }
2649
2650 nexttoken.label = t.value;
2651 t = nexttoken;
2652 }
2653
2654 // Is it a lonely block?
2655
2656 if (t.id === "{") {
2657 block(true, true);
2658 return;
2659 }
2660
2661 // Parse the statement.
2662
2663 if (!noindent) {
2664 indentation();
2665 }
2666 r = expression(0, true);
2667
2668 // Look for the final semicolon.
2669
2670 if (!t.block) {
2671 if (!option.expr && (!r || !r.exps)) {
2672 warning("Expected an assignment or function call and instead saw an expression.",
2673 token);
2674 } else if (option.nonew && r.id === "(" && r.left.id === "new") {
2675 warning("Do not use 'new' for side effects.", t);
2676 }
2677
2678 if (nexttoken.id === ",") {
2679 return comma();
2680 }
2681
2682 if (nexttoken.id !== ";") {
2683 if (!option.asi) {
2684 // If this is the last statement in a block that ends on
2685 // the same line *and* option lastsemic is on, ignore the warning.
2686 // Otherwise, complain about missing semicolon.
2687 if (!option.lastsemic || nexttoken.id !== "}" ||
2688 nexttoken.line !== token.line) {
2689 warningAt("Missing semicolon.", token.line, token.character);
2690 }
2691 }
2692 } else {
2693 adjacent(token, nexttoken);
2694 advance(";");
2695 nonadjacent(token, nexttoken);
2696 }
2697 }
2698
2699 // Restore the indentation.
2700
2701 indent = i;
2702 scope = s;
2703 return r;
2704 }
2705
2706
2707 function statements(startLine) {
2708 var a = [], p;
2709
2710 while (!nexttoken.reach && nexttoken.id !== "(end)") {
2711 if (nexttoken.id === ";") {
2712 p = peek();
2713 if (!p || p.id !== "(") {
2714 warning("Unnecessary semicolon.");
2715 }
2716 advance(";");
2717 } else {
2718 a.push(statement(startLine === nexttoken.line));
2719 }
2720 }
2721 return a;
2722 }
2723
2724
2725 /*
2726 * read all directives
2727 * recognizes a simple form of asi, but always
2728 * warns, if it is used
2729 */
2730 function directives() {
2731 var i, p, pn;
2732
2733 for (;;) {
2734 if (nexttoken.id === "(string)") {
2735 p = peek(0);
2736 if (p.id === "(endline)") {
2737 i = 1;
2738 do {
2739 pn = peek(i);
2740 i = i + 1;
2741 } while (pn.id === "(endline)");
2742
2743 if (pn.id !== ";") {
2744 if (pn.id !== "(string)" && pn.id !== "(number)" &&
2745 pn.id !== "(regexp)" && pn.identifier !== true &&
2746 pn.id !== "}") {
2747 break;
2748 }
2749 warning("Missing semicolon.", nexttoken);
2750 } else {
2751 p = pn;
2752 }
2753 } else if (p.id === "}") {
2754 // directive with no other statements, warn about missing semicolon
2755 warning("Missing semicolon.", p);
2756 } else if (p.id !== ";") {
2757 break;
2758 }
2759
2760 indentation();
2761 advance();
2762 if (directive[token.value]) {
2763 warning("Unnecessary directive \"{a}\".", token, token.value);
2764 }
2765
2766 if (token.value === "use strict") {
2767 if (!option["(explicitNewcap)"])
2768 option.newcap = true;
2769 option.undef = true;
2770 }
2771
2772 // there's no directive negation, so always set to true
2773 directive[token.value] = true;
2774
2775 if (p.id === ";") {
2776 advance(";");
2777 }
2778 continue;
2779 }
2780 break;
2781 }
2782 }
2783
2784
2785 /*
2786 * Parses a single block. A block is a sequence of statements wrapped in
2787 * braces.
2788 *
2789 * ordinary - true for everything but function bodies and try blocks.
2790 * stmt - true if block can be a single statement (e.g. in if/for/while).
2791 * isfunc - true if block is a function body
2792 */
2793 function block(ordinary, stmt, isfunc) {
2794 var a,
2795 b = inblock,
2796 old_indent = indent,
2797 m,
2798 s = scope,
2799 t,
2800 line,
2801 d;
2802
2803 inblock = ordinary;
2804
2805 if (!ordinary || !option.funcscope)
2806 scope = Object.create(scope);
2807
2808 nonadjacent(token, nexttoken);
2809 t = nexttoken;
2810
2811 var metrics = funct["(metrics)"];
2812 metrics.nestedBlockDepth += 1;
2813 metrics.verifyMaxNestedBlockDepthPerFunction();
2814
2815 if (nexttoken.id === "{") {
2816 advance("{");
2817 line = token.line;
2818 if (nexttoken.id !== "}") {
2819 indent += option.indent;
2820 while (!ordinary && nexttoken.from > indent) {
2821 indent += option.indent;
2822 }
2823
2824 if (isfunc) {
2825 m = {};
2826 for (d in directive) {
2827 if (is_own(directive, d)) {
2828 m[d] = directive[d];
2829 }
2830 }
2831 directives();
2832
2833 if (option.strict && funct["(context)"]["(global)"]) {
2834 if (!m["use strict"] && !directive["use strict"]) {
2835 warning("Missing \"use strict\" statement.");
2836 }
2837 }
2838 }
2839
2840 a = statements(line);
2841
2842 metrics.statementCount += a.length;
2843
2844 if (isfunc) {
2845 directive = m;
2846 }
2847
2848 indent -= option.indent;
2849 if (line !== nexttoken.line) {
2850 indentation();
2851 }
2852 } else if (line !== nexttoken.line) {
2853 indentation();
2854 }
2855 advance("}", t);
2856 indent = old_indent;
2857 } else if (!ordinary) {
2858 error("Expected '{a}' and instead saw '{b}'.",
2859 nexttoken, "{", nexttoken.value);
2860 } else {
2861 if (!stmt || option.curly)
2862 warning("Expected '{a}' and instead saw '{b}'.",
2863 nexttoken, "{", nexttoken.value);
2864
2865 noreach = true;
2866 indent += option.indent;
2867 // test indentation only if statement is in new line
2868 a = [statement(nexttoken.line === token.line)];
2869 indent -= option.indent;
2870 noreach = false;
2871 }
2872 funct["(verb)"] = null;
2873 if (!ordinary || !option.funcscope) scope = s;
2874 inblock = b;
2875 if (ordinary && option.noempty && (!a || a.length === 0)) {
2876 warning("Empty block.");
2877 }
2878 metrics.nestedBlockDepth -= 1;
2879 return a;
2880 }
2881
2882
2883 function countMember(m) {
2884 if (membersOnly && typeof membersOnly[m] !== "boolean") {
2885 warning("Unexpected /*member '{a}'.", token, m);
2886 }
2887 if (typeof member[m] === "number") {
2888 member[m] += 1;
2889 } else {
2890 member[m] = 1;
2891 }
2892 }
2893
2894
2895 function note_implied(token) {
2896 var name = token.value, line = token.line, a = implied[name];
2897 if (typeof a === "function") {
2898 a = false;
2899 }
2900
2901 if (!a) {
2902 a = [line];
2903 implied[name] = a;
2904 } else if (a[a.length - 1] !== line) {
2905 a.push(line);
2906 }
2907 }
2908
2909
2910 // Build the syntax table by declaring the syntactic elements of the language.
2911
2912 type("(number)", function () {
2913 return this;
2914 });
2915
2916 type("(string)", function () {
2917 return this;
2918 });
2919
2920 syntax["(identifier)"] = {
2921 type: "(identifier)",
2922 lbp: 0,
2923 identifier: true,
2924 nud: function () {
2925 var v = this.value,
2926 s = scope[v],
2927 f;
2928
2929 if (typeof s === "function") {
2930 // Protection against accidental inheritance.
2931 s = undefined;
2932 } else if (typeof s === "boolean") {
2933 f = funct;
2934 funct = functions[0];
2935 addlabel(v, "var");
2936 s = funct;
2937 funct = f;
2938 }
2939
2940 // The name is in scope and defined in the current function.
2941 if (funct === s) {
2942 // Change 'unused' to 'var', and reject labels.
2943 switch (funct[v]) {
2944 case "unused":
2945 funct[v] = "var";
2946 break;
2947 case "unction":
2948 funct[v] = "function";
2949 this["function"] = true;
2950 break;
2951 case "function":
2952 this["function"] = true;
2953 break;
2954 case "label":
2955 warning("'{a}' is a statement label.", token, v);
2956 break;
2957 }
2958 } else if (funct["(global)"]) {
2959 // The name is not defined in the function. If we are in the global
2960 // scope, then we have an undefined variable.
2961 //
2962 // Operators typeof and delete do not raise runtime errors even if
2963 // the base object of a reference is null so no need to display warning
2964 // if we're inside of typeof or delete.
2965
2966 if (option.undef && typeof predefined[v] !== "boolean") {
2967 // Attempting to subscript a null reference will throw an
2968 // error, even within the typeof and delete operators
2969 if (!(anonname === "typeof" || anonname === "delete") ||
2970 (nexttoken && (nexttoken.value === "." || nexttoken.value === "["))) {
2971
2972 isundef(funct, "'{a}' is not defined.", token, v);
2973 }
2974 }
2975
2976 note_implied(token);
2977 } else {
2978 // If the name is already defined in the current
2979 // function, but not as outer, then there is a scope error.
2980
2981 switch (funct[v]) {
2982 case "closure":
2983 case "function":
2984 case "var":
2985 case "unused":
2986 warning("'{a}' used out of scope.", token, v);
2987 break;
2988 case "label":
2989 warning("'{a}' is a statement label.", token, v);
2990 break;
2991 case "outer":
2992 case "global":
2993 break;
2994 default:
2995 // If the name is defined in an outer function, make an outer entry,
2996 // and if it was unused, make it var.
2997 if (s === true) {
2998 funct[v] = true;
2999 } else if (s === null) {
3000 warning("'{a}' is not allowed.", token, v);
3001 note_implied(token);
3002 } else if (typeof s !== "object") {
3003 // Operators typeof and delete do not raise runtime errors even
3004 // if the base object of a reference is null so no need to
3005 // display warning if we're inside of typeof or delete.
3006 if (option.undef) {
3007 // Attempting to subscript a null reference will throw an
3008 // error, even within the typeof and delete operators
3009 if (!(anonname === "typeof" || anonname === "delete") ||
3010 (nexttoken &&
3011 (nexttoken.value === "." || nexttoken.value === "["))) {
3012
3013 isundef(funct, "'{a}' is not defined.", token, v);
3014 }
3015 }
3016 funct[v] = true;
3017 note_implied(token);
3018 } else {
3019 switch (s[v]) {
3020 case "function":
3021 case "unction":
3022 this["function"] = true;
3023 s[v] = "closure";
3024 funct[v] = s["(global)"] ? "global" : "outer";
3025 break;
3026 case "var":
3027 case "unused":
3028 s[v] = "closure";
3029 funct[v] = s["(global)"] ? "global" : "outer";
3030 break;
3031 case "closure":
3032 funct[v] = s["(global)"] ? "global" : "outer";
3033 break;
3034 case "label":
3035 warning("'{a}' is a statement label.", token, v);
3036 }
3037 }
3038 }
3039 }
3040 return this;
3041 },
3042 led: function () {
3043 error("Expected an operator and instead saw '{a}'.",
3044 nexttoken, nexttoken.value);
3045 }
3046 };
3047
3048 type("(regexp)", function () {
3049 return this;
3050 });
3051
3052
3053 // ECMAScript parser
3054
3055 delim("(endline)");
3056 delim("(begin)");
3057 delim("(end)").reach = true;
3058 delim("</").reach = true;
3059 delim("<!");
3060 delim("<!--");
3061 delim("-->");
3062 delim("(error)").reach = true;
3063 delim("}").reach = true;
3064 delim(")");
3065 delim("]");
3066 delim("\"").reach = true;
3067 delim("'").reach = true;
3068 delim(";");
3069 delim(":").reach = true;
3070 delim(",");
3071 delim("#");
3072 delim("@");
3073 reserve("else");
3074 reserve("case").reach = true;
3075 reserve("catch");
3076 reserve("default").reach = true;
3077 reserve("finally");
3078 reservevar("arguments", function (x) {
3079 if (directive["use strict"] && funct["(global)"]) {
3080 warning("Strict violation.", x);
3081 }
3082 });
3083 reservevar("eval");
3084 reservevar("false");
3085 reservevar("Infinity");
3086 reservevar("null");
3087 reservevar("this", function (x) {
3088 if (directive["use strict"] && !option.validthis && ((funct["(statement)"] &&
3089 funct["(name)"].charAt(0) > "Z") || funct["(global)"])) {
3090 warning("Possible strict violation.", x);
3091 }
3092 });
3093 reservevar("true");
3094 reservevar("undefined");
3095 assignop("=", "assign", 20);
3096 assignop("+=", "assignadd", 20);
3097 assignop("-=", "assignsub", 20);
3098 assignop("*=", "assignmult", 20);
3099 assignop("/=", "assigndiv", 20).nud = function () {
3100 error("A regular expression literal can be confused with '/='.");
3101 };
3102 assignop("%=", "assignmod", 20);
3103 bitwiseassignop("&=", "assignbitand", 20);
3104 bitwiseassignop("|=", "assignbitor", 20);
3105 bitwiseassignop("^=", "assignbitxor", 20);
3106 bitwiseassignop("<<=", "assignshiftleft", 20);
3107 bitwiseassignop(">>=", "assignshiftright", 20);
3108 bitwiseassignop(">>>=", "assignshiftrightunsigned", 20);
3109 infix("?", function (left, that) {
3110 that.left = left;
3111 that.right = expression(10);
3112 advance(":");
3113 that["else"] = expression(10);
3114 return that;
3115 }, 30);
3116
3117 infix("||", "or", 40);
3118 infix("&&", "and", 50);
3119 bitwise("|", "bitor", 70);
3120 bitwise("^", "bitxor", 80);
3121 bitwise("&", "bitand", 90);
3122 relation("==", function (left, right) {
3123 var eqnull = option.eqnull && (left.value === "null" || right.value === "null");
3124
3125 if (!eqnull && option.eqeqeq)
3126 warning("Expected '{a}' and instead saw '{b}'.", this, "===", "==");
3127 else if (isPoorRelation(left))
3128 warning("Use '{a}' to compare with '{b}'.", this, "===", left.value);
3129 else if (isPoorRelation(right))
3130 warning("Use '{a}' to compare with '{b}'.", this, "===", right.value);
3131
3132 return this;
3133 });
3134 relation("===");
3135 relation("!=", function (left, right) {
3136 var eqnull = option.eqnull &&
3137 (left.value === "null" || right.value === "null");
3138
3139 if (!eqnull && option.eqeqeq) {
3140 warning("Expected '{a}' and instead saw '{b}'.",
3141 this, "!==", "!=");
3142 } else if (isPoorRelation(left)) {
3143 warning("Use '{a}' to compare with '{b}'.",
3144 this, "!==", left.value);
3145 } else if (isPoorRelation(right)) {
3146 warning("Use '{a}' to compare with '{b}'.",
3147 this, "!==", right.value);
3148 }
3149 return this;
3150 });
3151 relation("!==");
3152 relation("<");
3153 relation(">");
3154 relation("<=");
3155 relation(">=");
3156 bitwise("<<", "shiftleft", 120);
3157 bitwise(">>", "shiftright", 120);
3158 bitwise(">>>", "shiftrightunsigned", 120);
3159 infix("in", "in", 120);
3160 infix("instanceof", "instanceof", 120);
3161 infix("+", function (left, that) {
3162 var right = expression(130);
3163 if (left && right && left.id === "(string)" && right.id === "(string)") {
3164 left.value += right.value;
3165 left.character = right.character;
3166 if (!option.scripturl && jx.test(left.value)) {
3167 warning("JavaScript URL.", left);
3168 }
3169 return left;
3170 }
3171 that.left = left;
3172 that.right = right;
3173 return that;
3174 }, 130);
3175 prefix("+", "num");
3176 prefix("+++", function () {
3177 warning("Confusing pluses.");
3178 this.right = expression(150);
3179 this.arity = "unary";
3180 return this;
3181 });
3182 infix("+++", function (left) {
3183 warning("Confusing pluses.");
3184 this.left = left;
3185 this.right = expression(130);
3186 return this;
3187 }, 130);
3188 infix("-", "sub", 130);
3189 prefix("-", "neg");
3190 prefix("---", function () {
3191 warning("Confusing minuses.");
3192 this.right = expression(150);
3193 this.arity = "unary";
3194 return this;
3195 });
3196 infix("---", function (left) {
3197 warning("Confusing minuses.");
3198 this.left = left;
3199 this.right = expression(130);
3200 return this;
3201 }, 130);
3202 infix("*", "mult", 140);
3203 infix("/", "div", 140);
3204 infix("%", "mod", 140);
3205
3206 suffix("++", "postinc");
3207 prefix("++", "preinc");
3208 syntax["++"].exps = true;
3209
3210 suffix("--", "postdec");
3211 prefix("--", "predec");
3212 syntax["--"].exps = true;
3213 prefix("delete", function () {
3214 var p = expression(0);
3215 if (!p || (p.id !== "." && p.id !== "[")) {
3216 warning("Variables should not be deleted.");
3217 }
3218 this.first = p;
3219 return this;
3220 }).exps = true;
3221
3222 prefix("~", function () {
3223 if (option.bitwise) {
3224 warning("Unexpected '{a}'.", this, "~");
3225 }
3226 expression(150);
3227 return this;
3228 });
3229
3230 prefix("!", function () {
3231 this.right = expression(150);
3232 this.arity = "unary";
3233 if (bang[this.right.id] === true) {
3234 warning("Confusing use of '{a}'.", this, "!");
3235 }
3236 return this;
3237 });
3238 prefix("typeof", "typeof");
3239 prefix("new", function () {
3240 var c = expression(155), i;
3241 if (c && c.id !== "function") {
3242 if (c.identifier) {
3243 c["new"] = true;
3244 switch (c.value) {
3245 case "Number":
3246 case "String":
3247 case "Boolean":
3248 case "Math":
3249 case "JSON":
3250 warning("Do not use {a} as a constructor.", prevtoken, c.value);
3251 break;
3252 case "Function":
3253 if (!option.evil) {
3254 warning("The Function constructor is eval.");
3255 }
3256 break;
3257 case "Date":
3258 case "RegExp":
3259 break;
3260 default:
3261 if (c.id !== "function") {
3262 i = c.value.substr(0, 1);
3263 if (option.newcap && (i < "A" || i > "Z") && !is_own(global, c.value)) {
3264 warning("A constructor name should start with an uppercase letter.",
3265 token);
3266 }
3267 }
3268 }
3269 } else {
3270 if (c.id !== "." && c.id !== "[" && c.id !== "(") {
3271 warning("Bad constructor.", token);
3272 }
3273 }
3274 } else {
3275 if (!option.supernew)
3276 warning("Weird construction. Delete 'new'.", this);
3277 }
3278 adjacent(token, nexttoken);
3279 if (nexttoken.id !== "(" && !option.supernew) {
3280 warning("Missing '()' invoking a constructor.",
3281 token, token.value);
3282 }
3283 this.first = c;
3284 return this;
3285 });
3286 syntax["new"].exps = true;
3287
3288 prefix("void").exps = true;
3289
3290 infix(".", function (left, that) {
3291 adjacent(prevtoken, token);
3292 nobreak();
3293 var m = identifier();
3294 if (typeof m === "string") {
3295 countMember(m);
3296 }
3297 that.left = left;
3298 that.right = m;
3299 if (left && left.value === "arguments" && (m === "callee" || m === "caller")) {
3300 if (option.noarg)
3301 warning("Avoid arguments.{a}.", left, m);
3302 else if (directive["use strict"])
3303 error("Strict violation.");
3304 } else if (!option.evil && left && left.value === "document" &&
3305 (m === "write" || m === "writeln")) {
3306 warning("document.write can be a form of eval.", left);
3307 }
3308 if (!option.evil && (m === "eval" || m === "execScript")) {
3309 warning("eval is evil.");
3310 }
3311 return that;
3312 }, 160, true);
3313
3314 infix("(", function (left, that) {
3315 if (prevtoken.id !== "}" && prevtoken.id !== ")") {
3316 nobreak(prevtoken, token);
3317 }
3318 nospace();
3319 if (option.immed && !left.immed && left.id === "function") {
3320 warning("Wrap an immediate function invocation in parentheses " +
3321 "to assist the reader in understanding that the expression " +
3322 "is the result of a function, and not the function itself.");
3323 }
3324 var n = 0,
3325 p = [];
3326 if (left) {
3327 if (left.type === "(identifier)") {
3328 if (left.value.match(/^[A-Z]([A-Z0-9_$]*[a-z][A-Za-z0-9_$]*)?$/)) {
3329 if ("Number String Boolean Date Object".indexOf(left.value) === -1) {
3330 if (left.value === "Math") {
3331 warning("Math is not a function.", left);
3332 } else if (option.newcap) {
3333 warning("Missing 'new' prefix when invoking a constructor.", left);
3334 }
3335 }
3336 }
3337 }
3338 }
3339 if (nexttoken.id !== ")") {
3340 for (;;) {
3341 p[p.length] = expression(10);
3342 n += 1;
3343 if (nexttoken.id !== ",") {
3344 break;
3345 }
3346 comma();
3347 }
3348 }
3349 advance(")");
3350 nospace(prevtoken, token);
3351 if (typeof left === "object") {
3352 if (left.value === "parseInt" && n === 1) {
3353 warning("Missing radix parameter.", token);
3354 }
3355 if (!option.evil) {
3356 if (left.value === "eval" || left.value === "Function" ||
3357 left.value === "execScript") {
3358 warning("eval is evil.", left);
3359
3360 if (p[0] && [0].id === "(string)") {
3361 addInternalSrc(left, p[0].value);
3362 }
3363 } else if (p[0] && p[0].id === "(string)" &&
3364 (left.value === "setTimeout" ||
3365 left.value === "setInterval")) {
3366 warning(
3367 "Implied eval is evil. Pass a function instead of a string.", left);
3368 addInternalSrc(left, p[0].value);
3369
3370 // window.setTimeout/setInterval
3371 } else if (p[0] && p[0].id === "(string)" &&
3372 left.value === "." &&
3373 left.left.value === "window" &&
3374 (left.right === "setTimeout" ||
3375 left.right === "setInterval")) {
3376 warning(
3377 "Implied eval is evil. Pass a function instead of a string.", left);
3378 addInternalSrc(left, p[0].value);
3379 }
3380 }
3381 if (!left.identifier && left.id !== "." && left.id !== "[" &&
3382 left.id !== "(" && left.id !== "&&" && left.id !== "||" &&
3383 left.id !== "?") {
3384 warning("Bad invocation.", left);
3385 }
3386 }
3387 that.left = left;
3388 return that;
3389 }, 155, true).exps = true;
3390
3391 prefix("(", function () {
3392 nospace();
3393 if (nexttoken.id === "function") {
3394 nexttoken.immed = true;
3395 }
3396 var v = expression(0);
3397 advance(")", this);
3398 nospace(prevtoken, token);
3399 if (option.immed && v.id === "function") {
3400 if (nexttoken.id !== "(" &&
3401 (nexttoken.id !== "." || (peek().value !== "call" && peek().value !== "apply"))) {
3402 warning(
3403 "Do not wrap function literals in parens unless they are to be immediately invoked.",
3404 this);
3405 }
3406 }
3407
3408 return v;
3409 });
3410
3411 infix("[", function (left, that) {
3412 nobreak(prevtoken, token);
3413 nospace();
3414 var e = expression(0), s;
3415 if (e && e.type === "(string)") {
3416 if (!option.evil && (e.value === "eval" || e.value === "execScript")) {
3417 warning("eval is evil.", that);
3418 }
3419 countMember(e.value);
3420 if (!option.sub && ix.test(e.value)) {
3421 s = syntax[e.value];
3422 if (!s || !s.reserved) {
3423 warning("['{a}'] is better written in dot notation.",
3424 prevtoken, e.value);
3425 }
3426 }
3427 }
3428 advance("]", that);
3429 nospace(prevtoken, token);
3430 that.left = left;
3431 that.right = e;
3432 return that;
3433 }, 160, true);
3434
3435 prefix("[", function () {
3436 var b = token.line !== nexttoken.line;
3437 this.first = [];
3438 if (b) {
3439 indent += option.indent;
3440 if (nexttoken.from === indent + option.indent) {
3441 indent += option.indent;
3442 }
3443 }
3444 while (nexttoken.id !== "(end)") {
3445 while (nexttoken.id === ",") {
3446 if (!option.es5)
3447 warning("Extra comma.");
3448 advance(",");
3449 }
3450 if (nexttoken.id === "]") {
3451 break;
3452 }
3453 if (b && token.line !== nexttoken.line) {
3454 indentation();
3455 }
3456 this.first.push(expression(10));
3457 if (nexttoken.id === ",") {
3458 comma();
3459 if (nexttoken.id === "]" && !option.es5) {
3460 warning("Extra comma.", token);
3461 break;
3462 }
3463 } else {
3464 break;
3465 }
3466 }
3467 if (b) {
3468 indent -= option.indent;
3469 indentation();
3470 }
3471 advance("]", this);
3472 return this;
3473 }, 160);
3474
3475
3476 function property_name() {
3477 var id = optionalidentifier(true);
3478 if (!id) {
3479 if (nexttoken.id === "(string)") {
3480 id = nexttoken.value;
3481 advance();
3482 } else if (nexttoken.id === "(number)") {
3483 id = nexttoken.value.toString();
3484 advance();
3485 }
3486 }
3487 return id;
3488 }
3489
3490
3491 function functionparams() {
3492 var next = nexttoken;
3493 var params = [];
3494 var ident;
3495
3496 advance("(");
3497 nospace();
3498
3499 if (nexttoken.id === ")") {
3500 advance(")");
3501 return;
3502 }
3503
3504 for (;;) {
3505 ident = identifier(true);
3506 params.push(ident);
3507 addlabel(ident, "unused", token);
3508 if (nexttoken.id === ",") {
3509 comma();
3510 } else {
3511 advance(")", next);
3512 nospace(prevtoken, token);
3513 return params;
3514 }
3515 }
3516 }
3517
3518
3519 function doFunction(name, statement) {
3520 var f;
3521 var oldOption = option;
3522 var oldScope = scope;
3523
3524 option = Object.create(option);
3525 scope = Object.create(scope);
3526
3527 funct = {
3528 "(name)" : name || "\"" + anonname + "\"",
3529 "(line)" : nexttoken.line,
3530 "(character)": nexttoken.character,
3531 "(context)" : funct,
3532 "(breakage)" : 0,
3533 "(loopage)" : 0,
3534 "(metrics)" : createMetrics(nexttoken),
3535 "(scope)" : scope,
3536 "(statement)": statement,
3537 "(tokens)" : {}
3538 };
3539
3540 f = funct;
3541 token.funct = funct;
3542
3543 functions.push(funct);
3544
3545 if (name) {
3546 addlabel(name, "function");
3547 }
3548
3549 funct["(params)"] = functionparams();
3550 funct["(metrics)"].verifyMaxParametersPerFunction(funct["(params)"]);
3551
3552 block(false, false, true);
3553
3554 funct["(metrics)"].verifyMaxStatementsPerFunction();
3555 funct["(metrics)"].verifyMaxComplexityPerFunction();
3556
3557 scope = oldScope;
3558 option = oldOption;
3559 funct["(last)"] = token.line;
3560 funct["(lastcharacter)"] = token.character;
3561 funct = funct["(context)"];
3562
3563 return f;
3564 }
3565
3566 function createMetrics(functionStartToken) {
3567 return {
3568 statementCount: 0,
3569 nestedBlockDepth: -1,
3570 ComplexityCount: 1,
3571 verifyMaxStatementsPerFunction: function () {
3572 if (option.maxstatements &&
3573 this.statementCount > option.maxstatements) {
3574 var message = "Too many statements per function (" + this.statementCount + ").";
3575 warning(message, functionStartToken);
3576 }
3577 },
3578
3579 verifyMaxParametersPerFunction: function (params) {
3580 params = params || [];
3581
3582 if (option.maxparams && params.length > option.maxparams) {
3583 var message = "Too many parameters per function (" + params.length + ").";
3584 warning(message, functionStartToken);
3585 }
3586 },
3587
3588 verifyMaxNestedBlockDepthPerFunction: function () {
3589 if (option.maxdepth &&
3590 this.nestedBlockDepth > 0 &&
3591 this.nestedBlockDepth === option.maxdepth + 1) {
3592 var message = "Blocks are nested too deeply (" + this.nestedBlockDepth + ").";
3593 warning(message);
3594 }
3595 },
3596
3597 verifyMaxComplexityPerFunction: function () {
3598 var max = option.maxcomplexity;
3599 var cc = this.ComplexityCount;
3600 if (max && cc > max) {
3601 var message = "Cyclomatic complexity is too high per function (" + cc + ").";
3602 warning(message, functionStartToken);
3603 }
3604 }
3605 };
3606 }
3607
3608 function increaseComplexityCount() {
3609 funct["(metrics)"].ComplexityCount += 1;
3610 }
3611
3612
3613 (function (x) {
3614 x.nud = function () {
3615 var b, f, i, p, t;
3616 var props = {}; // All properties, including accessors
3617
3618 function saveProperty(name, token) {
3619 if (props[name] && is_own(props, name))
3620 warning("Duplicate member '{a}'.", nexttoken, i);
3621 else
3622 props[name] = {};
3623
3624 props[name].basic = true;
3625 props[name].basicToken = token;
3626 }
3627
3628 function saveSetter(name, token) {
3629 if (props[name] && is_own(props, name)) {
3630 if (props[name].basic || props[name].setter)
3631 warning("Duplicate member '{a}'.", nexttoken, i);
3632 } else {
3633 props[name] = {};
3634 }
3635
3636 props[name].setter = true;
3637 props[name].setterToken = token;
3638 }
3639
3640 function saveGetter(name) {
3641 if (props[name] && is_own(props, name)) {
3642 if (props[name].basic || props[name].getter)
3643 warning("Duplicate member '{a}'.", nexttoken, i);
3644 } else {
3645 props[name] = {};
3646 }
3647
3648 props[name].getter = true;
3649 props[name].getterToken = token;
3650 }
3651
3652 b = token.line !== nexttoken.line;
3653 if (b) {
3654 indent += option.indent;
3655 if (nexttoken.from === indent + option.indent) {
3656 indent += option.indent;
3657 }
3658 }
3659 for (;;) {
3660 if (nexttoken.id === "}") {
3661 break;
3662 }
3663 if (b) {
3664 indentation();
3665 }
3666 if (nexttoken.value === "get" && peek().id !== ":") {
3667 advance("get");
3668 if (!option.es5) {
3669 error("get/set are ES5 features.");
3670 }
3671 i = property_name();
3672 if (!i) {
3673 error("Missing property name.");
3674 }
3675 saveGetter(i);
3676 t = nexttoken;
3677 adjacent(token, nexttoken);
3678 f = doFunction();
3679 p = f["(params)"];
3680 if (p) {
3681 warning("Unexpected parameter '{a}' in get {b} function.", t, p[0], i);
3682 }
3683 adjacent(token, nexttoken);
3684 } else if (nexttoken.value === "set" && peek().id !== ":") {
3685 advance("set");
3686 if (!option.es5) {
3687 error("get/set are ES5 features.");
3688 }
3689 i = property_name();
3690 if (!i) {
3691 error("Missing property name.");
3692 }
3693 saveSetter(i, nexttoken);
3694 t = nexttoken;
3695 adjacent(token, nexttoken);
3696 f = doFunction();
3697 p = f["(params)"];
3698 if (!p || p.length !== 1) {
3699 warning("Expected a single parameter in set {a} function.", t, i);
3700 }
3701 } else {
3702 i = property_name();
3703 saveProperty(i, nexttoken);
3704 if (typeof i !== "string") {
3705 break;
3706 }
3707 advance(":");
3708 nonadjacent(token, nexttoken);
3709 expression(10);
3710 }
3711
3712 countMember(i);
3713 if (nexttoken.id === ",") {
3714 comma();
3715 if (nexttoken.id === ",") {
3716 warning("Extra comma.", token);
3717 } else if (nexttoken.id === "}" && !option.es5) {
3718 warning("Extra comma.", token);
3719 }
3720 } else {
3721 break;
3722 }
3723 }
3724 if (b) {
3725 indent -= option.indent;
3726 indentation();
3727 }
3728 advance("}", this);
3729
3730 // Check for lonely setters if in the ES5 mode.
3731 if (option.es5) {
3732 for (var name in props) {
3733 if (is_own(props, name) && props[name].setter && !props[name].getter) {
3734 warning("Setter is defined without getter.", props[name].setterToken);
3735 }
3736 }
3737 }
3738 return this;
3739 };
3740 x.fud = function () {
3741 error("Expected to see a statement and instead saw a block.", token);
3742 };
3743 }(delim("{")));
3744
3745 // This Function is called when esnext option is set to true
3746 // it adds the `const` statement to JSHINT
3747
3748 useESNextSyntax = function () {
3749 var conststatement = stmt("const", function (prefix) {
3750 var id, name, value;
3751
3752 this.first = [];
3753 for (;;) {
3754 nonadjacent(token, nexttoken);
3755 id = identifier();
3756 if (funct[id] === "const") {
3757 warning("const '" + id + "' has already been declared");
3758 }
3759 if (funct["(global)"] && predefined[id] === false) {
3760 warning("Redefinition of '{a}'.", token, id);
3761 }
3762 addlabel(id, "const");
3763 if (prefix) {
3764 break;
3765 }
3766 name = token;
3767 this.first.push(token);
3768
3769 if (nexttoken.id !== "=") {
3770 warning("const " +
3771 "'{a}' is initialized to 'undefined'.", token, id);
3772 }
3773
3774 if (nexttoken.id === "=") {
3775 nonadjacent(token, nexttoken);
3776 advance("=");
3777 nonadjacent(token, nexttoken);
3778 if (nexttoken.id === "undefined") {
3779 warning("It is not necessary to initialize " +
3780 "'{a}' to 'undefined'.", token, id);
3781 }
3782 if (peek(0).id === "=" && nexttoken.identifier) {
3783 error("Constant {a} was not declared correctly.",
3784 nexttoken, nexttoken.value);
3785 }
3786 value = expression(0);
3787 name.first = value;
3788 }
3789
3790 if (nexttoken.id !== ",") {
3791 break;
3792 }
3793 comma();
3794 }
3795 return this;
3796 });
3797 conststatement.exps = true;
3798 };
3799
3800 var varstatement = stmt("var", function (prefix) {
3801 // JavaScript does not have block scope. It only has function scope. So,
3802 // declaring a variable in a block can have unexpected consequences.
3803 var id, name, value;
3804
3805 if (funct["(onevar)"] && option.onevar) {
3806 warning("Too many var statements.");
3807 } else if (!funct["(global)"]) {
3808 funct["(onevar)"] = true;
3809 }
3810
3811 this.first = [];
3812
3813 for (;;) {
3814 nonadjacent(token, nexttoken);
3815 id = identifier();
3816
3817 if (option.esnext && funct[id] === "const") {
3818 warning("const '" + id + "' has already been declared");
3819 }
3820
3821 if (funct["(global)"] && predefined[id] === false) {
3822 warning("Redefinition of '{a}'.", token, id);
3823 }
3824
3825 addlabel(id, "unused", token);
3826
3827 if (prefix) {
3828 break;
3829 }
3830
3831 name = token;
3832 this.first.push(token);
3833
3834 if (nexttoken.id === "=") {
3835 nonadjacent(token, nexttoken);
3836 advance("=");
3837 nonadjacent(token, nexttoken);
3838 if (nexttoken.id === "undefined") {
3839 warning("It is not necessary to initialize '{a}' to 'undefined'.", token, id);
3840 }
3841 if (peek(0).id === "=" && nexttoken.identifier) {
3842 error("Variable {a} was not declared correctly.",
3843 nexttoken, nexttoken.value);
3844 }
3845 value = expression(0);
3846 name.first = value;
3847 }
3848 if (nexttoken.id !== ",") {
3849 break;
3850 }
3851 comma();
3852 }
3853 return this;
3854 });
3855 varstatement.exps = true;
3856
3857 blockstmt("function", function () {
3858 if (inblock) {
3859 warning("Function declarations should not be placed in blocks. " +
3860 "Use a function expression or move the statement to the top of " +
3861 "the outer function.", token);
3862
3863 }
3864 var i = identifier();
3865 if (option.esnext && funct[i] === "const") {
3866 warning("const '" + i + "' has already been declared");
3867 }
3868 adjacent(token, nexttoken);
3869 addlabel(i, "unction", token);
3870
3871 doFunction(i, { statement: true });
3872 if (nexttoken.id === "(" && nexttoken.line === token.line) {
3873 error(
3874 "Function declarations are not invocable. Wrap the whole function invocation in parens.");
3875 }
3876 return this;
3877 });
3878
3879 prefix("function", function () {
3880 var i = optionalidentifier();
3881 if (i) {
3882 adjacent(token, nexttoken);
3883 } else {
3884 nonadjacent(token, nexttoken);
3885 }
3886 doFunction(i);
3887 if (!option.loopfunc && funct["(loopage)"]) {
3888 warning("Don't make functions within a loop.");
3889 }
3890 return this;
3891 });
3892
3893 blockstmt("if", function () {
3894 var t = nexttoken;
3895 increaseComplexityCount();
3896 advance("(");
3897 nonadjacent(this, t);
3898 nospace();
3899 expression(20);
3900 if (nexttoken.id === "=") {
3901 if (!option.boss)
3902 warning("Expected a conditional expression and instead saw an assignment.");
3903 advance("=");
3904 expression(20);
3905 }
3906 advance(")", t);
3907 nospace(prevtoken, token);
3908 block(true, true);
3909 if (nexttoken.id === "else") {
3910 nonadjacent(token, nexttoken);
3911 advance("else");
3912 if (nexttoken.id === "if" || nexttoken.id === "switch") {
3913 statement(true);
3914 } else {
3915 block(true, true);
3916 }
3917 }
3918 return this;
3919 });
3920
3921 blockstmt("try", function () {
3922 var b;
3923
3924 function doCatch() {
3925 var oldScope = scope;
3926 var e;
3927
3928 advance("catch");
3929 nonadjacent(token, nexttoken);
3930 advance("(");
3931
3932 scope = Object.create(oldScope);
3933
3934 e = nexttoken.value;
3935 if (nexttoken.type !== "(identifier)") {
3936 e = null;
3937 warning("Expected an identifier and instead saw '{a}'.", nexttoken, e);
3938 }
3939
3940 advance();
3941 advance(")");
3942
3943 funct = {
3944 "(name)" : "(catch)",
3945 "(line)" : nexttoken.line,
3946 "(character)": nexttoken.character,
3947 "(context)" : funct,
3948 "(breakage)" : funct["(breakage)"],
3949 "(loopage)" : funct["(loopage)"],
3950 "(scope)" : scope,
3951 "(statement)": false,
3952 "(metrics)" : createMetrics(nexttoken),
3953 "(catch)" : true,
3954 "(tokens)" : {}
3955 };
3956
3957 if (e) {
3958 addlabel(e, "exception");
3959 }
3960
3961 token.funct = funct;
3962 functions.push(funct);
3963
3964 block(false);
3965
3966 scope = oldScope;
3967
3968 funct["(last)"] = token.line;
3969 funct["(lastcharacter)"] = token.character;
3970 funct = funct["(context)"];
3971 }
3972
3973 block(false);
3974
3975 if (nexttoken.id === "catch") {
3976 increaseComplexityCount();
3977 doCatch();
3978 b = true;
3979 }
3980
3981 if (nexttoken.id === "finally") {
3982 advance("finally");
3983 block(false);
3984 return;
3985 } else if (!b) {
3986 error("Expected '{a}' and instead saw '{b}'.",
3987 nexttoken, "catch", nexttoken.value);
3988 }
3989
3990 return this;
3991 });
3992
3993 blockstmt("while", function () {
3994 var t = nexttoken;
3995 funct["(breakage)"] += 1;
3996 funct["(loopage)"] += 1;
3997 increaseComplexityCount();
3998 advance("(");
3999 nonadjacent(this, t);
4000 nospace();
4001 expression(20);
4002 if (nexttoken.id === "=") {
4003 if (!option.boss)
4004 warning("Expected a conditional expression and instead saw an assignment.");
4005 advance("=");
4006 expression(20);
4007 }
4008 advance(")", t);
4009 nospace(prevtoken, token);
4010 block(true, true);
4011 funct["(breakage)"] -= 1;
4012 funct["(loopage)"] -= 1;
4013 return this;
4014 }).labelled = true;
4015
4016 blockstmt("with", function () {
4017 var t = nexttoken;
4018 if (directive["use strict"]) {
4019 error("'with' is not allowed in strict mode.", token);
4020 } else if (!option.withstmt) {
4021 warning("Don't use 'with'.", token);
4022 }
4023
4024 advance("(");
4025 nonadjacent(this, t);
4026 nospace();
4027 expression(0);
4028 advance(")", t);
4029 nospace(prevtoken, token);
4030 block(true, true);
4031
4032 return this;
4033 });
4034
4035 blockstmt("switch", function () {
4036 var t = nexttoken,
4037 g = false;
4038 funct["(breakage)"] += 1;
4039 advance("(");
4040 nonadjacent(this, t);
4041 nospace();
4042 this.condition = expression(20);
4043 advance(")", t);
4044 nospace(prevtoken, token);
4045 nonadjacent(token, nexttoken);
4046 t = nexttoken;
4047 advance("{");
4048 nonadjacent(token, nexttoken);
4049 indent += option.indent;
4050 this.cases = [];
4051 for (;;) {
4052 switch (nexttoken.id) {
4053 case "case":
4054 switch (funct["(verb)"]) {
4055 case "break":
4056 case "case":
4057 case "continue":
4058 case "return":
4059 case "switch":
4060 case "throw":
4061 break;
4062 default:
4063 // You can tell JSHint that you don't use break intentionally by
4064 // adding a comment /* falls through */ on a line just before
4065 // the next `case`.
4066 if (!ft.test(lines[nexttoken.line - 2])) {
4067 warning(
4068 "Expected a 'break' statement before 'case'.",
4069 token);
4070 }
4071 }
4072 indentation(-option.indent);
4073 advance("case");
4074 this.cases.push(expression(20));
4075 increaseComplexityCount();
4076 g = true;
4077 advance(":");
4078 funct["(verb)"] = "case";
4079 break;
4080 case "default":
4081 switch (funct["(verb)"]) {
4082 case "break":
4083 case "continue":
4084 case "return":
4085 case "throw":
4086 break;
4087 default:
4088 if (!ft.test(lines[nexttoken.line - 2])) {
4089 warning(
4090 "Expected a 'break' statement before 'default'.",
4091 token);
4092 }
4093 }
4094 indentation(-option.indent);
4095 advance("default");
4096 g = true;
4097 advance(":");
4098 break;
4099 case "}":
4100 indent -= option.indent;
4101 indentation();
4102 advance("}", t);
4103 if (this.cases.length === 1 || this.condition.id === "true" ||
4104 this.condition.id === "false") {
4105 if (!option.onecase)
4106 warning("This 'switch' should be an 'if'.", this);
4107 }
4108 funct["(breakage)"] -= 1;
4109 funct["(verb)"] = undefined;
4110 return;
4111 case "(end)":
4112 error("Missing '{a}'.", nexttoken, "}");
4113 return;
4114 default:
4115 if (g) {
4116 switch (token.id) {
4117 case ",":
4118 error("Each value should have its own case label.");
4119 return;
4120 case ":":
4121 g = false;
4122 statements();
4123 break;
4124 default:
4125 error("Missing ':' on a case clause.", token);
4126 return;
4127 }
4128 } else {
4129 if (token.id === ":") {
4130 advance(":");
4131 error("Unexpected '{a}'.", token, ":");
4132 statements();
4133 } else {
4134 error("Expected '{a}' and instead saw '{b}'.",
4135 nexttoken, "case", nexttoken.value);
4136 return;
4137 }
4138 }
4139 }
4140 }
4141 }).labelled = true;
4142
4143 stmt("debugger", function () {
4144 if (!option.debug) {
4145 warning("All 'debugger' statements should be removed.");
4146 }
4147 return this;
4148 }).exps = true;
4149
4150 (function () {
4151 var x = stmt("do", function () {
4152 funct["(breakage)"] += 1;
4153 funct["(loopage)"] += 1;
4154 increaseComplexityCount();
4155
4156 this.first = block(true);
4157 advance("while");
4158 var t = nexttoken;
4159 nonadjacent(token, t);
4160 advance("(");
4161 nospace();
4162 expression(20);
4163 if (nexttoken.id === "=") {
4164 if (!option.boss)
4165 warning("Expected a conditional expression and instead saw an assignment.");
4166 advance("=");
4167 expression(20);
4168 }
4169 advance(")", t);
4170 nospace(prevtoken, token);
4171 funct["(breakage)"] -= 1;
4172 funct["(loopage)"] -= 1;
4173 return this;
4174 });
4175 x.labelled = true;
4176 x.exps = true;
4177 }());
4178
4179 blockstmt("for", function () {
4180 var s, t = nexttoken;
4181 funct["(breakage)"] += 1;
4182 funct["(loopage)"] += 1;
4183 increaseComplexityCount();
4184 advance("(");
4185 nonadjacent(this, t);
4186 nospace();
4187 if (peek(nexttoken.id === "var" ? 1 : 0).id === "in") {
4188 if (nexttoken.id === "var") {
4189 advance("var");
4190 varstatement.fud.call(varstatement, true);
4191 } else {
4192 switch (funct[nexttoken.value]) {
4193 case "unused":
4194 funct[nexttoken.value] = "var";
4195 break;
4196 case "var":
4197 break;
4198 default:
4199 warning("Bad for in variable '{a}'.",
4200 nexttoken, nexttoken.value);
4201 }
4202 advance();
4203 }
4204 advance("in");
4205 expression(20);
4206 advance(")", t);
4207 s = block(true, true);
4208 if (option.forin && s && (s.length > 1 || typeof s[0] !== "object" ||
4209 s[0].value !== "if")) {
4210 warning("The body of a for in should be wrapped in an if statement to filter " +
4211 "unwanted properties from the prototype.", this);
4212 }
4213 funct["(breakage)"] -= 1;
4214 funct["(loopage)"] -= 1;
4215 return this;
4216 } else {
4217 if (nexttoken.id !== ";") {
4218 if (nexttoken.id === "var") {
4219 advance("var");
4220 varstatement.fud.call(varstatement);
4221 } else {
4222 for (;;) {
4223 expression(0, "for");
4224 if (nexttoken.id !== ",") {
4225 break;
4226 }
4227 comma();
4228 }
4229 }
4230 }
4231 nolinebreak(token);
4232 advance(";");
4233 if (nexttoken.id !== ";") {
4234 expression(20);
4235 if (nexttoken.id === "=") {
4236 if (!option.boss)
4237 warning("Expected a conditional expression and instead saw an assignment.");
4238 advance("=");
4239 expression(20);
4240 }
4241 }
4242 nolinebreak(token);
4243 advance(";");
4244 if (nexttoken.id === ";") {
4245 error("Expected '{a}' and instead saw '{b}'.",
4246 nexttoken, ")", ";");
4247 }
4248 if (nexttoken.id !== ")") {
4249 for (;;) {
4250 expression(0, "for");
4251 if (nexttoken.id !== ",") {
4252 break;
4253 }
4254 comma();
4255 }
4256 }
4257 advance(")", t);
4258 nospace(prevtoken, token);
4259 block(true, true);
4260 funct["(breakage)"] -= 1;
4261 funct["(loopage)"] -= 1;
4262 return this;
4263 }
4264 }).labelled = true;
4265
4266
4267 stmt("break", function () {
4268 var v = nexttoken.value;
4269
4270 if (funct["(breakage)"] === 0)
4271 warning("Unexpected '{a}'.", nexttoken, this.value);
4272
4273 if (!option.asi)
4274 nolinebreak(this);
4275
4276 if (nexttoken.id !== ";") {
4277 if (token.line === nexttoken.line) {
4278 if (funct[v] !== "label") {
4279 warning("'{a}' is not a statement label.", nexttoken, v);
4280 } else if (scope[v] !== funct) {
4281 warning("'{a}' is out of scope.", nexttoken, v);
4282 }
4283 this.first = nexttoken;
4284 advance();
4285 }
4286 }
4287 reachable("break");
4288 return this;
4289 }).exps = true;
4290
4291
4292 stmt("continue", function () {
4293 var v = nexttoken.value;
4294
4295 if (funct["(breakage)"] === 0)
4296 warning("Unexpected '{a}'.", nexttoken, this.value);
4297
4298 if (!option.asi)
4299 nolinebreak(this);
4300
4301 if (nexttoken.id !== ";") {
4302 if (token.line === nexttoken.line) {
4303 if (funct[v] !== "label") {
4304 warning("'{a}' is not a statement label.", nexttoken, v);
4305 } else if (scope[v] !== funct) {
4306 warning("'{a}' is out of scope.", nexttoken, v);
4307 }
4308 this.first = nexttoken;
4309 advance();
4310 }
4311 } else if (!funct["(loopage)"]) {
4312 warning("Unexpected '{a}'.", nexttoken, this.value);
4313 }
4314 reachable("continue");
4315 return this;
4316 }).exps = true;
4317
4318
4319 stmt("return", function () {
4320 if (this.line === nexttoken.line) {
4321 if (nexttoken.id === "(regexp)")
4322 warning("Wrap the /regexp/ literal in parens to disambiguate the slash operator.");
4323
4324 if (nexttoken.id !== ";" && !nexttoken.reach) {
4325 nonadjacent(token, nexttoken);
4326 if (peek().value === "=" && !option.boss) {
4327 warningAt("Did you mean to return a conditional instead of an assignment?",
4328 token.line, token.character + 1);
4329 }
4330 this.first = expression(0);
4331 }
4332 } else if (!option.asi) {
4333 nolinebreak(this); // always warn (Line breaking error)
4334 }
4335 reachable("return");
4336 return this;
4337 }).exps = true;
4338
4339
4340 stmt("throw", function () {
4341 nolinebreak(this);
4342 nonadjacent(token, nexttoken);
4343 this.first = expression(20);
4344 reachable("throw");
4345 return this;
4346 }).exps = true;
4347
4348 // Superfluous reserved words
4349
4350 reserve("class");
4351 reserve("const");
4352 reserve("enum");
4353 reserve("export");
4354 reserve("extends");
4355 reserve("import");
4356 reserve("super");
4357
4358 reserve("let");
4359 reserve("yield");
4360 reserve("implements");
4361 reserve("interface");
4362 reserve("package");
4363 reserve("private");
4364 reserve("protected");
4365 reserve("public");
4366 reserve("static");
4367
4368
4369 // Parse JSON
4370
4371 function jsonValue() {
4372
4373 function jsonObject() {
4374 var o = {}, t = nexttoken;
4375 advance("{");
4376 if (nexttoken.id !== "}") {
4377 for (;;) {
4378 if (nexttoken.id === "(end)") {
4379 error("Missing '}' to match '{' from line {a}.",
4380 nexttoken, t.line);
4381 } else if (nexttoken.id === "}") {
4382 warning("Unexpected comma.", token);
4383 break;
4384 } else if (nexttoken.id === ",") {
4385 error("Unexpected comma.", nexttoken);
4386 } else if (nexttoken.id !== "(string)") {
4387 warning("Expected a string and instead saw {a}.",
4388 nexttoken, nexttoken.value);
4389 }
4390 if (o[nexttoken.value] === true) {
4391 warning("Duplicate key '{a}'.",
4392 nexttoken, nexttoken.value);
4393 } else if ((nexttoken.value === "__proto__" &&
4394 !option.proto) || (nexttoken.value === "__iterator__" &&
4395 !option.iterator)) {
4396 warning("The '{a}' key may produce unexpected results.",
4397 nexttoken, nexttoken.value);
4398 } else {
4399 o[nexttoken.value] = true;
4400 }
4401 advance();
4402 advance(":");
4403 jsonValue();
4404 if (nexttoken.id !== ",") {
4405 break;
4406 }
4407 advance(",");
4408 }
4409 }
4410 advance("}");
4411 }
4412
4413 function jsonArray() {
4414 var t = nexttoken;
4415 advance("[");
4416 if (nexttoken.id !== "]") {
4417 for (;;) {
4418 if (nexttoken.id === "(end)") {
4419 error("Missing ']' to match '[' from line {a}.",
4420 nexttoken, t.line);
4421 } else if (nexttoken.id === "]") {
4422 warning("Unexpected comma.", token);
4423 break;
4424 } else if (nexttoken.id === ",") {
4425 error("Unexpected comma.", nexttoken);
4426 }
4427 jsonValue();
4428 if (nexttoken.id !== ",") {
4429 break;
4430 }
4431 advance(",");
4432 }
4433 }
4434 advance("]");
4435 }
4436
4437 switch (nexttoken.id) {
4438 case "{":
4439 jsonObject();
4440 break;
4441 case "[":
4442 jsonArray();
4443 break;
4444 case "true":
4445 case "false":
4446 case "null":
4447 case "(number)":
4448 case "(string)":
4449 advance();
4450 break;
4451 case "-":
4452 advance("-");
4453 if (token.character !== nexttoken.from) {
4454 warning("Unexpected space after '-'.", token);
4455 }
4456 adjacent(token, nexttoken);
4457 advance("(number)");
4458 break;
4459 default:
4460 error("Expected a JSON value.", nexttoken);
4461 }
4462 }
4463
4464
4465 // The actual JSHINT function itself.
4466 var itself = function (s, o, g) {
4467 var a, i, k, x;
4468 var optionKeys;
4469 var newOptionObj = {};
4470
4471 if (o && o.scope) {
4472 JSHINT.scope = o.scope;
4473 } else {
4474 JSHINT.errors = [];
4475 JSHINT.undefs = [];
4476 JSHINT.internals = [];
4477 JSHINT.blacklist = {};
4478 JSHINT.scope = "(main)";
4479 }
4480
4481 predefined = Object.create(standard);
4482 declared = Object.create(null);
4483 combine(predefined, g || {});
4484
4485 if (o) {
4486 a = o.predef;
4487 if (a) {
4488 if (!Array.isArray(a) && typeof a === "object") {
4489 a = Object.keys(a);
4490 }
4491 a.forEach(function (item) {
4492 var slice;
4493 if (item[0] === "-") {
4494 slice = item.slice(1);
4495 JSHINT.blacklist[slice] = slice;
4496 } else {
4497 predefined[item] = true;
4498 }
4499 });
4500 }
4501
4502 optionKeys = Object.keys(o);
4503 for (x = 0; x < optionKeys.length; x++) {
4504 newOptionObj[optionKeys[x]] = o[optionKeys[x]];
4505
4506 if (optionKeys[x] === "newcap" && o[optionKeys[x]] === false)
4507 newOptionObj["(explicitNewcap)"] = true;
4508
4509 if (optionKeys[x] === "indent")
4510 newOptionObj.white = true;
4511 }
4512 }
4513
4514 option = newOptionObj;
4515
4516 option.indent = option.indent || 4;
4517 option.maxerr = option.maxerr || 50;
4518
4519 tab = "";
4520 for (i = 0; i < option.indent; i += 1) {
4521 tab += " ";
4522 }
4523 indent = 1;
4524 global = Object.create(predefined);
4525 scope = global;
4526 funct = {
4527 "(global)": true,
4528 "(name)": "(global)",
4529 "(scope)": scope,
4530 "(breakage)": 0,
4531 "(loopage)": 0,
4532 "(tokens)": {},
4533 "(metrics)": createMetrics(nexttoken)
4534 };
4535 functions = [funct];
4536 urls = [];
4537 stack = null;
4538 member = {};
4539 membersOnly = null;
4540 implied = {};
4541 inblock = false;
4542 lookahead = [];
4543 jsonmode = false;
4544 warnings = 0;
4545 lines = [];
4546 unuseds = [];
4547
4548 if (!isString(s) && !Array.isArray(s)) {
4549 errorAt("Input is neither a string nor an array of strings.", 0);
4550 return false;
4551 }
4552
4553 if (isString(s) && /^\s*$/g.test(s)) {
4554 errorAt("Input is an empty string.", 0);
4555 return false;
4556 }
4557
4558 if (s.length === 0) {
4559 errorAt("Input is an empty array.", 0);
4560 return false;
4561 }
4562
4563 lex.init(s);
4564
4565 prereg = true;
4566 directive = {};
4567
4568 prevtoken = token = nexttoken = syntax["(begin)"];
4569
4570 // Check options
4571 for (var name in o) {
4572 if (is_own(o, name)) {
4573 checkOption(name, token);
4574 }
4575 }
4576
4577 assume();
4578
4579 // combine the passed globals after we've assumed all our options
4580 combine(predefined, g || {});
4581
4582 //reset values
4583 comma.first = true;
4584 quotmark = undefined;
4585
4586 try {
4587 advance();
4588 switch (nexttoken.id) {
4589 case "{":
4590 case "[":
4591 option.laxbreak = true;
4592 jsonmode = true;
4593 jsonValue();
4594 break;
4595 default:
4596 directives();
4597 if (directive["use strict"] && !option.globalstrict) {
4598 warning("Use the function form of \"use strict\".", prevtoken);
4599 }
4600
4601 statements();
4602 }
4603 advance((nexttoken && nexttoken.value !== ".") ? "(end)" : undefined);
4604
4605 var markDefined = function (name, context) {
4606 do {
4607 if (typeof context[name] === "string") {
4608 // JSHINT marks unused variables as 'unused' and
4609 // unused function declaration as 'unction'. This
4610 // code changes such instances back 'var' and
4611 // 'closure' so that the code in JSHINT.data()
4612 // doesn't think they're unused.
4613
4614 if (context[name] === "unused")
4615 context[name] = "var";
4616 else if (context[name] === "unction")
4617 context[name] = "closure";
4618
4619 return true;
4620 }
4621
4622 context = context["(context)"];
4623 } while (context);
4624
4625 return false;
4626 };
4627
4628 var clearImplied = function (name, line) {
4629 if (!implied[name])
4630 return;
4631
4632 var newImplied = [];
4633 for (var i = 0; i < implied[name].length; i += 1) {
4634 if (implied[name][i] !== line)
4635 newImplied.push(implied[name][i]);
4636 }
4637
4638 if (newImplied.length === 0)
4639 delete implied[name];
4640 else
4641 implied[name] = newImplied;
4642 };
4643
4644 var warnUnused = function (name, token) {
4645 var line = token.line;
4646 var chr = token.character;
4647
4648 if (option.unused)
4649 warningAt("'{a}' is defined but never used.", line, chr, name);
4650
4651 unuseds.push({
4652 name: name,
4653 line: line,
4654 character: chr
4655 });
4656 };
4657
4658 var checkUnused = function (func, key) {
4659 var type = func[key];
4660 var token = func["(tokens)"][key];
4661
4662 if (key.charAt(0) === "(")
4663 return;
4664
4665 if (type !== "unused" && type !== "unction")
4666 return;
4667
4668 // Params are checked separately from other variables.
4669 if (func["(params)"] && func["(params)"].indexOf(key) !== -1)
4670 return;
4671
4672 warnUnused(key, token);
4673 };
4674
4675 // Check queued 'x is not defined' instances to see if they're still undefined.
4676 for (i = 0; i < JSHINT.undefs.length; i += 1) {
4677 k = JSHINT.undefs[i].slice(0);
4678
4679 if (markDefined(k[2].value, k[0])) {
4680 clearImplied(k[2].value, k[2].line);
4681 } else {
4682 warning.apply(warning, k.slice(1));
4683 }
4684 }
4685
4686 functions.forEach(function (func) {
4687 for (var key in func) {
4688 if (is_own(func, key)) {
4689 checkUnused(func, key);
4690 }
4691 }
4692
4693 if (!func["(params)"])
4694 return;
4695
4696 var params = func["(params)"].slice();
4697 var param = params.pop();
4698 var type;
4699
4700 while (param) {
4701 type = func[param];
4702
4703 // 'undefined' is a special case for (function (window, undefined) { ... })();
4704 // patterns.
4705
4706 if (param === "undefined")
4707 return;
4708
4709 if (type !== "unused" && type !== "unction")
4710 return;
4711
4712 warnUnused(param, func["(tokens)"][param]);
4713 param = params.pop();
4714 }
4715 });
4716
4717 for (var key in declared) {
4718 if (is_own(declared, key) && !is_own(global, key)) {
4719 warnUnused(key, declared[key]);
4720 }
4721 }
4722 } catch (e) {
4723 if (e) {
4724 var nt = nexttoken || {};
4725 JSHINT.errors.push({
4726 raw : e.raw,
4727 reason : e.message,
4728 line : e.line || nt.line,
4729 character : e.character || nt.from
4730 }, null);
4731 }
4732 }
4733
4734 // Loop over the listed "internals", and check them as well.
4735
4736 if (JSHINT.scope === "(main)") {
4737 o = o || {};
4738
4739 for (i = 0; i < JSHINT.internals.length; i += 1) {
4740 k = JSHINT.internals[i];
4741 o.scope = k.elem;
4742 itself(k.value, o, g);
4743 }
4744 }
4745
4746 return JSHINT.errors.length === 0;
4747 };
4748
4749 // Data summary.
4750 itself.data = function () {
4751 var data = {
4752 functions: [],
4753 options: option
4754 };
4755 var implieds = [];
4756 var members = [];
4757 var fu, f, i, j, n, globals;
4758
4759 if (itself.errors.length) {
4760 data.errors = itself.errors;
4761 }
4762
4763 if (jsonmode) {
4764 data.json = true;
4765 }
4766
4767 for (n in implied) {
4768 if (is_own(implied, n)) {
4769 implieds.push({
4770 name: n,
4771 line: implied[n]
4772 });
4773 }
4774 }
4775
4776 if (implieds.length > 0) {
4777 data.implieds = implieds;
4778 }
4779
4780 if (urls.length > 0) {
4781 data.urls = urls;
4782 }
4783
4784 globals = Object.keys(scope);
4785 if (globals.length > 0) {
4786 data.globals = globals;
4787 }
4788
4789 for (i = 1; i < functions.length; i += 1) {
4790 f = functions[i];
4791 fu = {};
4792
4793 for (j = 0; j < functionicity.length; j += 1) {
4794 fu[functionicity[j]] = [];
4795 }
4796
4797 for (j = 0; j < functionicity.length; j += 1) {
4798 if (fu[functionicity[j]].length === 0) {
4799 delete fu[functionicity[j]];
4800 }
4801 }
4802
4803 fu.name = f["(name)"];
4804 fu.param = f["(params)"];
4805 fu.line = f["(line)"];
4806 fu.character = f["(character)"];
4807 fu.last = f["(last)"];
4808 fu.lastcharacter = f["(lastcharacter)"];
4809 data.functions.push(fu);
4810 }
4811
4812 if (unuseds.length > 0) {
4813 data.unused = unuseds;
4814 }
4815
4816 members = [];
4817 for (n in member) {
4818 if (typeof member[n] === "number") {
4819 data.member = member;
4820 break;
4821 }
4822 }
4823
4824 return data;
4825 };
4826
4827 itself.jshint = itself;
4828
4829 return itself;
4830 }());
4831
4832 // Make JSHINT a Node module, if possible.
4833 if (typeof exports === "object" && exports) {
4834 exports.JSHINT = JSHINT;
4835 }