4d9b01a23b8a81bb438ba989f9e0df76d85a0ceb
17 /* external definition */
19 extern void history ();
21 /* global variables */
25 double anglefactor
= 1;
29 int codecmp (char *ref
, char *str
)
33 while (*ref
!= '\0') {
35 sig
= (*str
== '.') ? -1 : ((*str
>= '0') && (*str
<= '9'));
40 return (sig
> 0) ? 1 : -1;
53 #define NB_OPERATORS 14
54 keyword_t operators
[NB_OPERATORS
] = {
55 { "+\t", Add
, 2, 1, 1},
56 { "-\t", Sub
, 2, 1, 1},
61 { "==", Equal
, 2, 2, -1},
62 { "!=", Diff
, 2, 2, -1},
63 { ">=", Ge
, 2, 2, -1},
64 { "<=", Le
, 2, 2, -1},
67 { "&", And
, 2, 1, -2},
71 #define NB_FUNCTIONS 56
72 keyword_t functions
[NB_FUNCTIONS
] = {
73 { "sqrt", Sqr
, 1, 4, 5},
74 { "pow", Pow
, 2, 3, 5},
75 { "cos", Cos
, 1, 3, 5},
76 { "sin", Sin
, 1, 3, 5},
77 { "tan", Tan
, 1, 3, 5},
78 { "acos", Acos
, 1, 4, 5},
79 { "asin", Asin
, 1, 4, 5},
80 { "atan", Atan
, 1, 4, 5},
82 { "log", Log
, 1, 3, 5},
83 { "exp", Exp
, 1, 3, 5},
84 { "erfc", Erfc
, 1, 4, 5},
85 { "erf", Erf
, 1, 3, 5},
86 { "abs", Abs
, 1, 3, 5},
87 { "floor", Floor
, 1, 5, 5},
88 { "ceil", Ceil
, 1, 4, 5},
89 { "sto", Store
, 2, 3, 5},
90 { "rcl", Recall
, 1, 3, 5},
91 { "inc", Inc
, 1, 3, 5},
92 { "dec", Dec
, 1, 3, 5},
93 { "disp", Disp
, 0, 4, 9},
94 { "mem", Memory
, 1, 3, 5},
95 { "clr", Clear
, 0, 3, 9},
96 { "quit", Quit
, 0, 4, 9},
97 { "help", Help
, 0, 4, 9},
98 { "hist", History
, 0, 4, 9},
100 { "cond", Cond
, 3, 4, 5},
101 { "while", While
, 2, 5, 5},
102 { "print", Print
, 1, 5, 5},
103 { "prog", Prog
, 2, 4, 9},
104 { "arg", Arg
, 1, 3, 5},
105 { "call", Call
, MAX_ARGS
, 4, 5},
106 { "ls", List
, 0, 2, 9},
107 { "edit", Edit
, 1, 4, 9},
108 { "del", Del
, 1, 3, 9},
109 { "get", Get
, 1, 3, 5},
110 { "len", Length
, 0, 3, 5},
111 { "pop", Pop
, 0, 3, 5},
112 { "push", Push
, 1, 4, 5},
113 { "put", Put
, 2, 3, 5},
114 { "set", Set
, MAX_ARGS
, 3, 5},
115 { "show", Show
, 0, 4, 5},
116 { "max", Max
, 2, 3, 5},
117 { "mean", Mean
, 2, 4, 5},
118 { "med", Median
, 0, 3, 5},
119 { "min", Min
, 2, 3, 5},
120 { "ord", Order
, 0, 3, 5},
121 { "prod", Prod
, 0, 4, 5},
122 { "sum", Sum
, 0, 3, 5},
123 { "var", Variance
, 2, 3, 5},
124 { "format", Precision
, 1, 6, 9},
125 { "base", Base
, 2, 4, 9},
126 { "deg", Deg
, 0, 3, 9},
127 { "grad", Grad
, 0, 4, 9},
128 { "rad", Rad
, 0, 3, 9}
131 #define NB_CONSTANTS 3
132 keyword_t constants
[NB_CONSTANTS
] = {
133 { "ans", Ans
, 0, 3, 5},
139 char *symbols
[NB_SYMBOLS
] = {
143 /* subparser function */
145 element_t
*subparser (element_t
**proot
, char **pstr
, func_t func
, int nbops
, int prio
)
147 element_t
*new = newelement (func
, nbops
, prio
);
148 new->ops
[0] = *proot
;
149 new->ops
[1] = parser (*pstr
, pstr
, new->prio
);
150 if ((new->ops
[1] == NULL
) || ((new->ops
[1] != ERROR_OP
) && (new->ops
[1]->prio
== 9))) {
151 delelement (new->ops
[1]);
152 new->ops
[1] = ERROR_OP
;
154 if (new->ops
[1] == ERROR_OP
) {
159 *proot
= newelement (Val
, 1, 5);
160 (*proot
)->ops
[0] = new;
165 /* parser function */
167 element_t
*parser (char *str
, char **next
, int prio
)
169 element_t
*root
= NULL
;
173 VERBOSE (DEBUG
, fprintf (stdout
, "Starting parsing\n"));
176 while (*str
!= '\0') {
178 element_t
*new = NULL
;
179 VERBOSE (INFO
, fprintf (stdout
, "Processing: %s\n", str
));
181 /* end without printing */
190 /* skip spaces and tabs */
192 if ((*str
== ' ') || (*str
== '\t')) {
197 /* check for open brace */
200 VERBOSE (DEBUG
, fprintf (stdout
, "start processing brace\n"));
205 root
= newelement (Code
, 0, 5);
208 new = parser (str
+ 1, &str
, 0);
209 if ((new == NULL
) || ((new != ERROR_OP
) && (new->prio
== 9))) {
213 if (new == ERROR_OP
) {
217 element_t
*newcode
= newelement (Code
, root
->nbops
+ 1, 5);
218 for (i
= 0; i
< root
->nbops
; i
++) {
219 newcode
->ops
[i
] = root
->ops
[i
];
222 newcode
->ops
[root
->nbops
] = new;
225 } while (*str
== ',');
232 VERBOSE (DEBUG
, fprintf (stdout
, "stop processing brace\n"));
236 /* check for open bracket */
239 VERBOSE (DEBUG
, fprintf (stdout
, "start processing bracket\n"));
243 new = parser (str
+ 1, &str
, 0);
244 if ((new == NULL
) || ((new != ERROR_OP
) && (new->prio
== 9))) {
248 if ((new == NULL
) || (new == ERROR_OP
)) {
252 for (i
= 0; i
< root
->nbops
; i
++) {
253 if (root
->ops
[i
] == NULL
) {
264 } while (*str
== ',');
266 root
= newelement (Val
, 1, 5);
267 new = parser (str
+ 1, &str
, 0);
268 if ((new == NULL
) || ((new != ERROR_OP
) && (new->prio
== 9))) {
272 if ((new == NULL
) || (new == ERROR_OP
) || (*str
== ',')) {
284 VERBOSE (DEBUG
, fprintf (stdout
, "stop processing bracket\n"));
288 /* check for closing bracket, closing brace or koma */
290 if ((*str
== ')') || (*str
== '}') || (*str
== ',')) {
301 /* look for operators */
303 for (i
= 0; i
< NB_OPERATORS
; i
++) {
304 keyword_t
*operator = operators
+ i
;
305 if (codecmp (operator->keyword
, str
) == 0) {
306 VERBOSE (DEBUG
, fprintf (stdout
, "start processing operator\n"));
307 if ((root
) && (root
->prio
== 9)) {
308 VERBOSE (DEBUG
, fprintf (stdout
, "terminal function (%d)\n", root
->func
));
312 if ((prio
) && (prio
> operator->prio
)) {
313 VERBOSE (DEBUG
, fprintf (stdout
, "stop because operator priority\n"));
317 str
+= operator->offset
;
318 VERBOSE (INFO
, fprintf (stdout
, "Oper: %d\n", operator->func
));
319 if (subparser (&root
, &str
, operator->func
, operator->nbops
, operator->prio
) == ERROR_OP
) {
323 } else if (*str
== '-') {
324 root
= newelement (Sig
, 1, 6);
329 VERBOSE (DEBUG
, fprintf (stdout
, "stop processing operator\n"));
337 /* look for functions */
339 for (i
= 0; i
< NB_FUNCTIONS
; i
++) {
340 keyword_t
*function
= functions
+ i
;
341 if (codecmp (function
->keyword
, str
) == 0) {
342 VERBOSE (DEBUG
, fprintf (stdout
, "start processing function\n"));
344 VERBOSE (INFO
, fprintf (stdout
, "Func: %d\n", function
->func
));
345 root
= newelement (function
->func
, function
->nbops
, function
->prio
);
350 str
+= function
->offset
;
352 VERBOSE (DEBUG
, fprintf (stdout
, "stop processing function\n"));
360 /* look for constant */
362 for (i
= 0; i
< NB_CONSTANTS
; i
++) {
363 keyword_t
*constant
= constants
+ i
;
364 if (codecmp (constant
->keyword
, str
) == 0) {
365 VERBOSE (DEBUG
, fprintf (stdout
, "start processing constant\n"));
367 VERBOSE (INFO
, fprintf (stdout
, "Const: %d\n", constant
->func
));
368 root
= newelement (constant
->func
, constant
->nbops
, constant
->prio
);
373 str
+= constant
->offset
;
375 VERBOSE (DEBUG
, fprintf (stdout
, "stop processing constant\n"));
383 /* look for number */
385 VERBOSE (DEBUG
, fprintf (stdout
, "start processing value\n"));
387 double value
= (get_ibase () == 10) ? strtod (str
, &pt
) : strtoul (str
, &pt
, get_ibase ());
388 VERBOSE (INFO
, fprintf (stdout
, "Value: %f\n", value
));
390 if ((root
== NULL
) || (root
->prio
== 6)) {
391 new = newelement (Val
, 1, 5);
396 for (i
= 0; i
< root
->nbops
; i
++) {
397 if (root
->ops
[i
] == NULL
) {
410 } else if ((*str
== '+') || (*str
== '-')) {
411 if ((prio
) && (prio
> 1)) {
412 VERBOSE (DEBUG
, fprintf (stdout
, "stop because operator priority\n"));
416 if (subparser (&root
, &str
, Add
, 2, 1) == ERROR_OP
) {
426 VERBOSE (DEBUG
, fprintf (stdout
, "stop processing value\n"));
443 root
->string
= string
;
449 /* print element tree */
451 void print_element (element_t
*root
, int level
)
456 if ((root
== NULL
) || (root
== ERROR_OP
)) {
460 for (i
= 0; i
< level
; i
++) {
464 switch (root
->func
) {
465 case Val
: func
= "Value"; break;
466 case Sig
: func
= "Sign"; break;
467 case Add
: func
= "Addition"; break;
468 case Sub
: func
= "Subtraction"; break;
469 case Mul
: func
= "Multiplication"; break;
470 case Div
: func
= "Division"; break;
471 case Mod
: func
= "Modulo"; break;
472 case Pow
: func
= "Power"; break;
473 case Sqr
: func
= "Square Root"; break;
474 case Cos
: func
= "Cosine"; break;
475 case Sin
: func
= "Sine"; break;
476 case Tan
: func
= "Tangent"; break;
477 case Acos
: func
= "Arc Cosine"; break;
478 case Asin
: func
= "Arc Sine"; break;
479 case Atan
: func
= "Arc Tangent"; break;
480 case Ln
: func
= "Logarithm (natural)"; break;
481 case Log
: func
= "Logarithm (10 base)"; break;
482 case Exp
: func
= "Exponantial"; break;
483 case Erfc
: func
= "Complementary Error Function"; break;
484 case Erf
: func
= "Error Function"; break;
485 case Abs
: func
= "Absolute value"; break;
486 case Ceil
: func
= "Ceil value"; break;
487 case Floor
: func
= "Floor value"; break;
488 case Store
: func
= "Store"; break;
489 case Recall
: func
= "Recall"; break;
490 case Inc
: func
= "Increase"; break;
491 case Dec
: func
= "Decrease"; break;
492 case Disp
: func
= "Display"; break;
493 case Memory
: func
= "Memory"; break;
494 case Clear
: func
= "Clear"; break;
495 case Quit
: func
= "Quit"; break;
496 case Help
: func
= "Help"; break;
497 case History
: func
= "History"; break;
498 case Ans
: func
= "Ans"; break;
499 case Pi
: func
= "Pi"; break;
500 case E
: func
= "E"; break;
501 case Equal
: func
= "Equal"; break;
502 case Diff
: func
= "Different"; break;
503 case Ge
: func
= "Greater or equal"; break;
504 case Le
: func
= "Lesser or equal"; break;
505 case Gt
: func
= "Greater"; break;
506 case Lt
: func
= "Lesser"; break;
507 case And
: func
= "And"; break;
508 case Or
: func
= "Or"; break;
509 case Not
: func
= "Not"; break;
510 case Cond
: func
= "Condition"; break;
511 case While
: func
= "While"; break;
512 case Code
: func
= "Code"; break;
513 case Print
: func
= "Print"; break;
514 case Prog
: func
= "Program"; break;
515 case Arg
: func
= "Argument"; break;
516 case Call
: func
= "Call"; break;
517 case List
: func
= "List"; break;
518 case Edit
: func
= "Edit"; break;
519 case Del
: func
= "Del"; break;
520 case Get
: func
= "Get"; break;
521 case Length
: func
= "Length"; break;
522 case Pop
: func
= "Pop"; break;
523 case Push
: func
= "Push"; break;
524 case Put
: func
= "Put"; break;
525 case Set
: func
= "Set"; break;
526 case Show
: func
= "Show"; break;
527 case Max
: func
= "Maximum"; break;
528 case Mean
: func
= "Mean"; break;
529 case Median
: func
= "Median"; break;
530 case Min
: func
= "Minimum"; break;
531 case Order
: func
= "Order"; break;
532 case Prod
: func
= "Product"; break;
533 case Sum
: func
= "Sum"; break;
534 case Variance
: func
= "Variance"; break;
535 case Precision
: func
= "Precision"; break;
536 case Base
: func
= "Base"; break;
537 case Deg
: func
= "Degree"; break;
538 case Grad
: func
= "Gradian"; break;
539 case Rad
: func
= "Radian"; break;
542 printf ("Function: %s\n", func
);
544 if ((root
->func
== Val
) && (root
->ops
[0] == NULL
)) {
545 for (i
= 0; i
< level
; i
++) {
548 printf ("value: %f\n", root
->value
);
550 for (i
= 0; i
< root
->nbops
; i
++) {
551 print_element (root
->ops
[i
], level
+ 1);
556 /* While do function */
558 double while_do (element_t
*cond
, element_t
*action
)
561 element_t
*temp
= NULL
;
563 VERBOSE (DEBUG
, fprintf (stdout
, "starting while loop\n"));
565 VERBOSE (DEBUG
, fprintf (stdout
, "loop...\n"));
567 temp
= dupelement (cond
);
568 double test
= evaluate_element (temp
, 0);
574 temp
= dupelement (action
);
575 ret
= evaluate_element (temp
, 0);
580 VERBOSE (DEBUG
, fprintf (stdout
, "ending while loop\n"));
585 /* program function */
587 double execute_code (element_t
**prog
, int nbcalls
)
591 for (i
= 0; i
< nbcalls
; i
++) {
592 ret
= evaluate_element (prog
[i
], 0);
609 printf ("calc is a simple calculator\n\n");
610 printf ("arithmetic op.:");
611 printf (" + - * / %% ^\n");
612 printf ("comparison op.:");
613 printf (" == != >= <= > <\n");
614 printf ("logical op.:");
616 printf ("mathematic func.:");
617 printf (" exp ln log pow sqrt\n");
618 printf ("trigonometric func.:");
619 printf (" acos asin atan cos sin tan\n");
620 printf ("error functions:");
621 printf (" erf erfc\n");
622 printf ("miscellaneous func.:");
623 printf (" abs ceil floor\n");
624 printf ("storage func.:");
625 printf (" clear dec disp inc mem rcl sto\n");
626 printf ("control flow prim.:");
627 printf (" cond print while {} ;\n");
628 printf ("program management:");
629 printf (" arg call del edit ls prog\n");
630 printf ("stack management:");
631 printf (" get len pop push put set show\n");
632 printf ("stack func.:");
633 printf (" max mean med min ord prod sum var\n");
634 printf ("control management:");
635 printf (" base format help hist quit\n");
636 printf ("angle management:");
637 printf (" deg grad rad\n");
638 printf ("constants:");
639 printf (" ans e pi\n");
642 /* format function */
644 int format (int precision
)
647 set_precision (precision
);
649 } else if (precision
!= -1) {
650 VERBOSE (WARNING
, fprintf (stdout
, "error incorrect precision (%d)\n", precision
));
653 return get_precision ();
658 void base (int in
, int out
)
660 if ((in
> 0) && (in
< 37)) {
662 if ((out
> 0) && (out
< 37)) {
664 } else if (out
!= - 1) {
665 VERBOSE (WARNING
, fprintf (stdout
, "error incorrect output base (%d)\n", out
));
667 } else if (in
!= -1 ) {
668 VERBOSE (WARNING
, fprintf (stdout
, "error incorrect input base (%d)\n", in
));
670 printf ("base (I/O): %s\n", show_base ());
674 /* evaluate element tree */
679 double evaluate_element (element_t
*root
, char mask
)
681 double op0
= 0, op1
= 0;
682 char nextmask
= mask
;
685 if ((root
== NULL
) || (root
== ERROR_OP
)) {
686 VERBOSE (WARNING
, fprintf (stdout
, "error while evaluating\n"));
690 /* mask to manage sub operator sub and div */
691 switch (root
->func
) {
693 nextmask
&= ~MASK_SUB
;
694 nextmask
&= ~MASK_DIV
;
697 nextmask
|= MASK_SUB
;
698 nextmask
&= ~MASK_DIV
;
701 nextmask
&= ~MASK_DIV
;
704 nextmask
|= MASK_DIV
;
710 switch (root
->func
) {
713 op0
= (root
->ops
[0]) ? evaluate_element (root
->ops
[0], nextmask
) : root
->value
;
730 op1
= evaluate_element (root
->ops
[1], nextmask
);
732 VERBOSE (WARNING
, fprintf (stdout
, "error while evaluating (op[1])\n"));
763 op0
= evaluate_element (root
->ops
[0], 0);
765 VERBOSE (WARNING
, fprintf (stdout
, "error while evaluating (op[0])\n"));
792 if (root
->ops
[0] == NULL
) {
793 VERBOSE (WARNING
, fprintf (stdout
, "error while evaluating (op[0])\n"));
798 if (root
->ops
[0] == NULL
) {
801 op0
= (int)evaluate_element (root
->ops
[0], 0);
803 VERBOSE (WARNING
, fprintf (stdout
, "error incorrect memory size (%d)\n", (int)op0
));
810 op0
= (root
->ops
[0]) ? evaluate_element (root
->ops
[0], 0) : answer
;
815 op0
= evaluate_element (root
->ops
[0], 0);
817 VERBOSE (WARNING
, fprintf (stdout
, "error while evaluating (op[0])\n"));
820 op1
= (root
->ops
[1]) ? evaluate_element (root
->ops
[1], 0) : answer
;
827 op0
= evaluate_element (root
->ops
[0], 0);
828 op1
= (root
->ops
[1]) ? evaluate_element (root
->ops
[1], 0) : answer
;
832 op0
= (root
->ops
[0]) ? evaluate_element (root
->ops
[0], 0) : -1;
835 op0
= (root
->ops
[0]) ? evaluate_element (root
->ops
[0], 0) : -1;
836 op1
= (root
->ops
[1]) ? evaluate_element (root
->ops
[1], 0) : -1;
840 switch (root
->func
) {
841 case Val
: return op0
;
842 case Sig
: return -op0
;
843 case Add
: return ((mask
& MASK_SUB
) == 0) ? op0
+ op1
: op0
- op1
;
844 case Sub
: return ((mask
& MASK_SUB
) == 0) ? op0
- op1
: op0
+ op1
;
845 case Mul
: return ((mask
& MASK_DIV
) == 0) ? op0
* op1
: op0
/ op1
;
846 case Div
: return ((mask
& MASK_DIV
) == 0) ? op0
/ op1
: op0
* op1
;
847 case Mod
: return fmod (op0
, op1
);
848 case Pow
: return pow (op0
, op1
);
849 case Sqr
: return sqrt (op0
);
850 case Cos
: return cos (op0
/ anglefactor
);
851 case Sin
: return sin (op0
/ anglefactor
);
852 case Tan
: return tan (op0
/ anglefactor
);
853 case Acos
: return acos (op0
) * anglefactor
;
854 case Asin
: return asin (op0
) * anglefactor
;
855 case Atan
: return atan (op0
) * anglefactor
;
856 case Ln
: return log (op0
);
857 case Log
: return log10 (op0
);
858 case Exp
: return exp (op0
);
859 case Erfc
: return erfc (op0
);
860 case Erf
: return erf (op0
);
861 case Abs
: return fabs (op0
);
862 case Ceil
: return ceil (op0
);
863 case Floor
: return floor (op0
);
864 case Store
: return store ((int)op0
, op1
);
865 case Recall
: return recall ((int)op0
);
866 case Inc
: return increase ((int)op0
);
867 case Dec
: return decrease ((int)op0
);
868 case Disp
: display (); break;
869 case Memory
: return memory ((root
->ops
[0]) ? (int)op0
: -1);
870 case Clear
: clear (); break;
871 case Quit
: quit (); break;
872 case Help
: help (); break;
873 case History
: history (); break;
874 case Ans
: return answer
;
875 case Pi
: return M_PI
;
877 case Equal
: return op0
== op1
;
878 case Diff
: return op0
!= op1
;
879 case Ge
: return op0
>= op1
;
880 case Le
: return op0
<= op1
;
881 case Gt
: return op0
> op1
;
882 case Lt
: return op0
< op1
;
883 case And
: return (op0
!= 0) && (op1
!= 0);
884 case Or
: return (op0
!= 0) || (op1
!= 0);
885 case Not
: return (op0
== 0);
887 if ((op0
) && (root
->ops
[1])) {
888 return evaluate_element (root
->ops
[1], 0);
889 } else if ((!op0
) && (root
->ops
[2])) {
890 return evaluate_element (root
->ops
[2], 0);
894 case While
: return while_do (root
->ops
[0], root
->ops
[1]);
895 case Code
: return execute_code (root
->ops
, root
->nbops
);
896 case Print
: return print (op0
);
898 prog ((int)op0
, root
->ops
[1]);
899 savestring ((int)op0
, root
->string
);
901 case Arg
: return arg ((int)op0
);
903 for (i
= 1, nb
= 0; i
< root
->nbops
; i
++) {
908 return call ((int)op0
, nb
, root
->ops
+ 1);
909 case List
: list (); break;
910 case Edit
: edit ((int)op0
); break;
911 case Del
: del ((int)op0
); break;
912 case Get
: return get ((int)op0
);
913 case Length
: return length ();
914 case Pop
: return pop ();
915 case Push
: return push (op0
);
916 case Put
: return put ((int)op0
, op1
);
918 for (i
= 0, nb
=0; i
< root
->nbops
; i
++) {
923 return set (nb
, root
->ops
);
924 case Show
: show (); break;
927 return op0
> op1
? op0
: op1
;
932 return (op0
+ op1
) / 2;
935 case Median
: return median ();
938 return op0
< op1
? op0
: op1
;
941 case Order
: order (); break;
942 case Prod
: return prod ();
943 case Sum
: return sum ();
946 double m
= (op0
+ op1
) / 2;
949 return op0
* op0
+ op1
* op1
;
953 return format ((int)op0
);
955 base ((int)op0
, (int)op1
);
958 anglefactor
= 180 / M_PI
;
961 anglefactor
= 200 / M_PI
;
971 char **generate_completion_list ()
974 char **list
= (char **) callocordie (NB_OPERATORS
+ NB_FUNCTIONS
+ NB_CONSTANTS
+ NB_SYMBOLS
+ 1, sizeof (char *));
976 for (i
= 0; i
< NB_OPERATORS
; i
++) {
977 list
[l
] = strdup ((operators
+ i
)->keyword
);
978 for (j
= 0; j
< (int)strlen (list
[l
]); j
++) {
979 if (list
[i
][j
] == '\t') {
983 if (list
[l
] != NULL
) {
988 for (i
= 0; i
< NB_FUNCTIONS
; i
++) {
989 list
[l
] = strdup ((functions
+ i
)->keyword
);
990 if (list
[l
] != NULL
) {
995 for (i
= 0; i
< NB_CONSTANTS
; i
++) {
996 list
[l
] = strdup ((constants
+ i
)->keyword
);
997 if (list
[l
] != NULL
) {
1002 for (i
= 0; i
< NB_SYMBOLS
; i
++) {
1003 list
[l
] = strdup (symbols
[i
]);
1004 if (list
[l
] != NULL
) {
1012 void free_completion_list (char **list
)
1017 for (i
= 0; i
< NB_OPERATORS
+ NB_FUNCTIONS
+ NB_CONSTANTS
+ NB_SYMBOLS
+ 1; i
++) {
1018 if (list
[i
] != NULL
) {
1026 /* vim: set ts=4 sw=4 et: */