op public repos

Blob

Date:: Fri Jan 10 14:54:30 2020 UTC
Message:: Trivial changes: whitespace and modes. Remote whitespace at the ends of lines. Remove blank lines from the ends of files. Change modes on source files so that they are not executable. Signed-off-by: Dan Cross <cross@gajendra.net>
Actions:: History | Blame | Raw File
1 #include <u.h>
2 #include <libc.h>
3 #include <bio.h>
4 #include <ctype.h>
5 #include <mach.h>
6 #include <regexp.h>
7 #define Extern extern
8 #include "acid.h"
9 #include "y.tab.h"
10 
11 void	cvtatof(Node*, Node*);
12 void	cvtatoi(Node*, Node*);
13 void	cvtitoa(Node*, Node*);
14 void	bprint(Node*, Node*);
15 void	funcbound(Node*, Node*);
16 void	printto(Node*, Node*);
17 void	getfile(Node*, Node*);
18 void	fmt(Node*, Node*);
19 void	pcfile(Node*, Node*);
20 void	pcline(Node*, Node*);
21 void	setproc(Node*, Node*);
22 void	strace(Node*, Node*);
23 void	follow(Node*, Node*);
24 void	reason(Node*, Node*);
25 void	newproc(Node*, Node*);
26 void	startstop(Node*, Node*);
27 void	match(Node*, Node*);
28 void	status(Node*, Node*);
29 void	xkill(Node*,Node*);
30 void	waitstop(Node*, Node*);
31 void waitsyscall(Node*, Node*);
32 void	stop(Node*, Node*);
33 void	start(Node*, Node*);
34 void	filepc(Node*, Node*);
35 void	doerror(Node*, Node*);
36 void	rc(Node*, Node*);
37 void	doaccess(Node*, Node*);
38 void	map(Node*, Node*);
39 void	readfile(Node*, Node*);
40 void	interpret(Node*, Node*);
41 void	include(Node*, Node*);
42 void	includepipe(Node*, Node*);
43 void	regexp(Node*, Node*);
44 void textfile(Node*, Node*);
45 void deltextfile(Node*, Node*);
46 void stringn(Node*, Node*);
47 void xregister(Node*, Node*);
48 void refconst(Node*, Node*);
49 void dolook(Node*, Node*);
50 void step1(Node*, Node*);
51 
52 typedef struct Btab Btab;
53 struct Btab
54 {
55 	char	*name;
56 	void	(*fn)(Node*, Node*);
57 } tab[] =
58 {
59 	"access",	doaccess,
60 	"atof",		cvtatof,
61 	"atoi",		cvtatoi,
62 	"deltextfile",	deltextfile,
63 	"error",	doerror,
64 	"file",		getfile,
65 	"filepc",	filepc,
66 	"fnbound",	funcbound,
67 	"fmt",		fmt,
68 	"follow",	follow,
69 	"include",	include,
70 	"includepipe",	includepipe,
71 	"interpret",	interpret,
72 	"itoa",		cvtitoa,
73 	"kill",		xkill,
74 	"map",		map,
75 	"match",	match,
76 	"newproc",	newproc,
77 	"pcfile",	pcfile,
78 	"pcline",	pcline,
79 	"print",	bprint,
80 	"printto",	printto,
81 	"rc",		rc,
82 	"readfile",	readfile,
83 	"reason",	reason,
84 	"refconst",	refconst,
85 	"regexp",	regexp,
86 	"register",	xregister,
87 	"setproc",	setproc,
88 	"start",	start,
89 	"startstop",	startstop,
90 	"status",	status,
91 	"step1",	step1,
92 	"stop",		stop,
93 	"strace",	strace,
94 	"stringn",	stringn,
95 	"textfile",	textfile,
96 	"var",	dolook,
97 	"waitstop",	waitstop,
98 	"waitsyscall",	waitsyscall,
99 	0
100 };
101 
102 void
103 mkprint(Lsym *s)
104 {
105 	prnt = malloc(sizeof(Node));
106 	memset(prnt, 0, sizeof(Node));
107 	prnt->op = OCALL;
108 	prnt->left = malloc(sizeof(Node));
109 	memset(prnt->left, 0, sizeof(Node));
110 	prnt->left->sym = s;
111 }
112 
113 void
114 installbuiltin(void)
115 {
116 	Btab *b;
117 	Lsym *s;
118 
119 	b = tab;
120 	while(b->name) {
121 		s = look(b->name);
122 		if(s == 0)
123 			s = enter(b->name, Tid);
124 
125 		s->builtin = b->fn;
126 		if(b->fn == bprint)
127 			mkprint(s);
128 		b++;
129 	}
130 }
131 
132 void
133 match(Node *r, Node *args)
134 {
135 	int i;
136 	List *f;
137 	Node *av[Maxarg];
138 	Node resi, resl;
139 
140 	na = 0;
141 	flatten(av, args);
142 	if(na != 2)
143 		error("match(obj, list): arg count");
144 
145 	expr(av[1], &resl);
146 	if(resl.type != TLIST)
147 		error("match(obj, list): need list");
148 	expr(av[0], &resi);
149 
150 	r->op = OCONST;
151 	r->type = TINT;
152 	r->store.fmt = 'D';
153 	r->store.u.ival = -1;
154 
155 	i = 0;
156 	for(f = resl.store.u.l; f; f = f->next) {
157 		if(resi.type == f->type) {
158 			switch(resi.type) {
159 			case TINT:
160 				if(resi.store.u.ival == f->store.u.ival) {
161 					r->store.u.ival = i;
162 					return;
163 				}
164 				break;
165 			case TFLOAT:
166 				if(resi.store.u.fval == f->store.u.fval) {
167 					r->store.u.ival = i;
168 					return;
169 				}
170 				break;
171 			case TSTRING:
172 				if(scmp(resi.store.u.string, f->store.u.string)) {
173 					r->store.u.ival = i;
174 					return;
175 				}
176 				break;
177 			case TLIST:
178 				error("match(obj, list): not defined for list");
179 			}
180 		}
181 		i++;
182 	}
183 }
184 
185 void
186 newproc(Node *r, Node *args)
187 {
188 	int i;
189 	Node res;
190 	char *p, *e;
191 	char *argv[Maxarg], buf[Strsize];
192 
193 	i = 1;
194 	argv[0] = symfil;
195 
196 	if(args) {
197 		expr(args, &res);
198 		if(res.type != TSTRING)
199 			error("newproc(): arg not string");
200 		if(res.store.u.string->len >= sizeof(buf))
201 			error("newproc(): too many arguments");
202 		memmove(buf, res.store.u.string->string, res.store.u.string->len);
203 		buf[res.store.u.string->len] = '\0';
204 		p = buf;
205 		e = buf+res.store.u.string->len;
206 		for(;;) {
207 			while(p < e && (*p == '\t' || *p == ' '))
208 				*p++ = '\0';
209 			if(p >= e)
210 				break;
211 			argv[i++] = p;
212 			if(i >= Maxarg)
213 				error("newproc: too many arguments");
214 			while(p < e && *p != '\t' && *p != ' ')
215 				p++;
216 		}
217 	}
218 	argv[i] = 0;
219 	r->op = OCONST;
220 	r->type = TINT;
221 	r->store.fmt = 'D';
222 	r->store.u.ival = nproc(argv);
223 }
224 
225 void
226 step1(Node *r, Node *args)
227 {
228 	Node res;
229 
230 	USED(r);
231 	if(args == 0)
232 		error("step1(pid): no pid");
233 	expr(args, &res);
234 	if(res.type != TINT)
235 		error("step1(pid): arg type");
236 
237 	msg(res.store.u.ival, "step");
238 	notes(res.store.u.ival);
239 	dostop(res.store.u.ival);
240 }
241 
242 void
243 startstop(Node *r, Node *args)
244 {
245 	Node res;
246 
247 	USED(r);
248 	if(args == 0)
249 		error("startstop(pid): no pid");
250 	expr(args, &res);
251 	if(res.type != TINT)
252 		error("startstop(pid): arg type");
253 
254 	msg(res.store.u.ival, "startstop");
255 	notes(res.store.u.ival);
256 	dostop(res.store.u.ival);
257 }
258 
259 void
260 waitstop(Node *r, Node *args)
261 {
262 	Node res;
263 
264 	USED(r);
265 	if(args == 0)
266 		error("waitstop(pid): no pid");
267 	expr(args, &res);
268 	if(res.type != TINT)
269 		error("waitstop(pid): arg type");
270 
271 	Bflush(bout);
272 	msg(res.store.u.ival, "waitstop");
273 	notes(res.store.u.ival);
274 	dostop(res.store.u.ival);
275 }
276 
277 void
278 waitsyscall(Node *r, Node *args)
279 {
280 	Node res;
281 
282 	USED(r);
283 	if(args == 0)
284 		error("waitsyscall(pid): no pid");
285 	expr(args, &res);
286 	if(res.type != TINT)
287 		error("waitsycall(pid): arg type");
288 
289 	Bflush(bout);
290 	msg(res.store.u.ival, "sysstop");
291 	notes(res.store.u.ival);
292 	dostop(res.store.u.ival);
293 }
294 
295 void
296 start(Node *r, Node *args)
297 {
298 	Node res;
299 
300 	USED(r);
301 	if(args == 0)
302 		error("start(pid): no pid");
303 	expr(args, &res);
304 	if(res.type != TINT)
305 		error("start(pid): arg type");
306 
307 	msg(res.store.u.ival, "start");
308 }
309 
310 void
311 stop(Node *r, Node *args)
312 {
313 	Node res;
314 
315 	USED(r);
316 	if(args == 0)
317 		error("stop(pid): no pid");
318 	expr(args, &res);
319 	if(res.type != TINT)
320 		error("stop(pid): arg type");
321 
322 	Bflush(bout);
323 	msg(res.store.u.ival, "stop");
324 	notes(res.store.u.ival);
325 	dostop(res.store.u.ival);
326 }
327 
328 void
329 xkill(Node *r, Node *args)
330 {
331 	Node res;
332 
333 	USED(r);
334 	if(args == 0)
335 		error("kill(pid): no pid");
336 	expr(args, &res);
337 	if(res.type != TINT)
338 		error("kill(pid): arg type");
339 
340 	msg(res.store.u.ival, "kill");
341 	deinstall(res.store.u.ival);
342 }
343 
344 void
345 xregister(Node *r, Node *args)
346 {
347 	int tid;
348 	Regdesc *rp;
349 	Node res, resid;
350 	Node *av[Maxarg];
351 
352 	na = 0;
353 	flatten(av, args);
354 	if(na != 1/* && na != 2 */)
355 		error("register(name): arg count");
356 
357 	expr(av[0], &res);
358 	if(res.type != TSTRING)
359 		error("register(name): arg type: name should be string");
360 	tid = 0;
361 	if(na == 2){
362 		expr(av[1], &resid);
363 		if(resid.type != TINT)
364 			error("register(name[, threadid]): arg type: threadid should be int");
365 		tid = resid.store.u.ival;
366 	}
367 	if((rp = regdesc(res.store.u.string->string)) == nil)
368 		error("no such register");
369 	r->op = OCONST;
370 	r->type = TREG;
371 	r->store.fmt = rp->format;
372 	r->store.u.reg.name = rp->name;
373 	r->store.u.reg.thread = tid;
374 }
375 
376 void
377 refconst(Node *r, Node *args)
378 {
379 	Node *n;
380 
381 	if(args == 0)
382 		error("refconst(expr): arg count");
383 
384 	n = an(OCONST, ZN, ZN);
385 	expr(args, n);
386 
387 	r->op = OCONST;
388 	r->type = TCON;
389 	r->store.u.con = n;
390 }
391 
392 void
393 dolook(Node *r, Node *args)
394 {
395 	Node res;
396 	Lsym *l;
397 
398 	if(args == 0)
399 		error("var(string): arg count");
400 	expr(args, &res);
401 	if(res.type != TSTRING)
402 		error("var(string): arg type");
403 
404 	r->op = OCONST;
405 	if((l = look(res.store.u.string->string)) == nil || l->v->set == 0){
406 		r->type = TLIST;
407 		r->store.u.l = nil;
408 	}else{
409 		r->type = l->v->type;
410 		r->store = l->v->store;
411 	}
412 }
413 
414 void
415 status(Node *r, Node *args)
416 {
417 	Node res;
418 	char *p;
419 
420 	USED(r);
421 	if(args == 0)
422 		error("status(pid): no pid");
423 	expr(args, &res);
424 	if(res.type != TINT)
425 		error("status(pid): arg type");
426 
427 	p = getstatus(res.store.u.ival);
428 	r->store.u.string = strnode(p);
429 	r->op = OCONST;
430 	r->store.fmt = 's';
431 	r->type = TSTRING;
432 }
433 
434 void
435 reason(Node *r, Node *args)
436 {
437 	Node res;
438 
439 	if(args == 0)
440 		error("reason(cause): no cause");
441 	expr(args, &res);
442 	if(res.type != TINT)
443 		error("reason(cause): arg type");
444 
445 	r->op = OCONST;
446 	r->type = TSTRING;
447 	r->store.fmt = 's';
448 	r->store.u.string = strnode((*mach->exc)(cormap, acidregs));
449 }
450 
451 void
452 follow(Node *r, Node *args)
453 {
454 	int n, i;
455 	Node res;
456 	u64int f[10];
457 	List **tail, *l;
458 
459 	if(args == 0)
460 		error("follow(addr): no addr");
461 	expr(args, &res);
462 	if(res.type != TINT)
463 		error("follow(addr): arg type");
464 
465 	n = (*mach->foll)(cormap, acidregs, res.store.u.ival, f);
466 	if (n < 0)
467 		error("follow(addr): %r");
468 	tail = &r->store.u.l;
469 	for(i = 0; i < n; i++) {
470 		l = al(TINT);
471 		l->store.u.ival = f[i];
472 		l->store.fmt = 'X';
473 		*tail = l;
474 		tail = &l->next;
475 	}
476 }
477 
478 void
479 funcbound(Node *r, Node *args)
480 {
481 	int n;
482 	Node res;
483 	u64int bounds[2];
484 	List *l;
485 
486 	if(args == 0)
487 		error("fnbound(addr): no addr");
488 	expr(args, &res);
489 	if(res.type != TINT)
490 		error("fnbound(addr): arg type");
491 
492 	n = fnbound(res.store.u.ival, bounds);
493 	if (n >= 0) {
494 		r->store.u.l = al(TINT);
495 		l = r->store.u.l;
496 		l->store.u.ival = bounds[0];
497 		l->store.fmt = 'X';
498 		l->next = al(TINT);
499 		l = l->next;
500 		l->store.u.ival = bounds[1];
501 		l->store.fmt = 'X';
502 	}
503 }
504 
505 void
506 setproc(Node *r, Node *args)
507 {
508 	Node res;
509 
510 	USED(r);
511 	if(args == 0)
512 		error("setproc(pid): no pid");
513 	expr(args, &res);
514 	if(res.type != TINT)
515 		error("setproc(pid): arg type");
516 
517 	sproc(res.store.u.ival);
518 }
519 
520 void
521 filepc(Node *r, Node *args)
522 {
523 	int i;
524 	Node res;
525 	char *p, c;
526 	u64int v;
527 
528 	if(args == 0)
529 		error("filepc(filename:line): arg count");
530 	expr(args, &res);
531 	if(res.type != TSTRING)
532 		error("filepc(filename:line): arg type");
533 
534 	p = strchr(res.store.u.string->string, ':');
535 	if(p == 0)
536 		error("filepc(filename:line): bad arg format");
537 
538 	c = *p;
539 	*p++ = '\0';
540 	i = file2pc(res.store.u.string->string, atoi(p), &v);
541 	p[-1] = c;
542 	if(i < 0)
543 		error("filepc(filename:line): can't find address");
544 
545 	r->op = OCONST;
546 	r->type = TINT;
547 	r->store.fmt = 'D';
548 	r->store.u.ival = v;
549 }
550 
551 void
552 interpret(Node *r, Node *args)
553 {
554 	Node res;
555 	int isave;
556 
557 	if(args == 0)
558 		error("interpret(string): arg count");
559 	expr(args, &res);
560 	if(res.type != TSTRING)
561 		error("interpret(string): arg type");
562 
563 	pushstr(&res);
564 
565 	isave = interactive;
566 	interactive = 0;
567 	r->store.u.ival = yyparse();
568 	interactive = isave;
569 	popio();
570 	r->op = OCONST;
571 	r->type = TINT;
572 	r->store.fmt = 'D';
573 }
574 
575 void
576 include(Node *r, Node *args)
577 {
578 	char *file, *libfile;
579 	static char buf[1024];
580 	Node res;
581 	int isave;
582 
583 	if(args == 0)
584 		error("include(string): arg count");
585 	expr(args, &res);
586 	if(res.type != TSTRING)
587 		error("include(string): arg type");
588 
589 	Bflush(bout);
590 
591 	libfile = nil;
592 	file = res.store.u.string->string;
593 	if(access(file, AREAD) < 0 && file[0] != '/'){
594 		snprint(buf, sizeof buf, "#9/acid/%s", file);
595 		libfile = unsharp(buf);
596 		if(access(libfile, AREAD) >= 0){
597 			strecpy(buf, buf+sizeof buf, libfile);
598 			file = buf;
599 		}
600 		free(libfile);
601 	}
602 
603 	pushfile(file);
604 	isave = interactive;
605 	interactive = 0;
606 	r->store.u.ival = yyparse();
607 	interactive = isave;
608 	popio();
609 	r->op = OCONST;
610 	r->type = TINT;
611 	r->store.fmt = 'D';
612 }
613 
614 void
615 includepipe(Node *r, Node *args)
616 {
617 	Node res;
618 	int i, isave, pid, pip[2];
619 	char *argv[4];
620 	Waitmsg *w;
621 
622 	USED(r);
623 	if(args == 0)
624 		error("includepipe(string): arg count");
625 	expr(args, &res);
626 	if(res.type != TSTRING)
627 		error("includepipe(string): arg type");
628 
629 	Bflush(bout);
630 
631 	argv[0] = "rc";
632 	argv[1] = "-c";
633 	argv[2] = res.store.u.string->string;
634 	argv[3] = 0;
635 
636 	if(pipe(pip) < 0)
637 		error("pipe: %r");
638 
639 	pid = fork();
640 	switch(pid) {
641 	case -1:
642 		close(pip[0]);
643 		close(pip[1]);
644 		error("fork: %r");
645 	case 0:
646 		close(pip[0]);
647 		close(0);
648 		open("/dev/null", OREAD);
649 		dup(pip[1], 1);
650 		if(pip[1] > 1)
651 			close(pip[1]);
652 		for(i=3; i<100; i++)
653 			close(i);
654 		exec("rc", argv);
655 		sysfatal("exec rc: %r");
656 	}
657 
658 	close(pip[1]);
659 	pushfd(pip[0]);
660 
661 	isave = interactive;
662 	interactive = 0;
663 	r->store.u.ival = yyparse();
664 	interactive = isave;
665 	popio();
666 
667 	r->op = OCONST;
668 	r->type = TINT;
669 	r->store.fmt = 'D';
670 
671 	w = waitfor(pid);
672 	if(w->msg && w->msg[0])
673 		error("includepipe(\"%s\"): %s", argv[2], w->msg);	/* leaks w */
674 	free(w);
675 }
676 
677 void
678 rc(Node *r, Node *args)
679 {
680 	Node res;
681 	int pid;
682 	char *p, *q, *argv[4];
683 	Waitmsg *w;
684 
685 	USED(r);
686 	if(args == 0)
687 		error("rc(string): arg count");
688 	expr(args, &res);
689 	if(res.type != TSTRING)
690 		error("rc(string): arg type");
691 
692 	argv[0] = "rc";
693 	argv[1] = "-c";
694 	argv[2] = res.store.u.string->string;
695 	argv[3] = 0;
696 
697 	pid = fork();
698 	switch(pid) {
699 	case -1:
700 		error("fork %r");
701 	case 0:
702 		exec("rc", argv);
703 		exits(0);
704 	default:
705 		w = waitfor(pid);
706 		break;
707 	}
708 	p = w->msg;
709 	q = strrchr(p, ':');
710 	if (q)
711 		p = q+1;
712 
713 	r->op = OCONST;
714 	r->type = TSTRING;
715 	r->store.u.string = strnode(p);
716 	free(w);
717 	r->store.fmt = 's';
718 }
719 
720 void
721 doerror(Node *r, Node *args)
722 {
723 	Node res;
724 
725 	USED(r);
726 	if(args == 0)
727 		error("error(string): arg count");
728 	expr(args, &res);
729 	if(res.type != TSTRING)
730 		error("error(string): arg type");
731 
732 	error(res.store.u.string->string);
733 }
734 
735 void
736 doaccess(Node *r, Node *args)
737 {
738 	Node res;
739 
740 	if(args == 0)
741 		error("access(filename): arg count");
742 	expr(args, &res);
743 	if(res.type != TSTRING)
744 		error("access(filename): arg type");
745 
746 	r->op = OCONST;
747 	r->type = TINT;
748 	r->store.fmt = 'D';
749 	r->store.u.ival = 0;
750 	if(access(res.store.u.string->string, 4) == 0)
751 		r->store.u.ival = 1;
752 }
753 
754 void
755 readfile(Node *r, Node *args)
756 {
757 	Node res;
758 	int n, fd;
759 	char *buf;
760 	Dir *db;
761 
762 	if(args == 0)
763 		error("readfile(filename): arg count");
764 	expr(args, &res);
765 	if(res.type != TSTRING)
766 		error("readfile(filename): arg type");
767 
768 	fd = open(res.store.u.string->string, OREAD);
769 	if(fd < 0)
770 		return;
771 
772 	db = dirfstat(fd);
773 	if(db == nil || db->length == 0)
774 		n = 8192;
775 	else
776 		n = db->length;
777 	free(db);
778 
779 	buf = malloc(n);
780 	n = read(fd, buf, n);
781 
782 	if(n > 0) {
783 		r->op = OCONST;
784 		r->type = TSTRING;
785 		r->store.u.string = strnodlen(buf, n);
786 		r->store.fmt = 's';
787 	}
788 	free(buf);
789 	close(fd);
790 }
791 
792 void
793 getfile(Node *r, Node *args)
794 {
795 	int n;
796 	char *p;
797 	Node res;
798 	String *s;
799 	Biobuf *bp;
800 	List **l, *new;
801 
802 	if(args == 0)
803 		error("file(filename): arg count");
804 	expr(args, &res);
805 	if(res.type != TSTRING)
806 		error("file(filename): arg type");
807 
808 	r->op = OCONST;
809 	r->type = TLIST;
810 	r->store.u.l = 0;
811 
812 	p = res.store.u.string->string;
813 	bp = Bopen(p, OREAD);
814 	if(bp == 0)
815 		return;
816 
817 	l = &r->store.u.l;
818 	for(;;) {
819 		p = Brdline(bp, '\n');
820 		n = Blinelen(bp);
821 		if(p == 0) {
822 			if(n == 0)
823 				break;
824 			s = strnodlen(0, n);
825 			Bread(bp, s->string, n);
826 		}
827 		else
828 			s = strnodlen(p, n-1);
829 
830 		new = al(TSTRING);
831 		new->store.u.string = s;
832 		new->store.fmt = 's';
833 		*l = new;
834 		l = &new->next;
835 	}
836 	Bterm(bp);
837 }
838 
839 void
840 cvtatof(Node *r, Node *args)
841 {
842 	Node res;
843 
844 	if(args == 0)
845 		error("atof(string): arg count");
846 	expr(args, &res);
847 	if(res.type != TSTRING)
848 		error("atof(string): arg type");
849 
850 	r->op = OCONST;
851 	r->type = TFLOAT;
852 	r->store.u.fval = atof(res.store.u.string->string);
853 	r->store.fmt = 'f';
854 }
855 
856 void
857 cvtatoi(Node *r, Node *args)
858 {
859 	Node res;
860 
861 	if(args == 0)
862 		error("atoi(string): arg count");
863 	expr(args, &res);
864 	if(res.type != TSTRING)
865 		error("atoi(string): arg type");
866 
867 	r->op = OCONST;
868 	r->type = TINT;
869 	r->store.u.ival = strtoull(res.store.u.string->string, 0, 0);
870 	r->store.fmt = 'D';
871 }
872 
873 void
874 cvtitoa(Node *r, Node *args)
875 {
876 	Node res;
877 	Node *av[Maxarg];
878 	s64int ival;
879 	char buf[128], *fmt;
880 
881 	if(args == 0)
882 err:
883 		error("itoa(number [, printformat]): arg count");
884 	na = 0;
885 	flatten(av, args);
886 	if(na == 0 || na > 2)
887 		goto err;
888 	expr(av[0], &res);
889 	if(res.type != TINT)
890 		error("itoa(integer): arg type");
891 	ival = (int)res.store.u.ival;
892 	fmt = "%d";
893 	if(na == 2){
894 		expr(av[1], &res);
895 		if(res.type != TSTRING)
896 			error("itoa(integer, string): arg type");
897 		fmt = res.store.u.string->string;
898 	}
899 
900 	sprint(buf, fmt, ival);
901 	r->op = OCONST;
902 	r->type = TSTRING;
903 	r->store.u.string = strnode(buf);
904 	r->store.fmt = 's';
905 }
906 
907 List*
908 mapent(Map *m)
909 {
910 	int i;
911 	List *l, *n, **t, *h;
912 
913 	h = 0;
914 	t = &h;
915 	for(i = 0; i < m->nseg; i++) {
916 		l = al(TSTRING);
917 		n = al(TLIST);
918 		n->store.u.l = l;
919 		*t = n;
920 		t = &n->next;
921 		l->store.u.string = strnode(m->seg[i].name);
922 		l->store.fmt = 's';
923 		l->next = al(TSTRING);
924 		l = l->next;
925 		l->store.u.string = strnode(m->seg[i].file ? m->seg[i].file : "");
926 		l->store.fmt = 's';
927 		l->next = al(TINT);
928 		l = l->next;
929 		l->store.u.ival = m->seg[i].base;
930 		l->store.fmt = 'X';
931 		l->next = al(TINT);
932 		l = l->next;
933 		l->store.u.ival = m->seg[i].base + m->seg[i].size;
934 		l->store.fmt = 'X';
935 		l->next = al(TINT);
936 		l = l->next;
937 		l->store.u.ival = m->seg[i].offset;
938 		l->store.fmt = 'X';
939 	}
940 	return h;
941 }
942 
943 void
944 map(Node *r, Node *args)
945 {
946 	int i;
947 	Map *m;
948 	List *l;
949 	char *nam, *fil;
950 	Node *av[Maxarg], res;
951 
952 	na = 0;
953 	flatten(av, args);
954 
955 	if(na != 0) {
956 		expr(av[0], &res);
957 		if(res.type != TLIST)
958 			error("map(list): map needs a list");
959 		if(listlen(res.store.u.l) != 5)
960 			error("map(list): list must have 5 entries");
961 
962 		l = res.store.u.l;
963 		if(l->type != TSTRING)
964 			error("map name must be a string");
965 		nam = l->store.u.string->string;
966 		l = l->next;
967 		if(l->type != TSTRING)
968 			error("map file must be a string");
969 		fil = l->store.u.string->string;
970 		m = symmap;
971 		i = findseg(m, nam, fil);
972 		if(i < 0) {
973 			m = cormap;
974 			i = findseg(m, nam, fil);
975 		}
976 		if(i < 0)
977 			error("%s %s is not a map entry", nam, fil);
978 		l = l->next;
979 		if(l->type != TINT)
980 			error("map entry not int");
981 		m->seg[i].base = l->store.u.ival;
982 /*
983 		if (strcmp(ent, "text") == 0)
984 			textseg(l->store.u.ival, &fhdr);
985 */
986 		l = l->next;
987 		if(l->type != TINT)
988 			error("map entry not int");
989 		m->seg[i].size = l->store.u.ival - m->seg[i].base;
990 		l = l->next;
991 		if(l->type != TINT)
992 			error("map entry not int");
993 		m->seg[i].offset = l->store.u.ival;
994 	}
995 
996 	r->type = TLIST;
997 	r->store.u.l = 0;
998 	if(symmap)
999 		r->store.u.l = mapent(symmap);
1000 	if(cormap) {
1001 		if(r->store.u.l == 0)
1002 			r->store.u.l = mapent(cormap);
1003 		else {
1004 			for(l = r->store.u.l; l->next; l = l->next)
1005 				;
1006 			l->next = mapent(cormap);
1007 		}
1008 	}
1009 }
1010 
1011 void
1012 flatten(Node **av, Node *n)
1013 {
1014 	if(n == 0)
1015 		return;
1016 
1017 	switch(n->op) {
1018 	case OLIST:
1019 		flatten(av, n->left);
1020 		flatten(av, n->right);
1021 		break;
1022 	default:
1023 		av[na++] = n;
1024 		if(na >= Maxarg)
1025 			error("too many function arguments");
1026 		break;
1027 	}
1028 }
1029 
1030 static struct
1031 {
1032 	char *name;
1033 	u64int val;
1034 } sregs[Maxarg/2];
1035 static int nsregs;
1036 
1037 static int
1038 straceregrw(Regs *regs, char *name, u64int *val, int isr)
1039 {
1040 	int i;
1041 
1042 	if(!isr){
1043 		werrstr("saved registers cannot be written");
1044 		return -1;
1045 	}
1046 	for(i=0; i<nsregs; i++)
1047 		if(strcmp(sregs[i].name, name) == 0){
1048 			*val = sregs[i].val;
1049 			return 0;
1050 		}
1051 	return rget(acidregs, name, val);
1052 }
1053 
1054 void
1055 strace(Node *r, Node *args)
1056 {
1057 	Node *av[Maxarg], res;
1058 	List *l;
1059 	Regs regs;
1060 
1061 	na = 0;
1062 	flatten(av, args);
1063 
1064 	if(na != 1)
1065 		error("strace(list): want one arg");
1066 
1067 	expr(av[0], &res);
1068 	if(res.type != TLIST)
1069 		error("strace(list): strace needs a list");
1070 	l = res.store.u.l;
1071 	if(listlen(l)%2)
1072 		error("strace(list): strace needs an even-length list");
1073 	for(nsregs=0; l; nsregs++){
1074 		if(l->type != TSTRING)
1075 			error("strace({r,v,r,v,...}): non-string name");
1076 		sregs[nsregs].name = l->store.u.string->string;
1077 		if(regdesc(sregs[nsregs].name) == nil)
1078 			error("strace: bad register '%s'", sregs[nsregs].name);
1079 		l = l->next;
1080 
1081 		if(l == nil)
1082 			error("cannot happen in strace");
1083 		if(l->type != TINT)
1084 			error("strace: non-int value for %s", sregs[nsregs].name);
1085 		sregs[nsregs].val = l->store.u.ival;
1086 		l = l->next;
1087 	}
1088 	regs.rw = straceregrw;
1089 
1090 	tracelist = 0;
1091 	if(stacktrace(cormap, &regs, trlist) <= 0)
1092 		error("no stack frame");
1093 	r->type = TLIST;
1094 	r->store.u.l = tracelist;
1095 }
1096 
1097 void
1098 regerror(char *msg)
1099 {
1100 	error(msg);
1101 }
1102 
1103 void
1104 regexp(Node *r, Node *args)
1105 {
1106 	Node res;
1107 	Reprog *rp;
1108 	Node *av[Maxarg];
1109 
1110 	na = 0;
1111 	flatten(av, args);
1112 	if(na != 2)
1113 		error("regexp(pattern, string): arg count");
1114 	expr(av[0], &res);
1115 	if(res.type != TSTRING)
1116 		error("regexp(pattern, string): pattern must be string");
1117 	rp = regcomp(res.store.u.string->string);
1118 	if(rp == 0)
1119 		return;
1120 
1121 	expr(av[1], &res);
1122 	if(res.type != TSTRING)
1123 		error("regexp(pattern, string): bad string");
1124 
1125 	r->store.fmt = 'D';
1126 	r->type = TINT;
1127 	r->store.u.ival = regexec(rp, res.store.u.string->string, 0, 0);
1128 	free(rp);
1129 }
1130 
1131 char vfmt[] = "aBbcCdDfFgGiIoOqQrRsSuUVxXYZ";
1132 
1133 void
1134 fmt(Node *r, Node *args)
1135 {
1136 	Node res;
1137 	Node *av[Maxarg];
1138 
1139 	na = 0;
1140 	flatten(av, args);
1141 	if(na != 2)
1142 		error("fmt(obj, fmt): arg count");
1143 	expr(av[1], &res);
1144 	if(res.type != TINT || strchr(vfmt, res.store.u.ival) == 0)
1145 		error("fmt(obj, fmt): bad format '%c'", (char)res.store.u.ival);
1146 	expr(av[0], r);
1147 	r->store.fmt = res.store.u.ival;
1148 }
1149 
1150 void
1151 patom(char type, Store *res)
1152 {
1153 	int i;
1154 	char buf[512];
1155 	extern char *typenames[];
1156 	Node *n;
1157 
1158 	switch(type){
1159 	case TREG:
1160 		if(res->u.reg.thread)
1161 			Bprint(bout, "register(\"%s\", %#ux)", res->u.reg.name, res->u.reg.thread);
1162 		else
1163 			Bprint(bout, "register(\"%s\")", res->u.reg.name);
1164 		return;
1165 	case TCON:
1166 		Bprint(bout, "refconst(");
1167 		n = res->u.con;
1168 		patom(n->type, &n->store);
1169 		Bprint(bout, ")");
1170 		return;
1171 	}
1172 
1173 	switch(res->fmt){
1174 	case 'c':
1175 	case 'C':
1176 	case 'r':
1177 	case 'B':
1178 	case 'b':
1179 	case 'X':
1180 	case 'x':
1181 	case 'W':
1182 	case 'D':
1183 	case 'd':
1184 	case 'u':
1185 	case 'U':
1186 	case 'Z':
1187 	case 'V':
1188 	case 'Y':
1189 	case 'o':
1190 	case 'O':
1191 	case 'q':
1192 	case 'Q':
1193 	case 'a':
1194 	case 'A':
1195 	case 'I':
1196 	case 'i':
1197 		if(type != TINT){
1198 		badtype:
1199 			Bprint(bout, "*%s\\%c*", typenames[(uchar)type], res->fmt);
1200 			return;
1201 		}
1202 		break;
1203 
1204 	case 'f':
1205 	case 'F':
1206 		if(type != TFLOAT)
1207 			goto badtype;
1208 		break;
1209 
1210 	case 's':
1211 	case 'g':
1212 	case 'G':
1213 	case 'R':
1214 		if(type != TSTRING)
1215 			goto badtype;
1216 		break;
1217 	}
1218 
1219 	switch(res->fmt) {
1220 	case 'c':
1221 		Bprint(bout, "%c", (int)res->u.ival);
1222 		break;
1223 	case 'C':
1224 		if(res->u.ival < ' ' || res->u.ival >= 0x7f)
1225 			Bprint(bout, "%3d", (int)res->u.ival&0xff);
1226 		else
1227 			Bprint(bout, "%3c", (int)res->u.ival);
1228 		break;
1229 	case 'r':
1230 		Bprint(bout, "%C", (int)res->u.ival);
1231 		break;
1232 	case 'B':
1233 		memset(buf, '0', 34);
1234 		buf[1] = 'b';
1235 		for(i = 0; i < 32; i++) {
1236 			if(res->u.ival & (1<<i))
1237 				buf[33-i] = '1';
1238 		}
1239 		buf[35] = '\0';
1240 		Bprint(bout, "%s", buf);
1241 		break;
1242 	case 'b':
1243 		Bprint(bout, "%#.2x", (int)res->u.ival&0xff);
1244 		break;
1245 	case 'X':
1246 		Bprint(bout, "%#.8lux", (ulong)res->u.ival);
1247 		break;
1248 	case 'x':
1249 		Bprint(bout, "%#.4lux", (ulong)res->u.ival&0xffff);
1250 		break;
1251 	case 'W':
1252 		Bprint(bout, "%#.16llux", res->u.ival);
1253 		break;
1254 	case 'D':
1255 		Bprint(bout, "%d", (int)res->u.ival);
1256 		break;
1257 	case 'd':
1258 		Bprint(bout, "%d", (ushort)res->u.ival);
1259 		break;
1260 	case 'u':
1261 		Bprint(bout, "%d", (int)res->u.ival&0xffff);
1262 		break;
1263 	case 'U':
1264 		Bprint(bout, "%lud", (ulong)res->u.ival);
1265 		break;
1266 	case 'Z':
1267 		Bprint(bout, "%llud", res->u.ival);
1268 		break;
1269 	case 'V':
1270 		Bprint(bout, "%lld", res->u.ival);
1271 		break;
1272 	case 'Y':
1273 		Bprint(bout, "%#.16llux", res->u.ival);
1274 		break;
1275 	case 'o':
1276 		Bprint(bout, "%#.11uo", (int)res->u.ival&0xffff);
1277 		break;
1278 	case 'O':
1279 		Bprint(bout, "%#.6uo", (int)res->u.ival);
1280 		break;
1281 	case 'q':
1282 		Bprint(bout, "%#.11o", (short)(res->u.ival&0xffff));
1283 		break;
1284 	case 'Q':
1285 		Bprint(bout, "%#.6o", (int)res->u.ival);
1286 		break;
1287 	case 'f':
1288 	case 'F':
1289 		Bprint(bout, "%g", res->u.fval);
1290 		break;
1291 	case 's':
1292 	case 'g':
1293 	case 'G':
1294 		Bwrite(bout, res->u.string->string, res->u.string->len);
1295 		break;
1296 	case 'R':
1297 		Bprint(bout, "%S", (Rune*)res->u.string->string);
1298 		break;
1299 	case 'a':
1300 	case 'A':
1301 		symoff(buf, sizeof(buf), res->u.ival, CANY);
1302 		Bprint(bout, "%s", buf);
1303 		break;
1304 	case 'I':
1305 	case 'i':
1306 		if (symmap == nil || (*mach->das)(symmap, res->u.ival, res->fmt, buf, sizeof(buf)) < 0)
1307 			Bprint(bout, "no instruction");
1308 		else
1309 			Bprint(bout, "%s", buf);
1310 		break;
1311 	}
1312 }
1313 
1314 void
1315 blprint(List *l)
1316 {
1317 	Store *res;
1318 
1319 	Bprint(bout, "{");
1320 	while(l) {
1321 		switch(l->type) {
1322 		case TINT:
1323 			res = &l->store;
1324 			if(res->fmt == 'c'){
1325 				Bprint(bout, "\'%c\'", (int)res->u.ival);
1326 				break;
1327 			}else if(res->fmt == 'r'){
1328 				Bprint(bout, "\'%C\'", (int)res->u.ival);
1329 				break;
1330 			}
1331 			/* fall through */
1332 		default:
1333 			patom(l->type, &l->store);
1334 			break;
1335 		case TSTRING:
1336 			Bputc(bout, '"');
1337 			patom(l->type, &l->store);
1338 			Bputc(bout, '"');
1339 			break;
1340 		case TLIST:
1341 			blprint(l->store.u.l);
1342 			break;
1343 		case TCODE:
1344 			pcode(l->store.u.cc, 0);
1345 			break;
1346 		}
1347 		l = l->next;
1348 		if(l)
1349 			Bprint(bout, ", ");
1350 	}
1351 	Bprint(bout, "}");
1352 }
1353 
1354 int
1355 comx(Node res)
1356 {
1357 	Lsym *sl;
1358 	Node *n, xx;
1359 
1360 	if(res.store.fmt != 'a' && res.store.fmt != 'A')
1361 		return 0;
1362 
1363 	if(res.store.comt == 0 || res.store.comt->base == 0)
1364 		return 0;
1365 
1366 	sl = res.store.comt->base;
1367 	if(sl->proc) {
1368 		res.left = ZN;
1369 		res.right = ZN;
1370 		n = an(ONAME, ZN, ZN);
1371 		n->sym = sl;
1372 		n = an(OCALL, n, &res);
1373 			n->left->sym = sl;
1374 		expr(n, &xx);
1375 		return 1;
1376 	}
1377 	print("(%s)", sl->name);
1378 	return 0;
1379 }
1380 
1381 void
1382 bprint(Node *r, Node *args)
1383 {
1384 	int i, nas;
1385 	Node res, *av[Maxarg];
1386 
1387 	USED(r);
1388 	na = 0;
1389 	flatten(av, args);
1390 	nas = na;
1391 	for(i = 0; i < nas; i++) {
1392 		expr(av[i], &res);
1393 		switch(res.type) {
1394 		default:
1395 			if(comx(res))
1396 				break;
1397 			patom(res.type, &res.store);
1398 			break;
1399 		case TCODE:
1400 			pcode(res.store.u.cc, 0);
1401 			break;
1402 		case TLIST:
1403 			blprint(res.store.u.l);
1404 			break;
1405 		}
1406 	}
1407 	if(ret == 0)
1408 		Bputc(bout, '\n');
1409 }
1410 
1411 void
1412 printto(Node *r, Node *args)
1413 {
1414 	int fd;
1415 	Biobuf *b;
1416 	int i, nas;
1417 	Node res, *av[Maxarg];
1418 
1419 	USED(r);
1420 	na = 0;
1421 	flatten(av, args);
1422 	nas = na;
1423 
1424 	expr(av[0], &res);
1425 	if(res.type != TSTRING)
1426 		error("printto(string, ...): need string");
1427 
1428 	fd = create(res.store.u.string->string, OWRITE, 0666);
1429 	if(fd < 0)
1430 		fd = open(res.store.u.string->string, OWRITE);
1431 	if(fd < 0)
1432 		error("printto: open %s: %r", res.store.u.string->string);
1433 
1434 	b = gmalloc(sizeof(Biobuf));
1435 	Binit(b, fd, OWRITE);
1436 
1437 	Bflush(bout);
1438 	io[iop++] = bout;
1439 	bout = b;
1440 
1441 	for(i = 1; i < nas; i++) {
1442 		expr(av[i], &res);
1443 		switch(res.type) {
1444 		default:
1445 			if(comx(res))
1446 				break;
1447 			patom(res.type, &res.store);
1448 			break;
1449 		case TLIST:
1450 			blprint(res.store.u.l);
1451 			break;
1452 		}
1453 	}
1454 	if(ret == 0)
1455 		Bputc(bout, '\n');
1456 
1457 	Bterm(b);
1458 	close(fd);
1459 	free(b);
1460 	bout = io[--iop];
1461 }
1462 
1463 void
1464 pcfile(Node *r, Node *args)
1465 {
1466 	Node res;
1467 	char *p, buf[128];
1468 
1469 	if(args == 0)
1470 		error("pcfile(addr): arg count");
1471 	expr(args, &res);
1472 	if(res.type != TINT)
1473 		error("pcfile(addr): arg type");
1474 
1475 	r->type = TSTRING;
1476 	r->store.fmt = 's';
1477 	if(fileline(res.store.u.ival, buf, sizeof(buf)) < 0) {
1478 		r->store.u.string = strnode("?file?");
1479 		return;
1480 	}
1481 	p = strrchr(buf, ':');
1482 	if(p == 0)
1483 		error("pcfile(addr): funny file %s", buf);
1484 	*p = '\0';
1485 	r->store.u.string = strnode(buf);
1486 }
1487 
1488 void
1489 pcline(Node *r, Node *args)
1490 {
1491 	Node res;
1492 	char *p, buf[128];
1493 
1494 	if(args == 0)
1495 		error("pcline(addr): arg count");
1496 	expr(args, &res);
1497 	if(res.type != TINT)
1498 		error("pcline(addr): arg type");
1499 
1500 	r->type = TINT;
1501 	r->store.fmt = 'D';
1502 	if(fileline(res.store.u.ival, buf, sizeof(buf)) < 0) {
1503 		r->store.u.ival = 0;
1504 		return;
1505 	}
1506 
1507 	p = strrchr(buf, ':');
1508 	if(p == 0)
1509 		error("pcline(addr): funny file %s", buf);
1510 	r->store.u.ival = atoi(p+1);
1511 }
1512 
1513 void
1514 textfile(Node *r, Node *args)
1515 {
1516 	char *file;
1517 	long base;
1518 	Fhdr *fp;
1519 	Node res, *av[Maxarg];
1520 	List *l, *l2, **tail, *list, *tl;
1521 
1522 	na = 0;
1523 	flatten(av, args);
1524 
1525 	if(na != 0) {
1526 		expr(av[0], &res);
1527 		if(res.type != TLIST)
1528 			error("textfile(list): textfile needs a list");
1529 		if(listlen(res.store.u.l) != 2)
1530 			error("textfile(list): list must have 2 entries");
1531 
1532 		l = res.store.u.l;
1533 		if(l->type != TSTRING)
1534 			error("textfile name must be a string");
1535 		file = l->store.u.string->string;
1536 
1537 		l = l->next;
1538 		if(l->type != TINT)
1539 			error("textfile base must be an int");
1540 		base = l->store.u.ival;
1541 
1542 		if((fp = crackhdr(file, OREAD)) == nil)
1543 			error("crackhdr %s: %r", file);
1544 		Bflush(bout);
1545 		fp->base = base;
1546 		fprint(2, "%s: %s %s %s\n", file, fp->aname, fp->mname, fp->fname);
1547 		if(mapfile(fp, base, symmap, nil) < 0)
1548 			fprint(2, "mapping %s: %r\n", file);
1549 		if(corhdr){
1550 			unmapfile(corhdr, cormap);
1551 			mapfile(fp, base, cormap, nil);
1552 			free(correg);
1553 			correg = nil;
1554 			mapfile(corhdr, 0, cormap, &correg);
1555 		}
1556 		if(symopen(fp) < 0)
1557 			fprint(2, "symopen %s: %r\n", file);
1558 		else
1559 			addvarsym(fp);
1560 		return;
1561 	}
1562 
1563 	l2 = nil;
1564 	tail = &l2;
1565 	for(fp=fhdrlist; fp; fp=fp->next){
1566 		if(fp->ftype == FCORE)
1567 			continue;
1568 		tl = al(TLIST);
1569 		*tail = tl;
1570 		tail = &tl->next;
1571 
1572 		list = al(TSTRING);
1573 		tl->store.u.l = list;
1574 		list->store.u.string = strnode(fp->filename);
1575 		list->store.fmt = 's';
1576 		list->next = al(TINT);
1577 		list = list->next;
1578 		list->store.fmt = 'X';
1579 		list->store.u.ival = fp->base;
1580 	}
1581 
1582 	r->type = TLIST;
1583 	r->store.u.l = l2;
1584 }
1585 
1586 void
1587 deltextfile(Node *r, Node *args)
1588 {
1589 	int did;
1590 	char *file;
1591 	Fhdr *fp, *fpnext;
1592 	Node res, *av[Maxarg];
1593 
1594 	na = 0;
1595 	flatten(av, args);
1596 
1597 	if(na != 1)
1598 		error("deltextfile(string): arg count");
1599 
1600 	expr(av[0], &res);
1601 	if(res.type != TSTRING)
1602 		error("deltextfile(string): arg type");
1603 	file = res.store.u.string->string;
1604 
1605 	did = 0;
1606 	for(fp=fhdrlist; fp; fp=fpnext){
1607 		fpnext = fp->next;
1608 		if(fp->ftype == FCORE)
1609 			continue;
1610 		if(strcmp(file, fp->filename) == 0){
1611 			did = 1;
1612 			if(fp == symhdr)
1613 				error("cannot remove symbols from main text file");
1614 			unmapfile(fp, symmap);
1615 			uncrackhdr(fp);
1616 		}
1617 	}
1618 
1619 	delvarsym(file);
1620 	if(!did)
1621 		error("symbol file %s not open", file);
1622 }
1623 
1624 void
1625 stringn(Node *r, Node *args)
1626 {
1627 	uint addr;
1628 	int i, n, ret;
1629 	Node res, *av[Maxarg];
1630 	char *buf;
1631 
1632 	na = 0;
1633 	flatten(av, args);
1634 	if(na != 2)
1635 		error("stringn(addr, n): arg count");
1636 
1637 	expr(av[0], &res);
1638 	if(res.type != TINT)
1639 		error("stringn(addr, n): arg type");
1640 	addr = res.store.u.ival;
1641 
1642 	expr(av[1], &res);
1643 	if(res.type != TINT)
1644 		error("stringn(addr,n): arg type");
1645 	n = res.store.u.ival;
1646 
1647 	buf = malloc(n+1);
1648 	if(buf == nil)
1649 		error("out of memory");
1650 
1651 	r->type = TSTRING;
1652 	for(i=0; i<n; i++){
1653 		ret = get1(cormap, addr, (uchar*)&buf[i], 1);
1654 		if(ret < 0){
1655 			free(buf);
1656 			error("indir: %r");
1657 		}
1658 		addr++;
1659 	}
1660 	buf[n] = 0;
1661 	r->store.u.string = strnode(buf);
1662 	free(buf);
1663 }