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