ghopp
/
tepal
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

some code cleanups

master
Georg Hopp 10 years ago
parent
933d4d7bc7
commit
5bf810a4a4
29 changed files with 1203 additions and 1312 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 1
      include/block.h
  2. 1
      include/expValue.h
  3. 3
      src/assign.c
  4. 61
      src/bbtree.c
  5. 4
      src/block.c
  6. 25
      src/evalCond.c
  7. 41
      src/evalExpr.c
  8. 23
      src/expValue.c
  9. 25
      src/ident.c
  10. 48
      src/identList.c
  11. 146
      src/statement.c
  12. 14
      src/stmtQueue.c
  13. 15
      src/tepal.c
  14. 69
      src/tepal_pars.y
  15. 108
      src/tepal_scan.l
  16. 1
      src/variable.c

1
include/block.h
View File

@ -16,4 +16,5 @@ s_stmtQueue * blockStmts (s_block *);
s_identList * blockIdl(s_block *);
s_identList * blockGetIdl(s_block *);
#endif /* _BLOCK_H_ */

1
include/expValue.h
View File

@ -27,5 +27,4 @@ char * expValueString (s_expVal *);
/* analyse expValue */
int expValueGetType(s_expVal *);
#endif /* _EXP_VALUE_H_ */

3
src/assign.c
View File

