C4AulParse Class Reference

#include <C4AulParse.h>

Public Member Functions
	C4AulParse (class C4ScriptHost *host)
	C4AulParse (C4AulScriptFunc *Fn, C4AulScriptContext *context, C4AulScriptEngine *Engine)
	~C4AulParse ()
std::unique_ptr<::aul::ast::FunctionDecl >	Parse_DirectExec (const char *code, bool whole_function)
std::unique_ptr<::aul::ast::Script >	Parse_Script (C4ScriptHost *)

Protected Member Functions
std::unique_ptr<::aul::ast::FunctionDecl >	Parse_ToplevelFunctionDecl ()
std::unique_ptr<::aul::ast::Stmt >	Parse_Statement ()
std::unique_ptr<::aul::ast::Block >	Parse_Block ()
std::unique_ptr<::aul::ast::ArrayLit >	Parse_Array ()
std::unique_ptr<::aul::ast::ProplistLit >	Parse_PropList ()
std::unique_ptr<::aul::ast::DoLoop >	Parse_DoWhile ()
std::unique_ptr<::aul::ast::WhileLoop >	Parse_While ()
std::unique_ptr<::aul::ast::If >	Parse_If ()
std::unique_ptr<::aul::ast::ForLoop >	Parse_For ()
std::unique_ptr<::aul::ast::RangeLoop >	Parse_ForEach ()
std::unique_ptr<::aul::ast::Expr >	Parse_Expression (int iParentPrio=-1)
std::unique_ptr<::aul::ast::VarDecl >	Parse_Var ()
void	Shift ()

Friends
class	C4AulParseError

Detailed Description

Definition at line 45 of file C4AulParse.h.

Constructor & Destructor Documentation

C4AulParse() [1/2]

C4AulParse::C4AulParse

(

class C4ScriptHost *

host

)

Definition at line 105 of file C4AulParse.cpp.

                                      :
    Fn(nullptr), Host(a), pOrgScript(a), Engine(a->Engine),
    SPos(a->Script.getData()), TokenSPos(SPos),
    TokenType(ATT_INVALID),
    ContextToExecIn(nullptr)
{ }

C4AulParse() [2/2]

C4AulParse::C4AulParse	(	C4AulScriptFunc *	Fn,
		C4AulScriptContext *	context,
		C4AulScriptEngine *	Engine
	)

Definition at line 112 of file C4AulParse.cpp.

                                                                                                   :
    Fn(Fn), Host(nullptr), pOrgScript(nullptr), Engine(Engine),
    SPos(Fn->Script), TokenSPos(SPos),
    TokenType(ATT_INVALID),
    ContextToExecIn(context)
{ }

~C4AulParse()

C4AulParse::~C4AulParse

(

)

Definition at line 119 of file C4AulParse.cpp.

{
    ClearToken();
}

Member Function Documentation

Parse_Array()

std::unique_ptr<::aul::ast::ArrayLit > C4AulParse::Parse_Array ( )

protected

Definition at line 1211 of file C4AulParse.cpp.

{
    auto arr = ::aul::ast::ArrayLit::New(TokenSPos);
    // force "["
    Match(ATT_BOPEN2);
    // Create an array
    while (TokenType != ATT_BCLOSE2)
    {
        // got no parameter before a ","? then push nil
        if (TokenType == ATT_COMMA)
        {
            Warn(C4AulWarningId::empty_parameter_in_array, (unsigned)arr->values.size());
            arr->values.emplace_back(::aul::ast::NilLit::New(TokenSPos));
        }
        else
            arr->values.emplace_back(Parse_Expression());
        if (TokenType == ATT_BCLOSE2)
            break;
        Match(ATT_COMMA, "',' or ']'");
        // [] -> size 0, [*,] -> size 2, [*,*,] -> size 3
        if (TokenType == ATT_BCLOSE2)
        {
            Warn(C4AulWarningId::empty_parameter_in_array, (unsigned)arr->values.size());
            arr->values.emplace_back(::aul::ast::NilLit::New(TokenSPos));
        }
    }
    Shift();
    return arr;
}

References ATT_BCLOSE2, ATT_BOPEN2, ATT_COMMA, Parse_Expression(), and Shift().

Referenced by Parse_Expression().

Here is the call graph for this function:

Here is the caller graph for this function:

Parse_Block()

std::unique_ptr<::aul::ast::Block > C4AulParse::Parse_Block ( )

protected

Definition at line 1050 of file C4AulParse.cpp.

