![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pc3.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 41BSD / cmd / pascal|
Return to pc3.c CVS log | Up to [CSRG BSD Unix] / 41BSD / cmd / pascal |
1.1 ! root 1: /* Copyright (c) 1980 Regents of the University of California */ ! 2: ! 3: static char sccsid[] = "@(#)pc3.c 1.6 9/9/80"; ! 4: ! 5: /* ! 6: * Pc3 is a pass in the Berkeley Pascal compilation ! 7: * process that is performed just prior to linking Pascal ! 8: * object files. Its purpose is to enforce the rules of ! 9: * separate compilation for Berkeley Pascal. Pc3 is called ! 10: * with the same argument list of object files that is sent to ! 11: * the loader. These checks are performed by pc3 by examining ! 12: * the symbol tables of the object files: ! 13: * (1) All source and included files must be "up-to-date" with ! 14: * the object files of which they are components. ! 15: * (2) Each global Pascal symbol (label, constant, type, ! 16: * variable, procedure, or function name) must be uniquely ! 17: * declared, i.e. declared in only one included file or ! 18: * source file. ! 19: * (3) Each external function (or procedure) may be resolved ! 20: * at most once in a source file which included the ! 21: * external declaration of the function. ! 22: * ! 23: * The symbol table of each object file is scanned and ! 24: * each global Pascal symbol is placed in a hashed symbol ! 25: * table. The Pascal compiler has been modified to emit all ! 26: * Pascal global symbols to the object file symbol table. The ! 27: * information stored in the symbol table for each such symbol ! 28: * is: ! 29: * ! 30: * - the name of the symbol; ! 31: * - a subtype descriptor; ! 32: * - for file symbols, their last modify time; ! 33: * - the file which logically contains the declaration of ! 34: * the symbol (not an include file); ! 35: * - the file which textually contains the declaration of ! 36: * the symbol (possibly an include file); ! 37: * - the line number at which the symbol is declared; ! 38: * - the file which contains the resolution of the symbol. ! 39: * - the line number at which the symbol is resolved; ! 40: * ! 41: * If a symbol has been previously entered into the symbol ! 42: * table, a check is made that the current declaration is of ! 43: * the same type and from the same include file as the previous ! 44: * one. Except for files and functions and procedures, it is ! 45: * an error for a symbol declaration to be encountered more ! 46: * than once, unless the re-declarations come from the same ! 47: * included file as the original. ! 48: * ! 49: * As an include file symbol is encountered in a source ! 50: * file, the symbol table entry of each symbol declared in that ! 51: * include file is modified to reflect its new logical ! 52: * inclusion in the source file. File symbols are also ! 53: * encountered as an included file ends, signaling the ! 54: * continuation of the enclosing file. ! 55: * ! 56: * Functions and procedures which have been declared ! 57: * external may be resolved by declarations from source files ! 58: * which included the external declaration of the function. ! 59: * Functions and procedures may be resolved at most once across ! 60: * a set of object files. The loader will complain if a ! 61: * function is not resolved at least once. ! 62: */ ! 63: ! 64: char program[] = "pc"; ! 65: ! 66: #include <sys/types.h> ! 67: #include <ar.h> ! 68: #include <stdio.h> ! 69: #include <ctype.h> ! 70: #include <a.out.h> ! 71: #include <stab.h> ! 72: #include <pagsiz.h> ! 73: #include <stat.h> ! 74: #include "pstab.h" ! 75: #include "pc3.h" ! 76: ! 77: int errors = 0; ! 78: ! 79: /* ! 80: * check each of the argument .o files (or archives of .o files). ! 81: */ ! 82: main( argc , argv ) ! 83: int argc; ! 84: char **argv; ! 85: { ! 86: struct fileinfo ofile; ! 87: ! 88: while ( ++argv , --argc ) { ! 89: # ifdef DEBUG ! 90: fprintf( stderr , "[main] *argv = %s\n" , *argv ); ! 91: # endif DEBUG ! 92: ofile.name = *argv; ! 93: checkfile( &ofile ); ! 94: } ! 95: exit( errors ); ! 96: } ! 97: ! 98: /* ! 99: * check the namelist of a file, or all namelists of an archive. ! 100: */ ! 101: checkfile( ofilep ) ! 102: struct fileinfo *ofilep; ! 103: { ! 104: union { ! 105: char mag_armag[ SARMAG + 1 ]; ! 106: struct exec mag_exec; ! 107: } mag_un; ! 108: int red; ! 109: struct stat filestat; ! 110: ! 111: ofilep -> file = fopen( ofilep -> name , "r" ); ! 112: if ( ofilep -> file == NULL ) { ! 113: error( WARNING , "cannot open: %s" , ofilep -> name ); ! 114: return; ! 115: } ! 116: fstat( fileno( ofilep -> file ) , &filestat ); ! 117: ofilep -> modtime = filestat.st_mtime; ! 118: red = fread( (char *) &mag_un , 1 , sizeof mag_un , ofilep -> file ); ! 119: if ( red != sizeof mag_un ) { ! 120: error( WARNING , "cannot read header: %s" , ofilep -> name ); ! 121: return; ! 122: } ! 123: if ( mag_un.mag_exec.a_magic == OARMAG ) { ! 124: error( WARNING , "old archive: %s" , ofilep -> name ); ! 125: return; ! 126: } ! 127: if ( strncmp( mag_un.mag_armag , ARMAG , SARMAG ) == 0 ) { ! 128: /* archive, iterate through elements */ ! 129: # ifdef DEBUG ! 130: fprintf( stderr , "[checkfile] archive %s\n" , ofilep -> name ); ! 131: # endif DEBUG ! 132: ofilep -> nextoffset = SARMAG; ! 133: while ( nextelement( ofilep ) ) { ! 134: checknl( ofilep ); ! 135: } ! 136: } else if ( N_BADMAG( mag_un.mag_exec ) ) { ! 137: /* not a file.o */ ! 138: error( WARNING , "bad format: %s" , ofilep -> name ); ! 139: return; ! 140: } else { ! 141: /* a file.o */ ! 142: # ifdef DEBUG ! 143: fprintf( stderr , "[checkfile] .o file %s\n" , ofilep -> name ); ! 144: # endif DEBUG ! 145: fseek( ofilep -> file , 0L , 0 ); ! 146: ofilep -> nextoffset = filestat.st_size; ! 147: checknl( ofilep ); ! 148: } ! 149: fclose( ofilep -> file ); ! 150: } ! 151: ! 152: /* ! 153: * check the namelist of this file for conflicts with ! 154: * previously entered symbols. ! 155: */ ! 156: checknl( ofilep ) ! 157: register struct fileinfo *ofilep; ! 158: { ! 159: ! 160: long red; ! 161: struct exec oexec; ! 162: off_t symoff; ! 163: long numsyms; ! 164: register struct nlist *nlp; ! 165: register char *stringp; ! 166: long strsize; ! 167: long sym; ! 168: ! 169: red = fread( (char *) &oexec , 1 , sizeof oexec , ofilep -> file ); ! 170: if ( red != sizeof oexec ) { ! 171: error( WARNING , "error reading struct exec: %s" ! 172: , ofilep -> name ); ! 173: return; ! 174: } ! 175: if ( N_BADMAG( oexec ) ) { ! 176: return; ! 177: } ! 178: symoff = N_SYMOFF( oexec ) - sizeof oexec; ! 179: fseek( ofilep -> file , symoff , 1 ); ! 180: numsyms = oexec.a_syms / sizeof ( struct nlist ); ! 181: if ( numsyms == 0 ) { ! 182: error( WARNING , "no name list: %s" , ofilep -> name ); ! 183: return; ! 184: } ! 185: nlp = (struct nlist *) calloc( numsyms , sizeof ( struct nlist ) ); ! 186: if ( nlp == 0 ) { ! 187: error( FATAL , "no room for %d nlists" , numsyms ); ! 188: } ! 189: red = fread( ( char * ) nlp , numsyms , sizeof ( struct nlist ) ! 190: , ofilep -> file ); ! 191: if ( ftell( ofilep -> file ) + sizeof ( off_t ) ! 192: >= ofilep -> nextoffset ) { ! 193: error( WARNING , "no string table (old format .o?)" ! 194: , ofilep -> name ); ! 195: return; ! 196: } ! 197: red = fread( (char *) &strsize , sizeof strsize , 1 ! 198: , ofilep -> file ); ! 199: if ( red != 1 ) { ! 200: error( WARNING , "no string table (old format .o?)" ! 201: , ofilep -> name ); ! 202: return; ! 203: } ! 204: stringp = ( char * ) malloc( strsize ); ! 205: if ( stringp == 0 ) { ! 206: error( FATAL , "no room for %d bytes of strings" , strsize ); ! 207: } ! 208: red = fread( stringp + sizeof strsize ! 209: , strsize - sizeof ( strsize ) , 1 , ofilep -> file ); ! 210: if ( red != 1 ) { ! 211: error( WARNING , "error reading string table: %s" ! 212: , ofilep -> name ); ! 213: } ! 214: # ifdef DEBUG ! 215: fprintf( stderr , "[checknl] %s: %d symbols\n" ! 216: , ofilep -> name , numsyms ); ! 217: # endif DEBUG ! 218: for ( sym = 0 ; sym < numsyms ; sym++) { ! 219: if ( nlp[ sym ].n_un.n_strx ) { ! 220: nlp[ sym ].n_un.n_name = stringp + nlp[ sym ].n_un.n_strx; ! 221: } else { ! 222: nlp[ sym ].n_un.n_name = ""; ! 223: } ! 224: checksymbol( &nlp[ sym ] , ofilep ); ! 225: } ! 226: if ( nlp ) { ! 227: free( nlp ); ! 228: } ! 229: if ( stringp ) { ! 230: free( stringp ); ! 231: } ! 232: } ! 233: ! 234: /* ! 235: * check a symbol. ! 236: * look it up in the hashed symbol table, ! 237: * entering it if necessary. ! 238: * this maintains a state of which .p and .i files ! 239: * it is currently in the midst from the nlist entries ! 240: * for source and included files. ! 241: * if we are inside a .p but not a .i, pfilep == ifilep. ! 242: */ ! 243: checksymbol( nlp , ofilep ) ! 244: struct nlist *nlp; ! 245: struct fileinfo *ofilep; ! 246: { ! 247: static struct symbol *pfilep = NIL; ! 248: static struct symbol *ifilep = NIL; ! 249: register struct symbol *symbolp; ! 250: ! 251: # ifdef DEBUG ! 252: if ( pfilep && ifilep ) { ! 253: fprintf( stderr , "[checksymbol] pfile %s ifile %s\n" ! 254: , pfilep -> name , ifilep -> name ); ! 255: } ! 256: fprintf( stderr , "[checksymbol] ->name %s ->n_desc %x (%s)\n" ! 257: , nlp -> n_un.n_name , nlp -> n_desc ! 258: , classify( nlp -> n_desc ) ); ! 259: # endif DEBUG ! 260: if ( nlp -> n_type != N_PC ) { ! 261: /* don't care about the others */ ! 262: return; ! 263: } ! 264: symbolp = entersymbol( nlp -> n_un.n_name ); ! 265: if ( symbolp -> lookup == NEW ) { ! 266: # ifdef DEBUG ! 267: fprintf( stderr , "[checksymbol] ->name %s is NEW\n" ! 268: , symbolp -> name ); ! 269: # endif DEBUG ! 270: symbolp -> desc = nlp -> n_desc; ! 271: switch ( symbolp -> desc ) { ! 272: case N_PGLABEL: ! 273: case N_PGCONST: ! 274: case N_PGTYPE: ! 275: case N_PGVAR: ! 276: case N_PGFUNC: ! 277: case N_PGPROC: ! 278: symbolp -> sym_un.sym_str.rfilep = ifilep; ! 279: symbolp -> sym_un.sym_str.rline = nlp -> n_value; ! 280: symbolp -> sym_un.sym_str.fromp = pfilep; ! 281: symbolp -> sym_un.sym_str.fromi = ifilep; ! 282: symbolp -> sym_un.sym_str.iline = nlp -> n_value; ! 283: return; ! 284: case N_PEFUNC: ! 285: case N_PEPROC: ! 286: symbolp -> sym_un.sym_str.rfilep = NIL; ! 287: symbolp -> sym_un.sym_str.rline = 0; ! 288: /* ! 289: * functions can only be declared external ! 290: * in included files. ! 291: */ ! 292: if ( pfilep == ifilep ) { ! 293: error( WARNING ! 294: , "%s, line %d: %s %s must be declared in included file" ! 295: , pfilep -> name , nlp -> n_value ! 296: , classify( symbolp -> desc ) ! 297: , symbolp -> name ); ! 298: } ! 299: symbolp -> sym_un.sym_str.fromp = pfilep; ! 300: symbolp -> sym_un.sym_str.fromi = ifilep; ! 301: symbolp -> sym_un.sym_str.iline = nlp -> n_value; ! 302: return; ! 303: case N_PSO: ! 304: pfilep = symbolp; ! 305: /* and fall through */ ! 306: case N_PSOL: ! 307: ifilep = symbolp; ! 308: symbolp -> sym_un.modtime = mtime( symbolp -> name ); ! 309: if ( symbolp -> sym_un.modtime > ofilep -> modtime ) { ! 310: error( WARNING , "%s is out of date with %s" ! 311: , ofilep -> name , symbolp -> name ); ! 312: } ! 313: return; ! 314: } ! 315: } else { ! 316: # ifdef DEBUG ! 317: fprintf( stderr , "[checksymbol] ->name %s is OLD\n" ! 318: , symbolp -> name ); ! 319: # endif DEBUG ! 320: switch ( symbolp -> desc ) { ! 321: case N_PSO: ! 322: /* ! 323: * finding a file again means you are back ! 324: * in it after finishing an include file. ! 325: */ ! 326: pfilep = symbolp; ! 327: /* and fall through */ ! 328: case N_PSOL: ! 329: /* ! 330: * include files can be seen more than once, ! 331: * but they still have to be timechecked. ! 332: * (this will complain twice for out of date ! 333: * include files which include other files. ! 334: * sigh.) ! 335: */ ! 336: ifilep = symbolp; ! 337: if ( symbolp -> sym_un.modtime > ofilep -> modtime ) { ! 338: error( WARNING , "%s is out of date with %s" ! 339: , ofilep -> name , symbolp -> name ); ! 340: } ! 341: return; ! 342: case N_PEFUNC: ! 343: case N_PEPROC: ! 344: /* ! 345: * we may see any number of external declarations, ! 346: * but they all have to come ! 347: * from the same include file. ! 348: */ ! 349: if ( nlp -> n_desc == N_PEFUNC ! 350: || nlp -> n_desc == N_PEPROC ) { ! 351: goto included; ! 352: } ! 353: /* ! 354: * an external function can be resolved by ! 355: * the resolution of the function ! 356: * if the resolving file ! 357: * included the external declaration. ! 358: */ ! 359: if ( ( symbolp -> desc == N_PEFUNC ! 360: && nlp -> n_desc != N_PGFUNC ) ! 361: || ( symbolp -> desc == N_PEPROC ! 362: && nlp -> n_desc != N_PGPROC ) ! 363: || symbolp -> sym_un.sym_str.fromp != pfilep ) { ! 364: break; ! 365: } ! 366: /* ! 367: * an external function can only be resolved once. ! 368: */ ! 369: if ( symbolp -> sym_un.sym_str.rfilep != NIL ) { ! 370: break; ! 371: } ! 372: symbolp -> sym_un.sym_str.rfilep = ifilep; ! 373: symbolp -> sym_un.sym_str.rline = nlp -> n_value; ! 374: return; ! 375: case N_PGFUNC: ! 376: case N_PGPROC: ! 377: /* ! 378: * functions may not be seen more than once. ! 379: * the loader will complain about ! 380: * `multiply defined', but we can, too. ! 381: */ ! 382: break; ! 383: case N_PGLABEL: ! 384: case N_PGCONST: ! 385: case N_PGTYPE: ! 386: case N_PGVAR: ! 387: /* ! 388: * labels, constants, types, variables ! 389: * and external declarations ! 390: * may be seen as many times as they want, ! 391: * as long as they come from the same include file. ! 392: * make it look like they come from this .p file. ! 393: */ ! 394: included: ! 395: if ( nlp -> n_desc != symbolp -> desc ! 396: || symbolp -> sym_un.sym_str.fromi != ifilep ) { ! 397: break; ! 398: } ! 399: symbolp -> sym_un.sym_str.fromp = pfilep; ! 400: return; ! 401: } ! 402: /* ! 403: * this is the breaks ! 404: */ ! 405: error( WARNING , "%s, line %d: %s already defined (%s, line %d)." ! 406: , ifilep -> name , nlp -> n_value , nlp -> n_un.n_name ! 407: , symbolp -> sym_un.sym_str.rfilep -> name ! 408: , symbolp -> sym_un.sym_str.rline ); ! 409: } ! 410: } ! 411: ! 412: /* ! 413: * quadratically hashed symbol table. ! 414: * things are never deleted from the hash symbol table. ! 415: * as more hash table is needed, ! 416: * a new one is alloc'ed and chained to the end. ! 417: * search is by rehashing within each table, ! 418: * traversing chains to next table if unsuccessful. ! 419: */ ! 420: struct symbol * ! 421: entersymbol( name ) ! 422: char *name; ! 423: { ! 424: static struct symboltableinfo *symboltable = NIL; ! 425: char *enteredname; ! 426: long hashindex; ! 427: register struct symboltableinfo *tablep; ! 428: register struct symbol **herep; ! 429: register struct symbol **limitp; ! 430: register long increment; ! 431: ! 432: enteredname = enterstring( name ); ! 433: hashindex = SHORT_ABS( ( long ) enteredname ) % SYMBOLPRIME; ! 434: for ( tablep = symboltable ; /*return*/ ; tablep = tablep -> chain ) { ! 435: if ( tablep == NIL ) { ! 436: # ifdef DEBUG ! 437: fprintf( stderr , "[entersymbol] calloc\n" ); ! 438: # endif DEBUG ! 439: tablep = ( struct symboltableinfo * ) ! 440: calloc( sizeof ( struct symboltableinfo ) , 1 ); ! 441: if ( tablep == NIL ) { ! 442: error( FATAL , "ran out of memory (entersymbol)" ); ! 443: } ! 444: if ( symboltable == NIL ) { ! 445: symboltable = tablep; ! 446: } ! 447: } ! 448: herep = &( tablep -> entry[ hashindex ] ); ! 449: limitp = &( tablep -> entry[ SYMBOLPRIME ] ); ! 450: increment = 1; ! 451: do { ! 452: # ifdef DEBUG ! 453: fprintf( stderr , "[entersymbol] increment %d\n" ! 454: , increment ); ! 455: # endif DEBUG ! 456: if ( *herep == NIL ) { ! 457: /* empty */ ! 458: if ( tablep -> used > ( ( SYMBOLPRIME / 3 ) * 4 ) ) { ! 459: /* too full, break for next table */ ! 460: break; ! 461: } ! 462: tablep -> used++; ! 463: *herep = symbolalloc(); ! 464: ( *herep ) -> name = enteredname; ! 465: ( *herep ) -> lookup = NEW; ! 466: # ifdef DEBUG ! 467: fprintf( stderr , "[entersymbol] name %s NEW\n" ! 468: , enteredname ); ! 469: # endif DEBUG ! 470: return *herep; ! 471: } ! 472: /* a find? */ ! 473: if ( ( *herep ) -> name == enteredname ) { ! 474: ( *herep ) -> lookup = OLD; ! 475: # ifdef DEBUG ! 476: fprintf( stderr , "[entersymbol] name %s OLD\n" ! 477: , enteredname ); ! 478: # endif DEBUG ! 479: return *herep; ! 480: } ! 481: herep += increment; ! 482: if ( herep >= limitp ) { ! 483: herep -= SYMBOLPRIME; ! 484: } ! 485: increment += 2; ! 486: } while ( increment < SYMBOLPRIME ); ! 487: } ! 488: } ! 489: ! 490: /* ! 491: * allocate a symbol from the dynamically allocated symbol table. ! 492: */ ! 493: struct symbol * ! 494: symbolalloc() ! 495: { ! 496: static struct symbol *nextsymbol = NIL; ! 497: static long symbolsleft = 0; ! 498: struct symbol *newsymbol; ! 499: ! 500: if ( symbolsleft <= 0 ) { ! 501: # ifdef DEBUG ! 502: fprintf( stderr , "[symbolalloc] malloc\n" ); ! 503: # endif DEBUG ! 504: nextsymbol = ( struct symbol * ) malloc( SYMBOLALLOC ); ! 505: if ( nextsymbol == 0 ) { ! 506: error( FATAL , "ran out of memory (symbolalloc)" ); ! 507: } ! 508: symbolsleft = SYMBOLALLOC / sizeof( struct symbol ); ! 509: } ! 510: newsymbol = nextsymbol; ! 511: nextsymbol++; ! 512: symbolsleft--; ! 513: return newsymbol; ! 514: } ! 515: ! 516: /* ! 517: * hash a string based on all of its characters. ! 518: */ ! 519: long ! 520: hashstring( string ) ! 521: char *string; ! 522: { ! 523: register char *cp; ! 524: register long value; ! 525: ! 526: value = 0; ! 527: for ( cp = string ; *cp ; cp++ ) { ! 528: value = ( value * 2 ) + *cp; ! 529: } ! 530: return value; ! 531: } ! 532: ! 533: /* ! 534: * quadratically hashed string table. ! 535: * things are never deleted from the hash string table. ! 536: * as more hash table is needed, ! 537: * a new one is alloc'ed and chained to the end. ! 538: * search is by rehashing within each table, ! 539: * traversing chains to next table if unsuccessful. ! 540: */ ! 541: char * ! 542: enterstring( string ) ! 543: char *string; ! 544: { ! 545: static struct stringtableinfo *stringtable = NIL; ! 546: long hashindex; ! 547: register struct stringtableinfo *tablep; ! 548: register char **herep; ! 549: register char **limitp; ! 550: register long increment; ! 551: ! 552: hashindex = SHORT_ABS( hashstring( string ) ) % STRINGPRIME; ! 553: for ( tablep = stringtable ; /*return*/ ; tablep = tablep -> chain ) { ! 554: if ( tablep == NIL ) { ! 555: # ifdef DEBUG ! 556: fprintf( stderr , "[enterstring] calloc\n" ); ! 557: # endif DEBUG ! 558: tablep = ( struct stringtableinfo * ) ! 559: calloc( sizeof ( struct stringtableinfo ) , 1 ); ! 560: if ( tablep == NIL ) { ! 561: error( FATAL , "ran out of memory (enterstring)" ); ! 562: } ! 563: if ( stringtable == NIL ) { ! 564: stringtable = tablep; ! 565: } ! 566: } ! 567: herep = &( tablep -> entry[ hashindex ] ); ! 568: limitp = &( tablep -> entry[ STRINGPRIME ] ); ! 569: increment = 1; ! 570: do { ! 571: # ifdef DEBUG ! 572: fprintf( stderr , "[enterstring] increment %d\n" ! 573: , increment ); ! 574: # endif DEBUG ! 575: if ( *herep == NIL ) { ! 576: /* empty */ ! 577: if ( tablep -> used > ( ( STRINGPRIME / 3 ) * 4 ) ) { ! 578: /* too full, break for next table */ ! 579: break; ! 580: } ! 581: tablep -> used++; ! 582: *herep = charalloc( strlen( string ) ); ! 583: strcpy( *herep , string ); ! 584: # ifdef DEBUG ! 585: fprintf( stderr , "[enterstring] string %s copied\n" ! 586: , *herep ); ! 587: # endif DEBUG ! 588: return *herep; ! 589: } ! 590: /* quick, check the first chars and then the rest */ ! 591: if ( **herep == *string && strcmp( *herep , string ) == 0 ) { ! 592: # ifdef DEBUG ! 593: fprintf( stderr , "[enterstring] string %s found\n" ! 594: , *herep ); ! 595: # endif DEBUG ! 596: return *herep; ! 597: } ! 598: herep += increment; ! 599: if ( herep >= limitp ) { ! 600: herep -= STRINGPRIME; ! 601: } ! 602: increment += 2; ! 603: } while ( increment < STRINGPRIME ); ! 604: } ! 605: } ! 606: ! 607: /* ! 608: * copy a string to the dynamically allocated character table. ! 609: */ ! 610: char * ! 611: charalloc( length ) ! 612: register long length; ! 613: { ! 614: static char *nextchar = NIL; ! 615: static long charsleft = 0; ! 616: register long lengthplus1 = length + 1; ! 617: register long askfor; ! 618: char *newstring; ! 619: ! 620: if ( charsleft < lengthplus1 ) { ! 621: askfor = lengthplus1 > CHARALLOC ? lengthplus1 : CHARALLOC; ! 622: # ifdef DEBUG ! 623: fprintf( stderr , "[charalloc] malloc( %d )\n" ! 624: , askfor ); ! 625: # endif DEBUG ! 626: nextchar = ( char * ) malloc( askfor ); ! 627: if ( nextchar == 0 ) { ! 628: error( FATAL , "no room for %d characters" , askfor ); ! 629: } ! 630: charsleft = askfor; ! 631: } ! 632: newstring = nextchar; ! 633: nextchar += lengthplus1; ! 634: charsleft -= lengthplus1; ! 635: return newstring; ! 636: } ! 637: ! 638: /* ! 639: * read an archive header for the next element ! 640: * and find the offset of the one after this. ! 641: */ ! 642: BOOL ! 643: nextelement( ofilep ) ! 644: struct fileinfo *ofilep; ! 645: { ! 646: register char *cp; ! 647: register long red; ! 648: register off_t arsize; ! 649: struct ar_hdr archdr; ! 650: ! 651: fseek( ofilep -> file , ofilep -> nextoffset , 0 ); ! 652: red = fread( (char *) &archdr , 1 , sizeof archdr , ofilep -> file ); ! 653: if ( red != sizeof archdr ) { ! 654: return FALSE; ! 655: } ! 656: /* null terminate the blank-padded name */ ! 657: cp = &archdr.ar_name[ ( sizeof archdr.ar_name ) - 1 ]; ! 658: *cp = '\0'; ! 659: while ( *--cp == ' ' ) { ! 660: *cp = '\0'; ! 661: } ! 662: /* set up the address of the beginning of next element */ ! 663: arsize = atol( archdr.ar_size ); ! 664: /* archive elements are aligned on 0 mod 2 boundaries */ ! 665: if ( arsize & 1 ) { ! 666: arsize += 1; ! 667: } ! 668: ofilep -> nextoffset = ftell( ofilep -> file ) + arsize; ! 669: /* say we had one */ ! 670: return TRUE; ! 671: } ! 672: ! 673: /* ! 674: * variable number of arguments to error, like printf. ! 675: */ ! 676: error( fatal , message , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 ) ! 677: int fatal; ! 678: char *message; ! 679: { ! 680: fprintf( stderr , "%s: " , program ); ! 681: fprintf( stderr , message , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 ); ! 682: fprintf( stderr , "\n" ); ! 683: if ( fatal == FATAL ) { ! 684: exit( 2 ); ! 685: } ! 686: errors = 1; ! 687: } ! 688: ! 689: /* ! 690: * find the last modify time of a file. ! 691: * on error, return the current time. ! 692: */ ! 693: time_t ! 694: mtime( filename ) ! 695: char *filename; ! 696: { ! 697: struct stat filestat; ! 698: ! 699: # ifdef DEBUG ! 700: fprintf( stderr , "[mtime] filename %s\n" ! 701: , filename ); ! 702: # endif DEBUG ! 703: if ( stat( filename , &filestat ) != 0 ) { ! 704: error( WARNING , "%s: cannot open" , filename ); ! 705: return ( (time_t) time( 0 ) ); ! 706: } ! 707: return filestat.st_mtime; ! 708: } ! 709: ! 710: char * ! 711: classify( type ) ! 712: unsigned char type; ! 713: { ! 714: switch ( type ) { ! 715: case N_PSO: ! 716: return "source file"; ! 717: case N_PSOL: ! 718: return "include file"; ! 719: case N_PGLABEL: ! 720: return "label"; ! 721: case N_PGCONST: ! 722: return "constant"; ! 723: case N_PGTYPE: ! 724: return "type"; ! 725: case N_PGVAR: ! 726: return "variable"; ! 727: case N_PGFUNC: ! 728: return "function"; ! 729: case N_PGPROC: ! 730: return "procedure"; ! 731: case N_PEFUNC: ! 732: return "external function"; ! 733: case N_PEPROC: ! 734: return "external procedure"; ! 735: default: ! 736: return "unknown symbol"; ! 737: } ! 738: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.