mirror of
https://github.com/TorqueGameEngines/Torque3D.git
synced 2026-05-18 03:36:29 +00:00
713 lines
23 KiB
Text
713 lines
23 KiB
Text
%define parse.error custom
|
|
%locations
|
|
%define api.header.include {"CMDgram.h"}
|
|
%{
|
|
|
|
// bison --defines=cmdgram.h --verbose -o cmdgram.cpp -p CMD CMDgram.y
|
|
|
|
// Make sure we don't get gram.h twice.
|
|
#define _CMDGRAM_H_
|
|
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include "console/console.h"
|
|
#include "console/torquescript/compiler.h"
|
|
#include "console/consoleInternal.h"
|
|
#include "core/strings/stringFunctions.h"
|
|
|
|
#ifndef YYDEBUG
|
|
#define YYDEBUG 0
|
|
#endif
|
|
|
|
#define YYSSIZE 350
|
|
|
|
int outtext(char *fmt, ...);
|
|
extern int serrors;
|
|
extern Vector<String> lines;
|
|
|
|
#define nil 0
|
|
#undef YY_ARGS
|
|
#define YY_ARGS(x) x
|
|
|
|
int CMDlex();
|
|
void CMDerror(const char *, ...);
|
|
|
|
|
|
#ifdef alloca
|
|
#undef alloca
|
|
#endif
|
|
#define alloca dMalloc
|
|
|
|
template< typename T >
|
|
struct Token
|
|
{
|
|
T value;
|
|
U32 lineNumber;
|
|
};
|
|
|
|
%}
|
|
|
|
%{
|
|
/* Reserved word token definitions */
|
|
%}
|
|
|
|
%token <i> rwDEFINE rwENDDEF rwDECLARE rwDECLARESINGLETON
|
|
%token <i> rwBREAK rwELSE rwCONTINUE rwGLOBAL
|
|
%token <i> rwIF rwNIL rwRETURN rwWHILE rwDO
|
|
%token <i> rwENDIF rwENDWHILE rwENDFOR rwDEFAULT
|
|
%token <i> rwFOR rwFOREACH rwFOREACHSTR rwIN rwDATABLOCK rwSWITCH rwCASE rwSWITCHSTR
|
|
%token <i> rwCASEOR rwPACKAGE
|
|
%token <i> rwASSERT
|
|
%token ILLEGAL_TOKEN
|
|
// NOTE: rwNAMESPACE and rwCLASS were declared here previously but had no
|
|
// lexer rules and appeared in no grammar productions. They have been
|
|
// removed. If namespace/class syntax is added in future, add both the
|
|
// token declaration AND the lexer rule at the same time.
|
|
|
|
%{
|
|
/* Constant and identifier token definitions */
|
|
%}
|
|
|
|
%token <c> CHRCONST
|
|
%token <i> INTCONST
|
|
%token <s> TTAG
|
|
%token <s> VAR
|
|
%token <s> IDENT
|
|
%token <i> TYPEIDENT
|
|
%token <str> DOCBLOCK
|
|
%token <str> STRATOM
|
|
%token <str> TAGATOM
|
|
%token <f> FLTCONST
|
|
|
|
%{
|
|
/* Operator token definitions */
|
|
%}
|
|
|
|
%token <i> '+' '-' '*' '/' '<' '>' '=' '.' '|' '&' '%'
|
|
%token <i> '(' ')' ',' ':' ';' '{' '}' '^' '~' '!' '@'
|
|
%token <i> opINTNAME opINTNAMER
|
|
%token <i> opMINUSMINUS opPLUSPLUS
|
|
|
|
// NOTE: STMT_SEP was declared here but never returned by the lexer and never
|
|
// used in any grammar production. Removed to prevent confusion.
|
|
|
|
%token <i> opSHL opSHR opPLASN opMIASN opMLASN opDVASN opMODASN opANDASN
|
|
%token <i> opXORASN opORASN opSLASN opSRASN opCAT
|
|
%token <i> opEQ opNE opGE opLE opAND opOR
|
|
|
|
// FIX: opSTREQ and opSTRNE must be declared with their semantic type <i>.
|
|
// Previously opSTRNE was only mentioned in the %left precedence line, which
|
|
// does declare it as a token but gives it no type — causing a silent type
|
|
// mismatch when used in grammar rules (even if $2 isn't used in the action,
|
|
// the generated parser code is technically undefined behaviour).
|
|
%token <i> opSTREQ opSTRNE
|
|
|
|
%token <i> opCOLONCOLON
|
|
|
|
%union {
|
|
Token< char > c;
|
|
Token< int > i;
|
|
Token< const char* > s;
|
|
Token< char* > str;
|
|
Token< double > f;
|
|
StmtNode* stmt;
|
|
ExprNode* expr;
|
|
SlotAssignNode* slist;
|
|
VarNode* var;
|
|
SlotDecl slot;
|
|
InternalSlotDecl intslot;
|
|
ObjectBlockDecl odcl;
|
|
ObjectDeclNode* od;
|
|
AssignDecl asn;
|
|
IfStmtNode* ifnode;
|
|
}
|
|
|
|
%type <s> parent_block
|
|
%type <ifnode> case_block
|
|
%type <stmt> switch_stmt
|
|
%type <stmt> decl
|
|
%type <stmt> decl_list
|
|
%type <stmt> package_decl
|
|
%type <stmt> fn_decl_stmt
|
|
%type <stmt> fn_decl_list
|
|
%type <stmt> statement_list
|
|
%type <stmt> stmt
|
|
%type <expr> expr_list
|
|
%type <expr> expr_list_decl
|
|
%type <expr> aidx_expr
|
|
%type <expr> funcall_expr
|
|
%type <expr> assert_expr
|
|
%type <expr> object_name
|
|
%type <expr> object_args
|
|
%type <expr> stmt_expr
|
|
%type <expr> case_expr
|
|
%type <expr> class_name_expr
|
|
%type <stmt> if_stmt
|
|
%type <stmt> while_stmt
|
|
%type <stmt> for_stmt
|
|
%type <stmt> foreach_stmt
|
|
%type <stmt> stmt_block
|
|
%type <stmt> datablock_decl
|
|
%type <od> object_decl
|
|
%type <od> object_decl_list
|
|
%type <odcl> object_declare_block
|
|
%type <expr> expr
|
|
%type <slist> slot_assign_list_opt
|
|
%type <slist> slot_assign_list
|
|
%type <slist> slot_assign
|
|
%type <slot> slot_acc
|
|
%type <intslot> intslot_acc
|
|
%type <stmt> expression_stmt
|
|
%type <var> param
|
|
%type <var> var_list
|
|
%type <var> var_list_decl
|
|
%type <asn> assign_op_struct
|
|
|
|
// Operator precedence — lowest to highest.
|
|
// FIX: opMDASN, opNDASN, opNTASN were listed here but were never defined
|
|
// as tokens anywhere and were never returned by the lexer. They appear to
|
|
// be leftovers from an earlier revision. Removed to prevent compiler
|
|
// warnings about undeclared token names.
|
|
%left '['
|
|
%right opMODASN opANDASN opXORASN opPLASN opMIASN opMLASN opDVASN opORASN opSLASN opSRASN '='
|
|
%left '?' ':'
|
|
%left opOR
|
|
%left opAND
|
|
%left '|'
|
|
%left '^'
|
|
%left '&'
|
|
%left opEQ opNE
|
|
%left '<' opLE '>' opGE
|
|
%left '@' opCAT opSTREQ opSTRNE
|
|
%left opSHL opSHR
|
|
%left '+' '-'
|
|
%left '*' '/' '%'
|
|
%right '!' '~' opPLUSPLUS opMINUSMINUS UNARY
|
|
%left '.'
|
|
%left opINTNAME opINTNAMER
|
|
|
|
%%
|
|
|
|
start
|
|
: decl_list
|
|
{ }
|
|
;
|
|
|
|
decl_list
|
|
:
|
|
{ $$ = nil; }
|
|
| decl_list decl
|
|
{ if(!Script::gStatementList) { Script::gStatementList = $2; } else { Script::gStatementList->append($2); } }
|
|
;
|
|
|
|
decl
|
|
: stmt
|
|
{ $$ = $1; }
|
|
| fn_decl_stmt
|
|
{ $$ = $1; }
|
|
| package_decl
|
|
{ $$ = $1; }
|
|
;
|
|
|
|
package_decl
|
|
: rwPACKAGE IDENT '{' fn_decl_list '}' ';'
|
|
{ $$ = $4; for(StmtNode *walk = ($4);walk;walk = walk->getNext() ) walk->setPackage($2.value); }
|
|
;
|
|
|
|
fn_decl_list
|
|
: fn_decl_stmt
|
|
{ $$ = $1; }
|
|
| fn_decl_list fn_decl_stmt
|
|
{ $$ = $1; ($1)->append($2); }
|
|
;
|
|
|
|
statement_list
|
|
:
|
|
{ $$ = nil; }
|
|
| statement_list stmt
|
|
{ if(!$1) { $$ = $2; } else { ($1)->append($2); $$ = $1; } }
|
|
;
|
|
|
|
stmt
|
|
: if_stmt
|
|
| while_stmt
|
|
| for_stmt
|
|
| foreach_stmt
|
|
| datablock_decl
|
|
| switch_stmt
|
|
| rwBREAK ';'
|
|
{ $$ = BreakStmtNode::alloc( $1.lineNumber ); }
|
|
| rwCONTINUE ';'
|
|
{ $$ = ContinueStmtNode::alloc( $1.lineNumber ); }
|
|
| rwRETURN ';'
|
|
{ $$ = ReturnStmtNode::alloc( $1.lineNumber, NULL ); }
|
|
| rwRETURN expr ';'
|
|
{ $$ = ReturnStmtNode::alloc( $1.lineNumber, $2 ); }
|
|
| expression_stmt ';'
|
|
{ $$ = $1; }
|
|
| TTAG '=' expr ';'
|
|
{ $$ = TTagSetStmtNode::alloc( $1.lineNumber, $1.value, $3, NULL ); }
|
|
| TTAG '=' expr ',' expr ';'
|
|
{ $$ = TTagSetStmtNode::alloc( $1.lineNumber, $1.value, $3, $5 ); }
|
|
| DOCBLOCK
|
|
{ $$ = StrConstNode::alloc( $1.lineNumber, $1.value, false, true ); }
|
|
;
|
|
|
|
fn_decl_stmt
|
|
// Global function
|
|
: rwDEFINE IDENT '(' var_list_decl ')' '{' statement_list '}'
|
|
{ $$ = FunctionDeclStmtNode::alloc( $1.lineNumber, $2.value, NULL, $4, $7 ); }
|
|
// Namespaced method: function Namespace::name(...) { }
|
|
| rwDEFINE IDENT opCOLONCOLON IDENT '(' var_list_decl ')' '{' statement_list '}'
|
|
{ $$ = FunctionDeclStmtNode::alloc( $1.lineNumber, $4.value, $2.value, $6, $9 ); }
|
|
;
|
|
|
|
var_list_decl
|
|
:
|
|
{ $$ = NULL; }
|
|
| var_list
|
|
{ $$ = $1; }
|
|
;
|
|
|
|
var_list
|
|
: param
|
|
{ $$ = $1; }
|
|
| var_list ',' param
|
|
{ $$ = $1; ((StmtNode*)($1))->append((StmtNode*)$3 ); }
|
|
;
|
|
|
|
// Parameter declaration forms:
|
|
//
|
|
// %var — required parameter
|
|
// %var ? — optional parameter, evaluates to "" / 0 when absent
|
|
// %var = expr — optional parameter with default value
|
|
// %var ? = expr — same as above; the '?' makes the optionality explicit
|
|
//
|
|
// NOTE: the default `expr` can be any valid expression, including function
|
|
// calls and variable references. At present these are evaluated once at
|
|
// declaration time (global scope). The planned codelet change (see
|
|
// FunctionDeclStmtNode::compileStmt in ast.cpp) will evaluate them at
|
|
// each call site instead — no grammar change is required for that fix.
|
|
param
|
|
: VAR
|
|
{ $$ = VarNode::allocParam($1.lineNumber, $1.value, NULL); }
|
|
| VAR '?'
|
|
{ $$ = VarNode::allocParam($1.lineNumber, $1.value, NULL); }
|
|
| VAR '=' expr
|
|
{ $$ = VarNode::allocParam($1.lineNumber, $1.value, $3); }
|
|
| VAR '?' '=' expr
|
|
{ $$ = VarNode::allocParam($1.lineNumber, $1.value, $4); }
|
|
;
|
|
|
|
datablock_decl
|
|
: rwDATABLOCK class_name_expr '(' expr parent_block ')' '{' slot_assign_list_opt '}' ';'
|
|
{ $$ = ObjectDeclNode::alloc( $1.lineNumber, $2, $4, NULL, $5.value, $8, NULL, true, false, false); }
|
|
;
|
|
|
|
object_decl
|
|
: rwDECLARE class_name_expr '(' object_name parent_block object_args ')' '{' object_declare_block '}'
|
|
{ $$ = ObjectDeclNode::alloc( $1.lineNumber, $2, $4, $6, $5.value, $9.slots, $9.decls, false, false, false); }
|
|
| rwDECLARE class_name_expr '(' object_name parent_block object_args ')'
|
|
{ $$ = ObjectDeclNode::alloc( $1.lineNumber, $2, $4, $6, $5.value, NULL, NULL, false, false, false); }
|
|
| rwDECLARE class_name_expr '(' '[' object_name ']' parent_block object_args ')' '{' object_declare_block '}'
|
|
{ $$ = ObjectDeclNode::alloc( $1.lineNumber, $2, $5, $8, $7.value, $11.slots, $11.decls, false, true, false); }
|
|
| rwDECLARE class_name_expr '(' '[' object_name ']' parent_block object_args ')'
|
|
{ $$ = ObjectDeclNode::alloc( $1.lineNumber, $2, $5, $8, $7.value, NULL, NULL, false, true, false); }
|
|
| rwDECLARESINGLETON class_name_expr '(' object_name parent_block object_args ')' '{' object_declare_block '}'
|
|
{ $$ = ObjectDeclNode::alloc( $1.lineNumber, $2, $4, $6, $5.value, $9.slots, $9.decls, false, false, true); }
|
|
| rwDECLARESINGLETON class_name_expr '(' object_name parent_block object_args ')'
|
|
{ $$ = ObjectDeclNode::alloc( $1.lineNumber, $2, $4, $6, $5.value, NULL, NULL, false, false, true); }
|
|
;
|
|
|
|
parent_block
|
|
:
|
|
{ $$.value = NULL; }
|
|
| ':' IDENT
|
|
{ $$ = $2; }
|
|
;
|
|
|
|
object_name
|
|
:
|
|
{ $$ = StrConstNode::alloc( CodeBlock::smCurrentParser->getCurrentLine(), "", false); }
|
|
| expr
|
|
{ $$ = $1; }
|
|
;
|
|
|
|
object_args
|
|
:
|
|
{ $$ = NULL; }
|
|
| ',' expr_list
|
|
{ $$ = $2; }
|
|
;
|
|
|
|
object_declare_block
|
|
:
|
|
{ $$.slots = NULL; $$.decls = NULL; }
|
|
| slot_assign_list
|
|
{ $$.slots = $1; $$.decls = NULL; }
|
|
| object_decl_list
|
|
{ $$.slots = NULL; $$.decls = $1; }
|
|
| slot_assign_list object_decl_list
|
|
{ $$.slots = $1; $$.decls = $2; }
|
|
;
|
|
|
|
object_decl_list
|
|
: object_decl ';'
|
|
{ $$ = $1; }
|
|
| object_decl_list object_decl ';'
|
|
{ $1->append($2); $$ = $1; }
|
|
;
|
|
|
|
stmt_block
|
|
: '{' statement_list '}'
|
|
{ $$ = $2; }
|
|
| stmt
|
|
{ $$ = $1; }
|
|
;
|
|
|
|
switch_stmt
|
|
: rwSWITCH '(' expr ')' '{' case_block '}'
|
|
{ $$ = $6; $6->propagateSwitchExpr($3, false); }
|
|
| rwSWITCHSTR '(' expr ')' '{' case_block '}'
|
|
{ $$ = $6; $6->propagateSwitchExpr($3, true); }
|
|
;
|
|
|
|
// NOTE: propagateSwitchExpr builds a recursive OR expression tree that is
|
|
// O(n) deep for n cases. Large switch statements (100+ cases) can overflow
|
|
// the compiler stack.
|
|
case_block
|
|
: rwCASE case_expr ':' statement_list
|
|
{ $$ = IfStmtNode::alloc( $1.lineNumber, $2, $4, NULL, false); }
|
|
| rwCASE case_expr ':' statement_list rwDEFAULT ':' statement_list
|
|
{ $$ = IfStmtNode::alloc( $1.lineNumber, $2, $4, $7, false); }
|
|
| rwCASE case_expr ':' statement_list case_block
|
|
{ $$ = IfStmtNode::alloc( $1.lineNumber, $2, $4, $5, true); }
|
|
;
|
|
|
|
case_expr
|
|
: expr
|
|
{ $$ = $1; }
|
|
| case_expr rwCASEOR expr
|
|
{ ($1)->append($3); $$ = $1; }
|
|
;
|
|
|
|
if_stmt
|
|
: rwIF '(' expr ')' stmt_block
|
|
{ $$ = IfStmtNode::alloc($1.lineNumber, $3, $5, NULL, false); }
|
|
| rwIF '(' expr ')' stmt_block rwELSE stmt_block
|
|
{ $$ = IfStmtNode::alloc($1.lineNumber, $3, $5, $7, false); }
|
|
;
|
|
|
|
while_stmt
|
|
: rwWHILE '(' expr ')' stmt_block
|
|
{ $$ = LoopStmtNode::alloc($1.lineNumber, nil, $3, nil, $5, false); }
|
|
| rwDO stmt_block rwWHILE '(' expr ')'
|
|
{ $$ = LoopStmtNode::alloc($3.lineNumber, nil, $5, nil, $2, true); }
|
|
;
|
|
|
|
for_stmt
|
|
: rwFOR '(' expr ';' expr ';' expr ')' stmt_block
|
|
{ $$ = LoopStmtNode::alloc($1.lineNumber, $3, $5, $7, $9, false); }
|
|
| rwFOR '(' expr ';' expr ';' ')' stmt_block
|
|
{ $$ = LoopStmtNode::alloc($1.lineNumber, $3, $5, NULL, $8, false); }
|
|
| rwFOR '(' expr ';' ';' expr ')' stmt_block
|
|
{ $$ = LoopStmtNode::alloc($1.lineNumber, $3, NULL, $6, $8, false); }
|
|
| rwFOR '(' expr ';' ';' ')' stmt_block
|
|
{ $$ = LoopStmtNode::alloc($1.lineNumber, $3, NULL, NULL, $7, false); }
|
|
| rwFOR '(' ';' expr ';' expr ')' stmt_block
|
|
{ $$ = LoopStmtNode::alloc($1.lineNumber, NULL, $4, $6, $8, false); }
|
|
| rwFOR '(' ';' expr ';' ')' stmt_block
|
|
{ $$ = LoopStmtNode::alloc($1.lineNumber, NULL, $4, NULL, $7, false); }
|
|
| rwFOR '(' ';' ';' expr ')' stmt_block
|
|
{ $$ = LoopStmtNode::alloc($1.lineNumber, NULL, NULL, $5, $7, false); }
|
|
| rwFOR '(' ';' ';' ')' stmt_block
|
|
{ $$ = LoopStmtNode::alloc($1.lineNumber, NULL, NULL, NULL, $6, false); }
|
|
;
|
|
|
|
foreach_stmt
|
|
: rwFOREACH '(' VAR rwIN expr ')' stmt_block
|
|
{ $$ = IterStmtNode::alloc( $1.lineNumber, $3.value, $5, $7, false ); }
|
|
| rwFOREACHSTR '(' VAR rwIN expr ')' stmt_block
|
|
{ $$ = IterStmtNode::alloc( $1.lineNumber, $3.value, $5, $7, true ); }
|
|
;
|
|
|
|
expression_stmt
|
|
: stmt_expr
|
|
{ $$ = $1; }
|
|
;
|
|
|
|
expr
|
|
: stmt_expr
|
|
{ $$ = $1; }
|
|
| '(' expr ')'
|
|
{ $$ = $2; }
|
|
| expr '^' expr
|
|
{ $$ = IntBinaryExprNode::alloc( $1->dbgLineNumber, $2.value, $1, $3); }
|
|
| expr '%' expr
|
|
{ $$ = IntBinaryExprNode::alloc( $1->dbgLineNumber, $2.value, $1, $3); }
|
|
| expr '&' expr
|
|
{ $$ = IntBinaryExprNode::alloc( $1->dbgLineNumber, $2.value, $1, $3); }
|
|
| expr '|' expr
|
|
{ $$ = IntBinaryExprNode::alloc( $1->dbgLineNumber, $2.value, $1, $3); }
|
|
| expr '+' expr
|
|
{ $$ = FloatBinaryExprNode::alloc( $1->dbgLineNumber, $2.value, $1, $3); }
|
|
| expr '-' expr
|
|
{ $$ = FloatBinaryExprNode::alloc( $1->dbgLineNumber, $2.value, $1, $3); }
|
|
| expr '*' expr
|
|
{ $$ = FloatBinaryExprNode::alloc( $1->dbgLineNumber, $2.value, $1, $3); }
|
|
| expr '/' expr
|
|
{ $$ = FloatBinaryExprNode::alloc( $1->dbgLineNumber, $2.value, $1, $3); }
|
|
| '-' expr %prec UNARY
|
|
{ $$ = FloatUnaryExprNode::alloc( $1.lineNumber, $1.value, $2); }
|
|
| '*' expr %prec UNARY
|
|
{ $$ = TTagDerefNode::alloc( $1.lineNumber, $2 ); }
|
|
| TTAG
|
|
{ $$ = TTagExprNode::alloc( $1.lineNumber, $1.value ); }
|
|
| expr '?' expr ':' expr
|
|
{ $$ = ConditionalExprNode::alloc( $1->dbgLineNumber, $1, $3, $5); }
|
|
| expr '<' expr
|
|
{ $$ = IntBinaryExprNode::alloc( $1->dbgLineNumber, $2.value, $1, $3); }
|
|
| expr '>' expr
|
|
{ $$ = IntBinaryExprNode::alloc( $1->dbgLineNumber, $2.value, $1, $3); }
|
|
| expr opGE expr
|
|
{ $$ = IntBinaryExprNode::alloc( $1->dbgLineNumber, $2.value, $1, $3); }
|
|
| expr opLE expr
|
|
{ $$ = IntBinaryExprNode::alloc( $1->dbgLineNumber, $2.value, $1, $3); }
|
|
| expr opEQ expr
|
|
{ $$ = IntBinaryExprNode::alloc( $1->dbgLineNumber, $2.value, $1, $3); }
|
|
| expr opNE expr
|
|
{ $$ = IntBinaryExprNode::alloc( $1->dbgLineNumber, $2.value, $1, $3); }
|
|
| expr opOR expr
|
|
{ $$ = IntBinaryExprNode::alloc( $1->dbgLineNumber, $2.value, $1, $3); }
|
|
| expr opSHL expr
|
|
{ $$ = IntBinaryExprNode::alloc( $1->dbgLineNumber, $2.value, $1, $3); }
|
|
| expr opSHR expr
|
|
{ $$ = IntBinaryExprNode::alloc( $1->dbgLineNumber, $2.value, $1, $3); }
|
|
| expr opAND expr
|
|
{ $$ = IntBinaryExprNode::alloc( $1->dbgLineNumber, $2.value, $1, $3); }
|
|
| expr opSTREQ expr
|
|
{ $$ = StreqExprNode::alloc( $1->dbgLineNumber, $1, $3, true); }
|
|
| expr opSTRNE expr
|
|
{ $$ = StreqExprNode::alloc( $1->dbgLineNumber, $1, $3, false); }
|
|
// The '@' operator covers four cases via token value encoding in the lexer:
|
|
// '@' → value 0 (plain concatenation)
|
|
// NL → value '\n'
|
|
// TAB → value '\t'
|
|
// SPC → value ' '
|
|
// The appendChar is stored in $2.value and forwarded to StrcatExprNode.
|
|
| expr '@' expr
|
|
{ $$ = StrcatExprNode::alloc( $1->dbgLineNumber, $1, $3, $2.value); }
|
|
| '!' expr
|
|
{ $$ = IntUnaryExprNode::alloc($1.lineNumber, $1.value, $2); }
|
|
| '~' expr
|
|
{ $$ = IntUnaryExprNode::alloc($1.lineNumber, $1.value, $2); }
|
|
| TAGATOM
|
|
{ $$ = StrConstNode::alloc( $1.lineNumber, $1.value, true); }
|
|
| FLTCONST
|
|
{ $$ = FloatNode::alloc( $1.lineNumber, $1.value ); }
|
|
| INTCONST
|
|
{ $$ = IntNode::alloc( $1.lineNumber, $1.value ); }
|
|
| rwBREAK
|
|
{ $$ = ConstantNode::alloc( $1.lineNumber, StringTable->insert("break")); }
|
|
| slot_acc
|
|
{ $$ = SlotAccessNode::alloc( $1.lineNumber, $1.object, $1.array, $1.slotName ); }
|
|
| intslot_acc
|
|
{ $$ = InternalSlotAccessNode::alloc( $1.lineNumber, $1.object, $1.slotExpr, $1.recurse); }
|
|
| IDENT
|
|
{ $$ = ConstantNode::alloc( $1.lineNumber, $1.value ); }
|
|
| STRATOM
|
|
{ $$ = StrConstNode::alloc( $1.lineNumber, $1.value, false); }
|
|
| VAR
|
|
{ $$ = (ExprNode*)VarNode::alloc( $1.lineNumber, $1.value, NULL); }
|
|
| VAR '[' aidx_expr ']'
|
|
{ $$ = (ExprNode*)VarNode::alloc( $1.lineNumber, $1.value, $3 ); }
|
|
;
|
|
|
|
slot_acc
|
|
: expr '.' IDENT
|
|
{ $$.lineNumber = $1->dbgLineNumber; $$.object = $1; $$.slotName = $3.value; $$.array = NULL; }
|
|
| expr '.' IDENT '[' aidx_expr ']'
|
|
{ $$.lineNumber = $1->dbgLineNumber; $$.object = $1; $$.slotName = $3.value; $$.array = $5; }
|
|
;
|
|
|
|
intslot_acc
|
|
: expr opINTNAME class_name_expr
|
|
{ $$.lineNumber = $1->dbgLineNumber; $$.object = $1; $$.slotExpr = $3; $$.recurse = false; }
|
|
| expr opINTNAMER class_name_expr
|
|
{ $$.lineNumber = $1->dbgLineNumber; $$.object = $1; $$.slotExpr = $3; $$.recurse = true; }
|
|
;
|
|
|
|
class_name_expr
|
|
: IDENT
|
|
{ $$ = ConstantNode::alloc( $1.lineNumber, $1.value ); }
|
|
| '(' expr ')'
|
|
{ $$ = $2; }
|
|
;
|
|
|
|
assign_op_struct
|
|
: opPLUSPLUS
|
|
{ $$.lineNumber = $1.lineNumber; $$.token = opPLUSPLUS; $$.expr = FloatNode::alloc( $1.lineNumber, 1 ); }
|
|
| opMINUSMINUS
|
|
{ $$.lineNumber = $1.lineNumber; $$.token = opMINUSMINUS; $$.expr = FloatNode::alloc( $1.lineNumber, 1 ); }
|
|
| opPLASN expr
|
|
{ $$.lineNumber = $1.lineNumber; $$.token = '+'; $$.expr = $2; }
|
|
| opMIASN expr
|
|
{ $$.lineNumber = $1.lineNumber; $$.token = '-'; $$.expr = $2; }
|
|
| opMLASN expr
|
|
{ $$.lineNumber = $1.lineNumber; $$.token = '*'; $$.expr = $2; }
|
|
| opDVASN expr
|
|
{ $$.lineNumber = $1.lineNumber; $$.token = '/'; $$.expr = $2; }
|
|
| opMODASN expr
|
|
{ $$.lineNumber = $1.lineNumber; $$.token = '%'; $$.expr = $2; }
|
|
| opANDASN expr
|
|
{ $$.lineNumber = $1.lineNumber; $$.token = '&'; $$.expr = $2; }
|
|
| opXORASN expr
|
|
{ $$.lineNumber = $1.lineNumber; $$.token = '^'; $$.expr = $2; }
|
|
| opORASN expr
|
|
{ $$.lineNumber = $1.lineNumber; $$.token = '|'; $$.expr = $2; }
|
|
| opSLASN expr
|
|
{ $$.lineNumber = $1.lineNumber; $$.token = opSHL; $$.expr = $2; }
|
|
| opSRASN expr
|
|
{ $$.lineNumber = $1.lineNumber; $$.token = opSHR; $$.expr = $2; }
|
|
;
|
|
|
|
stmt_expr
|
|
: funcall_expr
|
|
{ $$ = $1; }
|
|
| assert_expr
|
|
{ $$ = $1; }
|
|
| object_decl
|
|
{ $$ = $1; }
|
|
| VAR '=' expr
|
|
{ $$ = AssignExprNode::alloc( $1.lineNumber, $1.value, NULL, $3); }
|
|
| VAR '[' aidx_expr ']' '=' expr
|
|
{ $$ = AssignExprNode::alloc( $1.lineNumber, $1.value, $3, $6); }
|
|
| VAR assign_op_struct
|
|
{ $$ = AssignOpExprNode::alloc( $1.lineNumber, $1.value, NULL, $2.expr, $2.token); }
|
|
| VAR '[' aidx_expr ']' assign_op_struct
|
|
{ $$ = AssignOpExprNode::alloc( $1.lineNumber, $1.value, $3, $5.expr, $5.token); }
|
|
| slot_acc assign_op_struct
|
|
{ $$ = SlotAssignOpNode::alloc( $1.lineNumber, $1.object, $1.slotName, $1.array, $2.token, $2.expr); }
|
|
| slot_acc '=' expr
|
|
{ $$ = SlotAssignNode::alloc( $1.lineNumber, $1.object, $1.array, $1.slotName, $3); }
|
|
| slot_acc '=' '{' expr_list '}'
|
|
{ $$ = SlotAssignNode::alloc( $1.lineNumber, $1.object, $1.array, $1.slotName, $4); }
|
|
;
|
|
|
|
funcall_expr
|
|
// Global function call: name(args)
|
|
: IDENT '(' expr_list_decl ')'
|
|
{ $$ = FuncCallExprNode::alloc( $1.lineNumber, $1.value, NULL, $3, false); }
|
|
// Static/namespace call: Namespace::name(args)
|
|
| IDENT opCOLONCOLON IDENT '(' expr_list_decl ')'
|
|
{ $$ = FuncCallExprNode::alloc( $1.lineNumber, $3.value, $1.value, $5, false); }
|
|
// Method call: object.method(args)
|
|
// The object expression is prepended to the arg list so that exec() can
|
|
// find it as callArgv[1] (the implicit 'this').
|
|
| expr '.' IDENT '(' expr_list_decl ')'
|
|
{ $1->append($5); $$ = FuncCallExprNode::alloc( $1->dbgLineNumber, $3.value, NULL, $1, true); }
|
|
;
|
|
|
|
assert_expr
|
|
: rwASSERT '(' expr ')'
|
|
{ $$ = AssertCallExprNode::alloc( $1.lineNumber, $3, NULL ); }
|
|
| rwASSERT '(' expr ',' STRATOM ')'
|
|
{ $$ = AssertCallExprNode::alloc( $1.lineNumber, $3, $5.value ); }
|
|
;
|
|
|
|
expr_list_decl
|
|
:
|
|
{ $$ = NULL; }
|
|
| expr_list
|
|
{ $$ = $1; }
|
|
;
|
|
|
|
expr_list
|
|
: expr
|
|
{ $$ = $1; }
|
|
| expr_list ',' expr
|
|
{ ($1)->append($3); $$ = $1; }
|
|
;
|
|
|
|
slot_assign_list_opt
|
|
:
|
|
{ $$ = NULL; }
|
|
| slot_assign_list
|
|
{ $$ = $1; }
|
|
;
|
|
|
|
slot_assign_list
|
|
: slot_assign
|
|
{ $$ = $1; }
|
|
| slot_assign_list slot_assign
|
|
{ $1->append($2); $$ = $1; }
|
|
;
|
|
|
|
slot_assign
|
|
: IDENT '=' expr ';'
|
|
{ $$ = SlotAssignNode::alloc( $1.lineNumber, NULL, NULL, $1.value, $3); }
|
|
| TYPEIDENT IDENT '=' expr ';'
|
|
{ $$ = SlotAssignNode::alloc( $1.lineNumber, NULL, NULL, $2.value, $4, $1.value); }
|
|
| rwDATABLOCK '=' expr ';'
|
|
{ $$ = SlotAssignNode::alloc( $1.lineNumber, NULL, NULL, StringTable->insert("datablock"), $3); }
|
|
| IDENT '[' aidx_expr ']' '=' expr ';'
|
|
{ $$ = SlotAssignNode::alloc( $1.lineNumber, NULL, $3, $1.value, $6); }
|
|
| TYPEIDENT IDENT '[' aidx_expr ']' '=' expr ';'
|
|
{ $$ = SlotAssignNode::alloc( $1.lineNumber, NULL, $4, $2.value, $7, $1.value); }
|
|
;
|
|
|
|
// Array index expressions. Multiple comma-separated indices get
|
|
// concatenated with '_' separators at runtime (e.g. arr[1,2] → "arr_1_2").
|
|
aidx_expr
|
|
: expr
|
|
{ $$ = $1; }
|
|
| aidx_expr ',' expr
|
|
{ $$ = CommaCatExprNode::alloc( $1->dbgLineNumber, $1, $3); }
|
|
;
|
|
|
|
%%
|
|
|
|
int
|
|
yyreport_syntax_error(const yypcontext_t *ctx)
|
|
{
|
|
int ret = 0;
|
|
String output;
|
|
const YYLTYPE *loc = yypcontext_location(ctx);
|
|
output += "syntax error: ";
|
|
|
|
yysymbol_kind_t nxt = yypcontext_token(ctx);
|
|
if (nxt != YYSYMBOL_YYEMPTY)
|
|
output += String::ToString("unexpected: %s at column: %d",
|
|
yysymbol_name(nxt), loc->first_column);
|
|
|
|
enum { TOKENMAX = 10 };
|
|
yysymbol_kind_t expected[TOKENMAX];
|
|
|
|
int exp = yypcontext_expected_tokens(ctx, expected, TOKENMAX);
|
|
if (exp < 0)
|
|
{
|
|
ret = exp;
|
|
}
|
|
else
|
|
{
|
|
for (int i = 0; i < exp; ++i)
|
|
output += String::ToString("%s %s",
|
|
i == 0 ? ": expected" : "or",
|
|
yysymbol_name(expected[i]));
|
|
}
|
|
|
|
if (lines.size() > 0)
|
|
{
|
|
output += "\n";
|
|
for (int i = 0; i < lines.size(); i++)
|
|
{
|
|
int line = lines.size() - i;
|
|
output += String::ToString("%5d | ", loc->first_line - (line - 1))
|
|
+ lines[i] + "\n";
|
|
}
|
|
output += String::ToString("%5s | %*s", "", loc->first_column, "^");
|
|
}
|
|
|
|
yyerror("%s", output.c_str());
|
|
return ret;
|
|
}
|