#ifndef Parser_h
#define Parser_h
#include "Debugger.h"
#include "ExceptionHelpers.h"
#include "Executable.h"
#include "JSGlobalObject.h"
#include "Lexer.h"
#include "Nodes.h"
#include "ParserArena.h"
#include "SourceProvider.h"
#include <wtf/Forward.h>
#include <wtf/Noncopyable.h>
#include <wtf/OwnPtr.h>
#include <wtf/RefPtr.h>
namespace JSC {
class FunctionBodyNode;
class ProgramNode;
class UString;
template <typename T> inline bool isEvalNode() { return false; }
template <> inline bool isEvalNode<EvalNode>() { return true; }
template <typename T> struct ParserArenaData : ParserArenaDeletable { T data; };
class Parser {
WTF_MAKE_NONCOPYABLE(Parser); WTF_MAKE_FAST_ALLOCATED;
public:
Parser() { }
template <class ParsedNode>
PassRefPtr<ParsedNode> parse(JSGlobalObject* lexicalGlobalObject, Debugger*, ExecState*, const SourceCode& source, FunctionParameters*, JSParserStrictness strictness, JSObject** exception);
void didFinishParsing(SourceElements*, ParserArenaData<DeclarationStacks::VarStack>*,
ParserArenaData<DeclarationStacks::FunctionStack>*, CodeFeatures features,
int lastLine, int numConstants, IdentifierSet&);
ParserArena& arena() { return m_arena; }
private:
void parse(JSGlobalData*, FunctionParameters*, JSParserStrictness strictness, JSParserMode mode, int* errLine, UString* errMsg);
bool isFunctionBodyNode(ScopeNode*) { return false; }
bool isFunctionBodyNode(FunctionBodyNode*) { return true; }
ParserArena m_arena;
const SourceCode* m_source;
SourceElements* m_sourceElements;
ParserArenaData<DeclarationStacks::VarStack>* m_varDeclarations;
ParserArenaData<DeclarationStacks::FunctionStack>* m_funcDeclarations;
IdentifierSet m_capturedVariables;
CodeFeatures m_features;
int m_lastLine;
int m_numConstants;
};
template <class ParsedNode>
PassRefPtr<ParsedNode> Parser::parse(JSGlobalObject* lexicalGlobalObject, Debugger* debugger, ExecState* debuggerExecState, const SourceCode& source, FunctionParameters* parameters, JSParserStrictness strictness, JSObject** exception)
{
ASSERT(lexicalGlobalObject);
ASSERT(exception && !*exception);
int errLine;
UString errMsg;
m_source = &source;
if (ParsedNode::scopeIsFunction)
lexicalGlobalObject->globalData().lexer->setIsReparsing();
parse(&lexicalGlobalObject->globalData(), parameters, strictness, ParsedNode::isFunctionNode ? JSParseFunctionCode : JSParseProgramCode, &errLine, &errMsg);
RefPtr<ParsedNode> result;
if (m_sourceElements) {
result = ParsedNode::create(&lexicalGlobalObject->globalData(),
m_sourceElements,
m_varDeclarations ? &m_varDeclarations->data : 0,
m_funcDeclarations ? &m_funcDeclarations->data : 0,
m_capturedVariables,
source,
m_features,
m_numConstants);
result->setLoc(m_source->firstLine(), m_lastLine);
} else if (lexicalGlobalObject) {
if (isFunctionBodyNode(static_cast<ParsedNode*>(0)))
*exception = createStackOverflowError(lexicalGlobalObject);
else if (isEvalNode<ParsedNode>())
*exception = createSyntaxError(lexicalGlobalObject, errMsg);
else
*exception = addErrorInfo(&lexicalGlobalObject->globalData(), createSyntaxError(lexicalGlobalObject, errMsg), errLine, source);
}
m_arena.reset();
m_source = 0;
m_sourceElements = 0;
m_varDeclarations = 0;
m_funcDeclarations = 0;
if (debugger && !ParsedNode::scopeIsFunction)
debugger->sourceParsed(debuggerExecState, source.provider(), errLine, errMsg);
return result.release();
}
}
#endif // Parser_h