自学教程：C++ INCCS函数代码示例

intcapitalizeword(UNUSED(char **args)){    int first, n = zmult;    int neg = n < 0, ocs = zlecs;    if (neg)	n = -n;    while (n--) {	first = 1;	while (zlecs != zlell && !ZC_iword(zleline[zlecs]))	    INCCS();	while (zlecs != zlell && ZC_iword(zleline[zlecs]) && !ZC_ialpha(zleline[zlecs]))	    INCCS();	while (zlecs != zlell && ZC_iword(zleline[zlecs])) {	    zleline[zlecs] = (first) ? ZC_toupper(zleline[zlecs]) :		ZC_tolower(zleline[zlecs]);	    first = 0;	    INCCS();	}    }    if (neg)	zlecs = ocs;    return 0;}

intviforwardword(char **args){    int n = zmult;    if (n < 0) {	int ret;	zmult = -n;	ret = vibackwardword(args);	zmult = n;	return ret;    }    while (n--) {	int nl;	int cc = wordclass(zleline[zlecs]);	while (zlecs != zlell && wordclass(zleline[zlecs]) == cc) {	    INCCS();	}	if (wordflag && !n)	    return 0;	nl = (zleline[zlecs] == ZWC('/n'));	while (zlecs != zlell && nl < 2 && ZC_inblank(zleline[zlecs])) {	    INCCS();	    nl += (zleline[zlecs] == ZWC('/n'));	}    }    return 0;}

intviforwardword(char **args){    int n = zmult;    if (n < 0) {	int ret;	zmult = -n;	ret = backwardword(args);	zmult = n;	return ret;    }    while (n--) {	int nl;	if (Z_vialnum(zleline[zlecs]))	    while (zlecs != zlell && Z_vialnum(zleline[zlecs]))		INCCS();	else	    while (zlecs != zlell && !Z_vialnum(zleline[zlecs]) &&		    !ZC_inblank(zleline[zlecs]))		INCCS();	if (wordflag && !n)	    return 0;	nl = (zleline[zlecs] == ZWC('/n'));	while (zlecs != zlell && nl < 2 && ZC_inblank(zleline[zlecs])) {	    INCCS();	    nl += (zleline[zlecs] == ZWC('/n'));	}    }    return 0;}

