Subversion Repositories planix.SVN

Rev

Rev 2 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
2 - 1 
#include "l.h"
2 
 
3 
void
4 
listinit(void)
5 
{
6 
 
7 
	fmtinstall('A', Aconv);
8 
	fmtinstall('D', Dconv);
9 
	fmtinstall('P', Pconv);
10 
	fmtinstall('S', Sconv);
11 
	fmtinstall('N', Nconv);
12 
	fmtinstall('R', Rconv);
13 
}
14 
 
15 
void
16 
prasm(Prog *p)
17 
{
18 
	print("%P\n", p);
19 
}
20 
 
21 
int
22 
Pconv(Fmt *fp)
23 
{
24 
	char str[STRINGSZ], *s;
25 
	Prog *p;
26 
	int a;
27 
 
28 
	p = va_arg(fp->args, Prog*);
29 
	curp = p;
30 
	a = p->as;
31 
	if(a == ADATA || a == AINIT || a == ADYNT)
32 
		sprint(str, "(%d)	%A	%D/%d,%D", p->line, a, &p->from, p->reg, &p->to);
33 
	else {
34 
		s = str;
35 
		if(p->mark & NOSCHED)
36 
			s += sprint(s, "*");
37 
		if(p->reg == NREG && p->from3.type == D_NONE)
38 
			sprint(s, "(%d)	%A	%D,%D", p->line, a, &p->from, &p->to);
39 
		else
40 
		if(a != ATEXT && p->from.type == D_OREG) {
41 
			sprint(s, "(%d)	%A	%ld(R%d+R%d),%D", p->line, a,
42 
				p->from.offset, p->from.reg, p->reg, &p->to);
43 
		} else
44 
		if(p->to.type == D_OREG) {
45 
			sprint(s, "(%d)	%A	%D,%ld(R%d+R%d)", p->line, a,
46 
					&p->from, p->to.offset, p->to.reg, p->reg);
47 
		} else {
48 
			s += sprint(s, "(%d)	%A	%D", p->line, a, &p->from);
49 
			if(p->reg != NREG)
50 
				s += sprint(s, ",%c%d", p->from.type==D_FREG?'F':'R', p->reg);
51 
			if(p->from3.type != D_NONE)
52 
				s += sprint(s, ",%D", &p->from3);
53 
			sprint(s, ",%D", &p->to);
54 
		}
55 
	}
56 
	return fmtstrcpy(fp, str);
57 
}
58 
 
59 
int
60 
Aconv(Fmt *fp)
61 
{
62 
	char *s;
63 
	int a;
64 
 
65 
	a = va_arg(fp->args, int);
66 
	s = "???";
67 
	if(a >= AXXX && a < ALAST)
68 
		s = anames[a];
69 
	return fmtstrcpy(fp, s);
70 
}
71 
 
72 
int
73 
Dconv(Fmt *fp)
74 
{
75 
	char str[STRINGSZ];
76 
	Adr *a;
77 
	long v;
78 
 
79 
	a = va_arg(fp->args, Adr*);
80 
	switch(a->type) {
81 
 
82 
	default:
83 
		sprint(str, "GOK-type(%d)", a->type);
84 
		break;
85 
 
86 
	case D_NONE:
87 
		str[0] = 0;
88 
		if(a->name != D_NONE || a->reg != NREG || a->sym != S)
89 
			sprint(str, "%N(R%d)(NONE)", a, a->reg);
90 
		break;
91 
 
92 
	case D_CONST:
93 
		if(a->reg != NREG)
94 
			sprint(str, "$%N(R%d)", a, a->reg);
95 
		else
96 
			sprint(str, "$%N", a);
97 
		break;
98 
 
99 
	case D_OREG:
100 
		if(a->reg != NREG)
101 
			sprint(str, "%N(R%d)", a, a->reg);
102 
		else
103 
			sprint(str, "%N", a);
104 
		break;
105 
 
106 
	case D_REG:
107 
		sprint(str, "R%d", a->reg);
108 
		if(a->name != D_NONE || a->sym != S)
109 
			sprint(str, "%N(R%d)(REG)", a, a->reg);
110 
		break;
111 
 
112 
	case D_FREG:
113 
		sprint(str, "F%d", a->reg);
114 
		if(a->name != D_NONE || a->sym != S)
115 
			sprint(str, "%N(F%d)(REG)", a, a->reg);
116 
		break;
117 
 
118 
	case D_CREG:
119 
		if(a->reg == NREG)
120 
			strcpy(str, "CR");
121 
		else
122 
			sprint(str, "CR%d", a->reg);
123 
		if(a->name != D_NONE || a->sym != S)
124 
			sprint(str, "%N(C%d)(REG)", a, a->reg);
125 
		break;
126 
 
127 
	case D_SPR:
128 
		if(a->name == D_NONE && a->sym == S) {
129 
			switch(a->offset) {
130 
			case D_XER: sprint(str, "XER"); break;
131 
			case D_LR: sprint(str, "LR"); break;
132 
			case D_CTR: sprint(str, "CTR"); break;
133 
			default: sprint(str, "SPR(%ld)", a->offset); break;
134 
			}
135 
			break;
136 
		}
137 
		sprint(str, "SPR-GOK(%d)", a->reg);
138 
		if(a->name != D_NONE || a->sym != S)
139 
			sprint(str, "%N(SPR-GOK%d)(REG)", a, a->reg);
140 
		break;
141 
 
142 
	case D_DCR:
143 
		if(a->name == D_NONE && a->sym == S) {
144 
			if(a->reg == NREG)
145 
				sprint(str, "DCR(%ld)", a->offset);
146 
			else
147 
				sprint(str, "DCR(R%d)", a->reg);
148 
			break;
149 
		}
150 
		sprint(str, "DCR-GOK(%d)", a->reg);
151 
		if(a->name != D_NONE || a->sym != S)
152 
			sprint(str, "%N(DCR-GOK%d)(REG)", a, a->reg);
153 
		break;
154 
 
155 
	case D_OPT:
156 
		sprint(str, "OPT(%d)", a->reg);
157 
		break;
158 
 
159 
	case D_FPSCR:
160 
		if(a->reg == NREG)
161 
			strcpy(str, "FPSCR");
162 
		else
163 
			sprint(str, "FPSCR(%d)", a->reg);
164 
		break;
165 
 
166 
	case D_MSR:
167 
		sprint(str, "MSR");
168 
		break;
169 
 
170 
	case D_SREG:
171 
		sprint(str, "SREG(%d)", a->reg);
172 
		if(a->name != D_NONE || a->sym != S)
173 
			sprint(str, "%N(SREG%d)(REG)", a, a->reg);
174 
		break;
175 
 
176 
	case D_BRANCH:
177 
		if(curp->cond != P) {
178 
			v = curp->cond->pc;
179 
			if(v >= INITTEXT)
180 
				v -= INITTEXT-HEADR;
181 
			if(a->sym != S)
182 
				sprint(str, "%s+%.5lux(BRANCH)", a->sym->name, v);
183 
			else
184 
				sprint(str, "%.5lux(BRANCH)", v);
185 
		} else
186 
			if(a->sym != S)
187 
				sprint(str, "%s+%ld(APC)", a->sym->name, a->offset);
188 
			else
189 
				sprint(str, "%ld(APC)", a->offset);
190 
		break;
191 
 
192 
	case D_FCONST:
193 
		sprint(str, "$%lux-%lux", a->ieee.h, a->ieee.l);
194 
		break;
195 
 
196 
	case D_SCONST:
197 
		sprint(str, "$\"%S\"", a->sval);
198 
		break;
199 
	}
200 
	return fmtstrcpy(fp, str);
201 
}
202 
 
