X-Git-Url: https://secure.softndesign.org/git/?a=blobdiff_plain;f=parser.c;h=223b173bafd76faf34ba7ac0eca01f7b438d1965;hb=a28ab26a7d2d420a63cbbfdec0d2450263ecc352;hp=4e360ddaf70bec25ea4cb46ad72bd2bb12aa276e;hpb=a9a3da22ab3f1bf022fc02443494006bca82ed45;p=calc.git

diff --git a/parser.c b/parser.c
index 4e360dd..223b173 100644
--- a/parser.c
+++ b/parser.c
@@ -16,6 +16,9 @@ double answer = 0;
 int storage_size = -1;
 double *storage = NULL;
 
+int argument_size = 0;
+double *argument = NULL;
+
 int stack_size = 0;
 double *stack = NULL;
 
@@ -134,7 +137,7 @@ keyword_t operators[NB_OPERATORS] = {
     { "|",   Or, 2, 1, -2}
 };
 
-#define NB_FUNCTIONS 41
+#define NB_FUNCTIONS 50
 keyword_t functions[NB_FUNCTIONS] = {
     { "sqrt", Sqr, 1, 4, 5},
     { "pow",  Pow, 2, 3, 5},
@@ -157,7 +160,7 @@ keyword_t functions[NB_FUNCTIONS] = {
     { "inc",  Inc, 1, 3, 5},
     { "dec",  Dec, 1, 3, 5},
     { "disp", Disp, 0, 4, 9},
-    { "mem",  Mem, 1, 3, 9},
+    { "mem",  Mem, 1, 3, 5},
     { "clr",  Clear, 0, 3, 9},
     { "quit", Quit, 0, 4, 9},
     { "help", Help, 0, 4, 9},
@@ -165,7 +168,8 @@ keyword_t functions[NB_FUNCTIONS] = {
     { "cond", Cond, 3, 4, 5},
     { "while", While, 2, 5, 5},
     { "print", Print, 1, 5, 5},
-    { "prog", Prog, 3, 4, 9},
+    { "prog", Prog, 2, 4, 9},
+    { "arg",  Arg, 1, 3, 5},
     { "call", Call, MAX_ARGS, 4, 5},
     { "ls",   List, 0, 2, 9},
     { "edit", Edit, 1, 4, 9},
@@ -175,8 +179,16 @@ keyword_t functions[NB_FUNCTIONS] = {
     { "pop",  Pop, 0, 3, 5},
     { "push", Push, 1, 4, 5},
     { "put",  Put, 2, 3, 5},
-    { "set",  Set, MAX_ARGS, 3, 9},
-    { "show",  Show, 0, 4, 9},
+    { "set",  Set, MAX_ARGS, 3, 5},
+    { "show", Show, 0, 4, 5},
+    { "max",  Max, 2, 3, 5},
+    { "mean", Mean, 2, 4, 5},
+    { "med",  Median, 0, 3, 5},
+    { "min",  Min, 2, 3, 5},
+    { "ord",  Order, 0, 3, 5},
+    { "prod", Prod, 0, 4, 5},
+    { "sum",  Sum, 0, 3, 5},
+    { "var",  Variance, 2, 3, 5},
 };
 
 #define NB_CONSTANTS 3
@@ -265,14 +277,14 @@ element_t *parser (char *str, char **next, int prio)
                     delelement (root);
                     return ERROR_OP;
                 }
-                element_t *newprog = newelement (Code, root->nbops + 1, 5);
+                element_t *newcode = newelement (Code, root->nbops + 1, 5);
                 for (i = 0; i < root->nbops; i++) {
-                    newprog->ops[i] = root->ops[i];
+                    newcode->ops[i] = root->ops[i];
                     root->ops[i] = NULL;
                 }
-                newprog->ops[root->nbops] = new;
+                newcode->ops[root->nbops] = new;
                 delelement (root);
-                root = newprog;
+                root = newcode;
             } while (*str == ',');
 
             if (*str != '}') {
@@ -355,7 +367,11 @@ element_t *parser (char *str, char **next, int prio)
             keyword_t *operator = operators + i;
             if (codecmp (operator->keyword, str) == 0) {
                 VERBOSE (DEBUG, fprintf (stdout, "start processing operator\n"));
-                if (root) {
+                if ((root) && (root->prio == 9)) {
+                    VERBOSE (DEBUG, fprintf (stdout, "terminal function (%d)\n", root->func));
+                    delelement (root);
+                    return ERROR_OP;
+                } else if (root) {
                     if ((prio) && (prio > operator->prio)) {
                         VERBOSE (DEBUG, fprintf (stdout, "stop because operator priority\n"));
                         *next = str;
@@ -368,7 +384,7 @@ element_t *parser (char *str, char **next, int prio)
                         return ERROR_OP;
                     }
                 } else if (*str == '-') {
-                    root = newelement (Sig, 1, 9);
+                    root = newelement (Sig, 1, 6);
                 } else {
                     return ERROR_OP;
                 }
@@ -561,6 +577,7 @@ void print_element (element_t *root, int level)
     case Code: func = "Code"; break;
     case Print: func = "Print"; break;
     case Prog: func = "Program"; break;
+    case Arg: func = "Argument"; break;
     case Call: func = "Call"; break;
     case List: func = "List"; break;
     case Edit: func = "Edit"; break;
@@ -572,6 +589,14 @@ void print_element (element_t *root, int level)
     case Put: func = "Put"; break;
     case Set: func = "Set"; break;
     case Show: func = "Show"; break;
+    case Max: func = "Maximum"; break;
+    case Mean: func = "Mean"; break;
+    case Median: func = "Median"; break;
+    case Min: func = "Minimum"; break;
+    case Order: func = "Order"; break;
+    case Prod: func = "Product"; break;
+    case Sum: func = "Sum"; break;
+    case Variance: func = "Variance"; break;
     }
 
     fprintf (stdout, "Function: %s\n", func);
@@ -764,7 +789,7 @@ void quit (void)
 
 /* program function */
 
-void prog (int id, int nbmems, element_t *root)
+void prog (int id, element_t *root)
 {
     int i, n = -1;
 
@@ -814,17 +839,28 @@ void prog (int id, int nbmems, element_t *root)
     /* set program */
     (programs + n)->id = id;
     (programs + n)->answer = 0;
-    (programs + n)->storage = (double *) callocordie (nbmems, sizeof (double));
-    (programs + n)->storage_size = nbmems;
+    (programs + n)->storage = NULL;
+    (programs + n)->storage_size = 0;
     (programs + n)->stack = NULL;
     (programs + n)->stack_size = 0;
     (programs + n)->root = dupelement (root);
 }
 
-double call (int id, int nbops, element_t **ops)
+double arg (int id)
+{
+    double ret = 0;
+    if ((id <= 0) || (id > argument_size)) {
+        VERBOSE (WARNING, fprintf (stdout, "error out of bound (%d/%d)\n", id, argument_size));
+    } else {
+        ret = argument[id - 1];
+    }
+    return ret;
+}
+
+double call (int id, int nbargs, element_t **args)
 {
     workspace_t tmp = {0};
-    int i, n = -1;
+    int i, l, n = -1;
     double ret = 0;
 
     if (programs) {
@@ -844,6 +880,8 @@ double call (int id, int nbops, element_t **ops)
 
     /* store context */
     tmp.answer = answer;
+    tmp.argument = argument;
+    tmp.argument_size = argument_size;
     tmp.storage = storage;
     tmp.storage_size = storage_size;
     tmp.stack = stack;
@@ -853,30 +891,40 @@ double call (int id, int nbops, element_t **ops)
     answer = 0;
     storage = (programs + n)->storage;
     storage_size = (programs + n)->storage_size;
+    argument = NULL;
+    argument_size = 0;
     stack = (programs + n)->stack;
     stack_size = (programs + n)->stack_size;
-    if (nbops > storage_size) {
-        double *tmp = (double *) callocordie (nbops, sizeof (double));
-        memcpy (tmp, storage, storage_size * sizeof (double));
-        free (storage);
-        (programs + n)->storage = storage = tmp;
-        (programs + n)->storage_size = storage_size = nbops;
-    }
-    for (i = 0; i < nbops; i++) {
-        double val = evaluate_element (ops[i], 0);
-        store (i + 1, val);
+    if (nbargs > 0) {
+        argument = (double *) callocordie (nbargs, sizeof (double));
+        for (i = 0, l = 0; i < nbargs; l++) {
+            if (args[l]) {
+                argument[i++] = evaluate_element (args[l], 0);
+            }
+        }
+        argument_size = nbargs;
     }
 
     /* evaluate program */
     element_t *elements = dupelement ((programs + n)->root);
     ret = evaluate_element (elements, 0);
     delelement (elements);
+    (programs + n)->answer = answer;
+    (programs + n)->storage = storage;
+    (programs + n)->storage_size = storage_size;
+    if (argument) {
+        free (argument);
+    }
+    (programs + n)->stack = stack;
+    (programs + n)->stack_size = stack_size;
 
     /* restore context */
     answer = tmp.answer;
     storage = tmp.storage;
-    storage = tmp.storage;
-    stack_size = tmp.stack_size;
+    storage_size = tmp.storage_size;
+    argument = tmp.argument;
+    argument_size = tmp.argument_size;
+    stack = tmp.stack;
     stack_size = tmp.stack_size;
 
     return ret;
@@ -939,7 +987,9 @@ void savestring (int id, char *string)
     //    free ((programs + n)->string);
     //}
 
-    (programs + n)->string = strdup (string);
+    if (string) {
+        (programs + n)->string = strdup (string);
+    }
 }
 
 void del (int id)
@@ -1079,6 +1129,140 @@ void show (void)
     fprintf (stdout, "\n");
 }
 
+/* stack functions */
+
+double max ()
+{
+    double ret = 0;
+    int i;
+    if (stack_size < 1) {
+        VERBOSE (WARNING, fprintf (stdout, "error not enough element in stack (%d)\n", stack_size));
+        return 0;
+    }
+    ret = stack[0];
+    for (i = 1; i < stack_size; i++) {
+        if (stack[i] > ret) {
+            ret = stack[i];
+        }
+    }
+    return ret;
+}
+
+double mean ()
+{
+    double ret = 0;
+    int i;
+    if (stack_size < 1) {
+        VERBOSE (WARNING, fprintf (stdout, "error not enough element in stack (%d)\n", stack_size));
+        return 0;
+    }
+    for (i = 0; i < stack_size; i++) {
+        ret += stack[i];
+    }
+    return ret / stack_size;
+}
+
+double min ()
+{
+    double ret = 0;
+    int i;
+    if (stack_size < 1) {
+        VERBOSE (WARNING, fprintf (stdout, "error not enough element in stack (%d)\n", stack_size));
+        return 0;
+    }
+    ret = stack[0];
+    for (i = 1; i < stack_size; i++) {
+        if (stack[i] < ret) {
+            ret = stack[i];
+        }
+    }
+    return ret;
+}
+
+void order ()
+{
+    int i, j;
+    if (stack_size < 1) {
+        VERBOSE (WARNING, fprintf (stdout, "error not enough element in stack (%d)\n", stack_size));
+        return;
+    }
+    for (i = 0; i < stack_size - 1; i++) {
+        int done = 0;
+        for (j = 0; j < stack_size - 1; j++) {
+            if (stack[j] > stack[j + 1]) {
+                double tmp = stack[j];
+                stack[j] = stack[j + 1];
+                stack[j + 1] = tmp;
+                done = 1;
+            }
+        }
+        if (done == 0) {
+            break;
+        }
+    }
+}
+
+double median ()
+{
+    double ret = 0;
+    if (stack_size < 3) {
+        VERBOSE (WARNING, fprintf (stdout, "error not enough element in stack (%d)\n", stack_size));
+        return 0;
+    }
+    double *tmp = (double *) callocordie (stack_size, sizeof (double));
+    memcpy (tmp, stack, stack_size * sizeof (double));
+    order ();
+    ret = stack[(stack_size - 1)/ 2];
+    memcpy (stack, tmp, stack_size * sizeof (double));
+    free (tmp);
+    return ret;
+}
+
+double prod ()
+{
+    double ret = 1;
+    int i;
+    if (stack_size < 1) {
+        VERBOSE (WARNING, fprintf (stdout, "error not enough element in stack (%d)\n", stack_size));
+        return 0;
+    }
+    for (i = 0; i < stack_size; i++) {
+        ret *= stack[i];
+    }
+    return ret;
+}
+
+double sum ()
+{
+    double ret = 0;
+    int i;
+    if (stack_size < 1) {
+        VERBOSE (WARNING, fprintf (stdout, "error not enough element in stack (%d)\n", stack_size));
+        return 0;
+    }
+    for (i = 0; i < stack_size; i++) {
+        ret += stack[i];
+    }
+    return ret;
+}
+
+double variance ()
+{
+    double ret = 0;
+    double m = 0;
+    int i;
+    if (stack_size < 2) {
+        VERBOSE (WARNING, fprintf (stdout, "error not enough element in stack (%d)\n", stack_size));
+        return 0;
+    }
+    m = mean ();
+    for (i = 0; i < stack_size; i++) {
+        ret += (stack[i] - m) * (stack[i] - m);
+    }
+    return ret / stack_size;
+}
+
+
 /* help message */
 
 void help (void)
@@ -1103,9 +1287,11 @@ void help (void)
     fprintf (stdout, "control flow prim.:");
     fprintf (stdout, " cond print while {} ;\n");
     fprintf (stdout, "program management:");
-    fprintf (stdout, " call del edit ls prog\n");
+    fprintf (stdout, " arg call del edit ls prog\n");
     fprintf (stdout, "stack management:");
     fprintf (stdout, " get len pop push put set show\n");
+    fprintf (stdout, "stack func.:");
+    fprintf (stdout, " max mean med min ord prod sum var\n");
     fprintf (stdout, "control management:");
     fprintf (stdout, " help quit\n");
     fprintf (stdout, "constants:");
@@ -1168,7 +1354,6 @@ double evaluate_element (element_t *root, char mask)
     case Lt:
     case And:
     case Or:
-    case Prog:
         if (root->ops[1]) {
             op1 = evaluate_element (root->ops[1], nextmask);
         } else if (root->func != Store) {
@@ -1197,6 +1382,8 @@ double evaluate_element (element_t *root, char mask)
     case Not:
     case Mem:
     case Cond:
+    case Prog:
+    case Arg:
     case Call:
     case Edit:
     case Del:
@@ -1221,6 +1408,10 @@ double evaluate_element (element_t *root, char mask)
     case Pop:
     case Set:
     case Show:
+    case Median:
+    case Order:
+    case Prod:
+    case Sum:
         break;
     case While:
         if (root->ops[0] == NULL) {
@@ -1241,6 +1432,14 @@ double evaluate_element (element_t *root, char mask)
         }
         op1 = (root->ops[1]) ? evaluate_element (root->ops[1], 0) : answer;
         break;
+    case Max:
+    case Mean:
+    case Min:
+    case Variance:
+        if (root->ops[0]) {
+            op0 = evaluate_element (root->ops[0], 0);
+            op1 = (root->ops[1]) ? evaluate_element (root->ops[1], 0) : answer;
+        }
     }
 
     switch (root->func) {
@@ -1300,9 +1499,10 @@ double evaluate_element (element_t *root, char mask)
     case Code: return execute_code (root->ops, root->nbops);
     case Print: return print (op0);
     case Prog:
-        prog ((int)op0, (int)op1, root->ops[2]);
+        prog ((int)op0, root->ops[1]);
         savestring ((int)op0, root->string);
         break;
+    case Arg: return arg ((int)op0);
     case Call:
         for (i = 1, nb =0; i < root->nbops; i++) {
             if (root->ops[i]) {
@@ -1326,6 +1526,33 @@ double evaluate_element (element_t *root, char mask)
         }
         return set (nb, root->ops);
     case Show: show (); break;
+    case Max:
+        if (root->ops[0]) {
+            return op0 > op1 ? op0 : op1;
+        }
+        return max ();
+    case Mean:
+        if (root->ops[0]) {
+            return (op0 + op1) / 2;
+        }
+        return mean ();
+    case Median: return median ();
+    case Min:
+        if (root->ops[0]) {
+            return op0 < op1 ? op0 : op1;
+        }
+        return min ();
+    case Order: order (); break;
+    case Prod: return prod ();
+    case Sum: return sum ();
+    case Variance:
+        if (root->ops[0]) {
+            double m = (op0 + op1) / 2;
+            op0 -= m;
+            op1 -= m;
+            return op0 * op0 + op1 * op1;
+        }
+        return variance ();
     }
 
     return 0;