![[BACK]](/icons/back.gif){kind=icon}
Return to capaFormula.y CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [LON-CAPA] / capa / capa51 / pProj|
Return to capaFormula.y CVS log | Up to [LON-CAPA] / capa / capa51 / pProj |
1.3 albertel 1: /* formula parser
2: Copyright (C) 1992-2000 Michigan State University
3:
4: The CAPA system is free software; you can redistribute it and/or
5: modify it under the terms of the GNU Library General Public License as
6: published by the Free Software Foundation; either version 2 of the
7: License, or (at your option) any later version.
8:
9: The CAPA system is distributed in the hope that it will be useful,
10: but WITHOUT ANY WARRANTY; without even the implied warranty of
11: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12: Library General Public License for more details.
13:
14: You should have received a copy of the GNU Library General Public
15: License along with the CAPA system; see the file COPYING. If not,
16: write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17: Boston, MA 02111-1307, USA. */
1.1 albertel 18:
19: /* ====================================================== */
20: /* capaFormula.y created by Isaac Tsai @ Feb 1999 */
21: /* copyrighted by Isaac Tsai 1999 */
22: /* TODO: checking user inputs 2/27/99 IT */
23: /* ====================================================== */
24: %{
25: #include <stdio.h>
26: #include <ctype.h>
27: #include <string.h>
28: #include <math.h>
29: #include "capaParser.h" /* _symbol structure def */
30: #include "capaCommon.h"
31: #include "capaFunction.h"
1.2 albertel 32: #ifdef YYSTYPE
33: #undef YYSTYPE
34: #endif
35: #define YYSTYPE Symbol_p
1.1 albertel 36: #include "capaToken.h"
37:
38: #ifdef __hpux
39: #include <stdlib.h>
40: #include <alloca.h>
41: #endif
42:
43: #ifdef FML_DBUG
44: #define FMLDBUG_PR1(xx) { printf(xx); fflush(stdout); }
45: #define FMLDBUG_PR2(xx,yy) { printf(xx,yy); fflush(stdout); }
46: #define FMLDBUG_PR3(xx,yy,zz) { printf(xx,yy,zz); fflush(stdout); }
47: #else
48: #define FMLDBUG_PR1(xx) { }
49: #define FMLDBUG_PR2(xx,yy) { }
50: #define FMLDBUG_PR3(xx,yy,zz) { }
51: #endif
52:
53: #define ADD_op 1
54: #define SUB_op 2
55: #define MUL_op 3
56: #define DIV_op 4
57: #define IDIV_op 5
58: #define NOT_DEFINED_op 9
59:
60:
61: /* =============================================================== */
62:
63: extern int Func_idx;
64: extern Symbol FuncStack[MAX_FUNC_NEST];
1.2 albertel 65: void fml_error(char *msg);
1.1 albertel 66: double FormulaVal;
67: int FormulaParseOK=1;
68:
69: %}
70:
71:
72: %token F_NUMBER V_ID F_ID EoI F_ERROR
73: %left F_PLUS F_MINUS
74: %left F_MULT F_DIV F_MOD
75: %token F_POW F_LPAR F_RPAR F_COMMA
76:
77:
78: %start f_expr
79:
80:
81: %%
82:
83: f_expr : block { switch($1->s_type) {
84: case I_VAR:
85: case I_CONSTANT: FormulaVal = (double)($1->s_int);
86: break;
87: case R_VAR:
88: case R_CONSTANT: FormulaVal = $1->s_real;
89: break;
90: case S_VAR:
91: case S_CONSTANT: FormulaParseOK = 0;
92: break;
93: default: FormulaParseOK = 0;
94: break;
95: }
96: capa_mfree((char *)$1);
97: FMLDBUG_PR1("[f_expr <= block ]\n");
98: }
99: ;
100:
101: block : block F_PLUS term { $$ = symbols_op($1, $3, ADD_op); }
102: | block F_MINUS term { $$ = symbols_op($1, $3, SUB_op); }
103: | term { $$ = $1; }
104: | F_ERROR { FormulaParseOK = 0; FMLDBUG_PR1("[F_ERROR]\n"); return 0;}
105: | error { FormulaParseOK = 0; FMLDBUG_PR1("[ERROR]\n"); return 0; }
106: ;
107:
108: term : term F_MULT basic_constr { $$ = symbols_op($1, $3, MUL_op); }
109: | term F_DIV basic_constr { $$ = symbols_op($1, $3, DIV_op); }
110: | term F_MOD basic_constr { $$ = symbols_op($1, $3, IDIV_op); }
111: | basic_constr { $$ = $1; }
112: ;
113:
114: basic_constr : basic_constr F_POW basic_item { $$ = f_symbol_pow($1,$3);
115: FMLDBUG_PR3("[%.16g ^ %.16g] ",$1->s_real,$3->s_real); }
116: | basic_item { $$ = $1; }
117: ;
118:
119: arg_list : arg_list F_COMMA block { $$ = $1;
120: $$->s_argc++;
121: $$->s_argp = addto_arglist($1->s_argp, $3);
122: }
123: | block { $$ = $1;
124: $$->s_argc = 1;
125: $$->s_argp = new_arglist($1);
126: }
127: ;
128:
129: basic_item : F_ID F_LPAR F_RPAR { int tmp;
130:
131: Func_idx--;
132: if(Func_idx >= 0 ) {
133: tmp = match_function(FuncStack[Func_idx].s_name,0);
134: $$ = do_function(tmp, 0, NULL );
135: capa_mfree(FuncStack[Func_idx].s_name);
136: }
137: }
138: | F_ID F_LPAR arg_list F_RPAR { int tmp;
139:
140: Func_idx--;
141: if(Func_idx >= 0 ) {
142: tmp = match_function(FuncStack[Func_idx].s_name,$3->s_argc);
143: $$ = do_function(tmp, $3->s_argc, $3->s_argp);
144: capa_mfree(FuncStack[Func_idx].s_name);
145: free_arglist($3->s_argp);
146: }
147: }
148: | V_ID { FMLDBUG_PR3("[V %s = %.16g] ",$1->s_name, $1->s_real);
149: $$ = $1;
150: }
151: | F_MINUS basic_item { $$ = $2;
152: switch($2->s_type) {
153: case I_VAR: $$ = (Symbol *)capa_malloc(sizeof(Symbol),1);
154: $$->s_type = I_CONSTANT;
155: case I_CONSTANT: $$->s_int = - $2->s_int; break;
156: case R_VAR: $$ = (Symbol *)capa_malloc(sizeof(Symbol),1);
157: $$->s_type = R_CONSTANT;
158: case R_CONSTANT: $$->s_real = (-1.0)*($2->s_real);
159: break;
160: case S_VAR:
161: case S_CONSTANT: break;
162: default: break;
163: }
164: }
165: | F_PLUS basic_item { $$ = $2; }
166: | F_NUMBER { FMLDBUG_PR2("[F %.16g] ",$1->s_real);
167: $$ = $1;
168: }
169: | F_LPAR block F_RPAR { $$ = $2; }
170: ;
171: %%
172: void
173: fml_error(char *msg)
174: {
175: FormulaParseOK=0;
176: printf("Error Parsing: %s\n",msg);
177:
178: }
179: /* ---------------------------------------------------- */
180: Symbol *
181: f_symbol_pow(ap,bp) Symbol *ap; Symbol *bp;
182: {
183: Symbol *cp;
184: double a, b;
185: int error = 0;
186:
187: cp = NULL;
188: switch(ap->s_type) {
189: case I_VAR: a = (double)(ap->s_int);
190: break;
191: case I_CONSTANT: a = (double)(ap->s_int); capa_mfree((char *)ap);
192: break;
193: case R_VAR: a = ap->s_real;
194: break;
195: case R_CONSTANT: a = ap->s_real; capa_mfree((char *)ap);
196: break;
197: case S_VAR:
198: case S_CONSTANT:
199: default: error = 1; break;
200: }
201: switch(bp->s_type) {
202: case I_VAR: b = (double)(bp->s_int);
203: break;
204: case I_CONSTANT: b = (double)(bp->s_int); capa_mfree((char *)bp);
205: break;
206: case R_VAR: b = bp->s_real;
207: break;
208: case R_CONSTANT: b = bp->s_real; capa_mfree((char *)bp);
209: break;
210: case S_VAR:
211: case S_CONSTANT:
212: default: error = 1; break;
213: }
1.4 ! albertel 214: if ((!(((double)((int)b)) == b)) && (a < 0.0)) {
! 215: error = 1;
! 216: }
1.1 albertel 217: if (!error) {
218: cp = (Symbol *)capa_malloc(sizeof(Symbol),1);
219: cp->s_type = R_CONSTANT;
220: cp->s_real = pow(a,b);
221:
222: }
223: return (cp);
224: }
225:
226: /* ============================================================================= */