![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to operand.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / cmd / sun / as|
Return to operand.c CVS log | Up to [Research Unix] / researchv9 / cmd / sun / as |
1.1 ! root 1: #ifndef lint ! 2: static char sccsid[] = "@(#)operand.c 1.1 86/02/03 Copyr 1985 Sun Micro"; ! 3: #endif ! 4: ! 5: /* ! 6: * Copyright (c) 1985 by Sun Microsystems, Inc. ! 7: */ ! 8: ! 9: #include "as.h" ! 10: #include <ctype.h> ! 11: ! 12: short cinfo[128] = { ! 13: ERR, ERR, ERR, ERR, ERR, ERR, ERR, ERR, ! 14: ERR, SPC, EOL, SPC, SPC, SPC, ERR, ERR, ! 15: ERR, ERR, ERR, ERR, ERR, ERR, ERR, ERR, ! 16: ERR, ERR, ERR, ERR, ERR, ERR, ERR, ERR, ! 17: SPC, ERR, QUO, IMM, S+T, ERR, ERR, ERR, ! 18: LP, RP, MUL, ADD, COM, SUB, S+T, DIV, ! 19: D+T, D+T, D+T, D+T, D+T, D+T, D+T, D+T, ! 20: D+T, D+T, COL, EOL, ERR, EQL, ERR, ERR, ! 21: IND, S+T, S+T, S+T, S+T, S+T, S+T, S+T, ! 22: S+T, S+T, S+T, S+T, S+T, S+T, S+T, S+T, ! 23: S+T, S+T, S+T, S+T, S+T, S+T, S+T, S+T, ! 24: S+T, S+T, S+T, ERR, ERR, ERR, ERR, S+T, ! 25: ERR, S+T, S+T, S+T, S+T, S+T, S+T, S+T, ! 26: S+T, S+T, S+T, S+T, S+T, S+T, S+T, S+T, ! 27: S+T, S+T, S+T, S+T, S+T, S+T, S+T, S+T, ! 28: S+T, S+T, S+T, LB, EOL, RB, NOT, S+T ! 29: }; ! 30: ! 31: /* for local labels: ``[0-9]:'', and references ``[0-9][bh]'' */ ! 32: char *ll_format = "*%c%06d"; ! 33: int ll_val[10]; ! 34: ! 35: static struct suffix { ! 36: int indx_sx; /* index register */ ! 37: int scale_sx; /* index scaling */ ! 38: long disp_sx; /* displacement */ ! 39: struct sym_bkt *sym_sx; /* symbolic displacement */ ! 40: unsigned flags_sx; /* see below */ ! 41: } fix [2]; ! 42: ! 43: static struct suffix zero_suffix = { 0 }; ! 44: ! 45: /* flags_sx values */ ! 46: #define SX_INDXW 1 /* word-size index specified */ ! 47: #define SX_INDXL 2 /* long-size index specified */ ! 48: #define SX_DISPW 4 /* word-size displacement specified */ ! 49: #define SX_DISPL 010 /* long-size displacement specified */ ! 50: #define SX_GOTINDEX 020 /* index register specified */ ! 51: #define SX_GOTDISP 040 /* displacement specified */ ! 52: #define SX_DISPB 0100 /* word-size displacement specified */ ! 53: ! 54: static struct oper zero_oper = { T_NULL }; ! 55: ! 56: char *suffix(), *exp(), *term(), *scan_reg_or_immed(); ! 57: char * scan_float(); ! 58: double atof(); ! 59: char * reglist () ; ! 60: ! 61: /* ! 62: * Fetches operand value and register subfields and loads them into ! 63: * the operand structure. This routine will fetch only one set of value ! 64: * and register subfields. ! 65: * It will move line pointer to first untouched char. ! 66: */ ! 67: char * ! 68: soperand(lptr,opnd) ! 69: register char *lptr; ! 70: struct oper *opnd; ! 71: { ! 72: struct oper spare_oper; ! 73: int v; ! 74: ! 75: *opnd = zero_oper; ! 76: spare_oper = zero_oper; ! 77: ! 78: if ((v=cinfo[*lptr]) == IMM) { ! 79: lptr = exp(++lptr,opnd); ! 80: if (opnd->type_o == T_REG) ! 81: PROG_ERROR(E_REG); ! 82: opnd->immed_o = opnd->type_o ; /* Save type. */ ! 83: opnd->type_o = T_IMMED; ! 84: } else if (v == IND) { ! 85: /* index mode, omitted base */ ! 86: /* expecting LP next */ ! 87: lptr += 1; ! 88: skipb(lptr); ! 89: if (cinfo[*lptr] == LP) ! 90: goto index_mode; ! 91: else ! 92: PROG_ERROR(E_OPERAND); ! 93: } else { ! 94: lptr = exp(lptr,opnd); ! 95: skipb(lptr); ! 96: switch (opnd->type_o){ ! 97: case T_REG: ! 98: switch (cinfo[*lptr]){ ! 99: case COL: ! 100: /* should be a register pair */ ! 101: lptr = exp( ++lptr, &spare_oper); ! 102: if (spare_oper.type_o != T_REG) ! 103: PROG_ERROR(E_OPERAND); ! 104: if (!ext_instruction_set) ! 105: PROG_ERROR( E_OPERAND ); ! 106: opnd->type_o = T_REGPAIR; ! 107: opnd->reg_o = spare_oper.value_o; ! 108: break; ! 109: case IND: ! 110: if (!(areg(opnd->value_o) ! 111: || pcreg(opnd->value_o))) ! 112: PROG_ERROR(E_OPERAND); ! 113: lptr += 1; ! 114: skipb(lptr); ! 115: switch (cinfo[*lptr]){ ! 116: default: ! 117: opnd->type_o = T_DEFER; ! 118: break; ! 119: case ADD: ! 120: opnd->type_o = T_POSTINC; ! 121: lptr++; ! 122: break; ! 123: case SUB: ! 124: opnd->type_o = T_PREDEC; ! 125: lptr++; ! 126: break; ! 127: case LP: ! 128: /* defer or indexing coming up here */ ! 129: index_mode: ! 130: lptr = suffix( lptr, &fix[0] ); ! 131: if (cinfo[*lptr] != IND){ ! 132: simplify1( opnd, &fix[0] ); ! 133: } else { ! 134: lptr = suffix( ++lptr, &fix[1] ); ! 135: simplify2( opnd, &fix[0], &fix[1] ); ! 136: } ! 137: break; ! 138: case IND: ! 139: lptr = suffix( ++lptr, &fix[1] ); ! 140: simplify2( opnd, &zero_suffix, ! 141: &fix[1] ); ! 142: break; ! 143: } ! 144: if (opnd->type_o == T_INDEX ! 145: && !ext_instruction_set) ! 146: if ( (opnd->flags_o & ! 147: (O_BSUPRESS|O_INDIRECT|O_WDISP|O_LDISP)) ! 148: || opnd->scale_o != 1 ! 149: || !(opnd->flags_o&O_PREINDEX)) ! 150: PROG_ERROR( E_OPERAND ); ! 151: /* flow through */ ! 152: default: ! 153: break; ! 154: } ! 155: break; ! 156: case T_NORMAL: ! 157: if (cinfo[*lptr] == COL ){ ! 158: switch (*++lptr) { ! 159: case 'W': ! 160: case 'w': opnd->type_o = T_ABSS; ! 161: lptr++; ! 162: break; ! 163: case 'L': ! 164: case 'l': opnd->type_o = T_ABSL; ! 165: lptr++; ! 166: break; ! 167: } ! 168: } ! 169: if (cinfo[*lptr] == IND) ! 170: goto index_mode; ! 171: break; ! 172: } ! 173: } ! 174: skipb( lptr ); ! 175: if ( cinfo[ *lptr ] == LB ) { ! 176: /* oh, boy, bitfields */ ! 177: opnd->flags_o |= O_BFLD; ! 178: spare_oper = zero_oper; ! 179: lptr = scan_reg_or_immed( lptr+1, &spare_oper); ! 180: v = spare_oper.value_o; ! 181: if (spare_oper.type_o == T_REG){ ! 182: opnd->flags_o |= O_BFOREG; ! 183: } else if ((spare_oper.sym_o && !(spare_oper.sym_o->attr_s&S_DEF)) ! 184: || v < 0 || v > 31){ ! 185: PROG_ERROR(E_CONSTANT); ! 186: } ! 187: opnd->bfoffset_o = v; ! 188: skipb( lptr ); ! 189: if ( cinfo[ *lptr ] == COL) ! 190: lptr ++; ! 191: else ! 192: PROG_ERROR(E_OPERAND); ! 193: spare_oper = zero_oper; ! 194: lptr = scan_reg_or_immed( lptr, &spare_oper); ! 195: v = spare_oper.value_o; ! 196: if (spare_oper.type_o == T_REG){ ! 197: opnd->flags_o |= O_BFWREG; ! 198: } else if ((spare_oper.sym_o && !(spare_oper.sym_o->attr_s&S_DEF)) ! 199: || v < 0 || v > 32){ ! 200: PROG_ERROR(E_CONSTANT); ! 201: } ! 202: opnd->bfwidth_o = (v == 32 ? 0 : v); ! 203: skipb( lptr ); ! 204: if ( cinfo[ *lptr ] == RB ) ! 205: lptr++; ! 206: else ! 207: PROG_ERROR(E_OPERAND); ! 208: } ! 209: return(lptr); ! 210: } /* end soperand */ ! 211: ! 212: static char * ! 213: scan_reg_or_immed( lptr, o ) ! 214: register char *lptr; ! 215: register struct oper *o; ! 216: { ! 217: skipb( lptr ); ! 218: if (cinfo[*lptr] == IMM) { ! 219: lptr = exp(++lptr,o); ! 220: if (o->type_o == T_REG) ! 221: PROG_ERROR(E_REG); ! 222: if (o->sym_o && !(o->sym_o->attr_s&S_DEF)) ! 223: PROG_ERROR(E_REG); ! 224: o->type_o = T_IMMED; ! 225: } else { ! 226: lptr = exp( lptr, o ); ! 227: if ( o->type_o != T_REG || o->value_o > D7REG) ! 228: PROG_ERROR(E_OPERAND); ! 229: } ! 230: return lptr; ! 231: } ! 232: ! 233: static char * ! 234: opt_length( lptr, fp, wflag, lflag, bflag ) ! 235: register char * lptr; ! 236: struct suffix * fp; ! 237: { ! 238: char * save = lptr; ! 239: if (cinfo[ *lptr ] == COL){ ! 240: lptr++; ! 241: skipb( lptr ); ! 242: switch ( *lptr ){ ! 243: case 'b': ! 244: case 'B': ! 245: if (bflag == 0) return save ; ! 246: fp->flags_sx |= bflag; ! 247: lptr++; ! 248: break; ! 249: case 'l': ! 250: case 'L': ! 251: fp->flags_sx |= lflag; ! 252: lptr++; ! 253: break; ! 254: case 'w': ! 255: case 'W': ! 256: fp->flags_sx |= wflag; ! 257: lptr++; ! 258: break; ! 259: default: return save; /* : yes, length, no: may be scale */ ! 260: } ! 261: } ! 262: return lptr; ! 263: } ! 264: static char * ! 265: opt_scale( lptr, fp ) ! 266: char * lptr; ! 267: struct suffix * fp; ! 268: { ! 269: fp->scale_sx = 1; ! 270: if (cinfo[ *lptr ] == COL){ ! 271: lptr++; ! 272: skipb( lptr ); ! 273: switch ( *lptr ){ ! 274: case '1': ! 275: case '2': ! 276: case '4': ! 277: case '8': ! 278: fp->scale_sx = *lptr - '0'; ! 279: lptr++; ! 280: break; ! 281: default: PROG_ERROR(E_OPERAND); ! 282: } ! 283: } ! 284: return lptr; ! 285: } ! 286: ! 287: static char * ! 288: suffix( lptr, fixp ) ! 289: register char * lptr; ! 290: register struct suffix * fixp; ! 291: { ! 292: /* ! 293: * scan for open paran. look for displacement, optional length ! 294: * specifier, then index register, optional length specifier, ! 295: * optional scale specifier. ! 296: * fill in suffix structure with what we find. ! 297: */ ! 298: struct oper o; ! 299: o = zero_oper; ! 300: *fixp = zero_suffix; ! 301: skipb( lptr ); ! 302: if (cinfo[ *lptr ] == LP ) ! 303: lptr += 1; ! 304: else ! 305: return lptr; /* guess that null suffix might be ok */ ! 306: lptr = exp( lptr , &o ); ! 307: if ( o.type_o == T_NORMAL ){ ! 308: fixp->disp_sx = o.value_o; ! 309: fixp->sym_sx = o.sym_o; ! 310: fixp->flags_sx |= SX_GOTDISP; ! 311: lptr = opt_length( lptr, fixp, SX_DISPW, SX_DISPL, SX_DISPB ); ! 312: skipb( lptr ); ! 313: if (cinfo[ *lptr ] == COM) ! 314: lptr = exp( ++lptr, &o ); ! 315: else ! 316: goto scan_rp; ! 317: } ! 318: /* now we're talking index */ ! 319: if ( o.type_o != T_REG ){ ! 320: PROG_ERROR( E_OPERAND); ! 321: } ! 322: fixp->flags_sx |= SX_GOTINDEX; ! 323: fixp->indx_sx = o.value_o; ! 324: lptr = opt_length( lptr, fixp, SX_INDXW, SX_INDXL, 0 ); ! 325: lptr = opt_scale( lptr, fixp ); ! 326: scan_rp: ! 327: skipb( lptr ); ! 328: if (cinfo[ *lptr ] == RP) ! 329: lptr ++; ! 330: else ! 331: PROG_ERROR( E_OPERAND); ! 332: return lptr; ! 333: } ! 334: ! 335: static ! 336: simplify1( oper, fp ) ! 337: register struct oper * oper; ! 338: register struct suffix *fp; ! 339: { ! 340: register bval = oper->value_o; ! 341: /* we have some form of deferred or indexed addressing here */ ! 342: /* try to make the best of it. */ ! 343: /* ! 344: * examples are: ! 345: * a0@(disp) ! 346: * a0@(disp,d0:w:2) ! 347: * a0@(d0:w:2) ! 348: * pc@(disp) ! 349: * pc@(disp,d0:w:2) ! 350: * pc@(d0:w:2) ! 351: * @(d0) ! 352: * @(disp,d0) ! 353: */ ! 354: switch (oper->type_o){ ! 355: case T_REG: ! 356: if( !(fp->flags_sx&(SX_GOTINDEX|SX_DISPL)) ){ ! 357: /* displacement mode */ ! 358: oper->type_o = T_DISPL; ! 359: oper->reg_o = bval; ! 360: oper->value_o = fp->disp_sx; ! 361: oper->sym_o = fp->sym_sx; ! 362: if (fp->flags_sx & SX_DISPW) ! 363: oper->flags_o|= O_WDISP; ! 364: else if (fp->flags_sx & SX_DISPB) { ! 365: PROG_ERROR(E_OPERAND); ! 366: oper->flags_o|= O_WDISP; ! 367: } ! 368: } else { ! 369: /* index mode */ ! 370: imode: ! 371: oper->type_o = T_INDEX; ! 372: oper->reg_o = bval; ! 373: oper->disp_o = fp->disp_sx; ! 374: oper->sym_o = fp->sym_sx; ! 375: if (fp->flags_sx&SX_GOTINDEX){ ! 376: oper->value_o = fp->indx_sx; ! 377: oper->scale_o = fp->scale_sx; ! 378: if (fp->flags_sx&SX_INDXW) ! 379: oper->flags_o|= O_WINDEX|O_PREINDEX; ! 380: else ! 381: oper->flags_o|= O_LINDEX|O_PREINDEX; ! 382: } else { ! 383: oper->value_o = 0; ! 384: oper->scale_o = 0; ! 385: } ! 386: if (fp->flags_sx & SX_DISPL) ! 387: oper->flags_o|= O_LDISP; ! 388: /* else short form indexing */ ! 389: else if (fp->flags_sx & SX_DISPW) ! 390: oper->flags_o|= O_WDISP; ! 391: else if (fp->flags_sx & SX_DISPB) ! 392: oper->flags_o|= O_BDISP; ! 393: } ! 394: return; ! 395: case T_NULL: ! 396: /* @(disp,d0) */ ! 397: /* @(d0) */ ! 398: /* index mode, supressed base */ ! 399: oper->type_o= T_INDEX; ! 400: oper->flags_o|= O_BSUPRESS; ! 401: oper->reg_o = A0REG; /* Supress THIS register */ ! 402: oper->disp_o= fp->disp_sx; ! 403: oper->sym_o= fp->sym_sx; ! 404: if(fp->flags_sx & SX_DISPL) ! 405: oper->flags_o |= O_LDISP; ! 406: else if (fp->flags_sx & SX_DISPW) ! 407: oper->flags_o |= O_WDISP; ! 408: else if (fp->flags_sx & SX_DISPB) { ! 409: PROG_ERROR(E_OPERAND); ! 410: oper->flags_o |= O_WDISP; ! 411: } ! 412: do_index: ! 413: if (fp->flags_sx & SX_GOTINDEX){ ! 414: oper->value_o = fp->indx_sx; ! 415: oper->scale_o = fp->scale_sx; ! 416: if (fp->flags_sx & (SX_INDXW) ) ! 417: oper->flags_o |= O_PREINDEX|O_WINDEX; ! 418: else ! 419: oper->flags_o |= O_PREINDEX|O_LINDEX; ! 420: } else { ! 421: oper->value_o = 0; ! 422: oper->scale_o = 0; ! 423: } ! 424: return; ! 425: case T_ABSS: ! 426: oper->flags_o = O_WDISP; ! 427: goto normal; ! 428: case T_ABSL: ! 429: oper->flags_o = O_LDISP; ! 430: goto normal; ! 431: case T_NORMAL: ! 432: /* disp@ */ ! 433: /* disp@(d0) */ ! 434: /* index mode, supressed base */ ! 435: oper->flags_o = 0; ! 436: normal: ! 437: oper->type_o = T_INDEX; ! 438: oper->flags_o|= O_BSUPRESS; ! 439: oper->reg_o = A0REG; /* Supress THIS register */ ! 440: oper->disp_o = oper->value_o; ! 441: if (fp->flags_sx&SX_GOTDISP) ! 442: PROG_ERROR(E_OPERAND); ! 443: goto do_index; ! 444: default: ! 445: PROG_ERROR(E_OPERAND); ! 446: } ! 447: } ! 448: ! 449: static ! 450: simplify2( oper, fp, dfp ) ! 451: register struct oper * oper; ! 452: struct suffix *fp; ! 453: register struct suffix *dfp; ! 454: { ! 455: /* ! 456: * we have a memory indirect operand. ! 457: * examples: ! 458: * a0@(disp:l,d0:l:4)@(disp:w) ! 459: * a0@(disp)@(disp,d0:l:4) ! 460: * a0@@ ! 461: * @(disp,d0)@(disp) ! 462: * @(d0)@ ! 463: * @(disp)@ ! 464: * @(disp,d0)@ ! 465: * @(disp)@(d0) ! 466: */ ! 467: simplify1( oper, fp ); ! 468: if (oper->type_o == T_DISPL){ ! 469: oper->type_o = T_INDEX; ! 470: oper->disp_o = oper->value_o; ! 471: oper->value_o = 0; ! 472: } ! 473: /* now build on that with second suffix */ ! 474: oper->flags_o |= O_INDIRECT; ! 475: oper->disp2_o = dfp->disp_sx; ! 476: oper->sym2_o = dfp->sym_sx; ! 477: if (dfp->flags_sx & SX_DISPL) ! 478: oper->flags_o |= O_LDISP2; ! 479: else if (dfp->flags_sx & SX_DISPW) ! 480: oper->flags_o |= O_WDISP2; ! 481: else if (dfp->flags_sx & SX_DISPB) { ! 482: PROG_ERROR(E_OPERAND); ! 483: oper->flags_o |= O_WDISP2; ! 484: } ! 485: if (dfp->flags_sx & SX_GOTINDEX){ ! 486: if (oper->flags_o&O_PREINDEX) ! 487: PROG_ERROR(E_OPERAND); ! 488: oper->value_o = dfp->indx_sx; ! 489: oper->flags_o |= O_POSTINDEX; ! 490: oper->scale_o = dfp->scale_sx; ! 491: if (dfp->flags_sx&SX_INDXW) ! 492: oper->flags_o |= O_WINDEX; ! 493: else ! 494: oper->flags_o |= O_LINDEX; ! 495: } ! 496: ! 497: } ! 498: ! 499: /* read expression */ ! 500: char * ! 501: exp(lptr, arg1) ! 502: register char *lptr; ! 503: register struct oper *arg1; ! 504: { ! 505: struct oper arg2; /* holds value of right hand term */ ! 506: register int i; ! 507: static struct oper zero_opr; ! 508: register char *lptr0 ; ! 509: ! 510: lptr0 = lptr ; /* Save pointer to beginning for ! 511: use by reglist. */ ! 512: skipb(lptr); /* Find the operator */ ! 513: i = cinfo[*lptr]; ! 514: if (i==EOL || i==COM){ /* nil operand is zero */ ! 515: arg1->sym_o = NULL; ! 516: arg1->value_o = 0; ! 517: return(lptr); ! 518: } ! 519: lptr = term( lptr, arg1 ); ! 520: ! 521: while (1) { ! 522: arg2 = zero_opr; ! 523: skipb(lptr); ! 524: switch (cinfo[*lptr]) { ! 525: case ADD: lptr = term( ++lptr, &arg2 ); ! 526: if (arg1->type_o==T_REG || arg2.type_o==T_REG) ! 527: break; ! 528: if (arg1->sym_o && arg2.sym_o) ! 529: if (pass==2) break; ! 530: if (arg2.sym_o) ! 531: arg1->sym_o = arg2.sym_o; ! 532: arg1->value_o += arg2.value_o; ! 533: arg1->flags_o |= arg2.flags_o&O_COMPLEX; ! 534: continue; ! 535: ! 536: case MUL: lptr = term(++lptr,&arg2); ! 537: if (arg1->type_o==T_REG || arg2.type_o==T_REG) ! 538: break; ! 539: if (arg1->sym_o || arg2.sym_o) ! 540: if (pass==2) break; ! 541: arg1->value_o *= arg2.value_o; ! 542: arg1->flags_o |= arg2.flags_o&O_COMPLEX; ! 543: continue; ! 544: ! 545: case DIV: lptr = term( ++lptr, &arg2 ); ! 546: if (arg1->type_o==T_REG || arg2.type_o==T_REG) ! 547: if (arg1->type_o==T_REG && arg2.type_o==T_REG) ! 548: { /* try move multiple */ ! 549: lptr = lptr0 ; ! 550: return(reglist( lptr, arg1)) ; ! 551: } ! 552: else break; ! 553: if (arg1->sym_o || arg2.sym_o) ! 554: if (pass==2) break; ! 555: else if (arg2.value_o == 0) arg2.value_o = 1; ! 556: arg1->value_o /= arg2.value_o; ! 557: arg1->flags_o |= arg2.flags_o&O_COMPLEX; ! 558: continue; ! 559: ! 560: case SUB: lptr = term( ++lptr, &arg2 ); ! 561: if (arg1->type_o==T_REG || arg2.type_o==T_REG) ! 562: if (arg1->type_o==T_REG && arg2.type_o==T_REG) ! 563: { /* try move multiple */ ! 564: lptr = lptr0 ; ! 565: return(reglist( lptr, arg1)) ; ! 566: } ! 567: else break; ! 568: if (arg2.sym_o){ /* if B is relocatable, */ ! 569: if (arg1->sym_o){ /* and A is relocatable, */ ! 570: if ((arg1->sym_o->csect_s == 0) && ! 571: ( arg2.sym_o->csect_s != 0)) ! 572: { /* special case: external - relocatable */ ! 573: arg1->flags_o |= O_COMPLEX; ! 574: } ! 575: else ! 576: if (arg2.sym_o->csect_s ! 577: != arg1->sym_o->csect_s ! 578: && pass == 2){ ! 579: break; /* break into error */ ! 580: } else { /* result is absolute (no offset) */ ! 581: arg1->sym_o = NULL; ! 582: /* but not a simple address for sdi's */ ! 583: arg1->flags_o |= O_COMPLEX; ! 584: } ! 585: } ! 586: else break; /* if B rel., and A is not, */ ! 587: /* then break into relocation error */ ! 588: } ! 589: arg1->value_o -= arg2.value_o; ! 590: continue; ! 591: ! 592: default: return(lptr); ! 593: } ! 594: PROG_ERROR(E_RELOCATE); ! 595: return(lptr); ! 596: } ! 597: } /* end exp <read expression> */ ! 598: ! 599: /* read term: either symbol, constant, or unary minus */ ! 600: char * ! 601: term( lptr, vp ) ! 602: register char *lptr; ! 603: register struct oper *vp; ! 604: { ! 605: register struct sym_bkt *sbp; ! 606: register int base = 10; ! 607: register long val; ! 608: register char *p; ! 609: register int i; ! 610: char savechar, *t; ! 611: char token[50]; ! 612: ! 613: *vp = zero_oper; ! 614: skipb(lptr); ! 615: i = cinfo[*lptr]; ! 616: ! 617: /* here for number */ ! 618: if (i & D){ ! 619: p = lptr; ! 620: val = 0; ! 621: if (*lptr == '0'){ ! 622: lptr++; ! 623: switch (*lptr ){ ! 624: case 'x': ! 625: case 'X': ! 626: lptr++; ! 627: /* hexidecimal number */ ! 628: while (1){ ! 629: if (cinfo[*lptr] & D) ! 630: val = val*16 + *lptr++ - '0'; ! 631: else if (*lptr>='A' && *lptr<='F') ! 632: val = val*16 + *lptr++ - 'A' + 10; ! 633: else if (*lptr>='a' && *lptr<='f') ! 634: val = val*16 + *lptr++ - 'a' + 10; ! 635: else break; ! 636: } ! 637: break; ! 638: case 'r': ! 639: case 'R': ! 640: lptr = scan_float( lptr, vp ); ! 641: return (lptr); ! 642: default: ! 643: /* octal number */ ! 644: while (cinfo[*lptr] & D){ ! 645: if (*lptr == '8' || *lptr == '9') ! 646: PROG_ERROR(E_CONSTANT); ! 647: val = val*8 + *lptr++ - '0'; ! 648: } ! 649: } ! 650: } else { ! 651: /* decimal number */ ! 652: while (cinfo[*lptr] & D) ! 653: val = val*10 + *lptr++ - '0'; ! 654: } ! 655: got_a_number: ! 656: if (*lptr == '$') ! 657: { lptr = p; goto sym; } ! 658: if (*lptr == 'b' || *lptr == 'f'){ ! 659: /* local label reference, of form [0-9][bh] */ ! 660: /* single digits only */ ! 661: if (lptr > p+1 ){ ! 662: PROG_ERROR(E_SYMLEN); ! 663: } ! 664: val = ll_val[*p-'0'] + (*lptr++=='f'); ! 665: if (val < 0 ) PROG_ERROR(E_SYMDEF); ! 666: sprintf(token, ll_format, *p, val); ! 667: sbp = lookup(token); ! 668: goto sym2; ! 669: ! 670: } ! 671: vp->value_o = val; ! 672: vp->sym_o = NULL; ! 673: vp->type_o = T_NORMAL; ! 674: return(lptr); ! 675: } ! 676: ! 677: /* here for symbol name */ ! 678: if (i & S) { ! 679: sym: t = lptr; ! 680: while (cinfo[*lptr] & T) ! 681: lptr++; ! 682: savechar = *lptr; ! 683: *lptr = '\0'; ! 684: sbp = lookup(t); /* find its symbol bucket */ ! 685: *lptr = savechar; ! 686: sym2: ! 687: if (sbp->attr_s & S_DEF) /* if it's defined, use its value */ ! 688: vp->value_o = sbp->value_s; ! 689: else ! 690: vp->value_o = 0; ! 691: if (sbp->attr_s & S_REG) { ! 692: vp->sym_o = NULL; ! 693: vp->type_o = T_REG; ! 694: } else { ! 695: vp->sym_o = ((sbp->attr_s & S_DEF) && ! 696: (sbp->csect_s == C_UNDEF )) ? 0 : sbp; ! 697: vp->type_o = T_NORMAL; ! 698: } ! 699: return(lptr); ! 700: } ! 701: ! 702: /* check for unary minus */ ! 703: if (i == SUB) { ! 704: lptr = term(++lptr,vp); ! 705: if (vp->sym_o) PROG_ERROR(E_RELOCATE); ! 706: vp->value_o = -(vp->value_o); ! 707: vp->fval_o = -(vp->fval_o); ! 708: vp->dval_o = -(vp->dval_o); ! 709: return(lptr); ! 710: } ! 711: ! 712: /* check for complement */ ! 713: if (i == NOT) { ! 714: lptr = term(++lptr,vp); ! 715: if (vp->sym_o) PROG_ERROR(E_RELOCATE); ! 716: vp->value_o = ~(vp->value_o); ! 717: return(lptr); ! 718: } ! 719: ! 720: /* here for string */ ! 721: if (i == QUO) { ! 722: vp->stringval_o = lptr+1; ! 723: /* scan over the quoted string, being careful of \-stuff */ ! 724: do{ ! 725: i = *++lptr; ! 726: if (i=='\\') ! 727: switch (i = *++lptr){ ! 728: case '"': i = '\\'; /* fake-out loop test by covering up \"*/ ! 729: } ! 730: }while (i!='\n' && i!='"'); ! 731: if (i == '\n'){ ! 732: PROG_ERROR(E_STRING); ! 733: } ! 734: *lptr++ = 0; ! 735: vp->sym_o = NULL; ! 736: vp->type_o = T_STRING; ! 737: return(lptr); ! 738: } ! 739: ! 740: /* new, improved kluge -- parens !! */ ! 741: if (i==LP) { ! 742: lptr = exp(++lptr, vp); ! 743: skipb(lptr); ! 744: if ((i=cinfo[*lptr]) == RP) { ! 745: lptr++; ! 746: } else { ! 747: PROG_ERROR( E_PAREN ); ! 748: } ! 749: return( lptr ); ! 750: } ! 751: ! 752: PROG_ERROR(E_TERM); ! 753: return(lptr); ! 754: } /* end term */ ! 755: ! 756: char lowcase( c ) ! 757: char c ; ! 758: { ! 759: if (('A' <= c) && (c <= 'Z')) return(c+32) ; else return(c) ; ! 760: } ! 761: ! 762: char * ! 763: scan_float( lptr, vp ) ! 764: register char * lptr; ! 765: struct oper *vp; ! 766: { ! 767: /* ! 768: * lptr address a string which is a 'd' or an 'f', followed ! 769: * by a floating-point number. The latter looks like: ! 770: * [+-]nan ! 771: * or [+-]nan( [0-9a-f]+ ) ! 772: * or [+-]inf ! 773: * or [+-][0-9]+[.[0-9]+][e[+-][0-9]+] ! 774: * Upper/lower case may be used interchangeably. ! 775: * For numbers, call atof to do the conversion work. ! 776: * We do not take great care in syntax checking the number. ! 777: */ ! 778: int s=0; ! 779: union{ double d; float f; int x[2]; } fp; ! 780: unsigned nanno, nanno2; ! 781: register char *nbegin; ! 782: char c; ! 783: ! 784: lptr++ ; /* Skip F or f. */ ! 785: nbegin = lptr ; ! 786: again: ! 787: switch (lowcase( *lptr++)){ ! 788: case '+': if (s) goto bad_num; s = 1; goto again; ! 789: case '-': if (s) goto bad_num; s = -1; goto again; ! 790: case 'n': /* nan */ ! 791: if (lowcase(*lptr++) != 'a') goto bad_num; ! 792: if (lowcase(*lptr++) != 'n') goto bad_num; ! 793: nanno = nanno2 = 0; ! 794: if (*lptr == '(') ! 795: { /* nan significand */ ! 796: lptr++ ; /* pass paren */ ! 797: while( isxdigit(c = *lptr++)){ ! 798: if (isdigit(c)) c -= '0'; ! 799: else if (isupper(c)) c -= 'a'-10; ! 800: else c -= 'A'-10; ! 801: nanno2 = (nanno2 << 8) | (nanno >> 24); ! 802: nanno = (nanno<<8) | c; ! 803: } ! 804: if (c != ')') goto bad_num; ! 805: } /* nan significand */ ! 806: if ((nanno | nanno2) == 0) nanno = -1 ; /* avoid zero nan */ ! 807: goto make_indef; ! 808: ! 809: case 'i': /* inf */ ! 810: if (lowcase(*lptr++) != 'n') goto bad_num; ! 811: if (lowcase(*lptr++) != 'f') goto bad_num; ! 812: if (strncmp(lptr,"inity",5) == 0) lptr += 5; ! 813: nanno = nanno2 = 0; ! 814: make_indef: ! 815: fp.x[0] = ((s<0)?0xfff00000:0x7ff00000) | nanno2; ! 816: fp.x[1] = nanno; ! 817: break; ! 818: case '0': case '1': case '2': case '3': case '4': ! 819: case '5': case '6': case '7': case '8': case '9': ! 820: /* scan for more digits */ ! 821: while( isdigit( c = *lptr++ ) ) ! 822: continue; ! 823: if (c != '.' ) ! 824: goto scan_exp; ! 825: /* FALL THROUGH */ ! 826: case '.': ! 827: /* scan for more digits */ ! 828: while( isdigit( c = *lptr++ ) ) ! 829: continue; ! 830: scan_exp: ! 831: s = 0; ! 832: switch(lowcase(c)){ ! 833: case '+': ! 834: case '-': ! 835: s = 1; ! 836: /* FALL THROUGH */ ! 837: case 'e': ! 838: switch ( c= *lptr++ ){ ! 839: case '+': ! 840: case '-': ! 841: if (s) goto bad_num; ! 842: c = *lptr++; ! 843: /* FALL THROUGH */ ! 844: default: ! 845: s = 0; /* count chars: 0 is not ok */ ! 846: while( isdigit(c) ){ ! 847: c = *lptr++; ! 848: s++; ! 849: } ! 850: if (s == 0) goto bad_num; ! 851: break; ! 852: } ! 853: break; ! 854: } ! 855: fp.d = atof( nbegin ); ! 856: lptr--; ! 857: break; ! 858: default: ! 859: bad_num: ! 860: PROG_ERROR( E_BADCHAR ); ! 861: return lptr; ! 862: } ! 863: vp->dval_o = fp.d; ! 864: vp->value_o = (int) fp.d; ! 865: vp->type_o = T_DOUBLE; ! 866: return lptr; ! 867: } ! 868: ! 869: static void ! 870: printoffset( v, s ) ! 871: struct sym_bkt *s; ! 872: { ! 873: if (s != NULL){ ! 874: fputs(s->name_s, stdout); ! 875: if (v) ! 876: printf("+%d", v); ! 877: } else { ! 878: printf("%d", v); ! 879: } ! 880: } ! 881: ! 882: static char *rnames[] = { ! 883: "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", ! 884: "a0", "a1", "a2", "a3", "a4", "a5", "a6", ! 885: "sp", "pc", "cc", "sr", "usp", "sfc", "dfc", "vbr", ! 886: }; ! 887: ! 888: static void ! 889: printindex( o ) ! 890: register struct oper *o; ! 891: { ! 892: printf(",%s:%c", rnames[o->value_o], ! 893: o->flags_o&O_WINDEX ? 'w' : 'l'); ! 894: if (o->scale_o != 1) printf(":%d", o->scale_o); ! 895: } ! 896: ! 897: printop( o ) ! 898: register struct oper *o; ! 899: { ! 900: switch (o->type_o){ ! 901: case T_REG: printf("%s", rnames[o->value_o]); break; ! 902: case T_DEFER: printf("%s@", rnames[o->value_o]); break; ! 903: case T_POSTINC: printf("%s@+", rnames[o->value_o]); break; ! 904: case T_PREDEC: printf("%s@-", rnames[o->value_o]); break; ! 905: case T_DISPL: printf("%s@(", rnames[o->reg_o]); ! 906: printoffset(o->value_o, o->sym_o); ! 907: putchar(')'); ! 908: break; ! 909: case T_INDEX: printf("%s@(", (o->flags_o&O_BSUPRESS) ! 910: ? "XX" : rnames[o->reg_o]); ! 911: printoffset(o->disp_o, o->sym_o); ! 912: if (o->flags_o & O_WDISP) fputs(":w", stdout); ! 913: else if (o->flags_o & O_LDISP) fputs(":l", stdout); ! 914: if (o->flags_o&O_PREINDEX) ! 915: printindex( o ); ! 916: putchar(')'); ! 917: if (o->flags_o&O_INDIRECT){ ! 918: fputs("@(", stdout); ! 919: printoffset(o->disp2_o, o->sym2_o); ! 920: if (o->flags_o&O_POSTINDEX) ! 921: printindex( o ); ! 922: putchar(')'); ! 923: } ! 924: break; ! 925: case T_ABSS: ! 926: case T_ABSL: ! 927: printoffset(o->value_o, o->sym_o); ! 928: fputs( (o->type_o == T_ABSS) ? ":w" : ":l", stdout); ! 929: break; ! 930: case T_IMMED: ! 931: putchar('#'); ! 932: /* FALL THROUGH */ ! 933: case T_NORMAL: ! 934: printoffset(o->value_o, o->sym_o); ! 935: break; ! 936: case T_STRING: ! 937: printf("\"%s\"", o->stringval_o); ! 938: break; ! 939: case T_REGPAIR: printf("%s:%s", rnames[o->value_o],rnames[o->reg_o]); ! 940: break; ! 941: case T_FLOAT: ! 942: case T_DOUBLE: printf("0d%g", o->dval_o ); break; ! 943: default: ! 944: printf("UNKNOWN(%d)", o->type_o); ! 945: break; ! 946: } ! 947: if (o->flags_o&O_BFLD){ ! 948: /* bit field */ ! 949: /* first the offset part */ ! 950: if (o->flags_o&O_BFOREG) ! 951: printf("[%s:",rnames[o->bfoffset_o]); ! 952: else ! 953: printf("[#%d:",o->bfoffset_o); ! 954: /* then the width part */ ! 955: if (o->flags_o&O_BFWREG) ! 956: printf("%s]",rnames[o->bfwidth_o]); ! 957: else ! 958: printf("#%d]",o->bfwidth_o); ! 959: } ! 960: putchar('\n'); ! 961: } ! 962: ! 963: int aregs ; /* Contains bits for a7..a0. */ ! 964: int dregs ; /* Contains bits for d7..d0. */ ! 965: int fregs ; /* Contains bits for fp7..fp0. */ ! 966: int cregs ; /* Contains bits for fpc..fpi. */ ! 967: int otheregs ; /* Contains 1 for any other regs encountered. */ ! 968: ! 969: storeg( n ) ! 970: int n ; ! 971: ! 972: { ! 973: if ((A0REG <= n) && (n <= A7REG)) aregs |= 1 << (n-A0REG) ; ! 974: else ! 975: if ((D0REG <= n) && (n <= D7REG)) dregs |= 1 << (n-D0REG) ; ! 976: else ! 977: if ((FP0REG <= n) && (n <= FP7REG)) fregs |= 1 << (n-FP0REG) ; ! 978: else ! 979: if ((FPCREG <= n) && (n <= FPIREG)) cregs |= 1 << (FPIREG-n) ; ! 980: else ! 981: otheregs = 1 ; ! 982: } ! 983: ! 984: storegs( m, n ) ! 985: int m, n ; ! 986: ! 987: { ! 988: int t ; ! 989: ! 990: if (m > n) ! 991: { ! 992: t = m ; ! 993: m = n ; ! 994: n = t ; ! 995: } ! 996: if ((A0REG <= m) && (n <= A7REG)) for (t=m ; t <= n ; ) aregs |= 1 << (t++-A0REG) ; ! 997: else ! 998: if ((D0REG <= m) && (n <= D7REG)) for (t=m ; t<=n ; ) dregs |= 1 << (t++-D0REG) ; ! 999: else ! 1000: if ((FP0REG <= m) && (n <= FP7REG)) for (t=m ; t<=n ; ) fregs |= 1 << (t++-FP0REG) ; ! 1001: else ! 1002: if ((FPCREG <= m) && (n <= FPIREG)) for (t=m ; t<=n ; ) cregs |= 1 << (FPIREG-t++) ; ! 1003: else ! 1004: otheregs = 1 ; ! 1005: } ! 1006: ! 1007: char * reglist ( lptr, arg1 ) ! 1008: ! 1009: char *lptr ; ! 1010: struct oper *arg1 ; ! 1011: ! 1012: /* ! 1013: reglist is called from exp when a register list operand is ! 1014: suspected. If it fails, E_RELOCATE occurs. ! 1015: */ ! 1016: ! 1017: { ! 1018: struct oper arg2 ; ! 1019: ! 1020: aregs = dregs = fregs = cregs = otheregs = 0 ; ! 1021: skipb(lptr) ; ! 1022: lptr = term(lptr, arg1) ; ! 1023: while (arg1->type_o == T_REG) ! 1024: { ! 1025: skipb(lptr) ; ! 1026: switch (cinfo[*lptr]) ! 1027: { ! 1028: case EOL: ! 1029: case COM: /* end of list */ ! 1030: { ! 1031: storeg(arg1->value_o) ; ! 1032: if (otheregs) break ; ! 1033: if ((aregs|dregs) != 0) ! 1034: { /* list of a's and d's */ ! 1035: if ((fregs|cregs) != 0) break ; ! 1036: arg1->type_o = T_REGLIST ; ! 1037: arg1->value_o = dregs | (aregs << 8) ; ! 1038: return(lptr) ; ! 1039: } ! 1040: else ! 1041: if (fregs != 0) ! 1042: { /* list of fp's */ ! 1043: if (cregs != 0) break ; ! 1044: arg1->type_o = T_FREGLIST ; ! 1045: arg1->value_o = fregs ; ! 1046: return(lptr) ; ! 1047: } ! 1048: else ! 1049: if (cregs != 0) ! 1050: { /* list of fc's */ ! 1051: arg1->type_o = T_FCREGLIST ; ! 1052: arg1->value_o = cregs ; ! 1053: return(lptr) ; ! 1054: } ! 1055: break ; ! 1056: } ! 1057: case DIV: /* rn/... */ ! 1058: { ! 1059: storeg(arg1->value_o) ; ! 1060: lptr++ ; ! 1061: skipb(lptr) ; ! 1062: lptr = term(lptr, arg1) ; ! 1063: continue ; ! 1064: } ! 1065: case SUB: /* rn-... */ ! 1066: { ! 1067: lptr = term (++lptr, &arg2) ; ! 1068: if (arg2.type_o != T_REG) break ; ! 1069: storegs(arg1->value_o,arg2.value_o) ; ! 1070: continue ; ! 1071: } ! 1072: } ! 1073: break ; ! 1074: } ! 1075: arg1->type_o = T_NULL ; /* Avoid problems later. */ ! 1076: PROG_ERROR(E_REGLIST) ; ! 1077: return(lptr) ; ! 1078: } ! 1079:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.