![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to c02.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 c02.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: * Process a single external definition ! 9: */ ! 10: extdef() ! 11: { ! 12: register o; ! 13: int sclass, scflag; ! 14: struct nmlist typer; ! 15: register struct nmlist *ds; ! 16: ! 17: if(((o=symbol())==EOFC) || o==SEMI) ! 18: return; ! 19: peeksym = o; ! 20: sclass = 0; ! 21: blklev = 0; ! 22: if (getkeywords(&sclass, &typer)==0) { ! 23: sclass = EXTERN; ! 24: if (peeksym!=NAME) ! 25: goto syntax; ! 26: } ! 27: scflag = 0; ! 28: if (sclass==DEFXTRN) { ! 29: scflag++; ! 30: sclass = EXTERN; ! 31: } ! 32: if (sclass!=EXTERN && sclass!=STATIC && sclass!=TYPEDEF) ! 33: error("Illegal storage class"); ! 34: do { ! 35: defsym = 0; ! 36: paraml = NULL; ! 37: parame = NULL; ! 38: if (sclass==TYPEDEF) { ! 39: decl1(TYPEDEF, &typer, 0, (struct nmlist *)NULL); ! 40: continue; ! 41: } ! 42: decl1(EXTERN, &typer, 0, (struct nmlist *)NULL); ! 43: if ((ds=defsym)==0) ! 44: return; ! 45: funcsym = ds; ! 46: if ((ds->htype&XTYPE)==FUNC) { ! 47: if ((peeksym=symbol())==LBRACE || peeksym==KEYW ! 48: || (peeksym==NAME && csym->hclass==TYPEDEF)) { ! 49: funcblk.type = decref(ds->htype); ! 50: funcblk.strp = ds->hstrp; ! 51: setinit(ds); ! 52: outcode("BS", SYMDEF, sclass==EXTERN?ds->name:""); ! 53: cfunc(); ! 54: return; ! 55: } ! 56: if (paraml) ! 57: error("Inappropriate parameters"); ! 58: } else if ((o=symbol())==COMMA || o==SEMI) { ! 59: peeksym = o; ! 60: o = (length((union tree *)ds)+ALIGN) & ~ALIGN; ! 61: if (sclass==STATIC) { ! 62: setinit(ds); ! 63: outcode("BSBBSBN", SYMDEF, "", BSS, NLABEL, ds->name, SSPACE, o); ! 64: } else if (scflag) ! 65: outcode("BSN", CSPACE, ds->name, o); ! 66: } else { ! 67: if (o!=ASSIGN) { ! 68: error("Declaration syntax"); ! 69: peeksym = o; ! 70: } ! 71: setinit(ds); ! 72: if (sclass==EXTERN) ! 73: outcode("BS", SYMDEF, ds->name); ! 74: outcode("BBS", DATA, NLABEL, ds->name); ! 75: if (cinit(ds, 1, sclass) & ALIGN) ! 76: outcode("B", EVEN); ! 77: } ! 78: } while ((o=symbol())==COMMA); ! 79: if (o==SEMI) ! 80: return; ! 81: syntax: ! 82: if (o==RBRACE) { ! 83: error("Too many }'s"); ! 84: peeksym = 0; ! 85: return; ! 86: } ! 87: error("External definition syntax"); ! 88: errflush(o); ! 89: statement(); ! 90: } ! 91: ! 92: /* ! 93: * Process a function definition. ! 94: */ ! 95: cfunc() ! 96: { ! 97: register char *cb; ! 98: register sloc; ! 99: ! 100: sloc = isn; ! 101: isn += 2; ! 102: outcode("BBS", PROG, RLABEL, funcsym->name); ! 103: if (proflg) ! 104: outcode("BN", PROFIL, isn++); ! 105: regvar = 5; ! 106: autolen = STAUTO; ! 107: maxauto = STAUTO; ! 108: blklev = 1; ! 109: cb = locbase; ! 110: declist(ARG); ! 111: outcode("B", SAVE); ! 112: funchead(); ! 113: branch(sloc); ! 114: label(sloc+1); ! 115: retlab = isn++; ! 116: blklev = 0; ! 117: if ((peeksym = symbol()) != LBRACE) ! 118: error("Compound statement required"); ! 119: statement(); ! 120: outcode("BNB", LABEL, retlab, RETRN); ! 121: label(sloc); ! 122: outcode("BN", SETSTK, -maxauto); ! 123: branch(sloc+1); ! 124: locbase = cb; ! 125: } ! 126: ! 127: /* ! 128: * Process the initializers for an external definition. ! 129: */ ! 130: cinit(anp, flex, sclass) ! 131: struct nmlist *anp; ! 132: { ! 133: struct nmlist np; ! 134: register nel, ninit; ! 135: int width, isarray, o, brace, realtype; ! 136: union tree *s; ! 137: ! 138: np = *anp; ! 139: realtype = np.htype; ! 140: isarray = 0; ! 141: if ((realtype&XTYPE) == ARRAY) ! 142: isarray++; ! 143: else ! 144: flex = 0; ! 145: width = length((union tree *)&np); ! 146: nel = 1; ! 147: /* ! 148: * If it's an array, find the number of elements. ! 149: * temporarily modify to look like kind of thing it's ! 150: * an array of. ! 151: */ ! 152: if (sclass==AUTO) ! 153: if (isarray || realtype==STRUCT) ! 154: error("No auto. aggregate initialization"); ! 155: if (isarray) { ! 156: np.htype = decref(realtype); ! 157: np.hsubsp++; ! 158: if (width==0 && flex==0) ! 159: error("0-length row: %.8s", anp->name); ! 160: o = length((union tree *)&np); ! 161: nel = (unsigned)width/o; ! 162: width = o; ! 163: } ! 164: brace = 0; ! 165: if ((peeksym=symbol())==LBRACE && (isarray || np.htype!=STRUCT)) { ! 166: peeksym = -1; ! 167: brace++; ! 168: } ! 169: ninit = 0; ! 170: do { ! 171: if ((o=symbol())==RBRACE) ! 172: break; ! 173: peeksym = o; ! 174: if (o==STRING && (realtype==ARRAY+CHAR || realtype==ARRAY+UNCHAR)) { ! 175: if (sclass==AUTO) ! 176: error("No strings in automatic"); ! 177: peeksym = -1; ! 178: putstr(0, flex?10000:nel); ! 179: ninit += nchstr; ! 180: o = symbol(); ! 181: break; ! 182: } else if (np.htype==STRUCT) { ! 183: strinit(&np, sclass); ! 184: } else if ((np.htype&ARRAY)==ARRAY || peeksym==LBRACE) ! 185: cinit(&np, 0, sclass); ! 186: else { ! 187: char *st; ! 188: initflg++; ! 189: st = starttree(); ! 190: s = tree(0); ! 191: initflg = 0; ! 192: if (np.hflag&FFIELD) ! 193: error("No field initialization"); ! 194: *cp++ = nblock(&np); ! 195: *cp++ = s; ! 196: build(ASSIGN); ! 197: if (sclass==AUTO||sclass==REG) ! 198: rcexpr(*--cp); ! 199: else if (sclass==ENUMCON) { ! 200: if (s->t.op!=CON) ! 201: error("Illegal enum constant for %.8s", anp->name); ! 202: anp->hoffset = s->c.value; ! 203: } else ! 204: rcexpr(block(INIT,np.htype,(int *)NULL, ! 205: (union str *)NULL, (*--cp)->t.tr2, TNULL)); ! 206: endtree(st); ! 207: } ! 208: ninit++; ! 209: if ((ninit&077)==0 && sclass==EXTERN) ! 210: outcode("BS", SYMDEF, ""); ! 211: } while ((o=symbol())==COMMA && (ninit<nel || brace || flex)); ! 212: if (brace==0 || o!=RBRACE) ! 213: peeksym = o; ! 214: /* ! 215: * If there are too few initializers, allocate ! 216: * more storage. ! 217: * If there are too many initializers, extend ! 218: * the declared size for benefit of "sizeof" ! 219: */ ! 220: if (ninit<nel && sclass!=AUTO) ! 221: outcode("BN", SSPACE, (nel-ninit)*width); ! 222: else if (ninit>nel) { ! 223: if (flex && nel==0) { ! 224: np.hsubsp[-1] = ninit; ! 225: } else ! 226: error("Too many initializers: %.8s", anp->name); ! 227: nel = ninit; ! 228: } ! 229: return(nel*width); ! 230: } ! 231: ! 232: /* ! 233: * Initialize a structure ! 234: */ ! 235: strinit(np, sclass) ! 236: struct nmlist *np; ! 237: { ! 238: static struct nmlist junk; ! 239: register struct nmlist **mlp; ! 240: static struct nmlist *zerloc = NULL; ! 241: register int o, brace; ! 242: ! 243: if ((mlp = np->hstrp->S.memlist)==NULL) { ! 244: mlp = &zerloc; ! 245: error("Undefined structure initialization"); ! 246: } ! 247: brace = 0; ! 248: if ((o = symbol()) == LBRACE) ! 249: brace++; ! 250: else ! 251: peeksym = o; ! 252: do { ! 253: if ((o=symbol()) == RBRACE) ! 254: break; ! 255: peeksym = o; ! 256: if (*mlp==0) { ! 257: error("Too many structure initializers"); ! 258: cinit(&junk, 0, sclass); ! 259: } else ! 260: cinit(*mlp++, 0, sclass); ! 261: if (*mlp == &structhole) { ! 262: outcode("B", EVEN); ! 263: mlp++; ! 264: } ! 265: } while ((o=symbol())==COMMA && (*mlp || brace)); ! 266: if (sclass!=AUTO && sclass!=REG) { ! 267: if (*mlp) ! 268: outcode("BN", SSPACE, np->hstrp->S.ssize - (*mlp)->hoffset); ! 269: outcode("B", EVEN); ! 270: } ! 271: if (o!=RBRACE || brace==0) ! 272: peeksym = o; ! 273: } ! 274: ! 275: /* ! 276: * Mark already initialized ! 277: */ ! 278: setinit(np) ! 279: register struct nmlist *np; ! 280: { ! 281: ! 282: if (np->hflag&FINIT) ! 283: error("%s multiply defined", np->name); ! 284: np->hflag |= FINIT; ! 285: } ! 286: ! 287: /* ! 288: * Process one statement in a function. ! 289: */ ! 290: statement() ! 291: { ! 292: register o, o1; ! 293: int sauto, sreg; ! 294: ! 295: stmt: ! 296: switch(o=symbol()) { ! 297: ! 298: case EOFC: ! 299: error("Unexpected EOF"); ! 300: case SEMI: ! 301: return; ! 302: ! 303: case LBRACE: ! 304: sauto = autolen; ! 305: sreg = regvar; ! 306: blockhead(); ! 307: while (!eof) { ! 308: if ((o=symbol())==RBRACE) { ! 309: autolen = sauto; ! 310: if (sreg!=regvar) ! 311: outcode("BN", SETREG, sreg); ! 312: regvar = sreg; ! 313: blkend(); ! 314: return; ! 315: } ! 316: peeksym = o; ! 317: statement(); ! 318: } ! 319: error("Missing '}'"); ! 320: return; ! 321: ! 322: case KEYW: ! 323: switch(cval) { ! 324: ! 325: case GOTO: ! 326: if (o1 = simplegoto()) ! 327: branch(o1); ! 328: else ! 329: dogoto(); ! 330: goto semi; ! 331: ! 332: case RETURN: ! 333: doret(); ! 334: goto semi; ! 335: ! 336: case IF: { ! 337: register o2; ! 338: register union tree *np; ! 339: ! 340: np = pexpr(1); ! 341: o2 = 0; ! 342: if ((o1=symbol())==KEYW) switch (cval) { ! 343: case GOTO: ! 344: if (o2=simplegoto()) ! 345: goto simpif; ! 346: cbranch(np, o2=isn++, 0); ! 347: dogoto(); ! 348: label(o2); ! 349: goto hardif; ! 350: ! 351: case RETURN: ! 352: if (nextchar()==';') { ! 353: o2 = retlab; ! 354: goto simpif; ! 355: } ! 356: cbranch(np, o1=isn++, 0); ! 357: doret(); ! 358: label(o1); ! 359: o2++; ! 360: goto hardif; ! 361: ! 362: case BREAK: ! 363: o2 = brklab; ! 364: goto simpif; ! 365: ! 366: case CONTIN: ! 367: o2 = contlab; ! 368: simpif: ! 369: chconbrk(o2); ! 370: cbranch(np, o2, 1); ! 371: hardif: ! 372: if ((o=symbol())!=SEMI) ! 373: goto syntax; ! 374: if ((o1=symbol())==KEYW && cval==ELSE) ! 375: goto stmt; ! 376: peeksym = o1; ! 377: return; ! 378: } ! 379: peeksym = o1; ! 380: cbranch(np, o1=isn++, 0); ! 381: statement(); ! 382: if ((o=symbol())==KEYW && cval==ELSE) { ! 383: o2 = isn++; ! 384: branch(o2); ! 385: label(o1); ! 386: statement(); ! 387: label(o2); ! 388: return; ! 389: } ! 390: peeksym = o; ! 391: label(o1); ! 392: return; ! 393: } ! 394: ! 395: case WHILE: { ! 396: register o2; ! 397: o1 = contlab; ! 398: o2 = brklab; ! 399: label(contlab = isn++); ! 400: cbranch(pexpr(1), brklab=isn++, 0); ! 401: statement(); ! 402: branch(contlab); ! 403: label(brklab); ! 404: contlab = o1; ! 405: brklab = o2; ! 406: return; ! 407: } ! 408: ! 409: case BREAK: ! 410: chconbrk(brklab); ! 411: branch(brklab); ! 412: goto semi; ! 413: ! 414: case CONTIN: ! 415: chconbrk(contlab); ! 416: branch(contlab); ! 417: goto semi; ! 418: ! 419: case DO: { ! 420: register int o2, o3; ! 421: o1 = contlab; ! 422: o2 = brklab; ! 423: contlab = isn++; ! 424: brklab = isn++; ! 425: label(o3 = isn++); ! 426: statement(); ! 427: label(contlab); ! 428: contlab = o1; ! 429: if ((o=symbol())==KEYW && cval==WHILE) { ! 430: cbranch(tree(1), o3, 1); ! 431: label(brklab); ! 432: brklab = o2; ! 433: goto semi; ! 434: } ! 435: goto syntax; ! 436: } ! 437: ! 438: case CASE: ! 439: o1 = conexp(); ! 440: if ((o=symbol())!=COLON) ! 441: goto syntax; ! 442: if (swp==0) { ! 443: error("Case not in switch"); ! 444: goto stmt; ! 445: } ! 446: if(swp>=swtab+SWSIZ) { ! 447: error("Switch table overflow"); ! 448: } else { ! 449: swp->swlab = isn; ! 450: (swp++)->swval = o1; ! 451: label(isn++); ! 452: } ! 453: goto stmt; ! 454: ! 455: case SWITCH: { ! 456: register union tree *np; ! 457: register char *st; ! 458: ! 459: o1 = brklab; ! 460: brklab = isn++; ! 461: st = starttree(); ! 462: np = pexpr(0); ! 463: chkw(np, -1); ! 464: rcexpr(block(RFORCE,0,(int *)NULL,(union str *)NULL,np,TNULL)); ! 465: endtree(st); ! 466: pswitch(); ! 467: brklab = o1; ! 468: return; ! 469: } ! 470: ! 471: case DEFAULT: ! 472: if (swp==0) ! 473: error("Default not in switch"); ! 474: if (deflab) ! 475: error("More than 1 'default'"); ! 476: if ((o=symbol())!=COLON) ! 477: goto syntax; ! 478: label(deflab = isn++); ! 479: goto stmt; ! 480: ! 481: case FOR: { ! 482: register int o2; ! 483: o1 = contlab; ! 484: o2 = brklab; ! 485: contlab = isn++; ! 486: brklab = isn++; ! 487: if (o=forstmt()) ! 488: goto syntax; ! 489: contlab = o1; ! 490: brklab = o2; ! 491: return; ! 492: } ! 493: ! 494: case ELSE: ! 495: error("Inappropriate 'else'"); ! 496: statement(); ! 497: return; ! 498: } ! 499: error("Unknown keyword"); ! 500: goto syntax; ! 501: ! 502: case NAME: { ! 503: register struct nmlist *np; ! 504: if (nextchar()==':') { ! 505: peekc = 0; ! 506: np = csym; ! 507: if (np->hclass>0) { ! 508: if (np->hblklev==0) { ! 509: np = pushdecl(np); ! 510: np->hoffset = 0; ! 511: } else { ! 512: defsym = np; ! 513: redec(); ! 514: goto stmt; ! 515: } ! 516: } ! 517: np->hclass = STATIC; ! 518: np->htype = ARRAY; ! 519: np->hflag |= FLABL; ! 520: if (np->hoffset==0) ! 521: np->hoffset = isn++; ! 522: label(np->hoffset); ! 523: goto stmt; ! 524: } ! 525: } ! 526: } ! 527: peeksym = o; ! 528: rcexpr(tree(1)); ! 529: ! 530: semi: ! 531: if ((o=symbol())==SEMI) ! 532: return; ! 533: syntax: ! 534: error("Statement syntax"); ! 535: errflush(o); ! 536: } ! 537: ! 538: /* ! 539: * Process a for statement. ! 540: */ ! 541: forstmt() ! 542: { ! 543: register int o; ! 544: register union tree *st; ! 545: register l; ! 546: char *ss; ! 547: ! 548: if ((o=symbol()) != LPARN) ! 549: return(o); ! 550: if ((o=symbol()) != SEMI) { /* init part */ ! 551: peeksym = o; ! 552: rcexpr(tree(1)); ! 553: if ((o=symbol()) != SEMI) ! 554: return(o); ! 555: } ! 556: l = isn; ! 557: isn += 3; ! 558: branch(l+0); ! 559: label(l+1); ! 560: branch(l+2); ! 561: label(contlab); ! 562: st = NULL; ! 563: if ((o=symbol()) != SEMI) { /* test part */ ! 564: peeksym = o; ! 565: ss = starttree(); ! 566: st = tree(0); ! 567: if ((o=symbol()) != SEMI) { ! 568: endtree(ss); ! 569: return(o); ! 570: } ! 571: } ! 572: if ((o=symbol()) != RPARN) { /* incr part */ ! 573: peeksym = o; ! 574: rcexpr(tree(1)); ! 575: if ((o=symbol()) != RPARN) { ! 576: if (st) ! 577: endtree(ss); ! 578: return(o); ! 579: } ! 580: } ! 581: label(l+0); ! 582: if (st) { ! 583: cbranch(st, l+1, 1); ! 584: endtree(ss); ! 585: } else ! 586: branch(l+1); ! 587: branch(brklab); ! 588: label(l+2); ! 589: statement(); ! 590: branch(contlab); ! 591: label(brklab); ! 592: return(0); ! 593: } ! 594: ! 595: /* ! 596: * A parenthesized expression, ! 597: * as after "if". ! 598: */ ! 599: union tree * ! 600: pexpr(eflag) ! 601: { ! 602: register o; ! 603: register union tree *t; ! 604: ! 605: if ((o=symbol())!=LPARN) ! 606: goto syntax; ! 607: t = tree(eflag); ! 608: if ((o=symbol())!=RPARN) ! 609: goto syntax; ! 610: if (t->t.type==VOID) ! 611: error("Illegal use of void"); ! 612: return(t); ! 613: syntax: ! 614: error("Statement syntax"); ! 615: errflush(o); ! 616: return(0); ! 617: } ! 618: ! 619: /* ! 620: * The switch statement, which involves collecting the ! 621: * constants and labels for the cases. ! 622: */ ! 623: pswitch() ! 624: { ! 625: register struct swtab *cswp, *sswp; ! 626: int dl, swlab; ! 627: ! 628: cswp = sswp = swp; ! 629: if (swp==0) ! 630: cswp = swp = swtab; ! 631: branch(swlab=isn++); ! 632: dl = deflab; ! 633: deflab = 0; ! 634: statement(); ! 635: branch(brklab); ! 636: label(swlab); ! 637: if (deflab==0) ! 638: deflab = brklab; ! 639: outcode("BNN", SWIT, deflab, line); ! 640: for (; cswp < swp; cswp++) ! 641: outcode("NN", cswp->swlab, cswp->swval); ! 642: outcode("0"); ! 643: label(brklab); ! 644: deflab = dl; ! 645: swp = sswp; ! 646: } ! 647: ! 648: /* ! 649: * funchead is called at the start of each function ! 650: * to process the arguments, which have been linked in a list. ! 651: * This list is necessary because in ! 652: * f(a, b) float b; int a; ... ! 653: * the names are seen before the types. ! 654: */ ! 655: /* ! 656: * Structure resembling a block for a register variable. ! 657: */ ! 658: struct nmlist hreg = { REG, 0, 0, NULL, NULL, 0 }; ! 659: struct tnode areg = { NAME, 0, NULL, NULL, (union tree *)&hreg}; ! 660: funchead() ! 661: { ! 662: register pl; ! 663: register struct nmlist *cs; ! 664: register char *st; ! 665: ! 666: pl = STARG; ! 667: while(paraml) { ! 668: parame->sparent = NULL; ! 669: cs = paraml; ! 670: paraml = ¶ml->sparent->P; ! 671: if (cs->htype==FLOAT) ! 672: cs->htype = DOUBLE; ! 673: cs->hoffset = pl; ! 674: if ((cs->htype&XTYPE) == ARRAY) { ! 675: cs->htype -= (ARRAY-PTR); /* set ptr */ ! 676: cs->hsubsp++; /* pop dims */ ! 677: } ! 678: pl += rlength((union tree *)cs); ! 679: if (cs->hclass==AREG && (hreg.hoffset=goodreg(cs))>=0) { ! 680: st = starttree(); ! 681: *cp++ = (union tree *)&areg; ! 682: *cp++ = nblock(cs); ! 683: areg.type = cs->htype; ! 684: areg.strp = cs->hstrp; ! 685: cs->hclass = AUTO; ! 686: build(ASSIGN); ! 687: rcexpr(*--cp); ! 688: cs->hoffset = hreg.hoffset; ! 689: cs->hclass = REG; ! 690: endtree(st); ! 691: } else ! 692: cs->hclass = AUTO; ! 693: prste(cs); ! 694: } ! 695: for (pl=0; pl<HSHSIZ; pl++) { ! 696: for (cs = hshtab[pl]; cs!=NULL; cs = cs->nextnm) { ! 697: if (cs->hclass == ARG || cs->hclass==AREG) ! 698: error("Not an argument: %.8s", cs->name); ! 699: } ! 700: } ! 701: outcode("BN", SETREG, regvar); ! 702: } ! 703: ! 704: blockhead() ! 705: { ! 706: register r; ! 707: ! 708: r = regvar; ! 709: blklev++; ! 710: declist(0); ! 711: if (r != regvar) ! 712: outcode("BN", SETREG, regvar); ! 713: } ! 714: ! 715: /* ! 716: * After the end of a block, delete local ! 717: * symbols; ! 718: * Also complain about undefined labels. ! 719: */ ! 720: blkend() ! 721: { ! 722: register struct nmlist *cs, **lcs; ! 723: register i; ! 724: int nnames; ! 725: ! 726: blklev--; ! 727: nnames = 0; ! 728: for (i=0; i<HSHSIZ; i++) { ! 729: lcs = &hshtab[i]; ! 730: cs = *lcs; ! 731: while (cs) { ! 732: if (cs->hblklev > blklev ! 733: && (((cs->hflag&FLABL)==0 && cs->hclass!=EXTERN) || blklev<=0)) { ! 734: if (cs->hclass==0) ! 735: error("%.8s undefined", cs->name); ! 736: if (cs->hclass==EXTERN) ! 737: nameconflict(hshtab[i], cs); ! 738: *lcs = cs->nextnm; ! 739: } else { ! 740: lcs = &cs->nextnm; ! 741: nnames++; ! 742: } ! 743: cs = cs->nextnm; ! 744: } ! 745: } ! 746: } ! 747: ! 748: nameconflict(ocs, cs) ! 749: register struct nmlist *ocs, *cs; ! 750: { ! 751: ! 752: for (; ocs!=NULL; ocs = ocs->nextnm) ! 753: if (ocs!=cs && ocs->hclass==EXTERN && strncmp(cs->name, ocs->name, 7) == 0) ! 754: error("names %.8s and %.8s conflict", cs->name, ocs->name); ! 755: } ! 756: ! 757: /* ! 758: * write out special definitions of local symbols for ! 759: * benefit of the debugger. None of these are used ! 760: * by the assembler except to save them. ! 761: */ ! 762: prste(cs) ! 763: struct nmlist *cs; ! 764: { ! 765: register nkind; ! 766: ! 767: switch (cs->hclass) { ! 768: case REG: ! 769: nkind = RNAME; ! 770: break; ! 771: ! 772: case AUTO: ! 773: nkind = ANAME; ! 774: break; ! 775: ! 776: case STATIC: ! 777: nkind = SNAME; ! 778: break; ! 779: ! 780: default: ! 781: return; ! 782: ! 783: } ! 784: outcode("BSN", nkind, cs->name, cs->hoffset); ! 785: } ! 786: ! 787: /* ! 788: * In case of error, skip to the next ! 789: * statement delimiter. ! 790: */ ! 791: errflush(ao) ! 792: { ! 793: register o; ! 794: ! 795: o = ao; ! 796: while(o>RBRACE) { /* ; { } */ ! 797: if (o==STRING) ! 798: putstr(0, 0); ! 799: o = symbol(); ! 800: } ! 801: peeksym = o; ! 802: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.