mohayonao/SCScript

File esprima.js has 2993 lines of code (exceeds 250 allowed). Consider refactoring.

Open

/*
  Copyright (C) 2013 Ariya Hidayat <ariya.hidayat@gmail.com>
  Copyright (C) 2013 Thaddee Tyl <thaddee.tyl@gmail.com>
  Copyright (C) 2013 Mathias Bynens <mathias@qiwi.be>
  Copyright (C) 2012 Ariya Hidayat <ariya.hidayat@gmail.com>

Function scanPunctuator has 142 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    function scanPunctuator() {
        var start = index,
            code = source.charCodeAt(index),
            code2,
            ch1 = source[index],

Function scanStringLiteral has 89 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    function scanStringLiteral() {
        var str = '', quote, start, ch, code, unescaped, restore, octal = false;

        quote = source[index];
        assert((quote === '\'' || quote === '"'),

Function scanRegExp has 85 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    function scanRegExp() {
        var str, ch, start, pattern, flags, value, classMarker = false, restore, terminated = false;

        lookahead = null;
        skipComment();

Function tokenize has 77 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    function tokenize(code, options) {
        var toString,
            token,
            tokens;

Function parse has 72 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    function parse(code, options) {
        var program, toString;

        toString = String;
        if (typeof code !== 'string' && !(code instanceof String)) {

Function parseStatement has 68 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    function parseStatement() {
        var type = lookahead.type,
            expr,
            labeledBody,
            key;

Function scanNumericLiteral has 57 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    function scanNumericLiteral() {
        var number, start, ch;

        ch = source[index];
        assert(isDecimalDigit(ch.charCodeAt(0)) || (ch === '.'),

Function binaryPrecedence has 54 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    function binaryPrecedence(token, allowIn) {
        var prec = 0;

        if (token.type !== Token.Punctuator && token.type !== Token.Keyword) {
            return 0;

Function parseForStatement has 52 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    function parseForStatement() {
        var init, test, update, left, right, body, oldInIteration;

        init = test = update = null;

Function parseFunctionSourceElements has 50 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    function parseFunctionSourceElements() {
        var sourceElement, sourceElements = [], token, directive, firstRestricted,
            oldLabelSet, oldInIteration, oldInSwitch, oldInFunctionBody;

        delegate.markStart();

Function advanceSlash has 49 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    function advanceSlash() {
        var prevToken,
            checkToken;
        // Using the following algorithm:
        // https://github.com/mozilla/sweet.js/wiki/design

Function skipComment has 49 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    function skipComment() {
        var ch, start;

        start = (index === 0);
        while (index < length) {

Function parseBinaryExpression has 46 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    function parseBinaryExpression() {
        var marker, markers, expr, token, prec, stack, right, operator, left, i;

        marker = createLocationMarker();
        left = parseUnaryExpression();

Function parsePrimaryExpression has 44 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    function parsePrimaryExpression() {
        var type, token, expr;

        if (match('(')) {
            return parseGroupExpression();

Function parseParams has 44 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    function parseParams(firstRestricted) {
        var param, params = [], token, stricted, paramSet, key, message;
        expect('(');

        if (!match(')')) {

Function skipMultiLineComment has 42 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    function skipMultiLineComment() {
        var start, loc, ch, comment;

        if (extra.comments) {
            start = index - 2;

Function parseObjectProperty has 39 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    function parseObjectProperty() {
        var token, key, id, value, param;

        token = lookahead;
        delegate.markStart();

Function parseFunctionExpression has 37 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    function parseFunctionExpression() {
        var token, id = null, stricted, firstRestricted, message, tmp, params = [], body, previousStrict;

        delegate.markStart();
        expectKeyword('function');

Function skipSingleLineComment has 36 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    function skipSingleLineComment(offset) {
        var start, loc, ch, comment;

        start = index - offset;
        loc = {

Function parseObjectInitialiser has 36 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    function parseObjectInitialiser() {
        var properties = [], property, name, key, kind, map = {}, toString = String;

        expect('{');

Function parseFunctionDeclaration has 35 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    function parseFunctionDeclaration() {
        var id, params = [], body, token, stricted, tmp, firstRestricted, message, previousStrict;

        delegate.markStart();

Function getEscapedIdentifier has 35 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    function getEscapedIdentifier() {
        var ch, id;

        ch = source.charCodeAt(index++);
        id = String.fromCharCode(ch);

Function advance has 33 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    function advance() {
        var ch;

        skipComment();

Function processComment has 32 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        processComment: function (node) {
            var i, attacher, pos, len, candidate;

            if (typeof node.type === 'undefined' || node.type === Syntax.Program) {
                return;

Function parseSourceElements has 31 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    function parseSourceElements() {
        var sourceElement, sourceElements = [], token, directive, firstRestricted;

        while (index < length) {
            token = lookahead;

Function collectRegex has 31 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    function collectRegex() {
        var pos, loc, regex, token;

        skipComment();

Function parseSwitchStatement has 30 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    function parseSwitchStatement() {
        var discriminant, cases, clause, oldInSwitch, defaultFound;

        expectKeyword('switch');

Function parseUnaryExpression has 29 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    function parseUnaryExpression() {
        var token, expr;

        delegate.markStart();

Function isKeyword has 28 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    function isKeyword(id) {
        if (strict && isStrictModeReservedWord(id)) {
            return true;
        }

Function parseContinueStatement has 27 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    function parseContinueStatement() {
        var label = null, key;

        expectKeyword('continue');

Function parseBreakStatement has 27 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    function parseBreakStatement() {
        var label = null, key;

        expectKeyword('break');

Function addComment has 26 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    function addComment(type, value, start, end, loc) {
        var comment, attacher;

        assert(typeof start === 'number', 'Comment must have valid position');

Avoid deeply nested control flow statements.

Open

                        for (str += '\\u'; restore < index; ++restore) {
                            str += source[restore];
                        }

Avoid deeply nested control flow statements.

Open

                    if (!checkToken) {
                        return collectRegex();
                    }

Avoid deeply nested control flow statements.

Open

            } else if (ch === 0x3C) { // U+003C is '<'
                if (source.slice(index + 1, index + 4) === '!--') {
                    ++index; // `<`
                    ++index; // `!`
                    ++index; // `-`

Avoid deeply nested control flow statements.

Open

                    if (extra.comments) {
                        comment = source.slice(start + 2, index - 2);
                        loc.end = {
                            line: lineNumber,
                            column: index - lineStart

Avoid deeply nested control flow statements.

Open

                        if (isOctalDigit(ch)) {
                            code = '01234567'.indexOf(ch);

                            // \0 is not octal escape sequence
                            if (code !== 0) {

Avoid deeply nested control flow statements.

Open

                        if (unescaped) {
                            str += unescaped;
                        } else {
                            index = restore;
                            str += ch;

Avoid deeply nested control flow statements.

Open

                if ((source.charCodeAt(index + 1) === 0x2D) && (source.charCodeAt(index + 2) === 0x3E)) {
                    // '-->' is a single-line comment
                    index += 3;
                    skipSingleLineComment(3);
                } else {

Avoid deeply nested control flow statements.

Open

                    if (isRestrictedWord(token.value)) {
                        firstRestricted = token;
                        message = Messages.StrictParamName;
                    } else if (isStrictModeReservedWord(token.value)) {
                        firstRestricted = token;

Consider simplifying this complex logical expression.

Open

                if (checkToken &&
                        checkToken.type === 'Keyword' &&
                        (checkToken.value === 'if' ||
                         checkToken.value === 'while' ||
                         checkToken.value === 'for' ||

Function addComment has 5 arguments (exceeds 4 allowed). Consider refactoring.

Open

    function addComment(type, value, start, end, loc) {

Avoid too many return statements within this function.

Open

                    return scanPunctuator();

Avoid too many return statements within this function.

Open

                return collectRegex();

Avoid too many return statements within this function.

Open

            return scanNumericLiteral();

Avoid too many return statements within this function.

Open

                        return scanPunctuator();

Avoid too many return statements within this function.

Open

                    return scanPunctuator();

Avoid too many return statements within this function.

Open

            return {
                type: Token.Punctuator,
                value: '<<=',
                lineNumber: lineNumber,
                lineStart: lineStart,

Avoid too many return statements within this function.

Open

                return scanNumericLiteral();

Avoid too many return statements within this function.

Open

            return {
                type: Token.Punctuator,
                value: '>>=',
                lineNumber: lineNumber,
                lineStart: lineStart,

Avoid too many return statements within this function.

Open

            return {
                type: Token.Punctuator,
                value: ch1,
                lineNumber: lineNumber,
                lineStart: lineStart,

Avoid too many return statements within this function.

Open

                        return collectRegex();

Avoid too many return statements within this function.

Open

        return scanPunctuator();

Avoid too many return statements within this function.

Open

            return scanPunctuator();

Avoid too many return statements within this function.

Open

            return collectRegex();

Avoid too many return statements within this function.

Open

            return advanceSlash();

Avoid too many return statements within this function.

Open

            return {
                type: Token.Punctuator,
                value: ch1 + ch2,
                lineNumber: lineNumber,
                lineStart: lineStart,

Avoid too many return statements within this function.

Open

            return collectRegex();

Avoid too many return statements within this function.

Open

        return scanPunctuator();

Avoid too many return statements within this function.

Open

            return {
                type: Token.Punctuator,
                value: '>>>',
                lineNumber: lineNumber,
                lineStart: lineStart,

Similar blocks of code found in 2 locations. Consider refactoring.

Open

                if (node.range[1] <= attacher.comment.range[0]) {
                    candidate = attacher.trailing;
                    if (candidate) {
                        pos = candidate.range[0];
                        len = candidate.range[1] - pos;

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

                if (node.range[0] >= attacher.comment.range[1]) {
                    candidate = attacher.leading;
                    if (candidate) {
                        pos = candidate.range[0];
                        len = candidate.range[1] - pos;

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

        if (strict) {
            if (isRestrictedWord(token.value)) {
                throwErrorTolerant(token, Messages.StrictFunctionName);
            }
        } else {

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

            if (strict) {
                if (isRestrictedWord(token.value)) {
                    throwErrorTolerant(token, Messages.StrictFunctionName);
                }
            } else {

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

        if (lookahead.type === Token.Identifier) {
            label = parseVariableIdentifier();

            key = '$' + label.name;
            if (!Object.prototype.hasOwnProperty.call(state.labelSet, key)) {

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

        if (lookahead.type === Token.Identifier) {
            label = parseVariableIdentifier();

            key = '$' + label.name;
            if (!Object.prototype.hasOwnProperty.call(state.labelSet, key)) {

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

    function isWhiteSpace(ch) {
        return (ch === 0x20) || (ch === 0x09) || (ch === 0x0B) || (ch === 0x0C) || (ch === 0xA0) ||
            (ch >= 0x1680 && [0x1680, 0x180E, 0x2000, 0x2001, 0x2002, 0x2003, 0x2004, 0x2005, 0x2006, 0x2007, 0x2008, 0x2009, 0x200A, 0x202F, 0x205F, 0x3000, 0xFEFF].indexOf(ch) >= 0);
    }

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

            if (match('[')) {
                property = parseComputedMember();
                expr = delegate.createMemberExpression('[', expr, property);
            } else {
                property = parseNonComputedMember();

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

            } else if (match('[')) {
                property = parseComputedMember();
                expr = delegate.createMemberExpression('[', expr, property);
            } else {
                property = parseNonComputedMember();

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

        case 5:
            return (id === 'while') || (id === 'break') || (id === 'catch') ||
                (id === 'throw') || (id === 'const') || (id === 'yield') ||
                (id === 'class') || (id === 'super');

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

            if (directive === 'use strict') {
                strict = true;
                if (firstRestricted) {
                    throwErrorTolerant(firstRestricted, Messages.StrictOctalLiteral);
                }

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

            if (directive === 'use strict') {
                strict = true;
                if (firstRestricted) {
                    throwErrorTolerant(firstRestricted, Messages.StrictOctalLiteral);
                }

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

        createFunctionExpression: function (id, params, defaults, body) {
            return {
                type: Syntax.FunctionExpression,
                id: id,
                params: params,

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

        createFunctionDeclaration: function (id, params, defaults, body) {
            return {
                type: Syntax.FunctionDeclaration,
                id: id,
                params: params,

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

        while (index < length) {
            if (match('}')) {
                break;
            }
            sourceElement = parseSourceElement();

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

        while (index < length) {
            if (match('}')) {
                break;
            }
            statement = parseSourceElement();

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

        if (length > 0) {
            if (typeof source[0] === 'undefined') {
                // Try first to convert to a string. This is good as fast path
                // for old IE which understands string indexing for string
                // literals only and not for string object.

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

        if (length > 0) {
            if (typeof source[0] === 'undefined') {
                // Try first to convert to a string. This is good as fast path
                // for old IE which understands string indexing for string
                // literals only and not for string object.

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

            if (trailing) {
                if (typeof trailing.trailingComments === 'undefined') {
                    trailing.trailingComments = [];
                }
                trailing.trailingComments.push(attacher.comment);

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

            if (leading) {
                if (typeof leading.leadingComments === 'undefined') {
                    leading.leadingComments = [];
                }
                leading.leadingComments.push(attacher.comment);

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

    function expectKeyword(keyword) {
        var token = lex();
        if (token.type !== Token.Keyword || token.value !== keyword) {
            throwUnexpected(token);
        }

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

    function expect(value) {
        var token = lex();
        if (token.type !== Token.Punctuator || token.value !== value) {
            throwUnexpected(token);
        }

• Read up
  Read up

Similar blocks of code found in 4 locations. Consider refactoring.

Open

        case 6:
            return (id === 'return') || (id === 'typeof') || (id === 'delete') ||
                (id === 'switch') || (id === 'export') || (id === 'import');

• Read up
  Read up

Similar blocks of code found in 4 locations. Consider refactoring.

Open

        case 4:
            return (id === 'this') || (id === 'else') || (id === 'case') ||
                (id === 'void') || (id === 'with') || (id === 'enum');

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

                if (strict && expr.type === Syntax.Identifier && isRestrictedWord(expr.name)) {
                    throwErrorTolerant({}, Messages.StrictLHSPostfix);
                }

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

        return (ch === 0x24) || (ch === 0x5F) ||  // $ (dollar) and _ (underscore)
            (ch >= 0x41 && ch <= 0x5A) ||         // A..Z
            (ch >= 0x61 && ch <= 0x7A) ||         // a..z
            (ch >= 0x30 && ch <= 0x39) ||         // 0..9

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

        return (ch === 0x24) || (ch === 0x5F) ||  // $ (dollar) and _ (underscore)
            (ch >= 0x41 && ch <= 0x5A) ||         // A..Z
            (ch >= 0x61 && ch <= 0x7A) ||         // a..z
            (ch === 0x5C) ||                      // \ (backslash)

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

            if (strict && expr.type === Syntax.Identifier && isRestrictedWord(expr.name)) {
                throwErrorTolerant({}, Messages.StrictLHSPrefix);
            }

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

                if (!ch || ch === '\\' || !isIdentifierPart(ch.charCodeAt(0))) {
                    throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
                }

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

            if (!ch || ch === '\\' || !isIdentifierStart(ch.charCodeAt(0))) {
                throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
            }

• Read up
  Read up

Similar blocks of code found in 4 locations. Consider refactoring.

Open

        if (ch1 === '<' && ch2 === '<' && ch3 === '=') {
            index += 3;
            return {
                type: Token.Punctuator,
                value: '<<=',

• Read up
  Read up

Similar blocks of code found in 4 locations. Consider refactoring.

Open

            if (ch4 === '=') {
                index += 4;
                return {
                    type: Token.Punctuator,
                    value: '>>>=',

• Read up
  Read up

Similar blocks of code found in 4 locations. Consider refactoring.

Open

        if (ch1 === '>' && ch2 === '>' && ch3 === '=') {
            index += 3;
            return {
                type: Token.Punctuator,
                value: '>>=',

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

        createForStatement: function (init, test, update, body) {
            return {
                type: Syntax.ForStatement,
                init: init,
                test: test,

• Read up
  Read up

Similar blocks of code found in 4 locations. Consider refactoring.

Open

        if (ch1 === '>' && ch2 === '>' && ch3 === '>') {
            index += 3;
            return {
                type: Token.Punctuator,
                value: '>>>',

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

        createTryStatement: function (block, guardedHandlers, handlers, finalizer) {
            return {
                type: Syntax.TryStatement,
                block: block,
                guardedHandlers: guardedHandlers,

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

                } else if (extra.tokens[extra.openCurlyToken - 4] &&
                        extra.tokens[extra.openCurlyToken - 4].type === 'Keyword') {
                    // Named function.
                    checkToken = extra.tokens[extra.openCurlyToken - 5];
                    if (!checkToken) {

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

                if (extra.tokens[extra.openCurlyToken - 3] &&
                        extra.tokens[extra.openCurlyToken - 3].type === 'Keyword') {
                    // Anonymous function.
                    checkToken = extra.tokens[extra.openCurlyToken - 4];
                    if (!checkToken) {

• Read up
  Read up