![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to object.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 / dbx|
Return to object.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / lib / old_compiler / dbx |
1.1 root 1: /*
2: * Copyright (c) 1983 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[] = "@(#)object.c 5.2 (Berkeley) 1/12/88";
9: #endif not lint
10:
11: static char rcsid[] = "$Header: object.c,v 1.5 87/03/26 20:24:58 donn Exp $";
12:
13: /*
14: * Object code interface, mainly for extraction of symbolic information.
15: */
16:
17: #include "defs.h"
18: #include "object.h"
19: #include "stabstring.h"
20: #include "main.h"
21: #include "symbols.h"
22: #include "names.h"
23: #include "languages.h"
24: #include "mappings.h"
25: #include "lists.h"
26: #include <a.out.h>
27: #include <stab.h>
28: #include <ctype.h>
29:
30: #ifndef public
31:
32: struct {
33: unsigned int stringsize; /* size of the dumped string table */
34: unsigned int nsyms; /* number of symbols */
35: unsigned int nfiles; /* number of files */
36: unsigned int nlines; /* number of lines */
37: } nlhdr;
38:
39: #include "languages.h"
40: #include "symbols.h"
41:
42: #endif
43:
44: #ifndef N_MOD2
45: # define N_MOD2 0x50
46: #endif
47:
48: public String objname = "a.out";
49: public integer objsize;
50:
51: public Language curlang;
52: public Symbol curmodule;
53: public Symbol curparam;
54: public Symbol curcomm;
55: public Symbol commchain;
56:
57: private char *stringtab;
58: private struct nlist *curnp;
59: private Boolean warned;
60: private Boolean strip_ = false;
61:
62: private Filetab *filep;
63: private Linetab *linep, *prevlinep;
64:
65: public String curfilename ()
66: {
67: return ((filep-1)->filename);
68: }
69:
70: /*
71: * Blocks are figured out on the fly while reading the symbol table.
72: */
73:
74: #define MAXBLKDEPTH 25
75:
76: public Symbol curblock;
77:
78: private Symbol blkstack[MAXBLKDEPTH];
79: private integer curlevel;
80: private integer bnum, nesting;
81: private Address addrstk[MAXBLKDEPTH];
82:
83: public pushBlock (b)
84: Symbol b;
85: {
86: if (curlevel >= MAXBLKDEPTH) {
87: fatal("nesting depth too large (%d)", curlevel);
88: }
89: blkstack[curlevel] = curblock;
90: ++curlevel;
91: curblock = b;
92: if (traceblocks) {
93: printf("entering block %s\n", symname(b));
94: }
95: }
96:
97: /*
98: * Change the current block with saving the previous one,
99: * since it is assumed that the symbol for the current one is to be deleted.
100: */
101:
102: public changeBlock (b)
103: Symbol b;
104: {
105: curblock = b;
106: }
107:
108: public enterblock (b)
109: Symbol b;
110: {
111: if (curblock == nil) {
112: b->level = 1;
113: } else {
114: b->level = curblock->level + 1;
115: }
116: b->block = curblock;
117: pushBlock(b);
118: }
119:
120: public exitblock ()
121: {
122: if (curblock->class == FUNC or curblock->class == PROC) {
123: if (prevlinep != linep) {
124: curblock->symvalue.funcv.src = true;
125: }
126: }
127: if (curlevel <= 0) {
128: panic("nesting depth underflow (%d)", curlevel);
129: }
130: --curlevel;
131: if (traceblocks) {
132: printf("exiting block %s\n", symname(curblock));
133: }
134: curblock = blkstack[curlevel];
135: }
136:
137: /*
138: * Enter a source line or file name reference into the appropriate table.
139: * Expanded inline to reduce procedure calls.
140: *
141: * private enterline (linenumber, address)
142: * Lineno linenumber;
143: * Address address;
144: * ...
145: */
146:
147: #define enterline(linenumber, address) \
148: { \
149: register Linetab *lp; \
150: \
151: lp = linep - 1; \
152: if (linenumber != lp->line) { \
153: if (address != lp->addr) { \
154: ++lp; \
155: } \
156: lp->line = linenumber; \
157: lp->addr = address; \
158: linep = lp + 1; \
159: } \
160: }
161:
162: /*
163: * Read in the namelist from the obj file.
164: *
165: * Reads and seeks are used instead of fread's and fseek's
166: * for efficiency sake; there's a lot of data being read here.
167: */
168:
169: public readobj (file)
170: String file;
171: {
172: Fileid f;
173: struct exec hdr;
174: struct nlist nlist;
175:
176: f = open(file, 0);
177: if (f < 0) {
178: fatal("can't open %s", file);
179: }
180: read(f, &hdr, sizeof(hdr));
181: if (N_BADMAG(hdr)) {
182: objsize = 0;
183: nlhdr.nsyms = 0;
184: nlhdr.nfiles = 0;
185: nlhdr.nlines = 0;
186: } else {
187: objsize = hdr.a_text;
188: nlhdr.nsyms = hdr.a_syms / sizeof(nlist);
189: nlhdr.nfiles = nlhdr.nsyms;
190: nlhdr.nlines = nlhdr.nsyms;
191: }
192: if (nlhdr.nsyms > 0) {
193: lseek(f, (long) N_STROFF(hdr), 0);
194: read(f, &(nlhdr.stringsize), sizeof(nlhdr.stringsize));
195: nlhdr.stringsize -= 4;
196: stringtab = newarr(char, nlhdr.stringsize);
197: read(f, stringtab, nlhdr.stringsize);
198: allocmaps(nlhdr.nfiles, nlhdr.nlines);
199: lseek(f, (long) N_SYMOFF(hdr), 0);
200: readsyms(f);
201: ordfunctab();
202: setnlines();
203: setnfiles();
204: } else {
205: initsyms();
206: }
207: close(f);
208: }
209:
210: /*
211: * Found the beginning of the externals in the object file
212: * (signified by the "-lg" or find an external), close the
213: * block for the last procedure.
214: */
215:
216: private foundglobals ()
217: {
218: if (curblock->class != PROG) {
219: exitblock();
220: if (curblock->class != PROG) {
221: exitblock();
222: }
223: }
224: enterline(0, (linep-1)->addr + 1);
225: }
226:
227: /*
228: * Read in symbols from object file.
229: */
230:
231: private readsyms (f)
232: Fileid f;
233: {
234: struct nlist *namelist;
235: register struct nlist *np, *ub;
236: register String name;
237: boolean afterlg, foundstab;
238: integer index;
239: char *lastchar;
240:
241: initsyms();
242: namelist = newarr(struct nlist, nlhdr.nsyms);
243: read(f, namelist, nlhdr.nsyms * sizeof(struct nlist));
244: afterlg = false;
245: foundstab = false;
246: ub = &namelist[nlhdr.nsyms];
247: curnp = &namelist[0];
248: np = curnp;
249: while (np < ub) {
250: index = np->n_un.n_strx;
251: if (index != 0) {
252: name = &stringtab[index - 4];
253: /*
254: * If the program contains any .f files a trailing _ is stripped
255: * from the name on the assumption it was added by the compiler.
256: * This only affects names that follow the sdb N_SO entry with
257: * the .f name.
258: */
259: if (strip_ and name[0] != '\0' ) {
260: lastchar = &name[strlen(name) - 1];
261: if (*lastchar == '_') {
262: *lastchar = '\0';
263: }
264: }
265: } else {
266: name = nil;
267: }
268:
269: /*
270: * Assumptions:
271: * not an N_STAB ==> name != nil
272: * name[0] == '-' ==> name == "-lg"
273: * name[0] != '_' ==> filename or invisible
274: *
275: * The "-lg" signals the beginning of global loader symbols.
276: *
277: */
278: if ((np->n_type&N_STAB) != 0) {
279: foundstab = true;
280: enter_nl(name, np);
281: } else if (name[0] == '-') {
282: afterlg = true;
283: foundglobals();
284: } else if (afterlg) {
285: check_global(name, np);
286: } else if ((np->n_type&N_EXT) == N_EXT) {
287: afterlg = true;
288: foundglobals();
289: check_global(name, np);
290: } else if (name[0] == '_') {
291: check_local(&name[1], np);
292: } else if ((np->n_type&N_TEXT) == N_TEXT) {
293: check_filename(name);
294: }
295: ++curnp;
296: np = curnp;
297: }
298: if (not foundstab) {
299: warning("no source compiled with -g");
300: }
301: dispose(namelist);
302: }
303:
304: /*
305: * Get a continuation entry from the name list.
306: * Return the beginning of the name.
307: */
308:
309: public String getcont ()
310: {
311: register integer index;
312: register String name;
313:
314: ++curnp;
315: index = curnp->n_un.n_strx;
316: if (index == 0) {
317: name = "";
318: } else {
319: name = &stringtab[index - 4];
320: }
321: return name;
322: }
323:
324: /*
325: * Initialize symbol information.
326: */
327:
328: private initsyms ()
329: {
330: curblock = nil;
331: curlevel = 0;
332: nesting = 0;
333: program = insert(identname("", true));
334: program->class = PROG;
335: program->language = primlang;
336: program->symvalue.funcv.beginaddr = CODESTART;
337: program->symvalue.funcv.inline = false;
338: newfunc(program, codeloc(program));
339: findbeginning(program);
340: enterblock(program);
341: curmodule = program;
342: }
343:
344: /*
345: * Free all the object file information that's being stored.
346: */
347:
348: public objfree ()
349: {
350: symbol_free();
351: /* keywords_free(); */
352: /* names_free(); */
353: /* dispose(stringtab); */
354: clrfunctab();
355: }
356:
357: /*
358: * Enter a namelist entry.
359: */
360:
361: private enter_nl (name, np)
362: String name;
363: register struct nlist *np;
364: {
365: register Symbol s;
366: register Name n;
367:
368: s = nil;
369: switch (np->n_type) {
370: /*
371: * Build a symbol for the FORTRAN common area. All GSYMS that follow
372: * will be chained in a list with the head kept in common.offset, and
373: * the tail in common.chain.
374: */
375: case N_BCOMM:
376: if (curcomm) {
377: curcomm->symvalue.common.chain = commchain;
378: }
379: n = identname(name, true);
380: curcomm = lookup(n);
381: if (curcomm == nil) {
382: curcomm = insert(n);
383: curcomm->class = COMMON;
384: curcomm->block = curblock;
385: curcomm->level = program->level;
386: curcomm->symvalue.common.chain = nil;
387: }
388: commchain = curcomm->symvalue.common.chain;
389: break;
390:
391: case N_ECOMM:
392: if (curcomm) {
393: curcomm->symvalue.common.chain = commchain;
394: curcomm = nil;
395: }
396: break;
397:
398: case N_LBRAC:
399: ++nesting;
400: addrstk[nesting] = (linep - 1)->addr;
401: break;
402:
403: case N_RBRAC:
404: --nesting;
405: if (addrstk[nesting] == NOADDR) {
406: exitblock();
407: newfunc(curblock, (linep - 1)->addr);
408: addrstk[nesting] = (linep - 1)->addr;
409: }
410: break;
411:
412: case N_SLINE:
413: enterline((Lineno) np->n_desc, (Address) np->n_value);
414: break;
415:
416: /*
417: * Source files.
418: */
419: case N_SO:
420: n = identname(name, true);
421: enterSourceModule(n, (Address) np->n_value);
422: break;
423:
424: /*
425: * Textually included files.
426: */
427: case N_SOL:
428: enterfile(name, (Address) np->n_value);
429: break;
430:
431: /*
432: * These symbols are assumed to have non-nil names.
433: */
434: case N_GSYM:
435: case N_FUN:
436: case N_STSYM:
437: case N_LCSYM:
438: case N_RSYM:
439: case N_PSYM:
440: case N_LSYM:
441: case N_SSYM:
442: case N_LENG:
443: if (index(name, ':') == nil) {
444: if (not warned) {
445: warned = true;
446: printf("warning: old style symbol information ");
447: printf("found in \"%s\"\n", curfilename());
448: }
449: } else {
450: entersym(name, np);
451: }
452: break;
453:
454: case N_PC:
455: case N_MOD2:
456: break;
457:
458: default:
459: printf("warning: stab entry unrecognized: ");
460: if (name != nil) {
461: printf("name %s,", name);
462: }
463: printf("ntype %2x, desc %x, value %x'\n",
464: np->n_type, np->n_desc, np->n_value);
465: break;
466: }
467: }
468:
469: /*
470: * Try to find the symbol that is referred to by the given name. Since it's
471: * an external, we need to follow a level or two of indirection.
472: */
473:
474: private Symbol findsym (n, var_isextref)
475: Name n;
476: boolean *var_isextref;
477: {
478: register Symbol r, s;
479:
480: *var_isextref = false;
481: find(s, n) where
482: (
483: s->level == program->level and (
484: s->class == EXTREF or s->class == VAR or
485: s->class == PROC or s->class == FUNC
486: )
487: ) or (
488: s->block == program and s->class == MODULE
489: )
490: endfind(s);
491: if (s == nil) {
492: r = nil;
493: } else if (s->class == EXTREF) {
494: *var_isextref = true;
495: r = s->symvalue.extref;
496: delete(s);
497:
498: /*
499: * Now check for another level of indirection that could come from
500: * a forward reference in procedure nesting information. In this case
501: * the symbol has already been deleted.
502: */
503: if (r != nil and r->class == EXTREF) {
504: r = r->symvalue.extref;
505: }
506: /*
507: } else if (s->class == MODULE) {
508: s->class = FUNC;
509: s->level = program->level;
510: r = s;
511: */
512: } else {
513: r = s;
514: }
515: return r;
516: }
517:
518: /*
519: * Create a symbol for a text symbol with no source information.
520: * We treat it as an assembly language function.
521: */
522:
523: private Symbol deffunc (n)
524: Name n;
525: {
526: Symbol f;
527:
528: f = insert(n);
529: f->language = findlanguage(".s");
530: f->class = FUNC;
531: f->type = t_int;
532: f->block = curblock;
533: f->level = program->level;
534: f->symvalue.funcv.src = false;
535: f->symvalue.funcv.inline = false;
536: if (f->chain != nil) {
537: panic("chain not nil in deffunc");
538: }
539: return f;
540: }
541:
542: /*
543: * Create a symbol for a data or bss symbol with no source information.
544: * We treat it as an assembly language variable.
545: */
546:
547: private Symbol defvar (n)
548: Name n;
549: {
550: Symbol v;
551:
552: v = insert(n);
553: v->language = findlanguage(".s");
554: v->storage = EXT;
555: v->class = VAR;
556: v->type = t_int;
557: v->level = program->level;
558: v->block = curblock;
559: return v;
560: }
561:
562: /*
563: * Update a symbol entry with a text address.
564: */
565:
566: private updateTextSym (s, name, addr)
567: Symbol s;
568: char *name;
569: Address addr;
570: {
571: if (s->class == VAR) {
572: s->symvalue.offset = addr;
573: } else {
574: s->symvalue.funcv.beginaddr = addr;
575: if (name[0] == '_') {
576: newfunc(s, codeloc(s));
577: findbeginning(s);
578: }
579: }
580: }
581:
582: /*
583: * Avoid seeing Pascal labels as text symbols.
584: */
585:
586: private boolean PascalLabel (n)
587: Name n;
588: {
589: boolean b;
590: register char *p;
591:
592: b = false;
593: if (curlang == findlanguage(".p")) {
594: p = ident(n);
595: while (*p != '\0') {
596: if (*p == '_' and *(p+1) == '$') {
597: b = true;
598: break;
599: }
600: ++p;
601: }
602: }
603: return b;
604: }
605:
606: /*
607: * Check to see if a global _name is already in the symbol table,
608: * if not then insert it.
609: */
610:
611: private check_global (name, np)
612: String name;
613: register struct nlist *np;
614: {
615: register Name n;
616: register Symbol t, u;
617: char buf[4096];
618: boolean isextref;
619: integer count;
620:
621: if (not streq(name, "_end")) {
622: if (name[0] == '_') {
623: n = identname(&name[1], true);
624: } else {
625: n = identname(name, true);
626: if (lookup(n) != nil) {
627: sprintf(buf, "$%s", name);
628: n = identname(buf, false);
629: }
630: }
631: if ((np->n_type&N_TYPE) == N_TEXT) {
632: count = 0;
633: t = findsym(n, &isextref);
634: while (isextref) {
635: ++count;
636: updateTextSym(t, name, np->n_value);
637: t = findsym(n, &isextref);
638: }
639: if (count == 0) {
640: if (t == nil) {
641: if (not PascalLabel(n)) {
642: t = deffunc(n);
643: updateTextSym(t, name, np->n_value);
644: if (tracesyms) {
645: printdecl(t);
646: }
647: }
648: } else {
649: if (t->class == MODULE) {
650: u = t;
651: t = deffunc(n);
652: t->block = u;
653: if (tracesyms) {
654: printdecl(t);
655: }
656: }
657: updateTextSym(t, name, np->n_value);
658: }
659: }
660: } else if ((np->n_type&N_TYPE) == N_BSS or (np->n_type&N_TYPE) == N_DATA) {
661: find(t, n) where
662: t->class == COMMON
663: endfind(t);
664: if (t != nil) {
665: u = (Symbol) t->symvalue.common.offset;
666: while (u != nil) {
667: u->symvalue.offset = u->symvalue.common.offset+np->n_value;
668: u = u->symvalue.common.chain;
669: }
670: } else {
671: check_var(np, n);
672: }
673: } else {
674: check_var(np, n);
675: }
676: }
677: }
678:
679: /*
680: * Check to see if a namelist entry refers to a variable.
681: * If not, create a variable for the entry. In any case,
682: * set the offset of the variable according to the value field
683: * in the entry.
684: *
685: * If the external name has been referred to by several other symbols,
686: * we must update each of them.
687: */
688:
689: private check_var (np, n)
690: struct nlist *np;
691: register Name n;
692: {
693: register Symbol t, u, next;
694: Symbol conflict;
695:
696: t = lookup(n);
697: if (t == nil) {
698: t = defvar(n);
699: t->symvalue.offset = np->n_value;
700: if (tracesyms) {
701: printdecl(t);
702: }
703: } else {
704: conflict = nil;
705: do {
706: next = t->next_sym;
707: if (t->name == n) {
708: if (t->class == MODULE and t->block == program) {
709: conflict = t;
710: } else if (t->class == EXTREF and t->level == program->level) {
711: u = t->symvalue.extref;
712: while (u != nil and u->class == EXTREF) {
713: u = u->symvalue.extref;
714: }
715: u->symvalue.offset = np->n_value;
716: delete(t);
717: } else if (t->level == program->level and
718: (t->class == VAR or t->class == PROC or t->class == FUNC)
719: ) {
720: conflict = nil;
721: t->symvalue.offset = np->n_value;
722: }
723: }
724: t = next;
725: } while (t != nil);
726: if (conflict != nil) {
727: u = defvar(n);
728: u->block = conflict;
729: u->symvalue.offset = np->n_value;
730: }
731: }
732: }
733:
734: /*
735: * Check to see if a local _name is known in the current scope.
736: * If not then enter it.
737: */
738:
739: private check_local (name, np)
740: String name;
741: register struct nlist *np;
742: {
743: register Name n;
744: register Symbol t, cur;
745:
746: n = identname(name, true);
747: cur = ((np->n_type&N_TYPE) == N_TEXT) ? curmodule : curblock;
748: find(t, n) where t->block == cur endfind(t);
749: if (t == nil) {
750: t = insert(n);
751: t->language = findlanguage(".s");
752: t->type = t_int;
753: t->block = cur;
754: t->storage = EXT;
755: t->level = cur->level;
756: if ((np->n_type&N_TYPE) == N_TEXT) {
757: t->class = FUNC;
758: t->symvalue.funcv.src = false;
759: t->symvalue.funcv.inline = false;
760: t->symvalue.funcv.beginaddr = np->n_value;
761: newfunc(t, codeloc(t));
762: findbeginning(t);
763: } else {
764: t->class = VAR;
765: t->symvalue.offset = np->n_value;
766: }
767: }
768: }
769:
770: /*
771: * Check to see if a symbol corresponds to a object file name.
772: * For some reason these are listed as in the text segment.
773: */
774:
775: private check_filename (name)
776: String name;
777: {
778: register String mname;
779: register integer i;
780: Name n;
781: Symbol s;
782:
783: mname = strdup(name);
784: i = strlen(mname) - 2;
785: if (i >= 0 and mname[i] == '.' and mname[i+1] == 'o') {
786: mname[i] = '\0';
787: --i;
788: while (mname[i] != '/' and i >= 0) {
789: --i;
790: }
791: n = identname(&mname[i+1], true);
792: find(s, n) where s->block == program and s->class == MODULE endfind(s);
793: if (s == nil) {
794: s = insert(n);
795: s->language = findlanguage(".s");
796: s->class = MODULE;
797: s->symvalue.funcv.beginaddr = 0;
798: findbeginning(s);
799: }
800: if (curblock->class != PROG) {
801: exitblock();
802: if (curblock->class != PROG) {
803: exitblock();
804: }
805: }
806: enterblock(s);
807: curmodule = s;
808: }
809: }
810:
811: /*
812: * Check to see if a symbol is about to be defined within an unnamed block.
813: * If this happens, we create a procedure for the unnamed block, make it
814: * "inline" so that tracebacks don't associate an activation record with it,
815: * and enter it into the function table so that it will be detected
816: * by "whatblock".
817: */
818:
819: public chkUnnamedBlock ()
820: {
821: register Symbol s;
822: static int bnum = 0;
823: char buf[100];
824: Address startaddr;
825:
826: if (nesting > 0 and addrstk[nesting] != NOADDR) {
827: startaddr = (linep - 1)->addr;
828: ++bnum;
829: sprintf(buf, "$b%d", bnum);
830: s = insert(identname(buf, false));
831: s->language = curlang;
832: s->class = PROC;
833: s->symvalue.funcv.src = false;
834: s->symvalue.funcv.inline = true;
835: s->symvalue.funcv.beginaddr = startaddr;
836: enterblock(s);
837: newfunc(s, startaddr);
838: addrstk[nesting] = NOADDR;
839: }
840: }
841:
842: /*
843: * Compilation unit. C associates scope with filenames
844: * so we treat them as "modules". The filename without
845: * the suffix is used for the module name.
846: *
847: * Because there is no explicit "end-of-block" mark in
848: * the object file, we must exit blocks for the current
849: * procedure and module.
850: */
851:
852: private enterSourceModule (n, addr)
853: Name n;
854: Address addr;
855: {
856: register Symbol s;
857: Name nn;
858: String mname, suffix;
859:
860: mname = strdup(ident(n));
861: if (rindex(mname, '/') != nil) {
862: mname = rindex(mname, '/') + 1;
863: }
864: suffix = rindex(mname, '.');
865: if (suffix > mname && *(suffix-1) == '.') {
866: /* special hack for C++ */
867: --suffix;
868: }
869: curlang = findlanguage(suffix);
870: if (curlang == findlanguage(".f")) {
871: strip_ = true;
872: }
873: if (suffix != nil) {
874: *suffix = '\0';
875: }
876: if (not (*language_op(curlang, L_HASMODULES))()) {
877: if (curblock->class != PROG) {
878: exitblock();
879: if (curblock->class != PROG) {
880: exitblock();
881: }
882: }
883: nn = identname(mname, true);
884: if (curmodule == nil or curmodule->name != nn) {
885: s = insert(nn);
886: s->class = MODULE;
887: s->symvalue.funcv.beginaddr = 0;
888: findbeginning(s);
889: } else {
890: s = curmodule;
891: }
892: s->language = curlang;
893: enterblock(s);
894: curmodule = s;
895: }
896: if (program->language == nil) {
897: program->language = curlang;
898: }
899: warned = false;
900: enterfile(ident(n), addr);
901: initTypeTable();
902: }
903:
904: /*
905: * Allocate file and line tables and initialize indices.
906: */
907:
908: private allocmaps (nf, nl)
909: integer nf, nl;
910: {
911: if (filetab != nil) {
912: dispose(filetab);
913: }
914: if (linetab != nil) {
915: dispose(linetab);
916: }
917: filetab = newarr(Filetab, nf);
918: linetab = newarr(Linetab, nl);
919: filep = filetab;
920: linep = linetab;
921: }
922:
923: /*
924: * Add a file to the file table.
925: *
926: * If the new address is the same as the previous file address
927: * this routine used to not enter the file, but this caused some
928: * problems so it has been removed. It's not clear that this in
929: * turn may not also cause a problem.
930: */
931:
932: private enterfile (filename, addr)
933: String filename;
934: Address addr;
935: {
936: filep->addr = addr;
937: filep->filename = filename;
938: filep->lineindex = linep - linetab;
939: ++filep;
940: }
941:
942: /*
943: * Since we only estimated the number of lines (and it was a poor
944: * estimation) and since we need to know the exact number of lines
945: * to do a binary search, we set it when we're done.
946: */
947:
948: private setnlines ()
949: {
950: nlhdr.nlines = linep - linetab;
951: }
952:
953: /*
954: * Similarly for nfiles ...
955: */
956:
957: private setnfiles ()
958: {
959: nlhdr.nfiles = filep - filetab;
960: setsource(filetab[0].filename);
961: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.