![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to asexpr.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / lib / old_compiler / as / as.tahoe|
Return to asexpr.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / lib / old_compiler / as / as.tahoe |
1.1 root 1: /*
2: * Copyright (c) 1982 Regents of the University of California
3: */
4: #ifndef lint
5: static char sccsid[] = "@(#)asexpr.c 4.5 6/30/83";
6:
7: #endif not lint
8: #include <stdio.h>
9: #include "as.h"
10: #include "asscan.h"
11: #include "asexpr.h"
12:
13: /*
14: * Tables for combination of operands.
15: */
16: #define XTXRN 5<<1 /* indexes last row/column when right shifted */
17:
18: /*
19: * table for +
20: */
21: readonly char pltab[6][6] = {
22: /* UND ABS TXT DAT BSS EXT */
23:
24: /*UND*/ XUNDEF, XUNDEF, XUNDEF, XUNDEF, XUNDEF, XUNDEF,
25: /*ABS*/ XUNDEF, XABS, XTEXT, XDATA, XBSS, XXTRN,
26: /*TXT*/ XUNDEF, XTEXT, ERR, ERR, ERR, ERR,
27: /*DAT*/ XUNDEF, XDATA, ERR, ERR, ERR, ERR,
28: /*BSS*/ XUNDEF, XBSS, ERR, ERR, ERR, ERR,
29: /*EXT*/ XUNDEF, XXTRN, ERR, ERR, ERR, ERR,
30: };
31:
32: /*
33: * table for -
34: */
35: readonly char mintab[6][6] = {
36: /* UND ABS TXT DAT BSS EXT */
37:
38: /*UND*/ XUNDEF, XUNDEF, XUNDEF, XUNDEF, XUNDEF, XUNDEF,
39: /*ABS*/ XUNDEF, XABS, ERR, ERR, ERR, ERR,
40: /*TXT*/ XUNDEF, XTEXT, XABS, ERR, ERR, ERR,
41: /*DAT*/ XUNDEF, XDATA, ERR, XABS, ERR, ERR,
42: /*BSS*/ XUNDEF, XBSS, ERR, ERR, XABS, ERR,
43: /*EXT*/ XUNDEF, XXTRN, ERR, ERR, ERR, ERR,
44: };
45:
46: /*
47: * table for other operators
48: */
49: readonly char othtab[6][6] = {
50: /* UND ABS TXT DAT BSS EXT */
51:
52: /*UND*/ XUNDEF, XUNDEF, XUNDEF, XUNDEF, XUNDEF, XUNDEF,
53: /*ABS*/ XUNDEF, XABS, ERR, ERR, ERR, ERR,
54: /*TXT*/ XUNDEF, ERR, ERR, ERR, ERR, ERR,
55: /*DAT*/ XUNDEF, ERR, ERR, ERR, ERR, ERR,
56: /*BSS*/ XUNDEF, ERR, ERR, ERR, ERR, ERR,
57: /*EXT*/ XUNDEF, ERR, ERR, ERR, ERR, ERR,
58: };
59:
60: struct exp *combine(op, exp1, exp2)
61: reg struct exp *exp1, *exp2;
62: {
63: reg int e1_type, e2_type;
64: reg int back_type;
65: char *btype = "The assembler can only do arithmetic on 1,2, or 4 byte integers";
66:
67: lastnam=0; /* kludge for jxxx instructions */
68:
69: e1_type = exp1->e_xtype&XTYPE;
70: e2_type = exp2->e_xtype&XTYPE;
71:
72: if (exp1->e_xtype==XXTRN+XUNDEF)
73: e1_type = XTXRN;
74: if (exp2->e_xtype==XXTRN+XUNDEF)
75: e2_type = XTXRN;
76: if (passno==1)
77: if (exp1->e_xloc!=exp2->e_xloc && e1_type==e2_type)
78: e1_type = e2_type = XTXRN; /* error on != loc ctrs */
79: e1_type >>= 1; /*dispose of the external (XXTRN) bit*/
80: e2_type >>= 1;
81:
82: switch (op){
83: case PLUS:
84: exp1->e_xvalue += exp2->e_xvalue;
85: back_type = pltab[e1_type][e2_type];
86: break;
87: case MINUS:
88: exp1->e_xvalue -= exp2->e_xvalue;
89: back_type = mintab[e1_type][e2_type];
90: break;
91: case IOR:
92: exp1->e_xvalue |= exp2->e_xvalue;
93: goto comm;
94: case XOR:
95: exp1->e_xvalue ^= exp2->e_xvalue;
96: goto comm;
97: case AND:
98: exp1->e_xvalue &= exp2->e_xvalue;
99: goto comm;
100: case ORNOT:
101: exp1->e_xvalue |= ~exp2->e_xvalue;
102: goto comm;
103: case LSH:
104: exp1->e_xvalue <<= exp2->e_xvalue;
105: goto comm;
106: case RSH:
107: exp1->e_xvalue >>= exp2->e_xvalue;
108: goto comm;
109: case TILDE:
110: exp1->e_xvalue |= ~ exp2->e_xvalue;
111: goto comm;
112: case MUL:
113: exp1->e_xvalue *= exp2->e_xvalue;
114: goto comm;
115: case DIV:
116: if (exp2->e_xvalue == 0)
117: yyerror("Divide check");
118: else
119: exp1->e_xvalue /= exp2->e_xvalue;
120: goto comm;
121: case REGOP:
122: if (exp2->e_xvalue == 0)
123: yyerror("Divide check (modulo)");
124: else
125: exp1->e_xvalue %= exp2->e_xvalue;
126: goto comm;
127:
128: comm:
129: back_type = othtab[e1_type][e2_type];
130: break;
131: default:
132: yyerror("Internal error: unknown operator");
133: }
134:
135: if (e2_type==(XTXRN>>1))
136: exp1->e_xname = exp2->e_xname;
137: exp1->e_xtype = back_type | (
138: (exp1->e_xtype|exp2->e_xtype) & (XFORW|XXTRN) );
139: if (back_type==ERR)
140: yyerror("Relocation error");
141: return(exp1);
142: }
143:
144: buildtokensets()
145: {
146: #define clobber(val, set) tokensets[(val)] |= (set)
147:
148: clobber(SEMI, LINSTBEGIN);
149: clobber(NL, LINSTBEGIN);
150: clobber(INT, LINSTBEGIN);
151:
152: clobber(NAME, YUKKYEXPRBEG + LINSTBEGIN);
153: clobber(INSTn, YUKKYEXPRBEG);
154: clobber(INST0, YUKKYEXPRBEG);
155: clobber(REG, YUKKYEXPRBEG);
156: clobber(BFINT, YUKKYEXPRBEG);
157:
158: clobber(INT, SAFEEXPRBEG);
159: clobber(BIGNUM, SAFEEXPRBEG);
160:
161: clobber(PLUS, ADDOPS);
162: clobber(MINUS, ADDOPS + EBEGOPS);
163:
164: clobber(LP, EBEGOPS);
165:
166: clobber(IOR, BOOLOPS);
167: clobber(XOR, BOOLOPS);
168: clobber(AND, BOOLOPS);
169: clobber(ORNOT, BOOLOPS);
170:
171: clobber(TILDE, MULOPS + EBEGOPS);
172: clobber(LSH, MULOPS);
173: clobber(RSH, MULOPS);
174: clobber(MUL, MULOPS);
175: clobber(DIV, MULOPS);
176: clobber(REGOP, MULOPS); /* % */
177:
178: }
179:
180: /*
181: * We keep the current token class in this global variable, so
182: * the recursive descent expression analyzers can talk amongst
183: * themselves, and so that we may use the macros shift and shift over
184: */
185:
186: extern int yylval; /*the value of the lexical value*/
187: extern struct exp *xp; /*the next free expression slot*/
188:
189: static inttoktype val;
190:
191: /*
192: * return the value the read head is sitting on
193: */
194: inttoktype exprparse(inval, backexpr)
195: inttoktype inval;
196: struct exp **backexpr;
197: {
198: reg struct exp *lexpr;
199: inttoktype op;
200:
201: val = inval;
202: lexpr = boolterm();
203: while (INTOKSET(val, ADDOPS)){
204: op = val;
205: shift;
206: lexpr = combine(op, lexpr, boolterm());
207: }
208: *backexpr = lexpr;
209: return(val);
210: }
211:
212: struct exp *boolterm()
213: {
214: reg struct exp *lexpr;
215: inttoktype op;
216:
217: lexpr = term();
218: while(INTOKSET(val, BOOLOPS)){
219: op = val;
220: shift;
221: lexpr = combine(op, lexpr, term());
222: }
223: return(lexpr);
224: }
225:
226: struct exp *term()
227: {
228: reg struct exp *lexpr;
229: inttoktype op;
230:
231: lexpr = factor();
232: while(INTOKSET(val, MULOPS)){
233: op = val;
234: shift;
235: lexpr = combine(op, lexpr, factor());
236: }
237: return(lexpr);
238: }
239:
240: struct exp *factor()
241: {
242: struct exp *lexpr;
243: inttoktype op;
244: extern int droppedLP; /*called exprparse after consuming an LP*/
245:
246: if (val == LP || droppedLP){
247: if (droppedLP)
248: droppedLP = 0;
249: else
250: shift; /*the LP*/
251: val = exprparse(val, &lexpr);
252: if (val != RP)
253: yyerror("right parenthesis expected");
254: else
255: shift;
256: } else
257: if (INTOKSET(val, YUKKYEXPRBEG)){
258: lexpr = yukkyexpr(val, yylval);
259: shift;
260: }
261: else if (INTOKSET(val, SAFEEXPRBEG)){
262: lexpr = (struct exp *)yylval;
263: shift;
264: }
265: else if ( (val == TILDE) || (val == MINUS) ){
266: op = val;
267: shift;
268: lexpr = xp++;
269: lexpr->e_xtype = XABS;
270: lexpr->e_number = Znumber;
271: lexpr->e_number.num_tag = TYPL;
272: lexpr = combine(op, lexpr, factor());
273: } else {
274: yyerror("Bad expression syntax");
275: lexpr = xp++;
276: lexpr->e_xtype = XABS;
277: lexpr->e_number = Znumber;
278: lexpr->e_number.num_tag = TYPL;
279: }
280: return(lexpr);
281: }
282:
283: struct exp *yukkyexpr(val, np)
284: int val;
285: reg int np;
286: {
287: reg struct exp *locxp;
288: extern int exprisname; /*last factor is a name*/
289: int off = 0;
290:
291: exprisname = 0;
292: locxp = xp++;
293: locxp->e_number = Znumber;
294: locxp->e_number.num_tag = TYPL;
295:
296: switch(val){
297: case BFINT:
298: yylval = ((struct exp *)np)->e_xvalue;
299: if (yylval < 0) {
300: yylval = -yylval;
301: yylval--;
302: off = -1;
303: if (lgensym[yylval] == 1)
304: yyerror("Reference to undefined local label %db", yylval);
305: } else {
306: yylval--;
307: genref[yylval] = 1;
308: }
309: (void)sprintf(yytext, "L%d\001%d", yylval, lgensym[yylval] + off);
310: yylval = np = (int)*lookup(passno == 1);
311: lastnam = (struct symtab *)np;
312: /* FALLTHROUGH */
313: case NAME:
314: exprisname = (int)np;
315: locxp->e_xtype = ((struct symtab *)np)->s_type;
316: if (( ((struct symtab *)np)->s_type&XTYPE)==XUNDEF) { /*forward*/
317: locxp->e_xname = (struct symtab *)np;
318: locxp->e_xvalue = 0;
319: if (passno==1)
320: ((struct symtab *)np)->s_type |= XFORW;
321: } else { /*otherwise, just get the value*/
322: locxp->e_xvalue = ((struct symtab *)np)->s_value;
323: locxp->e_xname = NULL;
324: }
325: break;
326: default:
327: yyerror("Internal Error in yukkyexpr");
328: /* FALLTHROUGH */
329:
330: case INSTn:
331: case INST0:
332: case REG:
333: locxp->e_xtype = XABS;
334: locxp->e_xvalue = ( (int)np) & 0xFF;
335: locxp->e_xloc = 0;
336: locxp->e_xname = NULL;
337: break;
338: }
339:
340: return(locxp);
341: }
342:
343: /*
344: * Print definitions for token kinds
345: */
346: static char pdirect[] = "directive";
347: static char pinstr[] = "instruction";
348: static char phunk[] = "lexeme";
349: static char psmall[] = "small symbol";
350: static char pcntrl[] = "control token";
351:
352: #define DIRECT pdirect
353: #define INSTR pinstr
354: #define HUNK phunk
355: #define SMALL psmall
356: #define CNTRL pcntrl
357:
358: struct Tok_Desc{
359: int tok_which;
360: char *tok_kind;
361: char *tok_name;
362: };
363: struct Tok_Desc *tok_name[LASTTOKEN - FIRSTTOKEN + 1];
364:
365: struct Tok_Desc tok_desc[] = {
366: FIRSTTOKEN, DIRECT, "first token",
367:
368: IBYTE, DIRECT, ".byte",
369: IWORD, DIRECT, ".word",
370: IINT, DIRECT, ".int",
371: ILONG, DIRECT, ".long",
372: IQUAD, DIRECT, ".quad",
373: IFFLOAT, DIRECT, ".ffloat",
374: IDFLOAT, DIRECT, ".dfloat",
375: IASCII, DIRECT, ".ascii",
376: IASCIZ, DIRECT, ".asciz",
377: IFILL, DIRECT, ".fill",
378: ISPACE, DIRECT, ".space",
379:
380: IDATA, DIRECT, ".data",
381: ITEXT, DIRECT, ".text",
382: IGLOBAL, DIRECT, ".global",
383: IALIGN, DIRECT, ".align",
384:
385: ISET, DIRECT, ".set",
386: ICOMM, DIRECT, ".comm",
387: ILCOMM, DIRECT, ".lcomm",
388: IORG, DIRECT, ".org",
389: ILSYM, DIRECT, ".lsym",
390:
391: ISTAB, DIRECT, ".stab",
392: ISTABSTR, DIRECT, ".stabstr",
393: ISTABNONE, DIRECT, ".stabnone",
394: ISTABDOT, DIRECT, ".stabdot",
395:
396: IFILE, DIRECT, ".file",
397: ILINENO, DIRECT, ".lineno",
398: IABORT, DIRECT, ".abort",
399:
400: IJXXX, INSTR, "jump pseudo",
401: INST0, INSTR, "0 argument inst",
402: INSTn, INSTR, "n argument inst",
403:
404: PARSEEOF, CNTRL, "parse end of file",
405: ILINESKIP, CNTRL, "skip lines",
406: VOID, CNTRL, "void",
407: SKIP, CNTRL, "skip",
408: NL, CNTRL, "new line",
409: SCANEOF, CNTRL, "scanner end of file",
410: BADCHAR, CNTRL, "bad character",
411: SH, CNTRL, "comment, #",
412:
413: INT, HUNK, "int",
414: BFINT, HUNK, "local label",
415: BIGNUM, HUNK, "big number",
416: NAME, HUNK, "name",
417: STRING, HUNK, "string",
418: REG, HUNK, "register specifier",
419:
420: SIZESPEC, SMALL, "size specifier, [BWLbwl]",
421: SIZEQUOTE, SMALL, "sizequote, [^']",
422: LITOP, SMALL, "litop",
423:
424: MP, SMALL, "minus parenthesis, -(",
425: REGOP, SMALL, "register operator, %",
426:
427: SP, SMALL, "space",
428: ALPH, SMALL, "alphabetic character, [A-Za-z_]",
429: DIG, SMALL, "digit character, [A-Fa-f0-9]",
430:
431: SQ, SMALL, "single quote, '",
432: DQ, SMALL, "double quote, \"",
433:
434: LSH, SMALL, "arithmetic left shift, <",
435: RSH, SMALL, "arithmetic right shift, >",
436: XOR, SMALL, "exclusive or, ^",
437:
438: PLUS, SMALL, "plus, +",
439: MINUS, SMALL, "minus, -",
440: MUL, SMALL, "multiply, *",
441: DIV, SMALL, "divide, /",
442: SEMI, SMALL, "semi colon, ;",
443: COLON, SMALL, "colon, :",
444: IOR, SMALL, "inclusive or, |",
445: AND, SMALL, "and, &",
446:
447: TILDE, SMALL, "one's complement, ~",
448: ORNOT, SMALL, "ornot, !",
449: CM, SMALL, "comma",
450:
451: LB, SMALL, "left bracket, [",
452: RB, SMALL, "right bracket, ]",
453: LP, SMALL, "left parenthesis, (",
454: RP, SMALL, "right parentheis, )",
455:
456: LASTTOKEN, SMALL, "last token",
457: };
458: /*
459: * turn a token type into a string
460: */
461: char *tok_to_name(token)
462: {
463: static int fixed = 0;
464: static char buf[64];
465: static struct Tok_Desc NA = {0, (char *)0, "NOT ASSIGNED"};
466: int i;
467:
468: if (!fixed){
469: for (i = FIRSTTOKEN; i <= LASTTOKEN; i++)
470: tok_name[i] = &NA;
471: for (i = 0; i <= sizeof(tok_desc)/sizeof(struct Tok_Desc); i++){
472: tok_name[tok_desc[i].tok_which] = &tok_desc[i];
473: }
474: fixed = 1;
475: }
476: if (FIRSTTOKEN <= token && token <= LASTTOKEN){
477: (void)sprintf(buf, "%s %s", tok_name[token]->tok_kind,
478: tok_name[token]->tok_name);
479: return(buf);
480: } else {
481: panic("Unknown token number, %d\n", token);
482: /*NOTREACHED*/
483: }
484: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.