{
    auto block = ::aul::ast::Block::New(TokenSPos);
    Match(ATT_BLOPEN);
    while (TokenType != ATT_BLCLOSE)
    {
        block->children.push_back(Parse_Statement());
    }
    Shift();
    return block;
}

References ATT_BLCLOSE, ATT_BLOPEN, Parse_Statement(), and Shift().

Referenced by Parse_Statement().

Here is the call graph for this function:

Here is the caller graph for this function:

Parse_DirectExec()

std::unique_ptr<::aul::ast::FunctionDecl > C4AulParse::Parse_DirectExec	(	const char *	code,
		bool	whole_function
	)

Definition at line 857 of file C4AulParse.cpp.

{
    // get first token
    Shift();
    // Synthesize a wrapping function which we can call
    std::unique_ptr<::aul::ast::FunctionDecl> func;
    if (whole_function)
    {
        func = Parse_ToplevelFunctionDecl();
    }
    else
    {
        auto expr = Parse_Expression();
        func = std::make_unique<::aul::ast::FunctionDecl>("$internal$eval");
        func->body = std::make_unique<::aul::ast::Block>();
        func->body->children.push_back(std::make_unique<::aul::ast::Return>(std::move(expr)));
    }
    Match(ATT_EOF);
    return func;
}

References ATT_EOF, Parse_Expression(), Parse_ToplevelFunctionDecl(), and Shift().

Referenced by C4AulScriptFunc::ParseDirectExecFunc(), and C4AulScriptFunc::ParseDirectExecStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

Parse_DoWhile()

std::unique_ptr<::aul::ast::DoLoop > C4AulParse::Parse_DoWhile ( )

protected

Definition at line 1277 of file C4AulParse.cpp.

{
    auto loop = ::aul::ast::DoLoop::New(TokenSPos);
    Shift();
    loop->body = Parse_Statement();
    // Execute condition
    if (TokenType != ATT_IDTF || !SEqual(Idtf, C4AUL_While))
        UnexpectedToken("'while'");
    Shift();
    Match(ATT_BOPEN);
    loop->cond = Parse_Expression();
    Match(ATT_BCLOSE);
    return loop;
}

References ATT_BCLOSE, ATT_BOPEN, ATT_IDTF, C4AUL_While, Parse_Expression(), Parse_Statement(), SEqual(), and Shift().

Referenced by Parse_Statement().

Here is the call graph for this function:

Here is the caller graph for this function:

Parse_Expression()

std::unique_ptr<::aul::ast::Expr > C4AulParse::Parse_Expression ( int  iParentPrio = -1 )

protected

Definition at line 1380 of file C4AulParse.cpp.