203 
int
204 
Nconv(Fmt *fp)
205 
{
206 
	char str[STRINGSZ];
207 
	Adr *a;
208 
	Sym *s;
209 
 
210 
	a = va_arg(fp->args, Adr*);
211 
	s = a->sym;
212 
	if(s == S) {
213 
		sprint(str, "%ld", a->offset);
214 
		goto out;
215 
	}
216 
	switch(a->name) {
217 
	default:
218 
		sprint(str, "GOK-name(%d)", a->name);
219 
		break;
220 
 
221 
	case D_EXTERN:
222 
		sprint(str, "%s+%ld(SB)", s->name, a->offset);
223 
		break;
224 
 
225 
	case D_STATIC:
226 
		sprint(str, "%s<>+%ld(SB)", s->name, a->offset);
227 
		break;
228 
 
229 
	case D_AUTO:
230 
		sprint(str, "%s-%ld(SP)", s->name, -a->offset);
231 
		break;
232 
 
233 
	case D_PARAM:
234 
		sprint(str, "%s+%ld(FP)", s->name, a->offset);
235 
		break;
236 
	}
237 
out:
238 
	return fmtstrcpy(fp, str);
239 
}
240 
 
241 
int
242 
Rconv(Fmt *fp)
243 
{
244 
	char *s;
245 
	int a;
246 
 
247 
	a = va_arg(fp->args, int);
248 
	s = "C_??";
249 
	if(a >= C_NONE && a <= C_NCLASS)
250 
		s = cnames[a];
251 
	return fmtstrcpy(fp, s);
252 
}
253 
 
254 
int
255 
Sconv(Fmt *fp)
256 
{
257 
	int i, c;
258 
	char str[STRINGSZ], *p, *a;
259 
 
260 
	a = va_arg(fp->args, char*);
261 
	p = str;
262 
	for(i=0; i<sizeof(long); i++) {
263 
		c = a[i] & 0xff;
264 
		if(c >= 'a' && c <= 'z' ||
265 
		   c >= 'A' && c <= 'Z' ||
266 
		   c >= '0' && c <= '9' ||
267 
		   c == ' ' || c == '%') {
268 
			*p++ = c;
269 
			continue;
270 
		}
271 
		*p++ = '\\';
272 
		switch(c) {
273 
		case 0:
274 
			*p++ = 'z';
275 
			continue;
276 
		case '\\':
277 
		case '"':
278 
			*p++ = c;
279 
			continue;
280 
		case '\n':
281 
			*p++ = 'n';
282 
			continue;
283 
		case '\t':
284 
			*p++ = 't';
285 
			continue;
286 
		}
287 
		*p++ = (c>>6) + '0';
288 
		*p++ = ((c>>3) & 7) + '0';
289 
		*p++ = (c & 7) + '0';
290 
	}
291 
	*p = 0;
292 
	return fmtstrcpy(fp, str);
293 
}
294 
 
295 
void
296 
diag(char *fmt, ...)
297 
{
298 
	char buf[STRINGSZ], *tn;
299 
	va_list arg;
300 
 
301 
	tn = "??none??";
302 
	if(curtext != P && curtext->from.sym != S)
303 
		tn = curtext->from.sym->name;
304 
	va_start(arg, fmt);
305 
	vseprint(buf, buf+sizeof(buf), fmt, arg);
306 
	va_end(arg);
307 
	print("%s: %s\n", tn, buf);
308 
 
309 
	nerrors++;
310 
	if(nerrors > 10) {
311 
		print("too many errors\n");
312 
		errorexit();
313 
	}
314 
}