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
Unified 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 * blockIdl(s_block *);
s_identList * blockGetIdl(s_block *); s_identList * blockGetIdl(s_block *);
#endif /* _BLOCK_H_ */ #endif /* _BLOCK_H_ */

1
include/expValue.h
View File

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

3
src/assign.c
View File

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

61
src/bbtree.c
View File

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

4
src/block.c
View File

@ -17,6 +17,7 @@ blockGetIdl (s_block * block)
{ {
return block->idl; return block->idl;
} }
s_block * s_block *
blockNew(s_stmtQueue * stmts) blockNew(s_stmtQueue * stmts)
{ {
@ -54,9 +55,7 @@ blockSetNonLocalId (s_block * bs, s_ident * id)
blockPush(s_block ** bs, s_block * new) blockPush(s_block ** bs, s_block * new)
{ {
new->prev = *bs; new->prev = *bs;
*bs = new; *bs = new;
return *bs; return *bs;
} }
@ -65,7 +64,6 @@ blockPop (s_block ** bs)
{ {
s_block * ret = *bs; s_block * ret = *bs;
*bs = (*bs)->prev; *bs = (*bs)->prev;
return ret; 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 op1 = expValueInt(_op1);
long op2 = expValueInt(_op2); long op2 = expValueInt(_op2);
switch (op)
{
switch (op) {
case EQ: return (op1 == op2); case EQ: return (op1 == op2);
case NE: return (op1 != op2); case NE: return (op1 != op2);
case LT: 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 op1 = expValueFloat(_op1);
double op2 = expValueFloat(_op2); double op2 = expValueFloat(_op2);
switch (op)
{
switch (op) {
case EQ: return (op1 == op2); case EQ: return (op1 == op2);
case NE: return (op1 != op2); case NE: return (op1 != op2);
case LT: 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); char * op2 = expValueString(_op2);
long ret; long ret;
switch (op)
{
switch (op) {
case EQ: ret = (! strcmp(op1, op2)); case EQ: ret = (! strcmp(op1, op2));
case NE: ret = strcmp(op1, op2); case NE: ret = strcmp(op1, op2);
case LT: ret = (strcmp(op1, op2) < 0) ? 1 : 0; case LT: ret = (strcmp(op1, op2) < 0) ? 1 : 0;
@ -78,17 +75,16 @@ evalStringComp (int op, s_expVal * _op1, s_expVal * _op2)
int int
evalCondExpr(s_expVal * _op) 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: case EXP_TYP_STRING:
{ {
char * op = expValueString(_op); char * op = expValueString(_op);
long ret = strlen(op); long ret = strlen(op);
free(op); free(op);
return ret; return ret;
} }
} }
@ -99,14 +95,11 @@ evalCondExpr (s_expVal * _op)
int int
evalComp(int op, s_expVal * op1, s_expVal * op2) evalComp(int op, s_expVal * op1, s_expVal * op2)
{ {
switch (expValueGetType (op1))
{
switch (expValueGetType(op1)) {
case EXP_TYP_INT: case EXP_TYP_INT:
return evalIntComp(op, op1, op2); return evalIntComp(op, op1, op2);
case EXP_TYP_FLOAT: case EXP_TYP_FLOAT:
return evalFloatComp(op, op1, op2); return evalFloatComp(op, op1, op2);
case EXP_TYP_STRING: case EXP_TYP_STRING:
return evalStringComp(op, op1, op2); 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; s_expVal * ret;
char * op1 = expValueString (_op1); char * op1 = expValueString (_op1);
char * op2 = expValueString (_op2); 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); strcpy(retVal, op1);
strcat(retVal, op2); strcat(retVal, op2);
@ -45,8 +45,7 @@ stringNeg (s_expVal * _op)
char * op = expValueString(_op); char * op = expValueString(_op);
int len = strlen(op) - 1; int len = strlen(op) - 1;
for (i=0; i<=(len/2); i++)
{
for (i=0; i<=(len/2); i++) {
char tmp = op[i]; char tmp = op[i];
op[i] = op[len-i]; op[i] = op[len-i];
op[len-i] = tmp; op[len-i] = tmp;
@ -67,22 +66,18 @@ evalIntExp (int op, s_expVal * _op1, s_expVal * _op2)
if (op == NEG) return expValueIntNew(- op1); if (op == NEG) return expValueIntNew(- op1);
switch (expValueGetType (_op2))
{
switch (expValueGetType(_op2)) {
case EXP_TYP_INT: case EXP_TYP_INT:
case EXP_TYP_FLOAT: case EXP_TYP_FLOAT:
switch (op)
{
switch (op) {
case PLUS: return expValueIntNew(op1 + op2); case PLUS: return expValueIntNew(op1 + op2);
case MINUS: return expValueIntNew(op1 - op2); case MINUS: return expValueIntNew(op1 - op2);
case TIMES: return expValueIntNew(op1 * op2); case TIMES: return expValueIntNew(op1 * op2);
case OVER: return expValueIntNew(op1 / op2); case OVER: return expValueIntNew(op1 / op2);
case MODULO: return expValueIntNew(op1 % op2); case MODULO: return expValueIntNew(op1 % op2);
} }
case EXP_TYP_STRING: case EXP_TYP_STRING:
if (op == PLUS)
return stringPlus (_op1, _op2);
if (op == PLUS) return stringPlus(_op1, _op2);
exitError(ERR_STRING_OPERATOR, op); exitError(ERR_STRING_OPERATOR, op);
} }
} }
@ -97,22 +92,18 @@ evalFloatExp (int op, s_expVal * _op1, s_expVal * _op2)
if (op == NEG) return expValueFloatNew(- op1); if (op == NEG) return expValueFloatNew(- op1);
switch (expValueGetType (_op2))
{
switch (expValueGetType(_op2)) {
case EXP_TYP_INT: case EXP_TYP_INT:
case EXP_TYP_FLOAT: case EXP_TYP_FLOAT:
switch (op)
{
switch (op) {
case MODULO: exitError(ERR_FLOAT_OPERATOR, op); case MODULO: exitError(ERR_FLOAT_OPERATOR, op);
case PLUS: return expValueFloatNew(op1 + op2); case PLUS: return expValueFloatNew(op1 + op2);
case MINUS: return expValueFloatNew(op1 - op2); case MINUS: return expValueFloatNew(op1 - op2);
case TIMES: return expValueFloatNew(op1 * op2); case TIMES: return expValueFloatNew(op1 * op2);
case OVER: return expValueFloatNew(op1 / op2); case OVER: return expValueFloatNew(op1 / op2);
} }
case EXP_TYP_STRING: case EXP_TYP_STRING:
if (op == PLUS)
return stringPlus (_op1, _op2);
if (op == PLUS) return stringPlus(_op1, _op2);
exitError(ERR_STRING_OPERATOR, op); exitError(ERR_STRING_OPERATOR, op);
} }
} }
@ -125,21 +116,15 @@ evalFloatExp (int op, s_expVal * _op1, s_expVal * _op2)
s_expVal * s_expVal *
evalExpr(int op, s_expVal * op1, s_expVal * op2) evalExpr(int op, s_expVal * op1, s_expVal * op2)
{ {
switch (expValueGetType (op1))
{
switch (expValueGetType(op1)) {
case EXP_TYP_INT: case EXP_TYP_INT:
return evalIntExp(op, op1, op2); return evalIntExp(op, op1, op2);
case EXP_TYP_FLOAT: 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); exitError (ERR_FLOAT_OPERATOR, op);
case EXP_TYP_STRING: 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); exitError(ERR_STRING_OPERATOR, op);
} }
} }

23
src/expValue.c
View File

@ -62,10 +62,11 @@ expValueClone (s_expVal * eVal)
ret->type = eVal->type; 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: case EXP_TYP_STRING:
{ {
ret->val.cPtr = (char *)malloc( ret->val.cPtr = (char *)malloc(
@ -80,8 +81,7 @@ expValueClone (s_expVal * eVal)
void void
expValueFree(s_expVal * eVal) 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); free(eVal);
} }
@ -92,8 +92,7 @@ expValueFree (s_expVal * eVal)
long long
expValueInt(s_expVal * eVal) expValueInt(s_expVal * eVal)
{ {
switch (eVal->type)
{
switch (eVal->type) {
case EXP_TYP_INT: return eVal->val.iVal; case EXP_TYP_INT: return eVal->val.iVal;
case EXP_TYP_FLOAT: return (long)eVal->val.fVal; case EXP_TYP_FLOAT: return (long)eVal->val.fVal;
case EXP_TYP_STRING: return atoi(eVal->val.cPtr); case EXP_TYP_STRING: return atoi(eVal->val.cPtr);
@ -103,8 +102,7 @@ expValueInt (s_expVal * eVal)
double double
expValueFloat(s_expVal * eVal) expValueFloat(s_expVal * eVal)
{ {
switch (eVal->type)
{
switch (eVal->type) {
case EXP_TYP_INT: return (double) eVal->val.iVal; case EXP_TYP_INT: return (double) eVal->val.iVal;
case EXP_TYP_FLOAT: return eVal->val.fVal; case EXP_TYP_FLOAT: return eVal->val.fVal;
case EXP_TYP_STRING: return atof(eVal->val.cPtr); case EXP_TYP_STRING: return atof(eVal->val.cPtr);
@ -117,20 +115,17 @@ expValueString (s_expVal * eVal)
char buf[40]; char buf[40];
char * ret = NULL; char * ret = NULL;
switch (eVal->type)
{
switch (eVal->type) {
case EXP_TYP_INT: case EXP_TYP_INT:
sprintf(buf, "%d", eVal->val.iVal); sprintf(buf, "%d", eVal->val.iVal);
ret = (char*)malloc(sizeof(char) * (strlen(buf) + 1)); ret = (char*)malloc(sizeof(char) * (strlen(buf) + 1));
strcpy(ret, buf); strcpy(ret, buf);
break; break;
case EXP_TYP_FLOAT: case EXP_TYP_FLOAT:
sprintf(buf, "%f", eVal->val.fVal); sprintf(buf, "%f", eVal->val.fVal);
ret = (char*)malloc(sizeof(char) * (strlen(buf) + 1)); ret = (char*)malloc(sizeof(char) * (strlen(buf) + 1));
strcpy(ret, buf); strcpy(ret, buf);
break; break;
case EXP_TYP_STRING: case EXP_TYP_STRING:
ret = (char*)malloc(sizeof(char) * (strlen(eVal->val.cPtr) + 1)); ret = (char*)malloc(sizeof(char) * (strlen(eVal->val.cPtr) + 1));
strcpy(ret, eVal->val.cPtr); 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[0] = ID_TYP_UNDEF;
ident->key[1] = '\0'; ident->key[1] = '\0';
if (key != NULL)
strcpy (ident->key + 1, key);
if (key != NULL) strcpy(ident->key + 1, key);
ident->queued = 0; ident->queued = 0;
@ -107,8 +106,7 @@ identFree (s_ident * id)
printf("[!DEBUG!] identFree: %d/%s\n", id->idx, id->key); printf("[!DEBUG!] identFree: %d/%s\n", id->idx, id->key);
#endif #endif
switch (identGetType (id))
{
switch (identGetType(id)) {
case ID_TYP_EXP: expValueFree (id->val.base); break; case ID_TYP_EXP: expValueFree (id->val.base); break;
case ID_TYP_IDL: identListFree (id->val.idl); break; case ID_TYP_IDL: identListFree (id->val.idl); break;
} }
@ -162,13 +160,9 @@ identExp (s_ident * id)
{ {
s_expVal * ret = NULL; 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; return ret;
} }
@ -178,10 +172,7 @@ identIdl (s_ident * id)
{ {
s_identList * ret = NULL; 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; return ret;
} }
@ -189,8 +180,7 @@ identIdl (s_ident * id)
s_ident * s_ident *
identSetExp(s_ident * id, s_expVal * val) 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_EXP: expValueFree(id->val.base); break;
case ID_TYP_IDL: identListFree(id->val.idl); break; case ID_TYP_IDL: identListFree(id->val.idl); break;
} }
@ -204,8 +194,7 @@ identSetExp (s_ident * id, s_expVal * val)
s_ident * s_ident *
identSetIdl(s_ident * id, s_identList * val) identSetIdl(s_ident * id, s_identList * val)
{ {
switch (identGetType (id))
{
switch (identGetType (id)) {
case ID_TYP_EXP: expValueFree (id->val.base); case ID_TYP_EXP: expValueFree (id->val.base);
case ID_TYP_IDL: identListFree (id->val.idl); 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, s_ident ** idArray,
** _run; ** _run;
for (_run = idArray = (s_ident **) identListToArray (l);
for (
_run = idArray = (s_ident **)identListToArray(l);
*_run != NULL; *_run != NULL;
_run++ ) _run++ )
{ {
identDequeue(*_run); identDequeue(*_run);
if (! identIsQueued (*_run))
identFree (*_run);
if (! identIsQueued(*_run)) identFree(*_run);
} }
free(idArray); free(idArray);
@ -93,29 +93,27 @@ identListPutVal (s_identList * l, s_ident * val)
identEnqueue(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. */ /* calling error: either key or idx must be valid. But not both. */
return NULL; 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); identDequeue(oldVal);
if (! identIsQueued (oldVal))
identFree (oldVal);
if (! identIsQueued(oldVal)) identFree(oldVal);
} }
return val; return val;
@ -157,11 +155,9 @@ identListRemoveByIdx (s_identList * l, int idx)
identFree(seek); identFree(seek);
if (val != NULL)
{
if (val != NULL) {
identDequeue(val); 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); identFree(seek);
if (val != NULL)
{
if (val != NULL) {
identDequeue(val); 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); char * op = expValueString(_op);
s_block * run = actBlock; s_block * run = actBlock;
while (ret == NULL && run != NULL)
{
while (ret == NULL && run != NULL) {
ret = identListSeekKey(blockIdl(run), op); ret = identListSeekKey(blockIdl(run), op);
run = blockPrev(run); run = blockPrev(run);
} }
if (ret == NULL)
if (ret == NULL) {
ret = identListPutVal(blockIdl(actBlock), identUndefNew(-1, op)); ret = identListPutVal(blockIdl(actBlock), identUndefNew(-1, op));
}
expValueFree(_op); expValueFree(_op);
free(op); free(op);
@ -130,8 +130,7 @@ stmtAssign (s_stmt * stmt, s_block * actBlock)
s_expVal * op2 = stmtDo(stmtQueueGet(args, 1), actBlock).eVal, s_expVal * op2 = stmtDo(stmtQueueGet(args, 1), actBlock).eVal,
* ret; * ret;
if (op1 == NULL)
op1 = getVariable (NULL, NULL);
if (op1 == NULL) op1 = getVariable(NULL, NULL);
ret = assign(op1, op2); ret = assign(op1, op2);
@ -148,8 +147,7 @@ stmtPrint (s_stmt * stmt, s_block * actBlock)
s_stmtQueue * args = stmt->sQueue; 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)
{
if (op != NULL) {
printExpr(op); printExpr(op);
expValueFree(op); expValueFree(op);
} }
@ -181,20 +179,17 @@ stmtEvalCond (s_stmt * stmt, s_block * actBlock, int op)
s_stmtQueue * args = stmt->sQueue; 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: case LOGAND:
{ {
int op2 = stmtDo(stmtQueueGet(args, 1), actBlock).cond; int op2 = stmtDo(stmtQueueGet(args, 1), actBlock).cond;
return (u_stmtType)(op1 && op2); return (u_stmtType)(op1 && op2);
} }
case LOGOR: case LOGOR:
{ {
int op2 = stmtDo(stmtQueueGet(args, 1), actBlock).cond; int op2 = stmtDo(stmtQueueGet(args, 1), actBlock).cond;
return (u_stmtType)(op1 || op2); return (u_stmtType)(op1 || op2);
} }
case LOGNEG: case LOGNEG:
return (u_stmtType)(! op1); return (u_stmtType)(! op1);
} }
@ -265,24 +260,20 @@ stmtBlock (s_stmt * stmt, s_block * actBlock)
while (blockPrev(gBlock) != NULL) while (blockPrev(gBlock) != NULL)
gBlock = blockPrev(gBlock); 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; s_expVal * tmp = stmtDo(stmtQueueGet (gIds, i), actBlock).eVal;
char * _id; char * _id;
s_ident * id; s_ident * id;
if (tmp == NULL)
exitError (0);
if (tmp == NULL) exitError (0);
_id = expValueString(tmp); _id = expValueString(tmp);
id = identListSeekKey(blockGetIdl (gBlock), _id); id = identListSeekKey(blockGetIdl (gBlock), _id);
expValueFree(tmp); expValueFree(tmp);
free(_id); free(_id);
if (id == NULL)
exitError (0);
if (id == NULL) exitError (0);
blockSetNonLocalId(gBlock, id); blockSetNonLocalId(gBlock, id);
} }
@ -303,13 +294,10 @@ stmtIf (s_stmt * stmt, s_block * actBlock)
int cond = stmtDo(stmtQueueGet (args, 0), actBlock).cond; int cond = stmtDo(stmtQueueGet (args, 0), actBlock).cond;
s_stmt * _do; 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;
} }
@ -399,11 +387,9 @@ stmtGetConstTyp (s_stmt * stmt)
void void
stmtFree(s_stmt * stmt) 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_NONE: stmtQueueFree (stmt->sQueue); break;
case STYP_EVAL: expValueFree (stmt->sConst.eVal); break; case STYP_EVAL: expValueFree (stmt->sConst.eVal); break;
case STYP_IDVAL: identFree (stmt->sConst.idVal); break; case STYP_IDVAL: identFree (stmt->sConst.idVal); break;
@ -415,46 +401,68 @@ stmtFree (s_stmt * stmt)
u_stmtType u_stmtType
stmtDo(s_stmt * stmt, s_block * actBlock) 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; 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; unsigned int i;
if (sQueue == NULL)
return;
if (sQueue == NULL) return;
/* freeing the queue is the final step. All stmts should be freed too! */ /* freeing the queue is the final step. All stmts should be freed too! */
for (i=0; i < sQueue->maxIdx; i++) for (i=0; i < sQueue->maxIdx; i++)
@ -82,7 +81,7 @@ stmtQueueEnqueue (s_stmtQueue * sQueue, s_stmt * stmt)
&(sQueue->stmts[sQueue->size]), &(sQueue->stmts[sQueue->size]),
0, 0,
sizeof(s_stmt**) * QUEUE_GROW_SIZE); sizeof(s_stmt**) * QUEUE_GROW_SIZE);
sQueue->size = newSize;;
sQueue->size = newSize;
} }
sQueue->stmts[sQueue->maxIdx++] = stmt; sQueue->stmts[sQueue->maxIdx++] = stmt;
@ -101,10 +100,8 @@ stmtQueueDequeue (s_stmtQueue * sQueue)
s_stmt * s_stmt *
stmtQueueGet(s_stmtQueue * sQueue, unsigned int idx) 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 void
@ -112,8 +109,7 @@ stmtQueueDo (s_stmtQueue * sQueue)
{ {
int i; int i;
if (sQueue == NULL)
return;
if (sQueue == NULL) return;
for (i = 0; i < sQueue->maxIdx; i++) for (i = 0; i < sQueue->maxIdx; i++)
stmtDo(sQueue->stmts[i], NULL /* !!!FIXME: give me a sane value!!! */); 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); va_start(ap, errNum);
switch (errNum)
{
switch (errNum) {
case ERR_UNDEF_VAR: case ERR_UNDEF_VAR:
fprintf(stderr, tepalErrMsg[errNum], va_arg(ap, char *)); fprintf(stderr, tepalErrMsg[errNum], va_arg(ap, char *));
break; break;
case ERR_NO_INDEX: case ERR_NO_INDEX:
fprintf(stderr, tepalErrMsg[errNum], va_arg(ap, char *)); fprintf(stderr, tepalErrMsg[errNum], va_arg(ap, char *));
break; break;
case ERR_STRING_OPERATOR: case ERR_STRING_OPERATOR:
fprintf(stderr, tepalErrMsg[errNum], va_arg(ap, int)); fprintf(stderr, tepalErrMsg[errNum], va_arg(ap, int));
break; break;
case ERR_FLOAT_OPERATOR: case ERR_FLOAT_OPERATOR:
fprintf(stderr, tepalErrMsg[errNum], va_arg(ap, int)); fprintf(stderr, tepalErrMsg[errNum], va_arg(ap, int));
break; break;
@ -50,10 +46,11 @@ exitError (int errNum, ...)
void void
printExpr (s_expVal * val) 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: case EXP_TYP_STRING:
{ {
char * v = expValueString(val); char * v = expValueString(val);

69
src/tepal_pars.y
View File

@ -118,8 +118,7 @@ genStringStmt (s_stmt * stmt, char * string)
char * new = NULL; char * new = NULL;
if (stmt != NULL)
{
if (stmt != NULL) {
char * old = expValueString (stmtGetVal (stmt).eVal); char * old = expValueString (stmtGetVal (stmt).eVal);
size_t len = strlen (old) + strlen (string) + 1; size_t len = strlen (old) + strlen (string) + 1;
@ -130,8 +129,7 @@ genStringStmt (s_stmt * stmt, char * string)
stmtFree (stmt); stmtFree (stmt);
free (old); free (old);
} }
else
{
else {
new = (char *)calloc (sizeof (char), strlen (string) + 1); new = (char *)calloc (sizeof (char), strlen (string) + 1);
strcpy (new, string); 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 (NULL, $1); }
| stmt_queue stmt { $$ = enqStmt ($1, $2); }
;
| stmt_queue stmt { $$ = enqStmt ($1, $2); };
stmt : simple_stmt stmt : simple_stmt
| block_stmt | block_stmt
| if_stmt | if_stmt
| rep_stmt | rep_stmt
| fore_stmt | fore_stmt
| stmt_end stmt { $$ = $2; }
;
| stmt_end stmt { $$ = $2; };
simple_stmt : html stmt_end { $$ = genPrintStmt ($1); } simple_stmt : html stmt_end { $$ = genPrintStmt ($1); }
| expr stmt_end { $$ = genPrintStmt ($1); } | expr stmt_end { $$ = genPrintStmt ($1); }
| assig stmt_end
;
| assig stmt_end;
html : HTML { $$ = genStringStmt (NULL, $1); } html : HTML { $$ = genStringStmt (NULL, $1); }
| html HTML { $$ = genStringStmt ($1, $2); }
;
| html HTML { $$ = genStringStmt ($1, $2); };
stmt_end : STMT_END stmt_end : STMT_END
| ';'
;
| ';';
block_stmt : ':' BLOCK_END { $$ = genBlockStmt (NULL); } 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); } 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" * 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. * 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 (NULL, $1); }
| glob_decl ',' IDENT { $$ = enqGlobId ($1, $3); }
;
| glob_decl ',' IDENT { $$ = enqGlobId ($1, $3); };
/* /*
* ------ * ------
*/ */
/* here is 1 shift/reduce conflict, but thats ok. */ /* here is 1 shift/reduce conflict, but thats ok. */
if_stmt : IF '(' cond ')' stmt { $$ = genIfStmt ($3, $5, NULL); } 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); } cond : expr { $$ = genCondExprStmt($1); }
| comp { $$ = $1; } | comp { $$ = $1; }
| '(' comp ')' { $$ = $2; } | '(' comp ')' { $$ = $2; }
| '!' cond %prec LOGNEG { $$ = genOpStmt(LOGNEG, $2, NULL); } | '!' 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, $1, $3); }
| '(' cond LOGAND cond ')' { $$ = genOpStmt(LOGAND, $2, $4); } | '(' cond LOGAND cond ')' { $$ = genOpStmt(LOGAND, $2, $4); }
| cond LOGOR cond { $$ = genOpStmt(LOGOR, $1, $3); } | 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); } comp : expr EQ expr { $$ = genOpStmt(EQ, $1, $3); }
| expr NE expr { $$ = genOpStmt(NE, $1, $3); } | expr NE expr { $$ = genOpStmt(NE, $1, $3); }
| expr LT expr { $$ = genOpStmt(LT, $1, $3); } | expr LT expr { $$ = genOpStmt(LT, $1, $3); }
| expr GT expr { $$ = genOpStmt(GT, $1, $3); } | expr GT expr { $$ = genOpStmt(GT, $1, $3); }
| expr LE expr { $$ = genOpStmt(LE, $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); } assig : ident '=' expr { $$ = genAssignStmt ($1, $3); }
| ident '=' assig { $$ = genAssignStmt ($1, $3); }
;
| ident '=' assig { $$ = genAssignStmt ($1, $3); };
ident : IDENT { $$ = genIdentVarStmt ($1); } ident : IDENT { $$ = genIdentVarStmt ($1); }
| ident '[' expr ']' { $$ = genIdentArrStmt ($1, $3); }
;
| ident '[' expr ']' { $$ = genIdentArrStmt ($1, $3); };
expr : ident { $$ = genIdentValStmt ($1); } expr : ident { $$ = genIdentValStmt ($1); }
| INT { $$ = genIntStmt ($1); } | INT { $$ = genIntStmt ($1); }
@ -531,8 +509,7 @@ expr : ident { $$ = genIdentValStmt ($1); }
| expr '-' expr { $$ = genOpStmt (MINUS, $1, $3); } | expr '-' expr { $$ = genOpStmt (MINUS, $1, $3); }
| expr '*' expr { $$ = genOpStmt (TIMES, $1, $3); } | expr '*' expr { $$ = genOpStmt (TIMES, $1, $3); }
| expr '/' expr { $$ = genOpStmt (OVER, $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[0] = input();
tok[1] = input(); tok[1] = input();
if (tok[1] == '#' || tok[0] == EOF)
{
if (tok[1] == '#' || tok[0] == EOF) {
unput('#'); unput('#');
unput('<'); unput('<');
} }
else
{
else {
if (tok[1] != EOF) if (tok[1] != EOF)
unput(tok[1]); unput(tok[1]);
yylval.cPtr[len] = tok[0]; yylval.cPtr[len] = tok[0];
} }
#ifdef DEBUG #ifdef DEBUG
printf ("[TOKEN] HTML\n");
fputs("[TOKEN] HTML", stderr);
#endif #endif
return HTML; return HTML;
} }
{S_TOK} { {S_TOK} {
BEGIN(TOK); BEGIN(TOK);
#ifdef DEBUG #ifdef DEBUG
printf ("[TOKEN] STMT_END {[ \\t]*<#}\n");
fputs("[TOKEN] STMT_END {[ \\t]*<#}", stderr);
#endif #endif
return STMT_END; return STMT_END;
} }
<TOK>{E_TOK}\n? { <TOK>{E_TOK}\n? {
BEGIN(INITIAL); BEGIN(INITIAL);
#ifdef DEBUG #ifdef DEBUG
printf ("[TOKEN] STMT_END {#>\\n?}\n");
fputs("[TOKEN] STMT_END {#>\\n?}", stderr);
#endif #endif
return STMT_END; return STMT_END;
} }
<TOK>{OPERATOR} { <TOK>{OPERATOR} {
#ifdef DEBUG #ifdef DEBUG
printf ("[TOKEN] %c\n", yytext[0]);
fprintf(stderr, "[TOKEN] %c\n", yytext[0]);
#endif #endif
yylval.iVal = yytext[0]; yylval.iVal = yytext[0];
return yytext[0]; return yytext[0];
@ -83,79 +78,72 @@ TEXT (\<[^#].*)|([^\<]*)
<TOK>== { <TOK>== {
#ifdef DEBUG #ifdef DEBUG
printf ("[TOKEN] EQ\n");
fputs("[TOKEN] EQ", stderr);
#endif #endif
return EQ; return EQ;
} }
<TOK>!= { <TOK>!= {
#ifdef DEBUG #ifdef DEBUG
printf ("[TOKEN] NE\n");
fputs("[TOKEN] NE", stderr);
#endif #endif
return NE; return NE;
} }
<TOK>\< { <TOK>\< {
#ifdef DEBUG #ifdef DEBUG
printf ("[TOKEN] EQ\n");
fputs("[TOKEN] LT", stderr);
#endif #endif
return LT; return LT;
} }
<TOK>\> { <TOK>\> {
#ifdef DEBUG #ifdef DEBUG
printf ("[TOKEN] EQ\n");
fputs("[TOKEN] GT", stderr);
#endif #endif
return GT; return GT;
} }
<TOK>\<= { <TOK>\<= {
#ifdef DEBUG #ifdef DEBUG
printf ("[TOKEN] EQ\n");
fputs("[TOKEN] LE", stderr);
#endif #endif
return LE; return LE;
} }
<TOK>\>= { <TOK>\>= {
#ifdef DEBUG #ifdef DEBUG
printf ("[TOKEN] EQ\n");
fputs("[TOKEN] GE", stderr);
#endif #endif
return GE; return GE;
} }
<TOK>&& { <TOK>&& {
#ifdef DEBUG #ifdef DEBUG
printf ("[TOKEN] LOGAND\n");
fputs("[TOKEN] LOGAND", stderr);
#endif #endif
return LOGAND; return LOGAND;
} }
<TOK>\|\| { <TOK>\|\| {
#ifdef DEBUG #ifdef DEBUG
printf ("[TOKEN] LOGOR\n");
fputs("[TOKEN] LOGOR", stderr);
#endif #endif
return LOGOR; return LOGOR;
} }
<TOK>{INT} { <TOK>{INT} {
yylval.iVal = atol (yytext); yylval.iVal = atol (yytext);
#ifdef DEBUG #ifdef DEBUG
printf ("[TOKEN] INT\n");
fputs("[TOKEN] INT", stderr);
#endif #endif
return INT; return INT;
} }
<TOK>{FLOAT} { <TOK>{FLOAT} {
yylval.fVal = atof(yytext); yylval.fVal = atof(yytext);
#ifdef DEBUG #ifdef DEBUG
printf ("[TOKEN] FLOAT\n");
fputs("[TOKEN] FLOAT", stderr);
#endif #endif
return FLOAT; return FLOAT;
} }
@ -163,72 +151,65 @@ TEXT (\<[^#].*)|([^\<]*)
yylval.cPtr = (char *)malloc(strlen (yytext) - 1); yylval.cPtr = (char *)malloc(strlen (yytext) - 1);
memset (yylval.cPtr, 0, strlen(yytext) - 1); memset (yylval.cPtr, 0, strlen(yytext) - 1);
memcpy (yylval.cPtr, yytext + 1, strlen(yytext) - 2); memcpy (yylval.cPtr, yytext + 1, strlen(yytext) - 2);
#ifdef DEBUG #ifdef DEBUG
printf ("[TOKEN] STRING\n");
fputs("[TOKEN] STRING", stderr);
#endif #endif
return STRING; return STRING;
} }
<TOK>repeat { <TOK>repeat {
#ifdef DEBUG #ifdef DEBUG
printf ("[TOKEN] REPEAT\n");
fputs("[TOKEN] REPEAT", stderr);
#endif #endif
return REPEAT; return REPEAT;
} }
<TOK>count { <TOK>count {
#ifdef DEBUG #ifdef DEBUG
printf ("[TOKEN] COUNT\n");
fputs("[TOKEN] COUNT", stderr);
#endif #endif
return COUNT; return COUNT;
} }
<TOK>foreach { <TOK>foreach {
#ifdef DEBUG #ifdef DEBUG
printf ("[TOKEN] FOREACH\n");
fputs("[TOKEN] FOREACH", stderr);
#endif #endif
return FOREACH; return FOREACH;
} }
<TOK>as { <TOK>as {
#ifdef DEBUG #ifdef DEBUG
printf ("[TOKEN] AS\n");
fputs("[TOKEN] AS", stderr);
#endif #endif
return AS; return AS;
} }
<TOK>if { <TOK>if {
#ifdef DEBUG #ifdef DEBUG
printf ("[TOKEN] IF\n");
fputs("[TOKEN] IF", stderr);
#endif #endif
return IF; return IF;
} }
<TOK>else { <TOK>else {
#ifdef DEBUG #ifdef DEBUG
printf ("[TOKEN] ELSE\n");
fputs("[TOKEN] ELSE", stderr);
#endif #endif
return ELSE; return ELSE;
} }
<TOK>end { <TOK>end {
#ifdef DEBUG #ifdef DEBUG
printf ("[TOKEN] BLOCK_END\n");
fputs("[TOKEN] BLOCK_END", stderr);
#endif #endif
return BLOCK_END; return BLOCK_END;
} }
<TOK>unset { <TOK>unset {
#ifdef DEBUG #ifdef DEBUG
printf ("[TOKEN] UNSET\n");
fputs("[TOKEN] UNSET", stderr);
#endif #endif
return UNSET; return UNSET;
} }
@ -237,58 +218,51 @@ TEXT (\<[^#].*)|([^\<]*)
yylval.cPtr[0] = '\n'; yylval.cPtr[0] = '\n';
yylval.cPtr[1] = '\0'; yylval.cPtr[1] = '\0';
#ifdef DEBUG #ifdef DEBUG
printf ("[TOKEN] EOL\n");
fputs("[TOKEN] EOL", stderr);
#endif #endif
return EOL; return EOL;
} }
<TOK>parent { <TOK>parent {
#ifdef DEBUG #ifdef DEBUG
printf ("[TOKEN] PARENT\n");
fputs("[TOKEN] PARENT", stderr);
#endif #endif
return PARENT; return PARENT;
} }
<TOK>global { <TOK>global {
#ifdef DEBUG #ifdef DEBUG
printf ("[TOKEN] GLOBAL\n");
fputs("[TOKEN] GLOBAL", stderr);
#endif #endif
return GLOBAL; return GLOBAL;
} }
<TOK>{ICAST} { <TOK>{ICAST} {
#ifdef DEBUG #ifdef DEBUG
printf ("[TOKEN] ICAST\n");
fputs("[TOKEN] ICAST", stderr);
#endif #endif
return ICAST; return ICAST;
} }
<TOK>{FCAST} { <TOK>{FCAST} {
#ifdef DEBUG #ifdef DEBUG
printf ("[TOKEN] FCAST\n");
fputs("[TOKEN] FCAST", stderr);
#endif #endif
return FCAST; return FCAST;
} }
<TOK>{SCAST} { <TOK>{SCAST} {
#ifdef DEBUG #ifdef DEBUG
printf ("[TOKEN] SCAST\n");
fputs("[TOKEN] SCAST", stderr);
#endif #endif
return SCAST; return SCAST;
} }
<TOK>{IDENT} { <TOK>{IDENT} {
yylval.cPtr = (char *)malloc(strlen(yytext) + 1); yylval.cPtr = (char *)malloc(strlen(yytext) + 1);
strcpy(yylval.cPtr, yytext); strcpy(yylval.cPtr, yytext);
#ifdef DEBUG #ifdef DEBUG
printf ("[TOKEN] IDENT\n");
fputs("[TOKEN] IDENT", stderr);
#endif #endif
return IDENT; return IDENT;
} }

1
src/variable.c
View File

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

Write Preview
Loading…
Cancel
Save