|
99
|
1
|
|
|
2 #define DEBUG error(-1)
|
|
|
3
|
|
|
4 /*#include "CCLIB.TXT"
|
|
|
5 */
|
|
|
6 #include <stdio.h>
|
|
|
7
|
|
100
|
8 /* to avoid conflict with stdio.h */
|
|
|
9 #define getline getline1
|
|
|
10 #define index index1
|
|
|
11
|
|
99
|
12 #define INT (-1)
|
|
|
13 #define CHAR (-2)
|
|
|
14 #define UNSIGNED (-3)
|
|
|
15 #define POINTER (-4)
|
|
|
16 #define ARRAY (-5)
|
|
|
17 #define STRUCT (-6)
|
|
|
18 #define UNION (-7)
|
|
|
19 #define FUNCTION (-8)
|
|
|
20 #define EMPTY (-9)
|
|
|
21
|
|
|
22 #define STATIC (-10)
|
|
|
23 #define GOTO (-11)
|
|
|
24 #define RETURN (-12)
|
|
|
25 #define BREAK (-13)
|
|
|
26 #define CONTINUE (-14)
|
|
|
27 #define IF (-15)
|
|
|
28 #define ELSE (-16)
|
|
|
29 #define FOR (-17)
|
|
|
30 #define DO (-18)
|
|
|
31 #define WHILE (-19)
|
|
|
32 #define SWITCH (-20)
|
|
|
33 #define CASE (-21)
|
|
|
34 #define DEFAULT (-22)
|
|
|
35 #define RESERVE (-23)
|
|
|
36 #define TAG (-24)
|
|
|
37 #define FIELD (-25)
|
|
|
38 #define IDENT (-26)
|
|
|
39 #define STRING (-27)
|
|
|
40 #define MACRO (-28)
|
|
|
41 #define BLABEL (-29)
|
|
|
42 #define FLABEL (-30)
|
|
|
43 #define TYPEDEF (-31)
|
|
|
44 #define SIZEOF (-32)
|
|
|
45 #define TYPE (-33)
|
|
|
46 #define LONG (-34)
|
|
|
47 #define SHORT (-35)
|
|
|
48
|
|
|
49 #define TOP 0
|
|
|
50 #define GDECL 1
|
|
|
51 #define GSDECL 2
|
|
|
52 #define GUDECL 3
|
|
|
53 #define ADECL 4
|
|
|
54 #define LDECL 5
|
|
|
55 #define LSDECL 6
|
|
|
56 #define LUDECL 7
|
|
|
57 #define STADECL 8
|
|
|
58 #define STAT 9
|
|
|
59 #define GTDECL 10
|
|
|
60 #define LTDECL 11
|
|
|
61
|
|
|
62 #define GVAR 1
|
|
|
63 #define RGVAR 2
|
|
|
64 #define CRGVAR 3
|
|
|
65 #define LVAR 4
|
|
|
66 #define RLVAR 5
|
|
|
67 #define CRLVAR 6
|
|
|
68 #define CONST 7
|
|
|
69 #define FNAME 8
|
|
|
70 #define INDIRECT 9
|
|
|
71 #define RINDIRECT 10
|
|
|
72 #define CRINDIRECT 11
|
|
|
73 #define ADDRESS 12
|
|
|
74 #define MINUS 13
|
|
|
75 #define LNOT 14
|
|
|
76 #define BNOT 15
|
|
|
77 #define INC 16
|
|
|
78 #define POSTINC 17
|
|
|
79 #define PREINC 18
|
|
|
80 #define CPOSTINC 19
|
|
|
81 #define CPREINC 20
|
|
|
82 #define DEC 21
|
|
|
83 #define CPOSTDEC 22
|
|
|
84 #define CPREDEC 23
|
|
|
85 #define MUL 24
|
|
|
86 #define UMUL 25
|
|
|
87 #define DIV 26
|
|
|
88 #define UDIV 27
|
|
|
89 #define MOD 28
|
|
|
90 #define UMOD 29
|
|
|
91 #define ADD 30
|
|
|
92 #define SUB 31
|
|
|
93 #define RSHIFT 32
|
|
|
94 #define URSHIFT 33
|
|
|
95 #define LSHIFT 34
|
|
|
96 #define ULSHIFT 35
|
|
|
97 #define GT 36
|
|
|
98 #define UGT 37
|
|
|
99 #define GE 38
|
|
|
100 #define UGE 39
|
|
|
101 #define LT 40
|
|
|
102 #define ULT 41
|
|
|
103 #define LE 42
|
|
|
104 #define ULE 43
|
|
|
105 #define EQ 44
|
|
|
106 #define NEQ 45
|
|
|
107 #define BAND 46
|
|
|
108 #define EOR 47
|
|
|
109 #define BOR 48
|
|
|
110 #define LAND 49
|
|
|
111 #define LOR 50
|
|
|
112 #define COND 51
|
|
|
113 #define ASS 52
|
|
|
114 #define CASS 53
|
|
|
115 #define ASSOP 54
|
|
|
116 #define CASSOP 55
|
|
|
117 #define COMMA 56
|
|
|
118 #define LPAR 57
|
|
|
119 #define RPAR 58
|
|
|
120 #define LBRA 59
|
|
|
121 #define RBRA 60
|
|
|
122 #define LC 61
|
|
|
123 #define RC 62
|
|
|
124 #define COLON 63
|
|
|
125 #define SM 64
|
|
|
126 #define PERIOD 65
|
|
|
127 #define ARROW 66
|
|
|
128
|
|
|
129 #define US 1
|
|
|
130 #define AS 100
|
|
|
131
|
|
|
132 #define FILERR 1
|
|
|
133 #define DCERR 2
|
|
|
134 #define STERR 3
|
|
|
135 #define EXERR 4
|
|
|
136 #define CNERR 5
|
|
|
137 #define CHERR 6
|
|
|
138 #define GSERR 7
|
|
|
139 #define LSERR 8
|
|
|
140 #define STRERR 9
|
|
|
141 #define LNERR 10
|
|
|
142 #define EOFERR 11
|
|
|
143 #define MCERR 12
|
|
|
144 #define INCERR 13
|
|
|
145 #define HPERR 14
|
|
|
146 #define TYERR 15
|
|
|
147 #define LVERR 16
|
|
|
148 #define UDERR 17
|
|
|
149 #define OPTION 18
|
|
|
150
|
|
|
151 #define GSYMS 450
|
|
|
152 #define LSYMS 50
|
|
|
153
|
|
|
154 #define HEAPSIZE 1000
|
|
|
155 #define CHEAPSIZE 3000
|
|
|
156 #define LBUFSIZE 256
|
|
|
157
|
|
|
158 #define FILES 3
|
|
|
159
|
|
|
160 int sym,ch,chsave,type,mode,gfree,lfree,mflag,lineno,glineno;
|
|
|
161 int labelno,gpc,lvar,disp;
|
|
|
162 int symval,args,heap[HEAPSIZE];
|
|
|
163 int blabel,clabel,dlabel,cslabel,ilabel,control,ac,ac2,lsrc,chk,asmf;
|
|
|
164
|
|
|
165 unsigned hash;
|
|
|
166
|
|
|
167 char linebuf[LBUFSIZE],cheap[CHEAPSIZE],*chptr,*chptrsave;
|
|
|
168 char name[9],*cheapp,**av,/*obuf[320],*/*sptr,escape();
|
|
|
169
|
|
|
170 FILE *obuf;
|
|
|
171
|
|
|
172 typedef struct nametable {
|
|
|
173 char nm[9];
|
|
|
174 int sc,ty,dsp; } NMTBL;
|
|
|
175
|
|
|
176 NMTBL ntable[GSYMS+LSYMS],*nptr,*gnptr,*decl0(),*decl1(),*lsearch(),*gsearch();
|
|
|
177
|
|
|
178 struct {int fd,ln;/*char fcb[320]*/FILE *fcb;} *filep,filestack[FILES];
|
|
|
179
|
|
|
180 main(argc,argv)
|
|
|
181 int argc;
|
|
|
182 char **argv;
|
|
|
183 {NMTBL *nptr;
|
|
|
184 int i;
|
|
|
185 char *ccout;
|
|
104
|
186 char *modname;
|
|
99
|
187 if(argc==1) exit(1);
|
|
|
188 lsrc = chk = asmf = 0;
|
|
|
189 ccout = "c.out";
|
|
104
|
190 modname = "aout";
|
|
99
|
191 ac=argc;
|
|
|
192 av=argv;
|
|
|
193 for (ac2=1; (ac2 < ac) && (*av[ac2] == '-'); ++ac2)
|
|
|
194 switch (*(av[ac2]+1))
|
|
|
195 {case 'S': case 's':
|
|
|
196 lsrc = 1;
|
|
|
197 break;
|
|
|
198 case 'O': case 'o':
|
|
|
199 ccout = av[ac2]+2;
|
|
|
200 break;
|
|
101
|
201 case 'M': case 'm':
|
|
|
202 modname = av[ac2]+2;
|
|
|
203 break;
|
|
99
|
204 case 'C': case 'c':
|
|
|
205 chk = 1;
|
|
|
206 break;
|
|
|
207 default:
|
|
|
208 error(OPTION);
|
|
|
209 exit(1);
|
|
|
210 }
|
|
|
211 fclose(stdout);
|
|
101
|
212 if (!chk) {
|
|
99
|
213 if ( (obuf = fopen(ccout,"w")) == NULL ) error(FILERR);
|
|
101
|
214 else {
|
|
105
|
215 /* we'l resize data area later */
|
|
|
216 printf("\tmod _eom,_name,_tylg,_atrv,_start,16384\n"); /* os9 module header */
|
|
104
|
217 printf("_name fcs /%s/\n\tfcb 0\n",modname);
|
|
101
|
218 }
|
|
|
219 }
|
|
99
|
220 init();
|
|
|
221 while(1)
|
|
|
222 { for (nptr = &ntable[GSYMS],i=LSYMS; i--;)
|
|
|
223 (nptr++)->sc = EMPTY;
|
|
|
224 mode=TOP;
|
|
|
225 while(getsym()==SM);
|
|
|
226 mode=GDECL;
|
|
|
227 args=0;
|
|
|
228 decl();
|
|
|
229 }
|
|
|
230 }
|
|
|
231 error(n)
|
|
|
232 int n;
|
|
|
233 { if(n == EOFERR)
|
|
|
234 if(filep!=filestack)
|
|
|
235 { lineno=filep->ln;
|
|
|
236 fclose(filep->fcb);
|
|
|
237 fprintf(stderr,"End of inclusion.\n");
|
|
|
238 --filep;
|
|
|
239 return;
|
|
|
240 }
|
|
|
241 else if(ac2!=ac)
|
|
|
242 { fclose(filep->fcb);
|
|
|
243 newfile();
|
|
|
244 return;
|
|
|
245 }
|
|
|
246 else if(mode == TOP)
|
|
|
247 { fprintf(stderr,"\nCompiled %u lines.\n",glineno-1);
|
|
|
248 if (!chk) fprintf(stderr,
|
|
|
249 "Total internal labels : %u.\n",labelno-1);
|
|
|
250 fprintf(stderr,
|
|
|
251 "Total global variables : %u bytes.\n\n",gpc);
|
|
|
252 printf("_%d\tRTS\n_INITIALIZE\tEQU\t_1\n",ilabel);
|
|
100
|
253 printf("_GLOBALS\tEQU\t%u\n",gpc);
|
|
99
|
254 exit(0);
|
|
|
255 }
|
|
|
256 fprintf(stderr,"%5d:%s.\n",lineno,
|
|
|
257 (n==FILERR) ? "Can't open specified file" :
|
|
|
258 (n==DCERR) ? "Declaration syntax" :
|
|
|
259 (n==STERR) ? "Statement syntax" :
|
|
|
260 (n==EXERR) ? "Expression syntax" :
|
|
|
261 (n==CNERR) ? "Constant required" :
|
|
|
262 (n==CHERR) ? "Illegal character" :
|
|
|
263 (n==GSERR) ? "Too many global symbols" :
|
|
|
264 (n==LSERR) ? "Too many local symbols" :
|
|
|
265 (n==STRERR) ? "Too many strings or macros" :
|
|
|
266 (n==LNERR) ? "Line too long" :
|
|
|
267 (n==EOFERR) ? "Unexpected end of file" :
|
|
|
268 (n==MCERR) ? "Macro syntax" :
|
|
|
269 (n==INCERR) ? "Include syntax" :
|
|
|
270 (n==HPERR) ? "Too long expression" :
|
|
|
271 (n==TYERR) ? "Type mismatch" :
|
|
|
272 (n==LVERR) ? "Lvalue required" :
|
|
|
273 (n==UDERR) ? "Undeclared identifier" :
|
|
|
274 (n==OPTION) ? "Illegal option" :
|
|
|
275 "Bug of compiler");
|
|
|
276 errmsg();
|
|
|
277 exit(1);
|
|
|
278 }
|
|
|
279 errmsg()
|
|
|
280 {char *p,*lim;
|
|
|
281 if(lineno==0) return;
|
|
|
282 fprintf(stderr,"%s",linebuf);
|
|
|
283 lim=(mflag?chptrsave:chptr);
|
|
|
284 for (p=linebuf; p < lim;)
|
|
|
285 fprintf(stderr,(*p++ == '\t') ? "\t" : " ");
|
|
|
286 fprintf (stderr,"^\n");
|
|
|
287 }
|
|
|
288 checksym(s)
|
|
|
289 int s;
|
|
|
290 {char *p;
|
|
|
291 if (sym != s)
|
|
|
292 { p=(s==RPAR) ? "')'": (s==RBRA) ? "']'": (s==SM) ? "';'":
|
|
|
293 (s==LPAR) ? "'('": (s==WHILE) ? "'while'":
|
|
|
294 (s==COLON) ? "':'": "Identifier";
|
|
|
295 fprintf(stderr,"%d:%s expected.\n",lineno,p);
|
|
|
296 errmsg();
|
|
|
297 }
|
|
|
298 else getsym();
|
|
|
299 }
|
|
|
300 init()
|
|
|
301 {NMTBL *nptr;
|
|
|
302 int i;
|
|
|
303 for(nptr = ntable,i = GSYMS; i--;) (nptr++)->sc = EMPTY;
|
|
|
304 reserve("int",INT);
|
|
|
305 reserve("void",INT);
|
|
|
306 reserve("char",CHAR);
|
|
|
307 reserve("struct",STRUCT);
|
|
|
308 reserve("union",UNION);
|
|
|
309 reserve("unsigned",UNSIGNED);
|
|
|
310 reserve("static",STATIC);
|
|
|
311 reserve("goto",GOTO);
|
|
|
312 reserve("return",RETURN);
|
|
|
313 reserve("break",BREAK);
|
|
|
314 reserve("continue",CONTINUE);
|
|
|
315 reserve("if",IF);
|
|
|
316 reserve("else",ELSE);
|
|
|
317 reserve("for",FOR);
|
|
|
318 reserve("do",DO);
|
|
|
319 reserve("while",WHILE);
|
|
|
320 reserve("switch",SWITCH);
|
|
|
321 reserve("case",CASE);
|
|
|
322 reserve("default",DEFAULT);
|
|
|
323 reserve("typedef",TYPEDEF);
|
|
|
324 reserve("sizeof",SIZEOF);
|
|
|
325 reserve("long",LONG);
|
|
|
326 reserve("short",SHORT);
|
|
|
327 gpc=glineno=mflag=0;
|
|
|
328 gfree=ilabel=1;
|
|
|
329 labelno=2;
|
|
|
330 cheapp=cheap;
|
|
|
331 lfree=HEAPSIZE;
|
|
|
332 filep=filestack;
|
|
|
333 newfile();
|
|
|
334 getline();
|
|
|
335 getch();
|
|
|
336 }
|
|
|
337 newfile()
|
|
|
338 { lineno=0;
|
|
|
339 fprintf(stderr,"%s:\n",av[ac2]);
|
|
|
340 if ( (filep->fcb = fopen(av[ac2++],"r")) == NULL ) error(FILERR);
|
|
|
341 }
|
|
|
342 reserve(s,d)
|
|
|
343 char *s;
|
|
|
344 int d;
|
|
|
345 {NMTBL *nptr;
|
|
|
346 char *t;
|
|
|
347 hash=0;
|
|
|
348 t=name;
|
|
|
349 while(*t++ = *s) hash=7*(hash+*s++);
|
|
|
350 (nptr = gsearch())->sc = RESERVE;
|
|
|
351 nptr->dsp = d;
|
|
|
352 }
|
|
|
353
|
|
|
354 decl()
|
|
|
355 {NMTBL *n;
|
|
|
356 int t;
|
|
|
357 if(sym==STATIC)
|
|
|
358 if(mode==LDECL)
|
|
|
359 { getsym();
|
|
|
360 mode=STADECL;
|
|
|
361 }
|
|
|
362 else error(DCERR);
|
|
|
363 else if(sym==TYPEDEF)
|
|
|
364 if(mode==GDECL)
|
|
|
365 { getsym();
|
|
|
366 mode=GTDECL;
|
|
|
367 }
|
|
|
368 else if(mode==LDECL)
|
|
|
369 { getsym();
|
|
|
370 mode=LTDECL;
|
|
|
371 }
|
|
|
372 else error(DCERR);
|
|
|
373 if((t=typespec())==0) return;
|
|
|
374 if(sym==SM) return;
|
|
|
375 type=t;
|
|
|
376 n=decl0();
|
|
|
377 reverse(t);
|
|
|
378 if(args||sym==LC) {fdecl(n);return;}
|
|
|
379 def(n);
|
|
|
380 while(sym==COMMA)
|
|
|
381 { getsym();
|
|
|
382 type=t;
|
|
|
383 n=decl0();
|
|
|
384 reverse(t);
|
|
|
385 if(args) error(DCERR);
|
|
|
386 def(n);
|
|
|
387 }
|
|
|
388 if(sym!=SM) error(DCERR);
|
|
|
389 if(mode==GTDECL) mode=GDECL;
|
|
|
390 if(mode==STADECL||mode==LTDECL) mode=LDECL;
|
|
|
391 }
|
|
|
392 typespec()
|
|
|
393 {int t;
|
|
|
394 switch(sym)
|
|
|
395 {case INT:
|
|
|
396 case CHAR:
|
|
|
397 t= sym;
|
|
|
398 getsym();
|
|
|
399 break;
|
|
|
400 case STRUCT:
|
|
|
401 case UNION:
|
|
|
402 t=sdecl(sym);
|
|
|
403 break;
|
|
|
404 case UNSIGNED:
|
|
|
405 t = UNSIGNED;
|
|
|
406 if(getsym()==INT) getsym();
|
|
|
407 break;
|
|
|
408 case SHORT:
|
|
|
409 t=CHAR;
|
|
|
410 if(getsym()==INT) getsym();
|
|
|
411 break;
|
|
|
412 case LONG:
|
|
|
413 t=INT;
|
|
|
414 if(getsym()==INT) getsym();
|
|
|
415 break;
|
|
|
416 default:
|
|
|
417 if(sym==IDENT)
|
|
|
418 if(nptr->sc==TYPE)
|
|
|
419 { t=nptr->ty;
|
|
|
420 getsym();
|
|
|
421 break;
|
|
|
422 }
|
|
|
423 else if(nptr->sc==EMPTY && gnptr->sc==TYPE)
|
|
|
424 { t=gnptr->ty;
|
|
|
425 getsym();
|
|
|
426 break;
|
|
|
427 }
|
|
|
428 if(mode==LDECL) return 0;
|
|
|
429 t= INT;
|
|
|
430 }
|
|
|
431 return t;
|
|
|
432 }
|
|
|
433 struct nametable *decl0()
|
|
|
434 {NMTBL *n;
|
|
|
435 if(sym==MUL)
|
|
|
436 { getsym();
|
|
|
437 n=decl0();
|
|
|
438 type=list2(POINTER,type);
|
|
|
439 return n;
|
|
|
440 }
|
|
|
441 return decl1();
|
|
|
442 }
|
|
|
443 NMTBL *decl1()
|
|
|
444 {NMTBL *n;
|
|
|
445 int i,t;
|
|
|
446 if(sym==LPAR)
|
|
|
447 { getsym();
|
|
|
448 n=decl0();
|
|
|
449 checksym(RPAR);
|
|
|
450 }
|
|
|
451 else if (sym == IDENT)
|
|
|
452 { n=nptr;
|
|
|
453 getsym();
|
|
|
454 }
|
|
|
455 else error(DCERR);
|
|
|
456 while(1)
|
|
|
457 if(sym==LBRA)
|
|
|
458 if(getsym()==RBRA)
|
|
|
459 { getsym();
|
|
|
460 if(mode!=ADECL) error(DCERR);
|
|
|
461 t=type;
|
|
|
462 type=list2(POINTER,type);
|
|
|
463 }
|
|
|
464 else
|
|
|
465 { t=type;
|
|
|
466 i=cexpr(expr());
|
|
|
467 checksym(RBRA);
|
|
|
468 type=list3(ARRAY,t,i);
|
|
|
469 }
|
|
|
470 else if(sym==LPAR)
|
|
|
471 { if(mode==GDECL) {mode=ADECL;getsym();mode=GDECL;}
|
|
|
472 else getsym();
|
|
|
473 if(sym==RPAR) getsym();
|
|
|
474 else
|
|
|
475 { n->sc=FUNCTION;
|
|
|
476 adecl();
|
|
|
477 n->sc=EMPTY;
|
|
|
478 }
|
|
|
479 type=list2(FUNCTION,type);
|
|
|
480 }
|
|
|
481 else return n;
|
|
|
482 }
|
|
|
483 adecl()
|
|
|
484 { if(mode!=GDECL) error(DCERR);
|
|
|
485 mode=ADECL;
|
|
|
486 args= 2;
|
|
|
487 while(1)
|
|
|
488 { if(sym!=IDENT) error(DCERR);
|
|
|
489 nptr->ty = INT;
|
|
|
490 nptr->sc = LVAR;
|
|
|
491 nptr->dsp = (args += 2);
|
|
|
492 if(getsym()!=COMMA) break;
|
|
|
493 getsym();
|
|
|
494 }
|
|
|
495 checksym(RPAR);
|
|
|
496 mode=GDECL;
|
|
|
497 return;
|
|
|
498 }
|
|
|
499 reverse(t1)
|
|
|
500 int t1;
|
|
|
501 {int t2,t3;
|
|
|
502 t2=t1;
|
|
|
503 while(type!=t1)
|
|
|
504 { t3=cadr(type);
|
|
|
505 rplacad(type,t2);
|
|
|
506 t2=type;
|
|
|
507 type=t3;
|
|
|
508 }
|
|
|
509 type=t2;
|
|
|
510 }
|
|
|
511 size(t)
|
|
|
512 int t;
|
|
|
513 { if(t==CHAR) return 1;
|
|
|
514 if(scalar(t)) return 2;
|
|
|
515 if(car(t)==STRUCT||car(t)==UNION)
|
|
|
516 { if(cadr(t)==-1) error(DCERR);
|
|
|
517 return(cadr(t));
|
|
|
518 }
|
|
|
519 if(car(t)==ARRAY) return(size(cadr(t))*caddr(t));
|
|
|
520 else error(DCERR);
|
|
|
521 /*NOTREACHED*/
|
|
|
522 }
|
|
|
523 def(n)
|
|
|
524 NMTBL *n;
|
|
|
525 {int sz,nsc,ndsp,slfree,l,t,e;
|
|
|
526 if(car(type)==FUNCTION)
|
|
|
527 { fcheck(n);
|
|
|
528 return;
|
|
|
529 }
|
|
|
530 if (n->sc!=EMPTY &&
|
|
|
531 (mode!=ADECL || n->sc!=LVAR || n->ty!=INT) &&
|
|
|
532 (mode!=GSDECL&&mode!=LSDECL || n->sc!=FIELD || n->dsp!=disp) &&
|
|
|
533 (mode!=GUDECL&&mode!=LUDECL || n->sc!=FIELD || n->dsp!=0) )
|
|
|
534 error(DCERR);
|
|
|
535 sz = size(n->ty = type);
|
|
|
536 switch(mode)
|
|
|
537 {case GDECL:
|
|
|
538 printf("%s\tEQU\t%u\n",n->nm,gpc);
|
|
|
539 case STADECL:
|
|
|
540 nsc = GVAR;
|
|
|
541 ndsp = gpc;
|
|
|
542 if(sym==ASS)
|
|
|
543 { t=type;
|
|
|
544 if(!scalar(t))
|
|
|
545 error(TYERR);
|
|
|
546 if(mode==STADECL) printf("\tBRA\t_%d\n",l=fwdlabel());
|
|
|
547 fwddef(ilabel);
|
|
|
548 getsym();
|
|
|
549 slfree=lfree;
|
|
|
550 e=expr1();
|
|
|
551 if(car(e)==CONST)
|
|
|
552 { lddim(cadr(e));
|
|
|
553 indexy(t==CHAR?"STB":"STD",gpc);
|
|
|
554 }
|
|
|
555 else if(t!=CHAR)
|
|
|
556 { if(car(e)==ADDRESS&&car(cadr(e))==GVAR)
|
|
|
557 leaxy(cadr(cadr(e)));
|
|
|
558 else if(car(e)==FNAME)
|
|
|
559 leaxpcr((NMTBL *)cadr(e));
|
|
|
560 else error(TYERR);
|
|
|
561 stxy(gpc);
|
|
|
562 }
|
|
|
563 else error(TYERR);
|
|
|
564 lfree=slfree;
|
|
|
565 jmp(ilabel=fwdlabel());
|
|
|
566 if(mode==STADECL) fwddef(l);
|
|
|
567 type=t;
|
|
|
568 }
|
|
|
569 gpc +=sz;
|
|
|
570 break;
|
|
|
571 case GSDECL:
|
|
|
572 nsc = FIELD;
|
|
|
573 ndsp = disp;
|
|
|
574 disp += sz;
|
|
|
575 break;
|
|
|
576 case GUDECL:
|
|
|
577 nsc = FIELD;
|
|
|
578 ndsp = 0;
|
|
|
579 if (disp < sz) disp = sz;
|
|
|
580 break;
|
|
|
581 case GTDECL:
|
|
|
582 nsc = TYPE;
|
|
|
583 break;
|
|
|
584 case ADECL:
|
|
|
585 if(type==CHAR) ++(n->dsp);
|
|
|
586 else if (!scalar(type)) error(TYERR);
|
|
|
587 return;
|
|
|
588 case LDECL:
|
|
|
589 nsc = LVAR;
|
|
|
590 ndsp = (disp -= sz);
|
|
|
591 break;
|
|
|
592 case LSDECL:
|
|
|
593 nsc = FIELD;
|
|
|
594 ndsp = disp;
|
|
|
595 disp += sz;
|
|
|
596 break;
|
|
|
597 case LUDECL:
|
|
|
598 nsc = FIELD;
|
|
|
599 ndsp = 0;
|
|
|
600 if (disp < sz) disp = sz;
|
|
|
601 break;
|
|
|
602 case LTDECL:
|
|
|
603 nsc = TYPE;
|
|
|
604 break;
|
|
|
605 default:
|
|
|
606 error(DCERR);
|
|
|
607 }
|
|
|
608 n->sc = nsc;
|
|
|
609 n->dsp = ndsp;
|
|
|
610 }
|
|
|
611 sdecl(s)
|
|
|
612 int s;
|
|
|
613 {int smode,sdisp,type;
|
|
|
614 NMTBL *nptr0;
|
|
|
615 smode=mode;
|
|
|
616 if (mode==GDECL || mode==GSDECL || mode==GUDECL || mode==GTDECL)
|
|
|
617 mode=(s==STRUCT?GSDECL:GUDECL);
|
|
|
618 else mode=(s==STRUCT?LSDECL:LUDECL);
|
|
|
619 sdisp=disp;
|
|
|
620 disp=0;
|
|
|
621 if (getsym() == IDENT)
|
|
|
622 { nptr0 = nptr;
|
|
|
623 if (getsym() == LC)
|
|
|
624 { if (nptr0->sc != EMPTY) error(DCERR);
|
|
|
625 nptr0->sc = TAG;
|
|
|
626 nptr0->ty = list2(s,-1);
|
|
|
627 while (getsym() != RC) decl();
|
|
|
628 getsym();
|
|
|
629 rplacad(type = nptr0->ty,disp);
|
|
|
630 }
|
|
|
631 else
|
|
|
632 { if(nptr0->sc == EMPTY) nptr0=gnptr;
|
|
|
633 if(nptr0->sc == EMPTY) error(UDERR);
|
|
|
634 if(nptr0->sc != TAG) error(TYERR);
|
|
|
635 type = nptr0->ty;
|
|
|
636 }
|
|
|
637 }
|
|
|
638 else if(sym==LC)
|
|
|
639 { while(getsym() != RC) decl();
|
|
|
640 getsym();
|
|
|
641 type = list2(s,disp);
|
|
|
642 }
|
|
|
643 else error(DCERR);
|
|
|
644 disp=sdisp;
|
|
|
645 mode=smode;
|
|
|
646 return type;
|
|
|
647 }
|
|
|
648 fdecl(n)
|
|
|
649 NMTBL *n;
|
|
|
650 { args=0;
|
|
|
651 fcheck(n);
|
|
|
652 mode=ADECL;
|
|
|
653 lfree= HEAPSIZE;
|
|
|
654 while (sym!=LC) {decl(); getsym();}
|
|
|
655 disp=0;
|
|
|
656 mode=STAT;
|
|
|
657 while (typeid(getsym()) || sym==STATIC || sym==TYPEDEF)
|
|
|
658 { mode=LDECL;
|
|
|
659 decl();
|
|
|
660 mode=STAT;
|
|
|
661 }
|
|
|
662 control=1;
|
|
|
663 printf("%s\n\tPSHS\tU\n\tLEAU\t,S\n",n->nm);
|
|
|
664 if(disp) printf("\tLEAS\t%d,S\n",disp);
|
|
|
665 lvar= -disp;
|
|
|
666 while(sym!=RC) statement();
|
|
|
667 if (control) return2();
|
|
|
668 }
|
|
|
669 fcheck(n)
|
|
|
670 NMTBL *n;
|
|
|
671 { if(mode!=GDECL||car(type)!=FUNCTION) error(DCERR);
|
|
|
672 if(n->sc==FUNCTION) compatible(n->ty,cadr(type));
|
|
|
673 else if(n->sc!=EMPTY) error(DCERR);
|
|
|
674 n->sc=FUNCTION;
|
|
|
675 n->ty=cadr(type);
|
|
|
676 }
|
|
|
677 compatible(t1,t2)
|
|
|
678 int t1,t2;
|
|
|
679 { if(integral(t1))
|
|
|
680 { if(t1!=t2) error(TYERR);
|
|
|
681 }
|
|
|
682 else if(car(t1)!=car(t2)) error(TYERR);
|
|
|
683 else if((car(t1)==STRUCT || car(t1)==UNION) && cadr(t1)!=cadr(t2))
|
|
|
684 error(TYERR);
|
|
|
685 else if(car(t1)==POINTER || car(t1)==ARRAY ||car(t1)==FUNCTION)
|
|
|
686 compatible(cadr(t1),cadr(t2));
|
|
|
687 }
|
|
|
688 scalar(t)
|
|
|
689 int t;
|
|
|
690 { return(integral(t)||car(t)==POINTER);
|
|
|
691 }
|
|
|
692 integral(t)
|
|
|
693 int t;
|
|
|
694 { return(t==INT||t==CHAR||t==UNSIGNED);
|
|
|
695 }
|
|
|
696
|
|
|
697 statement()
|
|
|
698 {int slfree;
|
|
|
699 switch(sym)
|
|
|
700 {case IF:
|
|
|
701 doif();
|
|
|
702 return;
|
|
|
703 case WHILE:
|
|
|
704 dowhile();
|
|
|
705 return;
|
|
|
706 case DO:
|
|
|
707 dodo();
|
|
|
708 return;
|
|
|
709 case FOR:
|
|
|
710 dofor();
|
|
|
711 return;
|
|
|
712 case SWITCH:
|
|
|
713 doswitch();
|
|
|
714 return;
|
|
|
715 case LC:
|
|
|
716 docomp();
|
|
|
717 return;
|
|
|
718 case BREAK:
|
|
|
719 jmp(blabel);
|
|
|
720 getsym();
|
|
|
721 checksym(SM);
|
|
|
722 return;
|
|
|
723 case CONTINUE:
|
|
|
724 jmp(clabel);
|
|
|
725 getsym();
|
|
|
726 checksym(SM);
|
|
|
727 return;
|
|
|
728 case CASE:
|
|
|
729 docase();
|
|
|
730 statement();
|
|
|
731 return;
|
|
|
732 case DEFAULT:
|
|
|
733 dodefault();
|
|
|
734 statement();
|
|
|
735 return;
|
|
|
736 case RETURN:
|
|
|
737 doreturn();
|
|
|
738 return;
|
|
|
739 case GOTO:
|
|
|
740 dogoto();
|
|
|
741 return;
|
|
|
742 case SM:
|
|
|
743 getsym();
|
|
|
744 return;
|
|
|
745 default:if(sym==IDENT&&skipspc()==':')
|
|
|
746 { dolabel();
|
|
|
747 statement();
|
|
|
748 }
|
|
|
749 else
|
|
|
750 { slfree=lfree;
|
|
|
751 gexpr(expr());
|
|
|
752 lfree=slfree;
|
|
|
753 checksym(SM);
|
|
|
754 }
|
|
|
755 }
|
|
|
756 }
|
|
|
757 doif()
|
|
|
758 {int l1,l2,slfree;
|
|
|
759 getsym();
|
|
|
760 checksym(LPAR);
|
|
|
761 slfree=lfree;
|
|
|
762 bexpr(expr(),0,l1=fwdlabel());
|
|
|
763 lfree=slfree;
|
|
|
764 checksym(RPAR);
|
|
|
765 statement();
|
|
|
766 if(sym==ELSE)
|
|
|
767 { if (l2 = control) jmp(l2=fwdlabel());
|
|
|
768 fwddef(l1);
|
|
|
769 getsym();
|
|
|
770 statement();
|
|
|
771 if (l2) fwddef(l2);
|
|
|
772 }
|
|
|
773 else fwddef(l1);
|
|
|
774 }
|
|
|
775 dowhile()
|
|
|
776 {int sbreak,scontinue,slfree,e;
|
|
|
777 sbreak=blabel;
|
|
|
778 scontinue=clabel;
|
|
|
779 blabel=fwdlabel();
|
|
|
780 clabel=backdef();
|
|
|
781 getsym();
|
|
|
782 checksym(LPAR);
|
|
|
783 slfree=lfree;
|
|
|
784 e=expr();
|
|
|
785 checksym(RPAR);
|
|
|
786 if(sym==SM)
|
|
|
787 { bexpr(e,1,clabel);
|
|
|
788 lfree=slfree;
|
|
|
789 getsym();
|
|
|
790 }
|
|
|
791 else
|
|
|
792 { bexpr(e,0,blabel);
|
|
|
793 lfree=slfree;
|
|
|
794 statement();
|
|
|
795 jmp(clabel);
|
|
|
796 }
|
|
|
797 fwddef(blabel);
|
|
|
798 clabel=scontinue;
|
|
|
799 blabel=sbreak;
|
|
|
800 }
|
|
|
801 dodo()
|
|
|
802 {int sbreak,scontinue,l,slfree;
|
|
|
803 sbreak=blabel;
|
|
|
804 scontinue=clabel;
|
|
|
805 blabel=fwdlabel();
|
|
|
806 clabel=fwdlabel();
|
|
|
807 l=backdef();
|
|
|
808 getsym();
|
|
|
809 statement();
|
|
|
810 fwddef(clabel);
|
|
|
811 checksym(WHILE);
|
|
|
812 checksym(LPAR);
|
|
|
813 slfree=lfree;
|
|
|
814 bexpr(expr(),1,l);
|
|
|
815 lfree=slfree;
|
|
|
816 checksym(RPAR);
|
|
|
817 checksym(SM);
|
|
|
818 fwddef(blabel);
|
|
|
819 clabel=scontinue;
|
|
|
820 blabel=sbreak;
|
|
|
821 }
|
|
|
822 dofor()
|
|
|
823 {int sbreak,scontinue,l,e,slfree;
|
|
|
824 sbreak=blabel;
|
|
|
825 scontinue=clabel;
|
|
|
826 blabel=fwdlabel();
|
|
|
827 getsym();
|
|
|
828 checksym(LPAR);
|
|
|
829 slfree=lfree;
|
|
|
830 if(sym!=SM)
|
|
|
831 { gexpr(expr());
|
|
|
832 checksym(SM);
|
|
|
833 }
|
|
|
834 else getsym();
|
|
|
835 lfree=slfree;
|
|
|
836 l=backdef();
|
|
|
837 if(sym!=SM)
|
|
|
838 { bexpr(expr(),0,blabel);
|
|
|
839 checksym(SM);
|
|
|
840 }
|
|
|
841 else getsym();
|
|
|
842 lfree=slfree;
|
|
|
843 if(sym==RPAR)
|
|
|
844 { clabel=l;
|
|
|
845 getsym();
|
|
|
846 statement();
|
|
|
847 }
|
|
|
848 else
|
|
|
849 { clabel=fwdlabel();
|
|
|
850 e=expr();
|
|
|
851 checksym(RPAR);
|
|
|
852 statement();
|
|
|
853 fwddef(clabel);
|
|
|
854 gexpr(e);
|
|
|
855 lfree=slfree;
|
|
|
856 }
|
|
|
857 jmp(l);
|
|
|
858 fwddef(blabel);
|
|
|
859 clabel=scontinue;
|
|
|
860 blabel=sbreak;
|
|
|
861 }
|
|
|
862 doswitch()
|
|
|
863 {int sbreak,scase,sdefault,slfree;
|
|
|
864 sbreak=blabel;
|
|
|
865 blabel=fwdlabel();
|
|
|
866 sdefault=dlabel;
|
|
|
867 dlabel=0;
|
|
|
868 scase=cslabel;
|
|
|
869 getsym();
|
|
|
870 checksym(LPAR);
|
|
|
871 slfree=lfree;
|
|
|
872 gexpr(expr());
|
|
|
873 lfree=slfree;
|
|
|
874 checksym(RPAR);
|
|
|
875 cslabel = control = 0;
|
|
|
876 statement();
|
|
|
877 if(dlabel) printf("_%d\tEQU\t_%d\n",cslabel,dlabel);
|
|
|
878 else fwddef(cslabel);
|
|
|
879 cslabel=scase;
|
|
|
880 dlabel=sdefault;
|
|
|
881 fwddef(blabel);
|
|
|
882 blabel=sbreak;
|
|
|
883 }
|
|
|
884 docomp()
|
|
|
885 { getsym();
|
|
|
886 while(sym!=RC) statement();
|
|
|
887 getsym();
|
|
|
888 }
|
|
|
889 docase()
|
|
|
890 {int c,n,l,slfree;
|
|
|
891 c=0;
|
|
|
892 n=2;
|
|
|
893 slfree=lfree;
|
|
|
894 while(sym==CASE)
|
|
|
895 { getsym();
|
|
|
896 c=list2(cexpr(expr()),c);
|
|
|
897 n+=6;
|
|
|
898 checksym(COLON);
|
|
|
899 }
|
|
|
900 l=fwdlabel();
|
|
|
901 if (control)
|
|
|
902 { control=0;
|
|
|
903 if (n>127) jmp(l);
|
|
|
904 else printf("\tBRA\t_%d\n",l);
|
|
|
905 }
|
|
|
906 if (cslabel) fwddef(cslabel);
|
|
|
907 while(cadr(c))
|
|
|
908 { cmpdimm(car(c));
|
|
|
909 if((n-=6)>127) jcond(l,0);
|
|
|
910 else printf("\tBEQ\t_%d\n",l);
|
|
|
911 c=cadr(c);
|
|
|
912 }
|
|
|
913 lfree=slfree;
|
|
|
914 cmpdimm(car(c));
|
|
|
915 jcond(cslabel=fwdlabel(),1);
|
|
|
916 fwddef(l);
|
|
|
917 }
|
|
|
918 dodefault()
|
|
|
919 { getsym();
|
|
|
920 checksym(COLON);
|
|
|
921 if (dlabel) error(STERR);
|
|
|
922 if (!cslabel) jmp(cslabel = fwdlabel());
|
|
|
923 dlabel = backdef();
|
|
|
924 }
|
|
|
925 doreturn()
|
|
|
926 {int slfree;
|
|
|
927 if(getsym()==SM)
|
|
|
928 { getsym();
|
|
|
929 return2();
|
|
|
930 return;
|
|
|
931 }
|
|
|
932 slfree=lfree;
|
|
|
933 gexpr(expr());
|
|
|
934 lfree=slfree;
|
|
|
935 checksym(SM);
|
|
|
936 control=0;
|
|
|
937 switch(lvar)
|
|
|
938 {case 0:
|
|
|
939 ret("");
|
|
|
940 return;
|
|
|
941 case 2:
|
|
|
942 ret("X,");
|
|
|
943 return;
|
|
|
944 default:unlink();
|
|
|
945 return;
|
|
|
946 }
|
|
|
947 }
|
|
|
948 return2()
|
|
|
949 { control=0;
|
|
|
950 switch(lvar)
|
|
|
951 {case 0:
|
|
|
952 ret("");
|
|
|
953 return;
|
|
|
954 case 1:
|
|
|
955 ret("A,");
|
|
|
956 return;
|
|
|
957 case 2:
|
|
|
958 ret("D,");
|
|
|
959 return;
|
|
|
960 case 3:
|
|
|
961 ret("A,X,");
|
|
|
962 return;
|
|
|
963 case 4:
|
|
|
964 ret("D,X,");
|
|
|
965 return;
|
|
|
966 default:unlink();
|
|
|
967 return;
|
|
|
968 }
|
|
|
969 }
|
|
|
970 ret(reg)
|
|
|
971 char *reg;
|
|
|
972 { printf("\tPULS\t%sU,PC\n",reg);
|
|
|
973 }
|
|
|
974 unlink()
|
|
|
975 { printf("\tLEAS\t,U\n");
|
|
|
976 ret("");
|
|
|
977 }
|
|
|
978 dogoto()
|
|
|
979 {NMTBL *nptr0;
|
|
|
980 getsym();
|
|
|
981 nptr0=nptr;
|
|
|
982 checksym(IDENT);
|
|
|
983 if(nptr0->sc == BLABEL || nptr0->sc == FLABEL) jmp(nptr0->dsp);
|
|
|
984 else if(nptr0->sc == EMPTY)
|
|
|
985 { nptr0->sc = FLABEL;
|
|
|
986 jmp(nptr0->dsp = fwdlabel());
|
|
|
987 }
|
|
|
988 else error(STERR);
|
|
|
989 checksym(SM);
|
|
|
990 }
|
|
|
991 dolabel()
|
|
|
992 { if(nptr->sc == FLABEL) fwddef(nptr->dsp);
|
|
|
993 else if(nptr->sc != EMPTY) error(TYERR);
|
|
|
994 nptr->sc = BLABEL;
|
|
|
995 nptr->dsp = backdef();
|
|
|
996 getsym();
|
|
|
997 checksym(COLON);
|
|
|
998 }
|
|
|
999
|
|
|
1000 expr()
|
|
|
1001 { return(rvalue(expr0()));
|
|
|
1002 }
|
|
|
1003 expr0()
|
|
|
1004 {int e;
|
|
|
1005 e=expr1();
|
|
|
1006 while(sym==COMMA) {getsym();e=list3(COMMA,e,rvalue(expr1()));}
|
|
|
1007 return e;
|
|
|
1008 }
|
|
|
1009 expr1()
|
|
|
1010 {int e1,e2,t,op;
|
|
|
1011 e1=expr2();
|
|
|
1012 switch (sym)
|
|
|
1013 {case ASS:
|
|
|
1014 lcheck(e1);
|
|
|
1015 t=type;
|
|
|
1016 getsym();
|
|
|
1017 e2=rvalue(expr1());
|
|
|
1018 if(t==CHAR) {type= INT;return(list3(CASS,e1,e2));}
|
|
|
1019 type=t;
|
|
|
1020 return(list3(ASS,e1,e2));
|
|
|
1021 case ADD+AS: case SUB+AS: case MUL+AS: case DIV+AS: case MOD+AS:
|
|
|
1022 case RSHIFT+AS: case LSHIFT+AS: case BAND+AS: case EOR+AS: case BOR+AS:
|
|
|
1023 op = sym-AS;
|
|
|
1024 lcheck(e1);
|
|
|
1025 t=type;
|
|
|
1026 getsym();
|
|
|
1027 e2=rvalue(expr1());
|
|
|
1028 if(!integral(type)) error(TYERR);
|
|
|
1029 if((t==UNSIGNED||type==UNSIGNED)&&
|
|
|
1030 (op==MUL||op==DIV||op==MOD||op==RSHIFT||op==LSHIFT))
|
|
|
1031 op=op+US;
|
|
|
1032 if(t==CHAR)
|
|
|
1033 { type= INT;
|
|
|
1034 return(list4(CASSOP,e1,e2,op));
|
|
|
1035 }
|
|
|
1036 type=t;
|
|
|
1037 if(integral(t)) return(list4(ASSOP,e1,e2,op));
|
|
|
1038 if((op!=ADD&&op!=SUB)||car(t)!=POINTER) error(TYERR);
|
|
|
1039 e2=binop(MUL,e2,list2(CONST,size(cadr(t))),INT,UNSIGNED);
|
|
|
1040 type=t;
|
|
|
1041 return list4(ASSOP,e1,e2,op);
|
|
|
1042 default:
|
|
|
1043 return(e1);
|
|
|
1044 }
|
|
|
1045 }
|
|
|
1046 expr2()
|
|
|
1047 {int e1,e2,e3,t;
|
|
|
1048 e1=expr3();
|
|
|
1049 if(sym==COND)
|
|
|
1050 { e1=rvalue(e1);
|
|
|
1051 getsym();
|
|
|
1052 e2=rvalue(expr2());
|
|
|
1053 t=type;
|
|
|
1054 checksym(COLON);
|
|
|
1055 e3=rvalue(expr2());
|
|
|
1056 if(car(e1)==CONST)
|
|
|
1057 if(cadr(e1)) {type=t;return e2;}
|
|
|
1058 else return e3;
|
|
|
1059 if(type==INT||t!=INT&&type==UNSIGNED) type=t;
|
|
|
1060 return(list4(COND,e1,e2,e3));
|
|
|
1061 }
|
|
|
1062 return(e1);
|
|
|
1063 }
|
|
|
1064 expr3()
|
|
|
1065 {int e;
|
|
|
1066 e=expr4();
|
|
|
1067 while(sym==LOR)
|
|
|
1068 { e=rvalue(e);
|
|
|
1069 getsym();
|
|
|
1070 e=list3(LOR,e,rvalue(expr4()));
|
|
|
1071 type= INT;
|
|
|
1072 }
|
|
|
1073 return(e);
|
|
|
1074 }
|
|
|
1075 expr4()
|
|
|
1076 {int e;
|
|
|
1077 e=expr5();
|
|
|
1078 while(sym==LAND)
|
|
|
1079 { e=rvalue(e);
|
|
|
1080 getsym();
|
|
|
1081 e=list3(LAND,e,rvalue(expr5()));
|
|
|
1082 type= INT;
|
|
|
1083 }
|
|
|
1084 return(e);
|
|
|
1085 }
|
|
|
1086 expr5()
|
|
|
1087 {int e1,e2,t;
|
|
|
1088 e1=expr6();
|
|
|
1089 while(sym==BOR)
|
|
|
1090 { e1=rvalue(e1);
|
|
|
1091 t=type;
|
|
|
1092 getsym();
|
|
|
1093 e2=rvalue(expr6());
|
|
|
1094 e1=binop(BOR,e1,e2,t,type);
|
|
|
1095 }
|
|
|
1096 return(e1);
|
|
|
1097 }
|
|
|
1098 expr6()
|
|
|
1099 {int e1,e2,t;
|
|
|
1100 e1=expr7();
|
|
|
1101 while(sym==EOR)
|
|
|
1102 { e1=rvalue(e1);
|
|
|
1103 t=type;
|
|
|
1104 getsym();
|
|
|
1105 e2=rvalue(expr7());
|
|
|
1106 e1=binop(EOR,e1,e2,t,type);
|
|
|
1107 }
|
|
|
1108 return(e1);
|
|
|
1109 }
|
|
|
1110 expr7()
|
|
|
1111 {int e1,e2,t;
|
|
|
1112 e1=expr8();
|
|
|
1113 while(sym==BAND)
|
|
|
1114 { e1=rvalue(e1);
|
|
|
1115 t=type;
|
|
|
1116 getsym();
|
|
|
1117 e2=rvalue(expr8());
|
|
|
1118 e1=binop(BAND,e1,e2,t,type);
|
|
|
1119 }
|
|
|
1120 return(e1);
|
|
|
1121 }
|
|
|
1122 expr8()
|
|
|
1123 {int e,op;
|
|
|
1124 e=expr9();
|
|
|
1125 while((op=sym)==EQ||op==NEQ)
|
|
|
1126 { e=rvalue(e);
|
|
|
1127 getsym();
|
|
|
1128 e=list3(op,e,rvalue(expr9()));
|
|
|
1129 type= INT;
|
|
|
1130 }
|
|
|
1131 return e;
|
|
|
1132 }
|
|
|
1133 expr9()
|
|
|
1134 {int e1,e2,t,op;
|
|
|
1135 e1=expr10();
|
|
|
1136 while((op=sym)==GT||op==GE||op==LT||op==LE)
|
|
|
1137 { e1=rvalue(e1);
|
|
|
1138 t=type;
|
|
|
1139 getsym();
|
|
|
1140 e2=rvalue(expr10());
|
|
|
1141 if(t==INT&&type==INT) e1=list3(op,e1,e2);
|
|
|
1142 else e1=list3(op+US,e1,e2);
|
|
|
1143 type= INT;
|
|
|
1144 }
|
|
|
1145 return e1;
|
|
|
1146 }
|
|
|
1147 expr10()
|
|
|
1148 {int e1,e2,t,op;
|
|
|
1149 e1=expr11();
|
|
|
1150 while((op=sym)==RSHIFT||op==LSHIFT)
|
|
|
1151 { e1=rvalue(e1);
|
|
|
1152 t=type;
|
|
|
1153 getsym();
|
|
|
1154 e2=rvalue(expr11());
|
|
|
1155 e1=binop(op,e1,e2,t,type);
|
|
|
1156 }
|
|
|
1157 return e1;
|
|
|
1158 }
|
|
|
1159 expr11()
|
|
|
1160 {int e1,e2,t,op;
|
|
|
1161 e1=expr12();
|
|
|
1162 while((op=sym)==ADD||op==SUB)
|
|
|
1163 { e1=rvalue(e1);
|
|
|
1164 t=type;
|
|
|
1165 getsym();
|
|
|
1166 e2=rvalue(expr12());
|
|
|
1167 e1=binop(op,e1,e2,t,type);
|
|
|
1168 }
|
|
|
1169 return e1;
|
|
|
1170 }
|
|
|
1171 expr12()
|
|
|
1172 {int e1,e2,t,op;
|
|
|
1173 e1=expr13();
|
|
|
1174 while((op=sym)==MUL||op==DIV||op==MOD)
|
|
|
1175 { e1=rvalue(e1);
|
|
|
1176 t=type;
|
|
|
1177 getsym();
|
|
|
1178 e2=rvalue(expr13());
|
|
|
1179 e1=binop(op,e1,e2,t,type);
|
|
|
1180 }
|
|
|
1181 return e1;
|
|
|
1182 }
|
|
|
1183 expr13()
|
|
|
1184 {int e,op;
|
|
|
1185 switch (op = sym)
|
|
|
1186 {case INC: case DEC:
|
|
|
1187 getsym();
|
|
|
1188 lcheck(e=expr13());
|
|
|
1189 if(type==CHAR)
|
|
|
1190 { type= INT;
|
|
|
1191 return(list2(op==INC?CPREINC:CPREDEC,e));
|
|
|
1192 }
|
|
|
1193 if(integral(type))
|
|
|
1194 return(list3(PREINC,e,op==INC?1:-1));
|
|
|
1195 if(car(type)!=POINTER) error(TYERR);
|
|
|
1196 return(list3(PREINC,e,
|
|
|
1197 op==INC?size(cadr(type)):-size(cadr(type)) ));
|
|
|
1198 case MUL:
|
|
|
1199 getsym();
|
|
|
1200 e=rvalue(expr13());
|
|
|
1201 return(indop(e));
|
|
|
1202 case BAND:
|
|
|
1203 getsym();
|
|
|
1204 switch(car(e=expr13()))
|
|
|
1205 {case INDIRECT:
|
|
|
1206 e=cadr(e);
|
|
|
1207 break;
|
|
|
1208 case GVAR:
|
|
|
1209 case LVAR:
|
|
|
1210 e=list2(ADDRESS,e);
|
|
|
1211 break;
|
|
|
1212 case FNAME:
|
|
|
1213 return e;
|
|
|
1214 default:error(LVERR);
|
|
|
1215 }
|
|
|
1216 type=list2(POINTER,type);
|
|
|
1217 return e;
|
|
|
1218 case SUB:
|
|
|
1219 getsym();
|
|
|
1220 e=rvalue(expr13());
|
|
|
1221 if(!integral(type)) error(TYERR);
|
|
|
1222 return(car(e)==CONST?list2(CONST,-cadr(e)):list2(MINUS,e));
|
|
|
1223 case BNOT:
|
|
|
1224 getsym();
|
|
|
1225 e=rvalue(expr13());
|
|
|
1226 if(!integral(type)) error(TYERR);
|
|
|
1227 return(car(e)==CONST?list2(CONST,~cadr(e)):list2(BNOT,e));
|
|
|
1228 case LNOT:
|
|
|
1229 getsym();
|
|
|
1230 return(list2(LNOT,rvalue(expr13())));
|
|
|
1231 case SIZEOF:
|
|
|
1232 if(getsym()==LPAR)
|
|
|
1233 if(typeid(getsym()))
|
|
|
1234 { e=list2(CONST,size(typename()));
|
|
|
1235 type=INT;
|
|
|
1236 checksym(RPAR);
|
|
|
1237 return e;
|
|
|
1238 }
|
|
|
1239 else
|
|
|
1240 { e=expr0();
|
|
|
1241 checksym(RPAR);
|
|
|
1242 expr16(e);
|
|
|
1243 if(sym==INC||sym==DEC)
|
|
|
1244 { getsym();
|
|
|
1245 if(type==CHAR) type=INT;
|
|
|
1246 else if(!scalar(type))
|
|
|
1247 error(TYERR);
|
|
|
1248 }
|
|
|
1249 }
|
|
|
1250 else expr13();
|
|
|
1251 e=list2(CONST,size(type));
|
|
|
1252 type=INT;
|
|
|
1253 return e;
|
|
|
1254 }
|
|
|
1255 e=expr14();
|
|
|
1256 if((op=sym)==INC||op==DEC)
|
|
|
1257 { lcheck(e);
|
|
|
1258 getsym();
|
|
|
1259 if(type==CHAR)
|
|
|
1260 { type= INT;
|
|
|
1261 return(list2(op==INC?CPOSTINC:CPOSTDEC,e));
|
|
|
1262 }
|
|
|
1263 if(integral(type))
|
|
|
1264 return(list3(POSTINC,e,op==INC?1:-1));
|
|
|
1265 if(car(type)!=POINTER) error(TYERR);
|
|
|
1266 return (list3(POSTINC,e,
|
|
|
1267 op == INC ? size(cadr(type)): -size(cadr(type)) ));
|
|
|
1268 }
|
|
|
1269 return e;
|
|
|
1270 }
|
|
|
1271 expr14()
|
|
|
1272 {int e1,t;
|
|
|
1273 switch(sym)
|
|
|
1274 {case IDENT:
|
|
|
1275 switch(nptr->sc)
|
|
|
1276 {case GVAR:
|
|
|
1277 e1=list2(GVAR,nptr->dsp);
|
|
|
1278 type=nptr->ty;
|
|
|
1279 getsym();
|
|
|
1280 break;
|
|
|
1281 case LVAR:
|
|
|
1282 e1=list2(LVAR,nptr->dsp);
|
|
|
1283 type=nptr->ty;
|
|
|
1284 getsym();
|
|
|
1285 break;
|
|
|
1286 case FUNCTION:
|
|
|
1287 e1=list2(FNAME,(int)nptr);
|
|
|
1288 type=list2(FUNCTION,nptr->ty);
|
|
|
1289 getsym();
|
|
|
1290 break;
|
|
|
1291 case EMPTY:
|
|
|
1292 if(getsym()==LPAR)
|
|
|
1293 { nptr->sc = FUNCTION;
|
|
|
1294 nptr->ty= INT;
|
|
|
1295 type= list2(FUNCTION,INT);
|
|
|
1296 e1=expr15(list2(FNAME,(int)nptr));
|
|
|
1297 break;
|
|
|
1298 }
|
|
|
1299 default:error(UDERR);
|
|
|
1300 }
|
|
|
1301 break;
|
|
|
1302 case STRING:
|
|
|
1303 e1=list3(STRING,(int)sptr,symval);
|
|
|
1304 type=list3(ARRAY,CHAR,symval);
|
|
|
1305 getsym();
|
|
|
1306 break;
|
|
|
1307 case CONST:
|
|
|
1308 type= INT;
|
|
|
1309 e1=list2(CONST,symval);
|
|
|
1310 getsym();
|
|
|
1311 break;
|
|
|
1312 case LPAR:
|
|
|
1313 if(typeid(getsym()))
|
|
|
1314 { t=typename();
|
|
|
1315 checksym(RPAR);
|
|
|
1316 e1=expr13();
|
|
|
1317 type=t;
|
|
|
1318 return e1;
|
|
|
1319 }
|
|
|
1320 e1=expr0();
|
|
|
1321 checksym(RPAR);
|
|
|
1322 break;
|
|
|
1323 default:error(EXERR);
|
|
|
1324 }
|
|
|
1325 return expr16(e1);
|
|
|
1326 }
|
|
|
1327 expr16(e1)
|
|
|
1328 int e1;
|
|
|
1329 {int e2,t;
|
|
|
1330 while(1)
|
|
|
1331 if(sym==LBRA)
|
|
|
1332 { e1=rvalue(e1);
|
|
|
1333 t=type;
|
|
|
1334 getsym();
|
|
|
1335 e2=rvalue(expr0());
|
|
|
1336 checksym(RBRA);
|
|
|
1337 e1=binop(ADD,e1,e2,t,type);
|
|
|
1338 e1=indop(e1);
|
|
|
1339 }
|
|
|
1340 else if(sym==LPAR) e1=expr15(e1);
|
|
|
1341 else if(sym==PERIOD) e1=strop(e1);
|
|
|
1342 else if(sym==ARROW) e1=strop(indop(rvalue(e1)));
|
|
|
1343 else break;
|
|
|
1344 if(car(e1)==FNAME) type=list2(POINTER,type);
|
|
|
1345 return e1;
|
|
|
1346 }
|
|
|
1347 rvalue(e)
|
|
|
1348 int e;
|
|
|
1349 { if(type==CHAR)
|
|
|
1350 { type= INT;
|
|
|
1351 switch(car(e))
|
|
|
1352 {case GVAR:
|
|
|
1353 return(list2(CRGVAR,cadr(e)));
|
|
|
1354 case LVAR:
|
|
|
1355 return(list2(CRLVAR,cadr(e)));
|
|
|
1356 case INDIRECT:
|
|
|
1357 return(list2(CRINDIRECT,cadr(e)));
|
|
|
1358 default:return(e);
|
|
|
1359 }
|
|
|
1360 }
|
|
|
1361 if(!integral(type))
|
|
|
1362 if(car(type)==ARRAY)
|
|
|
1363 { type=list2(POINTER,cadr(type));
|
|
|
1364 if(car(e)==INDIRECT) return cadr(e);
|
|
|
1365 return list2(ADDRESS,e);
|
|
|
1366 }
|
|
|
1367 else if(car(type)!=POINTER) error(TYERR);
|
|
|
1368 switch(car(e))
|
|
|
1369 {case GVAR:
|
|
|
1370 return(list2(RGVAR,cadr(e)));
|
|
|
1371 case LVAR:
|
|
|
1372 return(list2(RLVAR,cadr(e)));
|
|
|
1373 case INDIRECT:
|
|
|
1374 return(list2(RINDIRECT,cadr(e)));
|
|
|
1375 default:return(e);
|
|
|
1376 }
|
|
|
1377 }
|
|
|
1378 lcheck(e)
|
|
|
1379 int e;
|
|
|
1380 { if(!scalar(type)||car(e)!=GVAR&&car(e)!=LVAR&&car(e)!=INDIRECT)
|
|
|
1381 error(LVERR);
|
|
|
1382 }
|
|
|
1383 indop(e)
|
|
|
1384 int e;
|
|
|
1385 { if(type!=INT&&type!=UNSIGNED)
|
|
|
1386 if(car(type)==POINTER) type=cadr(type);
|
|
|
1387 else error(TYERR);
|
|
|
1388 else type= CHAR;
|
|
|
1389 if(car(e)==ADDRESS) return(cadr(e));
|
|
|
1390 return(list2(INDIRECT,e));
|
|
|
1391 }
|
|
|
1392 strop(e)
|
|
|
1393 { getsym();
|
|
|
1394 if (sym!=IDENT||nptr->sc!=FIELD) error(TYERR);
|
|
|
1395 if (integral(type)||car(type)!=STRUCT && car(type)!=UNION)
|
|
|
1396 e=rvalue(e);
|
|
|
1397 type = nptr->ty;
|
|
|
1398 switch(car(e))
|
|
|
1399 {case GVAR:
|
|
|
1400 case LVAR:
|
|
|
1401 e=list2(car(e),cadr(e) + nptr->dsp);
|
|
|
1402 break;
|
|
|
1403 case INDIRECT:
|
|
|
1404 if(!nptr->dsp) break;
|
|
|
1405 e=list2(INDIRECT,list3(ADD,cadr(e),list2(CONST,nptr->dsp)));
|
|
|
1406 break;
|
|
|
1407 default:
|
|
|
1408 e=list2(INDIRECT,list3(ADD,e,list2(CONST,nptr->dsp)));
|
|
|
1409 }
|
|
|
1410 getsym();
|
|
|
1411 return e;
|
|
|
1412 }
|
|
|
1413 binop(op,e1,e2,t1,t2)
|
|
|
1414 int op,e1,e2,t1,t2;
|
|
|
1415 {int e;
|
|
|
1416 if(car(e1)==CONST&&car(e2)==CONST)
|
|
|
1417 { e1=cadr(e1);
|
|
|
1418 e2=cadr(e2);
|
|
|
1419 type= INT;
|
|
|
1420 switch(op)
|
|
|
1421 {case BOR:
|
|
|
1422 e=e1|e2;break;
|
|
|
1423 case EOR:
|
|
|
1424 e=e1^e2;break;
|
|
|
1425 case BAND:
|
|
|
1426 e=e1&e2;break;
|
|
|
1427 case ADD:
|
|
|
1428 if(integral(t1))
|
|
|
1429 { if(integral(t2))
|
|
|
1430 e=e1+e2;
|
|
|
1431 else
|
|
|
1432 { if(car(t2)!=POINTER) error(TYERR);
|
|
|
1433 e=size(cadr(t2))*e1+e2;
|
|
|
1434 type=t2;
|
|
|
1435 }
|
|
|
1436 }
|
|
|
1437 else
|
|
|
1438 { if(car(t1)!=POINTER) error(TYERR);
|
|
|
1439 e=e1+size(cadr(t1))*e2;
|
|
|
1440 type=t1;
|
|
|
1441 }
|
|
|
1442 break;
|
|
|
1443 case SUB:
|
|
|
1444 if(integral(t1))
|
|
|
1445 e=e1-e2;
|
|
|
1446 else
|
|
|
1447 { if(car(t1)!=POINTER) error(TYERR);
|
|
|
1448 e=e1-size(cadr(t1))*e2;
|
|
|
1449 type=t1;
|
|
|
1450 }
|
|
|
1451 break;
|
|
|
1452 case MUL:
|
|
|
1453 e=e1*e2;break;
|
|
|
1454 case DIV:
|
|
|
1455 if(!e2) error(EXERR);e=e1/e2;break;
|
|
|
1456 case MOD:
|
|
|
1457 if(!e2) error(EXERR);e=e1%e2;break;
|
|
|
1458 case RSHIFT:
|
|
|
1459 e=e1>>e2;break;
|
|
|
1460 case LSHIFT:
|
|
|
1461 e=e1<<e2;
|
|
|
1462 }
|
|
|
1463 return list2(CONST,e);
|
|
|
1464 }
|
|
|
1465 if((op==ADD||op==MUL||op==BOR||op==EOR||op==BAND)&&
|
|
|
1466 (car(e1)==CONST||car(e2)!=CONST&&
|
|
|
1467 (car(e1)==RGVAR||car(e1)==RLVAR)))
|
|
|
1468 {e=e1;e1=e2;e2=e;e=t1;t1=t2;t2=e;}
|
|
|
1469 if(op==ADD)
|
|
|
1470 { if(integral(t1))
|
|
|
1471 { if(integral(t2))
|
|
|
1472 { if(t1==INT) type=t2;else type=t1;
|
|
|
1473 return(list3(ADD,e1,e2));
|
|
|
1474 }
|
|
|
1475 if(car(t2)!=POINTER) error(TYERR);
|
|
|
1476 e=binop(MUL,e1,list2(CONST,size(cadr(t2))),t1,INT);
|
|
|
1477 type=t2;
|
|
|
1478 return(list3(ADD,e,e2));
|
|
|
1479 }
|
|
|
1480 if(car(t1)!=POINTER||!integral(t2)) error(TYERR);
|
|
|
1481 e=binop(MUL,e2,list2(CONST,size(cadr(t1))),t2,INT);
|
|
|
1482 type=t1;
|
|
|
1483 if(car(e1)==ADDRESS&&car(e)==CONST)
|
|
|
1484 return(list2(ADDRESS,list2(car(cadr(e1)),
|
|
|
1485 cadr(cadr(e1))+cadr(e))));
|
|
|
1486 return(list3(ADD,e1,e));
|
|
|
1487 }
|
|
|
1488 if(op==SUB)
|
|
|
1489 { if(integral(t1))
|
|
|
1490 { if(!integral(t2)) error(TYERR);
|
|
|
1491 if(t1==INT) type=t2;else type=t1;
|
|
|
1492 return(list3(SUB,e1,e2));
|
|
|
1493 }
|
|
|
1494 if(car(t1)!=POINTER) error(TYERR);
|
|
|
1495 if(integral(t2))
|
|
|
1496 { e=binop(MUL,e2,list2(CONST,size(cadr(t1))),t2,INT);
|
|
|
1497 type=t1;
|
|
|
1498 return(list3(SUB,e1,e));
|
|
|
1499 }
|
|
|
1500 if(car(t2)!=POINTER)
|
|
|
1501 error(TYERR);
|
|
|
1502 compatible(t1,t2);
|
|
|
1503 e=list3(SUB,e1,e2);
|
|
|
1504 e=binop(DIV,e,list2(CONST,size(cadr(t1))),UNSIGNED,INT);
|
|
|
1505 type= INT;
|
|
|
1506 return e;
|
|
|
1507 }
|
|
|
1508 if(!integral(t1)||!integral(t2)) error(TYERR);
|
|
|
1509 if(t1==INT) type=t2;else type=t1;
|
|
|
1510 if((op==MUL||op==DIV)&&car(e2)==CONST&&cadr(e2)==1) return e1;
|
|
|
1511 if(op==BOR||op==EOR||op==BAND) return(list3(op,e1,e2));
|
|
|
1512 return(list3(type==UNSIGNED?op+US:op,e1,e2));
|
|
|
1513 }
|
|
|
1514 expr15(e1)
|
|
|
1515 int e1;
|
|
|
1516 {int t,args;
|
|
|
1517 t=type;
|
|
|
1518 if(integral(t)||car(t)!=FUNCTION)
|
|
|
1519 error(TYERR);
|
|
|
1520 t=cadr(t);
|
|
|
1521 getsym();
|
|
|
1522 args=0;
|
|
|
1523 while(sym!=RPAR)
|
|
|
1524 { args=list2(rvalue(expr1()),args);
|
|
|
1525 if(sym!=COMMA) break;
|
|
|
1526 getsym();
|
|
|
1527 }
|
|
|
1528 checksym(RPAR);
|
|
|
1529 if(t==CHAR) type= INT;else type=t;
|
|
|
1530 return list3(FUNCTION,e1,args);
|
|
|
1531 }
|
|
|
1532 typeid(s)
|
|
|
1533 int s;
|
|
|
1534 { return (integral(s) || s==SHORT || s==LONG || s==STRUCT || s==UNION ||
|
|
|
1535 (s==IDENT && nptr->sc==TYPE));
|
|
|
1536 }
|
|
|
1537 typename()
|
|
|
1538 {int t;
|
|
|
1539 type=t=typespec();
|
|
|
1540 ndecl0();
|
|
|
1541 reverse(t);
|
|
|
1542 return type;
|
|
|
1543 }
|
|
|
1544 ndecl0()
|
|
|
1545 { if(sym==MUL)
|
|
|
1546 { getsym();
|
|
|
1547 return type=list2(POINTER,ndecl0());
|
|
|
1548 }
|
|
|
1549 return ndecl1();
|
|
|
1550 }
|
|
|
1551 ndecl1()
|
|
|
1552 {int i,t;
|
|
|
1553 if(sym==LPAR)
|
|
|
1554 if(getsym()==RPAR) {type=list2(FUNCTION,type); getsym();}
|
|
|
1555 else
|
|
|
1556 { ndecl0();
|
|
|
1557 checksym(RPAR);
|
|
|
1558 }
|
|
|
1559 while(1)
|
|
|
1560 if(sym==LBRA)
|
|
|
1561 { getsym();
|
|
|
1562 t=type;
|
|
|
1563 i=cexpr(expr());
|
|
|
1564 checksym(RBRA);
|
|
|
1565 type=list3(ARRAY,t,i);
|
|
|
1566 }
|
|
|
1567 else if(sym==LPAR)
|
|
|
1568 { getsym();
|
|
|
1569 checksym(RPAR);
|
|
|
1570 type=list2(FUNCTION,type);
|
|
|
1571 }
|
|
|
1572 else return type;
|
|
|
1573 }
|
|
|
1574
|
|
|
1575 bexpr(e1,cond,l1)
|
|
|
1576 int e1,l1;
|
|
|
1577 char cond;
|
|
|
1578 {int e2,l2;
|
|
|
1579 if (chk) return;
|
|
|
1580 e2=cadr(e1);
|
|
|
1581 switch(car(e1))
|
|
|
1582 {case LNOT:
|
|
|
1583 bexpr(e2,!cond,l1);
|
|
|
1584 return;
|
|
|
1585 case GT:
|
|
|
1586 rexpr(e1,l1,cond?"GT":"LE");
|
|
|
1587 return;
|
|
|
1588 case UGT:
|
|
|
1589 rexpr(e1,l1,cond?"HI":"LS");
|
|
|
1590 return;
|
|
|
1591 case GE:
|
|
|
1592 rexpr(e1,l1,cond?"GE":"LT");
|
|
|
1593 return;
|
|
|
1594 case UGE:
|
|
|
1595 rexpr(e1,l1,cond?"HS":"LO");
|
|
|
1596 return;
|
|
|
1597 case LT:
|
|
|
1598 rexpr(e1,l1,cond?"LT":"GE");
|
|
|
1599 return;
|
|
|
1600 case ULT:
|
|
|
1601 rexpr(e1,l1,cond?"LO":"HS");
|
|
|
1602 return;
|
|
|
1603 case LE:
|
|
|
1604 rexpr(e1,l1,cond?"LE":"GT");
|
|
|
1605 return;
|
|
|
1606 case ULE:
|
|
|
1607 rexpr(e1,l1,cond?"LS":"HI");
|
|
|
1608 return;
|
|
|
1609 case EQ:
|
|
|
1610 rexpr(e1,l1,cond?"EQ":"NE");
|
|
|
1611 return;
|
|
|
1612 case NEQ:
|
|
|
1613 rexpr(e1,l1,cond?"NE":"EQ");
|
|
|
1614 return;
|
|
|
1615 case LAND:
|
|
|
1616 bexpr(e2,0,cond?(l2=fwdlabel()):l1);
|
|
|
1617 bexpr(caddr(e1),cond,l1);
|
|
|
1618 if(cond) fwddef(l2);
|
|
|
1619 return;
|
|
|
1620 case LOR:
|
|
|
1621 bexpr(e2,1,cond?l1:(l2=fwdlabel()));
|
|
|
1622 bexpr(caddr(e1),cond,l1);
|
|
|
1623 if(!cond) fwddef(l2);
|
|
|
1624 return;
|
|
|
1625 case CRGVAR:
|
|
|
1626 ldby(e2);
|
|
|
1627 jcond(l1,cond);
|
|
|
1628 return;
|
|
|
1629 case CRLVAR:
|
|
|
1630 ldbu(e2);
|
|
|
1631 jcond(l1,cond);
|
|
|
1632 return;
|
|
|
1633 case CONST:
|
|
|
1634 if(cond&&e2||!cond&&!e2) jmp(l1);
|
|
|
1635 return;
|
|
|
1636 case RGVAR:
|
|
|
1637 case RLVAR:
|
|
|
1638 case CRINDIRECT:
|
|
|
1639 gexpr(e1);
|
|
|
1640 jcond(l1,cond);
|
|
|
1641 return;
|
|
|
1642 default:gexpr(e1);
|
|
|
1643 subdim(0);
|
|
|
1644 jcond(l1,cond);
|
|
|
1645 return;
|
|
|
1646 }
|
|
|
1647 }
|
|
|
1648 rexpr(e1,l1,s)
|
|
|
1649 int e1,l1;
|
|
|
1650 char *s;
|
|
|
1651 { gexpr(list3(SUB,cadr(e1),caddr(e1)));
|
|
|
1652 printf("\tLB%s\t_%d\n",s,l1);
|
|
|
1653 }
|
|
|
1654 jcond(l,cond)
|
|
|
1655 int l;
|
|
|
1656 char cond;
|
|
|
1657 { printf("\tLB%s\t_%d\n",cond?"NE":"EQ",l);
|
|
|
1658 }
|
|
|
1659 jmp(l)
|
|
|
1660 int l;
|
|
|
1661 { control=0;
|
|
|
1662 printf("\tLBRA\t_%d\n",l);
|
|
|
1663 }
|
|
|
1664 fwdlabel()
|
|
|
1665 { return labelno++;
|
|
|
1666 }
|
|
|
1667 fwddef(l)
|
|
|
1668 int l;
|
|
|
1669 { control=1;
|
|
|
1670 printf("_%d\n",l);
|
|
|
1671 }
|
|
|
1672 backdef()
|
|
|
1673 { control=1;
|
|
|
1674 printf("_%d\n",labelno);
|
|
|
1675 return labelno++;
|
|
|
1676 }
|
|
|
1677
|
|
|
1678 gexpr(e1)
|
|
|
1679 int e1;
|
|
|
1680 {int e2,e3;
|
|
|
1681 if (chk) return;
|
|
|
1682 e2 = cadr(e1);
|
|
|
1683 switch (car(e1))
|
|
|
1684 {case GVAR:
|
|
|
1685 leaxy(e2);
|
|
|
1686 return;
|
|
|
1687 case RGVAR:
|
|
|
1688 lddy(e2);
|
|
|
1689 return;
|
|
|
1690 case CRGVAR:
|
|
|
1691 ldby(e2);
|
|
|
1692 sex();
|
|
|
1693 return;
|
|
|
1694 case LVAR:
|
|
|
1695 leaxu(e2);
|
|
|
1696 return;
|
|
|
1697 case RLVAR:
|
|
|
1698 lddu(e2);
|
|
|
1699 return;
|
|
|
1700 case CRLVAR:
|
|
|
1701 ldbu(e2);
|
|
|
1702 sex();
|
|
|
1703 return;
|
|
|
1704 case FNAME:
|
|
|
1705 leaxpcr((NMTBL *)e2);
|
|
|
1706 tfrxd();
|
|
|
1707 return;
|
|
|
1708 case CONST:
|
|
|
1709 if (e2) lddim(e2);
|
|
|
1710 else clrd();
|
|
|
1711 return;
|
|
|
1712 case STRING:
|
|
|
1713 string(e1);
|
|
|
1714 return;
|
|
|
1715 case FUNCTION:
|
|
|
1716 function(e1);
|
|
|
1717 return;
|
|
|
1718 case INDIRECT:
|
|
|
1719 indirect(e1);
|
|
|
1720 return;
|
|
|
1721 case RINDIRECT: case CRINDIRECT:
|
|
|
1722 rindirect(e1);
|
|
|
1723 return;
|
|
|
1724 case ADDRESS:
|
|
|
1725 gexpr(e2);
|
|
|
1726 tfrxd();
|
|
|
1727 return;
|
|
|
1728 case MINUS:
|
|
|
1729 gexpr(e2);
|
|
|
1730 printf("\tNEGA\n\tNEGB\n\tSBCA\t#0\n");
|
|
|
1731 return;
|
|
|
1732 case BNOT:
|
|
|
1733 gexpr(e2);
|
|
|
1734 printf("\tCOMA\n\tCOMB\n");
|
|
|
1735 return;
|
|
|
1736 case PREINC:
|
|
|
1737 switch (car(e2))
|
|
|
1738 {case GVAR: case LVAR:
|
|
|
1739 ldd(e2);
|
|
|
1740 adddim(caddr(e1));
|
|
|
1741 std(e2);
|
|
|
1742 return;
|
|
|
1743 default:
|
|
|
1744 gexpr(e2);
|
|
|
1745 lddx();
|
|
|
1746 adddim(caddr(e1));
|
|
|
1747 stdx();
|
|
|
1748 return;
|
|
|
1749 }
|
|
|
1750 case POSTINC:
|
|
|
1751 switch (car(e2))
|
|
|
1752 {case GVAR: case LVAR:
|
|
|
1753 ldd(e2);
|
|
|
1754 adddim(e3 = caddr(e1));
|
|
|
1755 std(e2);
|
|
|
1756 subdim(e3);
|
|
|
1757 return;
|
|
|
1758 default:
|
|
|
1759 gexpr(e2);
|
|
|
1760 lddx();
|
|
|
1761 adddim(e3=caddr(e1));
|
|
|
1762 stdx();
|
|
|
1763 subdim(e3);
|
|
|
1764 return;
|
|
|
1765 }
|
|
|
1766 case CPOSTINC:
|
|
|
1767 gexpr(e2);
|
|
|
1768 ldbx();
|
|
|
1769 incx();
|
|
|
1770 sex();
|
|
|
1771 return;
|
|
|
1772 case CPREINC:
|
|
|
1773 gexpr(e2);
|
|
|
1774 incx();
|
|
|
1775 ldbx();
|
|
|
1776 sex();
|
|
|
1777 return;
|
|
|
1778 case CPOSTDEC:
|
|
|
1779 gexpr(e2);
|
|
|
1780 ldbx();
|
|
|
1781 decx();
|
|
|
1782 sex();
|
|
|
1783 return;
|
|
|
1784 case CPREDEC:
|
|
|
1785 gexpr(e2);
|
|
|
1786 decx();
|
|
|
1787 ldbx();
|
|
|
1788 sex();
|
|
|
1789 return;
|
|
|
1790 case MUL: case UMUL:
|
|
|
1791 if (car(e3=caddr(e1)) == CONST)
|
|
|
1792 { if (0 < (e3 = cadr(e3)) && e3 <= 10)
|
|
|
1793 { gexpr(e2);
|
|
|
1794 switch (e3)
|
|
|
1795 {case 8:
|
|
|
1796 asld();
|
|
|
1797 case 4:
|
|
|
1798 asld();
|
|
|
1799 case 2:
|
|
|
1800 asld();
|
|
|
1801 case 1:
|
|
|
1802 return;
|
|
|
1803 case 10:
|
|
|
1804 asld();
|
|
|
1805 case 5:
|
|
|
1806 pushd();
|
|
|
1807 asld();
|
|
|
1808 asld();
|
|
|
1809 addds();
|
|
|
1810 return;
|
|
|
1811 case 6:
|
|
|
1812 asld();
|
|
|
1813 case 3:
|
|
|
1814 pushd();
|
|
|
1815 asld();
|
|
|
1816 addds();
|
|
|
1817 return;
|
|
|
1818 case 9: case 7:
|
|
|
1819 pushd();
|
|
|
1820 asld();
|
|
|
1821 asld();
|
|
|
1822 asld();
|
|
|
1823 if (e3 == 9) addds(); else subds();
|
|
|
1824 return;
|
|
|
1825 }
|
|
|
1826 }
|
|
|
1827 }
|
|
|
1828 case DIV: case UDIV: case MOD: case UMOD:
|
|
|
1829 case LSHIFT: case ULSHIFT: case RSHIFT: case URSHIFT:
|
|
|
1830 binexpr(e1);
|
|
|
1831 return;
|
|
|
1832 case ADD: case SUB: case BAND: case EOR: case BOR:
|
|
|
1833 machinop(e1);
|
|
|
1834 return;
|
|
|
1835 case COND:
|
|
|
1836 e2=fwdlabel();
|
|
|
1837 bexpr(cadr(e1),0,e2);
|
|
|
1838 gexpr(caddr(e1));
|
|
|
1839 jmp(e3=fwdlabel());
|
|
|
1840 fwddef(e2);
|
|
|
1841 gexpr(cadddr(e1));
|
|
|
1842 fwddef(e3);
|
|
|
1843 return;
|
|
|
1844 case ASS: case CASS:
|
|
|
1845 assign(e1);
|
|
|
1846 return;
|
|
|
1847 case ASSOP: case CASSOP:
|
|
|
1848 assop(e1);
|
|
|
1849 return;
|
|
|
1850 case COMMA:
|
|
|
1851 gexpr(e2);
|
|
|
1852 gexpr(caddr(e1));
|
|
|
1853 return;
|
|
|
1854 default:
|
|
|
1855 bexpr(e1,1,e2=fwdlabel());
|
|
|
1856 clrd();
|
|
|
1857 printf("\tBRA\t*+5\n");
|
|
|
1858 fwddef(e2);
|
|
|
1859 lddim(1);
|
|
|
1860 }
|
|
|
1861 }
|
|
|
1862 string(e1)
|
|
|
1863 int e1;
|
|
|
1864 {char *s;
|
|
|
1865 int i,l,lb;
|
|
|
1866 s=(char *)cadr(e1);
|
|
|
1867 lb=fwdlabel();
|
|
|
1868 if ((l = caddr(e1)) < 128)
|
|
105
|
1869 printf("\tLEAX\t*+5,PCR\n\tBRA\t_%d\n",lb);
|
|
99
|
1870 else
|
|
105
|
1871 printf("\tLEAX\t*+6,PCR\n\tLBRA\t_%d\n",lb);
|
|
99
|
1872 do
|
|
|
1873 { printf("\tFCB\t%d",*s++);
|
|
|
1874 for (i=8; --l && --i;) printf(",%d",*s++);
|
|
|
1875 printf("\n");
|
|
|
1876 }
|
|
|
1877 while (l);
|
|
|
1878 fwddef(lb);
|
|
|
1879 }
|
|
|
1880 function(e1)
|
|
|
1881 int e1;
|
|
|
1882 {int e2,e3,e4,e5,nargs;
|
|
|
1883 NMTBL *n;
|
|
|
1884 e2 = cadr(e1);
|
|
|
1885 nargs = 0;
|
|
|
1886 for (e3 = caddr(e1); e3; e3 = cadr(e3))
|
|
|
1887 { n=(NMTBL *)(e5=(cadr(e4 = car(e3))));
|
|
|
1888 switch(car(e4))
|
|
|
1889 {case FNAME:
|
|
|
1890 leaxpcr(n);
|
|
|
1891 pushx();
|
|
|
1892 break;
|
|
|
1893 case ADDRESS:
|
|
|
1894 gexpr(e5);
|
|
|
1895 pushx();
|
|
|
1896 break;
|
|
|
1897 default:gexpr(e4);
|
|
|
1898 pushd();
|
|
|
1899 }
|
|
|
1900 ++nargs;
|
|
|
1901 }
|
|
|
1902 if (car(e2) == FNAME)
|
|
|
1903 { n=(NMTBL *)cadr(e2);
|
|
|
1904 printf("\tLBSR\t%s\n",n->nm);
|
|
|
1905 }
|
|
|
1906 else
|
|
|
1907 { gexpr(e2);
|
|
|
1908 printf("\tJSR\t,X\n");
|
|
|
1909 }
|
|
|
1910 if (nargs) printf("\tLEAS\t%d,S\n",2*nargs);
|
|
|
1911 }
|
|
|
1912 indirect(e1)
|
|
|
1913 int e1;
|
|
|
1914 {int e2,e3,e4;
|
|
|
1915 e3 = cadr(e2 = cadr(e1));
|
|
|
1916 switch(car(e2))
|
|
|
1917 {case RGVAR: case RLVAR:
|
|
|
1918 ldx(e2);
|
|
|
1919 return;
|
|
|
1920 case ADD:
|
|
|
1921 if(car(e3)==ADDRESS)
|
|
|
1922 { gexpr(caddr(e2));
|
|
|
1923 gexpr(cadr(e3));
|
|
|
1924 opdx("LEAX");
|
|
|
1925 return;
|
|
|
1926 }
|
|
|
1927 switch(car(e4 = caddr(e2)))
|
|
|
1928 {case RGVAR: case RLVAR:
|
|
|
1929 gexpr(e3);
|
|
|
1930 ldx(e4);
|
|
|
1931 opdx("LEAX");
|
|
|
1932 return;
|
|
|
1933 }
|
|
|
1934 default:
|
|
|
1935 gexpr(e2);
|
|
|
1936 tfrdx();
|
|
|
1937 }
|
|
|
1938 }
|
|
|
1939
|
|
|
1940 machinop(e1)
|
|
|
1941 int e1;
|
|
|
1942 {int e2,e3;
|
|
|
1943 e2 = cadr(e1);
|
|
|
1944 switch (car(e3 = caddr(e1)))
|
|
|
1945 {case RGVAR: case RLVAR: case CONST:
|
|
|
1946 gexpr(e2);
|
|
|
1947 oprt(car(e1),e3);
|
|
|
1948 return;
|
|
|
1949 default:
|
|
|
1950 gexpr(e3);
|
|
|
1951 pushd();
|
|
|
1952 gexpr(e2);
|
|
|
1953 tosop(car(e1));
|
|
|
1954 return;
|
|
|
1955 }
|
|
|
1956 }
|
|
|
1957
|
|
|
1958 rindirect(e1)
|
|
|
1959 int e1;
|
|
|
1960 {char *op;
|
|
|
1961 int e2,e3,e4,byte,l;
|
|
|
1962 op = ((byte = (car(e1) == CRINDIRECT)) ? "LDB" : "LDD");
|
|
|
1963 e3 = cadr(e2 = cadr(e1));
|
|
|
1964 switch (car(e2))
|
|
|
1965 {case RGVAR: case RLVAR:
|
|
|
1966 indir(op,e2);
|
|
|
1967 sextend(byte);
|
|
|
1968 return;
|
|
|
1969 case ADD:
|
|
|
1970 if(car(e3)==ADDRESS)
|
|
|
1971 { gexpr(caddr(e2));
|
|
|
1972 gexpr(cadr(e3));
|
|
|
1973 opdx(op);
|
|
|
1974 sextend(byte);
|
|
|
1975 return;
|
|
|
1976 }
|
|
|
1977 switch(car(e4=caddr(e2)))
|
|
|
1978 {case RGVAR: case RLVAR:
|
|
|
1979 gexpr(e3);
|
|
|
1980 ldx(e4);
|
|
|
1981 opdx(op);
|
|
|
1982 sextend(byte);
|
|
|
1983 return;
|
|
|
1984 case CONST:
|
|
|
1985 switch (car(e3))
|
|
|
1986 {case RGVAR: case RLVAR:
|
|
|
1987 ldx(e3);
|
|
|
1988 indexx(op,cadr(e4));
|
|
|
1989 sextend(byte);
|
|
|
1990 return;
|
|
|
1991 }
|
|
|
1992 default:
|
|
|
1993 gexpr(e3);
|
|
|
1994 pushd();
|
|
|
1995 gexpr(e4);
|
|
|
1996 pulx();
|
|
|
1997 opdx(op);
|
|
|
1998 sextend(byte);
|
|
|
1999 return;
|
|
|
2000 }
|
|
|
2001 case PREINC:
|
|
|
2002 if ((l = caddr(e2)) == -1 || l == -2)
|
|
|
2003 switch (car(e3))
|
|
|
2004 {case GVAR: case LVAR:
|
|
|
2005 ldx(e3);
|
|
|
2006 predecx(op,l);
|
|
|
2007 stx(e3);
|
|
|
2008 sextend(byte);
|
|
|
2009 return;
|
|
|
2010 }
|
|
|
2011 break;
|
|
|
2012 case POSTINC:
|
|
|
2013 if ((l = caddr(e2)) == 1 || l == 2)
|
|
|
2014 switch (car(e3))
|
|
|
2015 {case GVAR: case LVAR:
|
|
|
2016 ldx(e3);
|
|
|
2017 postincx(op,l);
|
|
|
2018 stx(e3);
|
|
|
2019 sextend(byte);
|
|
|
2020 return;
|
|
|
2021 }
|
|
|
2022 break;
|
|
|
2023 }
|
|
|
2024 gexpr(e2);
|
|
|
2025 tfrdx();
|
|
|
2026 indexx(op,0);
|
|
|
2027 sextend(byte);
|
|
|
2028 }
|
|
|
2029 assign(e1)
|
|
|
2030 int e1;
|
|
|
2031 {char *op;
|
|
|
2032 int e2,e3,e4,e5,l;
|
|
|
2033 op = (car(e1) == CASS ? "STB" : "STD");
|
|
|
2034 e3 = cadr(e2 = cadr(e1));
|
|
|
2035 e4 = caddr(e1);
|
|
|
2036 switch(car(e2))
|
|
|
2037 {case GVAR: case LVAR:
|
|
|
2038 gexpr(e4);
|
|
|
2039 index(op,e2);
|
|
|
2040 return;
|
|
|
2041 case INDIRECT:
|
|
|
2042 switch(car(e3))
|
|
|
2043 {case RGVAR: case RLVAR:
|
|
|
2044 gexpr(e4);
|
|
|
2045 indir(op,e3);
|
|
|
2046 return;
|
|
|
2047 case ADD:
|
|
|
2048 if (car(caddr(e3)) == CONST)
|
|
|
2049 switch (car(e5=cadr(e3)))
|
|
|
2050 {case RGVAR: case RLVAR:
|
|
|
2051 gexpr(e4);
|
|
|
2052 ldx(e5);
|
|
|
2053 indexx(op,cadr(caddr(e3)));
|
|
|
2054 return;
|
|
|
2055 }
|
|
|
2056 break;
|
|
|
2057 case PREINC:
|
|
|
2058 if ((l = caddr(e3)) == -1 || l == -2)
|
|
|
2059 switch (car(e5=cadr(e3)))
|
|
|
2060 {case GVAR: case LVAR:
|
|
|
2061 gexpr(e4);
|
|
|
2062 ldx(e5);
|
|
|
2063 predecx(op,l);
|
|
|
2064 stx(e5);
|
|
|
2065 return;
|
|
|
2066 }
|
|
|
2067 break;
|
|
|
2068 case POSTINC:
|
|
|
2069 if ((l = caddr(e3)) == 1 || l == 2)
|
|
|
2070 switch (car(e5=cadr(e3)))
|
|
|
2071 {case GVAR: case LVAR:
|
|
|
2072 gexpr(e4);
|
|
|
2073 ldx(e5);
|
|
|
2074 postincx(op,l);
|
|
|
2075 stx(e5);
|
|
|
2076 return;
|
|
|
2077 }
|
|
|
2078 break;
|
|
|
2079 }
|
|
|
2080 }
|
|
|
2081 switch (car(e4))
|
|
|
2082 {case RGVAR: case CRGVAR: case RLVAR: case CRLVAR: case CONST:
|
|
|
2083 gexpr(e2);
|
|
|
2084 gexpr(e4);
|
|
|
2085 break;
|
|
|
2086 default:
|
|
|
2087 gexpr(e4);
|
|
|
2088 pushd();
|
|
|
2089 gexpr(e2);
|
|
|
2090 pulld();
|
|
|
2091 }
|
|
|
2092 indexx(op,0);
|
|
|
2093 return;
|
|
|
2094 }
|
|
|
2095 assop(e1)
|
|
|
2096 int e1;
|
|
|
2097 {int e2,e3,byte,op;
|
|
|
2098 char *ldop,*stop;
|
|
|
2099 ldop = ((byte = (car(e1) == CASSOP)) ? "LDB" : "LDD");
|
|
|
2100 stop = (byte ? "STB" : "STD");
|
|
|
2101 e2 = cadr(e1);
|
|
|
2102 e3 = caddr(e1);
|
|
|
2103 op = cadddr(e1);
|
|
|
2104 switch (car(e2))
|
|
|
2105 {case GVAR: case LVAR:
|
|
|
2106 switch (car(e3))
|
|
|
2107 {case RGVAR: case RLVAR: case CONST:
|
|
|
2108 if (simpop(op))
|
|
|
2109 { index(ldop,e2);
|
|
|
2110 sextend(byte);
|
|
|
2111 oprt(op,e3);
|
|
|
2112 index(stop,e2);
|
|
|
2113 return;
|
|
|
2114 }
|
|
|
2115 default:
|
|
|
2116 gexpr(e3);
|
|
|
2117 pushd();
|
|
|
2118 index(ldop,e2);
|
|
|
2119 sextend(byte);
|
|
|
2120 tosop(op);
|
|
|
2121 index(stop,e2);
|
|
|
2122 return;
|
|
|
2123 }
|
|
|
2124 default:
|
|
|
2125 switch (car(e3))
|
|
|
2126 {case RGVAR: case RLVAR: case CONST:
|
|
|
2127 if (simpop(op))
|
|
|
2128 { gexpr(e2);
|
|
|
2129 indexx(ldop,0);
|
|
|
2130 sextend(byte);
|
|
|
2131 oprt(op,e3);
|
|
|
2132 indexx(stop,0);
|
|
|
2133 return;
|
|
|
2134 }
|
|
|
2135 default:
|
|
|
2136 gexpr(e3);
|
|
|
2137 pushd();
|
|
|
2138 gexpr(e2);
|
|
|
2139 indexx(ldop,0);
|
|
|
2140 sextend(byte);
|
|
|
2141 tosop(op);
|
|
|
2142 indexx(stop,0);
|
|
|
2143 return;
|
|
|
2144 }
|
|
|
2145 }
|
|
|
2146 }
|
|
|
2147 simpop(op)
|
|
|
2148 int op;
|
|
|
2149 { return (op == ADD || op == SUB ||
|
|
|
2150 op == BAND || op == EOR || op == BOR);
|
|
|
2151 }
|
|
|
2152 oprt(op,e1)
|
|
|
2153 int op,e1;
|
|
|
2154 {int e2;
|
|
|
2155 e2 = cadr(e1);
|
|
|
2156 switch (car(e1))
|
|
|
2157 {case RGVAR:
|
|
|
2158 oprt1(op,"Y",e2);
|
|
|
2159 return;
|
|
|
2160 case RLVAR:
|
|
|
2161 oprt1(op,"U",e2);
|
|
|
2162 return;
|
|
|
2163 case CONST:
|
|
|
2164 oprtc(op,e2);
|
|
|
2165 return;
|
|
|
2166 }
|
|
|
2167 }
|
|
|
2168 oprt1(op,index,n)
|
|
|
2169 int op,n;
|
|
|
2170 char *index;
|
|
|
2171 { switch (op)
|
|
|
2172 {case ADD:
|
|
|
2173 printf("\tADDD\t%d,%s\n",n,index);
|
|
|
2174 return;
|
|
|
2175 case SUB:
|
|
|
2176 printf("\tSUBD\t%d,%s\n",n,index);
|
|
|
2177 return;
|
|
|
2178 case BAND: case EOR: case BOR:
|
|
|
2179 dualop(op,index,n);
|
|
|
2180 return;
|
|
|
2181 }
|
|
|
2182 }
|
|
|
2183 dualop(op,index,n)
|
|
|
2184 int op;
|
|
|
2185 char *index;
|
|
|
2186 int n;
|
|
|
2187 {char *ops;
|
|
|
2188 ops = ((op == BAND) ? "AND" :
|
|
|
2189 (op == EOR) ? "EOR" :
|
|
|
2190 (op == BOR) ? "OR" : (char *)DEBUG);
|
|
|
2191 printf("\t%sA\t%d,%s\n\t%sB\t%d+1,%s\n",ops,n,index,ops,n,index);
|
|
|
2192 }
|
|
|
2193
|
|
|
2194 oprtc(op,n)
|
|
|
2195 int op,n;
|
|
|
2196 { switch (op)
|
|
|
2197 {case ADD:
|
|
|
2198 adddim(n);
|
|
|
2199 return;
|
|
|
2200 case SUB:
|
|
|
2201 subdim(n);
|
|
|
2202 return;
|
|
|
2203 case BAND: case EOR: case BOR:
|
|
|
2204 dualc(op,n);
|
|
|
2205 return;
|
|
|
2206 }
|
|
|
2207 }
|
|
|
2208 dualc(op,n)
|
|
|
2209 int op;
|
|
|
2210 int n;
|
|
|
2211 {char *ops;
|
|
|
2212 ops = ((op == BAND) ? "AND" :
|
|
|
2213 (op == EOR) ? "EOR" :
|
|
|
2214 (op == BOR) ? "OR" : (char *)DEBUG);
|
|
|
2215 printf("\t%sA\t#%d\n\t%sB\t#%d\n",ops,(n >> 8) & 0xff,ops,n & 0xff);
|
|
|
2216 }
|
|
|
2217 tosop(op)
|
|
|
2218 int op;
|
|
|
2219 { switch (op)
|
|
|
2220 {case ADD:
|
|
|
2221 addds();
|
|
|
2222 return;
|
|
|
2223 case SUB:
|
|
|
2224 subds();
|
|
|
2225 return;
|
|
|
2226 case BAND: case EOR: case BOR:
|
|
|
2227 dualtosop(op);
|
|
|
2228 return;
|
|
|
2229 default:
|
|
|
2230 pulx();
|
|
|
2231 library(op);
|
|
|
2232 }
|
|
|
2233 }
|
|
|
2234 dualtosop(op)
|
|
|
2235 int op;
|
|
|
2236 {char *ops;
|
|
|
2237 ops = ((op == BAND) ? "AND" :
|
|
|
2238 (op == EOR) ? "EOR" :
|
|
|
2239 (op == BOR) ? "OR" : (char *)DEBUG);
|
|
|
2240 printf("\t%sA\t,S+\n\t%sB\t,S+\n",ops,ops);
|
|
|
2241 }
|
|
|
2242 pushd()
|
|
|
2243 { printf("\tPSHS\tD\n");
|
|
|
2244 }
|
|
|
2245 pushx()
|
|
|
2246 { printf("\tPSHS\tX\n");
|
|
|
2247 }
|
|
|
2248 pulld()
|
|
|
2249 { printf("\tPULS\tD\n");
|
|
|
2250 }
|
|
|
2251 pulx()
|
|
|
2252 { printf("\tPULS\tX\n");
|
|
|
2253 }
|
|
|
2254 tfrdx()
|
|
|
2255 { printf("\tTFR\tD,X\n");
|
|
|
2256 }
|
|
|
2257 tfrxd()
|
|
|
2258 { printf("\tTFR\tX,D\n");
|
|
|
2259 }
|
|
|
2260 /*
|
|
|
2261 exgdx()
|
|
|
2262 { printf("\tEXG\tD,X\n");
|
|
|
2263 }
|
|
|
2264 */
|
|
|
2265 asld()
|
|
|
2266 { printf("\tASLB\n\tROLA\n");
|
|
|
2267 }
|
|
|
2268 adddim(n)
|
|
|
2269 { printf("\tADDD\t#%d\n",n);
|
|
|
2270 }
|
|
|
2271 subdim(n)
|
|
|
2272 { printf("\tSUBD\t#%d\n",n);
|
|
|
2273 }
|
|
|
2274 cmpdimm(n)
|
|
|
2275 int n;
|
|
|
2276 { printf("\tCMPD\t#%d\n",n);
|
|
|
2277 }
|
|
|
2278 addds()
|
|
|
2279 { printf("\tADDD\t,S++\n");
|
|
|
2280 }
|
|
|
2281 subds()
|
|
|
2282 { printf("\tSUBD\t,S++\n");
|
|
|
2283 }
|
|
|
2284 clrd()
|
|
|
2285 { printf("\tCLRA\n\tCLRB\n");
|
|
|
2286 }
|
|
|
2287 lddim(n)
|
|
|
2288 int n;
|
|
|
2289 { printf("\tLDD\t#%d\n",n);
|
|
|
2290 }
|
|
|
2291
|
|
|
2292 ldd(e)
|
|
|
2293 int e;
|
|
|
2294 { switch (car(e))
|
|
|
2295 {case GVAR:
|
|
|
2296 lddy(cadr(e));
|
|
|
2297 return;
|
|
|
2298 case LVAR:
|
|
|
2299 lddu(cadr(e));
|
|
|
2300 return;
|
|
|
2301 default:
|
|
|
2302 DEBUG;
|
|
|
2303 }
|
|
|
2304 }
|
|
|
2305
|
|
|
2306 lddx()
|
|
|
2307 { printf("\tLDD\t,X\n");
|
|
|
2308 }
|
|
|
2309 lddy(n)
|
|
|
2310 int n;
|
|
|
2311 { printf("\tLDD\t%d,Y\n",n);
|
|
|
2312 }
|
|
|
2313 lddu(n)
|
|
|
2314 int n;
|
|
|
2315 { printf("\tLDD\t%d,U\n",n);
|
|
|
2316 }
|
|
|
2317
|
|
|
2318 std(e)
|
|
|
2319 int e;
|
|
|
2320 { switch (car(e))
|
|
|
2321 {case GVAR:
|
|
|
2322 stdy(cadr(e));
|
|
|
2323 return;
|
|
|
2324 case LVAR:
|
|
|
2325 stdu(cadr(e));
|
|
|
2326 return;
|
|
|
2327 default:
|
|
|
2328 DEBUG;
|
|
|
2329 }
|
|
|
2330 }
|
|
|
2331 stdx()
|
|
|
2332 { printf("\tSTD\t,X\n");
|
|
|
2333 }
|
|
|
2334 stdy(n)
|
|
|
2335 int n;
|
|
|
2336 { printf("\tSTD\t%d,Y\n",n);
|
|
|
2337 }
|
|
|
2338 stdu(n)
|
|
|
2339 int n;
|
|
|
2340 { printf("\tSTD\t%d,U\n",n);
|
|
|
2341 }
|
|
|
2342
|
|
|
2343 ldbx()
|
|
|
2344 { printf("\tLDB\t,X\n");
|
|
|
2345 }
|
|
|
2346 /*
|
|
|
2347 stbx()
|
|
|
2348 { printf("\tSTB\t,X\n");
|
|
|
2349 }
|
|
|
2350 */
|
|
|
2351 ldby(n)
|
|
|
2352 int n;
|
|
|
2353 { printf("\tLDB\t%d,Y\n",n);
|
|
|
2354 }
|
|
|
2355 ldbu(n)
|
|
|
2356 int n;
|
|
|
2357 { printf("\tLDB\t%d,U\n",n);
|
|
|
2358 }
|
|
|
2359 predecx(op,l)
|
|
|
2360 char *op;
|
|
|
2361 int l;
|
|
|
2362 { printf("\t%s\t,%sX\n",op,(l == -1 ? "-" : "--"));
|
|
|
2363 }
|
|
|
2364 postincx(op,l)
|
|
|
2365 char *op;
|
|
|
2366 int l;
|
|
|
2367 { printf("\t%s\t,X%s\n",op,(l == 1 ? "+" : "++"));
|
|
|
2368 }
|
|
|
2369 leaxy(n)
|
|
|
2370 int n;
|
|
|
2371 { printf("\tLEAX\t%d,Y\n",n);
|
|
|
2372 }
|
|
|
2373 leaxu(n)
|
|
|
2374 int n;
|
|
|
2375 { printf("\tLEAX\t%d,U\n",n);
|
|
|
2376 }
|
|
|
2377 leaxpcr(n)
|
|
|
2378 NMTBL *n;
|
|
|
2379 { printf("\tLEAX\t%s,PCR\n",n->nm);
|
|
|
2380 }
|
|
|
2381
|
|
|
2382 ldx(e)
|
|
|
2383 int e;
|
|
|
2384 { switch (car(e))
|
|
|
2385 {case GVAR: case RGVAR:
|
|
|
2386 ldxy(cadr(e));
|
|
|
2387 return;
|
|
|
2388 case LVAR: case RLVAR:
|
|
|
2389 ldxu(cadr(e));
|
|
|
2390 return;
|
|
|
2391 default:
|
|
|
2392 DEBUG;
|
|
|
2393 }
|
|
|
2394 }
|
|
|
2395
|
|
|
2396 ldxy(n)
|
|
|
2397 int n;
|
|
|
2398 { printf("\tLDX\t%d,Y\n",n);
|
|
|
2399 }
|
|
|
2400 ldxu(n)
|
|
|
2401 int n;
|
|
|
2402 { printf("\tLDX\t%d,U\n",n);
|
|
|
2403 }
|
|
|
2404 /*
|
|
|
2405 ldxi(n)
|
|
|
2406 int n;
|
|
|
2407 { printf("\tLDX\t#%d\n",n);
|
|
|
2408 }
|
|
|
2409 */
|
|
|
2410 stx(e)
|
|
|
2411 int e;
|
|
|
2412 { switch (car(e))
|
|
|
2413 {case GVAR:
|
|
|
2414 stxy(cadr(e));
|
|
|
2415 return;
|
|
|
2416 case LVAR:
|
|
|
2417 stxu(cadr(e));
|
|
|
2418 return;
|
|
|
2419 default:
|
|
|
2420 DEBUG;
|
|
|
2421 }
|
|
|
2422 }
|
|
|
2423
|
|
|
2424 stxy(n)
|
|
|
2425 int n;
|
|
|
2426 { printf("\tSTX\t%d,Y\n",n);
|
|
|
2427 }
|
|
|
2428 stxu(n)
|
|
|
2429 int n;
|
|
|
2430 { printf("\tSTX\t%d,U\n",n);
|
|
|
2431 }
|
|
|
2432
|
|
|
2433 sex()
|
|
|
2434 { printf("\tSEX\n");
|
|
|
2435 }
|
|
|
2436 incx()
|
|
|
2437 { printf("\tINC\t,X\n");
|
|
|
2438 }
|
|
|
2439 decx()
|
|
|
2440 { printf("\tDEC\t,X\n");
|
|
|
2441 }
|
|
|
2442 opdx(op)
|
|
|
2443 char *op;
|
|
|
2444 { printf("\t%s\tD,X\n",op);
|
|
|
2445 }
|
|
|
2446 indexx(op,n)
|
|
|
2447 char *op;
|
|
|
2448 int n;
|
|
|
2449 { printf("\t%s\t%d,X\n",op,n);
|
|
|
2450 }
|
|
|
2451
|
|
|
2452 index(op,e)
|
|
|
2453 char *op;
|
|
|
2454 int e;
|
|
|
2455 { switch (car(e))
|
|
|
2456 {case GVAR:
|
|
|
2457 indexy(op,cadr(e));
|
|
|
2458 return;
|
|
|
2459 case LVAR:
|
|
|
2460 indexu(op,cadr(e));
|
|
|
2461 return;
|
|
|
2462 default:
|
|
|
2463 DEBUG;
|
|
|
2464 }
|
|
|
2465 }
|
|
|
2466
|
|
|
2467 indexy(op,n)
|
|
|
2468 char *op;
|
|
|
2469 int n;
|
|
|
2470 { printf("\t%s\t%d,Y\n",op,n);
|
|
|
2471 }
|
|
|
2472 indexu(op,n)
|
|
|
2473 char *op;
|
|
|
2474 int n;
|
|
|
2475 { printf("\t%s\t%d,U\n",op,n);
|
|
|
2476 }
|
|
|
2477
|
|
|
2478
|
|
|
2479 indir(op,e)
|
|
|
2480 char *op;
|
|
|
2481 int e;
|
|
|
2482 { switch (car(e))
|
|
|
2483 {case RGVAR:
|
|
|
2484 indiry(op,cadr(e));
|
|
|
2485 return;
|
|
|
2486 case RLVAR:
|
|
|
2487 indiru(op,cadr(e));
|
|
|
2488 return;
|
|
|
2489 default:
|
|
|
2490 DEBUG;
|
|
|
2491 }
|
|
|
2492 }
|
|
|
2493
|
|
|
2494 indiry(op,n)
|
|
|
2495 char *op;
|
|
|
2496 int n;
|
|
|
2497 { printf("\t%s\t[%d,Y]\n",op,n);
|
|
|
2498 }
|
|
|
2499 indiru(op,n)
|
|
|
2500 char *op;
|
|
|
2501 int n;
|
|
|
2502 { printf("\t%s\t[%d,U]\n",op,n);
|
|
|
2503 }
|
|
|
2504 sextend(byte)
|
|
|
2505 int byte;
|
|
|
2506 { if (byte) sex();
|
|
|
2507 }
|
|
|
2508 binexpr(e1)
|
|
|
2509 int e1;
|
|
|
2510 { gexpr(caddr(e1));
|
|
|
2511 pushd();
|
|
|
2512 gexpr(cadr(e1));
|
|
|
2513 pulx();
|
|
|
2514 library(car(e1));
|
|
|
2515 }
|
|
|
2516 library(op)
|
|
|
2517 int op;
|
|
|
2518 { printf("\tLBSR\t_0000%d\n",
|
|
|
2519 ((op == MUL || op == UMUL) ? 1 :
|
|
|
2520 (op == DIV) ? 2 :
|
|
|
2521 (op == UDIV) ? 3 :
|
|
|
2522 (op == MOD) ? 4 :
|
|
|
2523 (op == UMOD) ? 5 :
|
|
|
2524 (op == LSHIFT) ? 6 :
|
|
|
2525 (op == ULSHIFT) ? 7 :
|
|
|
2526 (op == RSHIFT) ? 8 :
|
|
|
2527 (op == URSHIFT) ? 9 : DEBUG));
|
|
|
2528 }
|
|
|
2529 cexpr(e)
|
|
|
2530 int e;
|
|
|
2531 { if (car(e) != CONST) error(CNERR);
|
|
|
2532 return (cadr(e));
|
|
|
2533 }
|
|
|
2534
|
|
|
2535 getsym()
|
|
|
2536 {NMTBL *nptr0,*nptr1;
|
|
|
2537 int i;
|
|
|
2538 char c;
|
|
|
2539 if (alpha(skipspc()))
|
|
|
2540 { i = hash = 0;
|
|
|
2541 while (alpha(ch) || digit(ch))
|
|
|
2542 { if (i <= 7) hash=7*(hash+(name[i++]=ch));
|
|
|
2543 getch();
|
|
|
2544 }
|
|
|
2545 name[i] = '\0';
|
|
|
2546 nptr0 = gsearch();
|
|
|
2547 if (nptr0->sc == RESERVE) return sym = nptr0->dsp;
|
|
|
2548 if (nptr0->sc == MACRO && !mflag)
|
|
|
2549 { mflag++;
|
|
|
2550 chsave = ch;
|
|
|
2551 chptrsave = chptr;
|
|
|
2552 chptr = (char *)nptr0->dsp;
|
|
|
2553 getch();
|
|
|
2554 return getsym();
|
|
|
2555 }
|
|
|
2556 sym = IDENT;
|
|
|
2557 gnptr=nptr=nptr0;
|
|
|
2558 if (mode==GDECL || mode==GSDECL || mode==GUDECL ||
|
|
|
2559 mode==GTDECL || mode==TOP)
|
|
|
2560 return sym;
|
|
|
2561 nptr1=lsearch();
|
|
|
2562 if (mode==STAT)
|
|
|
2563 if (nptr1->sc == EMPTY) return sym;
|
|
|
2564 else { nptr=nptr1; return sym;}
|
|
|
2565 nptr=nptr1;
|
|
|
2566 return sym;
|
|
|
2567 }
|
|
|
2568 else if (digit(ch))
|
|
|
2569 { symval=0;
|
|
|
2570 if (ch == '0')
|
|
|
2571 { if (getch() == 'x' || ch == 'X')
|
|
|
2572 while(1)
|
|
|
2573 if(digit(getch()))
|
|
|
2574 symval=symval*16+ch-'0';
|
|
|
2575 else if('a'<=ch&&ch<='f')
|
|
|
2576 symval=symval*16+ch-'a'+10;
|
|
|
2577 else if('A'<=ch&&ch<='F')
|
|
|
2578 symval=symval*16+ch-'A'+10;
|
|
|
2579 else break;
|
|
|
2580 else while (digit(ch)) {symval=symval*8+ch-'0';getch();}
|
|
|
2581 }
|
|
|
2582 else while(digit(ch)) {symval=symval*10+ch-'0';getch();}
|
|
|
2583 return sym=CONST;
|
|
|
2584 }
|
|
|
2585 else if(ch=='\'')
|
|
|
2586 { getch();
|
|
|
2587 symval=escape();
|
|
|
2588 if(ch!='\'') error(CHERR);
|
|
|
2589 getch();
|
|
|
2590 return sym=CONST;
|
|
|
2591 }
|
|
|
2592 else if(ch=='"')
|
|
|
2593 { getstring();
|
|
|
2594 return sym= STRING;
|
|
|
2595 }
|
|
|
2596 c=ch;
|
|
|
2597 getch();
|
|
|
2598 switch(c)
|
|
|
2599 {case '*':
|
|
|
2600 return postequ(MUL,MUL+AS);
|
|
|
2601 case '&':
|
|
|
2602 if(ch=='&') {getch();return sym=LAND;}
|
|
|
2603 return postequ(BAND,BAND+AS);
|
|
|
2604 case '-':
|
|
|
2605 if(ch=='>') {getch();return sym=ARROW;}
|
|
|
2606 if(ch=='-') {getch();return sym=DEC;}
|
|
|
2607 return postequ(SUB,SUB+AS);
|
|
|
2608 case '!':
|
|
|
2609 return postequ(LNOT,NEQ);
|
|
|
2610 case '~':
|
|
|
2611 return sym=BNOT;
|
|
|
2612 case '+':
|
|
|
2613 if(ch=='+') {getch();return sym=INC;}
|
|
|
2614 return postequ(ADD,ADD+AS);
|
|
|
2615 case '%':
|
|
|
2616 return postequ(MOD,MOD+AS);
|
|
|
2617 case '^':
|
|
|
2618 return postequ(EOR,EOR+AS);
|
|
|
2619 case '|':
|
|
|
2620 if(ch=='|') {getch();return sym=LOR;}
|
|
|
2621 return postequ(BOR,BOR+AS);
|
|
|
2622 case '=':
|
|
|
2623 return postequ(ASS,EQ);
|
|
|
2624 case '>':
|
|
|
2625 if(ch=='>') {getch();return postequ(RSHIFT,RSHIFT+AS);}
|
|
|
2626 return postequ(GT,GE);
|
|
|
2627 case '<':
|
|
|
2628 if(ch=='<') {getch();return postequ(LSHIFT,LSHIFT+AS);}
|
|
|
2629 return postequ(LT,LE);
|
|
|
2630 case '(':
|
|
|
2631 return sym=LPAR;
|
|
|
2632 case ')':
|
|
|
2633 return sym=RPAR;
|
|
|
2634 case '[':
|
|
|
2635 return sym=LBRA;
|
|
|
2636 case ']':
|
|
|
2637 return sym=RBRA;
|
|
|
2638 case '{':
|
|
|
2639 return sym=LC;
|
|
|
2640 case '}':
|
|
|
2641 return sym=RC;
|
|
|
2642 case ',':
|
|
|
2643 return sym=COMMA;
|
|
|
2644 case ';':
|
|
|
2645 return sym=SM;
|
|
|
2646 case ':':
|
|
|
2647 return sym=COLON;
|
|
|
2648 case '?':
|
|
|
2649 return sym=COND;
|
|
|
2650 case '.':
|
|
|
2651 return sym=PERIOD;
|
|
|
2652 case '/':
|
|
|
2653 if(ch!='*') return postequ(DIV,DIV+AS);
|
|
|
2654 getch();
|
|
|
2655 while(ch=='*'?getch()!='/':getch());
|
|
|
2656 getch();
|
|
|
2657 return getsym();
|
|
|
2658 default:
|
|
|
2659 error(CHERR);
|
|
|
2660 return getsym();
|
|
|
2661 }
|
|
|
2662 }
|
|
|
2663 postequ(s1,s2)
|
|
|
2664 int s1,s2;
|
|
|
2665 { if(ch=='=') {getch();return sym=s2;}
|
|
|
2666 return sym=s1;
|
|
|
2667 }
|
|
|
2668 alpha(c)
|
|
|
2669 char c;
|
|
|
2670 { return('a'<=c&&c<='z'||'A'<=c&&c<='Z'||c=='_');
|
|
|
2671 }
|
|
|
2672 digit(c)
|
|
|
2673 char c;
|
|
|
2674 { return('0'<=c&&c<='9');
|
|
|
2675 }
|
|
|
2676 NMTBL *gsearch()
|
|
|
2677 {NMTBL *nptr,*iptr;
|
|
|
2678 iptr=nptr= &ntable[hash % GSYMS];
|
|
|
2679 while(nptr->sc!=EMPTY && neqname(nptr->nm))
|
|
|
2680 { if (++nptr== &ntable[GSYMS]) nptr=ntable;
|
|
|
2681 if (nptr==iptr) error(GSERR);
|
|
|
2682 }
|
|
|
2683 if (nptr->sc == EMPTY) copy(nptr->nm);
|
|
|
2684 return nptr;
|
|
|
2685 }
|
|
|
2686 NMTBL *lsearch()
|
|
|
2687 {NMTBL *nptr,*iptr;
|
|
|
2688 iptr=nptr= &ntable[hash%LSYMS+GSYMS];
|
|
|
2689 while(nptr->sc!=EMPTY && neqname(nptr->nm))
|
|
|
2690 { if (++nptr== &ntable[LSYMS+GSYMS]) nptr= &ntable[GSYMS];
|
|
|
2691 if (nptr==iptr) error(LSERR);
|
|
|
2692 }
|
|
|
2693 if (nptr->sc == EMPTY) copy(nptr->nm);
|
|
|
2694 return nptr;
|
|
|
2695 }
|
|
|
2696 neqname(p)
|
|
|
2697 char *p;
|
|
|
2698 {char *q;
|
|
|
2699 q=name;
|
|
|
2700 while(*p) if(*p++ != *q++) return 1;
|
|
|
2701 return *q!=0;
|
|
|
2702 }
|
|
|
2703 copy(p)
|
|
|
2704 char *p;
|
|
|
2705 {char *q;
|
|
|
2706 q=name;
|
|
|
2707 while(*p++= *q++);
|
|
|
2708 }
|
|
|
2709 getstring()
|
|
|
2710 { getch();
|
|
|
2711 symval = 0;
|
|
|
2712 sptr = cheapp;
|
|
|
2713 while (ch != '"')
|
|
|
2714 { *cheapp++ = escape();
|
|
|
2715 symval++;
|
|
|
2716 if (cheapp >= cheap+CHEAPSIZE) error(STRERR);
|
|
|
2717 }
|
|
|
2718 getch();
|
|
|
2719 *cheapp++ = '\0';
|
|
|
2720 symval++;
|
|
|
2721 }
|
|
|
2722 skipspc()
|
|
|
2723 { while(ch=='\t'||ch=='\n'||ch==' '||ch=='\r') getch();
|
|
|
2724 return ch;
|
|
|
2725 }
|
|
|
2726 getch()
|
|
|
2727 { if(*chptr) return ch= *chptr++;
|
|
|
2728 if(mflag) {mflag=0;chptr=chptrsave;return ch=chsave;}
|
|
|
2729 getline();
|
|
|
2730 return getch();
|
|
|
2731 }
|
|
|
2732 char escape()
|
|
|
2733 {char c;
|
|
|
2734 if ((c=ch) == '\\')
|
|
|
2735 { if (digit(c=getch()))
|
|
|
2736 { c = ch-'0';
|
|
|
2737 if (digit(getch()))
|
|
|
2738 { c = c*8+ch-'0';
|
|
|
2739 if (digit(getch())) {c=c*8+ch-'0';getch();}
|
|
|
2740 }
|
|
|
2741 return c;
|
|
|
2742 }
|
|
|
2743 getch();
|
|
|
2744 switch(c)
|
|
|
2745 {case 'n':
|
|
|
2746 return '\n';
|
|
|
2747 case 't':
|
|
|
2748 return '\t';
|
|
|
2749 case 'b':
|
|
|
2750 return '\b';
|
|
|
2751 case 'r':
|
|
|
2752 return '\r';
|
|
|
2753 case 'f':
|
|
|
2754 return '\f';
|
|
|
2755 case '\n':
|
|
|
2756 return escape();
|
|
|
2757 default:
|
|
|
2758 return c;
|
|
|
2759 }
|
|
|
2760 }
|
|
|
2761 if (c == '\n') error(EXERR);
|
|
|
2762 getch();
|
|
|
2763 return c;
|
|
|
2764 }
|
|
|
2765 FILE *getfname()
|
|
|
2766 {int i;
|
|
|
2767 char name[LBUFSIZE];
|
|
|
2768 getch();
|
|
|
2769 if(skipspc()!='"') error(INCERR);
|
|
|
2770 for(i=0;(getch()!='"' && ch!='\n');)
|
|
|
2771 if(i<LBUFSIZE-1) name[i++]=ch;
|
|
|
2772 if(ch=='\n') error(INCERR);
|
|
|
2773 name[i]=0;
|
|
|
2774 return ( (filep+1)->fcb = fopen(name,"r") );
|
|
|
2775 }
|
|
|
2776 getline()
|
|
|
2777 {int i;
|
|
|
2778 int c;
|
|
|
2779 lineno++;
|
|
|
2780 glineno++;
|
|
|
2781 chptr=linebuf;
|
|
|
2782 i=0;
|
|
|
2783 while ((*chptr++ = c = getc(filep->fcb)) != '\n')
|
|
|
2784 { if (++i > LBUFSIZE-2) error(LNERR);
|
|
|
2785 if (c==EOF)
|
|
|
2786 { error(EOFERR);
|
|
|
2787 --chptr;
|
|
|
2788 }
|
|
|
2789 }
|
|
|
2790 *chptr = '\0';
|
|
|
2791 if (lsrc && !asmf) printf("* %s",linebuf);
|
|
|
2792 if (*(chptr = linebuf) == '#')
|
|
|
2793 { ++chptr;
|
|
|
2794 if (macroeq("define"))
|
|
|
2795 { i=mode;
|
|
|
2796 mode=GDECL;
|
|
|
2797 ch= *chptr;
|
|
|
2798 if (getsym() == IDENT)
|
|
|
2799 { if (nptr->sc == EMPTY)
|
|
|
2800 { nptr->sc = MACRO;
|
|
|
2801 nptr->dsp = (int)cheapp;
|
|
|
2802 while ((*cheapp++ = c = *chptr++)
|
|
|
2803 && c != '\n');
|
|
|
2804 *cheapp++ = '\0';
|
|
|
2805 if (cheapp >= cheap+CHEAPSIZE)
|
|
|
2806 error(STRERR);
|
|
|
2807 if (!c) error(EOFERR);
|
|
|
2808 }
|
|
|
2809 else error(MCERR);
|
|
|
2810 }
|
|
|
2811 else error(MCERR);
|
|
|
2812 mode=i;
|
|
|
2813 *(chptr = linebuf) = '\0';
|
|
|
2814 }
|
|
|
2815 else if (macroeq("include"))
|
|
|
2816 { fprintf(stderr,"%s",linebuf);
|
|
|
2817 if(filep+1 >= filestack + FILES) error(FILERR);
|
|
|
2818 if ( ((filep+1)->fcb=getfname()) == NULL) error(FILERR);
|
|
|
2819 (filep+1)->ln=lineno;
|
|
|
2820 lineno=0;
|
|
|
2821 ++filep;
|
|
|
2822 *(chptr = linebuf) = '\0';
|
|
|
2823 }
|
|
|
2824 else if (macroeq("asm"))
|
|
|
2825 { if (asmf) error(MCERR);
|
|
106
|
2826 asmf = 2; lineno--; glineno--;
|
|
|
2827 chptr = ";;";
|
|
99
|
2828 }
|
|
|
2829 else if (macroeq("endasm"))
|
|
|
2830 { if (!asmf) error(MCERR);
|
|
|
2831 asmf = 0;
|
|
|
2832 }
|
|
|
2833 else if (macroeq(" "))
|
|
|
2834 getline();
|
|
|
2835 else error(MCERR);
|
|
|
2836 }
|
|
106
|
2837 if (asmf==2) asmf=1; /* return ";" to get correct macro alignment */
|
|
|
2838 else if (asmf==1) {
|
|
|
2839 while (asmf)
|
|
|
2840 { printf("%s",linebuf);
|
|
|
2841 getline();
|
|
|
2842 }
|
|
|
2843 }
|
|
99
|
2844 }
|
|
|
2845
|
|
|
2846 macroeq(s)
|
|
|
2847 char *s;
|
|
|
2848 {char *p;
|
|
|
2849 for (p = chptr; *s;) if (*s++ != *p++) return 0;
|
|
|
2850 chptr = p;
|
|
|
2851 return 1;
|
|
|
2852 }
|
|
|
2853
|
|
|
2854 car(e)
|
|
|
2855 int e;
|
|
|
2856 { return heap[e];
|
|
|
2857 }
|
|
|
2858 cadr(e)
|
|
|
2859 int e;
|
|
|
2860 { return heap[e+1];
|
|
|
2861 }
|
|
|
2862 caddr(e)
|
|
|
2863 int e;
|
|
|
2864 { return heap[e+2];
|
|
|
2865 }
|
|
|
2866 cadddr(e)
|
|
|
2867 int e;
|
|
|
2868 { return heap[e+3];
|
|
|
2869 }
|
|
|
2870 list2(e1,e2)
|
|
|
2871 int e1,e2;
|
|
|
2872 {int e;
|
|
|
2873 e=getfree(2);
|
|
|
2874 heap[e]=e1;
|
|
|
2875 heap[e+1]=e2;
|
|
|
2876 return e;
|
|
|
2877 }
|
|
|
2878 list3(e1,e2,e3)
|
|
|
2879 int e1,e2,e3;
|
|
|
2880 {int e;
|
|
|
2881 e=getfree(3);
|
|
|
2882 heap[e]=e1;
|
|
|
2883 heap[e+1]=e2;
|
|
|
2884 heap[e+2]=e3;
|
|
|
2885 return e;
|
|
|
2886 }
|
|
|
2887 list4(e1,e2,e3,e4)
|
|
|
2888 int e1,e2,e3,e4;
|
|
|
2889 {int e;
|
|
|
2890 e=getfree(4);
|
|
|
2891 heap[e]=e1;
|
|
|
2892 heap[e+1]=e2;
|
|
|
2893 heap[e+2]=e3;
|
|
|
2894 heap[e+3]=e4;
|
|
|
2895 return e;
|
|
|
2896 }
|
|
|
2897 getfree(n)
|
|
|
2898 int n;
|
|
|
2899 {int e;
|
|
|
2900 switch (mode)
|
|
|
2901 {case GDECL: case GSDECL: case GUDECL: case GTDECL:
|
|
|
2902 e=gfree;
|
|
|
2903 gfree+=n;
|
|
|
2904 break;
|
|
|
2905 default:
|
|
|
2906 lfree-=n;
|
|
|
2907 e=lfree;
|
|
|
2908 }
|
|
|
2909 if(lfree<gfree) error(HPERR);
|
|
|
2910 return e;
|
|
|
2911 }
|
|
|
2912 rplacad(e,n)
|
|
|
2913 int e,n;
|
|
|
2914 { heap[e+1]=n;
|
|
|
2915 return e;
|
|
|
2916 }
|
