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