return new;
}
+/* desallocate element */
+
+void delelement (element_t *root)
+{
+ int i;
+ if ((root != NULL) && (root != ERROR_OP)) {
+ for (i = 0; i < root->nbops; i++) {
+ if ((root->ops[i] != NULL) && (root->ops[i] != ERROR_OP)) {
+ delelement (root->ops[i]);
+ }
+ }
+ free (root);
+ }
+}
+
/* functions */
#define NB_OPERATORS 6
{ "^", Pow, 2, 1, 4}
};
-#define NB_FUNCTIONS 7
+#define NB_FUNCTIONS 9
keyword_t functions[NB_FUNCTIONS] = {
{ "sqrt", Sqr, 1, 4, 5},
{ "pow", Pow, 2, 3, 5},
{ "sin", Sin, 1, 3, 5},
{ "atan", Atn, 1, 4, 5},
{ "exp", Exp, 1, 3, 5},
- { "log", Log, 1, 3, 5}
+ { "log", Log, 1, 3, 5},
+ { "quit", Qui, 0, 4, 5},
+ { "help", Hel, 0, 4, 5}
};
/* subparser function */
new->ops[0] = *proot;
new->ops[1] = parser (*pstr, pstr, new->prio);
if (new->ops[1] == ERROR_OP) {
+ delelement (new);
+ *proot = NULL;
return ERROR_OP;
}
- *proot = newelement (Val, 1, 4);
- if (*proot == ERROR_OP) {
+ *proot = newelement (Val, 1, 5);
+ if (*proot == NULL) {
+ delelement (new);
return ERROR_OP;
}
(*proot)->ops[0] = new;
found = 0;
new = parser (str + 1, &str, 0);
if (new == ERROR_OP) {
+ delelement (root);
return ERROR_OP;
}
for (i = 0; i < root->nbops; i++) {
}
}
if (!found) {
+ delelement (new);
+ delelement (root);
return ERROR_OP;
}
} while (*str == ',');
} else {
- root = newelement (Val, 1, 4);
+ root = newelement (Val, 1, 5);
if (root == NULL) {
return ERROR_OP;
}
new = parser (str + 1, &str, 0);
if ((new == ERROR_OP) || (*str == ',')) {
+ delelement (new);
+ delelement (root);
return ERROR_OP;
}
root->ops[0] = new;
str += operator->offset;
VERBOSE (INFO, PRINTOUT ("Oper: %d\n", operator->func));
if (subparser (&root, &str, operator->func, operator->nbops, operator->prio) == ERROR_OP) {
+ delelement (root);
+ return ERROR_OP;
+ }
+ } else if (*str == '-') {
+ new = newelement (Sig, 1, 9);
+ if (new == NULL) {
return ERROR_OP;
}
+ root = new;
} else {
return ERROR_OP;
}
return ERROR_OP;
}
root = new;
- } else {
+ } else {
+ delelement (root);
return ERROR_OP;
}
str += function->offset;
(*str == '.') || (*str == '+') || (*str == '-')) {
VERBOSE (DEBUG, PRINTOUT ("start processing value\n"));
char *pt;
- float value = strtof (str, &pt);
+ double value = strtod (str, &pt);
VERBOSE (INFO, PRINTOUT ("Value: %f\n", value));
if (str != pt) {
if (root == NULL) {
- new = newelement (Val, 1, 4);
+ new = newelement (Val, 1, 5);
if (new == NULL) {
return ERROR_OP;
}
return root;
}
if (subparser (&root, &str, Add, 2, 1) == ERROR_OP) {
+ delelement (root);
return ERROR_OP;
}
} else {
+ delelement (root);
return ERROR_OP;
}
} else {
+ delelement (root);
return ERROR_OP;
}
found = 1;
/* error */
if (!found) {
+ delelement (root);
return ERROR_OP;
}
if (next != NULL) {
*next = str;
}
+
return root;
}
switch (root->func) {
case Val: func = "Value"; break;
+ case Sig: func = "Sign"; break;
case Add: func = "Addition"; break;
case Sub: func = "Subtraction"; break;
case Mul: func = "Multiplication"; break;
case Atn: func = "Arc Tangent"; break;
case Log: func = "Logarithm"; break;
case Exp: func = "Exponantial"; break;
+ case Qui: func = "Quit"; break;
+ case Hel: func = "Help"; break;
}
PRINTOUT ("Function: %s\n", func);
}
}
+/* quit function */
+
+void quit (void)
+{
+ PRINTOUT ("bye\n");
+ exit (0);
+}
+
+/* help message */
+
+void help (void)
+{
+ PRINTOUT ("calc is a simple calculator\n\n");
+ PRINTOUT ("supported operators:\n");
+ PRINTOUT (" + - * / %% ^\n\n");
+ PRINTOUT ("supported functions:\n");
+ PRINTOUT (" pow sqrt cos sin atan log exp\n\n");
+ PRINTOUT ("miscellaneous functions:\n");
+ PRINTOUT (" quit help\n");
+}
+
/* evaluate element tree */
-double evaluate_element (element_t *root)
+#define MASK_SUB 0x1
+#define MASK_DIV 0x2
+
+double evaluate_element (element_t *root, char mask)
{
double op0 = 0, op1 = 0;
+ char nextmask = mask;
if ((root == NULL) || (root == ERROR_OP)) {
VERBOSE (WARNING, PRINTOUT ("error while evaluating\n"));
return 0;
}
+ /* mask to manage sub operator sub and div */
+ switch (root->func) {
+ case Add:
+ nextmask &= ~MASK_SUB;
+ nextmask &= ~MASK_DIV;
+ break;
+ case Sub:
+ nextmask |= MASK_SUB;
+ nextmask &= ~MASK_DIV;
+ break;
+ case Mul:
+ nextmask &= ~MASK_DIV;
+ break;
+ case Div:
+ nextmask |= MASK_DIV;
+ break;
+ default:
+ nextmask = mask;
+ }
+
switch (root->func) {
case Val:
- if (root->ops[0]) {
- return evaluate_element (root->ops[0]);
- } else {
- return root->value;
- }
+ case Sig:
+ op0 = (root->ops[0]) ? evaluate_element (root->ops[0], nextmask) : root->value;
break;
case Add:
case Sub:
case Mod:
case Pow:
if (root->ops[1]) {
- op1 = evaluate_element (root->ops[1]);
+ op1 = evaluate_element (root->ops[1], nextmask);
} else {
VERBOSE (WARNING, PRINTOUT ("error while evaluating (op[1])\n"));
return 0;
case Log:
case Exp:
if (root->ops[0]) {
- op0 = evaluate_element (root->ops[0]);
+ op0 = evaluate_element (root->ops[0], 0);
} else {
VERBOSE (WARNING, PRINTOUT ("error while evaluating (op[0])\n"));
return 0;
}
+ break;
+ case Qui:
+ case Hel:
+ break;
}
switch (root->func) {
- case Add: return op0 + op1;
- case Sub: return op0 - op1;
- case Mul: return op0 * op1;
- case Div: return op0 / op1;
+ case Val: return op0;
+ case Sig: return -op0;
+ case Add: return ((mask & MASK_SUB) == 0) ? op0 + op1 : op0 - op1;
+ case Sub: return ((mask & MASK_SUB) == 0) ? op0 - op1 : op0 + op1;
+ case Mul: return ((mask & MASK_DIV) == 0) ? op0 * op1 : op0 / op1;
+ case Div: return ((mask & MASK_DIV) == 0) ? op0 / op1 : op0 * op1;
case Mod: return fmod (op0, op1);
case Pow: return pow (op0, op1);
case Sqr: return sqrt (op0);
case Atn: return atan (op0);
case Log: return log (op0);
case Exp: return exp (op0);
- default: break;
+ case Qui: quit (); break;
+ case Hel: help (); break;
}
return 0;