JsLint
How do I make an jslint?
What is a jslint? How do you make a jslint? This script and codes were developed by Darby Rathbone on 03 October 2022, Monday.
JsLint Previews
JsLint - Script Codes HTML Codes
<!DOCTYPE html>
<html >
<head> <meta charset="UTF-8"> <title>JsLint</title>
</head>
<body> <script src="js/index.js"></script>
</body>
</html>JsLint - Script Codes JS Codes
// jslint.js
// 2013-11-23
// Copyright (c) 2002 Douglas Crockford (www.JSLint.com)
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
// The Software shall be used for Good, not Evil.
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
// WARNING: JSLint will hurt your feelings.
// JSLINT is a global function. It takes two parameters.
// var myResult = JSLINT(source, option);
// The first parameter is either a string or an array of strings. If it is a
// string, it will be split on '\n' or '\r'. If it is an array of strings, it
// is assumed that each string represents one line. The source can be a
// JavaScript text or a JSON text.
// The second parameter is an optional object of options that control the
// operation of JSLINT. Most of the options are booleans: They are all
// optional and have a default value of false. One of the options, predef,
// can be an array of names, which will be used to declare global variables,
// or an object whose keys are used as global names, with a boolean value
// that determines if they are assignable.
// If it checks out, JSLINT returns true. Otherwise, it returns false.
// If false, you can inspect JSLINT.errors to find out the problems.
// JSLINT.errors is an array of objects containing these properties:
// {
// line : The line (relative to 0) at which the lint was found
// character : The character (relative to 0) at which the lint was found
// reason : The problem
// evidence : The text line in which the problem occurred
// raw : The raw message before the details were inserted
// a : The first detail
// b : The second detail
// c : The third detail
// d : The fourth detail
// }
// If a stopping error was found, a null will be the last element of the
// JSLINT.errors array. A stopping error means that JSLint was not confident
// enough to continue. It does not necessarily mean that the error was
// especially heinous.
// You can request a data structure that contains JSLint's results.
// var myData = JSLINT.data();
// It returns a structure with this form:
// {
// errors: [
// {
// line: NUMBER,
// character: NUMBER,
// reason: STRING,
// evidence: STRING
// }
// ],
// functions: [
// {
// name: STRING,
// line: NUMBER,
// level: NUMBER,
// parameter: [
// STRING
// ],
// var: [
// STRING
// ],
// exception: [
// STRING
// ],
// closure: [
// STRING
// ],
// outer: [
// STRING
// ],
// global: [
// STRING
// ],
// label: [
// STRING
// ]
// }
// ],
// global: [
// STRING
// ],
// member: {
// STRING: NUMBER
// },
// json: BOOLEAN
// }
// You can request a Function Report, which shows all of the functions
// and the parameters and vars that they use. This can be used to find
// implied global variables and other problems. The report is in HTML and
// can be inserted into an HTML <body>. It should be given the result of the
// JSLINT.data function.
// var myReport = JSLINT.report(data);
// You can request an HTML error report.
// var myErrorReport = JSLINT.error_report(data);
// You can obtain an object containing all of the properties found in the
// file. JSLINT.property contains an object containing a key for each
// property used in the program, the value being the number of times that
// property name was used in the file.
// You can request a properties report, which produces a list of the program's
// properties in the form of a /*properties*/ declaration.
// var myPropertyReport = JSLINT.properties_report(JSLINT.property);
// You can obtain the parse tree that JSLint constructed while parsing. The
// latest tree is kept in JSLINT.tree. A nice stringification can be produced
// with
// JSON.stringify(JSLINT.tree, [
// 'string', 'arity', 'name', 'first',
// 'second', 'third', 'block', 'else'
// ], 4));
// You can request a context coloring table. It contains information that can be
// applied to the file that was analyzed. Context coloring colors functions
// based on their nesting level, and variables on the color of the functions
// in which they are defined.
// var myColorization = JSLINT.color(data);
// It returns an array containing objects of this form:
// {
// from: COLUMN,
// thru: COLUMN,
// line: ROW,
// level: 0 or higher
// }
// JSLint provides three inline directives. They look like slashstar comments,
// and allow for setting options, declaring global variables, and establishing a
// set of allowed property names.
// These directives respect function scope.
// The jslint directive is a special comment that can set one or more options.
// For example:
/*jslint evil: true, nomen: true, regexp: true, todo: true
*/
// The current option set is
// ass true, if assignment expressions should be allowed
// bitwise true, if bitwise operators should be allowed
// browser true, if the standard browser globals should be predefined
// closure true, if Google Closure idioms should be tolerated
// continue true, if the continuation statement should be tolerated
// debug true, if debugger statements should be allowed
// devel true, if logging should be allowed (console, alert, etc.)
// eqeq true, if == should be allowed
// evil true, if eval should be allowed
// forin true, if for in statements need not filter
// indent the indentation factor
// maxerr the maximum number of errors to allow
// maxlen the maximum length of a source line
// newcap true, if constructor names capitalization is ignored
// node true, if Node.js globals should be predefined
// nomen true, if names may have dangling _
// passfail true, if the scan should stop on first error
// plusplus true, if increment/decrement should be allowed
// properties true, if all property names must be declared with /*properties*/
// regexp true, if the . should be allowed in regexp literals
// rhino true, if the Rhino environment globals should be predefined
// unparam true, if unused parameters should be tolerated
// sloppy true, if the 'use strict'; pragma is optional
// stupid true, if really stupid practices are tolerated
// sub true, if all forms of subscript notation are tolerated
// todo true, if TODO comments are tolerated
// vars true, if multiple var statements per function should be allowed
// white true, if sloppy whitespace is tolerated
// The properties directive declares an exclusive list of property names.
// Any properties named in the program that are not in the list will
// produce a warning.
// For example:
/*properties '\b', '\t', '\n', '\f', '\r', '!', '!=', '!==', '"', '%', '\'', '(begin)', '(error)', '*', '+', '-', '/', '<', '<=', '==', '===', '>', '>=', '\\', a, a_label, a_scope, already_defined, and, apply, arguments, arity, ass, assign, assignment_expression, assignment_function_expression, at, avoid_a, b, bad_assignment, bad_constructor, bad_in_a, bad_invocation, bad_new, bad_number, bad_operand, bad_wrap, bitwise, block, break, breakage, browser, c, call, charAt, charCodeAt, character, closure, code, color, combine_var, comments, conditional_assignment, confusing_a, confusing_regexp, constructor_name_a, continue, control_a, couch, create, d, dangling_a, data, dead, debug, deleted, devel, disrupt, duplicate_a, edge, edition, elif, else, empty_block, empty_case, empty_class, entityify, eqeq, error_report, errors, evidence, evil, exception, exec, expected_a_at_b_c, expected_a_b, expected_a_b_from_c_d, expected_id_a, expected_identifier_a, expected_identifier_a_reserved, expected_number_a, expected_operator_a, expected_positive_a, expected_small_a, expected_space_a_b, expected_string_a, f, first, flag, floor, forEach, for_if, forin, from, fromCharCode, fud, function, function_block, function_eval, function_loop, function_statement, function_strict, functions, global, hasOwnProperty, id, identifier, identifier_function, immed, implied_evil, indent, indexOf, infix_in, init, insecure_a, isAlpha, isArray, isDigit, isNaN, join, jslint, json, keys, kind, label, labeled, lbp, leading_decimal_a, led, left, length, level, line, loopage, master, match, maxerr, maxlen, message, missing_a, missing_a_after_b, missing_property, missing_space_a_b, missing_use_strict, mode, move_invocation, move_var, n, name, name_function, nested_comment, newcap, node, nomen, not, not_a_constructor, not_a_defined, not_a_function, not_a_label, not_a_scope, not_greater, nud, number, octal_a, open, outer, parameter, parameter_a_get_b, parameter_arguments_a, parameter_set_a, params, paren, passfail, plusplus, pop, postscript, predef, properties, properties_report, property, prototype, push, quote, r, radix, raw, read_only, reason, redefinition_a_b, regexp, relation, replace, report, reserved, reserved_a, rhino, right, scanned_a_b, scope, search, second, shift, slash_equal, slice, sloppy, sort, split, statement, statement_block, stop, stopping, strange_loop, strict, string, stupid, sub, subscript, substr, supplant, sync_a, t, tag_a_in_b, test, third, thru, toString, todo, todo_comment, token, tokens, too_long, too_many, trailing_decimal_a, tree, unclosed, unclosed_comment, unclosed_regexp, unescaped_a, unexpected_a, unexpected_char_a, unexpected_comment, unexpected_label_a, unexpected_property_a, unexpected_space_a_b, unexpected_typeof_a, uninitialized_a, unnecessary_else, unnecessary_initialize, unnecessary_use, unparam, unreachable_a_b, unsafe, unused_a, url, use_array, use_braces, use_nested_if, use_object, use_or, use_param, use_spaces, used, used_before_a, var, var_a_not, var_loop, vars, varstatement, warn, warning, was, weird_assignment, weird_condition, weird_new, weird_program, weird_relation, weird_ternary, white, wrap, wrap_immediate, wrap_regexp, write_is_wrong, writeable
*/
// The global directive is used to declare global variables that can
// be accessed by the program. If a declaration is true, then the variable
// is writeable. Otherwise, it is read-only.
// We build the application inside a function so that we produce only a single
// global variable. That function will be invoked immediately, and its return
// value is the JSLINT function itself. That function is also an object that
// can contain data and other functions.
var JSLINT = (function () { 'use strict'; function array_to_object(array, value) {
// Make an object from an array of keys and a common value. var i, length = array.length, object = Object.create(null); for (i = 0; i < length; i += 1) { object[array[i]] = value; } return object; } var allowed_option = { ass : true, bitwise : true, browser : true, closure : true, continue : true, couch : true, debug : true, devel : true, eqeq : true, evil : true, forin : true, indent : 10, maxerr : 1000, maxlen : 256, newcap : true, node : true, nomen : true, passfail : true, plusplus : true, properties: true, regexp : true, rhino : true, unparam : true, sloppy : true, stupid : true, sub : true, todo : true, vars : true, white : true }, anonname, // The guessed name for anonymous functions.
// These are operators that should not be used with the ! operator. bang = { '<' : true, '<=' : true, '==' : true, '===': true, '!==': true, '!=' : true, '>' : true, '>=' : true, '+' : true, '-' : true, '*' : true, '/' : true, '%' : true }, begin, // The root token block_var, // vars defined in the current block
// browser contains a set of global names that are commonly provided by a
// web browser environment. browser = array_to_object([ 'clearInterval', 'clearTimeout', 'document', 'event', 'FormData', 'frames', 'history', 'Image', 'localStorage', 'location', 'name', 'navigator', 'Option', 'parent', 'screen', 'sessionStorage', 'setInterval', 'setTimeout', 'Storage', 'window', 'XMLHttpRequest' ], false),
// bundle contains the text messages. bundle = { a_label: "'{a}' is a statement label.", a_scope: "'{a}' used out of scope.", already_defined: "'{a}' is already defined.", and: "The '&&' subexpression should be wrapped in parens.", assignment_expression: "Unexpected assignment expression.", assignment_function_expression: "Expected an assignment or " + "function call and instead saw an expression.", avoid_a: "Avoid '{a}'.", bad_assignment: "Bad assignment.", bad_constructor: "Bad constructor.", bad_in_a: "Bad for in variable '{a}'.", bad_invocation: "Bad invocation.", bad_new: "Do not use 'new' for side effects.", bad_number: "Bad number '{a}'.", bad_operand: "Bad operand.", bad_wrap: "Do not wrap function literals in parens unless they " + "are to be immediately invoked.", combine_var: "Combine this with the previous 'var' statement.", conditional_assignment: "Expected a conditional expression and " + "instead saw an assignment.", confusing_a: "Confusing use of '{a}'.", confusing_regexp: "Confusing regular expression.", constructor_name_a: "A constructor name '{a}' should start with " + "an uppercase letter.", control_a: "Unexpected control character '{a}'.", dangling_a: "Unexpected dangling '_' in '{a}'.", deleted: "Only properties should be deleted.", duplicate_a: "Duplicate '{a}'.", empty_block: "Empty block.", empty_case: "Empty case.", empty_class: "Empty class.", evil: "eval is evil.", expected_a_b: "Expected '{a}' and instead saw '{b}'.", expected_a_b_from_c_d: "Expected '{a}' to match '{b}' from line " + "{c} and instead saw '{d}'.", expected_a_at_b_c: "Expected '{a}' at column {b}, not column {c}.", expected_id_a: "Expected an id, and instead saw #{a}.", expected_identifier_a: "Expected an identifier and instead saw '{a}'.", expected_identifier_a_reserved: "Expected an identifier and " + "instead saw '{a}' (a reserved word).", expected_number_a: "Expected a number and instead saw '{a}'.", expected_operator_a: "Expected an operator and instead saw '{a}'.", expected_positive_a: "Expected a positive number and instead saw '{a}'", expected_small_a: "Expected a small positive integer and instead saw '{a}'", expected_space_a_b: "Expected exactly one space between '{a}' and '{b}'.", expected_string_a: "Expected a string and instead saw '{a}'.", for_if: "The body of a for in should be wrapped in an if " + "statement to filter unwanted properties from the prototype.", function_block: "Function statements should not be placed in blocks." + "Use a function expression or move the statement to the top of " + "the outer function.", function_eval: "The Function constructor is eval.", function_loop: "Don't make functions within a loop.", function_statement: "Function statements are not invocable. " + "Wrap the whole function invocation in parens.", function_strict: "Use the function form of 'use strict'.", identifier_function: "Expected an identifier in an assignment " + "and instead saw a function invocation.", implied_evil: "Implied eval is evil. Pass a function instead of a string.", infix_in: "Unexpected 'in'. Compare with undefined, or use the " + "hasOwnProperty method instead.", insecure_a: "Insecure '{a}'.", isNaN: "Use the isNaN function to compare with NaN.", leading_decimal_a: "A leading decimal point can be confused with a dot: '.{a}'.", missing_a: "Missing '{a}'.", missing_a_after_b: "Missing '{a}' after '{b}'.", missing_property: "Missing property name.", missing_space_a_b: "Missing space between '{a}' and '{b}'.", missing_use_strict: "Missing 'use strict' statement.", move_invocation: "Move the invocation into the parens that " + "contain the function.", move_var: "Move 'var' declarations to the top of the function.", name_function: "Missing name in function statement.", nested_comment: "Nested comment.", not: "Nested not.", not_a_constructor: "Do not use {a} as a constructor.", not_a_defined: "'{a}' has not been fully defined yet.", not_a_function: "'{a}' is not a function.", not_a_label: "'{a}' is not a label.", not_a_scope: "'{a}' is out of scope.", not_greater: "'{a}' should not be greater than '{b}'.", octal_a: "Don't use octal: '{a}'. Use '\\u....' instead.", parameter_arguments_a: "Do not mutate parameter '{a}' when using 'arguments'.", parameter_a_get_b: "Unexpected parameter '{a}' in get {b} function.", parameter_set_a: "Expected parameter (value) in set {a} function.", radix: "Missing radix parameter.", read_only: "Read only.", redefinition_a_b: "Redefinition of '{a}' from line {b}.", reserved_a: "Reserved name '{a}'.", scanned_a_b: "{a} ({b}% scanned).", slash_equal: "A regular expression literal can be confused with '/='.", statement_block: "Expected to see a statement and instead saw a block.", stopping: "Stopping.", strange_loop: "Strange loop.", strict: "Strict violation.", subscript: "['{a}'] is better written in dot notation.", sync_a: "Unexpected sync method: '{a}'.", tag_a_in_b: "A '<{a}>' must be within '<{b}>'.", todo_comment: "Unexpected TODO comment.", too_long: "Line too long.", too_many: "Too many errors.", trailing_decimal_a: "A trailing decimal point can be confused " + "with a dot: '.{a}'.", unclosed: "Unclosed string.", unclosed_comment: "Unclosed comment.", unclosed_regexp: "Unclosed regular expression.", unescaped_a: "Unescaped '{a}'.", unexpected_a: "Unexpected '{a}'.", unexpected_char_a: "Unexpected character '{a}'.", unexpected_comment: "Unexpected comment.", unexpected_label_a: "Unexpected label '{a}'.", unexpected_property_a: "Unexpected /*property*/ '{a}'.", unexpected_space_a_b: "Unexpected space between '{a}' and '{b}'.", unexpected_typeof_a: "Unexpected 'typeof'. " + "Use '===' to compare directly with {a}.", uninitialized_a: "Uninitialized '{a}'.", unnecessary_else: "Unnecessary 'else' after disruption.", unnecessary_initialize: "It is not necessary to initialize '{a}' " + "to 'undefined'.", unnecessary_use: "Unnecessary 'use strict'.", unreachable_a_b: "Unreachable '{a}' after '{b}'.", unsafe: "Unsafe character.", unused_a: "Unused '{a}'.", url: "JavaScript URL.", use_array: "Use the array literal notation [].", use_braces: "Spaces are hard to count. Use {{a}}.", use_nested_if: "Expected 'else { if' and instead saw 'else if'.", use_object: "Use the object literal notation {} or Object.create(null).", use_or: "Use the || operator.", use_param: "Use a named parameter.", use_spaces: "Use spaces, not tabs.", used_before_a: "'{a}' was used before it was defined.", var_a_not: "Variable {a} was not declared correctly.", var_loop: "Don't declare variables in a loop.", weird_assignment: "Weird assignment.", weird_condition: "Weird condition.", weird_new: "Weird construction. Delete 'new'.", weird_program: "Weird program.", weird_relation: "Weird relation.", weird_ternary: "Weird ternary.", wrap_immediate: "Wrap an immediate function invocation in " + "parentheses to assist the reader in understanding that the " + "expression is the result of a function, and not the " + "function itself.", wrap_regexp: "Wrap the /regexp/ literal in parens to " + "disambiguate the slash operator.", write_is_wrong: "document.write can be a form of eval." }, closure = array_to_object([ 'goog' ], false), comments, comments_off, couch = array_to_object([ 'emit', 'getRow', 'isArray', 'log', 'provides', 'registerType', 'require', 'send', 'start', 'sum', 'toJSON' ], false), descapes = { 'b': '\b', 't': '\t', 'n': '\n', 'f': '\f', 'r': '\r', '"': '"', '/': '/', '\\': '\\', '!': '!' }, devel = array_to_object([ 'alert', 'confirm', 'console', 'Debug', 'opera', 'prompt', 'WSH' ], false), directive, escapes = { '\b': '\\b', '\t': '\\t', '\n': '\\n', '\f': '\\f', '\r': '\\r', '\'': '\\\'', '"' : '\\"', '/' : '\\/', '\\': '\\\\' }, funct, // The current function functions, // All of the functions global_funct, // The global body global_scope, // The global scope in_block, // Where function statements are not allowed indent, itself, // JSLINT itself json_mode, lex, // the tokenizer lines, lookahead, node = array_to_object([ 'Buffer', 'clearImmediate', 'clearInterval', 'clearTimeout', 'console', 'exports', 'global', 'module', 'process', 'querystring', 'require', 'setImmediate', 'setInterval', 'setTimeout', '__dirname', '__filename' ], false), node_js, numbery = array_to_object(['indexOf', 'lastIndexOf', 'search'], true), next_token, option, predefined, // Global variables defined by option prereg, prev_token, property, protosymbol, regexp_flag = array_to_object(['g', 'i', 'm'], true), return_this = function return_this() { return this; }, rhino = array_to_object([ 'defineClass', 'deserialize', 'gc', 'help', 'load', 'loadClass', 'print', 'quit', 'readFile', 'readUrl', 'runCommand', 'seal', 'serialize', 'spawn', 'sync', 'toint32', 'version' ], false), scope, // An object containing an object for each variable in scope semicolon_coda = array_to_object([';', '"', '\'', ')'], true),
// standard contains the global names that are provided by the
// ECMAScript standard. standard = array_to_object([ 'Array', 'Boolean', 'Date', 'decodeURI', 'decodeURIComponent', 'encodeURI', 'encodeURIComponent', 'Error', 'eval', 'EvalError', 'Function', 'isFinite', 'isNaN', 'JSON', 'Map', 'Math', 'Number', 'Object', 'parseInt', 'parseFloat', 'Promise', 'Proxy', 'RangeError', 'ReferenceError', 'Reflect', 'RegExp', 'Set', 'String', 'Symbol', 'SyntaxError', 'System', 'TypeError', 'URIError', 'WeakMap', 'WeakSet' ], false), strict_mode, syntax = Object.create(null), token, tokens, var_mode, warnings,
// Regular expressions. Some of these are stupidly long.
// carriage return, carriage return linefeed, or linefeed crlfx = /\r\n?|\n/,
// unsafe characters that are silently deleted by one or more browsers cx = /[\u0000-\u0008\u000a-\u001f\u007f-\u009f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/,
// identifier ix = /^([a-zA-Z_$][a-zA-Z0-9_$]*)$/,
// javascript url jx = /^(?:javascript|jscript|ecmascript|vbscript)\s*:/i,
// star slash lx = /\*\/|\/\*/,
// characters in strings that need escapement nx = /[\u0000-\u001f'\\\u007f-\u009f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
// sync syx = /Sync$/,
// comment todo tox = /^\W*to\s*do(?:\W|$)/i,
// token tx = /^\s*([(){}\[\]\?.,:;'"~#@`]|={1,3}|\/(\*(jslint|properties|property|members?|globals?)?|=|\/)?|\*[\/=]?|\+(?:=|\++)?|-(?:=|-+)?|[\^%]=?|&[&=]?|\|[|=]?|>{1,3}=?|<(?:[\/=!]|\!(\[|--)?|<=?)?|\!(\!|==?)?|[a-zA-Z_$][a-zA-Z0-9_$]*|[0-9]+(?:[xX][0-9a-fA-F]+|\.[0-9]*)?(?:[eE][+\-]?[0-9]+)?)/; if (typeof String.prototype.entityify !== 'function') { String.prototype.entityify = function () { return this .replace(/&/g, '&') .replace(/</g, '<') .replace(/>/g, '>'); }; } if (typeof String.prototype.isAlpha !== 'function') { String.prototype.isAlpha = function () { return (this >= 'a' && this <= 'z\uffff') || (this >= 'A' && this <= 'Z\uffff'); }; } if (typeof String.prototype.isDigit !== 'function') { String.prototype.isDigit = function () { return (this >= '0' && this <= '9'); }; } if (typeof String.prototype.supplant !== 'function') { String.prototype.supplant = function (o) { return this.replace(/\{([^{}]*)\}/g, function (a, b) { var replacement = o[b]; return typeof replacement === 'string' || typeof replacement === 'number' ? replacement : a; }); }; } function sanitize(a) {
// Escapify a troublesome character. return escapes[a] || '\\u' + ('0000' + a.charCodeAt().toString(16)).slice(-4); } function add_to_predefined(group) { Object.keys(group).forEach(function (name) { predefined[name] = group[name]; }); } function assume() { if (option.browser) { add_to_predefined(browser); option.browser = false; } if (option.closure) { add_to_predefined(closure); } if (option.couch) { add_to_predefined(couch); option.couch = false; } if (option.devel) { add_to_predefined(devel); option.devel = false; } if (option.node) { add_to_predefined(node); option.node = false; node_js = true; } if (option.rhino) { add_to_predefined(rhino); option.rhino = false; } }
// Produce an error warning. function artifact(tok) { if (!tok) { tok = next_token; } return tok.id === '(number)' ? tok.number : tok.string; } function quit(message, line, character) { throw { name: 'JSLintError', line: line, character: character, message: bundle.scanned_a_b.supplant({ a: bundle[message] || message, b: Math.floor((line / lines.length) * 100) }) }; } function warn(code, line, character, a, b, c, d) { var warning = { // ~~ id: '(error)', raw: bundle[code] || code, code: code, evidence: lines[line - 1] || '', line: line, character: character, a: a || artifact(this), b: b, c: c, d: d }; warning.reason = warning.raw.supplant(warning); itself.errors.push(warning); if (option.passfail) { quit('stopping', line, character); } warnings += 1; if (warnings >= option.maxerr) { quit('too_many', line, character); } return warning; } function stop(code, line, character, a, b, c, d) { var warning = warn(code, line, character, a, b, c, d); quit('stopping', warning.line, warning.character); } function expected_at(at) { if (!option.white && next_token.from !== at) { next_token.warn('expected_a_at_b_c', '', at, next_token.from); } }
// lexical analysis and token construction lex = (function lex() { var character, c, from, length, line, pos, source_row;
// Private lex methods function next_line() { var at; character = 1; source_row = lines[line]; line += 1; if (source_row === undefined) { return false; } at = source_row.search(/\t/); if (at >= 0) { if (option.white) { source_row = source_row.replace(/\t/g, ' '); } else { warn('use_spaces', line, at + 1); } } at = source_row.search(cx); if (at >= 0) { warn('unsafe', line, at); } if (option.maxlen && option.maxlen < source_row.length) { warn('too_long', line, source_row.length); } return true; }
// Produce a token object. The token inherits from a syntax symbol. function it(type, value) { var id, the_token; if (type === '(string)') { if (jx.test(value)) { warn('url', line, from); } } the_token = Object.create(syntax[( type === '(punctuator)' || (type === '(identifier)' && Object.prototype.hasOwnProperty.call(syntax, value)) ? value : type )] || syntax['(error)']); if (type === '(identifier)') { the_token.identifier = true; if (value === '__iterator__' || value === '__proto__') { stop('reserved_a', line, from, value); } else if (!option.nomen && (value.charAt(0) === '_' || value.charAt(value.length - 1) === '_')) { warn('dangling_a', line, from, value); } } if (type === '(number)') { the_token.number = +value; } else if (value !== undefined) { the_token.string = String(value); } the_token.line = line; the_token.from = from; the_token.thru = character; if (comments.length) { the_token.comments = comments; comments = []; } id = the_token.id; prereg = id && ( ('(,=:[!&|?{};~+-*%^<>'.indexOf(id.charAt(id.length - 1)) >= 0) || id === 'return' || id === 'case' ); return the_token; } function match(x) { var exec = x.exec(source_row), first; if (exec) { length = exec[0].length; first = exec[1]; c = first.charAt(0); source_row = source_row.slice(length); from = character + length - first.length; character += length; return first; } for (;;) { if (!source_row) { if (!option.white) { warn('unexpected_char_a', line, character - 1, '(space)'); } return; } c = source_row.charAt(0); if (c !== ' ') { break; } source_row = source_row.slice(1); character += 1; } stop('unexpected_char_a', line, character, c); } function string(x) { var ch, at = 0, r = '', result; function hex(n) { var i = parseInt(source_row.substr(at + 1, n), 16); at += n; if (i >= 32 && i <= 126 && i !== 34 && i !== 92 && i !== 39) { warn('unexpected_a', line, character, '\\'); } character += n; ch = String.fromCharCode(i); } if (json_mode && x !== '"') { warn('expected_a_b', line, character, '"', x); } for (;;) { while (at >= source_row.length) { at = 0; if (!next_line()) { stop('unclosed', line - 1, from); } } ch = source_row.charAt(at); if (ch === x) { character += 1; source_row = source_row.slice(at + 1); result = it('(string)', r); result.quote = x; return result; } if (ch < ' ') { if (ch === '\n' || ch === '\r') { break; } warn('control_a', line, character + at, source_row.slice(0, at)); } else if (ch === '\\') { at += 1; character += 1; ch = source_row.charAt(at); switch (ch) { case '': warn('unexpected_a', line, character, '\\'); next_line(); at = -1; break; case '\'': if (json_mode) { warn('unexpected_a', line, character, '\\\''); } break; case 'u': hex(4); break; case 'v': if (json_mode) { warn('unexpected_a', line, character, '\\v'); } ch = '\v'; break; case 'x': if (json_mode) { warn('unexpected_a', line, character, '\\x'); } hex(2); break; default: if (typeof descapes[ch] !== 'string') { warn(ch >= '0' && ch <= '7' ? 'octal_a' : 'unexpected_a', line, character, '\\' + ch); } else { ch = descapes[ch]; } } } r += ch; character += 1; at += 1; } } function number(snippet) { var digit; if (source_row.charAt(0).isAlpha()) { warn('expected_space_a_b', line, character, c, source_row.charAt(0)); } if (c === '0') { digit = snippet.charAt(1); if (digit.isDigit()) { if (token.id !== '.') { warn('unexpected_a', line, character, snippet); } } else if (json_mode && (digit === 'x' || digit === 'X')) { warn('unexpected_a', line, character, '0x'); } } if (snippet.slice(snippet.length - 1) === '.') { warn('trailing_decimal_a', line, character, snippet); } digit = +snippet; if (!isFinite(digit)) { warn('bad_number', line, character, snippet); } snippet = digit; return it('(number)', snippet); } function comment(snippet, type) { if (comments_off) { warn('unexpected_comment', line, character); } else if (!option.todo && tox.test(snippet)) { warn('todo_comment', line, character); } comments.push({ id: type, from: from, thru: character, line: line, string: snippet }); } function regexp() { var at = 0, b, bit, depth = 0, flag = '', high, letter, low, potential, quote, result; for (;;) { b = true; c = source_row.charAt(at); at += 1; switch (c) { case '': stop('unclosed_regexp', line, from); return; case '/': if (depth > 0) { warn('unescaped_a', line, from + at, '/'); } c = source_row.slice(0, at - 1); potential = Object.create(regexp_flag); for (;;) { letter = source_row.charAt(at); if (potential[letter] !== true) { break; } potential[letter] = false; at += 1; flag += letter; } if (source_row.charAt(at).isAlpha()) { stop('unexpected_a', line, from, source_row.charAt(at)); } character += at; source_row = source_row.slice(at); quote = source_row.charAt(0); if (quote === '/' || quote === '*') { stop('confusing_regexp', line, from); } result = it('(regexp)', c); result.flag = flag; return result; case '\\': c = source_row.charAt(at); if (c < ' ') { warn('control_a', line, from + at, String(c)); } else if (c === '<') { warn('unexpected_a', line, from + at, '\\'); } at += 1; break; case '(': depth += 1; b = false; if (source_row.charAt(at) === '?') { at += 1; switch (source_row.charAt(at)) { case ':': case '=': case '!': at += 1; break; default: warn('expected_a_b', line, from + at, ':', source_row.charAt(at)); } } break; case '|': b = false; break; case ')': if (depth === 0) { warn('unescaped_a', line, from + at, ')'); } else { depth -= 1; } break; case ' ': pos = 1; while (source_row.charAt(at) === ' ') { at += 1; pos += 1; } if (pos > 1) { warn('use_braces', line, from + at, pos); } break; case '[': c = source_row.charAt(at); if (c === '^') { at += 1; if (!option.regexp) { warn('insecure_a', line, from + at, c); } else if (source_row.charAt(at) === ']') { stop('unescaped_a', line, from + at, '^'); } } bit = false; if (c === ']') { warn('empty_class', line, from + at - 1); bit = true; }
klass: do { c = source_row.charAt(at); at += 1; switch (c) { case '[': case '^': warn('unescaped_a', line, from + at, c); bit = true; break; case '-': if (bit) { bit = false; } else { warn('unescaped_a', line, from + at, '-'); bit = true; } break; case ']': if (!bit) { warn('unescaped_a', line, from + at - 1, '-'); } break klass; case '\\': c = source_row.charAt(at); if (c < ' ') { warn('control_a', line, from + at, String(c)); } else if (c === '<') { warn('unexpected_a', line, from + at, '\\'); } at += 1; bit = true; break; case '/': warn('unescaped_a', line, from + at - 1, '/'); bit = true; break; default: bit = true; } } while (c); break; case '.': if (!option.regexp) { warn('insecure_a', line, from + at, c); } break; case ']': case '?': case '{': case '}': case '+': case '*': warn('unescaped_a', line, from + at, c); break; } if (b) { switch (source_row.charAt(at)) { case '?': case '+': case '*': at += 1; if (source_row.charAt(at) === '?') { at += 1; } break; case '{': at += 1; c = source_row.charAt(at); if (c < '0' || c > '9') { warn('expected_number_a', line, from + at, c); } at += 1; low = +c; for (;;) { c = source_row.charAt(at); if (c < '0' || c > '9') { break; } at += 1; low = +c + (low * 10); } high = low; if (c === ',') { at += 1; high = Infinity; c = source_row.charAt(at); if (c >= '0' && c <= '9') { at += 1; high = +c; for (;;) { c = source_row.charAt(at); if (c < '0' || c > '9') { break; } at += 1; high = +c + (high * 10); } } } if (source_row.charAt(at) !== '}') { warn('expected_a_b', line, from + at, '}', c); } else { at += 1; } if (source_row.charAt(at) === '?') { at += 1; } if (low > high) { warn('not_greater', line, from + at, low, high); } break; } } } c = source_row.slice(0, at - 1); character += at; source_row = source_row.slice(at); return it('(regexp)', c); }
// Public lex methods return { init: function (source) { if (typeof source === 'string') { lines = source.split(crlfx); } else { lines = source; } line = 0; next_line(); from = 1; },
// token -- this is called by advance to get the next token. token: function () { var first, i, snippet; for (;;) { while (!source_row) { if (!next_line()) { return it('(end)'); } } snippet = match(tx); if (snippet) {
// identifier first = snippet.charAt(0); if (first.isAlpha() || first === '_' || first === '$') { return it('(identifier)', snippet); }
// number if (first.isDigit()) { return number(snippet); } switch (snippet) {
// string case '"': case "'": return string(snippet);
// // comment case '//': comment(source_row, '//'); source_row = ''; break;
// /* comment case '/*': for (;;) { i = source_row.search(lx); if (i >= 0) { break; } character = source_row.length; comment(source_row); from = 0; if (!next_line()) { stop('unclosed_comment', line, character); } } comment(source_row.slice(0, i), '/*'); character += i + 2; if (source_row.charAt(i) === '/') { stop('nested_comment', line, character); } source_row = source_row.slice(i + 2); break; case '': break;
// / case '/': if (token.id === '/=') { stop('slash_equal', line, from); } return prereg ? regexp() : it('(punctuator)', snippet);
// punctuator default: return it('(punctuator)', snippet); } } } } }; }()); function define(kind, token) {
// Define a name. var name = token.string, master = scope[name]; // The current definition of the name
// vars are created with a deadzone, so that the expression that initializes
// the var cannot access the var. Functions are not writeable. token.dead = false; token.init = false; token.kind = kind; token.master = master; token.used = 0; token.writeable = true;
// Global variables are a little weird. They can be defined multiple times.
// Some predefined global vars are (or should) not be writeable. if (kind === 'var' && funct === global_funct) { if (!master) { if (predefined[name] === false) { token.writeable = false; } global_scope[name] = token; } } else {
// It is an error if the name has already been defined in this scope, except
// when reusing an exception variable name. if (master) { if (master.function === funct) { if (master.kind !== 'exception' || kind !== 'exception' || !master.dead) { token.warn('already_defined', name); } } else if (master.function !== global_funct) { if (kind === 'var') { token.warn('redefinition_a_b', name, master.line); } } } scope[name] = token; if (kind === 'var') { block_var.push(name); } } } function peek(distance) {
// Peek ahead to a future token. The distance is how far ahead to look. The
// default is the next token. var found, slot = 0; distance = distance || 0; while (slot <= distance) { found = lookahead[slot]; if (!found) { found = lookahead[slot] = lex.token(); } slot += 1; } return found; } function advance(id, match) {
// Produce the next token, also looking for programming errors. if (indent) {
// If indentation checking was requested, then inspect all of the line breakings.
// The var statement is tricky because the names might be aligned or not. We
// look at the first line break after the var to determine the programmer's
// intention. if (var_mode && next_token.line !== token.line) { if ((var_mode !== indent || !next_token.edge) && next_token.from === indent.at - (next_token.edge ? option.indent : 0)) { var dent = indent; for (;;) { dent.at -= option.indent; if (dent === var_mode) { break; } dent = dent.was; } dent.open = false; } var_mode = null; } if (next_token.id === '?' && indent.mode === ':' && token.line !== next_token.line) { indent.at -= option.indent; } if (indent.open) {
// If the token is an edge. if (next_token.edge) { if (next_token.edge === 'label') { expected_at(1); } else if (next_token.edge === 'case' || indent.mode === 'statement') { expected_at(indent.at - option.indent); } else if (indent.mode !== 'array' || next_token.line !== token.line) { expected_at(indent.at); }
// If the token is not an edge, but is the first token on the line. } else if (next_token.line !== token.line) { if (next_token.from < indent.at + (indent.mode === 'expression' ? 0 : option.indent)) { expected_at(indent.at + option.indent); } indent.wrap = true; } } else if (next_token.line !== token.line) { if (next_token.edge) { expected_at(indent.at); } else { indent.wrap = true; if (indent.mode === 'statement' || indent.mode === 'var') { expected_at(indent.at + option.indent); } else if (next_token.from < indent.at + (indent.mode === 'expression' ? 0 : option.indent)) { expected_at(indent.at + option.indent); } } } } switch (token.id) { case '(number)': if (next_token.id === '.') { next_token.warn('trailing_decimal_a'); } break; case '-': if (next_token.id === '-' || next_token.id === '--') { next_token.warn('confusing_a'); } break; case '+': if (next_token.id === '+' || next_token.id === '++') { next_token.warn('confusing_a'); } break; } if (token.id === '(string)' || token.identifier) { anonname = token.string; } if (id && next_token.id !== id) { if (match) { next_token.warn('expected_a_b_from_c_d', id, match.id, match.line, artifact()); } else if (!next_token.identifier || next_token.string !== id) { next_token.warn('expected_a_b', id, artifact()); } } prev_token = token; token = next_token; next_token = lookahead.shift() || lex.token(); next_token.function = funct; tokens.push(next_token); } function do_globals() { var name, writeable; for (;;) { if (next_token.id !== '(string)' && !next_token.identifier) { return; } name = next_token.string; advance(); writeable = false; if (next_token.id === ':') { advance(':'); switch (next_token.id) { case 'true': writeable = predefined[name] !== false; advance('true'); break; case 'false': advance('false'); break; default: next_token.stop('unexpected_a'); } } predefined[name] = writeable; if (next_token.id !== ',') { return; } advance(','); } } function do_jslint() { var name, value; while (next_token.id === '(string)' || next_token.identifier) { name = next_token.string; if (!allowed_option[name]) { next_token.stop('unexpected_a'); } advance(); if (next_token.id !== ':') { next_token.stop('expected_a_b', ':', artifact()); } advance(':'); if (typeof allowed_option[name] === 'number') { value = next_token.number; if (value > allowed_option[name] || value <= 0 || Math.floor(value) !== value) { next_token.stop('expected_small_a'); } option[name] = value; } else { if (next_token.id === 'true') { option[name] = true; } else if (next_token.id === 'false') { option[name] = false; } else { next_token.stop('unexpected_a'); } } advance(); if (next_token.id === ',') { advance(','); } } assume(); } function do_properties() { var name; option.properties = true; for (;;) { if (next_token.id !== '(string)' && !next_token.identifier) { return; } name = next_token.string; advance(); if (next_token.id === ':') { for (;;) { advance(); if (next_token.id !== '(string)' && !next_token.identifier) { break; } } } property[name] = 0; if (next_token.id !== ',') { return; } advance(','); } } directive = function directive() { var command = this.id, old_comments_off = comments_off, old_indent = indent; comments_off = true; indent = null; if (next_token.line === token.line && next_token.from === token.thru) { next_token.warn('missing_space_a_b', artifact(token), artifact()); } if (lookahead.length > 0) { this.warn('unexpected_a'); } switch (command) { case '/*properties': case '/*property': case '/*members': case '/*member': do_properties(); break; case '/*jslint': do_jslint(); break; case '/*globals': case '/*global': do_globals(); break; default: this.stop('unexpected_a'); } comments_off = old_comments_off; advance('*/'); indent = old_indent; };
// Indentation intention function edge(mode) { next_token.edge = indent ? indent.open && (mode || 'edge') : ''; } function step_in(mode) { var open; if (typeof mode === 'number') { indent = { at: +mode, open: true, was: indent }; } else if (!indent) { indent = { at: 1, mode: 'statement', open: true }; } else if (mode === 'statement') { indent = { at: indent.at, open: true, was: indent }; } else { open = mode === 'var' || next_token.line !== token.line; indent = { at: (open || mode === 'control' ? indent.at + option.indent : indent.at) + (indent.wrap ? option.indent : 0), mode: mode, open: open, was: indent }; if (mode === 'var' && open) { var_mode = indent; } } } function step_out(id, symbol) { if (id) { if (indent && indent.open) { indent.at -= option.indent; edge(); } advance(id, symbol); } if (indent) { indent = indent.was; } }
// Functions for conformance of whitespace. function one_space(left, right) { left = left || token; right = right || next_token; if (right.id !== '(end)' && !option.white && (token.line !== right.line || token.thru + 1 !== right.from)) { right.warn('expected_space_a_b', artifact(token), artifact(right)); } } function one_space_only(left, right) { left = left || token; right = right || next_token; if (right.id !== '(end)' && (left.line !== right.line || (!option.white && left.thru + 1 !== right.from))) { right.warn('expected_space_a_b', artifact(left), artifact(right)); } } function no_space(left, right) { left = left || token; right = right || next_token; if ((!option.white) && left.thru !== right.from && left.line === right.line) { right.warn('unexpected_space_a_b', artifact(left), artifact(right)); } } function no_space_only(left, right) { left = left || token; right = right || next_token; if (right.id !== '(end)' && (left.line !== right.line || (!option.white && left.thru !== right.from))) { right.warn('unexpected_space_a_b', artifact(left), artifact(right)); } } function spaces(left, right) { if (!option.white) { left = left || token; right = right || next_token; if (left.thru === right.from && left.line === right.line) { right.warn('missing_space_a_b', artifact(left), artifact(right)); } } } function comma() { if (next_token.id !== ',') { warn('expected_a_b', token.line, token.thru, ',', artifact()); } else { if (!option.white) { no_space_only(); } advance(','); spaces(); } } function semicolon() { if (next_token.id !== ';') { warn('expected_a_b', token.line, token.thru, ';', artifact()); } else { if (!option.white) { no_space_only(); } advance(';'); if (semicolon_coda[next_token.id] !== true) { spaces(); } } } function use_strict() { if (next_token.string === 'use strict') { if (strict_mode) { next_token.warn('unnecessary_use'); } edge(); advance(); semicolon(); strict_mode = true; return true; } return false; } function are_similar(a, b) { if (a === b) { return true; } if (Array.isArray(a)) { if (Array.isArray(b) && a.length === b.length) { var i; for (i = 0; i < a.length; i += 1) { if (!are_similar(a[i], b[i])) { return false; } } return true; } return false; } if (Array.isArray(b)) { return false; } if (a.id === '(number)' && b.id === '(number)') { return a.number === b.number; } if (a.arity === b.arity && a.string === b.string) { switch (a.arity) { case undefined: return a.string === b.string; case 'prefix': case 'suffix': return a.id === b.id && are_similar(a.first, b.first) && a.id !== '{' && a.id !== '['; case 'infix': return are_similar(a.first, b.first) && are_similar(a.second, b.second); case 'ternary': return are_similar(a.first, b.first) && are_similar(a.second, b.second) && are_similar(a.third, b.third); case 'function': case 'regexp': return false; default: return true; } } if (a.id === '.' && b.id === '[' && b.arity === 'infix') { return a.second.string === b.second.string && b.second.id === '(string)'; } if (a.id === '[' && a.arity === 'infix' && b.id === '.') { return a.second.string === b.second.string && a.second.id === '(string)'; } return false; }
// This is the heart of JSLINT, the Pratt parser. In addition to parsing, it
// is looking for ad hoc lint patterns. We add .fud to Pratt's model, which is
// like .nud except that it is only used on the first token of a statement.
// Having .fud makes it much easier to define statement-oriented languages like
// JavaScript. I retained Pratt's nomenclature.
// .nud Null denotation
// .fud First null denotation
// .led Left denotation
// lbp Left binding power
// rbp Right binding power
// They are elements of the parsing method called Top Down Operator Precedence. function expression(rbp, initial) {
// rbp is the right binding power.
// initial indicates that this is the first expression of a statement. var left; if (next_token.id === '(end)') { token.stop('unexpected_a', next_token.id); } advance(); if (initial) { anonname = 'anonymous'; } if (initial === true && token.fud) { left = token.fud(); } else { if (token.nud) { left = token.nud(); } else { if (next_token.id === '(number)' && token.id === '.') { token.warn('leading_decimal_a', artifact()); advance(); return token; } token.stop('expected_identifier_a', artifact(token)); } while (rbp < next_token.lbp) { advance(); left = token.led(left); } } if (left && left.assign && !initial) { if (!option.ass) { left.warn('assignment_expression'); } if (left.id !== '=' && left.first.master) { left.first.master.used = true; } } return left; } protosymbol = { nud: function () { this.stop('unexpected_a'); }, led: function () { this.stop('expected_operator_a'); }, warn: function (code, a, b, c, d) { if (!this.warning) { this.warning = warn(code, this.line || 0, this.from || 0, a || artifact(this), b, c, d); } }, stop: function (code, a, b, c, d) { this.warning = undefined; this.warn(code, a, b, c, d); return quit('stopping', this.line, this.character); }, lbp: 0 };
// Functional constructors for making the symbols that will be inherited by
// tokens. function symbol(s, bp) { var x = syntax[s]; if (!x) { x = Object.create(protosymbol); x.id = x.string = s; x.lbp = bp || 0; syntax[s] = x; } return x; } function postscript(x) { x.postscript = true; return x; } function ultimate(s) { var x = symbol(s, 0); x.from = 1; x.thru = 1; x.line = 0; x.edge = 'edge'; x.string = s; return postscript(x); } function reserve_name(x) { var c = x.id.charAt(0); if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')) { x.identifier = x.reserved = true; } return x; } function stmt(s, f) { var x = symbol(s); x.fud = f; return reserve_name(x); } function disrupt_stmt(s, f) { var x = stmt(s, f); x.disrupt = true; } function labeled_stmt(s, f) { var x = stmt(s, function labeled() { var the_statement; if (funct.breakage) { funct.breakage.push(this); } else { funct.breakage = [this]; } the_statement = f.apply(this); if (funct.breakage.length > 1) { funct.breakage.pop(); } else { delete funct.breakage; } return the_statement; }); x.labeled = true; } function prefix(s, f) { var x = symbol(s, 150); reserve_name(x); x.nud = function () { var that = this; that.arity = 'prefix'; if (typeof f === 'function') { that = f(that); if (that.arity !== 'prefix') { return that; } } else { if (s === 'typeof') { one_space(); } else { no_space_only(); } that.first = expression(150); } switch (that.id) { case '++': case '--': if (!option.plusplus) { that.warn('unexpected_a'); } else if ((!that.first.identifier || that.first.reserved) && that.first.id !== '.' && that.first.id !== '[') { that.warn('bad_operand'); } break; default: if (that.first.arity === 'prefix' || that.first.arity === 'function') { that.warn('unexpected_a'); } } return that; }; return x; } function type(s, t, nud) { var x = symbol(s); x.arity = t; if (nud) { x.nud = nud; } return x; } function reserve(s, f) { var x = symbol(s); x.identifier = x.reserved = true; if (typeof f === 'function') { x.nud = f; } return x; } function constant(name) { var x = reserve(name); x.string = name; x.nud = return_this; return x; } function reservevar(s, v) { return reserve(s, function () { if (typeof v === 'function') { v(this); } return this; }); } function infix(s, p, f, w) { var x = symbol(s, p); reserve_name(x); x.led = function (left) { this.arity = 'infix'; if (!w) { spaces(prev_token, token); spaces(); } if (!option.bitwise && this.bitwise) { this.warn('unexpected_a'); } if (typeof f === 'function') { return f(left, this); } this.first = left; this.second = expression(p); return this; }; return x; } function expected_relation(node, message) { if (node.assign) { node.warn(message || 'conditional_assignment'); } return node; } function expected_condition(node, message) { switch (node.id) { case '[': case '-': if (node.arity !== 'infix') { node.warn(message || 'weird_condition'); } break; case 'false': case 'function': case 'Infinity': case 'NaN': case 'null': case 'true': case 'undefined': case 'void': case '(number)': case '(regexp)': case '(string)': case '{': case '?': case '~': node.warn(message || 'weird_condition'); break; case '(': if (node.first.id === 'new' || (node.first.string === 'Boolean') || (node.first.id === '.' && numbery[node.first.second.string] === true)) { node.warn(message || 'weird_condition'); } break; } return node; } function check_relation(node) { switch (node.arity) { case 'prefix': switch (node.id) { case '{': case '[': node.warn('unexpected_a'); break; case '!': node.warn('confusing_a'); break; } break; case 'function': case 'regexp': node.warn('unexpected_a'); break; default: if (node.id === 'NaN') { node.warn('isNaN'); } else if (node.relation) { node.warn('weird_relation'); } } return node; } function relation(s, eqeq) { var x = infix(s, 100, function (left, that) { check_relation(left); if (eqeq && !option.eqeq) { that.warn('expected_a_b', eqeq, that.id); } var right = expression(100); if (are_similar(left, right) || ((left.id === '(string)' || left.id === '(number)') && (right.id === '(string)' || right.id === '(number)'))) { that.warn('weird_relation'); } else if (left.id === 'typeof') { if (right.id !== '(string)') { right.warn("expected_string_a", artifact(right)); } else if (right.string === 'undefined' || right.string === 'null') { left.warn("unexpected_typeof_a", right.string); } } else if (right.id === 'typeof') { if (left.id !== '(string)') { left.warn("expected_string_a", artifact(left)); } else if (left.string === 'undefined' || left.string === 'null') { right.warn("unexpected_typeof_a", left.string); } } that.first = left; that.second = check_relation(right); return that; }); x.relation = true; return x; } function lvalue(that, s) { var master; if (that.identifier) { master = scope[that.string]; if (master) { if (scope[that.string].writeable !== true) { that.warn('read_only'); } master.used -= 1; if (s === '=') { master.init = true; } } } else if (that.id === '.' || that.id === '[') { if (!that.first || that.first.string === 'arguments') { that.warn('bad_assignment'); } } else { that.warn('bad_assignment'); } } function assignop(s, op) { var x = infix(s, 20, function (left, that) { var next; that.first = left; lvalue(left, s); that.second = expression(20); if (that.id === '=' && are_similar(that.first, that.second)) { that.warn('weird_assignment'); } next = that; while (next_token.id === '=') { lvalue(next.second, '='); next_token.first = next.second; next.second = next_token; next = next_token; advance('='); next.second = expression(20); } return that; }); x.assign = true; if (op) { if (syntax[op].bitwise) { x.bitwise = true; } } return x; } function bitwise(s, p) { var x = infix(s, p, 'number'); x.bitwise = true; return x; } function suffix(s) { var x = symbol(s, 150); x.led = function (left) { no_space_only(prev_token, token); if (!option.plusplus) { this.warn('unexpected_a'); } else if ((!left.identifier || left.reserved) && left.id !== '.' && left.id !== '[') { this.warn('bad_operand'); } this.first = left; this.arity = 'suffix'; return this; }; return x; } function optional_identifier(variable) { if (next_token.identifier) { advance(); if (token.reserved && variable) { token.warn('expected_identifier_a_reserved'); } return token.string; } } function identifier(variable) { var i = optional_identifier(variable); if (!i) { next_token.stop(token.id === 'function' && next_token.id === '(' ? 'name_function' : 'expected_identifier_a'); } return i; } function statement() { var label, preamble, the_statement;
// We don't like the empty statement. if (next_token.id === ';') { next_token.warn('unexpected_a'); semicolon(); return; }
// Is this a labeled statement? if (next_token.identifier && !next_token.reserved && peek().id === ':') { edge('label'); label = next_token; advance(); advance(':'); define('label', label); if (next_token.labeled !== true || funct === global_funct) { label.stop('unexpected_label_a'); } else if (jx.test(label.string + ':')) { label.warn('url'); } next_token.label = label; label.init = true; label.statement = next_token; }
// Parse the statement. preamble = next_token; if (token.id !== 'else') { edge(); } step_in('statement'); the_statement = expression(0, true); if (the_statement) {
// Look for the final semicolon. if (the_statement.arity === 'statement') { if (the_statement.id === 'switch' || (the_statement.block && the_statement.id !== 'do')) { spaces(); } else { semicolon(); } } else {
// If this is an expression statement, determine if it is acceptable.
// We do not like
// new Blah;
// statements. If it is to be used at all, new should only be used to make
// objects, not side effects. The expression statements we do like do
// assignment or invocation or delete. if (the_statement.id === '(') { if (the_statement.first.id === 'new') { next_token.warn('bad_new'); } } else if (the_statement.id === '++' || the_statement.id === '--') { lvalue(the_statement.first); } else if (!the_statement.assign && the_statement.id !== 'delete') { if (!option.closure || !preamble.comments) { preamble.warn('assignment_function_expression'); } } semicolon(); } } step_out(); if (label) { label.dead = true; } return the_statement; } function statements() { var array = [], disruptor, the_statement;
// A disrupt statement may not be followed by any other statement.
// If the last statement is disrupt, then the sequence is disrupt. while (next_token.postscript !== true) { if (next_token.id === ';') { next_token.warn('unexpected_a'); semicolon(); } else { if (next_token.string === 'use strict') { if ((!node_js) || funct !== global_funct || array.length > 0) { next_token.warn('function_strict'); } use_strict(); } if (disruptor) { next_token.warn('unreachable_a_b', next_token.string, disruptor.string); disruptor = null; } the_statement = statement(); if (the_statement) { array.push(the_statement); if (the_statement.disrupt) { disruptor = the_statement; array.disrupt = true; } } } } return array; } function block(kind) {
// A block is a sequence of statements wrapped in braces. var array, curly = next_token, old_block_var = block_var, old_in_block = in_block, old_strict_mode = strict_mode; in_block = kind !== 'function' && kind !== 'try' && kind !== 'catch'; block_var = []; if (curly.id === '{') { spaces(); advance('{'); step_in(); if (kind === 'function' && !use_strict() && !old_strict_mode && !option.sloppy && funct.level === 1) { next_token.warn('missing_use_strict'); } array = statements(); strict_mode = old_strict_mode; step_out('}', curly); } else if (in_block) { curly.stop('expected_a_b', '{', artifact()); } else { curly.warn('expected_a_b', '{', artifact()); array = [statement()]; array.disrupt = array[0].disrupt; } if (kind !== 'catch' && array.length === 0) { curly.warn('empty_block'); } block_var.forEach(function (name) { scope[name].dead = true; }); block_var = old_block_var; in_block = old_in_block; return array; } function tally_property(name) { if (option.properties && typeof property[name] !== 'number') { token.warn('unexpected_property_a', name); } if (property[name]) { property[name] += 1; } else { property[name] = 1; } }
// ECMAScript parser (function () { var x = symbol('(identifier)'); x.nud = function () { var name = this.string, master = scope[name], writeable;
// If the master is not in scope, then we may have an undeclared variable.
// Check the predefined list. If it was predefined, create the global
// variable. if (!master) { writeable = predefined[name]; if (typeof writeable === 'boolean') { global_scope[name] = master = { dead: false, function: global_funct, kind: 'var', string: name, writeable: writeable };
// But if the variable is not in scope, and is not predefined, and if we are not
// in the global scope, then we have an undefined variable error. } else { token.warn('used_before_a'); } } else { this.master = master; }
// Annotate uses that cross scope boundaries. if (master) { if (master.kind === 'label') { this.warn('a_label'); } else { if (master.dead === true || master.dead === funct) { this.warn('a_scope'); } master.used += 1; if (master.function !== funct) { if (master.function === global_funct) { funct.global.push(name); } else { master.function.closure.push(name); funct.outer.push(name); } } } } return this; }; x.identifier = true; }());
// Build the syntax table by declaring the syntactic elements. type('(array)', 'array'); type('(function)', 'function'); type('(number)', 'number', return_this); type('(object)', 'object'); type('(string)', 'string', return_this); type('(boolean)', 'boolean', return_this); type('(regexp)', 'regexp', return_this); ultimate('(begin)'); ultimate('(end)'); ultimate('(error)'); postscript(symbol('}')); symbol(')'); symbol(']'); postscript(symbol('"')); postscript(symbol('\'')); symbol(';'); symbol(':'); symbol(','); symbol('#'); symbol('@'); symbol('*/'); postscript(reserve('case')); reserve('catch'); postscript(reserve('default')); reserve('else'); reserve('finally'); reservevar('arguments', function (x) { if (strict_mode && funct === global_funct) { x.warn('strict'); } funct.arguments = true; }); reservevar('eval'); constant('false', 'boolean'); constant('Infinity', 'number'); constant('NaN', 'number'); constant('null', ''); reservevar('this', function (x) { if (strict_mode && funct.statement && funct.name.charAt(0) > 'Z') { x.warn('strict'); } }); constant('true', 'boolean'); constant('undefined', ''); infix('?', 30, function (left, that) { step_in('?'); that.first = expected_condition(expected_relation(left)); that.second = expression(0); spaces(); step_out(); var colon = next_token; advance(':'); step_in(':'); spaces(); that.third = expression(10); that.arity = 'ternary'; if (are_similar(that.second, that.third)) { colon.warn('weird_ternary'); } else if (are_similar(that.first, that.second)) { that.warn('use_or'); } step_out(); return that; }); infix('||', 40, function (left, that) { function paren_check(that) { if (that.id === '&&' && !that.paren) { that.warn('and'); } return that; } that.first = paren_check(expected_condition(expected_relation(left))); that.second = paren_check(expected_relation(expression(40))); if (are_similar(that.first, that.second)) { that.warn('weird_condition'); } return that; }); infix('&&', 50, function (left, that) { that.first = expected_condition(expected_relation(left)); that.second = expected_relation(expression(50)); if (are_similar(that.first, that.second)) { that.warn('weird_condition'); } return that; }); prefix('void', function (that) { that.first = expression(0); that.warn('expected_a_b', 'undefined', 'void'); return that; }); bitwise('|', 70); bitwise('^', 80); bitwise('&', 90); relation('==', '==='); relation('==='); relation('!=', '!=='); relation('!=='); relation('<'); relation('>'); relation('<='); relation('>='); bitwise('<<', 120); bitwise('>>', 120); bitwise('>>>', 120); infix('in', 120, function (left, that) { that.warn('infix_in'); that.left = left; that.right = expression(130); return that; }); infix('instanceof', 120); infix('+', 130, function (left, that) { if (left.id === '(number)') { if (left.number === 0) { left.warn('unexpected_a', '0'); } } else if (left.id === '(string)') { if (left.string === '') { left.warn('expected_a_b', 'String', '\'\''); } } var right = expression(130); if (right.id === '(number)') { if (right.number === 0) { right.warn('unexpected_a', '0'); } } else if (right.id === '(string)') { if (right.string === '') { right.warn('expected_a_b', 'String', '\'\''); } } if (left.id === right.id) { if (left.id === '(string)' || left.id === '(number)') { if (left.id === '(string)') { left.string += right.string; if (jx.test(left.string)) { left.warn('url'); } } else { left.number += right.number; } left.thru = right.thru; return left; } } that.first = left; that.second = right; return that; }); prefix('+'); prefix('+++', function () { token.warn('confusing_a'); this.first = expression(150); this.arity = 'prefix'; return this; }); infix('+++', 130, function (left) { token.warn('confusing_a'); this.first = left; this.second = expression(130); return this; }); infix('-', 130, function (left, that) { if ((left.id === '(number)' && left.number === 0) || left.id === '(string)') { left.warn('unexpected_a'); } var right = expression(130); if ((right.id === '(number)' && right.number === 0) || right.id === '(string)') { right.warn('unexpected_a'); } if (left.id === right.id && left.id === '(number)') { left.number -= right.number; left.thru = right.thru; return left; } that.first = left; that.second = right; return that; }); prefix('-'); prefix('---', function () { token.warn('confusing_a'); this.first = expression(150); this.arity = 'prefix'; return this; }); infix('---', 130, function (left) { token.warn('confusing_a'); this.first = left; this.second = expression(130); return this; }); infix('*', 140, function (left, that) { if ((left.id === '(number)' && (left.number === 0 || left.number === 1)) || left.id === '(string)') { left.warn('unexpected_a'); } var right = expression(140); if ((right.id === '(number)' && (right.number === 0 || right.number === 1)) || right.id === '(string)') { right.warn('unexpected_a'); } if (left.id === right.id && left.id === '(number)') { left.number *= right.number; left.thru = right.thru; return left; } that.first = left; that.second = right; return that; }); infix('/', 140, function (left, that) { if ((left.id === '(number)' && left.number === 0) || left.id === '(string)') { left.warn('unexpected_a'); } var right = expression(140); if ((right.id === '(number)' && (right.number === 0 || right.number === 1)) || right.id === '(string)') { right.warn('unexpected_a'); } if (left.id === right.id && left.id === '(number)') { left.number /= right.number; left.thru = right.thru; return left; } that.first = left; that.second = right; return that; }); infix('%', 140, function (left, that) { if ((left.id === '(number)' && (left.number === 0 || left.number === 1)) || left.id === '(string)') { left.warn('unexpected_a'); } var right = expression(140); if ((right.id === '(number)' && right.number === 0) || right.id === '(string)') { right.warn('unexpected_a'); } if (left.id === right.id && left.id === '(number)') { left.number %= right.number; left.thru = right.thru; return left; } that.first = left; that.second = right; return that; }); suffix('++'); prefix('++'); suffix('--'); prefix('--'); prefix('delete', function (that) { one_space(); var p = expression(0); if (!p || (p.id !== '.' && p.id !== '[')) { next_token.warn('deleted'); } that.first = p; return that; }); prefix('~', function (that) { no_space_only(); if (!option.bitwise) { that.warn('unexpected_a'); } that.first = expression(150); return that; }); function banger(that) { no_space_only(); that.first = expected_condition(expression(150)); if (bang[that.first.id] === that || that.first.assign) { that.warn('confusing_a'); } return that; } prefix('!', banger); prefix('!!', banger); prefix('typeof'); prefix('new', function (that) { one_space(); var c = expression(160), n, p, v; that.first = c; if (c.id !== 'function') { if (c.identifier) { switch (c.string) { case 'Object': token.warn('use_object'); break; case 'Array': if (next_token.id === '(') { p = next_token; p.first = this; advance('('); if (next_token.id !== ')') { n = expression(0); p.second = [n]; if (n.id === '(string)' || next_token.id === ',') { p.warn('use_array'); } while (next_token.id === ',') { advance(','); p.second.push(expression(0)); } } else { token.warn('use_array'); } advance(')', p); return p; } token.warn('use_array'); break; case 'Number': case 'String': case 'Boolean': case 'Math': case 'JSON': c.warn('not_a_constructor'); break; case 'Function': if (!option.evil) { next_token.warn('function_eval'); } break; case 'Date': case 'RegExp': case 'this': break; default: if (c.id !== 'function') { v = c.string.charAt(0); if (!option.newcap && (v < 'A' || v > 'Z')) { token.warn('constructor_name_a'); } } } } else { if (c.id !== '.' && c.id !== '[' && c.id !== '(') { token.warn('bad_constructor'); } } } else { that.warn('weird_new'); } if (next_token.id !== '(') { next_token.warn('missing_a', '()'); } return that; }); infix('(', 160, function (left, that) { var e, p; if (indent && indent.mode === 'expression') { no_space(prev_token, token); } else { no_space_only(prev_token, token); } if (!left.immed && left.id === 'function') { next_token.warn('wrap_immediate'); } p = []; if (left.identifier) { if (left.string.match(/^[A-Z]([A-Z0-9_$]*[a-z][A-Za-z0-9_$]*)?$/)) { if (left.string !== 'Number' && left.string !== 'String' && left.string !== 'Boolean' && left.string !== 'Date') { if (left.string === 'Math') { left.warn('not_a_function'); } else if (left.string === 'Object') { token.warn('use_object'); } else if (left.string === 'Array' || !option.newcap) { left.warn('missing_a', 'new'); } } } else if (left.string === 'JSON') { left.warn('not_a_function'); } } else if (left.id === '.') { if (left.second.string === 'split' && left.first.id === '(string)') { left.second.warn('use_array'); } } step_in(); if (next_token.id !== ')') { no_space(); for (;;) { edge(); e = expression(10); if (left.string === 'Boolean' && (e.id === '!' || e.id === '~')) { e.warn('weird_condition'); } p.push(e); if (next_token.id !== ',') { break; } comma(); } } no_space(); step_out(')', that); if (typeof left === 'object') { if (left.string === 'parseInt' && p.length === 1) { left.warn('radix'); } else if (left.string === 'String' && p.length >= 1 && p[0].id === '(string)') { left.warn('unexpected_a'); } if (!option.evil) { if (left.string === 'eval' || left.string === 'Function' || left.string === 'execScript') { left.warn('evil'); } else if (p[0] && p[0].id === '(string)' && (left.string === 'setTimeout' || left.string === 'setInterval')) { left.warn('implied_evil'); } } if (!left.identifier && left.id !== '.' && left.id !== '[' && left.id !== '(' && left.id !== '&&' && left.id !== '||' && left.id !== '?') { left.warn('bad_invocation'); } if (left.id === '.') { if (p.length > 0 && left.first && left.first.first && are_similar(p[0], left.first.first)) { if (left.second.string === 'call' || (left.second.string === 'apply' && (p.length === 1 || (p[1].arity === 'prefix' && p[1].id === '[')))) { left.second.warn('unexpected_a'); } } if (left.second.string === 'toString') { if (left.first.id === '(string)' || left.first.id === '(number)') { left.second.warn('unexpected_a'); } } } } that.first = left; that.second = p; return that; }, true); prefix('(', function (that) { step_in('expression'); no_space(); edge(); if (next_token.id === 'function') { next_token.immed = true; } var value = expression(0); value.paren = true; no_space(); step_out(')', that); if (value.id === 'function') { switch (next_token.id) { case '(': next_token.warn('move_invocation'); break; case '.': case '[': next_token.warn('unexpected_a'); break; default: that.warn('bad_wrap'); } } else if (!value.arity) { if (!option.closure || !that.comments) { that.warn('unexpected_a'); } } return value; }); infix('.', 170, function (left, that) { no_space(prev_token, token); no_space(); var name = identifier(); if (typeof name === 'string') { tally_property(name); } that.first = left; that.second = token; if (left && left.string === 'arguments' && (name === 'callee' || name === 'caller')) { left.warn('avoid_a', 'arguments.' + name); } else if (!option.evil && left && left.string === 'document' && (name === 'write' || name === 'writeln')) { left.warn('write_is_wrong'); } else if (!option.stupid && syx.test(name)) { token.warn('sync_a'); } if (!option.evil && (name === 'eval' || name === 'execScript')) { next_token.warn('evil'); } return that; }, true); infix('[', 170, function (left, that) { var e, s; no_space_only(prev_token, token); no_space(); step_in(); edge(); e = expression(0); switch (e.id) { case '(number)': if (e.id === '(number)' && left.id === 'arguments') { left.warn('use_param'); } break; case '(string)': if (!option.evil && (e.string === 'eval' || e.string === 'execScript')) { e.warn('evil'); } else if (!option.sub && ix.test(e.string)) { s = syntax[e.string]; if (!s || !s.reserved) { e.warn('subscript'); } } tally_property(e.string); break; } step_out(']', that); no_space(prev_token, token); that.first = left; that.second = e; return that; }, true); prefix('[', function (that) { that.first = []; step_in('array'); while (next_token.id !== '(end)') { while (next_token.id === ',') { next_token.warn('unexpected_a'); advance(','); } if (next_token.id === ']') { break; } indent.wrap = false; edge(); that.first.push(expression(10)); if (next_token.id === ',') { comma(); if (next_token.id === ']') { token.warn('unexpected_a'); break; } } else { break; } } step_out(']', that); return that; }, 170); function property_name() { var id = optional_identifier(); if (!id) { if (next_token.id === '(string)') { id = next_token.string; advance(); } else if (next_token.id === '(number)') { id = next_token.number.toString(); advance(); } } return id; } assignop('='); assignop('+=', '+'); assignop('-=', '-'); assignop('*=', '*'); assignop('/=', '/').nud = function () { next_token.stop('slash_equal'); }; assignop('%=', '%'); assignop('&=', '&'); assignop('|=', '|'); assignop('^=', '^'); assignop('<<=', '<<'); assignop('>>=', '>>'); assignop('>>>=', '>>>'); function function_parameters() { var id, parameters = [], paren = next_token; advance('('); token.function = funct; step_in(); no_space(); if (next_token.id !== ')') { for (;;) { edge(); id = identifier(); define('parameter', token); parameters.push(id); token.init = true; token.writeable = true; if (next_token.id !== ',') { break; } comma(); } } no_space(); step_out(')', paren); return parameters; } function do_function(func, name) { var old_funct = funct, old_option = option, old_scope = scope; scope = Object.create(old_scope); funct = { closure: [], global: [], level: old_funct.level + 1, line: next_token.line, loopage: 0, name: name || '\'' + (anonname || '').replace(nx, sanitize) + '\'', outer: [], scope: scope }; funct.parameter = function_parameters(); func.function = funct; option = Object.create(old_option); functions.push(funct); if (name) { func.name = name; func.string = name; define('function', func); func.init = true; func.used += 1; } func.writeable = false; one_space(); func.block = block('function'); Object.keys(scope).forEach(function (name) { var master = scope[name]; if (!master.used && master.kind !== 'exception' && (master.kind !== 'parameter' || !option.unparam)) { master.warn('unused_a'); } else if (!master.init) { master.warn('uninitialized_a'); } }); funct = old_funct; option = old_option; scope = old_scope; } prefix('{', function (that) { var get, i, j, name, set, seen = Object.create(null); that.first = []; step_in(); while (next_token.id !== '}') { indent.wrap = false;
// JSLint recognizes the ES5 extension for get/set in object literals,
// but requires that they be used in pairs. edge(); if (next_token.string === 'get' && peek().id !== ':') { get = next_token; advance('get'); one_space_only(); name = next_token; i = property_name(); if (!i) { next_token.stop('missing_property'); } get.string = ''; do_function(get); if (funct.loopage) { get.warn('function_loop'); } if (get.function.parameter.length) { get.warn('parameter_a_get_b', get.function.parameter[0], i); } comma(); set = next_token; spaces(); edge(); advance('set'); set.string = ''; one_space_only(); j = property_name(); if (i !== j) { token.stop('expected_a_b', i, j || next_token.string); } do_function(set); if (set.block.length === 0) { token.warn('missing_a', 'throw'); } if (set.function.parameter.length === 0) { set.stop('parameter_set_a', 'value'); } else if (set.function.parameter[0] !== 'value') { set.stop('expected_a_b', 'value', set.function.parameter[0]); } name.first = [get, set]; } else { name = next_token; i = property_name(); if (typeof i !== 'string') { next_token.stop('missing_property'); } advance(':'); spaces(); name.first = expression(10); } that.first.push(name); if (seen[i] === true) { next_token.warn('duplicate_a', i); } seen[i] = true; tally_property(i); if (next_token.id !== ',') { break; } for (;;) { comma(); if (next_token.id !== ',') { break; } next_token.warn('unexpected_a'); } if (next_token.id === '}') { token.warn('unexpected_a'); } } step_out('}', that); return that; }); stmt('{', function () { next_token.warn('statement_block'); this.arity = 'statement'; this.block = statements(); this.disrupt = this.block.disrupt; advance('}', this); return this; }); stmt('/*global', directive); stmt('/*globals', directive); stmt('/*jslint', directive); stmt('/*member', directive); stmt('/*members', directive); stmt('/*property', directive); stmt('/*properties', directive); stmt('var', function () {
// JavaScript does not have block scope. It only has function scope. So,
// declaring a variable in a block can have unexpected consequences.
// var.first will contain an array, the array containing name tokens
// and assignment tokens. var assign, id, name; if (funct.loopage) { next_token.warn('var_loop'); } else if (funct.varstatement && !option.vars) { next_token.warn('combine_var'); } if (funct !== global_funct) { funct.varstatement = true; } this.arity = 'statement'; this.first = []; step_in('var'); for (;;) { name = next_token; id = identifier(true); define('var', name); name.dead = funct; if (next_token.id === '=') { if (funct === global_funct && !name.writeable) { name.warn('read_only'); } assign = next_token; assign.first = name; spaces(); advance('='); spaces(); if (next_token.id === 'undefined') { token.warn('unnecessary_initialize', id); } if (peek(0).id === '=' && next_token.identifier) { next_token.stop('var_a_not'); } assign.second = expression(0); assign.arity = 'infix'; name.init = true; this.first.push(assign); } else { this.first.push(name); } name.dead = false; name.writeable = true; if (next_token.id !== ',') { break; } comma(); indent.wrap = false; if (var_mode && next_token.line === token.line && this.first.length === 1) { var_mode = null; indent.open = false; indent.at -= option.indent; } spaces(); edge(); } var_mode = null; step_out(); return this; }); stmt('function', function () { one_space(); if (in_block) { token.warn('function_block'); } var name = next_token, id = identifier(true); define('var', name); if (!name.writeable) { name.warn('read_only'); } name.init = true; name.statement = true; no_space(); this.arity = 'statement'; do_function(this, id); if (next_token.id === '(' && next_token.line === token.line) { next_token.stop('function_statement'); } return this; }); prefix('function', function (that) { var id = optional_identifier(true), name; if (id) { name = token; no_space(); } else { id = ''; one_space(); } do_function(that, id); if (name) { name.function = that.function; } if (funct.loopage) { that.warn('function_loop'); } switch (next_token.id) { case ';': case '(': case ')': case ',': case ']': case '}': case ':': case '(end)': break; case '.': if (peek().string !== 'bind' || peek(1).id !== '(') { next_token.warn('unexpected_a'); } break; default: next_token.stop('unexpected_a'); } that.arity = 'function'; return that; }); stmt('if', function () { var paren = next_token; one_space(); advance('('); step_in('control'); no_space(); edge(); this.arity = 'statement'; this.first = expected_condition(expected_relation(expression(0))); no_space(); step_out(')', paren); one_space(); this.block = block('if'); if (next_token.id === 'else') { if (this.block.disrupt) { next_token.warn(this.elif ? 'use_nested_if' : 'unnecessary_else'); } one_space(); advance('else'); one_space(); if (next_token.id === 'if') { next_token.elif = true; this.else = statement(true); } else { this.else = block('else'); } if (this.else.disrupt && this.block.disrupt) { this.disrupt = true; } } return this; }); stmt('try', function () {
// try.first The catch variable
// try.second The catch clause
// try.third The finally clause
// try.block The try block var exception_variable, paren; one_space(); this.arity = 'statement'; this.block = block('try'); if (next_token.id === 'catch') { one_space(); advance('catch'); one_space(); paren = next_token; advance('('); step_in('control'); no_space(); edge(); exception_variable = next_token; this.first = identifier(); define('exception', exception_variable); exception_variable.init = true; no_space(); step_out(')', paren); one_space(); this.second = block('catch'); if (this.second.length) { if (this.first === 'ignore') { exception_variable.warn('unexpected_a'); } } else { if (this.first !== 'ignore') { exception_variable.warn('expected_a_b', 'ignore', exception_variable.string); } } exception_variable.dead = true; } if (next_token.id === 'finally') { one_space(); advance('finally'); one_space(); this.third = block('finally'); } else if (!this.second) { next_token.stop('expected_a_b', 'catch', artifact()); } return this; }); labeled_stmt('while', function () { one_space(); var paren = next_token; funct.loopage += 1; advance('('); step_in('control'); no_space(); edge(); this.arity = 'statement'; this.first = expected_relation(expression(0)); if (this.first.id !== 'true') { expected_condition(this.first, 'unexpected_a'); } no_space(); step_out(')', paren); one_space(); this.block = block('while'); if (this.block.disrupt) { prev_token.warn('strange_loop'); } funct.loopage -= 1; return this; }); reserve('with'); labeled_stmt('switch', function () {
// switch.first the switch expression
// switch.second the array of cases. A case is 'case' or 'default' token:
// case.first the array of case expressions
// case.second the array of statements
// If all of the arrays of statements are disrupt, then the switch is disrupt. var cases = [], old_in_block = in_block, particular, that = token, the_case = next_token; function find_duplicate_case(value) { if (are_similar(particular, value)) { value.warn('duplicate_a'); } } one_space(); advance('('); no_space(); step_in(); this.arity = 'statement'; this.first = expected_condition(expected_relation(expression(0))); no_space(); step_out(')', the_case); one_space(); advance('{'); step_in(); in_block = true; this.second = []; if (that.from !== next_token.from && !option.white) { next_token.warn('expected_a_at_b_c', next_token.string, that.from, next_token.from); } while (next_token.id === 'case') { the_case = next_token; the_case.first = []; the_case.arity = 'case'; for (;;) { spaces(); edge('case'); advance('case'); one_space(); particular = expression(0); cases.forEach(find_duplicate_case); cases.push(particular); the_case.first.push(particular); if (particular.id === 'NaN') { particular.warn('unexpected_a'); } no_space_only(); advance(':'); if (next_token.id !== 'case') { break; } } spaces(); the_case.second = statements(); if (the_case.second && the_case.second.length > 0) { if (!the_case.second[the_case.second.length - 1].disrupt) { next_token.warn('missing_a_after_b', 'break', 'case'); } } else { next_token.warn('empty_case'); } this.second.push(the_case); } if (this.second.length === 0) { next_token.warn('missing_a', 'case'); } if (next_token.id === 'default') { spaces(); the_case = next_token; the_case.arity = 'case'; edge('case'); advance('default'); no_space_only(); advance(':'); spaces(); the_case.second = statements(); if (the_case.second && the_case.second.length > 0) { this.disrupt = the_case.second[the_case.second.length - 1].disrupt; } else { the_case.warn('empty_case'); } this.second.push(the_case); } if (this.break) { this.disrupt = false; } spaces(); step_out('}', this); in_block = old_in_block; return this; }); stmt('debugger', function () { if (!option.debug) { this.warn('unexpected_a'); } this.arity = 'statement'; return this; }); labeled_stmt('do', function () { funct.loopage += 1; one_space(); this.arity = 'statement'; this.block = block('do'); if (this.block.disrupt) { prev_token.warn('strange_loop'); } one_space(); advance('while'); var paren = next_token; one_space(); advance('('); step_in(); no_space(); edge(); this.first = expected_condition(expected_relation(expression(0)), 'unexpected_a'); no_space(); step_out(')', paren); funct.loopage -= 1; return this; }); labeled_stmt('for', function () { var blok, filter, master, ok = false, paren = next_token, value; this.arity = 'statement'; funct.loopage += 1; advance('('); if (next_token.id === ';') { no_space(); advance(';'); no_space(); advance(';'); no_space(); advance(')'); blok = block('for'); } else { step_in('control'); spaces(this, paren); no_space(); if (next_token.id === 'var') { next_token.stop('move_var'); } edge(); if (peek(0).id === 'in') { this.forin = true; value = expression(1000); master = value.master; if (master.kind !== 'var' || master.function !== funct || !master.writeable || master.dead) { value.warn('bad_in_a'); } master.init = true; master.used -= 1; this.first = value; advance('in'); this.second = expression(20); step_out(')', paren); blok = block('for'); if (!option.forin) { if (blok.length === 1 && typeof blok[0] === 'object') { if (blok[0].id === 'if' && !blok[0].else) { filter = blok[0].first; while (filter.id === '&&') { filter = filter.first; } switch (filter.id) { case '===': case '!==': ok = filter.first.id === '[' ? are_similar(filter.first.first, this.second) && are_similar(filter.first.second, this.first) : filter.first.id === 'typeof' && filter.first.first.id === '[' && are_similar(filter.first.first.first, this.second) && are_similar(filter.first.first.second, this.first); break; case '(': ok = filter.first.id === '.' && (( are_similar(filter.first.first, this.second) && filter.first.second.string === 'hasOwnProperty' && are_similar(filter.second[0], this.first) ) || ( filter.first.first.id === '.' && filter.first.first.first.first && filter.first.first.first.first.string === 'Object' && filter.first.first.first.id === '.' && filter.first.first.first.second.string === 'prototype' && filter.first.first.second.string === 'hasOwnProperty' && filter.first.second.string === 'call' && are_similar(filter.second[0], this.second) && are_similar(filter.second[1], this.first) )); break; } } else if (blok[0].id === 'switch') { ok = blok[0].id === 'switch' && blok[0].first.id === 'typeof' && blok[0].first.first.id === '[' && are_similar(blok[0].first.first.first, this.second) && are_similar(blok[0].first.first.second, this.first); } } if (!ok) { this.warn('for_if'); } } } else { edge(); this.first = []; for (;;) { this.first.push(expression(0, 'for')); if (next_token.id !== ',') { break; } comma(); } semicolon(); edge(); this.second = expected_relation(expression(0)); if (this.second.id !== 'true') { expected_condition(this.second, 'unexpected_a'); } semicolon(token); if (next_token.id === ';') { next_token.stop('expected_a_b', ')', ';'); } this.third = []; edge(); for (;;) { this.third.push(expression(0, 'for')); if (next_token.id !== ',') { break; } comma(); } no_space(); step_out(')', paren); one_space(); blok = block('for'); } } if (blok.disrupt) { prev_token.warn('strange_loop'); } this.block = blok; funct.loopage -= 1; return this; }); function optional_label(that) { var label = next_token.string, master; that.arity = 'statement'; if (!funct.breakage || (!option.continue && that.id === 'continue')) { that.warn('unexpected_a'); } else if (next_token.identifier && token.line === next_token.line) { one_space_only(); master = scope[label]; if (!master || master.kind !== 'label') { next_token.warn('not_a_label'); } else if (master.dead || master.function !== funct) { next_token.warn('not_a_scope'); } else { master.used += 1; if (that.id === 'break') { master.statement.break = true; } if (funct.breakage[funct.breakage.length - 1] === master.statement) { next_token.warn('unexpected_a'); } } that.first = next_token; advance(); } else { if (that.id === 'break') { funct.breakage[funct.breakage.length - 1].break = true; } } return that; } disrupt_stmt('break', function () { return optional_label(this); }); disrupt_stmt('continue', function () { return optional_label(this); }); disrupt_stmt('return', function () { if (funct === global_funct) { this.warn('unexpected_a'); } this.arity = 'statement'; if (next_token.id !== ';' && next_token.line === token.line) { if (option.closure) { spaces(); } else { one_space_only(); } if (next_token.id === '/' || next_token.id === '(regexp)') { next_token.warn('wrap_regexp'); } this.first = expression(0); if (this.first.assign) { this.first.warn('unexpected_a'); } } return this; }); disrupt_stmt('throw', function () { this.arity = 'statement'; one_space_only(); this.first = expression(20); return this; });
// Superfluous reserved words reserve('class'); reserve('const'); reserve('enum'); reserve('export'); reserve('extends'); reserve('import'); reserve('super');
// Harmony reserved words reserve('implements'); reserve('interface'); reserve('let'); reserve('package'); reserve('private'); reserve('protected'); reserve('public'); reserve('static'); reserve('yield');
// Parse JSON function json_value() { function json_object() { var brace = next_token, object = Object.create(null); advance('{'); if (next_token.id !== '}') { while (next_token.id !== '(end)') { while (next_token.id === ',') { next_token.warn('unexpected_a'); advance(','); } if (next_token.id !== '(string)') { next_token.warn('expected_string_a'); } if (object[next_token.string] === true) { next_token.warn('duplicate_a'); } else if (next_token.string === '__proto__') { next_token.warn('dangling_a'); } else { object[next_token.string] = true; } advance(); advance(':'); json_value(); if (next_token.id !== ',') { break; } advance(','); if (next_token.id === '}') { token.warn('unexpected_a'); break; } } } advance('}', brace); } function json_array() { var bracket = next_token; advance('['); if (next_token.id !== ']') { while (next_token.id !== '(end)') { while (next_token.id === ',') { next_token.warn('unexpected_a'); advance(','); } json_value(); if (next_token.id !== ',') { break; } advance(','); if (next_token.id === ']') { token.warn('unexpected_a'); break; } } } advance(']', bracket); } switch (next_token.id) { case '{': json_object(); break; case '[': json_array(); break; case 'true': case 'false': case 'null': case '(number)': case '(string)': advance(); break; case '-': advance('-'); no_space_only(); advance('(number)'); break; default: next_token.stop('unexpected_a'); } }
// The actual JSLINT function itself. itself = function JSLint(the_source, the_option) { var i, predef, tree; itself.errors = []; itself.tree = ''; itself.properties = ''; begin = prev_token = token = next_token = Object.create(syntax['(begin)']); tokens = []; predefined = Object.create(null); add_to_predefined(standard); property = Object.create(null); if (the_option) { option = Object.create(the_option); predef = option.predef; if (predef) { if (Array.isArray(predef)) { for (i = 0; i < predef.length; i += 1) { predefined[predef[i]] = true; } } else if (typeof predef === 'object') { add_to_predefined(predef); } } } else { option = Object.create(null); } option.indent = +option.indent || 4; option.maxerr = +option.maxerr || 50; global_scope = scope = Object.create(null); global_funct = funct = { scope: scope, loopage: 0, level: 0 }; functions = [funct]; block_var = []; comments = []; comments_off = false; in_block = false; indent = null; json_mode = false; lookahead = []; node_js = false; prereg = true; strict_mode = false; var_mode = null; warnings = 0; lex.init(the_source); assume(); try { advance(); if (next_token.id === '(number)') { next_token.stop('unexpected_a'); } else { switch (next_token.id) { case '{': case '[': comments_off = true; json_mode = true; json_value(); break; default:
// If the first token is a semicolon, ignore it. This is sometimes used when
// files are intended to be appended to files that may be sloppy. A sloppy
// file may be depending on semicolon insertion on its last line. step_in(1); if (next_token.id === ';' && !node_js) { semicolon(); } tree = statements(); begin.first = tree; itself.tree = begin; if (tree.disrupt) { prev_token.warn('weird_program'); } } } indent = null; advance('(end)'); itself.property = property; } catch (e) { if (e) { // ~~ itself.errors.push({ reason : e.message, line : e.line || next_token.line, character : e.character || next_token.from }, null); } } return itself.errors.length === 0; }; function unique(array) { array = array.sort(); var i, length = 0, previous, value; for (i = 0; i < array.length; i += 1) { value = array[i]; if (value !== previous) { array[length] = value; previous = value; length += 1; } } array.length = length; return array; }
// Data summary. itself.data = function () { var data = {functions: []}, function_data, i, the_function, the_scope; data.errors = itself.errors; data.json = json_mode; data.global = unique(Object.keys(global_scope)); function selects(name) { var kind = the_scope[name].kind; switch (kind) { case 'var': case 'exception': case 'label': function_data[kind].push(name); break; } } for (i = 1; i < functions.length; i += 1) { the_function = functions[i]; function_data = { name: the_function.name, line: the_function.line, level: the_function.level, parameter: the_function.parameter, var: [], exception: [], closure: unique(the_function.closure), outer: unique(the_function.outer), global: unique(the_function.global), label: [] }; the_scope = the_function.scope; Object.keys(the_scope).forEach(selects); function_data.var.sort(); function_data.exception.sort(); function_data.label.sort(); data.functions.push(function_data); } data.tokens = tokens; return data; }; itself.error_report = function (data) { var evidence, i, output = [], warning; if (data.errors.length) { if (data.json) { output.push('<cite>JSON: bad.</cite><br>'); } for (i = 0; i < data.errors.length; i += 1) { warning = data.errors[i]; if (warning) { evidence = warning.evidence || ''; output.push('<cite>'); if (isFinite(warning.line)) { output.push('<address>line ' + String(warning.line) + ' character ' + String(warning.character) + '</address>'); } output.push(warning.reason.entityify() + '</cite>'); if (evidence) { output.push('<pre>' + evidence.entityify() + '</pre>'); } } } } return output.join(''); }; itself.report = function (data) { var dl, i, j, names, output = [], the_function; function detail(h, array) { var comma_needed = false; if (array.length) { output.push("<dt>" + h + "</dt><dd>"); array.forEach(function (item) { output.push((comma_needed ? ', ' : '') + item); comma_needed = true; }); output.push("</dd>"); } } output.push('<dl class=level0>'); if (data.global.length) { detail('global', data.global); dl = true; } else if (data.json) { if (!data.errors.length) { output.push("<dt>JSON: good.</dt>"); } } else { output.push("<dt><i>No new global variables introduced.</i></dt>"); } if (dl) { output.push("</dl>"); } else { output[0] = ''; } if (data.functions) { for (i = 0; i < data.functions.length; i += 1) { the_function = data.functions[i]; names = []; if (the_function.params) { for (j = 0; j < the_function.params.length; j += 1) { names[j] = the_function.params[j].string; } } output.push('<dl class=level' + the_function.level + '><address>line ' + String(the_function.line) + '</address>' + the_function.name.entityify()); detail('parameter', the_function.parameter); detail('variable', the_function.var); detail('exception', the_function.exception); detail('closure', the_function.closure); detail('outer', the_function.outer); detail('global', the_function.global); detail('label', the_function.label); output.push('</dl>'); } } return output.join(''); }; itself.properties_report = function (property) { if (!property) { return ''; } var i, key, keys = Object.keys(property).sort(), mem = ' ', name, not_first = false, output = ['/*properties']; for (i = 0; i < keys.length; i += 1) { key = keys[i]; if (property[key] > 0) { if (not_first) { mem += ','; } name = ix.test(key) ? key : '\'' + key.replace(nx, sanitize) + '\''; if (mem.length + name.length >= 80) { output.push(mem); mem = ' '; } else { mem += ' '; } mem += name; not_first = true; } } output.push(mem, '*/\n'); return output.join('\n'); }; itself.color = function (data) { var from, i = 1, level, line, result = [], thru, data_token = data.tokens[0]; while (data_token && data_token.id !== '(end)') { from = data_token.from; line = data_token.line; thru = data_token.thru; level = data_token.function.level; do { thru = data_token.thru; data_token = data.tokens[i]; i += 1; } while (data_token && data_token.line === line && data_token.from - thru < 5 && level === data_token.function.level); result.push({ line: line, level: level, from: from, thru: thru }); } return result; }; itself.jslint = itself; itself.edition = '2013-11-23'; return itself;
}());
| Developer | Darby Rathbone |
| Username | blackkbot |
| Uploaded | October 03, 2022 |
| Rating | 3 |
| Size | 30,020 Kb |
| Views | 32,384 |
Do you need developer help for JsLint?
Find the perfect freelance services for your business! Fiverr's mission is to change how the world works together. Fiverr connects businesses with freelancers offering digital services in 500+ categories. Find Developer!
Darby Rathbone (blackkbot) Script Codes
| Name | Size |
| Canvas buffer | 2,791 Kb |
| Graphing equations | 3,529 Kb |
| Drag, drop and snap | 2,542 Kb |
| Pendulum | 3,104 Kb |
| Perlin noise on worker | 2,989 Kb |
| Webworker with an editable textbox | 3,525 Kb |
| Jigsaw puzzle | 5,193 Kb |
| Balls | 3,920 Kb |
| 3d pure javascript 2d canvas | 2,600 Kb |
| JQuery Number Counter Plugin | 3,195 Kb |
Create amazing Facebook ads with AI!
Jasper is the AI Content Generator that helps you and your team break through creative blocks to create amazing, original content 10X faster. Discover all the ways the Jasper AI Content Platform can help streamline your creative workflows. Start For Free!
Similar Scripts & Codes
| Name | Username | Size |
| Ipad Mini Showcase | Hornebom | 10,479 Kb |
| Scifi-style Radio-based Tab | Aaronchuo | 4,427 Kb |
| My three.js practice | Esambino | 3,203 Kb |
| Pure CSS Dial | Lukewatts | 3,018 Kb |
| Multi column experiment. | Spylefkaditis | 2,805 Kb |
| SlideupBoxes | Gavra | 23,772 Kb |
| Wikipedia API | Coderpilot | 2,802 Kb |
| TigerWoods Freecodecamp Page | Baileytj | 2,869 Kb |
| Web Spiral - p5.js | TWAIN | 2,183 Kb |
| Direction-icon | Alexandremasy | 3,323 Kb |
Do you want hide your ip address?
Surf anonymously, prevent hackers from acquiring your IP address, send anonymous email, and encrypt your Internet connection. High speed, ultra secure, and easy to use. Instant setup. Hide Your IP Now!