{
    const char *NodeStart = TokenSPos;
    std::unique_ptr<::aul::ast::Expr> expr;
    const C4ScriptOpDef * op;
    C4Value val;
    switch (TokenType)
    {
    case ATT_IDTF:
        // XXX: Resolving literals here means that you can't create a variable
        // with the names "true", "false", "nil" or "this" anymore. I don't
        // consider this too much of a problem, because there is never a reason
        // to do this and it makes my job a lot easier
        if (SEqual(Idtf, C4AUL_True))
        {
            Shift();
            expr = ::aul::ast::BoolLit::New(NodeStart, true);
        }
        else if (SEqual(Idtf, C4AUL_False))
        {
            Shift();
            expr = ::aul::ast::BoolLit::New(NodeStart, false);
        }
        else if (SEqual(Idtf, C4AUL_Nil))
        {
            Shift();
            expr = ::aul::ast::NilLit::New(NodeStart);
        }
        else if (SEqual(Idtf, C4AUL_this))
        {
            Shift();
            if (TokenType == ATT_BOPEN)
            {
                Shift();
                Match(ATT_BCLOSE);
                // TODO: maybe warn about "this" with parentheses?
            }
            expr = ::aul::ast::ThisLit::New(NodeStart);
        }
        // XXX: Other things that people aren't allowed to do anymore: name their variables or functions any of:
        // "if", "else", "for", "while", "do", "return", or "Par".
        // We could allow variables with these names and disambiguate based on the syntax, but no.
        else if (SEqual(Idtf, C4AUL_If) || SEqual(Idtf, C4AUL_Else) || SEqual(Idtf, C4AUL_For) || SEqual(Idtf, C4AUL_While) || SEqual(Idtf, C4AUL_Do) || SEqual(Idtf, C4AUL_Return))
        {
            Error("reserved identifier not allowed in expressions: %s", Idtf);
        }
        else if (SEqual(Idtf, C4AUL_Par))
        {
            Shift();
            // "Par" is special in that it isn't a function and thus doesn't accept an arbitrary number of parameters
            Match(ATT_BOPEN);
            expr = ::aul::ast::ParExpr::New(NodeStart, Parse_Expression());
            Match(ATT_BCLOSE);
        }
        else if (SEqual(Idtf, C4AUL_New))
        {
            // Because people might call a variables or functions "new", we need to look ahead and guess whether it's a proplist constructor.
            PushParsePos();
            Shift();
            if (TokenType == ATT_IDTF)
            {
                // this must be a proplist because two identifiers can't immediately follow each other
                PopParsePos();
                expr = Parse_PropList();
            }
            else
            {
                // Some non-identifier means this is either a variable, a function, or a syntax error. Which one exactly is something we'll figure out later.
                PopParsePos();
            }
        }
        else if (SEqual(Idtf, C4AUL_Func))
        {
            PushParsePos();
            Shift();
            if (TokenType == ATT_BOPEN)
            {
                auto func = ::aul::ast::FunctionExpr::New(NodeStart);
                Parse_Function(func.get());
                expr = std::move(func);
                DiscardParsePos();
            }
            else
            {
                PopParsePos();
            }
        }
        if (!expr)
        {
            // If we end up here, it must be a proper identifier (or a reserved word that's used as an identifier).
            // Time to look ahead and see whether it's a function call.
            std::string identifier = Idtf;
            Shift();
            if (TokenType == ATT_BOPEN)
            {
                // Well, it looks like one, at least
                auto func = ::aul::ast::CallExpr::New(NodeStart);
                func->callee = identifier;
                Parse_CallParams(func.get());
                expr = std::move(func);
            }
            else
            {
                // It's most certainly not a function call.
                expr = ::aul::ast::VarExpr::New(NodeStart, identifier);
            }
        }
        break;
    case ATT_INT: // constant in cInt
        expr = ::aul::ast::IntLit::New(NodeStart, cInt);
        Shift();
        break;
    case ATT_STRING: // reference in cStr
        expr = ::aul::ast::StringLit::New(NodeStart, cStr->GetCStr());
        Shift();
        break;
    case ATT_OPERATOR:
        // -> must be a prefix operator
        op = &C4ScriptOpMap[cInt];
        // postfix?
        if (op->Postfix)
            // oops. that's wrong
            throw C4AulParseError(this, "postfix operator without first expression");
        Shift();
        // generate code for the following expression
        expr = Parse_Expression(op->Priority);
        if (SEqual(op->Identifier, "+"))
        {
            // This is a no-op.
        }
        else
        {
            expr = ::aul::ast::UnOpExpr::New(NodeStart, op - C4ScriptOpMap, std::move(expr));
        }
        break;
    case ATT_BOPEN:
        Shift();
        expr = Parse_Expression();
        Match(ATT_BCLOSE);
        break;
    case ATT_BOPEN2:
        expr = Parse_Array();
        break;
    case ATT_BLOPEN:
        expr = Parse_PropList();
        break;
    default:
        UnexpectedToken("expression");
    }
 
    assert(expr);
 
    while (true)
    {
        NodeStart = TokenSPos;
        switch (TokenType)
        {
        case ATT_SET:
            {
                // back out of any kind of parent operator
                // (except other setters, as those are right-associative)
                if (iParentPrio > 1)
                    return expr;
                Shift();
                expr = ::aul::ast::AssignmentExpr::New(NodeStart, std::move(expr), Parse_Expression(1));
                break;
            }
        case ATT_OPERATOR:
            {
                // expect postfix operator
                const C4ScriptOpDef * op = &C4ScriptOpMap[cInt];
                if (!op->Postfix)
                {
                    // does an operator with the same name exist?
                    // when it's a postfix-operator, it can be used instead.
                    const C4ScriptOpDef * postfixop;
                    for (postfixop = op + 1; postfixop->Identifier; ++postfixop)
                        if (SEqual(op->Identifier, postfixop->Identifier))
                            if (postfixop->Postfix)
                                break;
                    // not found?
                    if (!postfixop->Identifier)
                    {
                        Error("unexpected prefix operator: %s", op->Identifier);
                    }
                    // otherwise use the new-found correct postfix operator
                    op = postfixop;
                }
 
                if (iParentPrio + !op->Changer > op->Priority)
                    return expr;
 
                Shift();
                if (op->NoSecondStatement)
                {
                    // Postfix unary op
                    expr = ::aul::ast::UnOpExpr::New(NodeStart, op - C4ScriptOpMap, std::move(expr));
                }
                else
                {
                    expr = ::aul::ast::BinOpExpr::New(NodeStart, op - C4ScriptOpMap, std::move(expr), Parse_Expression(op->Priority));
                }
                break;
            }
        case ATT_BOPEN2:
            {
                // parse either [index], or [start:end] in which case either index is optional
                Shift();
                ::aul::ast::ExprPtr start;
                if (TokenType == ATT_COLON)
                    start = ::aul::ast::IntLit::New(TokenSPos, 0); // slice with first index missing -> implicit start index zero
                else
                    start = Parse_Expression();
 
                if (TokenType == ATT_BCLOSE2)
                {
                    expr = ::aul::ast::SubscriptExpr::New(NodeStart, std::move(expr), std::move(start));
                }
                else if (TokenType == ATT_COLON)
                {
                    Shift();
                    ::aul::ast::ExprPtr end;
                    if (TokenType == ATT_BCLOSE2)
                    {
                        end = ::aul::ast::IntLit::New(TokenSPos, std::numeric_limits<int32_t>::max());
                    }
                    else
                    {
                        end = Parse_Expression();
                    }
                    expr = ::aul::ast::SliceExpr::New(NodeStart, std::move(expr), std::move(start), std::move(end));
                }
                else
                {
                    UnexpectedToken("']' or ':'");
                }
                Match(ATT_BCLOSE2);
                break;
            }
        case ATT_DOT:
            Shift();
            Check(ATT_IDTF, "property name");
            expr = ::aul::ast::SubscriptExpr::New(NodeStart, std::move(expr), ::aul::ast::StringLit::New(TokenSPos, Idtf));
            Shift();
            break;
        case ATT_CALL: case ATT_CALLFS:
            {
                auto call = ::aul::ast::CallExpr::New(NodeStart);
                call->context = std::move(expr);
                call->safe_call = TokenType == ATT_CALLFS;
                Shift();
                Check(ATT_IDTF, "function name after '->'");
                call->callee = Idtf;
                Shift();
                Parse_CallParams(call.get());
                expr = std::move(call);
                break;
            }
        default:
            return expr;
        }
    }
}

