/*

 *  Copyright (C) 1999-2000 Harri Porten (porten@kde.org)

 *  Copyright (C) 2001 Peter Kelly (pmk@post.com)

 *  Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.

 *  Copyright (C) 2007 Cameron Zwarich (cwzwarich@uwaterloo.ca)

 *  Copyright (C) 2007 Maks Orlovich

 *  Copyright (C) 2007 Eric Seidel <eric@webkit.org>

 *

 *  This library is free software; you can redistribute it and/or

 *  modify it under the terms of the GNU Library General Public

 *  License as published by the Free Software Foundation; either

 *  version 2 of the License, or (at your option) any later version.

 *

 *  This library is distributed in the hope that it will be useful,

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 *  Library General Public License for more details.

 *

 *  You should have received a copy of the GNU Library General Public License

 *  along with this library; see the file COPYING.LIB.  If not, write to

 *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

 *  Boston, MA 02110-1301, USA.

 *

 */

#ifndef Nodes_h

#define Nodes_h

#include "Error.h"

#include "JITCode.h"

#include "Opcode.h"

#include "ParserArena.h"

#include "ResultType.h"

#include "SourceCode.h"

#include "SymbolTable.h"

#include <wtf/MathExtras.h>

namespace JSC {

    class ArgumentListNode;

    class BytecodeGenerator;

    class FunctionBodyNode;

    class Label;

    class PropertyListNode;

    class ReadModifyResolveNode;

    class RegisterID;

    class ScopeChainNode;

    class ScopeNode;

    typedef unsigned CodeFeatures;

    const CodeFeatures NoFeatures = 0;

    const CodeFeatures EvalFeature = 1 << 0;

    const CodeFeatures ClosureFeature = 1 << 1;

    const CodeFeatures AssignFeature = 1 << 2;

    const CodeFeatures ArgumentsFeature = 1 << 3;

    const CodeFeatures WithFeature = 1 << 4;

    const CodeFeatures CatchFeature = 1 << 5;

    const CodeFeatures ThisFeature = 1 << 6;

    const CodeFeatures AllFeatures = EvalFeature | ClosureFeature | AssignFeature | ArgumentsFeature | WithFeature | CatchFeature | ThisFeature;

    enum Operator {

        OpEqual,

        OpPlusEq,

        OpMinusEq,

        OpMultEq,

        OpDivEq,

        OpPlusPlus,

        OpMinusMinus,

        OpAndEq,

        OpXOrEq,

        OpOrEq,

        OpModEq,

        OpLShift,

        OpRShift,

        OpURShift

    };

    enum LogicalOperator {

        OpLogicalAnd,

        OpLogicalOr

    };

    namespace DeclarationStacks {

        enum VarAttrs { IsConstant = 1, HasInitializer = 2 };

        typedef Vector<std::pair<const Identifier*, unsigned> > VarStack;

        typedef Vector<FunctionBodyNode*> FunctionStack;

    }

    struct SwitchInfo {

        enum SwitchType { SwitchNone, SwitchImmediate, SwitchCharacter, SwitchString };

        uint32_t bytecodeOffset;

        SwitchType switchType;

    };

    class ParserArenaFreeable {

    public:

        // ParserArenaFreeable objects are are freed when the arena is deleted.

        // Destructors are not called. Clients must not call delete on such objects.

        void* operator new(size_t, JSGlobalData*);

    };

    class ParserArenaDeletable {

    public:

        virtual ~ParserArenaDeletable() { }

        // ParserArenaDeletable objects are deleted when the arena is deleted.

        // Clients must not call delete directly on such objects.

        void* operator new(size_t, JSGlobalData*);

    };

    class ParserArenaRefCounted : public RefCounted<ParserArenaRefCounted> {

    protected:

        ParserArenaRefCounted(JSGlobalData*);

    public:

        virtual ~ParserArenaRefCounted()

        {

            ASSERT(deletionHasBegun());

        }

    };

