943 lines
17 KiB
C
943 lines
17 KiB
C
/* cmd2.c */
|
|
|
|
/* Author:
|
|
* Steve Kirkendall
|
|
* 14407 SW Teal Blvd. #C
|
|
* Beaverton, OR 97005
|
|
* kirkenda@cs.pdx.edu
|
|
*/
|
|
|
|
|
|
/* This file contains some of the commands - mostly ones that change text */
|
|
|
|
#include "config.h"
|
|
#include "ctype.h"
|
|
#include "vi.h"
|
|
#include "regexp.h"
|
|
#if TOS
|
|
# include <stat.h>
|
|
#else
|
|
# if OSK
|
|
# include "osk.h"
|
|
# else
|
|
# if AMIGA
|
|
# include "amistat.h"
|
|
# else
|
|
# include <sys/stat.h>
|
|
# endif
|
|
# endif
|
|
#endif
|
|
|
|
|
|
/*ARGSUSED*/
|
|
void cmd_substitute(frommark, tomark, cmd, bang, extra)
|
|
MARK frommark;
|
|
MARK tomark;
|
|
CMD cmd;
|
|
int bang;
|
|
char *extra; /* rest of the command line */
|
|
{
|
|
char *line; /* a line from the file */
|
|
regexp *re; /* the compiled search expression */
|
|
char *subst; /* the substitution string */
|
|
char *opt; /* substitution options */
|
|
long l; /* a line number */
|
|
char *s, *d; /* used during subtitutions */
|
|
char *conf; /* used during confirmation */
|
|
long chline; /* # of lines changed */
|
|
long chsub; /* # of substitutions made */
|
|
static optp; /* boolean option: print when done? */
|
|
static optg; /* boolean option: substitute globally in line? */
|
|
static optc; /* boolean option: confirm before subst? */
|
|
#ifndef CRUNCH
|
|
long oldnlines;
|
|
#endif
|
|
|
|
|
|
/* for now, assume this will fail */
|
|
rptlines = -1L;
|
|
|
|
if (cmd == CMD_SUBAGAIN)
|
|
{
|
|
#ifndef NO_MAGIC
|
|
if (*o_magic)
|
|
subst = "~";
|
|
else
|
|
#endif
|
|
subst = "\\~";
|
|
re = regcomp("");
|
|
|
|
/* if visual "&", then turn off the "p" and "c" options */
|
|
if (bang)
|
|
{
|
|
optp = optc = FALSE;
|
|
}
|
|
}
|
|
else /* CMD_SUBSTITUTE */
|
|
{
|
|
/* make sure we got a search pattern */
|
|
if (*extra != '/' && *extra != '?')
|
|
{
|
|
msg("Usage: s/regular expression/new text/");
|
|
return;
|
|
}
|
|
|
|
/* parse & compile the search pattern */
|
|
subst = parseptrn(extra);
|
|
re = regcomp(extra + 1);
|
|
}
|
|
|
|
/* abort if RE error -- error message already given by regcomp() */
|
|
if (!re)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (cmd == CMD_SUBSTITUTE)
|
|
{
|
|
/* parse the substitution string & find the option string */
|
|
for (opt = subst; *opt && *opt != *extra; opt++)
|
|
{
|
|
if (*opt == '\\' && opt[1])
|
|
{
|
|
opt++;
|
|
}
|
|
}
|
|
if (*opt)
|
|
{
|
|
*opt++ = '\0';
|
|
}
|
|
|
|
/* analyse the option string */
|
|
if (!*o_edcompatible)
|
|
{
|
|
optp = optg = optc = FALSE;
|
|
}
|
|
while (*opt)
|
|
{
|
|
switch (*opt++)
|
|
{
|
|
case 'p': optp = !optp; break;
|
|
case 'g': optg = !optg; break;
|
|
case 'c': optc = !optc; break;
|
|
case ' ':
|
|
case '\t': break;
|
|
default:
|
|
msg("Subst options are p, c, and g -- not %c", opt[-1]);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* if "c" or "p" flag was given, and we're in visual mode, then NEWLINE */
|
|
if ((optc || optp) && mode == MODE_VI)
|
|
{
|
|
addch('\n');
|
|
exrefresh();
|
|
}
|
|
|
|
ChangeText
|
|
{
|
|
/* reset the change counters */
|
|
chline = chsub = 0L;
|
|
|
|
/* for each selected line */
|
|
for (l = markline(frommark); l <= markline(tomark); l++)
|
|
{
|
|
/* fetch the line */
|
|
line = fetchline(l);
|
|
|
|
/* if it contains the search pattern... */
|
|
if (regexec(re, line, TRUE))
|
|
{
|
|
/* increment the line change counter */
|
|
chline++;
|
|
|
|
/* initialize the pointers */
|
|
s = line;
|
|
d = tmpblk.c;
|
|
|
|
/* do once or globally ... */
|
|
do
|
|
{
|
|
#ifndef CRUNCH
|
|
/* confirm, if necessary */
|
|
if (optc)
|
|
{
|
|
for (conf = line; conf < re->startp[0]; conf++)
|
|
addch(*conf);
|
|
standout();
|
|
for ( ; conf < re->endp[0]; conf++)
|
|
addch(*conf);
|
|
standend();
|
|
for (; *conf; conf++)
|
|
addch(*conf);
|
|
addch('\n');
|
|
exrefresh();
|
|
if (getkey(0) != 'y')
|
|
{
|
|
/* copy accross the original chars */
|
|
while (s < re->endp[0])
|
|
*d++ = *s++;
|
|
|
|
/* skip to next match on this line, if any */
|
|
goto Continue;
|
|
}
|
|
}
|
|
#endif /* not CRUNCH */
|
|
|
|
/* increment the substitution change counter */
|
|
chsub++;
|
|
|
|
/* copy stuff from before the match */
|
|
while (s < re->startp[0])
|
|
{
|
|
*d++ = *s++;
|
|
}
|
|
|
|
/* substitute for the matched part */
|
|
regsub(re, subst, d);
|
|
s = re->endp[0];
|
|
d += strlen(d);
|
|
|
|
Continue:
|
|
/* if this regexp could conceivably match
|
|
* a zero-length string, then require at
|
|
* least 1 unmatched character between
|
|
* matches.
|
|
*/
|
|
if (re->minlen == 0)
|
|
{
|
|
if (!*s)
|
|
break;
|
|
*d++ = *s++;
|
|
}
|
|
|
|
} while (optg && regexec(re, s, FALSE));
|
|
|
|
/* copy stuff from after the match */
|
|
while (*d++ = *s++) /* yes, ASSIGNMENT! */
|
|
{
|
|
}
|
|
|
|
#ifndef CRUNCH
|
|
/* NOTE: since the substitution text is allowed to have ^Ms which are
|
|
* translated into newlines, it is possible that the number of lines
|
|
* in the file will increase after each line has been substituted.
|
|
* we need to adjust for this.
|
|
*/
|
|
oldnlines = nlines;
|
|
#endif
|
|
|
|
/* replace the old version of the line with the new */
|
|
d[-1] = '\n';
|
|
d[0] = '\0';
|
|
change(MARK_AT_LINE(l), MARK_AT_LINE(l + 1), tmpblk.c);
|
|
|
|
#ifndef CRUNCH
|
|
l += nlines - oldnlines;
|
|
tomark += MARK_AT_LINE(nlines - oldnlines);
|
|
#endif
|
|
|
|
/* if supposed to print it, do so */
|
|
if (optp)
|
|
{
|
|
addstr(tmpblk.c);
|
|
exrefresh();
|
|
}
|
|
|
|
/* move the cursor to that line */
|
|
cursor = MARK_AT_LINE(l);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* free the regexp */
|
|
free(re);
|
|
|
|
/* if done from within a ":g" command, then finish silently */
|
|
if (doingglobal)
|
|
{
|
|
rptlines = chline;
|
|
rptlabel = "changed";
|
|
return;
|
|
}
|
|
|
|
/* Reporting */
|
|
if (chsub == 0)
|
|
{
|
|
msg("Substitution failed");
|
|
}
|
|
else if (chline >= *o_report)
|
|
{
|
|
msg("%ld substitutions on %ld lines", chsub, chline);
|
|
}
|
|
rptlines = 0L;
|
|
}
|
|
|
|
|
|
|
|
|
|
/*ARGSUSED*/
|
|
void cmd_delete(frommark, tomark, cmd, bang, extra)
|
|
MARK frommark;
|
|
MARK tomark;
|
|
CMD cmd;
|
|
int bang;
|
|
char *extra;
|
|
{
|
|
MARK curs2; /* an altered form of the cursor */
|
|
|
|
/* choose your cut buffer */
|
|
if (*extra == '"')
|
|
{
|
|
extra++;
|
|
}
|
|
if (*extra)
|
|
{
|
|
cutname(*extra);
|
|
}
|
|
|
|
/* make sure we're talking about whole lines here */
|
|
frommark = frommark & ~(BLKSIZE - 1);
|
|
tomark = (tomark & ~(BLKSIZE - 1)) + BLKSIZE;
|
|
|
|
/* yank the lines */
|
|
cut(frommark, tomark);
|
|
|
|
/* if CMD_DELETE then delete the lines */
|
|
if (cmd != CMD_YANK)
|
|
{
|
|
curs2 = cursor;
|
|
ChangeText
|
|
{
|
|
/* delete the lines */
|
|
delete(frommark, tomark);
|
|
}
|
|
if (curs2 > tomark)
|
|
{
|
|
cursor = curs2 - tomark + frommark;
|
|
}
|
|
else if (curs2 > frommark)
|
|
{
|
|
cursor = frommark;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*ARGSUSED*/
|
|
void cmd_append(frommark, tomark, cmd, bang, extra)
|
|
MARK frommark;
|
|
MARK tomark;
|
|
CMD cmd;
|
|
int bang;
|
|
char *extra;
|
|
{
|
|
long l; /* line counter */
|
|
|
|
#ifndef CRUNCH
|
|
/* if '!' then toggle auto-indent */
|
|
if (bang)
|
|
{
|
|
*o_autoindent = !*o_autoindent;
|
|
}
|
|
#endif
|
|
|
|
ChangeText
|
|
{
|
|
/* if we're doing a change, delete the old version */
|
|
if (cmd == CMD_CHANGE)
|
|
{
|
|
/* delete 'em */
|
|
cmd_delete(frommark, tomark, cmd, bang, extra);
|
|
}
|
|
|
|
/* new lines start at the frommark line, or after it */
|
|
l = markline(frommark);
|
|
if (cmd == CMD_APPEND)
|
|
{
|
|
l++;
|
|
}
|
|
|
|
/* get lines until no more lines, or "." line, and insert them */
|
|
while (vgets('\0', tmpblk.c, BLKSIZE) >= 0)
|
|
{
|
|
addch('\n');
|
|
if (!strcmp(tmpblk.c, "."))
|
|
{
|
|
break;
|
|
}
|
|
|
|
strcat(tmpblk.c, "\n");
|
|
add(MARK_AT_LINE(l), tmpblk.c);
|
|
l++;
|
|
}
|
|
}
|
|
|
|
/* on the odd chance that we're calling this from vi mode ... */
|
|
redraw(MARK_UNSET, FALSE);
|
|
}
|
|
|
|
|
|
/*ARGSUSED*/
|
|
void cmd_put(frommark, tomark, cmd, bang, extra)
|
|
MARK frommark;
|
|
MARK tomark;
|
|
CMD cmd;
|
|
int bang;
|
|
char *extra;
|
|
{
|
|
/* choose your cut buffer */
|
|
if (*extra == '"')
|
|
{
|
|
extra++;
|
|
}
|
|
if (*extra)
|
|
{
|
|
cutname(*extra);
|
|
}
|
|
|
|
/* paste it */
|
|
ChangeText
|
|
{
|
|
cursor = paste(frommark, TRUE, FALSE);
|
|
}
|
|
}
|
|
|
|
|
|
/*ARGSUSED*/
|
|
void cmd_join(frommark, tomark, cmd, bang, extra)
|
|
MARK frommark;
|
|
MARK tomark;
|
|
CMD cmd;
|
|
int bang;
|
|
char *extra;
|
|
{
|
|
long l;
|
|
char *scan;
|
|
int len; /* length of the new line */
|
|
|
|
/* if only one line is specified, assume the following one joins too */
|
|
if (markline(frommark) == nlines)
|
|
{
|
|
msg("Nothing to join with this line");
|
|
return;
|
|
}
|
|
if (markline(frommark) == markline(tomark))
|
|
{
|
|
tomark += BLKSIZE;
|
|
}
|
|
|
|
/* get the first line */
|
|
l = markline(frommark);
|
|
strcpy(tmpblk.c, fetchline(l));
|
|
len = strlen(tmpblk.c);
|
|
|
|
/* build the longer line */
|
|
while (++l <= markline(tomark))
|
|
{
|
|
/* get the next line */
|
|
scan = fetchline(l);
|
|
|
|
/* remove any leading whitespace */
|
|
while (*scan == '\t' || *scan == ' ')
|
|
{
|
|
scan++;
|
|
}
|
|
|
|
/* see if the line will fit */
|
|
if (strlen(scan) + len + 3 > BLKSIZE)
|
|
{
|
|
msg("Can't join -- the resulting line would be too long");
|
|
return;
|
|
}
|
|
|
|
/* catenate it, with a space (or two) in between */
|
|
if (!bang)
|
|
{
|
|
if (len >= 1)
|
|
{
|
|
if (tmpblk.c[len - 1] == '.'
|
|
|| tmpblk.c[len - 1] == '?'
|
|
|| tmpblk.c[len - 1] == '!')
|
|
{
|
|
tmpblk.c[len++] = ' ';
|
|
}
|
|
tmpblk.c[len++] = ' ';
|
|
}
|
|
}
|
|
strcpy(tmpblk.c + len, scan);
|
|
len += strlen(scan);
|
|
}
|
|
tmpblk.c[len++] = '\n';
|
|
tmpblk.c[len] = '\0';
|
|
|
|
/* make the change */
|
|
ChangeText
|
|
{
|
|
frommark &= ~(BLKSIZE - 1);
|
|
tomark &= ~(BLKSIZE - 1);
|
|
tomark += BLKSIZE;
|
|
change(frommark, tomark, tmpblk.c);
|
|
}
|
|
|
|
/* Reporting... */
|
|
rptlines = markline(tomark) - markline(frommark) - 1L;
|
|
rptlabel = "joined";
|
|
}
|
|
|
|
|
|
|
|
/*ARGSUSED*/
|
|
void cmd_shift(frommark, tomark, cmd, bang, extra)
|
|
MARK frommark;
|
|
MARK tomark;
|
|
CMD cmd;
|
|
int bang;
|
|
char *extra;
|
|
{
|
|
long l; /* line number counter */
|
|
int oldidx; /* number of chars previously used for indent */
|
|
int newidx; /* number of chars in the new indent string */
|
|
int oldcol; /* previous indent amount */
|
|
int newcol; /* new indent amount */
|
|
char *text; /* pointer to the old line's text */
|
|
|
|
ChangeText
|
|
{
|
|
/* for each line to shift... */
|
|
for (l = markline(frommark); l <= markline(tomark); l++)
|
|
{
|
|
/* get the line - ignore empty lines unless ! mode */
|
|
text = fetchline(l);
|
|
if (!*text && !bang)
|
|
continue;
|
|
|
|
/* calc oldidx and oldcol */
|
|
for (oldidx = 0, oldcol = 0;
|
|
text[oldidx] == ' ' || text[oldidx] == '\t';
|
|
oldidx++)
|
|
{
|
|
if (text[oldidx] == ' ')
|
|
{
|
|
oldcol += 1;
|
|
}
|
|
else
|
|
{
|
|
oldcol += *o_tabstop - (oldcol % *o_tabstop);
|
|
}
|
|
}
|
|
|
|
/* calc newcol */
|
|
if (cmd == CMD_SHIFTR)
|
|
{
|
|
newcol = oldcol + (*o_shiftwidth & 0xff);
|
|
}
|
|
else
|
|
{
|
|
newcol = oldcol - (*o_shiftwidth & 0xff);
|
|
if (newcol < 0)
|
|
newcol = 0;
|
|
}
|
|
|
|
/* if no change, then skip to next line */
|
|
if (oldcol == newcol)
|
|
continue;
|
|
|
|
/* build a new indent string */
|
|
newidx = 0;
|
|
if (*o_autotab)
|
|
{
|
|
while (newcol >= *o_tabstop)
|
|
{
|
|
tmpblk.c[newidx++] = '\t';
|
|
newcol -= *o_tabstop;
|
|
}
|
|
}
|
|
while (newcol > 0)
|
|
{
|
|
tmpblk.c[newidx++] = ' ';
|
|
newcol--;
|
|
}
|
|
tmpblk.c[newidx] = '\0';
|
|
|
|
/* change the old indent string into the new */
|
|
change(MARK_AT_LINE(l), MARK_AT_LINE(l) + oldidx, tmpblk.c);
|
|
}
|
|
}
|
|
|
|
/* Reporting... */
|
|
rptlines = markline(tomark) - markline(frommark) + 1L;
|
|
if (cmd == CMD_SHIFTR)
|
|
{
|
|
rptlabel = ">ed";
|
|
}
|
|
else
|
|
{
|
|
rptlabel = "<ed";
|
|
}
|
|
}
|
|
|
|
|
|
/*ARGSUSED*/
|
|
void cmd_read(frommark, tomark, cmd, bang, extra)
|
|
MARK frommark;
|
|
MARK tomark;
|
|
CMD cmd;
|
|
int bang;
|
|
char *extra;
|
|
{
|
|
int fd, rc; /* used while reading from the file */
|
|
char *scan; /* used for finding NUL characters */
|
|
int hadnul; /* boolean: any NULs found? */
|
|
int addnl; /* boolean: forced to add newlines? */
|
|
int len; /* number of chars in current line */
|
|
long lines; /* number of lines in current block */
|
|
struct stat statb;
|
|
|
|
/* special case: if ":r !cmd" then let the filter() function do it */
|
|
if (extra[0] == '!')
|
|
{
|
|
filter(frommark, MARK_UNSET, extra + 1, TRUE);
|
|
return;
|
|
}
|
|
|
|
/* open the file */
|
|
fd = open(extra, O_RDONLY);
|
|
if (fd < 0)
|
|
{
|
|
msg("Can't open \"%s\"", extra);
|
|
return;
|
|
}
|
|
|
|
#ifndef CRUNCH
|
|
if (stat(extra, &statb) < 0)
|
|
{
|
|
msg("Can't stat \"%s\"", extra);
|
|
}
|
|
# if TOS
|
|
if (statb.st_mode & S_IJDIR)
|
|
# else
|
|
# if OSK
|
|
if (statb.st_mode & S_IFDIR)
|
|
# else
|
|
if ((statb.st_mode & S_IFMT) != S_IFREG)
|
|
# endif
|
|
# endif
|
|
{
|
|
msg("\"%s\" is not a regular file", extra);
|
|
return;
|
|
}
|
|
#endif /* not CRUNCH */
|
|
|
|
/* get blocks from the file, and add them */
|
|
ChangeText
|
|
{
|
|
/* insertion starts at the line following frommark */
|
|
tomark = frommark = (frommark | (BLKSIZE - 1L)) + 1L;
|
|
len = 0;
|
|
hadnul = addnl = FALSE;
|
|
|
|
/* add an extra newline, so partial lines at the end of
|
|
* the file don't trip us up
|
|
*/
|
|
add(tomark, "\n");
|
|
|
|
/* for each chunk of text... */
|
|
while ((rc = tread(fd, tmpblk.c, BLKSIZE - 1)) > 0)
|
|
{
|
|
/* count newlines, convert NULs, etc. ... */
|
|
for (lines = 0, scan = tmpblk.c; rc > 0; rc--, scan++)
|
|
{
|
|
/* break up long lines */
|
|
if (*scan != '\n' && len + 2 > BLKSIZE)
|
|
{
|
|
*scan = '\n';
|
|
addnl = TRUE;
|
|
}
|
|
|
|
/* protect against NUL chars in file */
|
|
if (!*scan)
|
|
{
|
|
*scan = 0x80;
|
|
hadnul = TRUE;
|
|
}
|
|
|
|
/* starting a new line? */
|
|
if (*scan == '\n')
|
|
{
|
|
/* reset length at newline */
|
|
len = 0;
|
|
lines++;
|
|
}
|
|
else
|
|
{
|
|
len++;
|
|
}
|
|
}
|
|
|
|
/* add the text */
|
|
*scan = '\0';
|
|
add(tomark, tmpblk.c);
|
|
tomark += MARK_AT_LINE(lines) + len - markidx(tomark);
|
|
}
|
|
|
|
/* if partial last line, then retain that first newline */
|
|
if (len > 0)
|
|
{
|
|
msg("Last line had no newline");
|
|
tomark += BLKSIZE; /* <- for the rptlines calc */
|
|
}
|
|
else /* delete that first newline */
|
|
{
|
|
delete(tomark, (tomark | (BLKSIZE - 1L)) + 1L);
|
|
}
|
|
}
|
|
|
|
/* close the file */
|
|
close(fd);
|
|
|
|
/* Reporting... */
|
|
rptlines = markline(tomark) - markline(frommark);
|
|
rptlabel = "read";
|
|
if (mode == MODE_EX)
|
|
{
|
|
cursor = (tomark & ~BLKSIZE) - BLKSIZE;
|
|
}
|
|
else
|
|
{
|
|
cursor = frommark;
|
|
}
|
|
|
|
if (addnl)
|
|
msg("Newlines were added to break up long lines");
|
|
if (hadnul)
|
|
msg("NULs were converted to 0x80");
|
|
}
|
|
|
|
|
|
|
|
/*ARGSUSED*/
|
|
void cmd_undo(frommark, tomark, cmd, bang, extra)
|
|
MARK frommark;
|
|
MARK tomark;
|
|
CMD cmd;
|
|
int bang;
|
|
char *extra;
|
|
{
|
|
undo();
|
|
}
|
|
|
|
|
|
/* print the selected lines */
|
|
/*ARGSUSED*/
|
|
void cmd_print(frommark, tomark, cmd, bang, extra)
|
|
MARK frommark;
|
|
MARK tomark;
|
|
CMD cmd;
|
|
int bang;
|
|
char *extra;
|
|
{
|
|
REG char *scan;
|
|
REG long l;
|
|
REG int col;
|
|
|
|
for (l = markline(frommark); l <= markline(tomark); l++)
|
|
{
|
|
/* display a line number, if CMD_NUMBER */
|
|
if (cmd == CMD_NUMBER)
|
|
{
|
|
sprintf(tmpblk.c, "%6ld ", l);
|
|
qaddstr(tmpblk.c);
|
|
col = 8;
|
|
}
|
|
else
|
|
{
|
|
col = 0;
|
|
}
|
|
|
|
/* get the next line & display it */
|
|
for (scan = fetchline(l); *scan; scan++)
|
|
{
|
|
/* expand tabs to the proper width */
|
|
if (*scan == '\t' && cmd != CMD_LIST)
|
|
{
|
|
do
|
|
{
|
|
qaddch(' ');
|
|
col++;
|
|
} while (col % *o_tabstop != 0);
|
|
}
|
|
else if (*scan > 0 && *scan < ' ' || *scan == '\177')
|
|
{
|
|
qaddch('^');
|
|
qaddch(*scan ^ 0x40);
|
|
col += 2;
|
|
}
|
|
else if ((*scan & 0x80) && cmd == CMD_LIST)
|
|
{
|
|
sprintf(tmpblk.c, "\\%03o", UCHAR(*scan));
|
|
qaddstr(tmpblk.c);
|
|
col += 4;
|
|
}
|
|
else
|
|
{
|
|
qaddch(*scan);
|
|
col++;
|
|
}
|
|
|
|
/* wrap at the edge of the screen */
|
|
if (!has_AM && col >= COLS)
|
|
{
|
|
addch('\n');
|
|
col -= COLS;
|
|
}
|
|
}
|
|
if (cmd == CMD_LIST)
|
|
{
|
|
qaddch('$');
|
|
}
|
|
addch('\n');
|
|
exrefresh();
|
|
}
|
|
}
|
|
|
|
|
|
/* move or copy selected lines */
|
|
/*ARGSUSED*/
|
|
void cmd_move(frommark, tomark, cmd, bang, extra)
|
|
MARK frommark;
|
|
MARK tomark;
|
|
CMD cmd;
|
|
int bang;
|
|
char *extra;
|
|
{
|
|
MARK destmark;
|
|
|
|
/* parse the destination linespec. No defaults. Line 0 is okay */
|
|
destmark = cursor;
|
|
if (!strcmp(extra, "0"))
|
|
{
|
|
destmark = 0L;
|
|
}
|
|
else if (linespec(extra, &destmark) == extra || !destmark)
|
|
{
|
|
msg("invalid destination address");
|
|
return;
|
|
}
|
|
|
|
/* flesh the marks out to encompass whole lines */
|
|
frommark &= ~(BLKSIZE - 1);
|
|
tomark = (tomark & ~(BLKSIZE - 1)) + BLKSIZE;
|
|
destmark = (destmark & ~(BLKSIZE - 1)) + BLKSIZE;
|
|
|
|
/* make sure the destination is valid */
|
|
if (cmd == CMD_MOVE && destmark >= frommark && destmark < tomark)
|
|
{
|
|
msg("invalid destination address");
|
|
}
|
|
|
|
/* Do it */
|
|
ChangeText
|
|
{
|
|
/* save the text to a cut buffer */
|
|
cutname('\0');
|
|
cut(frommark, tomark);
|
|
|
|
/* if we're not copying, delete the old text & adjust destmark */
|
|
if (cmd != CMD_COPY)
|
|
{
|
|
delete(frommark, tomark);
|
|
if (destmark >= frommark)
|
|
{
|
|
destmark -= (tomark - frommark);
|
|
}
|
|
}
|
|
|
|
/* add the new text */
|
|
paste(destmark, FALSE, FALSE);
|
|
}
|
|
|
|
/* move the cursor to the last line of the moved text */
|
|
cursor = destmark + (tomark - frommark) - BLKSIZE;
|
|
if (cursor < MARK_FIRST || cursor >= MARK_LAST + BLKSIZE)
|
|
{
|
|
cursor = MARK_LAST;
|
|
}
|
|
|
|
/* Reporting... */
|
|
rptlabel = ( (cmd == CMD_COPY) ? "copied" : "moved" );
|
|
}
|
|
|
|
|
|
|
|
/* execute EX commands from a file */
|
|
/*ARGSUSED*/
|
|
void cmd_source(frommark, tomark, cmd, bang, extra)
|
|
MARK frommark;
|
|
MARK tomark;
|
|
CMD cmd;
|
|
int bang;
|
|
char *extra;
|
|
{
|
|
/* must have a filename */
|
|
if (!*extra)
|
|
{
|
|
msg("\"source\" requires a filename");
|
|
return;
|
|
}
|
|
|
|
doexrc(extra);
|
|
}
|
|
|
|
|
|
#ifndef NO_AT
|
|
/*ARGSUSED*/
|
|
void cmd_at(frommark, tomark, cmd, bang, extra)
|
|
MARK frommark;
|
|
MARK tomark;
|
|
CMD cmd;
|
|
int bang;
|
|
char *extra;
|
|
{
|
|
static nest = FALSE;
|
|
int result;
|
|
char buf[MAXRCLEN];
|
|
|
|
/* don't allow nested macros */
|
|
if (nest)
|
|
{
|
|
msg("@ macros can't be nested");
|
|
return;
|
|
}
|
|
nest = TRUE;
|
|
|
|
/* require a buffer name */
|
|
if (*extra == '"')
|
|
extra++;
|
|
if (!*extra || !isascii(*extra) ||!islower(*extra))
|
|
{
|
|
msg("@ requires a cut buffer name (a-z)");
|
|
}
|
|
|
|
/* get the contents of the buffer */
|
|
result = cb2str(*extra, buf, (unsigned)(sizeof buf));
|
|
if (result <= 0)
|
|
{
|
|
msg("buffer \"%c is empty", *extra);
|
|
}
|
|
else if (result >= sizeof buf)
|
|
{
|
|
msg("buffer \"%c is too large to execute", *extra);
|
|
}
|
|
else
|
|
{
|
|
/* execute the contents of the buffer as ex commands */
|
|
exstring(buf, result, '\\');
|
|
}
|
|
|
|
nest = FALSE;
|
|
}
|
|
#endif
|