home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / altsrcs / 2 / 2196 < prev    next >
Encoding:
Internet Message Format  |  1990-12-28  |  66.8 KB
  1. From: kirkenda@eecs.cs.pdx.edu (Steve Kirkendall)
  2. Newsgroups: alt.sources
  3. Subject: Elvis 1.4, part 5 of 8
  4. Message-ID: <829@pdxgate.UUCP>
  5. Date: 3 Dec 90 21:32:42 GMT
  6.  
  7. # --------------------------- cut here ----------------------------
  8. # This is a shar archive.  To unpack it, save it to a file, and delete
  9. # anything above the "cut here" line.  Then run sh on the file.
  10. #
  11. # -rw-r--r--  1 kirkenda     8819 Dec  2 17:57 curses.h
  12. # -rw-r--r--  1 kirkenda    13222 Dec  2 17:57 cut.c
  13. # -rw-r--r--  1 kirkenda    15130 Dec  2 17:57 ex.c
  14. # -rw-r--r--  1 kirkenda    16368 Dec  2 17:57 input.c
  15. # -rw-r--r--  1 kirkenda     7778 Dec  2 17:57 main.c
  16. # -rw-r--r--  1 kirkenda     2166 Dec  2 17:57 misc.c
  17. #
  18.  
  19. if test -f curses.h -a "$1" != -f
  20. then
  21. echo Will not overwrite curses.h
  22. else
  23. echo Extracting curses.h
  24. sed 's/^X//' >curses.h <<\eof
  25. X/* curses.h */
  26. X
  27. X/* Author:
  28. X *    Steve Kirkendall
  29. X *    14407 SW Teal Blvd. #C
  30. X *    Beaverton, OR 97005
  31. X *    kirkenda@cs.pdx.edu
  32. X */
  33. X
  34. X
  35. X/* This is the header file for a small, fast, fake curses package */
  36. X
  37. X/* termcap stuff */
  38. Xextern char    *tgoto();
  39. Xextern char    *tgetstr();
  40. Xextern void    tputs();
  41. X
  42. X#if MSDOS
  43. X/* BIOS interface used instead of termcap for MS-DOS */
  44. Xextern int    vmode;
  45. Xextern void    v_up();
  46. Xextern void    v_cb();
  47. Xextern void    v_cs();
  48. Xextern void    v_ce();
  49. Xextern void    v_cl();
  50. Xextern void    v_cd();
  51. Xextern void    v_al();
  52. Xextern void    v_dl();
  53. Xextern void    v_sr();
  54. Xextern void    v_move();
  55. X#endif
  56. X
  57. X/* faddch() is a function.  a pointer to it is passed to tputs() */
  58. Xextern int    faddch();
  59. X
  60. X/* data types */
  61. X#define WINDOW    char
  62. X
  63. X/* CONSTANTS & SYMBOLS */
  64. X#define TRUE        1
  65. X#define FALSE        0
  66. X#define A_NORMAL    0
  67. X#define A_STANDOUT    1
  68. X#define A_BOLD        2
  69. X#define A_UNDERLINE    3
  70. X#define A_ALTCHARSET    4
  71. X#if MSDOS
  72. X#define KBSIZ        (10*1024)
  73. X#else
  74. X#define KBSIZ        (6*1024)
  75. X#endif
  76. X
  77. X/* extern variables, defined in curses.c */
  78. Xextern short    ospeed;        /* tty speed, eg B2400 */
  79. X#if OSK
  80. Xextern char PC_;    /* Pad char */
  81. Xextern char    *BC;    /* Backspace char string */
  82. X#else
  83. Xextern char    PC;        /* Pad char */
  84. X#endif
  85. Xextern WINDOW    *stdscr;    /* pointer into kbuf[] */
  86. Xextern WINDOW    kbuf[KBSIZ];    /* a very large output buffer */
  87. Xextern int    LINES;        /* :li#: number of rows */
  88. Xextern int    COLS;        /* :co#: number of columns */
  89. Xextern int    AM;        /* :am:  boolean: auto margins? */
  90. Xextern int    PT;        /* :pt:  boolean: physical tabs? */
  91. Xextern char    *VB;        /* :vb=: visible bell */
  92. Xextern char    *UP;        /* :up=: move cursor up */
  93. Xextern char    *SO;        /* :so=: standout start */
  94. Xextern char    *SE;        /* :se=: standout end */
  95. Xextern char    *US;        /* :us=: underline start */
  96. Xextern char    *UE;        /* :ue=: underline end */
  97. Xextern char    *MD;        /* :md=: bold start */
  98. Xextern char    *ME;        /* :me=: bold end */
  99. Xextern char    *AS;        /* :as=: alternate (italic) start */
  100. Xextern char    *AE;        /* :ae=: alternate (italic) end */
  101. Xextern char    *CM;        /* :cm=: cursor movement */
  102. Xextern char    *CE;        /* :ce=: clear to end of line */
  103. Xextern char    *CD;        /* :cd=: clear to end of screen */
  104. Xextern char    *AL;        /* :al=: add a line */
  105. Xextern char    *DL;        /* :dl=: delete a line */
  106. X#if OSK
  107. Xextern char    *SR_;        /* :sr=: scroll reverse */
  108. X#else
  109. Xextern char    *SR;        /* :sr=: scroll reverse */
  110. X#endif
  111. Xextern char    *KS;        /* :ks=: init string for cursor */
  112. Xextern char    *KE;        /* :ke=: restore string for cursor */
  113. Xextern char    *KU;        /* :ku=: sequence sent by up key */
  114. Xextern char    *KD;        /* :kd=: sequence sent by down key */
  115. Xextern char    *KL;        /* :kl=: sequence sent by left key */
  116. Xextern char    *KR;        /* :kr=: sequence sent by right key */
  117. Xextern char    *PU;        /* :PU=: key sequence sent by PgUp key */
  118. Xextern char    *PD;        /* :PD=: key sequence sent by PgDn key */
  119. Xextern char    *HM;        /* :HM=: key sequence sent by Home key */
  120. Xextern char    *EN;        /* :EN=: key sequence sent by End key */
  121. Xextern char    *IM;        /* :im=: insert mode start */
  122. Xextern char    *IC;        /* :ic=: insert following char */
  123. Xextern char    *EI;        /* :ei=: insert mode end */
  124. Xextern char    *DC;        /* :dc=: delete a character */
  125. Xextern char    *TI;        /* :ti=: terminal init */    /* GB */
  126. Xextern char    *TE;        /* :te=: terminal exit */    /* GB */
  127. X#ifndef NO_CURSORSHAPE
  128. Xextern char    *CQ;        /* :cQ=: normal cursor */
  129. Xextern char    *CX;        /* :cX=: cursor used for EX command/entry */
  130. Xextern char    *CV;        /* :cV=: cursor used for VI command mode */
  131. Xextern char    *CI;        /* :cI=: cursor used for VI input mode */
  132. Xextern char    *CR;        /* :cR=: cursor used for VI replace mode */
  133. X#endif
  134. Xextern char    *aend;        /* end an attribute -- either UE or ME */
  135. Xextern char    ERASEKEY;    /* taken from the ioctl structure */
  136. X
  137. X/* Msdos-versions may use bios; others always termcap.
  138. X * Will emit some 'code has no effect' warnings in unix.
  139. X */
  140. X 
  141. X#if MSDOS
  142. Xextern char o_pcbios[1];        /* BAH! */
  143. X#define    CHECKBIOS(x,y)    (*o_pcbios ? (x) : (y))
  144. X#define VOIDBIOS(x,y)    {if (*o_pcbios) {x;} else {y;}}
  145. X#else
  146. X#define    CHECKBIOS(x,y)    (y)
  147. X#define VOIDBIOS(x,y)    {y;}
  148. X#endif
  149. X
  150. X#define    do_VB()        VOIDBIOS(;, tputs(VB, 1, faddch))
  151. X#define    do_UP()        VOIDBIOS(v_up(), tputs(UP, 1, faddch))
  152. X#define    do_SO()        VOIDBIOS((vmode=A_STANDOUT), tputs(SO, 1, faddch))
  153. X#define    do_SE()        VOIDBIOS((vmode=A_NORMAL), tputs(SE, 1, faddch))
  154. X#define    do_US()        VOIDBIOS((vmode=A_UNDERLINE), tputs(US, 1, faddch))
  155. X#define    do_UE()        VOIDBIOS((vmode=A_NORMAL), tputs(UE, 1, faddch))
  156. X#define    do_MD()        VOIDBIOS((vmode=A_BOLD), tputs(MD, 1, faddch))
  157. X#define    do_ME()        VOIDBIOS((vmode=A_NORMAL), tputs(ME, 1, faddch))
  158. X#define    do_AS()        VOIDBIOS((vmode=A_ALTCHARSET), tputs(AS, 1, faddch))
  159. X#define    do_AE()        VOIDBIOS((vmode=A_NORMAL), tputs(AE, 1, faddch))
  160. X#undef    do_CM        /* move */
  161. X#define    do_CE()        VOIDBIOS(v_ce(), tputs(CE, 1, faddch))
  162. X#define    do_CD()        VOIDBIOS(v_cd(), tputs(CD, 1, faddch))
  163. X#define    do_AL()        VOIDBIOS(v_al(), tputs(AL, LINES, faddch))
  164. X#define    do_DL()        VOIDBIOS(v_dl(), tputs(DL, LINES, faddch))
  165. X#if OSK
  166. X#define    do_SR()        VOIDBIOS(v_sr(), tputs(SR_, 1, faddch))
  167. X#else
  168. X#define    do_SR()        VOIDBIOS(v_sr(), tputs(SR, 1, faddch))
  169. X#endif
  170. X#define do_KS()        VOIDBIOS(1, tputs(KS, 1, faddch))
  171. X#define do_KE()        VOIDBIOS(1, tputs(KE, 1, faddch))
  172. X#define    do_IM()        VOIDBIOS(;, tputs(IM, 1, faddch))
  173. X#define    do_IC()        VOIDBIOS(;, tputs(IC, 1, faddch))
  174. X#define    do_EI()        VOIDBIOS(;, tputs(EI, 1, faddch))
  175. X#define    do_DC()        VOIDBIOS(;, tputs(DC, COLS, faddch))
  176. X#define    do_TI()        VOIDBIOS(;, (void)ttywrite(TI, (unsigned)strlen(TI)))
  177. X#define    do_TE()        VOIDBIOS(;, (void)ttywrite(TE, (unsigned)strlen(TE)))
  178. X#ifndef NO_CURSORSHAPE
  179. X# define do_CQ()    VOIDBIOS(v_cs(), tputs(CQ, 1, faddch))
  180. X# define do_CX()    VOIDBIOS(v_cs(), tputs(CX, 1, faddch))
  181. X# define do_CV()    VOIDBIOS(v_cs(), tputs(CV, 1, faddch))
  182. X# define do_CI()    VOIDBIOS(v_cb(), tputs(CI, 1, faddch))
  183. X# define do_CR()    VOIDBIOS(v_cb(), tputs(CR, 1, faddch))
  184. X#endif
  185. X#define    do_aend()    VOIDBIOS((vmode=A_NORMAL), tputs(aend, 1, faddch))
  186. X
  187. X#define    has_AM        CHECKBIOS(1, AM)
  188. X#define    has_PT        CHECKBIOS(0, PT)
  189. X#define    has_VB        CHECKBIOS((char *)0, VB)
  190. X#define    has_UP        CHECKBIOS((char *)1, UP)
  191. X#define    has_SO        CHECKBIOS((char)1, (*SO))
  192. X#define    has_SE        CHECKBIOS((char)1, (*SE))
  193. X#define    has_US        CHECKBIOS((char)1, (*US))
  194. X#define    has_UE        CHECKBIOS((char)1, (*UE))
  195. X#define    has_MD        CHECKBIOS((char)1, (*MD))
  196. X#define    has_ME        CHECKBIOS((char)1, (*ME))
  197. X#define    has_AS        CHECKBIOS((char)1, (*AS))
  198. X#define    has_AE        CHECKBIOS((char)1, (*AE))
  199. X#undef    has_CM        /* cursor move: don't need */
  200. X#define    has_CB        CHECKBIOS(1, 0)
  201. X#define    has_CS        CHECKBIOS(1, 0)
  202. X#define    has_CE        CHECKBIOS((char *)1, CE)
  203. X#define    has_CD        CHECKBIOS((char *)1, CD)
  204. X#define    has_AL        CHECKBIOS((char *)1, AL)
  205. X#define    has_DL        CHECKBIOS((char *)1, DL)
  206. X#if OSK
  207. X#define    has_SR        CHECKBIOS((char *)1, SR_)
  208. X#else
  209. X#define    has_SR        CHECKBIOS((char *)1, SR)
  210. X#endif
  211. X#define has_KS        CHECKBIOS((char)1, (*KS))
  212. X#define has_KE        CHECKBIOS((char)1, (*KE))
  213. X#define    has_KU        CHECKBIOS("#H", KU)
  214. X#define    has_KD        CHECKBIOS("#P", KD)
  215. X#define    has_KL        CHECKBIOS("#K", KL)
  216. X#define    has_KR        CHECKBIOS("#M", KR)
  217. X#define has_HM        CHECKBIOS("#G", HM)
  218. X#define has_EN        CHECKBIOS("#O", EN)
  219. X#define has_PU        CHECKBIOS("#I", PU)
  220. X#define has_PD        CHECKBIOS("#Q", PD)
  221. X#define    has_IM        CHECKBIOS((char)0, (*IM))
  222. X#define    has_IC        CHECKBIOS((char)0, (*IC))
  223. X#define    has_EI        CHECKBIOS((char)0, (*EI))
  224. X#define    has_DC        CHECKBIOS((char *)0, DC)
  225. X#define    has_TI        CHECKBIOS((char)0, (*TI))
  226. X#define    has_TE        CHECKBIOS((char)0, (*TE))
  227. X#ifndef NO_CURSORSHAPE
  228. X#define has_CQ        CHECKBIOS((char *)1, CQ)
  229. X#endif
  230. X
  231. X/* (pseudo)-Curses-functions */
  232. X
  233. X#ifdef lint
  234. X# define _addCR        VOIDBIOS(;, (stdscr[-1] == '\n' ? qaddch('\r') : (stdscr[-1] = '\n')))
  235. X#else
  236. X# if OSK
  237. X#  define _addCR        VOIDBIOS(;, (stdscr[-1] == '\n' ? qaddch('\l') : (stdscr[-1] = stdscr[-1])))
  238. X# else
  239. X# define _addCR        VOIDBIOS(;, (stdscr[-1] == '\n' ? qaddch('\r') : 0))
  240. X#endif
  241. X#endif
  242. X#define qaddch(ch)    CHECKBIOS(v_put(ch), (*stdscr++ = (ch)))
  243. X#if OSK
  244. X#define addch(ch)    if (qaddch(ch) == '\n') qaddch('\l'); else
  245. X#else
  246. X#define addch(ch)    if (qaddch(ch) == '\n') qaddch('\r'); else
  247. X#endif
  248. X
  249. Xextern void initscr();
  250. Xextern void endwin();
  251. Xextern void suspend_curses();
  252. Xextern void resume_curses();
  253. Xextern void attrset();
  254. Xextern void insch();
  255. Xextern void qaddstr();
  256. X#define addstr(str)    {qaddstr(str); _addCR;}
  257. X#define move(y,x)    VOIDBIOS(v_move(x,y), \
  258. X                    tputs(tgoto(CM, x, y), 1, faddch))
  259. X#define mvaddch(y,x,ch)    {move(y,x); addch(ch);}
  260. X#define refresh()    VOIDBIOS(;, wrefresh(stdscr))
  261. X#define wrefresh(w)    if ((w) != kbuf) VOIDBIOS((w) = kbuf, {ttywrite(kbuf, (unsigned)((w) - kbuf)); (w) = kbuf;}) else
  262. X#define wqrefresh(w)    if ((w) - kbuf > 2000) VOIDBIOS((w) = kbuf, {ttywrite(kbuf, (unsigned)((w) - kbuf)); (w) = kbuf;}) else
  263. X#define standout()    do_SO()
  264. X#define standend()    do_SE()
  265. X#define clrtoeol()    do_CE()
  266. X#define clrtobot()    do_CD()
  267. X#define insertln()    do_AL()
  268. X#define deleteln()    do_DL()
  269. X#define delch()        do_DC()
  270. X#define scrollok(w,b)
  271. X#define raw()
  272. X#define echo()
  273. X#define cbreak()
  274. X#define noraw()
  275. X#define noecho()
  276. X#define nocbreak()
  277. eof
  278. if test `wc -c <curses.h` -ne 8819
  279. then
  280. echo curses.h damaged!
  281. fi
  282. fi
  283.  
  284. if test -f cut.c -a "$1" != -f
  285. then
  286. echo Will not overwrite cut.c
  287. else
  288. echo Extracting cut.c
  289. sed 's/^X//' >cut.c <<\eof
  290. X/* cut.c */
  291. X
  292. X/* Author:
  293. X *    Steve Kirkendall
  294. X *    14407 SW Teal Blvd. #C
  295. X *    Beaverton, OR 97005
  296. X *    kirkenda@cs.pdx.edu
  297. X */
  298. X
  299. X
  300. X/* This file contains function which manipulate the cut buffers. */
  301. X
  302. X#include "config.h"
  303. X#include "vi.h"
  304. X#if TURBOC
  305. X#include <process.h>        /* needed for getpid */
  306. X#endif
  307. X#if TOS
  308. X#include <osbind.h>
  309. X#define    rename(a,b)    Frename(0,a,b)
  310. X#endif
  311. X
  312. X# define NANNONS    9    /* number of annonymous buffers */
  313. X
  314. Xstatic struct cutbuf
  315. X{
  316. X    short    *phys;    /* pointer to an array of #s of BLKs containing text */
  317. X    int    nblks;    /* number of blocks in phys[] array */
  318. X    int    start;    /* offset into first block of start of cut */
  319. X    int    end;    /* offset into last block of end of cut */
  320. X    int    fd;    /* fd of tmp file, or -1 to use tmpfd */
  321. X    char    lnmode;    /* boolean: line-mode cut? (as opposed to char-mode) */
  322. X}
  323. X    named[27],    /* cut buffers "a through "z and ". */
  324. X    annon[NANNONS];    /* annonymous cut buffers */
  325. X
  326. Xstatic char    cbname;    /* name chosen for next cut/paste operation */
  327. X
  328. X
  329. X#ifndef NO_RECYCLE
  330. X/* This function builds a list of all blocks needed in the current tmp file
  331. X * for the contents of cut buffers.
  332. X * !!! WARNING: if you have more than ~450000 bytes of text in all of the
  333. X * cut buffers, then this will fail disastrously, because buffer overflow
  334. X * is *not* allowed for.
  335. X */
  336. Xint cutneeds(need)
  337. X    BLK        *need;    /* this is where we deposit the list */
  338. X{
  339. X    struct cutbuf    *cb;    /* used to count through cut buffers */
  340. X    int        i;    /* used to count through blocks of a cut buffer */
  341. X    int        n;    /* total number of blocks in list */
  342. X
  343. X    n = 0;
  344. X
  345. X    /* first the named buffers... */
  346. X    for (cb = named; cb < &named[27]; cb++)
  347. X    {
  348. X        if (cb->fd > 0)
  349. X            continue;
  350. X
  351. X        for (i = cb->nblks; i-- > 0; )
  352. X        {
  353. X            need->n[n++] = cb->phys[i];
  354. X        }
  355. X    }
  356. X
  357. X    /* then the anonymous buffers */
  358. X    for (cb = annon; cb < &annon[NANNONS]; cb++)
  359. X    {
  360. X        if (cb->fd > 0)
  361. X            continue;
  362. X
  363. X        for (i = cb->nblks; i-- > 0; )
  364. X        {
  365. X            need->n[n++] = cb->phys[i];
  366. X        }
  367. X    }
  368. X
  369. X    return n;
  370. X}
  371. X#endif
  372. X
  373. X/* This function frees a cut buffer */
  374. Xstatic void cutfree(buf)
  375. X    struct cutbuf    *buf;
  376. X{
  377. X    char    cutfname[50];
  378. X    int    i;
  379. X
  380. X    /* return immediately if the buffer is already empty */
  381. X    if (buf->nblks <= 0)
  382. X    {
  383. X        return;
  384. X    }
  385. X
  386. X    /* else free up stuff */
  387. X    buf->nblks = 0;
  388. X#ifdef DEBUG
  389. X    if (!buf->phys)
  390. X        msg("cutfree() tried to free an NULL buf->phys pointer.");
  391. X#endif
  392. X    free((char *)buf->phys);
  393. X
  394. X    /* see if anybody else needs this tmp file */
  395. X    if (buf->fd >= 0)
  396. X    {
  397. X        for (i = 0; i < 27; i++)
  398. X        {
  399. X            if (named[i].nblks > 0 && named[i].fd == buf->fd)
  400. X            {
  401. X                break;
  402. X            }
  403. X        }
  404. X    }
  405. X
  406. X    /* if nobody else needs it, then discard the tmp file */
  407. X    if (buf->fd >= 0 && i == 27)
  408. X    {
  409. X        close(buf->fd);
  410. X#if MSDOS || TOS
  411. X        strcpy(cutfname, o_directory);
  412. X        if ((i = strlen(cutfname)) && !strchr(":/\\", cutfname[i-1]))
  413. X            cutfname[i++]=SLASH;
  414. X        sprintf(cutfname+i, CUTNAME+3, getpid(), buf->fd);
  415. X#else
  416. X        sprintf(cutfname, CUTNAME, o_directory, getpid(), buf->fd);
  417. X#endif
  418. X        unlink(cutfname);
  419. X    }
  420. X}
  421. X
  422. X/* This function is called when we are about to abort a tmp file.  If any
  423. X * cut buffers still need the file, then a copy of the file should be
  424. X * created for use by the cut buffers.
  425. X *
  426. X * To minimize the number of extra files lying around, only named cut buffers
  427. X * are preserved in a file switch; the annonymous buffers just go away.
  428. X */
  429. Xvoid cutswitch(tmpname)
  430. X    char    *tmpname; /* name of the tmp file */
  431. X{
  432. X    char    cutfname[50];    /* used to build a new name for the tmp file */
  433. X    int    fd;        /* a new fd for the current tmp file */
  434. X    int    i;
  435. X#if MSDOS || TOS
  436. X    int    j;
  437. X#endif
  438. X
  439. X    /* discard all annonymous cut buffers */
  440. X    for (i = 0; i < NANNONS; i++)
  441. X    {
  442. X        cutfree(&annon[i]);
  443. X    }
  444. X
  445. X    /* find the first named buffer that uses this tmp file */
  446. X    for (i = 0; i < 27; i++)
  447. X    {
  448. X        if (named[i].nblks > 0 && named[i].fd < 0)
  449. X        {
  450. X            break;
  451. X        }
  452. X    }
  453. X
  454. X    /* if none of them use this tmp file, then we're done */
  455. X    if (i == 27)
  456. X    {
  457. X        return;
  458. X    }
  459. X
  460. X    /* else we'll need this file and an fd a little longer */
  461. X#if MSDOS || TOS
  462. X    strcpy(cutfname, o_directory);
  463. X    if ((j = strlen(cutfname)) && !strchr(":/\\", cutfname[j-1]))
  464. X        cutfname[j++]=SLASH;
  465. X    close(tmpfd);
  466. X    fd = open(tmpname, O_RDONLY|O_BINARY);
  467. X    close(fd);
  468. X    sprintf(cutfname+j, CUTNAME+3, getpid(), fd);
  469. X    rename(tmpname, cutfname);
  470. X    fd = open(cutfname, O_RDONLY|O_BINARY);
  471. X    tmpfd = -1; /* we'll try to close this in tmp.c, but who cares? */
  472. X#else
  473. X    fd = dup(tmpfd);
  474. X# if OSK
  475. X    sprintf(cutfname, CUTNAME, "", getpid(), fd);
  476. X    if (!link(tmpname, &cutfname[1])) /* skip slash */
  477. X        unlink(tmpname);
  478. X# else    
  479. X    sprintf(cutfname, CUTNAME, o_directory, getpid(), fd);
  480. X    link(tmpname, cutfname) || unlink(tmpname);
  481. X# endif
  482. X#endif
  483. X
  484. X    /* have all cut buffers use the new fd instead */
  485. X    for (; i < 27; i++)
  486. X    {
  487. X        if (named[i].nblks > 0 && named[i].fd < 0)
  488. X        {
  489. X            named[i].fd = fd;
  490. X        }
  491. X    }
  492. X}
  493. X
  494. X/* This function should be called just before termination of vi */
  495. Xvoid cutend()
  496. X{
  497. X    int    i;
  498. X
  499. X    /* free all named cut buffers, since they might be forcing an older
  500. X     * tmp file to be retained.
  501. X     */
  502. X    for (i = 0; i < 27; i++)
  503. X    {
  504. X        cutfree(&named[i]);
  505. X    }
  506. X}
  507. X
  508. X
  509. X/* This function is used to select the cut buffer to be used next */
  510. Xvoid cutname(name)
  511. X    int    name;    /* a single character */
  512. X{
  513. X    cbname = name;
  514. X}
  515. X
  516. X
  517. X
  518. X
  519. X/* This function copies a selected segment of text to a cut buffer */
  520. Xvoid cut(from, to)
  521. X    MARK    from;        /* start of text to cut */
  522. X    MARK    to;        /* end of text to cut */
  523. X{
  524. X    int        first;    /* logical number of first block in cut */
  525. X    int        last;    /* logical number of last block used in cut */
  526. X    long        line;    /* a line number */
  527. X    int        lnmode;    /* boolean: will this be a line-mode cut? */
  528. X    MARK        delthru;/* end of text temporarily inserted for apnd */
  529. X    REG struct cutbuf *cb;
  530. X    REG long    l;
  531. X    REG int        i;
  532. X    REG char    *scan;
  533. X    char        *blkc;
  534. X
  535. X    /* detect whether this must be a line-mode cut or char-mode cut */
  536. X    if (markidx(from) == 0 && markidx(to) == 0)
  537. X        lnmode = TRUE;
  538. X    else
  539. X        lnmode = FALSE;
  540. X
  541. X    /* by default, we don't "delthru" anything */
  542. X    delthru = MARK_UNSET;
  543. X
  544. X    /* decide which cut buffer to use */
  545. X    if (!cbname)
  546. X    {
  547. X        /* free up the last annonymous cut buffer */
  548. X        cutfree(&annon[NANNONS - 1]);
  549. X
  550. X        /* shift the annonymous cut buffers */
  551. X        for (i = NANNONS - 1; i > 0; i--)
  552. X        {
  553. X            annon[i] = annon[i - 1];
  554. X        }
  555. X
  556. X        /* use the first annonymous cut buffer */
  557. X        cb = annon;
  558. X        cb->nblks = 0;
  559. X    }
  560. X    else if (cbname >= 'a' && cbname <= 'z')
  561. X    {
  562. X        cb = &named[cbname - 'a'];
  563. X        cutfree(cb);
  564. X    }
  565. X#ifndef CRUNCH
  566. X    else if (cbname >= 'A' && cbname <= 'Z')
  567. X    {
  568. X        cb = &named[cbname - 'A'];
  569. X        if (cb->nblks > 0)
  570. X        {
  571. X            /* resolve linemode/charmode differences */
  572. X            if (!lnmode && cb->lnmode)
  573. X            {
  574. X                from &= ~(BLKSIZE - 1);
  575. X                if (markidx(to) != 0 || to == from)
  576. X                {
  577. X                    to = to + BLKSIZE - markidx(to);
  578. X                }
  579. X                lnmode = TRUE;
  580. X            }
  581. X
  582. X            /* insert the old cut-buffer before the new text */
  583. X            mark[28] = to;
  584. X            delthru = paste(from, FALSE, TRUE);
  585. X            if (delthru == MARK_UNSET)
  586. X            {
  587. X                return;
  588. X            }
  589. X            delthru++;
  590. X            to = mark[28];
  591. X        }
  592. X        cutfree(cb);
  593. X    }
  594. X#endif /* not CRUNCH */
  595. X    else if (cbname == '.')
  596. X    {
  597. X        cb = &named[26];
  598. X        cutfree(cb);
  599. X    }
  600. X    else
  601. X    {
  602. X        msg("Invalid cut buffer name: \"%c", cbname);
  603. X        cbname = '\0';
  604. X        return;
  605. X    }
  606. X    cbname = '\0';
  607. X    cb->fd = -1;
  608. X
  609. X    /* detect whether we're doing a line mode cut */
  610. X    cb->lnmode = lnmode;
  611. X
  612. X    /* ---------- */
  613. X
  614. X    /* Reporting... */    
  615. X    if (markidx(from) == 0 && markidx(to) == 0)
  616. X    {
  617. X        rptlines = markline(to) - markline(from);
  618. X        rptlabel = "yanked";
  619. X    }
  620. X
  621. X    /* ---------- */
  622. X
  623. X    /* make sure each block has a physical disk address */
  624. X    blksync();
  625. X
  626. X    /* find the first block in the cut */
  627. X    line = markline(from);
  628. X    for (first = 1; line > lnum[first]; first++)
  629. X    {
  630. X    }
  631. X
  632. X    /* fetch text of the block containing that line */
  633. X    blkc = scan = blkget(first)->c;
  634. X
  635. X    /* find the mark in the block */
  636. X    for (l = lnum[first - 1]; ++l < line; )
  637. X    {
  638. X        while (*scan++ != '\n')
  639. X        {
  640. X        }
  641. X    }
  642. X    scan += markidx(from);
  643. X
  644. X    /* remember the offset of the start */
  645. X    cb->start = scan - blkc;
  646. X
  647. X    /* ---------- */
  648. X
  649. X    /* find the last block in the cut */
  650. X    line = markline(to);
  651. X    for (last = first; line > lnum[last]; last++)
  652. X    {
  653. X    }
  654. X
  655. X    /* fetch text of the block containing that line */
  656. X    if (last != first)
  657. X    {
  658. X        blkc = scan = blkget(last)->c;
  659. X    }
  660. X    else
  661. X    {
  662. X        scan = blkc;
  663. X    }
  664. X
  665. X    /* find the mark in the block */
  666. X    for (l = lnum[last - 1]; ++l < line; )
  667. X    {
  668. X        while (*scan++ != '\n')
  669. X        {
  670. X        }
  671. X    }
  672. X    if (markline(to) <= nlines)
  673. X    {
  674. X        scan += markidx(to);
  675. X    }
  676. X
  677. X    /* remember the offset of the end */
  678. X    cb->end = scan - blkc;
  679. X
  680. X    /* ------- */
  681. X
  682. X    /* remember the physical block numbers of all included blocks */
  683. X    cb->nblks = last - first;
  684. X    if (cb->end > 0)
  685. X    {
  686. X        cb->nblks++;
  687. X    }
  688. X#ifdef lint
  689. X    cb->phys = (short *)0;
  690. X#else
  691. X    cb->phys = (short *)malloc((unsigned)(cb->nblks * sizeof(short)));
  692. X#endif
  693. X    for (i = 0; i < cb->nblks; i++)
  694. X    {
  695. X        cb->phys[i] = hdr.n[first++];
  696. X    }
  697. X
  698. X#ifndef CRUNCH
  699. X    /* if we temporarily inserted text for appending, then delete that
  700. X     * text now -- before the user sees it.
  701. X     */
  702. X    if (delthru)
  703. X    {
  704. X        line = rptlines;
  705. X        delete(from, delthru);
  706. X        rptlines = line;
  707. X        rptlabel = "yanked";
  708. X    }
  709. X#endif /* not CRUNCH */
  710. X}
  711. X
  712. X
  713. Xstatic void readcutblk(cb, blkno)
  714. X    struct cutbuf    *cb;
  715. X    int        blkno;
  716. X{
  717. X    int        fd;    /* either tmpfd or cb->fd */
  718. X
  719. X    /* decide which fd to use */
  720. X    if (cb->fd >= 0)
  721. X    {
  722. X        fd = cb->fd;
  723. X    }
  724. X    else
  725. X    {
  726. X        fd = tmpfd;
  727. X    }
  728. X
  729. X    /* get the block */
  730. X    lseek(fd, (long)cb->phys[blkno] * (long)BLKSIZE, 0);
  731. X    if (read(fd, tmpblk.c, (unsigned)BLKSIZE) != BLKSIZE)
  732. X    {
  733. X        msg("Error reading back from tmp file for pasting!");
  734. X    }
  735. X}
  736. X
  737. X
  738. X/* This function inserts text from a cut buffer, and returns the MARK where
  739. X * insertion ended.  Return MARK_UNSET on errors.
  740. X */
  741. XMARK paste(at, after, retend)
  742. X    MARK    at;    /* where to insert the text */
  743. X    int    after;    /* boolean: insert after mark? (rather than before) */
  744. X    int    retend;    /* boolean: return end of text? (rather than start) */
  745. X{
  746. X    REG struct cutbuf    *cb;
  747. X    REG int            i;
  748. X
  749. X    /* decide which cut buffer to use */
  750. X    if (cbname >= 'A' && cbname <= 'Z')
  751. X    {
  752. X        cb = &named[cbname - 'A'];
  753. X    }
  754. X    else if (cbname >= 'a' && cbname <= 'z')
  755. X    {
  756. X        cb = &named[cbname - 'a'];
  757. X    }
  758. X    else if (cbname >= '1' && cbname <= '9')
  759. X    {
  760. X        cb = &annon[cbname - '1'];
  761. X    }
  762. X    else if (cbname == '.')
  763. X    {
  764. X        cb = &named[26];
  765. X    }
  766. X    else if (!cbname)
  767. X    {
  768. X        cb = annon;
  769. X    }
  770. X    else
  771. X    {
  772. X        msg("Invalid cut buffer name: \"%c", cbname);
  773. X        cbname = '\0';
  774. X        return MARK_UNSET;
  775. X    }
  776. X
  777. X    /* make sure it isn't empty */
  778. X    if (cb->nblks == 0)
  779. X    {
  780. X        if (cbname)
  781. X            msg("Cut buffer \"%c is empty", cbname);
  782. X        else
  783. X            msg("Cut buffer is empty");
  784. X        cbname = '\0';
  785. X        return MARK_UNSET;
  786. X    }
  787. X    cbname = '\0';
  788. X
  789. X    /* adjust the insertion MARK for "after" and line-mode cuts */
  790. X    if (cb->lnmode)
  791. X    {
  792. X        at &= ~(BLKSIZE - 1);
  793. X        if (after)
  794. X        {
  795. X            at += BLKSIZE;
  796. X        }
  797. X    }
  798. X    else if (after)
  799. X    {
  800. X        /* careful! if markidx(at) == 0 we might be pasting into an
  801. X         * empty line -- so we can't blindly increment "at".
  802. X         */
  803. X        if (markidx(at) == 0)
  804. X        {
  805. X            pfetch(markline(at));
  806. X            if (plen != 0)
  807. X            {
  808. X                at++;
  809. X            }
  810. X        }
  811. X        else
  812. X        {
  813. X            at++;
  814. X        }
  815. X    }
  816. X
  817. X    /* put a copy of the "at" mark in the mark[] array, so it stays in
  818. X     * sync with changes made via add().
  819. X     */
  820. X    mark[27] = at;
  821. X
  822. X    /* simple one-block paste? */
  823. X    if (cb->nblks == 1)
  824. X    {
  825. X        /* get the block */
  826. X        readcutblk(cb, 0);
  827. X
  828. X        /* isolate the text we need within it */
  829. X        if (cb->end)
  830. X        {
  831. X            tmpblk.c[cb->end] = '\0';
  832. X        }
  833. X
  834. X        /* insert it */
  835. X        ChangeText
  836. X        {
  837. X            add(at, &tmpblk.c[cb->start]);
  838. X        }
  839. X    }
  840. X    else
  841. X    {
  842. X        /* multi-block paste */
  843. X
  844. X        ChangeText
  845. X        {
  846. X            i = cb->nblks - 1;
  847. X
  848. X            /* add text from the last block first */
  849. X            if (cb->end > 0)
  850. X            {
  851. X                readcutblk(cb, i);
  852. X                tmpblk.c[cb->end] = '\0';
  853. X                add(at, tmpblk.c);
  854. X                i--;
  855. X            }
  856. X
  857. X            /* add intervening blocks */
  858. X            while (i > 0)
  859. X            {
  860. X                readcutblk(cb, i);
  861. X                add(at, tmpblk.c);
  862. X                i--;
  863. X            }
  864. X
  865. X            /* add text from the first cut block */
  866. X            readcutblk(cb, 0);
  867. X            add(at, &tmpblk.c[cb->start]);
  868. X        }
  869. X    }
  870. X
  871. X    /* Reporting... */
  872. X    rptlines = markline(mark[27]) - markline(at);
  873. X    rptlabel = "pasted";
  874. X
  875. X    /* return the mark at the beginning/end of inserted text */
  876. X    if (retend)
  877. X    {
  878. X        return mark[27] - 1L;
  879. X    }
  880. X    return at;
  881. X}
  882. X
  883. X
  884. X
  885. X
  886. X#ifndef NO_AT
  887. X
  888. X/* This function copies characters from a cut buffer into a string.
  889. X * It returns the number of characters in the cut buffer.  If the cut
  890. X * buffer is too large to fit in the string (i.e. if cb2str() returns
  891. X * a number >= size) then the characters will not have been copied.
  892. X * It returns 0 if the cut buffer is empty, and -1 for invalid cut buffers.
  893. X */
  894. Xint cb2str(name, buf, size)
  895. X    int    name;    /* the name of a cut-buffer to get: a-z only! */
  896. X    char    *buf;    /* where to put the string */
  897. X    unsigned size;    /* size of buf */
  898. X{
  899. X    REG struct cutbuf    *cb;
  900. X    REG char        *src;
  901. X    REG char        *dest;
  902. X
  903. X    /* decide which cut buffer to use */
  904. X    if (name >= 'a' && name <= 'z')
  905. X    {
  906. X        cb = &named[name - 'a'];
  907. X    }
  908. X    else
  909. X    {
  910. X        return -1;
  911. X    }
  912. X
  913. X    /* if the buffer is empty, return 0 */
  914. X    if (cb->nblks == 0)
  915. X    {
  916. X        return 0;
  917. X    }
  918. X
  919. X    /* !!! if not a single-block cut, then fail */
  920. X    if (cb->nblks != 1)
  921. X    {
  922. X        return size;
  923. X    }
  924. X
  925. X    /* if too big, return the size now, without doing anything */
  926. X    if (cb->end - cb->start >= size)
  927. X    {
  928. X        return cb->end - cb->start;
  929. X    }
  930. X
  931. X    /* get the block */
  932. X    readcutblk(cb, 0);
  933. X
  934. X    /* isolate the string within that blk */
  935. X    if (cb->start == 0)
  936. X    {
  937. X        tmpblk.c[cb->end] = '\0';
  938. X    }
  939. X    else
  940. X    {
  941. X        for (dest = tmpblk.c, src = dest + cb->start; src < tmpblk.c + cb->end; )
  942. X        {
  943. X            *dest++ = *src++;
  944. X        }
  945. X        *dest = '\0';
  946. X    }
  947. X
  948. X    /* copy the string into the buffer */
  949. X    if (buf != tmpblk.c)
  950. X    {
  951. X        strcpy(buf, tmpblk.c);
  952. X    }
  953. X
  954. X    /* return the length */
  955. X    return cb->end - cb->start;
  956. X}
  957. X#endif
  958. eof
  959. if test `wc -c <cut.c` -ne 13222
  960. then
  961. echo cut.c damaged!
  962. fi
  963. fi
  964.  
  965. if test -f ex.c -a "$1" != -f
  966. then
  967. echo Will not overwrite ex.c
  968. else
  969. echo Extracting ex.c
  970. sed 's/^X//' >ex.c <<\eof
  971. X/* ex.c */
  972. X
  973. X/* Author:
  974. X *    Steve Kirkendall
  975. X *    14407 SW Teal Blvd. #C
  976. X *    Beaverton, OR 97005
  977. X *    kirkenda@cs.pdx.edu
  978. X */
  979. X
  980. X
  981. X/* This file contains the code for reading ex commands. */
  982. X
  983. X#include "config.h"
  984. X#include <ctype.h>
  985. X#include "vi.h"
  986. X
  987. X#ifndef isascii
  988. X# define isascii(c) !((c)&~0x7f)
  989. X#endif
  990. X
  991. X/* This data type is used to describe the possible argument combinations */
  992. Xtypedef short ARGT;
  993. X#define FROM    1        /* allow a linespec */
  994. X#define    TO    2        /* allow a second linespec */
  995. X#define BANG    4        /* allow a ! after the command name */
  996. X#define EXTRA    8        /* allow extra args after command name */
  997. X#define XFILE    16        /* expand wildcards in extra part */
  998. X#define NOSPC    32        /* no spaces allowed in the extra part */
  999. X#define    DFLALL    64        /* default file range is 1,$ */
  1000. X#define DFLNONE    128        /* no default file range */
  1001. X#define NODFL    256        /* do not default to the current file name */
  1002. X#define EXRCOK    512        /* can be in a .exrc file */
  1003. X#define NL    1024        /* if mode!=MODE_EX, then write a newline first */
  1004. X#define PLUS    2048        /* allow a line number, as in ":e +32 foo" */
  1005. X#define ZERO    4096        /* allow 0 to be given as a line number */
  1006. X#define FILES    (XFILE + EXTRA)    /* multiple extra files allowed */
  1007. X#define WORD1    (EXTRA + NOSPC)    /* one extra word allowed */
  1008. X#define FILE1    (FILES + NOSPC)    /* 1 file allowed, defaults to current file */
  1009. X#define NAMEDF    (FILE1 + NODFL)    /* 1 file allowed, defaults to "" */
  1010. X#define NAMEDFS    (FILES + NODFL)    /* multiple files allowed, default is "" */
  1011. X#define RANGE    (FROM + TO)    /* range of linespecs allowed */
  1012. X#define NONE    0        /* no args allowed at all */
  1013. X
  1014. X/* This array maps ex command names to command codes. The order in which
  1015. X * command names are listed below is significant -- ambiguous abbreviations
  1016. X * are always resolved to be the first possible match.  (e.g. "r" is taken
  1017. X * to mean "read", not "rewind", because "read" comes before "rewind")
  1018. X */
  1019. Xstatic struct
  1020. X{
  1021. X    char    *name;    /* name of the command */
  1022. X    CMD    code;    /* enum code of the command */
  1023. X    void    (*fn)();/* function which executes the command */
  1024. X    ARGT    argt;    /* command line arguments permitted/needed/used */
  1025. X}
  1026. X    cmdnames[] =
  1027. X{   /*    cmd name    cmd code    function    arguments */
  1028. X    {"append",    CMD_APPEND,    cmd_append,    FROM+ZERO    },
  1029. X#ifdef DEBUG
  1030. X    {"bug",        CMD_DEBUG,    cmd_debug,    RANGE+BANG+EXTRA+NL},
  1031. X#endif
  1032. X    {"change",    CMD_CHANGE,    cmd_append,    RANGE        },
  1033. X    {"delete",    CMD_DELETE,    cmd_delete,    RANGE+WORD1    },
  1034. X    {"edit",    CMD_EDIT,    cmd_edit,    BANG+FILE1+PLUS    },
  1035. X    {"file",    CMD_FILE,    cmd_file,    NAMEDF        },
  1036. X    {"global",    CMD_GLOBAL,    cmd_global,    RANGE+BANG+EXTRA+DFLALL},
  1037. X    {"insert",    CMD_INSERT,    cmd_append,    FROM        },
  1038. X    {"join",    CMD_INSERT,    cmd_join,    RANGE        },
  1039. X    {"k",        CMD_MARK,    cmd_mark,    FROM+WORD1    },
  1040. X    {"list",    CMD_LIST,    cmd_print,    RANGE+NL    },
  1041. X    {"move",    CMD_MOVE,    cmd_move,    RANGE+EXTRA    },
  1042. X    {"next",    CMD_NEXT,    cmd_next,    BANG+NAMEDFS    },
  1043. X    {"Next",    CMD_PREVIOUS,    cmd_next,    BANG        },
  1044. X    {"print",    CMD_PRINT,    cmd_print,    RANGE+NL    },
  1045. X    {"quit",    CMD_QUIT,    cmd_xit,    BANG        },
  1046. X    {"read",    CMD_READ,    cmd_read,    FROM+ZERO+NAMEDF},
  1047. X    {"substitute",    CMD_SUBSTITUTE,    cmd_substitute,    RANGE+EXTRA    },
  1048. X    {"to",        CMD_COPY,    cmd_move,    RANGE+EXTRA    },
  1049. X    {"undo",    CMD_UNDO,    cmd_undo,    NONE        },
  1050. X    {"vglobal",    CMD_VGLOBAL,    cmd_global,    RANGE+EXTRA+DFLALL},
  1051. X    {"write",    CMD_WRITE,    cmd_write,    RANGE+BANG+FILE1+DFLALL},
  1052. X    {"xit",        CMD_XIT,    cmd_xit,    BANG+NL        },
  1053. X    {"yank",    CMD_YANK,    cmd_delete,    RANGE+WORD1    },
  1054. X
  1055. X    {"!",        CMD_BANG,    cmd_shell,    EXRCOK+RANGE+NAMEDFS+DFLNONE+NL},
  1056. X    {"<",        CMD_SHIFTL,    cmd_shift,    RANGE        },
  1057. X    {">",        CMD_SHIFTR,    cmd_shift,    RANGE        },
  1058. X    {"=",        CMD_EQUAL,    cmd_file,    RANGE        },
  1059. X    {"&",        CMD_SUBAGAIN,    cmd_substitute,    RANGE        },
  1060. X#ifndef NO_AT
  1061. X    {"@",        CMD_AT,        cmd_at,        EXTRA        },
  1062. X#endif
  1063. X
  1064. X#ifndef NO_ABBR
  1065. X    {"abbreviate",    CMD_ABBR,    cmd_abbr,    EXRCOK+EXTRA    },
  1066. X#endif
  1067. X    {"args",    CMD_ARGS,    cmd_args,    EXRCOK+NAMEDFS    },
  1068. X#ifndef NO_ERRLIST
  1069. X    {"cc",        CMD_CC,        cmd_make,    BANG+FILES    },
  1070. X#endif
  1071. X    {"cd",        CMD_CD,        cmd_cd,        EXRCOK+NAMEDF    },
  1072. X    {"copy",    CMD_COPY,    cmd_move,    RANGE+EXTRA    },
  1073. X#ifndef NO_DIGRAPH
  1074. X    {"digraph",    CMD_DIGRAPH,    cmd_digraph,    EXRCOK+BANG+EXTRA},
  1075. X#endif
  1076. X#ifndef NO_ERRLIST
  1077. X    {"errlist",    CMD_ERRLIST,    cmd_errlist,    BANG+NAMEDF    },
  1078. X#endif
  1079. X    {"ex",        CMD_EDIT,    cmd_edit,    BANG+FILE1    },
  1080. X    {"map",        CMD_MAP,    cmd_map,    EXRCOK+BANG+EXTRA},
  1081. X#ifndef NO_MKEXRC
  1082. X    {"mkexrc",    CMD_MKEXRC,    cmd_mkexrc,    NAMEDF        },
  1083. X#endif
  1084. X    {"number",    CMD_NUMBER,    cmd_print,    RANGE+NL    },
  1085. X    {"put",        CMD_PUT,    cmd_put,    FROM+ZERO+WORD1    },
  1086. X    {"set",        CMD_SET,    cmd_set,    EXRCOK+EXTRA    },
  1087. X    {"shell",    CMD_SHELL,    cmd_shell,    NL        },
  1088. X    {"source",    CMD_SOURCE,    cmd_source,    EXRCOK+NAMEDF    },
  1089. X    {"tag",        CMD_TAG,    cmd_tag,    BANG+WORD1    },
  1090. X    {"version",    CMD_VERSION,    cmd_version,    EXRCOK+NONE    },
  1091. X    {"visual",    CMD_VISUAL,    cmd_visual,    NONE        },
  1092. X    {"wq",        CMD_WQUIT,    cmd_xit,    NL        },
  1093. X
  1094. X#ifdef DEBUG
  1095. X    {"debug",    CMD_DEBUG,    cmd_debug,    RANGE+BANG+EXTRA+NL},
  1096. X    {"validate",    CMD_VALIDATE,    cmd_validate,    BANG+NL        },
  1097. X#endif
  1098. X    {"chdir",    CMD_CD,        cmd_cd,        EXRCOK+NAMEDF    },
  1099. X#ifndef NO_ERRLIST
  1100. X    {"make",    CMD_MAKE,    cmd_make,    BANG+NAMEDFS    },
  1101. X#endif
  1102. X    {"mark",    CMD_MARK,    cmd_mark,    FROM+WORD1    },
  1103. X    {"previous",    CMD_PREVIOUS,    cmd_next,    BANG        },
  1104. X    {"rewind",    CMD_REWIND,    cmd_next,    BANG        },
  1105. X    {"unmap",    CMD_UNMAP,    cmd_map,    EXRCOK+BANG+EXTRA},
  1106. X#ifndef NO_ABBR
  1107. X    {"unabbreviate",CMD_UNABBR,    cmd_abbr,    EXRCOK+WORD1    },
  1108. X#endif
  1109. X
  1110. X    {(char *)0}
  1111. X};
  1112. X
  1113. X
  1114. X/* This function parses a search pattern - given a pointer to a / or ?,
  1115. X * it replaces the ending / or ? with a \0, and returns a pointer to the
  1116. X * stuff that came after the pattern.
  1117. X */
  1118. Xchar    *parseptrn(ptrn)
  1119. X    REG char    *ptrn;
  1120. X{
  1121. X    REG char     *scan;
  1122. X
  1123. X    for (scan = ptrn + 1;
  1124. X         *scan && *scan != *ptrn;
  1125. X         scan++)
  1126. X    {
  1127. X        /* allow backslashed versions of / and ? in the pattern */
  1128. X        if (*scan == '\\' && scan[1] != '\0')
  1129. X        {
  1130. X            scan++;
  1131. X        }
  1132. X    }
  1133. X    if (*scan)
  1134. X    {
  1135. X        *scan++ = '\0';
  1136. X    }
  1137. X
  1138. X    return scan;
  1139. X}
  1140. X
  1141. X
  1142. X/* This function parses a line specifier for ex commands */
  1143. Xchar *linespec(s, markptr)
  1144. X    REG char    *s;        /* start of the line specifier */
  1145. X    MARK        *markptr;    /* where to store the mark's value */
  1146. X{
  1147. X    long        num;
  1148. X    REG char    *t;
  1149. X
  1150. X    /* parse each ;-delimited clause of this linespec */
  1151. X    do
  1152. X    {
  1153. X        /* skip an initial ';', if any */
  1154. X        if (*s == ';')
  1155. X        {
  1156. X            s++;
  1157. X        }
  1158. X
  1159. X        /* skip leading spaces */
  1160. X        while (isascii(*s) && isspace(*s))
  1161. X        {
  1162. X            s++;
  1163. X        }
  1164. X    
  1165. X        /* dot means current position */
  1166. X        if (*s == '.')
  1167. X        {
  1168. X            s++;
  1169. X            *markptr = cursor;
  1170. X        }
  1171. X        /* '$' means the last line */
  1172. X        else if (*s == '$')
  1173. X        {
  1174. X            s++;
  1175. X            *markptr = MARK_LAST;
  1176. X        }
  1177. X        /* digit means an absolute line number */
  1178. X        else if (isascii(*s) && isdigit(*s))
  1179. X        {
  1180. X            for (num = 0; isascii(*s) && isdigit(*s); s++)
  1181. X            {
  1182. X                num = num * 10 + *s - '0';
  1183. X            }
  1184. X            *markptr = MARK_AT_LINE(num);
  1185. X        }
  1186. X        /* appostrophe means go to a set mark */
  1187. X        else if (*s == '\'')
  1188. X        {
  1189. X            s++;
  1190. X            *markptr = m_tomark(cursor, 1L, (int)*s);
  1191. X            s++;
  1192. X        }
  1193. X        /* slash means do a search */
  1194. X        else if (*s == '/' || *s == '?')
  1195. X        {
  1196. X            /* put a '\0' at the end of the search pattern */
  1197. X            t = parseptrn(s);
  1198. X    
  1199. X            /* search for the pattern */
  1200. X            *markptr &= ~(BLKSIZE - 1);
  1201. X            if (*s == '/')
  1202. X            {
  1203. X                pfetch(markline(*markptr));
  1204. X                if (plen > 0)
  1205. X                    *markptr += plen - 1;
  1206. X                *markptr = m_fsrch(*markptr, s);
  1207. X            }
  1208. X            else
  1209. X            {
  1210. X                *markptr = m_bsrch(*markptr, s);
  1211. X            }
  1212. X    
  1213. X            /* adjust command string pointer */
  1214. X            s = t;
  1215. X        }
  1216. X    
  1217. X        /* if linespec was faulty, quit now */
  1218. X        if (!*markptr)
  1219. X        {
  1220. X            return s;
  1221. X        }
  1222. X    
  1223. X        /* maybe add an offset */
  1224. X        t = s;
  1225. X        if (*t == '-' || *t == '+')
  1226. X        {
  1227. X            s++;
  1228. X            for (num = 0; *s >= '0' && *s <= '9'; s++)
  1229. X            {
  1230. X                num = num * 10 + *s - '0';
  1231. X            }
  1232. X            if (num == 0)
  1233. X            {
  1234. X                num = 1;
  1235. X            }
  1236. X            *markptr = m_updnto(*markptr, num, *t);
  1237. X        }
  1238. X    } while (*s == ';' || *s == '+' || *s == '-');
  1239. X
  1240. X    return s;
  1241. X}
  1242. X
  1243. X
  1244. X
  1245. X/* This function reads an ex command and executes it. */
  1246. Xvoid ex()
  1247. X{
  1248. X    char        cmdbuf[80];
  1249. X    REG int        cmdlen;
  1250. X    static long    oldline;
  1251. X    
  1252. X    significant = FALSE;
  1253. X    oldline = markline(cursor);
  1254. X
  1255. X    while (mode == MODE_EX)
  1256. X    {
  1257. X        /* read a line */
  1258. X        cmdlen = vgets(':', cmdbuf, sizeof cmdbuf);
  1259. X        if (cmdlen < 0)
  1260. X        {
  1261. X            return;
  1262. X        }
  1263. X
  1264. X        /* if empty line, assume ".+1" */
  1265. X        if (cmdlen == 0)
  1266. X        {
  1267. X            strcpy(cmdbuf, ".+1");
  1268. X            qaddch('\r');
  1269. X            clrtoeol();
  1270. X        }
  1271. X        else
  1272. X        {
  1273. X            addch('\n');
  1274. X        }
  1275. X        refresh();
  1276. X
  1277. X        /* parse & execute the command */
  1278. X        doexcmd(cmdbuf);
  1279. X
  1280. X        /* handle autoprint */
  1281. X        if (significant || markline(cursor) != oldline)
  1282. X        {
  1283. X            significant = FALSE;
  1284. X            oldline = markline(cursor);
  1285. X            if (*o_autoprint && mode == MODE_EX)
  1286. X            {
  1287. X                cmd_print(cursor, cursor, CMD_PRINT, FALSE, "");
  1288. X            }
  1289. X        }
  1290. X    }
  1291. X}
  1292. X
  1293. Xvoid doexcmd(cmdbuf)
  1294. X    char        *cmdbuf;    /* string containing an ex command */
  1295. X{
  1296. X    REG char    *scan;        /* used to scan thru cmdbuf */
  1297. X    MARK        frommark;    /* first linespec */
  1298. X    MARK        tomark;        /* second linespec */
  1299. X    REG int        cmdlen;        /* length of the command name given */
  1300. X    CMD        cmd;        /* what command is this? */
  1301. X    ARGT        argt;        /* argument types for this command */
  1302. X    short        forceit;    /* bang version of a command? */
  1303. X    REG int        cmdidx;        /* index of command */
  1304. X    REG char    *build;        /* used while copying filenames */
  1305. X    int        iswild;        /* boolean: filenames use wildcards? */
  1306. X    int        isdfl;        /* using default line ranges? */
  1307. X    int        didsub;        /* did we substitute file names for % or # */
  1308. X
  1309. X
  1310. X    /* ex commands can't be undone via the shift-U command */
  1311. X    U_line = 0L;
  1312. X
  1313. X    /* ignore command lines that start with a double-quote */
  1314. X    if (*cmdbuf == '"')
  1315. X    {
  1316. X        return;
  1317. X    }
  1318. X
  1319. X    /* permit extra colons at the start of the line */
  1320. X    while (*cmdbuf == ':')
  1321. X    {
  1322. X        cmdbuf++;
  1323. X    }
  1324. X
  1325. X    /* parse the line specifier */
  1326. X    scan = cmdbuf;
  1327. X    if (nlines < 1)
  1328. X    {
  1329. X        /* no file, so don't allow addresses */
  1330. X    }
  1331. X    else if (*scan == '%')
  1332. X    {
  1333. X        /* '%' means all lines */
  1334. X        frommark = MARK_FIRST;
  1335. X        tomark = MARK_LAST;
  1336. X        scan++;
  1337. X    }
  1338. X    else if (*scan == '0')
  1339. X    {
  1340. X        frommark = tomark = MARK_UNSET;
  1341. X        scan++;
  1342. X    }
  1343. X    else
  1344. X    {
  1345. X        frommark = cursor;
  1346. X        scan = linespec(scan, &frommark);
  1347. X        tomark = frommark;
  1348. X        if (frommark && *scan == ',')
  1349. X        {
  1350. X            scan++;
  1351. X            scan = linespec(scan, &tomark);
  1352. X        }
  1353. X        if (!tomark)
  1354. X        {
  1355. X            /* faulty line spec -- fault already described */
  1356. X            return;
  1357. X        }
  1358. X        if (frommark > tomark)
  1359. X        {
  1360. X            msg("first address exceeds the second");
  1361. X            return;
  1362. X        }
  1363. X    }
  1364. X    isdfl = (scan == cmdbuf);
  1365. X
  1366. X    /* skip whitespace */
  1367. X    while (isascii(*scan) && isspace(*scan))
  1368. X    {
  1369. X        scan++;
  1370. X    }
  1371. X
  1372. X    /* if no command, then just move the cursor to the mark */
  1373. X    if (!*scan)
  1374. X    {
  1375. X        cursor = tomark;
  1376. X        return;
  1377. X    }
  1378. X
  1379. X    /* figure out how long the command name is */
  1380. X    if (isascii(*scan) && !isalpha(*scan))
  1381. X    {
  1382. X        cmdlen = 1;
  1383. X    }
  1384. X    else
  1385. X    {
  1386. X        for (cmdlen = 1;
  1387. X             !isascii(scan[cmdlen]) || isalpha(scan[cmdlen]);
  1388. X             cmdlen++)
  1389. X        {
  1390. X        }
  1391. X    }
  1392. X
  1393. X    /* lookup the command code */
  1394. X    for (cmdidx = 0;
  1395. X         cmdnames[cmdidx].name && strncmp(scan, cmdnames[cmdidx].name, cmdlen);
  1396. X         cmdidx++)
  1397. X    {
  1398. X    }
  1399. X    argt = cmdnames[cmdidx].argt;
  1400. X    cmd = cmdnames[cmdidx].code;
  1401. X    if (cmd == CMD_NULL)
  1402. X    {
  1403. X#if OSK
  1404. X        msg("Unknown command \"%s\"", scan);
  1405. X#else
  1406. X        msg("Unknown command \"%.*s\"", cmdlen, scan);
  1407. X#endif
  1408. X        return;
  1409. X    }
  1410. X
  1411. X    /* if the command ended with a bang, set the forceit flag */
  1412. X    scan += cmdlen;
  1413. X    if ((argt & BANG) && *scan == '!')
  1414. X    {
  1415. X        scan++;
  1416. X        forceit = 1;
  1417. X    }
  1418. X    else
  1419. X    {
  1420. X        forceit = 0;
  1421. X    }
  1422. X
  1423. X    /* skip any more whitespace, to leave scan pointing to arguments */
  1424. X    while (isascii(*scan) && isspace(*scan))
  1425. X    {
  1426. X        scan++;
  1427. X    }
  1428. X
  1429. X    /* a couple of special cases for filenames */
  1430. X    if (argt & XFILE)
  1431. X    {
  1432. X        /* if names were given, process them */
  1433. X        if (*scan)
  1434. X        {
  1435. X            for (build = tmpblk.c, iswild = didsub = FALSE; *scan; scan++)
  1436. X            {
  1437. X                switch (*scan)
  1438. X                {
  1439. X                  case '%':
  1440. X                    if (!*origname)
  1441. X                    {
  1442. X                        msg("No filename to substitute for %%");
  1443. X                        return;
  1444. X                    }
  1445. X                    strcpy(build, origname);
  1446. X                    while (*build)
  1447. X                    {
  1448. X                        build++;
  1449. X                    }
  1450. X                    didsub = TRUE;
  1451. X                    break;
  1452. X    
  1453. X                  case '#':
  1454. X                    if (!*prevorig)
  1455. X                    {
  1456. X                        msg("No filename to substitute for #");
  1457. X                        return;
  1458. X                    }
  1459. X                    strcpy(build, prevorig);
  1460. X                    while (*build)
  1461. X                    {
  1462. X                        build++;
  1463. X                    }
  1464. X                    didsub = TRUE;
  1465. X                    break;
  1466. X    
  1467. X                  case '*':
  1468. X                  case '?':
  1469. X#if !(MSDOS || TOS)
  1470. X                  case '[':
  1471. X                  case '`':
  1472. X                  case '{': /* } */
  1473. X                  case '$':
  1474. X                  case '~':
  1475. X#endif
  1476. X                    *build++ = *scan;
  1477. X                    iswild = TRUE;
  1478. X                    break;
  1479. X
  1480. X                  default:
  1481. X                    *build++ = *scan;
  1482. X                }
  1483. X            }
  1484. X            *build = '\0';
  1485. X    
  1486. X            if (cmd == CMD_BANG
  1487. X             || cmd == CMD_READ && tmpblk.c[0] == '!'
  1488. X             || cmd == CMD_WRITE && tmpblk.c[0] == '!')
  1489. X            {
  1490. X                if (didsub)
  1491. X                {
  1492. X                    if (mode != MODE_EX)
  1493. X                    {
  1494. X                        addch('\n');
  1495. X                    }
  1496. X                    addstr(tmpblk.c);
  1497. X                    addch('\n');
  1498. X                    exrefresh();
  1499. X                }
  1500. X            }
  1501. X            else
  1502. X            {
  1503. X                if (iswild && tmpblk.c[0] != '>')
  1504. X                {
  1505. X                    scan = wildcard(tmpblk.c);
  1506. X                }
  1507. X            }
  1508. X        }
  1509. X        else /* no names given, maybe assume origname */
  1510. X        {
  1511. X            if (!(argt & NODFL))
  1512. X            {
  1513. X                strcpy(tmpblk.c, origname);
  1514. X            }
  1515. X            else
  1516. X            {
  1517. X                *tmpblk.c = '\0';
  1518. X            }
  1519. X        }
  1520. X
  1521. X        scan = tmpblk.c;
  1522. X    }
  1523. X
  1524. X    /* bad arguments? */
  1525. X    if (!(argt & EXRCOK) && nlines < 1L)
  1526. X    {
  1527. X        msg("Can't use the \"%s\" command in a %s file", cmdnames[cmdidx].name, EXRC);
  1528. X        return;
  1529. X    }
  1530. X    if (!(argt & (ZERO | EXRCOK)) && frommark == MARK_UNSET)
  1531. X    {
  1532. X        msg("Can't use address 0 with \"%s\" command.", cmdnames[cmdidx].name);
  1533. X        return;
  1534. X    }
  1535. X    if (!(argt & FROM) && frommark != cursor && nlines >= 1L)
  1536. X    {
  1537. X        msg("Can't use address with \"%s\" command.", cmdnames[cmdidx].name);
  1538. X        return;
  1539. X    }
  1540. X    if (!(argt & TO) && tomark != frommark && nlines >= 1L)
  1541. X    {
  1542. X        msg("Can't use a range with \"%s\" command.", cmdnames[cmdidx].name);
  1543. X        return;
  1544. X    }
  1545. X    if (!(argt & EXTRA) && *scan)
  1546. X    {
  1547. X        msg("Extra characters after \"%s\" command.", cmdnames[cmdidx].name);
  1548. X        return;
  1549. X    }
  1550. X    if ((argt & NOSPC) && !(cmd == CMD_READ && (forceit || *scan == '!')))
  1551. X    {
  1552. X        build = scan;
  1553. X#ifndef CRUNCH
  1554. X        if ((argt & PLUS) && *build == '+')
  1555. X        {
  1556. X            while (*build && !(isascii(*build) && isspace(*build)))
  1557. X            {
  1558. X                build++;
  1559. X            }
  1560. X            while (*build && isascii(*build) && isspace(*build))
  1561. X            {
  1562. X                build++;
  1563. X            }
  1564. X        }
  1565. X#endif /* not CRUNCH */
  1566. X        for (; *build; build++)
  1567. X        {
  1568. X            if (isspace(*build))
  1569. X            {
  1570. X                msg("Too many %s to \"%s\" command.",
  1571. X                    (argt & XFILE) ? "filenames" : "arguments",
  1572. X                    cmdnames[cmdidx].name);
  1573. X                return;
  1574. X            }
  1575. X        }
  1576. X    }
  1577. X
  1578. X    /* some commands have special default ranges */
  1579. X    if (isdfl && (argt & DFLALL))
  1580. X    {
  1581. X        frommark = MARK_FIRST;
  1582. X        tomark = MARK_LAST;
  1583. X    }
  1584. X    else if (isdfl && (argt & DFLNONE))
  1585. X    {
  1586. X        frommark = tomark = 0L;
  1587. X    }
  1588. X
  1589. X    /* write a newline if called from visual mode */
  1590. X    if ((argt & NL) && mode != MODE_EX && !exwrote)
  1591. X    {
  1592. X        addch('\n');
  1593. X        exrefresh();
  1594. X    }
  1595. X
  1596. X    /* act on the command */
  1597. X    (*cmdnames[cmdidx].fn)(frommark, tomark, cmd, forceit, scan);
  1598. X}
  1599. X
  1600. X
  1601. X/* This function executes EX commands from a file.  It returns 1 normally, or
  1602. X * 0 if the file could not be opened for reading.
  1603. X */
  1604. Xint doexrc(filename)
  1605. X    char    *filename;    /* name of a ".exrc" file */
  1606. X{
  1607. X    int    fd;        /* file descriptor */
  1608. X    int    len;        /* length of the ".exrc" file */
  1609. X    char    buf[MAXRCLEN];    /* buffer, holds the entire .exrc file */
  1610. X
  1611. X    /* open the file, read it, and close */
  1612. X    fd = open(filename, O_RDONLY);
  1613. X    if (fd < 0)
  1614. X    {
  1615. X        return 0;
  1616. X    }
  1617. X    len = tread(fd, buf, MAXRCLEN);
  1618. X    close(fd);
  1619. X
  1620. X    /* execute the string */
  1621. X    exstring(buf, len);
  1622. X
  1623. X    return 1;
  1624. X}
  1625. X
  1626. Xvoid exstring(buf, len)
  1627. X    char    *buf;    /* the commands to execute */
  1628. X    int    len;    /* the length of the string */
  1629. X{
  1630. X    char    *cmd;        /* start of a command */
  1631. X    char    *end;        /* used to search for the end of cmd */
  1632. X
  1633. X    /* find & do each command */
  1634. X    for (cmd = buf; cmd < &buf[len]; cmd = end + 1)
  1635. X    {
  1636. X        /* find the end of the command */
  1637. X        for (end = cmd; end < &buf[len] && *end != '\n' && *end != '|'; end++)
  1638. X        {
  1639. X        }
  1640. X        *end = '\0';
  1641. X
  1642. X        /* do it */
  1643. X        doexcmd(cmd);
  1644. X    }
  1645. X}
  1646. eof
  1647. if test `wc -c <ex.c` -ne 15130
  1648. then
  1649. echo ex.c damaged!
  1650. fi
  1651. fi
  1652.  
  1653. if test -f input.c -a "$1" != -f
  1654. then
  1655. echo Will not overwrite input.c
  1656. else
  1657. echo Extracting input.c
  1658. sed 's/^X//' >input.c <<\eof
  1659. X/* input.c */
  1660. X
  1661. X/* Author:
  1662. X *    Steve Kirkendall
  1663. X *    14407 SW Teal Blvd. #C
  1664. X *    Beaverton, OR 97005
  1665. X *    kirkenda@cs.pdx.edu
  1666. X */
  1667. X
  1668. X
  1669. X/* This file contains the input() function, which implements vi's INPUT mode.
  1670. X * It also contains the code that supports digraphs.
  1671. X */
  1672. X
  1673. X#include <ctype.h>
  1674. X#include "config.h"
  1675. X#include "vi.h"
  1676. X
  1677. X
  1678. X#ifndef NO_DIGRAPH
  1679. Xstatic struct _DIG
  1680. X{
  1681. X    struct _DIG    *next;
  1682. X    char        key1;
  1683. X    char        key2;
  1684. X    char        dig;
  1685. X    char        save;
  1686. X} *digs;
  1687. X
  1688. Xchar digraph(key1, key2)
  1689. X    char    key1;    /* the underlying character */
  1690. X    char    key2;    /* the second character */
  1691. X{
  1692. X    int        newkey;
  1693. X    REG struct _DIG    *dp;
  1694. X
  1695. X    /* if digraphs are disabled, then just return the new char */
  1696. X    if (!*o_digraph)
  1697. X    {
  1698. X        return key2;
  1699. X    }
  1700. X
  1701. X    /* remember the new key, so we can return it if this isn't a digraph */
  1702. X    newkey = key2;
  1703. X
  1704. X    /* sort key1 and key2, so that their original order won't matter */
  1705. X    if (key1 > key2)
  1706. X    {
  1707. X        key2 = key1;
  1708. X        key1 = newkey;
  1709. X    }
  1710. X
  1711. X    /* scan through the digraph chart */
  1712. X    for (dp = digs;
  1713. X         dp && (dp->key1 != key1 || dp->key2 != key2);
  1714. X         dp = dp->next)
  1715. X    {
  1716. X    }
  1717. X
  1718. X    /* if this combination isn't in there, just use the new key */
  1719. X    if (!dp)
  1720. X    {
  1721. X        return newkey;
  1722. X    }
  1723. X
  1724. X    /* else use the digraph key */
  1725. X    return dp->dig;
  1726. X}
  1727. X
  1728. X/* this function lists or defines digraphs */
  1729. Xvoid do_digraph(bang, extra)
  1730. X    int    bang;
  1731. X    char    extra[];
  1732. X{
  1733. X    int        dig;
  1734. X    REG struct _DIG    *dp;
  1735. X    struct _DIG    *prev;
  1736. X    static int    user_defined = FALSE; /* boolean: are all later digraphs user-defined? */
  1737. X    char        listbuf[8];
  1738. X
  1739. X    /* if "extra" is NULL, then we've reached the end of the built-ins */
  1740. X    if (!extra)
  1741. X    {
  1742. X        user_defined = TRUE;
  1743. X        return;
  1744. X    }
  1745. X
  1746. X    /* if no args, then display the existing digraphs */
  1747. X    if (*extra < ' ')
  1748. X    {
  1749. X        listbuf[0] = listbuf[1] = listbuf[2] = listbuf[5] = ' ';
  1750. X        listbuf[7] = '\0';
  1751. X        for (dig = 0, dp = digs; dp; dp = dp->next)
  1752. X        {
  1753. X            if (dp->save || bang)
  1754. X            {
  1755. X                dig += 7;
  1756. X                if (dig >= COLS)
  1757. X                {
  1758. X                    addch('\n');
  1759. X                    exrefresh();
  1760. X                    dig = 7;
  1761. X                }
  1762. X                listbuf[3] = dp->key1;
  1763. X                listbuf[4] = dp->key2;
  1764. X                listbuf[6] = dp->dig;
  1765. X                qaddstr(listbuf);
  1766. X            }
  1767. X        }
  1768. X        addch('\n');
  1769. X        exrefresh();
  1770. X        return;
  1771. X    }
  1772. X
  1773. X    /* make sure we have at least two characters */
  1774. X    if (!extra[1])
  1775. X    {
  1776. X        msg("Digraphs must be composed of two characters");
  1777. X        return;
  1778. X    }
  1779. X
  1780. X    /* sort key1 and key2, so that their original order won't matter */
  1781. X    if (extra[0] > extra[1])
  1782. X    {
  1783. X        dig = extra[0];
  1784. X        extra[0] = extra[1];
  1785. X        extra[1] = dig;
  1786. X    }
  1787. X
  1788. X    /* locate the new digraph character */
  1789. X    for (dig = 2; extra[dig] == ' ' || extra[dig] == '\t'; dig++)
  1790. X    {
  1791. X    }
  1792. X    dig = extra[dig];
  1793. X    if (!bang && dig)
  1794. X    {
  1795. X        dig |= 0x80;
  1796. X    }
  1797. X
  1798. X    /* search for the digraph */
  1799. X    for (prev = (struct _DIG *)0, dp = digs;
  1800. X         dp && (dp->key1 != extra[0] || dp->key2 != extra[1]);
  1801. X         prev = dp, dp = dp->next)
  1802. X    {
  1803. X    }
  1804. X
  1805. X    /* deleting the digraph? */
  1806. X    if (!dig)
  1807. X    {
  1808. X        if (!dp)
  1809. X        {
  1810. X#ifndef CRUNCH
  1811. X            msg("%c%c not a digraph", extra[0], extra[1]);
  1812. X#endif
  1813. X            return;
  1814. X        }
  1815. X        if (prev)
  1816. X            prev->next = dp->next;
  1817. X        else
  1818. X            digs = dp->next;
  1819. X        free(dp);
  1820. X        return;
  1821. X    }
  1822. X
  1823. X    /* if necessary, create a new digraph struct for the new digraph */
  1824. X    if (dig && !dp)
  1825. X    {
  1826. X        dp = (struct _DIG *)malloc(sizeof *dp);
  1827. X        if (!dp)
  1828. X        {
  1829. X            msg("Out of space in the digraph table");
  1830. X            return;
  1831. X        }
  1832. X        if (prev)
  1833. X            prev->next = dp;
  1834. X        else
  1835. X            digs = dp;
  1836. X        dp->next = (struct _DIG *)0;
  1837. X    }
  1838. X
  1839. X    /* assign it the new digraph value */
  1840. X    dp->key1 = extra[0];
  1841. X    dp->key2 = extra[1];
  1842. X    dp->dig = dig;
  1843. X    dp->save = user_defined;
  1844. X}
  1845. X
  1846. X# ifndef NO_MKEXRC
  1847. Xvoid savedigs(fd)
  1848. X    int        fd;
  1849. X{
  1850. X    static char    buf[] = "digraph! XX Y\n";
  1851. X    REG struct _DIG    *dp;
  1852. X
  1853. X    for (dp = digs; dp; dp = dp->next)
  1854. X    {
  1855. X        if (dp->save)
  1856. X        {
  1857. X            buf[9] = dp->key1;
  1858. X            buf[10] = dp->key2;
  1859. X            buf[12] = dp->dig;
  1860. X            write(fd, buf, (unsigned)14);
  1861. X        }
  1862. X    }
  1863. X}
  1864. X# endif
  1865. X#endif
  1866. X
  1867. X
  1868. X#ifndef NO_ABBR
  1869. Xstatic struct _AB
  1870. X{
  1871. X    struct _AB    *next;
  1872. X    char        *large;        /* the expanded form */
  1873. X    char        small[1];    /* the abbreviated form (appended to struct) */
  1874. X}
  1875. X    *abbrev;
  1876. X
  1877. X/* This functions lists or defines abbreviations */
  1878. Xvoid do_abbr(extra)
  1879. X    char    *extra;
  1880. X{
  1881. X    int        smlen;    /* length of the small form */
  1882. X    int        lrg;    /* index of the start of the large form */
  1883. X    REG struct _AB    *ab;    /* used to move through the abbrev list */
  1884. X    struct _AB    *prev;
  1885. X
  1886. X    /* no arguments? */
  1887. X    if (!*extra)
  1888. X    {
  1889. X        /* list all current abbreviations */
  1890. X        for (ab = abbrev; ab; ab = ab->next)
  1891. X        {
  1892. X            qaddstr("abbr ");
  1893. X            qaddstr(ab->small);
  1894. X            qaddch(' ');
  1895. X            qaddstr(ab->large);
  1896. X            addch('\n');
  1897. X            exrefresh();
  1898. X        }
  1899. X        return;
  1900. X    }
  1901. X
  1902. X    /* else one or more arguments.  Parse the first & look up in abbrev[] */
  1903. X    for (smlen = 0; extra[smlen] && isalnum(extra[smlen]); smlen++)
  1904. X    {
  1905. X    }
  1906. X    for (prev = (struct _AB *)0, ab = abbrev; ab; prev = ab, ab = ab->next)
  1907. X    {
  1908. X        if (!strncmp(extra, ab->small, smlen) && !ab->small[smlen])
  1909. X        {
  1910. X            break;
  1911. X        }
  1912. X    }
  1913. X
  1914. X    /* locate the start of the large form, if any */
  1915. X    for (lrg = smlen; extra[lrg] && isascii(extra[lrg]) && isspace(extra[lrg]); lrg++)
  1916. X    {
  1917. X    }
  1918. X
  1919. X    /* only one arg? */
  1920. X    if (!extra[lrg])
  1921. X    {
  1922. X        /* trying to undo an abbreviation which doesn't exist? */
  1923. X        if (!ab)
  1924. X        {
  1925. X#ifndef CRUNCH
  1926. X            msg("\"%s\" not an abbreviation", extra);
  1927. X#endif
  1928. X            return;
  1929. X        }
  1930. X
  1931. X        /* undo the abbreviation */
  1932. X        if (prev)
  1933. X            prev->next = ab->next;
  1934. X        else
  1935. X            abbrev = ab->next;
  1936. X        free(ab->large);
  1937. X        free(ab);
  1938. X
  1939. X        return;
  1940. X    }
  1941. X
  1942. X    /* multiple args - [re]define an abbreviation */
  1943. X    if (ab)
  1944. X    {
  1945. X        /* redefining - free the old large form */
  1946. X        free(ab->large);
  1947. X    }
  1948. X    else
  1949. X    {
  1950. X        /* adding a new definition - make a new struct */
  1951. X        ab = (struct _AB *)malloc((unsigned)(smlen + sizeof *ab));
  1952. X#ifndef CRUNCH
  1953. X        if (!ab)
  1954. X        {
  1955. X            msg("Out of memory -- Sorry");
  1956. X            return;
  1957. X        }
  1958. X#endif
  1959. X        strncpy(ab->small, extra, smlen);
  1960. X        ab->small[smlen] = '\0';
  1961. X        ab->next = (struct _AB *)0;
  1962. X        if (prev)
  1963. X            prev->next = ab;
  1964. X        else
  1965. X            abbrev = ab;
  1966. X    }
  1967. X
  1968. X    /* store the new form */
  1969. X    ab->large = (char *)malloc((unsigned)(strlen(&extra[lrg]) + 1));
  1970. X    strcpy(ab->large, &extra[lrg]);
  1971. X}
  1972. X
  1973. X
  1974. X# ifndef NO_MKEXRC
  1975. X/* This function is called from cmd_mkexrc() to save the abbreviations */
  1976. Xvoid saveabbr(fd)
  1977. X    int    fd;    /* fd to which the :abbr commands should be written */
  1978. X{
  1979. X    REG struct _AB    *ab;
  1980. X
  1981. X    for (ab = abbrev; ab; ab = ab->next)
  1982. X    {
  1983. X        twrite(fd, "abbr ", 5);
  1984. X        twrite(fd, ab->small, strlen(ab->small));
  1985. X        twrite(fd, " ", 1);
  1986. X        twrite(fd, ab->large, strlen(ab->large));
  1987. X        twrite(fd, "\n", 1);
  1988. X    }
  1989. X}
  1990. X# endif
  1991. X
  1992. X/* This function should be called before each char is inserted.  If the next
  1993. X * char is non-alphanumeric and we're at the end of a word, then that word
  1994. X * is checked against the abbrev[] array and expanded, if appropriate.  Upon
  1995. X * returning from this function, the new char still must be inserted.
  1996. X */
  1997. Xstatic MARK expandabbr(m, ch)
  1998. X    MARK        m;    /* the cursor position */
  1999. X    int        ch;    /* the character to insert */
  2000. X{
  2001. X    char        *word;    /* where the word starts */
  2002. X    int        len;    /* length of the word */
  2003. X    REG struct _AB    *ab;
  2004. X
  2005. X    /* if no abbreviations are in effect, or ch is aphanumeric, then
  2006. X     * don't do anything
  2007. X     */
  2008. X    if (!abbrev || !isascii(ch) || isalnum(ch))
  2009. X    {
  2010. X        return m;
  2011. X    }
  2012. X
  2013. X    /* see where the preceding word starts */
  2014. X    pfetch(markline(m));
  2015. X    for (word = ptext + markidx(m), len = 0;
  2016. X         --word >= ptext && (!isascii(*word) || isalnum(*word));
  2017. X         len++)
  2018. X    {
  2019. X    }
  2020. X    word++;
  2021. X
  2022. X    /* if zero-length, then it isn't a word, really -- so nothing */
  2023. X    if (len == 0)
  2024. X    {
  2025. X        return m;
  2026. X    }
  2027. X
  2028. X    /* look it up in the abbrev list */
  2029. X    for (ab = abbrev; ab; ab = ab->next)
  2030. X    {
  2031. X        if (!strncmp(ab->small, word, len) && !ab->small[len])
  2032. X        {
  2033. X            break;
  2034. X        }
  2035. X    }
  2036. X
  2037. X    /* not an abbreviation? then do nothing */
  2038. X    if (!ab)
  2039. X    {
  2040. X        return m;
  2041. X    }
  2042. X
  2043. X    /* else replace the small form with the large form */
  2044. X    add(m, ab->large);
  2045. X    delete(m - len, m);
  2046. X
  2047. X    /* return with the cursor after the end of the large form */
  2048. X    return m - len + strlen(ab->large);
  2049. X}
  2050. X#endif
  2051. X
  2052. X        
  2053. X/* This function allows the user to replace an existing (possibly zero-length)
  2054. X * chunk of text with typed-in text.  It returns the MARK of the last character
  2055. X * that the user typed in.
  2056. X */
  2057. XMARK input(from, to, when)
  2058. X    MARK    from;    /* where to start inserting text */
  2059. X    MARK    to;    /* extent of text to delete */
  2060. X    int    when;    /* either WHEN_VIINP or WHEN_VIREP */
  2061. X{
  2062. X    char    key[2];    /* key char followed by '\0' char */
  2063. X    char    *build;    /* used in building a newline+indent string */
  2064. X    char    *scan;    /* used while looking at the indent chars of a line */
  2065. X    MARK    m;    /* some place in the text */
  2066. X#ifndef NO_EXTENSIONS
  2067. X    int    quit = FALSE;    /* boolean: are we exiting after this? */
  2068. X#endif
  2069. X
  2070. X#ifdef DEBUG
  2071. X    /* if "from" and "to" are reversed, complain */
  2072. X    if (from > to)
  2073. X    {
  2074. X        msg("ERROR: input(%ld:%d, %ld:%d)",
  2075. X            markline(from), markidx(from),
  2076. X            markline(to), markidx(to));
  2077. X        return MARK_UNSET;
  2078. X    }
  2079. X#endif
  2080. X
  2081. X    key[1] = 0;
  2082. X
  2083. X    /* if we're replacing text with new text, save the old stuff */
  2084. X    /* (Alas, there is no easy way to save text for replace mode) */
  2085. X    if (from != to)
  2086. X    {
  2087. X        cut(from, to);
  2088. X    }
  2089. X
  2090. X    ChangeText
  2091. X    {
  2092. X        /* if doing a dot command, then reuse the previous text */
  2093. X        if (doingdot)
  2094. X        {
  2095. X            /* delete the text that's there now */
  2096. X            if (from != to)
  2097. X            {
  2098. X                delete(from, to);
  2099. X            }
  2100. X
  2101. X            /* insert the previous text */
  2102. X            cutname('.');
  2103. X            cursor = paste(from, FALSE, TRUE) + 1L;
  2104. X        }
  2105. X        else /* interactive version */
  2106. X        {
  2107. X            /* if doing a change within the line... */
  2108. X            if (from != to && markline(from) == markline(to))
  2109. X            {
  2110. X                /* mark the end of the text with a "$" */
  2111. X                change(to - 1, to, "$");
  2112. X            }
  2113. X            else
  2114. X            {
  2115. X                /* delete the old text right off */
  2116. X                if (from != to)
  2117. X                {
  2118. X                    delete(from, to);
  2119. X                }
  2120. X                to = from;
  2121. X            }
  2122. X
  2123. X            /* handle autoindent of the first line, maybe */
  2124. X            cursor = from;
  2125. X            if (*o_autoindent && markline(cursor) > 1L && markidx(cursor) == 0)
  2126. X            {
  2127. X                /* Only autoindent blank lines. */
  2128. X                pfetch(markline(cursor));
  2129. X                if (plen == 0)
  2130. X                {
  2131. X                    /* Okay, we really want to autoindent */
  2132. X                    pfetch(markline(cursor) - 1L);
  2133. X                    for (scan = ptext, build = tmpblk.c;
  2134. X                         *scan == ' ' || *scan == '\t';
  2135. X                         )
  2136. X                    {
  2137. X                        *build++ = *scan++;
  2138. X                    }
  2139. X                    if (build > tmpblk.c)
  2140. X                    {
  2141. X                        *build = '\0';
  2142. X                        add(cursor, tmpblk.c);
  2143. X                        cursor += (build - tmpblk.c);
  2144. X                    }
  2145. X                }
  2146. X            }
  2147. X
  2148. X            /* repeatedly add characters from the user */
  2149. X            for (;;)
  2150. X            {
  2151. X                /* Get a character */
  2152. X                redraw(cursor, TRUE);
  2153. X#ifdef DEBUG
  2154. X                msg("cursor=%ld.%d, to=%ld.%d",
  2155. X                    markline(cursor), markidx(cursor),
  2156. X                    markline(to), markidx(to));
  2157. X#endif
  2158. X                key[0] = getkey(when);
  2159. X
  2160. X                /* if whitespace & wrapmargin is set & we're
  2161. X                 * past the warpmargin, then change the
  2162. X                 * whitespace character into a newline
  2163. X                 */
  2164. X                if ((*key == ' ' || *key == '\t')
  2165. X                 && *o_wrapmargin != 0)
  2166. X                {
  2167. X                    pfetch(markline(cursor));
  2168. X                    if (idx2col(cursor, ptext, TRUE) > COLS - (*o_wrapmargin & 0xff))
  2169. X                    {
  2170. X                        *key = '\n';
  2171. X                    }
  2172. X                }
  2173. X
  2174. X                /* process it */
  2175. X                switch (*key)
  2176. X                {
  2177. X#ifndef NO_EXTENSIONS
  2178. X                  case 0: /* special movement mapped keys */
  2179. X                    *key = getkey(0);
  2180. X                    switch (*key)
  2181. X                    {
  2182. X                      case 'h':    m = m_left(cursor, 0L);        break;
  2183. X                      case 'j':
  2184. X                      case 'k':    m = m_updnto(cursor, 0L, *key);    break;
  2185. X                      case 'l':    m = cursor + 1;            break;
  2186. X                      case 'b':    m = m_bword(cursor, 0L);    break;
  2187. X                      case 'w':    m = m_fword(cursor, 0L);    break;
  2188. X                      case '^':    m = m_front(cursor, 0L);    break;
  2189. X                      case '$':    m = m_rear(cursor, 0L);        break;
  2190. X                      case ctrl('B'):
  2191. X                      case ctrl('F'):
  2192. X                            m = m_scroll(cursor, 0L, *key); break;
  2193. X                      case 'x':    m = v_xchar(cursor, 0L);    break;
  2194. X                      case 'i':    m = to = from = cursor;        break;
  2195. X                      default:    m = MARK_UNSET;            break;
  2196. X                    }
  2197. X                    /* adjust the moved cursor */
  2198. X                    m = adjmove(cursor, m, (*key == 'j' || *key == 'k' ? 0x20 : 0));
  2199. X                    if (*key == '$' || (*key == 'l' && m <= cursor))
  2200. X                    {
  2201. X                        m++;
  2202. X                    }
  2203. X                    /* if the cursor is reasonable, use it */
  2204. X                    if (m == MARK_UNSET)
  2205. X                    {
  2206. X                        beep();
  2207. X                    }
  2208. X                    else
  2209. X                    {
  2210. X                        if (to > cursor)
  2211. X                        {
  2212. X                            delete(cursor, to);
  2213. X                            redraw(cursor, TRUE);
  2214. X                        }
  2215. X                        from = to = cursor = m;
  2216. X                    }
  2217. X                    break;
  2218. X
  2219. X                  case ctrl('Z'):
  2220. X                    if (getkey(0) == ctrl('Z'))
  2221. X                    {
  2222. X                        quit = TRUE;
  2223. X                        goto BreakBreak;
  2224. X                    }
  2225. X                    break;
  2226. X#endif
  2227. X
  2228. X                  case ctrl('['):
  2229. X#ifndef NO_ABBR
  2230. X                    cursor = expandabbr(cursor, ctrl('['));
  2231. X#endif
  2232. X                    goto BreakBreak;
  2233. X
  2234. X                  case ctrl('U'):
  2235. X                    if (markline(cursor) == markline(from))
  2236. X                    {
  2237. X                        cursor = from;
  2238. X                    }
  2239. X                    else
  2240. X                    {
  2241. X                        cursor &= ~(BLKSIZE - 1);
  2242. X                    }
  2243. X                    break;
  2244. X
  2245. X                  case ctrl('D'):
  2246. X                  case ctrl('T'):
  2247. X                    if (to > cursor)
  2248. X                    {
  2249. X                        delete(cursor, to);
  2250. X                    }
  2251. X                    mark[27] = cursor;
  2252. X                    cmd_shift(cursor, cursor, *key == ctrl('D') ? CMD_SHIFTL : CMD_SHIFTR, TRUE, "");
  2253. X                    if (mark[27])
  2254. X                    {
  2255. X                        cursor = mark[27];
  2256. X                    }
  2257. X                    else
  2258. X                    {
  2259. X                        cursor = m_front(cursor, 0L);
  2260. X                    }
  2261. X                    to = cursor;
  2262. X                    break;
  2263. X
  2264. X                  case '\b':
  2265. X                    if (cursor <= from)
  2266. X                    {
  2267. X                        beep();
  2268. X                    }
  2269. X                    else if (markidx(cursor) == 0)
  2270. X                    {
  2271. X                        cursor -= BLKSIZE;
  2272. X                        pfetch(markline(cursor));
  2273. X                        cursor += plen;
  2274. X                    }
  2275. X                    else
  2276. X                    {
  2277. X                        cursor--;
  2278. X                    }
  2279. X                    break;
  2280. X
  2281. X                  case ctrl('W'):
  2282. X                    m = m_bword(cursor, 1L);
  2283. X                    if (markline(m) == markline(cursor) && m >= from)
  2284. X                    {
  2285. X                        cursor = m;
  2286. X                        if (from > cursor)
  2287. X                        {
  2288. X                            from = cursor;
  2289. X                        }
  2290. X                    }
  2291. X                    else
  2292. X                    {
  2293. X                        beep();
  2294. X                    }
  2295. X                    break;
  2296. X
  2297. X                  case '\n':
  2298. X#if OSK
  2299. X                  case '\l':
  2300. X#else                  
  2301. X                  case '\r':
  2302. X#endif
  2303. X#ifndef NO_ABBR
  2304. X                    cursor = expandabbr(cursor, '\n');
  2305. X#endif
  2306. X                    build = tmpblk.c;
  2307. X                    *build++ = '\n';
  2308. X                    if (*o_autoindent)
  2309. X                    {
  2310. X                        /* figure out indent for next line */
  2311. X                        pfetch(markline(cursor));
  2312. X                        for (scan = ptext; *scan == ' ' || *scan == '\t'; )
  2313. X                        {
  2314. X                            *build++ = *scan++;
  2315. X                        }
  2316. X
  2317. X                        /* remove indent from this line, if blank */
  2318. X                        if (!*scan && plen > 0)
  2319. X                        {
  2320. X                            to = cursor &= ~(BLKSIZE - 1);
  2321. X                            delete(cursor, cursor + plen);
  2322. X                        }
  2323. X                    }
  2324. X                    *build = 0;
  2325. X                    if (cursor >= to && when != WHEN_VIREP)
  2326. X                    {
  2327. X                        add(cursor, tmpblk.c);
  2328. X                    }
  2329. X                    else
  2330. X                    {
  2331. X                        change(cursor, to, tmpblk.c);
  2332. X                    }
  2333. X                    redraw(cursor, TRUE);
  2334. X                    to = cursor = (cursor & ~(BLKSIZE - 1))
  2335. X                            + BLKSIZE
  2336. X                            + (int)(build - tmpblk.c) - 1;
  2337. X                    break;
  2338. X
  2339. X                  case ctrl('A'):
  2340. X                  case ctrl('P'):
  2341. X                    if (cursor < to)
  2342. X                    {
  2343. X                        delete(cursor, to);
  2344. X                    }
  2345. X                    if (*key == ctrl('A'))
  2346. X                    {
  2347. X                        cutname('.');
  2348. X                    }
  2349. X                    to = cursor = paste(cursor, FALSE, TRUE) + 1L;
  2350. X                    break;
  2351. X
  2352. X                  case ctrl('V'):
  2353. X                    if (cursor >= to && when != WHEN_VIREP)
  2354. X                    {
  2355. X                        add(cursor, "^");
  2356. X                    }
  2357. X                    else
  2358. X                    {
  2359. X                        change(cursor, to, "^");
  2360. X                        to = cursor + 1;
  2361. X                    }
  2362. X                    redraw(cursor, TRUE);
  2363. X                    *key = getkey(0);
  2364. X                    if (*key == '\n')
  2365. X                    {
  2366. X                        /* '\n' too hard to handle */
  2367. X#if OSK
  2368. X                        *key = '\l';
  2369. X#else
  2370. X                        *key = '\r';
  2371. X#endif
  2372. X                    }
  2373. X                    change(cursor, cursor + 1, key);
  2374. X                    cursor++;
  2375. X                    if (cursor > to)
  2376. X                    {
  2377. X                        to = cursor;
  2378. X                    }
  2379. X                    break;
  2380. X
  2381. X                  case ctrl('L'):
  2382. X                  case ctrl('R'):
  2383. X                    redraw(MARK_UNSET, FALSE);
  2384. X                    break;
  2385. X
  2386. X                  default:
  2387. X                    if (cursor >= to && when != WHEN_VIREP)
  2388. X                    {
  2389. X#ifndef NO_ABBR
  2390. X                        cursor = expandabbr(cursor, *key);
  2391. X#endif
  2392. X                        add(cursor, key);
  2393. X                        cursor++;
  2394. X                        to = cursor;
  2395. X                    }
  2396. X                    else
  2397. X                    {
  2398. X                        pfetch(markline(cursor));
  2399. X                        if (markidx(cursor) == plen)
  2400. X                        {
  2401. X#ifndef NO_ABBR
  2402. X                            cursor = expandabbr(cursor, *key);
  2403. X#endif
  2404. X                            add(cursor, key);
  2405. X                        }
  2406. X                        else
  2407. X                        {
  2408. X#ifndef NO_DIGRAPH
  2409. X                            *key = digraph(ptext[markidx(cursor)], *key);
  2410. X#endif
  2411. X#ifndef NO_ABBR
  2412. X                            cursor = expandabbr(cursor, *key);
  2413. X#endif
  2414. X                            change(cursor, cursor + 1, key);
  2415. X                        }
  2416. X                        cursor++;
  2417. X                    }
  2418. X#ifndef NO_SHOWMATCH
  2419. X                    /* show matching "({[" if neceesary */
  2420. X                    if (*o_showmatch && strchr(")}]", *key))
  2421. X                    {
  2422. X                        redraw(cursor, TRUE);
  2423. X                        m = m_match(cursor - 1, 0L);
  2424. X                        if (markline(m) >= topline
  2425. X                         && markline(m) <= botline)
  2426. X                        {
  2427. X                            redraw(m, TRUE);
  2428. X                            refresh();
  2429. X                            sleep(1);
  2430. X                        }
  2431. X                    }
  2432. X#endif
  2433. X                } /* end switch(*key) */
  2434. X            } /* end for(;;) */
  2435. XBreakBreak:;
  2436. X
  2437. X            /* delete any excess characters */
  2438. X            if (cursor < to)
  2439. X            {
  2440. X                delete(cursor, to);
  2441. X            }
  2442. X
  2443. X        } /* end if doingdot else */
  2444. X
  2445. X    } /* end ChangeText */
  2446. X
  2447. X    /* put the new text into a cut buffer for possible reuse */
  2448. X    if (!doingdot)
  2449. X    {
  2450. X        blksync();
  2451. X        cutname('.');
  2452. X        cut(from, cursor);
  2453. X    }
  2454. X
  2455. X    /* move to last char that we inputted, unless it was newline */
  2456. X    if (markidx(cursor) != 0)
  2457. X    {
  2458. X        cursor--;
  2459. X    }
  2460. X    redraw(cursor, FALSE);
  2461. X
  2462. X#ifndef NO_EXTENSIONS
  2463. X    if (quit)
  2464. X    {
  2465. X        /* if this is a nested "do", then cut it short */
  2466. X        abortdo();
  2467. X
  2468. X        /* exit, unless we can't write out the file */
  2469. X        cursor = v_xit(cursor, 0L, 'Z');
  2470. X    }
  2471. X#endif
  2472. X
  2473. X    rptlines = 0L;
  2474. X    return cursor;
  2475. X}
  2476. eof
  2477. if test `wc -c <input.c` -ne 16368
  2478. then
  2479. echo input.c damaged!
  2480. fi
  2481. fi
  2482.  
  2483. if test -f main.c -a "$1" != -f
  2484. then
  2485. echo Will not overwrite main.c
  2486. else
  2487. echo Extracting main.c
  2488. sed 's/^X//' >main.c <<\eof
  2489. X/* main.c */
  2490. X
  2491. X/* Author:
  2492. X *    Steve Kirkendall
  2493. X *    14407 SW Teal Blvd. #C
  2494. X *    Beaverton, OR 97005
  2495. X *    kirkenda@cs.pdx.edu
  2496. X */
  2497. X
  2498. X
  2499. X/* This file contains the main() function of vi */
  2500. X
  2501. X#include "config.h"
  2502. X#include <signal.h>
  2503. X#include <setjmp.h>
  2504. X#include "vi.h"
  2505. X
  2506. Xextern        trapint(); /* defined below */
  2507. Xextern char    *getenv();
  2508. Xjmp_buf        jmpenv;
  2509. X
  2510. X#ifndef NO_DIGRAPH
  2511. Xstatic init_digraphs();
  2512. X#endif
  2513. X
  2514. X/*---------------------------------------------------------------------*/
  2515. X
  2516. Xvoid main(argc, argv)
  2517. X    int    argc;
  2518. X    char    *argv[];
  2519. X{
  2520. X    int    i;
  2521. X    char    *cmd = (char *)0;
  2522. X    char    *tag = (char *)0;
  2523. X    char    *err = (char *)0;
  2524. X    char    *str;
  2525. X#if MSDOS || TOS
  2526. X    char firstarg[256];
  2527. X#else
  2528. X    char *firstarg;
  2529. X#endif
  2530. X
  2531. X    /* set mode to MODE_VI or MODE_EX depending on program name */
  2532. X    switch (argv[0][strlen(argv[0]) - 1])
  2533. X    {
  2534. X      case 'x':            /* "ex" */
  2535. X        mode = MODE_EX;
  2536. X        break;
  2537. X
  2538. X      case 'w':            /* "view" */
  2539. X        mode = MODE_VI;
  2540. X        *o_readonly = TRUE;
  2541. X        break;
  2542. X#ifndef NO_EXTENSIONS
  2543. X      case 't':            /* "edit" or "input" */
  2544. X        mode = MODE_VI;
  2545. X        *o_inputmode = TRUE;
  2546. X        break;
  2547. X#endif
  2548. X      default:            /* "vi" or "elvis" */
  2549. X        mode = MODE_VI;
  2550. X    }
  2551. X
  2552. X#ifndef DEBUG
  2553. X# ifdef    SIGQUIT
  2554. X    /* normally, we ignore SIGQUIT.  SIGINT is trapped later */
  2555. X    signal(SIGQUIT, SIG_IGN);
  2556. X# endif
  2557. X#endif
  2558. X
  2559. X    /* temporarily ignore SIGINT */
  2560. X    signal(SIGINT, SIG_IGN);
  2561. X
  2562. X    /* start curses */
  2563. X    initscr();
  2564. X    cbreak();
  2565. X    noecho();
  2566. X    scrollok(stdscr, TRUE);
  2567. X
  2568. X    /* initialize the options */
  2569. X    initopts();
  2570. X
  2571. X    /* map the arrow keys.  The KU,KD,KL,and KR variables correspond to
  2572. X     * the :ku=: (etc.) termcap capabilities.  The variables are defined
  2573. X     * as part of the curses package.
  2574. X     */
  2575. X    if (has_KU) mapkey(has_KU, "k",    WHEN_VICMD|WHEN_INMV, "<Up>");
  2576. X    if (has_KD) mapkey(has_KD, "j",    WHEN_VICMD|WHEN_INMV, "<Down>");
  2577. X    if (has_KL) mapkey(has_KL, "h",    WHEN_VICMD|WHEN_INMV, "<Left>");
  2578. X    if (has_KR) mapkey(has_KR, "l",    WHEN_VICMD|WHEN_INMV, "<Right>");
  2579. X    if (has_HM) mapkey(has_HM, "^",    WHEN_VICMD|WHEN_INMV, "<Home>");
  2580. X    if (has_EN) mapkey(has_EN, "$",    WHEN_VICMD|WHEN_INMV, "<End>");
  2581. X    if (has_PU) mapkey(has_PU, "\002", WHEN_VICMD|WHEN_INMV, "<PgUp>");
  2582. X    if (has_PD) mapkey(has_PD, "\006", WHEN_VICMD|WHEN_INMV, "<PgDn>");
  2583. X#if MSDOS
  2584. X    if (*o_pcbios)
  2585. X    {
  2586. X        mapkey("#R", "i", WHEN_VICMD|WHEN_INMV,    "<Insrt>");
  2587. X        mapkey("#S", "x", WHEN_VICMD|WHEN_INMV,    "<Del>");
  2588. X        mapkey("#s", "B", WHEN_VICMD|WHEN_INMV,    "^<left>");
  2589. X        mapkey("#t", "W", WHEN_VICMD|WHEN_INMV,    "^<right>");
  2590. X    }
  2591. X#else
  2592. X    if (ERASEKEY != '\177')
  2593. X    {
  2594. X        mapkey("\177", "x", WHEN_VICMD|WHEN_INMV, "<Del>");
  2595. X    }
  2596. X#endif
  2597. X
  2598. X#ifndef NO_DIGRAPH
  2599. X    init_digraphs();
  2600. X#endif /* NO_DIGRAPH */
  2601. X
  2602. X    /* process any flags */
  2603. X    for (i = 1; i < argc && *argv[i] == '-'; i++)
  2604. X    {
  2605. X        switch (argv[i][1])
  2606. X        {
  2607. X          case 'R':    /* readonly */
  2608. X            *o_readonly = TRUE;
  2609. X            break;
  2610. X
  2611. X          case 'r':    /* recover */
  2612. X            msg("Use the `virec` program to recover lost files");
  2613. X            endmsgs();
  2614. X            refresh();
  2615. X            endwin();
  2616. X            exit(0);
  2617. X            break;
  2618. X
  2619. X          case 't':    /* tag */
  2620. X            if (argv[i][2])
  2621. X            {
  2622. X                tag = argv[i] + 2;
  2623. X            }
  2624. X            else
  2625. X            {
  2626. X                i++;
  2627. X                tag = argv[i];
  2628. X            }
  2629. X            break;
  2630. X
  2631. X          case 'v':    /* vi mode */
  2632. X            mode = MODE_VI;
  2633. X            break;
  2634. X
  2635. X          case 'e':    /* ex mode */
  2636. X            mode = MODE_EX;
  2637. X            break;
  2638. X#ifndef NO_EXTENSIONS
  2639. X          case 'i':    /* input mode */
  2640. X            *o_inputmode = TRUE;
  2641. X            break;
  2642. X#endif
  2643. X#ifndef NO_ERRLIST
  2644. X          case 'm':    /* use "errlist" as the errlist */
  2645. X            if (argv[i][2])
  2646. X            {
  2647. X                err = argv[i] + 2;
  2648. X            }
  2649. X            else if (i + 1 < argc)
  2650. X            {
  2651. X                i++;
  2652. X                err = argv[i];
  2653. X            }
  2654. X            else
  2655. X            {
  2656. X                err = "";
  2657. X            }
  2658. X            break;
  2659. X#endif
  2660. X          default:
  2661. X            msg("Ignoring unknown flag \"%s\"", argv[i]);
  2662. X        }
  2663. X    }
  2664. X
  2665. X    /* if we were given an initial ex command, save it... */
  2666. X    if (i < argc && *argv[i] == '+')
  2667. X    {
  2668. X        if (argv[i][1])
  2669. X        {
  2670. X            cmd = argv[i++] + 1;
  2671. X        }
  2672. X        else
  2673. X        {
  2674. X            cmd = "$"; /* "vi + file" means start at EOF */
  2675. X            i++;
  2676. X        }
  2677. X    }
  2678. X
  2679. X    /* the remaining args are file names. */
  2680. X    nargs = argc - i;
  2681. X    if (nargs > 0)
  2682. X    {
  2683. X#if ! ( MSDOS || TOS )
  2684. X        firstarg = argv[i];
  2685. X#endif
  2686. X        strcpy(args, argv[i]);
  2687. X        while (++i < argc && strlen(args) + 1 + strlen(argv[i]) < sizeof args)
  2688. X        {
  2689. X            strcat(args, " ");
  2690. X            strcat(args, argv[i]);
  2691. X        }
  2692. X    }
  2693. X#if ! ( MSDOS || TOS )
  2694. X    else
  2695. X    {
  2696. X        firstarg = "";
  2697. X    }
  2698. X#endif
  2699. X    argno = 0;
  2700. X
  2701. X#if MSDOS || TOS
  2702. X    if (nargs > 0)
  2703. X    {
  2704. X        strcpy(args, wildcard(args));
  2705. X        nargs = 1;
  2706. X        for (i = 0; args[i]; i++)
  2707. X        {
  2708. X            if (args[i] == ' ')
  2709. X            {
  2710. X                nargs++;
  2711. X            }
  2712. X        }
  2713. X        for (i = 0; args[i] && args[i] != ' '; i++)
  2714. X        {
  2715. X            firstarg[i] = args[i];
  2716. X        }
  2717. X        firstarg[i] = '\0';
  2718. X    }
  2719. X    else
  2720. X    {
  2721. X        firstarg[0] = '\0';
  2722. X    }
  2723. X#endif
  2724. X
  2725. X    /* perform the .exrc files and EXINIT environment variable */
  2726. X#ifdef SYSEXRC
  2727. X    doexrc(SYSEXRC);
  2728. X#endif
  2729. X#ifdef HMEXRC
  2730. X    str = getenv("HOME");
  2731. X    if (str)
  2732. X    {
  2733. X        sprintf(tmpblk.c, "%s%c%s", str, SLASH, HMEXRC);
  2734. X        doexrc(tmpblk.c);
  2735. X    }
  2736. X#endif
  2737. X    doexrc(EXRC);
  2738. X#ifdef EXINIT
  2739. X    str = getenv(EXINIT);
  2740. X    if (str)
  2741. X    {
  2742. X        exstring(str, strlen(str));
  2743. X    }
  2744. X#endif
  2745. X
  2746. X    /* search for a tag (or an error) now, if desired */
  2747. X    blkinit();
  2748. X    if (tag)
  2749. X    {
  2750. X        cmd_tag(MARK_FIRST, MARK_FIRST, CMD_TAG, 0, tag);
  2751. X    }
  2752. X#ifndef NO_ERRLIST
  2753. X    else if (err)
  2754. X    {
  2755. X        cmd_errlist(MARK_FIRST, MARK_FIRST, CMD_ERRLIST, 0, err);
  2756. X    }
  2757. X#endif
  2758. X
  2759. X    /* if no tag/err, or tag failed, then start with first arg */
  2760. X    if (tmpfd < 0 && tmpstart(firstarg) == 0 && *origname)
  2761. X    {
  2762. X        ChangeText
  2763. X        {
  2764. X        }
  2765. X        clrflag(file, MODIFIED);
  2766. X    }
  2767. X
  2768. X    /* now we do the immediate ex command that we noticed before */
  2769. X    if (cmd)
  2770. X    {
  2771. X        doexcmd(cmd);
  2772. X    }
  2773. X
  2774. X    /* repeatedly call ex() or vi() (depending on the mode) until the
  2775. X     * mode is set to MODE_QUIT
  2776. X     */
  2777. X    while (mode != MODE_QUIT)
  2778. X    {
  2779. X        if (setjmp(jmpenv))
  2780. X        {
  2781. X            /* Maybe we just aborted a change? */
  2782. X            abortdo();
  2783. X        }
  2784. X#if TURBOC
  2785. X        signal(SIGINT, (void(*)()) trapint);
  2786. X#else
  2787. X        signal(SIGINT, trapint);
  2788. X#endif
  2789. X
  2790. X        switch (mode)
  2791. X        {
  2792. X          case MODE_VI:
  2793. X            vi();
  2794. X            break;
  2795. X
  2796. X          case MODE_EX:
  2797. X            ex();
  2798. X            break;
  2799. X#ifdef DEBUG
  2800. X          default:
  2801. X            msg("mode = %d?", mode);
  2802. X            mode = MODE_QUIT;
  2803. X#endif
  2804. X        }
  2805. X    }
  2806. X
  2807. X    /* free up the cut buffers */
  2808. X    cutend();
  2809. X
  2810. X    /* end curses */
  2811. X#ifndef    NO_CURSORSHAPE
  2812. X    if (has_CQ)
  2813. X        do_CQ();
  2814. X#endif
  2815. X    endmsgs();
  2816. X    move(LINES - 1, 0);
  2817. X    clrtoeol();
  2818. X    refresh();
  2819. X    endwin();
  2820. X
  2821. X    exit(0);
  2822. X    /*NOTREACHED*/
  2823. X}
  2824. X
  2825. X
  2826. X/*ARGSUSED*/
  2827. Xint trapint(signo)
  2828. X    int    signo;
  2829. X{
  2830. X    resume_curses(FALSE);
  2831. X    abortdo();
  2832. X#if OSK
  2833. X    sigmask(-1);
  2834. X#endif
  2835. X#if TURBO_C
  2836. X    signal(signo, (void (*)())trapint);
  2837. X#else
  2838. X    signal(signo, trapint);
  2839. X#endif
  2840. X    longjmp(jmpenv, 1);
  2841. X
  2842. X    return 0;
  2843. X}
  2844. X
  2845. X
  2846. X#ifndef NO_DIGRAPH
  2847. X
  2848. X/* This stuff us used to build the default digraphs table. */
  2849. Xstatic char    digtable[][4] =
  2850. X{
  2851. X# if CS_IBMPC
  2852. X    "C,\200",    "u\"\1",    "e'\2",        "a^\3",
  2853. X    "a\"\4",    "a`\5",        "a@\6",        "c,\7",
  2854. X    "e^\10",    "e\"\211",    "e`\12",    "i\"\13",
  2855. X    "i^\14",    "i`\15",    "A\"\16",    "A@\17",
  2856. X    "E'\20",    "ae\21",    "AE\22",    "o^\23",
  2857. X    "o\"\24",    "o`\25",    "u^\26",    "u`\27",
  2858. X    "y\"\30",    "O\"\31",    "U\"\32",    "a'\240",
  2859. X    "i'!",        "o'\"",        "u'#",        "n~$",
  2860. X    "N~%",        "a-&",        "o-'",        "~?(",
  2861. X    "~!-",        "\"<.",        "\">/",
  2862. X#  if CS_SPECIAL
  2863. X    "2/+",        "4/,",        "^+;",        "^q<",
  2864. X    "^c=",        "^r>",        "^t?",        "pp]",
  2865. X    "^^^",        "oo_",        "*a`",        "*ba",
  2866. X    "*pc",        "*Sd",        "*se",        "*uf",
  2867. X    "*tg",        "*Ph",        "*Ti",        "*Oj",
  2868. X    "*dk",        "*Hl",        "*hm",        "*En",
  2869. X    "*No",        "eqp",        "pmq",        "ger",
  2870. X    "les",        "*It",        "*iu",        "*/v",
  2871. X    "*=w",        "sq{",        "^n|",        "^2}",
  2872. X    "^3~",        "^_\377",
  2873. X#  endif /* CS_SPECIAL */
  2874. X# endif /* CS_IBMPC */
  2875. X# if CS_LATIN1
  2876. X    "~!!",        "a-*",        "\">+",        "o-:",
  2877. X    "\"<>",        "~??",
  2878. X
  2879. X    "A`@",        "A'A",        "A^B",        "A~C",
  2880. X    "A\"D",        "A@E",        "AEF",        "C,G",
  2881. X    "E`H",        "E'I",        "E^J",        "E\"K",
  2882. X    "I`L",        "I'M",        "I^N",        "I\"O",
  2883. X    "-DP",        "N~Q",        "O`R",        "O'S",
  2884. X    "O^T",        "O~U",        "O\"V",        "O/X",
  2885. X    "U`Y",        "U'Z",        "U^[",        "U\"\\",
  2886. X    "Y'_",
  2887. X
  2888. X    "a``",        "a'a",        "a^b",        "a~c",
  2889. X    "a\"d",        "a@e",        "aef",        "c,g",
  2890. X    "e`h",        "e'i",        "e^j",        "e\"k",
  2891. X    "i`l",        "i'm",        "i^n",        "i\"o",
  2892. X    "-dp",        "n~q",        "o`r",        "o's",
  2893. X    "o^t",        "o~u",        "o\"v",        "o/x",
  2894. X    "u`y",        "u'z",        "u^{",        "u\"|",
  2895. X    "y'~",
  2896. X# endif /* CS_LATIN1 */
  2897. X    ""
  2898. X};
  2899. X
  2900. Xstatic init_digraphs()
  2901. X{
  2902. X    int    i;
  2903. X
  2904. X    for (i = 0; *digtable[i]; i++)
  2905. X    {
  2906. X        do_digraph(FALSE, digtable[i]);
  2907. X    }
  2908. X    do_digraph(FALSE, (char *)0);
  2909. X}
  2910. X#endif /* NO_DIGRAPH */
  2911. eof
  2912. if test `wc -c <main.c` -ne 7778
  2913. then
  2914. echo main.c damaged!
  2915. fi
  2916. fi
  2917.  
  2918. if test -f misc.c -a "$1" != -f
  2919. then
  2920. echo Will not overwrite misc.c
  2921. else
  2922. echo Extracting misc.c
  2923. sed 's/^X//' >misc.c <<\eof
  2924. X/* misc.c */
  2925. X
  2926. X/* Author:
  2927. X *    Steve Kirkendall
  2928. X *    14407 SW Teal Blvd. #C
  2929. X *    Beaverton, OR 97005
  2930. X *    kirkenda@cs.pdx.edu
  2931. X */
  2932. X
  2933. X
  2934. X/* This file contains functions which didn't seem happy anywhere else */
  2935. X
  2936. X#include "config.h"
  2937. X#include "vi.h"
  2938. X
  2939. X
  2940. X/* find a particular line & return a pointer to a copy of its text */
  2941. Xchar *fetchline(line)
  2942. X    long    line;    /* line number of the line to fetch */
  2943. X{
  2944. X    int        i;
  2945. X    REG char    *scan;    /* used to search for the line in a BLK */
  2946. X    long        l;    /* line number counter */
  2947. X    static BLK    buf;    /* holds ONLY the selected line (as string) */
  2948. X    REG char    *cpy;    /* used while copying the line */
  2949. X    static long    nextline;    /* }  These four variables are used */
  2950. X    static long    chglevel;    /*  } to implement a shortcut when  */
  2951. X    static char    *nextscan;    /*  } consecutive lines are fetched */
  2952. X    static long    nextlnum;    /* }                                */
  2953. X
  2954. X    /* can we do a shortcut? */
  2955. X    if (changes == chglevel && line == nextline)
  2956. X    {
  2957. X        scan = nextscan;
  2958. X    }
  2959. X    else
  2960. X    {
  2961. X        /* scan lnum[] to determine which block its in */
  2962. X        for (i = 1; line > lnum[i]; i++)
  2963. X        {
  2964. X        }
  2965. X        nextlnum = lnum[i];
  2966. X
  2967. X        /* fetch text of the block containing that line */
  2968. X        scan = blkget(i)->c;
  2969. X
  2970. X        /* find the line in the block */
  2971. X        for (l = lnum[i - 1]; ++l < line; )
  2972. X        {
  2973. X            while (*scan++ != '\n')
  2974. X            {
  2975. X            }
  2976. X        }
  2977. X    }
  2978. X
  2979. X    /* copy it into a block by itself, with no newline */
  2980. X    for (cpy = buf.c; *scan != '\n'; )
  2981. X    {
  2982. X        *cpy++ = *scan++;
  2983. X    }
  2984. X    *cpy = '\0';
  2985. X
  2986. X    /* maybe speed up the next call to fetchline() ? */
  2987. X    if (line < nextlnum)
  2988. X    {
  2989. X        nextline = line + 1;
  2990. X        chglevel = changes;
  2991. X        nextscan = scan + 1;
  2992. X    }
  2993. X    else
  2994. X    {
  2995. X        nextline = 0;
  2996. X    }
  2997. X
  2998. X    /* Calls to fetchline() interfere with calls to pfetch().  Make sure
  2999. X     * that pfetch() resets itself on its next invocation.
  3000. X     */
  3001. X    pchgs = 0L;
  3002. X
  3003. X    /* Return a pointer to the line's text */
  3004. X    return buf.c;
  3005. X}
  3006. X
  3007. X
  3008. X/* error message from the regexp code */
  3009. Xvoid regerror(txt)
  3010. X    char    *txt;    /* an error message */
  3011. X{
  3012. X    msg("RE error: %s", txt);
  3013. X}
  3014. X
  3015. X/* This function is equivelent to the pfetch() macro */
  3016. Xvoid    pfetch(l)
  3017. X    long    l;    /* line number of line to fetch */
  3018. X{
  3019. X    if(l != pline || changes != pchgs)
  3020. X    {
  3021. X        pline = (l);
  3022. X        ptext = fetchline(pline);
  3023. X        plen = strlen(ptext);
  3024. X        pchgs = changes;
  3025. X    }
  3026. X}
  3027. eof
  3028. if test `wc -c <misc.c` -ne 2166
  3029. then
  3030. echo misc.c damaged!
  3031. fi
  3032. fi
  3033.  
  3034. exit 0
  3035. -------------------------------------------------------------------------------
  3036. Steve Kirkendall     kirkenda@cs.pdx.edu      Grad student at Portland State U.
  3037.