References ATT_BCLOSE, ATT_BCLOSE2, ATT_BLOPEN, ATT_BOPEN, ATT_BOPEN2, ATT_CALL, ATT_CALLFS, ATT_COLON, ATT_DOT, ATT_IDTF, ATT_INT, ATT_OPERATOR, ATT_SET, ATT_STRING, C4AUL_Do, C4AUL_Else, C4AUL_False, C4AUL_For, C4AUL_Func, C4AUL_If, C4AUL_New, C4AUL_Nil, C4AUL_Par, C4AUL_Return, C4AUL_this, C4AUL_True, C4AUL_While, C4AulParseError, C4ScriptOpMap, aul::ast::CallExpr::callee, C4ScriptOpDef::Changer, aul::ast::CallExpr::context, C4String::GetCStr(), C4ScriptOpDef::Identifier, C4ScriptOpDef::NoSecondStatement, Parse_Array(), Parse_PropList(), C4ScriptOpDef::Postfix, C4ScriptOpDef::Priority, aul::ast::CallExpr::safe_call, SEqual(), and Shift().

Referenced by Parse_Array(), Parse_DirectExec(), Parse_DoWhile(), Parse_For(), Parse_ForEach(), Parse_If(), Parse_PropList(), Parse_Statement(), Parse_Var(), and Parse_While().

Here is the call graph for this function:

Here is the caller graph for this function:

Parse_For()

std::unique_ptr<::aul::ast::ForLoop > C4AulParse::Parse_For ( )

protected

Definition at line 1323 of file C4AulParse.cpp.

{
    auto loop = ::aul::ast::ForLoop::New(TokenSPos);
    Match(ATT_IDTF); Match(ATT_BOPEN);
    // Initialization
    if (TokenType == ATT_IDTF && SEqual(Idtf, C4AUL_VarNamed))
    {
        loop->init = Parse_Var();
    }
    else if (TokenType != ATT_SCOLON)
    {
        loop->init = Parse_Expression();
    }
    // Consume first semicolon
    Match(ATT_SCOLON);
    // Condition
    if (TokenType != ATT_SCOLON)
    {
        loop->cond = Parse_Expression();
    }
    // Consume second semicolon
    Match(ATT_SCOLON);
    // Incrementor
    if (TokenType != ATT_BCLOSE)
    {
        loop->incr = Parse_Expression();
    }
    // Consume closing bracket
    Match(ATT_BCLOSE);
    loop->body = Parse_Statement();
    return loop;
}

