home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume44 / vim / part10 < prev    next >
Encoding:
Internet Message Format  |  1994-08-16  |  69.1 KB
  1. From: mool@oce.nl (Bram Moolenaar)
  2. Newsgroups: comp.sources.misc
  3. Subject: v44i029:  vim - Vi IMproved editor, v3.0, Part10/26
  4. Date: 16 Aug 1994 21:18:14 -0500
  5. Organization: Sterling Software
  6. Sender: kent@sparky.sterling.com
  7. Approved: kent@sparky.sterling.com
  8. Message-ID: <32rs16$ke4@sparky.sterling.com>
  9. X-Md4-Signature: 645cc39459ac34c1a4813dce9d1e3c86
  10.  
  11. Submitted-by: mool@oce.nl (Bram Moolenaar)
  12. Posting-number: Volume 44, Issue 29
  13. Archive-name: vim/part10
  14. Environment: UNIX, AMIGA, MS-DOS, Windows NT
  15. Supersedes: vim: Volume 41, Issue 50-75
  16.  
  17. #! /bin/sh
  18. # This is a shell archive.  Remove anything before this line, then feed it
  19. # into a shell via "sh file" or similar.  To overwrite existing files,
  20. # type "sh file -c".
  21. # Contents:  vim/doc/digraph.doc.UU vim/src/misccmds.c vim/src/normal.c
  22. # Wrapped by kent@sparky on Mon Aug 15 21:44:04 1994
  23. PATH=/bin:/usr/bin:/usr/ucb:/usr/local/bin:/usr/lbin:$PATH ; export PATH
  24. echo If this archive is complete, you will see the following message:
  25. echo '          "shar: End of archive 10 (of 26)."'
  26. if test -f 'vim/doc/digraph.doc.UU' -a "${1}" != "-c" ; then 
  27.   echo shar: Will not clobber existing file \"'vim/doc/digraph.doc.UU'\"
  28. else
  29.   echo shar: Extracting \"'vim/doc/digraph.doc.UU'\" \(3112 characters\)
  30.   sed "s/^X//" >'vim/doc/digraph.doc.UU' <<'END_OF_FILE'
  31. Xbegin 644 vim/doc/digraph.doc
  32. XM5&AE<V4@87)E('1H92!D969A=6QT(&1I9W)A<&@@8VAA<F%C=&5R<R!F;W(@
  33. XM5FEM+@H*0F5S:61E<R!T:&4@9&EG<F%P:',@;&ES=&5D(&)E;&]W+"!M971A
  34. XM(&-H87)A8W1E<G,@8V%N(&)E(&5N=&5R960@=VET:"!#5%),+4L*/%-004-%
  35. XM/B![8VAA<GTN($]N;'D@15-#(&-A;FYO="!B92!U<V5D(&9O<B![8VAA<GTN
  36. XM(%5S92!#5%),+58@,34U(&9O<B!T:&ES+@H*5&AE(&9I<G-T('1W;R!C:&%R
  37. XM86-T97)S(&EN(&5A8V@@8V]L=6UN(&%R92!T:&4@8VAA<F%C=&5R<R!Y;W4@
  38. XM:&%V92!T;R!T>7!E('1O"F5N=&5R(&$@9&EG<F%P:"X*"DEN('1H92!M:61D
  39. XM;&4@;V8@96%C:"!C;VQU;6X@:7,@=&AE(')E<W5L=&EN9R!C:&%R86-T97(N
  40. XM(%1H:7,@;6%Y(&)E(&UA;F=L960*:68@>6]U(&QO;VL@870@=&AI<R!F:6QE
  41. XM(&]N('-O;65T:&EN9R!E;'-E('1H86X@=&AE('-Y<W1E;2!T:&%T('1H97D@
  42. XM=V5R90IM96%N="!F;W(@;W(@=VAE;B!Y;W4@<')I;G0@:70N"@I4:&4@9&5C
  43. XM:6UA;"!N=6UB97(@:7,@=&AE($%30TE)(&-O9&4@9F]R('1H92!C:&%R86-T
  44. XM97(N"@I$969A=6QT(&1I9W)A<&AS(&]N('1H92!!;6EG83H*?B$@H2 Q-C$@
  45. XM("!C?""B(#$V,B @("0D(*,@,38S(" @;W@@I" Q-C0@("!9+2"E(#$V-2 @
  46. XM('Q\(*8@,38V(" @<&$@IR Q-C<*(B(@J" Q-C@@("!C3R"I(#$V.2 @(&$M
  47. XM(*H@,3<P(" @/#P@JR Q-S$@(" M+2"M(#$W,R @(')/(*X@,3<T(" @+3T@
  48. XMKR Q-S4*?F\@L" Q-S8@(" K+2"Q(#$W-R @(#(R(+(@,3<X(" @,S,@LR Q
  49. XM-SD@(" G)R"T(#$X," @(&IU(+4@,3@Q(" @<' @MB Q.#(*?BX@MR Q.#,@
  50. XM(" L+""X(#$X-" @(#$Q(+D@,3@U(" @;RT@NB Q.#8@(" ^/B"[(#$X-R @
  51. XM(#$T(+P@,3@X(" @,3(@O2 Q.#D*,S0@OB Q.3 @("!^/R"_(#$Y,2 @($%@
  52. XM(, @,3DR(" @02<@P2 Q.3,@("!!7B#"(#$Y-" @($%^(,,@,3DU(" @02(@
  53. XMQ" Q.38*04 @Q2 Q.3<@("!!12#&(#$Y." @($,L(,<@,3DY(" @16 @R" R
  54. XM,# @("!%)R#)(#(P,2 @($5>(,H@,C R(" @12(@RR R,#,*26 @S" R,#0@
  55. XM("!))R#-(#(P-2 @($E>(,X@,C V(" @22(@SR R,#<@(" M1"#0(#(P." @
  56. XM($Y^(-$@,C Y(" @3V @TB R,3 *3R<@TR R,3$@("!/7B#4(#(Q,B @($]^
  57. XM(-4@,C$S(" @3R(@UB R,30@(" O7"#7(#(Q-2 @($\O(-@@,C$V(" @56 @
  58. XMV2 R,3<*52<@VB R,3@@("!57B#;(#(Q.2 @(%4B(-P@,C(P(" @62<@W2 R
  59. XM,C$@("!)<"#>(#(R,B @('-S(-\@,C(S(" @86 @X" R,C0*82<@X2 R,C4@
  60. XM("!A7B#B(#(R-B @(&%^(.,@,C(W(" @82(@Y" R,C@@("!A0"#E(#(R.2 @
  61. XM(&%E(.8@,C,P(" @8RP@YR R,S$*96 @Z" R,S(@("!E)R#I(#(S,R @(&5>
  62. XM(.H@,C,T(" @92(@ZR R,S4@("!I8"#L(#(S-B @(&DG(.T@,C,W(" @:5X@
  63. XM[B R,S@*:2(@[R R,SD@(" M9"#P(#(T," @(&Y^(/$@,C0Q(" @;V @\B R
  64. XM-#(@("!O)R#S(#(T,R @(&]>(/0@,C0T(" @;WX@]2 R-#4*;R(@]B R-#8@
  65. XM(" Z+2#W(#(T-R @(&\O(/@@,C0X(" @=6 @^2 R-#D@("!U)R#Z(#(U," @
  66. XM('5>(/L@,C4Q(" @=2(@_" R-3(*>2<@_2 R-3,@("!I<"#^(#(U-" @('DB
  67. XM(/\@,C4U"@I$969A=6QT(&1I9W)A<&AS(&]N($U31$]3.@I#+"" (#$R." @
  68. XM('4B(($@,3(Y(" @92<@@B Q,S @("!A7B"#(#$S,2 @(&$B((0@,3,R(" @
  69. XM86 @A2 Q,S,@("!A0""&(#$S- IC+""'(#$S-2 @(&5>((@@,3,V(" @92(@
  70. XMB2 Q,S<@("!E8""*(#$S." @(&DB((L@,3,Y(" @:5X@C" Q-# @("!I8""-
  71. XM(#$T,0I!(B".(#$T,B @($% ((\@,30S(" @12<@D" Q-#0@("!A92"1(#$T
  72. XM-2 @($%%()(@,30V(" @;UX@DR Q-#<@("!O(B"4(#$T. IO8""5(#$T.2 @
  73. XM('5>()8@,34P(" @=6 @ER Q-3$@("!Y(B"8(#$U,B @($\B()D@,34S(" @
  74. XM52(@FB Q-30@("!C?"";(#$U-0HD)""<(#$U-B @(%DM()T@,34W(" @4'0@
  75. XMGB Q-3@@("!F9B"?(#$U.2 @(&$G(* @,38P(" @:2<@H2 Q-C$@("!O)R"B
  76. XM(#$V,@IU)R"C(#$V,R @(&Y^(*0@,38T(" @3GX@I2 Q-C4@("!A82"F(#$V
  77. XM-B @(&]O(*<@,38W(" @?C\@J" Q-C@@(" M82"I(#$V.0IA+2"J(#$W," @
  78. XM(#$R(*L@,3<Q(" @,30@K" Q-S(@("!^(2"M(#$W,R @(#P\(*X@,3<T(" @
  79. XM/CX@KR Q-S4@("!S<R#A(#(R-0IJ=2#F(#(S," @(&\O(.T@,C,W(" @*RT@
  80. XM\2 R-#$@(" ^/2#R(#(T,B @(#P](/,@,C0S(" @.BT@]B R-#8@("!^?B#W
  81. X9(#(T-PI^;R#X(#(T." @(#(R(/T@,C4S"C0S
  82. X 
  83. Xend
  84. END_OF_FILE
  85.   if test 3112 -ne `wc -c <'vim/doc/digraph.doc.UU'`; then
  86.     echo shar: \"'vim/doc/digraph.doc.UU'\" unpacked with wrong size!
  87.   else
  88.     echo shar: Uudecoding \"'vim/doc/digraph.doc'\" \(2230 characters\)
  89.     cat vim/doc/digraph.doc.UU | uudecode
  90.     if test 2230 -ne `wc -c <'vim/doc/digraph.doc'`; then
  91.       echo shar: \"'vim/doc/digraph.doc'\" uudecoded with wrong size!
  92.     else
  93.       rm vim/doc/digraph.doc.UU
  94.     fi
  95.   fi
  96.   # end of 'vim/doc/digraph.doc.UU'
  97. fi
  98. if test -f 'vim/src/misccmds.c' -a "${1}" != "-c" ; then 
  99.   echo shar: Will not clobber existing file \"'vim/src/misccmds.c'\"
  100. else
  101.   echo shar: Extracting \"'vim/src/misccmds.c'\" \(20128 characters\)
  102.   sed "s/^X//" >'vim/src/misccmds.c' <<'END_OF_FILE'
  103. X/* vi:ts=4:sw=4
  104. X *
  105. X * VIM - Vi IMproved        by Bram Moolenaar
  106. X *
  107. X * Read the file "credits.txt" for a list of people who contributed.
  108. X * Read the file "uganda.txt" for copying and usage conditions.
  109. X */
  110. X
  111. X/*
  112. X * misccmds.c: functions that didn't seem to fit elsewhere
  113. X */
  114. X
  115. X#include "vim.h"
  116. X#include "globals.h"
  117. X#include "proto.h"
  118. X#include "param.h"
  119. X
  120. Xstatic void check_status __ARGS((BUF *));
  121. X
  122. Xstatic char_u *(si_tab[]) = {(char_u *)"if", (char_u *)"else", (char_u *)"while", (char_u *)"for", (char_u *)"do"};
  123. X
  124. X/*
  125. X * count the size of the indent in the current line
  126. X */
  127. X    int
  128. Xget_indent()
  129. X{
  130. X    register char_u *ptr;
  131. X    register int count = 0;
  132. X
  133. X    for (ptr = ml_get(curwin->w_cursor.lnum); *ptr; ++ptr)
  134. X    {
  135. X        if (*ptr == TAB)    /* count a tab for what it is worth */
  136. X            count += (int)curbuf->b_p_ts - (count % (int)curbuf->b_p_ts);
  137. X        else if (*ptr == ' ')
  138. X            ++count;            /* count a space for one */
  139. X        else
  140. X            break;
  141. X    }
  142. X    return (count);
  143. X}
  144. X
  145. X/*
  146. X * set the indent of the current line
  147. X * leaves the cursor on the first non-blank in the line
  148. X */
  149. X    void
  150. Xset_indent(size, delete)
  151. X    register int size;
  152. X    int delete;
  153. X{
  154. X    int                oldstate = State;
  155. X    register int    c;
  156. X
  157. X    State = INSERT;        /* don't want REPLACE for State */
  158. X    curwin->w_cursor.col = 0;
  159. X    if (delete)                            /* delete old indent */
  160. X    {
  161. X        while ((c = gchar_cursor()), iswhite(c))
  162. X            (void)delchar(FALSE);
  163. X    }
  164. X    if (!curbuf->b_p_et)            /* if 'expandtab' is set, don't use TABs */
  165. X        while (size >= (int)curbuf->b_p_ts)
  166. X        {
  167. X            inschar(TAB);
  168. X            size -= (int)curbuf->b_p_ts;
  169. X        }
  170. X    while (size)
  171. X    {
  172. X        inschar(' ');
  173. X        --size;
  174. X    }
  175. X    State = oldstate;
  176. X}
  177. X
  178. X/*
  179. X * Opencmd
  180. X *
  181. X * Add a blank line below or above the current line.
  182. X *
  183. X * Return TRUE for success, FALSE for failure
  184. X */
  185. X
  186. X    int
  187. XOpencmd(dir, redraw, delspaces)
  188. X    int         dir;
  189. X    int            redraw;
  190. X    int            delspaces;
  191. X{
  192. X    char_u   *ptr, *p_extra;
  193. X    FPOS    old_cursor;             /* old cursor position */
  194. X    int        newcol = 0;            /* new cursor column */
  195. X    int     newindent = 0;        /* auto-indent of the new line */
  196. X    int        n;
  197. X    int        truncate = FALSE;    /* truncate current line afterwards */
  198. X    int        no_si = FALSE;        /* reset did_si afterwards */
  199. X    int        retval = FALSE;        /* return value, default is FAIL */
  200. X
  201. X    ptr = strsave(ml_get(curwin->w_cursor.lnum));
  202. X    if (ptr == NULL)            /* out of memory! */
  203. X        return FALSE;
  204. X
  205. X    u_clearline();                /* cannot do "U" command when adding lines */
  206. X    did_si = FALSE;
  207. X    if (curbuf->b_p_ai || curbuf->b_p_si)
  208. X    {
  209. X        /*
  210. X         * count white space on current line
  211. X         */
  212. X        newindent = get_indent();
  213. X        if (newindent == 0)
  214. X            newindent = old_indent;        /* for ^^D command in insert mode */
  215. X        old_indent = 0;
  216. X
  217. X            /*
  218. X             * If we just did an auto-indent, then we didn't type anything on the
  219. X             * prior line, and it should be truncated.
  220. X             */
  221. X        if (dir == FORWARD && did_ai)
  222. X            truncate = TRUE;
  223. X        else if (curbuf->b_p_si && *ptr != NUL)
  224. X        {
  225. X            char_u    *p;
  226. X            char_u    *pp;
  227. X            int        i, save;
  228. X
  229. X            if (dir == FORWARD)
  230. X            {
  231. X                p = ptr + STRLEN(ptr) - 1;
  232. X                while (p > ptr && isspace(*p))    /* find last non-blank in line */
  233. X                    --p;
  234. X                if (*p == '{')                    /* line ends in '{': do indent */
  235. X                {
  236. X                    did_si = TRUE;
  237. X                    no_si = TRUE;
  238. X                }
  239. X                else                            /* look for "if" and the like */
  240. X                {
  241. X                    p = ptr;
  242. X                    skipspace(&p);
  243. X                    for (pp = p; islower(*pp); ++pp)
  244. X                        ;
  245. X                    if (!isidchar(*pp))            /* careful for vars starting with "if" */
  246. X                    {
  247. X                        save = *pp;
  248. X                        *pp = NUL;
  249. X                        for (i = sizeof(si_tab)/sizeof(char_u *); --i >= 0; )
  250. X                            if (STRCMP(p, si_tab[i]) == 0)
  251. X                            {
  252. X                                did_si = TRUE;
  253. X                                break;
  254. X                            }
  255. X                        *pp = save;
  256. X                    }
  257. X                }
  258. X            }
  259. X            else
  260. X            {
  261. X                p = ptr;
  262. X                skipspace(&p);
  263. X                if (*p == '}')            /* if line starts with '}': do indent */
  264. X                    did_si = TRUE;
  265. X            }
  266. X        }
  267. X        did_ai = TRUE;
  268. X        if (curbuf->b_p_si)
  269. X            can_si = TRUE;
  270. X    }
  271. X    if (State == INSERT || State == REPLACE)    /* only when dir == FORWARD */
  272. X    {
  273. X        p_extra = ptr + curwin->w_cursor.col;
  274. X        if (curbuf->b_p_ai && delspaces)
  275. X            skipspace(&p_extra);
  276. X        if (*p_extra != NUL)
  277. X            did_ai = FALSE;         /* append some text, don't trucate now */
  278. X    }
  279. X    else
  280. X        p_extra = (char_u *)"";                /* append empty line */
  281. X
  282. X    old_cursor = curwin->w_cursor;
  283. X    if (dir == BACKWARD)
  284. X        --curwin->w_cursor.lnum;
  285. X    if (ml_append(curwin->w_cursor.lnum, p_extra, (colnr_t)0, FALSE) == FAIL)
  286. X        goto theend;
  287. X    mark_adjust(curwin->w_cursor.lnum + 1, MAXLNUM, 1L);
  288. X    if (newindent || did_si)
  289. X    {
  290. X        ++curwin->w_cursor.lnum;
  291. X        if (did_si)
  292. X        {
  293. X            if (p_sr)
  294. X                newindent -= newindent % (int)curbuf->b_p_sw;
  295. X            newindent += (int)curbuf->b_p_sw;
  296. X        }
  297. X        set_indent(newindent, FALSE);
  298. X        newcol = curwin->w_cursor.col;
  299. X        if (no_si)
  300. X            did_si = FALSE;
  301. X    }
  302. X    curwin->w_cursor = old_cursor;
  303. X
  304. X    if (dir == FORWARD)
  305. X    {
  306. X        if (truncate || State == INSERT || State == REPLACE)
  307. X        {
  308. X            if (truncate)
  309. X                *ptr = NUL;
  310. X            else
  311. X                *(ptr + curwin->w_cursor.col) = NUL;    /* truncate current line at cursor */
  312. X            ml_replace(curwin->w_cursor.lnum, ptr, FALSE);
  313. X            ptr = NULL;
  314. X        }
  315. X
  316. X        /*
  317. X         * Get the cursor to the start of the line, so that 'curwin->w_row' gets
  318. X         * set to the right physical line number for the stuff that
  319. X         * follows...
  320. X         */
  321. X        curwin->w_cursor.col = 0;
  322. X
  323. X        if (redraw)
  324. X        {
  325. X            n = RedrawingDisabled;
  326. X            RedrawingDisabled = TRUE;
  327. X            cursupdate();                /* don't want it to update srceen */
  328. X            RedrawingDisabled = n;
  329. X
  330. X            /*
  331. X             * If we're doing an open on the last logical line, then go ahead and
  332. X             * scroll the screen up. Otherwise, just insert a blank line at the
  333. X             * right place. We use calls to plines() in case the cursor is
  334. X             * resting on a long line.
  335. X             */
  336. X            n = curwin->w_row + plines(curwin->w_cursor.lnum);
  337. X            if (n == curwin->w_height)
  338. X                scrollup(1L);
  339. X            else
  340. X                win_ins_lines(curwin, n, 1, TRUE, TRUE);
  341. X        }
  342. X        ++curwin->w_cursor.lnum;    /* cursor moves down */
  343. X    }
  344. X    else if (redraw)                 /* insert physical line above current line */
  345. X        win_ins_lines(curwin, curwin->w_row, 1, TRUE, TRUE);
  346. X
  347. X    curwin->w_cursor.col = newcol;
  348. X    if (redraw)
  349. X    {
  350. X        updateScreen(VALID_TO_CURSCHAR);
  351. X        cursupdate();            /* update curwin->w_row */
  352. X    }
  353. X    CHANGED;
  354. X
  355. X    retval = TRUE;                /* success! */
  356. Xtheend:
  357. X    free(ptr);
  358. X    return retval;
  359. X}
  360. X
  361. X/*
  362. X * plines(p) - return the number of physical screen lines taken by line 'p'
  363. X */
  364. X    int
  365. Xplines(p)
  366. X    linenr_t    p;
  367. X{
  368. X    return plines_win(curwin, p);
  369. X}
  370. X    
  371. X    int
  372. Xplines_win(wp, p)
  373. X    WIN            *wp;
  374. X    linenr_t    p;
  375. X{
  376. X    register long        col = 0;
  377. X    register char_u        *s;
  378. X    register int        lines;
  379. X
  380. X    if (!wp->w_p_wrap)
  381. X        return 1;
  382. X
  383. X    s = ml_get_buf(wp->w_buffer, p, FALSE);
  384. X    if (*s == NUL)                /* empty line */
  385. X        return 1;
  386. X
  387. X    while (*s != NUL)
  388. X        col += chartabsize(*s++, col);
  389. X
  390. X    /*
  391. X     * If list mode is on, then the '$' at the end of the line takes up one
  392. X     * extra column.
  393. X     */
  394. X    if (wp->w_p_list)
  395. X        col += 1;
  396. X
  397. X    /*
  398. X     * If 'number' mode is on, add another 8.
  399. X     */
  400. X    if (wp->w_p_nu)
  401. X        col += 8;
  402. X
  403. X    lines = (col + (Columns - 1)) / Columns;
  404. X    if (lines <= wp->w_height)
  405. X        return lines;
  406. X    return (int)(wp->w_height);        /* maximum length */
  407. X}
  408. X
  409. X/*
  410. X * Count the physical lines (rows) for the lines "first" to "last" inclusive.
  411. X */
  412. X    int
  413. Xplines_m(first, last)
  414. X    linenr_t        first, last;
  415. X{
  416. X    return plines_m_win(curwin, first, last);
  417. X}
  418. X
  419. X    int
  420. Xplines_m_win(wp, first, last)
  421. X    WIN                *wp;
  422. X    linenr_t        first, last;
  423. X{
  424. X    int count = 0;
  425. X
  426. X    while (first <= last)
  427. X        count += plines_win(wp, first++);
  428. X    return (count);
  429. X}
  430. X
  431. X/*
  432. X * insert or replace a single character at the cursor position
  433. X */
  434. X    void
  435. Xinschar(c)
  436. X    int            c;
  437. X{
  438. X    register char_u  *p;
  439. X    int                rir0;        /* reverse replace in column 0 */
  440. X    char_u            *new;
  441. X    char_u            *old;
  442. X    int                oldlen;
  443. X    int                extra;
  444. X    colnr_t            col = curwin->w_cursor.col;
  445. X    linenr_t        lnum = curwin->w_cursor.lnum;
  446. X
  447. X    old = ml_get(lnum);
  448. X    oldlen = STRLEN(old) + 1;
  449. X
  450. X    rir0 = (State == REPLACE && p_ri && col == 0);
  451. X    if (rir0 || State != REPLACE || *(old + col) == NUL)
  452. X        extra = 1;
  453. X    else
  454. X        extra = 0;
  455. X
  456. X    new = alloc((unsigned)(oldlen + extra));
  457. X    if (new == NULL)
  458. X        return;
  459. X    memmove((char *)new, (char *)old, (size_t)col);
  460. X    p = new + col;
  461. X    memmove((char *)p + extra, (char *)old + col, (size_t)(oldlen - col));
  462. X    if (rir0)                    /* reverse replace in column 0 */
  463. X    {
  464. X        *(p + 1) = c;            /* replace the char that was in column 0 */
  465. X        c = ' ';                /* insert a space */
  466. X        extraspace = TRUE;
  467. X    }
  468. X    *p = c;
  469. X    ml_replace(lnum, new, FALSE);
  470. X
  471. X    /*
  472. X     * If we're in insert mode and showmatch mode is set, then check for
  473. X     * right parens and braces. If there isn't a match, then beep. If there
  474. X     * is a match AND it's on the screen, then flash to it briefly. If it
  475. X     * isn't on the screen, don't do anything.
  476. X     */
  477. X    if (p_sm && State == INSERT && (c == ')' || c == '}' || c == ']'))
  478. X    {
  479. X        FPOS           *lpos, csave;
  480. X
  481. X        if ((lpos = showmatch(NUL)) == NULL)        /* no match, so beep */
  482. X            beep();
  483. X        else if (lpos->lnum >= curwin->w_topline)
  484. X        {
  485. X            updateScreen(VALID_TO_CURSCHAR); /* show the new char first */
  486. X            csave = curwin->w_cursor;
  487. X            curwin->w_cursor = *lpos;     /* move to matching char */
  488. X            cursupdate();
  489. X            showruler(0);
  490. X            setcursor();
  491. X            cursor_on();        /* make sure that the cursor is shown */
  492. X            flushbuf();
  493. X            vim_delay();        /* brief pause */
  494. X            curwin->w_cursor = csave;     /* restore cursor position */
  495. X            cursupdate();
  496. X        }
  497. X    }
  498. X    if (!p_ri)                            /* normal insert: cursor right */
  499. X        ++curwin->w_cursor.col;
  500. X    else if (State == REPLACE && !rir0)    /* reverse replace mode: cursor left */
  501. X        --curwin->w_cursor.col;
  502. X    CHANGED;
  503. X}
  504. X
  505. X/*
  506. X * insert a string at the cursor position
  507. X */
  508. X    void
  509. Xinsstr(s)
  510. X    register char_u  *s;
  511. X{
  512. X    register char_u        *old, *new;
  513. X    register int        newlen = STRLEN(s);
  514. X    int                    oldlen;
  515. X    colnr_t                col = curwin->w_cursor.col;
  516. X    linenr_t            lnum = curwin->w_cursor.lnum;
  517. X
  518. X    old = ml_get(lnum);
  519. X    oldlen = STRLEN(old);
  520. X    new = alloc((unsigned)(oldlen + newlen + 1));
  521. X    if (new == NULL)
  522. X        return;
  523. X    memmove((char *)new, (char *)old, (size_t)col);
  524. X    memmove((char *)new + col, (char *)s, (size_t)newlen);
  525. X    memmove((char *)new + col + newlen, (char *)old + col, (size_t)(oldlen - col + 1));
  526. X    ml_replace(lnum, new, FALSE);
  527. X    curwin->w_cursor.col += newlen;
  528. X    CHANGED;
  529. X}
  530. X
  531. X/*
  532. X * delete one character under the cursor
  533. X *
  534. X * return FAIL for failure, OK otherwise
  535. X */
  536. X    int
  537. Xdelchar(fixpos)
  538. X    int            fixpos;     /* if TRUE fix the cursor position when done */
  539. X{
  540. X    char_u        *old, *new;
  541. X    int            oldlen;
  542. X    linenr_t    lnum = curwin->w_cursor.lnum;
  543. X    colnr_t        col = curwin->w_cursor.col;
  544. X    int            was_alloced;
  545. X
  546. X    old = ml_get(lnum);
  547. X    oldlen = STRLEN(old);
  548. X
  549. X    if (col >= oldlen)    /* can't do anything (happens with replace mode) */
  550. X        return FAIL;
  551. X
  552. X/*
  553. X * If the old line has been allocated the deleteion can be done in the
  554. X * existing line. Otherwise a new line has to be allocated
  555. X */
  556. X    was_alloced = ml_line_alloced();        /* check if old was allocated */
  557. X    if (was_alloced)
  558. X        new = old;                            /* use same allocated memory */
  559. X    else
  560. X    {
  561. X        new = alloc((unsigned)oldlen);        /* need to allocated a new line */
  562. X        if (new == NULL)
  563. X            return FAIL;
  564. X        memmove((char *)new, (char *)old, (size_t)col);
  565. X    }
  566. X    memmove((char *)new + col, (char *)old + col + 1, (size_t)(oldlen - col));
  567. X    if (!was_alloced)
  568. X        ml_replace(lnum, new, FALSE);
  569. X
  570. X    /*
  571. X     * If we just took off the last character of a non-blank line, we don't
  572. X     * want to end up positioned at the newline.
  573. X     */
  574. X    if (fixpos && curwin->w_cursor.col > 0 && col == oldlen - 1)
  575. X        --curwin->w_cursor.col;
  576. X
  577. X    CHANGED;
  578. X    return OK;
  579. X}
  580. X
  581. X    void
  582. Xdellines(nlines, dowindow, undo)
  583. X    long             nlines;            /* number of lines to delete */
  584. X    int             dowindow;        /* if true, update the window */
  585. X    int                undo;            /* if true, prepare for undo */
  586. X{
  587. X    int             num_plines = 0;
  588. X
  589. X    if (nlines <= 0)
  590. X        return;
  591. X    /*
  592. X     * There's no point in keeping the window updated if we're deleting more
  593. X     * than a window's worth of lines.
  594. X     */
  595. X    if (nlines > (curwin->w_height - curwin->w_row) && dowindow)
  596. X    {
  597. X        dowindow = FALSE;
  598. X        /* flaky way to clear rest of window */
  599. X        win_del_lines(curwin, curwin->w_row, curwin->w_height, TRUE, TRUE);
  600. X    }
  601. X    if (undo && !u_savedel(curwin->w_cursor.lnum, nlines))
  602. X        return;
  603. X
  604. X    mark_adjust(curwin->w_cursor.lnum, curwin->w_cursor.lnum + nlines - 1, MAXLNUM);
  605. X    mark_adjust(curwin->w_cursor.lnum + nlines, MAXLNUM, -nlines);
  606. X
  607. X    while (nlines-- > 0)
  608. X    {
  609. X        if (bufempty())         /* nothing to delete */
  610. X            break;
  611. X
  612. X        /*
  613. X         * Set up to delete the correct number of physical lines on the
  614. X         * window
  615. X         */
  616. X        if (dowindow)
  617. X            num_plines += plines(curwin->w_cursor.lnum);
  618. X
  619. X        ml_delete(curwin->w_cursor.lnum);
  620. X
  621. X        CHANGED;
  622. X
  623. X        /* If we delete the last line in the file, stop */
  624. X        if (curwin->w_cursor.lnum > curbuf->b_ml.ml_line_count)
  625. X        {
  626. X            curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count;
  627. X            break;
  628. X        }
  629. X    }
  630. X    curwin->w_cursor.col = 0;
  631. X    /*
  632. X     * Delete the correct number of physical lines on the window
  633. X     */
  634. X    if (dowindow && num_plines > 0)
  635. X        win_del_lines(curwin, curwin->w_row, num_plines, TRUE, TRUE);
  636. X}
  637. X
  638. X    int
  639. Xgchar(pos)
  640. X    FPOS *pos;
  641. X{
  642. X    return (int)(*(ml_get_pos(pos)));
  643. X}
  644. X
  645. X    int
  646. Xgchar_cursor()
  647. X{
  648. X    return (int)(*(ml_get_cursor()));
  649. X}
  650. X
  651. X/*
  652. X * Write a character at the current cursor position.
  653. X * It is directly written into the block.
  654. X */
  655. X    void
  656. Xpchar_cursor(c)
  657. X    int c;
  658. X{
  659. X    *(ml_get_buf(curbuf, curwin->w_cursor.lnum, TRUE) + curwin->w_cursor.col) = c;
  660. X}
  661. X
  662. X/*
  663. X * return TRUE if the cursor is before or on the first non-blank in the line
  664. X */
  665. X    int
  666. Xinindent()
  667. X{
  668. X    register char_u *ptr;
  669. X    register int col;
  670. X
  671. X    for (col = 0, ptr = ml_get(curwin->w_cursor.lnum); iswhite(*ptr); ++col)
  672. X        ++ptr;
  673. X    if (col >= curwin->w_cursor.col)
  674. X        return TRUE;
  675. X    else
  676. X        return FALSE;
  677. X}
  678. X
  679. X/*
  680. X * skipspace: skip over ' ' and '\t'.
  681. X *
  682. X * note: you must give a pointer to a char_u pointer!
  683. X */
  684. X    void
  685. Xskipspace(pp)
  686. X    char_u **pp;
  687. X{
  688. X    register char_u *p;
  689. X    
  690. X    for (p = *pp; *p == ' ' || *p == '\t'; ++p)    /* skip to next non-white */
  691. X        ;
  692. X    *pp = p;
  693. X}
  694. X
  695. X/*
  696. X * skiptospace: skip over text until ' ' or '\t'.
  697. X *
  698. X * note: you must give a pointer to a char_u pointer!
  699. X */
  700. X    void
  701. Xskiptospace(pp)
  702. X    char_u **pp;
  703. X{
  704. X    register char_u *p;
  705. X
  706. X    for (p = *pp; *p != ' ' && *p != '\t' && *p != NUL; ++p)
  707. X        ;
  708. X    *pp = p;
  709. X}
  710. X
  711. X/*
  712. X * skiptodigit: skip over text until digit found
  713. X *
  714. X * note: you must give a pointer to a char_u pointer!
  715. X */
  716. X    void
  717. Xskiptodigit(pp)
  718. X    char_u **pp;
  719. X{
  720. X    register char_u *p;
  721. X
  722. X    for (p = *pp; !isdigit(*p) && *p != NUL; ++p)
  723. X        ;
  724. X    *pp = p;
  725. X}
  726. X
  727. X/*
  728. X * getdigits: get a number from a string and skip over it
  729. X *
  730. X * note: you must give a pointer to a char_u pointer!
  731. X */
  732. X
  733. X    long
  734. Xgetdigits(pp)
  735. X    char_u **pp;
  736. X{
  737. X    register char_u *p;
  738. X    long retval;
  739. X    
  740. X    p = *pp;
  741. X    retval = atol((char *)p);
  742. X    while (isdigit(*p))    /* skip to next non-digit */
  743. X        ++p;
  744. X    *pp = p;
  745. X    return retval;
  746. X}
  747. X
  748. X    char_u *
  749. Xplural(n)
  750. X    long n;
  751. X{
  752. X    static char_u buf[2] = "s";
  753. X
  754. X    if (n == 1)
  755. X        return &(buf[1]);
  756. X    return &(buf[0]);
  757. X}
  758. X
  759. X/*
  760. X * set_Changed is called when something in the current buffer is changed
  761. X */
  762. X    void
  763. Xset_Changed()
  764. X{
  765. X    if (!curbuf->b_changed)
  766. X    {
  767. X        change_warning();
  768. X        curbuf->b_changed = TRUE;
  769. X        check_status(curbuf);
  770. X    }
  771. X}
  772. X
  773. X/*
  774. X * unset_Changed is called when the changed flag must be reset for buffer 'buf'
  775. X */
  776. X    void
  777. Xunset_Changed(buf)
  778. X    BUF        *buf;
  779. X{
  780. X    if (buf->b_changed)
  781. X    {
  782. X        buf->b_changed = 0;
  783. X        check_status(buf);
  784. X    }
  785. X}
  786. X
  787. X/*
  788. X * check_status: called when the status bars for the buffer 'buf'
  789. X *                 need to be updated
  790. X */
  791. X    static void
  792. Xcheck_status(buf)
  793. X    BUF        *buf;
  794. X{
  795. X    WIN        *wp;
  796. X    int        i;
  797. X
  798. X    i = 0;
  799. X    for (wp = firstwin; wp != NULL; wp = wp->w_next)
  800. X        if (wp->w_buffer == buf && wp->w_status_height)
  801. X        {
  802. X            wp->w_redr_status = TRUE;
  803. X            ++i;
  804. X        }
  805. X    if (i && must_redraw < NOT_VALID)        /* redraw later */
  806. X        must_redraw = NOT_VALID;
  807. X}
  808. X
  809. X/*
  810. X * If the file is readonly, give a warning message with the first change.
  811. X * Don't use emsg(), because it flushes the macro buffer.
  812. X * If we have undone all changes b_changed will be FALSE, but b_did_warn
  813. X * will be TRUE.
  814. X */
  815. X    void
  816. Xchange_warning()
  817. X{
  818. X    if (curbuf->b_did_warn == FALSE && curbuf->b_changed == 0 && curbuf->b_p_ro)
  819. X    {
  820. X        curbuf->b_did_warn = TRUE;
  821. X        MSG("Warning: Changing a readonly file");
  822. X        sleep(1);            /* give him some time to think about it */
  823. X    }
  824. X}
  825. X
  826. X/*
  827. X * ask for a reply from the user, a 'y' or a 'n'.
  828. X * No other characters are accepted, the message is repeated until a valid
  829. X * reply is entered or CTRL-C is hit.
  830. X *
  831. X * return the 'y' or 'n'
  832. X */
  833. X    int
  834. Xask_yesno(str)
  835. X    char_u *str;
  836. X{
  837. X    int r = ' ';
  838. X
  839. X    while (r != 'y' && r != 'n')
  840. X    {
  841. X        (void)set_highlight('r');        /* same highlighting as for wait_return */
  842. X        msg_highlight = TRUE;
  843. X        smsg((char_u *)"%s (y/n)?", str);
  844. X        r = vgetc();
  845. X        if (r == Ctrl('C'))
  846. X            r = 'n';
  847. X        msg_outchar(r);        /* show what you typed */
  848. X        flushbuf();
  849. X    }
  850. X    return r;
  851. X}
  852. X
  853. X    void
  854. Xmsgmore(n)
  855. X    long n;
  856. X{
  857. X    long pn;
  858. X
  859. X    if (global_busy)        /* no messages now, wait until global is finished */
  860. X        return;
  861. X
  862. X    if (n > 0)
  863. X        pn = n;
  864. X    else
  865. X        pn = -n;
  866. X
  867. X    if (pn > p_report)
  868. X        smsg((char_u *)"%ld %s line%s %s", pn, n > 0 ? "more" : "fewer", plural(pn),
  869. X                                            got_int ? "(Interrupted)" : "");
  870. X}
  871. X
  872. X/*
  873. X * give a warning for an error
  874. X */
  875. X    void
  876. Xbeep()
  877. X{
  878. X    flush_buffers(FALSE);        /* flush internal buffers */
  879. X    if (p_vb)
  880. X    {
  881. X        if (T_VB && *T_VB)
  882. X            outstr(T_VB);
  883. X        else
  884. X        {                        /* very primitive visual bell */
  885. X            MSG("    ^G");
  886. X            MSG("     ^G");
  887. X            MSG("    ^G ");
  888. X            MSG("     ^G");
  889. X            MSG("       ");
  890. X            showmode();            /* may have deleted the mode message */
  891. X        }
  892. X    }
  893. X    else
  894. X        outchar('\007');
  895. X}
  896. X
  897. X/* 
  898. X * Expand environment variable with path name.
  899. X * "~/" is also expanded, like $HOME.
  900. X * If anything fails no expansion is done and dst equals src.
  901. X */
  902. X    void
  903. Xexpand_env(src, dst, dstlen)
  904. X    char_u    *src;            /* input string e.g. "$HOME/vim.hlp" */
  905. X    char_u    *dst;            /* where to put the result */
  906. X    int        dstlen;            /* maximum length of the result */
  907. X{
  908. X    char_u    *tail;
  909. X    int        c;
  910. X    char_u    *var;
  911. X
  912. X    if (*src == '$' || (*src == '~' && STRCHR("/ \t\n", src[1]) != NULL))
  913. X    {
  914. X/*
  915. X * The variable name is copied into dst temporarily, because it may be
  916. X * a string in read-only memory.
  917. X */
  918. X        if (*src == '$')
  919. X        {
  920. X            tail = src + 1;
  921. X            var = dst;
  922. X            c = dstlen - 1;
  923. X            while (c-- > 0 && *tail && isidchar(*tail))
  924. X                *var++ = *tail++;
  925. X            *var = NUL;
  926. X/*
  927. X * It is possible that vimgetenv() uses IObuff for the expansion, and that the
  928. X * 'dst' is also IObuff. This works, as long as 'var' is the first to be copied
  929. X * to 'dst'!
  930. X */
  931. X            var = vimgetenv(dst);
  932. X        }
  933. X        else
  934. X        {
  935. X            var = vimgetenv((char_u *)"HOME");
  936. X            tail = src + 1;
  937. X        }
  938. X        if (var && (STRLEN(var) + STRLEN(tail) + 1 < (unsigned)dstlen))
  939. X        {
  940. X            STRCPY(dst, var);
  941. X            STRCAT(dst, tail);
  942. X            return;
  943. X        }
  944. X    }
  945. X    STRNCPY(dst, src, (size_t)dstlen);
  946. X}
  947. X
  948. X/* 
  949. X * Replace home directory by "~/"
  950. X * If anything fails dst equals src.
  951. X */
  952. X    void
  953. Xhome_replace(src, dst, dstlen)
  954. X    char_u    *src;            /* input file name */
  955. X    char_u    *dst;            /* where to put the result */
  956. X    int        dstlen;            /* maximum length of the result */
  957. X{
  958. X    char_u    *home;
  959. X    size_t    len;
  960. X
  961. X    /*
  962. X     * If there is no "HOME" environment variable, or when it
  963. X     * is very short, don't replace anything.
  964. X     */
  965. X    if ((home = vimgetenv((char_u *)"HOME")) == NULL || (len = STRLEN(home)) <= 1)
  966. X        STRNCPY(dst, src, (size_t)dstlen);
  967. X    else
  968. X    {
  969. X        skipspace(&src);
  970. X        while (*src && dstlen > 0)
  971. X        {
  972. X            if (STRNCMP(src, home, len) == 0)
  973. X            {
  974. X                src += len;
  975. X                if (--dstlen > 0)
  976. X                    *dst++ = '~';
  977. X            }
  978. X            while (*src && *src != ' ' && --dstlen > 0)
  979. X                *dst++ = *src++;
  980. X            while (*src == ' ' && --dstlen > 0)
  981. X                *dst++ = *src++;
  982. X        }
  983. X        *dst = NUL;
  984. X    }
  985. X}
  986. X
  987. X/*
  988. X * Compare two file names and return TRUE if they are different files.
  989. X * For the first name environment variables are expanded
  990. X */
  991. X    int
  992. Xfullpathcmp(s1, s2)
  993. X    char_u *s1, *s2;
  994. X{
  995. X#ifdef UNIX
  996. X    struct stat st1, st2;
  997. X    char_u buf1[MAXPATHL];
  998. X
  999. X    expand_env(s1, buf1, MAXPATHL);
  1000. X    if (stat((char *)buf1, &st1) == 0 && stat((char *)s2, &st2) == 0 &&
  1001. X                st1.st_dev == st2.st_dev && st1.st_ino == st2.st_ino)
  1002. X        return FALSE;
  1003. X    return TRUE;
  1004. X#else
  1005. X    char_u buf1[MAXPATHL];
  1006. X    char_u buf2[MAXPATHL];
  1007. X
  1008. X    expand_env(s1, buf2, MAXPATHL);
  1009. X    if (FullName(buf2, buf1, MAXPATHL) == OK && FullName(s2, buf2, MAXPATHL) == OK)
  1010. X        return STRCMP(buf1, buf2);
  1011. X    /*
  1012. X     * one of the FullNames() failed, file probably doesn't exist.
  1013. X     */
  1014. X    return TRUE;
  1015. X#endif
  1016. X}
  1017. X
  1018. X/*
  1019. X * get the tail of a path: the file name.
  1020. X */
  1021. X    char_u *
  1022. Xgettail(fname)
  1023. X    char_u *fname;
  1024. X{
  1025. X    register char_u *p1, *p2;
  1026. X
  1027. X    for (p1 = p2 = fname; *p2; ++p2)    /* find last part of path */
  1028. X    {
  1029. X        if (ispathsep(*p2))
  1030. X            p1 = p2 + 1;
  1031. X    }
  1032. X    return p1;
  1033. X}
  1034. X
  1035. X/*
  1036. X * return TRUE if 'c' is a path separator.
  1037. X */
  1038. X    int
  1039. Xispathsep(c)
  1040. X    int c;
  1041. X{
  1042. X#ifdef UNIX
  1043. X    return (c == PATHSEP);        /* UNIX has ':' inside file names */
  1044. X#else
  1045. X# ifdef MSDOS
  1046. X    return (c == ':' || c == PATHSEP || c == '/');
  1047. X# else
  1048. X    return (c == ':' || c == PATHSEP);
  1049. X# endif
  1050. X#endif
  1051. X}
  1052. END_OF_FILE
  1053.   if test 20128 -ne `wc -c <'vim/src/misccmds.c'`; then
  1054.     echo shar: \"'vim/src/misccmds.c'\" unpacked with wrong size!
  1055.   fi
  1056.   # end of 'vim/src/misccmds.c'
  1057. fi
  1058. if test -f 'vim/src/normal.c' -a "${1}" != "-c" ; then 
  1059.   echo shar: Will not clobber existing file \"'vim/src/normal.c'\"
  1060. else
  1061.   echo shar: Extracting \"'vim/src/normal.c'\" \(41440 characters\)
  1062.   sed "s/^X//" >'vim/src/normal.c' <<'END_OF_FILE'
  1063. X/* vi:ts=4:sw=4
  1064. X *
  1065. X * VIM - Vi IMproved        by Bram Moolenaar
  1066. X *
  1067. X * Read the file "credits.txt" for a list of people who contributed.
  1068. X * Read the file "uganda.txt" for copying and usage conditions.
  1069. X */
  1070. X
  1071. X/*
  1072. X * Contains the main routine for processing characters in command mode.
  1073. X * Communicates closely with the code in ops.c to handle the operators.
  1074. X */
  1075. X
  1076. X#include "vim.h"
  1077. X#include "globals.h"
  1078. X#include "proto.h"
  1079. X#include "param.h"
  1080. X
  1081. X#undef EXTERN
  1082. X#undef INIT
  1083. X#define EXTERN
  1084. X#define INIT(x) x
  1085. X#include "ops.h"
  1086. X
  1087. X/*
  1088. X * Generally speaking, every command in normal() should either clear any
  1089. X * pending operator (with CLEAROP), or set the motion type variable.
  1090. X */
  1091. X
  1092. X#define CLEAROP (operator = NOP)        /* clear any pending operator */
  1093. X#define CLEAROPBEEP     clearopbeep()    /* CLEAROP plus a beep() */
  1094. X#define CHECKCLEAROP    if (checkclearop()) break;
  1095. X#define CHECKCLEAROPQ    if (checkclearopq()) break;
  1096. X
  1097. X/*
  1098. X * If a count is given before the operator, it is saved in opnum.
  1099. X */
  1100. Xstatic linenr_t    opnum = 0;
  1101. Xstatic linenr_t    Prenum;         /* The (optional) number before a command. */
  1102. Xint                redo_Visual_busy = FALSE;    /* TRUE when redo-ing a visual */
  1103. X
  1104. Xstatic void        prep_redo __ARGS((long, int, int, int));
  1105. Xstatic int        checkclearop __ARGS((void));
  1106. Xstatic int        checkclearopq __ARGS((void));
  1107. Xstatic void        clearopbeep __ARGS((void));
  1108. Xstatic void        premsg __ARGS((int, int));
  1109. X
  1110. Xextern int        restart_edit;    /* this is in edit.c */
  1111. X
  1112. X/*
  1113. X * normal
  1114. X *
  1115. X * Execute a command in normal mode.
  1116. X *
  1117. X * This is basically a big switch with the cases arranged in rough categories
  1118. X * in the following order:
  1119. X *
  1120. X *      0. Macros (q, @)
  1121. X *      1. Screen positioning commands (^U, ^D, ^F, ^B, ^E, ^Y, z)
  1122. X *      2. Control commands (:, <help>, ^L, ^G, ^^, ZZ, *, ^], ^T)
  1123. X *      3. Cursor motions (G, H, M, L, l, K_RARROW,  , h, K_LARROW, ^H, k, K_UARROW, ^P, +, CR, LF, j, K_DARROW, ^N, _, |, B, b, W, w, E, e, $, ^, 0)
  1124. X *      4. Searches (?, /, n, N, T, t, F, f, ,, ;, ], [, %, (, ), {, })
  1125. X *      5. Edits (., u, K_UNDO, ^R, U, r, J, p, P, ^A, ^S)
  1126. X *      6. Inserts (A, a, I, i, o, O, R)
  1127. X *      7. Operators (~, d, c, y, >, <, !, =, Q)
  1128. X *      8. Abbreviations (x, X, D, C, s, S, Y, &)
  1129. X *      9. Marks (m, ', `, ^O, ^I)
  1130. X *     10. Buffer setting (")
  1131. X *     11. Visual (v, V, ^V)
  1132. X *   12. Suspend (^Z)
  1133. X *   13. Window commands (^W)
  1134. X *   14. extended commands (starting with 'g')
  1135. X */
  1136. X
  1137. X    void
  1138. Xnormal()
  1139. X{
  1140. X    register int    c;
  1141. X    long             n;
  1142. X    int                flag = FALSE;
  1143. X    int                flag2 = FALSE;
  1144. X    int             type = 0;                /* type of operation */
  1145. X    int             dir = FORWARD;            /* search direction */
  1146. X    int                nchar = NUL;
  1147. X    int                finish_op;
  1148. X    linenr_t        Prenum1;
  1149. X    char_u            searchbuff[CMDBUFFSIZE];/* buffer for search string */
  1150. X    FPOS            *pos = NULL;            /* init for gcc */
  1151. X    register char_u    *ptr;
  1152. X    int                command_busy = FALSE;
  1153. X    static int        didwarn = FALSE;        /* warned for broken inversion */
  1154. X    int                modified = FALSE;        /* changed current buffer */
  1155. X    int                ctrl_w = FALSE;            /* got CTRL-W command */
  1156. X
  1157. X        /* the visual area is remembered for reselection */
  1158. X    static linenr_t    resel_Visual_nlines;        /* number of lines */
  1159. X    static int        resel_Visual_type = 0;    /* type 'v', 'V' or CTRL-V */
  1160. X    static colnr_t    resel_Visual_col;        /* number of columns or end column */
  1161. X        /* the visual area is remembered for redo */
  1162. X    static linenr_t    redo_Visual_nlines;        /* number of lines */
  1163. X    static int        redo_Visual_type = 0;    /* type 'v', 'V' or CTRL-V */
  1164. X    static colnr_t    redo_Visual_col;        /* number of columns or end column */
  1165. X    static long        redo_Visual_Prenum;        /* Prenum for operator */
  1166. X
  1167. X    Prenum = 0;
  1168. X    /*
  1169. X     * If there is an operator pending, then the command we take this time
  1170. X     * will terminate it. Finish_op tells us to finish the operation before
  1171. X     * returning this time (unless the operation was cancelled).
  1172. X     */
  1173. X    finish_op = (operator != NOP);
  1174. X
  1175. X    if (!finish_op && !yankbuffer)
  1176. X        opnum = 0;
  1177. X
  1178. X    if (p_sc && (vpeekc() == NUL || KeyTyped == TRUE))
  1179. X        premsg(NUL, NUL);
  1180. X    State = NORMAL_BUSY;
  1181. X    c = vgetc();
  1182. X
  1183. Xgetcount:
  1184. X    /* Pick up any leading digits and compute 'Prenum' */
  1185. X    while ((c >= '1' && c <= '9') || (Prenum != 0 && (c == DEL || c == '0')))
  1186. X    {
  1187. X        if (c == DEL)
  1188. X                Prenum /= 10;
  1189. X        else
  1190. X                Prenum = Prenum * 10 + (c - '0');
  1191. X        if (Prenum < 0)            /* got too large! */
  1192. X            Prenum = 999999999;
  1193. X        premsg(ctrl_w ? Ctrl('W') : ' ', NUL);
  1194. X        c = vgetc();
  1195. X    }
  1196. X
  1197. X/*
  1198. X * If we got CTRL-W there may be a/another count
  1199. X */
  1200. X    if (c == Ctrl('W') && !ctrl_w)
  1201. X    {
  1202. X        ctrl_w = TRUE;
  1203. X        opnum = Prenum;                        /* remember first count */
  1204. X        Prenum = 0;
  1205. X        State = ONLYKEY;                    /* no mapping for nchar, but keys */
  1206. X        premsg(c, NUL);
  1207. X        c = vgetc();                        /* get next character */
  1208. X        goto getcount;                        /* jump back */
  1209. X    }
  1210. X
  1211. X    /*
  1212. X     * If we're in the middle of an operator (including after entering a yank
  1213. X     * buffer with ") AND we had a count before the
  1214. X     * operator, then that count overrides the current value of Prenum. What
  1215. X     * this means effectively, is that commands like "3dw" get turned into
  1216. X     * "d3w" which makes things fall into place pretty neatly.
  1217. X     * If you give a count before AND after the operator, they are multiplied.
  1218. X     */
  1219. X    if (opnum != 0)
  1220. X    {
  1221. X            if (Prenum)
  1222. X                Prenum *= opnum;
  1223. X            else
  1224. X                Prenum = opnum;
  1225. X            opnum = 0;
  1226. X    }
  1227. X
  1228. X    Prenum1 = (Prenum == 0 ? 1 : Prenum);        /* Prenum often defaults to 1 */
  1229. X    premsg(c, NUL);
  1230. X
  1231. X    /*
  1232. X     * get an additional character if we need one
  1233. X     * for CTRL-W we already got it when looking for a count
  1234. X     */
  1235. X    if (ctrl_w)
  1236. X    {
  1237. X        nchar = c;
  1238. X        c = Ctrl('W');
  1239. X        premsg(c, nchar);
  1240. X    }
  1241. X    else if (strchr("@zZtTfF[]mg'`\"", c) || (c == 'q' && !Recording && !Exec_reg) ||
  1242. X                                        (c == 'r' && !VIsual.lnum))
  1243. X    {
  1244. X        State = NOMAPPING;
  1245. X        nchar = vgetc();        /* no macro mapping for this char */
  1246. X        premsg(c, nchar);
  1247. X    }
  1248. X    if (p_sc)
  1249. X        flushbuf();        /* flush the premsg() characters onto the screen so we can
  1250. X                            see them while the command is being executed */
  1251. X
  1252. X/*
  1253. X * For commands that don't get another character we can put the State back to
  1254. X * NORMAL and check for a window size change.
  1255. X */
  1256. X    if (STRCHR("z:/?", c) == NULL)
  1257. X        State = NORMAL;
  1258. X    if (nchar == ESC)
  1259. X    {
  1260. X        CLEAROP;
  1261. X        goto normal_end;
  1262. X    }
  1263. X    switch (c)
  1264. X    {
  1265. X
  1266. X/*
  1267. X * 0: Macros
  1268. X */
  1269. X      case 'q':         /* (stop) recording into a named register */
  1270. X        CHECKCLEAROP;
  1271. X                        /* command is ignored while executing a register */
  1272. X        if (!Exec_reg && dorecord(nchar) == FAIL)
  1273. X            CLEAROPBEEP;
  1274. X        break;
  1275. X
  1276. X     case '@':            /* execute a named buffer */
  1277. X        CHECKCLEAROP;
  1278. X        while (Prenum1--)
  1279. X        {
  1280. X            if (doexecbuf(nchar) == FAIL)
  1281. X            {
  1282. X                CLEAROPBEEP;
  1283. X                break;
  1284. X            }
  1285. X        }
  1286. X        break;
  1287. X
  1288. X/*
  1289. X * 1: Screen positioning commands
  1290. X */
  1291. X      case Ctrl('D'):
  1292. X        flag = TRUE;
  1293. X
  1294. X      case Ctrl('U'):
  1295. X        CHECKCLEAROP;
  1296. X        if (Prenum)
  1297. X            curwin->w_p_scroll = (Prenum > curwin->w_height) ? curwin->w_height : Prenum;
  1298. X        n = (curwin->w_p_scroll <= curwin->w_height) ? curwin->w_p_scroll : curwin->w_height;
  1299. X        if (flag)
  1300. X        {
  1301. X                curwin->w_topline += n;
  1302. X                if (curwin->w_topline > curbuf->b_ml.ml_line_count)
  1303. X                    curwin->w_topline = curbuf->b_ml.ml_line_count;
  1304. X                comp_Botline(curwin);        /* compute curwin->w_botline */
  1305. X                (void)onedown(n);
  1306. X        }
  1307. X        else
  1308. X        {
  1309. X                if (n >= curwin->w_cursor.lnum)
  1310. X                    n = curwin->w_cursor.lnum - 1;
  1311. X                Prenum1 = curwin->w_cursor.lnum - n;
  1312. X                scrolldown(n);
  1313. X                if (Prenum1 < curwin->w_cursor.lnum)
  1314. X                    curwin->w_cursor.lnum = Prenum1;
  1315. X        }
  1316. X        beginline(TRUE);
  1317. X        updateScreen(VALID);
  1318. X        break;
  1319. X
  1320. X      case Ctrl('B'):
  1321. X      case K_SUARROW:
  1322. X        dir = BACKWARD;
  1323. X
  1324. X      case Ctrl('F'):
  1325. X      case K_SDARROW:
  1326. X        CHECKCLEAROP;
  1327. X        (void)onepage(dir, Prenum1);
  1328. X        break;
  1329. X
  1330. X      case Ctrl('E'):
  1331. X        CHECKCLEAROP;
  1332. X        scrollup(Prenum1);
  1333. X                /* We may have moved to another line -- webb */
  1334. X        coladvance(curwin->w_curswant);
  1335. X        updateScreen(VALID);
  1336. X        break;
  1337. X
  1338. X      case Ctrl('Y'):
  1339. X        CHECKCLEAROP;
  1340. X        scrolldown(Prenum1);
  1341. X                /* We may have moved to another line -- webb */
  1342. X        coladvance(curwin->w_curswant);
  1343. X        updateScreen(VALID);
  1344. X        break;
  1345. X
  1346. X      case 'z':
  1347. X        CHECKCLEAROP;
  1348. X        if (isdigit(nchar))
  1349. X        {
  1350. X            /*
  1351. X             * we misuse some variables to be able to call premsg()
  1352. X             */
  1353. X            operator = c;
  1354. X            opnum = Prenum;
  1355. X            Prenum = nchar - '0';
  1356. X            for (;;)
  1357. X            {
  1358. X                premsg(' ', NUL);
  1359. X                nchar = vgetc();
  1360. X                State = NORMAL;
  1361. X                if (nchar == DEL)
  1362. X                    Prenum /= 10;
  1363. X                else if (isdigit(nchar))
  1364. X                    Prenum = Prenum * 10 + (nchar - '0');
  1365. X                else if (nchar == CR)
  1366. X                {
  1367. X                    win_setheight((int)Prenum);
  1368. X                    break;
  1369. X                }
  1370. X                else
  1371. X                {
  1372. X                    CLEAROPBEEP;
  1373. X                    break;
  1374. X                }
  1375. X            }
  1376. X            operator = NOP;
  1377. X            break;
  1378. X        }
  1379. X
  1380. X        if (Prenum && Prenum != curwin->w_cursor.lnum)    /* line number given */
  1381. X        {
  1382. X            setpcmark();
  1383. X            if (Prenum > curbuf->b_ml.ml_line_count)
  1384. X                curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count;
  1385. X            else
  1386. X                curwin->w_cursor.lnum = Prenum;
  1387. X        }
  1388. X        State = NORMAL;            /* for updateScreen() */
  1389. X        switch (nchar)
  1390. X        {
  1391. X          case NL:                /* put curwin->w_cursor at top of screen */
  1392. X          case CR:
  1393. X            beginline(TRUE);
  1394. X          case 't':
  1395. X            curwin->w_topline = curwin->w_cursor.lnum;
  1396. X            break;
  1397. X
  1398. X          case '.':             /* put curwin->w_cursor in middle of screen */
  1399. X          case 'z':
  1400. X            n = (curwin->w_height + plines(curwin->w_cursor.lnum)) / 2;
  1401. X            goto dozcmd;
  1402. X
  1403. X          case '-':             /* put curwin->w_cursor at bottom of screen */
  1404. X          case 'b':
  1405. X            n = curwin->w_height;
  1406. X            /* FALLTHROUGH */
  1407. X
  1408. X    dozcmd:
  1409. X            {
  1410. X                register linenr_t    lp = curwin->w_cursor.lnum;
  1411. X                register long        l = plines(lp);
  1412. X
  1413. X                do
  1414. X                {
  1415. X                    curwin->w_topline = lp;
  1416. X                    if (--lp == 0)
  1417. X                        break;
  1418. X                    l += plines(lp);
  1419. X                } while (l <= n);
  1420. X            }
  1421. X            if (nchar != 'z' && nchar != 'b')
  1422. X                beginline(TRUE);
  1423. X            break;
  1424. X
  1425. X          case Ctrl('S'):    /* ignore CTRL-S and CTRL-Q to avoid problems */
  1426. X          case Ctrl('Q'):    /* with terminals that use xon/xoff */
  1427. X              break;
  1428. X
  1429. X          default:
  1430. X            CLEAROPBEEP;
  1431. X        }
  1432. X        updateScreen(VALID);
  1433. X        break;
  1434. X
  1435. X/*
  1436. X *      2: Control commands
  1437. X */
  1438. X      case ':':
  1439. X        if (VIsual.lnum)
  1440. X            goto dooperator;
  1441. X        CHECKCLEAROP;
  1442. X        /*
  1443. X         * translate "count:" into ":.,.+(count - 1)"
  1444. X         */
  1445. X        if (Prenum)
  1446. X        {
  1447. X            stuffReadbuff((char_u *)".");
  1448. X            if (Prenum > 1)
  1449. X            {
  1450. X                stuffReadbuff((char_u *)",.+");
  1451. X                stuffnumReadbuff((long)Prenum - 1L);
  1452. X            }
  1453. X        }
  1454. X        docmdline(NULL);
  1455. X        modified = TRUE;
  1456. X        break;
  1457. X
  1458. X      case K_HELP:
  1459. X        CHECKCLEAROP;
  1460. X        help();
  1461. X        break;
  1462. X
  1463. X      case Ctrl('L'):
  1464. X        CHECKCLEAROP;
  1465. X        updateScreen(CLEAR);
  1466. X        break;
  1467. X
  1468. X      case Ctrl('G'):
  1469. X        CHECKCLEAROP;
  1470. X        fileinfo(did_cd || Prenum);    /* print full name if count given or :cd used */
  1471. X        break;
  1472. X
  1473. X      case K_CCIRCM:            /* CTRL-^, short for ":e #" */
  1474. X        CHECKCLEAROPQ;
  1475. X        (void)buflist_getfile((int)Prenum, (linenr_t)0, TRUE);
  1476. X        break;
  1477. X
  1478. X      case 'Z':         /* write, if changed, and exit */
  1479. X        CHECKCLEAROPQ;
  1480. X        if (nchar != 'Z')
  1481. X        {
  1482. X            CLEAROPBEEP;
  1483. X            break;
  1484. X        }
  1485. X        stuffReadbuff((char_u *)":x\n");
  1486. X        break;
  1487. X
  1488. X      case Ctrl(']'):            /* :ta to current identifier */
  1489. X        CHECKCLEAROPQ;
  1490. X      case '*':                 /* / to current identifier or string */
  1491. X      case '#':                 /* ? to current identifier or string */
  1492. X      case 'K':                    /* run program for current identifier */
  1493. X        {
  1494. X            register int     col;
  1495. X            register int    i;
  1496. X
  1497. X            /*
  1498. X             * if i == 0: try to find an identifier
  1499. X             * if i == 1: try to find any string
  1500. X             */
  1501. X            ptr = ml_get(curwin->w_cursor.lnum);
  1502. X            for (i = 0;    i < 2; ++i)
  1503. X            {
  1504. X                /*
  1505. X                 * skip to start of identifier/string
  1506. X                 */
  1507. X                col = curwin->w_cursor.col;
  1508. X                while (ptr[col] != NUL &&
  1509. X                            (i == 0 ? !isidchar(ptr[col]) : iswhite(ptr[col])))
  1510. X                    ++col;
  1511. X
  1512. X                /*
  1513. X                 * Back up to start of identifier/string. This doesn't match the
  1514. X                 * real vi but I like it a little better and it shouldn't bother
  1515. X                 * anyone.
  1516. X                 */
  1517. X                while (col > 0 && (i == 0 ? isidchar(ptr[col - 1]) :
  1518. X                            (!iswhite(ptr[col - 1]) && !isidchar(ptr[col - 1]))))
  1519. X                    --col;
  1520. X
  1521. X                /*
  1522. X                 * if identifier found or not '*' or '#' command, stop searching
  1523. X                 */
  1524. X                if (isidchar(ptr[col]) || (c != '*' && c != '#'))
  1525. X                    break;
  1526. X            }
  1527. X            /*
  1528. X             * did't find an identifier of string
  1529. X             */
  1530. X            if (ptr[col] == NUL || (!isidchar(ptr[col]) && i == 0))
  1531. X            {
  1532. X                CLEAROPBEEP;
  1533. X                break;
  1534. X            }
  1535. X
  1536. X            if (Prenum)
  1537. X                stuffnumReadbuff(Prenum);
  1538. X            switch (c)
  1539. X            {
  1540. X                case '*':
  1541. X                    stuffReadbuff((char_u *)"/");
  1542. X                    goto sow;
  1543. X
  1544. X                case '#':
  1545. X                    stuffReadbuff((char_u *)"?");
  1546. Xsow:                if (i == 0)
  1547. X                        stuffReadbuff((char_u *)"\\<");
  1548. X                    break;
  1549. X
  1550. X                case 'K':
  1551. X                    stuffReadbuff((char_u *)":! ");
  1552. X                    stuffReadbuff(p_kp);
  1553. X                    stuffReadbuff((char_u *)" ");
  1554. X                    break;
  1555. X                default:
  1556. X                    stuffReadbuff((char_u *)":ta ");
  1557. X            }
  1558. X
  1559. X            /*
  1560. X             * Now grab the chars in the identifier
  1561. X             */
  1562. X            while (i == 0 ? isidchar(ptr[col]) :
  1563. X                                (ptr[col] != NUL && !iswhite(ptr[col])))
  1564. X            {
  1565. X                stuffcharReadbuff(ptr[col]);
  1566. X                ++col;
  1567. X            }
  1568. X            if ((c == '*' || c == '#') && i == 0)
  1569. X                stuffReadbuff((char_u *)"\\>");
  1570. X            stuffReadbuff((char_u *)"\n");
  1571. X        }
  1572. X        break;
  1573. X
  1574. X      case Ctrl('T'):        /* backwards in tag stack */
  1575. X            CHECKCLEAROPQ;
  1576. X              dotag((char_u *)"", 2, (int)Prenum1);
  1577. X            break;
  1578. X
  1579. X/*
  1580. X * Cursor motions
  1581. X */
  1582. X      case 'G':
  1583. X        mtype = MLINE;
  1584. X        setpcmark();
  1585. X        if (Prenum == 0 || Prenum > curbuf->b_ml.ml_line_count)
  1586. X                curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count;
  1587. X        else
  1588. X                curwin->w_cursor.lnum = Prenum;
  1589. X        beginline(TRUE);
  1590. X        break;
  1591. X
  1592. X      case 'H':
  1593. X      case 'M':
  1594. X        if (c == 'M')
  1595. X                n = (curwin->w_height - curwin->w_empty_rows) / 2;
  1596. X        else
  1597. X                n = Prenum;
  1598. X        mtype = MLINE;
  1599. X        setpcmark();
  1600. X        curwin->w_cursor.lnum = curwin->w_topline;
  1601. X        while (n && onedown((long)1) == OK)
  1602. X                --n;
  1603. X        beginline(TRUE);
  1604. X        break;
  1605. X
  1606. X      case 'L':
  1607. X        mtype = MLINE;
  1608. X        setpcmark();
  1609. X        curwin->w_cursor.lnum = curwin->w_botline - 1;
  1610. X        for (n = Prenum; n && oneup((long)1) == OK; n--)
  1611. X                ;
  1612. X        beginline(TRUE);
  1613. X        break;
  1614. X
  1615. X      case 'l':
  1616. X      case K_RARROW:
  1617. X      case ' ':
  1618. X        mtype = MCHAR;
  1619. X        mincl = FALSE;
  1620. X        n = Prenum1;
  1621. X        while (n--)
  1622. X        {
  1623. X            if (oneright() == FAIL)
  1624. X            {
  1625. X                    /* space wraps to next line if 'whichwrap' bit 1 set */
  1626. X                    /* 'l' wraps to next line if 'whichwrap' bit 2 set */
  1627. X                    /* CURS_RIGHT wraps to next line if 'whichwrap' bit 3 set */
  1628. X                if (((c == ' ' && (p_ww & 2)) ||
  1629. X                     (c == 'l' && (p_ww & 4)) ||
  1630. X                     (c == K_RARROW && (p_ww & 8))) &&
  1631. X                         curwin->w_cursor.lnum < curbuf->b_ml.ml_line_count)
  1632. X                {
  1633. X                    ++curwin->w_cursor.lnum;
  1634. X                    curwin->w_cursor.col = 0;
  1635. X                    curwin->w_set_curswant = TRUE;
  1636. X                    continue;
  1637. X                }
  1638. X                if (operator == NOP)
  1639. X                    beep();
  1640. X                else
  1641. X                {
  1642. X                    if (lineempty(curwin->w_cursor.lnum))
  1643. X                        CLEAROPBEEP;
  1644. X                    else
  1645. X                    {
  1646. X                        mincl = TRUE;
  1647. X                        if (n)
  1648. X                            beep();
  1649. X                    }
  1650. X                }
  1651. X                break;
  1652. X            }
  1653. X        }
  1654. X        break;
  1655. X
  1656. X      case Ctrl('H'):
  1657. X      case 'h':
  1658. X      case K_LARROW:
  1659. X      case DEL:
  1660. X        mtype = MCHAR;
  1661. X        mincl = FALSE;
  1662. X        n = Prenum1;
  1663. X        while (n--)
  1664. X        {
  1665. X            if (oneleft() == FAIL)
  1666. X            {
  1667. X                    /* backspace and del wrap to previous line if 'whichwrap'
  1668. X                     *                                            bit 0 set */
  1669. X                    /* 'h' wraps to previous line if 'whichwrap' bit 2 set */
  1670. X                    /* CURS_LEFT wraps to previous line if 'whichwrap' bit 3 set */
  1671. X                if ((((c == Ctrl('H') || c == DEL) && (p_ww & 1)) ||
  1672. X                     (c == 'h' && (p_ww & 4)) ||
  1673. X                     (c == K_LARROW && (p_ww & 8))) &&
  1674. X                            curwin->w_cursor.lnum > 1)
  1675. X                {
  1676. X                    --(curwin->w_cursor.lnum);
  1677. X                    coladvance(MAXCOL);
  1678. X                    curwin->w_set_curswant = TRUE;
  1679. X                    continue;
  1680. X                }
  1681. X                else if (operator != DELETE && operator != CHANGE)
  1682. X                    beep();
  1683. X                else if (Prenum1 == 1)
  1684. X                    CLEAROPBEEP;
  1685. X                break;
  1686. X            }
  1687. X        }
  1688. X        break;
  1689. X
  1690. X      case '-':
  1691. X        flag = TRUE;
  1692. X        /* FALLTHROUGH */
  1693. X
  1694. X      case 'k':
  1695. X      case K_UARROW:
  1696. X      case Ctrl('P'):
  1697. X        mtype = MLINE;
  1698. X        if (oneup(Prenum1) == FAIL)
  1699. X            CLEAROPBEEP;
  1700. X        else if (flag)
  1701. X            beginline(TRUE);
  1702. X        break;
  1703. X
  1704. X      case '+':
  1705. X      case CR:
  1706. X        flag = TRUE;
  1707. X        /* FALLTHROUGH */
  1708. X
  1709. X      case 'j':
  1710. X      case K_DARROW:
  1711. X      case Ctrl('N'):
  1712. X      case NL:
  1713. X        mtype = MLINE;
  1714. X        if (onedown(Prenum1) == FAIL)
  1715. X            CLEAROPBEEP;
  1716. X        else if (flag)
  1717. X            beginline(TRUE);
  1718. X        break;
  1719. X
  1720. X        /*
  1721. X         * This is a strange motion command that helps make operators more
  1722. X         * logical. It is actually implemented, but not documented in the
  1723. X         * real 'vi'. This motion command actually refers to "the current
  1724. X         * line". Commands like "dd" and "yy" are really an alternate form of
  1725. X         * "d_" and "y_". It does accept a count, so "d3_" works to delete 3
  1726. X         * lines.
  1727. X         */
  1728. X      case '_':
  1729. Xlineop:
  1730. X        mtype = MLINE;
  1731. X        if (onedown((long)(Prenum1 - 1)) == FAIL)
  1732. X            CLEAROPBEEP;
  1733. X        if (operator != YANK)            /* 'Y' does not move cursor */
  1734. X            beginline(TRUE);
  1735. X        break;
  1736. X
  1737. X      case '|':
  1738. X        mtype = MCHAR;
  1739. X        mincl = TRUE;
  1740. X        beginline(FALSE);
  1741. X        if (Prenum > 0)
  1742. X            coladvance((colnr_t)(Prenum - 1));
  1743. X        curwin->w_curswant = (colnr_t)(Prenum - 1);
  1744. X            /* keep curswant at the column where we wanted to go, not where
  1745. X                we ended; differs is line is too short */
  1746. X        curwin->w_set_curswant = FALSE;
  1747. X        break;
  1748. X
  1749. X        /*
  1750. X         * Word Motions
  1751. X         */
  1752. X
  1753. X      case 'B':
  1754. X        type = 1;
  1755. X        /* FALLTHROUGH */
  1756. X
  1757. X      case 'b':
  1758. X      case K_SLARROW:
  1759. X        mtype = MCHAR;
  1760. X        mincl = FALSE;
  1761. X        curwin->w_set_curswant = TRUE;
  1762. X        if (bck_word(Prenum1, type))
  1763. X            CLEAROPBEEP;
  1764. X        break;
  1765. X
  1766. X      case 'E':
  1767. X        type = 1;
  1768. X        /* FALLTHROUGH */
  1769. X
  1770. X      case 'e':
  1771. X        mincl = TRUE;
  1772. X        goto dowrdcmd;
  1773. X
  1774. X      case 'W':
  1775. X        type = 1;
  1776. X        /* FALLTHROUGH */
  1777. X
  1778. X      case 'w':
  1779. X      case K_SRARROW:
  1780. X        mincl = FALSE;
  1781. X        flag = TRUE;
  1782. X        /*
  1783. X         * This is a little strange. To match what the real vi does, we
  1784. X         * effectively map 'cw' to 'ce', and 'cW' to 'cE', provided that we are
  1785. X         * not on a space or a TAB. This seems
  1786. X         * impolite at first, but it's really more what we mean when we say
  1787. X         * 'cw'.
  1788. X         * Another strangeness: When standing on the end of a word "ce" will
  1789. X         * change until the end of the next wordt, but "cw" will change only
  1790. X         * one character! This is done by setting type to 2.
  1791. X         */
  1792. X        if (operator == CHANGE && (n = gchar_cursor()) != ' ' && n != TAB &&
  1793. X                                                                n != NUL)
  1794. X        {
  1795. X            mincl = TRUE;
  1796. X            flag = FALSE;
  1797. X            flag2 = TRUE;
  1798. X        }
  1799. X
  1800. Xdowrdcmd:
  1801. X        mtype = MCHAR;
  1802. X        curwin->w_set_curswant = TRUE;
  1803. X        if (flag)
  1804. X            n = fwd_word(Prenum1, type, operator != NOP);
  1805. X        else
  1806. X            n = end_word(Prenum1, type, flag2);
  1807. X        if (n)
  1808. X        {
  1809. X            CLEAROPBEEP;
  1810. X            break;
  1811. X        }
  1812. X#if 0
  1813. X        /*
  1814. X         * If we do a 'dw' for the last word in a line, we only delete the rest
  1815. X         * of the line, not joining the two lines, unless the current line is empty.
  1816. X         */
  1817. X        if (operator == DELETE && Prenum1 == 1 &&
  1818. X                curbuf->b_startop.lnum != curwin->w_cursor.lnum && !lineempty(startop.lnum))
  1819. X        {
  1820. X                curwin->w_cursor = curbuf->b_startop;
  1821. X                while (oneright() == OK)
  1822. X                    ;
  1823. X                mincl = TRUE;
  1824. X        }
  1825. X#endif
  1826. X        break;
  1827. X
  1828. X      case '$':
  1829. X        mtype = MCHAR;
  1830. X        mincl = TRUE;
  1831. X        curwin->w_curswant = MAXCOL;                /* so we stay at the end */
  1832. X        if (onedown((long)(Prenum1 - 1)) == FAIL)
  1833. X        {
  1834. X            CLEAROPBEEP;
  1835. X            break;
  1836. X        }
  1837. X        break;
  1838. X
  1839. X      case '^':
  1840. X        flag = TRUE;
  1841. X        /* FALLTHROUGH */
  1842. X
  1843. X      case '0':
  1844. X        mtype = MCHAR;
  1845. X        mincl = FALSE;
  1846. X        beginline(flag);
  1847. X        break;
  1848. X
  1849. X/*
  1850. X * 4: Searches
  1851. X */
  1852. X      case '?':
  1853. X      case '/':
  1854. X        if (!getcmdline(c, searchbuff))
  1855. X        {
  1856. X            CLEAROP;
  1857. X            break;
  1858. X        }
  1859. X        mtype = MCHAR;
  1860. X        mincl = FALSE;
  1861. X        curwin->w_set_curswant = TRUE;
  1862. X
  1863. X        n = dosearch(c, searchbuff, FALSE, Prenum1, TRUE, TRUE);
  1864. X        if (n == 0)
  1865. X            CLEAROP;
  1866. X        else if (n == 2)
  1867. X            mtype = MLINE;
  1868. X        break;
  1869. X
  1870. X      case 'N':
  1871. X        flag = 1;
  1872. X
  1873. X      case 'n':
  1874. X        mtype = MCHAR;
  1875. X        mincl = FALSE;
  1876. X        curwin->w_set_curswant = TRUE;
  1877. X        if (!dosearch(0, NULL, flag, Prenum1, TRUE, TRUE))
  1878. X            CLEAROP;
  1879. X        break;
  1880. X
  1881. X        /*
  1882. X         * Character searches
  1883. X         */
  1884. X      case 'T':
  1885. X        dir = BACKWARD;
  1886. X        /* FALLTHROUGH */
  1887. X
  1888. X      case 't':
  1889. X        type = 1;
  1890. X        goto docsearch;
  1891. X
  1892. X      case 'F':
  1893. X        dir = BACKWARD;
  1894. X        /* FALLTHROUGH */
  1895. X
  1896. X      case 'f':
  1897. Xdocsearch:
  1898. X        mtype = MCHAR;
  1899. X        if (dir == BACKWARD)
  1900. X            mincl = FALSE;
  1901. X        else
  1902. X            mincl = TRUE;
  1903. X        curwin->w_set_curswant = TRUE;
  1904. X        if (!searchc(nchar, dir, type, Prenum1))
  1905. X            CLEAROPBEEP;
  1906. X        break;
  1907. X
  1908. X      case ',':
  1909. X        flag = 1;
  1910. X        /* FALLTHROUGH */
  1911. X
  1912. X      case ';':
  1913. X        dir = flag;
  1914. X        goto docsearch;        /* nchar == NUL, thus repeat previous search */
  1915. X
  1916. X        /*
  1917. X         * section or C function searches
  1918. X         */
  1919. X      case '[':
  1920. X        dir = BACKWARD;
  1921. X        /* FALLTHROUGH */
  1922. X
  1923. X      case ']':
  1924. X        mtype = MCHAR;
  1925. X        mincl = FALSE;
  1926. X
  1927. X        /*
  1928. X         * "[f" or "]f" : Edit file under the cursor (same as "gf")
  1929. X         */
  1930. X        if ((c == ']' || c == '[') && nchar == 'f')
  1931. X            goto gotofile;
  1932. X
  1933. X        /*
  1934. X         * "[{", "[(", "]}" or "])": go to Nth unclosed '{', '(', '}' or ')'
  1935. X         */
  1936. X        if ((c == '[' && (nchar == '{' || nchar == '(')) ||
  1937. X           ((c == ']' && (nchar == '}' || nchar == ')'))))
  1938. X        {
  1939. X            FPOS old_pos;
  1940. X
  1941. X            old_pos = curwin->w_cursor;
  1942. X            while (Prenum1--)
  1943. X            {
  1944. X                if ((pos = showmatch(nchar)) == NULL)
  1945. X                {
  1946. X                    CLEAROPBEEP;
  1947. X                    break;
  1948. X                }
  1949. X                curwin->w_cursor = *pos;
  1950. X            }
  1951. X            curwin->w_cursor = old_pos;
  1952. X            if (pos != NULL)
  1953. X            {
  1954. X                setpcmark();
  1955. X                curwin->w_cursor = *pos;
  1956. X                curwin->w_set_curswant = TRUE;
  1957. X            }
  1958. X            break;
  1959. X        }
  1960. X
  1961. X        /*
  1962. X         * "[[", "[]", "]]" and "][": move to start or end of function
  1963. X         */
  1964. X        if (nchar == '[' || nchar == ']')
  1965. X        {
  1966. X            if (nchar == c)                /* "]]" or "[[" */
  1967. X                flag = '{';
  1968. X            else
  1969. X                flag = '}';                /* "][" or "[]" */
  1970. X
  1971. X            curwin->w_set_curswant = TRUE;
  1972. X            /*
  1973. X             * Imitate strange vi behaviour: When using "]]" with an operator we
  1974. X             * also stop at '}'.
  1975. X             */
  1976. X            if (!findpar(dir, Prenum1, flag,
  1977. X                            (operator != NOP && dir == FORWARD && flag == '{')))
  1978. X                CLEAROPBEEP;
  1979. X            break;
  1980. X        }
  1981. X
  1982. X        /*
  1983. X         * "[p" and "]p": put with indent adjustment
  1984. X         */
  1985. X        if (nchar == 'p')
  1986. X        {
  1987. X            doput((c == ']') ? FORWARD : BACKWARD, Prenum1, TRUE);
  1988. X            modified = TRUE;
  1989. X            break;
  1990. X        }
  1991. X
  1992. X        /*
  1993. X         * end of '[' and ']': not a valid nchar
  1994. X         */
  1995. X        CLEAROPBEEP;
  1996. X        break;
  1997. X
  1998. X      case '%':
  1999. X        mincl = TRUE;
  2000. X        if (Prenum)        /* {cnt}% : goto {cnt} percentage in file */
  2001. X        {
  2002. X            if (Prenum > 100)
  2003. X                CLEAROPBEEP;
  2004. X            else
  2005. X            {
  2006. X                mtype = MLINE;
  2007. X                setpcmark();
  2008. X                        /* round up, so CTRL-G will give same value */
  2009. X                curwin->w_cursor.lnum = (curbuf->b_ml.ml_line_count * Prenum + 99) / 100;
  2010. X                beginline(TRUE);
  2011. X            }
  2012. X        }
  2013. X        else            /* % : go to matching paren */
  2014. X        {
  2015. X            mtype = MCHAR;
  2016. X            if ((pos = showmatch(NUL)) == NULL)
  2017. X                CLEAROPBEEP;
  2018. X            else
  2019. X            {
  2020. X                setpcmark();
  2021. X                curwin->w_cursor = *pos;
  2022. X                curwin->w_set_curswant = TRUE;
  2023. X            }
  2024. X        }
  2025. X        break;
  2026. X
  2027. X      case '(':
  2028. X        dir = BACKWARD;
  2029. X        /* FALLTHROUGH */
  2030. X
  2031. X      case ')':
  2032. X        mtype = MCHAR;
  2033. X        if (c == ')')
  2034. X            mincl = FALSE;
  2035. X        else
  2036. X            mincl = TRUE;
  2037. X        curwin->w_set_curswant = TRUE;
  2038. X
  2039. X        if (!findsent(dir, Prenum1))
  2040. X            CLEAROPBEEP;
  2041. X        break;
  2042. X
  2043. X      case '{':
  2044. X        dir = BACKWARD;
  2045. X        /* FALLTHROUGH */
  2046. X
  2047. X      case '}':
  2048. X        mtype = MCHAR;
  2049. X        mincl = FALSE;
  2050. X        curwin->w_set_curswant = TRUE;
  2051. X        if (!findpar(dir, Prenum1, NUL, FALSE))
  2052. X            CLEAROPBEEP;
  2053. X        break;
  2054. X
  2055. X/*
  2056. X * 5: Edits
  2057. X */
  2058. X      case '.':
  2059. X        CHECKCLEAROPQ;
  2060. X        if (start_redo(Prenum) == FAIL)
  2061. X            CLEAROPBEEP;
  2062. X        modified = TRUE;
  2063. X        break;
  2064. X
  2065. X      case 'u':
  2066. X        if (VIsual.lnum)
  2067. X            goto dooperator;
  2068. X      case K_UNDO:
  2069. X        CHECKCLEAROPQ;
  2070. X        u_undo((int)Prenum1);
  2071. X        curwin->w_set_curswant = TRUE;
  2072. X        modified = TRUE;
  2073. X        break;
  2074. X
  2075. X      case Ctrl('R'):
  2076. X        CHECKCLEAROPQ;
  2077. X          u_redo((int)Prenum1);
  2078. X        curwin->w_set_curswant = TRUE;
  2079. X        modified = TRUE;
  2080. X        break;
  2081. X
  2082. X      case 'U':
  2083. X        if (VIsual.lnum)
  2084. X            goto dooperator;
  2085. X        CHECKCLEAROPQ;
  2086. X        u_undoline();
  2087. X        curwin->w_set_curswant = TRUE;
  2088. X        modified = TRUE;
  2089. X        break;
  2090. X
  2091. X      case 'r':
  2092. X        if (VIsual.lnum)
  2093. X        {
  2094. X            c = 'c';
  2095. X            goto dooperator;
  2096. X        }
  2097. X        CHECKCLEAROPQ;
  2098. X        ptr = ml_get_cursor();
  2099. X        if (STRLEN(ptr) < (unsigned)Prenum1)    /* not enough characters to replace */
  2100. X        {
  2101. X            CLEAROPBEEP;
  2102. X            break;
  2103. X        }
  2104. X        /*
  2105. X         * Replacing with a line break or tab is done by edit(), because it
  2106. X         * is complicated.
  2107. X         * Other characters are done below to avoid problems with things like
  2108. X         * CTRL-V 048 (for edit() this would be R CTRL-V 0 ESC).
  2109. X         */
  2110. X        if (nchar == '\r' || nchar == '\n' || nchar == '\t')
  2111. X        {
  2112. X            prep_redo(Prenum1, 'r', nchar, NUL);
  2113. X            stuffnumReadbuff(Prenum1);
  2114. X            stuffcharReadbuff('R');
  2115. X            stuffcharReadbuff(nchar);
  2116. X            stuffcharReadbuff(ESC);
  2117. X            break;
  2118. X        }
  2119. X
  2120. X        if (nchar == Ctrl('V'))                /* get another character */
  2121. X        {
  2122. X            c = Ctrl('V');
  2123. X            nchar = get_literal(&type);
  2124. X            if (type)                        /* typeahead */
  2125. X                stuffcharReadbuff(type);
  2126. X        }
  2127. X        else
  2128. X            c = NUL;
  2129. X        prep_redo(Prenum1, 'r', c, nchar);
  2130. X        if (!u_save_cursor())                /* save line for undo */
  2131. X            break;
  2132. X            /*
  2133. X             * Get ptr again, because u_save will have released the line.
  2134. X             * At the same time we let know that the line will be changed.
  2135. X             */
  2136. X        ptr = ml_get_buf(curbuf, curwin->w_cursor.lnum, TRUE) + curwin->w_cursor.col;
  2137. X        curwin->w_cursor.col += Prenum1 - 1;
  2138. X        while (Prenum1--)                    /* replace the characters */
  2139. X            *ptr++ = nchar;
  2140. X        curwin->w_set_curswant = TRUE;
  2141. X        CHANGED;
  2142. X        updateline();
  2143. X        modified = TRUE;
  2144. X        break;
  2145. X
  2146. X      case 'J':
  2147. X        if (VIsual.lnum)        /* join the visual lines */
  2148. X        {
  2149. X            if (curwin->w_cursor.lnum > VIsual.lnum)
  2150. X            {
  2151. X                Prenum = curwin->w_cursor.lnum - VIsual.lnum + 1;
  2152. X                curwin->w_cursor.lnum = VIsual.lnum;
  2153. X            }
  2154. X            else
  2155. X                Prenum = VIsual.lnum - curwin->w_cursor.lnum + 1;
  2156. X            VIsual.lnum = 0;
  2157. X        }
  2158. X        CHECKCLEAROP;
  2159. X        if (Prenum <= 1)
  2160. X            Prenum = 2;             /* default for join is two lines! */
  2161. X        if (curwin->w_cursor.lnum + Prenum - 1 > curbuf->b_ml.ml_line_count)    /* beyond last line */
  2162. X        {
  2163. X            CLEAROPBEEP;
  2164. X            break;
  2165. X        }
  2166. X
  2167. X        prep_redo(Prenum, 'J', NUL, NUL);
  2168. X        dodojoin(Prenum, TRUE, TRUE);
  2169. X        modified = TRUE;
  2170. X        break;
  2171. X
  2172. X      case 'P':
  2173. X        dir = BACKWARD;
  2174. X        /* FALLTHROUGH */
  2175. X
  2176. X      case 'p':
  2177. X        CHECKCLEAROPQ;
  2178. X        prep_redo(Prenum, c, NUL, NUL);
  2179. X        doput(dir, Prenum1, FALSE);
  2180. X        modified = TRUE;
  2181. X        break;
  2182. X
  2183. X      case Ctrl('A'):            /* add to number */
  2184. X      case Ctrl('X'):            /* subtract from number */
  2185. X        CHECKCLEAROPQ;
  2186. X        if (doaddsub((int)c, Prenum1) == OK)
  2187. X            prep_redo(Prenum1, c, NUL, NUL);
  2188. X        modified = TRUE;
  2189. X        break;
  2190. X
  2191. X/*
  2192. X * 6: Inserts
  2193. X */
  2194. X      case 'A':
  2195. X        curwin->w_set_curswant = TRUE;
  2196. X        while (oneright() == OK)
  2197. X                ;
  2198. X        /* FALLTHROUGH */
  2199. X
  2200. X      case 'a':
  2201. X        CHECKCLEAROPQ;
  2202. X        /* Works just like an 'i'nsert on the next character. */
  2203. X        if (u_save_cursor())
  2204. X        {
  2205. X            if (!lineempty(curwin->w_cursor.lnum))
  2206. X                inc_cursor();
  2207. X            startinsert(c, FALSE, Prenum1);
  2208. X            modified = TRUE;
  2209. X            command_busy = TRUE;
  2210. X        }
  2211. X        break;
  2212. X
  2213. X      case 'I':
  2214. X        beginline(TRUE);
  2215. X        /* FALLTHROUGH */
  2216. X
  2217. X      case 'i':
  2218. X        CHECKCLEAROPQ;
  2219. X        if (u_save_cursor())
  2220. X        {
  2221. X            startinsert(c, FALSE, Prenum1);
  2222. X            modified = TRUE;
  2223. X            command_busy = TRUE;
  2224. X        }
  2225. X        break;
  2226. X
  2227. X      case 'o':
  2228. X          if (VIsual.lnum)    /* switch start and end of visual */
  2229. X        {
  2230. X            Prenum = VIsual.lnum;
  2231. X            VIsual.lnum = curwin->w_cursor.lnum;
  2232. X            curwin->w_cursor.lnum = Prenum;
  2233. X            if (VIsual.col != VISUALLINE)
  2234. X            {
  2235. X                n = VIsual.col;
  2236. X                VIsual.col = curwin->w_cursor.col;
  2237. X                curwin->w_cursor.col = (int)n;
  2238. X                curwin->w_set_curswant = TRUE;
  2239. X            }
  2240. X            break;
  2241. X        }
  2242. X        CHECKCLEAROP;
  2243. X        if (u_save(curwin->w_cursor.lnum, (linenr_t)(curwin->w_cursor.lnum + 1)) &&
  2244. X                            Opencmd(FORWARD, TRUE, TRUE))
  2245. X        {
  2246. X            startinsert('o', TRUE, Prenum1);
  2247. X            modified = TRUE;
  2248. X            command_busy = TRUE;
  2249. X        }
  2250. X        break;
  2251. X
  2252. X      case 'O':
  2253. X        CHECKCLEAROPQ;
  2254. X        if (u_save((linenr_t)(curwin->w_cursor.lnum - 1), curwin->w_cursor.lnum) && Opencmd(BACKWARD, TRUE, TRUE))
  2255. X        {
  2256. X            startinsert('O', TRUE, Prenum1);
  2257. X            modified = TRUE;
  2258. X            command_busy = TRUE;
  2259. X        }
  2260. X        break;
  2261. X
  2262. X      case 'R':
  2263. X        if (VIsual.lnum)
  2264. X        {
  2265. X            c = 'c';
  2266. X            VIsual.col = VISUALLINE;
  2267. X            goto dooperator;
  2268. X        }
  2269. X        CHECKCLEAROPQ;
  2270. X        if (u_save_cursor())
  2271. X        {
  2272. X            startinsert('R', FALSE, Prenum1);
  2273. X            modified = TRUE;
  2274. X            command_busy = TRUE;
  2275. X        }
  2276. X        break;
  2277. X
  2278. X/*
  2279. X * 7: Operators
  2280. X */
  2281. X      case '~':         /* swap case */
  2282. X      /*
  2283. X       * if tilde is not an operator and Visual is off: swap case
  2284. X       * of a single character
  2285. X       */
  2286. X        if (!p_to && !VIsual.lnum)
  2287. X        {
  2288. X            CHECKCLEAROPQ;
  2289. X            if (lineempty(curwin->w_cursor.lnum))
  2290. X            {
  2291. X                CLEAROPBEEP;
  2292. X                break;
  2293. X            }
  2294. X            prep_redo(Prenum, '~', NUL, NUL);
  2295. X
  2296. X            if (!u_save_cursor())
  2297. X                break;
  2298. X
  2299. X            for (; Prenum1 > 0; --Prenum1)
  2300. X            {
  2301. X                if (gchar_cursor() == NUL)
  2302. X                    break;
  2303. X                swapchar(&curwin->w_cursor);
  2304. X                inc_cursor();
  2305. X            }
  2306. X
  2307. X            curwin->w_set_curswant = TRUE;
  2308. X            CHANGED;
  2309. X            updateline();
  2310. X            modified = TRUE;
  2311. X            break;
  2312. X        }
  2313. X        /*FALLTHROUGH*/
  2314. X
  2315. X      case 'd':
  2316. X      case 'c':
  2317. X      case 'y':
  2318. X      case '>':
  2319. X      case '<':
  2320. X      case '!':
  2321. X      case '=':
  2322. X      case 'Q':
  2323. Xdooperator:
  2324. X        n = STRCHR(opchars, c) - opchars + 1;
  2325. X        if (n == operator)        /* double operator works on lines */
  2326. X            goto lineop;
  2327. X        CHECKCLEAROP;
  2328. X        if (Prenum != 0)
  2329. X            opnum = Prenum;
  2330. X        curbuf->b_startop = curwin->w_cursor;
  2331. X        operator = (int)n;
  2332. X        break;
  2333. X
  2334. X/*
  2335. X * 8: Abbreviations
  2336. X */
  2337. X
  2338. X     /* when Visual the next commands are operators */
  2339. X      case 'S':
  2340. X      case 'Y':
  2341. X      case 'D':
  2342. X      case 'C':
  2343. X      case 'x':
  2344. X      case 'X':
  2345. X      case 's':
  2346. X          if (VIsual.lnum)
  2347. X        {
  2348. X            static char_u trans[] = "ScYyDdCcxdXdsc";
  2349. X
  2350. X            if (isupper(c) && !Visual_block)        /* uppercase means linewise */
  2351. X                VIsual.col = VISUALLINE;
  2352. X            c = *(STRCHR(trans, c) + 1);
  2353. X            goto dooperator;
  2354. X        }
  2355. X
  2356. X      case '&':
  2357. X        CHECKCLEAROPQ;
  2358. X        if (Prenum)
  2359. X            stuffnumReadbuff(Prenum);
  2360. X
  2361. X        if (c == 'Y' && p_ye)
  2362. X            c = 'Z';
  2363. X        {
  2364. X                static char_u *(ar[9]) = {(char_u *)"dl", (char_u *)"dh", (char_u *)"d$", (char_u *)"c$", (char_u *)"cl", (char_u *)"cc", (char_u *)"yy", (char_u *)"y$", (char_u *)":s\r"};
  2365. X                static char_u *str = (char_u *)"xXDCsSYZ&";
  2366. X
  2367. X                stuffReadbuff(ar[(int)(STRCHR(str, c) - str)]);
  2368. X        }
  2369. X        break;
  2370. X
  2371. X/*
  2372. X * 9: Marks
  2373. X */
  2374. X
  2375. X      case 'm':
  2376. X        CHECKCLEAROP;
  2377. X        if (setmark(nchar) == FAIL)
  2378. X            CLEAROPBEEP;
  2379. X        break;
  2380. X
  2381. X      case '\'':
  2382. X        flag = TRUE;
  2383. X        /* FALLTHROUGH */
  2384. X
  2385. X      case '`':
  2386. X        pos = getmark(nchar, (operator == NOP));
  2387. X        if (pos == (FPOS *)-1)    /* jumped to other file */
  2388. X        {
  2389. X            if (flag)
  2390. X                beginline(TRUE);
  2391. X            break;
  2392. X        }
  2393. X
  2394. X        if (pos != NULL)
  2395. X            setpcmark();
  2396. X
  2397. Xcursormark:
  2398. X        if (pos == NULL || pos->lnum == 0)
  2399. X            CLEAROPBEEP;
  2400. X        else
  2401. X        {
  2402. X            curwin->w_cursor = *pos;
  2403. X            if (flag)
  2404. X                beginline(TRUE);
  2405. X        }
  2406. X        mtype = flag ? MLINE : MCHAR;
  2407. X        mincl = FALSE;        /* ignored if not MCHAR */
  2408. X        curwin->w_set_curswant = TRUE;
  2409. X        break;
  2410. X
  2411. X    case Ctrl('O'):            /* goto older pcmark */
  2412. X        Prenum1 = -Prenum1;
  2413. X        /* FALLTHROUGH */
  2414. X
  2415. X    case Ctrl('I'):            /* goto newer pcmark */
  2416. X        CHECKCLEAROPQ;
  2417. X        pos = movemark((int)Prenum1);
  2418. X        if (pos == (FPOS *)-1)    /* jump to other file */
  2419. X        {
  2420. X            curwin->w_set_curswant = TRUE;
  2421. X            break;
  2422. X        }
  2423. X        goto cursormark;
  2424. X
  2425. X/*
  2426. X * 10. Buffer setting
  2427. X */
  2428. X      case '"':
  2429. X        CHECKCLEAROP;
  2430. X        if (nchar != NUL && is_yank_buffer(nchar, FALSE))
  2431. X        {
  2432. X            yankbuffer = nchar;
  2433. X            opnum = Prenum;        /* remember count before '"' */
  2434. X        }
  2435. X        else
  2436. X            CLEAROPBEEP;
  2437. X        break;
  2438. X
  2439. X/*
  2440. X * 11. Visual
  2441. X */
  2442. X       case 'v':
  2443. X      case 'V':
  2444. X      case Ctrl('V'):
  2445. X        CHECKCLEAROP;
  2446. X        Visual_block = FALSE;
  2447. X
  2448. X            /* stop Visual */
  2449. X        if (VIsual.lnum)
  2450. X        {
  2451. X            VIsual.lnum = 0;
  2452. X            updateScreen(NOT_VALID);        /* delete the inversion */
  2453. X        }
  2454. X            /* start Visual */
  2455. X        else
  2456. X        {
  2457. X            if (!didwarn && set_highlight('v') == FAIL)/* cannot highlight */
  2458. X            {
  2459. X                EMSG("Warning: terminal cannot highlight");
  2460. X                didwarn = TRUE;
  2461. X            }
  2462. X            if (Prenum)                        /* use previously selected part */
  2463. X            {
  2464. X                if (!resel_Visual_type)        /* there is none */
  2465. X                {
  2466. X                    beep();
  2467. X                    break;
  2468. X                }
  2469. X                VIsual = curwin->w_cursor;
  2470. X                if (resel_Visual_nlines > 1)
  2471. X                    curwin->w_cursor.lnum += resel_Visual_nlines * Prenum - 1;
  2472. X                switch (resel_Visual_type)
  2473. X                {
  2474. X                case 'V':    VIsual.col = VISUALLINE;
  2475. X                            break;
  2476. X
  2477. X                case Ctrl('V'):
  2478. X                            Visual_block = TRUE;
  2479. X                            break;
  2480. X
  2481. X                case 'v':        
  2482. X                            if (resel_Visual_nlines <= 1)
  2483. X                                curwin->w_cursor.col += resel_Visual_col * Prenum - 1;
  2484. X                            else
  2485. X                                curwin->w_cursor.col = resel_Visual_col;
  2486. X                            break;
  2487. X                }
  2488. X                if (resel_Visual_col == MAXCOL)
  2489. X                {
  2490. X                    curwin->w_curswant = MAXCOL;
  2491. X                    coladvance(MAXCOL);
  2492. X                }
  2493. X                else if (Visual_block)
  2494. X                    coladvance((colnr_t)(curwin->w_virtcol + resel_Visual_col * Prenum - 1));
  2495. X                curs_columns(TRUE);            /* recompute w_virtcol */
  2496. X                updateScreen(NOT_VALID);    /* show the inversion */
  2497. X            }
  2498. X            else
  2499. X            {
  2500. X                VIsual = curwin->w_cursor;
  2501. X                if (c == 'V')                /* linewise */
  2502. X                    VIsual.col = VISUALLINE;
  2503. X                else if (c == Ctrl('V'))    /* blockwise */
  2504. X                    Visual_block = TRUE;
  2505. X                updateline();                /* start the inversion */
  2506. X            }
  2507. X        }
  2508. X        break;
  2509. X
  2510. X/*
  2511. X * 12. Suspend
  2512. X */
  2513. X
  2514. X     case Ctrl('Z'):
  2515. X        CLEAROP;
  2516. X        VIsual.lnum = 0;                    /* stop Visual */
  2517. X        stuffReadbuff((char_u *)":st\r");    /* with autowrite */
  2518. X        break;
  2519. X
  2520. X/*
  2521. X * 13. Window commands
  2522. X */
  2523. X
  2524. X     case Ctrl('W'):
  2525. X        CHECKCLEAROP;
  2526. X        do_window(nchar, Prenum);            /* everything is in window.c */
  2527. X        break;
  2528. X
  2529. X/*
  2530. X *   14. extended commands (starting with 'g')
  2531. X */
  2532. X     case 'g':
  2533. X        switch (nchar)
  2534. X        {
  2535. X                        /*
  2536. X                         * "gf": goto file, edit file under cursor
  2537. X                         * "]f" and "[f": can also be used.
  2538. X                         */
  2539. X            case 'f':
  2540. Xgotofile:
  2541. X                        ptr = file_name_at_cursor();
  2542. X                            /* do autowrite if necessary */
  2543. X                        if (curbuf->b_changed && curbuf->b_nwindows <= 1 && !p_hid)
  2544. X                            autowrite(curbuf);
  2545. X                        if (ptr != NULL)
  2546. X                        {
  2547. X                            setpcmark();
  2548. X                            stuffReadbuff((char_u *) ":e ");
  2549. X                            stuffReadbuff(ptr);
  2550. X                            stuffReadbuff((char_u *) "\n");
  2551. X                            free(ptr);
  2552. X                        }
  2553. X                        else
  2554. X                            CLEAROPBEEP;
  2555. X                        break;
  2556. X
  2557. X                        /*
  2558. X                         * "gs": goto sleep
  2559. X                         */
  2560. X            case 's':    while (Prenum1-- && !got_int)
  2561. X                        {
  2562. X                            sleep(1);
  2563. X                            breakcheck();
  2564. X                        }
  2565. X                        break;
  2566. X
  2567. X            default:    CLEAROPBEEP;
  2568. X                        break;
  2569. X        }
  2570. X        break;
  2571. X
  2572. X/*
  2573. X * The end
  2574. X */
  2575. X      case ESC:
  2576. X        if (VIsual.lnum)
  2577. X        {
  2578. X            VIsual.lnum = 0;            /* stop Visual */
  2579. X            updateScreen(NOT_VALID);
  2580. X            CLEAROP;                    /* don't beep */
  2581. X            break;
  2582. X        }
  2583. X        /* Don't drop through and beep if we are canceling a command: */
  2584. X        else if (operator != NOP || opnum || Prenum || yankbuffer)
  2585. X        {
  2586. X            CLEAROP;                    /* don't beep */
  2587. X            break;
  2588. X        }
  2589. X        /* FALLTHROUGH */
  2590. X
  2591. X      default:                    /* not a known command */
  2592. X        CLEAROPBEEP;
  2593. X        break;
  2594. X
  2595. X    }    /* end of switch on command character */
  2596. X
  2597. X/*
  2598. X * if we didn't start or finish an operator, reset yankbuffer, unless we
  2599. X * need it later.
  2600. X */
  2601. X    if (!finish_op && !operator && strchr("\"DCYSsXx.", c) == NULL)
  2602. X        yankbuffer = 0;
  2603. X
  2604. X    /*
  2605. X     * If an operation is pending, handle it...
  2606. X     */
  2607. X    if ((VIsual.lnum || finish_op) && operator != NOP)
  2608. X    {
  2609. X        if (operator != YANK && !VIsual.lnum)        /* can't redo yank */
  2610. X        {
  2611. X            prep_redo(Prenum, opchars[operator - 1], c, nchar);
  2612. X            if (c == '/' || c == '?')                /* was a search */
  2613. X            {
  2614. X                AppendToRedobuff(searchbuff);
  2615. X                AppendToRedobuff(NL_STR);
  2616. X            }
  2617. X        }
  2618. X
  2619. X        if (redo_Visual_busy)
  2620. X        {
  2621. X            curbuf->b_startop = curwin->w_cursor;
  2622. X            curwin->w_cursor.lnum += redo_Visual_nlines - 1;
  2623. X            switch (redo_Visual_type)
  2624. X            {
  2625. X            case 'V':    VIsual.col = VISUALLINE;
  2626. X                        break;
  2627. X
  2628. X            case Ctrl('V'):
  2629. X                        Visual_block = TRUE;
  2630. X                        break;
  2631. X
  2632. X            case 'v':        
  2633. X                        if (redo_Visual_nlines <= 1)
  2634. X                            curwin->w_cursor.col += redo_Visual_col - 1;
  2635. X                        else
  2636. X                            curwin->w_cursor.col = redo_Visual_col;
  2637. X                        break;
  2638. X            }
  2639. X            if (redo_Visual_col == MAXCOL)
  2640. X            {
  2641. X                curwin->w_curswant = MAXCOL;
  2642. X                coladvance(MAXCOL);
  2643. X            }
  2644. X            Prenum = redo_Visual_Prenum;
  2645. X            if (Prenum == 0)
  2646. X                Prenum1 = 1L;
  2647. X            else
  2648. X                Prenum1 = Prenum;
  2649. X        }
  2650. X        else if (VIsual.lnum)
  2651. X            curbuf->b_startop = VIsual;
  2652. X
  2653. X        if (lt(curbuf->b_startop, curwin->w_cursor))
  2654. X        {
  2655. X            curbuf->b_endop = curwin->w_cursor;
  2656. X            curwin->w_cursor = curbuf->b_startop;
  2657. X        }
  2658. X        else
  2659. X        {
  2660. X            curbuf->b_endop = curbuf->b_startop;
  2661. X            curbuf->b_startop = curwin->w_cursor;
  2662. X        }
  2663. X        nlines = curbuf->b_endop.lnum - curbuf->b_startop.lnum + 1;
  2664. X
  2665. X        if (VIsual.lnum || redo_Visual_busy)
  2666. X        {
  2667. X            if (Visual_block)                /* block mode */
  2668. X            {
  2669. X                startvcol = getvcol(curwin, &(curbuf->b_startop), 2);
  2670. X                n = getvcol(curwin, &(curbuf->b_endop), 2);
  2671. X                if (n < startvcol)
  2672. X                    startvcol = (colnr_t)n;
  2673. X
  2674. X            /* if '$' was used, get endvcol from longest line */
  2675. X                if (curwin->w_curswant == MAXCOL)
  2676. X                {
  2677. X                    curwin->w_cursor.col = MAXCOL;
  2678. X                    endvcol = 0;
  2679. X                    for (curwin->w_cursor.lnum = curbuf->b_startop.lnum; curwin->w_cursor.lnum <= curbuf->b_endop.lnum; ++curwin->w_cursor.lnum)
  2680. X                        if ((n = getvcol(curwin, &curwin->w_cursor, 3)) > endvcol)
  2681. X                            endvcol = (colnr_t)n;
  2682. X                    curwin->w_cursor = curbuf->b_startop;
  2683. X                }
  2684. X                else if (redo_Visual_busy)
  2685. X                    endvcol = startvcol + redo_Visual_col - 1;
  2686. X                else
  2687. X                {
  2688. X                    endvcol = getvcol(curwin, &(curbuf->b_startop), 3);
  2689. X                    n = getvcol(curwin, &(curbuf->b_endop), 3);
  2690. X                    if (n > endvcol)
  2691. X                        endvcol = (colnr_t)n;
  2692. X                }
  2693. X                coladvance(startvcol);
  2694. X            }
  2695. X
  2696. X    /*
  2697. X     * prepare to reselect and redo Visual: this is based on the size
  2698. X     * of the Visual text
  2699. X     */
  2700. X            if (Visual_block)
  2701. X                resel_Visual_type = Ctrl('V');
  2702. X            else if (VIsual.col == VISUALLINE)
  2703. X                resel_Visual_type = 'V';
  2704. X            else
  2705. X                resel_Visual_type = 'v';
  2706. X            if (curwin->w_curswant == MAXCOL)
  2707. X                resel_Visual_col = MAXCOL;
  2708. X            else if (Visual_block)
  2709. X                resel_Visual_col = endvcol - startvcol + 1;
  2710. X            else if (nlines > 1)
  2711. X                resel_Visual_col = curbuf->b_endop.col;
  2712. X            else
  2713. X                resel_Visual_col = curbuf->b_endop.col - curbuf->b_startop.col + 1;
  2714. X            resel_Visual_nlines = nlines;
  2715. X            if (operator != YANK && operator != COLON)    /* can't redo yank and : */
  2716. X            {
  2717. X                prep_redo(0L, 'v', opchars[operator - 1], NUL);
  2718. X                redo_Visual_type = resel_Visual_type;
  2719. X                redo_Visual_col = resel_Visual_col;
  2720. X                redo_Visual_nlines = resel_Visual_nlines;
  2721. X                redo_Visual_Prenum = Prenum;
  2722. X            }
  2723. X
  2724. X            /*
  2725. X             * Mincl defaults to TRUE.
  2726. X             * If endop is on a NUL (empty line) mincl becomes FALSE
  2727. X             * This makes "d}P" and "v}dP" work the same.
  2728. X             */
  2729. X            mincl = TRUE;
  2730. X            if (VIsual.col == VISUALLINE)
  2731. X                mtype = MLINE;
  2732. X            else
  2733. X            {
  2734. X                mtype = MCHAR;
  2735. X                if (*ml_get_pos(&(curbuf->b_endop)) == NUL)
  2736. X                    mincl = FALSE;
  2737. X            }
  2738. X
  2739. X            redo_Visual_busy = FALSE;
  2740. X            /*
  2741. X             * Switch Visual off now, so screen updating does
  2742. X             * not show inverted text when the screen is redrawn.
  2743. X             * With YANK and sometimes with COLON and FILTER there is no screen
  2744. X             * redraw, so it is done here to remove the inverted part.
  2745. X             */
  2746. X            VIsual.lnum = 0;
  2747. X            if (operator == YANK || operator == COLON || operator == FILTER)
  2748. X                updateScreen(NOT_VALID);
  2749. X        }
  2750. X        else if (operator == LSHIFT || operator == RSHIFT)
  2751. X            Prenum1 = 1L;        /* if not visual mode: shift one indent */
  2752. X
  2753. X        curwin->w_set_curswant = 1;
  2754. X
  2755. X            /* no_op is set when start and end are the same */
  2756. X        no_op = (mtype == MCHAR && !mincl && equal(curbuf->b_startop, curbuf->b_endop));
  2757. X
  2758. X    /*
  2759. X     * If the end of an operator is in column one while mtype is MCHAR and mincl
  2760. X     * is FALSE, we put endop after the last character in the previous line.
  2761. X     * If startop is on or before the first non-blank in the line, the operator
  2762. X     * becomes linewise (strange, but that's the way vi does it).
  2763. X     */
  2764. X        if (mtype == MCHAR && mincl == FALSE && curbuf->b_endop.col == 0 && nlines > 1)
  2765. X        {
  2766. X            --nlines;
  2767. X            --curbuf->b_endop.lnum;
  2768. X            if (inindent())
  2769. X                mtype = MLINE;
  2770. X            else
  2771. X            {
  2772. X                curbuf->b_endop.col = STRLEN(ml_get(curbuf->b_endop.lnum));
  2773. X                if (curbuf->b_endop.col)
  2774. X                {
  2775. X                    --curbuf->b_endop.col;
  2776. X                    mincl = TRUE;
  2777. X                }
  2778. X            }
  2779. X        }
  2780. X        switch (operator)
  2781. X        {
  2782. X          case LSHIFT:
  2783. X          case RSHIFT:
  2784. X            doshift(operator, TRUE, (int)Prenum1);
  2785. X            modified = TRUE;
  2786. X            break;
  2787. X
  2788. X          case DELETE:
  2789. X            if (!no_op)
  2790. X            {
  2791. X                dodelete();
  2792. X                modified = TRUE;
  2793. X            }
  2794. X            break;
  2795. X
  2796. X          case YANK:
  2797. X            if (!no_op)
  2798. X                (void)doyank(FALSE);
  2799. X            break;
  2800. X
  2801. X          case CHANGE:
  2802. X            dochange();
  2803. X            modified = TRUE;
  2804. X            command_busy = TRUE;
  2805. X            break;
  2806. X
  2807. X          case FILTER:
  2808. X            bangredo = TRUE;            /* dobang() will put cmd in redo buffer */
  2809. X
  2810. X          case INDENT:
  2811. X          case COLON:
  2812. Xdofilter:
  2813. X            sprintf((char *)IObuff, ":%ld,%ld", (long)curbuf->b_startop.lnum, (long)curbuf->b_endop.lnum);
  2814. X            stuffReadbuff(IObuff);
  2815. X            if (operator != COLON)
  2816. X                stuffReadbuff((char_u *)"!");
  2817. X            if (operator == INDENT)
  2818. X            {
  2819. X                stuffReadbuff(p_ep);
  2820. X                stuffReadbuff((char_u *)"\n");
  2821. X            }
  2822. X            else if (operator == FORMAT)
  2823. X            {
  2824. X                stuffReadbuff(p_fp);
  2825. X                stuffReadbuff((char_u *)"\n");
  2826. X            }
  2827. X                /*    docmdline() does the rest */
  2828. X            break;
  2829. X
  2830. X          case TILDE:
  2831. X          case UPPER:
  2832. X          case LOWER:
  2833. X            if (!no_op)
  2834. X            {
  2835. X                dotilde();
  2836. X                modified = TRUE;
  2837. X            }
  2838. X            break;
  2839. X
  2840. X          case FORMAT:
  2841. X            if (*p_fp != NUL)
  2842. X                goto dofilter;        /* use external command */
  2843. X            doformat();                /* use internal function */
  2844. X            modified = TRUE;
  2845. X            break;
  2846. X
  2847. X          default:
  2848. X            CLEAROPBEEP;
  2849. X        }
  2850. X        operator = NOP;
  2851. X        Visual_block = FALSE;
  2852. X        yankbuffer = 0;
  2853. X    }
  2854. X
  2855. Xnormal_end:
  2856. X    premsg(-1, NUL);
  2857. X
  2858. X    if (restart_edit && operator == NOP && VIsual.lnum == 0 && !command_busy && stuff_empty() && yankbuffer == 0)
  2859. X    {
  2860. X        startinsert(restart_edit, FALSE, 1L);
  2861. X        modified = TRUE;
  2862. X    }
  2863. X
  2864. X    checkpcmark();            /* check if we moved since setting pcmark */
  2865. X
  2866. X/*
  2867. X * TEMPORARY: update the other windows for the current buffer if modified
  2868. X */
  2869. X    if (modified)
  2870. X    {
  2871. X        WIN        *wp;
  2872. X
  2873. X        for (wp = firstwin; wp; wp = wp->w_next)
  2874. X            if (wp != curwin && wp->w_buffer == curbuf)
  2875. X            {
  2876. X                cursor_off();
  2877. X                wp->w_redr_type = NOT_VALID;
  2878. X                win_update(wp);
  2879. X            }
  2880. X    }
  2881. X}
  2882. X
  2883. X    static void
  2884. Xprep_redo(num, cmd, c, nchar)
  2885. X    long     num;
  2886. X    int        cmd;
  2887. X    int        c;
  2888. X    int        nchar;
  2889. X{
  2890. X    ResetRedobuff();
  2891. X    if (yankbuffer != 0)    /* yank from specified buffer */
  2892. X    {
  2893. X        AppendCharToRedobuff('\"');
  2894. X        AppendCharToRedobuff(yankbuffer);
  2895. X    }
  2896. X    if (num)
  2897. X        AppendNumberToRedobuff(num);
  2898. X    AppendCharToRedobuff(cmd);
  2899. X    if (c != NUL)
  2900. X        AppendCharToRedobuff(c);
  2901. X    if (nchar != NUL)
  2902. X        AppendCharToRedobuff(nchar);
  2903. X}
  2904. X
  2905. X/*
  2906. X * check for operator active
  2907. X *
  2908. X * return TRUE if operator was active
  2909. X */
  2910. X    static int
  2911. Xcheckclearop()
  2912. X{
  2913. X    if (operator == NOP)
  2914. X        return (FALSE);
  2915. X    clearopbeep();
  2916. X    return (TRUE);
  2917. X}
  2918. X
  2919. X/*
  2920. X * check for operator or Visual active
  2921. X *
  2922. X * return TRUE if operator was active
  2923. X */
  2924. X    static int
  2925. Xcheckclearopq()
  2926. X{
  2927. X    if (operator == NOP && VIsual.lnum == 0)
  2928. X        return (FALSE);
  2929. X    clearopbeep();
  2930. X    return (TRUE);
  2931. X}
  2932. X
  2933. X    static void
  2934. Xclearopbeep()
  2935. X{
  2936. X    CLEAROP;
  2937. X    beep();
  2938. X}
  2939. X
  2940. X/*
  2941. X * display, on the last line of the window, the characters typed before
  2942. X * the last command character, plus 'c1' and 'c2'
  2943. X */
  2944. X    static void
  2945. Xpremsg(c1, c2)
  2946. X    int c1, c2;
  2947. X{
  2948. X    char_u    buf[40];
  2949. X    char_u    *p;
  2950. X
  2951. X    if (!p_sc || !(KeyTyped || c1 == -1 || c1 == ' '))
  2952. X        return;
  2953. X
  2954. X    cursor_off();
  2955. X    msg_pos((int)Rows - 1, sc_col);
  2956. X    if (c1 == -1)
  2957. X        msg_outstr((char_u *)"          ");    /* look in comp_col() for the number of spaces */
  2958. X    else
  2959. X    {
  2960. X        p = buf;
  2961. X        if (opnum)
  2962. X        {
  2963. X            sprintf((char *)p, "%ld", (long)opnum);
  2964. X            p = p + STRLEN(buf);
  2965. X        }
  2966. X        if (yankbuffer)
  2967. X        {
  2968. X            *p++ = '"';
  2969. X            *p++ = yankbuffer;
  2970. X        }
  2971. X        if (c1 == Ctrl('W'))        /* ^W is in between counts */
  2972. X        {
  2973. X            *p++ = '^';
  2974. X            *p++ = 'W';
  2975. X            c1 = NUL;
  2976. X        }
  2977. X        else if (operator == 'z')
  2978. X            *p++ = 'z';
  2979. X        else if (operator)
  2980. X            *p++ = opchars[operator - 1];
  2981. X        if (Prenum)
  2982. X        {
  2983. X            sprintf((char *)p, "%ld", (long)Prenum);
  2984. X            p = p + STRLEN(p);
  2985. X        }
  2986. X        *p = NUL;
  2987. X        if (c1)
  2988. X            STRCPY(p, transchar(c1));
  2989. X        if (c2)
  2990. X            STRCAT(p, transchar(c2));
  2991. X        buf[10] = NUL;            /* truncate at maximal length */
  2992. X        msg_outstr(buf);
  2993. X    }
  2994. X    setcursor();
  2995. X    /* cursor_on(); */
  2996. X}
  2997. END_OF_FILE
  2998.   if test 41440 -ne `wc -c <'vim/src/normal.c'`; then
  2999.     echo shar: \"'vim/src/normal.c'\" unpacked with wrong size!
  3000.   fi
  3001.   # end of 'vim/src/normal.c'
  3002. fi
  3003. echo shar: End of archive 10 \(of 26\).
  3004. cp /dev/null ark10isdone
  3005. MISSING=""
  3006. for I in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 ; do
  3007.     if test ! -f ark${I}isdone ; then
  3008.     MISSING="${MISSING} ${I}"
  3009.     fi
  3010. done
  3011. if test "${MISSING}" = "" ; then
  3012.     echo You have unpacked all 26 archives.
  3013.     rm -f ark[1-9]isdone ark[1-9][0-9]isdone
  3014. else
  3015.     echo You still must unpack the following archives:
  3016.     echo "        " ${MISSING}
  3017. fi
  3018. exit 0
  3019. exit 0 # Just in case...
  3020.