![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to put.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / ucb / pascal / src|
Return to put.c CVS log | Up to [CSRG BSD Unix] / 43BSD / ucb / pascal / src |
1.1 ! root 1: /* ! 2: * Copyright (c) 1980 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[] = "@(#)put.c 5.1 (Berkeley) 6/18/85"; ! 9: #endif not lint ! 10: ! 11: #include "whoami.h" ! 12: #include "opcode.h" ! 13: #include "0.h" ! 14: #include "objfmt.h" ! 15: #ifdef PC ! 16: # include "pc.h" ! 17: # include "align.h" ! 18: #else ! 19: short *obufp = obuf; ! 20: #endif ! 21: ! 22: /* ! 23: * If DEBUG is defined, include the table ! 24: * of the printing opcode names. ! 25: */ ! 26: #ifdef DEBUG ! 27: #include "OPnames.h" ! 28: #endif ! 29: ! 30: #ifdef OBJ ! 31: /* ! 32: * Put is responsible for the interpreter equivalent of code ! 33: * generation. Since the interpreter is specifically designed ! 34: * for Pascal, little work is required here. ! 35: */ ! 36: /*VARARGS*/ ! 37: put(a) ! 38: { ! 39: register int *p, i; ! 40: register char *cp; ! 41: register short *sp; ! 42: register long *lp; ! 43: int n, subop, suboppr, op, oldlc; ! 44: char *string; ! 45: static int casewrd; ! 46: ! 47: /* ! 48: * It would be nice to do some more ! 49: * optimizations here. The work ! 50: * done to collapse offsets in lval ! 51: * should be done here, the IFEQ etc ! 52: * relational operators could be used ! 53: * etc. ! 54: */ ! 55: oldlc = (int) lc; /* its either this or change put to return a char * */ ! 56: if ( !CGENNING ) ! 57: /* ! 58: * code disabled - do nothing ! 59: */ ! 60: return (oldlc); ! 61: p = &a; ! 62: n = *p++; ! 63: suboppr = subop = (*p >> 8) & 0377; ! 64: op = *p & 0377; ! 65: string = 0; ! 66: #ifdef DEBUG ! 67: if ((cp = otext[op]) == NIL) { ! 68: printf("op= %o\n", op); ! 69: panic("put"); ! 70: } ! 71: #endif ! 72: switch (op) { ! 73: case O_ABORT: ! 74: cp = "*"; ! 75: break; ! 76: case O_AS: ! 77: switch(p[1]) { ! 78: case 0: ! 79: break; ! 80: case 2: ! 81: op = O_AS2; ! 82: n = 1; ! 83: break; ! 84: case 4: ! 85: op = O_AS4; ! 86: n = 1; ! 87: break; ! 88: case 8: ! 89: op = O_AS8; ! 90: n = 1; ! 91: break; ! 92: default: ! 93: goto pack; ! 94: } ! 95: # ifdef DEBUG ! 96: cp = otext[op]; ! 97: # endif DEBUG ! 98: break; ! 99: case O_FOR1U: ! 100: case O_FOR2U: ! 101: case O_FOR4U: ! 102: case O_FOR1D: ! 103: case O_FOR2D: ! 104: case O_FOR4D: ! 105: /* relative addressing */ ! 106: p[1] -= ( unsigned ) lc + sizeof(short); ! 107: /* try to pack the jump */ ! 108: if (p[1] <= 127 && p[1] >= -128) { ! 109: suboppr = subop = p[1]; ! 110: p++; ! 111: n--; ! 112: } else { ! 113: /* have to allow for extra displacement */ ! 114: p[1] -= sizeof(short); ! 115: } ! 116: break; ! 117: case O_CONG: ! 118: case O_LVCON: ! 119: case O_CON: ! 120: case O_LINO: ! 121: case O_NEW: ! 122: case O_DISPOSE: ! 123: case O_DFDISP: ! 124: case O_IND: ! 125: case O_OFF: ! 126: case O_INX2: ! 127: case O_INX4: ! 128: case O_CARD: ! 129: case O_ADDT: ! 130: case O_SUBT: ! 131: case O_MULT: ! 132: case O_IN: ! 133: case O_CASE1OP: ! 134: case O_CASE2OP: ! 135: case O_CASE4OP: ! 136: case O_FRTN: ! 137: case O_WRITES: ! 138: case O_WRITEC: ! 139: case O_WRITEF: ! 140: case O_MAX: ! 141: case O_MIN: ! 142: case O_ARGV: ! 143: case O_CTTOT: ! 144: case O_INCT: ! 145: case O_RANG2: ! 146: case O_RSNG2: ! 147: case O_RANG42: ! 148: case O_RSNG42: ! 149: case O_SUCC2: ! 150: case O_SUCC24: ! 151: case O_PRED2: ! 152: case O_PRED24: ! 153: if (p[1] == 0) ! 154: break; ! 155: case O_CON2: ! 156: case O_CON24: ! 157: pack: ! 158: if (p[1] <= 127 && p[1] >= -128) { ! 159: suboppr = subop = p[1]; ! 160: p++; ! 161: n--; ! 162: if (op == O_CON2) { ! 163: op = O_CON1; ! 164: # ifdef DEBUG ! 165: cp = otext[O_CON1]; ! 166: # endif DEBUG ! 167: } ! 168: if (op == O_CON24) { ! 169: op = O_CON14; ! 170: # ifdef DEBUG ! 171: cp = otext[O_CON14]; ! 172: # endif DEBUG ! 173: } ! 174: } ! 175: break; ! 176: case O_CON8: ! 177: { ! 178: short *sp = (short *) (&p[1]); ! 179: ! 180: #ifdef DEBUG ! 181: if ( opt( 'k' ) ) ! 182: printf ( "%5d\tCON8\t%22.14e\n" , ! 183: lc - HEADER_BYTES , ! 184: * ( ( double * ) &p[1] ) ); ! 185: #endif ! 186: # ifdef DEC11 ! 187: word(op); ! 188: # else ! 189: word(op << 8); ! 190: # endif DEC11 ! 191: for ( i = 1 ; i <= 4 ; i ++ ) ! 192: word ( *sp ++ ); ! 193: return ( oldlc ); ! 194: } ! 195: default: ! 196: if (op >= O_REL2 && op <= O_REL84) { ! 197: if ((i = (subop >> INDX) * 5 ) >= 30) ! 198: i -= 30; ! 199: else ! 200: i += 2; ! 201: #ifdef DEBUG ! 202: string = &"IFEQ\0IFNE\0IFLT\0IFGT\0IFLE\0IFGE"[i]; ! 203: #endif ! 204: suboppr = 0; ! 205: } ! 206: break; ! 207: case O_IF: ! 208: case O_TRA: ! 209: /***** ! 210: codeline = 0; ! 211: *****/ ! 212: /* relative addressing */ ! 213: p[1] -= ( unsigned ) lc + sizeof(short); ! 214: break; ! 215: case O_CONC: ! 216: #ifdef DEBUG ! 217: (string = "'x'")[1] = p[1]; ! 218: #endif ! 219: suboppr = 0; ! 220: op = O_CON1; ! 221: # ifdef DEBUG ! 222: cp = otext[O_CON1]; ! 223: # endif DEBUG ! 224: subop = p[1]; ! 225: goto around; ! 226: case O_CONC4: ! 227: #ifdef DEBUG ! 228: (string = "'x'")[1] = p[1]; ! 229: #endif ! 230: suboppr = 0; ! 231: op = O_CON14; ! 232: subop = p[1]; ! 233: goto around; ! 234: case O_CON1: ! 235: case O_CON14: ! 236: suboppr = subop = p[1]; ! 237: around: ! 238: n--; ! 239: break; ! 240: case O_CASEBEG: ! 241: casewrd = 0; ! 242: return (oldlc); ! 243: case O_CASEEND: ! 244: if ((unsigned) lc & 1) { ! 245: lc--; ! 246: word(casewrd); ! 247: } ! 248: return (oldlc); ! 249: case O_CASE1: ! 250: #ifdef DEBUG ! 251: if (opt('k')) ! 252: printf("%5d\tCASE1\t%d\n" ! 253: , lc - HEADER_BYTES, p[1]); ! 254: #endif ! 255: /* ! 256: * this to build a byte size case table ! 257: * saving bytes across calls in casewrd ! 258: * so they can be put out by word() ! 259: */ ! 260: lc++; ! 261: if ((unsigned) lc & 1) ! 262: # ifdef DEC11 ! 263: casewrd = p[1] & 0377; ! 264: # else ! 265: casewrd = (p[1] & 0377) << 8; ! 266: # endif DEC11 ! 267: else { ! 268: lc -= 2; ! 269: # ifdef DEC11 ! 270: word(((p[1] & 0377) << 8) | casewrd); ! 271: # else ! 272: word((p[1] & 0377) | casewrd); ! 273: # endif DEC11 ! 274: } ! 275: return (oldlc); ! 276: case O_CASE2: ! 277: #ifdef DEBUG ! 278: if (opt('k')) ! 279: printf("%5d\tCASE2\t%d\n" ! 280: , lc - HEADER_BYTES , p[1]); ! 281: #endif ! 282: word(p[1]); ! 283: return (oldlc); ! 284: case O_PUSH: ! 285: lp = (long *)&p[1]; ! 286: if (*lp == 0) ! 287: return (oldlc); ! 288: /* and fall through */ ! 289: case O_RANG4: ! 290: case O_RANG24: ! 291: case O_RSNG4: ! 292: case O_RSNG24: ! 293: case O_SUCC4: ! 294: case O_PRED4: ! 295: /* sub opcode optimization */ ! 296: lp = (long *)&p[1]; ! 297: if (*lp < 128 && *lp >= -128 && *lp != 0) { ! 298: suboppr = subop = *lp; ! 299: p += (sizeof(long) / sizeof(int)); ! 300: n--; ! 301: } ! 302: goto longgen; ! 303: case O_TRA4: ! 304: case O_CALL: ! 305: case O_FSAV: ! 306: case O_GOTO: ! 307: case O_NAM: ! 308: case O_READE: ! 309: /* absolute long addressing */ ! 310: lp = (long *)&p[1]; ! 311: *lp -= HEADER_BYTES; ! 312: goto longgen; ! 313: case O_RV1: ! 314: case O_RV14: ! 315: case O_RV2: ! 316: case O_RV24: ! 317: case O_RV4: ! 318: case O_RV8: ! 319: case O_RV: ! 320: case O_LV: ! 321: /* ! 322: * positive offsets represent arguments ! 323: * and must use "ap" display entry rather ! 324: * than the "fp" entry ! 325: */ ! 326: if (p[1] >= 0) { ! 327: subop++; ! 328: suboppr++; ! 329: } ! 330: # ifdef PDP11 ! 331: break; ! 332: # else ! 333: /* ! 334: * offsets out of range of word addressing ! 335: * must use long offset opcodes ! 336: */ ! 337: if (p[1] < SHORTADDR && p[1] >= -SHORTADDR) ! 338: break; ! 339: else { ! 340: op += O_LRV - O_RV; ! 341: # ifdef DEBUG ! 342: cp = otext[op]; ! 343: # endif DEBUG ! 344: } ! 345: /* and fall through */ ! 346: # endif PDP11 ! 347: case O_BEG: ! 348: case O_NODUMP: ! 349: case O_CON4: ! 350: case O_CASE4: ! 351: longgen: ! 352: n = (n << 1) - 1; ! 353: if ( op == O_LRV ) { ! 354: n--; ! 355: # if defined(ADDR32) && !defined(DEC11) ! 356: p[n / 2] <<= 16; ! 357: # endif ! 358: } ! 359: #ifdef DEBUG ! 360: if (opt('k')) { ! 361: printf("%5d\t%s", lc - HEADER_BYTES, cp+1); ! 362: if (suboppr) ! 363: printf(":%d", suboppr); ! 364: for ( i = 2, lp = (long *)&p[1]; i < n ! 365: ; i += sizeof ( long )/sizeof ( short ) ) ! 366: printf( "\t%D " , *lp ++ ); ! 367: if (i == n) { ! 368: sp = (short *)lp; ! 369: printf( "\t%d ", *sp ); ! 370: } ! 371: pchr ( '\n' ); ! 372: } ! 373: #endif ! 374: if ( op != O_CASE4 ) ! 375: # ifdef DEC11 ! 376: word((op & 0377) | subop << 8); ! 377: # else ! 378: word(op << 8 | (subop & 0377)); ! 379: # endif DEC11 ! 380: for ( i = 1, sp = (short *)&p[1]; i < n; i++) ! 381: word ( *sp ++ ); ! 382: return ( oldlc ); ! 383: } ! 384: #ifdef DEBUG ! 385: if (opt('k')) { ! 386: printf("%5d\t%s", lc - HEADER_BYTES, cp+1); ! 387: if (suboppr) ! 388: printf(":%d", suboppr); ! 389: if (string) ! 390: printf("\t%s",string); ! 391: if (n > 1) ! 392: pchr('\t'); ! 393: for (i=1; i<n; i++) ! 394: printf("%d ", p[i]); ! 395: pchr('\n'); ! 396: } ! 397: #endif ! 398: if (op != NIL) ! 399: # ifdef DEC11 ! 400: word((op & 0377) | subop << 8); ! 401: # else ! 402: word(op << 8 | (subop & 0377)); ! 403: # endif DEC11 ! 404: for (i=1; i<n; i++) ! 405: word(p[i]); ! 406: return (oldlc); ! 407: } ! 408: #endif OBJ ! 409: ! 410: /* ! 411: * listnames outputs a list of enumerated type names which ! 412: * can then be selected from to output a TSCAL ! 413: * a pointer to the address in the code of the namelist ! 414: * is kept in value[ NL_ELABEL ]. ! 415: */ ! 416: listnames(ap) ! 417: ! 418: register struct nl *ap; ! 419: { ! 420: struct nl *next; ! 421: #ifdef OBJ ! 422: register int oldlc; ! 423: #endif ! 424: register int len; ! 425: register unsigned w; ! 426: register char *strptr; ! 427: ! 428: if ( !CGENNING ) ! 429: /* code is off - do nothing */ ! 430: return(NIL); ! 431: if (ap->class != TYPE) ! 432: ap = ap->type; ! 433: if (ap->value[ NL_ELABEL ] != 0) { ! 434: /* the list already exists */ ! 435: return( ap -> value[ NL_ELABEL ] ); ! 436: } ! 437: # ifdef OBJ ! 438: oldlc = (int) lc; /* same problem as put */ ! 439: (void) put(2, O_TRA, lc); ! 440: ap->value[ NL_ELABEL ] = (int) lc; ! 441: # endif OBJ ! 442: # ifdef PC ! 443: putprintf(" .data", 0); ! 444: aligndot(A_STRUCT); ! 445: ap -> value[ NL_ELABEL ] = (int) getlab(); ! 446: (void) putlab((char *) ap -> value[ NL_ELABEL ] ); ! 447: # endif PC ! 448: /* number of scalars */ ! 449: next = ap->type; ! 450: len = next->range[1]-next->range[0]+1; ! 451: # ifdef OBJ ! 452: (void) put(2, O_CASE2, len); ! 453: # endif OBJ ! 454: # ifdef PC ! 455: putprintf( " .word %d" , 0 , len ); ! 456: # endif PC ! 457: /* offsets of each scalar name */ ! 458: len = (len+1)*sizeof(short); ! 459: # ifdef OBJ ! 460: (void) put(2, O_CASE2, len); ! 461: # endif OBJ ! 462: # ifdef PC ! 463: putprintf( " .word %d" , 0 , len ); ! 464: # endif PC ! 465: next = ap->chain; ! 466: do { ! 467: for(strptr = next->symbol; *strptr++; len++) ! 468: continue; ! 469: len++; ! 470: # ifdef OBJ ! 471: (void) put(2, O_CASE2, len); ! 472: # endif OBJ ! 473: # ifdef PC ! 474: putprintf( " .word %d" , 0 , len ); ! 475: # endif PC ! 476: } while (next = next->chain); ! 477: /* list of scalar names */ ! 478: strptr = getnext(ap, &next); ! 479: # ifdef OBJ ! 480: do { ! 481: # ifdef DEC11 ! 482: w = (unsigned) *strptr; ! 483: # else ! 484: w = *strptr << 8; ! 485: # endif DEC11 ! 486: if (!*strptr++) ! 487: strptr = getnext(next, &next); ! 488: # ifdef DEC11 ! 489: w |= *strptr << 8; ! 490: # else ! 491: w |= (unsigned) *strptr; ! 492: # endif DEC11 ! 493: if (!*strptr++) ! 494: strptr = getnext(next, &next); ! 495: word((int) w); ! 496: } while (next); ! 497: /* jump over the mess */ ! 498: patch((PTR_DCL) oldlc); ! 499: # endif OBJ ! 500: # ifdef PC ! 501: while ( next ) { ! 502: while ( *strptr ) { ! 503: putprintf( " .byte 0%o" , 1 , *strptr++ ); ! 504: for ( w = 2 ; ( w <= 8 ) && *strptr ; w ++ ) { ! 505: putprintf( ",0%o" , 1 , *strptr++ ); ! 506: } ! 507: putprintf( "" , 0 ); ! 508: } ! 509: putprintf( " .byte 0" , 0 ); ! 510: strptr = getnext( next , &next ); ! 511: } ! 512: putprintf( " .text" , 0 ); ! 513: # endif PC ! 514: return( ap -> value[ NL_ELABEL ] ); ! 515: } ! 516: ! 517: char * ! 518: getnext(next, new) ! 519: ! 520: struct nl *next, **new; ! 521: { ! 522: if (next != NIL) { ! 523: next = next->chain; ! 524: *new = next; ! 525: } ! 526: if (next == NLNIL) ! 527: return(""); ! 528: #ifdef OBJ ! 529: if (opt('k') && CGENNING ) ! 530: printf("%5d\t\t\"%s\"\n", lc-HEADER_BYTES, next->symbol); ! 531: #endif OBJ ! 532: return(next->symbol); ! 533: } ! 534: ! 535: #ifdef OBJ ! 536: /* ! 537: * Putspace puts out a table ! 538: * of nothing to leave space ! 539: * for the case branch table e.g. ! 540: */ ! 541: putspace(n) ! 542: int n; ! 543: { ! 544: register i; ! 545: ! 546: if ( !CGENNING ) ! 547: /* ! 548: * code disabled - do nothing ! 549: */ ! 550: return; ! 551: #ifdef DEBUG ! 552: if (opt('k')) ! 553: printf("%5d\t.=.+%d\n", lc - HEADER_BYTES, n); ! 554: #endif ! 555: for (i = even(n); i > 0; i -= 2) ! 556: word(0); ! 557: } ! 558: ! 559: putstr(sptr, padding) ! 560: ! 561: char *sptr; ! 562: int padding; ! 563: { ! 564: register unsigned short w; ! 565: register char *strptr = sptr; ! 566: register int pad = padding; ! 567: ! 568: if ( !CGENNING ) ! 569: /* ! 570: * code disabled - do nothing ! 571: */ ! 572: return; ! 573: #ifdef DEBUG ! 574: if (opt('k')) ! 575: printf("%5d\t\t\"%s\"\n", lc-HEADER_BYTES, strptr); ! 576: #endif ! 577: if (pad == 0) { ! 578: do { ! 579: # ifdef DEC11 ! 580: w = (unsigned short) * strptr; ! 581: # else ! 582: w = (unsigned short)*strptr<<8; ! 583: # endif DEC11 ! 584: if (w) ! 585: # ifdef DEC11 ! 586: w |= *++strptr << 8; ! 587: # else ! 588: w |= *++strptr; ! 589: # endif DEC11 ! 590: word((int) w); ! 591: } while (*strptr++); ! 592: } else { ! 593: # ifdef DEC11 ! 594: do { ! 595: w = (unsigned short) * strptr; ! 596: if (w) { ! 597: if (*++strptr) ! 598: w |= *strptr << 8; ! 599: else { ! 600: w |= ' ' << 8; ! 601: pad--; ! 602: } ! 603: word((int) w); ! 604: } ! 605: } while (*strptr++); ! 606: # else ! 607: do { ! 608: w = (unsigned short)*strptr<<8; ! 609: if (w) { ! 610: if (*++strptr) ! 611: w |= *strptr; ! 612: else { ! 613: w |= ' '; ! 614: pad--; ! 615: } ! 616: word(w); ! 617: } ! 618: } while (*strptr++); ! 619: # endif DEC11 ! 620: while (pad > 1) { ! 621: # ifdef DEC11 ! 622: word(' ' | (' ' << 8)); ! 623: # else ! 624: word((' ' << 8) | ' '); ! 625: # endif DEC11 ! 626: pad -= 2; ! 627: } ! 628: if (pad == 1) ! 629: # ifdef DEC11 ! 630: word(' '); ! 631: # else ! 632: word(' ' << 8); ! 633: # endif DEC11 ! 634: else ! 635: word(0); ! 636: } ! 637: } ! 638: #endif OBJ ! 639: ! 640: #ifndef PC ! 641: lenstr(sptr, padding) ! 642: ! 643: char *sptr; ! 644: int padding; ! 645: ! 646: { ! 647: register int cnt; ! 648: register char *strptr = sptr; ! 649: ! 650: cnt = padding; ! 651: do { ! 652: cnt++; ! 653: } while (*strptr++); ! 654: return((++cnt) & ~1); ! 655: } ! 656: #endif ! 657: ! 658: /* ! 659: * Patch repairs the branch ! 660: * at location loc to come ! 661: * to the current location. ! 662: * for PC, this puts down the label ! 663: * and the branch just references that label. ! 664: * lets here it for two pass assemblers. ! 665: */ ! 666: patch(loc) ! 667: PTR_DCL loc; ! 668: { ! 669: ! 670: # ifdef OBJ ! 671: patchfil(loc, (long)(lc-loc-2), 1); ! 672: # endif OBJ ! 673: # ifdef PC ! 674: (void) putlab((char *) loc ); ! 675: # endif PC ! 676: } ! 677: ! 678: #ifdef OBJ ! 679: patch4(loc) ! 680: PTR_DCL loc; ! 681: { ! 682: patchfil(loc, (long)(lc - HEADER_BYTES), 2); ! 683: } ! 684: ! 685: /* ! 686: * Patchfil makes loc+2 have jmploc ! 687: * as its contents. ! 688: */ ! 689: patchfil(loc, jmploc, words) ! 690: PTR_DCL loc; ! 691: long jmploc; ! 692: int words; ! 693: { ! 694: register i; ! 695: extern long lseek(); ! 696: short val; ! 697: ! 698: if ( !CGENNING ) ! 699: return; ! 700: if (loc > (unsigned) lc) ! 701: panic("patchfil"); ! 702: #ifdef DEBUG ! 703: if (opt('k')) ! 704: printf("\tpatch %u %D\n", loc - HEADER_BYTES, jmploc); ! 705: #endif ! 706: val = jmploc; ! 707: do { ! 708: # ifndef DEC11 ! 709: if (words > 1) ! 710: val = jmploc >> 16; ! 711: else ! 712: val = jmploc; ! 713: # endif DEC11 ! 714: i = ((unsigned) loc + 2 - ((unsigned) lc & ~01777))/2; ! 715: if (i >= 0 && i < 1024) { ! 716: obuf[i] = val; ! 717: } else { ! 718: (void) lseek(ofil, (long) loc+2, 0); ! 719: write(ofil, (char *) (&val), 2); ! 720: (void) lseek(ofil, (long) 0, 2); ! 721: } ! 722: loc += 2; ! 723: # ifdef DEC11 ! 724: val = jmploc >> 16; ! 725: # endif DEC11 ! 726: } while (--words); ! 727: } ! 728: ! 729: /* ! 730: * Put the word o into the code ! 731: */ ! 732: word(o) ! 733: int o; ! 734: { ! 735: ! 736: *obufp = o; ! 737: obufp++; ! 738: lc += 2; ! 739: if (obufp >= obuf+512) ! 740: pflush(); ! 741: } ! 742: ! 743: extern char *obj; ! 744: /* ! 745: * Flush the code buffer ! 746: */ ! 747: pflush() ! 748: { ! 749: register i; ! 750: ! 751: i = (obufp - ( ( short * ) obuf ) ) * 2; ! 752: if (i != 0 && write(ofil, (char *) obuf, i) != i) ! 753: perror(obj), pexit(DIED); ! 754: obufp = obuf; ! 755: } ! 756: #endif OBJ ! 757: ! 758: /* ! 759: * Getlab - returns the location counter. ! 760: * included here for the eventual code generator. ! 761: * for PC, thank you! ! 762: */ ! 763: char * ! 764: getlab() ! 765: { ! 766: # ifdef OBJ ! 767: ! 768: return (lc); ! 769: # endif OBJ ! 770: # ifdef PC ! 771: static long lastlabel; ! 772: ! 773: return ( (char *) ++lastlabel ); ! 774: # endif PC ! 775: } ! 776: ! 777: /* ! 778: * Putlab - lay down a label. ! 779: * for PC, just print the label name with a colon after it. ! 780: */ ! 781: char * ! 782: putlab(l) ! 783: char *l; ! 784: { ! 785: ! 786: # ifdef PC ! 787: putprintf( PREFIXFORMAT , 1 , (int) LABELPREFIX , (int) l ); ! 788: putprintf( ":" , 0 ); ! 789: # endif PC ! 790: return (l); ! 791: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.