fish/microemacs/word.c

   1 /*
   2  * The routines in this file implement commands that work word at a time.
   3  * There are all sorts of word mode commands. If I do any sentence and/or
   4  * paragraph mode commands, they are likely to be put in this file.
   5  */
   6
   7 #include        <stdio.h>
   8 #include        "ed.h"
   9
  10
  11 /* Word wrap on n-spaces. Back-over whatever precedes the point on the current
  12  * line and stop on the first word-break or the beginning of the line. If we
  13  * reach the beginning of the line, jump back to the end of the word and start
  14  * a new line.  Otherwise, break the line at the word-break, eat it, and jump
  15  * back to the end of the word.
  16  *      NOTE:  This function may leaving trailing blanks.
  17  * Returns TRUE on success, FALSE on errors.
  18  */
  19 int wrapword()
  20 {
  21         register int cnt;
  22         struct LINE *oldp;
  23         oldp = curwp->w_dotp;
  24         cnt = -1;
  25         do {
  26                 cnt++;
  27                 if (! backchar(0, 1))
  28                         return(FALSE);
  29         }
  30         while (! inword());
  31         if (! backword(0, 1))
  32                 return(FALSE);
  33         if ((oldp == curwp->w_dotp) && curwp->w_doto) {
  34                 if (! backdel(0, 1))
  35                         return(FALSE);
  36                 if (! newline(0, 1))
  37                         return(FALSE);
  38         }
  39         return(forwword(0, 1) && forwchar(0, cnt));
  40 }
  41
  42 /*
  43  * Move the cursor backward by "n" words. All of the details of motion are
  44  * performed by the "backchar" and "forwchar" routines. Error if you try to
  45  * move beyond the buffers.
  46  */
  47 int backword(f, n)
  48         int f;
  49         int n;
  50 {
  51         if (n < 0)
  52                 return (forwword(f, -n));
  53         if (backchar(FALSE, 1) == FALSE)
  54                 return (FALSE);
  55         while (n--) {
  56                 while (inword() == FALSE) {
  57                         if (backchar(FALSE, 1) == FALSE)
  58                                 return (FALSE);
  59                 }
  60                 while (inword() != FALSE) {
  61                         if (backchar(FALSE, 1) == FALSE)
  62                                 return (FALSE);
  63                 }
  64         }
  65         return (forwchar(FALSE, 1));
  66 }
  67
  68 /*
  69  * Move the cursor forward by the specified number of words. All of the motion
  70  * is done by "forwchar". Error if you try and move beyond the buffer's end.
  71  */
  72 int forwword(f, n)
  73         int f;
  74         int n;
  75 {
  76         if (n < 0)
  77                 return (backword(f, -n));
  78         while (n--) {
  79                 while (inword() == FALSE) {
  80                         if (forwchar(FALSE, 1) == FALSE)
  81                                 return (FALSE);
  82                 }
  83                 while (inword() != FALSE) {
  84                         if (forwchar(FALSE, 1) == FALSE)
  85                                 return (FALSE);
  86                 }
  87         }
  88         return (TRUE);
  89 }
  90
  91 /*
  92  * Move the cursor forward by the specified number of words. As you move,
  93  * convert any characters to upper case. Error if you try and move beyond the
  94  * end of the buffer. Bound to "M-U".
  95  */
  96 int upperword(f, n)
  97         int f;
  98         int n;
  99 {
 100         register int    c;
 101
 102         if (n < 0)
 103                 return (FALSE);
 104         while (n--) {
 105                 while (inword() == FALSE) {
 106                         if (forwchar(FALSE, 1) == FALSE)
 107                                 return (FALSE);
 108                 }
 109                 while (inword() != FALSE) {
 110                         c = lgetc(curwp->w_dotp, curwp->w_doto);
 111                         if (c>='a' && c<='z') {
 112                                 c -= 'a'-'A';
 113                                 lputc(curwp->w_dotp, curwp->w_doto, c);
 114                                 lchange(WFHARD);
 115                         }
 116                         if (forwchar(FALSE, 1) == FALSE)
 117                                 return (FALSE);
 118                 }
 119         }
 120         return (TRUE);
 121 }
 122
 123 /*
 124  * Move the cursor forward by the specified number of words. As you move
 125  * convert characters to lower case. Error if you try and move over the end of
 126  * the buffer. Bound to "M-L".
 127  */
 128 int lowerword(f, n)
 129         int f;
 130         int n;
 131 {
 132         register int    c;
 133
 134         if (n < 0)
 135                 return (FALSE);
 136         while (n--) {
 137                 while (inword() == FALSE) {
 138                         if (forwchar(FALSE, 1) == FALSE)
 139                                 return (FALSE);
 140                 }
 141                 while (inword() != FALSE) {
 142                         c = lgetc(curwp->w_dotp, curwp->w_doto);
 143                         if (c>='A' && c<='Z') {
 144                                 c += 'a'-'A';
 145                                 lputc(curwp->w_dotp, curwp->w_doto, c);
 146                                 lchange(WFHARD);
 147                         }
 148                         if (forwchar(FALSE, 1) == FALSE)
 149                                 return (FALSE);
 150                 }
 151         }
 152         return (TRUE);
 153 }
 154
 155 /*
 156  * Move the cursor forward by the specified number of words. As you move
 157  * convert the first character of the word to upper case, and subsequent
 158  * characters to lower case. Error if you try and move past the end of the
 159  * buffer. Bound to "M-C".
 160  */
 161 int capword(f, n)
 162         int f;
 163         int n;
 164 {
 165         register int    c;
 166
 167         if (n < 0)
 168                 return (FALSE);
 169         while (n--) {
 170                 while (inword() == FALSE) {
 171                         if (forwchar(FALSE, 1) == FALSE)
 172                                 return (FALSE);
 173                 }
 174                 if (inword() != FALSE) {
 175                         c = lgetc(curwp->w_dotp, curwp->w_doto);
 176                         if (c>='a' && c<='z') {
 177                                 c -= 'a'-'A';
 178                                 lputc(curwp->w_dotp, curwp->w_doto, c);
 179                                 lchange(WFHARD);
 180                         }
 181                         if (forwchar(FALSE, 1) == FALSE)
 182                                 return (FALSE);
 183                         while (inword() != FALSE) {
 184                                 c = lgetc(curwp->w_dotp, curwp->w_doto);
 185                                 if (c>='A' && c<='Z') {
 186                                         c += 'a'-'A';
 187                                         lputc(curwp->w_dotp, curwp->w_doto, c);
 188                                         lchange(WFHARD);
 189                                 }
 190                                 if (forwchar(FALSE, 1) == FALSE)
 191                                         return (FALSE);
 192                         }
 193                 }
 194         }
 195         return (TRUE);
 196 }
 197
 198 /*
 199  * Kill forward by "n" words. Remember the location of dot. Move forward by
 200  * the right number of words. Put dot back where it was and issue the kill
 201  * command for the right number of characters. Bound to "M-D".
 202  */
 203 int delfword(f, n)
 204         int f;
 205         int n;
 206 {
 207         register int    size;
 208         register LINE   *dotp;
 209         register int    doto;
 210
 211         if (n < 0)
 212                 return (FALSE);
 213         dotp = curwp->w_dotp;
 214         doto = curwp->w_doto;
 215         size = 0;
 216         while (n--) {
 217                 while (inword() == FALSE) {
 218                         if (forwchar(FALSE, 1) == FALSE)
 219                                 return (FALSE);
 220                         ++size;
 221                 }
 222                 while (inword() != FALSE) {
 223                         if (forwchar(FALSE, 1) == FALSE)
 224                                 return (FALSE);
 225                         ++size;
 226                 }
 227         }
 228         curwp->w_dotp = dotp;
 229         curwp->w_doto = doto;
 230         return (ldelete(size, TRUE));
 231 }
 232
 233 /*
 234  * Kill backwards by "n" words. Move backwards by the desired number of words,
 235  * counting the characters. When dot is finally moved to its resting place,
 236  * fire off the kill command. Bound to "M-Rubout" and to "M-Backspace".
 237  */
 238 int delbword(f, n)
 239         int f;
 240         int n;
 241 {
 242         register int    size;
 243
 244         if (n < 0)
 245                 return (FALSE);
 246         if (backchar(FALSE, 1) == FALSE)
 247                 return (FALSE);
 248         size = 0;
 249         while (n--) {
 250                 while (inword() == FALSE) {
 251                         if (backchar(FALSE, 1) == FALSE)
 252                                 return (FALSE);
 253                         ++size;
 254                 }
 255                 while (inword() != FALSE) {
 256                         if (backchar(FALSE, 1) == FALSE)
 257                                 return (FALSE);
 258                         ++size;
 259                 }
 260         }
 261         if (forwchar(FALSE, 1) == FALSE)
 262                 return (FALSE);
 263         return (ldelete(size, TRUE));
 264 }
 265
 266 /*
 267  * Return TRUE if the character at dot is a character that is considered to be
 268  * part of a word. The word character list is hard coded. Should be setable.
 269  */
 270 int inword()
 271 {
 272         register int    c;
 273
 274         if (curwp->w_doto == llength(curwp->w_dotp))
 275                 return (FALSE);
 276         c = lgetc(curwp->w_dotp, curwp->w_doto);
 277         if (c>='a' && c<='z')
 278                 return (TRUE);
 279         if (c>='A' && c<='Z')
 280                 return (TRUE);
 281         if (c>='0' && c<='9')
 282                 return (TRUE);
 283         if (c=='$' || c=='_')                   /* For identifiers      */
 284                 return (TRUE);
 285         return (FALSE);
 286 }
 287