![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to assyms.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / bin / as|
Return to assyms.c CVS log | Up to [CSRG BSD Unix] / 43BSD / bin / as |
1.1 root 1: /*
2: * Copyright (c) 1982 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[] = "@(#)assyms.c 5.1 (Berkeley) 4/30/85";
9: #endif not lint
10:
11: #include <stdio.h>
12: #include <ctype.h>
13: #include "as.h"
14: #include "asscan.h"
15: #include "assyms.h"
16:
17: /*
18: * Managers for chunks of symbols allocated from calloc()
19: * We maintain a linked list of such chunks.
20: *
21: */
22: struct allocbox *allochead; /*head of chunk list*/
23: struct allocbox *alloctail; /*tail*/
24: struct allocbox *newbox; /*for creating a new chunk*/
25: struct symtab *nextsym; /*next symbol free*/
26: int symsleft; /*slots left in current chunk*/
27:
28: struct symtab **symptrs;
29: struct symtab **symdelim[NLOC + NLOC +1];
30: struct symtab **symptrub;
31: /*
32: * Managers for the dynamically extendable hash table
33: */
34: struct hashdallop *htab;
35:
36: Iptr *itab[NINST]; /*maps opcodes to instructions*/
37: /*
38: * Counts what went into the symbol table, so that the
39: * size of the symbol table can be computed.
40: */
41: int nsyms; /* total number in the symbol table */
42: int njxxx; /* number of jxxx entrys */
43: int nforgotten; /* number of symbols erroneously entered */
44: int nlabels; /* number of label entries */
45:
46: /*
47: * Managers of the symbol literal storage.
48: */
49: struct strpool *strplhead = 0;
50:
51: symtabinit()
52: {
53: allochead = 0;
54: alloctail = 0;
55: nextsym = 0;
56: symsleft = 0;
57: strpoolalloc(); /* get the first strpool storage area */
58: htab = 0;
59: htaballoc(); /* get the first part of the hash table */
60: }
61:
62: /*
63: * Install all known instructions in the symbol table
64: */
65: syminstall()
66: {
67: register Iptr ip;
68: register struct symtab **hp;
69: register char *p1, *p2;
70: register int i;
71:
72: for (i = 0; i < NINST; i++)
73: itab[i] = (Iptr*)BADPOINT;
74:
75: for (ip = (Iptr)instab; FETCHNAME(ip)[0]; ip++) {
76: p1 = FETCHNAME(ip);
77: p2 = yytext;
78: while (*p2++ = *p1++);
79: hp = lookup(0); /* 0 => don't install this*/
80: if (*hp==NULL) {
81: *hp = (struct symtab *)ip;
82: if ( (ip->s_tag!=INSTn)
83: && (ip->s_tag!=INST0)
84: && (ip->s_tag!=0))
85: continue; /* was pseudo-op */
86: if (itab[ip->i_eopcode] == (Iptr*)BADPOINT){
87: itab[ip->i_eopcode] =
88: (Iptr*)ClearCalloc(256, sizeof(Iptr));
89: for (i = 0; i < 256; i++)
90: itab[ip->i_eopcode][i] =
91: (Iptr)BADPOINT;
92: }
93: itab[ip->i_eopcode][ip->i_popcode] = ip;
94: }
95: }
96: } /*end of syminstall*/
97:
98: #define ISLABEL(sp) \
99: ( (!savelabels) \
100: && (sp->s_tag == LABELID) \
101: && (STRPLACE(sp) & STR_CORE) \
102: && (FETCHNAME(sp)[0] == 'L'))
103: /*
104: * Assign final values to symbols,
105: * and overwrite the index field with its relative position in
106: * the symbol table we give to the loader.
107: */
108: extern struct exec hdr;
109:
110: freezesymtab()
111: {
112: register struct symtab *sp;
113: long bs;
114: register int relpos = 0;
115: register struct symtab *ubsp;
116: register struct allocbox *allocwalk;
117:
118: DECLITERATE(allocwalk, sp, ubsp)
119: {
120: if (sp->s_tag >= IGNOREBOUND)
121: continue; /*totally ignore jxxx entries */
122: /*
123: * Ignore stabs, but give them a symbol table index
124: */
125: if (sp->s_type & STABFLAG)
126: goto assignindex;
127: if ((sp->s_type&XTYPE)==XUNDEF)
128: sp->s_type = XXTRN+XUNDEF;
129: else if ((sp->s_type&XTYPE)==XDATA)
130: sp->s_value += usedot[sp->s_index].e_xvalue;
131: else if ((sp->s_type&XTYPE)==XTEXT)
132: sp->s_value += usedot[sp->s_index].e_xvalue;
133: else if ((sp->s_type&XTYPE)==XBSS) {
134: bs = sp->s_value;
135: sp->s_value = hdr.a_bss + datbase;
136: hdr.a_bss += bs;
137: }
138: assignindex:
139: if (!ISLABEL(sp))
140: sp->s_index = relpos++;
141: }
142: }
143:
144: /*
145: * For all of the stabs that had their final value undefined during pass 1
146: * and during pass 2 assign a final value.
147: * We have already given stab entrys a initial approximation
148: * when we constsructed the sorted symbol table.
149: * Iteration order doesn't matter.
150: */
151:
152: stabfix()
153: {
154: register struct symtab *sp, **cosp;
155: register struct symtab *p;
156:
157: SYMITERATE(cosp, sp){
158: if(sp->s_ptype && (sp->s_type & STABFLAG)) {
159: p = sp->s_dest;
160: /*
161: * STABFLOATING indicates that the offset has been saved in s_desc, s_other
162: */
163: if(sp->s_tag == STABFLOATING) {
164: sp->s_value = ( ( ((unsigned char) sp->s_other) << 16) | ( (unsigned short) sp->s_desc ) );
165: sp->s_value = sp->s_value + p->s_value;
166: }
167: else sp->s_value = p->s_value;
168: sp->s_index = p->s_index;
169: sp->s_type = p->s_type;
170:
171:
172: }
173: }
174: }
175:
176: char *Calloc(number, size)
177: int number, size;
178: {
179: register char *newstuff;
180: char *sbrk();
181: newstuff = sbrk(number*size);
182: if ((int)newstuff == -1){
183: yyerror("Ran out of Memory");
184: delexit();
185: }
186: return(newstuff);
187: }
188:
189: char *ClearCalloc(number, size)
190: int number, size;
191: {
192: register char *newstuff; /* r11 */
193: register int length = number * size; /* r10 */
194: #ifdef lint
195: length = length;
196: #endif length
197: newstuff = Calloc(number, size);
198: asm("movc5 $0, (r0), $0, r10, (r11)");
199: return(newstuff);
200: }
201:
202: struct symtab *symalloc()
203: {
204: if (symsleft == 0){
205: newbox = (struct allocbox *)ClearCalloc(1,ALLOCQTY);
206: symsleft = SYMDALLOP;
207: nextsym = &newbox->symslots[0];
208: if (alloctail == 0){
209: allochead = alloctail = newbox;
210: } else {
211: alloctail->nextalloc = newbox;
212: alloctail = newbox;
213: }
214: }
215: --symsleft;
216: ++nsyms;
217: return(nextsym++);
218: }
219:
220: strpoolalloc()
221: {
222: register struct strpool *new;
223:
224: new = (struct strpool *)Calloc(1, sizeof (struct strpool));
225: new->str_nalloc = 0;
226: new->str_next = strplhead;
227: strplhead = new;
228: }
229:
230: symcmp(Pptr, Qptr)
231: struct symtab **Pptr, **Qptr;
232: {
233: register struct symtab *p = *Pptr;
234: register struct symtab *q = *Qptr;
235: if (p->s_index < q->s_index)
236: return(-1);
237: if (p->s_index > q->s_index)
238: return(1);
239: if (p->s_value < q->s_value)
240: return(-1);
241: if (p->s_value > q->s_value)
242: return(1);
243: /*
244: * Force jxxx entries to virtually preceed labels defined
245: * to follow the jxxxx instruction, so that bumping the
246: * jxxx instruction correctly fixes up the following labels
247: */
248: if (p->s_tag >= IGNOREBOUND) /*p points to a jxxx*/
249: return(-1);
250: if (q->s_tag >= IGNOREBOUND)
251: return(1);
252: /*
253: * both are now just plain labels; the relative order doesn't
254: * matter. Both can't be jxxxes, as they would have different
255: * values.
256: */
257: return(0);
258: } /*end of symcmp*/
259:
260: /*
261: * We construct the auxiliary table of pointers, symptrs and
262: * symdelim
263: * We also assign preliminary values to stab entries that did not yet
264: * have an absolute value (because they initially referred to
265: * forward references). We don't worry about .stabds, as they
266: * already have an estimated final value
267: */
268:
269: sortsymtab()
270: {
271: register struct symtab *sp;
272: register struct symtab **cowalk;
273: register struct allocbox *allocwalk;
274: struct symtab *ubsp;
275: int segno;
276: int slotno;
277: int symsin; /*number put into symptrs*/
278:
279: symptrs = (struct symtab **)Calloc(nsyms + 2, sizeof *symptrs);
280: /*
281: * Allocate one word at the beginning of the symptr array
282: * so that backwards scans through the symptr array will
283: * work correctly while scanning through the zeroth segment
284: */
285: *symptrs++ = 0;
286: cowalk = symptrs;
287: symsin = 0;
288: DECLITERATE(allocwalk, sp, ubsp) {
289: if (sp->s_ptype && (sp->s_type &STABFLAG)){
290: sp->s_value = sp->s_dest->s_value;
291: sp->s_index = sp->s_dest->s_index;
292: }
293: if (symsin >= nsyms)
294: yyerror("INTERNAL ERROR: overfilled symbol table indirection table");
295: *cowalk++ = sp;
296: symsin++;
297: }
298: if (symsin != nsyms)
299: yyerror("INTERNAL ERROR: installed %d syms, should have installed %d",
300: symsin, nsyms);
301: symptrub = &symptrs[nsyms ];
302: qsort(symptrs, nsyms, sizeof *symptrs, symcmp);
303: symdelim[0] = symptrs;
304: for (cowalk = symptrs, sp = *cowalk, segno = 0, slotno = 1;
305: segno < NLOC + NLOC;
306: segno++, slotno++){
307: for (; sp && sp->s_index == segno; sp = *++cowalk);
308: symdelim[slotno] = cowalk; /*forms the ub delimeter*/
309: }
310: } /*end of sortsymtab*/
311:
312: #ifdef DEBUG
313: dumpsymtab()
314: {
315: register int segno;
316: register struct symtab *sp, **cosp, *ub;
317: char *tagstring();
318:
319: printf("Symbol Table dump:\n");
320: for (segno = 0; segno < NLOC + NLOC; segno++){
321: printf("Segment number: %d\n", segno);
322: SEGITERATE(segno, 0, 0, cosp, sp, ub, ++){
323: printf("\tSeg: %d \"%s\" value: %d index: %d tag %s\n",
324: segno, FETCHNAME(sp),
325: sp->s_value, sp->s_index,
326: tagstring(sp->s_tag));
327: printf("\t\ttype: %d jxbump %d jxfear: %d\n",
328: sp->s_type, sp->s_jxbump, sp->s_jxfear);
329: }
330: printf("\n\n");
331: }
332: }
333:
334: static char tagbuff[4];
335:
336: char *tagstring(tag)
337: unsigned char tag;
338: {
339: switch(tag){
340: case JXACTIVE: return("active");
341: case JXNOTYET: return("notyet");
342: case JXALIGN: return("align");
343: case JXQUESTIONABLE: return("jxquestionable");
344: case JXINACTIVE: return("inactive");
345: case JXTUNNEL: return("tunnel");
346: case OBSOLETE: return("obsolete");
347: case IGNOREBOUND: return("ignorebound");
348: case STABFLOATING: return("stabfloating");
349: case STABFIXED: return("stabfixed");
350: case LABELID: return("labelid");
351: case OKTOBUMP: return("oktobump");
352: case ISET: return("iset");
353: case ILSYM: return("ilsym");
354: default: sprintf(tagbuff,"%d", tag);
355: return(tagbuff);
356: }
357: }
358: #endif DEBUG
359:
360: htaballoc()
361: {
362: register struct hashdallop *new;
363: new = (struct hashdallop *)ClearCalloc(1, sizeof (struct hashdallop));
364: if (htab == 0)
365: htab = new;
366: else { /* add AFTER the 1st slot */
367: new->h_next = htab->h_next;
368: htab->h_next = new;
369: }
370: }
371:
372: #define HASHCLOGGED (NHASH / 2)
373:
374: /*
375: * Lookup a symbol stored in extern yytext.
376: * All strings passed in via extern yytext had better have
377: * a trailing null. Strings are placed in yytext for hashing by
378: * syminstall() and by yylex();
379: *
380: * We take pains to avoid function calls; this functdion
381: * is called quite frequently, and the calls overhead
382: * in the vax contributes significantly to the overall
383: * execution speed of as.
384: */
385: struct symtab **lookup(instflg)
386: int instflg; /* 0: don't install */
387: {
388: static int initialprobe;
389: register struct symtab **hp;
390: register char *from;
391: register char *to;
392: register int len;
393: register int nprobes;
394: static struct hashdallop *hdallop;
395: static struct symtab **emptyslot;
396: static struct hashdallop *emptyhd;
397: static struct symtab **hp_ub;
398:
399: emptyslot = 0;
400: for (nprobes = 0, from = yytext;
401: *from;
402: nprobes <<= 2, nprobes += *from++)
403: continue;
404: nprobes += from[-1] << 5;
405: nprobes %= NHASH;
406: if (nprobes < 0)
407: nprobes += NHASH;
408:
409: initialprobe = nprobes;
410: for (hdallop = htab; hdallop != 0; hdallop = hdallop->h_next){
411: for (hp = &(hdallop->h_htab[initialprobe]),
412: nprobes = 1,
413: hp_ub = &(hdallop->h_htab[NHASH]);
414: (*hp) && (nprobes < NHASH);
415: hp += nprobes,
416: hp -= (hp >= hp_ub) ? NHASH:0,
417: nprobes += 2)
418: {
419: from = yytext;
420: to = FETCHNAME(*hp);
421: while (*from && *to)
422: if (*from++ != *to++)
423: goto nextprobe;
424: if (*to == *from) /*assert both are == 0*/
425: return(hp);
426: nextprobe: ;
427: }
428: if (*hp == 0 && emptyslot == 0 &&
429: hdallop->h_nused < HASHCLOGGED) {
430: emptyslot = hp;
431: emptyhd = hdallop;
432: }
433: }
434: if (emptyslot == 0) {
435: htaballoc();
436: hdallop = htab->h_next; /* aren't we smart! */
437: hp = &hdallop->h_htab[initialprobe];
438: } else {
439: hdallop = emptyhd;
440: hp = emptyslot;
441: }
442: if (instflg) {
443: *hp = symalloc();
444: hdallop->h_nused++;
445: for (from = yytext, len = 0; *from++; len++)
446: continue;
447: (*hp)->s_name = (char *)savestr(yytext, len + 1, STR_BOTH);
448: }
449: return(hp);
450: } /*end of lookup*/
451: /*
452: * save a string str with len in the places indicated by place
453: */
454: struct strdesc *savestr(str, len, place)
455: char *str;
456: int len;
457: int place;
458: {
459: reg struct strdesc *res;
460: int tlen;
461: /*
462: * Compute the total length of the record to live in core
463: */
464: tlen = sizeof(struct strdesc) - sizeof(res->sd_string);
465: if (place & STR_CORE)
466: tlen += len;
467: /*
468: * See if there is enough space for the record,
469: * and allocate the record.
470: */
471: if (tlen >= (STRPOOLDALLOP - strplhead->str_nalloc))
472: strpoolalloc();
473: res = (struct strdesc *)(strplhead->str_names + strplhead->str_nalloc);
474: /*
475: * Save the string information that is always present
476: */
477: res->sd_stroff = strfilepos;
478: res->sd_strlen = len;
479: res->sd_place = place;
480: /*
481: * Now, save the string itself. If str is null, then
482: * the characters have already been dumped to the file
483: */
484: if ((place & STR_CORE) && str)
485: movestr(res[0].sd_string, str, len);
486: if (place & STR_FILE){
487: if (str){
488: fwrite(str, 1, len, strfile);
489: }
490: strfilepos += len;
491: }
492: /*
493: * Adjust the in core string pool size
494: */
495: strplhead->str_nalloc += tlen;
496: return(res);
497: }
498: /*
499: * The relocation information is saved internally in an array of
500: * lists of relocation buffers. The relocation buffers are
501: * exactly the same size as a token buffer; if we use VM for the
502: * temporary file we reclaim this storage, otherwise we create
503: * them by mallocing.
504: */
505: #define RELBUFLG TOKBUFLG
506: #define NRELOC ((TOKBUFLG - \
507: (sizeof (int) + sizeof (struct relbufdesc *)) \
508: ) / (sizeof (struct relocation_info)))
509:
510: struct relbufdesc{
511: int rel_count;
512: struct relbufdesc *rel_next;
513: struct relocation_info rel_reloc[NRELOC];
514: };
515: extern struct relbufdesc *tok_free;
516: #define rel_free tok_free
517: static struct relbufdesc *rel_temp;
518: struct relocation_info r_can_1PC;
519: struct relocation_info r_can_0PC;
520:
521: initoutrel()
522: {
523: r_can_0PC.r_address = 0;
524: r_can_0PC.r_symbolnum = 0;
525: r_can_0PC.r_pcrel = 0;
526: r_can_0PC.r_length = 0;
527: r_can_0PC.r_extern = 0;
528:
529: r_can_1PC = r_can_0PC;
530: r_can_1PC.r_pcrel = 1;
531: }
532:
533: outrel(xp, reloc_how)
534: register struct exp *xp;
535: int reloc_how; /* TYPB..TYPH + (possibly)RELOC_PCREL */
536: {
537: struct relocation_info reloc;
538: register int x_type_mask;
539: int pcrel;
540:
541: x_type_mask = xp->e_xtype & ~XFORW;
542: pcrel = reloc_how & RELOC_PCREL;
543: reloc_how &= ~RELOC_PCREL;
544:
545: if (bitoff&07)
546: yyerror("Padding error");
547: if (x_type_mask == XUNDEF)
548: yyerror("Undefined reference");
549:
550: if ( (x_type_mask != XABS) || pcrel ) {
551: if (ty_NORELOC[reloc_how])
552: yyerror("Illegal Relocation of floating or large int number.");
553: reloc = pcrel ? r_can_1PC : r_can_0PC;
554: reloc.r_address = dotp->e_xvalue -
555: ( (dotp < &usedot[NLOC] || readonlydata) ? 0 : datbase );
556: reloc.r_length = ty_nlg[reloc_how];
557: switch(x_type_mask){
558: case XXTRN | XUNDEF:
559: reloc.r_symbolnum = xp->e_xname->s_index;
560: reloc.r_extern = 1;
561: break;
562: default:
563: if (readonlydata && (x_type_mask&~XXTRN) == XDATA)
564: x_type_mask = XTEXT | (x_type_mask&XXTRN);
565: reloc.r_symbolnum = x_type_mask;
566: break;
567: }
568: if ( (relfil == 0) || (relfil->rel_count >= NRELOC) ){
569: if (rel_free){
570: rel_temp = rel_free;
571: rel_free = rel_temp->rel_next;
572: } else {
573: rel_temp = (struct relbufdesc *)
574: Calloc(1,sizeof (struct relbufdesc));
575: }
576: rel_temp->rel_count = 0;
577: rel_temp->rel_next = relfil;
578: relfil = rusefile[dotp - &usedot[0]] = rel_temp;
579: }
580: relfil->rel_reloc[relfil->rel_count++] = reloc;
581: }
582: /*
583: * write the unrelocated value to the text file
584: */
585: dotp->e_xvalue += ty_nbyte[reloc_how];
586: if (pcrel)
587: xp->e_xvalue -= dotp->e_xvalue;
588: switch(reloc_how){
589: case TYPO:
590: case TYPQ:
591:
592: case TYPF:
593: case TYPD:
594: case TYPG:
595: case TYPH:
596: bignumwrite(xp->e_number, reloc_how);
597: break;
598:
599: default:
600: bwrite((char *)&(xp->e_xvalue), ty_nbyte[reloc_how], txtfil);
601: break;
602: }
603: }
604: /*
605: * Flush out all of the relocation information.
606: * Note that the individual lists of buffers are in
607: * reverse order, so we must reverse them
608: */
609: off_t closeoutrel(relocfile)
610: BFILE *relocfile;
611: {
612: int locindex;
613: u_long Closeoutrel();
614:
615: trsize = 0;
616: for (locindex = 0; locindex < NLOC; locindex++){
617: trsize += Closeoutrel(rusefile[locindex], relocfile);
618: }
619: drsize = 0;
620: for (locindex = 0; locindex < NLOC; locindex++){
621: drsize += Closeoutrel(rusefile[NLOC + locindex], relocfile);
622: }
623: return(trsize + drsize);
624: }
625:
626: u_long Closeoutrel(relfil, relocfile)
627: struct relbufdesc *relfil;
628: BFILE *relocfile;
629: {
630: u_long tail;
631: if (relfil == 0)
632: return(0L);
633: tail = Closeoutrel(relfil->rel_next, relocfile);
634: bwrite((char *)&relfil->rel_reloc[0],
635: relfil->rel_count * sizeof (struct relocation_info),
636: relocfile);
637: return(tail + relfil->rel_count * sizeof (struct relocation_info));
638: }
639:
640: #define NOUTSYMS (nsyms - njxxx - nforgotten - (savelabels ? 0 : nlabels))
641: int sizesymtab()
642: {
643: return (sizeof (struct nlist) * NOUTSYMS);
644: }
645: /*
646: * Write out n symbols to file f, beginning at p
647: * ignoring symbols that are obsolete, jxxx instructions, and
648: * possibly, labels
649: */
650: int symwrite(symfile)
651: BFILE *symfile;
652: {
653: int symsout; /*those actually written*/
654: int symsdesired = NOUTSYMS;
655: reg struct symtab *sp, *ub;
656: char *name; /* temp to save the name */
657: int totalstr;
658: /*
659: * We use sp->s_index to hold the length of the
660: * name; it isn't used for anything else
661: */
662: register struct allocbox *allocwalk;
663:
664: symsout = 0;
665: totalstr = sizeof(totalstr);
666: DECLITERATE(allocwalk, sp, ub) {
667: if (sp->s_tag >= IGNOREBOUND)
668: continue;
669: if (ISLABEL(sp))
670: continue;
671: symsout++;
672: name = sp->s_name; /* save pointer */
673: /*
674: * the length of the symbol table string
675: * always includes the trailing null;
676: * blast the pointer to its a.out value.
677: */
678: if (sp->s_name && (sp->s_index = STRLEN(sp))){
679: sp->s_nmx = totalstr;
680: totalstr += sp->s_index;
681: } else {
682: sp->s_nmx = 0;
683: }
684: if (sp->s_ptype != 0)
685: sp->s_type = sp->s_ptype;
686: else
687: sp->s_type = (sp->s_type & (~XFORW));
688: if (readonlydata && (sp->s_type&~N_EXT) == N_DATA)
689: sp->s_type = N_TEXT | (sp->s_type & N_EXT);
690: bwrite((char *)&sp->s_nm, sizeof (struct nlist), symfile);
691: sp->s_name = name; /* restore pointer */
692: }
693: if (symsout != symsdesired)
694: yyerror("INTERNAL ERROR: Wrote %d symbols, wanted to write %d symbols\n",
695: symsout, symsdesired);
696: /*
697: * Construct the string pool from the symbols that were written,
698: * possibly fetching from the string file if the string
699: * is not core resident.
700: */
701: bwrite(&totalstr, sizeof(totalstr), symfile);
702: symsout = 0;
703: DECLITERATE(allocwalk, sp, ub) {
704: if (sp->s_tag >= IGNOREBOUND)
705: continue;
706: if (ISLABEL(sp))
707: continue;
708: symsout++;
709: if (STRLEN(sp) > 0){
710: if (STRPLACE(sp) & STR_CORE){
711: bwrite(FETCHNAME(sp), STRLEN(sp), symfile);
712: } else if (STRPLACE(sp) & STR_FILE){
713: char rbuf[2048];
714: int left, nread;
715: fseek(strfile, STROFF(sp), 0);
716: for (left = STRLEN(sp); left > 0; left -= nread){
717: nread = fread(rbuf, sizeof(char),
718: min(sizeof(rbuf), left), strfile);
719: if (nread == 0)
720: break;
721: bwrite(rbuf, nread, symfile);
722: }
723: }
724: }
725: }
726: if (symsout != symsdesired)
727: yyerror("INTERNAL ERROR: Wrote %d strings, wanted %d\n",
728: symsout, symsdesired);
729: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.