sys/src/cmd/acid/builtin.c

   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    kill(Node*,Node*);
  30 void    waitstop(Node*, Node*);
  31 void    stop(Node*, Node*);
  32 void    start(Node*, Node*);
  33 void    filepc(Node*, Node*);
  34 void    doerror(Node*, Node*);
  35 void    rc(Node*, Node*);
  36 void    doaccess(Node*, Node*);
  37 void    map(Node*, Node*);
  38 void    readfile(Node*, Node*);
  39 void    interpret(Node*, Node*);
  40 void    include(Node*, Node*);
  41 void    regexp(Node*, Node*);
  42 void    dosysr1(Node*, Node*);
  43 void    fmtof(Node*, Node*) ;
  44 void    dofmtsize(Node*, Node*) ;
  45
  46 typedef struct Btab Btab;
  47 struct Btab
  48 {
  49         char    *name;
  50         void    (*fn)(Node*, Node*);
  51 } tab[] =
  52 {
  53         "atof",         cvtatof,
  54         "atoi",         cvtatoi,
  55         "error",        doerror,
  56         "file",         getfile,
  57         "readfile",     readfile,
  58         "access",       doaccess,
  59         "filepc",       filepc,
  60         "fnbound",      funcbound,
  61         "fmt",          fmt,
  62         "follow",       follow,
  63         "itoa",         cvtitoa,
  64         "kill",         kill,
  65         "match",        match,
  66         "newproc",      newproc,
  67         "pcfile",       pcfile,
  68         "pcline",       pcline,
  69         "print",        bprint,
  70         "printto",      printto,
  71         "rc",           rc,
  72         "reason",       reason,
  73         "setproc",      setproc,
  74         "start",        start,
  75         "startstop",    startstop,
  76         "status",       status,
  77         "stop",         stop,
  78         "strace",       strace,
  79         "sysr1",        dosysr1,
  80         "waitstop",     waitstop,
  81         "map",          map,
  82         "interpret",    interpret,
  83         "include",      include,
  84         "regexp",       regexp,
  85         "fmtof",        fmtof,
  86         "fmtsize",      dofmtsize,
  87         0
  88 };
  89
  90 char vfmt[] = "aBbcCdDfFgGiIoOqQrRsSuUVWxXYZ38";
  91
  92 void
  93 mkprint(Lsym *s)
  94 {
  95         prnt = malloc(sizeof(Node));
  96         memset(prnt, 0, sizeof(Node));
  97         prnt->op = OCALL;
  98         prnt->left = malloc(sizeof(Node));
  99         memset(prnt->left, 0, sizeof(Node));
 100         prnt->left->sym = s;
 101 }
 102
 103 void
 104 installbuiltin(void)
 105 {
 106         Btab *b;
 107         Lsym *s;
 108
 109         b = tab;
 110         while(b->name) {
 111                 s = look(b->name);
 112                 if(s == 0)
 113                         s = enter(b->name, Tid);
 114
 115                 s->builtin = b->fn;
 116                 if(b->fn == bprint)
 117                         mkprint(s);
 118                 b++;
 119         }
 120 }
 121
 122 void
 123 dosysr1(Node *r, Node*)
 124 {
 125         extern int sysr1(void);
 126
 127         r->op = OCONST;
 128         r->type = TINT;
 129         r->fmt = 'D';
 130         r->ival = sysr1();
 131 }
 132
 133 void
 134 match(Node *r, Node *args)
 135 {
 136         int i;
 137         List *f;
 138         Node *av[Maxarg];
 139         Node resi, resl;
 140
 141         na = 0;
 142         flatten(av, args);
 143         if(na != 2)
 144                 error("match(obj, list): arg count");
 145
 146         expr(av[1], &resl);
 147         if(resl.type != TLIST)
 148                 error("match(obj, list): need list");
 149         expr(av[0], &resi);
 150
 151         r->op = OCONST;
 152         r->type = TINT;
 153         r->fmt = 'D';
 154         r->ival = -1;
 155
 156         i = 0;
 157         for(f = resl.l; f; f = f->next) {
 158                 if(resi.type == f->type) {
 159                         switch(resi.type) {
 160                         case TINT:
 161                                 if(resi.ival == f->ival) {
 162                                         r->ival = i;
 163                                         return;
 164                                 }
 165                                 break;
 166                         case TFLOAT:
 167                                 if(resi.fval == f->fval) {
 168                                         r->ival = i;
 169                                         return;
 170                                 }
 171                                 break;
 172                         case TSTRING:
 173                                 if(scmp(resi.string, f->string)) {
 174                                         r->ival = i;
 175                                         return;
 176                                 }
 177                                 break;
 178                         case TLIST:
 179                                 error("match(obj, list): not defined for list");
 180                         }
 181                 }
 182                 i++;
 183         }
 184 }
 185
 186 void
 187 newproc(Node *r, Node *args)
 188 {
 189         int i;
 190         Node res;
 191         char *p, *e;
 192         char *argv[Maxarg], buf[Strsize];
 193
 194         i = 1;
 195         argv[0] = aout;
 196
 197         if(args) {
 198                 expr(args, &res);
 199                 if(res.type != TSTRING)
 200                         error("newproc(): arg not string");
 201                 if(res.string->len >= sizeof(buf))
 202                         error("newproc(): too many arguments");
 203                 memmove(buf, res.string->string, res.string->len);
 204                 buf[res.string->len] = '\0';
 205                 p = buf;
 206                 e = buf+res.string->len;
 207                 for(;;) {
 208                         while(p < e && (*p == '\t' || *p == ' '))
 209                                 *p++ = '\0';
 210                         if(p >= e)
 211                                 break;
 212                         argv[i++] = p;
 213                         if(i >= Maxarg)
 214                                 error("newproc: too many arguments");
 215                         while(p < e && *p != '\t' && *p != ' ')
 216                                 p++;
 217                 }
 218         }
 219         argv[i] = 0;
 220         r->op = OCONST;
 221         r->type = TINT;
 222         r->fmt = 'D';
 223         r->ival = nproc(argv);
 224 }
 225
 226 void
 227 startstop(Node *r, Node *args)
 228 {
 229         Node res;
 230
 231         USED(r);
 232         if(args == 0)
 233                 error("startstop(pid): no pid");
 234         expr(args, &res);
 235         if(res.type != TINT)
 236                 error("startstop(pid): arg type");
 237
 238         msg(res.ival, "startstop");
 239         notes(res.ival);
 240         dostop(res.ival);
 241 }
 242
 243 void
 244 waitstop(Node *r, Node *args)
 245 {
 246         Node res;
 247
 248         USED(r);
 249         if(args == 0)
 250                 error("waitstop(pid): no pid");
 251         expr(args, &res);
 252         if(res.type != TINT)
 253                 error("waitstop(pid): arg type");
 254
 255         Bflush(bout);
 256         msg(res.ival, "waitstop");
 257         notes(res.ival);
 258         dostop(res.ival);
 259 }
 260
 261 void
 262 start(Node *r, Node *args)
 263 {
 264         Node res;
 265
 266         USED(r);
 267         if(args == 0)
 268                 error("start(pid): no pid");
 269         expr(args, &res);
 270         if(res.type != TINT)
 271                 error("start(pid): arg type");
 272
 273         msg(res.ival, "start");
 274 }
 275
 276 void
 277 stop(Node *r, Node *args)
 278 {
 279         Node res;
 280
 281         USED(r);
 282         if(args == 0)
 283                 error("stop(pid): no pid");
 284         expr(args, &res);
 285         if(res.type != TINT)
 286                 error("stop(pid): arg type");
 287
 288         Bflush(bout);
 289         msg(res.ival, "stop");
 290         notes(res.ival);
 291         dostop(res.ival);
 292 }
 293
 294 void
 295 kill(Node *r, Node *args)
 296 {
 297         Node res;
 298
 299         USED(r);
 300         if(args == 0)
 301                 error("kill(pid): no pid");
 302         expr(args, &res);
 303         if(res.type != TINT)
 304                 error("kill(pid): arg type");
 305
 306         msg(res.ival, "kill");
 307         deinstall(res.ival);
 308 }
 309
 310 void
 311 status(Node *r, Node *args)
 312 {
 313         Node res;
 314         char *p;
 315
 316         USED(r);
 317         if(args == 0)
 318                 error("status(pid): no pid");
 319         expr(args, &res);
 320         if(res.type != TINT)
 321                 error("status(pid): arg type");
 322
 323         p = getstatus(res.ival);
 324         r->string = strnode(p);
 325         r->op = OCONST;
 326         r->fmt = 's';
 327         r->type = TSTRING;
 328 }
 329
 330 void
 331 reason(Node *r, Node *args)
 332 {
 333         Node res;
 334
 335         if(args == 0)
 336                 error("reason(cause): no cause");
 337         expr(args, &res);
 338         if(res.type != TINT)
 339                 error("reason(cause): arg type");
 340
 341         r->op = OCONST;
 342         r->type = TSTRING;
 343         r->fmt = 's';
 344         r->string = strnode((*machdata->excep)(cormap, rget));
 345 }
 346
 347 void
 348 follow(Node *r, Node *args)
 349 {
 350         int n, i;
 351         Node res;
 352         uvlong f[10];
 353         List **tail, *l;
 354
 355         if(args == 0)
 356                 error("follow(addr): no addr");
 357         expr(args, &res);
 358         if(res.type != TINT)
 359                 error("follow(addr): arg type");
 360
 361         n = (*machdata->foll)(cormap, res.ival, rget, f);
 362         if (n < 0)
 363                 error("follow(addr): %r");
 364         tail = &r->l;
 365         for(i = 0; i < n; i++) {
 366                 l = al(TINT);
 367                 l->ival = f[i];
 368                 l->fmt = 'X';
 369                 *tail = l;
 370                 tail = &l->next;
 371         }
 372 }
 373
 374 void
 375 funcbound(Node *r, Node *args)
 376 {
 377         int n;
 378         Node res;
 379         uvlong bounds[2];
 380         List *l;
 381
 382         if(args == 0)
 383                 error("fnbound(addr): no addr");
 384         expr(args, &res);
 385         if(res.type != TINT)
 386                 error("fnbound(addr): arg type");
 387
 388         n = fnbound(res.ival, bounds);
 389         if (n != 0) {
 390                 r->l = al(TINT);
 391                 l = r->l;
 392                 l->ival = bounds[0];
 393                 l->fmt = 'X';
 394                 l->next = al(TINT);
 395                 l = l->next;
 396                 l->ival = bounds[1];
 397                 l->fmt = 'X';
 398         }
 399 }
 400
 401 void
 402 setproc(Node *r, Node *args)
 403 {
 404         Node res;
 405
 406         USED(r);
 407         if(args == 0)
 408                 error("setproc(pid): no pid");
 409         expr(args, &res);
 410         if(res.type != TINT)
 411                 error("setproc(pid): arg type");
 412
 413         sproc(res.ival);
 414 }
 415
 416 void
 417 filepc(Node *r, Node *args)
 418 {
 419         Node res;
 420         char *p, c;
 421
 422         if(args == 0)
 423                 error("filepc(filename:line): arg count");
 424         expr(args, &res);
 425         if(res.type != TSTRING)
 426                 error("filepc(filename:line): arg type");
 427
 428         p = strchr(res.string->string, ':');
 429         if(p == 0)
 430                 error("filepc(filename:line): bad arg format");
 431
 432         c = *p;
 433         *p++ = '\0';
 434         r->ival = file2pc(res.string->string, strtol(p, 0, 0));
 435         p[-1] = c;
 436         if(r->ival == ~0)
 437                 error("filepc(filename:line): can't find address");
 438
 439         r->op = OCONST;
 440         r->type = TINT;
 441         r->fmt = 'V';
 442 }
 443
 444 void
 445 interpret(Node *r, Node *args)
 446 {
 447         Node res;
 448         int isave;
 449
 450         if(args == 0)
 451                 error("interpret(string): arg count");
 452         expr(args, &res);
 453         if(res.type != TSTRING)
 454                 error("interpret(string): arg type");
 455
 456         pushstr(&res);
 457
 458         isave = interactive;
 459         interactive = 0;
 460         r->ival = yyparse();
 461         interactive = isave;
 462         popio();
 463         r->op = OCONST;
 464         r->type = TINT;
 465         r->fmt = 'D';
 466 }
 467
 468 void
 469 include(Node *r, Node *args)
 470 {
 471         Node res;
 472         int isave;
 473
 474         if(args == 0)
 475                 error("include(string): arg count");
 476         expr(args, &res);
 477         if(res.type != TSTRING)
 478                 error("include(string): arg type");
 479
 480         pushfile(res.string->string);
 481
 482         isave = interactive;
 483         interactive = 0;
 484         r->ival = yyparse();
 485         interactive = isave;
 486         popio();
 487         r->op = OCONST;
 488         r->type = TINT;
 489         r->fmt = 'D';
 490 }
 491
 492 void
 493 rc(Node *r, Node *args)
 494 {
 495         Node res;
 496         int pid;
 497         char *p, *q, *argv[4];
 498         Waitmsg *w;
 499
 500         USED(r);
 501         if(args == 0)
 502                 error("error(string): arg count");
 503         expr(args, &res);
 504         if(res.type != TSTRING)
 505                 error("error(string): arg type");
 506
 507         argv[0] = "/bin/rc";
 508         argv[1] = "-c";
 509         argv[2] = res.string->string;
 510         argv[3] = 0;
 511
 512         pid = fork();
 513         switch(pid) {
 514         case -1:
 515                 error("fork %r");
 516         case 0:
 517                 exec("/bin/rc", argv);
 518                 exits(0);
 519         default:
 520                 w = waitfor(pid);
 521                 break;
 522         }
 523         p = w->msg;
 524         q = strrchr(p, ':');
 525         if (q)
 526                 p = q+1;
 527
 528         r->op = OCONST;
 529         r->type = TSTRING;
 530         r->string = strnode(p);
 531         free(w);
 532         r->fmt = 's';
 533 }
 534
 535 void
 536 doerror(Node *r, Node *args)
 537 {
 538         Node res;
 539
 540         USED(r);
 541         if(args == 0)
 542                 error("error(string): arg count");
 543         expr(args, &res);
 544         if(res.type != TSTRING)
 545                 error("error(string): arg type");
 546
 547         error(res.string->string);
 548 }
 549
 550 void
 551 doaccess(Node *r, Node *args)
 552 {
 553         Node res;
 554
 555         if(args == 0)
 556                 error("access(filename): arg count");
 557         expr(args, &res);
 558         if(res.type != TSTRING)
 559                 error("access(filename): arg type");
 560
 561         r->op = OCONST;
 562         r->type = TINT;
 563         r->ival = 0;
 564         if(access(res.string->string, 4) == 0)
 565                 r->ival = 1;
 566 }
 567
 568 void
 569 readfile(Node *r, Node *args)
 570 {
 571         Node res;
 572         int n, fd;
 573         char *buf;
 574         Dir *db;
 575
 576         if(args == 0)
 577                 error("readfile(filename): arg count");
 578         expr(args, &res);
 579         if(res.type != TSTRING)
 580                 error("readfile(filename): arg type");
 581
 582         fd = open(res.string->string, OREAD);
 583         if(fd < 0)
 584                 return;
 585
 586         db = dirfstat(fd);
 587         if(db == nil || db->length == 0)
 588                 n = 8192;
 589         else
 590                 n = db->length;
 591         free(db);
 592
 593         buf = malloc(n);
 594         n = read(fd, buf, n);
 595
 596         if(n > 0) {
 597                 r->op = OCONST;
 598                 r->type = TSTRING;
 599                 r->string = strnodlen(buf, n);
 600                 r->fmt = 's';
 601         }
 602         free(buf);
 603         close(fd);
 604 }
 605
 606 void
 607 getfile(Node *r, Node *args)
 608 {
 609         int n;
 610         char *p;
 611         Node res;
 612         String *s;
 613         Biobuf *bp;
 614         List **l, *new;
 615
 616         if(args == 0)
 617                 error("file(filename): arg count");
 618         expr(args, &res);
 619         if(res.type != TSTRING)
 620                 error("file(filename): arg type");
 621
 622         r->op = OCONST;
 623         r->type = TLIST;
 624         r->l = 0;
 625
 626         p = res.string->string;
 627         bp = Bopen(p, OREAD);
 628         if(bp == 0)
 629                 return;
 630
 631         l = &r->l;
 632         for(;;) {
 633                 p = Brdline(bp, '\n');
 634                 n = Blinelen(bp);
 635                 if(p == 0) {
 636                         if(n == 0)
 637                                 break;
 638                         s = strnodlen(0, n);
 639                         Bread(bp, s->string, n);
 640                 }
 641                 else
 642                         s = strnodlen(p, n-1);
 643
 644                 new = al(TSTRING);
 645                 new->string = s;
 646                 new->fmt = 's';
 647                 *l = new;
 648                 l = &new->next;
 649         }
 650         Bterm(bp);
 651 }
 652
 653 void
 654 cvtatof(Node *r, Node *args)
 655 {
 656         Node res;
 657
 658         if(args == 0)
 659                 error("atof(string): arg count");
 660         expr(args, &res);
 661         if(res.type != TSTRING)
 662                 error("atof(string): arg type");
 663
 664         r->op = OCONST;
 665         r->type = TFLOAT;
 666         r->fval = atof(res.string->string);
 667         r->fmt = 'f';
 668 }
 669
 670 void
 671 cvtatoi(Node *r, Node *args)
 672 {
 673         Node res;
 674
 675         if(args == 0)
 676                 error("atoi(string): arg count");
 677         expr(args, &res);
 678         if(res.type != TSTRING)
 679                 error("atoi(string): arg type");
 680
 681         r->op = OCONST;
 682         r->type = TINT;
 683         r->ival = strtoull(res.string->string, 0, 0);
 684         r->fmt = 'V';
 685 }
 686
 687 static char *fmtflags = "-0123456789. #,u";
 688 static char *fmtverbs = "bdox";
 689
 690 static int
 691 acidfmt(char *fmt, char *buf, int blen)
 692 {
 693         char *r, *w, *e;
 694
 695         w = buf;
 696         e = buf+blen;
 697         for(r=fmt; *r; r++){
 698                 if(w >= e)
 699                         return -1;
 700                 if(*r != '%'){
 701                         *w++ = *r;
 702                         continue;
 703                 }
 704                 if(*r == '%'){
 705                         *w++ = *r++;
 706                         if(*r == '%'){
 707                                 if(w >= e)
 708                                         return -1;
 709                                 *w++ = *r;
 710                                 continue;
 711                         }
 712                         while(*r && strchr(fmtflags, *r)){
 713                                 if(w >= e)
 714                                         return -1;
 715                                 *w++ = *r++;
 716                         }
 717                         if(*r == 0 || strchr(fmtverbs, *r) == nil)
 718                                 return -1;
 719                         if(w+3 > e)
 720                                 return -1;
 721                         *w++ = 'l';
 722                         *w++ = 'l';
 723                         *w++ = *r;
 724                 }
 725         }
 726         if(w >= e)
 727                 return -1;
 728         *w = 0;
 729
 730         return 0;
 731 }
 732
 733 void
 734 cvtitoa(Node *r, Node *args)
 735 {
 736         Node res;
 737         Node *av[Maxarg];
 738         vlong ival;
 739         char buf[128], fmt[32];
 740
 741         if(args == 0)
 742 err:
 743                 error("itoa(number [, fmt]): arg count");
 744         na = 0;
 745         flatten(av, args);
 746         if(na == 0 || na > 2)
 747                 goto err;
 748         expr(av[0], &res);
 749         if(res.type != TINT)
 750                 error("itoa(number [, fmt]): arg type");
 751         ival = res.ival;
 752         strncpy(fmt, "%lld", sizeof(fmt));
 753         if(na == 2){
 754                 expr(av[1], &res);
 755                 if(res.type != TSTRING)
 756                         error("itoa(number [, fmt]): fmt type");
 757                 if(acidfmt(res.string->string, fmt, sizeof(buf)))
 758                         error("itoa(number [, fmt]): malformed fmt");
 759         }
 760
 761         snprint(buf, sizeof(buf), fmt, ival);
 762         r->op = OCONST;
 763         r->type = TSTRING;
 764         r->string = strnode(buf);
 765         r->fmt = 's';
 766 }
 767
 768 List*
 769 mapent(Map *m)
 770 {
 771         int i;
 772         List *l, *n, **t, *h;
 773
 774         h = 0;
 775         t = &h;
 776         for(i = 0; i < m->nsegs; i++) {
 777                 if(m->seg[i].inuse == 0)
 778                         continue;
 779                 l = al(TSTRING);
 780                 n = al(TLIST);
 781                 n->l = l;
 782                 *t = n;
 783                 t = &n->next;
 784                 l->string = strnode(m->seg[i].name);
 785                 l->fmt = 's';
 786                 l->next = al(TINT);
 787                 l = l->next;
 788                 l->ival = m->seg[i].b;
 789                 l->fmt = 'W';
 790                 l->next = al(TINT);
 791                 l = l->next;
 792                 l->ival = m->seg[i].e;
 793                 l->fmt = 'W';
 794                 l->next = al(TINT);
 795                 l = l->next;
 796                 l->ival = m->seg[i].f;
 797                 l->fmt = 'W';
 798         }
 799         return h;
 800 }
 801
 802 void
 803 map(Node *r, Node *args)
 804 {
 805         int i;
 806         Map *m;
 807         List *l;
 808         char *ent;
 809         Node *av[Maxarg], res;
 810
 811         na = 0;
 812         flatten(av, args);
 813
 814         if(na != 0) {
 815                 expr(av[0], &res);
 816                 if(res.type != TLIST)
 817                         error("map(list): map needs a list");
 818                 if(listlen(res.l) != 4)
 819                         error("map(list): list must have 4 entries");
 820
 821                 l = res.l;
 822                 if(l->type != TSTRING)
 823                         error("map name must be a string");
 824                 ent = l->string->string;
 825                 m = symmap;
 826                 i = findseg(m, ent);
 827                 if(i < 0) {
 828                         m = cormap;
 829                         i = findseg(m, ent);
 830                 }
 831                 if(i < 0)
 832                         error("%s is not a map entry", ent);
 833                 l = l->next;
 834                 if(l->type != TINT)
 835                         error("map entry not int");
 836                 m->seg[i].b = l->ival;
 837                 if (strcmp(ent, "text") == 0)
 838                         textseg(l->ival, &fhdr);
 839                 l = l->next;
 840                 if(l->type != TINT)
 841                         error("map entry not int");
 842                 m->seg[i].e = l->ival;
 843                 l = l->next;
 844                 if(l->type != TINT)
 845                         error("map entry not int");
 846                 m->seg[i].f = l->ival;
 847         }
 848
 849         r->type = TLIST;
 850         r->l = 0;
 851         if(symmap)
 852                 r->l = mapent(symmap);
 853         if(cormap) {
 854                 if(r->l == 0)
 855                         r->l = mapent(cormap);
 856                 else {
 857                         for(l = r->l; l->next; l = l->next)
 858                                 ;
 859                         l->next = mapent(cormap);
 860                 }
 861         }
 862 }
 863
 864 void
 865 flatten(Node **av, Node *n)
 866 {
 867         if(n == 0)
 868                 return;
 869
 870         switch(n->op) {
 871         case OLIST:
 872                 flatten(av, n->left);
 873                 flatten(av, n->right);
 874                 break;
 875         default:
 876                 av[na++] = n;
 877                 if(na >= Maxarg)
 878                         error("too many function arguments");
 879                 break;
 880         }
 881 }
 882
 883 void
 884 strace(Node *r, Node *args)
 885 {
 886         Node *av[Maxarg], *n, res;
 887         uvlong pc, sp;
 888
 889         na = 0;
 890         flatten(av, args);
 891         if(na != 3)
 892                 error("strace(pc, sp, link): arg count");
 893
 894         n = av[0];
 895         expr(n, &res);
 896         if(res.type != TINT)
 897                 error("strace(pc, sp, link): pc bad type");
 898         pc = res.ival;
 899
 900         n = av[1];
 901         expr(n, &res);
 902         if(res.type != TINT)
 903                 error("strace(pc, sp, link): sp bad type");
 904         sp = res.ival;
 905
 906         n = av[2];
 907         expr(n, &res);
 908         if(res.type != TINT)
 909                 error("strace(pc, sp, link): link bad type");
 910
 911         tracelist = 0;
 912         if ((*machdata->ctrace)(cormap, pc, sp, res.ival, trlist) <= 0)
 913                 error("no stack frame: %r");
 914         r->type = TLIST;
 915         r->l = tracelist;
 916 }
 917
 918 void
 919 regerror(char *msg)
 920 {
 921         error(msg);
 922 }
 923
 924 void
 925 regexp(Node *r, Node *args)
 926 {
 927         Node res;
 928         Reprog *rp;
 929         Node *av[Maxarg];
 930
 931         na = 0;
 932         flatten(av, args);
 933         if(na != 2)
 934                 error("regexp(pattern, string): arg count");
 935         expr(av[0], &res);
 936         if(res.type != TSTRING)
 937                 error("regexp(pattern, string): pattern must be string");
 938         rp = regcomp(res.string->string);
 939         if(rp == 0)
 940                 return;
 941
 942         expr(av[1], &res);
 943         if(res.type != TSTRING)
 944                 error("regexp(pattern, string): bad string");
 945
 946         r->fmt = 'D';
 947         r->type = TINT;
 948         r->ival = regexec(rp, res.string->string, 0, 0);
 949         free(rp);
 950 }
 951
 952 void
 953 fmt(Node *r, Node *args)
 954 {
 955         Node res;
 956         Node *av[Maxarg];
 957
 958         na = 0;
 959         flatten(av, args);
 960         if(na != 2)
 961                 error("fmt(obj, fmt): arg count");
 962         expr(av[1], &res);
 963         if(res.type != TINT || strchr(vfmt, res.ival) == 0)
 964                 error("fmt(obj, fmt): bad format '%c'", (char)res.ival);
 965         expr(av[0], r);
 966         r->fmt = res.ival;
 967 }
 968
 969 void
 970 patom(char type, Store *res)
 971 {
 972         int i;
 973         char buf[512];
 974         extern char *typenames[];
 975
 976         switch(res->fmt) {
 977         case 'c':
 978                 Bprint(bout, "%c", (int)res->ival);
 979                 break;
 980         case 'C':
 981                 if(res->ival < ' ' || res->ival >= 0x7f)
 982                         Bprint(bout, "%3d", (int)res->ival&0xff);
 983                 else
 984                         Bprint(bout, "%3c", (int)res->ival);
 985                 break;
 986         case 'r':
 987                 Bprint(bout, "%C", (int)res->ival);
 988                 break;
 989         case 'B':
 990                 memset(buf, '0', 34);
 991                 buf[1] = 'b';
 992                 for(i = 0; i < 32; i++) {
 993                         if(res->ival & (1<<i))
 994                                 buf[33-i] = '1';
 995                 }
 996                 buf[35] = '\0';
 997                 Bprint(bout, "%s", buf);
 998                 break;
 999         case 'b':
1000                 Bprint(bout, "%.2x", (int)res->ival&0xff);
1001                 break;
1002         case 'X':
1003                 Bprint(bout, "%.8lux", (ulong)res->ival);
1004                 break;
1005         case 'x':
1006                 Bprint(bout, "%.4lux", (ulong)res->ival&0xffff);
1007                 break;
1008         case 'D':
1009                 Bprint(bout, "%d", (int)res->ival);
1010                 break;
1011         case 'd':
1012                 Bprint(bout, "%d", (ushort)res->ival);
1013                 break;
1014         case 'u':
1015                 Bprint(bout, "%d", (int)res->ival&0xffff);
1016                 break;
1017         case 'U':
1018                 Bprint(bout, "%lud", (ulong)res->ival);
1019                 break;
1020         case 'Z':
1021                 Bprint(bout, "%llud", res->ival);
1022                 break;
1023         case 'V':
1024                 Bprint(bout, "%lld", res->ival);
1025                 break;
1026         case 'W':
1027                 Bprint(bout, "%.8llux", res->ival);
1028                 break;
1029         case 'Y':
1030                 Bprint(bout, "%.16llux", res->ival);
1031                 break;
1032         case 'o':
1033                 Bprint(bout, "0%.11uo", (int)res->ival&0xffff);
1034                 break;
1035         case 'O':
1036                 Bprint(bout, "0%.6uo", (int)res->ival);
1037                 break;
1038         case 'q':
1039                 Bprint(bout, "0%.11o", (short)(res->ival&0xffff));
1040                 break;
1041         case 'Q':
1042                 Bprint(bout, "0%.6o", (int)res->ival);
1043                 break;
1044         case 'f':
1045         case 'F':
1046         case '3':
1047         case '8':
1048                 if(type != TFLOAT)
1049                         Bprint(bout, "*%c<%s>*", res->fmt, typenames[type]);
1050                 else
1051                         Bprint(bout, "%g", res->fval);
1052                 break;
1053         case 's':
1054         case 'g':
1055         case 'G':
1056                 if(type != TSTRING)
1057                         Bprint(bout, "*%c<%s>*", res->fmt, typenames[type]);
1058                 else
1059                         Bwrite(bout, res->string->string, res->string->len);
1060                 break;
1061         case 'R':
1062                 if(type != TSTRING)
1063                         Bprint(bout, "*%c<%s>*", res->fmt, typenames[type]);
1064                 else
1065                         Bprint(bout, "%S", (Rune*)res->string->string);
1066                 break;
1067         case 'a':
1068         case 'A':
1069                 symoff(buf, sizeof(buf), res->ival, CANY);
1070                 Bprint(bout, "%s", buf);
1071                 break;
1072         case 'I':
1073         case 'i':
1074                 if(type != TINT)
1075                         Bprint(bout, "*%c<%s>*", res->fmt, typenames[type]);
1076                 else {
1077                         if (symmap == nil || (*machdata->das)(symmap, res->ival, res->fmt, buf, sizeof(buf)) < 0)
1078                                 Bprint(bout, "no instruction");
1079                         else
1080                                 Bprint(bout, "%s", buf);
1081                 }
1082                 break;
1083         }
1084 }
1085
1086 void
1087 blprint(List *l)
1088 {
1089         Bprint(bout, "{");
1090         while(l) {
1091                 switch(l->type) {
1092                 default:
1093                         patom(l->type, &l->Store);
1094                         break;
1095                 case TSTRING:
1096                         Bputc(bout, '"');
1097                         patom(l->type, &l->Store);
1098                         Bputc(bout, '"');
1099                         break;
1100                 case TLIST:
1101                         blprint(l->l);
1102                         break;
1103                 case TCODE:
1104                         pcode(l->cc, 0);
1105                         break;
1106                 }
1107                 l = l->next;
1108                 if(l)
1109                         Bprint(bout, ", ");
1110         }
1111         Bprint(bout, "}");
1112 }
1113
1114 int
1115 comx(Node res)
1116 {
1117         Lsym *sl;
1118         Node *n, xx;
1119
1120         if(res.fmt != 'a' && res.fmt != 'A')
1121                 return 0;
1122
1123         if(res.comt == 0 || res.comt->base == 0)
1124                 return 0;
1125
1126         sl = res.comt->base;
1127         if(sl->proc) {
1128                 res.left = ZN;
1129                 res.right = ZN;
1130                 n = an(ONAME, ZN, ZN);
1131                 n->sym = sl;
1132                 n = an(OCALL, n, &res);
1133                         n->left->sym = sl;
1134                 expr(n, &xx);
1135                 return 1;
1136         }
1137         print("(%s)", sl->name);
1138         return 0;
1139 }
1140
1141 void
1142 bprint(Node *r, Node *args)
1143 {
1144         int i, nas;
1145         Node res, *av[Maxarg];
1146
1147         USED(r);
1148         na = 0;
1149         flatten(av, args);
1150         nas = na;
1151         for(i = 0; i < nas; i++) {
1152                 expr(av[i], &res);
1153                 switch(res.type) {
1154                 default:
1155                         if(comx(res))
1156                                 break;
1157                         patom(res.type, &res.Store);
1158                         break;
1159                 case TCODE:
1160                         pcode(res.cc, 0);
1161                         break;
1162                 case TLIST:
1163                         blprint(res.l);
1164                         break;
1165                 }
1166         }
1167         if(ret == 0)
1168                 Bputc(bout, '\n');
1169 }
1170
1171 void
1172 printto(Node *r, Node *args)
1173 {
1174         int fd;
1175         Biobuf *b;
1176         int i, nas;
1177         Node res, *av[Maxarg];
1178
1179         USED(r);
1180         na = 0;
1181         flatten(av, args);
1182         nas = na;
1183
1184         expr(av[0], &res);
1185         if(res.type != TSTRING)
1186                 error("printto(string, ...): need string");
1187
1188         fd = create(res.string->string, OWRITE, 0666);
1189         if(fd < 0)
1190                 fd = open(res.string->string, OWRITE);
1191         if(fd < 0)
1192                 error("printto: open %s: %r", res.string->string);
1193
1194         b = gmalloc(sizeof(Biobuf));
1195         Binit(b, fd, OWRITE);
1196
1197         Bflush(bout);
1198         io[iop++] = bout;
1199         bout = b;
1200
1201         for(i = 1; i < nas; i++) {
1202                 expr(av[i], &res);
1203                 switch(res.type) {
1204                 default:
1205                         if(comx(res))
1206                                 break;
1207                         patom(res.type, &res.Store);
1208                         break;
1209                 case TLIST:
1210                         blprint(res.l);
1211                         break;
1212                 }
1213         }
1214         if(ret == 0)
1215                 Bputc(bout, '\n');
1216
1217         Bterm(b);
1218         close(fd);
1219         free(b);
1220         bout = io[--iop];
1221 }
1222
1223 void
1224 pcfile(Node *r, Node *args)
1225 {
1226         Node res;
1227         char *p, buf[128];
1228
1229         if(args == 0)
1230                 error("pcfile(addr): arg count");
1231         expr(args, &res);
1232         if(res.type != TINT)
1233                 error("pcfile(addr): arg type");
1234
1235         r->type = TSTRING;
1236         r->fmt = 's';
1237         if(fileline(buf, sizeof(buf), res.ival) == 0) {
1238                 r->string = strnode("?file?");
1239                 return;
1240         }
1241         p = strrchr(buf, ':');
1242         if(p == 0)
1243                 error("pcfile(addr): funny file %s", buf);
1244         *p = '\0';
1245         r->string = strnode(buf);
1246 }
1247
1248 void
1249 pcline(Node *r, Node *args)
1250 {
1251         Node res;
1252         char *p, buf[128];
1253
1254         if(args == 0)
1255                 error("pcline(addr): arg count");
1256         expr(args, &res);
1257         if(res.type != TINT)
1258                 error("pcline(addr): arg type");
1259
1260         r->type = TINT;
1261         r->fmt = 'D';
1262         if(fileline(buf, sizeof(buf), res.ival) == 0) {
1263                 r->ival = 0;
1264                 return;
1265         }
1266
1267         p = strrchr(buf, ':');
1268         if(p == 0)
1269                 error("pcline(addr): funny file %s", buf);
1270         r->ival = strtol(p+1, 0, 0);
1271 }
1272
1273 void fmtof(Node *r, Node *args)
1274 {
1275         Node *av[Maxarg];
1276         Node res;
1277
1278         na = 0;
1279         flatten(av, args);
1280         if(na < 1)
1281                 error("fmtof(obj): no argument");
1282         if(na > 1)
1283                 error("fmtof(obj): too many arguments") ;
1284         expr(av[0], &res);
1285
1286         r->op = OCONST;
1287         r->type = TINT ;
1288         r->ival = res.fmt ;
1289         r->fmt = 'c';
1290 }
1291
1292 void dofmtsize(Node *r, Node *args)
1293 {
1294         Node *av[Maxarg];
1295         Node res;
1296         Store * s ;
1297         Value v ;
1298
1299         na = 0;
1300         flatten(av, args);
1301         if(na < 1)
1302                 error("fmtsize(obj): no argument");
1303         if(na > 1)
1304                 error("fmtsize(obj): too many arguments") ;
1305         expr(av[0], &res);
1306
1307         v.type = res.type ;
1308         s = &v.Store ;
1309         *s = res ;
1310
1311         r->op = OCONST;
1312         r->type = TINT ;
1313         r->ival = fmtsize(&v) ;
1314         r->fmt = 'D';
1315 }