Soft'N'Design Software / projects / calc.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
stack management
[calc.git] / parser.c
... / ...
CommitLineData
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
13double answer = 0;
14
15#define DEFAULT_STORAGE_SIZE 10
16int storage_size = -1;
17double *storage = NULL;
18
19int stack_size = 0;
20double *stack = NULL;
21
22#define DEFAULT_FORMAT "=> %.6g\n"
23char *format = NULL;
24char *minform = NULL;
25
26workspace_t *programs = NULL;
27int nb_programs = 0;
28
29/* compare codes */
30
31int 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
53void *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
68element_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
83void 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
99element_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
120keyword_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
138keyword_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, 9},
179 { "show", Show, 0, 4, 9},
180};
181
182#define NB_CONSTANTS 3
183keyword_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
190char *symbols[NB_SYMBOLS] = {
191 "(", ")", "{", "}"
192};
193
194/* subparser function */
195
196element_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
218element_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
501void 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
593void 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
611double 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
624double 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
637double 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
650double 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
663void 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
677void 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
687double 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
716double 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
728void 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
738void 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
750double print (double value)
751{
752 fprintf (stdout, format ? format : DEFAULT_FORMAT, value);
753 fflush (stdout);
754 return value;
755}
756
757/* quit function */
758
759void quit (void)
760{
761 fprintf (stdout, "bye\n");
762 exit (0);
763}
764
765/* program function */
766
767void 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
824double 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
875 /* restore context */
876 answer = tmp.answer;
877 storage = tmp.storage;
878 storage = tmp.storage;
879 stack_size = tmp.stack_size;
880 stack_size = tmp.stack_size;
881
882 return ret;
883}
884
885void list ()
886{
887 int i;
888 fprintf (stdout, "programs:");
889 for (i = 0; i < nb_programs; i++) {
890 fprintf (stdout, " %d", (programs + i)->id);
891 }
892 fprintf (stdout, "\n");
893}
894
895void edit (int id)
896{
897 int i, n = -1;
898
899 if (programs) {
900
901 /* look for program */
902 for (i = 0; i < nb_programs; i++) {
903 if ((programs + i)->id == id) {
904 n = i;
905 break;
906 }
907 }
908 }
909 if (n == -1) {
910 VERBOSE (WARNING, fprintf (stdout, "error unknown program (%d)\n", id));
911 return;
912 }
913
914 /* set string program */
915 fprintf (stdout, "edit: %s\n", (programs + n)->string);
916}
917
918void savestring (int id, char *string)
919{
920 int i, n = -1;
921
922 if (programs) {
923
924 /* look for program */
925 for (i = 0; i < nb_programs; i++) {
926 if ((programs + i)->id == id) {
927 n = i;
928 break;
929 }
930 }
931 }
932
933 /* unnecesary code */
934 //if (n == -1) {
935 // VERBOSE (WARNING, fprintf (stdout, "error unknown program (%d)\n", id));
936 // return;
937 //}
938 //if ((programs + n)->string) {
939 // free ((programs + n)->string);
940 //}
941
942 (programs + n)->string = strdup (string);
943}
944
945void del (int id)
946{
947 int i, j, n = -1;
948
949 if (programs) {
950
951 /* look for program */
952 for (i = 0; i < nb_programs; i++) {
953 if ((programs + i)->id == id) {
954 n = i;
955 break;
956 }
957 }
958 }
959 if (n == -1) {
960 VERBOSE (WARNING, fprintf (stdout, "error unknown program (%d)\n", id));
961 return;
962 }
963
964 /* clean program */
965 if ((programs + n)->storage) {
966 free ((programs + n)->storage);
967 }
968 if ((programs + n)->stack) {
969 free ((programs + n)->stack);
970 }
971 if ((programs + n)->root) {
972 delelement ((programs + n)->root);
973 }
974 if ((programs + n)->string) {
975 free ((programs + n)->string);
976 }
977
978 /* remove entry */
979 workspace_t *tmp = (workspace_t *) callocordie (nb_programs - 1, sizeof (workspace_t));
980 for (i = 0, j = 0; i < nb_programs; i++) {
981 if (i != n) {
982 memcpy (tmp + j, programs + i, sizeof (workspace_t));
983 j++;
984 }
985 }
986 free (programs);
987 programs = tmp;
988 nb_programs--;
989}
990
991/* stack management */
992
993double get (int n)
994{
995 double ret = 0;
996 if ((n <= 0) || (n > stack_size)) {
997 VERBOSE (WARNING, fprintf (stdout, "error out of bound (%d/%d)\n", n, stack_size));
998 } else {
999 ret = stack[n - 1];
1000 }
1001 return ret;
1002}
1003
1004double length ()
1005{
1006 return stack_size;
1007}
1008
1009double pop ()
1010{
1011 double ret = 0;
1012 if (stack_size > 0) {
1013 ret = stack[--stack_size];
1014 double *tmp = (double *) callocordie (stack_size, sizeof (double));
1015 memcpy (tmp, stack, stack_size * sizeof (double));
1016 free (stack);
1017 stack = tmp;
1018 } else {
1019 VERBOSE (WARNING, fprintf (stdout, "error stack empty\n"));
1020 }
1021 return ret;
1022}
1023
1024double push (double val)
1025{
1026 double *tmp = (double *) callocordie (stack_size + 1, sizeof (double));
1027 memcpy (tmp, stack, stack_size * sizeof (double));
1028 if (stack) {
1029 free (stack);
1030 }
1031 stack = tmp;
1032 stack[stack_size++] = val;
1033 return val;
1034}
1035
1036double put (int n, double val)
1037{
1038 if (n <= 0) {
1039 VERBOSE (WARNING, fprintf (stdout, "error out of bound (%d/%d)\n", n, stack_size));
1040 return 0;
1041 }
1042 if (n > stack_size) {
1043 double *tmp = (double *) callocordie (n, sizeof (double));
1044 memcpy (tmp, stack, stack_size * sizeof (double));
1045 free (stack);
1046 stack = tmp;
1047 stack_size = n;
1048 }
1049 stack[n - 1] = val;
1050 return val;
1051}
1052
1053double set (int nbops, element_t **ops)
1054{
1055 int i;
1056 if (stack) {
1057 free (stack);
1058 }
1059 stack = NULL;
1060 stack_size = 0;
1061 if (nbops != 0) {
1062 stack = (double *) callocordie (nbops, sizeof (double));
1063 for (i = 0; i < nbops; i++) {
1064 stack[i] = evaluate_element (ops[i], 0);
1065 }
1066 stack_size = nbops;
1067 }
1068 return stack_size;
1069}
1070
1071void show (void)
1072{
1073 int i;
1074 fprintf (stdout, "stack:");
1075 for (i = 0; i < stack_size; i++) {
1076 fprintf (stdout, " ");
1077 fprintf (stdout, minform, stack[i]);
1078 }
1079 fprintf (stdout, "\n");
1080}
1081
1082/* help message */
1083
1084void help (void)
1085{
1086 fprintf (stdout, "calc is a simple calculator\n\n");
1087 fprintf (stdout, "arithmetic op.:");
1088 fprintf (stdout, " + - * / %% ^\n");
1089 fprintf (stdout, "comparison op.:");
1090 fprintf (stdout, " == != >= <= > <\n");
1091 fprintf (stdout, "logical op.:");
1092 fprintf (stdout, " & | !\n");
1093 fprintf (stdout, "mathematic func.:");
1094 fprintf (stdout, " exp ln log pow sqrt\n");
1095 fprintf (stdout, "trigonometric func.:");
1096 fprintf (stdout, " acos asin atan cos sin tan\n");
1097 fprintf (stdout, "error functions:");
1098 fprintf (stdout, " erf erfc\n");
1099 fprintf (stdout, "miscellaneous func.:");
1100 fprintf (stdout, " abs ceil floor\n");
1101 fprintf (stdout, "storage func.:");
1102 fprintf (stdout, " clear dec disp inc mem rcl sto\n");
1103 fprintf (stdout, "control flow prim.:");
1104 fprintf (stdout, " cond print while {} ;\n");
1105 fprintf (stdout, "program management:");
1106 fprintf (stdout, " call del edit ls prog\n");
1107 fprintf (stdout, "stack management:");
1108 fprintf (stdout, " get len pop push put set show\n");
1109 fprintf (stdout, "control management:");
1110 fprintf (stdout, " help quit\n");
1111 fprintf (stdout, "constants:");
1112 fprintf (stdout, " ans e pi\n");
1113}
1114
1115/* evaluate element tree */
1116
1117#define MASK_SUB 0x1
1118#define MASK_DIV 0x2
1119
1120double evaluate_element (element_t *root, char mask)
1121{
1122 double op0 = 0, op1 = 0;
1123 char nextmask = mask;
1124 int i, nb;
1125
1126 if ((root == NULL) || (root == ERROR_OP)) {
1127 VERBOSE (WARNING, fprintf (stdout, "error while evaluating\n"));
1128 return 0;
1129 }
1130
1131 /* mask to manage sub operator sub and div */
1132 switch (root->func) {
1133 case Add:
1134 nextmask &= ~MASK_SUB;
1135 nextmask &= ~MASK_DIV;
1136 break;
1137 case Sub:
1138 nextmask |= MASK_SUB;
1139 nextmask &= ~MASK_DIV;
1140 break;
1141 case Mul:
1142 nextmask &= ~MASK_DIV;
1143 break;
1144 case Div:
1145 nextmask |= MASK_DIV;
1146 break;
1147 default:
1148 nextmask = mask;
1149 }
1150
1151 switch (root->func) {
1152 case Val:
1153 case Sig:
1154 op0 = (root->ops[0]) ? evaluate_element (root->ops[0], nextmask) : root->value;
1155 break;
1156 case Add:
1157 case Sub:
1158 case Mul:
1159 case Div:
1160 case Mod:
1161 case Pow:
1162 case Store:
1163 case Equal:
1164 case Diff:
1165 case Ge:
1166 case Le:
1167 case Gt:
1168 case Lt:
1169 case And:
1170 case Or:
1171 case Prog:
1172 if (root->ops[1]) {
1173 op1 = evaluate_element (root->ops[1], nextmask);
1174 } else if (root->func != Store) {
1175 VERBOSE (WARNING, fprintf (stdout, "error while evaluating (op[1])\n"));
1176 return 0;
1177 }
1178 /* fallthrough */
1179 case Sqr:
1180 case Cos:
1181 case Sin:
1182 case Tan:
1183 case Acos:
1184 case Asin:
1185 case Atan:
1186 case Ln:
1187 case Log:
1188 case Exp:
1189 case Erfc:
1190 case Erf:
1191 case Abs:
1192 case Ceil:
1193 case Floor:
1194 case Recall:
1195 case Inc:
1196 case Dec:
1197 case Not:
1198 case Mem:
1199 case Cond:
1200 case Call:
1201 case Edit:
1202 case Del:
1203 case Get:
1204 if (root->ops[0]) {
1205 op0 = evaluate_element (root->ops[0], 0);
1206 } else {
1207 VERBOSE (WARNING, fprintf (stdout, "error while evaluating (op[0])\n"));
1208 return 0;
1209 }
1210 break;
1211 case Disp:
1212 case Clear:
1213 case Quit:
1214 case Help:
1215 case Ans:
1216 case Pi:
1217 case E:
1218 case Code:
1219 case List:
1220 case Length:
1221 case Pop:
1222 case Set:
1223 case Show:
1224 break;
1225 case While:
1226 if (root->ops[0] == NULL) {
1227 VERBOSE (WARNING, fprintf (stdout, "error while evaluating (op[0])\n"));
1228 return 0;
1229 }
1230 break;
1231 case Push:
1232 case Print:
1233 op0 = (root->ops[0]) ? evaluate_element (root->ops[0], 0) : answer;
1234 break;
1235 case Put:
1236 if (root->ops[0]) {
1237 op0 = evaluate_element (root->ops[0], 0);
1238 } else {
1239 VERBOSE (WARNING, fprintf (stdout, "error while evaluating (op[0])\n"));
1240 return 0;
1241 }
1242 op1 = (root->ops[1]) ? evaluate_element (root->ops[1], 0) : answer;
1243 break;
1244 }
1245
1246 switch (root->func) {
1247 case Val: return op0;
1248 case Sig: return -op0;
1249 case Add: return ((mask & MASK_SUB) == 0) ? op0 + op1 : op0 - op1;
1250 case Sub: return ((mask & MASK_SUB) == 0) ? op0 - op1 : op0 + op1;
1251 case Mul: return ((mask & MASK_DIV) == 0) ? op0 * op1 : op0 / op1;
1252 case Div: return ((mask & MASK_DIV) == 0) ? op0 / op1 : op0 * op1;
1253 case Mod: return fmod (op0, op1);
1254 case Pow: return pow (op0, op1);
1255 case Sqr: return sqrt (op0);
1256 case Cos: return cos (op0);
1257 case Sin: return sin (op0);
1258 case Tan: return tan (op0);
1259 case Acos: return acos (op0);
1260 case Asin: return asin (op0);
1261 case Atan: return atan (op0);
1262 case Ln: return log (op0);
1263 case Log: return log10 (op0);
1264 case Exp: return exp (op0);
1265 case Erfc: return erfc (op0);
1266 case Erf: return erf (op0);
1267 case Abs: return fabs (op0);
1268 case Ceil: return ceil (op0);
1269 case Floor: return floor (op0);
1270 case Store: return store ((int)op0, (op1) ? op1 : answer);
1271 case Recall: return recall ((int)op0);
1272 case Inc: return increase ((int)op0);
1273 case Dec: return decrease ((int)op0);
1274 case Disp: display (); break;
1275 case Mem: memory ((int)op0); break;
1276 case Clear: clear (); break;
1277 case Quit: quit (); break;
1278 case Help: help (); break;
1279 case Ans: return answer;
1280 case Pi: return M_PI;
1281 case E: return M_E;
1282 case Equal: return op0 == op1;
1283 case Diff: return op0 != op1;
1284 case Ge: return op0 >= op1;
1285 case Le: return op0 <= op1;
1286 case Gt: return op0 > op1;
1287 case Lt: return op0 < op1;
1288 case And: return (op0 != 0) && (op1 != 0);
1289 case Or: return (op0 != 0) || (op1 != 0);
1290 case Not: return (op0 == 0);
1291 case Cond:
1292 if ((op0) && (root->ops[1])) {
1293 return evaluate_element (root->ops[1], 0);
1294 } else if ((!op0) && (root->ops[2])) {
1295 return evaluate_element (root->ops[2], 0);
1296 } else {
1297 return 0;
1298 }
1299 case While: return while_do (root->ops[0], root->ops[1]);
1300 case Code: return execute_code (root->ops, root->nbops);
1301 case Print: return print (op0);
1302 case Prog:
1303 prog ((int)op0, (int)op1, root->ops[2]);
1304 savestring ((int)op0, root->string);
1305 break;
1306 case Call:
1307 for (i = 1, nb =0; i < root->nbops; i++) {
1308 if (root->ops[i]) {
1309 nb++;
1310 }
1311 }
1312 return call ((int)op0, nb, root->ops + 1);
1313 case List: list (); break;
1314 case Edit: edit ((int)op0); break;
1315 case Del: del ((int)op0); break;
1316 case Get: return get ((int)op0);
1317 case Length: return length ();
1318 case Pop: return pop ();
1319 case Push: return push (op0);
1320 case Put: return put ((int)op0, op1);
1321 case Set:
1322 for (i = 0, nb =0; i < root->nbops; i++) {
1323 if (root->ops[i]) {
1324 nb++;
1325 }
1326 }
1327 return set (nb, root->ops);
1328 case Show: show (); break;
1329 }
1330
1331 return 0;
1332}
1333
1334char **generate_completion_list ()
1335{
1336 int i, j, l = 0;
1337 char **list = (char **) callocordie (NB_OPERATORS + NB_FUNCTIONS + NB_CONSTANTS + NB_SYMBOLS + 1, sizeof (char *));
1338
1339 for (i = 0; i < NB_OPERATORS; i++) {
1340 list[l] = strdup ((operators + i)->keyword);
1341 for (j = 0; j < (int)strlen (list[l]); j++) {
1342 if (list[i][j] == '\t') {
1343 list[i][j] = '\0';
1344 }
1345 }
1346 if (list[l] != NULL) {
1347 l++;
1348 }
1349 }
1350
1351 for (i = 0; i < NB_FUNCTIONS; i++) {
1352 list[l] = strdup ((functions + i)->keyword);
1353 if (list[l] != NULL) {
1354 l++;
1355 }
1356 }
1357
1358 for (i = 0; i < NB_CONSTANTS; i++) {
1359 list[l] = strdup ((constants + i)->keyword);
1360 if (list[l] != NULL) {
1361 l++;
1362 }
1363 }
1364
1365 for (i = 0; i < NB_SYMBOLS; i++) {
1366 list[l] = strdup (symbols[i]);
1367 if (list[l] != NULL) {
1368 l++;
1369 }
1370 }
1371
1372 return (list);
1373}
1374
1375void free_completion_list (char **list)
1376{
1377 int i;
1378
1379 if (list) {
1380 for (i = 0; i < NB_OPERATORS + NB_FUNCTIONS + NB_CONSTANTS + NB_SYMBOLS + 1; i++) {
1381 if (list[i] != NULL) {
1382 free (list[i]);
1383 }
1384 }
1385 free (list);
1386 }
1387}
1388
1389
1390/* vim: set ts=4 sw=4 et: */
Simple calculator