/*
 Copyright (c) 2008-2009 Yahoo! Inc. All rights reserved.
 The copyrights embodied in the content of this file are licensed by
 Yahoo! Inc. under the BSD (revised) open source license

 @author Dan Vlad Dascalescu <dandv@yahoo-inc.com>


 Parse function for PHP. Makes use of the tokenizer from tokenizephp.js.
 Based on parsejavascript.js by Marijn Haverbeke.


 Features:
 + special "deprecated" style for PHP4 keywords like 'var'
 + support for PHP 5.3 keywords: 'namespace', 'use'
 + 911 predefined constants, 1301 predefined functions, 105 predeclared classes
 from a typical PHP installation in a LAMP environment
 + new feature: syntax error flagging, thus enabling strict parsing of:
 + function definitions with explicitly or implicitly typed arguments and default values
 + modifiers (public, static etc.) applied to method and member definitions
 + foreach(array_expression as $key [=> $value]) loops
 + differentiation between single-quoted strings and double-quoted interpolating strings

 */


// add the Array.indexOf method for JS engines that don't support it (e.g. IE)
// code from https://developer.mozilla.org/En/Core_JavaScript_1.5_Reference/Global_Objects/Array/IndexOf
if (!Array.prototype.indexOf) {
    Array.prototype.indexOf = function (elt /*, from*/) {
        var len = this.length;

        var from = Number(arguments[1]) || 0;
        from = (from < 0)
            ? Math.ceil(from)
            : Math.floor(from);
        if (from < 0)
            from += len;

        for (; from < len; from++) {
            if (from in this &&
                this[from] === elt)
                return from;
        }
        return -1;
    };
}
;


