![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to asmain.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / lib / old_compiler / as / as.tahoe|
Return to asmain.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / lib / old_compiler / as / as.tahoe |
1.1 ! root 1: /* ! 2: * Copyright (c) 1982 Regents of the University of California ! 3: */ ! 4: #ifndef lint ! 5: static char sccsid[] = "@(#)asmain.c 4.13 6/30/83"; ! 6: #endif not lint ! 7: ! 8: #include <stdio.h> ! 9: #include <ctype.h> ! 10: #include <signal.h> ! 11: ! 12: #include "as.h" ! 13: #include "assyms.h" ! 14: #include "asscan.h" ! 15: #include "asexpr.h" ! 16: ! 17: #define unix_lang_name "VAX/UNIX Assembler V6/30/83 4.13" ! 18: /* ! 19: * variables to manage reading the assembly source files ! 20: */ ! 21: char *dotsname; /*the current file name; managed by the parser*/ ! 22: int lineno; /*current line number; managed by the parser*/ ! 23: char **innames; /*names of the files being assembled*/ ! 24: int ninfiles; /*how many interesting files there are*/ ! 25: FILE *source; /*current source file (for listing) */ ! 26: char layout[400]; /*layout bytes */ ! 27: char *layoutpos = layout; /*layout position in listfile */ ! 28: int ind = 0; /*innames in-index: 0..minfiles */ ! 29: int endofsource = 0; ! 30: long sourcepos; ! 31: /* ! 32: * Flags settable from the argv process argument list ! 33: */ ! 34: int silent = 0; /*don't complain about any errors*/ ! 35: int savelabels = 0; /*write the labels to the a.out file*/ ! 36: int d124 = 4; /*default allocate 4 bytes for unknown pointers*/ ! 37: int anyerrs = 0; /*no errors yet*/ ! 38: int anywarnings=0; /*no warnings yet*/ ! 39: int orgwarn = 0; /*Bad origins*/ ! 40: int passno = 1; /* current pass*/ ! 41: int jxxxJUMP = 0; /* in jxxxes that branch too far, use jmp instead of brw */ ! 42: int readonlydata = 0; /* initialzed data -> text space */ ! 43: int liston = 0; /* don't produce listing */ ! 44: ! 45: ! 46: #ifdef DEBUG ! 47: int debug = 0; ! 48: int toktrace = 0; ! 49: #endif ! 50: ! 51: int useVM = 0; ! 52: ! 53: char *endcore; /*where to get more symbol space*/ ! 54: ! 55: /* ! 56: * Managers of the a.out file. ! 57: */ ! 58: struct exec hdr; ! 59: #define MAGIC 0407 ! 60: u_long tsize; /* total text size */ ! 61: u_long dsize; /* total data size */ ! 62: u_long datbase; /* base of the data segment */ ! 63: u_long trsize; /* total text relocation size */ ! 64: u_long drsize; /* total data relocation size */ ! 65: ! 66: /* ! 67: * Information about the current segment is accumulated in ! 68: * usedot; the most important information stored is the ! 69: * accumulated size of each of the text and data segments ! 70: * ! 71: * dotp points to the correct usedot expression for the current segment ! 72: */ ! 73: struct exp usedot[NLOC+NLOC]; /* info about all segments */ ! 74: struct exp *dotp; /* data/text location pointer */ ! 75: /* ! 76: * The inter pass temporary token file is opened and closed by stdio, but ! 77: * is written to using direct read/write, as the temporary file ! 78: * is composed of buffers exactly BUFSIZ long. ! 79: */ ! 80: FILE *tokfile; /* interpass communication file */ ! 81: char tokfilename[TNAMESIZE]; ! 82: /* ! 83: * The string file is the string table ! 84: * cat'ed to the end of the built up a.out file ! 85: */ ! 86: FILE *strfile; /* interpass string file */ ! 87: char strfilename[TNAMESIZE]; ! 88: int strfilepos = 0; /* position within the string file */ ! 89: /* ! 90: * a.out is created during the second pass. ! 91: * It is opened by stdio, but is filled with the parallel ! 92: * block I/O library ! 93: */ ! 94: char *outfile = "a.out"; ! 95: FILE *a_out_file; ! 96: off_t a_out_off; /* cumulative offsets for segments */ ! 97: /* ! 98: * The logical files containing the assembled data for each of ! 99: * the text and data segments are ! 100: * managed by the parallel block I/O library. ! 101: * a.out is logically opened in many places at once to ! 102: * receive the assembled data from the various segments as ! 103: * it all trickles in, but is physically opened only once ! 104: * to minimize file overhead. ! 105: */ ! 106: BFILE *usefile[NLOC+NLOC]; /* text/data files */ ! 107: BFILE *txtfil; /* current text/data file */ ! 108: /* ! 109: * Relocation information is accumulated seperately for each ! 110: * segment. This is required by the old loader (from BTL), ! 111: * but not by the new loader (Bill Joy). ! 112: * ! 113: * However, the size of the relocation information can not be computed ! 114: * during or after the 1st pass because the ''absoluteness' of values ! 115: * is unknown until all locally declared symbols have been seen. ! 116: * Thus, the size of the relocation information is only ! 117: * known after the second pass is finished. ! 118: * This obviates the use of the block I/O ! 119: * library, which requires knowing the exact offsets in a.out. ! 120: * ! 121: * So, we save the relocation information internally (we don't ! 122: * go to internal files to minimize overhead). ! 123: * ! 124: * Empirically, we studied 259 files composing the system, ! 125: * two compilers and a compiler generator: (all of which have ! 126: * fairly large source files) ! 127: * ! 128: * Number of files = 259 ! 129: * Number of non zero text reloc files: 233 ! 130: * Number of non zero data reloc files: 53 ! 131: * Average text relocation = 889 ! 132: * Average data relocation = 346 ! 133: * Number of files > BUFSIZ text relocation = 71 ! 134: * Number of files > BUFSIZ data relocation = 6 ! 135: * ! 136: * For compiled C code, there is usually one text segment and two ! 137: * data segments; we see that allocating our own buffers and ! 138: * doing our internal handling of relocation information will, ! 139: * on the average, not use more memory than taken up by the buffers ! 140: * allocated for doing file I/O in parallel to a number of file. ! 141: * ! 142: * If we are assembling with the -V option, we ! 143: * use the left over token buffers from the 2nd pass, ! 144: * otherwise, we create our own. ! 145: * ! 146: * When the 2nd pass is complete, closeoutrel flushes the token ! 147: * buffers out to a BFILE. ! 148: * ! 149: * The internals to relbufdesc are known only in assyms.c ! 150: * ! 151: * outrel constructs the relocation information. ! 152: * closeoutrel flushes the relocation information to relfil. ! 153: */ ! 154: struct relbufdesc *rusefile[NLOC+NLOC]; ! 155: struct relbufdesc *relfil; /* un concatnated relocation info */ ! 156: BFILE *relocfile; /* concatnated relocation info */ ! 157: /* ! 158: * Once the relocation information has been written, ! 159: * we can write out the symbol table using the Block I/O ! 160: * mechanisms, as we once again know the offsets into ! 161: * the a.out file. ! 162: * ! 163: * We use relfil to output the symbol table information. ! 164: */ ! 165: char *tmpdirprefix = "/tmp/"; ! 166: int delexit(); ! 167: ! 168: main(argc, argv) ! 169: int argc; ! 170: char **argv; ! 171: { ! 172: char *sbrk(); ! 173: ! 174: tokfilename[0] = 0; ! 175: strfilename[0] = 0; ! 176: endcore = sbrk(0); ! 177: ! 178: argprocess(argc, argv); /* process argument lists */ ! 179: if (anyerrs) exit(1); ! 180: ! 181: initialize(); ! 182: zeroorigins(); /* set origins to zero */ ! 183: zerolocals(); /* fix local label counters */ ! 184: ! 185: i_pass1(); /* open temp files, etc */ ! 186: pass1(); /* first pass through .s files */ ! 187: testlocals(); /* check for undefined locals */ ! 188: if (anyerrs) delexit(); ! 189: ! 190: pass1_5(); /* resolve jxxx */ ! 191: if (anyerrs) delexit(); ! 192: ! 193: open_a_out(); /* open a.out */ ! 194: roundsegments(); /* round segments to FW */ ! 195: build_hdr(); /* build initial header, and output */ ! 196: ! 197: i_pass2(); /* reopen temporary file, etc */ ! 198: pass2(); /* second pass through the virtual .s */ ! 199: if (anyerrs) delexit(); ! 200: ! 201: fillsegments(); /* fill segments with 0 to FW */ ! 202: reloc_syms(); /* dump relocation and symbol table */ ! 203: ! 204: delete(); /* remove tmp file */ ! 205: bflush(); /* close off block I/O view of a.out */ ! 206: fix_a_out(); /* add in text and data reloc counts */ ! 207: ! 208: if (anyerrs == 0 && orgwarn) ! 209: yyerror("Caution: absolute origins.\n"); ! 210: ! 211: exit(anyerrs != 0); ! 212: } ! 213: ! 214: argprocess(argc, argv) ! 215: int argc; ! 216: char *argv[]; ! 217: { ! 218: register char *cp; ! 219: ! 220: ninfiles = 0; ! 221: silent = 0; ! 222: #ifdef DEBUG ! 223: debug = 0; ! 224: #endif ! 225: innames = (char **)ClearCalloc(argc+1, sizeof (innames[0])); ! 226: dotsname = "<argv error>"; ! 227: while (argc > 1) { ! 228: if (argv[1][0] != '-') ! 229: innames[ninfiles++] = argv[1]; ! 230: else { ! 231: cp = argv[1] + 1; ! 232: /* ! 233: * We can throw away single minus signs, so ! 234: * that make scripts for the PDP 11 assembler work ! 235: * on this assembler too ! 236: */ ! 237: while (*cp){ ! 238: switch(*cp++){ ! 239: default: ! 240: yyerror("Unknown flag: %c", *--cp); ! 241: cp++; ! 242: break; ! 243: case 'v': ! 244: selfwhat(stdout); ! 245: exit(1); ! 246: case 'd': ! 247: d124 = *cp++ - '0'; ! 248: if ( (d124 != 1) && (d124 != 2) && ! 249: (d124 != 4)){ ! 250: yyerror("-d[124] only"); ! 251: exit(1); ! 252: } ! 253: break; ! 254: case 'P': ! 255: liston = 1; ! 256: listfile = stdout; ! 257: break; ! 258: case 'o': ! 259: if (argc < 3){ ! 260: yyerror("-o what???"); ! 261: exit(1); ! 262: } ! 263: outfile = argv[2]; ! 264: bumpone: ! 265: argc -= 2; ! 266: argv += 2; ! 267: goto nextarg; ! 268: ! 269: case 't': ! 270: if (argc < 3){ ! 271: yyerror("-t what???"); ! 272: exit(1); ! 273: } ! 274: tmpdirprefix = argv[2]; ! 275: goto bumpone; ! 276: ! 277: case 'V': ! 278: useVM = 1; ! 279: break; ! 280: case 'W': ! 281: silent = 1; ! 282: break; ! 283: case 'L': ! 284: savelabels = 1; ! 285: break; ! 286: case 'J': ! 287: jxxxJUMP = 1; ! 288: break; ! 289: #ifdef DEBUG ! 290: case 'D': ! 291: debug = 1; ! 292: break; ! 293: case 'T': ! 294: toktrace = 1; ! 295: break; ! 296: #endif ! 297: case 'R': ! 298: readonlydata = 1; ! 299: break; ! 300: } /*end of the switch*/ ! 301: } /*end of pulling out all arguments*/ ! 302: } /*end of a flag argument*/ ! 303: --argc; ++argv; ! 304: nextarg:; ! 305: } ! 306: /* innames[ninfiles] = 0; */ ! 307: } ! 308: /* ! 309: * poke through the data space and find all sccs identifiers. ! 310: * We assume: ! 311: * a) that extern char **environ; is the first thing in the bss ! 312: * segment (true, if one is using the new version of cmgt.crt0.c) ! 313: * b) that the sccsid's have not been put into text space. ! 314: */ ! 315: selfwhat(place) ! 316: FILE *place; ! 317: { ! 318: extern char **environ; ! 319: register char *ub; ! 320: register char *cp; ! 321: char *sbrk(); ! 322: ! 323: for (cp = (char *)&environ, ub = sbrk(0); cp < ub; cp++){ ! 324: if (cp[0] != '@') continue; ! 325: if (cp[1] != '(') continue; ! 326: if (cp[2] != '#') continue; ! 327: if (cp[3] != ')') continue; ! 328: fputc('\t', place); ! 329: for (cp += 4; cp < ub; cp++){ ! 330: if (*cp == 0) break; ! 331: if (*cp == '>') break; ! 332: if (*cp == '\n') break; ! 333: fputc(*cp, place); ! 334: } ! 335: fputc('\n', place); ! 336: } ! 337: } ! 338: ! 339: initialize() ! 340: { ! 341: if (signal(SIGINT, SIG_IGN) != SIG_IGN) ! 342: signal(SIGINT, delexit); ! 343: /* ! 344: * Install symbols in the table ! 345: */ ! 346: symtabinit(); ! 347: syminstall(); ! 348: /* ! 349: * Build the expression parser accelerator token sets ! 350: */ ! 351: buildtokensets(); ! 352: } ! 353: ! 354: zeroorigins() ! 355: { ! 356: register int locindex; ! 357: /* ! 358: * Mark usedot: the first NLOC slots are for named text segments, ! 359: * the next for named data segments. ! 360: */ ! 361: for (locindex = 0; locindex < NLOC; locindex++){ ! 362: usedot[locindex].e_xtype = XTEXT; ! 363: usedot[NLOC + locindex].e_xtype = XDATA; ! 364: usedot[locindex].e_xvalue = 0; ! 365: usedot[NLOC + locindex].e_xvalue = 0; ! 366: } ! 367: } ! 368: ! 369: zerolocals() ! 370: { ! 371: register int i; ! 372: ! 373: for (i = 0; i <= 9; i++) { ! 374: lgensym[i] = 1; ! 375: genref[i] = 0; ! 376: } ! 377: } ! 378: ! 379: i_pass1() ! 380: { ! 381: FILE *tempopen(); ! 382: if (useVM == 0) ! 383: tokfile = tempopen(tokfilename, "T"); ! 384: strfile = tempopen(strfilename, "S"); ! 385: /* ! 386: * write out the string length. ! 387: * This will be overwritten when the ! 388: * strings are tacked onto the growing a.out file ! 389: */ ! 390: strfilepos = sizeof(int); ! 391: fwrite(&strfilepos, sizeof(int), 1, strfile); ! 392: ! 393: inittokfile(); ! 394: initijxxx(); ! 395: } ! 396: ! 397: FILE *tempopen(tname, part) ! 398: char *tname; ! 399: char *part; ! 400: { ! 401: FILE *file; ! 402: (void)sprintf(tname, "%s%sas%s%05d", ! 403: tmpdirprefix, ! 404: (tmpdirprefix[strlen(tmpdirprefix)-1] != '/') ? "/" : 0, ! 405: part, ! 406: getpid()); ! 407: file = fopen(tname, "w"); ! 408: if (file == NULL) { ! 409: yyerror("Bad pass 1 temporary file for writing %s", tname); ! 410: delexit(); ! 411: } ! 412: return(file); ! 413: } ! 414: ! 415: pass1() ! 416: { ! 417: register int i; ! 418: ! 419: passno = 1; ! 420: dotp = &usedot[0]; ! 421: txtfil = (BFILE *)0; ! 422: relfil = (struct relbufdesc *)0; ! 423: ! 424: if (ninfiles == 0){ /*take the input from stdin directly*/ ! 425: lineno = 1; ! 426: dotsname = "<stdin>"; ! 427: ! 428: yyparse(); ! 429: } else { /*we have the names tanked*/ ! 430: for (i = 0; i < ninfiles; i++){ ! 431: new_dot_s(innames[i]); ! 432: if (freopen(innames[i], "r", stdin) == NULL) { ! 433: yyerror( "Can't open source file %s\n", ! 434: innames[i]); ! 435: exit(2); ! 436: } ! 437: /* stdio is NOT used to read the input characters */ ! 438: /* we use read directly, into our own buffers */ ! 439: yyparse(); ! 440: } ! 441: } ! 442: ! 443: closetokfile(); /*kick out the last buffered intermediate text*/ ! 444: } ! 445: ! 446: testlocals() ! 447: { ! 448: register int i; ! 449: for (i = 0; i <= 9; i++) { ! 450: if (genref[i]) ! 451: yyerror("Reference to undefined local label %df", i); ! 452: lgensym[i] = 1; ! 453: genref[i] = 0; ! 454: } ! 455: } ! 456: ! 457: pass1_5() ! 458: { ! 459: sortsymtab(); ! 460: #ifdef DEBUG ! 461: if (debug) dumpsymtab(); ! 462: #endif ! 463: jxxxfix(); ! 464: #ifdef DEBUG ! 465: if (debug) dumpsymtab(); ! 466: #endif ! 467: } ! 468: ! 469: open_a_out() ! 470: { ! 471: /* ! 472: * Open up the a.out file now, and get set to build ! 473: * up offsets into it for all of the various text,data ! 474: * text relocation and data relocation segments. ! 475: */ ! 476: a_out_file = fopen(outfile, "w"); ! 477: if (a_out_file == NULL) { ! 478: yyerror("Cannot create %s", outfile); ! 479: delexit(); ! 480: } ! 481: biofd = a_out_file->_file; ! 482: a_out_off = 0; ! 483: } ! 484: ! 485: roundsegments() ! 486: { ! 487: register int locindex; ! 488: register long v; ! 489: /* ! 490: * round and assign text segment origins ! 491: * the exec header always goes in usefile[0] ! 492: */ ! 493: tsize = 0; ! 494: for (locindex=0; locindex<NLOC; locindex++) { ! 495: v = round(usedot[locindex].e_xvalue, FW); ! 496: usedot[locindex].e_xvalue = tsize; ! 497: if ((locindex == 0) || (v != 0) ){ ! 498: usefile[locindex] = (BFILE *)Calloc(1, sizeof(BFILE)); ! 499: bopen(usefile[locindex], a_out_off); ! 500: if (locindex == 0) ! 501: a_out_off = sizeof (struct exec); ! 502: } else { ! 503: usefile[locindex] = (BFILE *)-1; ! 504: } ! 505: tsize += v; ! 506: a_out_off += v; ! 507: } ! 508: /* ! 509: * Round and assign data segment origins. ! 510: */ ! 511: datbase = round(tsize, FW); ! 512: for (locindex=0; locindex<NLOC; locindex++) { ! 513: v = round(usedot[NLOC+locindex].e_xvalue, FW); ! 514: usedot[NLOC+locindex].e_xvalue = datbase + dsize; ! 515: if (v != 0){ ! 516: usefile[NLOC + locindex] = (BFILE *)Calloc(1,sizeof(BFILE)); ! 517: bopen(usefile[NLOC + locindex], a_out_off); ! 518: } else { ! 519: usefile[NLOC + locindex] = (BFILE *)-1; ! 520: } ! 521: dsize += v; ! 522: a_out_off += v; ! 523: } ! 524: /* ! 525: * Assign final values to symbols ! 526: */ ! 527: hdr.a_bss = dsize; ! 528: freezesymtab(); /* this touches hdr.a_bss */ ! 529: stabfix(); ! 530: /* ! 531: * Set up the relocation information "files" to ! 532: * be zero; outrel takes care of the rest ! 533: */ ! 534: for (locindex = 0; locindex < NLOC + NLOC; locindex++){ ! 535: rusefile[locindex] = (struct relbufdesc *)0; ! 536: } ! 537: } ! 538: ! 539: build_hdr() ! 540: { ! 541: /* ! 542: * Except for the text and data relocation sizes, ! 543: * calculate the final values for the header ! 544: * ! 545: * Write out the initial copy; we to come ! 546: * back later and patch up a_trsize and a_drsize, ! 547: * and overwrite this first version of the header. ! 548: */ ! 549: hdr.a_magic = MAGIC; ! 550: hdr.a_text = tsize; ! 551: hdr.a_data = dsize; ! 552: hdr.a_bss -= dsize; ! 553: hdr.a_syms = sizesymtab(); /* Does not include string pool length */ ! 554: hdr.a_entry = 0; ! 555: hdr.a_trsize = 0; ! 556: hdr.a_drsize = 0; ! 557: ! 558: bwrite((char *)&hdr, sizeof(hdr), usefile[0]); ! 559: } ! 560: ! 561: i_pass2() ! 562: { ! 563: if (useVM == 0) { ! 564: fclose(tokfile); ! 565: tokfile = fopen(tokfilename, "r"); ! 566: if (tokfile==NULL) { ! 567: yyerror("Bad pass 2 temporary file for reading %s", tokfilename); ! 568: delexit(); ! 569: } ! 570: } ! 571: fclose(strfile); ! 572: strfile = fopen(strfilename, "r"); ! 573: } ! 574: ! 575: pass2() ! 576: { ! 577: #ifdef DEBUG ! 578: if (debug) ! 579: printf("\n\n\n\t\tPASS 2\n\n\n\n"); ! 580: #endif DEBUG ! 581: passno = 2; ! 582: lineno = 1; ! 583: if (liston && ninfiles != 0) ! 584: { ! 585: char ch; ! 586: source = fopen (innames[ind++], "r"); ! 587: (void)sprintf (layoutpos, "%4ld 00000000 ", lineno); ! 588: layoutpos += LHEAD; ! 589: ch = getc (source); ! 590: if (ch == EOF) ! 591: { ! 592: if (ind == ninfiles) ! 593: endofsource = 1; ! 594: else ! 595: source = fopen (innames[ind++], "r"); ! 596: } ! 597: else ! 598: ungetc (ch, source); ! 599: } ! 600: else ! 601: endofsource = 1; ! 602: dotp = &usedot[0]; ! 603: txtfil = usefile[0]; /* already opened (always!) */ ! 604: relfil = 0; /* outrel takes care of the rest */ ! 605: initoutrel(); ! 606: ! 607: inittokfile(); ! 608: ! 609: yyparse(); ! 610: ! 611: closetokfile(); ! 612: } ! 613: ! 614: fillsegments() ! 615: { ! 616: int locindex; ! 617: /* ! 618: * Round text and data segments to FW by appending zeros ! 619: */ ! 620: for (locindex = 0; locindex < NLOC + NLOC; locindex++) { ! 621: if (usefile[locindex]) { ! 622: txtfil = usefile[locindex]; ! 623: dotp = &usedot[locindex]; ! 624: while (usedot[locindex].e_xvalue & FW) ! 625: outb(0); ! 626: } ! 627: } ! 628: } ! 629: ! 630: reloc_syms() ! 631: { ! 632: u_long closerelfil(); ! 633: /* ! 634: * Move the relocation information to a.out ! 635: * a_out_off is the offset so far: ! 636: * exec + text segments + data segments ! 637: */ ! 638: relocfile = (BFILE *)Calloc(1,sizeof(BFILE)); ! 639: bopen(relocfile, a_out_off); ! 640: a_out_off += closeoutrel(relocfile); ! 641: ! 642: hdr.a_trsize = trsize; ! 643: hdr.a_drsize = drsize; ! 644: if (readonlydata) { ! 645: hdr.a_text += hdr.a_data; ! 646: hdr.a_data = 0; ! 647: hdr.a_trsize += hdr.a_drsize; ! 648: hdr.a_drsize = 0; ! 649: } ! 650: /* ! 651: * Output the symbol table and the string pool ! 652: * ! 653: * We must first rewind the string pool file to its beginning, ! 654: * in case it was seek'ed into for fetching ascii and asciz ! 655: * strings. ! 656: */ ! 657: fseek(strfile, 0, 0); ! 658: symwrite(relocfile); ! 659: } ! 660: ! 661: fix_a_out() ! 662: { ! 663: if (lseek(a_out_file->_file, 0L, 0) < 0L) ! 664: yyerror("Reposition for header rewrite fails"); ! 665: if (write(a_out_file->_file, (char *)&hdr, sizeof (struct exec)) < 0) ! 666: yyerror("Rewrite of header fails"); ! 667: } ! 668: ! 669: delexit() ! 670: { ! 671: delete(); ! 672: if (passno == 2){ ! 673: unlink(outfile); ! 674: } ! 675: exit(1); ! 676: } ! 677: ! 678: delete() ! 679: { ! 680: if (useVM == 0 || tokfilename[0]) ! 681: unlink(tokfilename); ! 682: if (strfilename[0]) ! 683: unlink(strfilename); ! 684: } ! 685: ! 686: sawabort() ! 687: { ! 688: char *fillinbuffer(); ! 689: while (fillinbuffer() != (char *)0) ! 690: continue; ! 691: delete(); ! 692: exit(1); /*although the previous pass will also exit non zero*/ ! 693: } ! 694: ! 695: panic(fmt, a1, a2, a3, a4) ! 696: char *fmt; ! 697: /*VARARGS 1*/ ! 698: { ! 699: yyerror("Assembler panic: bad internal data structure."); ! 700: yyerror(fmt, a1, a2, a3, a4); ! 701: delete(); ! 702: abort(); ! 703: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.