add some coverage tests

[calc.git] / parser.c

diff --git a/parser.c b/parser.c
index 9796048af19e5f8d552a682fef0c1afc564fd799..c70a15cfde5b65282851d52587cd3920971c317f 100644 (file)
--- a/parser.c
+++ b/parser.c
@@ -2,6 +2,7 @@
 #include <math.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 
 #include "debug.h"
 
@@ -14,6 +15,8 @@ double answer = 0;
 #define STORAGE_SIZE 10
 double storage[STORAGE_SIZE] = {0};
 
+char format[9] = "=> %..g\n";
+
 /* compare codes */
 
 int codecmp (char *ref, char *str)
@@ -115,15 +118,21 @@ keyword_t operators[NB_OPERATORS] = {
     { "|",   Or, 2, 1, -2}
 };
 
-#define NB_FUNCTIONS 17
+#define NB_FUNCTIONS 24
 keyword_t functions[NB_FUNCTIONS] = {
     { "sqrt", Sqr, 1, 4, 5},
     { "pow",  Pow, 2, 3, 5},
     { "cos",  Cos, 1, 3, 5},
     { "sin",  Sin, 1, 3, 5},
+    { "tan",  Tan, 1, 3, 5},
+    { "acos", Acos, 1, 4, 5},
+    { "asin", Asin, 1, 4, 5},
     { "atan", Atan, 1, 4, 5},
-    { "exp",  Exp, 1, 3, 5},
     { "log",  Log, 1, 3, 5},
+    { "exp",  Exp, 1, 3, 5},
+    { "abs",  Abs, 1, 3, 5},
+    { "floor", Floor, 1, 5, 5},
+    { "ceil", Ceil, 1, 4, 5},
     { "sto",  Store, 2, 3, 5},
     { "rcl",  Recall, 1, 3, 5},
     { "inc",  Inc, 1, 3, 5},
@@ -133,7 +142,8 @@ keyword_t functions[NB_FUNCTIONS] = {
     { "help", Help, 0, 4, 9},
     { "!",    Not, 1, 1, 6},
     { "cond", Cond, 3, 4, 5},
-    { "whl",  While, 2, 3, 5}
+    { "while", While, 2, 5, 5},
+    { "print", Print, 1, 5, 5}
 };
 
 #define NB_CONSTANTS 3
@@ -143,6 +153,11 @@ keyword_t constants[NB_CONSTANTS] = {
     { "pi",  Pi, 0, 2, 5}
 };
 
+#define NB_SYMBOLS 4
+char *symbols[NB_SYMBOLS] = {
+    "(", ")", "{", "}"
+};
+
 /* subparser function */
 
 element_t *subparser (element_t **proot, char **pstr, func_t func, int nbops, int prio)
@@ -463,9 +478,15 @@ void print_element (element_t *root, int level)
     case Sqr: func = "Square Root"; break;
     case Cos: func = "Cosine"; break;
     case Sin: func = "Sine"; break;
+    case Tan: func = "Tangent"; break;
+    case Acos: func = "Arc Cosine"; break;
+    case Asin: func = "Arc Sine"; break;
     case Atan: func = "Arc Tangent"; break;
     case Log: func = "Logarithm"; break;
     case Exp: func = "Exponantial"; break;
+    case Abs: func = "Absolute value"; break;
+    case Ceil: func = "Ceil value"; break;
+    case Floor: func = "Floor value"; break;
     case Store: func = "Store"; break;
     case Recall: func = "Recall"; break;
     case Inc: func = "Increase"; break;
@@ -488,6 +509,7 @@ void print_element (element_t *root, int level)
     case Cond: func = "Condition"; break;
     case While: func = "While"; break;
     case Prog: func = "Program"; break;
+    case Print: func = "Print"; break;
     }
 
     fprintf (stdout, "Function: %s\n", func);
@@ -614,12 +636,16 @@ void help (void)
     fprintf (stdout, " == != >= <= > <\n");
     fprintf (stdout, "logical operators:");
     fprintf (stdout, " & | !\n");
