#include <jetscript/Parser.h>

#include <jetscript/Token.h>

#include <jetscript/UniquePtr.h>

using namespace Jet;

const char* Jet::Operator(TokenType t)

{

if (t == TokenType::Plus)

return "+";

else if (t == TokenType::Minus)

return "-";

else if (t == TokenType::Asterisk)

return "*";

else if (t == TokenType::Slash)

return "/";

else if (t == TokenType::Modulo)

return "%";

else if (t == TokenType::Comma)

return ",";

else if (t == TokenType::Increment)

return "++";

else if (t == TokenType::Decrement)

return "--";

else if (t == TokenType::Equals)

return "==";

else if (t == TokenType::NotEqual)

return "!=";

else if (t == TokenType::Semicolon)

return ";";

else if (t == TokenType::RightBrace)

return "}";

return "";

}

Parser::Parser(Lexer* l)

{

this->lexer = l;

this->filename = l->filename;

this->Register(TokenType::Name, new NameParselet());

this->Register(TokenType::Number, new NumberParselet());

this->Register(TokenType::String, new StringParselet());

this->Register(TokenType::Assign, new AssignParselet());

this->Register(TokenType::LeftParen, new GroupParselet());

this->Register(TokenType::Swap, new SwapParselet());

this->Register(TokenType::Colon, new MemberParselet());

this->Register(TokenType::Dot, new MemberParselet());

this->Register(TokenType::LeftBrace, new ObjectParselet());

//array/index stuffs

this->Register(TokenType::LeftBracket, new ArrayParselet());

this->Register(TokenType::LeftBracket, new IndexParselet());//postfix

//operator assign

this->Register(TokenType::AddAssign, new OperatorAssignParselet());

this->Register(TokenType::SubtractAssign, new OperatorAssignParselet());

this->Register(TokenType::MultiplyAssign, new OperatorAssignParselet());

this->Register(TokenType::DivideAssign, new OperatorAssignParselet());

this->Register(TokenType::AndAssign, new OperatorAssignParselet());

this->Register(TokenType::OrAssign, new OperatorAssignParselet());

this->Register(TokenType::XorAssign, new OperatorAssignParselet());

//prefix stuff

this->Register(TokenType::Increment, new PrefixOperatorParselet(Precedence::PREFIX));

this->Register(TokenType::Decrement, new PrefixOperatorParselet(Precedence::PREFIX));

this->Register(TokenType::Minus, new PrefixOperatorParselet(Precedence::PREFIX));

this->Register(TokenType::BNot, new PrefixOperatorParselet(Precedence::PREFIX));

//postfix stuff

this->Register(TokenType::Increment, new PostfixOperatorParselet(Precedence::POSTFIX));

this->Register(TokenType::Decrement, new PostfixOperatorParselet(Precedence::POSTFIX));

//boolean stuff

this->Register(TokenType::Equals, new BinaryOperatorParselet(Precedence::CONDITIONAL, false));

this->Register(TokenType::NotEqual, new BinaryOperatorParselet(Precedence::CONDITIONAL, false));

this->Register(TokenType::LessThan, new BinaryOperatorParselet(Precedence::CONDITIONAL, false));

this->Register(TokenType::GreaterThan, new BinaryOperatorParselet(Precedence::CONDITIONAL, false));

this->Register(TokenType::LessThanEqual, new BinaryOperatorParselet(Precedence::CONDITIONAL, false));

this->Register(TokenType::GreaterThanEqual, new BinaryOperatorParselet(Precedence::CONDITIONAL, false));

//logical and/or

this->Register(TokenType::And, new BinaryOperatorParselet(Precedence::LOGICAL, false));

this->Register(TokenType::Or, new BinaryOperatorParselet(Precedence::LOGICAL, false));

//math

this->Register(TokenType::Plus, new BinaryOperatorParselet(Precedence::SUM, false));

this->Register(TokenType::Minus, new BinaryOperatorParselet(Precedence::SUM, false));

this->Register(TokenType::Asterisk, new BinaryOperatorParselet(Precedence::PRODUCT, false));

this->Register(TokenType::Slash, new BinaryOperatorParselet(Precedence::PRODUCT, false));

this->Register(TokenType::Modulo, new BinaryOperatorParselet(Precedence::PRODUCT, false));

this->Register(TokenType::BOr, new BinaryOperatorParselet(Precedence::BINARY, false));//or

this->Register(TokenType::BAnd, new BinaryOperatorParselet(Precedence::BINARY, false));//and

this->Register(TokenType::Xor, new BinaryOperatorParselet(Precedence::BINARY, false));

this->Register(TokenType::LeftShift, new BinaryOperatorParselet(Precedence::BINARY, false));

this->Register(TokenType::RightShift, new BinaryOperatorParselet(Precedence::BINARY, false));

//add parser for includes k

//function stuff

this->Register(TokenType::LeftParen, new CallParselet());

//lambda

this->Register(TokenType::Function, new LambdaParselet());

//this->Register(TokenType::LeftParen, new LambdaParselet());

//statements

this->Register(TokenType::While, new WhileParselet());

this->Register(TokenType::If, new IfParselet());

this->Register(TokenType::Function, new FunctionParselet());

this->Register(TokenType::Ret, new ReturnParselet());

this->Register(TokenType::For, new ForParselet());

this->Register(TokenType::Local, new LocalParselet());

this->Register(TokenType::Break, new BreakParselet());

this->Register(TokenType::Continue, new ContinueParselet());

this->Register(TokenType::Const, new ConstParselet());

this->Register(TokenType::Null, new NullParselet());

this->Register(TokenType::Yield, new YieldParselet());

this->Register(TokenType::Yield, new InlineYieldParselet());

this->Register(TokenType::Resume, new ResumeParselet());

this->Register(TokenType::Resume, new ResumePrefixParselet());

}

Parser::~Parser()

{

for (auto ii: this->mInfixParselets)

delete ii.second;

for (auto ii: this->mPrefixParselets)

delete ii.second;

for (auto ii: this->mStatementParselets)

delete ii.second;

};

Expression* Parser::parseExpression(int precedence)

{

Token token = Consume();

PrefixParselet* prefix = mPrefixParselets[token.getType()];

if (prefix == 0)

{

std::string str = "ParseExpression: No Parser Found for: " + token.getText();

throw CompilerException(this->filename, token.line, str);//printf("Consume: TokenType not as expected!\n");

}

Expression* left = prefix->parse(this, token);

while (precedence < getPrecedence())

{

token = Consume();

InfixParselet* infix = mInfixParselets[token.getType()];

left = infix->parse(this, left, token);

}

return left;

}

Expression* Parser::ParseStatement(bool takeTrailingSemicolon)//call this until out of tokens (hit EOF)

{

Token token = LookAhead();

StatementParselet* statement = mStatementParselets[token.getType()];

if (statement == 0)

{

UniquePtr<Expression*> result(parseExpression());

if (takeTrailingSemicolon)

Consume(TokenType::Semicolon);

return result.Release();

}

token = Consume();

UniquePtr<Expression*> result(statement->parse(this, token));

if (takeTrailingSemicolon && statement->TrailingSemicolon)

Consume(TokenType::Semicolon);

return result.Release();

}

BlockExpression* Parser::parseBlock(bool allowsingle)

{

std::vector<Expression*> statements;

if (allowsingle && !Match(TokenType::LeftBrace))

{

statements.push_back(this->ParseStatement());

return new BlockExpression(std::move(statements));

}

Consume(TokenType::LeftBrace);

while (!Match(TokenType::RightBrace))

{

statements.push_back(this->ParseStatement());

}

Consume(TokenType::RightBrace);

return new BlockExpression(std::move(statements));

}

BlockExpression* Parser::parseAll()

{

std::vector<Expression*> statements;

while (!Match(TokenType::EoF))

{

statements.push_back(this->ParseStatement());

}

auto n = new BlockExpression(std::move(statements));

n->SetParent(0);//go through and setup parents

return n;

}

Token Parser::Consume()

{

auto temp = LookAhead();

mRead.pop_front();

return temp;

}

Token Parser::Consume(TokenType expected)

{

auto temp = LookAhead();

if (temp.getType() != expected)

{

std::string str = "Consume: TokenType not as expected! Expected: " + TokenToString[expected] + " Got: " + temp.text;

throw CompilerException(this->filename, temp.line, str);

}

mRead.pop_front();

return temp;

}

Token Parser::LookAhead(unsigned int num)

{

while (num >= mRead.size())

mRead.push_back(lexer->Next());

int c = 0;

for (auto ii: mRead)

{

if (c++ == num)

return ii;

}

return Token(0, TokenType::EoF, "EOF");

}

bool Parser::Match(TokenType expected)

{

Token token = LookAhead();

if (token.getType() != expected)

{

return false;

}

return true;

}

bool Parser::MatchAndConsume(TokenType expected)

{

Token token = LookAhead();

if (token.getType() != expected)

{

return false;

}

mRead.pop_front();

return true;

}

void Parser::Register(TokenType token, InfixParselet* parselet)

{

this->mInfixParselets[token] = parselet;

}

void Parser::Register(TokenType token, PrefixParselet* parselet)

{

this->mPrefixParselets[token] = parselet;

}

void Parser::Register(TokenType token, StatementParselet* parselet)

{

this->mStatementParselets[token] = parselet;

}

int Parser::getPrecedence() {

InfixParselet* parser = mInfixParselets[LookAhead(0).getType()];

if (parser != 0)

return parser->getPrecedence();

return 0;

}