normal.c

STEVIE文本文件编缉器的C 语言源程序

		mtype = MCHAR;
		mincl = FALSE;
		beginline(TRUE);
		break;

	case '0':
		mtype = MCHAR;
		mincl = TRUE;
		beginline(FALSE);
		break;

	/*
	 * Searches of various kinds
	 */
	case '?':
	case '/':
		s = getcmdln(c);	/* get the search string */

		/*
		 * If they backspaced out of the search command,
		 * just bag everything.
		 */
		if (s == NULL) {
			CLEAROP;
			break;
		}

		mtype = MCHAR;
		mincl = FALSE;
		set_want_col = TRUE;

		/*
		 * If no string given, pass NULL to repeat the prior search.
		 * If the search fails, abort any pending operator.
		 */
		if (!dosearch(
				(c == '/') ? FORWARD : BACKWARD,
				(*s == NUL) ? NULL : s
			     ))
			CLEAROP;
		break;

	case 'n':
		mtype = MCHAR;
		mincl = FALSE;
		set_want_col = TRUE;
		if (!repsearch(0))
			CLEAROP;
		break;

	case 'N':
		mtype = MCHAR;
		mincl = FALSE;
		set_want_col = TRUE;
		if (!repsearch(1))
			CLEAROP;
		break;

	/*
	 * Character searches
	 */
	case 'T':
		dir = BACKWARD;
		/* fall through */

	case 't':
		type = 1;
		goto docsearch;

	case 'F':
		dir = BACKWARD;
		/* fall through */

	case 'f':
	docsearch:
		mtype = MCHAR;
		mincl = TRUE;
		set_want_col = TRUE;
		if ((nchar = vgetc()) == ESC)	/* search char */
			break;

		for (n = DEFAULT1(Prenum); n > 0 ;n--) {
			if (!searchc(nchar, dir, type)) {
				CLEAROP;
				beep();
			}
		}
		break;

	case ',':
		flag = 1;
		/* fall through */

	case ';':
		mtype = MCHAR;
		mincl = TRUE;
		set_want_col = TRUE;
		for (n = DEFAULT1(Prenum); n > 0 ;n--) {
			if (!crepsearch(flag)) {
				CLEAROP;
				beep();
			}
		}
		break;

	case '[':			/* function searches */
		dir = BACKWARD;
		/* fall through */

	case ']':
		mtype = MLINE;
		set_want_col = TRUE;
		if (vgetc() != c) {
			beep();
			CLEAROP;
			break;
		}

		if (!findfunc(dir)) {
			beep();
			CLEAROP;
		}
		break;

	case '%':
		mtype = MCHAR;
		mincl = TRUE;
		{
			LPTR	*pos;

			if ((pos = showmatch()) == NULL) {
				beep();
				CLEAROP;
			} else {
				setpcmark();
				*Curschar = *pos;
				set_want_col = TRUE;
			}
		}
		break;
		
	/*
	 * Edits
	 */
	case '.':		/* repeat last change (usually) */
		/*
		 * If a delete is in effect, we let '.' help out the same
		 * way that '_' helps for some line operations. It's like
		 * an 'l', but subtracts one from the count and is inclusive.
		 */
		if (operator == DELETE || operator == CHANGE) {
			if (Prenum != 0) {
				n = DEFAULT1(Prenum) - 1;
				while (n--)
					if (! oneright())
						break;
			}
			mtype = MCHAR;
			mincl = TRUE;
		} else {			/* a normal 'redo' */
			CLEAROP;
			stuffin(Redobuff);
		}
		break;

	case 'u':
	case K_UNDO:
		CLEAROP;
		u_undo();
		break;

	case 'U':
		CLEAROP;
		u_lundo();
		break;

	case 'x':
		CLEAROP;
		if (lineempty())	/* can't do it on a blank line */
			beep();
		if (Prenum)
			stuffnum(Prenum);
		stuffin("d.");
		break;

	case 'X':
		CLEAROP;
		if (!oneleft())
			beep();
		else {
			strcpy(Redobuff, "X");
			u_saveline();
			delchar(TRUE);
			updateline();
		}
		break;

	case 'r':
		CLEAROP;
		if (lineempty()) {	/* Nothing to replace */
			beep();
			break;
		}
		if ((nchar = vgetc()) == ESC)
			break;

		if ((nchar & 0x80) || nchar == CR || nchar == NL) {
			beep();
			break;
		}
		u_saveline();

		/* Change current character. */
		pchar(Curschar, nchar);

		/* Save stuff necessary to redo it */
		sprintf(Redobuff, "r%c", nchar);

		CHANGED;
		updateline();
		break;

	case '~':		/* swap case */
		if (!P(P_TO)) {
			CLEAROP;
			if (lineempty()) {
				beep();
				break;
			}
			c = gchar(Curschar);

			if (isalpha(c)) {
				if (islower(c))
					c = toupper(c);
				else
					c = tolower(c);
			}
			u_saveline();

			pchar(Curschar, c);	/* Change current character. */
			oneright();

			strcpy(Redobuff, "~");

			CHANGED;
			updateline();
		}
