![[BACK]](/icons/back.gif){kind=icon}
Return to word.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / mg|
Return to word.c CVS log | Up to [local] / src / usr.bin / mg |
1.1 ! deraadt 1: /*
! 2: * Word mode commands.
! 3: * The routines in this file
! 4: * implement commands that work word at
! 5: * a time. There are all sorts of word mode
! 6: * commands.
! 7: */
! 8: #include "def.h"
! 9:
! 10: /*
! 11: * Move the cursor backward by
! 12: * "n" words. All of the details of motion
! 13: * are performed by the "backchar" and "forwchar"
! 14: * routines.
! 15: */
! 16: /*ARGSUSED*/
! 17: backword(f, n)
! 18: {
! 19: if (n < 0) return forwword(f | FFRAND, -n);
! 20: if (backchar(FFRAND, 1) == FALSE)
! 21: return FALSE;
! 22: while (n--) {
! 23: while (inword() == FALSE) {
! 24: if (backchar(FFRAND, 1) == FALSE)
! 25: return TRUE;
! 26: }
! 27: while (inword() != FALSE) {
! 28: if (backchar(FFRAND, 1) == FALSE)
! 29: return TRUE;
! 30: }
! 31: }
! 32: return forwchar(FFRAND, 1);
! 33: }
! 34:
! 35: /*
! 36: * Move the cursor forward by
! 37: * the specified number of words. All of the
! 38: * motion is done by "forwchar".
! 39: */
! 40: /*ARGSUSED*/
! 41: forwword(f, n)
! 42: {
! 43: if (n < 0)
! 44: return backword(f | FFRAND, -n);
! 45: while (n--) {
! 46: while (inword() == FALSE) {
! 47: if (forwchar(FFRAND, 1) == FALSE)
! 48: return TRUE;
! 49: }
! 50: while (inword() != FALSE) {
! 51: if (forwchar(FFRAND, 1) == FALSE)
! 52: return TRUE;
! 53: }
! 54: }
! 55: return TRUE;
! 56: }
! 57:
! 58: /*
! 59: * Move the cursor forward by
! 60: * the specified number of words. As you move,
! 61: * convert any characters to upper case.
! 62: */
! 63: /*ARGSUSED*/
! 64: upperword(f, n)
! 65: {
! 66: register int c;
! 67:
! 68: if (n < 0) return FALSE;
! 69: while (n--) {
! 70: while (inword() == FALSE) {
! 71: if (forwchar(FFRAND, 1) == FALSE)
! 72: return TRUE;
! 73: }
! 74: while (inword() != FALSE) {
! 75: c = lgetc(curwp->w_dotp, curwp->w_doto);
! 76: if (ISLOWER(c) != FALSE) {
! 77: c = TOUPPER(c);
! 78: lputc(curwp->w_dotp, curwp->w_doto, c);
! 79: lchange(WFHARD);
! 80: }
! 81: if (forwchar(FFRAND, 1) == FALSE)
! 82: return TRUE;
! 83: }
! 84: }
! 85: return TRUE;
! 86: }
! 87:
! 88: /*
! 89: * Move the cursor forward by
! 90: * the specified number of words. As you move
! 91: * convert characters to lower case.
! 92: */
! 93: /*ARGSUSED*/
! 94: lowerword(f, n)
! 95: {
! 96: register int c;
! 97:
! 98: if (n < 0) return FALSE;
! 99: while (n--) {
! 100: while (inword() == FALSE) {
! 101: if (forwchar(FFRAND, 1) == FALSE)
! 102: return TRUE;
! 103: }
! 104: while (inword() != FALSE) {
! 105: c = lgetc(curwp->w_dotp, curwp->w_doto);
! 106: if (ISUPPER(c) != FALSE) {
! 107: c = TOLOWER(c);
! 108: lputc(curwp->w_dotp, curwp->w_doto, c);
! 109: lchange(WFHARD);
! 110: }
! 111: if (forwchar(FFRAND, 1) == FALSE)
! 112: return TRUE;
! 113: }
! 114: }
! 115: return TRUE;
! 116: }
! 117:
! 118: /*
! 119: * Move the cursor forward by
! 120: * the specified number of words. As you move
! 121: * convert the first character of the word to upper
! 122: * case, and subsequent characters to lower case. Error
! 123: * if you try and move past the end of the buffer.
! 124: */
! 125: /*ARGSUSED*/
! 126: capword(f, n)
! 127: {
! 128: register int c;
! 129: VOID lchange();
! 130:
! 131: if (n < 0) return FALSE;
! 132: while (n--) {
! 133: while (inword() == FALSE) {
! 134: if (forwchar(FFRAND, 1) == FALSE)
! 135: return TRUE;
! 136: }
! 137: if (inword() != FALSE) {
! 138: c = lgetc(curwp->w_dotp, curwp->w_doto);
! 139: if (ISLOWER(c) != FALSE) {
! 140: c = TOUPPER(c);
! 141: lputc(curwp->w_dotp, curwp->w_doto, c);
! 142: lchange(WFHARD);
! 143: }
! 144: if (forwchar(FFRAND, 1) == FALSE)
! 145: return TRUE;
! 146: while (inword() != FALSE) {
! 147: c = lgetc(curwp->w_dotp, curwp->w_doto);
! 148: if (ISUPPER(c) != FALSE) {
! 149: c = TOLOWER(c);
! 150: lputc(curwp->w_dotp, curwp->w_doto, c);
! 151: lchange(WFHARD);
! 152: }
! 153: if (forwchar(FFRAND, 1) == FALSE)
! 154: return TRUE;
! 155: }
! 156: }
! 157: }
! 158: return TRUE;
! 159: }
! 160:
! 161: /*
! 162: * Kill forward by "n" words.
! 163: */
! 164: /*ARGSUSED*/
! 165: delfword(f, n)
! 166: {
! 167: register RSIZE size;
! 168: register LINE *dotp;
! 169: register int doto;
! 170:
! 171: if (n < 0)
! 172: return FALSE;
! 173: if ((lastflag&CFKILL) == 0) /* Purge kill buffer. */
! 174: kdelete();
! 175: thisflag |= CFKILL;
! 176: dotp = curwp->w_dotp;
! 177: doto = curwp->w_doto;
! 178: size = 0;
! 179: while (n--) {
! 180: while (inword() == FALSE) {
! 181: if (forwchar(FFRAND, 1) == FALSE)
! 182: goto out; /* Hit end of buffer. */
! 183: ++size;
! 184: }
! 185: while (inword() != FALSE) {
! 186: if (forwchar(FFRAND, 1) == FALSE)
! 187: goto out; /* Hit end of buffer. */
! 188: ++size;
! 189: }
! 190: }
! 191: out:
! 192: curwp->w_dotp = dotp;
! 193: curwp->w_doto = doto;
! 194: return (ldelete(size, KFORW));
! 195: }
! 196:
! 197: /*
! 198: * Kill backwards by "n" words. The rules
! 199: * for success and failure are now different, to prevent
! 200: * strange behavior at the start of the buffer. The command
! 201: * only fails if something goes wrong with the actual delete
! 202: * of the characters. It is successful even if no characters
! 203: * are deleted, or if you say delete 5 words, and there are
! 204: * only 4 words left. I considered making the first call
! 205: * to "backchar" special, but decided that that would just
! 206: * be wierd. Normally this is bound to "M-Rubout" and
! 207: * to "M-Backspace".
! 208: */
! 209: /*ARGSUSED*/
! 210: delbword(f, n)
! 211: {
! 212: register RSIZE size;
! 213: VOID kdelete();
! 214:
! 215: if (n < 0) return FALSE;
! 216: if ((lastflag&CFKILL) == 0) /* Purge kill buffer. */
! 217: kdelete();
! 218: thisflag |= CFKILL;
! 219: if (backchar(FFRAND, 1) == FALSE)
! 220: return (TRUE); /* Hit buffer start. */
! 221: size = 1; /* One deleted. */
! 222: while (n--) {
! 223: while (inword() == FALSE) {
! 224: if (backchar(FFRAND, 1) == FALSE)
! 225: goto out; /* Hit buffer start. */
! 226: ++size;
! 227: }
! 228: while (inword() != FALSE) {
! 229: if (backchar(FFRAND, 1) == FALSE)
! 230: goto out; /* Hit buffer start. */
! 231: ++size;
! 232: }
! 233: }
! 234: if (forwchar(FFRAND, 1) == FALSE)
! 235: return FALSE;
! 236: --size; /* Undo assumed delete. */
! 237: out:
! 238: return ldelete(size, KBACK);
! 239: }
! 240:
! 241: /*
! 242: * Return TRUE if the character at dot
! 243: * is a character that is considered to be
! 244: * part of a word. The word character list is hard
! 245: * coded. Should be setable.
! 246: */
! 247: inword() {
! 248: /* can't use lgetc in ISWORD due to bug in OSK cpp */
! 249: return curwp->w_doto != llength(curwp->w_dotp) &&
! 250: ISWORD(curwp->w_dotp->l_text[curwp->w_doto]);
! 251: }
! 252: