Parser Class Reference

Encapsulates a recursive descent parser. More...

#include <parser.h>

Collaboration diagram for Parser:

Public Member Functions
	Parser (const char *input)
	~Parser ()
SyntaxNode *	Parse ()
	Parses the input into a syntax tree. More...

Private Member Functions
SyntaxNode *	ParseDefault ()
SyntaxNode *	TryParseStatement ()
SyntaxNode *	ParseStatement ()
SyntaxNode *	ParseEvaluation ()
ExpressionNode *	ParseExpression ()
ExpressionNode *	ParseAddSubstract ()
ExpressionNode *	ParseFactor ()
ExpressionNode *	ParsePower ()
ExpressionNode *	ParseUnary ()
ExpressionNode *	ParseAtomic ()
ExpressionNode *	ParseIdent ()
ExpressionNode *	ParseNumber ()
SyntaxNode *	ParseFunctionDef ()
SyntaxNode *	ParseHelpStatement ()
SyntaxNode *	ParseDeleteStatement ()
SyntaxNode *	ParseListStatement ()
SyntaxNode *	ParseFileStatement ()
SyntaxNode *	ParseNumeralStatement ()
SyntaxNode *	ParseDigistStatement ()
SyntaxNode *	ParseDrawStatement ()
SyntaxNode *	ParsePromptStatement ()
SyntaxNode *	ParsePrefsStatement ()
void	GetToken ()
void	PutToken ()
bool	Expect (Symbol symbol)
Token *	Peek () const

Private Attributes
Lexer *	lexer
Token *	token
int	syntaxError
ErrorNode *	errorNode

Detailed Description

Encapsulates a recursive descent parser.

More info on recursive descent parsers is available at Wikipedia: https://wikipedia.org/wiki/Recursive_descent_parser

Definition at line 49 of file parser.h.

Constructor & Destructor Documentation

Parser()

Parser::Parser ( const char *  input )

explicit

Definition at line 43 of file parser.cpp.

References errorNode, Lexer::Lexer(), lexer, syntaxError, and token.

Referenced by Evaluator::Evaluate(), ExecuteStatement::Execute(), LoadStatement::Execute(), and PreferencesBase::SetPrefs().

{
    lexer = new Lexer(input);
    token = nullptr;
    errorNode = nullptr;
    syntaxError = 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

~Parser()

Parser::~Parser

(

)

Definition at line 51 of file parser.cpp.

References lexer.

{
    delete lexer;
}

Member Function Documentation

Expect()

bool Parser::Expect ( Symbol  symbol )

private

Definition at line 519 of file parser.cpp.

References Token::GetPos(), GetToken(), Token::symbol, syntaxError, and token.

Referenced by ParseAtomic(), ParseDefault(), ParseDeleteStatement(), ParseDrawStatement(), ParseFileStatement(), ParseFunctionDef(), and ParseIdent().

{
    GetToken();
    if (token->symbol != symbol)
    {
        syntaxError = token->GetPos();
        return false;
    }

    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetToken()

void Parser::GetToken ( )

private

Definition at line 494 of file parser.cpp.

References Lexer::GetFirstToken(), Token::GetNextToken(), lexer, and token.

Referenced by Expect(), Parse(), ParseAddSubstract(), ParseAtomic(), ParseDeleteStatement(), ParseDigistStatement(), ParseFactor(), ParseHelpStatement(), ParseIdent(), ParseListStatement(), ParseNumber(), ParseNumeralStatement(), ParsePower(), ParsePrefsStatement(), ParsePromptStatement(), ParseStatement(), ParseUnary(), and TryParseStatement().

{
    if (token == nullptr)
    {
        token = lexer->GetFirstToken();
    }
    else
    {
        token = token->GetNextToken();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Parse()

SyntaxNode * Parser::Parse

(

)

Parses the input into a syntax tree.

Returns

SyntaxNode* representing a pointer to the top node of the tree. Notice: The caller is responsible for releasing memory.

Definition at line 56 of file parser.cpp.

References StatementBlockNode::Add(), EmptyStatement::EmptyStatement(), ErrorNode::ErrorNode(), Lexer::GetInput(), Token::GetPos(), GetToken(), lexer, PutToken(), StatementBlockNode::StatementBlockNode(), Token::symbol, symdelimiter, symend, token, Lexer::Tokenize(), and TryParseStatement().

Referenced by Evaluator::Evaluate(), ExecuteStatement::Execute(), LoadStatement::Execute(), and PreferencesBase::SetPrefs().

{
    lexer->Tokenize();
    token = nullptr;

    StatementBlockNode* block = nullptr;
    SyntaxNode* result;
    Token* current;

    do
    {
        result = TryParseStatement();

        GetToken();
        if (token->symbol == symdelimiter || (token->symbol == symend && block != nullptr))
        {
            if (block == nullptr)
            {
                block = new StatementBlockNode();
            }

            if (result != nullptr)
            {
                block->Add(result);
            }

            while (token->symbol == symdelimiter)
            {
                GetToken();
            }
        }
        else if (token->symbol != symend)
        {
            if (result != nullptr)
            {
                delete result;
            }

            if (block == nullptr)
            {
                block = new StatementBlockNode();
            }

            result = new ErrorNode(lexer->GetInput(), token->GetPos());
            block->Add(result);

            // Skip until next statement
            do
            {
                GetToken();
            }
            while (token->symbol != symdelimiter && token->symbol != symend);
        }

        current = token;
        PutToken();
    }
    while (current->symbol != symend);

    if (block != nullptr)
        return block;

    if (result == nullptr)
        return new EmptyStatement();

    return result;;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ParseAddSubstract()

ExpressionNode * Parser::ParseAddSubstract ( )

private

Definition at line 283 of file parser.cpp.

References AdditionNode::AdditionNode(), GetToken(), ParseFactor(), PutToken(), SubtractionNode::SubtractionNode(), Token::symbol, symminus, symplus, and token.

Referenced by ParseExpression().

{
    ExpressionNode* node = ParseFactor();

    GetToken();
    while (token->symbol == symplus || token->symbol == symminus)
    {
        if (token->symbol == symplus)
        {
            node = new AdditionNode(node, ParseFactor());
        }
        else if (token->symbol == symminus)
        {
            node = new SubtractionNode(node, ParseFactor());
        }

        GetToken();
    }

    PutToken();
    return node;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ParseAtomic()

ExpressionNode * Parser::ParseAtomic ( )

private

Definition at line 362 of file parser.cpp.

References AbsoluteNode::AbsoluteNode(), ComplexiNode::ComplexiNode(), EulersNumberNode::EulersNumberNode(), Expect(), FactorialNode::FactorialNode(), Token::GetPos(), GetToken(), InsVariableNode::InsVariableNode(), NumericValueNode::NumericValueNode(), ParseExpression(), ParseIdent(), ParseNumber(), Peek(), PiNode::PiNode(), symabsolute, Token::symbol, syme, symfactorial, symi, symident, symins, symlparen, symnumber, sympi, symrparen, syntaxError, and token.

Referenced by ParseUnary().

{
    ExpressionNode* node;

    GetToken();
    if (token->symbol == symlparen)
    {
        node = ParseExpression();
        Expect(symrparen);
    }
    else if (token->symbol == symabsolute)
    {
        node = new AbsoluteNode(ParseExpression());
        Expect(symabsolute);
    }
    else if (token->symbol == symident)
    {
        node = ParseIdent();
    }
    else if (token->symbol == sympi)
    {
        node = new PiNode();
    }
    else if (token->symbol == syme)
    {
        node = new EulersNumberNode();
    }
    else if (token->symbol == symi)
    {
        node = new ComplexiNode();
    }
    else if (token->symbol == symins)
    {
        node = new InsVariableNode();
    }
    else if (token->symbol == symnumber)
    {
        node = ParseNumber();
    }
    else
    {
        node = new NumericValueNode();
        syntaxError = token->GetPos();
    }

    if (Peek()->symbol == symfactorial)
    {
        GetToken();
        node = new FactorialNode(node);
    }

    return node;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ParseDefault()

SyntaxNode * Parser::ParseDefault ( )

private

Definition at line 237 of file parser.cpp.

References errorNode, Expect(), ParseEvaluation(), ParseFunctionDef(), symassign, symident, symlparen, symrparen, syntaxError, and token.

Referenced by ParseStatement().

{
    Token* temp = token;

    // Peek tokens
    bool funcdef = Expect(symident);
    funcdef = funcdef && Expect(symlparen);
    funcdef = funcdef && Expect(symident);
    funcdef = funcdef && Expect(symrparen);
    funcdef = funcdef && Expect(symassign);

    // Restart parsing
    syntaxError = -1;
    errorNode = nullptr;
    token = temp;

    if (funcdef)
    {
        return ParseFunctionDef();
    }

    return ParseEvaluation();
}

Here is the call graph for this function:

Here is the caller graph for this function:

ParseDeleteStatement()

SyntaxNode * Parser::ParseDeleteStatement ( )

private

Definition at line 582 of file parser.cpp.

References DeleteStatement::DeleteStatement(), Expect(), Token::GetPos(), Token::GetText(), GetToken(), PutToken(), Token::symbol, symfunction, symident, symlparen, symrparen, symvariable, syntaxError, and token.

Referenced by ParseStatement().

{
    GetToken();
    if (token->symbol == symvariable || token->symbol == symfunction)
    {
        return new DeleteStatement(token->symbol);
    }

    if (token->symbol != symident)
    {
        syntaxError = token->GetPos();
        return nullptr;
    }

    Token* identToken = token;

    GetToken();
    if (token->symbol == symlparen)
    {
        Expect(symident);
        Token* parameter = token;
        Expect(symrparen);
        return new DeleteStatement(identToken->GetText(), parameter->GetText());
    }

    PutToken();
    return new DeleteStatement(token->GetText());
}

Here is the call graph for this function:

Here is the caller graph for this function:

ParseDigistStatement()

SyntaxNode * Parser::ParseDigistStatement ( )

private

Definition at line 713 of file parser.cpp.

References DecimalSystem::DecimalSystem(), DigitsStatement::DigitsStatement(), errorNode, ErrorNode::ErrorNode(), Lexer::GetInput(), Number::GetIntegerValue(), Token::GetPos(), Token::GetText(), GetToken(), lexer, NumeralSystem::Parse(), PutToken(), Token::symbol, symdelimiter, symend, symnumber, syntaxError, and token.

Referenced by ParseStatement().

{
    GetToken();
    if (token->symbol == symdelimiter || token->symbol == symend)
    {
        PutToken();
        return new DigitsStatement();
    }

    if (token->symbol != symnumber)
    {
        syntaxError = token->GetPos();
        return nullptr;
    }

    NumeralSystem* nsys = new DecimalSystem(0);
    Number* number = nsys->Parse(token->GetText());
    int digits = number->GetIntegerValue();
    delete number;
    delete nsys;

    if (digits < 0 || digits > 15)
    {
        errorNode = new ErrorNode(
            lexer->GetInput(),
            HELPPDIGITS,
            token->GetText(),
            token->GetPos());

        return nullptr;
    }

    return new DigitsStatement(digits);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ParseDrawStatement()

SyntaxNode * Parser::ParseDrawStatement ( )

private

Definition at line 772 of file parser.cpp.

References DrawStatement::DrawStatement(), Expect(), Token::GetText(), PlotStatement::PlotStatement(), Token::symbol, symident, symlparen, symplot, symrparen, and token.

Referenced by ParseStatement().

{
    Token* statement = token;

    Expect(symident);
    Token* identToken = token;
    Expect(symlparen);
    Expect(symident);
    Token* paramToken = token;
    Expect(symrparen);

    if (statement->symbol == symplot)
        return new PlotStatement(identToken->GetText(), paramToken->GetText());

    return new DrawStatement(identToken->GetText(), paramToken->GetText());
}

Here is the call graph for this function:

Here is the caller graph for this function:

ParseEvaluation()

SyntaxNode * Parser::ParseEvaluation ( )

private

Definition at line 261 of file parser.cpp.

References EvalStatement::EvalStatement(), ExpressionNode::IsSilent(), ParseExpression(), and SilentStatement::SilentStatement().

Referenced by ParseDefault().

{
    ExpressionNode* exp = ParseExpression();
    if (exp == nullptr)
    {
        return nullptr;
    }

    StatementNode* sta = new EvalStatement(exp);
    if (exp->IsSilent())
    {
        sta = new SilentStatement(sta);
    }

    return sta;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ParseExpression()

ExpressionNode * Parser::ParseExpression ( )

private

Definition at line 278 of file parser.cpp.

References ParseAddSubstract().

Referenced by ParseAtomic(), ParseEvaluation(), ParseFunctionDef(), ParseIdent(), and ParseStatement().

{
    return ParseAddSubstract();
}

Here is the call graph for this function:

Here is the caller graph for this function:

ParseFactor()

ExpressionNode * Parser::ParseFactor ( )

private

Definition at line 306 of file parser.cpp.

References DivisionNode::DivisionNode(), GetToken(), MultiplicationNode::MultiplicationNode(), ParsePower(), PutToken(), Token::symbol, symslash, symtimes, and token.

Referenced by ParseAddSubstract().

{
    ExpressionNode* node = ParsePower();

    GetToken();
    while (token->symbol == symtimes || token->symbol == symslash)
    {
        if (token->symbol == symtimes)
        {
            node = new MultiplicationNode(node, ParsePower());
        }
        else if (token->symbol == symslash)
        {
            node = new DivisionNode(node, ParsePower());
        }

        GetToken();
    }

    PutToken();
    return node;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ParseFileStatement()

SyntaxNode * Parser::ParseFileStatement ( )

private

Definition at line 627 of file parser.cpp.

References ErrorNode::ErrorNode(), ExecuteStatement::ExecuteStatement(), Expect(), Lexer::GetInput(), Token::GetPos(), Token::GetText(), lexer, LoadStatement::LoadStatement(), SaveStatement::SaveStatement(), ShowStatement::ShowStatement(), Token::symbol, symexecute, symload, symqident, symsave, symshow, and token.

Referenced by ParseStatement().

{
    Token* statement = token;

    Expect(symqident);
    Token* identToken = token;

    if (statement->symbol == symload)
        return new LoadStatement(identToken->GetText());

    if (statement->symbol == symsave)
        return new SaveStatement(identToken->GetText());

    if (statement->symbol == symexecute)
        return new ExecuteStatement(identToken->GetText());

    if (statement->symbol == symshow)
        return new ShowStatement(identToken->GetText());

    return new ErrorNode(
        lexer->GetInput(),
        HELPUERROR, EMPTYSTRING,
        statement->GetPos());
}

Here is the call graph for this function:

Here is the caller graph for this function:

ParseFunctionDef()

SyntaxNode * Parser::ParseFunctionDef ( )

private

Definition at line 535 of file parser.cpp.

References UserFunction::CreateVariable(), errorNode, ErrorNode::ErrorNode(), Expect(), FunctionDefinitionNode::FunctionDefinitionNode(), Program::Functions, FunctionList::GetFunctionDef(), Lexer::GetInput(), Token::GetPos(), Token::GetText(), VariableList::InsertTemporaryVariable(), FunctionList::IsSystemFunction(), lexer, ParseExpression(), VariableList::RemoveTemporaryVariable(), UserFunction::SetExpression(), symassign, symident, symlparen, symrparen, token, and Program::Variables.

Referenced by ParseDefault(), and ParseStatement().

{
    Expect(symident);
    Token* funcToken = token;
    Expect(symlparen);
    Expect(symident);
    Token* funcVariable = token;
    Expect(symrparen);
    Expect(symassign);

    if (Program->Functions->IsSystemFunction(funcToken->GetText()))
    {
        errorNode = new ErrorNode(
            lexer->GetInput(),
            HELPFUNRDEF,
            funcToken->GetText(),
            funcToken->GetPos());

        return nullptr;
    }

    UserFunction* function = Program->Functions->GetFunctionDef(funcToken->GetText());
    Variable* variable = function->CreateVariable(funcVariable->GetText());
    Program->Variables->InsertTemporaryVariable(variable);
    function->SetExpression(ParseExpression());
    Program->Variables->RemoveTemporaryVariable();

    // TODO: Move logic to FunctionDefinitionNode
    return new FunctionDefinitionNode();
}

Here is the call graph for this function:

Here is the caller graph for this function:

ParseHelpStatement()

SyntaxNode * Parser::ParseHelpStatement ( )

private

Definition at line 566 of file parser.cpp.

References Token::GetText(), GetToken(), HelpStatement::HelpStatement(), PutToken(), Token::symbol, symdelimiter, symend, symident, and token.

Referenced by ParseStatement().

{
    GetToken();

    if (token->symbol == symdelimiter || token->symbol == symend)
    {
        PutToken();
        return new HelpStatement();
    }

    if (token->symbol == symident)
        return new HelpStatement(token->GetText());

    return new HelpStatement(token->symbol);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ParseIdent()

ExpressionNode * Parser::ParseIdent ( )

private

Definition at line 416 of file parser.cpp.

References AssignmentNode::AssignmentNode(), VariableList::CreateVariable(), errorNode, ErrorNode::ErrorNode(), Expect(), Program::Functions, FunctionList::GetFunctionCall(), Lexer::GetInput(), Token::GetPos(), Token::GetText(), GetToken(), VariableList::GetVariable(), lexer, NumericValueNode::NumericValueNode(), ParseExpression(), PutToken(), symassign, Token::symbol, symlparen, symrparen, token, VariableNode::VariableNode(), and Program::Variables.

Referenced by ParseAtomic().

{
    ExpressionNode* node;
    Token* identToken = token;

    GetToken();
    if (token->symbol == symlparen)
    {
        ExpressionNode* parameter = ParseExpression();
        Expect(symrparen);
        node = Program->Functions->GetFunctionCall(identToken->GetText(), parameter);

        if (node == nullptr)
        {
            errorNode = new ErrorNode(
                lexer->GetInput(),
                HELPFUNNDEF,
                identToken->GetText(),
                identToken->GetPos());

            delete parameter;
            node = new NumericValueNode();
        }
    }
    else if (token->symbol == symassign)
    {
        Variable* var = Program->Variables->CreateVariable(identToken->GetText());
        node = new AssignmentNode(new VariableNode(var), ParseExpression());
    }
    else
    {
        PutToken();
        Variable* var = Program->Variables->GetVariable(token->GetText());

        if (var == nullptr)
        {
            errorNode = new ErrorNode(
                lexer->GetInput(),
                HELPVARNDEF,
                identToken->GetText(),
                identToken->GetPos());

            node = new NumericValueNode();
        }
        else
        {
            node = new VariableNode(var);
        }
    }

    return node;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ParseListStatement()

SyntaxNode * Parser::ParseListStatement ( )

private

Definition at line 611 of file parser.cpp.

References Token::GetPos(), Token::GetText(), GetToken(), ListStatement::ListStatement(), PutToken(), Token::symbol, symdelimiter, symend, symqident, syntaxError, and token.

Referenced by ParseStatement().

{
    GetToken();
    if (token->symbol == symqident)
        return new ListStatement(token->GetText());

    if (token->symbol == symend || token->symbol == symdelimiter)
    {
        PutToken();
        return new ListStatement();
    }

    syntaxError = token->GetPos();
    return nullptr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ParseNumber()

ExpressionNode * Parser::ParseNumber ( )

private

Definition at line 469 of file parser.cpp.

References ComplexNumber::ComplexNumber(), Number::GetRealValue(), Token::GetText(), GetToken(), Program::Input, NumericValueNode::NumericValueNode(), NumeralSystem::Parse(), PutToken(), Token::symbol, symi, and token.

Referenced by ParseAtomic().

{
    const char* a = token->GetText();
    Number* number;

    GetToken();
    if (token->symbol == symi)
    {
        Number* imag = Program->Input->Parse(a);
        number = new ComplexNumber(0.0, imag->GetRealValue());
        delete imag;
    }
    else
    {
        PutToken();
        number = Program->Input->Parse(a);
    }

    return new NumericValueNode(number);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ParseNumeralStatement()

SyntaxNode * Parser::ParseNumeralStatement ( )

private

Definition at line 652 of file parser.cpp.

References DecimalSystem::DecimalSystem(), errorNode, ErrorNode::ErrorNode(), Lexer::GetInput(), Number::GetIntegerValue(), Token::GetPos(), Token::GetText(), GetToken(), InputStatement::InputStatement(), lexer, OutputStatement::OutputStatement(), NumeralSystem::Parse(), PutToken(), symbin, Token::symbol, symdec, symdelimiter, symend, symhex, syminput, symnumber, symoct, syntaxError, and token.

Referenced by ParseStatement().

{
    Token* statement = token;
    unsigned int base;

    GetToken();
    switch (token->symbol)
    {
    case symend:
    case symdelimiter:
        PutToken();
        return (statement->symbol == syminput)
                   ? static_cast<SyntaxNode*>(new InputStatement())
                   : static_cast<SyntaxNode*>(new OutputStatement());
    case symbin:
        base = 2;
        break;
    case symoct:
        base = 8;
        break;
    case symdec:
        base = 10;
        break;
    case symhex:
        base = 16;
        break;
    default:
        base = 0;
    }

    if (base == 0 && token->symbol != symnumber)
    {
        syntaxError = token->GetPos();
        return nullptr;
    }

    if (base == 0)
    {
        NumeralSystem* nsys = new DecimalSystem(0);
        Number* number = nsys->Parse(token->GetText());
        base = number->GetIntegerValue();
        delete number;
        delete nsys;

        if (base < 2 || base > 32)
        {
            errorNode = new ErrorNode(
                lexer->GetInput(),
                HELPPNUMERA,
                token->GetText(),
                token->GetPos());

            return nullptr;
        }
    }

    return (statement->symbol == syminput)
               ? static_cast<SyntaxNode*>(new InputStatement(base))
               : static_cast<SyntaxNode*>(new OutputStatement(base));
}

Here is the call graph for this function:

Here is the caller graph for this function:

ParsePower()

ExpressionNode * Parser::ParsePower ( )

private

Definition at line 329 of file parser.cpp.

References GetToken(), ParseUnary(), PowerNode::PowerNode(), PutToken(), Token::symbol, sympower, and token.

Referenced by ParseFactor().

{
    ExpressionNode* node = ParseUnary();

    GetToken();
    while (token->symbol == sympower)
    {
        node = new PowerNode(node, ParseUnary());
        GetToken();
    }

    PutToken();
    return node;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ParsePrefsStatement()

SyntaxNode * Parser::ParsePrefsStatement ( )

private

Definition at line 760 of file parser.cpp.

References GetToken(), PrefsStatement::PrefsStatement(), PutToken(), Token::symbol, symload, symsave, and token.

Referenced by ParseStatement().

{
    GetToken();
    if (token->symbol == symload || token->symbol == symsave)
    {
        return new PrefsStatement(token->symbol);
    }

    PutToken();
    return new PrefsStatement();;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ParsePromptStatement()

SyntaxNode * Parser::ParsePromptStatement ( )

private

Definition at line 748 of file parser.cpp.

References Token::GetText(), GetToken(), PromptStatement::PromptStatement(), PutToken(), Token::symbol, symqident, and token.

Referenced by ParseStatement().

{
    GetToken();
    if (token->symbol == symqident)
    {
        return new PromptStatement(token->GetText());
    }

    PutToken();
    return nullptr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ParseStatement()

SyntaxNode * Parser::ParseStatement ( )

private

Definition at line 156 of file parser.cpp.

References AboutStatement::AboutStatement(), ClearStatement::ClearStatement(), EvalStatement::EvalStatement(), ExitStatement::ExitStatement(), GetToken(), LicenseStatement::LicenseStatement(), ListFunctionsStatement::ListFunctionsStatement(), ListVariablesStatement::ListVariablesStatement(), MemoryStatement::MemoryStatement(), ParseDefault(), ParseDeleteStatement(), ParseDigistStatement(), ParseDrawStatement(), ParseExpression(), ParseFileStatement(), ParseFunctionDef(), ParseHelpStatement(), ParseListStatement(), ParseNumeralStatement(), ParsePrefsStatement(), ParsePromptStatement(), PutToken(), symabout, Token::symbol, symclear, symdef, symdelete, symdigits, symdraw, symeval, symexecute, symexit, symfunction, symhelp, syminput, symlicense, symlist, symload, symmem, symoutput, symplot, symprefs, symprompt, symsave, symshow, symvariable, symversion, token, and VersionStatement::VersionStatement().

Referenced by TryParseStatement().

{
    SyntaxNode* res;

    GetToken();
    switch (token->symbol)
    {
    case symhelp:
        res = ParseHelpStatement();
        break;
    case symdelete:
        res = ParseDeleteStatement();
        break;
    case symdef:
        res = ParseFunctionDef();
        break;
#if defined(UNIX) || defined(HAIKU) || defined(AMIGA)
    case symlist:
        res = ParseListStatement();
        break;
#endif
    case symshow:
    case symload:
    case symsave:
    case symexecute:
        res = ParseFileStatement();
        break;
    case syminput:
    case symoutput:
        res = ParseNumeralStatement();
        break;
    case symprompt:
        res = ParsePromptStatement();
        break;
    case symprefs:
        res = ParsePrefsStatement();
        break;
    case symdigits:
        res = ParseDigistStatement();
        break;
    case symdraw:
    case symplot:
        res = ParseDrawStatement();
        break;
    case symabout:
        res = new AboutStatement();
        break;
    case symlicense:
        res = new LicenseStatement();
        break;
    case symversion:
        res = new VersionStatement();
        break;
    case symexit:
        res = new ExitStatement();
        break;
#if defined(AMIGA) || defined(TERMIOS) || defined(WINDOWS)
    case symclear:
        res = new ClearStatement();
        break;
#endif
    case symmem:
        res = new MemoryStatement();
        break;
    case symvariable:
        res = new ListVariablesStatement();
        break;
    case symfunction:
        res = new ListFunctionsStatement();
        break;
    case symeval:
        res = new EvalStatement(ParseExpression());
        break;
    default:
        PutToken();
        res = ParseDefault();
    }

    return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ParseUnary()

ExpressionNode * Parser::ParseUnary ( )

private

Definition at line 344 of file parser.cpp.

References GetToken(), ParseAtomic(), PutToken(), Token::symbol, symminus, token, and UnaryNode::UnaryNode().

Referenced by ParsePower().

{
    ExpressionNode* node;

    GetToken();
    if (token->symbol == symminus)
    {
        node = new UnaryNode(ParseAtomic());
    }
    else
    {
        PutToken();
        node = ParseAtomic();
    }

    return node;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Peek()

Token * Parser::Peek ( ) const

private

Definition at line 506 of file parser.cpp.

References Lexer::GetFirstToken(), Token::GetNextToken(), lexer, and token.

Referenced by ParseAtomic().

{
    if (token == nullptr)
        return lexer->GetFirstToken();

    return token->GetNextToken();
}

Here is the call graph for this function:

Here is the caller graph for this function:

PutToken()

void Parser::PutToken ( )

private

Definition at line 514 of file parser.cpp.

References Token::GetLastToken(), and token.

Referenced by Parse(), ParseAddSubstract(), ParseDeleteStatement(), ParseDigistStatement(), ParseFactor(), ParseHelpStatement(), ParseIdent(), ParseListStatement(), ParseNumber(), ParseNumeralStatement(), ParsePower(), ParsePrefsStatement(), ParsePromptStatement(), ParseStatement(), ParseUnary(), and TryParseStatement().

{
    token = token->GetLastToken();
}

Here is the call graph for this function:

Here is the caller graph for this function:

TryParseStatement()

SyntaxNode * Parser::TryParseStatement ( )

private

Definition at line 124 of file parser.cpp.

References errorNode, ErrorNode::ErrorNode(), Lexer::GetInput(), GetToken(), lexer, ParseStatement(), PutToken(), Token::symbol, symdelimiter, symend, syntaxError, and token.

Referenced by Parse().

{
    GetToken();
    if (token->symbol == symend || token->symbol == symdelimiter)
    {
        PutToken();
        return nullptr;
    }
    PutToken();

    errorNode = nullptr;
    syntaxError = -1;
    SyntaxNode* result = ParseStatement();

    if (errorNode == nullptr && syntaxError != -1)
    {
        errorNode = new ErrorNode(lexer->GetInput(), syntaxError);
    }

    if (errorNode != nullptr)
    {
        delete result;
        result = errorNode;
    }

    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

errorNode

ErrorNode* Parser::errorNode

private

Definition at line 69 of file parser.h.

Referenced by ParseDefault(), ParseDigistStatement(), ParseFunctionDef(), ParseIdent(), ParseNumeralStatement(), Parser(), and TryParseStatement().

lexer

Lexer* Parser::lexer

private

Definition at line 65 of file parser.h.

Referenced by GetToken(), Parse(), ParseDigistStatement(), ParseFileStatement(), ParseFunctionDef(), ParseIdent(), ParseNumeralStatement(), Parser(), Peek(), TryParseStatement(), and ~Parser().

syntaxError

int Parser::syntaxError

private

Definition at line 68 of file parser.h.

Referenced by Expect(), ParseAtomic(), ParseDefault(), ParseDeleteStatement(), ParseDigistStatement(), ParseListStatement(), ParseNumeralStatement(), Parser(), and TryParseStatement().

token

Token* Parser::token

private

Definition at line 66 of file parser.h.

Referenced by Expect(), GetToken(), Parse(), ParseAddSubstract(), ParseAtomic(), ParseDefault(), ParseDeleteStatement(), ParseDigistStatement(), ParseDrawStatement(), ParseFactor(), ParseFileStatement(), ParseFunctionDef(), ParseHelpStatement(), ParseIdent(), ParseListStatement(), ParseNumber(), ParseNumeralStatement(), ParsePower(), ParsePrefsStatement(), ParsePromptStatement(), Parser(), ParseStatement(), ParseUnary(), Peek(), PutToken(), and TryParseStatement().

---

The documentation for this class was generated from the following files:

• src/main/parser.h
• src/main/parser.cpp