Rev 9093 | Rev 9227 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
10 | reyssat | 1 | /* Copyright (C) 1998-2003 XIAO, Gang of Universite de Nice - Sophia Antipolis |
2 | * |
||
3 | * This program is free software; you can redistribute it and/or modify |
||
4 | * it under the terms of the GNU General Public License as published by |
||
5 | * the Free Software Foundation; either version 2 of the License, or |
||
6 | * (at your option) any later version. |
||
7 | * |
||
8 | * This program is distributed in the hope that it will be useful, |
||
9 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
||
10 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||
11 | * GNU General Public License for more details. |
||
12 | * |
||
13 | * You should have received a copy of the GNU General Public License |
||
14 | * along with this program; if not, write to the Free Software |
||
15 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. |
||
16 | */ |
||
8135 | bpr | 17 | #include "../Lib/libwims.h" |
18 | #include "oef2wims.h" |
||
10 | reyssat | 19 | int prepcnt; |
2656 | bpr | 20 | int ex_statement=0, ex_hint=0, ex_help=0, ex_solution=0, ex_latex=0; |
8135 | bpr | 21 | |
22 | const size_t MAX_KEY_LEN=128; |
||
10 | reyssat | 23 | char vbuf_statement[MAX_LINELEN+1]; |
24 | char vbuf_hint[MAX_LINELEN+1]; |
||
25 | char vbuf_help[MAX_LINELEN+1]; |
||
26 | char vbuf_solution[MAX_LINELEN+1]; |
||
9093 | bpr | 27 | char vbuf_latex[MAX_LINELEN+1]; |
10 | reyssat | 28 | |
7677 | bpr | 29 | /* empty processor, template. */ |
10 | reyssat | 30 | void empty(char *p[MAX_PARM]) {} |
31 | |||
9095 | bpr | 32 | void p_header(char *p[MAX_PARM]) |
3288 | bpr | 33 | { |
34 | p[0]=find_word_start(p[0]); |
||
35 | if(strlen(p[0])>MAX_KEY_LEN) p[0][MAX_KEY_LEN]=0; |
||
9095 | bpr | 36 | fprintf(outf,"%s=%s\n", p[1], p[0]); |
3288 | bpr | 37 | } |
38 | |||
10 | reyssat | 39 | void p_computeanswer(char *p[MAX_PARM]) |
7677 | bpr | 40 | { |
10 | reyssat | 41 | p[0]=find_word_start(p[0]); |
42 | *find_word_end(p[0])=0; |
||
43 | if(strcasecmp(p[0],"yes")) |
||
44 | fprintf(outf,"computeanswer=no\n"); |
||
45 | else fprintf(outf,"computeanswer=%s\n",p[0]); |
||
46 | } |
||
47 | |||
48 | void p_precision(char *p[MAX_PARM]) |
||
49 | { |
||
50 | int pr; |
||
51 | pr=atoi(p[0]); |
||
52 | if(pr<0 || pr>100000000) return; |
||
53 | fprintf(outf,"precision=%d\n",pr); |
||
54 | } |
||
55 | |||
1105 | bpr | 56 | void p_css(char *p[MAX_PARM]) |
7677 | bpr | 57 | { |
1105 | bpr | 58 | char vbuf_css[MAX_LINELEN+1]; |
59 | if(p==NULL) return; |
||
60 | snprintf(vbuf_css,sizeof(vbuf_css),"%s",p[0]); subst(vbuf_css); |
||
8113 | bpr | 61 | fprintf(outf,"oefcss=%s\n",vbuf_css); |
1105 | bpr | 62 | } |
4810 | bpr | 63 | |
64 | void p_credits(char *p[MAX_PARM]) |
||
65 | { |
||
66 | char vbuf_credits[MAX_LINELEN+1]; |
||
67 | if(p==NULL) return; |
||
9095 | bpr | 68 | snprintf(vbuf_credits,sizeof(vbuf_credits),"%s",p[0]); subst(vbuf_credits); |
7677 | bpr | 69 | singlespace(vbuf_credits); |
70 | fprintf(outf,"credits=%s\n\n", vbuf_credits); |
||
4810 | bpr | 71 | } |
72 | |||
10 | reyssat | 73 | void p_wims(char *p[MAX_PARM]) |
74 | { |
||
75 | char vbuf[MAX_LINELEN+1]; |
||
76 | snprintf(vbuf,sizeof(vbuf),"%s",p[0]); subst(vbuf); |
||
7677 | bpr | 77 | /* the second condition could be removed? |
78 | * To be very careful! */ |
||
10 | reyssat | 79 | if(strchr(vbuf,'=')==NULL || strchr(vbuf,'!')!=NULL) return; |
7677 | bpr | 80 | fprintf(outf,"%s\n",vbuf); |
10 | reyssat | 81 | } |
82 | |||
83 | void p_mdef(char *p[MAX_PARM]) |
||
84 | { |
||
85 | char vbuf[MAX_LINELEN+1]; |
||
86 | if(wordchr(mdef,p[0])==NULL) return; |
||
87 | snprintf(vbuf,sizeof(vbuf),"%s",p[1]); subst(vbuf); |
||
7677 | bpr | 88 | /* the second condition could be removed? |
89 | * To be very careful! */ |
||
10 | reyssat | 90 | if(strchr(vbuf,'!')!=NULL) return; |
91 | fprintf(outf,"m_%s=%s\n",p[0],vbuf); |
||
92 | } |
||
93 | |||
94 | void p_range(char *p[MAX_PARM]) |
||
95 | { |
||
96 | double left, right; |
||
97 | char *pp; |
||
98 | pp=strstr(p[0],".."); |
||
99 | if(pp==NULL) return; |
||
100 | *pp=0;pp+=strlen(".."); |
||
101 | left=atof(p[0]); right=atof(pp); |
||
102 | if(left>=right-1E-50 || left<-1E50 || right>1E50) return; |
||
103 | fprintf(outf,"leftrange=%f\nrightrange=%f\n",left,right); |
||
104 | } |
||
105 | |||
106 | void p_language(char *p[MAX_PARM]) |
||
7677 | bpr | 107 | { |
10 | reyssat | 108 | p[0]=find_word_start(p[0]); |
109 | *find_word_end(p[0])=0; |
||
7677 | bpr | 110 | if(strlen(p[0])==2) fprintf(outf,"language=%s\n",p[0]); |
10 | reyssat | 111 | } |
112 | |||
113 | void p_statement(char *p[MAX_PARM]) |
||
114 | { |
||
115 | if(ex_statement<0) return; |
||
116 | if(ex_statement>0 || p==NULL) { |
||
7677 | bpr | 117 | out_exec(vbuf_statement,"question"); |
118 | ex_statement=-1; return; |
||
10 | reyssat | 119 | } |
120 | if(p==NULL) return; |
||
121 | snprintf(vbuf_statement,sizeof(vbuf_statement),"%s",p[0]); |
||
122 | subst(vbuf_statement); |
||
123 | if(strcmp(format,"html")!=0) { |
||
7677 | bpr | 124 | fprintf(outf,"question=!nosubst %s\n",vbuf_statement); |
125 | ex_statement=-1; |
||
10 | reyssat | 126 | } |
127 | else { |
||
7677 | bpr | 128 | fprintf(outf,"question=%s\n",executed_str); |
129 | ex_statement=1; |
||
10 | reyssat | 130 | } |
131 | } |
||
132 | |||
9093 | bpr | 133 | void p_gen(int *ex_gen, char vbuf_gen[], char *name_gen, char *p[MAX_PARM]) |
10 | reyssat | 134 | { |
9093 | bpr | 135 | if(*ex_gen<0) return; |
136 | if(*ex_gen>0 || p==NULL) { |
||
137 | out_exec(vbuf_gen, name_gen); |
||
138 | *ex_gen=-1; return; |
||
10 | reyssat | 139 | } |
9093 | bpr | 140 | snprintf(vbuf_gen,MAX_LINELEN,"%s",p[0]); subst(vbuf_gen); |
141 | if(strchr(vbuf_gen,'\\')!=NULL) { |
||
142 | fprintf(outf,"%s=%s\n", name_gen, executed_str); |
||
143 | *ex_gen=1; |
||
10 | reyssat | 144 | } |
145 | else { |
||
9093 | bpr | 146 | singlespace(vbuf_gen); |
147 | fprintf(outf,"%s=!nosubst %s\n\n", name_gen, vbuf_gen); |
||
10 | reyssat | 148 | } |
149 | } |
||
150 | |||
9093 | bpr | 151 | void p_hint(char *p[MAX_PARM]) {p_gen(&ex_hint, vbuf_hint, "hint", p);} |
152 | void p_help(char *p[MAX_PARM]) {p_gen(&ex_help, vbuf_help, "help", p);} |
||
153 | void p_solution(char *p[MAX_PARM]) {p_gen(&ex_solution, vbuf_solution, "solution", p);} |
||
10 | reyssat | 154 | |
2656 | bpr | 155 | void p_latex(char *p[MAX_PARM]) |
156 | { |
||
157 | if(ex_latex<0) return; |
||
158 | if(ex_latex>0 || p==NULL) { |
||
7677 | bpr | 159 | out_exec(vbuf_latex,"latex"); |
160 | ex_latex=-1; return; |
||
2656 | bpr | 161 | } |
7677 | bpr | 162 | snprintf(vbuf_latex,sizeof(vbuf_latex),"%s",p[0]); |
2656 | bpr | 163 | subst(vbuf_latex); |
7677 | bpr | 164 | singlespace(vbuf_latex); |
165 | fprintf(outf,"latex=!nosubst %s\n\n", vbuf_latex); |
||
2656 | bpr | 166 | } |
167 | |||
10 | reyssat | 168 | enum {typ_default, typ_num, typ_func, typ_units, typ_text, |
169 | typ_formal,typ_matrix,typ_vector,typ_set,typ_equation, |
||
170 | typ_case, typ_nocase, typ_atext, typ_wlist, typ_comp, |
||
171 | typ_algexp, typ_litexp, typ_menu, typ_coord, typ_fill, |
||
172 | typ_raw, typ_symtext, |
||
173 | typ_java, typ_src, typ_chem |
||
174 | }; |
||
175 | |||
176 | struct { |
||
177 | char *name; |
||
178 | int type; |
||
179 | char *def; |
||
180 | } anstype[]={ |
||
7677 | bpr | 181 | {"algexp", typ_algexp, "algexp"}, |
182 | {"aset", typ_set, "aset"}, |
||
183 | {"atext", typ_atext, "atext"}, |
||
184 | {"case", typ_case, "case"}, |
||
185 | {"checkbox", typ_menu, "checkbox"}, |
||
10 | reyssat | 186 | {"chemeq", typ_chem, "chemeq"}, |
7677 | bpr | 187 | {"chset", typ_atext, "chset"}, |
188 | {"click", typ_menu, "click"}, |
||
189 | {"clickfill", typ_fill, "clickfill"}, |
||
190 | {"code", typ_src, "code"}, |
||
191 | {"compose", typ_comp, "compose"}, |
||
192 | {"coord", typ_coord, "coord"}, |
||
193 | {"coordinates", typ_coord, "coord"}, |
||
194 | {"corresp", typ_comp, "correspond"}, |
||
195 | {"correspond", typ_comp, "correspond"}, |
||
196 | {"default", typ_default, "default"}, |
||
197 | {"dragfill", typ_fill, "dragfill"}, |
||
198 | {"equation", typ_equation, "equation"}, |
||
199 | {"expalg", typ_algexp, "algexp"}, |
||
200 | {"formal", typ_formal, "formal"}, |
||
201 | {"fset", typ_set, "fset"}, |
||
202 | {"function", typ_func, "function"}, |
||
203 | {"imgcomp", typ_comp, "imgcomp"}, |
||
204 | {"javacurve", typ_java, "javacurve"}, |
||
205 | {"link", typ_menu, "click"}, |
||
206 | {"litexp", typ_litexp, "litexp"}, |
||
207 | {"mark", typ_menu, "mark"}, |
||
208 | {"matrix", typ_matrix, "matrix"}, |
||
209 | {"menu", typ_menu, "menu"}, |
||
210 | {"nocase", typ_nocase, "nocase"}, |
||
211 | {"number", typ_num, "numeric"}, |
||
212 | {"numeric", typ_num, "numeric"}, |
||
213 | {"numexp", typ_algexp, "numexp"}, |
||
214 | {"radio", typ_menu, "radio"}, |
||
215 | {"range", typ_func, "range"}, |
||
216 | {"ranges", typ_func, "range"}, |
||
217 | {"raw", typ_raw, "raw"}, |
||
218 | {"reorder", typ_comp, "reorder"}, |
||
219 | {"select", typ_menu, "menu"}, |
||
220 | {"set", typ_set, "set"}, |
||
221 | {"sigunits", typ_units, "sigunits"}, |
||
222 | {"symtext", typ_symtext, "symtext"}, |
||
223 | {"text", typ_text, "case"}, |
||
224 | {"textcomp", typ_comp, "textcomp"}, |
||
225 | {"unit", typ_units, "units"}, |
||
226 | {"units", typ_units, "units"}, |
||
227 | {"vector", typ_vector, "vector"}, |
||
228 | {"wlist", typ_wlist, "wlist"}, |
||
229 | {"wordcomp", typ_comp, "textcomp"} |
||
10 | reyssat | 230 | }; |
231 | |||
232 | #define anstype_no (sizeof(anstype)/sizeof(anstype[0])) |
||
233 | |||
234 | void p_answer(char *p[MAX_PARM]) |
||
235 | { |
||
236 | char *pp, vbuf[MAX_LINELEN+1],nbuf[MAX_LINELEN+1]; |
||
237 | int i,j,k,typ; |
||
7677 | bpr | 238 | |
239 | /* look for type definition */ |
||
10 | reyssat | 240 | typ=typ_default; |
241 | for(i=0;i<5;i++) { |
||
7677 | bpr | 242 | if(p[i]==NULL || p[i][0]==0) continue; |
243 | p[i]=find_word_start(p[i]); |
||
244 | if(strncasecmp(p[i],"type",strlen("type"))==0) { |
||
245 | char *tt; |
||
246 | tt=find_word_start(p[i]+strlen("type")); |
||
247 | if(*tt=='=') { |
||
248 | for(j=i;j<6;j++) p[j]=p[j+1]; i--; |
||
249 | tt=find_word_start(tt+1); *find_word_end(tt)=0; |
||
250 | k=search_list(anstype,anstype_no,sizeof(anstype[0]),tt); |
||
251 | /* unknown type is now substituted */ |
||
252 | if(k>=0) { |
||
253 | fprintf(outf,"replytype%d=%s\n", |
||
254 | answercnt,anstype[k].def); |
||
255 | typ=anstype[k].type; |
||
256 | } |
||
257 | else { |
||
258 | snprintf(nbuf,sizeof(nbuf),"%s",tt); subst(nbuf); |
||
259 | fprintf(outf,"replytype%d=%s\n\n",answercnt,nbuf); |
||
260 | } |
||
261 | } |
||
262 | continue; |
||
263 | } |
||
264 | if(strncasecmp(p[i],"option",strlen("option"))==0) { |
||
265 | char *tt, *tv; |
||
266 | tt=p[i]+strlen("option"); |
||
267 | if(*tt=='s' || *tt=='S') tt++; |
||
268 | tt=find_word_start(tt); |
||
269 | if(*tt=='=') { |
||
270 | for(j=i;j<6;j++) p[j]=p[j+1]; i--; |
||
271 | snprintf(nbuf,sizeof(nbuf),"%s",tt+1); subst(nbuf); |
||
272 | for(tv=nbuf; *tv; tv++) if(*tv==',' || *tv==';') *tv=' '; |
||
273 | strip_trailing_spaces(nbuf); |
||
274 | fprintf(outf,"replyoption%d=%s \n",answercnt, |
||
275 | find_word_start(nbuf)); |
||
276 | } |
||
277 | continue; |
||
278 | } |
||
279 | if(strncasecmp(p[i],"weight",strlen("weight"))==0) { |
||
280 | char *tt; |
||
281 | tt=p[i]+strlen("weight"); |
||
282 | tt=find_word_start(tt); |
||
283 | if(*tt=='=') { |
||
284 | for(j=i;j<6;j++) p[j]=p[j+1]; i--; |
||
285 | snprintf(nbuf,sizeof(nbuf),"%s",tt+1); subst(nbuf); |
||
286 | strip_trailing_spaces(nbuf); |
||
287 | fprintf(outf,"replyweight%d=%s \n",answercnt, |
||
288 | find_word_start(nbuf)); |
||
289 | } |
||
290 | continue; |
||
291 | } |
||
10 | reyssat | 292 | } |
293 | p[0]=find_word_start(p[0]); |
||
294 | strncpy(nbuf,p[0],MAX_LINELEN); nbuf[MAX_LINELEN]=0; subst(nbuf); |
||
295 | nbuf[MAX_PROMPTLEN]=0; |
||
296 | strip_trailing_spaces(nbuf); pp=nbuf+strlen(nbuf)-1; |
||
297 | if(*pp=='=') *pp=0; |
||
298 | p[1]=find_word_start(p[1]); |
||
299 | if(*p[1]=='\\' && (isalnum(*(p[1]+1)) || *(p[1]+1)=='_')) { |
||
7677 | bpr | 300 | /* check for analyzed answers */ |
301 | int i,n; char *pt; |
||
302 | strncpy(vbuf,p[1]+1,MAX_LINELEN); vbuf[MAX_LINELEN]=0; |
||
303 | pt=strchr(vbuf,';'); if(pt!=NULL) *pt=0; |
||
304 | strip_trailing_spaces(vbuf); n=strlen(vbuf); |
||
305 | if(n>=MAX_NAMELEN) goto normal; |
||
306 | for(i=0;i<n && (isalnum(vbuf[i]) || vbuf[i]=='_');i++); |
||
307 | if(i<n) goto normal; |
||
308 | for(i=varcnt-1;i>=1 && strcmp(vbuf,param[i].name)!=0;i--); |
||
309 | if(i<1) { /* unused name; the answer should be analyzed */ |
||
310 | char *pm; |
||
311 | pm=xmalloc(MAX_NAMELEN+2); |
||
312 | ovlstrcpy(pm,vbuf); param[varcnt].name=pm; |
||
313 | if(pt) { |
||
314 | *pt=';'; |
||
315 | ovlstrcpy(vbuf,pt); subst(vbuf); pt=vbuf; |
||
316 | } |
||
317 | else pt=""; |
||
318 | param[varcnt].type=pt_real; |
||
319 | param[varcnt].save=1; |
||
320 | fprintf(outf,"replyname%d=%s\nreplygood%d=?analyze %d%s\n", |
||
321 | answercnt,nbuf,answercnt,varcnt,pt); |
||
322 | condans++; answercnt++; varcnt++; return; |
||
323 | } |
||
10 | reyssat | 324 | } |
325 | normal: |
||
326 | strncpy(vbuf,p[1],MAX_LINELEN); vbuf[MAX_LINELEN]=0; |
||
327 | subst(vbuf); |
||
328 | switch(typ) { |
||
7677 | bpr | 329 | default: |
330 | case typ_default: { |
||
331 | fprintf(outf,"replyname%d=%s\nreplygood%d=%s\n", |
||
332 | answercnt,nbuf,answercnt,vbuf); |
||
333 | break; |
||
334 | } |
||
335 | case typ_num: { |
||
336 | fprintf(outf,"replyname%d=%s\nreplygood%d=$[%s]\n", |
||
337 | answercnt,nbuf,answercnt,vbuf); |
||
338 | break; |
||
339 | } |
||
340 | case typ_equation: |
||
341 | case typ_func: { |
||
342 | fprintf(outf,"replyname%d=%s\nreplygood%d=!rawmath %s\n", |
||
343 | answercnt,nbuf,answercnt,vbuf); |
||
344 | break; |
||
345 | } |
||
346 | case typ_units: { |
||
347 | fprintf(outf,"replyname%d=%s\nreplygood%d=%s\n", |
||
348 | answercnt,nbuf,answercnt,vbuf); |
||
349 | break; |
||
350 | } |
||
10 | reyssat | 351 | } |
352 | answercnt++; |
||
353 | } |
||
354 | |||
355 | void p_choice(char *p[MAX_PARM]) |
||
356 | { |
||
357 | int i,j; |
||
358 | char buf1[MAX_LINELEN+1],buf2[MAX_LINELEN+1],nbuf[MAX_LINELEN+1]; |
||
359 | for(i=0;i<5;i++) { |
||
7677 | bpr | 360 | if(p[i]==NULL || p[i][0]==0) continue; |
361 | p[i]=find_word_start(p[i]); |
||
362 | if(strncasecmp(p[i],"option",strlen("option"))==0) { |
||
363 | char *tt, *tv; |
||
364 | tt=p[i]+strlen("option"); |
||
365 | if(*tt=='s' || *tt=='S') tt++; |
||
366 | tt=find_word_start(tt); |
||
367 | if(*tt=='=') { |
||
368 | for(j=i;j<6;j++) p[j]=p[j+1]; i--; |
||
369 | snprintf(nbuf,sizeof(nbuf),"%s",tt+1); subst(nbuf); |
||
370 | for(tv=nbuf; *tv; tv++) if(*tv==',' || *tv==';') *tv=' '; |
||
371 | strip_trailing_spaces(nbuf); |
||
372 | fprintf(outf,"choiceoption%d=%s \n",choicecnt, |
||
373 | find_word_start(nbuf)); |
||
374 | } |
||
375 | continue; |
||
376 | } |
||
377 | if(strncasecmp(p[i],"weight",strlen("weight"))==0) { |
||
378 | char *tt; |
||
379 | tt=p[i]+strlen("weight"); |
||
380 | tt=find_word_start(tt); |
||
381 | if(*tt=='=') { |
||
382 | for(j=i;j<6;j++) p[j]=p[j+1]; i--; |
||
383 | snprintf(nbuf,sizeof(nbuf),"%s",tt+1); subst(nbuf); |
||
384 | strip_trailing_spaces(nbuf); |
||
385 | fprintf(outf,"choiceweight%d=%s \n",choicecnt, |
||
386 | find_word_start(nbuf)); |
||
387 | } |
||
388 | continue; |
||
389 | } |
||
10 | reyssat | 390 | } |
391 | p[0]=find_word_start(p[0]); |
||
392 | snprintf(buf1,sizeof(buf1),"%s",p[1]); subst(buf1); |
||
393 | snprintf(buf2,sizeof(buf2),"%s",p[2]); subst(buf2); |
||
394 | snprintf(nbuf,sizeof(nbuf),"%s",p[0]); subst(nbuf); |
||
395 | nbuf[MAX_PROMPTLEN]=0; |
||
396 | fprintf(outf,"choicename%d=%s\nchoicegood%d=%s\nchoicebad%d=%s\n", |
||
7677 | bpr | 397 | choicecnt,nbuf,choicecnt,buf1,choicecnt,buf2); |
10 | reyssat | 398 | choicecnt++; |
399 | } |
||
400 | |||
401 | void putval(char *p, int n, int ptype) |
||
402 | { |
||
403 | switch(ptype) { |
||
7677 | bpr | 404 | case pt_int: { |
405 | fprintf(outf,"val%d=$[rint(%s)]\n",n,p); |
||
406 | break; |
||
407 | } |
||
408 | case pt_real: { |
||
409 | fprintf(outf,"val%d=$[%s]\n",n,p); |
||
410 | break; |
||
411 | } |
||
412 | case pt_func: { |
||
413 | fprintf(outf,"val%d=!rawmath %s\n",n,p); |
||
414 | break; |
||
415 | } |
||
416 | case pt_complex: { |
||
417 | fprintf(outf,"t_=!rawmath %s\nt_=!exec pari print($t_)\n\ |
||
10 | reyssat | 418 | val%d=!mathsubst I=i in $t_\n",p,n); |
7677 | bpr | 419 | break; |
420 | } |
||
421 | case pt_matrix: { |
||
422 | fprintf(outf,"tmp=!trim %s\n\ |
||
7688 | bpr | 423 | val%d=!translate internal $ \\\n$ to ;; in $tmp\n",p,n); |
7677 | bpr | 424 | break; |
425 | } |
||
426 | case pt_rat: { |
||
427 | fprintf(outf,"t_=!rawmath %s\n\ |
||
10 | reyssat | 428 | val%d=!exec pari print($t_)\n",p,n); |
7677 | bpr | 429 | break; |
430 | } |
||
431 | default: { |
||
432 | fprintf(outf,"val%d=%s\n",n,p); |
||
433 | break; |
||
434 | } |
||
10 | reyssat | 435 | } |
436 | } |
||
437 | |||
438 | void parm(char *p[MAX_PARM], int ptype) |
||
439 | { |
||
440 | char *pp, *p2; |
||
441 | char vbuf[MAX_LINELEN+1]; |
||
442 | int i; |
||
443 | |||
444 | p[0]=find_word_start(p[0]); |
||
445 | if(*p[0]=='\\') p[0]++; |
||
7677 | bpr | 446 | /* bad name */ |
10 | reyssat | 447 | if(!isalpha(*p[0])) return; |
448 | strip_trailing_spaces(p[0]); |
||
449 | for(pp=p[0];*pp;pp++) if(!isalnum(*pp) && *pp!='_') { |
||
7677 | bpr | 450 | /* bad name and security risk */ |
451 | if(!isspace(*pp)) return; |
||
452 | ovlstrcpy(pp,pp+1); pp--; |
||
10 | reyssat | 453 | } |
454 | for(i=1;i<varcnt && strcmp(p[0],param[i].name)!=0;i++); |
||
455 | p[1]=find_word_start(p[1]); |
||
456 | snprintf(vbuf,sizeof(vbuf),"%s",p[1]); subst(vbuf); |
||
457 | if(deftag) repsubst(vbuf); |
||
458 | if((pp=strparchr(vbuf,'?'))!=NULL && pp[1]!='?') { |
||
7677 | bpr | 459 | char buf[MAX_LINELEN+1]; |
460 | if(check_compare(vbuf)==0) goto noif; |
||
461 | p2=strparchr(pp,':'); *pp++=0; if(p2!=NULL) *p2++=0; |
||
462 | snprintf(buf,sizeof(buf),"%s",vbuf); |
||
463 | prepcnt=0; parmprep(buf,ptype); |
||
464 | fprintf(outf,"\n!ifval %s\n",buf); |
||
465 | snprintf(buf,sizeof(buf),"%s",pp); |
||
466 | parmprep(buf,ptype); putval(buf,i,ptype); |
||
467 | if(p2!=NULL) { |
||
468 | fprintf(outf,"!else\n"); |
||
469 | snprintf(buf,sizeof(buf),"%s",p2); |
||
470 | parmprep(buf,ptype); putval(buf,i,ptype); |
||
471 | } |
||
472 | fprintf(outf,"!endif\n"); |
||
10 | reyssat | 473 | } |
474 | else { |
||
475 | noif: |
||
7677 | bpr | 476 | prepcnt=0; parmprep(vbuf, ptype); |
477 | putval(vbuf,i,ptype); |
||
10 | reyssat | 478 | } |
479 | if(i>=varcnt && i<MAX_PARAM) { |
||
7677 | bpr | 480 | param[varcnt].name=p[0]; |
481 | param[varcnt].type=ptype; |
||
482 | param[varcnt].save=0; |
||
483 | varcnt++; |
||
10 | reyssat | 484 | } |
485 | } |
||
486 | |||
487 | void p_int(char *p[MAX_PARM]) {parm(p,pt_int);} |
||
488 | void p_rational(char *p[MAX_PARM]) {parm(p,pt_rat);} |
||
489 | void p_real(char *p[MAX_PARM]) {parm(p,pt_real);} |
||
490 | void p_complex(char *p[MAX_PARM]) {parm(p,pt_complex);} |
||
491 | void p_func(char *p[MAX_PARM]) {parm(p,pt_func);} |
||
492 | void p_text(char *p[MAX_PARM]) {parm(p,pt_text);} |
||
493 | void p_matrix(char *p[MAX_PARM]) {parm(p,pt_matrix);} |
||
494 | |||
495 | void p_parm(char *p[MAX_PARM]) |
||
496 | { |
||
497 | parm(p,pt_real); |
||
498 | } |
||
499 | |||
8367 | bpr | 500 | void _p_if(char *p[MAX_PARM], int type) |
10 | reyssat | 501 | { |
502 | char vbuf[MAX_LINELEN+1]; |
||
503 | snprintf(vbuf,sizeof(vbuf),"%s",p[0]); subst(vbuf); |
||
504 | if(deftag) repsubst(vbuf); |
||
505 | prepcnt=0; parmprep(vbuf, pt_real); |
||
8367 | bpr | 506 | switch(type) { |
507 | case 0: fprintf(outf,"!if %s \n",vbuf); break; |
||
508 | case 1: fprintf(outf,"!ifval %s \n",vbuf); |
||
509 | } |
||
10 | reyssat | 510 | } |
8367 | bpr | 511 | void p_if(char *p[MAX_PARM]) { return _p_if(p, 0);} |
512 | void p_ifval(char *p[MAX_PARM]) { return _p_if(p, 1);} |
||
10 | reyssat | 513 | |
514 | void p_else(char *p[MAX_PARM]) |
||
515 | { |
||
516 | fprintf(outf,"!else\n"); |
||
517 | } |
||
518 | |||
519 | void p_endif(char *p[MAX_PARM]) |
||
520 | { |
||
521 | fprintf(outf,"!endif\n"); |
||
522 | } |
||
523 | |||
524 | |||
525 | void p_while(char *p[MAX_PARM]) |
||
526 | { |
||
527 | char vbuf[MAX_LINELEN+1]; |
||
528 | snprintf(vbuf,sizeof(vbuf),"%s",p[0]); subst(vbuf); |
||
529 | if(deftag) repsubst(vbuf); |
||
530 | prepcnt=0; parmprep(vbuf, pt_real); |
||
531 | fprintf(outf,"!while %s \n",vbuf); |
||
532 | } |
||
533 | |||
534 | void p_endwhile(char *p[MAX_PARM]) |
||
535 | { |
||
536 | fprintf(outf,"!endwhile\n"); |
||
537 | } |
||
538 | |||
539 | void p_for(char *p[MAX_PARM]) |
||
540 | { |
||
541 | char *p1, *p2, buf[256]; |
||
542 | char vbuf[MAX_LINELEN+1]; |
||
543 | int i; |
||
544 | |||
545 | p1=find_word_start(p[0]); |
||
546 | if(!isalpha(*p1)) return; |
||
547 | for(p2=p1; isalnum(*p2); p2++); |
||
548 | if(p2-p1>64) return; |
||
549 | memmove(buf,p1,p2-p1); buf[p2-p1]=0; |
||
550 | for(i=1;i<varcnt && strcmp(buf,param[i].name)!=0;i++); |
||
551 | if(i>=varcnt && i<MAX_PARAM) { |
||
7677 | bpr | 552 | param[varcnt].name=p1; |
553 | param[varcnt].type=pt_real; |
||
554 | param[varcnt].save=0; |
||
555 | varcnt++; |
||
10 | reyssat | 556 | } |
557 | snprintf(vbuf,sizeof(vbuf),"%s",p2); subst(vbuf); *p2=0; |
||
558 | if(deftag) repsubst(vbuf); |
||
559 | prepcnt=0; parmprep(vbuf, pt_real); |
||
560 | fprintf(outf,"!for val%d %s \n", i, vbuf); |
||
561 | } |
||
562 | |||
563 | void p_next(char *p[MAX_PARM]) |
||
564 | { |
||
565 | fprintf(outf,"!next\n"); |
||
566 | } |
||
567 | |||
568 | void p_plot(char *p[MAX_PARM]) |
||
569 | { |
||
570 | int i, f, xr, yr; |
||
571 | char *pp, *p2; |
||
572 | char buf[MAX_LINELEN+1]; |
||
7677 | bpr | 573 | f=xr=yr=-1; |
10 | reyssat | 574 | for(i=0;i<3;i++) { |
7677 | bpr | 575 | if(*p[i]==0) continue; |
576 | if((pp=strchr(p[i],'='))==NULL) f=i; |
||
577 | else { |
||
578 | *pp=0; pp++; |
||
579 | p2=find_word_start(p[i]); |
||
580 | if(*p2=='x' || *p2=='X') xr=i; |
||
581 | else if (*p2=='y' || *p2=='Y') yr=i; |
||
582 | ovlstrcpy(p[i],pp); |
||
583 | } |
||
10 | reyssat | 584 | } |
585 | /* if(xr>=0 && (pp=strstr(p[xr],".."))!=NULL) { |
||
7677 | bpr | 586 | |
10 | reyssat | 587 | } |
588 | */ if(f<0) return; |
||
3718 | reyssat | 589 | ovlstrcpy(buf, p[f]); |
10 | reyssat | 590 | prepcnt=0; parmprep(buf,pt_func); |
591 | fprintf(outf,"plot_fn=!rawmath %s\n",buf); |
||
7677 | bpr | 592 | |
10 | reyssat | 593 | } |
594 | |||
595 | void p_condition(char *p[MAX_PARM]) |
||
596 | { |
||
597 | int i,j; |
||
598 | char buf1[MAX_LINELEN+1],buf2[MAX_LINELEN+1]; |
||
599 | for(i=0;i<5;i++) { |
||
7677 | bpr | 600 | if(p[i]==NULL || p[i][0]==0) continue; |
601 | p[i]=find_word_start(p[i]); |
||
602 | if(strncasecmp(p[i],"option",strlen("option"))==0) { |
||
603 | char *tt, *tv; |
||
604 | tt=p[i]+strlen("option"); |
||
605 | if(*tt=='s' || *tt=='S') tt++; |
||
606 | tt=find_word_start(tt); |
||
607 | if(*tt=='=') { |
||
608 | for(j=i;j<6;j++) p[j]=p[j+1]; i--; |
||
609 | snprintf(buf1,sizeof(buf1),"%s",tt+1); subst(buf1); |
||
610 | for(tv=buf1; *tv; tv++) if(*tv==',' || *tv==';') *tv=' '; |
||
611 | strip_trailing_spaces(buf1); |
||
612 | fprintf(outf,"condoption%d=%s \n",conditioncnt, |
||
613 | find_word_start(buf1)); |
||
614 | } |
||
615 | continue; |
||
616 | } |
||
617 | if(strncasecmp(p[i],"weight",strlen("weight"))==0) { |
||
618 | char *tt; |
||
619 | tt=p[i]+strlen("weight"); |
||
620 | tt=find_word_start(tt); |
||
621 | if(*tt=='=') { |
||
622 | for(j=i;j<6;j++) p[j]=p[j+1]; i--; |
||
623 | snprintf(buf1,sizeof(buf1),"%s",tt+1); subst(buf1); |
||
624 | strip_trailing_spaces(buf1); |
||
625 | fprintf(outf,"condweight%d=%s \n",conditioncnt, |
||
626 | find_word_start(buf1)); |
||
627 | } |
||
628 | continue; |
||
629 | } |
||
10 | reyssat | 630 | } |
631 | if(p[1][0]==0) {p[1]=p[0]; p[0]="";} |
||
632 | snprintf(buf1,sizeof(buf1),"%s",p[0]); subst(buf1); |
||
633 | snprintf(buf2,sizeof(buf2),"%s",p[1]); subst(buf2); |
||
634 | prepcnt=0; parmprep(buf2, pt_real); |
||
635 | repsubst(buf2); |
||
636 | fprintf(outf,"\n!ifval %s\n condtest%d=1\n!else\n condtest%d=0\n!endif\n\ |
||
637 | condname%d=%s\n", buf2,conditioncnt,conditioncnt,conditioncnt,buf1); |
||
638 | conditioncnt++; |
||
639 | } |
||
640 | |||
641 | void p_conditions(char *p[MAX_PARM]) |
||
642 | { |
||
643 | char buf[MAX_LINELEN+1]; |
||
644 | snprintf(buf,sizeof(buf),"%s",p[0]); subst(buf); |
||
645 | prepcnt=0; parmprep(buf, pt_real); |
||
646 | repsubst(buf); |
||
647 | fprintf(outf,"\ncondlist=%s\n",buf); |
||
648 | } |
||
649 | |||
650 | void p_feedback(char *p[MAX_PARM]) |
||
651 | { |
||
652 | char buf1[MAX_LINELEN+1],buf2[MAX_LINELEN+1]; |
||
653 | char *cmpstr="ifval"; |
||
7677 | bpr | 654 | |
10 | reyssat | 655 | snprintf(buf1,sizeof(buf1),"%s",p[0]); subst(buf1); |
656 | snprintf(buf2,sizeof(buf2),"%s",p[1]); subst(buf2); |
||
657 | repsubst(buf1); repsubst(buf2); |
||
658 | if(strstr(buf1,"$m_choice")!=NULL) cmpstr="if"; |
||
659 | prepcnt=0; setpre="!set "; parmprep(buf1, pt_real); setpre=""; |
||
6450 | obado | 660 | fprintf(outf,"!%s %s\n <div class='oef_feedbacks'>",cmpstr, buf1); |
10 | reyssat | 661 | out_exec(buf2,NULL); |
6450 | obado | 662 | fprintf(outf,"</div>\n!endif\n"); |
10 | reyssat | 663 | } |
664 | |||
7677 | bpr | 665 | /* definition of steps */ |
10 | reyssat | 666 | void p_steps(char *p[MAX_PARM]) |
667 | { |
||
668 | char vbuf[MAX_LINELEN+1]; |
||
669 | char *pp, *p2; |
||
7677 | bpr | 670 | |
10 | reyssat | 671 | snprintf(vbuf,sizeof(vbuf),"%s",find_word_start(p[0])); subst(vbuf); |
672 | strip_trailing_spaces(vbuf); |
||
673 | if(vbuf[0]==0) return; |
||
674 | if((pp=strparchr(vbuf,'?'))!=NULL && pp[1]!='?') { |
||
7677 | bpr | 675 | char buf[MAX_LINELEN+1]; |
676 | if(check_compare(vbuf)==0) goto noif; |
||
677 | p2=strparchr(pp,':'); *pp++=0; if(p2!=NULL) *p2++=0; |
||
678 | snprintf(buf,sizeof(buf),"%s",vbuf); |
||
679 | prepcnt=0; parmprep(buf,pt_text); |
||
680 | fprintf(outf,"\n!ifval %s \n",buf); |
||
681 | snprintf(buf,sizeof(buf),"%s",pp); |
||
682 | parmprep(buf,pt_text); |
||
683 | fprintf(outf,"oefsteps=%s \n",buf); |
||
684 | if(p2!=NULL) { |
||
685 | fprintf(outf,"!else\n"); |
||
686 | snprintf(buf,sizeof(buf),"%s",p2); |
||
687 | parmprep(buf,pt_text); |
||
688 | fprintf(outf,"oefsteps=%s \n",buf); |
||
689 | } |
||
690 | fprintf(outf,"!endif\n"); |
||
10 | reyssat | 691 | } |
692 | else { |
||
693 | noif: |
||
7677 | bpr | 694 | prepcnt=0; parmprep(vbuf, pt_text); |
695 | fprintf(outf,"oefsteps=%s \nnextstep=!nosubst %s \n",vbuf,vbuf); |
||
10 | reyssat | 696 | } |
697 | fprintf(outf,"!readproc oef/steps.proc\n"); |
||
698 | } |
||
699 | |||
7677 | bpr | 700 | /* dynamic steps */ |
10 | reyssat | 701 | void p_nextstep(char *p[MAX_PARM]) |
702 | { |
||
703 | fprintf(outf,"dynsteps=yes\n"); |
||
704 | p_steps(p); |
||
705 | } |
||
706 |