References ATT_BCLOSE, ATT_BOPEN, ATT_IDTF, ATT_SCOLON, C4AUL_VarNamed, Parse_Expression(), Parse_Statement(), Parse_Var(), and SEqual().

Referenced by Parse_Statement().

Here is the call graph for this function:

Here is the caller graph for this function:

Parse_ForEach()

std::unique_ptr<::aul::ast::RangeLoop > C4AulParse::Parse_ForEach ( )

protected

Definition at line 1356 of file C4AulParse.cpp.

{
    auto loop = ::aul::ast::RangeLoop::New(TokenSPos);
    Match(ATT_IDTF); Match(ATT_BOPEN);
    if (TokenType == ATT_IDTF && SEqual(Idtf, C4AUL_VarNamed))
    {
        loop->scoped_var = true;
        Shift();
    }
    // get variable name
    Check(ATT_IDTF, "variable name");
    loop->var = Idtf;
    Shift();
    if (TokenType != ATT_IDTF || !SEqual(Idtf, C4AUL_In))
        UnexpectedToken("'in'");
    Shift();
    // get expression for array
    loop->cond = Parse_Expression();
    Match(ATT_BCLOSE);
    // loop body
    loop->body = Parse_Statement();
    return loop;
}

References ATT_BCLOSE, ATT_BOPEN, ATT_IDTF, C4AUL_In, C4AUL_VarNamed, Parse_Expression(), Parse_Statement(), SEqual(), and Shift().

Referenced by Parse_Statement().

Here is the call graph for this function:

Here is the caller graph for this function:

Parse_If()

std::unique_ptr<::aul::ast::If > C4AulParse::Parse_If ( )

protected

Definition at line 1305 of file C4AulParse.cpp.

{
    auto stmt = ::aul::ast::If::New(TokenSPos);
    Shift();
    Match(ATT_BOPEN);
    stmt->cond = Parse_Expression();
    Match(ATT_BCLOSE);
    // parse controlled statement
    stmt->iftrue = Parse_Statement();
    if (TokenType == ATT_IDTF && SEqual(Idtf, C4AUL_Else))
    {
        Shift();
        // expect a command now
        stmt->iffalse = Parse_Statement();
    }
    return stmt;
}

References ATT_BCLOSE, ATT_BOPEN, ATT_IDTF, C4AUL_Else, Parse_Expression(), Parse_Statement(), SEqual(), and Shift().

Referenced by Parse_Statement().

Here is the call graph for this function:

Here is the caller graph for this function:

Parse_PropList()

std::unique_ptr<::aul::ast::ProplistLit > C4AulParse::Parse_PropList ( )

protected

Definition at line 1241 of file C4AulParse.cpp.

{
    auto proplist = ::aul::ast::ProplistLit::New(TokenSPos);
    if (TokenType == ATT_IDTF && SEqual(Idtf, C4AUL_New))
    {
        Shift();
        proplist->values.emplace_back(Strings.P[P_Prototype].GetCStr(), Parse_Expression());
    }
    Match(ATT_BLOPEN);
    while (TokenType != ATT_BLCLOSE)
    {
        std::string key;
        if (TokenType == ATT_IDTF)
        {
            key = Idtf;
            Shift();
        }
        else if (TokenType == ATT_STRING)
        {
            key = cStr->GetCStr();
            Shift();
        }
        else UnexpectedToken("string or identifier");
        if (TokenType != ATT_COLON && TokenType != ATT_SET)
            UnexpectedToken("':' or '='");
        Shift();
        proplist->values.emplace_back(key, Parse_Expression());
        if (TokenType == ATT_COMMA)
            Shift();
        else if (TokenType != ATT_BLCLOSE)
            UnexpectedToken("'}' or ','");
    }
    Shift();
    return proplist;
}

References ATT_BLCLOSE, ATT_BLOPEN, ATT_COLON, ATT_COMMA, ATT_IDTF, ATT_SET, ATT_STRING, C4AUL_New, C4String::GetCStr(), C4StringTable::P, P_Prototype, Parse_Expression(), SEqual(), Shift(), and Strings.

Referenced by Parse_Expression().