inttransposechars(UNUSED(char **args)){    int ct;    int n = zmult;    int neg = n < 0;    if (neg)	n = -n;    while (n--) {	if (!(ct = zlecs) || zleline[zlecs - 1] == '/n') {	    if (zlell == zlecs || zleline[zlecs] == '/n')		return 1;	    if (!neg)		INCCS();	    INCPOS(ct);	}	if (neg) {	    if (zlecs && zleline[zlecs - 1] != '/n') {		DECCS();		if (ct > 1 && zleline[ct - 2] != '/n') {		    DECPOS(ct);		}	    }	} else {	    if (zlecs != zlell && zleline[zlecs] != '/n')		INCCS();	}	if (ct == zlell || zleline[ct] == '/n') {	    DECPOS(ct);	}	if (ct < 1 || zleline[ct - 1] == '/n')	    return 1;#ifdef MULTIBYTE_SUPPORT	{	    /*	     * We should keep any accents etc. on their original characters.	     */	    int start = ct, end = ct;	    DECPOS(start);	    INCPOS(end);	    transpose_swap(start, ct, end);	}#else	{	    ZLE_CHAR_T cc = zleline[ct - 1];	    zleline[ct - 1] = zleline[ct];	    zleline[ct] = cc;	}#endif    }    return 0;}

intvioperswapcase(UNUSED(char **args)){    int oldcs, c2, ret = 1;    /* get the range */    startvichange(1);    if ((c2 = getvirange(0)) != -1) {	oldcs = zlecs;	/* swap the case of all letters within range */	while (zlecs < c2) {	    if (ZC_ilower(zleline[zlecs]))		zleline[zlecs] = ZC_toupper(zleline[zlecs]);	    else if (ZC_iupper(zleline[zlecs]))		zleline[zlecs] = ZC_tolower(zleline[zlecs]);	    INCCS();	}	/* go back to the first line of the range */	zlecs = oldcs;	ret = 0;#if 0	vifirstnonblank();#endif    }    vichgflag = 0;    return ret;}

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

intviforwardblankwordend(char **args){    int n = zmult;    if (n < 0) {	int ret;	zmult = -n;	ret = vibackwardblankwordend(args);	zmult = n;	return ret;    }    while (n--) {	while (zlecs != zlell) {	    int pos = zlecs;	    INCPOS(pos);	    if (!ZC_inblank(zleline[pos]))		break;	    zlecs = pos;	}	while (zlecs != zlell) {	    int pos = zlecs;	    INCPOS(pos);	    if (ZC_inblank(zleline[pos]))		break;	    zlecs = pos;	}    }    if (zlecs != zlell && virangeflag)	INCCS();    return 0;}

intviputafter(UNUSED(char **args)){    Cutbuffer buf = &cutbuf;    int n = zmult;    startvichange(-1);    if (n < 0)	return 1;    if (zmod.flags & MOD_VIBUF)	buf = &vibuf[zmod.vibuf];    if (!buf->buf)	return 1;    if(buf->flags & CUTBUFFER_LINE) {	zlecs = findeol();	spaceinline(buf->len + 1);	zleline[zlecs++] = ZWC('/n');	ZS_memcpy(zleline + zlecs, buf->buf, buf->len);	vifirstnonblank(zlenoargs);    } else {	if (zlecs != findeol())	    INCCS();	while (n--) {	    spaceinline(buf->len);	    ZS_memcpy(zleline + zlecs, buf->buf, buf->len);	    zlecs += buf->len;	}	if (zlecs)	    DECCS();    }    return 0;}

static intdovilinerange(void){    int pos = zlecs, n = zmult;    /* A number of lines is taken as the range.  The current line *     * is included.  If the repeat count is positive the lines go *     * downward, otherwise upward.  The repeat count gives the    *     * number of lines.                                           */    vilinerange = 1;    if (!n)	return 1;    if (n > 0) {	while(n-- && zlecs <= zlell)	    zlecs = findeol() + 1;	if (n != -1) {	    zlecs = pos;	    return 1;	}	DECCS();    } else {	while(n++ && zlecs >= 0)	    zlecs = findbol() - 1;	if (n != 1) {	    zlecs = pos;	    return 1;	}	INCCS();    }    virangeflag = 2;    return 0;}

intviaddnext(UNUSED(char **args)){    if (zlecs != findeol())	INCCS();    startvitext(1);    return 0;}

intdowncaseword(UNUSED(char **args)){    int n = zmult;    int neg = n < 0, ocs = zlecs;    if (neg)	n = -n;    while (n--) {	while (zlecs != zlell && !ZC_iword(zleline[zlecs]))	    INCCS();	while (zlecs != zlell && ZC_iword(zleline[zlecs])) {	    zleline[zlecs] = ZC_tolower(zleline[zlecs]);	    INCCS();	}    }    if (neg)	zlecs = ocs;    return 0;}

intforwardword(char **args){    int n = zmult;    if (n < 0) {	int ret;	zmult = -n;	ret = backwardword(args);	zmult = n;	return ret;    }    while (n--) {	while (zlecs != zlell && ZC_iword(zleline[zlecs]))	    INCCS();	if (wordflag && !n)	    return 0;	while (zlecs != zlell && !ZC_iword(zleline[zlecs]))	    INCCS();    }    return 0;}

intgosmacstransposechars(UNUSED(char **args)){    if (zlecs < 2 || zleline[zlecs - 1] == '/n' || zleline[zlecs - 2] == '/n') {	int twice = (zlecs == 0 || zleline[zlecs - 1] == '/n');	if (zlecs == zlell || zleline[zlecs] == '/n')	    return 1;	INCCS();	if (twice) {	    if (zlecs == zlell || zleline[zlecs] == '/n')		return 1;	    INCCS();	}    }#ifdef MULTIBYTE_SUPPORT    {	int start, middle;	middle = zlecs;	DECPOS(middle);	start = middle;	DECPOS(start);	transpose_swap(start, middle, zlecs);    }#else    {	ZLE_CHAR_T cc = zleline[zlecs - 2];	zleline[zlecs - 2] = zleline[zlecs - 1];	zleline[zlecs - 1] = cc;    }#endif    return 0;}

intviforwardwordend(char **args){    int n = zmult;    if (n < 0) {	int ret;	zmult = -n;	ret = vibackwardwordend(args);	zmult = n;	return ret;    }    while (n--) {	int pos;	while (zlecs != zlell) {	    pos = zlecs;	    INCPOS(pos);	    if (!ZC_inblank(zleline[pos]))		break;	    zlecs = pos;	}	if (zlecs != zlell) {	    pos = zlecs;	    INCPOS(pos);	    if (Z_vialnum(zleline[pos])) {		for (;;) {		    zlecs = pos;		    if (zlecs == zlell)			break;		    INCPOS(pos);		    if (!Z_vialnum(zleline[pos]))			break;		}	    } else {		for (;;) {		    zlecs = pos;		    if (zlecs == zlell)			break;		    INCPOS(pos);		    if (Z_vialnum(zleline[pos]) || ZC_inblank(zleline[pos]))			break;		}	    }	}    }    if (zlecs != zlell && virangeflag)	INCCS();    return 0;}

intvibackwardword(char **args){    int n = zmult;    if (n < 0) {	int ret;	zmult = -n;	ret = backwardword(args);	zmult = n;	return ret;    }    while (n--) {	int nl = 0;	while (zlecs) {	    DECCS();	    if (!ZC_inblank(zleline[zlecs]))		break;	    nl += (zleline[zlecs] == ZWC('/n'));	    if (nl == 2) {		INCCS();		break;	    }	}	if (zlecs) {	    int pos = zlecs;	    if (Z_vialnum(zleline[pos])) {		for (;;) {		    zlecs = pos;		    if (zlecs == 0)			break;		    DECPOS(pos);		    if (!Z_vialnum(zleline[pos]))			break;		}	    } else {		for (;;) {		    zlecs = pos;		    if (zlecs == 0)			break;		    DECPOS(pos);		    if (Z_vialnum(zleline[pos]) || ZC_inblank(zleline[pos]))			break;		}	    }	}    }    return 0;}

/* position: 0 is before, 1 after, 2 split the line */static void pastebuf(Cutbuffer buf, int mult, int position){    int cc;    if (buf->flags & CUTBUFFER_LINE) {	if (position == 2) {	    if (!zlecs)		position = 0;	    else if (zlecs == zlell)		position = 1;	}	if (position == 2) {	    yankb = zlecs;	    spaceinline(buf->len + 2);	    zleline[zlecs++] = ZWC('/n');	    ZS_memcpy(zleline + zlecs, buf->buf, buf->len);	    zlecs += buf->len;	    zleline[zlecs] = ZWC('/n');	    yanke = zlecs + 1;	} else if (position != 0) {	    yankb = zlecs = findeol();	    spaceinline(buf->len + 1);	    zleline[zlecs++] = ZWC('/n');	    yanke = zlecs + buf->len;	    ZS_memcpy(zleline + zlecs, buf->buf, buf->len);	} else {	    yankb = zlecs = findbol();	    spaceinline(buf->len + 1);	    ZS_memcpy(zleline + zlecs, buf->buf, buf->len);	    yanke = zlecs + buf->len + 1;	    zleline[zlecs + buf->len] = ZWC('/n');	}	vifirstnonblank(zlenoargs);    } else {	if (position == 1 && zlecs != findeol())	    INCCS();	yankb = zlecs;	cc = buf->len;	while (mult--) {	    spaceinline(cc);	    ZS_memcpy(zleline + zlecs, buf->buf, cc);	    zlecs += cc;	}	yanke = zlecs;	if (zlecs && invicmdmode())	    DECCS();    }}

mod_export voidforekill(int ct, int flags){    int i = zlecs;    UNMETACHECK();    if (!(flags & CUT_RAW)) {	int n = ct;	while (n--)	    INCCS();	ct = zlecs - i;	zlecs = i;    }    cut(i, ct, flags);    shiftchars(i, ct);    CCRIGHT();}

intviswapcase(UNUSED(char **args)){    int eol, n = zmult;    startvichange(-1);    if (n < 1)	return 1;    eol = findeol();    while (zlecs < eol && n--) {	if (ZC_ilower(zleline[zlecs]))	    zleline[zlecs] = ZC_toupper(zleline[zlecs]);	else if (ZC_iupper(zleline[zlecs]))	    zleline[zlecs] = ZC_tolower(zleline[zlecs]);	INCCS();    }    if (zlecs && zlecs == eol)	DECCS();    return 0;}

intvidowncase(UNUSED(char **args)){    int oldcs, c2, ret = 1;    /* get the range */    startvichange(1);    if ((c2 = getvirange(0)) != -1) {	oldcs = zlecs;	/* convert the case of all letters within range */	while (zlecs < c2) {	    zleline[zlecs] = ZC_tolower(zleline[zlecs]);	    INCCS();	}	/* go back to the first line of the range */	zlecs = oldcs;	ret = 0;    }    vichgflag = 0;    return ret;}

intdeletechar(char **args){    int n;    if (zmult < 0) {	int ret;	zmult = -zmult;	ret = backwarddeletechar(args);	zmult = -zmult;	return ret;    }    n = zmult;    while (n--) {	if (zlecs == zlell)	    return 1;	INCCS();    }    backdel(zmult, 0);    return 0;}

intviforwardwordend(char **args){    int n = zmult;    if (n < 0) {	int ret;	zmult = -n;	ret = vibackwardwordend(args);	zmult = n;	return ret;    }    while (n--) {	int pos;	while (zlecs != zlell) {	    pos = zlecs;	    INCPOS(pos);	    if (!ZC_inblank(zleline[pos]))		break;	    zlecs = pos;	}	if (zlecs != zlell) {	    int cc;	    pos = zlecs;	    INCPOS(pos);	    cc = wordclass(zleline[pos]);	    for (;;) {		zlecs = pos;		if (zlecs == zlell)		    break;		INCPOS(pos);		if (wordclass(zleline[pos]) != cc)			break;	    }	}    }    if (zlecs != zlell && virangeflag)	INCCS();    return 0;}

intvibackwardword(char **args){    int n = zmult;    if (n < 0) {	int ret;	zmult = -n;	ret = viforwardword(args);	zmult = n;	return ret;    }    while (n--) {	int nl = 0;	while (zlecs) {	    DECCS();	    if (!ZC_inblank(zleline[zlecs]))		break;	    nl += (zleline[zlecs] == ZWC('/n'));	    if (nl == 2) {		INCCS();		break;	    }	}	if (zlecs) {	    int pos = zlecs;	    int cc = wordclass(zleline[pos]);	    for (;;) {		zlecs = pos;		if (zlecs == 0)		    break;		DECPOS(pos);		if (wordclass(zleline[pos]) != cc || ZC_inblank(zleline[pos]))		    break;	    }	}    }    return 0;}

mod_export voidforedel(int ct, int flags){    if (flags & CUT_RAW) {	if (zlemetaline != NULL) {	    shiftchars(zlemetacs, ct);	} else if (flags & CUT_RAW) {	    shiftchars(zlecs, ct);	    CCRIGHT();	}    } else {	int origcs = zlecs;	int n = ct;	DPUTS(zlemetaline != NULL, "foredel needs CUT_RAW when metafied");	while (n--)	    INCCS();	ct = zlecs - origcs;	zlecs = origcs;	shiftchars(zlecs, ct);	CCRIGHT();    }}

static intgetvirange(int wf){    int pos = zlecs, ret = 0;    int mult1 = zmult, hist1 = histline;    Thingy k2;    virangeflag = 1;    wordflag = wf;    /* Now we need to execute the movement command, to see where it *     * actually goes.  virangeflag here indicates to the movement   *     * function that it should place the cursor at the end of the   *     * range, rather than where the cursor would actually go if it  *     * were executed normally.  This makes a difference to some     *     * commands, but not all.  For example, if searching forward    *     * for a character, under normal circumstances the cursor lands *     * on the character.  For a range, the range must include the   *     * character, so the cursor gets placed after the character if  *     * virangeflag is set.  vi-match-bracket needs to change the    *     * value of virangeflag under some circumstances, meaning that  *     * we need to change the *starting* position.                   */    zmod.flags &= ~MOD_TMULT;    do {	vilinerange = 0;	prefixflag = 0;	if (!(k2 = getkeycmd()) || (k2->flags & DISABLED) ||		k2 == Th(z_sendbreak)) {	    wordflag = 0;	    virangeflag = 0;	    return -1;	}	/*	 * With k2 == bindk, the command key is repeated:	 * a number of lines is used.  If the function used	 * returns 1, we fail.	 */	if ((k2 == bindk) ? dovilinerange() : execzlefunc(k2, zlenoargs, 1))	    ret = -1;	if(vichgrepeat)	    zmult = mult1;	else	    zmult = mult1 * zmod.tmult;    } while(prefixflag && !ret);    wordflag = 0;    virangeflag = 0;    /* It is an error to use a non-movement command to delimit the *     * range.  We here reject the case where the command modified  *     * the line, or selected a different history line.             */    if (histline != hist1 || zlell != lastll || memcmp(zleline, lastline, zlell)) {	histline = hist1;	ZS_memcpy(zleline, lastline, zlell = lastll);	zlecs = pos;	return -1;    }    /* Can't handle an empty file.  Also, if the movement command *     * failed, or didn't move, it is an error.                    */    if (!zlell || (zlecs == pos && virangeflag != 2) || ret == -1)	return -1;    /* vi-match-bracket changes the value of virangeflag when *     * moving to the opening bracket, meaning that we need to *     * change the *starting* position.                        */    if(virangeflag == -1)    {	int origcs = zlecs;	zlecs = pos;	INCCS();	pos = zlecs;	zlecs = origcs;    }    /* Get the range the right way round.  zlecs is placed at the *     * start of the range, and pos (the return value of this   *     * function) is the end.                                   */    if (zlecs > pos) {	int tmp = zlecs;	zlecs = pos;	pos = tmp;    }    /* Was it a line-oriented move?  If so, the command will have set *     * the vilinerange flag.  In this case, entire lines are taken,   *     * rather than just the sequence of characters delimited by pos   *     * and zlecs.  The terminating newline is left out of the range,     *     * which the real command must deal with appropriately.  At this  *     * point we just need to make the range encompass entire lines.   */    if(vilinerange) {	int newcs = findbol();	zlecs = pos;	pos = findeol();	zlecs = newcs;    }    return pos;}