xref: /plan9/sys/src/cmd/vi/cmd.c (revision ec59a3ddbfceee0efe34584c2c9981a5e5ff1ec4) 
1 #include <u.h>
2 #include <libc.h>
3 #include <bio.h>
4 #include <mach.h>
5 #include <ctype.h>
6 #define Extern extern
7 #include "mips.h"
8 
9 char	buf[128], lastcmd[128];
10 char	fmt = 'X';
11 int	width = 60;
12 int	inc;
13 
14 ulong	expr(char*);
15 ulong	expr1(char*);
16 char*	term(char*, ulong*);
17 
18 char *
19 nextc(char *p)
20 {
21 	while(*p && (*p == ' ' || *p == '\t') && *p != '\n')
22 		p++;
23 
24 	if(*p == '\n')
25 		*p = '\0';
26 
27 	return p;
28 }
29 
30 char *
31 numsym(char *addr, ulong *val)
32 {
33 	char tsym[128], *t;
34 	static char *delim = "`'<>/\\@*|-~+-/=?\n";
35 	Symbol s;
36 	char c;
37 
38 	t = tsym;
39 	while(c = *addr) {
40 		if(strchr(delim, c))
41 			break;
42 		*t++ = c;
43 		addr++;
44 	}
45 	t[0] = '\0';
46 
47 	if(strcmp(tsym, ".") == 0) {
48 		*val = dot;
49 		return addr;
50 	}
51 
52 	if(lookup(0, tsym, &s))
53 		*val = s.value;
54 	else {
55 		if(tsym[0] == '#')
56 			*val = strtoul(tsym+1, 0, 16);
57 		else
58 			*val = strtoul(tsym, 0, 0);
59 	}
60 	return addr;
61 }
62 
63 ulong
64 expr(char *addr)
65 {
66 	ulong t, t2;
67 	char op;
68 
69 	if(*addr == '\0')
70 		return dot;
71 
72 	addr = numsym(addr, &t);
73 
74 	if(*addr == '\0')
75 		return t;
76 
77 	addr = nextc(addr);
78 	op = *addr++;
79 	numsym(addr, &t2);
80 	switch(op) {
81 	default:
82 		Bprint(bioout, "expr syntax\n");
83 		return 0;
84 	case '+':
85 		t += t2;
86 		break;
87 	case '-':
88 		t -= t2;
89 		break;
90 	case '%':
91 		t /= t2;
92 		break;
93 	case '&':
94 		t &= t2;
95 		break;
96 	case '|':
97 		t |= t2;
98 		break;
99 	}
100 
101 	return t;
102 }
103 
104 int
105 buildargv(char *str, char **args, int max)
106 {
107 	int na = 0;
108 
109 	while (na < max) {
110 		while((*str == ' ' || *str == '\t' || *str == '\n') && *str != '\0')
111 			str++;
112 
113 		if(*str == '\0')
114 			return na;
115 
116 		args[na++] = str;
117 		while(!(*str == ' ' || *str == '\t'|| *str == '\n') && *str != '\0')
118 			str++;
119 
120 		if(*str == '\n')
121 			*str = '\0';
122 
123 		if(*str == '\0')
124 			break;
125 
126 		*str++ = '\0';
127 	}
128 	return na;
129 }
130 
131 void
132 colon(char *addr, char *cp)
133 {
134 	int argc;
135 	char *argv[100];
136 	char tbuf[512];
137 
138 	cp = nextc(cp);
139 	switch(*cp) {
140 	default:
141 		Bprint(bioout, "?\n");
142 		return;
143 	case 'b':
144 		breakpoint(addr, cp+1);
145 		return;
146 
147 	case 'd':
148 		delbpt(addr);
149 		return;
150 
151 	/* These fall through to print the stopped address */
152 	case 'r':
153 		reset();
154 		argc = buildargv(cp+1, argv, 100);
155 		initstk(argc, argv);
156 		count = 0;
157 		atbpt = 0;
158 		run();
159 		break;
160 	case 'c':
161 		count = 0;
162 		atbpt = 0;
163 		run();
164 		break;
165 	case 's':
166 		cp = nextc(cp+1);
167 		count = 0;
168 		if(*cp)
169 			count = strtoul(cp, 0, 0);
170 		if(count == 0)
171 			count = 1;
172 		atbpt = 0;
173 		run();
174 		break;
175 	}
176 
177 	dot = reg.pc;
178 	Bprint(bioout, "%s at #%lux ", atbpt ? "breakpoint" : "stopped", dot);
179 	symoff(tbuf, sizeof(tbuf), dot, CTEXT);
180 	Bprint(bioout, tbuf);
181 	if(fmt == 'z')
182 		printsource(dot);
183 
184 	Bprint(bioout, "\n");
185 }
186 
187 
188 void
189 dollar(char *cp)
190 {
191 	int nr;
192 
193 	cp = nextc(cp);
194 	switch(*cp) {
195 	default:
196 		Bprint(bioout, "?\n");
197 		break;
198 
199 	case 'c':
200 		stktrace(*cp);
201 		break;
202 
203 	case 'C':
204 		stktrace(*cp);
205 		break;
206 
207 	case 'b':
208 		dobplist();
209 		break;
210 
211 	case 'r':
212 		dumpreg();
213 		break;
214 
215 	case 'R':
216 		dumpreg();
217 
218 	case 'f':
219 		dumpfreg();
220 		break;
221 
222 	case 'F':
223 		dumpdreg();
224 		break;
225 
226 	case 'q':
227 		exits(0);
228 		break;
229 
230 	case 'Q':
231 		isum();
232 		tlbsum();
233 		segsum();
234 		break;
235 
236 	case 't':
237 		cp++;
238 		switch(*cp) {
239 		default:
240 			Bprint(bioout, "$t[0sicr#]\n");
241 			break;
242 		case '\0':
243 			trace = 1;
244 			break;
245 		case '0':
246 			trace = 0;
247 			sysdbg = 0;
248 			calltree = 0;
249 			break;
250 		case 's':
251 			sysdbg = 1;
252 			break;
253 		case 'i':
254 			trace = 1;
255 			break;
256 		case 'c':
257 			calltree = 1;
258 			break;
259 		case 'r':
260 			nr = atoi(cp+1);
261 			if(nr < 0 || nr > 31) {
262 				print("bad register\n");
263 				break;
264 			}
265 			rtrace ^= (1<<nr);
266 			print("%.8ux\n", rtrace);
267 			break;
268 		}
269 		break;
270 
271 	case 'i':
272 		cp++;
273 		switch(*cp) {
274 		default:
275 			Bprint(bioout, "$i[itsa]\n");
276 			break;
277 		case 'i':
278 			isum();
279 			break;
280 		case 't':
281 			tlbsum();
282 			break;
283 		case 's':
284 			segsum();
285 			break;
286 		case 'a':
287 			isum();
288 			tlbsum();
289 			segsum();
290 			iprofile();
291 			break;
292 		case 'p':
293 			iprofile();
294 			break;
295 		}
296 	}
297 }
298 
299 int
300 pfmt(char fmt, int mem, ulong val)
301 {
302 	int c, i;
303 	Symbol s;
304 	char *p, ch, str[1024];
305 
306 	c = 0;
307 	switch(fmt) {
308 	default:
309 		Bprint(bioout, "bad modifier\n");
310 		return 0;
311 	case 'o':
312 		c = Bprint(bioout, "%-4lo ", mem ? (ushort)getmem_2(dot) : val);
313 		inc = 2;
314 		break;
315 
316 	case 'O':
317 		c = Bprint(bioout, "%-8lo ", mem ? getmem_4(dot) : val);
318 		inc = 4;
319 		break;
320 
321 	case 'q':
322 		c = Bprint(bioout, "%-4lo ", mem ? (short)getmem_2(dot) : val);
323 		inc = 2;
324 		break;
325 
326 	case 'Q':
327 		c = Bprint(bioout, "%-8lo ", mem ? (long)getmem_4(dot) : val);
328 		inc = 4;
329 		break;
330 
331 	case 'd':
332 		c = Bprint(bioout, "%-5ld ", mem ? (short)getmem_2(dot) : val);
333 		inc = 2;
334 		break;
335 
336 
337 	case 'D':
338 		c = Bprint(bioout, "%-8ld ", mem ? (long)getmem_4(dot) : val);
339 		inc = 4;
340 		break;
341 
342 	case 'x':
343 		c = Bprint(bioout, "#%-4lux ", mem ? (long)getmem_2(dot) : val);
344 		inc = 2;
345 		break;
346 
347 	case 'X':
348 		c = Bprint(bioout, "#%-8lux ", mem ? (long)getmem_4(dot) : val);
349 		inc = 4;
350 		break;
351 
352 	case 'u':
353 		c = Bprint(bioout, "%-5ld ", mem ? (ushort)getmem_2(dot) : val);
354 		inc = 2;
355 		break;
356 
357 	case 'U':
358 		c = Bprint(bioout, "%-8ld ", mem ? (ulong)getmem_4(dot) : val);
359 		inc = 4;
360 		break;
361 
362 	case 'b':
363 		c = Bprint(bioout, "%-3ld ", mem ? getmem_b(dot) : val);
364 		inc = 1;
365 		break;
366 
367 	case 'c':
368 		c = Bprint(bioout, "%c ", (int)(mem ? getmem_b(dot) : val));
369 		inc = 1;
370 		break;
371 
372 	case 'C':
373 		ch = mem ? getmem_b(dot) : val;
374 		if(isprint(ch))
375 			c = Bprint(bioout, "%c ", ch);
376 		else
377 			c = Bprint(bioout, "\\x%.2x ", ch);
378 		inc = 1;
379 		break;
380 
381 	case 's':
382 		i = 0;
383 		while(ch = getmem_b(dot+i))
384 			str[i++] = ch;
385 		str[i] = '\0';
386 		dot += i;
387 		c = Bprint(bioout, "%s", str);
388 		inc = 0;
389 		break;
390 
391 	case 'S':
392 		i = 0;
393 		while(ch = getmem_b(dot+i))
394 			str[i++] = ch;
395 		str[i] = '\0';
396 		dot += i;
397 		for(p = str; *p; p++)
398 			if(isprint(*p))
399 				c += Bprint(bioout, "%c", *p);
400 			else
401 				c += Bprint(bioout, "\\x%.2ux", *p);
402 		inc = 0;
403 		break;
404 
405 	case 'Y':
406 		p = ctime(mem ? getmem_b(dot) : val);
407 		p[30] = '\0';
408 		c = Bprint(bioout, "%s", p);
409 		inc = 4;
410 		break;
411 
412 	case 'a':
413 		symoff(str, sizeof(str), dot, CTEXT);
414 		c = Bprint(bioout, str);
415 		inc = 0;
416 		break;
417 
418 	case 'e':
419 		for (i = 0; globalsym(&s, i); i++)
420 			Bprint(bioout, "%-15s #%lux\n", s.name,	getmem_4(s.value));
421 		inc = 0;
422 		break;
423 
424 	case 'i':
425 		inc = _mipscoinst(symmap, dot, str, sizeof(str));
426 		if (inc < 0) {
427 			Bprint(bioout, "vi: %r\n");
428 			return 0;
429 		}
430 		c = Bprint(bioout, str);
431 		break;
432 
433 	case 'n':
434 		c = width+1;
435 		inc = 0;
436 		break;
437 
438 	case '-':
439 		c = 0;
440 		inc = -1;
441 		break;
442 
443 	case '+':
444 		c = 0;
445 		inc = 1;
446 		break;
447 
448 	case '^':
449 		c = 0;
450 		if(inc > 0)
451 			inc = -inc;
452 		break;
453 
454 	case 'z':
455 		if (findsym(dot, CTEXT, &s))
456 			Bprint(bioout, "  %s() ", s.name);
457 		printsource(dot);
458 		inc = 0;
459 		break;
460 	}
461 	return c;
462 }
463 
464 void
465 eval(char *addr, char *p)
466 {
467 	ulong val;
468 
469 	val = expr(addr);
470 	p = nextc(p);
471 	if(*p == '\0') {
472 		p[0] = fmt;
473 		p[1] = '\0';
474 	}
475 	pfmt(*p, 0, val);
476 	Bprint(bioout, "\n");
477 }
478 
479 void
480 quesie(char *p)
481 {
482 	int c, count, i;
483 	char tbuf[512];
484 
485 	c = 0;
486 	symoff(tbuf, sizeof(tbuf), dot, CTEXT);
487 	Bprint(bioout, "%s?\t", tbuf);
488 
489 	while(*p) {
490 		p = nextc(p);
491 		if(*p == '"') {
492 			for(p++; *p && *p != '"'; p++) {
493 				Bputc(bioout, *p);
494 				c++;
495 			}
496 			if(*p)
497 				p++;
498 			continue;
499 		}
500 		count = 0;
501 		while(*p >= '0' && *p <= '9')
502 			count = count*10 + (*p++ - '0');
503 		if(count == 0)
504 			count = 1;
505 		p = nextc(p);
506 		if(*p == '\0') {
507 			p[0] = fmt;
508 			p[1] = '\0';
509 		}
510 		for(i = 0; i < count; i++) {
511 			c += pfmt(*p, 1, 0);
512 			dot += inc;
513 			if(c > width) {
514 				Bprint(bioout, "\n");
515 				symoff(tbuf, sizeof(tbuf), dot, CTEXT);
516 				Bprint(bioout, "%s?\t", tbuf);
517 				c = 0;
518 			}
519 		}
520 		fmt = *p++;
521 		p = nextc(p);
522 	}
523 	Bprint(bioout, "\n");
524 }
525 
526 void
527 catcher(void *a, char *msg)
528 {
529 	USED(a);
530 	if(strcmp(msg, "interrupt") != 0)
531 		noted(NDFLT);
532 
533 	count = 1;
534 	print("vi\n");
535 	noted(NCONT);
536 }
537 
538 void
539 setreg(char *addr, char *cp)
540 {
541 	int rn;
542 
543 	dot = expr(addr);
544 	cp = nextc(cp);
545 	if(strcmp(cp, "pc") == 0) {
546 		reg.pc = dot;
547 		return;
548 	}
549 	if(strcmp(cp, "sp") == 0) {
550 		reg.r[29] = dot;
551 		return;
552 	}
553 	if(strcmp(cp, "mh") == 0) {
554 		reg.mhi = dot;
555 		return;
556 	}
557 	if(strcmp(cp, "ml") == 0) {
558 		reg.mlo = dot;
559 		return;
560 	}
561 	if(*cp++ == 'r') {
562 		rn = strtoul(cp, 0, 10);
563 		if(rn > 0 && rn < 32) {
564 			reg.r[rn] = dot;
565 			return;
566 		}
567 	}
568 	Bprint(bioout, "bad register\n");
569 }
570 
571 void
572 cmd(void)
573 {
574 	char *p, *a, *cp, *gotint;
575 	char addr[128];
576 	static char *cmdlet = ":$?/=>";
577 	int n, i;
578 
579 	notify(catcher);
580 
581 	dot = reg.pc;
582 	setjmp(errjmp);
583 
584 	for(;;) {
585 		Bflush(bioout);
586 		p = buf;
587 		n = 0;
588 		for(;;) {
589 			i = Bgetc(bin);
590 			if(i < 0)
591 				exits(0);
592 			*p++ = i;
593 			n++;
594 			if(i == '\n')
595 				break;
596 		}
597 
598 		if(buf[0] == '\n')
599 			strcpy(buf, lastcmd);
600 		else {
601 			buf[n-1] = '\0';
602 			strcpy(lastcmd, buf);
603 		}
604 		p = buf;
605 		a = addr;
606 
607 		for(;;) {
608 			p = nextc(p);
609 			if(*p == 0 || strchr(cmdlet, *p))
610 				break;
611 			*a++ = *p++;
612 		}
613 
614 		*a = '\0';
615 		cmdcount = 1;
616 		cp = strchr(addr, ',');
617 		if(cp != 0) {
618 			if(cp[1] == '#')
619 				cmdcount = strtoul(cp+2, &gotint, 16);
620 			else
621 				cmdcount = strtoul(cp+1, &gotint, 0);
622 			*cp = '\0';
623 		}
624 
625 		switch(*p) {
626 		case '$':
627 			dollar(p+1);
628 			break;
629 		case ':':
630 			colon(addr, p+1);
631 			break;
632 		case '/':
633 		case '?':
634 			dot = expr(addr);
635 			for(i = 0; i < cmdcount; i++)
636 				quesie(p+1);
637 			break;
638 		case '=':
639 			eval(addr, p+1);
640 			break;
641 		case '>':
642 			setreg(addr, p+1);
643 			break;
644 		default:
645 			Bprint(bioout, "?\n");
646 			break;
647 		}
648 	}
649 }
650