X-Git-Url: https://secure.softndesign.org/git/?a=blobdiff_plain;f=parser.c;h=eba4fb7cf62e635927735e9912ad66bb9e734d12;hb=3559b26cba4b13ce35a27aed478b3a5e0433be31;hp=5333a9c4a06ee01163a972a544777eb2cde1977f;hpb=2d0cd54c457714ca3eb97cfad3cc892612248353;p=calc.git diff --git a/parser.c b/parser.c index 5333a9c..eba4fb7 100644 --- a/parser.c +++ b/parser.c @@ -1,10 +1,15 @@ -#include #include #include #include #include +#include "alloc.h" #include "debug.h" +#include "element.h" +#include "format.h" +#include "program.h" +#include "stack.h" +#include "storage.h" #include "parser.h" @@ -12,11 +17,6 @@ double answer = 0; -#define STORAGE_SIZE 10 -double storage[STORAGE_SIZE] = {0}; - -char *format = NULL; - /* compare codes */ int codecmp (char *ref, char *str) @@ -39,67 +39,10 @@ int codecmp (char *ref, char *str) return 0; } -/* allocate new element */ - -element_t *newelement (func_t function, int nbops, int prio) -{ - element_t *new = (element_t *) calloc (1, sizeof (element_t)); - if (new == NULL) { - VERBOSE (ERROR, fprintf (stderr, "can't allocate memory\n")); - exit (1); - } - if (nbops) { - new->ops = (element_t **) calloc (nbops, sizeof (element_t *)); - if (new->ops == NULL) { - VERBOSE (ERROR, fprintf (stderr, "can't allocate memory\n")); - exit (1); - } - } - new->func = function; - new->nbops = nbops; - new->prio = prio; - - return new; -} - -/* desallocate element */ - -void delelement (element_t *root) -{ - if ((root != NULL) && (root != ERROR_OP)) { - int i; - for (i = 0; i < root->nbops; i++) { - if ((root->ops[i] != NULL) && (root->ops[i] != ERROR_OP)) { - delelement (root->ops[i]); - } - } - if (root->nbops) { - free (root->ops); - } - free (root); - } -} - -/* duplicate element */ - -element_t *dupelement (element_t *root) -{ - element_t *tmp = NULL; - int i; - - if ((root == NULL) || (root == ERROR_OP)) { - return root; - } - tmp = newelement (root->func, root->nbops, root->prio); - tmp->value = root->value; - for (i = 0; i < root->nbops; i++) { - tmp->ops[i] = dupelement (root->ops[i]); - } - return tmp; -} - /* functions */ +#define MAX_ARGS 100 + #define NB_OPERATORS 14 keyword_t operators[NB_OPERATORS] = { { "+\t", Add, 2, 1, 1}, @@ -118,7 +61,7 @@ keyword_t operators[NB_OPERATORS] = { { "|", Or, 2, 1, -2} }; -#define NB_FUNCTIONS 24 +#define NB_FUNCTIONS 50 keyword_t functions[NB_FUNCTIONS] = { { "sqrt", Sqr, 1, 4, 5}, { "pow", Pow, 2, 3, 5}, @@ -128,8 +71,11 @@ keyword_t functions[NB_FUNCTIONS] = { { "acos", Acos, 1, 4, 5}, { "asin", Asin, 1, 4, 5}, { "atan", Atan, 1, 4, 5}, + { "ln", Ln, 1, 2, 5}, { "log", Log, 1, 3, 5}, { "exp", Exp, 1, 3, 5}, + { "erfc", Erfc, 1, 4, 5}, + { "erf", Erf, 1, 3, 5}, { "abs", Abs, 1, 3, 5}, { "floor", Floor, 1, 5, 5}, { "ceil", Ceil, 1, 4, 5}, @@ -138,12 +84,35 @@ keyword_t functions[NB_FUNCTIONS] = { { "inc", Inc, 1, 3, 5}, { "dec", Dec, 1, 3, 5}, { "disp", Disp, 0, 4, 9}, + { "mem", Mem, 1, 3, 5}, + { "clr", Clear, 0, 3, 9}, { "quit", Quit, 0, 4, 9}, { "help", Help, 0, 4, 9}, { "!", Not, 1, 1, 6}, { "cond", Cond, 3, 4, 5}, { "while", While, 2, 5, 5}, - { "print", Print, 1, 5, 5} + { "print", Print, 1, 5, 5}, + { "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}, + { "del", Del, 1, 3, 9}, + { "get", Get, 1, 3, 5}, + { "len", Length, 0, 3, 5}, + { "pop", Pop, 0, 3, 5}, + { "push", Push, 1, 4, 5}, + { "put", Put, 2, 3, 5}, + { "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 @@ -185,6 +154,7 @@ element_t *subparser (element_t **proot, char **pstr, func_t func, int nbops, in element_t *parser (char *str, char **next, int prio) { element_t *root = NULL; + char *string = str; int i; VERBOSE (DEBUG, fprintf (stdout, "Starting parsing\n")); @@ -219,10 +189,7 @@ element_t *parser (char *str, char **next, int prio) delelement (root); return ERROR_OP; } - element_t **prog = NULL; - new = newelement (Prog, 0, 5); - root = new; - prog = &root; + root = newelement (Code, 0, 5); do { new = parser (str + 1, &str, 0); @@ -234,14 +201,14 @@ element_t *parser (char *str, char **next, int prio) delelement (root); return ERROR_OP; } - element_t *newprog = newelement (Prog, (*prog)->nbops + 1, 5); - for (i = 0; i < (*prog)->nbops; i++) { - newprog->ops[i] = (*prog)->ops[i]; - (*prog)->ops[i] = NULL; + element_t *newcode = newelement (Code, root->nbops + 1, 5); + for (i = 0; i < root->nbops; i++) { + newcode->ops[i] = root->ops[i]; + root->ops[i] = NULL; } - newprog->ops[(*prog)->nbops] = new; - delelement (*prog); - (*prog) = newprog; + newcode->ops[root->nbops] = new; + delelement (root); + root = newcode; } while (*str == ','); if (*str != '}') { @@ -324,7 +291,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; @@ -337,7 +308,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; } @@ -457,6 +428,11 @@ element_t *parser (char *str, char **next, int prio) *next = str; } + /* save string */ + if (root != NULL) { + root->string = string; + } + return root; } @@ -491,8 +467,11 @@ void print_element (element_t *root, int level) case Acos: func = "Arc Cosine"; break; case Asin: func = "Arc Sine"; break; case Atan: func = "Arc Tangent"; break; - case Log: func = "Logarithm"; break; + case Ln: func = "Logarithm (natural)"; break; + case Log: func = "Logarithm (10 base)"; break; case Exp: func = "Exponantial"; break; + case Erfc: func = "Complementary Error Function"; break; + case Erf: func = "Error Function"; break; case Abs: func = "Absolute value"; break; case Ceil: func = "Ceil value"; break; case Floor: func = "Floor value"; break; @@ -501,6 +480,8 @@ void print_element (element_t *root, int level) case Inc: func = "Increase"; break; case Dec: func = "Decrease"; break; case Disp: func = "Display"; break; + case Mem: func = "Memory"; break; + case Clear: func = "Clear"; break; case Quit: func = "Quit"; break; case Help: func = "Help"; break; case Ans: func = "Ans"; break; @@ -517,8 +498,29 @@ void print_element (element_t *root, int level) case Not: func = "Not"; break; case Cond: func = "Condition"; break; case While: func = "While"; break; - case Prog: func = "Program"; break; + 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; + case Del: func = "Del"; break; + case Get: func = "Get"; break; + case Length: func = "Length"; break; + case Pop: func = "Pop"; break; + case Push: func = "Push"; break; + 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); @@ -535,58 +537,6 @@ void print_element (element_t *root, int level) } } -/* storage functions */ - -double store (int index, double value) -{ - if ((index > 0) && (index <= STORAGE_SIZE)) { - storage[index - 1] = value; - } else { - VERBOSE (WARNING, fprintf (stdout, "invalid index (%d) [1, %d]\n", index, STORAGE_SIZE)); - } - return value; -} - -double recall (int index) -{ - if ((index > 0) && (index <= STORAGE_SIZE)) { - return storage[index - 1]; - } else { - VERBOSE (WARNING, fprintf (stdout, "invalid index (%d) [1, %d]\n", index, STORAGE_SIZE)); - } - return 0; -} - -double increase (int index) -{ - if ((index > 0) && (index <= STORAGE_SIZE)) { - return storage[index - 1]++; - } else { - VERBOSE (WARNING, fprintf (stdout, "invalid index (%d) [1, %d]\n", index, STORAGE_SIZE)); - } - return 0; -} - -double decrease (int index) -{ - if ((index > 0) && (index <= STORAGE_SIZE)) { - return storage[index - 1]--; - } else { - VERBOSE (WARNING, fprintf (stdout, "invalid index (%d) [1, %d]\n", index, STORAGE_SIZE)); - } - return 0; -} - -void display (void) -{ - int i; - fprintf (stdout, "storage:"); - for (i = 0; i < STORAGE_SIZE; i++) { - fprintf (stdout, " %g", storage[i]); - } - fprintf (stdout, "\n"); -} - /* While do function */ double while_do (element_t *cond, element_t *action) @@ -599,12 +549,15 @@ double while_do (element_t *cond, element_t *action) VERBOSE (DEBUG, fprintf (stdout, "loop...\n")); temp = dupelement (cond); - if (!evaluate_element (temp, 0)) { + double test = evaluate_element (temp, 0); + delelement (temp); + if (!test) { break; } if (action) { temp = dupelement (action); ret = evaluate_element (temp, 0); + delelement (temp); } } @@ -615,42 +568,16 @@ double while_do (element_t *cond, element_t *action) /* program function */ -double program_do (element_t **prog, int nbcalls) +double execute_code (element_t **prog, int nbcalls) { double ret = 0; int i; for (i = 0; i < nbcalls; i++) { ret = evaluate_element (prog[i], 0); - prog[i] = NULL; } return ret; } -/* print function */ - -void set_format (char *prompt, int precision) -{ - char buffer[128] = {0}; - sprintf (buffer, "%s%%.%dg\n", prompt, precision); - free_format (); - format = strdup (buffer); -} - -void free_format () -{ - if (format) { - free (format); - format = NULL; - } -} - -double print (double value) -{ - fprintf (stdout, format ? format : "=> %.6g\n", value); - fflush (stdout); - return value; -} - /* quit function */ void quit (void) @@ -664,26 +591,34 @@ void quit (void) void help (void) { fprintf (stdout, "calc is a simple calculator\n\n"); - fprintf (stdout, "supported operators:"); + fprintf (stdout, "arithmetic op.:"); fprintf (stdout, " + - * / %% ^\n"); - fprintf (stdout, "camparison operators:"); + fprintf (stdout, "comparison op.:"); fprintf (stdout, " == != >= <= > <\n"); - fprintf (stdout, "logical operators:"); + fprintf (stdout, "logical op.:"); 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, "mathematic func.:"); + fprintf (stdout, " exp ln log pow sqrt\n"); + fprintf (stdout, "trigonometric func.:"); + fprintf (stdout, " acos asin atan cos sin tan\n"); + fprintf (stdout, "error functions:"); + fprintf (stdout, " erf erfc\n"); + fprintf (stdout, "miscellaneous func.:"); fprintf (stdout, " abs ceil floor\n"); - fprintf (stdout, "storage functions:"); - fprintf (stdout, " sto rcl inc dec\n"); - fprintf (stdout, "conditional functions:"); - fprintf (stdout, " cond while print {} ;\n"); - fprintf (stdout, "miscellaneous functions:"); - fprintf (stdout, " quit help\n"); - fprintf (stdout, "supported constants:"); - fprintf (stdout, " e pi\n"); + fprintf (stdout, "storage func.:"); + fprintf (stdout, " clear dec disp inc mem rcl sto\n"); + fprintf (stdout, "control flow prim.:"); + fprintf (stdout, " cond print while {} ;\n"); + fprintf (stdout, "program management:"); + 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:"); + fprintf (stdout, " ans e pi\n"); } /* evaluate element tree */ @@ -695,6 +630,7 @@ double evaluate_element (element_t *root, char mask) { double op0 = 0, op1 = 0; char nextmask = mask; + int i, nb; if ((root == NULL) || (root == ERROR_OP)) { VERBOSE (WARNING, fprintf (stdout, "error while evaluating\n")); @@ -755,8 +691,11 @@ double evaluate_element (element_t *root, char mask) case Acos: case Asin: case Atan: + case Ln: case Log: case Exp: + case Erfc: + case Erf: case Abs: case Ceil: case Floor: @@ -764,7 +703,14 @@ double evaluate_element (element_t *root, char mask) case Inc: case Dec: case Not: + case Mem: case Cond: + case Prog: + case Arg: + case Call: + case Edit: + case Del: + case Get: if (root->ops[0]) { op0 = evaluate_element (root->ops[0], 0); } else { @@ -773,12 +719,22 @@ double evaluate_element (element_t *root, char mask) } break; case Disp: + case Clear: case Quit: case Help: case Ans: case Pi: case E: - case Prog: + case Code: + case List: + case Length: + case Pop: + case Set: + case Show: + case Median: + case Order: + case Prod: + case Sum: break; case While: if (root->ops[0] == NULL) { @@ -786,9 +742,27 @@ double evaluate_element (element_t *root, char mask) return 0; } break; + case Push: case Print: op0 = (root->ops[0]) ? evaluate_element (root->ops[0], 0) : answer; break; + case Put: + if (root->ops[0]) { + op0 = evaluate_element (root->ops[0], 0); + } else { + VERBOSE (WARNING, fprintf (stdout, "error while evaluating (op[0])\n")); + return 0; + } + 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) { @@ -807,8 +781,11 @@ double evaluate_element (element_t *root, char mask) case Acos: return acos (op0); case Asin: return asin (op0); case Atan: return atan (op0); - case Log: return log (op0); + case Ln: return log (op0); + case Log: return log10 (op0); case Exp: return exp (op0); + case Erfc: return erfc (op0); + case Erf: return erf (op0); case Abs: return fabs (op0); case Ceil: return ceil (op0); case Floor: return floor (op0); @@ -817,6 +794,8 @@ double evaluate_element (element_t *root, char mask) case Inc: return increase ((int)op0); case Dec: return decrease ((int)op0); case Disp: display (); break; + case Mem: memory ((int)op0); break; + case Clear: clear (); break; case Quit: quit (); break; case Help: help (); break; case Ans: return answer; @@ -840,8 +819,63 @@ double evaluate_element (element_t *root, char mask) return 0; } case While: return while_do (root->ops[0], root->ops[1]); - case Prog: return program_do (root->ops, root->nbops); + case Code: return execute_code (root->ops, root->nbops); case Print: return print (op0); + case Prog: + 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]) { + nb++; + } + } + return call ((int)op0, nb, root->ops + 1); + case List: list (); break; + case Edit: edit ((int)op0); break; + case Del: del ((int)op0); break; + case Get: return get ((int)op0); + case Length: return length (); + case Pop: return pop (); + case Push: return push (op0); + case Put: return put ((int)op0, op1); + case Set: + for (i = 0, nb =0; i < root->nbops; i++) { + if (root->ops[i]) { + nb++; + } + } + 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; @@ -850,11 +884,7 @@ double evaluate_element (element_t *root, char mask) 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); - } + char **list = (char **) callocordie (NB_OPERATORS + NB_FUNCTIONS + NB_CONSTANTS + NB_SYMBOLS + 1, sizeof (char *)); for (i = 0; i < NB_OPERATORS; i++) { list[l] = strdup ((operators + i)->keyword); @@ -897,7 +927,7 @@ void free_completion_list (char **list) int i; if (list) { - for (i = 0; i < NB_FUNCTIONS + NB_CONSTANTS; i++) { + for (i = 0; i < NB_OPERATORS + NB_FUNCTIONS + NB_CONSTANTS + NB_SYMBOLS + 1; i++) { if (list[i] != NULL) { free (list[i]); } @@ -906,5 +936,4 @@ void free_completion_list (char **list) } } - /* vim: set ts=4 sw=4 et: */