|
|
|
@ -32,343 +32,331 @@ struct stmt |
|
|
|
static |
|
|
|
inline |
|
|
|
u_stmtType |
|
|
|
stmtEval (s_stmt * stmt, s_block * actBlock, int op) |
|
|
|
stmtEval(s_stmt * stmt, s_block * actBlock, int op) |
|
|
|
{ |
|
|
|
s_stmtQueue * args = stmt->sQueue; |
|
|
|
s_expVal * op1 = stmtDo (stmtQueueGet (args, 0), actBlock).eVal, |
|
|
|
* op2 = stmtDo (stmtQueueGet (args, 1), actBlock).eVal, |
|
|
|
* ret; |
|
|
|
s_expVal * op1 = stmtDo(stmtQueueGet(args, 0), actBlock).eVal, |
|
|
|
* op2 = stmtDo(stmtQueueGet(args, 1), actBlock).eVal, |
|
|
|
* ret; |
|
|
|
|
|
|
|
ret = evalExpr (op, op1, op2); |
|
|
|
ret = evalExpr(op, op1, op2); |
|
|
|
|
|
|
|
if (op1 != NULL) expValueFree (op1); |
|
|
|
if (op2 != NULL) expValueFree (op2); |
|
|
|
if (op1 != NULL) expValueFree(op1); |
|
|
|
if (op2 != NULL) expValueFree(op2); |
|
|
|
|
|
|
|
return (u_stmtType) ret; |
|
|
|
return (u_stmtType)ret; |
|
|
|
} |
|
|
|
|
|
|
|
static |
|
|
|
inline |
|
|
|
u_stmtType |
|
|
|
stmtIdentVar (s_stmt * stmt, s_block * actBlock) |
|
|
|
stmtIdentVar(s_stmt * stmt, s_block * actBlock) |
|
|
|
{ |
|
|
|
s_ident * ret = NULL; |
|
|
|
|
|
|
|
s_stmtQueue * args = stmt->sQueue; |
|
|
|
s_expVal * _op = stmtDo (stmtQueueGet (args, 0), actBlock).eVal; |
|
|
|
char * op = expValueString (_op); |
|
|
|
s_expVal * _op = stmtDo(stmtQueueGet(args, 0), actBlock).eVal; |
|
|
|
char * op = expValueString(_op); |
|
|
|
s_block * run = actBlock; |
|
|
|
|
|
|
|
while (ret == NULL && run != NULL) |
|
|
|
{ |
|
|
|
ret = identListSeekKey (blockIdl (run), op); |
|
|
|
run = blockPrev (run); |
|
|
|
while (ret == NULL && run != NULL) { |
|
|
|
ret = identListSeekKey(blockIdl(run), op); |
|
|
|
run = blockPrev(run); |
|
|
|
} |
|
|
|
|
|
|
|
if (ret == NULL) |
|
|
|
ret = identListPutVal (blockIdl (actBlock), identUndefNew (-1, op)); |
|
|
|
if (ret == NULL) { |
|
|
|
ret = identListPutVal(blockIdl(actBlock), identUndefNew(-1, op)); |
|
|
|
} |
|
|
|
|
|
|
|
expValueFree (_op); |
|
|
|
free (op); |
|
|
|
expValueFree(_op); |
|
|
|
free(op); |
|
|
|
|
|
|
|
return (u_stmtType) ret; |
|
|
|
return (u_stmtType)ret; |
|
|
|
} |
|
|
|
|
|
|
|
static |
|
|
|
inline |
|
|
|
u_stmtType |
|
|
|
stmtIdentArray (s_stmt * stmt, s_block * actBlock) |
|
|
|
stmtIdentArray(s_stmt * stmt, s_block * actBlock) |
|
|
|
{ |
|
|
|
s_stmtQueue * args = stmt->sQueue; |
|
|
|
s_ident * op1 = stmtDo (stmtQueueGet (args, 0), actBlock).idVal; |
|
|
|
s_expVal * op2 = stmtDo (stmtQueueGet (args, 1), actBlock).eVal; |
|
|
|
s_ident * op1 = stmtDo(stmtQueueGet(args, 0), actBlock).idVal; |
|
|
|
s_expVal * op2 = stmtDo(stmtQueueGet(args, 1), actBlock).eVal; |
|
|
|
s_ident * ret; |
|
|
|
|
|
|
|
ret = getArray (op1, op2); |
|
|
|
ret = getArray(op1, op2); |
|
|
|
|
|
|
|
if (op2 != NULL) expValueFree (op2); |
|
|
|
if (op2 != NULL) expValueFree(op2); |
|
|
|
|
|
|
|
return (u_stmtType) ret; |
|
|
|
return (u_stmtType)ret; |
|
|
|
} |
|
|
|
|
|
|
|
static |
|
|
|
inline |
|
|
|
u_stmtType |
|
|
|
stmtIdentVal (s_stmt * stmt, s_block * actBlock) |
|
|
|
stmtIdentVal(s_stmt * stmt, s_block * actBlock) |
|
|
|
{ |
|
|
|
s_stmtQueue * args = stmt->sQueue; |
|
|
|
s_ident * op1 = stmtDo (stmtQueueGet (args, 0), actBlock).idVal; |
|
|
|
s_ident * op1 = stmtDo(stmtQueueGet(args, 0), actBlock).idVal; |
|
|
|
|
|
|
|
return (u_stmtType) identExp (op1); |
|
|
|
return (u_stmtType)identExp(op1); |
|
|
|
} |
|
|
|
|
|
|
|
static |
|
|
|
inline |
|
|
|
u_stmtType |
|
|
|
stmtEvalComp (s_stmt * stmt, s_block * actBlock, int op) |
|
|
|
stmtEvalComp(s_stmt * stmt, s_block * actBlock, int op) |
|
|
|
{ |
|
|
|
s_stmtQueue * args = stmt->sQueue; |
|
|
|
s_expVal * op1 = stmtDo (stmtQueueGet (args, 0), actBlock).eVal, |
|
|
|
* op2 = stmtDo (stmtQueueGet (args, 1), actBlock).eVal; |
|
|
|
int ret; |
|
|
|
s_expVal * op1 = stmtDo(stmtQueueGet(args, 0), actBlock).eVal, |
|
|
|
* op2 = stmtDo(stmtQueueGet(args, 1), actBlock).eVal; |
|
|
|
int ret; |
|
|
|
|
|
|
|
ret = evalComp (op, op1, op2); |
|
|
|
ret = evalComp(op, op1, op2); |
|
|
|
|
|
|
|
if (op1 != NULL) expValueFree (op1); |
|
|
|
if (op2 != NULL) expValueFree (op2); |
|
|
|
if (op1 != NULL) expValueFree(op1); |
|
|
|
if (op2 != NULL) expValueFree(op2); |
|
|
|
|
|
|
|
return (u_stmtType) ret; |
|
|
|
return (u_stmtType)ret; |
|
|
|
} |
|
|
|
|
|
|
|
static |
|
|
|
inline |
|
|
|
u_stmtType |
|
|
|
stmtAssign (s_stmt * stmt, s_block * actBlock) |
|
|
|
stmtAssign(s_stmt * stmt, s_block * actBlock) |
|
|
|
{ |
|
|
|
s_stmtQueue * args = stmt->sQueue; |
|
|
|
s_ident * op1 = stmtDo (stmtQueueGet (args, 0), actBlock).idVal; |
|
|
|
s_expVal * op2 = stmtDo (stmtQueueGet (args, 1), actBlock).eVal, |
|
|
|
* ret; |
|
|
|
s_ident * op1 = stmtDo(stmtQueueGet(args, 0), actBlock).idVal; |
|
|
|
s_expVal * op2 = stmtDo(stmtQueueGet(args, 1), actBlock).eVal, |
|
|
|
* ret; |
|
|
|
|
|
|
|
if (op1 == NULL) |
|
|
|
op1 = getVariable (NULL, NULL); |
|
|
|
if (op1 == NULL) op1 = getVariable(NULL, NULL); |
|
|
|
|
|
|
|
ret = assign (op1, op2); |
|
|
|
ret = assign(op1, op2); |
|
|
|
|
|
|
|
if (op2 != NULL) expValueFree (op2); |
|
|
|
if (op2 != NULL) expValueFree(op2); |
|
|
|
|
|
|
|
return (u_stmtType) ret; |
|
|
|
return (u_stmtType)ret; |
|
|
|
} |
|
|
|
|
|
|
|
static |
|
|
|
inline |
|
|
|
u_stmtType |
|
|
|
stmtPrint (s_stmt * stmt, s_block * actBlock) |
|
|
|
stmtPrint(s_stmt * stmt, s_block * actBlock) |
|
|
|
{ |
|
|
|
s_stmtQueue * args = stmt->sQueue; |
|
|
|
s_expVal * op = stmtDo (stmtQueueGet (args, 0), actBlock).eVal; |
|
|
|
s_expVal * op = stmtDo(stmtQueueGet(args, 0), actBlock).eVal; |
|
|
|
|
|
|
|
if (op != NULL) |
|
|
|
{ |
|
|
|
printExpr (op); |
|
|
|
expValueFree (op); |
|
|
|
if (op != NULL) { |
|
|
|
printExpr(op); |
|
|
|
expValueFree(op); |
|
|
|
} |
|
|
|
|
|
|
|
return (u_stmtType) 0; |
|
|
|
return (u_stmtType)0; |
|
|
|
} |
|
|
|
|
|
|
|
static |
|
|
|
inline |
|
|
|
u_stmtType |
|
|
|
stmtEvalCondExpr (s_stmt * stmt, s_block * actBlock) |
|
|
|
stmtEvalCondExpr(s_stmt * stmt, s_block * actBlock) |
|
|
|
{ |
|
|
|
s_stmtQueue * args = stmt->sQueue; |
|
|
|
s_expVal * op = stmtDo (stmtQueueGet (args, 0), actBlock).eVal; |
|
|
|
int ret; |
|
|
|
s_expVal * op = stmtDo(stmtQueueGet(args, 0), actBlock).eVal; |
|
|
|
int ret; |
|
|
|
|
|
|
|
ret = evalCondExpr (op); |
|
|
|
ret = evalCondExpr(op); |
|
|
|
|
|
|
|
if (op != NULL) expValueFree (op); |
|
|
|
if (op != NULL) expValueFree(op); |
|
|
|
|
|
|
|
return (u_stmtType) ret; |
|
|
|
return (u_stmtType)ret; |
|
|
|
} |
|
|
|
|
|
|
|
static |
|
|
|
inline |
|
|
|
u_stmtType |
|
|
|
stmtEvalCond (s_stmt * stmt, s_block * actBlock, int op) |
|
|
|
stmtEvalCond(s_stmt * stmt, s_block * actBlock, int op) |
|
|
|
{ |
|
|
|
s_stmtQueue * args = stmt->sQueue; |
|
|
|
int op1 = stmtDo (stmtQueueGet (args, 0), actBlock).cond; |
|
|
|
int op1 = stmtDo(stmtQueueGet(args, 0), actBlock).cond; |
|
|
|
|
|
|
|
switch (op) |
|
|
|
{ |
|
|
|
switch (op) { |
|
|
|
case LOGAND: |
|
|
|
{ |
|
|
|
int op2 = stmtDo (stmtQueueGet (args, 1), actBlock).cond; |
|
|
|
return (u_stmtType) (op1 && op2); |
|
|
|
int op2 = stmtDo(stmtQueueGet(args, 1), actBlock).cond; |
|
|
|
return (u_stmtType)(op1 && op2); |
|
|
|
} |
|
|
|
|
|
|
|
case LOGOR: |
|
|
|
{ |
|
|
|
int op2 = stmtDo (stmtQueueGet (args, 1), actBlock).cond; |
|
|
|
return (u_stmtType) (op1 || op2); |
|
|
|
int op2 = stmtDo(stmtQueueGet(args, 1), actBlock).cond; |
|
|
|
return (u_stmtType)(op1 || op2); |
|
|
|
} |
|
|
|
|
|
|
|
case LOGNEG: |
|
|
|
return (u_stmtType) (! op1); |
|
|
|
return (u_stmtType)(! op1); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
static |
|
|
|
inline |
|
|
|
u_stmtType |
|
|
|
stmtCastInt (s_stmt * stmt, s_block * actBlock) |
|
|
|
stmtCastInt(s_stmt * stmt, s_block * actBlock) |
|
|
|
{ |
|
|
|
s_stmtQueue * args = stmt->sQueue; |
|
|
|
s_expVal * op = stmtDo (stmtQueueGet (args, 0), actBlock).eVal, |
|
|
|
* ret; |
|
|
|
s_expVal * op = stmtDo(stmtQueueGet(args, 0), actBlock).eVal, |
|
|
|
* ret; |
|
|
|
|
|
|
|
ret = castExprToInt (op); |
|
|
|
ret = castExprToInt(op); |
|
|
|
|
|
|
|
if (op != NULL) expValueFree (op); |
|
|
|
if (op != NULL) expValueFree(op); |
|
|
|
|
|
|
|
return (u_stmtType) ret; |
|
|
|
return (u_stmtType)ret; |
|
|
|
} |
|
|
|
|
|
|
|
static |
|
|
|
inline |
|
|
|
u_stmtType |
|
|
|
stmtCastFloat (s_stmt * stmt, s_block * actBlock) |
|
|
|
stmtCastFloat(s_stmt * stmt, s_block * actBlock) |
|
|
|
{ |
|
|
|
s_stmtQueue * args = stmt->sQueue; |
|
|
|
s_expVal * op = stmtDo (stmtQueueGet (args, 0), actBlock).eVal, |
|
|
|
* ret; |
|
|
|
|
|
|
|
ret = castExprToFloat (op); |
|
|
|
ret = castExprToFloat(op); |
|
|
|
|
|
|
|
if (op != NULL) expValueFree (op); |
|
|
|
if (op != NULL) expValueFree(op); |
|
|
|
|
|
|
|
return (u_stmtType) ret; |
|
|
|
return (u_stmtType)ret; |
|
|
|
} |
|
|
|
|
|
|
|
static |
|
|
|
inline |
|
|
|
u_stmtType |
|
|
|
stmtCastString (s_stmt * stmt, s_block * actBlock) |
|
|
|
stmtCastString(s_stmt * stmt, s_block * actBlock) |
|
|
|
{ |
|
|
|
s_stmtQueue * args = stmt->sQueue; |
|
|
|
s_expVal * op = stmtDo (stmtQueueGet (args, 0), actBlock).eVal, |
|
|
|
* ret; |
|
|
|
s_expVal * op = stmtDo(stmtQueueGet (args, 0), actBlock).eVal, |
|
|
|
* ret; |
|
|
|
|
|
|
|
ret = castExprToString (op); |
|
|
|
ret = castExprToString(op); |
|
|
|
|
|
|
|
if (op != NULL) expValueFree (op); |
|
|
|
if (op != NULL) expValueFree(op); |
|
|
|
|
|
|
|
return (u_stmtType) ret; |
|
|
|
return (u_stmtType)ret; |
|
|
|
} |
|
|
|
|
|
|
|
static |
|
|
|
inline |
|
|
|
u_stmtType |
|
|
|
stmtBlock (s_stmt * stmt, s_block * actBlock) |
|
|
|
stmtBlock(s_stmt * stmt, s_block * actBlock) |
|
|
|
{ |
|
|
|
unsigned int i; |
|
|
|
|
|
|
|
s_stmtQueue * gIds = stmtQueueGet (stmt->sQueue, 0)->sQueue; |
|
|
|
s_stmtQueue * args = stmtQueueGet (stmt->sQueue, 1)->sQueue; |
|
|
|
s_stmtQueue * gIds = stmtQueueGet(stmt->sQueue, 0)->sQueue; |
|
|
|
s_stmtQueue * args = stmtQueueGet(stmt->sQueue, 1)->sQueue; |
|
|
|
s_block * gBlock = NULL; |
|
|
|
|
|
|
|
gBlock = actBlock = blockPush (&actBlock, blockNew (args)); |
|
|
|
gBlock = actBlock = blockPush(&actBlock, blockNew (args)); |
|
|
|
|
|
|
|
/* find the global block */ |
|
|
|
while (blockPrev (gBlock) != NULL) |
|
|
|
gBlock = blockPrev (gBlock); |
|
|
|
|
|
|
|
if (gIds != NULL) |
|
|
|
{ |
|
|
|
for (i = 0; i < stmtQueueGetSize (gIds); i++) |
|
|
|
{ |
|
|
|
s_expVal * tmp = stmtDo (stmtQueueGet (gIds, i), actBlock).eVal; |
|
|
|
while (blockPrev(gBlock) != NULL) |
|
|
|
gBlock = blockPrev(gBlock); |
|
|
|
|
|
|
|
if (gIds != NULL) { |
|
|
|
for (i=0; i < stmtQueueGetSize(gIds); i++) { |
|
|
|
s_expVal * tmp = stmtDo(stmtQueueGet (gIds, i), actBlock).eVal; |
|
|
|
char * _id; |
|
|
|
s_ident * id; |
|
|
|
|
|
|
|
if (tmp == NULL) |
|
|
|
exitError (0); |
|
|
|
if (tmp == NULL) exitError (0); |
|
|
|
|
|
|
|
_id = expValueString (tmp); |
|
|
|
id = identListSeekKey (blockGetIdl (gBlock), _id); |
|
|
|
expValueFree (tmp); |
|
|
|
free (_id); |
|
|
|
_id = expValueString(tmp); |
|
|
|
id = identListSeekKey(blockGetIdl (gBlock), _id); |
|
|
|
expValueFree(tmp); |
|
|
|
free(_id); |
|
|
|
|
|
|
|
if (id == NULL) |
|
|
|
exitError (0); |
|
|
|
if (id == NULL) exitError (0); |
|
|
|
|
|
|
|
blockSetNonLocalId (gBlock, id); |
|
|
|
blockSetNonLocalId(gBlock, id); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
blockDo (actBlock); |
|
|
|
blockFree (actBlock); |
|
|
|
blockDo(actBlock); |
|
|
|
blockFree(actBlock); |
|
|
|
|
|
|
|
return (u_stmtType) 0; |
|
|
|
return (u_stmtType)0; |
|
|
|
} |
|
|
|
|
|
|
|
static |
|
|
|
inline |
|
|
|
u_stmtType |
|
|
|
stmtIf (s_stmt * stmt, s_block * actBlock) |
|
|
|
stmtIf(s_stmt * stmt, s_block * actBlock) |
|
|
|
{ |
|
|
|
s_stmtQueue * args = stmt->sQueue; |
|
|
|
int cond = stmtDo (stmtQueueGet (args, 0), actBlock).cond; |
|
|
|
int cond = stmtDo(stmtQueueGet (args, 0), actBlock).cond; |
|
|
|
s_stmt * _do; |
|
|
|
|
|
|
|
if (cond) |
|
|
|
_do = stmtQueueGet (args, 1); |
|
|
|
else |
|
|
|
_do = stmtQueueGet (args, 2); |
|
|
|
if (cond) _do = stmtQueueGet(args, 1); |
|
|
|
else _do = stmtQueueGet(args, 2); |
|
|
|
|
|
|
|
if (_do != NULL) |
|
|
|
stmtDo (_do, actBlock); |
|
|
|
if (_do != NULL) stmtDo(_do, actBlock); |
|
|
|
|
|
|
|
return (u_stmtType) 0; |
|
|
|
return (u_stmtType)0; |
|
|
|
} |
|
|
|
|
|
|
|
static |
|
|
|
inline |
|
|
|
u_stmtType |
|
|
|
stmtForeach (s_stmt * stmt, s_block * actBlock) |
|
|
|
stmtForeach(s_stmt * stmt, s_block * actBlock) |
|
|
|
{ |
|
|
|
s_stmtQueue * args = stmt->sQueue; |
|
|
|
s_expVal * _id = stmtDo (stmtQueueGet (args, 0), actBlock).eVal, |
|
|
|
* _key = stmtDo (stmtQueueGet (args, 1), actBlock).eVal, |
|
|
|
* _val = stmtDo (stmtQueueGet (args, 2), actBlock).eVal; |
|
|
|
char * id = expValueString (_id); |
|
|
|
char * key = expValueString (_key); |
|
|
|
char * val = expValueString (_val); |
|
|
|
|
|
|
|
printf ("[DEBUG]found foreach statement: id=%s, key=%s, val=%s\n", |
|
|
|
s_expVal * _id = stmtDo(stmtQueueGet (args, 0), actBlock).eVal, |
|
|
|
* _key = stmtDo(stmtQueueGet (args, 1), actBlock).eVal, |
|
|
|
* _val = stmtDo(stmtQueueGet (args, 2), actBlock).eVal; |
|
|
|
char * id = expValueString(_id); |
|
|
|
char * key = expValueString(_key); |
|
|
|
char * val = expValueString(_val); |
|
|
|
|
|
|
|
printf("[DEBUG]found foreach statement: id=%s, key=%s, val=%s\n", |
|
|
|
id, key, val); |
|
|
|
|
|
|
|
free (id); |
|
|
|
free (key); |
|
|
|
free (val); |
|
|
|
free(id); |
|
|
|
free(key); |
|
|
|
free(val); |
|
|
|
|
|
|
|
expValueFree (_id); |
|
|
|
expValueFree (_key); |
|
|
|
expValueFree (_val); |
|
|
|
expValueFree(_id); |
|
|
|
expValueFree(_key); |
|
|
|
expValueFree(_val); |
|
|
|
|
|
|
|
return (u_stmtType) 0; |
|
|
|
return (u_stmtType)0; |
|
|
|
} |
|
|
|
|
|
|
|
static |
|
|
|
inline |
|
|
|
u_stmtType |
|
|
|
stmtRepeat (s_stmt * stmt, s_block * actBlock) |
|
|
|
stmtRepeat(s_stmt * stmt, s_block * actBlock) |
|
|
|
{ |
|
|
|
s_stmtQueue * args = stmt->sQueue; |
|
|
|
s_expVal * _id = stmtDo (stmtQueueGet (args, 0), actBlock).eVal, |
|
|
|
* _count = stmtDo (stmtQueueGet (args, 1), actBlock).eVal; |
|
|
|
char * id = expValueString (_id); |
|
|
|
int count = expValueInt (_count); |
|
|
|
s_expVal * _id = stmtDo(stmtQueueGet (args, 0), actBlock).eVal, |
|
|
|
* _count = stmtDo(stmtQueueGet (args, 1), actBlock).eVal; |
|
|
|
char * id = expValueString(_id); |
|
|
|
int count = expValueInt(_count); |
|
|
|
|
|
|
|
printf ("[DEBUG]found repeat statement: id=%s, count=%d\n", id, count); |
|
|
|
printf("[DEBUG]found repeat statement: id=%s, count=%d\n", id, count); |
|
|
|
|
|
|
|
free (id); |
|
|
|
free(id); |
|
|
|
|
|
|
|
expValueFree (_id); |
|
|
|
expValueFree (_count); |
|
|
|
expValueFree(_id); |
|
|
|
expValueFree(_count); |
|
|
|
|
|
|
|
return (u_stmtType) 0; |
|
|
|
return (u_stmtType)0; |
|
|
|
} |
|
|
|
|
|
|
|
/* |
|
|
|
* Interface |
|
|
|
*/ |
|
|
|
s_stmt * |
|
|
|
stmtNew (int id, s_stmtQueue * queue, int conTyp, u_stmtType con) |
|
|
|
stmtNew(int id, s_stmtQueue * queue, int conTyp, u_stmtType con) |
|
|
|
{ |
|
|
|
s_stmt * new = (s_stmt *) malloc (sizeof (s_stmt)); |
|
|
|
s_stmt * new = (s_stmt *)malloc(sizeof(s_stmt)); |
|
|
|
|
|
|
|
new->sId = id; |
|
|
|
new->sQueue = queue; |
|
|
|
@ -379,82 +367,102 @@ stmtNew (int id, s_stmtQueue * queue, int conTyp, u_stmtType con) |
|
|
|
} |
|
|
|
|
|
|
|
s_stmtQueue * |
|
|
|
stmtGetArgs (s_stmt * stmt) |
|
|
|
stmtGetArgs(s_stmt * stmt) |
|
|
|
{ |
|
|
|
return stmt->sQueue; |
|
|
|
} |
|
|
|
|
|
|
|
u_stmtType |
|
|
|
stmtGetVal (s_stmt * stmt) |
|
|
|
stmtGetVal(s_stmt * stmt) |
|
|
|
{ |
|
|
|
return stmt->sConst; |
|
|
|
} |
|
|
|
|
|
|
|
int |
|
|
|
stmtGetConstTyp (s_stmt * stmt) |
|
|
|
stmtGetConstTyp(s_stmt * stmt) |
|
|
|
{ |
|
|
|
return stmt->sConstTyp; |
|
|
|
} |
|
|
|
|
|
|
|
void |
|
|
|
stmtFree (s_stmt * stmt) |
|
|
|
stmtFree(s_stmt * stmt) |
|
|
|
{ |
|
|
|
if (stmt == NULL) |
|
|
|
return; |
|
|
|
|
|
|
|
switch (stmt->sConstTyp) |
|
|
|
{ |
|
|
|
case STYP_NONE: stmtQueueFree (stmt->sQueue); break; |
|
|
|
case STYP_EVAL: expValueFree (stmt->sConst.eVal); break; |
|
|
|
case STYP_IDVAL: identFree (stmt->sConst.idVal); break; |
|
|
|
if (stmt == NULL) return; |
|
|
|
|
|
|
|
switch(stmt->sConstTyp) { |
|
|
|
case STYP_NONE: stmtQueueFree (stmt->sQueue); break; |
|
|
|
case STYP_EVAL: expValueFree (stmt->sConst.eVal); break; |
|
|
|
case STYP_IDVAL: identFree (stmt->sConst.idVal); break; |
|
|
|
} |
|
|
|
|
|
|
|
free (stmt); |
|
|
|
free(stmt); |
|
|
|
} |
|
|
|
|
|
|
|
u_stmtType |
|
|
|
stmtDo (s_stmt * stmt, s_block * actBlock) |
|
|
|
stmtDo(s_stmt * stmt, s_block * actBlock) |
|
|
|
{ |
|
|
|
if (stmt == NULL) |
|
|
|
return (u_stmtType) 0; |
|
|
|
|
|
|
|
switch (stmt->sId) |
|
|
|
{ |
|
|
|
case STMT_CONST: return (u_stmtType) expValueClone (stmt->sConst.eVal); |
|
|
|
case STMT_BLOCK: return stmtBlock (stmt, actBlock); |
|
|
|
|
|
|
|
case STMT_PRINT: return stmtPrint (stmt, actBlock); |
|
|
|
case STMT_IF: return stmtIf (stmt, actBlock); |
|
|
|
case STMT_FOREACH: return stmtForeach (stmt, actBlock); |
|
|
|
case STMT_REPEAT: return stmtRepeat (stmt, actBlock); |
|
|
|
case STMT_ASSIGN: return stmtAssign (stmt, actBlock); |
|
|
|
case STMT_UNSET: return (u_stmtType) 0; |
|
|
|
|
|
|
|
case STMT_EVAL_PLUS: return stmtEval (stmt, actBlock, PLUS); |
|
|
|
case STMT_EVAL_MINUS: return stmtEval (stmt, actBlock, MINUS); |
|
|
|
case STMT_EVAL_TIMES: return stmtEval (stmt, actBlock, TIMES); |
|
|
|
case STMT_EVAL_OVER: return stmtEval (stmt, actBlock, OVER); |
|
|
|
case STMT_EVAL_MODULO: return stmtEval (stmt, actBlock, MODULO); |
|
|
|
case STMT_EVAL_NEG: return stmtEval (stmt, actBlock, NEG); |
|
|
|
|
|
|
|
case STMT_IDENT_VAR: return stmtIdentVar (stmt, actBlock); |
|
|
|
case STMT_IDENT_ARRAY: return stmtIdentArray (stmt, actBlock); |
|
|
|
case STMT_IDENT_VAL: return stmtIdentVal (stmt, actBlock); |
|
|
|
|
|
|
|
case STMT_CAST_INT: return stmtCastInt (stmt, actBlock); |
|
|
|
case STMT_CAST_FLOAT: return stmtCastFloat (stmt, actBlock); |
|
|
|
case STMT_CAST_STRING: return stmtCastString (stmt, actBlock); |
|
|
|
|
|
|
|
case STMT_COMP_EQ: return stmtEvalComp (stmt, actBlock, EQ); |
|
|
|
case STMT_COMP_NE: return stmtEvalComp (stmt, actBlock, NE); |
|
|
|
case STMT_COMP_LT: return stmtEvalComp (stmt, actBlock, LT); |
|
|
|
case STMT_COMP_GT: return stmtEvalComp (stmt, actBlock, GT); |
|
|
|
case STMT_COMP_LE: return stmtEvalComp (stmt, actBlock, LE); |
|
|
|
case STMT_COMP_GE: return stmtEvalComp (stmt, actBlock, GE); |
|
|
|
|
|
|
|
case STMT_COND_EXPR: return stmtEvalCondExpr (stmt, actBlock); |
|
|
|
case STMT_COND_AND: return stmtEvalCond (stmt, actBlock, LOGAND); |
|
|
|
case STMT_COND_OR: return stmtEvalCond (stmt, actBlock, LOGOR); |
|
|
|
case STMT_COND_NEG: return stmtEvalCond (stmt, actBlock, LOGNEG); |
|
|
|
if (stmt == NULL) return (u_stmtType)0; |
|
|
|
|
|
|
|
switch (stmt->sId) { |
|
|
|
case STMT_CONST: |
|
|
|
return (u_stmtType)expValueClone(stmt->sConst.eVal); |
|
|
|
case STMT_BLOCK: |
|
|
|
return stmtBlock(stmt, actBlock); |
|
|
|
case STMT_PRINT: |
|
|
|
return stmtPrint(stmt, actBlock); |
|
|
|
case STMT_IF: |
|
|
|
return stmtIf(stmt, actBlock); |
|
|
|
case STMT_FOREACH: |
|
|
|
return stmtForeach(stmt, actBlock); |
|
|
|
case STMT_REPEAT: |
|
|
|
return stmtRepeat(stmt, actBlock); |
|
|
|
case STMT_ASSIGN: |
|
|
|
return stmtAssign(stmt, actBlock); |
|
|
|
case STMT_UNSET: |
|
|
|
return (u_stmtType)0; |
|
|
|
case STMT_EVAL_PLUS: |
|
|
|
return stmtEval(stmt, actBlock, PLUS); |
|
|
|
case STMT_EVAL_MINUS: |
|
|
|
return stmtEval(stmt, actBlock, MINUS); |
|
|
|
case STMT_EVAL_TIMES: |
|
|
|
return stmtEval(stmt, actBlock, TIMES); |
|
|
|
case STMT_EVAL_OVER: |
|
|
|
return stmtEval(stmt, actBlock, OVER); |
|
|
|
case STMT_EVAL_MODULO: |
|
|
|
return stmtEval(stmt, actBlock, MODULO); |
|
|
|
case STMT_EVAL_NEG: |
|
|
|
return stmtEval(stmt, actBlock, NEG); |
|
|
|
case STMT_IDENT_VAR: |
|
|
|
return stmtIdentVar(stmt, actBlock); |
|
|
|
case STMT_IDENT_ARRAY: |
|
|
|
return stmtIdentArray(stmt, actBlock); |
|
|
|
case STMT_IDENT_VAL: |
|
|
|
return stmtIdentVal(stmt, actBlock); |
|
|
|
case STMT_CAST_INT: |
|
|
|
return stmtCastInt(stmt, actBlock); |
|
|
|
case STMT_CAST_FLOAT: |
|
|
|
return stmtCastFloat(stmt, actBlock); |
|
|
|
case STMT_CAST_STRING: |
|
|
|
return stmtCastString(stmt, actBlock); |
|
|
|
case STMT_COMP_EQ: |
|
|
|
return stmtEvalComp(stmt, actBlock, EQ); |
|
|
|
case STMT_COMP_NE: |
|
|
|
return stmtEvalComp(stmt, actBlock, NE); |
|
|
|
case STMT_COMP_LT: |
|
|
|
return stmtEvalComp(stmt, actBlock, LT); |
|
|
|
case STMT_COMP_GT: |
|
|
|
return stmtEvalComp(stmt, actBlock, GT); |
|
|
|
case STMT_COMP_LE: |
|
|
|
return stmtEvalComp(stmt, actBlock, LE); |
|
|
|
case STMT_COMP_GE: |
|
|
|
return stmtEvalComp(stmt, actBlock, GE); |
|
|
|
case STMT_COND_EXPR: |
|
|
|
return stmtEvalCondExpr(stmt, actBlock); |
|
|
|
case STMT_COND_AND: |
|
|
|
return stmtEvalCond(stmt, actBlock, LOGAND); |
|
|
|
case STMT_COND_OR: |
|
|
|
return stmtEvalCond(stmt, actBlock, LOGOR); |
|
|
|
case STMT_COND_NEG: |
|
|
|
return stmtEvalCond(stmt, actBlock, LOGNEG); |
|
|
|
} |
|
|
|
} |
