![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to stab.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / lib / pcc|
Return to stab.c CVS log | Up to [CSRG BSD Unix] / 43BSD / lib / pcc |
1.1 root 1: #ifndef lint
2: static char *sccsid ="@(#)stab.c 1.12 (Berkeley) 3/27/86";
3: #endif
4: /*
5: * Symbolic debugging info interface.
6: *
7: * Here we generate pseudo-ops that cause the assembler to put
8: * symbolic debugging information into the object file.
9: */
10:
11: #include "pass1.h"
12:
13: #include <sys/types.h>
14: #include <a.out.h>
15: #include <stab.h>
16:
17: #define private static
18: #define and &&
19: #define or ||
20: #define not !
21: #define div /
22: #define mod %
23: #define nil 0
24:
25: #define bytes(bits) ((bits) / SZCHAR)
26: #define bsize(p) bytes(dimtab[p->sizoff]) /* size in bytes of a symbol */
27:
28: #define NILINDEX -1
29: #define FORWARD -2
30:
31: typedef int Boolean;
32:
33: #define false 0
34: #define true 1
35:
36: extern int ddebug;
37: extern int gdebug;
38: extern char *malloc();
39:
40: int stabLCSYM;
41:
42: /*
43: * Flag for producing either sdb or dbx symbol information.
44: */
45: int oldway = false;
46:
47: /*
48: * Generate debugging info for a parameter.
49: * The offset isn't known when it is first entered into the symbol table
50: * since the types are read later.
51: */
52:
53: fixarg(p)
54: struct symtab *p;
55: {
56: if (oldway) {
57: old_fixarg(p);
58: } else if (gdebug) {
59: printf("\t.stabs\t\"%s:p", p->sname);
60: gentype(p);
61: printf("\",0x%x,0,%d,%d\n", N_PSYM, bsize(p), bytes(argoff));
62: }
63: }
64:
65: /*
66: * Determine if the given symbol is a global array with dimension 0,
67: * which only makes sense if it's dimension is to be given later.
68: * We therefore currently do not generate symbol information for
69: * such entries.
70: */
71:
72: #define isglobal(class) ( \
73: class == EXTDEF or class == EXTERN or class == STATIC \
74: )
75:
76: private Boolean zero_length_array(p)
77: register struct symtab *p;
78: {
79: Boolean b;
80: int t;
81:
82: if (not isglobal(p->sclass)) {
83: b = false;
84: } else {
85: t = p->stype;
86: if (ISFTN(t)) {
87: t = DECREF(t);
88: }
89: b = (Boolean) (ISARY(t) and dimtab[p->dimoff] == 0);
90: }
91: return b;
92: }
93:
94: /*
95: * Generate debugging info for a given symbol.
96: */
97:
98: outstab(sym)
99: struct symtab *sym;
100: {
101: register struct symtab *p;
102: char *classname;
103: int offset;
104: Boolean ignore;
105: static Boolean firsttime = true;
106:
107: if (oldway) {
108: old_outstab(sym);
109: } else if (gdebug and not zero_length_array(sym)) {
110: if (firsttime) {
111: firsttime = false;
112: inittypes();
113: }
114: ignore = false;
115: p = sym;
116: offset = bytes(p->offset);
117: switch (p->sclass) {
118: case REGISTER:
119: classname = "r";
120: offset = p->offset;
121: break;
122:
123: /*
124: * Locals are the default class.
125: */
126: case AUTO:
127: classname = "";
128: break;
129:
130: case STATIC:
131: if (ISFTN(p->stype)) {
132: ignore = true;
133: } else if (p->slevel <= 1) {
134: classname = "S";
135: } else {
136: classname = "V";
137: }
138: break;
139:
140: case EXTDEF:
141: case EXTERN:
142: if (ISFTN(p->stype)) {
143: ignore = true;
144: } else {
145: classname = "G";
146: }
147: break;
148:
149: case TYPEDEF:
150: classname = "t";
151: break;
152:
153: case PARAM:
154: case MOS:
155: case MOU:
156: case MOE:
157: ignore = true;
158: break;
159:
160: case ENAME:
161: case UNAME:
162: case STNAME:
163: entertype(p->stype, NILINDEX, FORWARD, dimtab[p->sizoff + 3]);
164: ignore = true;
165: break;
166:
167: default:
168: if ((p->sclass&FIELD) == 0) {
169: printf("/* no info for %s (%d) */\n", p->sname, p->sclass);
170: }
171: ignore = true;
172: break;
173: }
174: if (not ignore) {
175: printf("\t.stabs\t\"%s:%s", p->sname, classname);
176: gentype(p);
177: geninfo(p);
178: }
179: }
180: }
181:
182: /*
183: * Since type names are lost in the travels and because C has
184: * structural type equivalence we keep a table of type words that
185: * we've already seen. The first time we see a type, it is assigned
186: * (inline) a number and future references just list that number.
187: * Structures, unions, enums, and arrays must be handled carefully
188: * since not all the necessary information is in the type word.
189: */
190:
191: typedef struct Typeid *Typeid;
192:
193: struct Typeid {
194: TWORD tword;
195: int tarray;
196: int tstruct;
197: int tstrtag;
198: int tnum;
199: Typeid chain;
200: };
201:
202: #define TABLESIZE 2003
203:
204: private int tcount = 1;
205: private int t_int, t_char;
206: private Typeid typetable[TABLESIZE];
207:
208: /*
209: * Look for the given type word in the type table.
210: */
211:
212: private Typeid typelookup(type, arrindex, strindex, strtag)
213: TWORD type;
214: int arrindex;
215: int strindex;
216: int strtag;
217: {
218: register TWORD tword;
219: register int i1, i2;
220: Typeid t;
221:
222: t = typetable[type mod TABLESIZE];
223: while (t != nil) {
224: if (t->tword == type and
225: strindex == t->tstruct and strtag == t->tstrtag) {
226: if (arrindex == NILINDEX) {
227: break;
228: } else {
229: tword = type;
230: i1 = arrindex;
231: i2 = t->tarray;
232: while (ISARY(tword) and dimtab[i1] == dimtab[i2]) {
233: ++i1;
234: ++i2;
235: tword >>= TSHIFT;
236: }
237: if (!ISARY(tword)) {
238: break;
239: }
240: }
241: }
242: t = t->chain;
243: }
244: return t;
245: }
246:
247: /*
248: * Enter a type word and associated symtab indices into the type table.
249: */
250:
251: private int entertype(type, arrindex, strindex, strtag)
252: TWORD type;
253: int arrindex;
254: int strindex;
255: int strtag;
256: {
257: register Typeid t;
258: register int i;
259:
260: t = (Typeid) malloc(sizeof(struct Typeid));
261: t->tword = type;
262: t->tarray = arrindex;
263: t->tstruct = strindex;
264: t->tstrtag = strtag;
265: t->tnum = tcount;
266: ++tcount;
267: i = type mod TABLESIZE;
268: t->chain = typetable[i];
269: typetable[i] = t;
270: return t->tnum;
271: }
272:
273: /*
274: * Change the information associated with a type table entry.
275: * Since I'm lazy this just creates a new entry with the number
276: * as the old one.
277: */
278:
279: private reentertype(typeid, type, arrindex, strindex, strtag)
280: Typeid typeid;
281: TWORD type;
282: int arrindex;
283: int strindex;
284: int strtag;
285: {
286: register Typeid t;
287: register int i;
288:
289: t = (Typeid) malloc(sizeof(struct Typeid));
290: t->tword = type;
291: t->tarray = arrindex;
292: t->tstruct = strindex;
293: t->tstrtag = strtag;
294: t->tnum = typeid->tnum;
295: i = type mod TABLESIZE;
296: t->chain = typetable[i];
297: typetable[i] = t;
298: }
299:
300: /*
301: * Initialize type table with predefined types.
302: */
303:
304: #define builtintype(type) entertype(type, NILINDEX, NILINDEX, NILINDEX)
305:
306: private inittypes()
307: {
308: int t;
309:
310: t_int = builtintype(INT);
311: t_char = builtintype(CHAR);
312: maketype("int", t_int, t_int, 0x80000000L, 0x7fffffffL);
313: maketype("char", t_char, t_char, 0L, 127L);
314: maketype("long", builtintype(LONG), t_int, 0x80000000L, 0x7fffffffL);
315: maketype("short", builtintype(SHORT), t_int, 0xffff8000L, 0x7fffL);
316: maketype("unsigned char", builtintype(UCHAR), t_int, 0L, 255L);
317: maketype("unsigned short", builtintype(USHORT), t_int, 0L, 0xffffL);
318: maketype("unsigned long", builtintype(ULONG), t_int, 0L, 0xffffffffL);
319: maketype("unsigned int", builtintype(UNSIGNED), t_int, 0L, 0xffffffffL);
320: maketype("float", builtintype(FLOAT), t_int, 4L, 0L);
321: maketype("double", builtintype(DOUBLE), t_int, 8L, 0L);
322: t = builtintype(UNDEF);
323: printf("\t.stabs\t\"void:t%d=%d", t, t);
324: geninfo(nil);
325: t = builtintype(FARG);
326: printf("\t.stabs\t\"???:t%d=%d", t, t_int);
327: geninfo(nil);
328: }
329:
330: /*
331: * Generate info for a new range type.
332: */
333:
334: private maketype(name, tnum, eqtnum, lower, upper)
335: char *name;
336: int tnum, eqtnum;
337: long lower, upper;
338: {
339: printf("\t.stabs\t\"%s:t%d=r%d;%d;%d;", name, tnum, eqtnum, lower, upper);
340: geninfo(nil);
341: }
342:
343: /*
344: * Generate debugging information for the given type of the given symbol.
345: */
346:
347: private gentype(sym)
348: struct symtab *sym;
349: {
350: register struct symtab *p;
351: register TWORD t;
352: register TWORD basictype;
353: register Typeid typeid;
354: int i, arrindex, strindex, strtag;
355:
356: p = sym;
357: t = p->stype;
358: if (ISFTN(t)) {
359: t = DECREF(t);
360: }
361: basictype = BTYPE(t);
362: if (ISARY(t)) {
363: arrindex = p->dimoff;
364: } else {
365: arrindex = NILINDEX;
366: }
367: if (basictype == STRTY or basictype == UNIONTY or basictype == ENUMTY) {
368: strindex = dimtab[p->sizoff + 1];
369: if (strindex == -1) {
370: strindex = FORWARD;
371: strtag = dimtab[p->sizoff + 3];
372: } else {
373: strtag = NILINDEX;
374: }
375: } else {
376: strindex = NILINDEX;
377: strtag = NILINDEX;
378: }
379: i = arrindex;
380: typeid = typelookup(t, arrindex, strindex, strtag);
381: while (t != basictype and typeid == nil) {
382: printf("%d=", entertype(t, i, strindex, strtag));
383: switch (t&TMASK) {
384: case PTR:
385: printf("*");
386: break;
387:
388: case FTN:
389: printf("f");
390: break;
391:
392: case ARY:
393: printf("ar%d;0;%d;", t_int, dimtab[i++] - 1);
394: break;
395: }
396: t = DECREF(t);
397: if (i == NILINDEX && ISARY(t)) {
398: i = p->dimoff;
399: }
400: if (t == basictype) {
401: typeid = typelookup(t, NILINDEX, strindex, strtag);
402: } else {
403: typeid = typelookup(t, i, strindex, strtag);
404: }
405: }
406: if (typeid == nil) {
407: if (strindex == FORWARD) {
408: typeid = typelookup(t, NILINDEX, FORWARD, dimtab[p->sizoff + 3]);
409: if (typeid == nil) {
410: cerror("unbelievable forward reference");
411: }
412: printf("%d", typeid->tnum);
413: } else {
414: genstruct(t, NILINDEX, strindex, p->sname, bsize(p));
415: }
416: } else {
417: printf("%d", typeid->tnum);
418: }
419: }
420:
421: /*
422: * Generate type information for structures, unions, and enumerations.
423: */
424:
425: private genstruct(t, structid, index, name, size)
426: TWORD t;
427: int structid;
428: int index;
429: char *name;
430: int size;
431: {
432: register int i;
433: register struct symtab *field;
434: int id;
435:
436: if (structid == NILINDEX) {
437: id = entertype(t, NILINDEX, index, NILINDEX);
438: } else {
439: id = structid;
440: }
441: switch (t) {
442: case STRTY:
443: case UNIONTY:
444: printf("%d=%c%d", id, t == STRTY ? 's' : 'u', size);
445: i = index;
446: while (dimtab[i] != -1) {
447: field = &stab[dimtab[i]];
448: printf("%s:", field->sname);
449: gentype(field);
450: if (field->sclass > FIELD) {
451: printf(",%d,%d;", field->offset, field->sclass - FIELD);
452: } else {
453: printf(",%d,%d;", field->offset,
454: tsize(field->stype, field->dimoff, field->sizoff));
455: }
456: ++i;
457: }
458: putchar(';');
459: break;
460:
461: case ENUMTY:
462: printf("%d=e", id);
463: i = index;
464: while (dimtab[i] != -1) {
465: field = &stab[dimtab[i]];
466: printf("%s:%d,", field->sname, field->offset);
467: i++;
468: }
469: putchar(';');
470: break;
471:
472: default:
473: cerror("couldn't find basic type %d for %s\n", t, name);
474: break;
475: }
476: }
477:
478: /*
479: * Generate offset and size info.
480: */
481:
482: private geninfo(p)
483: register struct symtab *p;
484: {
485: int stabtype;
486:
487: if (p == nil) {
488: printf("\",0x%x,0,0,0\n", N_LSYM);
489: } else {
490: switch (p->sclass) {
491: case EXTERN:
492: case EXTDEF:
493: if (ISFTN(p->stype)) {
494: printf("\",0x%x,0,%d,_%s\n", N_FUN, bsize(p), p->sname);
495: } else {
496: printf("\",0x%x,0,%d,0\n", N_GSYM, bsize(p));
497: }
498: break;
499:
500: case STATIC:
501: stabtype = stabLCSYM ? N_LCSYM : N_STSYM;
502: if (ISFTN(p->stype)) {
503: printf("\",0x%x,0,%d,_%s\n", N_FUN, bsize(p), p->sname);
504: } else if (p->slevel > 1) {
505: printf("\",0x%x,0,%d,L%d\n", stabtype, bsize(p), p->offset);
506: } else {
507: printf("\",0x%x,0,%d,_%s\n", stabtype, bsize(p), p->sname);
508: }
509: break;
510:
511: case REGISTER:
512: printf("\",0x%x,0,%d,%d\n", N_RSYM, bsize(p), p->offset);
513: break;
514:
515: case PARAM:
516: printf("\",0x%x,0,%d,%d\n", N_PSYM, bsize(p), bytes(argoff));
517: break;
518:
519: default:
520: printf("\",0x%x,0,%d,%d\n", N_LSYM, bsize(p), bytes(p->offset));
521: break;
522: }
523: }
524: }
525:
526: /*
527: * Generate information for a newly-defined structure.
528: */
529:
530: outstruct(szindex, paramindex)
531: int szindex, paramindex;
532: {
533: register Typeid typeid;
534: register struct symtab *p;
535: register int i, t, strindex;
536:
537: if (oldway) {
538: /* do nothing */;
539: } else if (gdebug) {
540: i = dimtab[szindex + 3];
541: p = &stab[i];
542: if (p->sname != nil) {
543: strindex = dimtab[p->sizoff + 1];
544: typeid = typelookup(p->stype, NILINDEX, FORWARD, i);
545: if (typeid == nil) {
546: t = 0;
547: } else {
548: t = typeid->tnum;
549: reentertype(typeid, p->stype, NILINDEX, strindex, NILINDEX);
550: }
551: printf("\t.stabs\t\"%s:T", p->sname);
552: genstruct(p->stype, t, strindex, p->sname, bsize(p));
553: geninfo(p);
554: }
555: }
556: }
557:
558: pstab(name, type)
559: char *name;
560: int type;
561: {
562: register int i;
563: register char c;
564:
565: if (!gdebug) {
566: return;
567: } else if (oldway) {
568: old_pstab(name, type);
569: return;
570: }
571: /* locctr(PROG); /* .stabs must appear in .text for c2 */
572: #ifdef ASSTRINGS
573: if ( name[0] == '\0')
574: printf("\t.stabn\t");
575: else
576: #ifndef FLEXNAMES
577: printf("\t.stabs\t\"%.8s\",", name);
578: #else
579: printf("\t.stabs\t\"%s\",", name);
580: #endif
581: #else
582: printf(" .stab ");
583: for(i=0; i<8; i++)
584: if (c = name[i]) printf("'%c,", c);
585: else printf("0,");
586: #endif
587: printf("0%o,", type);
588: }
589:
590: #ifdef STABDOT
591: pstabdot(type, value)
592: int type;
593: int value;
594: {
595: if ( ! gdebug) {
596: return;
597: } else if (oldway) {
598: old_pstabdot(type, value);
599: return;
600: }
601: /* locctr(PROG); /* .stabs must appear in .text for c2 */
602: printf("\t.stabd\t");
603: printf("0%o,0,0%o\n",type, value);
604: }
605: #endif
606:
607: extern char NULLNAME[8];
608: extern int labelno;
609: extern int fdefflag;
610:
611: psline()
612: {
613: static int lastlineno;
614: register char *cp, *cq;
615: register int i;
616:
617: if (!gdebug) {
618: return;
619: } else if (oldway) {
620: old_psline();
621: return;
622: }
623:
624: cq = ititle;
625: cp = ftitle;
626:
627: while ( *cq ) if ( *cp++ != *cq++ ) goto neq;
628: if ( *cp == '\0' ) goto eq;
629:
630: neq: for (i=0; i<100; i++)
631: ititle[i] = '\0';
632: cp = ftitle;
633: cq = ititle;
634: while ( *cp )
635: *cq++ = *cp++;
636: *cq = '\0';
637: *--cq = '\0';
638: #ifndef FLEXNAMES
639: for ( cp = ititle+1; *(cp-1); cp += 8 ) {
640: pstab(cp, N_SOL);
641: if (gdebug) printf("0,0,LL%d\n", labelno);
642: }
643: #else
644: pstab(ititle+1, N_SOL);
645: if (gdebug) printf("0,0,LL%d\n", labelno);
646: #endif
647: *cq = '"';
648: printf("LL%d:\n", labelno++);
649:
650: eq: if (lineno == lastlineno) return;
651: lastlineno = lineno;
652:
653: if (fdefflag) {
654: #ifdef STABDOT
655: pstabdot(N_SLINE, lineno);
656: #else
657: pstab(NULLNAME, N_SLINE);
658: printf("0,%d,LL%d\n", lineno, labelno);
659: printf("LL%d:\n", labelno++);
660: #endif
661: }
662: }
663:
664: plcstab(level)
665: int level;
666: {
667: if (!gdebug) {
668: return;
669: } else if (oldway) {
670: old_plcstab(level);
671: return;
672: }
673: #ifdef STABDOT
674: pstabdot(N_LBRAC, level);
675: #else
676: pstab(NULLNAME, N_LBRAC);
677: printf("0,%d,LL%d\n", level, labelno);
678: printf("LL%d:\n", labelno++);
679: #endif
680: }
681:
682: prcstab(level)
683: int level;
684: {
685: if (!gdebug) {
686: return;
687: } else if (oldway) {
688: old_prcstab(level);
689: return;
690: }
691: #ifdef STABDOT
692: pstabdot(N_RBRAC, level);
693: #else
694: pstab(NULLNAME, N_RBRAC);
695: printf("0,%d,LL%d\n", level, labelno);
696: printf("LL%d:\n", labelno++);
697: #endif
698: }
699:
700: pfstab(sname)
701: char *sname;
702: {
703: register struct symtab *p;
704:
705: if (gdebug) {
706: if (oldway) {
707: old_pfstab(sname);
708: } else {
709: p = &stab[lookup(sname, 0)];
710: printf("\t.stabs\t\"%s:", p->sname);
711: putchar((p->sclass == STATIC) ? 'f' : 'F');
712: gentype(p);
713: geninfo(p);
714: }
715: }
716: }
717:
718: /*
719: * Old way of doing things.
720: */
721:
722: private old_fixarg(p)
723: struct symtab *p; {
724: if (gdebug) {
725: old_pstab(p->sname, N_PSYM);
726: if (gdebug) printf("0,%d,%d\n", p->stype, argoff/SZCHAR);
727: old_poffs(p);
728: }
729: }
730:
731: private old_outstab(p)
732: struct symtab *p; {
733: register TWORD ptype;
734: register char *pname;
735: register char pclass;
736: register int poffset;
737:
738: if (!gdebug) return;
739:
740: ptype = p->stype;
741: pname = p->sname;
742: pclass = p->sclass;
743: poffset = p->offset;
744:
745: if (ISFTN(ptype)) {
746: return;
747: }
748:
749: switch (pclass) {
750:
751: case AUTO:
752: old_pstab(pname, N_LSYM);
753: printf("0,%d,%d\n", ptype, (-poffset)/SZCHAR);
754: old_poffs(p);
755: return;
756:
757: case EXTDEF:
758: case EXTERN:
759: old_pstab(pname, N_GSYM);
760: printf("0,%d,0\n", ptype);
761: old_poffs(p);
762: return;
763:
764: case STATIC:
765: #ifdef LCOMM
766: /* stabLCSYM is 1 during nidcl so we can get stab type right */
767: old_pstab(pname, stabLCSYM ? N_LCSYM : N_STSYM);
768: #else
769: old_pstab(pname, N_STSYM);
770: #endif
771: if (p->slevel > 1) {
772: printf("0,%d,L%d\n", ptype, poffset);
773: } else {
774: printf("0,%d,%s\n", ptype, exname(pname));
775: }
776: old_poffs(p);
777: return;
778:
779: case REGISTER:
780: old_pstab(pname, N_RSYM);
781: printf("0,%d,%d\n", ptype, poffset);
782: old_poffs(p);
783: return;
784:
785: case MOS:
786: case MOU:
787: old_pstab(pname, N_SSYM);
788: printf("0,%d,%d\n", ptype, poffset/SZCHAR);
789: old_poffs(p);
790: return;
791:
792: case PARAM:
793: /* parameter stab entries are processed in dclargs() */
794: return;
795:
796: default:
797: #ifndef FLEXNAMES
798: if (ddebug) printf(" No .stab for %.8s\n", pname);
799: #else
800: if (ddebug) printf(" No .stab for %s\n", pname);
801: #endif
802:
803: }
804: }
805:
806: private old_pstab(name, type)
807: char *name;
808: int type; {
809: register int i;
810: register char c;
811: if (!gdebug) return;
812: /* locctr(PROG); /* .stabs must appear in .text for c2 */
813: #ifdef ASSTRINGS
814: if ( name[0] == '\0')
815: printf("\t.stabn\t");
816: else
817: #ifndef FLEXNAMES
818: printf("\t.stabs\t\"%.8s\", ", name);
819: #else
820: printf("\t.stabs\t\"%s\", ", name);
821: #endif
822: #else
823: printf(" .stab ");
824: for(i=0; i<8; i++)
825: if (c = name[i]) printf("'%c,", c);
826: else printf("0,");
827: #endif
828: printf("0%o,", type);
829: }
830:
831: #ifdef STABDOT
832: private old_pstabdot(type, value)
833: int type;
834: int value;
835: {
836: if ( ! gdebug) return;
837: /* locctr(PROG); /* .stabs must appear in .text for c2 */
838: printf("\t.stabd\t");
839: printf("0%o,0,0%o\n",type, value);
840: }
841: #endif
842:
843: private old_poffs(p)
844: register struct symtab *p; {
845: int s;
846: if (!gdebug) return;
847: if ((s = dimtab[p->sizoff]/SZCHAR) > 1) {
848: old_pstab(p->sname, N_LENG);
849: printf("1,0,%d\n", s);
850: }
851: }
852:
853: private old_psline() {
854: static int lastlineno;
855: register char *cp, *cq;
856: register int i;
857:
858: if (!gdebug) return;
859:
860: cq = ititle;
861: cp = ftitle;
862:
863: while ( *cq ) if ( *cp++ != *cq++ ) goto neq;
864: if ( *cp == '\0' ) goto eq;
865:
866: neq: for (i=0; i<100; i++)
867: ititle[i] = '\0';
868: cp = ftitle;
869: cq = ititle;
870: while ( *cp )
871: *cq++ = *cp++;
872: *cq = '\0';
873: *--cq = '\0';
874: #ifndef FLEXNAMES
875: for ( cp = ititle+1; *(cp-1); cp += 8 ) {
876: old_pstab(cp, N_SOL);
877: if (gdebug) printf("0,0,LL%d\n", labelno);
878: }
879: #else
880: old_pstab(ititle+1, N_SOL);
881: if (gdebug) printf("0,0,LL%d\n", labelno);
882: #endif
883: *cq = '"';
884: printf("LL%d:\n", labelno++);
885:
886: eq: if (lineno == lastlineno) return;
887: lastlineno = lineno;
888:
889: if (fdefflag) {
890: #ifdef STABDOT
891: old_pstabdot(N_SLINE, lineno);
892: #else
893: old_pstab(NULLNAME, N_SLINE);
894: printf("0,%d,LL%d\n", lineno, labelno);
895: printf("LL%d:\n", labelno++);
896: #endif
897: }
898: }
899:
900: private old_plcstab(level) {
901: if (!gdebug) return;
902: #ifdef STABDOT
903: old_pstabdot(N_LBRAC, level);
904: #else
905: old_pstab(NULLNAME, N_LBRAC);
906: printf("0,%d,LL%d\n", level, labelno);
907: printf("LL%d:\n", labelno++);
908: #endif
909: }
910:
911: private old_prcstab(level) {
912: if (!gdebug) return;
913: #ifdef STABDOT
914: pstabdot(N_RBRAC, level);
915: #else
916: pstab(NULLNAME, N_RBRAC);
917: printf("0,%d,LL%d\n", level, labelno);
918: printf("LL%d:\n", labelno++);
919: #endif
920: }
921:
922: private old_pfstab(sname)
923: char *sname; {
924: if (!gdebug) return;
925: pstab(sname, N_FUN);
926: #ifndef FLEXNAMES
927: printf("0,%d,_%.7s\n", lineno, sname);
928: #else
929: printf("0,%d,_%s\n", lineno, sname);
930: #endif
931: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.