commands/elvis/move1.c

   1 /* move1.c */
   2
   3 /* Author:
   4  *      Steve Kirkendall
   5  *      14407 SW Teal Blvd. #C
   6  *      Beaverton, OR 97005
   7  *      kirkenda@cs.pdx.edu
   8  */
   9
  10
  11 /* This file contains most movement functions */
  12
  13 #include "config.h"
  14 #include "vi.h"
  15 #include "ctype.h"
  16
  17 MARK    m_updnto(m, cnt, cmd)
  18         MARK    m;      /* movement is relative to this mark */
  19         long    cnt;    /* a numeric argument */
  20         char    cmd;    /* the command character */
  21 {
  22         DEFAULT(cmd == 'G' ? nlines : 1L);
  23
  24         /* move up or down 'cnt' lines */
  25         switch (cmd)
  26         {
  27           case ctrl('P'):
  28           case '-':
  29           case 'k':
  30                 m -= MARK_AT_LINE(cnt);
  31                 break;
  32
  33           case 'G':
  34                 if (cnt < 1L || cnt > nlines)
  35                 {
  36                         msg("Only %ld lines", nlines);
  37                         return MARK_UNSET;
  38                 }
  39                 m = MARK_AT_LINE(cnt);
  40                 break;
  41
  42           case '_':
  43                 cnt--;
  44                 /* fall through... */
  45
  46           default:
  47                 m += MARK_AT_LINE(cnt);
  48         }
  49
  50         /* if that left us screwed up, then fail */
  51         if (m < MARK_FIRST || markline(m) > nlines)
  52         {
  53                 return MARK_UNSET;
  54         }
  55
  56         return m;
  57 }
  58
  59 /*ARGSUSED*/
  60 MARK    m_right(m, cnt, key, prevkey)
  61         MARK    m;      /* movement is relative to this mark */
  62         long    cnt;    /* a numeric argument */
  63         int     key;    /* movement keystroke */
  64         int     prevkey;/* operator keystroke, or 0 if none */
  65 {
  66         int             idx;    /* index of the new cursor position */
  67
  68         DEFAULT(1);
  69
  70         /* If used with an operator, then move 1 less character, since the 'l'
  71          * command includes the character that it moves onto.
  72          */
  73         if (prevkey != '\0')
  74         {
  75                 cnt--;
  76         }
  77
  78         /* move to right, if that's OK */
  79         pfetch(markline(m));
  80         idx = markidx(m) + cnt;
  81         if (idx < plen)
  82         {
  83                 m += cnt;
  84         }
  85         else
  86         {
  87                 return MARK_UNSET;
  88         }
  89
  90         return m;
  91 }
  92
  93 /*ARGSUSED*/
  94 MARK    m_left(m, cnt)
  95         MARK    m;      /* movement is relative to this mark */
  96         long    cnt;    /* a numeric argument */
  97 {
  98         DEFAULT(1);
  99
 100         /* move to the left, if that's OK */
 101         if (markidx(m) >= cnt)
 102         {
 103                 m -= cnt;
 104         }
 105         else
 106         {
 107                 return MARK_UNSET;
 108         }
 109
 110         return m;
 111 }
 112
 113 /*ARGSUSED*/
 114 MARK    m_tocol(m, cnt, cmd)
 115         MARK    m;      /* movement is relative to this mark */
 116         long    cnt;    /* a numeric argument */
 117         int     cmd;    /* either ctrl('X') or '|' */
 118 {
 119         char    *text;  /* text of the line */
 120         int     col;    /* column number */
 121         int     idx;    /* index into the line */
 122
 123
 124         /* if doing ^X, then adjust for sideways scrolling */
 125         if (cmd == ctrl('X'))
 126         {
 127                 DEFAULT(*o_columns & 0xff);
 128                 cnt += leftcol;
 129         }
 130         else
 131         {
 132                 DEFAULT(1);
 133         }
 134
 135         /* internally, columns are numbered 0..COLS-1, not 1..COLS */
 136         cnt--;
 137
 138         /* if 0, that's easy */
 139         if (cnt == 0)
 140         {
 141                 m &= ~(BLKSIZE - 1);
 142                 return m;
 143         }
 144
 145         /* find that column within the line */
 146         pfetch(markline(m));
 147         text = ptext;
 148         for (col = idx = 0; col < cnt && *text; text++, idx++)
 149         {
 150                 if (*text == '\t' && !*o_list)
 151                 {
 152                         col += *o_tabstop;
 153                         col -= col % *o_tabstop;
 154                 }
 155                 else if (UCHAR(*text) < ' ' || *text == '\177')
 156                 {
 157                         col += 2;
 158                 }
 159 #ifndef NO_CHARATTR
 160                 else if (text[0] == '\\' && text[1] == 'f' && text[2] && *o_charattr)
 161                 {
 162                         text += 2; /* plus one more as part of for loop */
 163                 }
 164 #endif
 165                 else
 166                 {
 167                         col++;
 168                 }
 169         }
 170         if (!*text)
 171         {
 172                 /* the desired column was past the end of the line, so
 173                  * act like the user pressed "$" instead.
 174                  */
 175                 return m | (BLKSIZE - 1);
 176         }
 177         else
 178         {
 179                 m = (m & ~(BLKSIZE - 1)) + idx;
 180         }
 181         return m;
 182 }
 183
 184 /*ARGSUSED*/
 185 MARK    m_front(m, cnt)
 186         MARK    m;      /* movement is relative to this mark */
 187         long    cnt;    /* a numeric argument (ignored) */
 188 {
 189         char    *scan;
 190
 191         /* move to the first non-whitespace character */
 192         pfetch(markline(m));
 193         scan = ptext;
 194         m &= ~(BLKSIZE - 1);
 195         while (*scan == ' ' || *scan == '\t')
 196         {
 197                 scan++;
 198                 m++;
 199         }
 200
 201         return m;
 202 }
 203
 204 /*ARGSUSED*/
 205 MARK    m_rear(m, cnt)
 206         MARK    m;      /* movement is relative to this mark */
 207         long    cnt;    /* a numeric argument (ignored) */
 208 {
 209         /* Try to move *EXTREMELY* far to the right.  It is fervently hoped
 210          * that other code will convert this to a more reasonable MARK before
 211          * anything tries to actually use it.  (See adjmove() in vi.c)
 212          */
 213         return m | (BLKSIZE - 1);
 214 }
 215
 216 #ifndef NO_SENTENCE
 217 static int isperiod(ptr)
 218         char    *ptr;   /* pointer to possible sentence-ender */
 219 {
 220         /* if not '.', '?', or '!', then it isn't a sentence ender */
 221         if (*ptr != '.' && *ptr != '?' && *ptr != '!')
 222         {
 223                 return FALSE;
 224         }
 225
 226         /* skip any intervening ')', ']', or '"' characters */
 227         do
 228         {
 229                 ptr++;
 230         } while (*ptr == ')' || *ptr == ']' || *ptr == '"');
 231
 232         /* do we have two spaces or EOL? */
 233         if (!*ptr || ptr[0] == ' ' && ptr[1] == ' ')
 234         {
 235                 return TRUE;
 236         }
 237         return FALSE;
 238 }
 239
 240 /*ARGSUSED*/
 241 MARK    m_sentence(m, cnt, cmd)
 242         MARK    m;      /* movement is relative to this mark */
 243         long    cnt;    /* a numeric argument */
 244         int     cmd;    /* either '(' or ')' */
 245 {
 246         REG char        *text;
 247         REG long        l;
 248
 249         DEFAULT(1);
 250
 251         /* If '(' command, then move back one word, so that if we hit '(' at
 252          * the start of a sentence we don't simply stop at the end of the
 253          * previous sentence and bounce back to the start of this one again.
 254          */
 255         if (cmd == '(')
 256         {
 257                 m = m_bword(m, 1L, 'b');
 258                 if (!m)
 259                 {
 260                         return m;
 261                 }
 262         }
 263
 264         /* get the current line */
 265         l = markline(m);
 266         pfetch(l);
 267         text = ptext + markidx(m);
 268
 269         /* for each requested sentence... */
 270         while (cnt-- > 0)
 271         {
 272                 /* search forward for one of [.?!] followed by spaces or EOL */
 273                 do
 274                 {
 275                         if (cmd == ')')
 276                         {
 277                                 /* move forward, wrap at end of line */
 278                                 if (!text[0])
 279                                 {
 280                                         if (l >= nlines)
 281                                         {
 282                                                 return MARK_UNSET;
 283                                         }
 284                                         l++;
 285                                         pfetch(l);
 286                                         text = ptext;
 287                                 }
 288                                 else
 289                                 {
 290                                         text++;
 291                                 }
 292                         }
 293                         else
 294                         {
 295                                 /* move backward, wrap at beginning of line */
 296                                 if (text == ptext)
 297                                 {
 298                                         do
 299                                         {
 300                                                 if (l <= 1)
 301                                                 {
 302                                                         return MARK_FIRST;
 303                                                 }
 304                                                 l--;
 305                                                 pfetch(l);
 306                                         } while (!*ptext);
 307                                         text = ptext + plen - 1;
 308                                 }
 309                                 else
 310                                 {
 311                                         text--;
 312                                 }
 313                         }
 314                 } while (!isperiod(text));
 315         }
 316
 317         /* construct a mark for this location */
 318         m = buildmark(text);
 319
 320         /* move forward to the first word of the next sentence */
 321         m = m_fword(m, 1L, 'w', '\0');
 322
 323         return m;
 324 }
 325 #endif
 326
 327 MARK    m_paragraph(m, cnt, cmd)
 328         MARK    m;      /* movement is relative to this mark */
 329         long    cnt;    /* a numeric argument */
 330         int     cmd;    /* either '{' or '}' */
 331 {
 332         char    *text;  /* text of the current line */
 333         char    *pscn;  /* used to scan thru value of "paragraphs" option */
 334         long    l, ol;  /* current line number, original line number */
 335         int     dir;    /* -1 if we're moving up, or 1 if down */
 336         char    col0;   /* character to expect in column 0 */
 337 #ifndef NO_SENTENCE
 338 # define SENTENCE(x)    (x)
 339         char    *list;  /* either o_sections or o_paragraph */
 340 #else
 341 # define SENTENCE(x)
 342 #endif
 343
 344         DEFAULT(1);
 345
 346         /* set the direction, based on the command */
 347         switch (cmd)
 348         {
 349           case '{':
 350                 dir = -1;
 351                 col0 = '\0';
 352                 SENTENCE(list = o_paragraphs);
 353                 break;
 354
 355           case '}':
 356                 dir = 1;
 357                 col0 = '\0';
 358                 SENTENCE(list = o_paragraphs);
 359                 break;
 360
 361           case '[':
 362                 if (getkey(0) != '[')
 363                 {
 364                         return MARK_UNSET;
 365                 }
 366                 dir = -1;
 367                 col0 = '{';
 368                 SENTENCE(list = o_sections);
 369                 break;
 370
 371           case ']':
 372                 if (getkey(0) != ']')
 373                 {
 374                         return MARK_UNSET;
 375                 }
 376                 dir = 1;
 377                 col0 = '{';
 378                 SENTENCE(list = o_sections);
 379                 break;
 380         }
 381         ol = l = markline(m);
 382
 383         /* for each paragraph that we want to travel through... */
 384         while (l > 0 && l <= nlines && cnt-- > 0)
 385         {
 386                 /* skip blank lines between paragraphs */
 387                 while (l > 0 && l <= nlines && col0 == *(text = fetchline(l)))
 388                 {
 389                         l += dir;
 390                 }
 391
 392                 /* skip non-blank lines that aren't paragraph separators
 393                  */
 394                 do
 395                 {
 396 #ifndef NO_SENTENCE
 397                         if (*text == '.' && l != ol)
 398                         {
 399                                 for (pscn = list; pscn[0] && pscn[1]; pscn += 2)
 400                                 {
 401                                         if (pscn[0] == text[1] && pscn[1] == text[2])
 402                                         {
 403                                                 pscn = (char *)0;
 404                                                 goto BreakBreak;
 405                                         }
 406                                 }
 407                         }
 408 #endif
 409                         l += dir;
 410                 } while (l > 0 && l <= nlines && col0 != *(text = fetchline(l)));
 411 BreakBreak:     ;
 412         }
 413
 414         if (l > nlines)
 415         {
 416                 m = MARK_LAST;
 417         }
 418         else if (l <= 0)
 419         {
 420                 m = MARK_FIRST;
 421         }
 422         else
 423         {
 424                 m = MARK_AT_LINE(l);
 425         }
 426         return m;
 427 }
 428
 429
 430 /*ARGSUSED*/
 431 MARK    m_match(m, cnt)
 432         MARK    m;      /* movement is relative to this mark */
 433         long    cnt;    /* a numeric argument (normally 0) */
 434 {
 435         long    l;
 436         REG char        *text;
 437         REG char        match;
 438         REG char        nest;
 439         REG int         count;
 440
 441 #ifndef NO_EXTENSIONS
 442         /* if we're given a number, then treat it as a percentage of the file */
 443         if (cnt > 0)
 444         {
 445                 /* make sure it is a reasonable number */
 446                 if (cnt > 100)
 447                 {
 448                         msg("can only be from 1%% to 100%%");
 449                         return MARK_UNSET;
 450                 }
 451
 452                 /* return the appropriate line number */
 453                 l = (nlines - 1L) * cnt / 100L + 1L;
 454                 return MARK_AT_LINE(l);
 455         }
 456 #endif /* undef NO_EXTENSIONS */
 457
 458         /* get the current line */
 459         l = markline(m);
 460         pfetch(l);
 461         text = ptext + markidx(m);
 462
 463         /* search forward within line for one of "[](){}" */
 464         for (match = '\0'; !match && *text; text++)
 465         {
 466                 /* tricky way to recognize 'em in ASCII */
 467                 nest = *text;
 468                 if ((nest & 0xdf) == ']' || (nest & 0xdf) == '[')
 469                 {
 470                         match = nest ^ ('[' ^ ']');
 471                 }
 472                 else if ((nest & 0xfe) == '(')
 473                 {
 474                         match = nest ^ ('(' ^ ')');
 475                 }
 476                 else
 477                 {
 478                         match = 0;
 479                 }
 480         }
 481         if (!match)
 482         {
 483                 return MARK_UNSET;
 484         }
 485         text--;
 486
 487         /* search forward or backward for match */
 488         if (match == '(' || match == '[' || match == '{')
 489         {
 490                 /* search backward */
 491                 for (count = 1; count > 0; )
 492                 {
 493                         /* wrap at beginning of line */
 494                         if (text == ptext)
 495                         {
 496                                 do
 497                                 {
 498                                         if (l <= 1L)
 499                                         {
 500                                                 return MARK_UNSET;
 501                                         }
 502                                         l--;
 503                                         pfetch(l);
 504                                 } while (!*ptext);
 505                                 text = ptext + plen - 1;
 506                         }
 507                         else
 508                         {
 509                                 text--;
 510                         }
 511
 512                         /* check the char */
 513                         if (*text == match)
 514                                 count--;
 515                         else if (*text == nest)
 516                                 count++;
 517                 }
 518         }
 519         else
 520         {
 521                 /* search forward */
 522                 for (count = 1; count > 0; )
 523                 {
 524                         /* wrap at end of line */
 525                         if (!*text)
 526                         {
 527                                 if (l >= nlines)
 528                                 {
 529                                         return MARK_UNSET;
 530                                 }
 531                                 l++;
 532                                 pfetch(l);
 533                                 text = ptext;
 534                         }
 535                         else
 536                         {
 537                                 text++;
 538                         }
 539
 540                         /* check the char */
 541                         if (*text == match)
 542                                 count--;
 543                         else if (*text == nest)
 544                                 count++;
 545                 }
 546         }
 547
 548         /* construct a mark for this place */
 549         m = buildmark(text);
 550         return m;
 551 }
 552
 553 /*ARGSUSED*/
 554 MARK    m_tomark(m, cnt, key)
 555         MARK    m;      /* movement is relative to this mark */
 556         long    cnt;    /* (ignored) */
 557         int     key;    /* keystroke - the mark to move to */
 558 {
 559         /* mark '' is a special case */
 560         if (key == '\'' || key == '`')
 561         {
 562                 if (mark[26] == MARK_UNSET)
 563                 {
 564                         return MARK_FIRST;
 565                 }
 566                 else
 567                 {
 568                         return mark[26];
 569                 }
 570         }
 571
 572         /* if not a valid mark number, don't move */
 573         if (key < 'a' || key > 'z')
 574         {
 575                 return MARK_UNSET;
 576         }
 577
 578         /* return the selected mark -- may be MARK_UNSET */
 579         if (!mark[key - 'a'])
 580         {
 581                 msg("mark '%c is unset", key);
 582         }
 583         return mark[key - 'a'];
 584 }
 585