![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to kas0.y CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / kasb|
Return to kas0.y CVS log | Up to [Research Unix] / researchv10no / cmd / kasb |
1.1 root 1: /* @(#)kas0.y 1.1 */
2: %union {
3: int ival;
4: struct exp *expr;
5: struct symtab *sym;
6: char *str;
7: }
8:
9: %token NOCHAR NL
10: %token CM SEMI COLON LP RP
11: %token PLUS MINUS MUL DIV NOT POP BAR INC
12: %token AND XOR LS RS
13: %token <ival> INT
14: %token <sym> DNAME UNAME TNAME PAGE
15: %token <str> STR
16: %token <sym> REG BRG MEM MAR REGL REGH PC PCR
17: %token <sym> MVINS SFINS DFINS BRINS JMPINS
18: %token <sym> SEG ORG DATA DEBUG
19:
20: %nonassoc COLON
21: %left BAR XOR
22: %left AND
23: %left LS RS
24: %left PLUS MINUS
25: %left MUL DIV
26: %left NOT POP
27:
28:
29: %type <sym> fref
30: %type <ival> mach func page dst pdst sdst udst boreg oreg reg2
31: %type <expr> expr val db debug
32: %{
33: #include <stdio.h>
34: #include "kas.h"
35: struct exp explist[10];
36: struct exp *xp = { explist};
37: %}
38:
39: %%
40: %{
41: int dinc;
42: int nlf;
43: %}
44: prog: /* empty */
45: | prog line = {
46: xp = explist;
47: if (nlf)
48: lineno++;
49: }
50: ;
51:
52: line: labels close
53: | labels mach = {
54: putins($2);
55: }
56: | labels pseudo close
57: | debug close = {
58: debug($1->xvalue, $1->xtype);
59: }
60: | error close = {
61: yyerrok;
62: }
63: ;
64:
65: labels: /* empty */
66: | labels UNAME COLON = {
67: $2->type = dot->type;
68: backup($2,dot->value);
69: }
70: | labels INT COLON = {
71: if ($2<0 || $2>9) {
72: yyerror("illegal numeric label");
73: } else {
74: loclab[$2].name[0] = 1;
75: backup(&loclab[$2], dot->value);
76: loclab[$2].type = dot->value;
77: loclab[$2].value = 0;
78: }
79: }
80: ;
81:
82: close: NL = {
83: nlf = 1;
84: }
85: | SEMI = {
86: nlf = 0;
87: }
88: ;
89:
90: mach: MVINS fref CM udst close = {
91: $$ = $1->value|$4;
92: reloc[dot->value] = $2->value;
93: $2->value = dot->value|RLCMV;
94: }
95: | MVINS POP fref CM udst close = {
96: $$ = $1->value|$5;
97: reloc[dot->value] = $3->value;
98: $3->value = dot->value|RLCPOP;
99: }
100: | MVINS expr CM dst close = {
101: $$ = $1->value|cksrc($2->xvalue&0377, $4);
102: }
103: | MVINS REG CM dst close = {
104: $$ = $1->value|SRCBRG|SELA|ckreg($2->value, $4);
105: }
106: | MVINS oreg CM dst close = {
107: $$ = $1->value|$2|$4;
108: }
109: | SFINS REG CM dst close = {
110: $$ = $1->value|SRCBRG|ckreg($2->value, $4);
111: }
112: | SFINS REG close = {
113: $$ = $1->value|SRCBRG|$2->value|DSTREG;
114: }
115: | DFINS reg2 CM REG CM dst close = {
116: $$ = $1->value|$2|ckreg($4->value, $6);
117: }
118: | DFINS reg2 CM REG close = {
119: $$ = $1->value|$2|$4->value|DSTREG;
120: }
121: | BRINS expr close = {
122: $$ = $1->value|($2->xvalue&0377)|(($2->xvalue&01400)<<3);
123: if ((dot->value&~01777) != ($2->xvalue&~01777))
124: yyerror("branch out of range");
125: }
126: | BRINS fref close = {
127: $$ = $1->value;
128: reloc[dot->value] = $2->value;
129: $2->value = dot->value|RLCBR;
130: }
131: | BRINS LP func RP page close = {
132: $$ = $1->value|$3|$5;
133: }
134: | JMPINS expr close = {
135: $$ = $1->value|($2->xvalue&0377);
136: }
137: | JMPINS fref close = {
138: $$ = $1->value;
139: reloc[dot->value] = $2->value;
140: $2->value = dot->value|RLCMV;
141: }
142: | JMPINS LP func RP close = {
143: $$ = $1->value|$3;
144: }
145: ;
146:
147: func: REG = {
148: $$ = $1->value|SRCBRG|SELA;
149: }
150: | reg2 = {
151: $$ = $1|SELB;
152: }
153: | SFINS CM REG = {
154: $$ = $1->value|$3->value|SRCBRG;
155: }
156: | DFINS CM reg2 CM REG = {
157: $$ = $1->value|$3|$5->value;
158: }
159: ;
160:
161: page: /* empty */ = {
162: $$ = 0;
163: }
164: | CM PAGE = {
165: $$ = $2->value;
166: }
167: | CM POP val = {
168: $$ = ($3->xvalue&01400)<<3;
169: }
170: | CM POP fref = {
171: $$ = 0;
172: reloc[dot->value] = $3->value;
173: $3->value = dot->value|RLCPG;
174: }
175: ;
176:
177: fref:
178: UNAME
179: | TNAME
180: ;
181:
182: dst: MINUS = {
183: $$ = 0;
184: }
185: | pdst
186: | pdst BAR pdst = {
187: $$ = ckdst($1, $3);
188: }
189: | pdst BAR pdst BAR pdst = {
190: $$ = ckdst(ckdst($1, $3), $5);
191: }
192: ;
193:
194: pdst: REG = {
195: $$ = $1->value|DSTREG;
196: }
197: | BRG = {
198: $$ = DSTBRG;
199: }
200: | MEM = {
201: $$ = DSTMEM;
202: }
203: | REGL = {
204: $$ = $1->value|DSTREGL;
205: }
206: | REGH = {
207: $$ = $1->value|DSTREGH;
208: }
209: | BRG RS = {
210: $$ = DSTBGRS;
211: }
212: | MAR = {
213: $$ = DSTMAR;
214: }
215: | MAR INC = {
216: $$ = DSTMARI;
217: }
218: | POP MAR = {
219: $$ = DSTMARP;
220: }
221: | PCR = {
222: $$ = DSTPCH|DSTREGH;
223: }
224: ;
225:
226: udst: sdst
227: | sdst BAR sdst = {
228: $$ = ckdst($1, $3);
229: }
230: ;
231:
232: sdst: BRG = {
233: $$ = DSTBRG;
234: }
235: | MEM = {
236: $$ = DSTMEM;
237: }
238: | MAR = {
239: $$ = DSTMAR;
240: }
241: | MAR INC = {
242: $$ = DSTMARI;
243: }
244: | POP MAR = {
245: $$ = DSTMARP;
246: }
247: ;
248:
249: oreg: reg2 = {
250: $$ = $1|SELB;
251: }
252: | REGL = {
253: $$ = ($1->value<<4)|SRCREGL;
254: }
255: | REGH = {
256: $$ = ($1->value<<4)|SRCREGH;
257: }
258: | boreg = {
259: $$ = ($1<<4)|SRCREGH;
260: }
261: ;
262:
263: reg2: BRG = {
264: $$ = SRCBRG;
265: }
266: | MEM = {
267: $$ = SRCMEM;
268: }
269: ;
270:
271: boreg: MAR = {
272: $$ = SRCMARL;
273: }
274: | POP MAR = {
275: $$ = SRCMARH;
276: }
277: | PC = {
278: $$ = SRCPCL;
279: }
280: | POP PC = {
281: $$ = SRCPCH;
282: }
283: ;
284:
285: expr: val
286: | LP expr RP = {
287: $$ = $2;
288: }
289: | expr BAR expr = {
290: $1->xvalue |= $3->xvalue;
291: }
292: | expr XOR expr = {
293: $1->xvalue ^= $3->xvalue;
294: }
295: | expr AND expr = {
296: $1->xvalue &= $3->xvalue;
297: }
298: | expr LS expr = {
299: $1->xvalue <<= $3->xvalue;
300: }
301: | expr RS expr = {
302: $1->xvalue >>= $3->xvalue;
303: }
304: | expr PLUS expr = {
305: $1->xvalue += $3->xvalue;
306: }
307: | expr MINUS expr = {
308: $1->xvalue -= $3->xvalue;
309: }
310: | expr MUL expr = {
311: $1->xvalue *= $3->xvalue;
312: }
313: | expr DIV expr = {
314: $1->xvalue /= $3->xvalue;
315: }
316: | NOT expr = {
317: $2->xvalue = ~$2->xvalue;
318: $$ = $2;
319: }
320: | POP expr = {
321: $2->xvalue = ($2->xvalue>>8)&0377;
322: $$ = $2;
323: }
324: | MINUS expr %prec POP = {
325: $2->xvalue = -$2->xvalue;
326: $$ = $2;
327: }
328: ;
329:
330: val: DNAME = {
331: $$ = xp++;
332: $$->xtype = XABS;
333: $$->xvalue = $1->value;
334: }
335: | INT = {
336: $$ = xp++;
337: $$->xtype = XABS;
338: $$->xvalue = $1;
339: }
340: ;
341:
342: pseudo: SEG = {
343: if (dot->type==XTEXT)
344: textsv = dot->value;
345: else datasv = dot->value;
346: dot->type = $1->value;
347: if (dot->type==XTEXT)
348: dot->value = textsv;
349: else dot->value = datasv;
350: }
351: | ORG expr = {
352: if ($2->xvalue<0 || $2->xvalue>=NKMCI)
353: yyerror("illegal org value");
354: else dot->value = $2->xvalue;
355: }
356: | data explist
357: ;
358:
359: data: DATA = {
360: if (dot->type != XDATA) {
361: yyerror("no data in text");
362: }
363: dinc = $1->value;
364: }
365: ;
366:
367: explist: outexpr
368: | explist CM outexpr
369: ;
370:
371: outexpr: expr = {
372: putdat($1->xvalue&0377);
373: if (dinc==2)
374: putdat(($1->xvalue>>8)&0377);
375: xp = explist;
376: }
377: ;
378:
379: debug: db
380: | db INT = {
381: $1->xtype = $2;
382: }
383: | db STR = {
384: $1->xtype = (int)$2;
385: }
386: ;
387:
388: db: DEBUG = {
389: $$ = xp++;
390: $$->xvalue = $1->value;
391: $$->xtype = 0;
392: }
393: ;
394: %%
395:
396: yyerror(s, a)
397: char *s;
398: {
399: anyerrs++;
400: if (infile)
401: fprintf(stderr, "%s:", infile);
402: fprintf(stderr, "%d:", lineno);
403: fprintf(stderr, s, a);
404: fprintf(stderr, "\n");
405: }
406:
407: #include "kas0.yl"
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.