/** * Structures and functions for parsing tokens to a parse tree. The parser * reads through a list of tokens (generated by the tokenizer) and adds semantic * meaning to them by forming them into a parse tree which can then be passed on * to later stages (such as the interpreter). * * \file parser.h * * \author Justin J. Meza * * \date 2010-2012 */ /** * \page impvar The Implicit Variable * * The implicit variable in LOLCODE is denoted by the keyword \c IT and stores a * copy of the result of the most recently evaluated expression statement (an * expression all by itself on a line). (See * http://lolcode.com/specs/1.2#conditionals for an example.) */ /** * \page lolebnf The LOLCODE EBNF * * Presented below is the EBNF (see * http://en.wikipedia.org/wiki/Extended_Backus%E2%80%93Naur_Form) for the * LOLCODE language that \c lci parses. Note that by this stage, the scanner * has: * - already removed any whitespace between tokens, * - added in and truncated newline tokens at logical line breaks, and * - added an end-of-file (\c $) token. * * \section progebnf Program Structure * * These production rules dictate the overall form of the program. * * \par * MainNode ::= \c TT_HAI \a version \c TT_NEWLINE BlockNode \c $ * * \par * BlockNode ::= StmtNode * * * \section typesebnf Types * * These production rules specify some general types of parse structures. * * \par * ConstantNode ::= Boolean | Integer | Float | String * * \par * IdentifierNode ::= Identifier | \c TT_SRS ExprNode * * \par * TypeNode ::= \c TT_NOOB | \c TT_TROOF | \c TT_NUMBR | \c TT_NUMBAR | \c * TT_YARN * * \section stmtebnf Statements * * These production rules specify the types of statements formed. * * \par * StmtNode ::= CastStmtNode | PrintStmtNode | InputStmtNode | * AssignmentStmtNode | DeclarationStmtNode | IfThenElseStmtNode | * SwitchStmtNode | BreakStmt | ReturnStmtNode | LoopStmtNode | * DeallocationStmtNode | FuncDefStmtNode | ExprStmt | AltArrayDefStmtNode * * \par * CastStmtNode ::= IdentifierNode \c TT_ISNOWA TypeNode \c TT_NEWLINE * * \par * PrintStmtNode ::= \c TT_VISIBLE ExprNodeList \c TT_BANG ? \c TT_NEWLINE * * \par * InputStmtNode ::= \c TT_GIMMEH IdentifierNode \c TT_NEWLINE * * \par * AssignmentStmtNode ::= IdentifierNode \c TT_R ExprNode \c TT_NEWLINE * * \par * DeclarationStmtNode ::= IdentifierNode \c TT_HASA IdentifierNode * Initialization ? \c TT_NEWLINE * * \par * Initialization ::= \c TT_ITZ ExprNode | \c TT_ITZA TypeNode | \c TT_ITZLIEKA IdentifierNode * * \par * IfThenElseStmtNode ::= \c TT_ORLY \c TT_NEWLINE \c TT_YARLY \c TT_NEWLINE * BlockNode ElseIf * Else ? \c TT_OIC \c TT_NEWLINE * * \par * ElseIf ::= \c TT_MEBBE ExprNode \c TT_NEWLINE BlockNode * * \par * Else ::= \c TT_NOWAI \c TT_NEWLINE BlockNode * * \par * SwitchStmtNode ::= \c TT_WTF \c TT_NEWLINE Case + DefaultCase ? \c TT_OIC \c * TT_NEWLINE * * \par * Case ::= \c TT_OMG ExprNode \c TT_NEWLINE BlockNode * * \par * DefaultCase ::= \c TT_OMGWTF \c TT_NEWLINE BlockNode * * \par * BreakStmt ::= \c TT_GTFO \c TT_NEWLINE * * \par * ReturnStmtNode ::= \c TT_FOUNDYR ExprNode \c TT_NEWLINE * * \par * LoopStmtNode ::= \c TT_IMINYR IdentifierNode LoopUpdate ? LoopGuard ? \c * TT_NEWLINE BlockNode \c TT_IMOUTTAYR IdentifierNode \c TT_NEWLINE * * \par * LoopUpdate ::= LoopUpdateOp \c TT_YR IdentifierNode * * \par * LoopUpdateOp ::= \c TT_UPPIN | \c TT_NERFIN | UnaryFunction * * \par * UnaryFunction ::= The name of a previously defined unary function. * * \par * LoopGuard ::= \c TT_TIL ExprNode | \c TT_WILE ExprNode * * \par * DeallocationStmtNode ::= IdentifierNode \c TT_RNOOB * * \par * FuncDefStmtNode ::= \c TT_HOWIZ IdentifierNode IdentifierNode FunctionArgs ? * \c TT_NEWLINE BlockNode \c TT_IFUSAYSO \c TT_NEWLINE * * \par * FunctionArgs ::= \c TT_YR IdentifierNode FunctionArg * * * \par * FunctionArg ::= \c TT_ANYR IdentifierNode * * \par * ExprStmt ::= ExprNode \c TT_NEWLINE * * \par * AltArrayDefStmtNode ::= \c TT_OHAIIM IdentifierNode AltArrayInheritance ? \c * TT_NEWLINE BlockNode \c TT_KTHX \c TT_NEWLINE * * \par * AltArrayInheritance ::= \c TT_IMLIEK IdentifierNode * * \section exprebnf Expressions * * These production rules specify the types of expressions formed. * * \par * ExprNode ::= CastExprNode | ConstantNode | IdentifierNode | FuncCallExprNode * | OpExprNode | ImplicitVariable | SystemCommandExprNode * * \par * CastExprNode ::= \c TT_MAEK ExprNode \c TT_A TypeNode * * \par * FuncCallExprNode ::= IdentifierNode \c TT_IZ IdentifierNode FunctionArgs ? * TT_MKAY * * \par * SystemCommandExprNode ::= \c TT_DUZ \c IdentifierNode * * \par * OpExprNode ::= UnaryOp | BinaryOp | NaryOp * * \par * UnaryOp ::= UnaryOpType ExprNode * * \par * UnaryOpType ::= \c TT_NOT * * \par * BinaryOp ::= BinaryOpType ExprNode \c TT_AN ? ExprNode * * \par * BinaryOpType ::= \c TT_SUMOF | \c TT_DIFFOF | \c TT_PRODUKTOF | \c * TT_QUOSHUNTOF | \c TT_MODOF | \c BIGGROF | \c SMALLROF | \c TT_BOTHOF | \c * TT_EITHEROF | \c TT_WONOF * * \par * NaryOp ::= NaryOpType NaryOpArgs \c TT_MKAY * * \par * NaryOpType ::= \c TT_ALLOF | \c TT_ANYOF | \c TT_SMOOSH * * \par * NaryOpArgs ::= ExprNode NaryOpArg + * * \par * NaryOpArg ::= \c TT_AN ? ExprNode * * \par * ImplicitVariable ::= \c TT_IT */ #ifndef __PARSER_H__ #define __PARSER_H__ #include #include #include #include #include #include "tokenizer.h" #undef DEBUG /** * Represents a statement type. */ typedef enum { ST_CAST, /**< Cast statement. */ ST_PRINT, /**< Print statement. */ ST_INPUT, /**< Input statement. */ ST_ASSIGNMENT, /**< Assignment statement. */ ST_DECLARATION, /**< Declaration statement. */ ST_IFTHENELSE, /**< If/then/else statement. */ ST_SWITCH, /**< Switch statement. */ ST_BREAK, /**< Break statement. */ ST_RETURN, /**< Return statement. */ ST_LOOP, /**< Loop statement. */ ST_DEALLOCATION, /**< Deallocation statement. */ ST_FUNCDEF, /**< Function definition statement. */ ST_EXPR, /**< Expression statement. */ ST_ALTARRAYDEF, /**< Function definition statement. */ ST_BINDING, /**< Binding to external library. */ ST_IMPORT, /**< Library import statement. */ } StmtType; /** * Stores statement data. */ typedef struct { StmtType type; /**< The type of statement in \a node. */ void *stmt; /**< The statement. */ } StmtNode; /** * Stores a list of statements. */ typedef struct { unsigned int num; /**< The number of statements. */ StmtNode **stmts; /**< The array of statements. */ } StmtNodeList; /** * Represents an expression type. */ typedef enum { ET_CAST, /**< Cast expression. */ ET_CONSTANT, /**< Constant expression. */ ET_IDENTIFIER, /**< Identifier expression. */ ET_FUNCCALL, /**< Function call expression. */ ET_OP, /**< Operation expression. */ ET_IMPVAR, /**< \ref impvar "Implicit variable". */ ET_SYSTEMCOMMAND, /**< System command expression. */ } ExprType; /** * Stores an expression. */ typedef struct { ExprType type; /**< The type of expression in \a expr. */ void *expr; /**< The expression. */ } ExprNode; /** * Stores a list of expressions. */ typedef struct { unsigned int num; /**< The number of expressions. */ ExprNode **exprs; /**< The array of statements. */ } ExprNodeList; /** * Represents an identifier type. */ typedef enum { IT_DIRECT, /**< Direct identifier. */ IT_INDIRECT /**< Indirect identifier. */ } IdentifierType; /** * Stores an identifier. */ typedef struct identifiernode { IdentifierType type; /**< The type of identifier in \a id. */ void *id; /**< The identifier. */ char *fname; /**< The original file name. */ unsigned int line; /**< The original line number. */ struct identifiernode *slot; /**< The slot to access. */ } IdentifierNode; /** * Stores a list of identifiers. */ typedef struct { unsigned int num; /**< The number of identifiers. */ IdentifierNode **ids; /**< The array of identifiers. */ } IdentifierNodeList; /** * Stores a code block. */ typedef struct { StmtNodeList *stmts; /**< The list of statements in the block. */ } BlockNode; /** * Stores a list of code blocks. */ typedef struct { unsigned int num; /**< The number of code blocks. */ BlockNode **blocks; /**< The array of code blocks. */ } BlockNodeList; /** * Represents a constant type. */ typedef enum { CT_INTEGER, /**< Integer constant. */ CT_FLOAT, /**< Decimal constant. */ CT_BOOLEAN, /**< Boolean constant. */ CT_STRING, /**< String constant. */ CT_NIL, /**< Nil constant. */ CT_ARRAY /**< Array constant. */ } ConstantType; /** * Stores constant data. */ typedef union { long long i; /**< Integer data. */ float f; /**< Decimal data. */ char *s; /**< String data. */ } ConstantData; /** * Stores a constant. */ typedef struct { ConstantType type; /**< The type of constant in \a data. */ ConstantData data; /**< The constant. */ } ConstantNode; /** * Stores a function definition statement. */ typedef struct { IdentifierNode *scope; /**< The scope of the function. */ IdentifierNode *name; /**< The name of the function. */ IdentifierNodeList *args; /**< The names of the function arguments. */ BlockNode *body; /**< The body of the function. */ } FuncDefStmtNode; /** * Stores an alternate array definition statement. */ typedef struct { IdentifierNode *name; /**< The name of the array. */ BlockNode *body; /**< The body of the array definition. */ IdentifierNode *parent; /**< An optional inherited array. */ } AltArrayDefStmtNode; /** * Stores a library import statement. */ typedef struct { IdentifierNode *name; /**< The name of the library to import. */ } ImportStmtNode; /** * Stores a binding to a native function. */ struct returnobject; struct scopeobject; typedef struct { struct returnobject *(*binding)(struct scopeobject *); /**< The function that implements the binding. */ } BindingStmtNode; /** * Stores the main code block of a program. * * \note This could be represented with just a BlockNode, but it seems * significant enough to merit its own structure. */ typedef struct { BlockNode *block; /**< The first block of code to execute. */ } MainNode; /** * Stores a variable type. */ typedef struct { ConstantType type; /**< The type variable. */ } TypeNode; /** * Stores a cast statement. This statement changes the type of a variable. */ typedef struct { IdentifierNode *target; /**< The name of the variable to cast. */ TypeNode *newtype; /**< The type to cast \a target to. */ } CastStmtNode; /** * Stores a print statement. This statement prints a list of expressions with * an optional newline. */ typedef struct { ExprNodeList *args; /**< The expressions to print. */ int nonl; /**< Whether to print an ending newline. */ } PrintStmtNode; /** * Stores an input statement. This statement accepts input from the user and * stores it in a variable. */ typedef struct { IdentifierNode *target; /**< The variable to store the input in. */ } InputStmtNode; /** * Stores an assignment statement. This statement stores an evaluated * expression in a variable. */ typedef struct { IdentifierNode *target; /**< The variable to store \a expr in. */ ExprNode *expr; /**< The expression to store. */ } AssignmentStmtNode; /** * Stores a declaration statement. This statement creates a new variable in a * given scope and optionally initializes it to an expression. * * \note Either provide \a expr OR \a type. If both are provided, the result is * undefined. */ typedef struct { IdentifierNode *scope; /**< The scope to create the variable in. */ IdentifierNode *target; /**< The name of the variable to create. */ ExprNode *expr; /**< An optional initialization expression. */ TypeNode *type; /**< An optional initialization type. */ IdentifierNode *parent; /**< An optional inherited array. */ } DeclarationStmtNode; /** * Stores an if/then/else statement. This statement checks the value of the * \ref impvar "implicit variable" and executes the \c yes block if it can be * cast to true. Else, the \c guards are evaluated and the corresponding code * in one of the \c blocks is executed. Finally, if none of these things occur, * the \c no block is executed. */ typedef struct { BlockNode *yes; /**< The code to execute if \c IT is true. */ BlockNode *no; /**< The code to execute if nothing else does. */ ExprNodeList *guards; /**< The guards for the \c blocks. */ BlockNodeList *blocks; /**< The code to execute if a guard is true. */ } IfThenElseStmtNode; /** * Stores a switch statement. This statement compares the value of the \ref * impvar "implicit variable" to each of the \a guards and executes the * respective block of code in \a blocks if they match. If no matches are * found, the optional default block of code, \a def, is executed. */ typedef struct { ExprNodeList *guards; /**< The expressions to evaluate. */ BlockNodeList *blocks; /**< The blocks of code to execute. */ BlockNode *def; /**< An optional default block of code. */ } SwitchStmtNode; /** * Stores a return statement. This statement signals that control should be * returned to the caller with a status value. */ typedef struct { ExprNode *value; /**< The value to return. */ } ReturnStmtNode; /** * Stores a loop statement. This statement repeatedly executes its \a body * while \a guard evaluates to true, executing \a update at the end of each * cycle. */ typedef struct { IdentifierNode *name; /**< The name of the loop. */ IdentifierNode *var; /**< The variable to be updated. */ ExprNode *guard; /**< The expression to determine continuation. */ ExprNode *update; /**< The expression to update \a var with. */ BlockNode *body; /**< The code to execute at each iteration. */ } LoopStmtNode; /** * Stores a deallocation statement. This statement releases the resources used * by a variable. */ typedef struct { IdentifierNode *target; /**< The variable to deallocate. */ } DeallocationStmtNode; /** * Stores a cast expression. This expression evaluates an expression and casts * its value to a particular type. */ typedef struct { ExprNode *target; /**< The expression to cast. */ TypeNode *newtype; /**< The type to cast \a target to. */ } CastExprNode; /** * Stores a function call expression. This expression calls a named function * and evaluates to the return value of that function. */ typedef struct { IdentifierNode *scope; /**< The scope to call the function in. */ IdentifierNode *name; /**< The name of the function to call. */ ExprNodeList *args; /**< The arguments to supply the function. */ } FuncCallExprNode; /** * Stores a system command expression. This expression evaluates an identifier * which contains a system command, and evaluates to the standard output of the * executed system command. */ typedef struct { ExprNode *cmd; /**< The expression containing the command to execute */ } SystemCommandExprNode; /** * Represents the type of operation an OpExprNode performs. */ typedef enum { OP_ADD, /**< Addition. */ OP_SUB, /**< Subtraction. */ OP_MULT, /**< Multiplication. */ OP_DIV, /**< Division. */ OP_MOD, /**< Modulo. */ OP_MAX, /**< Maximum. */ OP_MIN, /**< Minimum. */ OP_AND, /**< Logical AND. */ OP_OR, /**< Logical OR. */ OP_XOR, /**< Logical XOR. */ OP_NOT, /**< Logical NOT. */ OP_EQ, /**< Equality. */ OP_NEQ, /**< Inequality. */ OP_CAT /**< String concatenation. */ } OpType; /** * Stores an operation expression. This expression applies an operator to its * arguments. */ typedef struct { OpType type; /**< The type of operation to perform. */ ExprNodeList *args; /**< The arguments to perform the operation on. */ } OpExprNode; /** * \name MainNode modifiers * * Functions for creating and deleting MainNodes. */ /**@{*/ MainNode *createMainNode(BlockNode *); void deleteMainNode(MainNode *); /**@}*/ /** * \name BlockNode modifiers * * Functions for creating and deleting single or multiple BlockNodes. */ /**@{*/ BlockNode *createBlockNode(StmtNodeList *); void deleteBlockNode(BlockNode *); BlockNodeList *createBlockNodeList(void); int addBlockNode(BlockNodeList *, BlockNode *); void deleteBlockNodeList(BlockNodeList *); /**@}*/ /** * \name IdentifierNode modifiers * * Functions for creating and deleting single or multiple IdentifierNodes. */ /**@{*/ IdentifierNode *createIdentifierNode(IdentifierType, void *, IdentifierNode *, const char *, unsigned int); void deleteIdentifierNode(IdentifierNode *); IdentifierNodeList *createIdentifierNodeList(void); int addIdentifierNode(IdentifierNodeList *, IdentifierNode *); void deleteIdentifierNodeList(IdentifierNodeList *); /**@}*/ /** * \name TypeNode modifiers * * Functions for creating and deleting TypeNodes. */ /**@{*/ TypeNode *createTypeNode(ConstantType); void deleteTypeNode(TypeNode *); /**@}*/ /** * \name StmtNode modifiers * * Functions for creating and deleting single or multiple of StmtNodes. */ /**@{*/ StmtNode *createStmtNode(StmtType, void *); void deleteStmtNode(StmtNode *); StmtNodeList *createStmtNodeList(void); int addStmtNode(StmtNodeList *, StmtNode *); void deleteStmtNodeList(StmtNodeList *); /**@}*/ /** * \name CastStmtNode modifiers * * Functions for creating and deleting CastStmtNodes. */ /**@{*/ CastStmtNode *createCastStmtNode(IdentifierNode *, TypeNode *); void deleteCastStmtNode(CastStmtNode *); /**@}*/ /** * \name PrintStmtNode modifiers * * Functions for creating and deleting PrintStmtNodes. */ /**@{*/ PrintStmtNode *createPrintStmtNode(ExprNodeList *, int); void deletePrintStmtNode(PrintStmtNode *); /**@}*/ /** * \name InputStmtNode modifiers * * Functions for creating and deleting InputStmtNodes. */ /**@{*/ InputStmtNode *createInputStmtNode(IdentifierNode *); void deleteInputStmtNode(InputStmtNode *); /**@}*/ /** * \name AssignmentStmtNode modifiers * * Functions for creating and deleting AssignmentStmtNodes. */ /**@{*/ AssignmentStmtNode *createAssignmentStmtNode(IdentifierNode *, ExprNode *); void deleteAssignmentStmtNode(AssignmentStmtNode *); /**@}*/ /** * \name DeclarationStmtNode modifiers * * Functions for creating and deleting DeclarationStmtNodes. */ /**@{*/ DeclarationStmtNode *createDeclarationStmtNode(IdentifierNode *, IdentifierNode *, ExprNode *, TypeNode *, IdentifierNode *); void deleteDeclarationStmtNode(DeclarationStmtNode *); /**@}*/ /** * \name IfThenElseStmtNode modifiers * * Functions for creating and deleting IfThenElseStmtNodes. */ /**@{*/ IfThenElseStmtNode *createIfThenElseStmtNode(BlockNode *, BlockNode *, ExprNodeList *, BlockNodeList *); void deleteIfThenElseStmtNode(IfThenElseStmtNode *); /**@}*/ /** * \name SwitchStmtNode modifiers * * Functions for creating and deleting SwitchStmtNodes. */ /**@{*/ SwitchStmtNode *createSwitchStmtNode(ExprNodeList *, BlockNodeList *, BlockNode *); void deleteSwitchStmtNode(SwitchStmtNode *); /**@}*/ /** * \name ReturnStmtNode modifiers * * Functions for creating and deleting ReturnStmtNodes. */ /**@{*/ ReturnStmtNode *createReturnStmtNode(ExprNode *); void deleteReturnStmtNode(ReturnStmtNode *); /**@}*/ /** * \name LoopStmtNode modifiers * * Functions for creating and deleting LoopStmtNodes. */ /**@{*/ LoopStmtNode *createLoopStmtNode(IdentifierNode *, IdentifierNode *, ExprNode *, ExprNode *, BlockNode *); void deleteLoopStmtNode(LoopStmtNode *); /**@}*/ /** * \name DeallocationStmtNode modifiers * * Functions for creating and deleting DeallocationStmtNodes. */ /**@{*/ DeallocationStmtNode *createDeallocationStmtNode(IdentifierNode *); void deleteDeallocationStmtNode(DeallocationStmtNode *); /**@}*/ /** * \name FuncDefStmtNode modifiers * * Functions for creating and deleting FuncDefStmtNodes. */ /**@{*/ FuncDefStmtNode *createFuncDefStmtNode(IdentifierNode *, IdentifierNode *, IdentifierNodeList *, BlockNode *); void deleteFuncDefStmtNode(FuncDefStmtNode *); /**@}*/ /** * \name AltArrayDefStmtNode modifiers * * Functions for creating and deleting AltArrayDefStmtNodes. */ /**@{*/ AltArrayDefStmtNode *createAltArrayDefStmtNode(IdentifierNode *, BlockNode *, IdentifierNode *); void deleteAltArrayDefStmtNode(AltArrayDefStmtNode *); /**@}*/ /** * \name ImportStmtNode modifiers * * Functions for creating and deleting ImportStmtNodes. */ /**@{*/ ImportStmtNode *createImportStmtNode(IdentifierNode *); void deleteImportStmtNode(ImportStmtNode *); /**@}*/ /** * \name BindingStmtNode modifiers * * Functions for creating and deleting BindingStmtNodes. */ /**@{*/ struct returnobject; struct scopeobject; BindingStmtNode *createBindingStmtNode(struct returnobject *(*)(struct scopeobject *)); void deleteBindingStmtNode(BindingStmtNode *); /**@}*/ /** * \name ExprNode modifiers * * Functions for creating and deleting single or multiple ExprNodes. */ /**@{*/ ExprNode *createExprNode(ExprType, void *); void deleteExprNode(ExprNode *); ExprNodeList *createExprNodeList(void); int addExprNode(ExprNodeList *, ExprNode *); void deleteExprNodeList(ExprNodeList *); /**@}*/ /** * \name CastExprNode modifiers * * Functions for creating and deleting CastExprNodes. */ /**@{*/ CastExprNode *createCastExprNode(ExprNode *, TypeNode *); void deleteCastExprNode(CastExprNode *); /**@}*/ /** * \name FuncCallExprNode modifiers * * Functions for creating and deleting FuncCallExprNodes. */ /**@{*/ FuncCallExprNode *createFuncCallExprNode(IdentifierNode *, IdentifierNode *, ExprNodeList *); void deleteFuncCallExprNode(FuncCallExprNode *); /**@}*/ /** * \name SystemCommandExprNode modifiers * * Functions for creating and deleting SystemCommandExprNode. */ /**@{*/ SystemCommandExprNode *createSystemCommandExprNode(ExprNode *); void deleteSystemCommandExprNode(SystemCommandExprNode *); /**@}*/ /** * \name OpExprNode modifiers * * Functions for creating and deleting OpExprNodes. */ /**@{*/ OpExprNode *createOpExprNode(OpType, ExprNodeList *); void deleteOpExprNode(OpExprNode *); /**@}*/ /** * \name Utilities * * Functions for performing helper tasks. */ /**@{*/ int acceptToken(Token ***, TokenType); int peekToken(Token ***, TokenType); int nextToken(Token ***, TokenType); /**@}*/ /** * \name Parsing functions * * Functions for parsing a stream of tokens. */ /**@{*/ ConstantNode *parseConstantNode(Token ***); TypeNode *parseTypeNode(Token ***); IdentifierNode *parseIdentifierNode(Token ***); ExprNode *parseExprNode(Token ***); StmtNode *parseStmtNode(Token ***); BlockNode *parseBlockNode(Token ***); MainNode *parseMainNode(Token **); ExprNode *parseCastExprNode(Token ***); ExprNode *parseConstantExprNode(Token ***); ExprNode *parseIdentifierExprNode(Token ***); ExprNode *parseFuncCallExprNode(Token ***); ExprNode *parseSystemCommandExprNode(Token ***); ExprNode *parseOpExprNode(Token ***); StmtNode *parseCastStmtNode(Token ***); StmtNode *parsePrintStmtNode(Token ***); StmtNode *parseInputStmtNode(Token ***); StmtNode *parseAssignmentStmtNode(Token ***); StmtNode *parseDeclarationStmtNode(Token ***); StmtNode *parseIfThenElseStmtNode(Token ***); StmtNode *parseSwitchStmtNode(Token ***); StmtNode *parseBreakStmtNode(Token ***); StmtNode *parseReturnStmtNode(Token ***); StmtNode *parseLoopStmtNode(Token ***); StmtNode *parseDeallocationStmtNode(Token ***); StmtNode *parseFuncDefStmtNode(Token ***); StmtNode *parseAltArrayDefStmtNode(Token ***); StmtNode *parseImportStmtNode(Token ***); /**@}*/ /** * \name ConstantNode modifiers * * Functions for creating and deleting ConstantNode. */ /**@{*/ ConstantNode *createBooleanConstantNode(int); ConstantNode *createIntegerConstantNode(long long); ConstantNode *createFloatConstantNode(float); ConstantNode *createStringConstantNode(char *); void deleteConstantNode(ConstantNode *); /**@}*/ #endif /* __PARSER_H__ */