Src/Plugins/Visualization/vis_avs/evallib/cal.y


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155


       %{
       #define YYSTYPE double
       #include <malloc.h>
       #include <memory.h>
       #include "Compiler.h"
       #include "eval.h"

       yyerror(char *);
       yylex();

       extern int yyStackSize;
       extern double result;

       int regs[26];
       int base;

       %}

       %token VALUE IDENTIFIER FUNCTION1 FUNCTION2 FUNCTION3

       %left '|' 
       %left '&'
       %left '+' '-'
       %left '*' '/' '%'
       %left UMINUS /*supplies precedence for unary minus */
       %left UPLUS /*supplies precedence for unary plus */

       %%      /*beginning of rules section */

       stat    :       math_expr 
		       {       $$ = $1; result = $1;     }
	       |       IDENTIFIER '=' math_expr 
		       {       if (parseType == PARSE_EVAL)
                                 {
                                 setVar((int)$1, $3);  
                                 $$ = $3;
			         result = $3;
                                 }
                               else
                                 {
                                 double i = setVar((int)$1, 0);
                                 double v = createCompiledValue(0, &(varTable[(int)i].value));
                                 $$ = createCompiledFunction2(MATH_SIMPLE, FN_ASSIGN, v, $3);
                                 result = $$;
                                 }
                       }
	       ;

       value   :       VALUE { $$ = $1 }


       primary_expr
               :       IDENTIFIER
		       {       $$ = getVar((int)$1);}
               |       value
		       {       $$ = $1;}
               |       '(' math_expr ')'
		       {       $$ = $2;}
               ;

       math_expr
               :       primary_expr
                       { $$ = $1;              }
               |       math_expr '*' math_expr
		       {       if (parseType == PARSE_EVAL)
                                  $$ = $1 * $3;
                               else
                                  $$ = createCompiledFunction2(MATH_SIMPLE, FN_MULTIPLY, $1, $3);
                       }
	       |       math_expr '/' math_expr
		       {       if (parseType == PARSE_EVAL)
                                  $$ = $1 / $3;
                               else
                                  $$ = createCompiledFunction2(MATH_SIMPLE, FN_DIVIDE, $1, $3);
                       }
	       |       math_expr '%' math_expr
		       {       if (parseType == PARSE_EVAL)
                                  $$ = (double)((int)$1 % (int)$3);
                               else
                                  $$ = createCompiledFunction2(MATH_SIMPLE, FN_MODULO, $1, $3);
                       }
	       |       math_expr '+' math_expr
		       {       if (parseType == PARSE_EVAL)
		                  $$ = $1 + $3;   
                               else
                                  $$ = createCompiledFunction2(MATH_SIMPLE, FN_ADD, $1, $3);
                       }
	       |       math_expr '-' math_expr
		       {       if (parseType == PARSE_EVAL)
		                  $$ = $1 - $3;   
                               else
                                  $$ = createCompiledFunction2(MATH_SIMPLE, FN_SUB, $1, $3);
                       }
	       |       math_expr '&' math_expr 
		       {       if (parseType == PARSE_EVAL)
		                  $$ = (double)((int)$1 & (int)$3);   
                               else
                                  $$ = createCompiledFunction2(MATH_SIMPLE, FN_AND, $1, $3);
                       }
	       |       math_expr '|' math_expr
		       {       if (parseType == PARSE_EVAL)
		                  $$ = (double)((int)$1 | (int)$3);   
                               else
                                  $$ = createCompiledFunction2(MATH_SIMPLE, FN_OR, $1, $3);
                       }
	       |       '-' math_expr %prec UMINUS
		       {       if (parseType == PARSE_EVAL)
		                  $$ = -$2;       
                               else
                                  $$ = createCompiledFunction1(MATH_SIMPLE, FN_UMINUS, $2);
                       }
	       |       '+' math_expr %prec UPLUS
		       {       if (parseType == PARSE_EVAL)
		                  $$ = +$2;       
                               else
                                  $$ = createCompiledFunction1(MATH_SIMPLE, FN_UPLUS, $2);
                       }
               |       fonction
                       {       $$ = $1;        }
	       ;

       fonction
               :       FUNCTION1 '(' math_expr ')'
		       {       if (parseType == PARSE_EVAL)
                                  $$ = calcFunction1((int)$1, $3);
                               else
                                  $$ = createCompiledFunction1(MATH_FN, (int)$1, $3);
                       }
               |       FUNCTION2 '(' math_expr ',' math_expr ')'
		       {       if (parseType == PARSE_EVAL)
                                  $$ = calcFunction2((int)$1, $3, $5);
                               else
                                  $$ = createCompiledFunction2(MATH_FN, (int)$1, $3, $5);
                       }
               |       FUNCTION3 '(' math_expr ',' math_expr ',' math_expr ')'
		       {       if (parseType == PARSE_EVAL)
                                  $$ = calcFunction3((int)$1, $3, $5, $7);
                               else
                                  $$ = createCompiledFunction3(MATH_FN, (int)$1, $3, $5, $7);
                       }
               ;
             

       %%
       main()
       {
	       return(yyparse());
       }

       yywrap()
       {
	       return(1);
       }