#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 "ParserError.h"

#include "ParserTokens.h"

#include "SourceProvider.h"

#include "SourceProviderCache.h"

#include "SourceProviderCacheItem.h"

#include <wtf/Forward.h>

#include <wtf/Noncopyable.h>

#include <wtf/OwnPtr.h>

#include <wtf/RefPtr.h>

namespace JSC {

struct Scope;

}

namespace WTF {

template <> struct VectorTraits<JSC::Scope> : SimpleClassVectorTraits {

static const bool canInitializeWithMemset = false; // Not all Scope data members initialize to 0.

};

}

namespace JSC {

class ExecState;

class FunctionBodyNode;

class FunctionParameters;

class Identifier;

class VM;

class ProgramNode;

class SourceCode;

#define TreeStatement typename TreeBuilder::Statement

#define TreeExpression typename TreeBuilder::Expression

#define TreeFormalParameterList typename TreeBuilder::FormalParameterList

#define TreeSourceElements typename TreeBuilder::SourceElements

#define TreeClause typename TreeBuilder::Clause

#define TreeClauseList typename TreeBuilder::ClauseList

#define TreeConstDeclList typename TreeBuilder::ConstDeclList

#define TreeArguments typename TreeBuilder::Arguments

#define TreeArgumentsList typename TreeBuilder::ArgumentsList

#define TreeFunctionBody typename TreeBuilder::FunctionBody

#define TreeProperty typename TreeBuilder::Property

#define TreePropertyList typename TreeBuilder::PropertyList

#define TreeDeconstructionPattern typename TreeBuilder::DeconstructionPattern

COMPILE_ASSERT(LastUntaggedToken < 64, LessThan64UntaggedTokens);

enum SourceElementsMode { CheckForStrictMode, DontCheckForStrictMode };

enum FunctionRequirements { FunctionNoRequirements, FunctionNeedsName };

enum FunctionParseMode { FunctionMode, GetterMode, SetterMode };

enum DeconstructionKind {

};

template <typename T> inline bool isEvalNode() { return false; }

template <> inline bool isEvalNode<EvalNode>() { return true; }

struct ScopeLabelInfo {

};

struct Scope {

};

typedef Vector<Scope, 10> ScopeStack;

struct ScopeRef {

};

template <typename LexerType>

class Parser {

};

template <typename LexerType>

template <class ParsedNode>

PassRefPtr<ParsedNode> Parser<LexerType>::parse(ParserError& error, bool needReparsingAdjustment)

{

int errLine;

String errMsg;

if (ParsedNode::scopeIsFunction && needReparsingAdjustment)

m_lexer->setIsReparsing();

m_sourceElements = 0;

errLine = -1;

errMsg = String();

JSTokenLocation startLocation(tokenLocation());

ASSERT(m_source->startColumn() > 0);

unsigned startColumn = m_source->startColumn() - 1;

String parseError = parseInner();

int lineNumber = m_lexer->lineNumber();

bool lexError = m_lexer->sawError();

String lexErrorMessage = lexError ? m_lexer->getErrorMessage() : String();

ASSERT(lexErrorMessage.isNull() != lexError);

m_lexer->clear();

if (!parseError.isNull() || lexError) {

errLine = lineNumber;

errMsg = !lexErrorMessage.isNull() ? lexErrorMessage : parseError;

m_sourceElements = 0;

}

RefPtr<ParsedNode> result;

if (m_sourceElements) {

JSTokenLocation endLocation;

endLocation.line = m_lexer->lineNumber();

endLocation.lineStartOffset = m_lexer->currentLineStartOffset();

endLocation.startOffset = m_lexer->currentOffset();

unsigned endColumn = endLocation.startOffset - endLocation.lineStartOffset;

result = ParsedNode::create(m_vm,

startLocation,

endLocation,

startColumn,

endColumn,

m_sourceElements,

m_varDeclarations ? &m_varDeclarations->data : 0,

m_funcDeclarations ? &m_funcDeclarations->data : 0,

m_capturedVariables,

*m_source,

m_features,

m_numConstants);

result->setLoc(m_source->firstLine(), m_lexer->lineNumber(), m_lexer->currentOffset(), m_lexer->currentLineStartOffset());

} else {

// We can never see a syntax error when reparsing a function, since we should have

// reported the error when parsing the containing program or eval code. So if we're

// parsing a function body node, we assume that what actually happened here is that

// we ran out of stack while parsing. If we see an error while parsing eval or program

// code we assume that it was a syntax error since running out of stack is much less

// likely, and we are currently unable to distinguish between the two cases.

if (isFunctionBodyNode(static_cast<ParsedNode*>(0)) || m_hasStackOverflow)

error = ParserError(ParserError::StackOverflow, ParserError::SyntaxErrorNone, m_token);

else {

ParserError::SyntaxErrorType errorType = ParserError::SyntaxErrorIrrecoverable;

if (m_token.m_type == EOFTOK)

errorType = ParserError::SyntaxErrorRecoverable;

else if (m_token.m_type & UnterminatedErrorTokenFlag)

errorType = ParserError::SyntaxErrorUnterminatedLiteral;

if (isEvalNode<ParsedNode>())

error = ParserError(ParserError::EvalError, errorType, m_token, errMsg, errLine);

else

error = ParserError(ParserError::SyntaxError, errorType, m_token, errMsg, errLine);

}

}

m_arena->reset();

return result.release();

}

template <class ParsedNode>

PassRefPtr<ParsedNode> parse(VM* vm, const SourceCode& source, FunctionParameters* parameters, const Identifier& name, JSParserStrictness strictness, JSParserMode parserMode, ParserError& error, JSTextPosition* positionBeforeLastNewline = 0, bool needReparsingAdjustment = false)

}

} // namespace

#endif