    class Node : public ParserArenaFreeable {

    protected:

        Node(JSGlobalData*);

    public:

        virtual ~Node() { }

        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* destination = 0) = 0;

        int lineNo() const { return m_line; }

    protected:

        int m_line;

    };

    class ExpressionNode : public Node {

    protected:

        ExpressionNode(JSGlobalData*, ResultType = ResultType::unknownType());

    public:

        virtual bool isNumber() const { return false; }

        virtual bool isString() const { return false; }

        virtual bool isNull() const { return false; }

        virtual bool isPure(BytecodeGenerator&) const { return false; }        

        virtual bool isLocation() const { return false; }

        virtual bool isResolveNode() const { return false; }

        virtual bool isBracketAccessorNode() const { return false; }

        virtual bool isDotAccessorNode() const { return false; }

        virtual bool isFuncExprNode() const { return false; }

        virtual bool isCommaNode() const { return false; }

        virtual bool isSimpleArray() const { return false; }

        virtual bool isAdd() const { return false; }

        virtual bool isSubtract() const { return false; }

        virtual bool hasConditionContextCodegen() const { return false; }

        virtual void emitBytecodeInConditionContext(BytecodeGenerator&, Label*, Label*, bool) { ASSERT_NOT_REACHED(); }

        virtual ExpressionNode* stripUnaryPlus() { return this; }

        ResultType resultDescriptor() const { return m_resultType; }

    private:

        ResultType m_resultType;

    };

    class StatementNode : public Node {

    protected:

        StatementNode(JSGlobalData*);

    public:

        void setLoc(int firstLine, int lastLine);

        int firstLine() const { return lineNo(); }

        int lastLine() const { return m_lastLine; }

        virtual bool isEmptyStatement() const { return false; }

        virtual bool isReturnNode() const { return false; }

        virtual bool isExprStatement() const { return false; }

        virtual bool isBlock() const { return false; }

    private:

        int m_lastLine;

    };

    class NullNode : public ExpressionNode {

    public:

        NullNode(JSGlobalData*);

    private:

        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

        virtual bool isNull() const { return true; }

    };

    class BooleanNode : public ExpressionNode {

    public:

        BooleanNode(JSGlobalData*, bool value);

    private:

        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

        virtual bool isPure(BytecodeGenerator&) const { return true; }

        bool m_value;

    };

    class NumberNode : public ExpressionNode {

    public:

        NumberNode(JSGlobalData*, double value);

        double value() const { return m_value; }

        void setValue(double value) { m_value = value; }

    private:

        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

        virtual bool isNumber() const { return true; }

        virtual bool isPure(BytecodeGenerator&) const { return true; }

        double m_value;

    };

    class StringNode : public ExpressionNode {

    public:

        StringNode(JSGlobalData*, const Identifier&);

        const Identifier& value() { return m_value; }

    private:

        virtual bool isPure(BytecodeGenerator&) const { return true; }

        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

        virtual bool isString() const { return true; }

        const Identifier& m_value;

    };

    class ThrowableExpressionData {

    public:

        ThrowableExpressionData()

            : m_divot(static_cast<uint32_t>(-1))

            , m_startOffset(static_cast<uint16_t>(-1))

            , m_endOffset(static_cast<uint16_t>(-1))

        {

        }

        ThrowableExpressionData(unsigned divot, unsigned startOffset, unsigned endOffset)

            : m_divot(divot)

            , m_startOffset(startOffset)

            , m_endOffset(endOffset)

        {

        }

        void setExceptionSourceCode(unsigned divot, unsigned startOffset, unsigned endOffset)

        {

            m_divot = divot;

            m_startOffset = startOffset;

            m_endOffset = endOffset;

        }

        uint32_t divot() const { return m_divot; }

        uint16_t startOffset() const { return m_startOffset; }

        uint16_t endOffset() const { return m_endOffset; }

    protected:

        RegisterID* emitThrowError(BytecodeGenerator&, bool isReferenceError, const char* message);

        RegisterID* emitThrowError(BytecodeGenerator&, bool isReferenceError, const char* message, const UString&);

        RegisterID* emitThrowError(BytecodeGenerator&, bool isReferenceError, const char* message, const Identifier&);

    private:

        uint32_t m_divot;

        uint16_t m_startOffset;

        uint16_t m_endOffset;

    };

    class ThrowableSubExpressionData : public ThrowableExpressionData {

    public:

        ThrowableSubExpressionData()

            : m_subexpressionDivotOffset(0)

            , m_subexpressionEndOffset(0)

        {

        }

        ThrowableSubExpressionData(unsigned divot, unsigned startOffset, unsigned endOffset)

            : ThrowableExpressionData(divot, startOffset, endOffset)

            , m_subexpressionDivotOffset(0)

            , m_subexpressionEndOffset(0)

        {

        }

        void setSubexpressionInfo(uint32_t subexpressionDivot, uint16_t subexpressionOffset)

        {

            ASSERT(subexpressionDivot <= divot());

            if ((divot() - subexpressionDivot) & ~0xFFFF) // Overflow means we can't do this safely, so just point at the primary divot

                return;

            m_subexpressionDivotOffset = divot() - subexpressionDivot;

            m_subexpressionEndOffset = subexpressionOffset;

        }

    protected:

        uint16_t m_subexpressionDivotOffset;

        uint16_t m_subexpressionEndOffset;

    };

    class ThrowablePrefixedSubExpressionData : public ThrowableExpressionData {

    public:

        ThrowablePrefixedSubExpressionData()

            : m_subexpressionDivotOffset(0)

            , m_subexpressionStartOffset(0)

        {

        }

        ThrowablePrefixedSubExpressionData(unsigned divot, unsigned startOffset, unsigned endOffset)

            : ThrowableExpressionData(divot, startOffset, endOffset)

            , m_subexpressionDivotOffset(0)

            , m_subexpressionStartOffset(0)

        {

        }

        void setSubexpressionInfo(uint32_t subexpressionDivot, uint16_t subexpressionOffset)

        {

            ASSERT(subexpressionDivot >= divot());

            if ((subexpressionDivot - divot()) & ~0xFFFF) // Overflow means we can't do this safely, so just point at the primary divot

                return;

            m_subexpressionDivotOffset = subexpressionDivot - divot();

            m_subexpressionStartOffset = subexpressionOffset;

        }

    protected:

        uint16_t m_subexpressionDivotOffset;

        uint16_t m_subexpressionStartOffset;

    };

    class RegExpNode : public ExpressionNode, public ThrowableExpressionData {

    public:

        RegExpNode(JSGlobalData*, const Identifier& pattern, const Identifier& flags);

    private:

        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

        const Identifier& m_pattern;

        const Identifier& m_flags;

    };

    class ThisNode : public ExpressionNode {

    public:

        ThisNode(JSGlobalData*);

    private:

        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

    };

    class ResolveNode : public ExpressionNode {

    public:

        ResolveNode(JSGlobalData*, const Identifier&, int startOffset);

        const Identifier& identifier() const { return m_ident; }

    private:

        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

        virtual bool isPure(BytecodeGenerator&) const ;

        virtual bool isLocation() const { return true; }

        virtual bool isResolveNode() const { return true; }

        const Identifier& m_ident;

        int32_t m_startOffset;

    };

    class ElementNode : public ParserArenaFreeable {

    public:

        ElementNode(JSGlobalData*, int elision, ExpressionNode*);

        ElementNode(JSGlobalData*, ElementNode*, int elision, ExpressionNode*);

        int elision() const { return m_elision; }

        ExpressionNode* value() { return m_node; }

        ElementNode* next() { return m_next; }

    private:

        ElementNode* m_next;

        int m_elision;

        ExpressionNode* m_node;

    };

    class ArrayNode : public ExpressionNode {

    public:

        ArrayNode(JSGlobalData*, int elision);

        ArrayNode(JSGlobalData*, ElementNode*);

        ArrayNode(JSGlobalData*, int elision, ElementNode*);

        ArgumentListNode* toArgumentList(JSGlobalData*) const;

    private:

        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

        virtual bool isSimpleArray() const ;

        ElementNode* m_element;

        int m_elision;

        bool m_optional;

    };

    class PropertyNode : public ParserArenaFreeable {

    public:

        enum Type { Constant = 1, Getter = 2, Setter = 4 };

        PropertyNode(JSGlobalData*, const Identifier& name, ExpressionNode* value, Type);

        PropertyNode(JSGlobalData*, double name, ExpressionNode* value, Type);

        const Identifier& name() const { return m_name; }

        Type type() const { return m_type; }

    private:

        friend class PropertyListNode;

        const Identifier& m_name;

        ExpressionNode* m_assign;

        Type m_type;

    };

    class PropertyListNode : public Node {

    public:

        PropertyListNode(JSGlobalData*, PropertyNode*);

        PropertyListNode(JSGlobalData*, PropertyNode*, PropertyListNode*);

        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

    private:

        PropertyNode* m_node;

        PropertyListNode* m_next;

    };

    class ObjectLiteralNode : public ExpressionNode {

    public:

        ObjectLiteralNode(JSGlobalData*);

        ObjectLiteralNode(JSGlobalData*, PropertyListNode*);

    private:

        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

        PropertyListNode* m_list;

    };

    class BracketAccessorNode : public ExpressionNode, public ThrowableExpressionData {

    public:

        BracketAccessorNode(JSGlobalData*, ExpressionNode* base, ExpressionNode* subscript, bool subscriptHasAssignments);

        ExpressionNode* base() const { return m_base; }

        ExpressionNode* subscript() const { return m_subscript; }

    private:

        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

        virtual bool isLocation() const { return true; }

        virtual bool isBracketAccessorNode() const { return true; }

        ExpressionNode* m_base;

        ExpressionNode* m_subscript;

        bool m_subscriptHasAssignments;

    };

    class DotAccessorNode : public ExpressionNode, public ThrowableExpressionData {

    public:

        DotAccessorNode(JSGlobalData*, ExpressionNode* base, const Identifier&);

        ExpressionNode* base() const { return m_base; }

        const Identifier& identifier() const { return m_ident; }

    private:

        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

        virtual bool isLocation() const { return true; }

        virtual bool isDotAccessorNode() const { return true; }

        ExpressionNode* m_base;

        const Identifier& m_ident;

    };

    class ArgumentListNode : public Node {

    public:

        ArgumentListNode(JSGlobalData*, ExpressionNode*);

        ArgumentListNode(JSGlobalData*, ArgumentListNode*, ExpressionNode*);

        ArgumentListNode* m_next;

        ExpressionNode* m_expr;

    private:

        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

    };

    class ArgumentsNode : public ParserArenaFreeable {

    public:

        ArgumentsNode(JSGlobalData*);

        ArgumentsNode(JSGlobalData*, ArgumentListNode*);

        ArgumentListNode* m_listNode;

    };

    class NewExprNode : public ExpressionNode, public ThrowableExpressionData {

    public:

        NewExprNode(JSGlobalData*, ExpressionNode*);

        NewExprNode(JSGlobalData*, ExpressionNode*, ArgumentsNode*);

    private:

        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

        ExpressionNode* m_expr;

        ArgumentsNode* m_args;

    };

    class EvalFunctionCallNode : public ExpressionNode, public ThrowableExpressionData {

    public:

        EvalFunctionCallNode(JSGlobalData*, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);

    private:

        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);

        ArgumentsNode* m_args;

    };

    class FunctionCallValueNode : public ExpressionNode, public ThrowableExpressionData {

    public:

        FunctionCallValueNode(JSGlobalData*, ExpressionNode*, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);

    private:

        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);