var PHPParser = Editor.Parser = (function () {
    // Token types that can be considered to be atoms, part of operator expressions
    var atomicTypes = {
        "atom": true, "number": true, "variable": true, "string": true
    };
    // Constructor for the lexical context objects.
    function PHPLexical(indented, column, type, align, prev, info) {
        // indentation at start of this line
        this.indented = indented;
        // column at which this scope was opened
        this.column = column;
        // type of scope ('stat' (statement), 'form' (special form), '[', '{', or '(')
        this.type = type;
        // '[', '{', or '(' blocks that have any text after their opening
        // character are said to be 'aligned' -- any lines below are
        // indented all the way to the opening character.
        if (align != null)
            this.align = align;
        // Parent scope, if any.
        this.prev = prev;
        this.info = info;
    };

    // PHP indentation rules
    function indentPHP(lexical) {
        return function (firstChars) {
            var firstChar = firstChars && firstChars.charAt(0), type = lexical.type;
            var closing = firstChar == type;
            if (type == "form" && firstChar == "{")
                return lexical.indented;
            else if (type == "stat" || type == "form")
                return lexical.indented + indentUnit;
            else if (lexical.info == "switch" && !closing)
                return lexical.indented + (/^(?:case|default)\b/.test(firstChars) ? indentUnit : 2 * indentUnit);
            else if (lexical.align)
                return lexical.column - (closing ? 1 : 0);
            else
                return lexical.indented + (closing ? 0 : indentUnit);
        };
    };

    // The parser-iterator-producing function itself.
    function parsePHP(input, basecolumn) {
        // Wrap the input in a token stream
        var tokens = tokenizePHP(input);
        // The parser state. cc is a stack of actions that have to be
        // performed to finish the current statement. For example we might
        // know that we still need to find a closing parenthesis and a
        // semicolon. Actions at the end of the stack go first. It is
        // initialized with an infinitely looping action that consumes
        // whole statements.
        var cc = [statements];
        // The lexical scope, used mostly for indentation.
        var lexical = new PHPLexical((basecolumn || 0) - indentUnit, 0, "block", false);
        // Current column, and the indentation at the start of the current
        // line. Used to create lexical scope objects.
        var column = 0;
        var indented = 0;
        // Variables which are used by the mark, cont, and pass functions
        // below to communicate with the driver loop in the 'next' function.
        var consume, marked;

        // The iterator object.
        var parser = {next: next, copy: copy};

        // parsing is accomplished by calling next() repeatedly
        function next() {
            // Start by performing any 'lexical' actions (adjusting the
            // lexical variable), or the operations below will be working
            // with the wrong lexical state.
            while (cc[cc.length - 1].lex)
                cc.pop()();

            // Fetch the next token.
            var token = tokens.next();

            // Adjust column and indented.
            if (token.type == "whitespace" && column == 0)
                indented = token.value.length;
            column += token.value.length;
            if (token.content == "\n") {
                indented = column = 0;
                // If the lexical scope's align property is still undefined at
                // the end of the line, it is an un-aligned scope.
                if (!("align" in lexical))
                    lexical.align = false;
                // Newline tokens get an indentation function associated with
                // them.
                token.indentation = indentPHP(lexical);
            }
            // No more processing for meaningless tokens.
            if (token.type == "whitespace" || token.type == "comment"
                || token.type == "string_not_terminated")
                return token;
            // When a meaningful token is found and the lexical scope's
            // align is undefined, it is an aligned scope.
            if (!("align" in lexical))
                lexical.align = true;

            // Execute actions until one 'consumes' the token and we can
            // return it. 'marked' is used to change the style of the current token.
            while (true) {
                consume = marked = false;
                // Take and execute the topmost action.
                var action = cc.pop();
                action(token);

                if (consume) {
                    if (marked)
                        token.style = marked;
                    // Here we differentiate between local and global variables.
                    return token;
                }
            }
            return 1; // Firebug workaround for http://code.google.com/p/fbug/issues/detail?id=1239#c1
        }

        // This makes a copy of the parser state. It stores all the
        // stateful variables in a closure, and returns a function that
        // will restore them when called with a new input stream. Note
        // that the cc array has to be copied, because it is contantly
        // being modified. Lexical objects are not mutated, so they can
        // be shared between runs of the parser.
        function copy() {
            var _lexical = lexical, _cc = cc.concat([]), _tokenState = tokens.state;

            return function copyParser(input) {
                lexical = _lexical;
                cc = _cc.concat([]); // copies the array
                column = indented = 0;
                tokens = tokenizePHP(input, _tokenState);
                return parser;
            };
        }

        // Helper function for pushing a number of actions onto the cc
        // stack in reverse order.
        function push(fs) {
            for (var i = fs.length - 1; i >= 0; i--)
                cc.push(fs[i]);
        }

        // cont and pass are used by the action functions to add other
        // actions to the stack. cont will cause the current token to be
        // consumed, pass will leave it for the next action.
        function cont() {
            push(arguments);
            consume = true;
        }

        function pass() {
            push(arguments);
            consume = false;
        }

        // Used to change the style of the current token.
        function mark(style) {
            marked = style;
        }

        // Add a lyer of style to the current token, for example syntax-error
        function mark_add(style) {
            marked = marked + ' ' + style;
        }

        // Push a new lexical context of the given type.
        function pushlex(type, info) {
            var result = function pushlexing() {
                lexical = new PHPLexical(indented, column, type, null, lexical, info)
            };
            result.lex = true;
            return result;
        }

        // Pop off the current lexical context.
        function poplex() {
            lexical = lexical.prev;
        }

        poplex.lex = true;
        // The 'lex' flag on these actions is used by the 'next' function
        // to know they can (and have to) be ran before moving on to the
        // next token.

        // Creates an action that discards tokens until it finds one of
        // the given type. This will ignore (and recover from) syntax errors.
        function expect(wanted) {
            return function expecting(token) {
                if (token.type == wanted) cont();  // consume the token
                else {
                    cont(arguments.callee);  // continue expecting() - call itself
                }
            };
        }

        // Require a specific token type, or one of the tokens passed in the 'wanted' array
        // Used to detect blatant syntax errors. 'execute' is used to pass extra code
        // to be executed if the token is matched. For example, a '(' match could
        // 'execute' a cont( compasep(funcarg), require(")") )
        function require(wanted, execute) {
            return function requiring(token) {
                var ok;
                var type = token.type;
                if (typeof(wanted) == "string")
                    ok = (type == wanted) - 1;
                else
                    ok = wanted.indexOf(type);
                if (ok >= 0) {
                    if (execute && typeof(execute[ok]) == "function")
                        execute[ok](token);
                    cont();  // just consume the token
                }
                else {
                    if (!marked) mark(token.style);
                    mark_add("syntax-error");
                    cont(arguments.callee);
                }
            };
        }

        // Looks for a statement, and then calls itself.
        function statements(token) {
            return pass(statement, statements);
        }

        // Dispatches various types of statements based on the type of the current token.
        function statement(token) {
            var type = token.type;
            if (type == "keyword a") cont(pushlex("form"), expression, statement, poplex);
            else if (type == "keyword b") cont(pushlex("form"), statement, poplex);
            else if (type == "{") cont(pushlex("}"), block, poplex);
            else if (type == "function") funcdef();
            // technically, "class implode {...}" is correct, but we'll flag that as an error because it overrides a predefined function
            else if (type == "class") cont(require("t_string"), expect("{"), pushlex("}"), block, poplex);
            else if (type == "foreach") cont(pushlex("form"), require("("), pushlex(")"), expression, require("as"), require("variable"), /* => $value */ expect(")"), poplex, statement, poplex);
            else if (type == "for") cont(pushlex("form"), require("("), pushlex(")"), expression, require(";"), expression, require(";"), expression, require(")"), poplex, statement, poplex);
            // public final function foo(), protected static $bar;
            else if (type == "modifier") cont(require(["modifier", "variable", "function"], [null, null, funcdef]));
            else if (type == "switch") cont(pushlex("form"), require("("), expression, require(")"), pushlex("}", "switch"), require([":", "{"]), block, poplex, poplex);
            else if (type == "case") cont(expression, require(":"));
            else if (type == "default") cont(require(":"));
            else if (type == "catch") cont(pushlex("form"), require("("), require("t_string"), require("variable"), require(")"), statement, poplex);
            else if (type == "const") cont(require("t_string"));  // 'const static x=5' is a syntax error
            // technically, "namespace implode {...}" is correct, but we'll flag that as an error because it overrides a predefined function
            else if (type == "namespace") cont(namespacedef, require(";"));
            // $variables may be followed by operators, () for variable function calls, or [] subscripts
            else pass(pushlex("stat"), expression, require(";"), poplex);
        }

        // Dispatch expression types.
        function expression(token) {
            var type = token.type;
            if (atomicTypes.hasOwnProperty(type)) cont(maybeoperator);
            else if (type == "<<<") cont(require("string"), maybeoperator);  // heredoc/nowdoc
            else if (type == "t_string") cont(maybe_double_colon, maybeoperator);
            else if (type == "keyword c") cont(expression);
            // function call or parenthesized expression: $a = ($b + 1) * 2;
            else if (type == "(") cont(pushlex(")"), commasep(expression), require(")"), poplex, maybeoperator);
            else if (type == "operator") cont(expression);
        }

        // Called for places where operators, function calls, or subscripts are
        // valid. Will skip on to the next action if none is found.
        function maybeoperator(token) {
            var type = token.type;
            if (type == "operator") {
                if (token.content == "?") cont(expression, require(":"), expression);  // ternary operator
                else cont(expression);
            }
            else if (type == "(") cont(pushlex(")"), expression, commasep(expression), require(")"), poplex, maybeoperator /* $varfunc() + 3 */);
            else if (type == "[") cont(pushlex("]"), expression, require("]"), maybeoperator /* for multidimensional arrays, or $func[$i]() */, poplex);
        }

        // A regular use of the double colon to specify a class, as in self::func() or myclass::$var;
        // Differs from `namespace` or `use` in that only one class can be the parent; chains (A::B::$var) are a syntax error.
        function maybe_double_colon(token) {
            if (token.type == "t_double_colon")
            // A::$var, A::func(), A::const
                cont(require(["t_string", "variable"]), maybeoperator);
            else {
                // a t_string wasn't followed by ::, such as in a function call: foo()
                pass(expression)
            }
        }

        // the declaration or definition of a function
        function funcdef() {
            cont(require("t_string"), require("("), pushlex(")"), commasep(funcarg), require(")"), poplex, block);
        }

        // Parses a comma-separated list of the things that are recognized
        // by the 'what' argument.
        function commasep(what) {
            function proceed(token) {
                if (token.type == ",") cont(what, proceed);
            };
            return function commaSeparated() {
                pass(what, proceed);
            };
        }

        // Look for statements until a closing brace is found.
        function block(token) {
            if (token.type == "}") cont();
            else pass(statement, block);
        }

        function maybedefaultparameter(token) {
            if (token.content == "=") cont(expression);
        }

        // support for default arguments: http://us.php.net/manual/en/functions.arguments.php#functions.arguments.default
        function funcarg(token) {
            // function foo(myclass $obj) {...}
            if (token.type == "t_string") cont(require("variable"), maybedefaultparameter);
            // function foo($string) {...}
            else if (token.type == "variable") cont(maybedefaultparameter);
        }

        // A namespace definition or use
        function maybe_double_colon_def(token) {
            if (token.type == "t_double_colon")
                cont(namespacedef);
        }

        function namespacedef(token) {
            pass(require("t_string"), maybe_double_colon_def);
        }

        return parser;
    }

    return {make: parsePHP, electricChars: "{}:"};

})();