+    fprintf (stdout, "mathematic functions:");
+    fprintf (stdout, " pow sqrt log exp\n");
+    fprintf (stdout, "trigonometric functions:");
+    fprintf (stdout, " cos sin tan acos asin atan\n");
     fprintf (stdout, "supported functions:");
-    fprintf (stdout, " pow sqrt cos sin atan log exp\n");
+    fprintf (stdout, " abs ceil floor\n");
     fprintf (stdout, "storage functions:");
     fprintf (stdout, " sto rcl inc dec\n");
     fprintf (stdout, "conditional functions:");
-    fprintf (stdout, " cond\n");
+    fprintf (stdout, " cond while print {}\n");
     fprintf (stdout, "miscellaneous functions:");
     fprintf (stdout, " quit help\n");
     fprintf (stdout, "supported constants:");
@@ -691,9 +717,15 @@ double evaluate_element (element_t *root, char mask)
     case Sqr:
     case Cos:
     case Sin:
+    case Tan:
+    case Acos:
+    case Asin:
     case Atan:
     case Log:
     case Exp:
+    case Abs:
+    case Ceil:
+    case Floor:
     case Recall:
     case Inc:
     case Dec:
@@ -720,6 +752,9 @@ double evaluate_element (element_t *root, char mask)
             return 0;
         }
         break;
+    case Print:
+        op0 = (root->ops[0]) ? evaluate_element (root->ops[0], 0) : answer;
+        break;
     }
 
     switch (root->func) {
@@ -734,9 +769,15 @@ double evaluate_element (element_t *root, char mask)
     case Sqr: return sqrt (op0);
     case Cos: return cos (op0);
     case Sin: return sin (op0);
+    case Tan: return tan (op0);
+    case Acos: return acos (op0);
+    case Asin: return asin (op0);
     case Atan: return atan (op0);
     case Log: return log (op0);
     case Exp: return exp (op0);
+    case Abs: return fabs (op0);
+    case Ceil: return ceil (op0);
+    case Floor: return floor (op0);
     case Store: return store ((int)op0, (op1) ? op1 : answer);
     case Recall: return recall ((int)op0);
     case Inc: return increase ((int)op0);
@@ -766,9 +807,70 @@ double evaluate_element (element_t *root, char mask)
         }
     case While: return while_do (root->ops[0], root->ops[1]);
     case Prog: return program_do (root->ops, root->nbops);
+    case Print: printf (format, op0); return op0;
     }
 
     return 0;
 }
 
+char **generate_completion_list ()
+{
+    int i, j, l = 0;
+    char **list = (char **) calloc (NB_OPERATORS + NB_FUNCTIONS + NB_CONSTANTS + NB_SYMBOLS + 1, sizeof (char *));
+    if (list == NULL) {
+        VERBOSE (ERROR, fprintf (stderr, "can't allocate memory\n"));
+        exit (1);
+    }
+
+    for (i = 0; i < NB_OPERATORS; i++) {
+        list[l] = strdup ((operators + i)->keyword);
+        for (j = 0; j < (int)strlen (list[l]); j++) {
+            if (list[i][j] == '\t') {
+                list[i][j] = '\0';
+            }
+        }
+        if (list[l] != NULL) {
+            l++;
+        }
+    }
+
+    for (i = 0; i < NB_FUNCTIONS; i++) {
+        list[l] = strdup ((functions + i)->keyword);
+        if (list[l] != NULL) {
+            l++;
+        }
+    }
+
+    for (i = 0; i < NB_CONSTANTS; i++) {
+        list[l] = strdup ((constants + i)->keyword);
+        if (list[l] != NULL) {
+            l++;
+        }
+    }
+
+    for (i = 0; i < NB_SYMBOLS; i++) {
+        list[l] = strdup (symbols[i]);
+        if (list[l] != NULL) {
+            l++;
+        }
+    }
+
+    return (list);
+}
+
+void free_completion_list (char **list)
+{
+    int i;
+
+    if (list) {
+        for (i = 0; i < NB_FUNCTIONS + NB_CONSTANTS; i++) {
+            if (list[i] != NULL) {
+                free (list[i]);
+            }
+        }
+        free (list);
+    }
+}
+
+
 /* vim: set ts=4 sw=4 et: */