#ifdef	TILDEOP
		else {
			if (operator == TILDE)		/* handle '~~' */
				goto lineop;
			if (Prenum != 0)
				opnum = Prenum;
			startop = *Curschar;
			operator = TILDE;
		}
#endif

		break;

	case 'J':
		CLEAROP;

		u_save(Curschar->linep->prev, Curschar->linep->next->next);

		if (!dojoin(TRUE))
			beep();

		strcpy(Redobuff, "J");
		updatescreen();
		break;

	/*
	 * Inserts
	 */
	case 'A':
		set_want_col = TRUE;
		while (oneright())
			;
		/* fall through */

	case 'a':
		CLEAROP;
		/* Works just like an 'i'nsert on the next character. */
		if (!lineempty())
			inc(Curschar);
		u_saveline();
		startinsert(mkstr(c), FALSE);
		break;

	case 'I':
		beginline(TRUE);
		/* fall through */

	case 'i':
	case K_INSERT:
		CLEAROP;
		u_saveline();
		startinsert(mkstr(c), FALSE);
		break;

	case 'o':
		CLEAROP;
		u_save(Curschar->linep, Curschar->linep->next);
		opencmd(FORWARD, TRUE);
		startinsert("o", TRUE);
		break;

	case 'O':
		CLEAROP;
		u_save(Curschar->linep->prev, Curschar->linep);
		opencmd(BACKWARD, TRUE);
		startinsert("O", TRUE);
		break;

	case 'R':
		CLEAROP;
		u_saveline();
		startinsert("R", FALSE);
		break;

	/*
	 * Operators
	 */
	case 'd':
		if (operator == DELETE)		/* handle 'dd' */
			goto lineop;
		if (Prenum != 0)
			opnum = Prenum;
		startop = *Curschar;
		operator = DELETE;
		break;

	case 'c':
		if (operator == CHANGE)		/* handle 'cc' */
			goto lineop;
		if (Prenum != 0)
			opnum = Prenum;
		startop = *Curschar;
		operator = CHANGE;
		break;

	case 'y':
		if (operator == YANK)		/* handle 'yy' */
			goto lineop;
		if (Prenum != 0)
			opnum = Prenum;
		startop = *Curschar;
		operator = YANK;
		break;

	case '>':
		if (operator == RSHIFT)		/* handle >> */
			goto lineop;
		if (Prenum != 0)
			opnum = Prenum;
		startop = *Curschar;
		operator = RSHIFT;
		break;

	case '<':
		if (operator == LSHIFT)		/* handle << */
			goto lineop;
		if (Prenum != 0)
			opnum = Prenum;
		startop = *Curschar;	/* save current position */
		operator = LSHIFT;
		break;

	case '!':
		if (operator == FILTER)		/* handle '!!' */
			goto lineop;
		if (Prenum != 0)
			opnum = Prenum;
		startop = *Curschar;
		operator = FILTER;
		break;

	case 'p':
		doput(FORWARD);
		break;

	case 'P':
		doput(BACKWARD);
		break;

	/*
	 * Abbreviations
	 */
	case 'D':
		stuffin("d$");
		break;

	case 'Y':
		if (Prenum)
			stuffnum(Prenum);
		stuffin("yy");
		break;

	case 'C':
		stuffin("c$");
		break;

	case 's':				/* substitute characters */
		if (Prenum)
			stuffnum(Prenum);
		stuffin("c.");
		break;

	/*
	 * Marks
	 */
	case 'm':
		CLEAROP;
		if (!setmark(vgetc()))
			beep();
		break;

	case '\'':
		flag = TRUE;
		/* fall through */

	case '`':
		{
			LPTR	mtmp, *mark = getmark(vgetc());

			if (mark == NULL) {
				beep();
				CLEAROP;
			} else {
				mtmp = *mark;
				setpcmark();
				*Curschar = mtmp;
				if (flag)
					beginline(TRUE);
			}
			mtype = flag ? MLINE : MCHAR;
			mincl = TRUE;		/* ignored if not MCHAR */
			set_want_col = TRUE;
		}
		break;

	default:
		CLEAROP;
		beep();
		break;
	}

	/*
	 * If an operation is pending, handle it...
	 */
	if (finish_op) {		/* we just finished an operator */
		if (operator == NOP)	/* ... but it was cancelled */
			return;

		switch (operator) {

		case LSHIFT:
		case RSHIFT:
			doshift(operator, c, nchar, Prenum);
			break;

		case DELETE:
			dodelete(c, nchar, Prenum);
			break;

		case YANK:
			(void) doyank();	/* no redo on yank... */
			break;

		case CHANGE:
			dochange(c, nchar, Prenum);
			break;

		case FILTER:
			dofilter(c, nchar, Prenum);
			break;

#ifdef	TILDEOP
		case TILDE:
			dotilde(c, nchar, Prenum);
			break;
#endif

		default:
			beep();
		}
		operator = NOP;
	}
}