![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to c++filt.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / cfront / demangle|
Return to c++filt.c CVS log | Up to [Research Unix] / researchv10no / cmd / cfront / demangle |
1.1 root 1: /*ident "@(#)ctrans:demangler/c++filt.c 1.1"*/
2: /*
3: * C++ Demangler Source Code
4: * @(#)master 1.5
5: * 7/27/88 13:54:37
6: */
7: #include <stdio.h>
8: #include <ctype.h>
9: #include <assert.h>
10: extern char *demangle();
11: extern char *malloc(),*realloc();
12: #define TAB 8
13: #define START 10
14:
15: int mflag = 0, sflag = 0;
16:
17: char *
18: dem(c)
19: char *c;
20: {
21: char *d,*s = c;
22: #if vax || sun
23: if(*c == '_') c++;
24: #endif
25: d = demangle(c);
26: if(d == c)
27: return s;
28: else
29: return d;
30: }
31:
32: void
33: space(n)
34: int n;
35: {
36: while(n--) putchar(' ');
37: }
38:
39: void
40: subprint(c,i,l)
41: char *c;
42: int i,l;
43: {
44: int n;
45: for(n=i;n<l;n++)
46: putchar(c[n]);
47: }
48:
49: struct dlist { char *mname,*dname; } *ds;
50: int di = 2;
51: int dn = START;
52:
53: int
54: doline(c)
55: char *c;
56: {
57: int state = 0,q = 0,last=0;
58: register int i;
59:
60: for(i=0;c[i];i++) {
61:
62: /* if state is zero, we have not yet located
63: * a c identifier. If it is non-zero, we have.
64: */
65: if(state == 0) {
66: if(isalnum(c[i]) || c[i] == '_')
67: state++;
68: }
69: if(state == 1) {
70: char *x,*d;
71: int ln,n = i;
72:
73: /* find end of c identifier */
74: while(c[n] && (isalnum(c[n]) || c[n] == '_'))n++;
75: q = n;
76:
77: /* find end of spaces following identifier */
78: while(c[q] && c[q] == ' ') q++;
79:
80: /* extract the c identifier from the line */
81: x = malloc(n-i+1);
82: strncpy(x,c+i,n-i);
83: x[n-i] = 0;
84:
85: /* print out the line from the end of the
86: * last identifier+following spaces to the beginning of
87: * this identifier.
88: */
89: subprint(c,last,i);
90:
91: /* demangle the identifier */
92: d = dem(x);
93: if(d != x) {
94: int flag=0,ix;
95:
96: /* print out the demangled name.
97: * assure that it is followed by at least
98: * one space. More if there is room.
99: */
100: printf("%s",d);
101: ln = strlen(d);
102:
103: /* Print out mangled name if sflag is set.
104: * otherwise, just remember it.
105: */
106: if(sflag) {
107: int tab = 3*TAB - ln%(3*TAB);
108: space(tab);
109: ln += tab;
110: printf("%s",x);
111: ln += strlen(x);
112: ln++;
113: }
114:
115: if(q - i <= ln)
116: putchar(' ');
117: else
118: space(q - i - ln);
119:
120: if(mflag) {
121:
122: /* check to see if mangled name
123: * is already in the dlist (list of
124: * mangled-demangled names).
125: */
126: for(ix=0;ix<di;ix++) {
127: if(strcmp(x,ds[ix].mname)==0) {
128: flag++;
129: break;
130: }
131: }
132:
133: if(flag == 0) {
134:
135: /* assure that the list is
136: * big enough to accomodate the
137: * new names.
138: */
139: if(di >= dn) {
140: dn *= 2;
141: ds = (struct dlist *)realloc(ds,
142: sizeof(struct dlist)*(dn+1));
143: assert(ds != 0);
144: }
145:
146: /* enter the new names in the list. */
147: ds[di].mname = x;
148: ds[di].dname = malloc(ln+1);
149: strcpy(ds[di].dname,d);
150: di++;
151: } else free(x);
152: /* x is freed only if it is not
153: * put in the list.
154: */
155: }
156:
157: } else {
158: subprint(c,i,q);
159: free(x);
160: }
161:
162: /* move counter to the end
163: * of this (identifier + following spaces)
164: * and continue
165: */
166: last = i = q;
167:
168: /* counter the ++ of the for loop */
169: i--;
170: state = 0;
171: }
172: }
173:
174: /* print remainder of line */
175: printf("%s\n",c+q);
176: }
177:
178: main(argc,argv)
179: int argc;
180: char **argv;
181: {
182: int c;
183: char *s;
184: int i = 0;
185: int n = START;
186: int copt;
187: s = malloc(n+1);
188: *s = 0;
189:
190: /* The only argument to this command is
191: * -n. If it is given, the the C++ symbol
192: * map is not generated. Instead, the symbols
193: * are printed side by side on stdout.
194: */
195: while((copt = getopt(argc,argv,"smv")) != EOF) {
196: switch (copt) {
197: case 'm':
198: mflag = 1;
199: break;
200: case 's':
201: sflag = 1;
202: break;
203: case 'v':
204: fprintf(stderr,"Demangler Version 1.5, Date 7/27/88\n");
205: break;
206: default:
207: fprintf(stderr, "usage: %s [ -smv ]\n", argv[0]);
208: exit(1);
209: }
210: }
211: /* Initialize C++ symbol map. The column headings
212: * are entries in the table -- this assures that they
213: * will be alligned correctly.
214: */
215: if(mflag) {
216: ds = (struct dlist *)malloc(sizeof(struct dlist)*(dn+1));
217: ds[0].mname = "mangled:";
218: ds[0].dname = "demangled:";
219: ds[1].mname = ds[1].dname = "";
220: }
221:
222: while((c = getchar()) != EOF) {
223:
224: /* read one line at a time */
225: if(c != '\n') {
226:
227: /* expand tabs to spaces */
228: if(c == '\t') {
229: int nb = TAB - i%TAB;
230: c = ' ';
231: while(--nb) {
232: if(i >= n) {
233: n *= 2;
234: s = realloc(s,n+1);
235: assert(s != 0);
236: }
237: s[i++] = c;
238: s[i] = 0;
239: }
240: }
241:
242: /* append a character to the buffer */
243: /* make sure the buffer is big enough */
244: if(i >= n) {
245: n *= 2;
246: s = realloc(s,n+1);
247: assert(s != 0);
248: }
249: s[i++] = c;
250: s[i] = 0;
251:
252: } else {
253: doline(s);
254: s[i = 0] = 0;
255: }
256: }
257:
258: if(sflag || di <= 2)
259: return 0;
260:
261: printf("\nC++ symbol mapping\n");
262: {
263: int width = 0;
264: register int ix;
265:
266: /* determine size of columns */
267: for(ix=0;ix<di;ix++) {
268: int ln = strlen(ds[ix].dname);
269: if(ln > width) width = ln;
270: }
271:
272: width++;
273: for(ix=0;ix<di;ix++) {
274: printf("%s",ds[ix].dname);
275: space(width-strlen(ds[ix].dname));
276: printf("%s\n",ds[ix].mname);
277: }
278: }
279: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.