Here is the call graph for this function:

Here is the caller graph for this function:

Parse_Script()

std::unique_ptr<::aul::ast::Script > C4AulParse::Parse_Script

(

C4ScriptHost *

scripthost

)

Definition at line 878 of file C4AulParse.cpp.

{
    pOrgScript = scripthost;
    SPos = pOrgScript->Script.getData();
    const char * SPos0 = SPos;
    bool first_error = true;
    auto script = ::aul::ast::Script::New(SPos0);
    while (true) try
    {
        // Go to the next token if the current token could not be processed or no token has yet been parsed
        if (SPos == SPos0)
        {
            Shift();
        }
        SPos0 = SPos;
        switch (TokenType)
        {
        case ATT_DIR:
            // check for include statement
            if (SEqual(Idtf, C4AUL_Include))
            {
                Shift();
                // get id of script to include
                Check(ATT_IDTF, "script name");
                script->declarations.push_back(::aul::ast::IncludePragma::New(TokenSPos, Idtf));
                Shift();
            }
            else if (SEqual(Idtf, C4AUL_Append))
            {
                if (pOrgScript->GetPropList()->GetDef())
                    throw C4AulParseError(this, "#appendto in a Definition");
                Shift();
                // get id of script to include/append
                switch (TokenType)
                {
                case ATT_IDTF:
                    script->declarations.push_back(::aul::ast::AppendtoPragma::New(TokenSPos, Idtf));
                    break;
                case ATT_OPERATOR:
                    if (SEqual(C4ScriptOpMap[cInt].Identifier, "*"))
                    {
                        script->declarations.push_back(::aul::ast::AppendtoPragma::New(TokenSPos));
                        break;
                    }
                    //fallthrough
                default:
                    // -> ID expected
                    UnexpectedToken("identifier or '*'");
                }
                Shift();
            }
            else
                // -> unknown directive
                Error("unknown directive: %s", Idtf);
            break;
        case ATT_IDTF:
            // need a keyword here to avoid parsing random function contents
            // after a syntax error in a function
            // check for object-local variable definition (local)
            if (SEqual(Idtf, C4AUL_LocalNamed) || SEqual(Idtf, C4AUL_GlobalNamed))
            {
                script->declarations.push_back(Parse_Var());
                Match(ATT_SCOLON);
            }
            // check for variable definition (static)
            else
                script->declarations.push_back(Parse_ToplevelFunctionDecl());
            break;
        case ATT_EOF:
            return script;
        default:
            UnexpectedToken("declaration");
        }
        first_error = true;
    }
    catch (C4AulError &err)
    {
        if (first_error)
        {
            ++Engine->errCnt;
            ::ScriptEngine.ErrorHandler->OnError(err.what());
        }
        first_error = false;
    }
}

References ATT_DIR, ATT_EOF, ATT_IDTF, ATT_OPERATOR, ATT_SCOLON, C4AUL_Append, C4AUL_GlobalNamed, C4AUL_Include, C4AUL_LocalNamed, C4AulParseError, C4ScriptOpMap, C4AulScriptEngine::errCnt, C4AulScriptEngine::ErrorHandler, StdStrBuf::getData(), C4PropList::GetDef(), C4ScriptHost::GetPropList(), C4AulErrorHandler::OnError(), Parse_ToplevelFunctionDecl(), Parse_Var(), C4ScriptHost::Script, ScriptEngine, SEqual(), Shift(), and C4AulError::what().

Referenced by C4ScriptHost::Preparse().

Here is the call graph for this function:

Here is the caller graph for this function:

Parse_Statement()

std::unique_ptr<::aul::ast::Stmt > C4AulParse::Parse_Statement ( )

protected

Definition at line 1062 of file C4AulParse.cpp.

