user/elvis-tiny/vcmd.c

   1 /* vcmd.c */
   2
   3 /* Author:
   4  *      Steve Kirkendall
   5  *      14407 SW Teal Blvd. #C
   6  *      Beaverton, OR 97005
   7  *      kirkenda@cs.pdx.edu
   8  */
   9
  10
  11 /* This file contains the functions that handle VI commands */
  12
  13
  14 #include "config.h"
  15 #include "vi.h"
  16 #if MSDOS
  17 #include <process.h>
  18 #include <string.h>
  19 #endif
  20 #if TOS
  21 #include <osbind.h>
  22 #include <string.h>
  23 #endif
  24 #if OSK
  25 # include <stdio.h>
  26 #endif
  27
  28
  29 /* This function puts the editor in EX mode */
  30 MARK v_quit()
  31 {
  32         move(LINES - 1, 0);
  33         mode = MODE_EX;
  34         return cursor;
  35 }
  36
  37 /* This function causes the screen to be redrawn */
  38 MARK v_redraw()
  39 {
  40         redraw(MARK_UNSET, FALSE);
  41         return cursor;
  42 }
  43
  44 /* This function executes a single EX command, and waits for a user keystroke
  45  * before returning to the VI screen.  If that keystroke is another ':', then
  46  * another EX command is read and executed.
  47  */
  48 /*ARGSUSED*/
  49 MARK v_1ex(m, text)
  50         MARK    m;      /* the current line */
  51         char    *text;  /* the first command to execute */
  52 {
  53         /* run the command.  be careful about modes & output */
  54         exwrote = (mode == MODE_COLON);
  55         doexcmd(text);
  56         exrefresh();
  57
  58         /* if mode is no longer MODE_VI, then we should quit right away! */
  59         if (mode != MODE_VI && mode != MODE_COLON)
  60                 return cursor;
  61
  62         /* The command did some output.  Wait for a keystoke. */
  63         if (exwrote)
  64         {
  65                 mode = MODE_VI;
  66                 msg("[Hit <RETURN> to continue]");
  67                 if (getkey(0) == ':')
  68                 {       mode = MODE_COLON;
  69                         addch('\n');
  70                 }
  71                 else
  72                         redraw(MARK_UNSET, FALSE);
  73         }
  74
  75         return cursor;
  76 }
  77
  78 /* This function undoes the last change */
  79 /*ARGSUSED*/
  80 MARK v_undo(m)
  81         MARK    m;      /* (ignored) */
  82 {
  83         if (undo())
  84         {
  85                 redraw(MARK_UNSET, FALSE);
  86         }
  87         return cursor;
  88 }
  89
  90 /* This function deletes the character(s) that the cursor is on */
  91 MARK v_xchar(m, cnt, cmd)
  92         MARK    m;      /* where to start deletions */
  93         long    cnt;    /* number of chars to delete */
  94         int     cmd;    /* either 'x' or 'X' */
  95 {
  96         DEFAULT(1);
  97
  98         /* for 'X', adjust so chars are deleted *BEFORE* cursor */
  99         if (cmd == 'X')
 100         {
 101                 if (markidx(m) < cnt)
 102                         return MARK_UNSET;
 103                 m -= cnt;
 104         }
 105
 106         /* make sure we don't try to delete more thars than there are */
 107         pfetch(markline(m));
 108         if (markidx(m + cnt) > plen)
 109         {
 110                 cnt = plen - markidx(m);
 111         }
 112         if (cnt == 0L)
 113         {
 114                 return MARK_UNSET;
 115         }
 116
 117         /* do it */
 118         ChangeText
 119         {
 120                 cut(m, m + cnt);
 121                 delete(m, m + cnt);
 122         }
 123         return m;
 124 }
 125
 126 /* This function defines a mark */
 127 /*ARGSUSED*/
 128 MARK v_mark(m, count, key)
 129         MARK    m;      /* where the mark will be */
 130         long    count;  /* (ignored) */
 131         int     key;    /* the ASCII label of the mark */
 132 {
 133         if (key < 'a' || key > 'z')
 134         {
 135                 msg("Marks must be from a to z");
 136         }
 137         else
 138         {
 139                 mark[key - 'a'] = m;
 140         }
 141         return m;
 142 }
 143
 144 /* This function toggles upper & lower case letters */
 145 MARK v_ulcase(m, cnt)
 146         MARK    m;      /* where to make the change */
 147         long    cnt;    /* number of chars to flip */
 148 {
 149         REG char        *pos;
 150         REG int         i, j;
 151         static char     flip[] =
 152                 "aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ[](){}<>";
 153
 154         DEFAULT(1);
 155
 156         /* fetch the current version of the line */
 157         pfetch(markline(m));
 158
 159         /* for each position in the line */
 160         for (j = 0, i = markidx(m); j < cnt && ptext[i]; j++, i++)
 161         {
 162                 tmpblk.c[j] = 0;
 163
 164                 /* one of the standard chars? */
 165                 for (pos = flip; *pos && *pos != ptext[i]; pos++)
 166                 {
 167                 }
 168                 if (*pos)
 169                 {
 170                         tmpblk.c[j] = flip[(int)(pos - flip) ^ 1];
 171                 }
 172 #ifndef NO_DIGRAPH
 173                 else /* one of the non-standard chars? */
 174                 {
 175                         for (pos = o_flipcase; *pos && *pos != ptext[i]; pos++)
 176                         {
 177                         }
 178                         if (*pos)
 179                         {
 180                                 tmpblk.c[j] = o_flipcase[(int)(pos - o_flipcase) ^ 1];
 181                         }
 182                 }
 183 #endif
 184
 185                 /* if nothing special, then don't change it */
 186                 if (tmpblk.c[j] == 0)
 187                 {
 188                         tmpblk.c[j] = ptext[i];
 189                 }
 190         }
 191
 192         /* if the new text is different from the old, then change it */
 193         if (strncmp(tmpblk.c, &ptext[markidx(m)], j))
 194         {
 195                 ChangeText
 196                 {
 197                         tmpblk.c[j] = '\0';
 198                         change(m, m + j, tmpblk.c);
 199                 }
 200         }
 201
 202         return m + j;
 203 }
 204
 205
 206 MARK v_replace(m, cnt, key)
 207         MARK    m;      /* first char to be replaced */
 208         long    cnt;    /* number of chars to replace */
 209         int     key;    /* what to replace them with */
 210 {
 211         REG char        *text;
 212         REG int         i;
 213
 214         DEFAULT(1);
 215
 216         /* map ^M to '\n' */
 217         if (key == '\r')
 218         {
 219                 key = '\n';
 220         }
 221
 222         /* make sure the resulting line isn't too long */
 223         if (cnt > BLKSIZE - 2 - markidx(m))
 224         {
 225                 cnt = BLKSIZE - 2 - markidx(m);
 226         }
 227
 228         /* build a string of the desired character with the desired length */
 229         for (text = tmpblk.c, i = cnt; i > 0; i--)
 230         {
 231                 *text++ = key;
 232         }
 233         *text = '\0';
 234
 235         /* make sure cnt doesn't extend past EOL */
 236         pfetch(markline(m));
 237         key = markidx(m);
 238         if (key + cnt > plen)
 239         {
 240                 cnt = plen - key;
 241         }
 242
 243         /* do the replacement */
 244         ChangeText
 245         {
 246                 change(m, m + cnt, tmpblk.c);
 247         }
 248
 249         if (*tmpblk.c == '\n')
 250         {
 251                 return (m & ~(BLKSIZE - 1)) + cnt * BLKSIZE;
 252         }
 253         else
 254         {
 255                 return m + cnt - 1;
 256         }
 257 }
 258
 259 MARK v_overtype(m)
 260         MARK            m;      /* where to start overtyping */
 261 {
 262         MARK            end;    /* end of a substitution */
 263         static long     width;  /* width of a single-line replace */
 264
 265         /* the "doingdot" version of replace is really a substitution */
 266         if (doingdot)
 267         {
 268                 /* was the last one really repeatable? */
 269                 if (width < 0)
 270                 {
 271                         msg("Can't repeat a multi-line overtype command");
 272                         return MARK_UNSET;
 273                 }
 274
 275                 /* replacing nothing by nothing?  Don't bother */
 276                 if (width == 0)
 277                 {
 278                         return m;
 279                 }
 280
 281                 /* replace some chars by repeated text */
 282                 return v_subst(m, width);
 283         }
 284
 285         /* Normally, we input starting here, in replace mode */
 286         ChangeText
 287         {
 288                 end = input(m, m, WHEN_VIREP);
 289         }
 290
 291         /* if we ended on the same line we started on, then this
 292          * overtype is repeatable via the dot key.
 293          */
 294         if (markline(end) == markline(m) && end >= m - 1L)
 295         {
 296                 width = end - m + 1L;
 297         }
 298         else /* it isn't repeatable */
 299         {
 300                 width = -1L;
 301         }
 302
 303         return end;
 304 }
 305
 306
 307 /* This function selects which cut buffer to use */
 308 /*ARGSUSED*/
 309 MARK v_selcut(m, cnt, key)
 310         MARK    m;
 311         long    cnt;
 312         int     key;
 313 {
 314         cutname(key);
 315         return m;
 316 }
 317
 318 /* This function pastes text from a cut buffer */
 319 /*ARGSUSED*/
 320 MARK v_paste(m, cnt, cmd)
 321         MARK    m;      /* where to paste the text */
 322         long    cnt;    /* (ignored) */
 323         int     cmd;    /* either 'p' or 'P' */
 324 {
 325         ChangeText
 326         {
 327                 m = paste(m, cmd == 'p', FALSE);
 328         }
 329         return m;
 330 }
 331
 332 /* This function yanks text into a cut buffer */
 333 MARK v_yank(m, n)
 334         MARK    m, n;   /* range of text to yank */
 335 {
 336         cut(m, n);
 337         return m;
 338 }
 339
 340 /* This function deletes a range of text */
 341 MARK v_delete(m, n)
 342         MARK    m, n;   /* range of text to delete */
 343 {
 344         /* illegal to try and delete nothing */
 345         if (n <= m)
 346         {
 347                 return MARK_UNSET;
 348         }
 349
 350         /* Do it */
 351         ChangeText
 352         {
 353                 cut(m, n);
 354                 delete(m, n);
 355         }
 356         return m;
 357 }
 358
 359
 360 /* This starts input mode without deleting anything */
 361 MARK v_insert(m, cnt, key)
 362         MARK    m;      /* where to start (sort of) */
 363         long    cnt;    /* repeat how many times? */
 364         int     key;    /* what command is this for? {a,A,i,I,o,O} */
 365 {
 366         int     wasdot;
 367         long    reps;
 368         int     after;  /* are we appending or inserting? */
 369
 370         DEFAULT(1);
 371
 372         ChangeText
 373         {
 374                 /* tweak the insertion point, based on command key */
 375                 switch (key)
 376                 {
 377                   case 'i':
 378                         after = FALSE;
 379                         break;
 380
 381                   case 'a':
 382                         pfetch(markline(m));
 383                         if (plen > 0)
 384                         {
 385                                 m++;
 386                         }
 387                         after = TRUE;
 388                         break;
 389
 390                   case 'I':
 391                         m = m_front(m, 1L);
 392                         after = FALSE;
 393                         break;
 394
 395                   case 'A':
 396                         pfetch(markline(m));
 397                         m = (m & ~(BLKSIZE - 1)) + plen;
 398                         after = TRUE;
 399                         break;
 400
 401                   case 'O':
 402                         m &= ~(BLKSIZE - 1);
 403                         add(m, "\n");
 404                         after = FALSE;
 405                         break;
 406
 407                   case 'o':
 408                         m = (m & ~(BLKSIZE - 1)) + BLKSIZE;
 409                         add(m, "\n");
 410                         after = FALSE;
 411                         break;
 412                 }
 413
 414                 /* insert the same text once or more */
 415                 for (reps = cnt, wasdot = doingdot; reps > 0; reps--, doingdot = TRUE)
 416                 {
 417                         m = input(m, m, WHEN_VIINP);
 418                         if (after)
 419                         {
 420                                 m++;
 421                         }
 422                 }
 423                 if (after)
 424                 {
 425                         m--;
 426                 }
 427
 428                 doingdot = wasdot;
 429         }
 430
 431 #ifndef CRUNCH
 432 # ifndef NO_EXTENSIONS
 433         if (key == 'i' && *o_inputmode && mode == MODE_VI)
 434         {
 435                 msg("Now in visual command mode!  To return to input mode, hit <i>.");
 436         }
 437 # endif
 438 #endif
 439
 440         return m;
 441 }
 442
 443 /* This starts input mode with some text deleted */
 444 MARK v_change(m, n)
 445         MARK    m, n;   /* the range of text to change */
 446 {
 447         int     lnmode; /* is this a line-mode change? */
 448
 449         /* swap them if they're in reverse order */
 450         if (m > n)
 451         {
 452                 MARK    tmp;
 453                 tmp = m;
 454                 m = n;
 455                 n = tmp;
 456         }
 457
 458         /* for line mode, retain the last newline char */
 459         lnmode = (markidx(m) == 0 && markidx(n) == 0 && m != n);
 460         if (lnmode)
 461         {
 462                 n -= BLKSIZE;
 463                 pfetch(markline(n));
 464                 n = (n & ~(BLKSIZE - 1)) + plen;
 465         }
 466
 467         ChangeText
 468         {
 469                 cut(m, n);
 470                 m = input(m, n, WHEN_VIINP);
 471         }
 472
 473         return m;
 474 }
 475
 476 /* This function replaces a given number of characters with input */
 477 MARK v_subst(m, cnt)
 478         MARK    m;      /* where substitutions start */
 479         long    cnt;    /* number of chars to replace */
 480 {
 481         DEFAULT(1);
 482
 483         /* make sure we don't try replacing past EOL */
 484         pfetch(markline(m));
 485         if (markidx(m) + cnt > plen)
 486         {
 487                 cnt = plen - markidx(m);
 488         }
 489
 490         /* Go for it! */
 491         ChangeText
 492         {
 493                 cut(m, m + cnt);
 494                 m = input(m, m + cnt, WHEN_VIINP);
 495         }
 496         return m;
 497 }
 498
 499 /* This calls the ex "join" command to join some lines together */
 500 MARK v_join(m, cnt)
 501         MARK    m;      /* the first line to be joined */
 502         long    cnt;    /* number of other lines to join */
 503 {
 504         MARK    joint;  /* where the lines were joined */
 505
 506         DEFAULT(1);
 507
 508         /* figure out where the joint will be */
 509         pfetch(markline(m));
 510         joint = (m & ~(BLKSIZE - 1)) + plen;
 511
 512         /* join the lines */
 513         cmd_join(m, m + MARK_AT_LINE(cnt), CMD_JOIN, 0, "");
 514         mustredraw = TRUE;
 515
 516         /* the cursor should be left at the joint */
 517         return joint;
 518 }
 519
 520 /* This calls the ex shifter command to shift some lines */
 521 static MARK shift_help(m, n, excmd)
 522         MARK    m, n;   /* range of lines to shift */
 523         CMD     excmd;  /* which way do we shift? */
 524 {
 525         /* adjust for inclusive endmarks in ex */
 526         n -= BLKSIZE;
 527
 528         cmd_shift(m, n, excmd, 0, "");
 529         return m;
 530 }
 531
 532 /* This calls the ex "<" command to shift some lines left */
 533 MARK v_lshift(m, n)
 534         MARK    m, n;   /* range of lines to shift */
 535 {
 536         return shift_help(m, n, CMD_SHIFTL);
 537 }
 538
 539 /* This calls the ex ">" command to shift some lines right */
 540 MARK v_rshift(m, n)
 541         MARK    m, n;   /* range of lines to shift */
 542 {
 543         return shift_help(m, n, CMD_SHIFTR);
 544 }
 545
 546 /* This runs some lines through a filter program */
 547 MARK v_filter(m, n)
 548         MARK    m, n;   /* range of lines to shift */
 549 {
 550         char    cmdln[100];     /* a shell command line */
 551
 552         /* adjust for inclusive endmarks in ex */
 553         n -= BLKSIZE;
 554
 555         if (vgets('!', cmdln, sizeof(cmdln)) > 0)
 556         {
 557                 filter(m, n, cmdln);
 558         }
 559
 560         redraw(MARK_UNSET, FALSE);
 561         return m;
 562 }
 563
 564
 565 /* This function runs the ex "file" command to show the file's status */
 566 MARK v_status()
 567 {
 568         cmd_file(cursor, cursor, CMD_FILE, 0, "");
 569         return cursor;
 570 }
 571
 572
 573 /* This function runs the ":&" command to repeat the previous :s// */
 574 MARK v_again(m, n)
 575         MARK    m, n;
 576 {
 577         cmd_substitute(m, n - BLKSIZE, CMD_SUBAGAIN, TRUE, "");
 578         return cursor;
 579 }
 580
 581
 582
 583 /* This function switches to the previous file, if possible */
 584 MARK v_switch()
 585 {
 586         if (!*prevorig)
 587                 msg("No previous file");
 588         else
 589         {       strcpy(tmpblk.c, prevorig);
 590                 cmd_edit(cursor, cursor, CMD_EDIT, 0, tmpblk.c);
 591         }
 592         return cursor;
 593 }
 594
 595 /* This function does a tag search on a keyword */
 596 /*ARGSUSED*/
 597 MARK v_tag(keyword, m, cnt)
 598         char    *keyword;
 599         MARK    m;
 600         long    cnt;
 601 {
 602         /* move the cursor to the start of the tag name, where m is */
 603         cursor = m;
 604
 605         /* perform the tag search */
 606         cmd_tag(cursor, cursor, CMD_TAG, 0, keyword);
 607
 608         return cursor;
 609 }
 610
 611 #ifndef NO_EXTENSIONS
 612 /* This function looks up a keyword by calling the helpprog program */
 613 /*ARGSUSED*/
 614 MARK v_keyword(keyword, m, cnt)
 615         char    *keyword;
 616         MARK    m;
 617         long    cnt;
 618 {
 619         int     waswarn;
 620         char    cmdline[130];
 621
 622         move(LINES - 1, 0);
 623         addstr("---------------------------------------------------------\n");
 624         clrtoeol();
 625         refresh();
 626         sprintf(cmdline, "%s %s", o_keywordprg, keyword);
 627         waswarn = *o_warn;
 628         *o_warn = FALSE;
 629         suspend_curses();
 630         if (system(cmdline))
 631         {
 632                 addstr("<<< failed >>>\n");
 633         }
 634         resume_curses(FALSE);
 635         mode = MODE_VI;
 636         redraw(MARK_UNSET, FALSE);
 637         *o_warn = waswarn;
 638
 639         return m;
 640 }
 641
 642
 643
 644 MARK v_increment(keyword, m, cnt)
 645         char    *keyword;
 646         MARK    m;
 647         long    cnt;
 648 {
 649         static  sign;
 650         char    newval[12];
 651         long    atol();
 652
 653         DEFAULT(1);
 654
 655         /* get one more keystroke, unless doingdot */
 656         if (!doingdot)
 657         {
 658                 sign = getkey(0);
 659         }
 660
 661         /* adjust the number, based on that second keystroke */
 662         switch (sign)
 663         {
 664           case '+':
 665           case '#':
 666                 cnt = atol(keyword) + cnt;
 667                 break;
 668
 669           case '-':
 670                 cnt = atol(keyword) - cnt;
 671                 break;
 672
 673           case '=':
 674                 break;
 675
 676           default:
 677                 return MARK_UNSET;
 678         }
 679         sprintf(newval, "%ld", cnt);
 680
 681         ChangeText
 682         {
 683                 change(m, m + strlen(keyword), newval);
 684         }
 685
 686         return m;
 687 }
 688 #endif
 689
 690
 691 /* This function acts like the EX command "xit" */
 692 /*ARGSUSED*/
 693 MARK v_xit(m, cnt, key)
 694         MARK    m;      /* ignored */
 695         long    cnt;    /* ignored */
 696         int     key;    /* must be a second 'Z' */
 697 {
 698         /* if second char wasn't 'Z', fail */
 699         if (key != 'Z')
 700         {
 701                 return MARK_UNSET;
 702         }
 703
 704         /* move the cursor to the bottom of the screen */
 705         move(LINES - 1, 0);
 706         clrtoeol();
 707
 708         /* do the xit command */
 709         cmd_xit(m, m, CMD_XIT, FALSE, "");
 710
 711         /* return the cursor */
 712         return m;
 713 }
 714
 715
 716 /* This function undoes changes to a single line, if possible */
 717 MARK v_undoline(m)
 718         MARK    m;      /* where we hope to undo the change */
 719 {
 720         /* make sure we have the right line in the buffer */
 721         if (markline(m) != U_line)
 722         {
 723                 return MARK_UNSET;
 724         }
 725
 726         /* fix it */
 727         ChangeText
 728         {
 729                 strcat(U_text, "\n");
 730                 change(MARK_AT_LINE(U_line), MARK_AT_LINE(U_line + 1), U_text);
 731         }
 732
 733         /* nothing in the buffer anymore */
 734         U_line = -1L;
 735
 736         /* return, with the cursor at the front of the line */
 737         return m & ~(BLKSIZE - 1);
 738 }
 739
 740
 741 #ifndef NO_ERRLIST
 742 MARK v_errlist(m)
 743         MARK    m;
 744 {
 745         cmd_errlist(m, m, CMD_ERRLIST, FALSE, "");
 746         return cursor;
 747 }
 748 #endif
 749
 750
 751 #ifndef NO_AT
 752 /*ARGSUSED*/
 753 MARK v_at(m, cnt, key)
 754         MARK    m;
 755         long    cnt;
 756         int     key;
 757 {
 758         if (!fromcutbuf(key))
 759         {
 760                 return MARK_UNSET;
 761         }
 762         return cursor;
 763 }
 764 #endif