@ -10,8 +10,7 @@
s_expVal *
assign(s_ident * to, s_expVal * from)
{
if (identGetType (to) == ID_TYP_IDL)
{
if (identGetType (to) == ID_TYP_IDL) {
char * key = identGetKey(to);
exitError(ERR_NO_INDEX, key);
}

61
src/bbtree.c
View File

@ -8,7 +8,6 @@
#include <helper.h>
#include <bbtree.h>
/*
* statisch Funktionen
*/
@ -33,14 +32,12 @@ bbTreeNodeFree (s_bbTreeNode * t)
if (t == NULL)
return;
while (t->left != NULL)
{
while (t->left != NULL) {
bbTreeNodeFree(t->left);
t->left = NULL;
}
while (t->right != NULL)
{
while (t->right != NULL) {
bbTreeNodeFree(t->right);
t->right = NULL;
}
@ -94,17 +91,15 @@ static
void
bbTreeNodeBalance(s_bbTreeNode * node)
{
if (BBTREE_AVL (node) == -2)
if (BBTREE_AVL(node) == -2) {
/* left is to long */
{
if (BBTREE_AVL(node->left) == 1)
bbTreeNodeRotLeft(node->left);
bbTreeNodeRotRight(node);
}
if (BBTREE_AVL (node) == -2)
if (BBTREE_AVL(node) == -2) {
/* right is to long */
{
if (BBTREE_AVL(node->right) == 1)
bbTreeNodeRotRight(node->right);
bbTreeNodeRotLeft(node);
@ -122,26 +117,23 @@ bbTreeNodeInsert (s_bbTreeNode ** _node, t_bbTreeCmp cmp, void * value)
s_bbTreeNode * node = *_node;
s_bbTreeNode * ret;
if (node == NULL)
if (node == NULL) {
/* This happens only when bbTree::root is NULL
* on bbTreeInsert call */
{
*_node = bbTreeNodeNew(value);
return NULL;
}
if (cmp (value, node->value) == 0)
if (cmp(value, node->value) == 0) {
/* The key is already in the tree.
* In this case a node containing the old value is returned. */
{
ret = bbTreeNodeNew(node->value);
node->value = value;
return ret;
}
if (cmp (value, node->value) < 0)
if (node->left == NULL)
{
if (cmp(value, node->value) < 0) {
if (node->left == NULL) {
node->left = bbTreeNodeNew(value);
ret = NULL;
@ -151,12 +143,13 @@ bbTreeNodeInsert (s_bbTreeNode ** _node, t_bbTreeCmp cmp, void * value)
node->height = 1 + MAX(
BBTREE_LEFT_HEIGHT(node), BBTREE_RIGHT_HEIGHT(node));
}
else
else {
ret = bbTreeNodeInsert(&node->left, cmp, value);
}
}
if (cmp (value, node->value) > 0)
if (node->right == NULL)
{
if (cmp(value, node->value) > 0) {
if (node->right == NULL) {
node->right = bbTreeNodeNew(value);
ret = NULL;
@ -166,8 +159,10 @@ bbTreeNodeInsert (s_bbTreeNode ** _node, t_bbTreeCmp cmp, void * value)
node->height = 1 + MAX(
BBTREE_LEFT_HEIGHT(node), BBTREE_RIGHT_HEIGHT(node));
}
else
else {
ret = bbTreeNodeInsert(&node->right, cmp, value);
}
}
/* if we come here a new node was inserted a returned node
* containing {NULL, NULL} as value reflects this fact. */
@ -243,19 +238,16 @@ bbTreeNodeRemove (s_bbTreeNode ** _node, t_bbTreeCmp cmp, void * value)
if (node == NULL)
return NULL;
if (cmp (value, node->value) == 0)
if (cmp (value, node->value) == 0) {
/* found the element left */
{
if (node->left == NULL && node->right == NULL)
if (node->left == NULL && node->right == NULL) {
/* found a leaf */
{
ret = bbTreeNodeNew(node->value);
free(node);
*_node = NULL;
}
else if (node->left != NULL && node->left != NULL)
else if (node->left != NULL && node->left != NULL) {
/* left & right subtree exists use either max(left) or min(right) */
{
s_bbTreeNode * maxLeft;
maxLeft = bbTreeNodeMax(node->left);
@ -268,22 +260,19 @@ bbTreeNodeRemove (s_bbTreeNode ** _node, t_bbTreeCmp cmp, void * value)
node->height = 1 + MAX(
BBTREE_LEFT_HEIGHT(node), BBTREE_RIGHT_HEIGHT(node));
}
else if ((node->left == NULL) != (node->right == NULL) /* ^^ */)
else if ((node->left == NULL) != (node->right == NULL) /* ^^ */) {
/* there is only one subtree */
/* This subtree must be a leaf, because the tree is balanced */
{
ret = bbTreeNodeNew(node->value);
if (node->left != NULL)
if (node->left != NULL) {
/* found left node */
{
node->value = node->left->value;
free(node->left);
node->left = NULL;
}
else
else {
/* found right node */
{
node->value = node->right->value;
free(node->right);
node->right = NULL;
@ -343,8 +332,7 @@ bbTreeInsert (s_bbTree * t, void * value)
{
s_bbTreeNode * oldNode = bbTreeNodeInsert(&t->root, t->cmp, value);
if (oldNode != NULL)
{
if (oldNode != NULL) {
value = oldNode->value;
free(oldNode);
@ -367,8 +355,7 @@ bbTreeRemove (s_bbTree * t, void * value)
{
s_bbTreeNode * oldNode = bbTreeNodeRemove(&t->root, t->cmp, value);
if (oldNode != NULL)
{
if (oldNode != NULL) {
value = oldNode->value;
free(oldNode);

4
src/block.c
View File

@ -17,6 +17,7 @@ blockGetIdl (s_block * block)
{
return block->idl;
}
s_block *
blockNew(s_stmtQueue * stmts)
{
@ -54,9 +55,7 @@ blockSetNonLocalId (s_block * bs, s_ident * id)
blockPush(s_block ** bs, s_block * new)
{
new->prev = *bs;
*bs = new;
return *bs;
}
@ -65,7 +64,6 @@ blockPop (s_block ** bs)
{
s_block * ret = *bs;
*bs = (*bs)->prev;
return ret;
}

25
src/evalCond.c
View File

@ -17,8 +17,7 @@ evalIntComp (int op, s_expVal * _op1, s_expVal * _op2)
long op1 = expValueInt(_op1);
long op2 = expValueInt(_op2);
switch (op)
{
switch (op) {
case EQ: return (op1 == op2);
case NE: return (op1 != op2);
case LT: return (op1 < op2);
@ -35,8 +34,7 @@ evalFloatComp (int op, s_expVal * _op1, s_expVal * _op2)
double op1 = expValueFloat(_op1);
double op2 = expValueFloat(_op2);
switch (op)
{
switch (op) {
case EQ: return (op1 == op2);
case NE: return (op1 != op2);
case LT: return (op1 < op2);
@ -54,8 +52,7 @@ evalStringComp (int op, s_expVal * _op1, s_expVal * _op2)
char * op2 = expValueString(_op2);
long ret;
switch (op)
{
switch (op) {
case EQ: ret = (! strcmp(op1, op2));
case NE: ret = strcmp(op1, op2);
case LT: ret = (strcmp(op1, op2) < 0) ? 1 : 0;
@ -78,17 +75,16 @@ evalStringComp (int op, s_expVal * _op1, s_expVal * _op2)
int
evalCondExpr(s_expVal * _op)
{
switch (expValueGetType (_op))
{
case EXP_TYP_INT: return expValueInt (_op);
case EXP_TYP_FLOAT: return expValueInt (_op);
switch (expValueGetType(_op)) {
case EXP_TYP_INT:
return expValueInt(_op);
case EXP_TYP_FLOAT:
return expValueInt(_op);
case EXP_TYP_STRING:
{
char * op = expValueString(_op);
long ret = strlen(op);
free(op);
return ret;
}
}
@ -99,14 +95,11 @@ evalCondExpr (s_expVal * _op)
int
evalComp(int op, s_expVal * op1, s_expVal * op2)
{
switch (expValueGetType (op1))
{
switch (expValueGetType(op1)) {
case EXP_TYP_INT:
return evalIntComp(op, op1, op2);
case EXP_TYP_FLOAT:
return evalFloatComp(op, op1, op2);
case EXP_TYP_STRING:
return evalStringComp(op, op1, op2);
}

41
src/evalExpr.c
View File

@ -20,8 +20,8 @@ stringPlus (s_expVal * _op1, s_expVal * _op2)
s_expVal * ret;
char * op1 = expValueString (_op1);
char * op2 = expValueString (_op2);
char * retVal = (char *) malloc (
sizeof (char) * (strlen (op1) + strlen (op2) + 1));
char * retVal =
(char *)malloc(sizeof(char) * (strlen(op1) + strlen(op2) + 1));
strcpy(retVal, op1);
strcat(retVal, op2);
@ -45,8 +45,7 @@ stringNeg (s_expVal * _op)
char * op = expValueString(_op);
int len = strlen(op) - 1;
for (i=0; i<=(len/2); i++)
{
for (i=0; i<=(len/2); i++) {
char tmp = op[i];
op[i] = op[len-i];
op[len-i] = tmp;
@ -67,22 +66,18 @@ evalIntExp (int op, s_expVal * _op1, s_expVal * _op2)
if (op == NEG) return expValueIntNew(- op1);
switch (expValueGetType (_op2))
{
switch (expValueGetType(_op2)) {
case EXP_TYP_INT:
case EXP_TYP_FLOAT:
switch (op)
{
switch (op) {
case PLUS: return expValueIntNew(op1 + op2);
case MINUS: return expValueIntNew(op1 - op2);
case TIMES: return expValueIntNew(op1 * op2);
case OVER: return expValueIntNew(op1 / op2);
case MODULO: return expValueIntNew(op1 % op2);
}
case EXP_TYP_STRING:
if (op == PLUS)
return stringPlus (_op1, _op2);
if (op == PLUS) return stringPlus(_op1, _op2);
exitError(ERR_STRING_OPERATOR, op);
}
}
@ -97,22 +92,18 @@ evalFloatExp (int op, s_expVal * _op1, s_expVal * _op2)
if (op == NEG) return expValueFloatNew(- op1);
switch (expValueGetType (_op2))
{
switch (expValueGetType(_op2)) {
case EXP_TYP_INT:
case EXP_TYP_FLOAT:
switch (op)
{
switch (op) {
case MODULO: exitError(ERR_FLOAT_OPERATOR, op);
case PLUS: return expValueFloatNew(op1 + op2);
case MINUS: return expValueFloatNew(op1 - op2);
case TIMES: return expValueFloatNew(op1 * op2);
case OVER: return expValueFloatNew(op1 / op2);
}
case EXP_TYP_STRING:
if (op == PLUS)
return stringPlus (_op1, _op2);
if (op == PLUS) return stringPlus(_op1, _op2);
exitError(ERR_STRING_OPERATOR, op);
}
}
@ -125,21 +116,15 @@ evalFloatExp (int op, s_expVal * _op1, s_expVal * _op2)
s_expVal *
evalExpr(int op, s_expVal * op1, s_expVal * op2)
{
switch (expValueGetType (op1))
{
switch (expValueGetType(op1)) {
case EXP_TYP_INT:
return evalIntExp(op, op1, op2);
case EXP_TYP_FLOAT:
if (op != MODULO)
return evalFloatExp (op, op1, op2);
if (op != MODULO) return evalFloatExp(op, op1, op2);
exitError (ERR_FLOAT_OPERATOR, op);
case EXP_TYP_STRING:
if (op == PLUS)
return stringPlus (op1, op2);
if (op == NEG)
return stringNeg (op1);
if (op == PLUS) return stringPlus(op1, op2);
if (op == NEG) return stringNeg(op1);
exitError(ERR_STRING_OPERATOR, op);
}
}

23
src/expValue.c
View File

@ -62,10 +62,11 @@ expValueClone (s_expVal * eVal)
ret->type = eVal->type;
switch (eVal->type)
{
case EXP_TYP_INT: ret->val.iVal = eVal->val.iVal; break;
case EXP_TYP_FLOAT: ret->val.fVal = eVal->val.fVal; break;
switch (eVal->type) {
case EXP_TYP_INT:
ret->val.iVal = eVal->val.iVal; break;
case EXP_TYP_FLOAT:
ret->val.fVal = eVal->val.fVal; break;
case EXP_TYP_STRING:
{
ret->val.cPtr = (char *)malloc(
@ -80,8 +81,7 @@ expValueClone (s_expVal * eVal)
void
expValueFree(s_expVal * eVal)
{
if (eVal->type == EXP_TYP_STRING)
free (eVal->val.cPtr);
if (eVal->type == EXP_TYP_STRING) free(eVal->val.cPtr);
free(eVal);
}
@ -92,8 +92,7 @@ expValueFree (s_expVal * eVal)
long
expValueInt(s_expVal * eVal)
{
switch (eVal->type)
{
switch (eVal->type) {
case EXP_TYP_INT: return eVal->val.iVal;
case EXP_TYP_FLOAT: return (long)eVal->val.fVal;
case EXP_TYP_STRING: return atoi(eVal->val.cPtr);
@ -103,8 +102,7 @@ expValueInt (s_expVal * eVal)
double
expValueFloat(s_expVal * eVal)
{
switch (eVal->type)
{
switch (eVal->type) {
case EXP_TYP_INT: return (double) eVal->val.iVal;
case EXP_TYP_FLOAT: return eVal->val.fVal;
case EXP_TYP_STRING: return atof(eVal->val.cPtr);
@ -117,20 +115,17 @@ expValueString (s_expVal * eVal)
char buf[40];
char * ret = NULL;
switch (eVal->type)
{
switch (eVal->type) {
case EXP_TYP_INT:
sprintf(buf, "%d", eVal->val.iVal);
ret = (char*)malloc(sizeof(char) * (strlen(buf) + 1));
strcpy(ret, buf);
break;
case EXP_TYP_FLOAT:
sprintf(buf, "%f", eVal->val.fVal);
ret = (char*)malloc(sizeof(char) * (strlen(buf) + 1));
strcpy(ret, buf);
break;
case EXP_TYP_STRING:
ret = (char*)malloc(sizeof(char) * (strlen(eVal->val.cPtr) + 1));
strcpy(ret, eVal->val.cPtr);

25
src/ident.c
View File

@ -52,8 +52,7 @@ identNew (int idx, const char * key)
ident->key[0] = ID_TYP_UNDEF;
ident->key[1] = '\0';
if (key != NULL)
strcpy (ident->key + 1, key);
if (key != NULL) strcpy(ident->key + 1, key);
ident->queued = 0;
@ -107,8 +106,7 @@ identFree (s_ident * id)
printf("[!DEBUG!] identFree: %d/%s\n", id->idx, id->key);
#endif
switch (identGetType (id))
{
switch (identGetType(id)) {
case ID_TYP_EXP: expValueFree (id->val.base); break;
case ID_TYP_IDL: identListFree (id->val.idl); break;
}
@ -162,13 +160,9 @@ identExp (s_ident * id)
{
s_expVal * ret = NULL;
if (id == NULL)
exitError (ERR_UNDEF_VAR, identGetKey (id));
if (id == NULL) exitError (ERR_UNDEF_VAR, identGetKey (id));
if (identGetType (id) == ID_TYP_EXP)
{
ret = expValueClone (id->val.base);
}
if (identGetType (id) == ID_TYP_EXP) ret = expValueClone(id->val.base);
return ret;
}
@ -178,10 +172,7 @@ identIdl (s_ident * id)
{
s_identList * ret = NULL;
if (identGetType (id) == ID_TYP_IDL)
{
ret = id->val.idl;
}
if (identGetType(id) == ID_TYP_IDL) ret = id->val.idl;
return ret;
}
@ -189,8 +180,7 @@ identIdl (s_ident * id)
s_ident *
identSetExp(s_ident * id, s_expVal * val)
{
switch (identGetType (id))
{
switch (identGetType(id)) {
case ID_TYP_EXP: expValueFree(id->val.base); break;
case ID_TYP_IDL: identListFree(id->val.idl); break;
}
@ -204,8 +194,7 @@ identSetExp (s_ident * id, s_expVal * val)
s_ident *
identSetIdl(s_ident * id, s_identList * val)
{
switch (identGetType (id))
{
switch (identGetType (id)) {
case ID_TYP_EXP: expValueFree (id->val.base);
case ID_TYP_IDL: identListFree (id->val.idl);
}

48
src/identList.c
View File

@ -64,13 +64,13 @@ identListFree (s_identList * l)
s_ident ** idArray,
** _run;
for (_run = idArray = (s_ident **) identListToArray (l);
for (
_run = idArray = (s_ident **)identListToArray(l);
*_run != NULL;
_run++ )
{
identDequeue(*_run);
if (! identIsQueued (*_run))
identFree (*_run);
if (! identIsQueued(*_run)) identFree(*_run);
}
free(idArray);
@ -93,29 +93,27 @@ identListPutVal (s_identList * l, s_ident * val)
identEnqueue(val);
if ((idx < 0 && key[0] == '\0') || idx != -1 && key[0] != '\0')
if ((idx < 0 && key[0] == '\0') || idx != -1 && key[0] != '\0') {
/* calling error: either key or idx must be valid. But not both. */
return NULL;
}
if (idx >= 0)
oldVal = (s_ident *) bbTreeInsert (l->idIdx, val);
else
oldVal = (s_ident *) bbTreeInsert (l->idHash, val);
if (idx >= 0) oldVal = (s_ident*)bbTreeInsert(l->idIdx, val);
else oldVal = (s_ident*)bbTreeInsert(l->idHash, val);
if (oldVal != NULL)
if (oldVal != NULL) {
/*
* these are few lines with a lot behind them. The not obvious question
* here is: What happens if oldval points to the same address than val?
* well, this could only happen if val was was formally queued, because
* else oldVal would be NULL. Knowing this makes clear that the queue
* state is not changed at all, because first it was increased above with
* identEnqueue and the it will be decreased in this if block again. But as
* it was formally queued it will not be freed (Good)!
* these are few lines with a lot behind them. The not obvious
* question here is: What happens if oldval points to the same address
* than val? well, this could only happen if val was was formally
* queued, because else oldVal would be NULL. Knowing this makes clear
* that the queue state is not changed at all, because first it was
* increased above with identEnqueue and the it will be decreased in
* this if block again. But as it was formally queued it will not be
* freed (Good)!
*/
{
identDequeue(oldVal);
if (! identIsQueued (oldVal))
identFree (oldVal);
if (! identIsQueued(oldVal)) identFree(oldVal);
}
return val;
@ -157,11 +155,9 @@ identListRemoveByIdx (s_identList * l, int idx)
identFree(seek);
if (val != NULL)
{
if (val != NULL) {
identDequeue(val);
if (! identIsQueued (val))
identFree (val);
if (! identIsQueued(val)) identFree(val);
}
}
@ -177,11 +173,9 @@ identListRemoveByKey (s_identList * l, const char * key)
identFree(seek);
if (val != NULL)
{
if (val != NULL) {
identDequeue(val);
if (! identIsQueued (val))
identFree (val);
if (! identIsQueued(val)) identFree(val);
}
}

146
src/statement.c
View File

@ -59,14 +59,14 @@ stmtIdentVar (s_stmt * stmt, s_block * actBlock)
char * op = expValueString(_op);
s_block * run = actBlock;
while (ret == NULL && run != NULL)
{
while (ret == NULL && run != NULL) {
ret = identListSeekKey(blockIdl(run), op);
run = blockPrev(run);
}
if (ret == NULL)
if (ret == NULL) {
ret = identListPutVal(blockIdl(actBlock), identUndefNew(-1, op));
}
expValueFree(_op);
free(op);
@ -130,8 +130,7 @@ stmtAssign (s_stmt * stmt, s_block * actBlock)
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);
@ -148,8 +147,7 @@ stmtPrint (s_stmt * stmt, s_block * actBlock)
s_stmtQueue * args = stmt->sQueue;
s_expVal * op = stmtDo(stmtQueueGet(args, 0), actBlock).eVal;
if (op != NULL)
{
if (op != NULL) {
printExpr(op);
expValueFree(op);
}
@ -181,20 +179,17 @@ stmtEvalCond (s_stmt * stmt, s_block * actBlock, int op)
s_stmtQueue * args = stmt->sQueue;
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);
}
case LOGOR:
{
int op2 = stmtDo(stmtQueueGet(args, 1), actBlock).cond;
return (u_stmtType)(op1 || op2);
}
case LOGNEG:
return (u_stmtType)(! op1);
}
@ -265,24 +260,20 @@ stmtBlock (s_stmt * stmt, s_block * actBlock)
while (blockPrev(gBlock) != NULL)
gBlock = blockPrev(gBlock);
if (gIds != NULL)
{
for (i = 0; i < stmtQueueGetSize (gIds); i++)
{
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);
if (id == NULL)
exitError (0);
if (id == NULL) exitError (0);
blockSetNonLocalId(gBlock, id);
}
@ -303,13 +294,10 @@ stmtIf (s_stmt * stmt, s_block * actBlock)
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;
}
@ -399,11 +387,9 @@ stmtGetConstTyp (s_stmt * stmt)
void
stmtFree(s_stmt * stmt)
{
if (stmt == NULL)
return;
if (stmt == NULL) return;
switch (stmt->sConstTyp)
{
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;
@ -415,46 +401,68 @@ stmtFree (s_stmt * stmt)
u_stmtType
stmtDo(s_stmt * stmt, s_block * actBlock)
{
if (stmt == NULL)
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;
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);
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);
}
}

14
src/stmtQueue.c
View File

@ -56,8 +56,7 @@ stmtQueueFree (s_stmtQueue * sQueue)
{
unsigned int i;
if (sQueue == NULL)
return;
if (sQueue == NULL) return;
/* freeing the queue is the final step. All stmts should be freed too! */
for (i=0; i < sQueue->maxIdx; i++)
@ -82,7 +81,7 @@ stmtQueueEnqueue (s_stmtQueue * sQueue, s_stmt * stmt)
&(sQueue->stmts[sQueue->size]),
0,
sizeof(s_stmt**) * QUEUE_GROW_SIZE);
sQueue->size = newSize;;
sQueue->size = newSize;
}
sQueue->stmts[sQueue->maxIdx++] = stmt;
@ -101,10 +100,8 @@ stmtQueueDequeue (s_stmtQueue * sQueue)
s_stmt *
stmtQueueGet(s_stmtQueue * sQueue, unsigned int idx)
{
if (idx < sQueue->size)
return sQueue->stmts [idx];
else
return NULL;
if (idx < sQueue->size) return sQueue->stmts[idx];
else return NULL;
}
void
@ -112,8 +109,7 @@ stmtQueueDo (s_stmtQueue * sQueue)
{
int i;
if (sQueue == NULL)
return;
if (sQueue == NULL) return;
for (i = 0; i < sQueue->maxIdx; i++)
stmtDo(sQueue->stmts[i], NULL /* !!!FIXME: give me a sane value!!! */);

15
src/tepal.c
View File

@ -24,20 +24,16 @@ exitError (int errNum, ...)
va_start(ap, errNum);
switch (errNum)
{
switch (errNum) {
case ERR_UNDEF_VAR:
fprintf(stderr, tepalErrMsg[errNum], va_arg(ap, char *));
break;
case ERR_NO_INDEX:
fprintf(stderr, tepalErrMsg[errNum], va_arg(ap, char *));
break;
case ERR_STRING_OPERATOR:
fprintf(stderr, tepalErrMsg[errNum], va_arg(ap, int));
break;
case ERR_FLOAT_OPERATOR:
fprintf(stderr, tepalErrMsg[errNum], va_arg(ap, int));
break;
@ -50,10 +46,11 @@ exitError (int errNum, ...)
void
printExpr (s_expVal * val)
{
switch (expValueGetType (val))
{
case EXP_TYP_INT: printf ("%d", expValueInt (val)); break;
case EXP_TYP_FLOAT: printf ("%f", expValueFloat (val)); break;
switch (expValueGetType (val)) {
case EXP_TYP_INT:
printf("%d", expValueInt (val)); break;
case EXP_TYP_FLOAT:
printf("%f", expValueFloat (val)); break;
case EXP_TYP_STRING:
{
char * v = expValueString(val);

69
src/tepal_pars.y
View File

@ -118,8 +118,7 @@ genStringStmt (s_stmt * stmt, char * string)
char * new = NULL;
if (stmt != NULL)
{
if (stmt != NULL) {
char * old = expValueString (stmtGetVal (stmt).eVal);
size_t len = strlen (old) + strlen (string) + 1;
@ -130,8 +129,7 @@ genStringStmt (s_stmt * stmt, char * string)
stmtFree (stmt);
free (old);
}
else
{
else {
new = (char *)calloc (sizeof (char), strlen (string) + 1);
strcpy (new, string);
}
@ -419,41 +417,33 @@ genCastStringStmt (s_stmt * stmt)
%%
script : stmt_queue { astRoot = $1; }
;
script : stmt_queue { astRoot = $1; };
stmt_queue : stmt { $$ = enqStmt (NULL, $1); }
| stmt_queue stmt { $$ = enqStmt ($1, $2); }
;
| stmt_queue stmt { $$ = enqStmt ($1, $2); };
stmt : simple_stmt
| block_stmt
| if_stmt
| rep_stmt
| fore_stmt
| stmt_end stmt { $$ = $2; }
;
| stmt_end stmt { $$ = $2; };
simple_stmt : html stmt_end { $$ = genPrintStmt ($1); }
| expr stmt_end { $$ = genPrintStmt ($1); }
| assig stmt_end
;
| assig stmt_end;
html : HTML { $$ = genStringStmt (NULL, $1); }
| html HTML { $$ = genStringStmt ($1, $2); }
;
| html HTML { $$ = genStringStmt ($1, $2); };
stmt_end : STMT_END
| ';'
;
| ';';
block_stmt : ':' BLOCK_END { $$ = genBlockStmt (NULL); }
| ':' block_queue BLOCK_END { $$ = genBlockStmt ($2); }
;
| ':' block_queue BLOCK_END { $$ = genBlockStmt ($2); };
block_queue : stmt_queue { $$ = genBlockQue (NULL, $1); }
| gdecl_block stmt_queue { $$ = genBlockQue ($1, $2); }
;
| gdecl_block stmt_queue { $$ = genBlockQue ($1, $2); };
/*
* Here follows the definitions for the "globals definition block"
@ -462,58 +452,46 @@ block_queue : stmt_queue { $$ = genBlockQue (NULL, $1); }
* block a newline should not be interpreted as statmend-end.
* ------
*/
gdecl_block : GLOBAL ':' glob_decl BLOCK_END
{ $$ = $3; }
;
gdecl_block : GLOBAL ':' glob_decl BLOCK_END { $$ = $3; };
glob_decl : IDENT { $$ = enqGlobId (NULL, $1); }
| glob_decl ',' IDENT { $$ = enqGlobId ($1, $3); }
;
| glob_decl ',' IDENT { $$ = enqGlobId ($1, $3); };
/*
* ------
*/
/* here is 1 shift/reduce conflict, but thats ok. */
if_stmt : IF '(' cond ')' stmt { $$ = genIfStmt ($3, $5, NULL); }
| IF '(' cond ')' stmt ELSE stmt
{ $$ = genIfStmt ($3, $5, $7); }
;
| IF '(' cond ')' stmt ELSE stmt { $$ = genIfStmt ($3, $5, $7); };
rep_stmt : REPEAT '(' IDENT COUNT '=' INT ')' stmt
{ $$ = genRepStmt ($3, $6, $8); }
;
rep_stmt : REPEAT '(' IDENT COUNT '=' INT ')' stmt {
$$ = genRepStmt($3, $6, $8); };
fore_stmt : FOREACH '(' IDENT AS IDENT ',' IDENT ')' stmt
{ $$ = genForeStmt ($3, $5, $7, $9); }
;
fore_stmt : FOREACH '(' IDENT AS IDENT ',' IDENT ')' stmt {
$$ = genForeStmt($3, $5, $7, $9); };
cond : expr { $$ = genCondExprStmt($1); }
| comp { $$ = $1; }
| '(' comp ')' { $$ = $2; }
| '!' cond %prec LOGNEG { $$ = genOpStmt(LOGNEG, $2, NULL); }
| '(' '!' cond ')' %prec LOGNEG
{ $$ = genOpStmt (LOGNEG, $3, NULL); }
| '(' '!' cond ')' %prec LOGNEG { $$ = genOpStmt(LOGNEG, $3, NULL); }
| cond LOGAND cond { $$ = genOpStmt(LOGAND, $1, $3); }
| '(' cond LOGAND cond ')' { $$ = genOpStmt(LOGAND, $2, $4); }
| cond LOGOR cond { $$ = genOpStmt(LOGOR, $1, $3); }
| '(' cond LOGOR cond ')' { $$ = genOpStmt (LOGOR, $2, $4); }
;
| '(' cond LOGOR cond ')' { $$ = genOpStmt(LOGOR, $2, $4); };
comp : expr EQ expr { $$ = genOpStmt(EQ, $1, $3); }
| expr NE expr { $$ = genOpStmt(NE, $1, $3); }
| expr LT expr { $$ = genOpStmt(LT, $1, $3); }
| expr GT expr { $$ = genOpStmt(GT, $1, $3); }
| expr LE expr { $$ = genOpStmt(LE, $1, $3); }
| expr GE expr { $$ = genOpStmt (GE, $1, $3); }
;
| expr GE expr { $$ = genOpStmt(GE, $1, $3); };
assig : ident '=' expr { $$ = genAssignStmt ($1, $3); }
| ident '=' assig { $$ = genAssignStmt ($1, $3); }
;
| ident '=' assig { $$ = genAssignStmt ($1, $3); };
ident : IDENT { $$ = genIdentVarStmt ($1); }
| ident '[' expr ']' { $$ = genIdentArrStmt ($1, $3); }
;
| ident '[' expr ']' { $$ = genIdentArrStmt ($1, $3); };
expr : ident { $$ = genIdentValStmt ($1); }
| INT { $$ = genIntStmt ($1); }
@ -531,8 +509,7 @@ expr : ident { $$ = genIdentValStmt ($1); }
| expr '-' expr { $$ = genOpStmt (MINUS, $1, $3); }
| expr '*' expr { $$ = genOpStmt (TIMES, $1, $3); }
| expr '/' expr { $$ = genOpStmt (OVER, $1, $3); }
| expr '%' expr { $$ = genOpStmt (MODULO, $1, $3); }
;
| expr '%' expr { $$ = genOpStmt (MODULO, $1, $3); };
%%

108
src/tepal_scan.l
View File

@ -36,46 +36,41 @@ TEXT (\<[^#].*)|([^\<]*)
tok[0] = input();
tok[1] = input();
if (tok[1] == '#' || tok[0] == EOF)
{
if (tok[1] == '#' || tok[0] == EOF) {
unput('#');
unput('<');
}
else
{
else {
if (tok[1] != EOF)
unput(tok[1]);
yylval.cPtr[len] = tok[0];
}
#ifdef DEBUG
printf ("[TOKEN] HTML\n");
fputs("[TOKEN] HTML", stderr);
#endif
return HTML;
}
{S_TOK} {
BEGIN(TOK);
#ifdef DEBUG
printf ("[TOKEN] STMT_END {[ \\t]*<#}\n");
fputs("[TOKEN] STMT_END {[ \\t]*<#}", stderr);
#endif
return STMT_END;
}
<TOK>{E_TOK}\n? {
BEGIN(INITIAL);
#ifdef DEBUG
printf ("[TOKEN] STMT_END {#>\\n?}\n");
fputs("[TOKEN] STMT_END {#>\\n?}", stderr);
#endif
return STMT_END;
}
<TOK>{OPERATOR} {
#ifdef DEBUG
printf ("[TOKEN] %c\n", yytext[0]);
fprintf(stderr, "[TOKEN] %c\n", yytext[0]);
#endif
yylval.iVal = yytext[0];
return yytext[0];
@ -83,79 +78,72 @@ TEXT (\<[^#].*)|([^\<]*)
<TOK>== {
#ifdef DEBUG
printf ("[TOKEN] EQ\n");
fputs("[TOKEN] EQ", stderr);
#endif
return EQ;
}
<TOK>!= {
#ifdef DEBUG
printf ("[TOKEN] NE\n");
fputs("[TOKEN] NE", stderr);
#endif
return NE;
}
<TOK>\< {
#ifdef DEBUG
printf ("[TOKEN] EQ\n");
fputs("[TOKEN] LT", stderr);
#endif
return LT;
}
<TOK>\> {
#ifdef DEBUG
printf ("[TOKEN] EQ\n");
fputs("[TOKEN] GT", stderr);
#endif
return GT;
}
<TOK>\<= {
#ifdef DEBUG
printf ("[TOKEN] EQ\n");
fputs("[TOKEN] LE", stderr);
#endif
return LE;
}
<TOK>\>= {
#ifdef DEBUG
printf ("[TOKEN] EQ\n");
fputs("[TOKEN] GE", stderr);
#endif
return GE;
}
<TOK>&& {
#ifdef DEBUG
printf ("[TOKEN] LOGAND\n");
fputs("[TOKEN] LOGAND", stderr);
#endif
return LOGAND;
}
<TOK>\|\| {
#ifdef DEBUG
printf ("[TOKEN] LOGOR\n");
fputs("[TOKEN] LOGOR", stderr);
#endif
return LOGOR;
}
<TOK>{INT} {
yylval.iVal = atol (yytext);
#ifdef DEBUG
printf ("[TOKEN] INT\n");
fputs("[TOKEN] INT", stderr);
#endif
return INT;
}
<TOK>{FLOAT} {
yylval.fVal = atof(yytext);
#ifdef DEBUG
printf ("[TOKEN] FLOAT\n");
fputs("[TOKEN] FLOAT", stderr);
#endif
return FLOAT;
}
@ -163,72 +151,65 @@ TEXT (\<[^#].*)|([^\<]*)
yylval.cPtr = (char *)malloc(strlen (yytext) - 1);
memset (yylval.cPtr, 0, strlen(yytext) - 1);
memcpy (yylval.cPtr, yytext + 1, strlen(yytext) - 2);
#ifdef DEBUG
printf ("[TOKEN] STRING\n");
fputs("[TOKEN] STRING", stderr);
#endif
return STRING;
}
<TOK>repeat {
#ifdef DEBUG
printf ("[TOKEN] REPEAT\n");
fputs("[TOKEN] REPEAT", stderr);
#endif
return REPEAT;
}
<TOK>count {
#ifdef DEBUG
printf ("[TOKEN] COUNT\n");
fputs("[TOKEN] COUNT", stderr);
#endif
return COUNT;
}
<TOK>foreach {
#ifdef DEBUG
printf ("[TOKEN] FOREACH\n");
fputs("[TOKEN] FOREACH", stderr);
#endif
return FOREACH;
}
<TOK>as {
#ifdef DEBUG
printf ("[TOKEN] AS\n");
fputs("[TOKEN] AS", stderr);
#endif
return AS;
}
<TOK>if {
#ifdef DEBUG
printf ("[TOKEN] IF\n");
fputs("[TOKEN] IF", stderr);
#endif
return IF;
}
<TOK>else {
#ifdef DEBUG
printf ("[TOKEN] ELSE\n");
fputs("[TOKEN] ELSE", stderr);
#endif
return ELSE;
}
<TOK>end {
#ifdef DEBUG
printf ("[TOKEN] BLOCK_END\n");
fputs("[TOKEN] BLOCK_END", stderr);
#endif
return BLOCK_END;
}
<TOK>unset {
#ifdef DEBUG
printf ("[TOKEN] UNSET\n");
fputs("[TOKEN] UNSET", stderr);
#endif
return UNSET;
}
@ -237,58 +218,51 @@ TEXT (\<[^#].*)|([^\<]*)
yylval.cPtr[0] = '\n';
yylval.cPtr[1] = '\0';
#ifdef DEBUG
printf ("[TOKEN] EOL\n");
fputs("[TOKEN] EOL", stderr);
#endif
return EOL;
}
<TOK>parent {
#ifdef DEBUG
printf ("[TOKEN] PARENT\n");
fputs("[TOKEN] PARENT", stderr);
#endif
return PARENT;
}
<TOK>global {
#ifdef DEBUG
printf ("[TOKEN] GLOBAL\n");
fputs("[TOKEN] GLOBAL", stderr);
#endif
return GLOBAL;
}
<TOK>{ICAST} {
#ifdef DEBUG
printf ("[TOKEN] ICAST\n");
fputs("[TOKEN] ICAST", stderr);
#endif
return ICAST;
}
<TOK>{FCAST} {
#ifdef DEBUG
printf ("[TOKEN] FCAST\n");
fputs("[TOKEN] FCAST", stderr);
#endif
return FCAST;
}
<TOK>{SCAST} {
#ifdef DEBUG
printf ("[TOKEN] SCAST\n");
fputs("[TOKEN] SCAST", stderr);
#endif
return SCAST;
}
<TOK>{IDENT} {
yylval.cPtr = (char *)malloc(strlen(yytext) + 1);
strcpy(yylval.cPtr, yytext);
#ifdef DEBUG
printf ("[TOKEN] IDENT\n");
fputs("[TOKEN] IDENT", stderr);
#endif
return IDENT;
}

1
src/variable.c
View File

@ -37,7 +37,6 @@ getArray (s_ident * var, s_expVal * eVal)
break;
}
case EXP_TYP_STRING:
{
char * key = expValueString(eVal);

Write Preview
Loading…
Cancel
Save