{
    const char *NodeStart = TokenSPos;
    std::unique_ptr<::aul::ast::Stmt> stmt;
    switch (TokenType)
    {
        // do we have a block start?
    case ATT_BLOPEN:
        return Parse_Block();
    case ATT_BOPEN:
    case ATT_BOPEN2:
    case ATT_SET:
    case ATT_OPERATOR:
    case ATT_INT:
    case ATT_STRING:
    {
        stmt = Parse_Expression();
        Match(ATT_SCOLON);
        return stmt;
    }
    // additional function separator
    case ATT_SCOLON:
        Shift();
        return ::aul::ast::Noop::New(NodeStart);
    case ATT_IDTF:
        // check for variable definition
        if (SEqual(Idtf, C4AUL_VarNamed) || SEqual(Idtf, C4AUL_LocalNamed) || SEqual(Idtf, C4AUL_GlobalNamed))
            stmt = Parse_Var();
        // check new-form func begin
        else if (SEqual(Idtf, C4AUL_Func) ||
                 SEqual(Idtf, C4AUL_Private) ||
                 SEqual(Idtf, C4AUL_Protected) ||
                 SEqual(Idtf, C4AUL_Public) ||
                 SEqual(Idtf, C4AUL_Global))
        {
            throw C4AulParseError(this, "unexpected end of function");
        }
        // get function by identifier: first check special functions
        else if (SEqual(Idtf, C4AUL_If)) // if
        {
            return Parse_If();
        }
        else if (SEqual(Idtf, C4AUL_Else)) // else
        {
            throw C4AulParseError(this, "misplaced 'else'");
        }
        else if (SEqual(Idtf, C4AUL_Do)) // while
        {
            stmt = Parse_DoWhile();
        }
        else if (SEqual(Idtf, C4AUL_While)) // while
        {
            return Parse_While();
        }
        else if (SEqual(Idtf, C4AUL_For)) // for
        {
            PushParsePos();
            Shift();
            // Look if it's the for([var] foo in array)-form
            // must be followed by a bracket
            Match(ATT_BOPEN);
            // optional var
            if (TokenType == ATT_IDTF && SEqual(Idtf, C4AUL_VarNamed))
                Shift();
            // variable and "in"
            if (TokenType == ATT_IDTF
                && GetNextToken() == ATT_IDTF
                && SEqual(Idtf, C4AUL_In))
            {
                // reparse the stuff in the brackets like normal statements
                PopParsePos();
                return Parse_ForEach();
            }
            else
            {
                // reparse the stuff in the brackets like normal statements
                PopParsePos();
                return Parse_For();
            }
        }
        else if (SEqual(Idtf, C4AUL_Return)) // return
        {
            Shift();
            if (TokenType == ATT_SCOLON)
            {
                // allow return; without return value (implies nil)
                stmt = ::aul::ast::Return::New(NodeStart, ::aul::ast::NilLit::New(NodeStart));
            }
            else
            {
                // return retval;
                stmt = ::aul::ast::Return::New(NodeStart, Parse_Expression());
            }
        }
        else if (SEqual(Idtf, C4AUL_Break)) // break
        {
            Shift();
            stmt = ::aul::ast::Break::New(NodeStart);
        }
        else if (SEqual(Idtf, C4AUL_Continue)) // continue
        {
            Shift();
            stmt = ::aul::ast::Continue::New(NodeStart);
        }
        else
        {
            stmt = Parse_Expression();
        }
        Match(ATT_SCOLON);
        assert(stmt);
        return stmt;
    default:
        UnexpectedToken("statement");
    }
}

References ATT_BLOPEN, ATT_BOPEN, ATT_BOPEN2, ATT_IDTF, ATT_INT, ATT_OPERATOR, ATT_SCOLON, ATT_SET, ATT_STRING, C4AUL_Break, C4AUL_Continue, C4AUL_Do, C4AUL_Else, C4AUL_For, C4AUL_Func, C4AUL_Global, C4AUL_GlobalNamed, C4AUL_If, C4AUL_In, C4AUL_LocalNamed, C4AUL_Private, C4AUL_Protected, C4AUL_Public, C4AUL_Return, C4AUL_VarNamed, C4AUL_While, C4AulParseError, Parse_Block(), Parse_DoWhile(), Parse_Expression(), Parse_For(), Parse_ForEach(), Parse_If(), Parse_Var(), Parse_While(), SEqual(), and Shift().

Referenced by Parse_Block(), Parse_DoWhile(), Parse_For(), Parse_ForEach(), Parse_If(), and Parse_While().

Here is the call graph for this function:

Here is the caller graph for this function:

Parse_ToplevelFunctionDecl()

std::unique_ptr<::aul::ast::FunctionDecl > C4AulParse::Parse_ToplevelFunctionDecl ( )

protected

Definition at line 964 of file C4AulParse.cpp.

