int
poundinsert(UNUSED(char **args))
{
zlecs = 0;
vifirstnonblank(zlenoargs);
if (zleline[zlecs] != '#') {
spaceinline(1);
zleline[zlecs] = '#';
zlecs = findeol();
while(zlecs != zlell) {
zlecs++;
vifirstnonblank(zlenoargs);
spaceinline(1);
zleline[zlecs] = '#';
zlecs = findeol();
}
} else {
foredel(1, 0);
zlecs = findeol();
while(zlecs != zlell) {
zlecs++;
vifirstnonblank(zlenoargs);
if(zleline[zlecs] == '#')
foredel(1, 0);
zlecs = findeol();
}
}
done = 1;
return 0;
}
void
viunindent(void)
{
int oldcs = cs, c2;
/* get the range */
startvichange(1);
if ((c2 = getvirange(0)) == -1) {
vichgflag = vilinerange = 0;
return;
}
vichgflag = 0;
/* must be a line range */
if (!vilinerange) {
feep();
cs = oldcs;
return;
}
vilinerange = 0;
oldcs = cs;
/* remove a tab from the beginning of each line within range */
while (cs < c2) {
if (line[cs] == '\t')
foredel(1);
cs = findeol() + 1;
}
/* go back to the first line of the range */
cs = oldcs;
vifirstnonblank();
}
int
viquotedinsert(char **args)
{
#ifndef HAS_TIO
struct sgttyb sob;
#endif
spaceinline(1);
zleline[zlecs] = '^';
zrefresh();
#ifndef HAS_TIO
sob = shttyinfo.sgttyb;
sob.sg_flags = (sob.sg_flags | RAW) & ~ECHO;
ioctl(SHTTY, TIOCSETN, &sob);
#endif
getfullchar(0);
#ifndef HAS_TIO
zsetterm();
#endif
foredel(1, 0);
if(LASTFULLCHAR == ZLEEOF)
return 1;
else
return selfinsert(args);
}
int
killregion(UNUSED(char **args))
{
if (mark > zlell)
mark = zlell;
if (region_active == 2) {
int a, b;
regionlines(&a, &b);
zlecs = a;
region_active = 0;
cut(zlecs, b - zlecs, CUT_RAW);
shiftchars(zlecs, b - zlecs);
if (zlell) {
if (zlecs == zlell)
DECCS();
foredel(1, 0);
vifirstnonblank(zlenoargs);
}
} else if (mark > zlecs) {
if (invicmdmode())
INCPOS(mark);
forekill(mark - zlecs, CUT_RAW);
} else {
if (invicmdmode())
INCCS();
backkill(zlecs - mark, CUT_FRONT|CUT_RAW);
}
return 0;
}
int
quoteregion(UNUSED(char **args))
{
ZLE_STRING_T str;
size_t len;
int extra = invicmdmode();
if (mark > zlell)
mark = zlell;
if (region_active == 2) {
int a, b;
regionlines(&a, &b);
zlecs = a;
mark = b;
extra = 0;
} else if (mark < zlecs) {
int tmp = mark;
mark = zlecs;
zlecs = tmp;
}
if (extra)
INCPOS(mark);
str = (ZLE_STRING_T)hcalloc((len = mark - zlecs) *
ZLE_CHAR_SIZE);
ZS_memcpy(str, zleline + zlecs, len);
foredel(len, CUT_RAW);
str = makequote(str, &len);
spaceinline(len);
ZS_memcpy(zleline + zlecs, str, len);
mark = zlecs;
zlecs += len;
return 0;
}
int
vipoundinsert(UNUSED(char **args))
{
int oldcs = zlecs;
startvichange(-1);
vifirstnonblank(zlenoargs);
if(zleline[zlecs] != '#') {
spaceinline(1);
zleline[zlecs] = '#';
if(zlecs <= viinsbegin)
INCPOS(viinsbegin);
if (zlecs <= oldcs)
INCPOS(oldcs);
zlecs = oldcs;
} else {
foredel(1, 0);
if (zlecs < viinsbegin)
DECPOS(viinsbegin);
if (zlecs < oldcs)
DECPOS(oldcs);
zlecs = oldcs;
}
return 0;
}
int
viunindent(UNUSED(char **args))
{
int oldcs = zlecs, c2;
/* get the range */
startvichange(1);
if ((c2 = getvirange(0)) == -1) {
vichgflag = 0;
return 1;
}
vichgflag = 0;
/* must be a line range */
if (!vilinerange) {
zlecs = oldcs;
return 1;
}
oldcs = zlecs;
/* remove a tab from the beginning of each line within range */
while (zlecs < c2) {
if (zleline[zlecs] == '\t')
foredel(1, 0);
zlecs = findeol() + 1;
}
/* go back to the first line of the range */
zlecs = oldcs;
vifirstnonblank(zlenoargs);
return 0;
}
void
viquotedinsert(void)
{
#ifndef WINNT
#ifndef HAS_TIO
struct sgttyb sob;
#endif
#endif /* WINNT */
spaceinline(1);
line[cs] = '^';
refresh();
#ifndef WINNT
#ifndef HAS_TIO
sob = shttyinfo.sgttyb;
sob.sg_flags = (sob.sg_flags | RAW) & ~ECHO;
ioctl(SHTTY, TIOCSETN, &sob);
#endif
#endif /* WINNT */
c = getkey(0);
#ifndef WINNT
#ifndef HAS_TIO
setterm();
#endif
#endif /* WINNT */
foredel(1);
if(c < 0)
feep();
else
selfinsert();
}
int
yankpop(UNUSED(char **args))
{
int cc, kctstart = kct;
Cutbuffer buf;
if (!(lastcmd & ZLE_YANK) || !kring || !kctbuf) {
kctbuf = NULL;
return 1;
}
do {
/*
* This is supposed to make the yankpop loop
* original buffer -> kill ring in order -> original buffer -> ...
* where the original buffer is -1 and the remainder are
* indices into the kill ring, remember that we need to start
* that at kringnum rather than zero.
*/
if (kct == -1)
kct = kringnum;
else {
int kctnew = (kct + kringsize - 1) % kringsize;
if (kctnew == kringnum)
kct = -1;
else
kct = kctnew;
}
if (kct == -1)
buf = kctbuf; /* Use original cutbuffer */
else
buf = kring+kct; /* Use somewhere in the kill ring */
/* Careful to prevent infinite looping */
if (kct == kctstart)
return 1;
/*
* Skip unset buffers instead of stopping as we used to do.
* Also skip zero-length buffers.
* There are two reasons for this:
* 1. We now map the array $killring directly into the
* killring, instead of via some extra size-checking logic.
* When $killring has been set, a buffer will always have
* at least a zero-length string in it.
* 2. The old logic was inconsistent; when the kill ring
* was full, we could loop round and round it, otherwise
* we just stopped when we hit the first empty buffer.
*/
} while (!buf->buf || *buf->buf == ZWC('\0'));
zlecs = yankb;
foredel(yanke - yankb, CUT_RAW);
cc = buf->len;
spaceinline(cc);
ZS_memcpy(zleline + zlecs, buf->buf, cc);
zlecs += cc;
yanke = zlecs;
return 0;
}
/**
* Widget method that will be called when a tab key is pressed.
*/
static int rift_complete(UNUSED(char** arg))
{
int new_len = 0;
char *new_line = NULL;
int i = 0;
/* Metafy - changes the zleline to string and stores in zlemetaline
* zleline is not in string format */
metafy_line();
for (i = 0; zlemetaline[i] != '\0'; i++) {
if (zlemetaline[i] == '|' || zlemetaline[i] == '>') {
unmetafy_line();
execzlefunc(rwcli_controller.t_orig_tab_bind, zlenoargs, 0);
return 0;
}
}
new_line = rwcli_tab_complete(zlemetaline);
fflush(stdout);
if (new_line) {
new_len = strlen(new_line);
if ((new_len > 1 && new_line[new_len - 1] != ' ') ||
(zlemetall == new_len)) {
trash_line();
}
// First truncate the zlemetaline and then insert the new line
// zlemetacs is the cursor, zlemetall is the line length
zlemetacs = 0;
foredel(zlemetall, CUT_RAW);
inststrlen(new_line, new_len, new_len);
free(new_line);
} else {
trash_line();
zlemetacs = 0;
foredel(zlemetall, CUT_RAW);
}
unmetafy_line();
/* zlemeta* is not valid beyond this point */
return 0;
}
void
insertlastword(void)
{
int n;
char *s, *t;
int len;
Histent he;
/* multiple calls will now search back through the history, pem */
static char *lastinsert;
static int lasthist, lastpos;
int evhist = curhist - 1, save;
if (lastinsert) {
int lastlen = ztrlen(lastinsert);
int pos = cs;
if (lastpos <= pos &&
lastlen == pos - lastpos &&
memcmp(lastinsert, (char *)&line[lastpos], lastlen) == 0) {
evhist = --lasthist;
cs = lastpos;
foredel(pos - cs);
}
zsfree(lastinsert);
lastinsert = NULL;
}
if (!(he = quietgethist(evhist)) || !he->nwords) {
feep();
return;
}
if (zmult > 0) {
n = he->nwords - (zmult - 1);
} else {
n = 1 - zmult;
}
if (n < 1 || n > he->nwords) {
feep();
return;
}
s = he->text + he->words[2*n-2];
t = he->text + he->words[2*n-1];
save = *t;
*t = '\0'; /* ignore trailing whitespace */
lasthist = evhist;
lastpos = cs;
lastinsert = ztrdup(s);
spaceinline(len = ztrlen(s));
while (len--) {
line[cs++] = *s == Meta ? *++s ^ 32 : *s;
s++;
}
*t = save;
}
void poundinsert() /**/
{
if (*line != '#') {
cs = 0;
spaceinline(1);
*line = '#';
} else {
cs = 0;
foredel(1);
}
done = 1;
}
void
videlete(void)
{
int c2;
startvichange(1);
if ((c2 = getvirange(0)) != -1) {
forekill(c2 - cs, 0);
if (vilinerange && ll) {
if (cs == ll)
cs--;
foredel(1);
vifirstnonblank();
}
}
vichgflag = vilinerange = 0;
}
void yankpop() /**/
{
int cc;
if (!(lastcmd & ZLE_YANK) || !kring[kct]) {
feep();
return;
}
cs = yankb;
foredel(yanke-yankb);
cc = strlen(kring[kct]);
spaceinline(cc);
strncpy((char *) line+cs,kring[kct],cc);
cs += cc;
yanke = cs;
kct = (kct-1) & (KRINGCT-1);
}
static int
applychange(struct change *ch)
{
if(ch->hist != histline) {
zle_setline(quietgethist(ch->hist));
zlecs = ch->old_cs;
return 0;
}
zlecs = ch->off;
if(ch->del)
foredel(ch->dell, CUT_RAW);
if(ch->ins) {
spaceinline(ch->insl);
ZS_memcpy(zleline + zlecs, ch->ins, ch->insl);
zlecs += ch->insl;
}
zlecs = ch->new_cs;
return 1;
}
int
videlete(UNUSED(char **args))
{
int c2, ret = 1;
startvichange(1);
if ((c2 = getvirange(0)) != -1) {
forekill(c2 - zlecs, CUT_RAW);
ret = 0;
if (vilinerange && zlell) {
if (zlecs == zlell)
DECCS();
foredel(1, 0);
vifirstnonblank(zlenoargs);
}
}
vichgflag = 0;
return ret;
}
void
vipoundinsert(void)
{
int oldcs = cs;
startvichange(-1);
vifirstnonblank();
if(line[cs] != '#') {
spaceinline(1);
line[cs] = '#';
if(cs <= viinsbegin)
viinsbegin++;
cs = oldcs + (cs <= oldcs);
} else {
foredel(1);
if (cs < viinsbegin)
viinsbegin--;
cs = oldcs - (cs < oldcs);
}
}
int
deleteword(char **args)
{
int x = zlecs;
int n = zmult;
if (n < 0) {
int ret;
zmult = -n;
ret = backwarddeleteword(args);
zmult = n;
return ret;
}
while (n--) {
while (x != zlell && !ZC_iword(zleline[x]))
INCPOS(x);
while (x != zlell && ZC_iword(zleline[x]))
INCPOS(x);
}
foredel(x - zlecs, CUT_RAW);
return 0;
}
void quoteregion() /**/
{
char *s,*t;
int x,y;
if (mark > ll)
mark = ll;
if (mark < cs)
{
x = mark;
mark = cs;
cs = x;
}
s = hcalloc((y = mark-cs)+1);
strncpy(s,(char *) line+cs,y);
s[y] = '\0';
foredel(mark-cs);
t = makequote(s);
spaceinline(x = strlen(t));
strncpy((char *) line+cs,t,x);
mark = cs;
cs += x;
}
int
quoteregion(UNUSED(char **args))
{
ZLE_STRING_T str;
size_t len;
if (mark > zlell)
mark = zlell;
if (mark < zlecs) {
int tmp = mark;
mark = zlecs;
zlecs = tmp;
}
str = (ZLE_STRING_T)hcalloc((len = mark - zlecs) * ZLE_CHAR_SIZE);
ZS_memcpy(str, zleline + zlecs, len);
foredel(len, CUT_RAW);
str = makequote(str, &len);
spaceinline(len);
ZS_memcpy(zleline + zlecs, str, len);
mark = zlecs;
zlecs += len;
return 0;
}
