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