add covering rule

[calc.git] / parser.c

diff --git a/parser.c b/parser.c
index 02443079228e3385b361b5e2f027152ad48f18ad..fdabef2bf15e6c3848c87824b6a55b44fbc18169 100644 (file)
--- a/parser.c
+++ b/parser.c
@@ -47,27 +47,50 @@ element_t *newelement (func_t function, int nbops, int prio)
 
 /* functions */
 
-#define NB_OPERATORS 5
+#define NB_OPERATORS 6
 
 keyword_t operators[NB_OPERATORS] = {
     { "+\t", Add, 2, 1, 1},
     { "-\t", Sub, 2, 1, 1},
     { "*",   Mul, 2, 1, 2},
     { "/",   Div, 2, 1, 2},
-    { "^",   Pow, 2, 1, 3}
+    { "%",   Mod, 2, 1, 3},
+    { "^",   Pow, 2, 1, 4}
 };
 
 #define NB_FUNCTIONS 7
 keyword_t functions[NB_FUNCTIONS] = {
-    { "sqrt", Sqr, 1, 4, 4},
-    { "pow",  Pow, 2, 3, 4},
-    { "cos",  Cos, 1, 3, 4},
-    { "sin",  Sin, 1, 3, 4},
-    { "atan", Atn, 1, 4, 4},
-    { "exp",  Exp, 1, 3, 4},
-    { "log",  Log, 1, 3, 4}
+    { "sqrt", Sqr, 1, 4, 5},
+    { "pow",  Pow, 2, 3, 5},
+    { "cos",  Cos, 1, 3, 5},
+    { "sin",  Sin, 1, 3, 5},
+    { "atan", Atn, 1, 4, 5},
+    { "exp",  Exp, 1, 3, 5},
+    { "log",  Log, 1, 3, 5}
 };
 
+/* subparser function */
+
+element_t *subparser (element_t **proot, char **pstr, func_t func, int nbops, int prio)
+{
+    element_t *new = newelement (func, nbops, prio);
+    if (new == NULL) {
+        return ERROR_OP;
+    }
+    new->ops[0] = *proot;
+    new->ops[1] = parser (*pstr, pstr, new->prio);
+    if (new->ops[1] == ERROR_OP) {
+        return ERROR_OP;
+    }
+    *proot = newelement (Val, 1, 4);
+    if (*proot == ERROR_OP) {
+        return ERROR_OP;
+    }
+    (*proot)->ops[0] = new;
+
+    return *proot;
+}
+
 /* parser function */
 
 element_t *parser (char *str, char **next, int prio)
@@ -145,26 +168,15 @@ element_t *parser (char *str, char **next, int prio)
                 VERBOSE (DEBUG, PRINTOUT ("start processing operator\n"));
                 if (root) {
                     if ((prio) && (prio > operator->prio)) {
-                        VERBOSE (DEBUG, PRINTOUT ("stop processing operator because operator priority\n"));
+                        VERBOSE (DEBUG, PRINTOUT ("stop because operator priority\n"));
                         *next = str;
                         return root;
                     }
                     str += operator->offset;
                     VERBOSE (INFO, PRINTOUT ("Oper: %d\n", operator->func));
-                    new = newelement (operator->func, operator->nbops, operator->prio);
-                    if (new == NULL) {
+                    if (subparser (&root, &str, operator->func, operator->nbops, operator->prio) == ERROR_OP) {
                         return ERROR_OP;
                     }
-                    new->ops[0] = root;
-                    new->ops[1] = parser (str, &str, new->prio);
-                    if (new->ops[1] == ERROR_OP) {
-                        return ERROR_OP;
-                    }
-                    root = newelement (Val, 1, 4);
-                    if (root == ERROR_OP) {
-                        return ERROR_OP;
-                    }
-                    root->ops[0] = new;
                 } else {
                     return ERROR_OP;
                 }
@@ -212,29 +224,30 @@ element_t *parser (char *str, char **next, int prio)
             float value = strtof (str, &pt);
             VERBOSE (INFO, PRINTOUT ("Value: %f\n", value));
             if (str != pt) {
-                new = newelement (Val, 1, 4);
-                if (new == NULL) {
-                    return ERROR_OP;
-                }
-                new->value = value;
                 if (root == NULL) {
+                    new = newelement (Val, 1, 4);
+                    if (new == NULL) {
+                        return ERROR_OP;
+                    }
+                    new->value = value;
                     root = new;
+                    str = pt;
                 } else if (root->func == Val) {
                     if ((*str == '+') || (*str == '-')) {
-                        element_t *add = newelement (Add, 2, 1);
-                        if (add == NULL) {
+                        if ((prio) && (prio > 1)) {
+                            VERBOSE (DEBUG, PRINTOUT ("stop because operator priority\n"));
+                            *next = str;
+                            return root;
+                        }
+                        if (subparser (&root, &str, Add, 2, 1) == ERROR_OP) {
                             return ERROR_OP;
                         }
-                        add->ops[0] = root;
-                        add->ops[1] = new;
-                        root = add;
                     } else {
                         return ERROR_OP;
                     }
                 } else {
                     return ERROR_OP;
                 }
-                str = pt;
                 found = 1;
             }
             VERBOSE (DEBUG, PRINTOUT ("stop processing value\n"));
@@ -275,6 +288,7 @@ void print_element (element_t *root, int level)
     case Sub: func = "Subtraction"; break;
     case Mul: func = "Multiplication"; break;
     case Div: func = "Division"; break;
+    case Mod: func = "Modulo"; break;
     case Pow: func = "Power"; break;
     case Sqr: func = "Square Root"; break;
     case Cos: func = "Cosine"; break;
@@ -321,6 +335,7 @@ double evaluate_element (element_t *root)
     case Sub:
     case Mul:
     case Div:
+    case Mod:
     case Pow:
         if (root->ops[1]) {
             op1 = evaluate_element (root->ops[1]);
@@ -348,6 +363,7 @@ double evaluate_element (element_t *root)
     case Sub: return op0 - op1;
     case Mul: return op0 * op1;
     case Div: return op0 / op1;
+    case Mod: return fmod (op0, op1);
     case Pow: return pow (op0, op1);
     case Sqr: return sqrt (op0);
     case Cos: return cos (op0);