![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to c01.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / PDP11 / 11c|
Return to c01.c CVS log | Up to [Research Unix] / researchv10no / cmd / PDP11 / 11c |
1.1 ! root 1: /* ! 2: * C compiler ! 3: */ ! 4: ! 5: #include "c0.h" ! 6: ! 7: /* ! 8: * Called from tree, this routine takes the top 1, 2, or 3 ! 9: * operands on the expression stack, makes a new node with ! 10: * the operator op, and puts it on the stack. ! 11: * Essentially all the work is in inserting ! 12: * appropriate conversions. ! 13: */ ! 14: build(op) ! 15: { ! 16: register int t1; ! 17: int t2, t; ! 18: register union tree *p1, *p2, *p3; ! 19: int dope, leftc, cvn, pcvn; ! 20: ! 21: /* ! 22: * a[i] => *(a+i) ! 23: */ ! 24: if (op==LBRACK) { ! 25: build(PLUS); ! 26: op = STAR; ! 27: } ! 28: dope = opdope[op]; ! 29: t2 = INT; ! 30: if ((dope&BINARY)!=0) { ! 31: p2 = chkfun(disarray(*--cp)); ! 32: if (p2) ! 33: t2 = p2->t.type; ! 34: } ! 35: p1 = *--cp; ! 36: /* ! 37: * sizeof gets turned into a number here. ! 38: */ ! 39: if (op==SIZEOF) { ! 40: p1 = cblock(length(p1)); ! 41: p1->c.type = UNSIGN; ! 42: *cp++ = p1; ! 43: return; ! 44: } ! 45: if (op!=AMPER) { ! 46: p1 = disarray(p1); ! 47: if (op!=CALL) ! 48: p1 = chkfun(p1); ! 49: } ! 50: t1 = p1->t.type; ! 51: if (t1==CHAR) ! 52: t1 = INT; ! 53: else if (t1==UNCHAR) ! 54: t1 = UNSIGN; ! 55: if (t2==CHAR) ! 56: t2 = INT; ! 57: else if (t2==UNCHAR) ! 58: t2 = UNSIGN; ! 59: pcvn = 0; ! 60: t = INT; ! 61: switch (op) { ! 62: ! 63: case CAST: ! 64: if ((t1&XTYPE)==FUNC || (t1&XTYPE)==ARRAY) ! 65: error("Disallowed conversion"); ! 66: if (p1->t.type==UNCHAR) { ! 67: *cp++ = block(ETYPE, UNSIGN, (int *)NULL, (union str *)NULL, ! 68: TNULL, TNULL); ! 69: *cp++ = p2; ! 70: build(CAST); ! 71: *cp++ = cblock(0377); ! 72: build(AND); ! 73: return; ! 74: } ! 75: if (p2->t.type==CHAR || p2->t.type==UNCHAR) ! 76: p2 = block(PLUS, t2, (int *)NULL, (union str *)NULL, ! 77: p2, cblock(0)); ! 78: break; ! 79: ! 80: /* end of expression */ ! 81: case 0: ! 82: *cp++ = p1; ! 83: return; ! 84: ! 85: /* no-conversion operators */ ! 86: case QUEST: ! 87: if (p2->t.op!=COLON) ! 88: error("Illegal conditional"); ! 89: else ! 90: if (fold(QUEST, p1, p2)) ! 91: return; ! 92: ! 93: case SEQNC: ! 94: t = t2; ! 95: ! 96: case COMMA: ! 97: case LOGAND: ! 98: case LOGOR: ! 99: *cp++ = block(op, t, p2->t.subsp, p2->t.strp, p1, p2); ! 100: return; ! 101: ! 102: case EXCLA: ! 103: t1 = INT; ! 104: break; ! 105: ! 106: case CALL: ! 107: if ((t1&XTYPE) != FUNC) ! 108: error("Call of non-function"); ! 109: *cp++ = block(CALL,decref(t1),p1->t.subsp,p1->t.strp,p1,p2); ! 110: return; ! 111: ! 112: case STAR: ! 113: if ((t1&XTYPE) == FUNC) ! 114: error("Illegal indirection"); ! 115: *cp++ = block(STAR, decref(t1), p1->t.subsp, p1->t.strp, p1, TNULL); ! 116: return; ! 117: ! 118: case AMPER: ! 119: if (p1->t.op==NAME || p1->t.op==STAR) { ! 120: *cp++ = block(op,incref(p1->t.type),p1->t.subsp,p1->t.strp,p1,TNULL); ! 121: return; ! 122: } ! 123: error("Illegal lvalue"); ! 124: break; ! 125: ! 126: /* ! 127: * a.b goes to (&a)->b ! 128: */ ! 129: case DOT: ! 130: if (p1->t.op==CALL && t1==STRUCT) { ! 131: t1 = incref(t1); ! 132: setype(p1, t1, p1); ! 133: } else { ! 134: *cp++ = p1; ! 135: build(AMPER); ! 136: p1 = *--cp; ! 137: } ! 138: ! 139: /* ! 140: * In a->b, a is given the type ptr-to-structure element; ! 141: * then the offset is added in without conversion; ! 142: * then * is tacked on to access the member. ! 143: */ ! 144: case ARROW: ! 145: if (p2->t.op!=NAME || p2->t.tr1->n.hclass!=MOS) { ! 146: error("Illegal structure ref"); ! 147: *cp++ = p1; ! 148: return; ! 149: } ! 150: p2 = structident(p1, p2); ! 151: t2 = p2->n.htype; ! 152: if (t2==INT && p2->t.tr1->n.hflag&FFIELD) ! 153: t2 = UNSIGN; ! 154: t = incref(t2); ! 155: chkw(p1, -1); ! 156: setype(p1, t, p2); ! 157: *cp++ = block(PLUS, t, p2->t.subsp, p2->t.strp, ! 158: p1, cblock(p2->t.tr1->n.hoffset)); ! 159: build(STAR); ! 160: if (p2->t.tr1->n.hflag&FFIELD) ! 161: *cp++ = block(FSEL, UNSIGN, (int *)NULL, (union str *)NULL, ! 162: *--cp, p2->t.tr1->n.hstrp); ! 163: return; ! 164: } ! 165: if ((dope&LVALUE)!=0) ! 166: chklval(p1); ! 167: if ((dope&LWORD)!=0) ! 168: chkw(p1, LONG); ! 169: if ((dope&RWORD)!=0) ! 170: chkw(p2, LONG); ! 171: if ((t1==VOID && op!=CAST) || (t2==VOID && (op!=CAST || t1!=VOID))) { ! 172: error("Illegal use of void object"); ! 173: t = t1 = t2 = INT; ! 174: } ! 175: if ((dope&BINARY)==0) { ! 176: if (op==ITOF) ! 177: t1 = DOUBLE; ! 178: else if (op==FTOI) ! 179: t1 = INT; ! 180: if (!fold(op, p1, (union tree *)NULL)) ! 181: *cp++ = block(op, t1, p1->t.subsp, p1->t.strp, p1,TNULL); ! 182: return; ! 183: } ! 184: cvn = 0; ! 185: if (t1==STRUCT || t2==STRUCT) { ! 186: if (t1!=t2 || p1->t.strp != p2->t.strp) ! 187: error("Incompatible structures"); ! 188: cvn = 0; ! 189: } else ! 190: cvn = cvtab[lintyp(t1)][lintyp(t2)]; ! 191: leftc = (cvn>>4)&017; ! 192: cvn &= 017; ! 193: t = leftc? t2:t1; ! 194: if ((t==INT||t==CHAR) && (t1==UNSIGN||t2==UNSIGN)) ! 195: t = UNSIGN; ! 196: if (dope&ASSGOP || op==CAST) { ! 197: if (leftc && (op>=ASPLUS && op<=ASXOR)) { ! 198: assignop(op, p1, p2); ! 199: return; ! 200: } ! 201: t = t1; ! 202: if (op==ASSIGN) { ! 203: if (cvn==PTI) { ! 204: if (t1!=t2 || ((t1&TYPE)==STRUCT && p1->t.strp!=p2->t.strp)) { ! 205: error("Warning: mixed pointer assignment"); ! 206: nerror--; ! 207: } ! 208: cvn = leftc = 0; ! 209: } ! 210: } else if (op==CAST) { ! 211: if (cvn==ITP||cvn==PTI) ! 212: cvn = leftc = 0; ! 213: else if (cvn==LTP) { ! 214: if (leftc==0) ! 215: cvn = LTI; ! 216: else { ! 217: cvn = ITL; ! 218: leftc = 0; ! 219: } ! 220: } ! 221: } ! 222: if (leftc) ! 223: cvn = leftc; ! 224: leftc = 0; ! 225: } else if (op==COLON || op==MAX || op==MIN) { ! 226: if (t1>=PTR && t1==t2) ! 227: cvn = 0; ! 228: if (op!=COLON && (t1>=PTR || t2>=PTR)) ! 229: op += MAXP-MAX; ! 230: } else if (dope&RELAT) { ! 231: if (op>=LESSEQ && (t1>=PTR||t2>=PTR||(t1==UNSIGN||t2==UNSIGN) ! 232: && (t==INT||t==CHAR||t==UNSIGN))) ! 233: op += LESSEQP-LESSEQ; ! 234: if (cvn==ITP || cvn==PTI) ! 235: cvn = 0; ! 236: } ! 237: if (cvn==PTI) { ! 238: cvn = 0; ! 239: if (op==MINUS) { ! 240: pcvn++; ! 241: p1 = block(ITOL, LONG, (int *)NULL, (union str *)NULL, p1, TNULL); ! 242: p2 = block(ITOL, LONG, (int *)NULL, (union str *)NULL, p2, TNULL); ! 243: t = LONG; ! 244: } else { ! 245: if (t1!=t2 || (t1!=(PTR+CHAR) && t1!=(PTR+UNCHAR))) ! 246: cvn = XX; ! 247: } ! 248: } ! 249: if (cvn) { ! 250: if ((cvn==ITP || cvn==LTP) && (opdope[op]&PCVOK)==0) { ! 251: p3 = leftc? p1: p2; ! 252: if ((p3->t.op!=CON || p3->c.value!=0) ! 253: && (p3->t.op!=LCON || p3->l.lvalue!=0)) ! 254: cvn = XX; ! 255: else ! 256: cvn = 0; ! 257: } ! 258: t1 = plength(p1); ! 259: t2 = plength(p2); ! 260: if (cvn==XX || (cvn==PTI&&t1!=t2)) ! 261: error("Illegal conversion"); ! 262: else if (leftc) ! 263: p1 = convert(p1, t, cvn, t2); ! 264: else ! 265: p2 = convert(p2, t, cvn, t1); ! 266: } ! 267: if (dope&RELAT) ! 268: t = INT; ! 269: if (t==FLOAT) ! 270: t = DOUBLE; ! 271: if (t==CHAR) ! 272: t = INT; ! 273: if (op==CAST) { ! 274: if (t!=DOUBLE && (t!=INT || p2->t.type!=CHAR || p2->t.type!=UNCHAR)) { ! 275: p2->t.type = t; ! 276: p2->t.subsp = p1->t.subsp; ! 277: p2->t.strp = p1->t.strp; ! 278: } ! 279: if (t==INT && p1->t.type==CHAR) ! 280: p2 = block(ITOC, INT, (int *)NULL, (union str *)NULL, p2, TNULL); ! 281: *cp++ = p2; ! 282: return; ! 283: } ! 284: if (pcvn) ! 285: t2 = plength(p1->t.tr1); ! 286: if (fold(op, p1, p2)==0) { ! 287: p3 = leftc?p2:p1; ! 288: *cp++ = block(op, t, p3->t.subsp, p3->t.strp, p1, p2); ! 289: } ! 290: if (pcvn) { ! 291: p1 = *--cp; ! 292: *cp++ = convert(p1, 0, PTI, t2); ! 293: } ! 294: } ! 295: ! 296: union tree * ! 297: structident(p1, p2) ! 298: register union tree *p1, *p2; ! 299: { ! 300: register struct nmlist *np; ! 301: int vartypes = 0, namesame = 1; ! 302: ! 303: np = (struct nmlist *)p2->t.tr1; ! 304: for (;;) { ! 305: if (namesame && p1->t.type==STRUCT+PTR && p1->t.strp == np->sparent) { ! 306: p2->t.type = np->htype; ! 307: p2->t.strp = np->hstrp; ! 308: p2->t.subsp = np->hsubsp; ! 309: p2->t.tr1 = (union tree *)np; ! 310: return(p2); ! 311: } ! 312: np = np->nextnm; ! 313: if (np==NULL) ! 314: break; ! 315: namesame = 0; ! 316: if (strncmp(p2->t.tr1->n.name, np->name, NCPS) != 0) ! 317: continue; ! 318: if ((p2->t.tr1->n.hflag&FKIND) != (np->hflag&FMOS)) ! 319: continue; ! 320: namesame = 1; ! 321: if (p2->t.tr1->n.htype==np->htype && p2->t.tr1->n.hoffset==np->hoffset) ! 322: continue; ! 323: vartypes++; ! 324: } ! 325: if (vartypes) ! 326: error("Ambiguous structure reference for %.8s", p2->t.tr1->n.name); ! 327: else { ! 328: error("Warning: %.8s not member of cited struct/union", p2->t.tr1->n.name); ! 329: nerror--; ! 330: } ! 331: return(p2); ! 332: } ! 333: ! 334: /* ! 335: * Generate the appropriate conversion operator. ! 336: */ ! 337: union tree * ! 338: convert(p, t, cvn, len) ! 339: union tree *p; ! 340: { ! 341: register int op; ! 342: ! 343: if (cvn==0) ! 344: return(p); ! 345: op = cvntab[cvn]; ! 346: if (opdope[op]&BINARY) { ! 347: if (len==0) ! 348: error("Illegal conversion"); ! 349: return(block(op, t, (int *)NULL, (union str *)NULL, p, cblock(len))); ! 350: } ! 351: return(block(op, t, (int *)NULL, (union str *)NULL, p, TNULL)); ! 352: } ! 353: ! 354: /* ! 355: * Traverse an expression tree, adjust things ! 356: * so the types of things in it are consistent ! 357: * with the view that its top node has ! 358: * type at. ! 359: * Used with structure references. ! 360: */ ! 361: setype(p, t, newp) ! 362: register union tree *p, *newp; ! 363: register t; ! 364: { ! 365: for (;; p = p->t.tr1) { ! 366: p->t.subsp = newp->t.subsp; ! 367: p->t.strp = newp->t.strp; ! 368: p->t.type = t; ! 369: if (p->t.op==AMPER) ! 370: t = decref(t); ! 371: else if (p->t.op==STAR) ! 372: t = incref(t); ! 373: else if (p->t.op!=PLUS) ! 374: break; ! 375: } ! 376: } ! 377: ! 378: /* ! 379: * A mention of a function name is turned into ! 380: * a pointer to that function. ! 381: */ ! 382: union tree * ! 383: chkfun(p) ! 384: register union tree *p; ! 385: { ! 386: register int t; ! 387: ! 388: if (((t = p->t.type)&XTYPE)==FUNC && p->t.op!=ETYPE) ! 389: return(block(AMPER,incref(t),p->t.subsp,p->t.strp,p,TNULL)); ! 390: return(p); ! 391: } ! 392: ! 393: /* ! 394: * A mention of an array is turned into ! 395: * a pointer to the base of the array. ! 396: */ ! 397: union tree * ! 398: disarray(p) ! 399: register union tree *p; ! 400: { ! 401: register int t; ! 402: ! 403: if (p==NULL) ! 404: return(p); ! 405: /* check array & not MOS and not typer */ ! 406: if (((t = p->t.type)&XTYPE)!=ARRAY ! 407: || p->t.op==NAME && p->t.tr1->n.hclass==MOS ! 408: || p->t.op==ETYPE) ! 409: return(p); ! 410: p->t.subsp++; ! 411: *cp++ = p; ! 412: setype(p, decref(t), p); ! 413: build(AMPER); ! 414: return(*--cp); ! 415: } ! 416: ! 417: /* ! 418: * make sure that p is a ptr to a node ! 419: * with type int or char or 'okt.' ! 420: * okt might be nonexistent or 'long' ! 421: * (e.g. for <<). ! 422: */ ! 423: chkw(p, okt) ! 424: union tree *p; ! 425: { ! 426: register int t; ! 427: ! 428: if ((t=p->t.type)!=INT && t<PTR && t!=CHAR && t!=UNCHAR && t!=UNSIGN && t!=okt) ! 429: error("Illegal type of operand"); ! 430: return; ! 431: } ! 432: ! 433: /* ! 434: *'linearize' a type for looking up in the ! 435: * conversion table ! 436: */ ! 437: lintyp(t) ! 438: { ! 439: switch(t) { ! 440: ! 441: case INT: ! 442: case CHAR: ! 443: case UNSIGN: ! 444: case UNCHAR: ! 445: return(0); ! 446: ! 447: case FLOAT: ! 448: case DOUBLE: ! 449: return(1); ! 450: ! 451: case LONG: ! 452: return(2); ! 453: ! 454: default: ! 455: return(3); ! 456: } ! 457: } ! 458: ! 459: /* ! 460: * Report an error. ! 461: */ ! 462: /* VARARGS1 */ ! 463: error(s, p1, p2, p3, p4, p5, p6) ! 464: char *s; ! 465: { ! 466: nerror++; ! 467: if (filename[0]) ! 468: fprintf(stderr, "%s:", filename); ! 469: fprintf(stderr, "%d: ", line); ! 470: fprintf(stderr, s, p1, p2, p3, p4, p5, p6); ! 471: fprintf(stderr, "\n"); ! 472: } ! 473: ! 474: /* ! 475: * Generate a node in an expression tree, ! 476: * setting the operator, type, dimen/struct table ptrs, ! 477: * and the operands. ! 478: */ ! 479: union tree * ! 480: block(op, t, subs, str, p1,p2) ! 481: int *subs; ! 482: union str *str; ! 483: union tree *p1, *p2; ! 484: { ! 485: register union tree *p; ! 486: ! 487: p = (union tree *)Tblock(sizeof(struct tnode)); ! 488: p->t.op = op; ! 489: p->t.type = t; ! 490: p->t.subsp = subs; ! 491: p->t.strp = str; ! 492: p->t.tr1 = p1; ! 493: if (opdope[op]&BINARY) ! 494: p->t.tr2 = p2; ! 495: else ! 496: p->t.tr2 = NULL; ! 497: return(p); ! 498: } ! 499: ! 500: union tree * ! 501: nblock(ds) ! 502: register struct nmlist *ds; ! 503: { ! 504: return(block(NAME, ds->htype, ds->hsubsp, ds->hstrp, (union tree *)ds, TNULL)); ! 505: } ! 506: ! 507: /* ! 508: * Generate a block for a constant ! 509: */ ! 510: union tree * ! 511: cblock(v) ! 512: { ! 513: register union tree *p; ! 514: ! 515: p = (union tree *)Tblock(sizeof(struct cnode)); ! 516: p->c.op = CON; ! 517: p->c.type = INT; ! 518: p->c.subsp = NULL; ! 519: p->c.strp = NULL; ! 520: p->c.value = v; ! 521: return(p); ! 522: } ! 523: ! 524: /* ! 525: * A block for a float constant ! 526: */ ! 527: union tree * ! 528: fblock(t, string) ! 529: char *string; ! 530: { ! 531: register union tree *p; ! 532: ! 533: p = (union tree *)Tblock(sizeof(struct fnode)); ! 534: p->f.op = FCON; ! 535: p->f.type = t; ! 536: p->f.subsp = NULL; ! 537: p->f.strp = NULL; ! 538: p->f.cstr = string; ! 539: return(p); ! 540: } ! 541: ! 542: /* ! 543: * Assign a block for use in the ! 544: * expression tree. ! 545: */ ! 546: char * ! 547: Tblock(n) ! 548: { ! 549: register char *p; ! 550: ! 551: p = treebase; ! 552: if (p==NULL) { ! 553: error("c0 internal error: tree not active"); ! 554: exit(1); ! 555: } ! 556: if ((treebase += n) >= coremax) { ! 557: if (sbrk(1024) == (char *)-1) { ! 558: error("Out of space"); ! 559: exit(1); ! 560: } ! 561: coremax += 1024; ! 562: } ! 563: return(p); ! 564: } ! 565: ! 566: char * ! 567: starttree() ! 568: { ! 569: register char *st; ! 570: ! 571: st = treebase; ! 572: if (st==NULL) ! 573: treebot = treebase = locbase+DCLSLOP; ! 574: return(st); ! 575: } ! 576: ! 577: endtree(tp) ! 578: char *tp; ! 579: { ! 580: treebase = tp; ! 581: if (tp==NULL) ! 582: treebot = NULL; ! 583: } ! 584: ! 585: /* ! 586: * Assign a block for use in a declaration ! 587: */ ! 588: char * ! 589: Dblock(n) ! 590: { ! 591: register char *p; ! 592: ! 593: p = locbase; ! 594: locbase += n; ! 595: if (treebot && locbase > treebot) { ! 596: error("Too much declaring in an expression"); ! 597: exit(1); ! 598: } ! 599: if (locbase > coremax) { ! 600: if (sbrk(1024) == (char *)-1) { ! 601: error("out of space"); ! 602: exit(1); ! 603: } ! 604: coremax += 1024; ! 605: } ! 606: return(p); ! 607: } ! 608: ! 609: /* ! 610: * Check that a tree can be used as an lvalue. ! 611: */ ! 612: chklval(p) ! 613: register union tree *p; ! 614: { ! 615: if (p->t.op==FSEL) ! 616: p = p->t.tr1; ! 617: if (p->t.op!=NAME && p->t.op!=STAR) ! 618: error("Lvalue required"); ! 619: } ! 620: ! 621: /* ! 622: * reduce some forms of `constant op constant' ! 623: * to a constant. More of this is done in the next pass ! 624: * but this is used to allow constant expressions ! 625: * to be used in switches and array bounds. ! 626: */ ! 627: fold(op, p1, p2) ! 628: register union tree *p1; ! 629: union tree *p2; ! 630: { ! 631: register int v1, v2; ! 632: int unsignf; ! 633: ! 634: if (p1->t.op!=CON) ! 635: return(0); ! 636: unsignf = p1->c.type==UNSIGN; ! 637: if (op==QUEST) { ! 638: if (p2->t.tr1->t.op==CON && p2->t.tr2->t.op==CON) { ! 639: p1->c.value = p1->c.value? p2->t.tr1->c.value: p2->t.tr2->c.value; ! 640: *cp++ = p1; ! 641: p1->t.type = p2->t.type; ! 642: return(1); ! 643: } ! 644: return(0); ! 645: } ! 646: if (p2) { ! 647: if (p2->t.op!=CON) ! 648: return(0); ! 649: v2 = p2->c.value; ! 650: unsignf |= p2->c.type==UNSIGN; ! 651: } ! 652: v1 = p1->c.value; ! 653: switch (op) { ! 654: ! 655: case PLUS: ! 656: v1 += v2; ! 657: break; ! 658: ! 659: case MINUS: ! 660: v1 -= v2; ! 661: break; ! 662: ! 663: case TIMES: ! 664: v1 *= v2; ! 665: break; ! 666: ! 667: case DIVIDE: ! 668: if (v2==0) ! 669: goto divchk; ! 670: if (unsignf) { ! 671: if (v2==1) ! 672: break; ! 673: if (v2<0) { ! 674: v1 = (unsigned)v1 >= (unsigned)v2; ! 675: break; ! 676: } ! 677: v1 = (unsigned)v1 / v2; ! 678: break; ! 679: } ! 680: v1 /= v2; ! 681: break; ! 682: ! 683: case MOD: ! 684: if (v2==0) ! 685: goto divchk; ! 686: if (unsignf) { ! 687: if (v2==1) { ! 688: v1 = 0; ! 689: break; ! 690: } ! 691: if (v2<0) { ! 692: if ((unsigned)v1 >= (unsigned)v2) ! 693: v1 -= v2; ! 694: break; ! 695: } ! 696: v1 = (unsigned)v1 % v2; ! 697: break; ! 698: } ! 699: v1 %= v2; ! 700: break; ! 701: ! 702: case AND: ! 703: v1 &= v2; ! 704: break; ! 705: ! 706: case OR: ! 707: v1 |= v2; ! 708: break; ! 709: ! 710: case EXOR: ! 711: v1 ^= v2; ! 712: break; ! 713: ! 714: case NEG: ! 715: v1 = - v1; ! 716: break; ! 717: ! 718: case COMPL: ! 719: v1 = ~ v1; ! 720: break; ! 721: ! 722: case LSHIFT: ! 723: v1 <<= v2; ! 724: break; ! 725: ! 726: case RSHIFT: ! 727: if (unsignf) { ! 728: v1 = (unsigned)v1 >> v2; ! 729: break; ! 730: } ! 731: v1 >>= v2; ! 732: break; ! 733: ! 734: case EQUAL: ! 735: v1 = v1==v2; ! 736: break; ! 737: ! 738: case NEQUAL: ! 739: v1 = v1!=v2; ! 740: break; ! 741: ! 742: case LESS: ! 743: v1 = v1<v2; ! 744: break; ! 745: ! 746: case GREAT: ! 747: v1 = v1>v2; ! 748: break; ! 749: ! 750: case LESSEQ: ! 751: v1 = v1<=v2; ! 752: break; ! 753: ! 754: case GREATEQ: ! 755: v1 = v1>=v2; ! 756: break; ! 757: ! 758: divchk: ! 759: error("Divide check"); ! 760: nerror--; ! 761: default: ! 762: return(0); ! 763: } ! 764: p1->c.value = v1; ! 765: *cp++ = p1; ! 766: if (unsignf) ! 767: p1->t.type = UNSIGN; ! 768: return(1); ! 769: } ! 770: ! 771: /* ! 772: * Compile an expression expected to have constant value, ! 773: * for example an array bound or a case value. ! 774: */ ! 775: conexp() ! 776: { ! 777: register union tree *t; ! 778: ! 779: initflg++; ! 780: if (t = tree(1)) ! 781: if (t->t.op != CON) ! 782: error("Constant required"); ! 783: initflg--; ! 784: return(t->c.value); ! 785: } ! 786: ! 787: /* ! 788: * Handle peculiar assignment ops that need a temporary. ! 789: */ ! 790: assignop(op, p1, p2) ! 791: register union tree *p1, *p2; ! 792: { ! 793: register struct nmlist *np; ! 794: ! 795: op += PLUS - ASPLUS; ! 796: if (p1->t.op==NAME) { ! 797: *cp++ = p1; ! 798: *cp++ = p1; ! 799: *cp++ = p2; ! 800: build(op); ! 801: build(ASSIGN); ! 802: return; ! 803: } ! 804: np = gentemp(incref(p1->t.type)); ! 805: *cp++ = nblock(np); ! 806: *cp++ = p1; ! 807: build(AMPER); ! 808: build(ASSIGN); ! 809: *cp++ = nblock(np); ! 810: build(STAR); ! 811: *cp++ = nblock(np); ! 812: build(STAR); ! 813: *cp++ = p2; ! 814: build(op); ! 815: build(ASSIGN); ! 816: build(SEQNC); ! 817: } ! 818: ! 819: /* ! 820: * Generate an automatic temporary for ! 821: * use in certain assignment ops ! 822: */ ! 823: struct nmlist * ! 824: gentemp(type) ! 825: { ! 826: register struct nmlist *tp; ! 827: ! 828: tp = (struct nmlist *)Tblock(sizeof(struct nmlist)); ! 829: tp->hclass = AUTO; ! 830: tp->htype = type; ! 831: tp->hflag = 0; ! 832: tp->hsubsp = NULL; ! 833: tp->hstrp = NULL; ! 834: tp->hblklev = blklev; ! 835: autolen -= rlength((union tree *)tp); ! 836: tp->hoffset = autolen; ! 837: if (autolen < maxauto) ! 838: maxauto = autolen; ! 839: return(tp); ! 840: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.