1/*
2 *  Copyright (C) 1999-2001 Harri Porten (porten@kde.org)
3 *  Copyright (C) 2001 Peter Kelly (pmk@post.com)
4 *  Copyright (C) 2003, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
5 *
6 *  This library is free software; you can redistribute it and/or
7 *  modify it under the terms of the GNU Library General Public
8 *  License as published by the Free Software Foundation; either
9 *  version 2 of the License, or (at your option) any later version.
10 *
11 *  This library is distributed in the hope that it will be useful,
12 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14 *  Library General Public License for more details.
15 *
16 *  You should have received a copy of the GNU Library General Public License
17 *  along with this library; see the file COPYING.LIB.  If not, write to
18 *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
19 *  Boston, MA 02110-1301, USA.
20 *
21 */
22
23#ifndef Parser_h
24#define Parser_h
25
26#include "Debugger.h"
27#include "ExceptionHelpers.h"
28#include "Executable.h"
29#include "JSGlobalObject.h"
30#include "Lexer.h"
31#include "Nodes.h"
32#include "ParserArena.h"
33#include "SourceProvider.h"
34#include <wtf/Forward.h>
35#include <wtf/Noncopyable.h>
36#include <wtf/OwnPtr.h>
37#include <wtf/RefPtr.h>
38
39namespace JSC {
40
41    class FunctionBodyNode;
42
43    class ProgramNode;
44    class UString;
45
46    template <typename T> struct ParserArenaData : ParserArenaDeletable { T data; };
47
48    class Parser {
49        WTF_MAKE_NONCOPYABLE(Parser); WTF_MAKE_FAST_ALLOCATED;
50    public:
51        Parser() { }
52        template <class ParsedNode>
53        PassRefPtr<ParsedNode> parse(JSGlobalObject* lexicalGlobalObject, Debugger*, ExecState*, const SourceCode& source, FunctionParameters*, JSParserStrictness strictness, JSObject** exception);
54
55        void didFinishParsing(SourceElements*, ParserArenaData<DeclarationStacks::VarStack>*,
56                              ParserArenaData<DeclarationStacks::FunctionStack>*, CodeFeatures features,
57                              int lastLine, int numConstants, IdentifierSet&);
58
59        ParserArena& arena() { return m_arena; }
60
61    private:
62        void parse(JSGlobalData*, FunctionParameters*, JSParserStrictness strictness, JSParserMode mode, int* errLine, UString* errMsg);
63
64        // Used to determine type of error to report.
65        bool isFunctionBodyNode(ScopeNode*) { return false; }
66        bool isFunctionBodyNode(FunctionBodyNode*) { return true; }
67
68        ParserArena m_arena;
69        const SourceCode* m_source;
70        SourceElements* m_sourceElements;
71        ParserArenaData<DeclarationStacks::VarStack>* m_varDeclarations;
72        ParserArenaData<DeclarationStacks::FunctionStack>* m_funcDeclarations;
73        IdentifierSet m_capturedVariables;
74        CodeFeatures m_features;
75        int m_lastLine;
76        int m_numConstants;
77    };
78
79    template <class ParsedNode>
80    PassRefPtr<ParsedNode> Parser::parse(JSGlobalObject* lexicalGlobalObject, Debugger* debugger, ExecState* debuggerExecState, const SourceCode& source, FunctionParameters* parameters, JSParserStrictness strictness, JSObject** exception)
81    {
82        ASSERT(lexicalGlobalObject);
83        ASSERT(exception && !*exception);
84        int errLine;
85        UString errMsg;
86
87        m_source = &source;
88        if (ParsedNode::scopeIsFunction)
89            lexicalGlobalObject->globalData().lexer->setIsReparsing();
90        parse(&lexicalGlobalObject->globalData(), parameters, strictness, ParsedNode::isFunctionNode ? JSParseFunctionCode : JSParseProgramCode, &errLine, &errMsg);
91
92        RefPtr<ParsedNode> result;
93        if (m_sourceElements) {
94            result = ParsedNode::create(&lexicalGlobalObject->globalData(),
95                m_sourceElements,
96                m_varDeclarations ? &m_varDeclarations->data : 0,
97                m_funcDeclarations ? &m_funcDeclarations->data : 0,
98                m_capturedVariables,
99                source,
100                m_features,
101                m_numConstants);
102            result->setLoc(m_source->firstLine(), m_lastLine);
103        } else if (lexicalGlobalObject) {
104            // We can never see a syntax error when reparsing a function, since we should have
105            // reported the error when parsing the containing program or eval code. So if we're
106            // parsing a function body node, we assume that what actually happened here is that
107            // we ran out of stack while parsing. If we see an error while parsing eval or program
108            // code we assume that it was a syntax error since running out of stack is much less
109            // likely, and we are currently unable to distinguish between the two cases.
110            if (isFunctionBodyNode(static_cast<ParsedNode*>(0)))
111                *exception = createStackOverflowError(lexicalGlobalObject);
112            else
113                *exception = addErrorInfo(&lexicalGlobalObject->globalData(), createSyntaxError(lexicalGlobalObject, errMsg), errLine, source);
114        }
115
116        m_arena.reset();
117
118        m_source = 0;
119        m_sourceElements = 0;
120        m_varDeclarations = 0;
121        m_funcDeclarations = 0;
122
123        if (debugger && !ParsedNode::scopeIsFunction)
124            debugger->sourceParsed(debuggerExecState, source.provider(), errLine, errMsg);
125        return result.release();
126    }
127
128} // namespace JSC
129
130#endif // Parser_h
131