![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to x.y CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / pico|
Return to x.y CVS log | Up to [Research Unix] / researchv10no / cmd / pico |
1.1 root 1: %{
2: #include <stdio.h>
3: #include "pico.h"
4: #include "pico2.h"
5:
6: #define usedboth usedold=usednew=1
7:
8: #define YYDEBUG 1
9:
10: extern short CURSCRATCH, CUROLD;
11: extern char *progr;
12: extern struct SRC src[MANY];
13: extern int nsrc, nrparams, LO, linenumber, whichdevice;
14: extern char usednew, usedold, faster, frameb, metheus;
15: extern char isglobal, seetree, optim, touchedcmap;
16: extern FILE *INPUT;
17: %}
18:
19: %union{
20: Node *node;
21: Symbol *sym;
22: int resu;
23: struct SNode *snode;
24: }
25:
26: %type <node> stmnt sstmnt pprog pbody rval assign ifpre whpre
27: %type <node> aparams fcall elist expr chann
28: %type <snode> iarray lval
29: %type <resu> array SPEC eval vval arname
30: %type <sym> ANAME XYI pathn defpr
31: %token <sym> VARIABLE AUTO ARRAY FCT BLTN NAME
32: %token <resu> VAL STRING
33:
34: %start comm
35: %token A WINDOW C DEF DEL SCOM ECOM
36: %token UP DOWN RUN F H Q R SET SETF
37: %token GET W PCONST RETURN
38: %token OPEN CLOSE DECL INT GLOBAL
39: %token X Y I OLD TMP CMAP
40: %token FOR DO WHILE JUMP IF ELSE
41: %token COLOR NOCOLOR ZAP FASTER SLOWER HELP
42: %token FRAMEBUFFER METHEUS BLIND SEETREE OPTIM
43: %right ','
44: %right ASSIGN
45: %right '?' ':' ';'
46: %right OPER
47: %left OROR
48: %left ANDAND
49: %left OR
50: %left '^'
51: %left AND
52: %left EQ NE
53: %left GT GE LT LE
54: %left LSH RSH
55: %left '+' '-'
56: %left '*' '/' '%'
57: %right POST
58: %right UNARYMINUS NOT '$' '~'
59: %right RCHAN GCHAN BCHAN BW RGB
60: %right POW
61: %right '.'
62:
63: %%
64: comm: pcom ';' { return 1; }
65: | RUN SPEC { munge($2); return 1; }
66: | defpr YoN SPEC { postfunct($1); return 1; }
67: | R pathn ';' { redirect($2->name);
68: checkit();
69: return 1;
70: }
71: | Q ';' { return 0; }
72:
73: defpr: DEF NAME '(' rglst ')' { prefunct($2, nrparams); $$ = $2; }
74: | DEF FCT '(' rglst ')' { prefunct($2, nrparams); $$ = $2; }
75:
76: pcom: /* empty */ { /* if (INPUT == stdin) linenumber--; */ }
77: | A pathn { append( 0, 0, 0, 0, $2->name); }
78: | A vval vval vval vval pathn { append($2, $3, $4, $5, $6->name); }
79: | DEL pathn { discard($2->name); }
80: | DEL array { if ($2 > 1 && $2 <= nsrc-1)
81: discard(src[$2].fname);
82: else
83: yyerror("unknown file number %d", $2);
84: }
85: | DEL VAL { if ($2 > 1 && $2 <= nsrc-1)
86: discard(src[$2].fname);
87: else
88: yyerror("unknown file number %d", $2);
89: }
90: | F { files(); }
91: | GET { getscreen(Old); }
92: | GET arname { getter($2); }
93: | GET pathn { getter(append( 0, 0, 0, 0, $2->name)); }
94: | GET vval vval vval vval pathn { getter(append($2, $3, $4, $5, $6->name)); }
95: | H hnmlst
96: | FASTER { faster = 1; }
97: | SLOWER { faster = 0; }
98: | SEETREE { seetree = 1 - seetree; }
99: | OPTIM { optim = 1 - optim; }
100: | NOCOLOR { Old->nchan = Scratch->nchan = 1; }
101: | COLOR { Old->nchan = Scratch->nchan = 3;
102: checkpix(Old); checkpix(Scratch);
103: }
104: | HELP { dohelp(); }
105: | SET { showvars(); }
106: | SET ANAME { showsym($2); }
107: | SETF { showfcts(); }
108: | WINDOW vval vval vval vval { setwindow($2, $3, $4, $5); }
109: | W pathn { putdpix($2->name, PICO); }
110: | W '-' pathn { putdpix($3->name, 0); }
111:
112: arname: array { $$ = $1; }
113: | vval vval array { $$ = append($1, $2, 0, 0, src[$3].fname); }
114: | vval vval vval vval array { $$ = append($1, $2, $3, $4, src[$5].fname); }
115:
116: hnmlst: pathn { interpret($1->name); }
117: | hnmlst pathn { interpret($2->name); }
118:
119: rglst: /* empty */
120: | arglst
121:
122: arglst: NAME { automa($1, nrparams++); }
123: | arglst ',' NAME { automa($3, nrparams++); }
124:
125: SPEC: sstmnt { compile($1, progr); $$ = BLOOP; }
126: | chann ';' { compile($1, progr); $$ = SLOOP; }
127: | pprog ';' { compile($1, progr); $$ = NLOOP; }
128:
129: chann: CMAP ASSIGN expr { $$ = mapall(cast($3)); }
130: | CMAP '.' RGB ASSIGN expr { $$ = mapall($5); }
131: | CMAP '.' RCHAN ASSIGN expr { $$ = mapred(cast($5)); }
132: | CMAP '.' GCHAN ASSIGN expr { $$ = mapgrn(cast($5)); }
133: | CMAP '.' BCHAN ASSIGN expr { $$ = mapblu(cast($5)); }
134:
135: YoN: /* empty */
136: | ';'
137:
138: decls: glob INT declst ';'
139: | glob DECL decars ';'
140:
141: glob: GLOBAL { isglobal = 1; }
142: | /* none */ { isglobal = 0; }
143:
144: declst: declo
145: | declst ',' declo
146:
147: decars: decar
148: | decars ',' decar
149:
150: declo: XYI
151: | NAME { decvar($1, 0); }
152: | VARIABLE { decvar($1, 0); }
153: | NAME ASSIGN eval { decvar($1, $3); }
154: | VARIABLE ASSIGN eval { decvar($1, $3); }
155:
156: decar: NAME '[' eval ']' { decarray($1, $3); }
157: | ARRAY '[' eval ']' { decarray($1, $3); }
158:
159: XYI: X { $$ = newsym("x"); }
160: | Y { $$ = newsym("y"); }
161: | I { $$ = newsym("i"); }
162:
163: pprog: OPEN pbody YoN CLOSE { $$ = $2; }
164:
165: pbody: stmnt { $$ = $1; }
166: | pbody stmnt { $$ = new(OCOMMA, $1, $2, Z); }
167:
168: aparams: '(' ')' { $$ = Z; }
169: | '(' elist ')' { $$ = $2; }
170:
171: elist: expr { $$ = cast($1); }
172: | expr ',' elist { $$ = new(ACOMMA, cast($1), $3, Z); }
173:
174: ifpre: IF '(' expr ')' YoN { $$ = $3; }
175: whpre: WHILE '(' expr ')' YoN { $$ = $3; }
176:
177: ANAME: NAME { $$ = $1; }
178: | VARIABLE { $$ = $1; }
179: | FCT { $$ = $1; }
180: | BLTN { $$ = $1; }
181: | AUTO { $$ = $1; }
182: | ARRAY { $$ = $1; }
183: | XYI { $$ = $1; }
184: | STRING { $$ = lookup($1); }
185:
186: pathn: ANAME { $$ = $1; }
187:
188: stmnt: pprog ';' { $$ = $1; }
189: | ANAME ':' stmnt { $$ = new(LABL,$3, Z, $1); }
190: | JUMP ANAME ';' { $$ = new(GOTO, Z, Z, $2); }
191: | sstmnt { $$ = $1; }
192: | chann ';' { $$ = $1; }
193:
194: sstmnt: assign ';' { $$ = $1; }
195: | decls { $$ = Z; }
196: | fcall ';' { $$ = $1; }
197: | ifpre stmnt { $$ = new(CONDI, $2, Z, $1); }
198: | ifpre stmnt ELSE YoN stmnt { $$ = new(CONDI, $2, $5, $1); }
199: | FOR '(' expr ';' expr ';' expr ')' YoN stmnt {
200: $$ = newloop($3, $5, $7, $10); }
201: | whpre stmnt { $$ = newhile($1, $2); }
202: | DO YoN stmnt WHILE '(' expr ')' ';' { $$ = newuntil($3, $6); }
203: | RETURN expr ';' { $$ = new(ORETURN, $2, Z, Z); }
204:
205: iarray: BW { usedboth; $$ = super(CURSCRATCH, Z, BW); }
206: | RGB { usedboth; $$ = super(CURSCRATCH, Z, RGB); }
207: | RCHAN { usedboth; $$ = super(CURSCRATCH, Z, RCHAN); }
208: | GCHAN { usedboth; $$ = super(CURSCRATCH, Z, GCHAN); }
209: | BCHAN { usedboth; $$ = super(CURSCRATCH, Z, BCHAN); }
210: | array { $$ = super($1, Z, (src[$1].nchan == 1)?BW:RGB); }
211: | array '.' RGB { $$ = super($1, Z, RGB); }
212: | array '.' BW { $$ = super($1, Z, BW); }
213: | array '.' RCHAN { $$ = super($1, Z, RCHAN); }
214: | array '.' GCHAN { $$ = super($1, Z, GCHAN); }
215: | array '.' BCHAN { $$ = super($1, Z, BCHAN); }
216: | array '[' elist ']' { $$ = super($1, $3,(src[$1].nchan == 1)?BW:RGB); }
217: | array '[' elist ']' '.' RGB { $$ = super($1, $3, RGB); }
218: | array '[' elist ']' '.' BW { $$ = super($1, $3, BW); }
219: | array '[' elist ']' '.' RCHAN { $$ = super($1, $3, RCHAN); }
220: | array '[' elist ']' '.' GCHAN { $$ = super($1, $3, GCHAN); }
221: | array '[' elist ']' '.' BCHAN { $$ = super($1, $3, BCHAN); }
222: | array '.' RGB '[' elist ']' { $$ = super($1, $5, RGB); }
223: | array '.' BW '[' elist ']' { $$ = super($1, $5, BW); }
224: | array '.' RCHAN '[' elist ']' { $$ = super($1, $5, RCHAN); }
225: | array '.' GCHAN '[' elist ']' { $$ = super($1, $5, GCHAN); }
226: | array '.' BCHAN '[' elist ']' { $$ = super($1, $5, BCHAN); }
227: | ARRAY '[' elist ']' { $$=nsup(RL(($1->u.ar->base),Index($3)),0,0,128);}
228: | ARRAY { $$=nsup(RL(($1->u.ar->base),DII), 0,0,128); }
229:
230: assign: lval POST { $$ = weird($1, notnew(LO, $1->n, NR(1))); }
231: | lval OPER expr { $$ = weird($1, notnew(LO, $1->n, $3)); }
232: | lval ASSIGN expr { $$ = weird($1, $3); }
233:
234: rval: lval { $$ = $1->n; }
235: | fcall { $$ = $1; }
236:
237: lval: X { $$ = nsup(new(REG, Z, Z, XREG), 0, 0, 128); }
238: | Y { $$ = nsup(new(REG, Z, Z, YREG), 0, 0, 128); }
239: | I { $$ = nsup(new(REG, Z, Z, IREG), 0, 0, 128); }
240: | iarray { $$ = $1; }
241: | NAME { yyerror("undeclared variable %s", $1->name); }
242: | VARIABLE { $$ = nsup(new(VAR, Z, Z, &$1->u.val), 0,0,128);}
243: | AUTO { $$ = nsup(new(OARG, Z, Z, $1->u.val), 0,0,128);}
244:
245: fcall: FCT aparams { if ($1->u.fu->usednew == -1 && notrecurcall($1))
246: yyerror("undefined function %s", $1->name);
247: argcount($1->u.fu->nrparams, $2, $1->name);
248: usednew += $1->u.fu->usednew;
249: usedold += $1->u.fu->usedold;
250: $$ = new(OCALL, $2, Z, $1->u.fu->fct);
251: }
252: | BLTN aparams { argcount($1->u.bl->nrparams, $2, $1->name);
253: usednew += $1->u.bl->usednew;
254: $$ = new(CCALL, $2, Z, $1->u.bl->faddr);
255: }
256:
257: vval: VAL { $$ = $1; }
258: | '-' VAL { $$ = -$2; }
259:
260: eval: VAL { $$ = $1; }
261: | VARIABLE { $$ = $1->u.val; }
262: | fcall { compile($1, progr); $$ = callit(); }
263:
264: expr: rval { $$ = $1; }
265: | assign { $$ = $1; }
266: | '(' expr ')' { $$ = $2; }
267: | '[' elist ']' { $$ = new(COMP, $2, Z, Z); }
268: | VAL { $$ = NR($1); }
269: | STRING { $$ = NR($1); }
270: | expr '?' expr ':' expr { $$ = new(CONDI, $3, $5, $1); }
271: | '-' expr %prec UNARYMINUS { $$ = new(OMINUS, $2, Z, Z); }
272: | '~' expr { $$ = new(ONEG, $2, Z, Z); }
273: | NOT expr { $$ = new(ONOT, $2, Z, Z); }
274: | expr '+' expr { $$ = notnew(OADD, $1, $3); }
275: | expr '-' expr { $$ = notnew(OSUB, $1, $3); }
276: | expr '*' expr { $$ = notnew(OMUL, $1, $3); }
277: | expr '/' expr { $$ = notnew(DIVV, $1, $3); }
278: | expr '%' expr { $$ = notnew(MODU, $1, $3); }
279: | expr '^' expr { $$ = notnew(OXOR, $1, $3); }
280: | expr POW expr { $$ = notnew(OPOW, $1, $3); }
281: | expr GT expr { $$ = notnew(OGT, $1, $3); }
282: | expr GE expr { $$ = notnew(OGE, $1, $3); }
283: | expr LT expr { $$ = notnew(OLT, $1, $3); }
284: | expr LE expr { $$ = notnew(OLE, $1, $3); }
285: | expr EQ expr { $$ = notnew(OEQ, $1, $3); }
286: | expr NE expr { $$ = notnew(ONE, $1, $3); }
287: | expr ANDAND expr { $$ = notnew(OANDAND, $1, $3); }
288: | expr OROR expr { $$ = notnew(OOROR, $1, $3); }
289: | expr OR expr { $$ = notnew(OOR, $1, $3); }
290: | expr AND expr { $$ = notnew(OAND, $1, $3); }
291: | expr LSH expr { $$ = notnew(OLSH, $1, $3); }
292: | expr RSH expr { $$ = notnew(OLSH, $1, notnew(OMINUS, $3, Z)); }
293:
294: array: TMP { usednew=usedold=1; $$ = CURSCRATCH; }
295: | OLD { usedold=1; $$ = CUROLD; }
296: | '$' TMP { usednew=usedold=1; $$ = CURSCRATCH; }
297: | '$' OLD { usedold=1; $$ = CUROLD; }
298: | '$' VAL { int x = $2;
299: if (x < 0 || x > nsrc-2)
300: yyerror("unknown file number %d", x);
301: x = (x == 0) ? CUROLD : x+1;
302: if (x == CUROLD)
303: usedold=1;
304: else
305: src[x].used = 1;
306: $$ = x;
307: }
308: | '$' ANAME { int x = whatarray($2->name);
309: if (x <= 0)
310: x = prepare($2->name);
311: if (x <= 0)
312: yyerror("unknown file %s", $2->name);
313: src[x].used = 1;
314: $$ = x;
315: }
316: %%
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.