Soft'N'Design Software / projects / calc.git / blob
? search:


74e980b39c4dac2ea4e3f812d7fe0483c8e9989e
[calc.git] / parser.c
1 #include <malloc.h>
2 #include <math.h>
3 #include <stdio.h>
4 #include <stdlib.h>
5 #include <string.h>
6
7 #include "debug.h"
8
9 #include "parser.h"
10
11 /* global variables */
12
13 double answer = 0;
14
15 #define DEFAULT_STORAGE_SIZE 10
16 int storage_size = -1;
17 double *storage = NULL;
18
19 int stack_size = 0;
20 double *stack = NULL;
21
22 #define DEFAULT_FORMAT "=> %.6g\n"
23 char *format = NULL;
24 char *minform = NULL;
25
26 workspace_t *programs = NULL;
27 int nb_programs = 0;
28
29 /* compare codes */
30
31 int codecmp (char *ref, char *str)
32 {
33 int sig;
34
35 while (*ref != '\0') {
36 if (*ref == '\t') {
37 sig = (*str == '.') ? -1 : ((*str >= '0') && (*str <= '9'));
38 } else {
39 sig = *str - *ref;
40 }
41 if (sig != 0) {
42 return (sig > 0) ? 1 : -1;
43 }
44 str++;
45 ref++;
46 }
47
48 return 0;
49 }
50
51 /* calloc or die function */
52
53 void *callocordie (size_t count, size_t size)
54 {
55 if (count * size == 0) {
56 return NULL;
57 }
58 void *new = calloc (count, size);
59 if (new == NULL) {
60 VERBOSE (ERROR, fprintf (stderr, "can't allocate memory\n"));
61 exit (1);
62 }
63 return new;
64 }
65
66 /* allocate new element */
67
68 element_t *newelement (func_t function, int nbops, int prio)
69 {
70 element_t *new = (element_t *) callocordie (1, sizeof (element_t));
71 if (nbops) {
72 new->ops = (element_t **) callocordie (nbops, sizeof (element_t *));
73 }
74 new->func = function;
75 new->nbops = nbops;
76 new->prio = prio;
77
78 return new;
79 }
80
81 /* desallocate element */
82
83 void delelement (element_t *root)
84 {
85 if ((root != NULL) && (root != ERROR_OP)) {
86 int i;
87 for (i = 0; i < root->nbops; i++) {
88 delelement (root->ops[i]);
89 }
90 if (root->nbops) {
91 free (root->ops);
92 }
93 free (root);
94 }
95 }
96
97 /* duplicate element */
98
99 element_t *dupelement (element_t *root)
100 {
101 element_t *tmp = NULL;
102 int i;
103
104 if ((root == NULL) || (root == ERROR_OP)) {
105 return root;
106 }
107 tmp = newelement (root->func, root->nbops, root->prio);
108 tmp->value = root->value;
109 for (i = 0; i < root->nbops; i++) {
110 tmp->ops[i] = dupelement (root->ops[i]);
111 }
112 return tmp;
113 }
114
115 /* functions */
116
117 #define MAX_ARGS 100
118
119 #define NB_OPERATORS 14
120 keyword_t operators[NB_OPERATORS] = {
121 { "+\t", Add, 2, 1, 1},
122 { "-\t", Sub, 2, 1, 1},
123 { "*", Mul, 2, 1, 2},
124 { "/", Div, 2, 1, 2},
125 { "%", Mod, 2, 1, 3},
126 { "^", Pow, 2, 1, 4},
127 { "==", Equal, 2, 2, -1},
128 { "!=", Diff, 2, 2, -1},
129 { ">=", Ge, 2, 2, -1},
130 { "<=", Le, 2, 2, -1},
131 { ">", Gt, 2, 1, -1},
132 { "<", Lt, 2, 1, -1},
133 { "&", And, 2, 1, -2},
134 { "|", Or, 2, 1, -2}
135 };
136
137 #define NB_FUNCTIONS 41
138 keyword_t functions[NB_FUNCTIONS] = {
139 { "sqrt", Sqr, 1, 4, 5},
140 { "pow", Pow, 2, 3, 5},
141 { "cos", Cos, 1, 3, 5},
142 { "sin", Sin, 1, 3, 5},
143 { "tan", Tan, 1, 3, 5},
144 { "acos", Acos, 1, 4, 5},
145 { "asin", Asin, 1, 4, 5},
146 { "atan", Atan, 1, 4, 5},
147 { "ln", Ln, 1, 2, 5},
148 { "log", Log, 1, 3, 5},
149 { "exp", Exp, 1, 3, 5},
150 { "erfc", Erfc, 1, 4, 5},
151 { "erf", Erf, 1, 3, 5},
152 { "abs", Abs, 1, 3, 5},
153 { "floor", Floor, 1, 5, 5},
154 { "ceil", Ceil, 1, 4, 5},
155 { "sto", Store, 2, 3, 5},
156 { "rcl", Recall, 1, 3, 5},
157 { "inc", Inc, 1, 3, 5},
158 { "dec", Dec, 1, 3, 5},
159 { "disp", Disp, 0, 4, 9},
160 { "mem", Mem, 1, 3, 9},
161 { "clr", Clear, 0, 3, 9},
162 { "quit", Quit, 0, 4, 9},
163 { "help", Help, 0, 4, 9},
164 { "!", Not, 1, 1, 6},
165 { "cond", Cond, 3, 4, 5},
166 { "while", While, 2, 5, 5},
167 { "print", Print, 1, 5, 5},
168 { "prog", Prog, 3, 4, 9},
169 { "call", Call, MAX_ARGS, 4, 5},
170 { "ls", List, 0, 2, 9},
171 { "edit", Edit, 1, 4, 9},
172 { "del", Del, 1, 3, 9},
173 { "get", Get, 1, 3, 5},
174 { "len", Length, 0, 3, 5},
175 { "pop", Pop, 0, 3, 5},
176 { "push", Push, 1, 4, 5},
177 { "put", Put, 2, 3, 5},
178 { "set", Set, MAX_ARGS, 3, 5},
179 { "show", Show, 0, 4, 5},
180 };
181
182 #define NB_CONSTANTS 3
183 keyword_t constants[NB_CONSTANTS] = {
184 { "ans", Ans, 0, 3, 5},
185 { "e", E, 0, 1, 5},
186 { "pi", Pi, 0, 2, 5}
187 };
188
189 #define NB_SYMBOLS 4
190 char *symbols[NB_SYMBOLS] = {
191 "(", ")", "{", "}"
192 };
193
194 /* subparser function */
195
196 element_t *subparser (element_t **proot, char **pstr, func_t func, int nbops, int prio)
197 {
198 element_t *new = newelement (func, nbops, prio);
199 new->ops[0] = *proot;
200 new->ops[1] = parser (*pstr, pstr, new->prio);
201 if ((new->ops[1] == NULL) || ((new->ops[1] != ERROR_OP) && (new->ops[1]->prio == 9))) {
202 delelement (new->ops[1]);
203 new->ops[1] = ERROR_OP;
204 }
205 if (new->ops[1] == ERROR_OP) {
206 delelement (new);
207 *proot = NULL;
208 return ERROR_OP;
209 }
210 *proot = newelement (Val, 1, 5);
211 (*proot)->ops[0] = new;
212
213 return *proot;
214 }
215
216 /* parser function */
217
218 element_t *parser (char *str, char **next, int prio)
219 {
220 element_t *root = NULL;
221 char *string = str;
222 int i;
223
224 VERBOSE (DEBUG, fprintf (stdout, "Starting parsing\n"));
225
226 /* main loop */
227 while (*str != '\0') {
228 int found = 0;
229 element_t *new = NULL;
230 VERBOSE (INFO, fprintf (stdout, "Processing: %s\n", str));
231
232 /* end without printing */
233
234 if (*str == ';') {
235 if (root) {
236 root->hidden = 1;
237 }
238 break;
239 }
240
241 /* skip spaces and tabs */
242
243 if ((*str == ' ') || (*str == '\t')) {
244 str++;
245 continue;
246 }
247
248 /* check for open brace */
249
250 if (*str == '{') {
251 VERBOSE (DEBUG, fprintf (stdout, "start processing brace\n"));
252 if (root != NULL) {
253 delelement (root);
254 return ERROR_OP;
255 }
256 root = newelement (Code, 0, 5);
257
258 do {
259 new = parser (str + 1, &str, 0);
260 if ((new == NULL) || ((new != ERROR_OP) && (new->prio == 9))) {
261 delelement (new);
262 new = ERROR_OP;
263 }
264 if (new == ERROR_OP) {
265 delelement (root);
266 return ERROR_OP;
267 }
268 element_t *newprog = newelement (Code, root->nbops + 1, 5);
269 for (i = 0; i < root->nbops; i++) {
270 newprog->ops[i] = root->ops[i];
271 root->ops[i] = NULL;
272 }
273 newprog->ops[root->nbops] = new;
274 delelement (root);
275 root = newprog;
276 } while (*str == ',');
277
278 if (*str != '}') {
279 delelement (root);
280 return ERROR_OP;
281 }
282 str++;
283 VERBOSE (DEBUG, fprintf (stdout, "stop processing brace\n"));
284 continue;
285 }
286
287 /* check for open bracket */
288
289 if (*str == '(') {
290 VERBOSE (DEBUG, fprintf (stdout, "start processing bracket\n"));
291 if (root) {
292 do {
293 found = 0;
294 new = parser (str + 1, &str, 0);
295 if ((new == NULL) || ((new != ERROR_OP) && (new->prio == 9))) {
296 delelement (new);
297 new = ERROR_OP;
298 }
299 if ((new == NULL) || (new == ERROR_OP)) {
300 delelement (root);
301 return ERROR_OP;
302 }
303 for (i = 0; i < root->nbops; i++) {
304 if (root->ops[i] == NULL) {
305 root->ops[i] = new;
306 found = 1;
307 break;
308 }
309 }
310 if (!found) {
311 delelement (new);
312 delelement (root);
313 return ERROR_OP;
314 }
315 } while (*str == ',');
316 } else {
317 root = newelement (Val, 1, 5);
318 new = parser (str + 1, &str, 0);
319 if ((new == NULL) || ((new != ERROR_OP) && (new->prio == 9))) {
320 delelement (new);
321 new = ERROR_OP;
322 }
323 if ((new == NULL) || (new == ERROR_OP) || (*str == ',')) {
324 delelement (new);
325 delelement (root);
326 return ERROR_OP;
327 }
328 root->ops[0] = new;
329 }
330 if (*str != ')') {
331 delelement (root);
332 return ERROR_OP;
333 }
334 str++;
335 VERBOSE (DEBUG, fprintf (stdout, "stop processing bracket\n"));
336 continue;
337 }
338
339 /* check for closing bracket, closing brace or koma */
340
341 if ((*str == ')') || (*str == '}') || (*str == ',')) {
342 if (prio == -9) {
343 delelement (root);
344 return ERROR_OP;
345 }
346 if (next != NULL) {
347 *next = str;
348 }
349 return root;
350 }
351
352 /* look for operators */
353
354 for (i = 0; i < NB_OPERATORS; i++) {
355 keyword_t *operator = operators + i;
356 if (codecmp (operator->keyword, str) == 0) {
357 VERBOSE (DEBUG, fprintf (stdout, "start processing operator\n"));
358 if (root) {
359 if ((prio) && (prio > operator->prio)) {
360 VERBOSE (DEBUG, fprintf (stdout, "stop because operator priority\n"));
361 *next = str;
362 return root;
363 }
364 str += operator->offset;
365 VERBOSE (INFO, fprintf (stdout, "Oper: %d\n", operator->func));
366 if (subparser (&root, &str, operator->func, operator->nbops, operator->prio) == ERROR_OP) {
367 delelement (root);
368 return ERROR_OP;
369 }
370 } else if (*str == '-') {
371 root = newelement (Sig, 1, 9);
372 } else {
373 return ERROR_OP;
374 }
375 found = 1;
376 VERBOSE (DEBUG, fprintf (stdout, "stop processing operator\n"));
377 break;
378 }
379 }
380 if (found) {
381 continue;
382 }
383
384 /* look for functions */
385
386 for (i = 0; i < NB_FUNCTIONS; i++) {
387 keyword_t *function = functions + i;
388 if (codecmp (function->keyword, str) == 0) {
389 VERBOSE (DEBUG, fprintf (stdout, "start processing function\n"));
390 if (root == NULL) {
391 VERBOSE (INFO, fprintf (stdout, "Func: %d\n", function->func));
392 root = newelement (function->func, function->nbops, function->prio);
393 } else {
394 delelement (root);
395 return ERROR_OP;
396 }
397 str += function->offset;
398 found = 1;
399 VERBOSE (DEBUG, fprintf (stdout, "stop processing function\n"));
400 break;
401 }
402 }
403 if (found) {
404 continue;
405 }
406
407 /* look for constant */
408
409 for (i = 0; i < NB_CONSTANTS; i++) {
410 keyword_t *constant = constants + i;
411 if (codecmp (constant->keyword, str) == 0) {
412 VERBOSE (DEBUG, fprintf (stdout, "start processing constant\n"));
413 if (root == NULL) {
414 VERBOSE (INFO, fprintf (stdout, "Const: %d\n", constant->func));
415 root = newelement (constant->func, constant->nbops, constant->prio);
416 } else {
417 delelement (root);
418 return ERROR_OP;
419 }
420 str += constant->offset;
421 found = 1;
422 VERBOSE (DEBUG, fprintf (stdout, "stop processing constant\n"));
423 break;
424 }
425 }
426 if (found) {
427 continue;
428 }
429
430 /* look for number */
431
432 if (((*str >= '0') && (*str <= '9')) ||
433 (*str == '.') || (*str == '+') || (*str == '-')) {
434 VERBOSE (DEBUG, fprintf (stdout, "start processing value\n"));
435 char *pt;
436 double value = strtod (str, &pt);
437 VERBOSE (INFO, fprintf (stdout, "Value: %f\n", value));
438 if (str != pt) {
439 if ((root == NULL) || (root->prio == 6)) {
440 new = newelement (Val, 1, 5);
441 new->value = value;
442 if (root == NULL) {
443 root = new;
444 } else {
445 for (i = 0; i < root->nbops; i++) {
446 if (root->ops[i] == NULL) {
447 root->ops[i] = new;
448 found = 1;
449 break;
450 }
451 }
452 if (!found) {
453 delelement (new);
454 delelement (root);
455 return ERROR_OP;
456 }
457 }
458 str = pt;
459 } else if ((*str == '+') || (*str == '-')) {
460 if ((prio) && (prio > 1)) {
461 VERBOSE (DEBUG, fprintf (stdout, "stop because operator priority\n"));
462 *next = str;
463 return root;
464 }
465 if (subparser (&root, &str, Add, 2, 1) == ERROR_OP) {
466 delelement (root);
467 return ERROR_OP;
468 }
469 } else {
470 delelement (root);
471 return ERROR_OP;
472 }
473 found = 1;
474 }
475 VERBOSE (DEBUG, fprintf (stdout, "stop processing value\n"));
476 }
477
478 /* error */
479
480 if (!found) {
481 delelement (root);
482 return ERROR_OP;
483 }
484
485 }
486
487 if (next != NULL) {
488 *next = str;
489 }
490
491 /* save string */
492 if (root != NULL) {
493 root->string = string;
494 }
495
496 return root;
497 }
498
499 /* print element tree */
500
501 void print_element (element_t *root, int level)
502 {
503 char *func = NULL;
504 int i;
505
506 if ((root == NULL) || (root == ERROR_OP)) {
507 return;
508 }
509
510 for (i = 0; i < level; i++) {
511 fprintf (stdout, " ");
512 }
513
514 switch (root->func) {
515 case Val: func = "Value"; break;
516 case Sig: func = "Sign"; break;
517 case Add: func = "Addition"; break;
518 case Sub: func = "Subtraction"; break;
519 case Mul: func = "Multiplication"; break;
520 case Div: func = "Division"; break;
521 case Mod: func = "Modulo"; break;
522 case Pow: func = "Power"; break;
523 case Sqr: func = "Square Root"; break;
524 case Cos: func = "Cosine"; break;
525 case Sin: func = "Sine"; break;
526 case Tan: func = "Tangent"; break;
527 case Acos: func = "Arc Cosine"; break;
528 case Asin: func = "Arc Sine"; break;
529 case Atan: func = "Arc Tangent"; break;
530 case Ln: func = "Logarithm (natural)"; break;
531 case Log: func = "Logarithm (10 base)"; break;
532 case Exp: func = "Exponantial"; break;
533 case Erfc: func = "Complementary Error Function"; break;
534 case Erf: func = "Error Function"; break;
535 case Abs: func = "Absolute value"; break;
536 case Ceil: func = "Ceil value"; break;
537 case Floor: func = "Floor value"; break;
538 case Store: func = "Store"; break;
539 case Recall: func = "Recall"; break;
540 case Inc: func = "Increase"; break;
541 case Dec: func = "Decrease"; break;
542 case Disp: func = "Display"; break;
543 case Mem: func = "Memory"; break;
544 case Clear: func = "Clear"; break;
545 case Quit: func = "Quit"; break;
546 case Help: func = "Help"; break;
547 case Ans: func = "Ans"; break;
548 case Pi: func = "Pi"; break;
549 case E: func = "E"; break;
550 case Equal: func = "Equal"; break;
551 case Diff: func = "Different"; break;
552 case Ge: func = "Greater or equal"; break;
553 case Le: func = "Lesser or equal"; break;
554 case Gt: func = "Greater"; break;
555 case Lt: func = "Lesser"; break;
556 case And: func = "And"; break;
557 case Or: func = "Or"; break;
558 case Not: func = "Not"; break;
559 case Cond: func = "Condition"; break;
560 case While: func = "While"; break;
561 case Code: func = "Code"; break;
562 case Print: func = "Print"; break;
563 case Prog: func = "Program"; break;
564 case Call: func = "Call"; break;
565 case List: func = "List"; break;
566 case Edit: func = "Edit"; break;
567 case Del: func = "Del"; break;
568 case Get: func = "Get"; break;
569 case Length: func = "Length"; break;
570 case Pop: func = "Pop"; break;
571 case Push: func = "Push"; break;
572 case Put: func = "Put"; break;
573 case Set: func = "Set"; break;
574 case Show: func = "Show"; break;
575 }
576
577 fprintf (stdout, "Function: %s\n", func);
578
579 if ((root->func == Val) && (root->ops[0] == NULL)) {
580 for (i = 0; i < level; i++) {
581 fprintf (stdout, " ");
582 }
583 fprintf (stdout, "value: %f\n", root->value);
584 } else {
585 for (i = 0; i < root->nbops; i++) {
586 print_element (root->ops[i], level + 1);
587 }
588 }
589 }
590
591 /* storage functions */
592
593 void memory (int nb)
594 {
595 int i, l;
596 double *tmp = NULL;
597 if (nb != storage_size) {
598 l = (nb < storage_size) ? nb : storage_size;
599 tmp = (double *) callocordie (nb, sizeof (double));
600 for (i = 0; i < l; i++) {
601 tmp[i] = storage[i];
602 }
603 if (storage != NULL) {
604 free (storage);
605 }
606 storage = tmp;
607 storage_size = nb;
608 }
609 }
610
611 double store (int index, double value)
612 {
613 if (storage_size == -1) {
614 memory (DEFAULT_STORAGE_SIZE);
615 }
616 if ((index > 0) && (index <= storage_size)) {
617 storage[index - 1] = value;
618 } else {
619 VERBOSE (WARNING, fprintf (stdout, "invalid index (%d) [%d, %d]\n", index, (storage_size) ? 1 : 0, storage_size));
620 }
621 return value;
622 }
623
624 double recall (int index)
625 {
626 if (storage_size == -1) {
627 memory (DEFAULT_STORAGE_SIZE);
628 }
629 if ((index > 0) && (index <= storage_size)) {
630 return storage[index - 1];
631 } else {
632 VERBOSE (WARNING, fprintf (stdout, "invalid index (%d) [%d, %d]\n", index, (storage_size) ? 1 : 0, storage_size));
633 }
634 return 0;
635 }
636
637 double increase (int index)
638 {
639 if (storage_size == -1) {
640 memory (DEFAULT_STORAGE_SIZE);
641 }
642 if ((index > 0) && (index <= storage_size)) {
643 return storage[index - 1]++;
644 } else {
645 VERBOSE (WARNING, fprintf (stdout, "invalid index (%d) [%d, %d]\n", index, (storage_size) ? 1 : 0, storage_size));
646 }
647 return 0;
648 }
649
650 double decrease (int index)
651 {
652 if (storage_size == -1) {
653 memory (DEFAULT_STORAGE_SIZE);
654 }
655 if ((index > 0) && (index <= storage_size)) {
656 return storage[index - 1]--;
657 } else {
658 VERBOSE (WARNING, fprintf (stdout, "invalid index (%d) [%d, %d]\n", index, (storage_size) ? 1 : 0, storage_size));
659 }
660 return 0;
661 }
662
663 void display (void)
664 {
665 int i;
666 if (storage_size == -1) {
667 memory (DEFAULT_STORAGE_SIZE);
668 }
669 fprintf (stdout, "storage:");
670 for (i = 0; i < storage_size; i++) {
671 fprintf (stdout, " ");
672 fprintf (stdout, minform, storage[i]);
673 }
674 fprintf (stdout, "\n");
675 }
676
677 void clear ()
678 {
679 int i;
680 for (i = 0; i < storage_size; i++) {
681 storage[i] = 0;
682 }
683 }
684
685 /* While do function */
686
687 double while_do (element_t *cond, element_t *action)
688 {
689 double ret = 0;
690 element_t *temp = NULL;
691
692 VERBOSE (DEBUG, fprintf (stdout, "starting while loop\n"));
693 while (1) {
694 VERBOSE (DEBUG, fprintf (stdout, "loop...\n"));
695
696 temp = dupelement (cond);
697 double test = evaluate_element (temp, 0);
698 delelement (temp);
699 if (!test) {
700 break;
701 }
702 if (action) {
703 temp = dupelement (action);
704 ret = evaluate_element (temp, 0);
705 delelement (temp);
706 }
707 }
708
709 VERBOSE (DEBUG, fprintf (stdout, "ending while loop\n"));
710
711 return ret;
712 }
713
714 /* program function */
715
716 double execute_code (element_t **prog, int nbcalls)
717 {
718 double ret = 0;
719 int i;
720 for (i = 0; i < nbcalls; i++) {
721 ret = evaluate_element (prog[i], 0);
722 }
723 return ret;
724 }
725
726 /* print function */
727
728 void set_format (char *prompt, int precision)
729 {
730 char buffer[128] = {0};
731 free_format ();
732 sprintf (buffer, "%s%%.%dg\n", prompt, precision);
733 format = strdup (buffer);
734 sprintf (buffer, "%%.%dg", precision);
735 minform = strdup (buffer);
736 }
737
738 void free_format ()
739 {
740 if (format) {
741 free (format);
742 format = NULL;
743 }
744 if (minform) {
745 free (minform);
746 minform = NULL;
747 }
748 }
749
750 double print (double value)
751 {
752 fprintf (stdout, format ? format : DEFAULT_FORMAT, value);
753 fflush (stdout);
754 return value;
755 }
756
757 /* quit function */
758
759 void quit (void)
760 {
761 fprintf (stdout, "bye\n");
762 exit (0);
763 }
764
765 /* program function */
766
767 void prog (int id, int nbmems, element_t *root)
768 {
769 int i, n = -1;
770
771 if (programs == NULL) {
772
773 /* initial memory allocation */
774 programs = (workspace_t *) callocordie (1, sizeof (workspace_t));
775 nb_programs = 1;
776 n = 0;
777
778 } else {
779
780 /* look for existing program */
781 for (i = 0; i < nb_programs; i++) {
782 if ((programs + i)->id == id) {
783 n = i;
784 break;
785 }
786 }
787 if (n == -1) {
788
789 /* new program */
790 n = nb_programs++;
791 workspace_t *tmp = (workspace_t *) callocordie (nb_programs, sizeof (workspace_t));
792 memcpy (tmp, programs, (nb_programs - 1) * sizeof (workspace_t));
793 free (programs);
794 programs = tmp;
795 } else {
796
797 /* clean old program */
798 if ((programs + n)->storage) {
799 free ((programs + n)->storage);
800 }
801 if ((programs + n)->stack) {
802 free ((programs + n)->stack);
803 }
804 if ((programs + n)->root) {
805 delelement ((programs + n)->root);
806 }
807 if ((programs + n)->string) {
808 free ((programs + n)->string);
809 (programs + n)->string = NULL;
810 }
811 }
812 }
813
814 /* set program */
815 (programs + n)->id = id;
816 (programs + n)->answer = 0;
817 (programs + n)->storage = (double *) callocordie (nbmems, sizeof (double));
818 (programs + n)->storage_size = nbmems;
819 (programs + n)->stack = NULL;
820 (programs + n)->stack_size = 0;
821 (programs + n)->root = dupelement (root);
822 }
823
824 double call (int id, int nbops, element_t **ops)
825 {
826 workspace_t tmp = {0};
827 int i, n = -1;
828 double ret = 0;
829
830 if (programs) {
831
832 /* look for program */
833 for (i = 0; i < nb_programs; i++) {
834 if ((programs + i)->id == id) {
835 n = i;
836 break;
837 }
838 }
839 }
840 if (n == -1) {
841 VERBOSE (WARNING, fprintf (stdout, "error unknown program (%d)\n", id));
842 return 0;
843 }
844
845 /* store context */
846 tmp.answer = answer;
847 tmp.storage = storage;
848 tmp.storage_size = storage_size;
849 tmp.stack = stack;
850 tmp.stack_size = stack_size;
851
852 /* change context */
853 answer = 0;
854 storage = (programs + n)->storage;
855 storage_size = (programs + n)->storage_size;
856 stack = (programs + n)->stack;
857 stack_size = (programs + n)->stack_size;
858 if (nbops > storage_size) {
859 double *tmp = (double *) callocordie (nbops, sizeof (double));
860 memcpy (tmp, storage, storage_size * sizeof (double));
861 free (storage);
862 (programs + n)->storage = storage = tmp;
863 (programs + n)->storage_size = storage_size = nbops;
864 }
865 for (i = 0; i < nbops; i++) {
866 double val = evaluate_element (ops[i], 0);
867 store (i + 1, val);
868 }
869
870 /* evaluate program */
871 element_t *elements = dupelement ((programs + n)->root);
872 ret = evaluate_element (elements, 0);
873 delelement (elements);
874 (programs + n)->answer = answer;
875 (programs + n)->storage = storage;
876 (programs + n)->storage_size = storage_size;
877 (programs + n)->stack = stack;
878 (programs + n)->stack_size = stack_size;
879
880 /* restore context */
881 answer = tmp.answer;
882 storage = tmp.storage;
883 storage_size = tmp.storage_size;
884 stack = tmp.stack;
885 stack_size = tmp.stack_size;
886
887 return ret;
888 }
889
890 void list ()
891 {
892 int i;
893 fprintf (stdout, "programs:");
894 for (i = 0; i < nb_programs; i++) {
895 fprintf (stdout, " %d", (programs + i)->id);
896 }
897 fprintf (stdout, "\n");
898 }
899
900 void edit (int id)
901 {
902 int i, n = -1;
903
904 if (programs) {
905
906 /* look for program */
907 for (i = 0; i < nb_programs; i++) {
908 if ((programs + i)->id == id) {
909 n = i;
910 break;
911 }
912 }
913 }
914 if (n == -1) {
915 VERBOSE (WARNING, fprintf (stdout, "error unknown program (%d)\n", id));
916 return;
917 }
918
919 /* set string program */
920 fprintf (stdout, "edit: %s\n", (programs + n)->string);
921 }
922
923 void savestring (int id, char *string)
924 {
925 int i, n = -1;
926
927 if (programs) {
928
929 /* look for program */
930 for (i = 0; i < nb_programs; i++) {
931 if ((programs + i)->id == id) {
932 n = i;
933 break;
934 }
935 }
936 }
937
938 /* unnecesary code */
939 //if (n == -1) {
940 // VERBOSE (WARNING, fprintf (stdout, "error unknown program (%d)\n", id));
941 // return;
942 //}
943 //if ((programs + n)->string) {
944 // free ((programs + n)->string);
945 //}
946
947 (programs + n)->string = strdup (string);
948 }
949
950 void del (int id)
951 {
952 int i, j, n = -1;
953
954 if (programs) {
955
956 /* look for program */
957 for (i = 0; i < nb_programs; i++) {
958 if ((programs + i)->id == id) {
959 n = i;
960 break;
961 }
962 }
963 }
964 if (n == -1) {
965 VERBOSE (WARNING, fprintf (stdout, "error unknown program (%d)\n", id));
966 return;
967 }
968
969 /* clean program */
970 if ((programs + n)->storage) {
971 free ((programs + n)->storage);
972 }
973 if ((programs + n)->stack) {
974 free ((programs + n)->stack);
975 }
976 if ((programs + n)->root) {
977 delelement ((programs + n)->root);
978 }
979 if ((programs + n)->string) {
980 free ((programs + n)->string);
981 }
982
983 /* remove entry */
984 workspace_t *tmp = (workspace_t *) callocordie (nb_programs - 1, sizeof (workspace_t));
985 for (i = 0, j = 0; i < nb_programs; i++) {
986 if (i != n) {
987 memcpy (tmp + j, programs + i, sizeof (workspace_t));
988 j++;
989 }
990 }
991 free (programs);
992 programs = tmp;
993 nb_programs--;
994 }
995
996 /* stack management */
997
998 double get (int n)
999 {
1000 double ret = 0;
1001 if ((n <= 0) || (n > stack_size)) {
1002 VERBOSE (WARNING, fprintf (stdout, "error out of bound (%d/%d)\n", n, stack_size));
1003 } else {
1004 ret = stack[n - 1];
1005 }
1006 return ret;
1007 }
1008
1009 double length ()
1010 {
1011 return stack_size;
1012 }
1013
1014 double pop ()
1015 {
1016 double ret = 0;
1017 if (stack_size > 0) {
1018 ret = stack[--stack_size];
1019 double *tmp = (double *) callocordie (stack_size, sizeof (double));
1020 memcpy (tmp, stack, stack_size * sizeof (double));
1021 free (stack);
1022 stack = tmp;
1023 } else {
1024 VERBOSE (WARNING, fprintf (stdout, "error stack empty\n"));
1025 }
1026 return ret;
1027 }
1028
1029 double push (double val)
1030 {
1031 double *tmp = (double *) callocordie (stack_size + 1, sizeof (double));
1032 memcpy (tmp, stack, stack_size * sizeof (double));
1033 if (stack) {
1034 free (stack);
1035 }
1036 stack = tmp;
1037 stack[stack_size++] = val;
1038 return val;
1039 }
1040
1041 double put (int n, double val)
1042 {
1043 if (n <= 0) {
1044 VERBOSE (WARNING, fprintf (stdout, "error out of bound (%d/%d)\n", n, stack_size));
1045 return 0;
1046 }
1047 if (n > stack_size) {
1048 double *tmp = (double *) callocordie (n, sizeof (double));
1049 memcpy (tmp, stack, stack_size * sizeof (double));
1050 free (stack);
1051 stack = tmp;
1052 stack_size = n;
1053 }
1054 stack[n - 1] = val;
1055 return val;
1056 }
1057
1058 double set (int nbops, element_t **ops)
1059 {
1060 int i;
1061 if (stack) {
1062 free (stack);
1063 }
1064 stack = NULL;
1065 stack_size = 0;
1066 if (nbops != 0) {
1067 stack = (double *) callocordie (nbops, sizeof (double));
1068 for (i = 0; i < nbops; i++) {
1069 stack[i] = evaluate_element (ops[i], 0);
1070 }
1071 stack_size = nbops;
1072 }
1073 return stack_size;
1074 }
1075
1076 void show (void)
1077 {
1078 int i;
1079 fprintf (stdout, "stack:");
1080 for (i = 0; i < stack_size; i++) {
1081 fprintf (stdout, " ");
1082 fprintf (stdout, minform, stack[i]);
1083 }
1084 fprintf (stdout, "\n");
1085 }
1086
1087 /* help message */
1088
1089 void help (void)
1090 {
1091 fprintf (stdout, "calc is a simple calculator\n\n");
1092 fprintf (stdout, "arithmetic op.:");
1093 fprintf (stdout, " + - * / %% ^\n");
1094 fprintf (stdout, "comparison op.:");
1095 fprintf (stdout, " == != >= <= > <\n");
1096 fprintf (stdout, "logical op.:");
1097 fprintf (stdout, " & | !\n");
1098 fprintf (stdout, "mathematic func.:");
1099 fprintf (stdout, " exp ln log pow sqrt\n");
1100 fprintf (stdout, "trigonometric func.:");
1101 fprintf (stdout, " acos asin atan cos sin tan\n");
1102 fprintf (stdout, "error functions:");
1103 fprintf (stdout, " erf erfc\n");
1104 fprintf (stdout, "miscellaneous func.:");
1105 fprintf (stdout, " abs ceil floor\n");
1106 fprintf (stdout, "storage func.:");
1107 fprintf (stdout, " clear dec disp inc mem rcl sto\n");
1108 fprintf (stdout, "control flow prim.:");
1109 fprintf (stdout, " cond print while {} ;\n");
1110 fprintf (stdout, "program management:");
1111 fprintf (stdout, " call del edit ls prog\n");
1112 fprintf (stdout, "stack management:");
1113 fprintf (stdout, " get len pop push put set show\n");
1114 fprintf (stdout, "control management:");
1115 fprintf (stdout, " help quit\n");
1116 fprintf (stdout, "constants:");
1117 fprintf (stdout, " ans e pi\n");
1118 }
1119
1120 /* evaluate element tree */
1121
1122 #define MASK_SUB 0x1
1123 #define MASK_DIV 0x2
1124
1125 double evaluate_element (element_t *root, char mask)
1126 {
1127 double op0 = 0, op1 = 0;
1128 char nextmask = mask;
1129 int i, nb;
1130
1131 if ((root == NULL) || (root == ERROR_OP)) {
1132 VERBOSE (WARNING, fprintf (stdout, "error while evaluating\n"));
1133 return 0;
1134 }
1135
1136 /* mask to manage sub operator sub and div */
1137 switch (root->func) {
1138 case Add:
1139 nextmask &= ~MASK_SUB;
1140 nextmask &= ~MASK_DIV;
1141 break;
1142 case Sub:
1143 nextmask |= MASK_SUB;
1144 nextmask &= ~MASK_DIV;
1145 break;
1146 case Mul:
1147 nextmask &= ~MASK_DIV;
1148 break;
1149 case Div:
1150 nextmask |= MASK_DIV;
1151 break;
1152 default:
1153 nextmask = mask;
1154 }
1155
1156 switch (root->func) {
1157 case Val:
1158 case Sig:
1159 op0 = (root->ops[0]) ? evaluate_element (root->ops[0], nextmask) : root->value;
1160 break;
1161 case Add:
1162 case Sub:
1163 case Mul:
1164 case Div:
1165 case Mod:
1166 case Pow:
1167 case Store:
1168 case Equal:
1169 case Diff:
1170 case Ge:
1171 case Le:
1172 case Gt:
1173 case Lt:
1174 case And:
1175 case Or:
1176 case Prog:
1177 if (root->ops[1]) {
1178 op1 = evaluate_element (root->ops[1], nextmask);
1179 } else if (root->func != Store) {
1180 VERBOSE (WARNING, fprintf (stdout, "error while evaluating (op[1])\n"));
1181 return 0;
1182 }
1183 /* fallthrough */
1184 case Sqr:
1185 case Cos:
1186 case Sin:
1187 case Tan:
1188 case Acos:
1189 case Asin:
1190 case Atan:
1191 case Ln:
1192 case Log:
1193 case Exp:
1194 case Erfc:
1195 case Erf:
1196 case Abs:
1197 case Ceil:
1198 case Floor:
1199 case Recall:
1200 case Inc:
1201 case Dec:
1202 case Not:
1203 case Mem:
1204 case Cond:
1205 case Call:
1206 case Edit:
1207 case Del:
1208 case Get:
1209 if (root->ops[0]) {
1210 op0 = evaluate_element (root->ops[0], 0);
1211 } else {
1212 VERBOSE (WARNING, fprintf (stdout, "error while evaluating (op[0])\n"));
1213 return 0;
1214 }
1215 break;
1216 case Disp:
1217 case Clear:
1218 case Quit:
1219 case Help:
1220 case Ans:
1221 case Pi:
1222 case E:
1223 case Code:
1224 case List:
1225 case Length:
1226 case Pop:
1227 case Set:
1228 case Show:
1229 break;
1230 case While:
1231 if (root->ops[0] == NULL) {
1232 VERBOSE (WARNING, fprintf (stdout, "error while evaluating (op[0])\n"));
1233 return 0;
1234 }
1235 break;
1236 case Push:
1237 case Print:
1238 op0 = (root->ops[0]) ? evaluate_element (root->ops[0], 0) : answer;
1239 break;
1240 case Put:
1241 if (root->ops[0]) {
1242 op0 = evaluate_element (root->ops[0], 0);
1243 } else {
1244 VERBOSE (WARNING, fprintf (stdout, "error while evaluating (op[0])\n"));
1245 return 0;
1246 }
1247 op1 = (root->ops[1]) ? evaluate_element (root->ops[1], 0) : answer;
1248 break;
1249 }
1250
1251 switch (root->func) {
1252 case Val: return op0;
1253 case Sig: return -op0;
1254 case Add: return ((mask & MASK_SUB) == 0) ? op0 + op1 : op0 - op1;
1255 case Sub: return ((mask & MASK_SUB) == 0) ? op0 - op1 : op0 + op1;
1256 case Mul: return ((mask & MASK_DIV) == 0) ? op0 * op1 : op0 / op1;
1257 case Div: return ((mask & MASK_DIV) == 0) ? op0 / op1 : op0 * op1;
1258 case Mod: return fmod (op0, op1);
1259 case Pow: return pow (op0, op1);
1260 case Sqr: return sqrt (op0);
1261 case Cos: return cos (op0);
1262 case Sin: return sin (op0);
1263 case Tan: return tan (op0);
1264 case Acos: return acos (op0);
1265 case Asin: return asin (op0);
1266 case Atan: return atan (op0);
1267 case Ln: return log (op0);
1268 case Log: return log10 (op0);
1269 case Exp: return exp (op0);
1270 case Erfc: return erfc (op0);
1271 case Erf: return erf (op0);
1272 case Abs: return fabs (op0);
1273 case Ceil: return ceil (op0);
1274 case Floor: return floor (op0);
1275 case Store: return store ((int)op0, (op1) ? op1 : answer);
1276 case Recall: return recall ((int)op0);
1277 case Inc: return increase ((int)op0);
1278 case Dec: return decrease ((int)op0);
1279 case Disp: display (); break;
1280 case Mem: memory ((int)op0); break;
1281 case Clear: clear (); break;
1282 case Quit: quit (); break;
1283 case Help: help (); break;
1284 case Ans: return answer;
1285 case Pi: return M_PI;
1286 case E: return M_E;
1287 case Equal: return op0 == op1;
1288 case Diff: return op0 != op1;
1289 case Ge: return op0 >= op1;
1290 case Le: return op0 <= op1;
1291 case Gt: return op0 > op1;
1292 case Lt: return op0 < op1;
1293 case And: return (op0 != 0) && (op1 != 0);
1294 case Or: return (op0 != 0) || (op1 != 0);
1295 case Not: return (op0 == 0);
1296 case Cond:
1297 if ((op0) && (root->ops[1])) {
1298 return evaluate_element (root->ops[1], 0);
1299 } else if ((!op0) && (root->ops[2])) {
1300 return evaluate_element (root->ops[2], 0);
1301 } else {
1302 return 0;
1303 }
1304 case While: return while_do (root->ops[0], root->ops[1]);
1305 case Code: return execute_code (root->ops, root->nbops);
1306 case Print: return print (op0);
1307 case Prog:
1308 prog ((int)op0, (int)op1, root->ops[2]);
1309 savestring ((int)op0, root->string);
1310 break;
1311 case Call:
1312 for (i = 1, nb =0; i < root->nbops; i++) {
1313 if (root->ops[i]) {
1314 nb++;
1315 }
1316 }
1317 return call ((int)op0, nb, root->ops + 1);
1318 case List: list (); break;
1319 case Edit: edit ((int)op0); break;
1320 case Del: del ((int)op0); break;
1321 case Get: return get ((int)op0);
1322 case Length: return length ();
1323 case Pop: return pop ();
1324 case Push: return push (op0);
1325 case Put: return put ((int)op0, op1);
1326 case Set:
1327 for (i = 0, nb =0; i < root->nbops; i++) {
1328 if (root->ops[i]) {
1329 nb++;
1330 }
1331 }
1332 return set (nb, root->ops);
1333 case Show: show (); break;
1334 }
1335
1336 return 0;
1337 }
1338
1339 char **generate_completion_list ()
1340 {
1341 int i, j, l = 0;
1342 char **list = (char **) callocordie (NB_OPERATORS + NB_FUNCTIONS + NB_CONSTANTS + NB_SYMBOLS + 1, sizeof (char *));
1343
1344 for (i = 0; i < NB_OPERATORS; i++) {
1345 list[l] = strdup ((operators + i)->keyword);
1346 for (j = 0; j < (int)strlen (list[l]); j++) {
1347 if (list[i][j] == '\t') {
1348 list[i][j] = '\0';
1349 }
1350 }
1351 if (list[l] != NULL) {
1352 l++;
1353 }
1354 }
1355
1356 for (i = 0; i < NB_FUNCTIONS; i++) {
1357 list[l] = strdup ((functions + i)->keyword);
1358 if (list[l] != NULL) {
1359 l++;
1360 }
1361 }
1362
1363 for (i = 0; i < NB_CONSTANTS; i++) {
1364 list[l] = strdup ((constants + i)->keyword);
1365 if (list[l] != NULL) {
1366 l++;
1367 }
1368 }
1369
1370 for (i = 0; i < NB_SYMBOLS; i++) {
1371 list[l] = strdup (symbols[i]);
1372 if (list[l] != NULL) {
1373 l++;
1374 }
1375 }
1376
1377 return (list);
1378 }
1379
1380 void free_completion_list (char **list)
1381 {
1382 int i;
1383
1384 if (list) {
1385 for (i = 0; i < NB_OPERATORS + NB_FUNCTIONS + NB_CONSTANTS + NB_SYMBOLS + 1; i++) {
1386 if (list[i] != NULL) {
1387 free (list[i]);
1388 }
1389 }
1390 free (list);
1391 }
1392 }
1393
1394
1395 /* vim: set ts=4 sw=4 et: */
Simple calculator