{
    const char *NodeStart = TokenSPos;
    bool is_global = SEqual(Idtf, C4AUL_Global);
    // skip access modifier
    if (SEqual(Idtf, C4AUL_Private) ||
        SEqual(Idtf, C4AUL_Protected) ||
        SEqual(Idtf, C4AUL_Public) ||
        SEqual(Idtf, C4AUL_Global))
    {
        Shift();
    }
 
    // check for func declaration
    if (!SEqual(Idtf, C4AUL_Func))
        Error("Declaration expected, but found identifier: %s", Idtf);
    Shift();
    // get next token, must be func name
    Check(ATT_IDTF, "function name");
 
    auto func = ::aul::ast::FunctionDecl::New(NodeStart, Idtf);
    func->is_global = is_global;
    Shift();
    Parse_Function(func.get());
    return func;
}

References ATT_IDTF, C4AUL_Func, C4AUL_Global, C4AUL_Private, C4AUL_Protected, C4AUL_Public, SEqual(), and Shift().

Referenced by Parse_DirectExec(), and Parse_Script().

Here is the call graph for this function:

Here is the caller graph for this function:

Parse_Var()

std::unique_ptr<::aul::ast::VarDecl > C4AulParse::Parse_Var ( )

protected

Definition at line 1644 of file C4AulParse.cpp.

{
    auto decl = ::aul::ast::VarDecl::New(TokenSPos);
    if (SEqual(Idtf, C4AUL_VarNamed))
    {
        decl->scope = ::aul::ast::VarDecl::Scope::Func;
    }
    else if (SEqual(Idtf, C4AUL_LocalNamed))
    {
        decl->scope = ::aul::ast::VarDecl::Scope::Object;
    }
    else if (SEqual(Idtf, C4AUL_GlobalNamed))
    {
        decl->scope = ::aul::ast::VarDecl::Scope::Global;
    }
    else
    {
        assert(0 && "C4AulParse::Parse_Var called with invalid parse state (current token should be scope of variable)");
        // Uh this shouldn't happen, ever
        Error("internal error: C4AulParse::Parse_Var called with invalid parse state (current token should be scope of variable, but is '%s')", Idtf);
    }
    Shift();
    if (TokenType == ATT_IDTF && SEqual(Idtf, C4AUL_Const))
    {
        decl->constant = true;
        Shift();
    }
    while (true)
    {
        // get desired variable name
        Check(ATT_IDTF, "variable name");
        std::string identifier = Idtf;
        Shift();
        ::aul::ast::ExprPtr init;
        if (TokenType == ATT_SET)
        {
            Shift();
            init = Parse_Expression();
        }
        decl->decls.push_back({ identifier, std::move(init) });
        if (TokenType == ATT_SCOLON)
            return decl;
        Match(ATT_COMMA, "',' or ';'");
    }
}

References ATT_COMMA, ATT_IDTF, ATT_SCOLON, ATT_SET, C4AUL_Const, C4AUL_GlobalNamed, C4AUL_LocalNamed, C4AUL_VarNamed, aul::ast::VarDecl::Func, aul::ast::VarDecl::Global, aul::ast::VarDecl::Object, Parse_Expression(), SEqual(), and Shift().

Referenced by Parse_For(), Parse_Script(), and Parse_Statement().

Here is the call graph for this function:

Here is the caller graph for this function:

Parse_While()

std::unique_ptr<::aul::ast::WhileLoop > C4AulParse::Parse_While ( )

protected

Definition at line 1292 of file C4AulParse.cpp.

{
    auto loop = ::aul::ast::WhileLoop::New(TokenSPos);
    Shift();
    // Execute condition
    Match(ATT_BOPEN);
    loop->cond = Parse_Expression();
    Match(ATT_BCLOSE);
    // Execute body
    loop->body = Parse_Statement();
    return loop;
}

References ATT_BCLOSE, ATT_BOPEN, Parse_Expression(), Parse_Statement(), and Shift().

Referenced by Parse_Statement().

Here is the call graph for this function:

Here is the caller graph for this function:

Shift()

void C4AulParse::Shift ( )

protected

Definition at line 760 of file C4AulParse.cpp.

{
    TokenType = GetNextToken();
}

Referenced by Parse_Array(), Parse_Block(), Parse_DirectExec(), Parse_DoWhile(), Parse_Expression(), Parse_ForEach(), Parse_If(), Parse_PropList(), Parse_Script(), Parse_Statement(), Parse_ToplevelFunctionDecl(), Parse_Var(), and Parse_While().

Here is the caller graph for this function:

Friends And Related Function Documentation

C4AulParseError

friend class C4AulParseError

friend

Definition at line 102 of file C4AulParse.h.

Referenced by Parse_Expression(), Parse_Script(), and Parse_Statement().

---

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

• C4AulParse.h
• C4AulParse.cpp