sys/src/cmd/acme/ecmd.c

   1 #include <u.h>
   2 #include <libc.h>
   3 #include <draw.h>
   4 #include <thread.h>
   5 #include <cursor.h>
   6 #include <mouse.h>
   7 #include <keyboard.h>
   8 #include <frame.h>
   9 #include <fcall.h>
  10 #include <plumb.h>
  11 #include "dat.h"
  12 #include "edit.h"
  13 #include "fns.h"
  14
  15 int     Glooping;
  16 int     nest;
  17 char    Enoname[] = "no file name given";
  18
  19 Address addr;
  20 File    *menu;
  21 Rangeset        sel;
  22 extern  Text*   curtext;
  23 Rune    *collection;
  24 int     ncollection;
  25
  26 int     append(File*, Cmd*, long);
  27 int     pdisplay(File*);
  28 void    pfilename(File*);
  29 void    looper(File*, Cmd*, int);
  30 void    filelooper(Cmd*, int);
  31 void    linelooper(File*, Cmd*);
  32 Address lineaddr(long, Address, int);
  33 int     filematch(File*, String*);
  34 File    *tofile(String*);
  35 Rune*   cmdname(File *f, String *s, int);
  36 void    runpipe(Text*, int, Rune*, int, int);
  37
  38 void
  39 clearcollection(void)
  40 {
  41         free(collection);
  42         collection = nil;
  43         ncollection = 0;
  44 }
  45
  46 void
  47 resetxec(void)
  48 {
  49         Glooping = nest = 0;
  50         clearcollection();
  51 }
  52
  53 void
  54 mkaddr(Address *a, File *f)
  55 {
  56         a->r.q0 = f->curtext->q0;
  57         a->r.q1 = f->curtext->q1;
  58         a->f = f;
  59 }
  60
  61 int
  62 cmdexec(Text *t, Cmd *cp)
  63 {
  64         int i;
  65         Addr *ap;
  66         File *f;
  67         Window *w;
  68         Address dot;
  69
  70         if(t == nil)
  71                 w = nil;
  72         else
  73                 w = t->w;
  74         if(w==nil && (cp->addr==0 || cp->addr->type!='"') &&
  75             !utfrune("bBnqUXY!", cp->cmdc) &&
  76             !(cp->cmdc=='D' && cp->text))
  77                 editerror("no current window");
  78         i = cmdlookup(cp->cmdc);        /* will be -1 for '{' */
  79         f = nil;
  80         if(t && t->w){
  81                 t = &t->w->body;
  82                 f = t->file;
  83                 f->curtext = t;
  84         }
  85         if(i>=0 && cmdtab[i].defaddr != aNo){
  86                 if((ap=cp->addr)==0 && cp->cmdc!='\n'){
  87                         cp->addr = ap = newaddr();
  88                         ap->type = '.';
  89                         if(cmdtab[i].defaddr == aAll)
  90                                 ap->type = '*';
  91                 }else if(ap && ap->type=='"' && ap->next==0 && cp->cmdc!='\n'){
  92                         ap->next = newaddr();
  93                         ap->next->type = '.';
  94                         if(cmdtab[i].defaddr == aAll)
  95                                 ap->next->type = '*';
  96                 }
  97                 if(cp->addr){   /* may be false for '\n' (only) */
  98                         static Address none = {0,0,nil};
  99                         if(f){
 100                                 mkaddr(&dot, f);
 101                                 addr = cmdaddress(ap, dot, 0);
 102                         }else   /* a " */
 103                                 addr = cmdaddress(ap, none, 0);
 104                         f = addr.f;
 105                         t = f->curtext;
 106                 }
 107         }
 108         switch(cp->cmdc){
 109         case '{':
 110                 mkaddr(&dot, f);
 111                 if(cp->addr != nil)
 112                         dot = cmdaddress(cp->addr, dot, 0);
 113                 for(cp = cp->cmd; cp; cp = cp->next){
 114                         if(dot.r.q1 > t->file->nc)
 115                                 editerror("dot extends past end of buffer during { command");
 116                         t->q0 = dot.r.q0;
 117                         t->q1 = dot.r.q1;
 118                         cmdexec(t, cp);
 119                 }
 120                 break;
 121         default:
 122                 if(i < 0)
 123                         editerror("unknown command %c in cmdexec", cp->cmdc);
 124                 i = (*cmdtab[i].fn)(t, cp);
 125                 return i;
 126         }
 127         return 1;
 128 }
 129
 130 char*
 131 edittext(Window *w, int q, Rune *r, int nr)
 132 {
 133         File *f;
 134
 135         f = w->body.file;
 136         switch(editing){
 137         case Inactive:
 138                 return "permission denied";
 139         case Inserting:
 140                 eloginsert(f, q, r, nr);
 141                 return nil;
 142         case Collecting:
 143                 collection = runerealloc(collection, ncollection+nr+1);
 144                 runemove(collection+ncollection, r, nr);
 145                 ncollection += nr;
 146                 collection[ncollection] = '\0';
 147                 return nil;
 148         default:
 149                 return "unknown state in edittext";
 150         }
 151 }
 152
 153 /* string is known to be NUL-terminated */
 154 Rune*
 155 filelist(Text *t, Rune *r, int nr)
 156 {
 157         if(nr == 0)
 158                 return nil;
 159         r = skipbl(r, nr, &nr);
 160         if(r[0] != '<')
 161                 return runestrdup(r);
 162         /* use < command to collect text */
 163         clearcollection();
 164         runpipe(t, '<', r+1, nr-1, Collecting);
 165         return collection;
 166 }
 167
 168 int
 169 a_cmd(Text *t, Cmd *cp)
 170 {
 171         return append(t->file, cp, addr.r.q1);
 172 }
 173
 174 int
 175 b_cmd(Text*, Cmd *cp)
 176 {
 177         File *f;
 178
 179         f = tofile(cp->text);
 180         if(nest == 0)
 181                 pfilename(f);
 182         curtext = f->curtext;
 183         return TRUE;
 184 }
 185
 186 int
 187 B_cmd(Text *t, Cmd *cp)
 188 {
 189         Rune *list, *r, *s;
 190         int nr;
 191
 192         list = filelist(t, cp->text->r, cp->text->n);
 193         if(list == nil)
 194                 editerror(Enoname);
 195         r = list;
 196         nr = runestrlen(r);
 197         r = skipbl(r, nr, &nr);
 198         if(nr == 0)
 199                 new(t, t, nil, 0, 0, r, 0);
 200         else while(nr > 0){
 201                 s = findbl(r, nr, &nr);
 202                 *s = '\0';
 203                 new(t, t, nil, 0, 0, r, runestrlen(r));
 204                 if(nr > 0)
 205                         r = skipbl(s+1, nr-1, &nr);
 206         }
 207         clearcollection();
 208         return TRUE;
 209 }
 210
 211 int
 212 c_cmd(Text *t, Cmd *cp)
 213 {
 214         elogreplace(t->file, addr.r.q0, addr.r.q1, cp->text->r, cp->text->n);
 215         t->q0 = addr.r.q0;
 216         t->q1 = addr.r.q0;
 217         return TRUE;
 218 }
 219
 220 int
 221 d_cmd(Text *t, Cmd*)
 222 {
 223         if(addr.r.q1 > addr.r.q0)
 224                 elogdelete(t->file, addr.r.q0, addr.r.q1);
 225         t->q0 = addr.r.q0;
 226         t->q1 = addr.r.q0;
 227         return TRUE;
 228 }
 229
 230 void
 231 D1(Text *t)
 232 {
 233         if(t->w->body.file->ntext>1 || winclean(t->w, FALSE))
 234                 colclose(t->col, t->w, TRUE);
 235 }
 236
 237 int
 238 D_cmd(Text *t, Cmd *cp)
 239 {
 240         Rune *list, *r, *s, *n;
 241         int nr, nn;
 242         Window *w;
 243         Runestr dir, rs;
 244         char buf[128];
 245
 246         list = filelist(t, cp->text->r, cp->text->n);
 247         if(list == nil){
 248                 D1(t);
 249                 return TRUE;
 250         }
 251         dir = dirname(t, nil, 0);
 252         r = list;
 253         nr = runestrlen(r);
 254         r = skipbl(r, nr, &nr);
 255         do{
 256                 s = findbl(r, nr, &nr);
 257                 *s = '\0';
 258                 /* first time through, could be empty string, meaning delete file empty name */
 259                 nn = runestrlen(r);
 260                 if(r[0]=='/' || nn==0 || dir.nr==0){
 261                         rs.r = runestrdup(r);
 262                         rs.nr = nn;
 263                 }else{
 264                         n = runemalloc(dir.nr+1+nn);
 265                         runemove(n, dir.r, dir.nr);
 266                         n[dir.nr] = '/';
 267                         runemove(n+dir.nr+1, r, nn);
 268                         rs = cleanrname((Runestr){n, dir.nr+1+nn});
 269                 }
 270                 w = lookfile(rs.r, rs.nr);
 271                 if(w == nil){
 272                         snprint(buf, sizeof buf, "no such file %.*S", rs.nr, rs.r);
 273                         free(rs.r);
 274                         editerror(buf);
 275                 }
 276                 free(rs.r);
 277                 D1(&w->body);
 278                 if(nr > 0)
 279                         r = skipbl(s+1, nr-1, &nr);
 280         }while(nr > 0);
 281         clearcollection();
 282         free(dir.r);
 283         return TRUE;
 284 }
 285
 286 static int
 287 readloader(void *v, uint q0, Rune *r, int nr)
 288 {
 289         if(nr > 0)
 290                 eloginsert(v, q0, r, nr);
 291         return 0;
 292 }
 293
 294 int
 295 e_cmd(Text *t, Cmd *cp)
 296 {
 297         Rune *name;
 298         File *f;
 299         int i, isdir, q0, q1, fd, nulls, samename, allreplaced;
 300         char *s, tmp[128];
 301         Dir *d;
 302
 303         f = t->file;
 304         q0 = addr.r.q0;
 305         q1 = addr.r.q1;
 306         if(cp->cmdc == 'e'){
 307                 if(winclean(t->w, TRUE)==FALSE)
 308                         editerror("");  /* winclean generated message already */
 309                 q0 = 0;
 310                 q1 = f->nc;
 311         }
 312         allreplaced = (q0==0 && q1==f->nc);
 313         name = cmdname(f, cp->text, cp->cmdc=='e');
 314         if(name == nil)
 315                 editerror(Enoname);
 316         i = runestrlen(name);
 317         samename = runeeq(name, i, t->file->name, t->file->nname);
 318         s = runetobyte(name, i);
 319         free(name);
 320         fd = open(s, OREAD);
 321         if(fd < 0){
 322                 snprint(tmp, sizeof tmp, "can't open %s: %r", s);
 323                 free(s);
 324                 editerror(tmp);
 325         }
 326         d = dirfstat(fd);
 327         isdir = (d!=nil && (d->qid.type&QTDIR));
 328         free(d);
 329         if(isdir){
 330                 close(fd);
 331                 snprint(tmp, sizeof tmp, "%s is a directory", s);
 332                 free(s);
 333                 editerror(tmp);
 334         }
 335         elogdelete(f, q0, q1);
 336         nulls = 0;
 337         loadfile(fd, q1, &nulls, readloader, f);
 338         free(s);
 339         close(fd);
 340         if(nulls)
 341                 warning(nil, "%s: NUL bytes elided\n", s);
 342         else if(allreplaced && samename)
 343                 f->editclean = TRUE;
 344         return TRUE;
 345 }
 346
 347 int
 348 f_cmd(Text *t, Cmd *cp)
 349 {
 350         Rune *name;
 351         String *str;
 352         String empty;
 353
 354         if(cp->text == nil){
 355                 empty.n = 0;
 356                 empty.r = L"";
 357                 str = &empty;
 358         }else
 359                 str = cp->text;
 360         name = cmdname(t->file, str, TRUE);
 361         free(name);
 362         pfilename(t->file);
 363         return TRUE;
 364 }
 365
 366 int
 367 g_cmd(Text *t, Cmd *cp)
 368 {
 369         if(t->file != addr.f){
 370                 warning(nil, "internal error: g_cmd f!=addr.f\n");
 371                 return FALSE;
 372         }
 373         if(rxcompile(cp->re->r) == FALSE)
 374                 editerror("bad regexp in g command");
 375         if(rxexecute(t, nil, addr.r.q0, addr.r.q1, &sel) ^ cp->cmdc=='v'){
 376                 t->q0 = addr.r.q0;
 377                 t->q1 = addr.r.q1;
 378                 return cmdexec(t, cp->cmd);
 379         }
 380         return TRUE;
 381 }
 382
 383 int
 384 i_cmd(Text *t, Cmd *cp)
 385 {
 386         return append(t->file, cp, addr.r.q0);
 387 }
 388
 389 void
 390 copy(File *f, Address addr2)
 391 {
 392         long p;
 393         int ni;
 394         Rune *buf;
 395
 396         buf = fbufalloc();
 397         for(p=addr.r.q0; p<addr.r.q1; p+=ni){
 398                 ni = addr.r.q1-p;
 399                 if(ni > RBUFSIZE)
 400                         ni = RBUFSIZE;
 401                 bufread(f, p, buf, ni);
 402                 eloginsert(addr2.f, addr2.r.q1, buf, ni);
 403         }
 404         fbuffree(buf);
 405 }
 406
 407 void
 408 move(File *f, Address addr2)
 409 {
 410         if(addr.f!=addr2.f || addr.r.q1<=addr2.r.q0){
 411                 elogdelete(f, addr.r.q0, addr.r.q1);
 412                 copy(f, addr2);
 413         }else if(addr.r.q0 >= addr2.r.q1){
 414                 copy(f, addr2);
 415                 elogdelete(f, addr.r.q0, addr.r.q1);
 416         }else if(addr.r.q0==addr2.r.q0 && addr.r.q1==addr2.r.q1){
 417                 ;       /* move to self; no-op */
 418         }else
 419                 editerror("move overlaps itself");
 420 }
 421
 422 int
 423 m_cmd(Text *t, Cmd *cp)
 424 {
 425         Address dot, addr2;
 426
 427         mkaddr(&dot, t->file);
 428         addr2 = cmdaddress(cp->mtaddr, dot, 0);
 429         if(cp->cmdc == 'm')
 430                 move(t->file, addr2);
 431         else
 432                 copy(t->file, addr2);
 433         return TRUE;
 434 }
 435
 436 int
 437 p_cmd(Text *t, Cmd*)
 438 {
 439         return pdisplay(t->file);
 440 }
 441
 442 int
 443 s_cmd(Text *t, Cmd *cp)
 444 {
 445         int i, j, k, c, m, n, nrp, didsub;
 446         long p1, op, delta;
 447         String *buf;
 448         Rangeset *rp;
 449         char *err;
 450         Rune *rbuf;
 451
 452         n = cp->num;
 453         op= -1;
 454         if(rxcompile(cp->re->r) == FALSE)
 455                 editerror("bad regexp in s command");
 456         nrp = 0;
 457         rp = nil;
 458         delta = 0;
 459         didsub = FALSE;
 460         for(p1 = addr.r.q0; p1<=addr.r.q1 && rxexecute(t, nil, p1, addr.r.q1, &sel); ){
 461                 if(sel.r[0].q0 == sel.r[0].q1){ /* empty match? */
 462                         if(sel.r[0].q0 == op){
 463                                 p1++;
 464                                 continue;
 465                         }
 466                         p1 = sel.r[0].q1+1;
 467                 }else
 468                         p1 = sel.r[0].q1;
 469                 op = sel.r[0].q1;
 470                 if(--n>0)
 471                         continue;
 472                 nrp++;
 473                 rp = erealloc(rp, nrp*sizeof(Rangeset));
 474                 rp[nrp-1] = sel;
 475         }
 476         rbuf = fbufalloc();
 477         buf = allocstring(0);
 478         for(m=0; m<nrp; m++){
 479                 buf->n = 0;
 480                 buf->r[0] = L'\0';
 481                 sel = rp[m];
 482                 for(i = 0; i<cp->text->n; i++)
 483                         if((c = cp->text->r[i])=='\\' && i<cp->text->n-1){
 484                                 c = cp->text->r[++i];
 485                                 if('1'<=c && c<='9') {
 486                                         j = c-'0';
 487                                         if(sel.r[j].q1-sel.r[j].q0>RBUFSIZE){
 488                                                 err = "replacement string too long";
 489                                                 goto Err;
 490                                         }
 491                                         bufread(t->file, sel.r[j].q0, rbuf, sel.r[j].q1-sel.r[j].q0);
 492                                         for(k=0; k<sel.r[j].q1-sel.r[j].q0; k++)
 493                                                 Straddc(buf, rbuf[k]);
 494                                 }else
 495                                         Straddc(buf, c);
 496                         }else if(c!='&')
 497                                 Straddc(buf, c);
 498                         else{
 499                                 if(sel.r[0].q1-sel.r[0].q0>RBUFSIZE){
 500                                         err = "right hand side too long in substitution";
 501                                         goto Err;
 502                                 }
 503                                 bufread(t->file, sel.r[0].q0, rbuf, sel.r[0].q1-sel.r[0].q0);
 504                                 for(k=0; k<sel.r[0].q1-sel.r[0].q0; k++)
 505                                         Straddc(buf, rbuf[k]);
 506                         }
 507                 elogreplace(t->file, sel.r[0].q0, sel.r[0].q1,  buf->r, buf->n);
 508                 delta -= sel.r[0].q1-sel.r[0].q0;
 509                 delta += buf->n;
 510                 didsub = 1;
 511                 if(!cp->flag)
 512                         break;
 513         }
 514         free(rp);
 515         freestring(buf);
 516         fbuffree(rbuf);
 517         if(!didsub && nest==0)
 518                 editerror("no substitution");
 519         t->q0 = addr.r.q0;
 520         t->q1 = addr.r.q1;
 521         return TRUE;
 522
 523 Err:
 524         free(rp);
 525         freestring(buf);
 526         fbuffree(rbuf);
 527         editerror(err);
 528         return FALSE;
 529 }
 530
 531 int
 532 u_cmd(Text *t, Cmd *cp)
 533 {
 534         int n, oseq, flag;
 535
 536         n = cp->num;
 537         flag = TRUE;
 538         if(n < 0){
 539                 n = -n;
 540                 flag = FALSE;
 541         }
 542         oseq = -1;
 543         while(n-->0 && t->file->seq!=0 && t->file->seq!=oseq){
 544                 oseq = t->file->seq;
 545                 undo(t, nil, nil, flag, 0, nil, 0);
 546         }
 547         return TRUE;
 548 }
 549
 550 int
 551 w_cmd(Text *t, Cmd *cp)
 552 {
 553         Rune *r;
 554         File *f;
 555
 556         f = t->file;
 557         if(f->seq == seq)
 558                 editerror("can't write file with pending modifications");
 559         r = cmdname(f, cp->text, FALSE);
 560         if(r == nil)
 561                 editerror("no name specified for 'w' command");
 562         putfile(f, addr.r.q0, addr.r.q1, r, runestrlen(r));
 563         /* r is freed by putfile */
 564         return TRUE;
 565 }
 566
 567 int
 568 x_cmd(Text *t, Cmd *cp)
 569 {
 570         if(cp->re)
 571                 looper(t->file, cp, cp->cmdc=='x');
 572         else
 573                 linelooper(t->file, cp);
 574         return TRUE;
 575 }
 576
 577 int
 578 X_cmd(Text*, Cmd *cp)
 579 {
 580         filelooper(cp, cp->cmdc=='X');
 581         return TRUE;
 582 }
 583
 584 void
 585 runpipe(Text *t, int cmd, Rune *cr, int ncr, int state)
 586 {
 587         Rune *r, *s;
 588         int n;
 589         Runestr dir;
 590         Window *w;
 591
 592         r = skipbl(cr, ncr, &n);
 593         if(n == 0)
 594                 editerror("no command specified for %c", cmd);
 595         w = nil;
 596         if(state == Inserting){
 597                 w = t->w;
 598                 t->q0 = addr.r.q0;
 599                 t->q1 = addr.r.q1;
 600                 if(cmd == '<' || cmd=='|')
 601                         elogdelete(t->file, t->q0, t->q1);
 602         }
 603         s = runemalloc(n+2);
 604         s[0] = cmd;
 605         runemove(s+1, r, n);
 606         n++;
 607         dir.r = nil;
 608         dir.nr = 0;
 609         if(t != nil)
 610                 dir = dirname(t, nil, 0);
 611         if(dir.nr==1 && dir.r[0]=='.'){ /* sigh */
 612                 free(dir.r);
 613                 dir.r = nil;
 614                 dir.nr = 0;
 615         }
 616         editing = state;
 617         if(t!=nil && t->w!=nil)
 618                 incref(t->w);   /* run will decref */
 619         run(w, runetobyte(s, n), dir.r, dir.nr, TRUE, nil, nil, TRUE);
 620         free(s);
 621         if(t!=nil && t->w!=nil)
 622                 winunlock(t->w);
 623         qunlock(&row);
 624         recvul(cedit);
 625         qlock(&row);
 626         editing = Inactive;
 627         if(t!=nil && t->w!=nil)
 628                 winlock(t->w, 'M');
 629 }
 630
 631 int
 632 pipe_cmd(Text *t, Cmd *cp)
 633 {
 634         runpipe(t, cp->cmdc, cp->text->r, cp->text->n, Inserting);
 635         return TRUE;
 636 }
 637
 638 long
 639 nlcount(Text *t, long q0, long q1)
 640 {
 641         long nl;
 642         Rune *buf;
 643         int i, nbuf;
 644
 645         buf = fbufalloc();
 646         nbuf = 0;
 647         i = nl = 0;
 648         while(q0 < q1){
 649                 if(i == nbuf){
 650                         nbuf = q1-q0;
 651                         if(nbuf > RBUFSIZE)
 652                                 nbuf = RBUFSIZE;
 653                         bufread(t->file, q0, buf, nbuf);
 654                         i = 0;
 655                 }
 656                 if(buf[i++] == '\n')
 657                         nl++;
 658                 q0++;
 659         }
 660         fbuffree(buf);
 661         return nl;
 662 }
 663
 664 void
 665 printposn(Text *t, int charsonly)
 666 {
 667         long l1, l2;
 668
 669         if (t != nil && t->file != nil && t->file->name != nil)
 670                 warning(nil, "%.*S:", t->file->nname, t->file->name);
 671         if(!charsonly){
 672                 l1 = 1+nlcount(t, 0, addr.r.q0);
 673                 l2 = l1+nlcount(t, addr.r.q0, addr.r.q1);
 674                 /* check if addr ends with '\n' */
 675                 if(addr.r.q1>0 && addr.r.q1>addr.r.q0 && textreadc(t, addr.r.q1-1)=='\n')
 676                         --l2;
 677                 warning(nil, "%lud", l1);
 678                 if(l2 != l1)
 679                         warning(nil, ",%lud", l2);
 680                 warning(nil, "\n");
 681                 return;
 682         }
 683         warning(nil, "#%d", addr.r.q0);
 684         if(addr.r.q1 != addr.r.q0)
 685                 warning(nil, ",#%d", addr.r.q1);
 686         warning(nil, "\n");
 687 }
 688
 689 int
 690 eq_cmd(Text *t, Cmd *cp)
 691 {
 692         int charsonly;
 693
 694         switch(cp->text->n){
 695         case 0:
 696                 charsonly = FALSE;
 697                 break;
 698         case 1:
 699                 if(cp->text->r[0] == '#'){
 700                         charsonly = TRUE;
 701                         break;
 702                 }
 703         default:
 704                 SET(charsonly);
 705                 editerror("newline expected");
 706         }
 707         printposn(t, charsonly);
 708         return TRUE;
 709 }
 710
 711 int
 712 nl_cmd(Text *t, Cmd *cp)
 713 {
 714         Address a;
 715         File *f;
 716
 717         f = t->file;
 718         if(cp->addr == 0){
 719                 /* First put it on newline boundaries */
 720                 mkaddr(&a, f);
 721                 addr = lineaddr(0, a, -1);
 722                 a = lineaddr(0, a, 1);
 723                 addr.r.q1 = a.r.q1;
 724                 if(addr.r.q0==t->q0 && addr.r.q1==t->q1){
 725                         mkaddr(&a, f);
 726                         addr = lineaddr(1, a, 1);
 727                 }
 728         }
 729         textshow(t, addr.r.q0, addr.r.q1, 1);
 730         return TRUE;
 731 }
 732
 733 int
 734 append(File *f, Cmd *cp, long p)
 735 {
 736         if(cp->text->n > 0)
 737                 eloginsert(f, p, cp->text->r, cp->text->n);
 738         f->curtext->q0 = p;
 739         f->curtext->q1 = p;
 740         return TRUE;
 741 }
 742
 743 int
 744 pdisplay(File *f)
 745 {
 746         long p1, p2;
 747         int np;
 748         Rune *buf;
 749
 750         p1 = addr.r.q0;
 751         p2 = addr.r.q1;
 752         if(p2 > f->nc)
 753                 p2 = f->nc;
 754         buf = fbufalloc();
 755         while(p1 < p2){
 756                 np = p2-p1;
 757                 if(np>RBUFSIZE-1)
 758                         np = RBUFSIZE-1;
 759                 bufread(f, p1, buf, np);
 760                 buf[np] = L'\0';
 761                 warning(nil, "%S", buf);
 762                 p1 += np;
 763         }
 764         fbuffree(buf);
 765         f->curtext->q0 = addr.r.q0;
 766         f->curtext->q1 = addr.r.q1;
 767         return TRUE;
 768 }
 769
 770 void
 771 pfilename(File *f)
 772 {
 773         int dirty;
 774         Window *w;
 775
 776         w = f->curtext->w;
 777         /* same check for dirty as in settag, but we know ncache==0 */
 778         dirty = !w->isdir && !w->isscratch && f->mod;
 779         warning(nil, "%c%c%c %.*S\n", " '"[dirty],
 780                 '+', " ."[curtext!=nil && curtext->file==f], f->nname, f->name);
 781 }
 782
 783 void
 784 loopcmd(File *f, Cmd *cp, Range *rp, long nrp)
 785 {
 786         long i;
 787
 788         for(i=0; i<nrp; i++){
 789                 f->curtext->q0 = rp[i].q0;
 790                 f->curtext->q1 = rp[i].q1;
 791                 cmdexec(f->curtext, cp);
 792         }
 793 }
 794
 795 void
 796 looper(File *f, Cmd *cp, int xy)
 797 {
 798         long p, op, nrp;
 799         Range r, tr;
 800         Range *rp;
 801
 802         r = addr.r;
 803         op= xy? -1 : r.q0;
 804         nest++;
 805         if(rxcompile(cp->re->r) == FALSE)
 806                 editerror("bad regexp in %c command", cp->cmdc);
 807         nrp = 0;
 808         rp = nil;
 809         for(p = r.q0; p<=r.q1; ){
 810                 if(!rxexecute(f->curtext, nil, p, r.q1, &sel)){ /* no match, but y should still run */
 811                         if(xy || op>r.q1)
 812                                 break;
 813                         tr.q0 = op, tr.q1 = r.q1;
 814                         p = r.q1+1;     /* exit next loop */
 815                 }else{
 816                         if(sel.r[0].q0==sel.r[0].q1){   /* empty match? */
 817                                 if(sel.r[0].q0==op){
 818                                         p++;
 819                                         continue;
 820                                 }
 821                                 p = sel.r[0].q1+1;
 822                         }else
 823                                 p = sel.r[0].q1;
 824                         if(xy)
 825                                 tr = sel.r[0];
 826                         else
 827                                 tr.q0 = op, tr.q1 = sel.r[0].q0;
 828                 }
 829                 op = sel.r[0].q1;
 830                 nrp++;
 831                 rp = erealloc(rp, nrp*sizeof(Range));
 832                 rp[nrp-1] = tr;
 833         }
 834         loopcmd(f, cp->cmd, rp, nrp);
 835         free(rp);
 836         --nest;
 837 }
 838
 839 void
 840 linelooper(File *f, Cmd *cp)
 841 {
 842         long nrp, p;
 843         Range r, linesel;
 844         Address a, a3;
 845         Range *rp;
 846
 847         nest++;
 848         nrp = 0;
 849         rp = nil;
 850         r = addr.r;
 851         a3.f = f;
 852         a3.r.q0 = a3.r.q1 = r.q0;
 853         a = lineaddr(0, a3, 1);
 854         linesel = a.r;
 855         for(p = r.q0; p<r.q1; p = a3.r.q1){
 856                 a3.r.q0 = a3.r.q1;
 857                 if(p!=r.q0 || linesel.q1==p){
 858                         a = lineaddr(1, a3, 1);
 859                         linesel = a.r;
 860                 }
 861                 if(linesel.q0 >= r.q1)
 862                         break;
 863                 if(linesel.q1 >= r.q1)
 864                         linesel.q1 = r.q1;
 865                 if(linesel.q1 > linesel.q0)
 866                         if(linesel.q0>=a3.r.q1 && linesel.q1>a3.r.q1){
 867                                 a3.r = linesel;
 868                                 nrp++;
 869                                 rp = erealloc(rp, nrp*sizeof(Range));
 870                                 rp[nrp-1] = linesel;
 871                                 continue;
 872                         }
 873                 break;
 874         }
 875         loopcmd(f, cp->cmd, rp, nrp);
 876         free(rp);
 877         --nest;
 878 }
 879
 880 struct Looper
 881 {
 882         Cmd *cp;
 883         int     XY;
 884         Window  **w;
 885         int     nw;
 886 } loopstruct;   /* only one; X and Y can't nest */
 887
 888 void
 889 alllooper(Window *w, void *v)
 890 {
 891         Text *t;
 892         struct Looper *lp;
 893         Cmd *cp;
 894
 895         lp = v;
 896         cp = lp->cp;
 897 //      if(w->isscratch || w->isdir)
 898 //              return;
 899         t = &w->body;
 900         /* only use this window if it's the current window for the file */
 901         if(t->file->curtext != t)
 902                 return;
 903 //      if(w->nopen[QWevent] > 0)
 904 //              return;
 905         /* no auto-execute on files without names */
 906         if(cp->re==nil && t->file->nname==0)
 907                 return;
 908         if(cp->re==nil || filematch(t->file, cp->re)==lp->XY){
 909                 lp->w = erealloc(lp->w, (lp->nw+1)*sizeof(Window*));
 910                 lp->w[lp->nw++] = w;
 911         }
 912 }
 913
 914 void
 915 alllocker(Window *w, void *v)
 916 {
 917         if(v)
 918                 incref(w);
 919         else
 920                 winclose(w);
 921 }
 922
 923 void
 924 filelooper(Cmd *cp, int XY)
 925 {
 926         int i;
 927
 928         if(Glooping++)
 929                 editerror("can't nest %c command", "YX"[XY]);
 930         nest++;
 931
 932         loopstruct.cp = cp;
 933         loopstruct.XY = XY;
 934         if(loopstruct.w)        /* error'ed out last time */
 935                 free(loopstruct.w);
 936         loopstruct.w = nil;
 937         loopstruct.nw = 0;
 938         allwindows(alllooper, &loopstruct);
 939         /*
 940          * add a ref to all windows to keep safe windows accessed by X
 941          * that would not otherwise have a ref to hold them up during
 942          * the shenanigans.  note this with globalincref so that any
 943          * newly created windows start with an extra reference.
 944          */
 945         allwindows(alllocker, (void*)1);
 946         globalincref = 1;
 947         for(i=0; i<loopstruct.nw; i++)
 948                 cmdexec(&loopstruct.w[i]->body, cp->cmd);
 949         allwindows(alllocker, (void*)0);
 950         globalincref = 0;
 951         free(loopstruct.w);
 952         loopstruct.w = nil;
 953
 954         --Glooping;
 955         --nest;
 956 }
 957
 958 void
 959 nextmatch(File *f, String *r, long p, int sign)
 960 {
 961         if(rxcompile(r->r) == FALSE)
 962                 editerror("bad regexp in command address");
 963         if(sign >= 0){
 964                 if(!rxexecute(f->curtext, nil, p, 0x7FFFFFFFL, &sel))
 965                         editerror("no match for regexp");
 966                 if(sel.r[0].q0==sel.r[0].q1 && sel.r[0].q0==p){
 967                         if(++p>f->nc)
 968                                 p = 0;
 969                         if(!rxexecute(f->curtext, nil, p, 0x7FFFFFFFL, &sel))
 970                                 editerror("address");
 971                 }
 972         }else{
 973                 if(!rxbexecute(f->curtext, p, &sel))
 974                         editerror("no match for regexp");
 975                 if(sel.r[0].q0==sel.r[0].q1 && sel.r[0].q1==p){
 976                         if(--p<0)
 977                                 p = f->nc;
 978                         if(!rxbexecute(f->curtext, p, &sel))
 979                                 editerror("address");
 980                 }
 981         }
 982 }
 983
 984 File    *matchfile(String*);
 985 Address charaddr(long, Address, int);
 986 Address lineaddr(long, Address, int);
 987
 988 Address
 989 cmdaddress(Addr *ap, Address a, int sign)
 990 {
 991         File *f = a.f;
 992         Address a1, a2;
 993
 994         do{
 995                 switch(ap->type){
 996                 case 'l':
 997                 case '#':
 998                         a = (*(ap->type=='#'?charaddr:lineaddr))(ap->num, a, sign);
 999                         break;
1000
1001                 case '.':
1002                         mkaddr(&a, f);
1003                         break;
1004
1005                 case '$':
1006                         a.r.q0 = a.r.q1 = f->nc;
1007                         break;
1008
1009                 case '\'':
1010 editerror("can't handle '");
1011 //                      a.r = f->mark;
1012                         break;
1013
1014                 case '?':
1015                         sign = -sign;
1016                         if(sign == 0)
1017                                 sign = -1;
1018                         /* fall through */
1019                 case '/':
1020                         nextmatch(f, ap->re, sign>=0? a.r.q1 : a.r.q0, sign);
1021                         a.r = sel.r[0];
1022                         break;
1023
1024                 case '"':
1025                         f = matchfile(ap->re);
1026                         mkaddr(&a, f);
1027                         break;
1028
1029                 case '*':
1030                         a.r.q0 = 0, a.r.q1 = f->nc;
1031                         return a;
1032
1033                 case ',':
1034                 case ';':
1035                         if(ap->left)
1036                                 a1 = cmdaddress(ap->left, a, 0);
1037                         else
1038                                 a1.f = a.f, a1.r.q0 = a1.r.q1 = 0;
1039                         if(ap->type == ';'){
1040                                 f = a1.f;
1041                                 a = a1;
1042                                 f->curtext->q0 = a1.r.q0;
1043                                 f->curtext->q1 = a1.r.q1;
1044                         }
1045                         if(ap->next)
1046                                 a2 = cmdaddress(ap->next, a, 0);
1047                         else
1048                                 a2.f = a.f, a2.r.q0 = a2.r.q1 = f->nc;
1049                         if(a1.f != a2.f)
1050                                 editerror("addresses in different files");
1051                         a.f = a1.f, a.r.q0 = a1.r.q0, a.r.q1 = a2.r.q1;
1052                         if(a.r.q1 < a.r.q0)
1053                                 editerror("addresses out of order");
1054                         return a;
1055
1056                 case '+':
1057                 case '-':
1058                         sign = 1;
1059                         if(ap->type == '-')
1060                                 sign = -1;
1061                         if(ap->next==0 || ap->next->type=='+' || ap->next->type=='-')
1062                                 a = lineaddr(1L, a, sign);
1063                         break;
1064                 default:
1065                         error("cmdaddress");
1066                         return a;
1067                 }
1068         }while(ap = ap->next);  /* assign = */
1069         return a;
1070 }
1071
1072 struct Tofile{
1073         File            *f;
1074         String  *r;
1075 };
1076
1077 void
1078 alltofile(Window *w, void *v)
1079 {
1080         Text *t;
1081         struct Tofile *tp;
1082
1083         tp = v;
1084         if(tp->f != nil)
1085                 return;
1086         if(w->isscratch || w->isdir)
1087                 return;
1088         t = &w->body;
1089         /* only use this window if it's the current window for the file */
1090         if(t->file->curtext != t)
1091                 return;
1092 //      if(w->nopen[QWevent] > 0)
1093 //              return;
1094         if(runeeq(tp->r->r, tp->r->n, t->file->name, t->file->nname))
1095                 tp->f = t->file;
1096 }
1097
1098 File*
1099 tofile(String *r)
1100 {
1101         struct Tofile t;
1102         String rr;
1103
1104         rr.r = skipbl(r->r, r->n, &rr.n);
1105         t.f = nil;
1106         t.r = &rr;
1107         allwindows(alltofile, &t);
1108         if(t.f == nil)
1109                 editerror("no such file\"%S\"", rr.r);
1110         return t.f;
1111 }
1112
1113 void
1114 allmatchfile(Window *w, void *v)
1115 {
1116         struct Tofile *tp;
1117         Text *t;
1118
1119         tp = v;
1120         if(w->isscratch || w->isdir)
1121                 return;
1122         t = &w->body;
1123         /* only use this window if it's the current window for the file */
1124         if(t->file->curtext != t)
1125                 return;
1126 //      if(w->nopen[QWevent] > 0)
1127 //              return;
1128         if(filematch(w->body.file, tp->r)){
1129                 if(tp->f != nil)
1130                         editerror("too many files match \"%S\"", tp->r->r);
1131                 tp->f = w->body.file;
1132         }
1133 }
1134
1135 File*
1136 matchfile(String *r)
1137 {
1138         struct Tofile tf;
1139
1140         tf.f = nil;
1141         tf.r = r;
1142         allwindows(allmatchfile, &tf);
1143
1144         if(tf.f == nil)
1145                 editerror("no file matches \"%S\"", r->r);
1146         return tf.f;
1147 }
1148
1149 int
1150 filematch(File *f, String *r)
1151 {
1152         char *buf;
1153         Rune *rbuf;
1154         Window *w;
1155         int match, i, dirty;
1156         Rangeset s;
1157
1158         /* compile expr first so if we get an error, we haven't allocated anything */
1159         if(rxcompile(r->r) == FALSE)
1160                 editerror("bad regexp in file match");
1161         buf = fbufalloc();
1162         w = f->curtext->w;
1163         /* same check for dirty as in settag, but we know ncache==0 */
1164         dirty = !w->isdir && !w->isscratch && f->mod;
1165         snprint(buf, BUFSIZE, "%c%c%c %.*S\n", " '"[dirty],
1166                 '+', " ."[curtext!=nil && curtext->file==f], f->nname, f->name);
1167         rbuf = bytetorune(buf, &i);
1168         fbuffree(buf);
1169         match = rxexecute(nil, rbuf, 0, i, &s);
1170         free(rbuf);
1171         return match;
1172 }
1173
1174 Address
1175 charaddr(long l, Address addr, int sign)
1176 {
1177         if(sign == 0)
1178                 addr.r.q0 = addr.r.q1 = l;
1179         else if(sign < 0)
1180                 addr.r.q1 = addr.r.q0 -= l;
1181         else if(sign > 0)
1182                 addr.r.q0 = addr.r.q1 += l;
1183         if(addr.r.q0<0 || addr.r.q1>addr.f->nc)
1184                 editerror("address out of range");
1185         return addr;
1186 }
1187
1188 Address
1189 lineaddr(long l, Address addr, int sign)
1190 {
1191         int n;
1192         int c;
1193         File *f = addr.f;
1194         Address a;
1195         long p;
1196
1197         a.f = f;
1198         if(sign >= 0){
1199                 if(l == 0){
1200                         if(sign==0 || addr.r.q1==0){
1201                                 a.r.q0 = a.r.q1 = 0;
1202                                 return a;
1203                         }
1204                         a.r.q0 = addr.r.q1;
1205                         p = addr.r.q1-1;
1206                 }else{
1207                         if(sign==0 || addr.r.q1==0){
1208                                 p = 0;
1209                                 n = 1;
1210                         }else{
1211                                 p = addr.r.q1-1;
1212                                 n = textreadc(f->curtext, p++)=='\n';
1213                         }
1214                         while(n < l){
1215                                 if(p >= f->nc)
1216                                         editerror("address out of range");
1217                                 if(textreadc(f->curtext, p++) == '\n')
1218                                         n++;
1219                         }
1220                         a.r.q0 = p;
1221                 }
1222                 while(p < f->nc && textreadc(f->curtext, p++)!='\n')
1223                         ;
1224                 a.r.q1 = p;
1225         }else{
1226                 p = addr.r.q0;
1227                 if(l == 0)
1228                         a.r.q1 = addr.r.q0;
1229                 else{
1230                         for(n = 0; n<l; ){      /* always runs once */
1231                                 if(p == 0){
1232                                         if(++n != l)
1233                                                 editerror("address out of range");
1234                                 }else{
1235                                         c = textreadc(f->curtext, p-1);
1236                                         if(c != '\n' || ++n != l)
1237                                                 p--;
1238                                 }
1239                         }
1240                         a.r.q1 = p;
1241                         if(p > 0)
1242                                 p--;
1243                 }
1244                 while(p > 0 && textreadc(f->curtext, p-1)!='\n')        /* lines start after a newline */
1245                         p--;
1246                 a.r.q0 = p;
1247         }
1248         return a;
1249 }
1250
1251 struct Filecheck
1252 {
1253         File    *f;
1254         Rune    *r;
1255         int nr;
1256 };
1257
1258 void
1259 allfilecheck(Window *w, void *v)
1260 {
1261         struct Filecheck *fp;
1262         File *f;
1263
1264         fp = v;
1265         f = w->body.file;
1266         if(w->body.file == fp->f)
1267                 return;
1268         if(runeeq(fp->r, fp->nr, f->name, f->nname))
1269                 warning(nil, "warning: duplicate file name \"%.*S\"\n", fp->nr, fp->r);
1270 }
1271
1272 Rune*
1273 cmdname(File *f, String *str, int set)
1274 {
1275         Rune *r, *s;
1276         int n;
1277         struct Filecheck fc;
1278         Runestr newname;
1279
1280         r = nil;
1281         n = str->n;
1282         s = str->r;
1283         if(n == 0){
1284                 /* no name; use existing */
1285                 if(f->nname == 0)
1286                         return nil;
1287                 r = runemalloc(f->nname+1);
1288                 runemove(r, f->name, f->nname);
1289                 return r;
1290         }
1291         s = skipbl(s, n, &n);
1292         if(n == 0)
1293                 goto Return;
1294
1295         if(s[0] == '/'){
1296                 r = runemalloc(n+1);
1297                 runemove(r, s, n);
1298         }else{
1299                 newname = dirname(f->curtext, runestrdup(s), n);
1300                 n = newname.nr;
1301                 r = runemalloc(n+1);    /* NUL terminate */
1302                 runemove(r, newname.r, n);
1303                 free(newname.r);
1304         }
1305         fc.f = f;
1306         fc.r = r;
1307         fc.nr = n;
1308         allwindows(allfilecheck, &fc);
1309         if(f->nname == 0)
1310                 set = TRUE;
1311
1312     Return:
1313         if(set && !runeeq(r, n, f->name, f->nname)){
1314                 filemark(f);
1315                 f->mod = TRUE;
1316                 f->curtext->w->dirty = TRUE;
1317                 winsetname(f->curtext->w, r, n);
1318         }
1319         return r;
1320 }