![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cmd2.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / usr / bin / elvis|
Return to cmd2.c CVS log | Up to [MW Coherent from dump] / coherent / d / usr / bin / elvis |
1.1 ! root 1: /* cmd2.c */ ! 2: ! 3: /* Author: ! 4: * Steve Kirkendall ! 5: * 16820 SW Tallac Way ! 6: * Beaverton, OR 97006 ! 7: * [email protected], or ...uunet!tektronix!psueea!jove!kirkenda ! 8: */ ! 9: ! 10: ! 11: /* This file contains some of the commands - mostly ones that change text */ ! 12: ! 13: #include <ctype.h> ! 14: #include "config.h" ! 15: #include "vi.h" ! 16: #include "regexp.h" ! 17: #if TOS ! 18: # include <stat.h> ! 19: #else ! 20: # if OSK ! 21: # include "osk.h" ! 22: # else ! 23: # include <sys/stat.h> ! 24: # endif ! 25: #endif ! 26: ! 27: ! 28: /*ARGSUSED*/ ! 29: void cmd_substitute(frommark, tomark, cmd, bang, extra) ! 30: MARK frommark; ! 31: MARK tomark; ! 32: CMD cmd; ! 33: int bang; ! 34: char *extra; /* rest of the command line */ ! 35: { ! 36: char *line; /* a line from the file */ ! 37: regexp *re; /* the compiled search expression */ ! 38: char *subst; /* the substitution string */ ! 39: char *opt; /* substitution options */ ! 40: long l; /* a line number */ ! 41: char *s, *d; /* used during subtitutions */ ! 42: char *conf; /* used during confirmation */ ! 43: long chline; /* # of lines changed */ ! 44: long chsub; /* # of substitutions made */ ! 45: static optp; /* boolean option: print when done? */ ! 46: static optg; /* boolean option: substitute globally in line? */ ! 47: static optc; /* boolean option: confirm before subst? */ ! 48: ! 49: ! 50: /* for now, assume this will fail */ ! 51: rptlines = -1L; ! 52: ! 53: if (cmd == CMD_SUBAGAIN) ! 54: { ! 55: #ifndef NO_MAGIC ! 56: if (*o_magic) ! 57: subst = "~"; ! 58: else ! 59: #endif ! 60: subst = "\\~"; ! 61: re = regcomp(""); ! 62: ! 63: /* if visual "&", then turn off the "p" and "c" options */ ! 64: if (bang) ! 65: { ! 66: optp = optc = FALSE; ! 67: } ! 68: } ! 69: else ! 70: { ! 71: /* make sure we got a search pattern */ ! 72: if (*extra != '/' && *extra != '?') ! 73: { ! 74: msg("Usage: s/regular expression/new text/"); ! 75: return; ! 76: } ! 77: ! 78: /* parse & compile the search pattern */ ! 79: subst = parseptrn(extra); ! 80: re = regcomp(extra + 1); ! 81: } ! 82: ! 83: /* abort if RE error -- error message already given by regcomp() */ ! 84: if (!re) ! 85: { ! 86: return; ! 87: } ! 88: ! 89: if (cmd == CMD_SUBSTITUTE) ! 90: { ! 91: /* parse the substitution string & find the option string */ ! 92: for (opt = subst; *opt && *opt != *extra; opt++) ! 93: { ! 94: if (*opt == '\\' && opt[1]) ! 95: { ! 96: opt++; ! 97: } ! 98: } ! 99: if (*opt) ! 100: { ! 101: *opt++ = '\0'; ! 102: } ! 103: ! 104: /* analyse the option string */ ! 105: if (!*o_edcompatible) ! 106: { ! 107: optp = optg = optc = FALSE; ! 108: } ! 109: while (*opt) ! 110: { ! 111: switch (*opt++) ! 112: { ! 113: case 'p': optp = !optp; break; ! 114: case 'g': optg = !optg; break; ! 115: case 'c': optc = !optc; break; ! 116: case ' ': ! 117: case '\t': break; ! 118: default: ! 119: msg("Subst options are p, c, and g -- not %c", opt[-1]); ! 120: return; ! 121: } ! 122: } ! 123: } ! 124: ! 125: /* if "c" or "p" flag was given, and we're in visual mode, then NEWLINE */ ! 126: if ((optc || optp) && mode == MODE_VI) ! 127: { ! 128: addch('\n'); ! 129: exrefresh(); ! 130: } ! 131: ! 132: ChangeText ! 133: { ! 134: /* reset the change counters */ ! 135: chline = chsub = 0L; ! 136: ! 137: /* for each selected line */ ! 138: for (l = markline(frommark); l <= markline(tomark); l++) ! 139: { ! 140: /* fetch the line */ ! 141: line = fetchline(l); ! 142: ! 143: /* if it contains the search pattern... */ ! 144: if (regexec(re, line, TRUE)) ! 145: { ! 146: /* increment the line change counter */ ! 147: chline++; ! 148: ! 149: /* initialize the pointers */ ! 150: s = line; ! 151: d = tmpblk.c; ! 152: ! 153: /* do once or globally ... */ ! 154: do ! 155: { ! 156: #ifndef CRUNCH ! 157: /* confirm, if necessary */ ! 158: if (optc) ! 159: { ! 160: for (conf = line; conf < re->startp[0]; conf++) ! 161: addch(*conf); ! 162: standout(); ! 163: for ( ; conf < re->endp[0]; conf++) ! 164: addch(*conf); ! 165: standend(); ! 166: for (; *conf; conf++) ! 167: addch(*conf); ! 168: addch('\n'); ! 169: exrefresh(); ! 170: if (getkey(0) != 'y') ! 171: { ! 172: /* copy accross the original chars */ ! 173: while (s < re->endp[0]) ! 174: *d++ = *s++; ! 175: ! 176: /* skip to next match on this line, if any */ ! 177: continue; ! 178: } ! 179: } ! 180: #endif /* not CRUNCH */ ! 181: ! 182: /* increment the substitution change counter */ ! 183: chsub++; ! 184: ! 185: /* this may be the first line to redraw */ ! 186: redrawrange(l, l + 1L, l + 1L); ! 187: ! 188: /* copy stuff from before the match */ ! 189: while (s < re->startp[0]) ! 190: { ! 191: *d++ = *s++; ! 192: } ! 193: ! 194: /* substitute for the matched part */ ! 195: regsub(re, subst, d); ! 196: s = re->endp[0]; ! 197: d += strlen(d); ! 198: ! 199: } while (optg && regexec(re, s, FALSE)); ! 200: ! 201: /* copy stuff from after the match */ ! 202: while (*d++ = *s++) /* yes, ASSIGNMENT! */ ! 203: { ! 204: } ! 205: ! 206: /* replace the old version of the line with the new */ ! 207: d[-1] = '\n'; ! 208: d[0] = '\0'; ! 209: change(MARK_AT_LINE(l), MARK_AT_LINE(l + 1), tmpblk.c); ! 210: ! 211: /* if supposed to print it, do so */ ! 212: if (optp) ! 213: { ! 214: addstr(tmpblk.c); ! 215: exrefresh(); ! 216: } ! 217: ! 218: /* move the cursor to that line */ ! 219: cursor = MARK_AT_LINE(l); ! 220: } ! 221: } ! 222: } ! 223: ! 224: /* tweak for redrawing */ ! 225: mustredraw = TRUE; ! 226: ! 227: /* free the regexp */ ! 228: free(re); ! 229: ! 230: /* if done from within a ":g" command, then finish silently */ ! 231: if (doingglobal) ! 232: { ! 233: rptlines = chline; ! 234: rptlabel = "changed"; ! 235: return; ! 236: } ! 237: ! 238: /* Reporting */ ! 239: if (chsub == 0) ! 240: { ! 241: msg("Substitution failed"); ! 242: } ! 243: else if (chline >= *o_report) ! 244: { ! 245: msg("%ld substitutions on %ld lines", chsub, chline); ! 246: } ! 247: } ! 248: ! 249: ! 250: ! 251: ! 252: /*ARGSUSED*/ ! 253: void cmd_delete(frommark, tomark, cmd, bang, extra) ! 254: MARK frommark; ! 255: MARK tomark; ! 256: CMD cmd; ! 257: int bang; ! 258: char *extra; ! 259: { ! 260: MARK curs2; /* an altered form of the cursor */ ! 261: ! 262: /* choose your cut buffer */ ! 263: if (*extra == '"') ! 264: { ! 265: extra++; ! 266: } ! 267: if (*extra) ! 268: { ! 269: cutname(*extra); ! 270: } ! 271: ! 272: /* make sure we're talking about whole lines here */ ! 273: frommark = frommark & ~(BLKSIZE - 1); ! 274: tomark = (tomark & ~(BLKSIZE - 1)) + BLKSIZE; ! 275: ! 276: /* yank the lines */ ! 277: cut(frommark, tomark); ! 278: ! 279: /* if CMD_DELETE then delete the lines */ ! 280: if (cmd != CMD_YANK) ! 281: { ! 282: curs2 = cursor; ! 283: ChangeText ! 284: { ! 285: /* delete the lines */ ! 286: delete(frommark, tomark); ! 287: } ! 288: if (curs2 > tomark) ! 289: { ! 290: cursor = curs2 - tomark + frommark; ! 291: } ! 292: else if (curs2 > frommark) ! 293: { ! 294: cursor = frommark; ! 295: } ! 296: } ! 297: } ! 298: ! 299: ! 300: /*ARGSUSED*/ ! 301: void cmd_append(frommark, tomark, cmd, bang, extra) ! 302: MARK frommark; ! 303: MARK tomark; ! 304: CMD cmd; ! 305: int bang; ! 306: char *extra; ! 307: { ! 308: long l; /* line counter */ ! 309: ! 310: ChangeText ! 311: { ! 312: /* if we're doing a change, delete the old version */ ! 313: if (cmd == CMD_CHANGE) ! 314: { ! 315: /* delete 'em */ ! 316: cmd_delete(frommark, tomark, cmd, bang, extra); ! 317: } ! 318: ! 319: /* new lines start at the frommark line, or after it */ ! 320: l = markline(frommark); ! 321: if (cmd == CMD_APPEND) ! 322: { ! 323: l++; ! 324: } ! 325: ! 326: /* get lines until no more lines, or "." line, and insert them */ ! 327: while (vgets('\0', tmpblk.c, BLKSIZE) >= 0) ! 328: { ! 329: addch('\n'); ! 330: if (!strcmp(tmpblk.c, ".")) ! 331: { ! 332: break; ! 333: } ! 334: ! 335: strcat(tmpblk.c, "\n"); ! 336: add(MARK_AT_LINE(l), tmpblk.c); ! 337: l++; ! 338: } ! 339: } ! 340: ! 341: /* on the odd chance that we're calling this from vi mode ... */ ! 342: redraw(MARK_UNSET, FALSE); ! 343: } ! 344: ! 345: ! 346: /*ARGSUSED*/ ! 347: void cmd_put(frommark, tomark, cmd, bang, extra) ! 348: MARK frommark; ! 349: MARK tomark; ! 350: CMD cmd; ! 351: int bang; ! 352: char *extra; ! 353: { ! 354: /* choose your cut buffer */ ! 355: if (*extra == '"') ! 356: { ! 357: extra++; ! 358: } ! 359: if (*extra) ! 360: { ! 361: cutname(*extra); ! 362: } ! 363: ! 364: /* paste it */ ! 365: ChangeText ! 366: { ! 367: cursor = paste(frommark, TRUE, FALSE); ! 368: } ! 369: } ! 370: ! 371: ! 372: /*ARGSUSED*/ ! 373: void cmd_join(frommark, tomark, cmd, bang, extra) ! 374: MARK frommark; ! 375: MARK tomark; ! 376: CMD cmd; ! 377: int bang; ! 378: char *extra; ! 379: { ! 380: long l; ! 381: char *scan; ! 382: int len; /* length of the new line */ ! 383: ! 384: /* if only one line is specified, assume the following one joins too */ ! 385: if (markline(frommark) == nlines) ! 386: { ! 387: msg("Nothing to join with this line"); ! 388: return; ! 389: } ! 390: if (markline(frommark) == markline(tomark)) ! 391: { ! 392: tomark += BLKSIZE; ! 393: } ! 394: ! 395: /* get the first line */ ! 396: l = markline(frommark); ! 397: strcpy(tmpblk.c, fetchline(l)); ! 398: len = strlen(tmpblk.c); ! 399: ! 400: /* build the longer line */ ! 401: while (++l <= markline(tomark)) ! 402: { ! 403: /* get the next line */ ! 404: scan = fetchline(l); ! 405: ! 406: /* remove any leading whitespace */ ! 407: while (*scan == '\t' || *scan == ' ') ! 408: { ! 409: scan++; ! 410: } ! 411: ! 412: /* see if the line will fit */ ! 413: if (strlen(scan) + len + 3 > BLKSIZE) ! 414: { ! 415: msg("Can't join -- the resulting line would be too long"); ! 416: return; ! 417: } ! 418: ! 419: /* catenate it, with a space (or two) in between */ ! 420: if (len >= 1 && ! 421: (tmpblk.c[len - 1] == '.' ! 422: || tmpblk.c[len - 1] == '?' ! 423: || tmpblk.c[len - 1] == '!')) ! 424: { ! 425: tmpblk.c[len++] = ' '; ! 426: } ! 427: tmpblk.c[len++] = ' '; ! 428: strcpy(tmpblk.c + len, scan); ! 429: len += strlen(scan); ! 430: } ! 431: tmpblk.c[len++] = '\n'; ! 432: tmpblk.c[len] = '\0'; ! 433: ! 434: /* make the change */ ! 435: ChangeText ! 436: { ! 437: frommark &= ~(BLKSIZE - 1); ! 438: tomark &= ~(BLKSIZE - 1); ! 439: tomark += BLKSIZE; ! 440: change(frommark, tomark, tmpblk.c); ! 441: } ! 442: ! 443: /* Reporting... */ ! 444: rptlines = markline(tomark) - markline(frommark) - 1L; ! 445: rptlabel = "joined"; ! 446: } ! 447: ! 448: ! 449: ! 450: /*ARGSUSED*/ ! 451: void cmd_shift(frommark, tomark, cmd, bang, extra) ! 452: MARK frommark; ! 453: MARK tomark; ! 454: CMD cmd; ! 455: int bang; ! 456: char *extra; ! 457: { ! 458: long l; /* line number counter */ ! 459: int oldidx; /* number of chars previously used for indent */ ! 460: int newidx; /* number of chars in the new indent string */ ! 461: int oldcol; /* previous indent amount */ ! 462: int newcol; /* new indent amount */ ! 463: char *text; /* pointer to the old line's text */ ! 464: ! 465: /* figure out how much of the screen we must redraw (for vi mode) */ ! 466: if (markline(frommark) != markline(tomark)) ! 467: { ! 468: mustredraw = TRUE; ! 469: redrawrange(markline(frommark), markline(tomark) + 1L, markline(tomark) + 1L); ! 470: } ! 471: ! 472: ChangeText ! 473: { ! 474: /* for each line to shift... */ ! 475: for (l = markline(frommark); l <= markline(tomark); l++) ! 476: { ! 477: /* get the line - ignore empty lines unless ! mode */ ! 478: text = fetchline(l); ! 479: if (!*text && !bang) ! 480: continue; ! 481: ! 482: /* calc oldidx and oldcol */ ! 483: for (oldidx = 0, oldcol = 0; ! 484: text[oldidx] == ' ' || text[oldidx] == '\t'; ! 485: oldidx++) ! 486: { ! 487: if (text[oldidx] == ' ') ! 488: { ! 489: oldcol += 1; ! 490: } ! 491: else ! 492: { ! 493: oldcol += *o_tabstop - (oldcol % *o_tabstop); ! 494: } ! 495: } ! 496: ! 497: /* calc newcol */ ! 498: if (cmd == CMD_SHIFTR) ! 499: { ! 500: newcol = oldcol + (*o_shiftwidth & 0xff); ! 501: } ! 502: else ! 503: { ! 504: newcol = oldcol - (*o_shiftwidth & 0xff); ! 505: if (newcol < 0) ! 506: newcol = 0; ! 507: } ! 508: ! 509: /* if no change, then skip to next line */ ! 510: if (oldcol == newcol) ! 511: continue; ! 512: ! 513: /* build a new indent string */ ! 514: newidx = 0; ! 515: while (newcol >= *o_tabstop) ! 516: { ! 517: tmpblk.c[newidx++] = '\t'; ! 518: newcol -= *o_tabstop; ! 519: } ! 520: while (newcol > 0) ! 521: { ! 522: tmpblk.c[newidx++] = ' '; ! 523: newcol--; ! 524: } ! 525: tmpblk.c[newidx] = '\0'; ! 526: ! 527: /* change the old indent string into the new */ ! 528: change(MARK_AT_LINE(l), MARK_AT_LINE(l) + oldidx, tmpblk.c); ! 529: } ! 530: } ! 531: ! 532: /* Reporting... */ ! 533: rptlines = markline(tomark) - markline(frommark) + 1L; ! 534: if (cmd == CMD_SHIFTR) ! 535: { ! 536: rptlabel = ">ed"; ! 537: } ! 538: else ! 539: { ! 540: rptlabel = "<ed"; ! 541: } ! 542: } ! 543: ! 544: ! 545: /*ARGSUSED*/ ! 546: void cmd_read(frommark, tomark, cmd, bang, extra) ! 547: MARK frommark; ! 548: MARK tomark; ! 549: CMD cmd; ! 550: int bang; ! 551: char *extra; ! 552: { ! 553: int fd, rc; /* used while reading from the file */ ! 554: char *scan; /* used for finding NUL characters */ ! 555: int hadnul; /* boolean: any NULs found? */ ! 556: int addnl; /* boolean: forced to add newlines? */ ! 557: int len; /* number of chars in current line */ ! 558: long lines; /* number of lines in current block */ ! 559: struct stat statb; ! 560: ! 561: /* special case: if ":r !cmd" then let the filter() function do it */ ! 562: if (extra[0] == '!') ! 563: { ! 564: filter(frommark, MARK_UNSET, extra + 1); ! 565: return; ! 566: } ! 567: ! 568: /* open the file */ ! 569: fd = open(extra, O_RDONLY); ! 570: if (fd < 0) ! 571: { ! 572: msg("Can't open \"%s\"", extra); ! 573: return; ! 574: } ! 575: ! 576: #ifndef CRUNCH ! 577: if (stat(extra, &statb) < 0) ! 578: { ! 579: msg("Can't stat \"%s\"", extra); ! 580: } ! 581: # if TOS ! 582: if (statb.st_mode & S_IJDIR) ! 583: # else ! 584: # if OSK ! 585: if (statb.st_mode & S_IFDIR) ! 586: # else ! 587: if ((statb.st_mode & S_IFMT) != S_IFREG) ! 588: # endif ! 589: # endif ! 590: { ! 591: msg("\"%s\" is not a regular file", extra); ! 592: return; ! 593: } ! 594: #endif /* not CRUNCH */ ! 595: ! 596: /* get blocks from the file, and add them */ ! 597: ChangeText ! 598: { ! 599: /* insertion starts at the line following frommark */ ! 600: tomark = frommark = (frommark | (BLKSIZE - 1L)) + 1L; ! 601: len = 0; ! 602: hadnul = addnl = FALSE; ! 603: ! 604: /* add an extra newline, so partial lines at the end of ! 605: * the file don't trip us up ! 606: */ ! 607: add(tomark, "\n"); ! 608: ! 609: /* for each chunk of text... */ ! 610: while ((rc = read(fd, tmpblk.c, BLKSIZE - 1)) > 0) ! 611: { ! 612: /* count newlines, convert NULs, etc. ... */ ! 613: for (lines = 0, scan = tmpblk.c; rc > 0; rc--, scan++) ! 614: { ! 615: /* break up long lines */ ! 616: if (*scan != '\n' && len + 2 > BLKSIZE) ! 617: { ! 618: *scan = '\n'; ! 619: addnl = TRUE; ! 620: } ! 621: ! 622: /* protect against NUL chars in file */ ! 623: if (!*scan) ! 624: { ! 625: *scan = 0x80; ! 626: hadnul = TRUE; ! 627: } ! 628: ! 629: /* starting a new line? */ ! 630: if (*scan == '\n') ! 631: { ! 632: /* reset length at newline */ ! 633: len = 0; ! 634: lines++; ! 635: } ! 636: else ! 637: { ! 638: len++; ! 639: } ! 640: } ! 641: ! 642: /* add the text */ ! 643: *scan = '\0'; ! 644: add(tomark, tmpblk.c); ! 645: tomark += MARK_AT_LINE(lines) + len - markidx(tomark); ! 646: } ! 647: ! 648: /* if partial last line, then retain that first newline */ ! 649: if (len > 0) ! 650: { ! 651: msg("Last line had no newline"); ! 652: tomark += BLKSIZE; /* <- for the rptlines calc */ ! 653: } ! 654: else /* delete that first newline */ ! 655: { ! 656: delete(tomark, (tomark | (BLKSIZE - 1L)) + 1L); ! 657: } ! 658: } ! 659: ! 660: /* close the file */ ! 661: close(fd); ! 662: ! 663: /* Reporting... */ ! 664: rptlines = markline(tomark) - markline(frommark); ! 665: rptlabel = "read"; ! 666: ! 667: if (addnl) ! 668: msg("Newlines were added to break up long lines"); ! 669: if (hadnul) ! 670: msg("NULs were converted to 0x80"); ! 671: } ! 672: ! 673: ! 674: ! 675: /*ARGSUSED*/ ! 676: void cmd_undo(frommark, tomark, cmd, bang, extra) ! 677: MARK frommark; ! 678: MARK tomark; ! 679: CMD cmd; ! 680: int bang; ! 681: char *extra; ! 682: { ! 683: undo(); ! 684: } ! 685: ! 686: ! 687: /* print the selected lines */ ! 688: /*ARGSUSED*/ ! 689: void cmd_print(frommark, tomark, cmd, bang, extra) ! 690: MARK frommark; ! 691: MARK tomark; ! 692: CMD cmd; ! 693: int bang; ! 694: char *extra; ! 695: { ! 696: REG char *scan; ! 697: REG long l; ! 698: REG int col; ! 699: ! 700: for (l = markline(frommark); l <= markline(tomark); l++) ! 701: { ! 702: /* display a line number, if CMD_NUMBER */ ! 703: if (cmd == CMD_NUMBER) ! 704: { ! 705: sprintf(tmpblk.c, "%6ld ", l); ! 706: qaddstr(tmpblk.c); ! 707: col = 8; ! 708: } ! 709: else ! 710: { ! 711: col = 0; ! 712: } ! 713: ! 714: /* get the next line & display it */ ! 715: for (scan = fetchline(l); *scan; scan++) ! 716: { ! 717: /* expand tabs to the proper width */ ! 718: if (*scan == '\t' && cmd != CMD_LIST) ! 719: { ! 720: do ! 721: { ! 722: qaddch(' '); ! 723: col++; ! 724: } while (col % *o_tabstop != 0); ! 725: } ! 726: else if (*scan >= 0 && *scan < ' ' || *scan == '\177') ! 727: { ! 728: qaddch('^'); ! 729: qaddch(*scan ^ 0x40); ! 730: col += 2; ! 731: } ! 732: else if ((*scan & 0x80) && cmd == CMD_LIST) ! 733: { ! 734: sprintf(tmpblk.c, "\\%03o", *scan); ! 735: qaddstr(tmpblk.c); ! 736: col += 4; ! 737: } ! 738: else ! 739: { ! 740: qaddch(*scan); ! 741: col++; ! 742: } ! 743: ! 744: /* wrap at the edge of the screen */ ! 745: if (!has_AM && col >= COLS) ! 746: { ! 747: addch('\n'); ! 748: col -= COLS; ! 749: } ! 750: } ! 751: if (cmd == CMD_LIST) ! 752: { ! 753: qaddch('$'); ! 754: } ! 755: addch('\n'); ! 756: exrefresh(); ! 757: } ! 758: } ! 759: ! 760: ! 761: /* move or copy selected lines */ ! 762: /*ARGSUSED*/ ! 763: void cmd_move(frommark, tomark, cmd, bang, extra) ! 764: MARK frommark; ! 765: MARK tomark; ! 766: CMD cmd; ! 767: int bang; ! 768: char *extra; ! 769: { ! 770: MARK destmark; ! 771: ! 772: /* parse the destination linespec. No defaults. Line 0 is okay */ ! 773: destmark = cursor; ! 774: if (!strcmp(extra, "0")) ! 775: { ! 776: destmark = 0L; ! 777: } ! 778: else if (linespec(extra, &destmark) == extra || !destmark) ! 779: { ! 780: msg("invalid destination address"); ! 781: return; ! 782: } ! 783: ! 784: /* flesh the marks out to encompass whole lines */ ! 785: frommark &= ~(BLKSIZE - 1); ! 786: tomark = (tomark & ~(BLKSIZE - 1)) + BLKSIZE; ! 787: destmark = (destmark & ~(BLKSIZE - 1)) + BLKSIZE; ! 788: ! 789: /* make sure the destination is valid */ ! 790: if (cmd == CMD_MOVE && destmark >= frommark && destmark < tomark) ! 791: { ! 792: msg("invalid destination address"); ! 793: } ! 794: ! 795: /* Do it */ ! 796: ChangeText ! 797: { ! 798: /* save the text to a cut buffer */ ! 799: cutname('\0'); ! 800: cut(frommark, tomark); ! 801: ! 802: /* if we're not copying, delete the old text & adjust destmark */ ! 803: if (cmd != CMD_COPY) ! 804: { ! 805: delete(frommark, tomark); ! 806: if (destmark >= frommark) ! 807: { ! 808: destmark -= (tomark - frommark); ! 809: } ! 810: } ! 811: ! 812: /* add the new text */ ! 813: paste(destmark, FALSE, FALSE); ! 814: } ! 815: ! 816: /* move the cursor to the last line of the moved text */ ! 817: cursor = destmark + (tomark - frommark) - BLKSIZE; ! 818: if (cursor < MARK_FIRST || cursor >= MARK_LAST + BLKSIZE) ! 819: { ! 820: cursor = MARK_LAST; ! 821: } ! 822: ! 823: /* Reporting... */ ! 824: rptlabel = ( (cmd == CMD_COPY) ? "copied" : "moved" ); ! 825: } ! 826: ! 827: ! 828: ! 829: /* execute EX commands from a file */ ! 830: /*ARGSUSED*/ ! 831: void cmd_source(frommark, tomark, cmd, bang, extra) ! 832: MARK frommark; ! 833: MARK tomark; ! 834: CMD cmd; ! 835: int bang; ! 836: char *extra; ! 837: { ! 838: /* must have a filename */ ! 839: if (!*extra) ! 840: { ! 841: msg("\"source\" requires a filename"); ! 842: return; ! 843: } ! 844: ! 845: doexrc(extra); ! 846: } ! 847: ! 848: ! 849: #ifndef NO_AT ! 850: /*ARGSUSED*/ ! 851: void cmd_at(frommark, tomark, cmd, bang, extra) ! 852: MARK frommark; ! 853: MARK tomark; ! 854: CMD cmd; ! 855: int bang; ! 856: char *extra; ! 857: { ! 858: static nest = FALSE; ! 859: int result; ! 860: char buf[MAXRCLEN]; ! 861: ! 862: /* don't allow nested macros */ ! 863: if (nest) ! 864: { ! 865: msg("@ macros can't be nested"); ! 866: return; ! 867: } ! 868: nest = TRUE; ! 869: ! 870: /* require a buffer name */ ! 871: if (*extra == '"') ! 872: extra++; ! 873: if (!*extra || !isascii(*extra) ||!islower(*extra)) ! 874: { ! 875: msg("@ requires a cut buffer name (a-z)"); ! 876: } ! 877: ! 878: /* get the contents of the buffer */ ! 879: result = cb2str(*extra, buf, (unsigned)(sizeof buf)); ! 880: if (result <= 0) ! 881: { ! 882: msg("buffer \"%c is empty", *extra); ! 883: } ! 884: else if (result >= sizeof buf) ! 885: { ! 886: msg("buffer \"%c is too large to execute", *extra); ! 887: } ! 888: else ! 889: { ! 890: /* execute the contents of the buffer as ex commands */ ! 891: exstring(buf, result); ! 892: } ! 893: ! 894: nest = FALSE; ! 895: } ! 896: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.