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; }