home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / altsrcs / 3 / 3501 < prev    next >
Internet Message Format  |  1991-06-19  |  56KB
  1. From: pgf@cayman.COM (Paul Fox)
  2. Newsgroups: alt.sources
  3. Subject: Vile 05/17 - vi feel-alike (multi-window)
  4. Message-ID: <4524@cayman.COM>
  5. Date: 7 Jun 91 22:09:27 GMT
  6.  
  7. #!/bin/sh
  8. # this is vileshar.05 (part 5 of Vile)
  9. # do not concatenate these parts, unpack them in order with /bin/sh
  10. # file efunc.h continued
  11. #
  12. if test ! -r _shar_seq_.tmp; then
  13.     echo 'Please unpack part 1 first!'
  14.     exit 1
  15. fi
  16. (read Scheck
  17.  if test "$Scheck" != 5; then
  18.     echo Please unpack part "$Scheck" next!
  19.     exit 1
  20.  else
  21.     exit 0
  22.  fi
  23. ) < _shar_seq_.tmp || exit 1
  24. echo 'x - continuing file efunc.h'
  25. sed 's/^X//' << 'SHAR_EOF' >> 'efunc.h' &&
  26. #if ! SMALLER
  27. X    {"save-window",            savewnd,    NONE },
  28. #endif
  29. X    {"scroll-next-up",        scrnextup,    NONE },
  30. X    {"scroll-next-down",        scrnextdw,    NONE },
  31. X    {"search-forward",        forwsearch,    ABS|MOTION },
  32. X    {"search-reverse",        backsearch,    ABS|MOTION },
  33. X    {"select-buffer",        usebuffer,    NONE },
  34. X    {"set",                setmode,    NONE },
  35. X    {"setall",            showmodes,    NONE },
  36. X    {"setg",            setgmode,    NONE },
  37. X    {"setgall",            showgmodes,    NONE },
  38. X    {"setgno",            delgmode,    NONE },
  39. X    {"setno",            delmode,    NONE },
  40. #if ! SMALLER
  41. X    {"setv",            setvar,        NONE },
  42. #endif
  43. #if    CRYPT
  44. X    {"set-encryption-key",        setkey,        NONE },
  45. #endif
  46. X    {"set-fill-column",        setfillcol,    NONE },
  47. X    {"set-named-mark",        setnmmark,    NONE },
  48. X    {"set-mark",            setmark,    NONE },
  49. X    {"sh",                spawncli,    NONE },
  50. X    {"shell-command",        spawn,        NONE },
  51. X    {"shift-left-til",        operlshift,    REDO|UNDO },
  52. X    {"shift-right-til",        operrshift,    REDO|UNDO },
  53. X    {"show-modes",            showmodes,    NONE },
  54. X    {"show-global-modes",        showgmodes,    NONE },
  55. X    {"shrink-window",        shrinkwind,    NONE },
  56. X    {"split-current-window",    splitwind,    NONE },
  57. X    {"store-macro",            storemac,    NONE },
  58. #if    PROC
  59. X    {"store-procedure",        storeproc,    NONE },
  60. #endif
  61. #if    BSD
  62. X    {"suspend-emacs",        bktoshell,    NONE },
  63. #endif
  64. #if TAGS
  65. X    {"ta",                gototag,    NONE },
  66. X    {"tag",                gototag,    NONE },
  67. #endif
  68. X    {"toggle-buffer-list",        togglelistbuffers,    NONE },
  69. #if ! SMALLER
  70. X    {"transpose-characters",    twiddle,    REDO|UNDO },
  71. #endif
  72. #if    AEDIT
  73. X    {"trim-line",            trim,        REDO|UNDO },
  74. #endif
  75. X    {"unbind-key",            unbindkey,    NONE },
  76. X    {"undo-change",            undo,        NONE },
  77. X    {"undo-line-changes",        lineundo,    NONE },
  78. X    {"universal-argument",        unarg,        NONE },
  79. X    {"unmark-buffer",        unmark,        NONE },
  80. X    {"unsetg",            delgmode,    NONE },
  81. X    {"unset",            delmode,    NONE },
  82. X    {"update-screen",        upscreen,    NONE },
  83. X    {"upper-til",            operupper,    REDO|UNDO },
  84. X    {"use-named-kill-register",    usekreg,    REDO },
  85. X    {"view-file",            viewfile,    NONE },
  86. X    {"w",                filesave,    NONE },
  87. #if    WORDPRO
  88. X    {"wc",                wordcount,    NONE },
  89. #endif
  90. X    {"wq",                writequit,    NONE },
  91. X    {"wrap-word",            wrapword,    REDO|UNDO },
  92. X    {"write-file",            filewrite,    NONE },
  93. X    {"write-file-and-quit",        writequit,    NONE },
  94. #if ! SMALLER
  95. X    {"write-message",        writemsg,    NONE },
  96. #endif
  97. X    {"write-til",            operwrite,    NONE },
  98. X    {"x",                quickexit,    NONE },
  99. X    {"yank-line",            yankline,    NONE },
  100. X    {"yank-lines-til",        operlineyank,    NONE },
  101. X    {"yank-til",            operyank,    NONE },
  102. X
  103. X    {"",            NULL}
  104. };
  105. SHAR_EOF
  106. echo 'File efunc.h is complete' &&
  107. chmod 0444 efunc.h ||
  108. echo 'restore of efunc.h failed'
  109. Wc_c="`wc -c < 'efunc.h'`"
  110. test 27465 -eq "$Wc_c" ||
  111.     echo 'efunc.h: original size 27465, current size' "$Wc_c"
  112. # ============= epath.h ==============
  113. echo 'x - extracting epath.h (Text)'
  114. sed 's/^X//' << 'SHAR_EOF' > 'epath.h' &&
  115. /*    EPATH:    This file contains certain info needed to locate the
  116. X        MicroEMACS files on a system dependant basis.
  117. X
  118. X                                    */
  119. X
  120. /*    possible names and paths of help files under different OSs    */
  121. X
  122. /* first two entries are default startup and help files, the rest are
  123. X    possible places to look for them */
  124. X
  125. char *pathname[] =
  126. X
  127. #if    AMIGA
  128. {
  129. X    ".vilerc",
  130. X    "vile.hlp",
  131. X    "",
  132. X    "sys:c/",
  133. X    "sys:t/",
  134. X    "sys:s/",
  135. X    ":c/",
  136. X    ":t/",
  137. X    ":s/"
  138. };
  139. #endif
  140. X
  141. #if    ST520
  142. {
  143. X    "vile.rc",
  144. X    "vile.hlp",
  145. X    "\\",
  146. X    "\\bin\\",
  147. X    "\\util\\",
  148. X    ""
  149. };
  150. #endif
  151. X
  152. #if    FINDER
  153. {
  154. X    "vile.rc",
  155. X    "vile.hlp",
  156. X    "/bin",
  157. X    "/sys/public",
  158. X    ""
  159. };
  160. #endif
  161. X
  162. #if    MSDOS
  163. {
  164. X    "vile.rc",
  165. X    "vile.hlp",
  166. X    "\\sys\\public\\",
  167. X    "\\usr\\bin\\",
  168. X    "\\bin\\",
  169. X    "\\",
  170. X    ""
  171. };
  172. #endif
  173. X
  174. #if    V7 | BSD | USG
  175. {
  176. X    ".vilerc",
  177. X    "vile.hlp",
  178. X    "/usr/local/",
  179. X    "/usr/lib/",
  180. X    "/usr/local/bin",
  181. X    "/usr/local/lib",
  182. X    ""
  183. };
  184. #endif
  185. X
  186. #if    VMS
  187. {
  188. X    "vile.rc",
  189. X    "vile.hlp",
  190. X    "",
  191. X    "sys$sysdevice:[vmstools]"
  192. };
  193. #endif
  194. X
  195. #define    NPNAMES    (sizeof(pathname)/sizeof(char *))
  196. SHAR_EOF
  197. chmod 0444 epath.h ||
  198. echo 'restore of epath.h failed'
  199. Wc_c="`wc -c < 'epath.h'`"
  200. test 956 -eq "$Wc_c" ||
  201.     echo 'epath.h: original size 956, current size' "$Wc_c"
  202. # ============= estruct.h ==============
  203. echo 'x - extracting estruct.h (Text)'
  204. sed 's/^X//' << 'SHAR_EOF' > 'estruct.h' &&
  205. /*    ESTRUCT:    Structure and preprocesser defines for
  206. X            vile.  Reshaped from the original, which
  207. X            was for MicroEMACS 3.9
  208. X
  209. X            vile is by Paul Fox
  210. X            MicroEmacs was written by Dave G. Conroy
  211. X            modified by Steve Wilhite, George Jones
  212. X            substantially modified by Daniel Lawrence
  213. */
  214. X
  215. #ifdef    LATTICE
  216. #undef    LATTICE        /* don't use their definitions...use ours    */
  217. #endif
  218. #ifdef    MSDOS
  219. #undef    MSDOS
  220. #endif
  221. #ifdef    CPM
  222. #undef    CPM
  223. #endif
  224. #ifdef    AMIGA
  225. #undef    AMIGA
  226. #endif
  227. #ifdef    EGA
  228. #undef    EGA
  229. #endif
  230. X
  231. /*    Machine/OS definitions            */
  232. /* sun, mips, generic 386, ODT, and Ultrix, see below... */
  233. /* unix flavors */
  234. #define BSD    1            /* UNIX BSD 4.2    and ULTRIX    */
  235. #define USG    0            /* UNIX system V        */
  236. #define V7    0            /* V7 UNIX or Coherent or BSD4.2*/
  237. X                    /*     presumably also Minix?    */
  238. /* unix sub-flavors */
  239. #define ODT    0            /* UNIX OPEN DESK TOP        */
  240. #define ULTRIX    0            /* UNIX ULTRIX            */
  241. #define POSIX    0
  242. X
  243. /* non-unix flavors */
  244. #define AMIGA    0            /* AmigaDOS            */
  245. #define ST520    0            /* ST520, TOS               */
  246. #define MSDOS    0            /* MS-DOS               */
  247. #define CPM    0            /* CP/M-86               */
  248. #define VMS    0            /* VAX/VMS               */
  249. X
  250. /* the following overrides for sun, i386, and mips are for convenience only */
  251. #if sun
  252. # undef BSD
  253. # undef USG
  254. # define BSD    1            /* UNIX BSD 4.2    and ULTRIX    */
  255. # define USG    0            /* UNIX system V        */
  256. #endif
  257. X
  258. #if i386 || mips
  259. # undef BSD
  260. # undef USG
  261. # define BSD    0            /* UNIX BSD 4.2    and ULTRIX    */
  262. # define USG    1            /* UNIX system V        */
  263. #endif
  264. X
  265. #if ODT
  266. # undef POSIX
  267. # undef BSD
  268. # undef USG
  269. # define POSIX    1
  270. # define BSD    0            /* UNIX BSD 4.2    and ULTRIX    */
  271. # define USG    1            /* UNIX system V        */
  272. #endif
  273. X
  274. #if ULTRIX
  275. # undef POSIX
  276. # undef BSD
  277. # undef USG
  278. # define POSIX    1
  279. # define BSD    1
  280. # define USG    0            /* UNIX system V        */
  281. #endif
  282. X
  283. #define UNIX    (V7 | BSD | USG)    /* any unix        */
  284. X
  285. #define OS    (UNIX | AMIGA | ST520 | MSDOS | CPM | VMS)
  286. #if ! OS
  287. X  you need to choose a system #define...
  288. #endif
  289. X
  290. /*    Porting constraints            */
  291. #define HAVE_MKDIR    1    /* if your system has the mkdir() system call */
  292. #define SHORTNAMES    0    /* if your compiler insists on 7 char names */
  293. X
  294. /*    Compiler definitions            */
  295. #define MWC86    0    /* marc williams compiler */
  296. #define    LATTICE    0    /* Lattice 2.14 thruough 3.0 compilers */
  297. #define    AZTEC    0    /* Aztec C 3.20e */
  298. #define    MSC    0    /* MicroSoft C compile version 3 & 4 */
  299. #define    TURBO    0    /* Turbo C/MSDOS */
  300. X
  301. /*    Terminal Output definitions        */
  302. /* choose one of the following */
  303. #define TERMCAP 1            /* Use TERMCAP            */
  304. #define ANSI    0            /* ANSI escape sequences    */
  305. #define AT386    0            /* AT style 386 unix console    */
  306. #define    HP150    0            /* HP150 screen driver        */
  307. #define    HP110    0            /* HP110 screen driver        */
  308. #define    VMSVT    0            /* various VMS terminal entries    */
  309. #define VT52    0            /* VT52 terminal (Zenith).    */
  310. #define RAINBOW 0            /* Use Rainbow fast video.    */
  311. #define    IBMPC    0            /* IBM-PC CGA/MONO/EGA driver    */
  312. #define    DG10    0            /* Data General system/10    */
  313. #define    TIPC    0            /* TI Profesional PC driver    */
  314. #define    Z309    0            /* Zenith 100 PC family    driver    */
  315. #define    MAC    0            /* Macintosh            */
  316. #define    ATARI    0            /* Atari 520/1040ST screen    */
  317. #define NeWS    0            /* distributed */
  318. X
  319. /*   Special keyboard definitions         */
  320. #define WANGPC    0        /* WangPC - mostly escape sequences    */
  321. /* the WANGPC stuff isn't in the cmdtbl keyboard definitions: sorry -- pgf */
  322. X
  323. /*    Configuration options... pick and choose as you wish */
  324. X
  325. /* Appearance */
  326. #define    TYPEAH    1    /* type ahead causes screen refresh to be delayed */
  327. #define    REVSTA    1    /* Status line appears in reverse video        */
  328. #define    COLOR    0    /* color commands and windows            */
  329. #define    CLRMSG    0    /* space clears the message line with no insert    */
  330. X
  331. /* Feature turnon/turnoff */
  332. #define    CTRLZ    0    /* add a ^Z at end of files under MSDOS only    */
  333. #define    DOSFILES 1    /* turn on code for DOS mode (lines that end in crlf) */
  334. X            /* use DOSFILES, for instance, if you edit DOS- */
  335. X            /*    created files under UNIX        */
  336. #define    CFENCE    1    /* do fench matching in CMODE            */
  337. #define    REBIND    1    /* permit rebinding of keys at run-time        */
  338. #define    APROP    1    /* Add code for Apropos command    (needs REBIND)    */
  339. #define    FILOCK    0    /* file locking under unix BSD 4.2 (uses scanf) */
  340. #define    ISRCH    1    /* Incremental searches like ITS EMACS        */
  341. #define    FLABEL    0    /* function key label code [HP150]        */
  342. #define    CRYPT    0    /* file encryption? (not crypt(1) compatible!)    */
  343. #define MAGIC    1    /* include regular expression matching?        */
  344. #define    TAGS    1    /* tags support.  requires MAGIC        */
  345. #define    WORDPRO    1    /* "Advanced" word processing features        */
  346. #define    AEDIT    1    /* advanced editing options: e.g. en/detabbing    */
  347. #define    PROC    1    /* named procedures                */
  348. #define    FINDERR    1    /* finderr support. uses scanf()        */
  349. #define    GLOBALS    1    /* "global" command support.            */
  350. #define    PATHLOOK 1    /* look along $PATH for startup and help files    */
  351. #define    SCROLLCODE 1    /* code in display.c for scrolling the screen.
  352. X               Only useful if your display can scroll
  353. X               regions, or at least insert/delete lines. 
  354. X               ANSI, TERMCAP, and AT386 can do this         */
  355. X
  356. #define CVMVAS    1    /* arguments to forward/back page and half page */
  357. X            /* are in pages    instead of rows */
  358. #define PRETTIER_SCROLL 1 /* can improve the appearance of a scrolling screen */
  359. #define STUTTER_SEC_CMD 0 /* must the next/prev section commands (i.e.
  360. X                ']]' and '[[' be stuttered?  they must be
  361. X                stuttered in real vi, I prefer them not
  362. X                to be */
  363. X
  364. /*    Code size options    */
  365. #define    FEWNAMES 0    /* strip some names - will no longer be bindable */
  366. #define    SMALLER    0    /* strip out a bunch of uemacs fluff */
  367. X            /*     (to each their own... :-)  pgf) */
  368. X
  369. /*    Debugging options    */
  370. #define    RAMSIZE    0    /* dynamic RAM memory usage tracking */
  371. #define    RAMSHOW    0    /* auto dynamic RAM reporting */
  372. #define    VMALLOC    0    /* verify malloc operation (slow!) */
  373. #define    DEBUG    1    /* allows core dump from keyboard under UNIX */
  374. #define    TIMING    0    /* shows user time spent on each user command */
  375. X            /* TIMING doesn't work yet... sorry  -pgf */ 
  376. #define DEBUGM    0    /* $debug triggers macro debugging        */
  377. #define    VISMAC    0    /* update display during keyboard macros    */
  378. X
  379. X
  380. /* That's the end of the user selections -- the rest is static definition */
  381. /* (i.e. you shouldn't need to touch anything below here */
  382. /* ====================================================================== */
  383. X
  384. #if SHORTNAMES
  385. #include "shorten/remap.h"
  386. #endif
  387. X
  388. /*    System dependant library redefinitions, structures and includes    */
  389. X
  390. #if    TURBO
  391. #include      <dos.h>
  392. #include      <mem.h>
  393. #undef peek
  394. #undef poke
  395. #define       peek(a,b,c,d)   movedata(a,b,FP_SEG(c),FP_OFF(c),d)
  396. #define       poke(a,b,c,d)   movedata(FP_SEG(c),FP_OFF(c),a,b,d)
  397. #endif
  398. X
  399. #if    VMS
  400. #define    atoi    xatoi
  401. #define    abs    xabs
  402. #define    getname    xgetname
  403. #endif
  404. X
  405. #if    LATTICE
  406. #define    unsigned
  407. #endif
  408. X
  409. #if    AZTEC
  410. #undef    fputc
  411. #undef    fgetc
  412. #if    MSDOS
  413. #define    fgetc    a1getc
  414. #else
  415. #define    fgetc    agetc
  416. #endif
  417. #define    fputc    aputc
  418. #define    int86    sysint
  419. #define    intdos(a, b)    sysint(33, a, b)
  420. #define    inp    inportb
  421. #define    outp    outportb
  422. X
  423. struct XREG {
  424. X    int ax,bx,cx,dx,si,di;
  425. };
  426. X
  427. struct HREG {
  428. X    char al,ah,bl,bh,cl,ch,dl,dh;
  429. };
  430. X
  431. union REGS {
  432. X    struct XREG x;
  433. X    struct HREG h;
  434. };
  435. #endif
  436. X
  437. #if    MSDOS & MWC86
  438. #include    <dos.h>
  439. #define    int86(a, b, c)    intcall(b, c, a)
  440. #define    inp    in
  441. X
  442. struct XREG {
  443. X    int ax,bx,cx,dx,si,di,ds,es,flags;
  444. };
  445. X
  446. struct HREG {
  447. X    char al,ah,bl,bh,cl,ch,dl,dh;
  448. X    int ds,es,flags;
  449. };
  450. X
  451. union REGS {
  452. X    struct XREG x;
  453. X    struct HREG h;
  454. };
  455. #endif
  456. X
  457. #if    MSDOS & MSC
  458. #include    <dos.h>
  459. #include    <memory.h>
  460. #define    peek(a,b,c,d)    movedata(a,b,FP_SEG(c),FP_OFF(c),d)
  461. #define    poke(a,b,c,d)    movedata(FP_SEG(c),FP_OFF(c),a,b,d)
  462. #define    movmem(a, b, c)        memcpy(b, a, c)
  463. #endif
  464. X
  465. #if    MSDOS & LATTICE
  466. #undef    CPM
  467. #undef    LATTICE
  468. #include    <dos.h>
  469. #undef    CPM
  470. #endif
  471. X
  472. #if    VMS
  473. #define    unlink(a)    delete(a)
  474. #endif
  475. X
  476. /*    define some ability flags */
  477. X
  478. #if    IBMPC | Z309
  479. #define    MEMMAP    1
  480. #else
  481. #define    MEMMAP    0
  482. #endif
  483. X
  484. #if    ((MSDOS) & (LATTICE | AZTEC | MSC | TURBO)) | UNIX
  485. #define    ENVFUNC    1
  486. #else
  487. #define    ENVFUNC    0
  488. #endif
  489. X
  490. #if BSD
  491. #define strchr index
  492. #define strrchr rindex
  493. #endif
  494. X
  495. #define TABVAL tabval
  496. #define TABMASK tabmask
  497. X
  498. /*    internal constants    */
  499. X
  500. #define    NBINDS    100            /* max # of bound prefixed keys    */
  501. #define NFILEN    80            /* # of bytes, file name    */
  502. #define NBUFN    20            /* # of bytes, buffer name    */
  503. #define NLINE    256            /* # of bytes, input line    */
  504. #define    NSTRING    128            /* # of bytes, string buffers    */
  505. #define NKBDM    256            /* # of strokes, keyboard macro */
  506. #define NPAT    128            /* # of bytes, pattern        */
  507. #define HUGE    60000            /* Huge number            */
  508. #define    NLOCKS    100            /* max # of file locks active    */
  509. #define    NCOLORS    8            /* number of supported colors    */
  510. #define    KBLOCK    256            /* sizeof kill buffer chunks    */
  511. #define    NKREGS    36            /* number of kill buffers    */
  512. #define    NBLOCK    16            /* line block chunk size    */
  513. #define    NVSIZE    10            /* max #chars in a var name    */
  514. X
  515. /* SPEC is just 8th bit set, for convenience in some systems (like NeWS?) */
  516. #define SPEC    0x0080            /* special key (function keys)    */
  517. #define CTLA    0x0100            /* ^A flag, or'ed in        */
  518. #define CTLX    0x0200            /* ^X flag, or'ed in        */
  519. X
  520. #define kcod2key(c) (c & 0x7f)        /* strip off the above prefixes */
  521. X
  522. #ifdef    FALSE
  523. #undef    FALSE
  524. #endif
  525. #ifdef    TRUE
  526. #undef    TRUE
  527. #endif
  528. X
  529. #define FALSE    0            /* False, no, bad, etc.     */
  530. #define TRUE    1            /* True, yes, good, etc.    */
  531. #define ABORT    2            /* Death, ESC, abort, etc.    */
  532. #define    FAILED    3            /* not-quite fatal false return    */
  533. #define    SORTOFTRUE    4        /* really!    */
  534. X
  535. #define    STOP    0            /* keyboard macro not in use    */
  536. #define    PLAY    1            /*    "     "      playing    */
  537. #define    RECORD    2            /*    "     "   recording    */
  538. #define    TMPSTOP    3            /* temporary stop, record can resume */
  539. X
  540. /* flook options */
  541. #define FL_HERE 1
  542. #define FL_HERE_HOME 2
  543. #define FL_ANYWHERE 3
  544. X
  545. /* bfind options */
  546. #define OK_CREAT TRUE
  547. #define NO_CREAT FALSE
  548. X
  549. /* kbd_string options */
  550. #define EXPAND TRUE
  551. #define NO_EXPAND FALSE
  552. X
  553. /*    Directive definitions    */
  554. X
  555. #if ! SMALLER
  556. X
  557. #define    DIF        0
  558. #define DELSE        1
  559. #define DENDIF        2
  560. #define DGOTO        3
  561. #define DRETURN        4
  562. #define DENDM        5
  563. #define DWHILE        6
  564. #define    DENDWHILE    7
  565. #define    DBREAK        8
  566. #define DFORCE        9
  567. X
  568. #define NUMDIRS        10
  569. X
  570. #else
  571. X
  572. #define DENDM        0
  573. #define NUMDIRS        1
  574. X
  575. #endif
  576. X
  577. /*
  578. X * PTBEG, PTEND, FORWARD, and REVERSE are all toggle-able values for
  579. X * the scan routines.
  580. X */
  581. #define    PTBEG    0    /* Leave the point at the beginning on search    */
  582. #define    PTEND    1    /* Leave the point at the end on search        */
  583. #define    FORWARD    0            /* forward direction        */
  584. #define REVERSE    1            /* backwards direction        */
  585. X
  586. #define FIOSUC    0            /* File I/O, success.        */
  587. #define FIOFNF    1            /* File I/O, file not found.    */
  588. #define FIOEOF    2            /* File I/O, end of file.    */
  589. #define FIOERR    3            /* File I/O, error.        */
  590. #define    FIOMEM    4            /* File I/O, out of memory    */
  591. #define    FIOFUN    5            /* File I/O, eod of file/bad line*/
  592. X
  593. /* two flavors of insert mode */
  594. #define INSERT 1
  595. #define OVERWRITE 2
  596. X
  597. /* kill register control */
  598. #define KNEEDCLEAN   0x01        /* Kill register needs cleaning */
  599. #define KYANK    0x02            /* Kill register resulted from yank */
  600. #define KLINES    0x04            /* Kill register contains full lines */
  601. #define KAPPEND  0x04            /* Kill register should be appended */
  602. X
  603. /* operator types.  Needed mainly because word movement changes depending on
  604. X    whether operator is "delete" or not.  Aargh.  */
  605. #define OPDEL 1
  606. #define OPOTHER 2
  607. X
  608. /* define these so C-fence matching doesn't get confused when we're editing
  609. X    the cfence code itself */
  610. #define LBRACE '{'
  611. #define RBRACE '}'
  612. X
  613. X
  614. #if UNIX
  615. #define    PATHCHR    ':'
  616. #else
  617. #define    PATHCHR    ';'
  618. #endif
  619. X
  620. /* how big is the ascii rep. of an int? */
  621. #define    INTWIDTH    sizeof(int) * 3
  622. X
  623. /*    Macro argument token types                    */
  624. X
  625. #define    TKNUL    0            /* end-of-string        */
  626. #define    TKARG    1            /* interactive argument        */
  627. #define    TKBUF    2            /* buffer argument        */
  628. #define    TKVAR    3            /* user variables        */
  629. #define    TKENV    4            /* environment variables    */
  630. #define    TKFUN    5            /* function....            */
  631. #define    TKDIR    6            /* directive            */
  632. #define    TKLBL    7            /* line label            */
  633. #define    TKLIT    8            /* numeric literal        */
  634. #define    TKSTR    9            /* quoted string literal    */
  635. #define    TKCMD    10            /* command name            */
  636. X
  637. /*    Internal defined functions                    */
  638. X
  639. #define    nextab(a)    ((a & ~TABMASK) + TABVAL)
  640. X
  641. #ifdef    abs
  642. #undef    abs
  643. #endif
  644. X
  645. /* these are the bits that go into the _chartypes_ array */
  646. /* the macros below test for them */
  647. #define N_chars 128
  648. #define _upper 1        /* upper case */
  649. #define _lower 2        /* lower case */
  650. #define _digit 4        /* digits */
  651. #define _space 8        /* whitespace */
  652. #define _bspace 16        /* backspace character (^H, DEL, and user's) */
  653. #define _cntrl 32        /* control characterts, including DEL */
  654. #define _print 64        /* printable */
  655. #define _punct 128        /* punctuation */
  656. #define _ident 256        /* is typically legal in "normal" identifier */
  657. #define _path 512        /* is typically legal in a file's pathname */
  658. #define _wild 2048        /* is typically a shell wildcard char */
  659. #define _linespec 4096        /* ex-style line range: 1,$ or 13,15 or % etc.*/
  660. X
  661. /* these intentionally match the ctypes.h definitions, except that
  662. X    they force the char to 7-bit ascii first */
  663. #define istype(sometype,c)    (_chartypes_[(c)&(N_chars-1)] & (sometype))
  664. #define islower(c)    istype(_lower, c)
  665. #define isupper(c)    istype(_upper, c)
  666. #define isdigit(c)    istype(_digit, c)
  667. #define isspace(c)    istype(_space, c)
  668. #define iscntrl(c)    istype(_cntrl, c)
  669. #define isprint(c)    istype(_print, c)
  670. #define ispunct(c)    istype(_punct, c)
  671. #define iswild(c)    istype(_wild, c)
  672. #define isalpha(c)    istype(_lower|_upper, c)
  673. #define isalnum(c)    istype(_lower|_upper|_digit, c)
  674. #define isident(c)    istype(_ident, c)
  675. #define ispath(c)    istype(_path, c)
  676. #define isbackspace(c)    istype(_bspace, c)
  677. #define islinespecchar(c)    istype(_linespec, c)
  678. X
  679. /* DIFCASE represents the difference between upper
  680. X   and lower case letters, DIFCNTRL the difference between upper case and
  681. X   control characters.    They are xor-able values.  */
  682. #define    DIFCASE        0x20
  683. #define    DIFCNTRL    0x40
  684. #define toupper(c)    ((c)^DIFCASE)
  685. #define tolower(c)    ((c)^DIFCASE)
  686. #define tocntrl(c)    ((c)^DIFCNTRL)
  687. #define toalpha(c)    ((c)^DIFCNTRL)
  688. X
  689. /*    Dynamic RAM tracking and reporting redefinitions    */
  690. X
  691. #if    RAMSIZE
  692. #define    malloc    allocate
  693. #define    free    release
  694. #endif
  695. X
  696. #if VMALLOC
  697. char *vmalloc();
  698. void vfree();
  699. void rvverify();
  700. char *vrealloc();
  701. char *vcalloc();
  702. void vdump();
  703. # define malloc(x) vmalloc(x,__FILE__,__LINE__)
  704. # define free(x) vfree(x,__FILE__,__LINE__)
  705. # define realloc(x,y) vrealloc(x,y,__FILE__,__LINE__)
  706. # define calloc(x,y) vcalloc(x,y,__FILE__,__LINE__)
  707. # define vverify(s) rvverify(s,__FILE__,__LINE__)
  708. #else
  709. # define vverify(s) ;
  710. #endif
  711. X
  712. /*
  713. X * There is a window structure allocated for every active display window. The
  714. X * windows are kept in a big list, in top to bottom screen order, with the
  715. X * listhead at "wheadp". Each window contains its own values of dot and mark.
  716. X * The flag field contains some bits that are set by commands to guide
  717. X * redisplay. Although this is a bit of a compromise in terms of decoupling,
  718. X * the full blown redisplay is just too expensive to run for every input
  719. X * character.
  720. X */
  721. typedef struct    WINDOW {
  722. X    struct    WINDOW *w_wndp;     /* Next window            */
  723. X    struct    BUFFER *w_bufp;     /* Buffer displayed in window    */
  724. X    struct    LINE *w_linep;        /* Top line in the window    */
  725. X    struct    LINE *w_dotp;        /* Line containing "."        */
  726. X    struct    LINE *w_mkp;          /* Line containing "mark"       */
  727. X    struct    LINE *w_ldmkp;          /* Line containing "lastdotmark"*/
  728. X    int    w_doto;              /* Byte offset for "."          */
  729. X    int    w_mko;            /* Byte offset for "mark"        */
  730. X    int    w_ldmko;            /* Byte offset for "lastdotmark"*/
  731. X    int    w_toprow;           /* Origin 0 top row of window   */
  732. X    int    w_ntrows;           /* # of rows of text in window  */
  733. X    int    w_force;            /* If non-zero, forcing row.   */
  734. X    int    w_flag;               /* Flags.               */
  735. X    int    w_sideways;           /* sideways offset */
  736. #if    COLOR
  737. X    int    w_fcolor;        /* current forground color    */
  738. X    int    w_bcolor;        /* current background color    */
  739. #endif
  740. }    WINDOW;
  741. X
  742. #define WFFORCE 0x01            /* Window needs forced reframe    */
  743. #define WFMOVE    0x02            /* Movement from line to line    */
  744. #define WFEDIT    0x04            /* Editing within a line    */
  745. #define WFHARD    0x08            /* Better do a full display    */
  746. #define WFMODE    0x10            /* Update mode line.        */
  747. #define    WFCOLR    0x20            /* Needs a color change        */
  748. #define    WFKILLS    0x40            /* something was deleted    */
  749. #define    WFINS    0x80            /* something was inserted    */
  750. X
  751. struct MARK {
  752. X    struct LINE *markp;
  753. X    int marko;
  754. };
  755. X
  756. /*
  757. X * Text is kept in buffers. A buffer header, described below, exists for every
  758. X * buffer in the system. The buffers are kept in a big list, so that commands
  759. X * that search for a buffer by name can find the buffer header. There is a
  760. X * safe store for the dot and mark in the header, but this is only valid if
  761. X * the buffer is not being displayed (that is, if "b_nwnd" is 0). The text for
  762. X * the buffer is kept in a circularly linked list of lines, with a pointer to
  763. X * the header line in "b_linep"    Buffers may be "Inactive" which means the files associated with them
  764. X * have not been read in yet. These get read in at "use buffer" time.
  765. X */
  766. typedef struct    BUFFER {
  767. X    struct    BUFFER *b_bufp;     /* Link to next BUFFER        */
  768. X    struct    MARK *b_nmmarks;    /* named marks a-z        */
  769. X    struct    LINE *b_linep;        /* Link to the header LINE    */
  770. X    struct    LINE *b_dotp;        /* Link to "." LINE structure    */
  771. X    struct    LINE *b_markp;        /* The same as the above two,    */
  772. X    struct    LINE *b_ldmkp;            /* The same as the above two,   */
  773. X    int    b_doto;                /* Offset of "." in above LINE  */
  774. X    int    b_marko;        /* same but for the "mark"    */
  775. X    int    b_ldmko;        /* same but for the "last dot mark" */
  776. X    int    b_sideways;        /* sideways offset        */
  777. X    int    b_mode;            /* editor mode of this buffer    */
  778. X    struct    LINE *b_udstks[2];    /* undo stack pointers        */
  779. X    short    b_udstkindx;        /* which of above to use    */
  780. X    struct    LINE *b_uddotps[2];    /* Link to "." before undoable op*/
  781. X    int    b_uddotos[2];        /* offset of "." before undoable op*/
  782. X    struct    LINE *b_ulinep;        /* pointer at 'Undo' line    */
  783. X    int    b_active;        /* window activated flag    */
  784. X    int    b_nwnd;                /* Count of windows on buffer   */
  785. X    int    b_flag;                /* Flags                 */
  786. X    char    b_fname[NFILEN];    /* File name            */
  787. X    char    b_bname[NBUFN];     /* Buffer name            */
  788. #if    CRYPT
  789. X    char    b_key[NPAT];        /* current encrypted key    */
  790. #endif
  791. }    BUFFER;
  792. X
  793. #define BFINVS    0x01            /* Internal invisable buffer    */
  794. #define BFCHG    0x02            /* Changed since last write    */
  795. #define BFSCRTCH   0x04         /* scratch -- gone on last close */
  796. X
  797. /*    mode flags    */
  798. /* the first set are bitmapped, and are inherited from global to per-buffer */
  799. #define    NUMMODES    11 /* # of defined modes        */
  800. #define    MDWRAP    0x0001            /* word wrap            */
  801. #define    MDCMOD    0x0002            /* C indentation and fence match*/
  802. #define    MDSWRAP 0x0004            /* wrap-around search mode    */
  803. #define    MDEXACT    0x0008            /* Exact matching for searches    */
  804. #define    MDVIEW    0x0010            /* read-only buffer        */
  805. #define MDMAGIC    0x0020            /* regular expresions in search */
  806. #define    MDCRYPT    0x0040            /* encrytion mode active    */
  807. #define    MDASAVE    0x0080            /* auto-save mode        */
  808. #define    MDLIST    0x0100            /* "list" mode -- show tabs and EOL */
  809. #define    MDDOS    0x0200            /* "dos" mode -- lines end in crlf */
  810. #define    MDAIND    0x0400            /* auto-indent */
  811. X
  812. /* the next set are global, bit-mapped, but are meaningless per-buffer */
  813. #define    NUMOTHERMODES    2 /* # of defined modes        */
  814. #define OTH_LAZY 0x01
  815. #define OTH_VERS 0x02
  816. X
  817. /* the last set are global, and have values */
  818. #define    NUMVALUEMODES    2 /* # of defined modes        */
  819. #define VAL_TAB 0
  820. #define VAL_FILL 1
  821. X
  822. /*
  823. X * The starting position of a region, and the size of the region in
  824. X * characters, is kept in a region structure.  Used by the region commands.
  825. X */
  826. typedef struct    {
  827. X    struct    LINE *r_linep;        /* Origin LINE address.     */
  828. X    int    r_offset;        /* Origin LINE offset.        */
  829. X    struct    LINE *r_endlinep;    /* Ending LINE address.     */
  830. X    int    r_endoffset;        /* Ending LINE offset.        */
  831. X    long    r_size;         /* Length in characters.    */
  832. }    REGION;
  833. X
  834. /*
  835. X * All text is kept in circularly linked lists of "LINE" structures. These
  836. X * begin at the header line. This line is pointed to by the "BUFFER".
  837. X * Each line contains:
  838. X *  number of bytes in the line (the "used" size), 
  839. X *  the size of the text array,
  840. X *  the text.
  841. X * The end of line is not stored as a byte; it's implied. Future
  842. X * additions may include update hints, and a list of marks into the line.
  843. X *
  844. X * Lines are additionally sometimes stacked in undo lists.
  845. X */
  846. typedef struct    LINE {
  847. X    struct    LINE *l_fp;        /* Link to the next line    */
  848. X    struct    LINE *l_bp;        /* Link to the previous line    */
  849. X    int   l_size;              /* Allocated size           */
  850. X    int   l_used;              /* Used size              */
  851. X    char *l_text;
  852. X    union {
  853. X        struct  LINE *l_stklnk;    /* Link for undo stack        */
  854. X        long    l_flag;        /* flags for undo ops        */
  855. X    } l;
  856. }    LINE;
  857. X
  858. /* flag values */
  859. #define LCOPIED 1    /* original line is already on an undo stack */
  860. #define LGMARK 2    /* line matched a global scan */
  861. X
  862. /* macros to ease the use of lines */
  863. #define lforw(lp)    ((lp)->l_fp)
  864. #define lback(lp)    ((lp)->l_bp)
  865. #define lgetc(lp, n)    ((lp)->l_text[(n)]&0xFF)
  866. #define lputc(lp, n, c) ((lp)->l_text[(n)]=(c))
  867. #define llength(lp)    ((lp)->l_used)
  868. #define l_nxtundo    l.l_stklnk
  869. #define liscopied(lp)    (lp->l.l_flag & LCOPIED)
  870. #define lismarked(lp)    (lp->l.l_flag & LGMARK)
  871. #define lsetcopied(lp)        (lp->l.l_flag |= LCOPIED)
  872. #define lsetnotcopied(lp)    (lp->l.l_flag &= ~LCOPIED)
  873. #define lsetmarked(lp)        (lp->l.l_flag |= LGMARK)
  874. #define lsetnotmarked(lp)    (lp->l.l_flag &= ~LGMARK)
  875. #define lsetclear(lp)    (lp->l.l_flag = 0)
  876. #define LINENOTREAL    ((int)(-1))
  877. #define LINEUNDOPATCH    ((int)(-2))
  878. #define MARKPATCH    ((int)(-3))
  879. #define lisreal(lp)    ((lp)->l_used >= 0)
  880. #define lisnotreal(lp)       ((lp)->l_used == LINENOTREAL)
  881. #define lislinepatch(lp)     ((lp)->l_used == LINEUNDOPATCH)
  882. #define lismarkpatch(lp)     ((lp)->l_used == MARKPATCH)
  883. #define lispatch(lp)     (lislinepatch(lp) || lismarkpatch(lp))
  884. #define lneedscopying(lp)     ((lp)->l_copied != TRUE)
  885. X
  886. /*
  887. X * The editor communicates with the display using a high level interface. A
  888. X * "TERM" structure holds useful variables, and indirect pointers to routines
  889. X * that do useful operations. The low level get and put routines are here too.
  890. X * This lets a terminal, in addition to having non standard commands, have
  891. X * funny get and put character code too. The calls might get changed to
  892. X * "termp->t_field" style in the future, to make it possible to run more than
  893. X * one terminal type.
  894. X */
  895. typedef struct    {
  896. X    int    t_mrow;            /* max number of rows allowable */
  897. X    int    t_nrow;         /* current number of rows used    */
  898. X    int    t_mcol;         /* max Number of columns.    */
  899. X    int    t_ncol;         /* current Number of columns.    */
  900. X    int    t_margin;        /* min margin for extended lines*/
  901. X    int    t_scrsiz;        /* size of scroll region "    */
  902. X    int    t_pause;        /* # times thru update to pause */
  903. X    int    (*t_open)();        /* Open terminal at the start.    */
  904. X    int    (*t_close)();        /* Close terminal at end.    */
  905. X    int    (*t_kopen)();        /* Open keyboard        */
  906. X    int    (*t_kclose)();        /* close keyboard        */
  907. X    int    (*t_getchar)();     /* Get character from keyboard. */
  908. X    int    (*t_putchar)();     /* Put character to display.    */
  909. X    int    (*t_flush)();        /* Flush output buffers.    */
  910. X    int    (*t_move)();        /* Move the cursor, origin 0.    */
  911. X    int    (*t_eeol)();        /* Erase to end of line.    */
  912. X    int    (*t_eeop)();        /* Erase to end of page.    */
  913. X    int    (*t_beep)();        /* Beep.            */
  914. X    int    (*t_rev)();        /* set reverse video state    */
  915. X    int    (*t_rez)();        /* change screen resolution    */
  916. #if    COLOR
  917. X    int    (*t_setfor)();        /* set forground color        */
  918. X    int    (*t_setback)();        /* set background color        */
  919. #endif
  920. #if    SCROLLCODE
  921. X    int    (*t_scroll)();        /* scroll a region of the screen */
  922. #endif
  923. }    TERM;
  924. X
  925. /*    TEMPORARY macros for terminal I/O  (to be placed in a machine
  926. X                        dependant place later)    */
  927. X
  928. #define    TTopen        (*term.t_open)
  929. #define    TTclose        (*term.t_close)
  930. #define    TTkopen        (*term.t_kopen)
  931. #define    TTkclose    (*term.t_kclose)
  932. #define    TTgetc        (*term.t_getchar)
  933. #define    TTputc        (*term.t_putchar)
  934. #define    TTflush        (*term.t_flush)
  935. #define    TTmove        (*term.t_move)
  936. #define    TTeeol        (*term.t_eeol)
  937. #define    TTeeop        (*term.t_eeop)
  938. #define    TTbeep        (*term.t_beep)
  939. #define    TTrev        (*term.t_rev)
  940. #define    TTrez        (*term.t_rez)
  941. #if    COLOR
  942. #define    TTforg        (*term.t_setfor)
  943. #define    TTbacg        (*term.t_setback)
  944. #endif
  945. X
  946. X
  947. /* Commands are represented as CMDFUNC structures, which contain a
  948. X *    pointer to the actual function, and flags which help to classify it.
  949. X *    (things like is it a MOTION, can it be UNDOne)
  950. X *
  951. X *    These structures are generated automatically from the cmdtbl file,
  952. X *    and can be found in the file nefunc.h
  953. */
  954. typedef  struct {
  955. X    int (*c_func)();    /* function name is bound to */
  956. X    unsigned long c_flags;        /* what sort of command is it? */
  957. }    CMDFUNC;
  958. X
  959. /* when referencing a command by name (e.g ":e file") it is looked up in
  960. X *    the nametbl, which is an array of NTAB structures, containing the
  961. X *    name, and a pointer to the CMDFUNC structure.  There can be several
  962. X *    entries pointing at a single CMDFUNC, since a command might have
  963. X *    several synonymous names.
  964. X *
  965. X *    The nametbl array is generated automatically from the cmdtbl file,
  966. X *    and can be found in the file nename.h
  967. X */
  968. typedef struct {
  969. X    char *n_name;
  970. X    CMDFUNC    *n_cmd;
  971. }    NTAB;
  972. X
  973. /* when a command is referenced by bound key (like h,j,k,l, or "dd"), it
  974. X *    is looked up one of two ways:  single character 7-bit ascii commands
  975. X *    (by far the majority) are simply indexed into a 128 element array of
  976. X *    CMDFUNC pointers.  Other commands (those with ^A, ^X, or SPEC
  977. X *    prefixes) are searched for in a binding table, made up of KBIND
  978. X *    structures.  This structure contains the command code, and again, a
  979. X *    pointer to the CMDFUNC structure for the command 
  980. X *
  981. X *    The asciitbl array, and the kbindtbl array are generated automatically
  982. X *    from the cmdtbl file, and can be found in the file nebind.h
  983. X */
  984. typedef struct {
  985. X    short    k_code;         /* Key code            */
  986. X    CMDFUNC    *k_cmd;
  987. }    KBIND;
  988. X
  989. X
  990. /* these are the flags which can appear in the CMDFUNC structure, describing
  991. X    a command */
  992. #define NONE    0
  993. #define UNDO    0x01    /* command is undo-able, so clean up undo lists */
  994. #define REDO    0x02    /* command is redo-able, record it for dotcmd */
  995. #define MOTION    0x04    /* command causes motion, okay after operator cmds */
  996. #define FL    0x08    /* if command causes motion, opers act on full lines */
  997. #define ABS    0x10    /* command causes absolute (i.e. non-relative) motion */
  998. #define GOAL    0x20    /* column goal should be retained */
  999. #define GLOBOK    0x40    /* permitted after global command */
  1000. #define OPER    0x80    /* function is an operator, affects a region */
  1001. #define LISTED    0x100    /* internal use only -- used in describing bindings
  1002. X                to only describe each once */
  1003. X
  1004. /* these flags are ex argument descriptors. I simply moved them over 
  1005. X    from elvis.  Not all are used or honored or implemented */
  1006. #define FROM    (1<<16)        /* allow a linespec */
  1007. #define    TO    (2<<16)        /* allow a second linespec */
  1008. #define BANG    (4<<16)        /* allow a ! after the command name */
  1009. #define EXTRA    (8<<16)        /* allow extra args after command name */
  1010. #define XFILE    (16<<16)    /* expand wildcards in extra part */
  1011. #define NOSPC    (32<<16)    /* no spaces allowed in the extra part */
  1012. #define    DFLALL    (64<<16)    /* default file range is 1,$ */
  1013. #define DFLNONE    (128<<16)    /* no default file range */
  1014. #define NODFL    (256<<16)    /* do not default to the current file name */
  1015. #define EXRCOK    (512<<16)    /* can be in a .exrc file */
  1016. #define NL    (1024<<16)    /* if !exmode, then write a newline first */
  1017. #define PLUS    (2048<<16)    /* allow a line number, as in ":e +32 foo" */
  1018. #define ZERO    (4096<<16)    /* allow 0 to be given as a line number */
  1019. #define FILES    (XFILE + EXTRA)    /* multiple extra files allowed */
  1020. #define WORD1    (EXTRA + NOSPC)    /* one extra word allowed */
  1021. #define FILE1    (FILES + NOSPC)    /* 1 file allowed, defaults to current file */
  1022. #define NAMEDF    (FILE1 + NODFL)    /* 1 file allowed, defaults to "" */
  1023. #define NAMEDFS    (FILES + NODFL)    /* multiple files allowed, default is "" */
  1024. #define RANGE    (FROM + TO)    /* range of linespecs allowed */
  1025. X
  1026. /*    The editor holds deleted text chunks in the KILL registers. The
  1027. X    kill registers are logically a stream of ascii characters, however
  1028. X    due to unpredicatable size, get implemented as a linked
  1029. X    list of chunks. (The d_ prefix is for "deleted" text, as k_
  1030. X    was taken up by the keycode structure)
  1031. */
  1032. X
  1033. typedef    struct KILL {
  1034. X    struct KILL *d_next;    /* link to next chunk, NULL if last */
  1035. X    char d_chunk[KBLOCK];    /* deleted text */
  1036. } KILL;
  1037. X
  1038. typedef struct KILLREG {
  1039. X    struct KILL *kbufp;    /* current kill register chunk pointer */
  1040. X    struct KILL *kbufh;    /* kill register header pointer    */
  1041. X    int   kused;        /* # of bytes used in kill last chunk    */
  1042. X    short kbflag;        /* flags describing kill register    */
  1043. } KILLREG;
  1044. X
  1045. /*    When the command interpretor needs to get a variable's name,
  1046. X    rather than its value, it is passed back as a VDESC variable
  1047. X    description structure. The v_num field is an index into the
  1048. X    appropriate variable table.
  1049. */
  1050. X
  1051. typedef struct VDESC {
  1052. X    int v_type;    /* type of variable */
  1053. X    int v_num;    /* ordinal pointer to variable in list */
  1054. } VDESC;
  1055. X
  1056. /*    The !WHILE directive in the execution language needs to
  1057. X    stack references to pending whiles. These are stored linked
  1058. X    to each currently open procedure via a linked list of
  1059. X    the following structure
  1060. */
  1061. X
  1062. typedef struct WHBLOCK {
  1063. X    LINE *w_begin;        /* ptr to !while statement */
  1064. X    LINE *w_end;        /* ptr to the !endwhile statement*/
  1065. X    int w_type;        /* block type */
  1066. X    struct WHBLOCK *w_next;    /* next while */
  1067. } WHBLOCK;
  1068. X
  1069. #define    BTWHILE        1
  1070. #define    BTBREAK        2
  1071. X
  1072. /*
  1073. X * Incremental search defines.
  1074. X */
  1075. #if    ISRCH
  1076. X
  1077. #define    CMDBUFLEN    256    /* Length of our command buffer */
  1078. X
  1079. #define IS_REVERSE    tocntrl('R')    /* Search backward */
  1080. #define    IS_FORWARD    tocntrl('F')    /* Search forward */
  1081. X
  1082. #endif
  1083. X
  1084. #if    MAGIC
  1085. X
  1086. /*
  1087. X * Defines for the metacharacters in the regular expressions in search
  1088. X * routines.
  1089. X */
  1090. X
  1091. #define    MCNIL        0    /* Like the '\0' for strings.*/
  1092. #define    LITCHAR        1
  1093. #define    ANY        2
  1094. #define    CCL        3
  1095. #define    NCCL        4
  1096. #define    BOL        5
  1097. #define    EOL        6
  1098. #define    CLOSURE        256    /* An or-able value.*/
  1099. #define    MASKCL        CLOSURE - 1
  1100. X
  1101. #define    MC_ANY        '.'    /* 'Any' character (except newline).*/
  1102. #define    MC_CCL        '['    /* Character class.*/
  1103. #define    MC_NCCL        '^'    /* Negate character class.*/
  1104. #define    MC_RCCL        '-'    /* Range in character class.*/
  1105. #define    MC_ECCL        ']'    /* End of character class.*/
  1106. #define    MC_BOL        '^'    /* Beginning of line.*/
  1107. #define    MC_EOL        '$'    /* End of line.*/
  1108. #define    MC_CLOSURE    '*'    /* Closure - does not extend past newline.*/
  1109. X
  1110. #define    MC_ESC        '\\'    /* Escape - suppress meta-meaning.*/
  1111. X
  1112. #define    BIT(n)        (1 << (n))    /* An integer with one bit set.*/
  1113. #define    CHCASE(c)    ((c) ^ DIFCASE)    /* Toggle the case of a letter.*/
  1114. X
  1115. /* HICHAR - 1 is the largest character we will deal with.
  1116. X * HIBYTE represents the number of bytes in the bitmap.
  1117. X */
  1118. X
  1119. #define    HICHAR        256
  1120. #define    HIBYTE        HICHAR >> 3
  1121. X
  1122. typedef char    *BITMAP;
  1123. X
  1124. typedef    struct {
  1125. X    short int    mc_type;
  1126. X    union {
  1127. X        int    lchar;
  1128. X        BITMAP    cclmap;
  1129. X    } u;
  1130. } MC;
  1131. #endif
  1132. X
  1133. SHAR_EOF
  1134. chmod 0444 estruct.h ||
  1135. echo 'restore of estruct.h failed'
  1136. Wc_c="`wc -c < 'estruct.h'`"
  1137. test 30449 -eq "$Wc_c" ||
  1138.     echo 'estruct.h: original size 30449, current size' "$Wc_c"
  1139. # ============= eval.c ==============
  1140. echo 'x - extracting eval.c (Text)'
  1141. sed 's/^X//' << 'SHAR_EOF' > 'eval.c' &&
  1142. /*    EVAL.C:    Expresion evaluation functions for
  1143. X        MicroEMACS
  1144. X
  1145. X    written 1986 by Daniel Lawrence                */
  1146. X
  1147. #include    <stdio.h>
  1148. #include    "estruct.h"
  1149. #include    "edef.h"
  1150. #include    "evar.h"
  1151. X
  1152. varinit()        /* initialize the user variable list */
  1153. X
  1154. {
  1155. #if ! SMALLER
  1156. X    register int i;
  1157. X
  1158. X    for (i=0; i < MAXVARS; i++)
  1159. X        uv[i].u_name[0] = 0;
  1160. #endif
  1161. }
  1162. X
  1163. #if ! SMALLER
  1164. char *gtfun(fname)    /* evaluate a function */
  1165. char *fname;        /* name of function to evaluate */
  1166. {
  1167. X    register int fnum;        /* index to function to eval */
  1168. X    register int status;        /* return status */
  1169. X    char arg1[NSTRING];        /* value of first argument */
  1170. X    char arg2[NSTRING];        /* value of second argument */
  1171. X    char arg3[NSTRING];        /* value of third argument */
  1172. X    static char result[2 * NSTRING];    /* string result */
  1173. #if    ENVFUNC
  1174. X    char *getenv();
  1175. #endif
  1176. X
  1177. X    /* look the function up in the function table */
  1178. X    fname[3] = 0;    /* only first 3 chars significant */
  1179. X    mklower(fname);    /* and let it be upper or lower case */
  1180. X    for (fnum = 0; fnum < NFUNCS; fnum++)
  1181. X        if (strcmp(fname, funcs[fnum].f_name) == 0)
  1182. X            break;
  1183. X
  1184. X    /* return errorm on a bad reference */
  1185. X    if (fnum == NFUNCS)
  1186. X        return(errorm);
  1187. X
  1188. X    /* if needed, retrieve the first argument */
  1189. X    if (funcs[fnum].f_type >= MONAMIC) {
  1190. X        if ((status = macarg(arg1)) != TRUE)
  1191. X            return(errorm);
  1192. X
  1193. X        /* if needed, retrieve the second argument */
  1194. X        if (funcs[fnum].f_type >= DYNAMIC) {
  1195. X            if ((status = macarg(arg2)) != TRUE)
  1196. X                return(errorm);
  1197. X    
  1198. X            /* if needed, retrieve the third argument */
  1199. X            if (funcs[fnum].f_type >= TRINAMIC)
  1200. X                if ((status = macarg(arg3)) != TRUE)
  1201. X                    return(errorm);
  1202. X        }
  1203. X    }
  1204. X        
  1205. X
  1206. X    /* and now evaluate it! */
  1207. X    switch (fnum) {
  1208. X        case UFADD:    return(itoa(atoi(arg1) + atoi(arg2)));
  1209. X        case UFSUB:    return(itoa(atoi(arg1) - atoi(arg2)));
  1210. X        case UFTIMES:    return(itoa(atoi(arg1) * atoi(arg2)));
  1211. X        case UFDIV:    return(itoa(atoi(arg1) / atoi(arg2)));
  1212. X        case UFMOD:    return(itoa(atoi(arg1) % atoi(arg2)));
  1213. X        case UFNEG:    return(itoa(-atoi(arg1)));
  1214. X        case UFCAT:    strcpy(result, arg1);
  1215. X                return(strcat(result, arg2));
  1216. X        case UFLEFT:    return(strncpy(result, arg1, atoi(arg2)));
  1217. X        case UFRIGHT:    return(strcpy(result, &arg1[atoi(arg2)-1]));
  1218. X        case UFMID:    return(strncpy(result, &arg1[atoi(arg2)-1],
  1219. X                    atoi(arg3)));
  1220. X        case UFNOT:    return(ltos(stol(arg1) == FALSE));
  1221. X        case UFEQUAL:    return(ltos(atoi(arg1) == atoi(arg2)));
  1222. X        case UFLESS:    return(ltos(atoi(arg1) < atoi(arg2)));
  1223. X        case UFGREATER:    return(ltos(atoi(arg1) > atoi(arg2)));
  1224. X        case UFSEQUAL:    return(ltos(strcmp(arg1, arg2) == 0));
  1225. X        case UFSLESS:    return(ltos(strcmp(arg1, arg2) < 0));
  1226. X        case UFSGREAT:    return(ltos(strcmp(arg1, arg2) > 0));
  1227. X        case UFIND:    return(tokval(arg1));
  1228. X        case UFAND:    return(ltos(stol(arg1) && stol(arg2)));
  1229. X        case UFOR:    return(ltos(stol(arg1) || stol(arg2)));
  1230. X        case UFLENGTH:    return(itoa(strlen(arg1)));
  1231. X        case UFUPPER:    return(mkupper(arg1));
  1232. X        case UFLOWER:    return(mklower(arg1));
  1233. X        case UFTRUTH:    return(ltos(atoi(arg1) == 42));
  1234. X        case UFASCII:    return(itoa((int)arg1[0]));
  1235. X        case UFCHR:    result[0] = atoi(arg1);
  1236. X                result[1] = 0;
  1237. X                return(result);
  1238. X        case UFGTKEY:    result[0] = tgetc();
  1239. X                result[1] = 0;
  1240. X                return(result);
  1241. X        case UFRND:    return(itoa((ernd() % abs(atoi(arg1))) + 1));
  1242. X        case UFABS:    return(itoa(abs(atoi(arg1))));
  1243. X        case UFSINDEX:    return(itoa(sindex(arg1, arg2)));
  1244. X        case UFENV:
  1245. #if    ENVFUNC
  1246. X                return(getenv(arg1) == NULL ? "" : getenv(arg1));
  1247. #else
  1248. X                return("");
  1249. #endif
  1250. X        case UFBIND:    return(prc2engl(arg1));
  1251. X    }
  1252. X
  1253. X    exit(-11);    /* never should get here */
  1254. }
  1255. X
  1256. char *gtusr(vname)    /* look up a user var's value */
  1257. char *vname;        /* name of user variable to fetch */
  1258. {
  1259. X
  1260. X    register int vnum;    /* ordinal number of user var */
  1261. X
  1262. X    /* scan the list looking for the user var name */
  1263. X    for (vnum = 0; vnum < MAXVARS; vnum++)
  1264. X        if (strcmp(vname, uv[vnum].u_name) == 0)
  1265. X            break;
  1266. X
  1267. X    /* return errorm on a bad reference */
  1268. X    if (vnum == MAXVARS)
  1269. X        return(errorm);
  1270. X
  1271. X    return(uv[vnum].u_value);
  1272. }
  1273. X
  1274. char *gtenv(vname)
  1275. char *vname;        /* name of environment variable to retrieve */
  1276. {
  1277. X    register int vnum;    /* ordinal number of var refrenced */
  1278. X    char *getkill();
  1279. X
  1280. X    /* scan the list, looking for the referenced name */
  1281. X    for (vnum = 0; vnum < NEVARS; vnum++)
  1282. X        if (strcmp(vname, envars[vnum]) == 0)
  1283. X            break;
  1284. X
  1285. X    /* return errorm on a bad reference */
  1286. X    if (vnum == NEVARS)
  1287. X        return(errorm);
  1288. X
  1289. X    /* otherwise, fetch the appropriate value */
  1290. X    switch (vnum) {
  1291. X        case EVFILLCOL:    return(itoa(fillcol));
  1292. X        case EVPAGELEN:    return(itoa(term.t_nrow + 1));
  1293. X        case EVCURCOL:    return(itoa(getccol(FALSE)));
  1294. X        case EVCURLINE: return(itoa(getcline()));
  1295. X        case EVRAM:    return(itoa((int)(envram / 1024l)));
  1296. X        case EVFLICKER:    return(ltos(flickcode));
  1297. X        case EVCURWIDTH:return(itoa(term.t_nrow));
  1298. X        case EVCBUFNAME:return(curbp->b_bname);
  1299. X        case EVCFNAME:    return(curbp->b_fname);
  1300. X        case EVSRES:    return(sres);
  1301. X        case EVDEBUG:    return(ltos(macbug));
  1302. X        case EVSTATUS:    return(ltos(cmdstatus));
  1303. X        case EVPALETTE:    return(palstr);
  1304. X        case EVASAVE:    return(itoa(gasave));
  1305. X        case EVACOUNT:    return(itoa(gacount));
  1306. X        case EVLASTKEY: return(itoa(lastkey));
  1307. X        case EVCURCHAR:
  1308. X            return(curwp->w_dotp->l_used ==
  1309. X                    curwp->w_doto ? itoa('\n') :
  1310. X                itoa(lgetc(curwp->w_dotp, curwp->w_doto)));
  1311. X        case EVDISCMD:    return(ltos(discmd));
  1312. X        case EVVERSION:    return(version);
  1313. X        case EVPROGNAME:return(prognam);
  1314. X        case EVSEED:    return(itoa(seed));
  1315. X        case EVDISINP:    return(ltos(disinp));
  1316. X        case EVWLINE:    return(itoa(curwp->w_ntrows));
  1317. X        case EVCWLINE:    return(itoa(getwpos()));
  1318. X        case EVSEARCH:    return(pat);
  1319. X        case EVREPLACE:    return(rpat);
  1320. X        case EVMATCH:    return((patmatch == NULL)? "": patmatch);
  1321. X        case EVKILL:    return(getkill());
  1322. X        case EVCMODE:    return(itoa(curbp->b_mode));
  1323. X        case EVGMODE:    return(itoa(gmode));
  1324. X        case EVTPAUSE:    return(itoa(term.t_pause));
  1325. X        case EVPENDING:
  1326. #if    TYPEAH
  1327. X                return(ltos(typahead()));
  1328. #else
  1329. X                return(falsem);
  1330. #endif
  1331. X        case EVLWIDTH:    return(itoa(llength(curwp->w_dotp)));
  1332. X        case EVLINE:    return(getctext());
  1333. X    }
  1334. X    exit(-12);    /* again, we should never get here */
  1335. }
  1336. X
  1337. char *getkill()        /* return some of the contents of the kill buffer */
  1338. X
  1339. {
  1340. X    register int size;    /* max number of chars to return */
  1341. X    char value[NSTRING];    /* temp buffer for value */
  1342. X
  1343. X    if (kbs[0].kbufh == NULL)
  1344. X        /* no kill buffer....just a null string */
  1345. X        value[0] = 0;
  1346. X    else {
  1347. X        /* copy in the contents... */
  1348. X        if (kbs[0].kused < NSTRING)
  1349. X            size = kbs[0].kused;
  1350. X        else
  1351. X            size = NSTRING - 1;
  1352. X        strncpy(value, kbs[0].kbufh->d_chunk, size);
  1353. X    }
  1354. X
  1355. X    /* and return the constructed value */
  1356. X    return(value);
  1357. }
  1358. X
  1359. int setvar(f, n)        /* set a variable */
  1360. X
  1361. int f;        /* default flag */
  1362. int n;        /* numeric arg (can overide prompted value) */
  1363. X
  1364. {
  1365. X    register int status;    /* status return */
  1366. #if    DEBUGM
  1367. X    register char *sp;    /* temp string pointer */
  1368. X    register char *ep;    /* ptr to end of outline */
  1369. #endif
  1370. X    VDESC vd;        /* variable num/type */
  1371. X    static char var[NVSIZE+1];    /* name of variable to fetch */
  1372. X    char value[NSTRING];    /* value to set variable to */
  1373. X
  1374. X    /* first get the variable to set.. */
  1375. X    if (clexec == FALSE) {
  1376. X        status = mlreply("Variable to set: ", &var[0], NVSIZE);
  1377. X        if (status != TRUE)
  1378. X            return(status);
  1379. X    } else {    /* macro line argument */
  1380. X        /* grab token and skip it */
  1381. X        execstr = token(execstr, var);
  1382. X    }
  1383. X
  1384. X    /* check the legality and find the var */
  1385. X    findvar(var, &vd);
  1386. X    
  1387. X    /* if its not legal....bitch */
  1388. X    if (vd.v_type == -1) {
  1389. X        mlwrite("%%No such variable as '%s'", var);
  1390. X        return(FALSE);
  1391. X    }
  1392. X
  1393. X    /* get the value for that variable */
  1394. X    if (f == TRUE)
  1395. X        strcpy(value, itoa(n));
  1396. X    else {
  1397. X        value[0] = 0;
  1398. X        status = mlreply("Value: ", &value[0], NSTRING);
  1399. X        if (status != TRUE)
  1400. X            return(status);
  1401. X    }
  1402. X
  1403. X    /* and set the appropriate value */
  1404. X    status = svar(&vd, value);
  1405. X
  1406. #if    DEBUGM
  1407. X    /* if $debug == TRUE, every assignment will echo a statment to
  1408. X       that effect here. */
  1409. X    
  1410. X    if (macbug) {
  1411. X        strcpy(outline, "(((");
  1412. X
  1413. X        /* assignment status */
  1414. X        strcat(outline, ltos(status));
  1415. X        strcat(outline, ":");
  1416. X
  1417. X        /* variable name */
  1418. X        strcat(outline, var);
  1419. X        strcat(outline, ":");
  1420. X
  1421. X        /* and lastly the value we tried to assign */
  1422. X        strcat(outline, value);
  1423. X        strcat(outline, ")))");
  1424. X
  1425. X        /* expand '%' to "%%" so mlwrite wont bitch */
  1426. X        sp = outline;
  1427. X        while (*sp)
  1428. X            if (*sp++ == '%') {
  1429. X                /* advance to the end */
  1430. X                ep = --sp;
  1431. X                while (*ep++)
  1432. X                    ;
  1433. X                /* null terminate the string one out */
  1434. X                *(ep + 1) = 0;
  1435. X                /* copy backwards */
  1436. X                while(ep-- > sp)
  1437. X                    *(ep + 1) = *ep;
  1438. X
  1439. X                /* and advance sp past the new % */
  1440. X                sp += 2;                    
  1441. X            }
  1442. X
  1443. X        /* write out the debug line */
  1444. X        mlforce(outline);
  1445. X        update(TRUE);
  1446. X
  1447. X        /* and get the keystroke to hold the output */
  1448. X        if (kbd_key() == abortc) {
  1449. X            mlforce("[Macro aborted]");
  1450. X            status = FALSE;
  1451. X        }
  1452. X    }
  1453. #endif
  1454. X
  1455. X    /* and return it */
  1456. X    return(status);
  1457. }
  1458. X
  1459. findvar(var, vd)    /* find a variables type and name */
  1460. X
  1461. char *var;    /* name of var to get */
  1462. VDESC *vd;    /* structure to hold type and ptr */
  1463. X
  1464. {
  1465. X    register int vnum;    /* subscript in varable arrays */
  1466. X    register int vtype;    /* type to return */
  1467. X
  1468. fvar:    vtype = -1;
  1469. X    switch (var[0]) {
  1470. X
  1471. X        case '$': /* check for legal enviromnent var */
  1472. X            for (vnum = 0; vnum < NEVARS; vnum++)
  1473. X                if (strcmp(&var[1], envars[vnum]) == 0) {
  1474. X                    vtype = TKENV;
  1475. X                    break;
  1476. X                }
  1477. X            break;
  1478. X
  1479. X        case '%': /* check for existing legal user variable */
  1480. X            for (vnum = 0; vnum < MAXVARS; vnum++)
  1481. X                if (strcmp(&var[1], uv[vnum].u_name) == 0) {
  1482. X                    vtype = TKVAR;
  1483. X                    break;
  1484. X                }
  1485. X            if (vnum < MAXVARS)
  1486. X                break;
  1487. X
  1488. X            /* create a new one??? */
  1489. X            for (vnum = 0; vnum < MAXVARS; vnum++)
  1490. X                if (uv[vnum].u_name[0] == 0) {
  1491. X                    vtype = TKVAR;
  1492. X                    strcpy(uv[vnum].u_name, &var[1]);
  1493. X                    break;
  1494. X                }
  1495. X            break;
  1496. X
  1497. X        case '&':    /* indirect operator? */
  1498. X            var[4] = 0;
  1499. X            if (strcmp(&var[1], "ind") == 0) {
  1500. X                /* grab token, and eval it */
  1501. X                execstr = token(execstr, var);
  1502. X                strcpy(var, tokval(var));
  1503. X                goto fvar;
  1504. X            }
  1505. X    }
  1506. X
  1507. X    /* return the results */
  1508. X    vd->v_num = vnum;
  1509. X    vd->v_type = vtype;
  1510. X    return;
  1511. }
  1512. X
  1513. int svar(var, value)        /* set a variable */
  1514. X
  1515. VDESC *var;    /* variable to set */
  1516. char *value;    /* value to set to */
  1517. X
  1518. {
  1519. X    register int vnum;    /* ordinal number of var refrenced */
  1520. X    register int vtype;    /* type of variable to set */
  1521. X    register int status;    /* status return */
  1522. X    register int c;        /* translated character */
  1523. X    register char * sp;    /* scratch string pointer */
  1524. X
  1525. X    /* simplify the vd structure (we are gonna look at it a lot) */
  1526. X    vnum = var->v_num;
  1527. X    vtype = var->v_type;
  1528. X
  1529. X    /* and set the appropriate value */
  1530. X    status = TRUE;
  1531. X    switch (vtype) {
  1532. X    case TKVAR: /* set a user variable */
  1533. X        if (uv[vnum].u_value != NULL)
  1534. X            free(uv[vnum].u_value);
  1535. X        sp = malloc(strlen(value) + 1);
  1536. X        if (sp == NULL)
  1537. X            return(FALSE);
  1538. X        strcpy(sp, value);
  1539. X        uv[vnum].u_value = sp;
  1540. X        break;
  1541. X
  1542. X    case TKENV: /* set an environment variable */
  1543. X        status = TRUE;    /* by default */
  1544. X        switch (vnum) {
  1545. X        case EVFILLCOL:    fillcol = atoi(value);
  1546. X                break;
  1547. X        case EVCURCOL:    status = gotocol(TRUE,atoi(value));
  1548. X                break;
  1549. X        case EVCURLINE:    status = gotoline(TRUE, atoi(value));
  1550. X                break;
  1551. X        case EVRAM:    break;
  1552. X        case EVFLICKER:    flickcode = stol(value);
  1553. X                break;
  1554. X        case EVCURWIDTH:status = newwidth(TRUE, atoi(value));
  1555. X                break;
  1556. X        case EVPAGELEN:    status = newlength(TRUE,atoi(value));
  1557. X                break;
  1558. X        case EVCBUFNAME:strcpy(curbp->b_bname, value);
  1559. X                curwp->w_flag |= WFMODE;
  1560. X                break;
  1561. X        case EVCFNAME:    strcpy(curbp->b_fname, value);
  1562. X                curwp->w_flag |= WFMODE;
  1563. X                break;
  1564. X        case EVSRES:    status = TTrez(value);
  1565. X                break;
  1566. X        case EVDEBUG:    macbug = stol(value);
  1567. X                break;
  1568. X        case EVSTATUS:    cmdstatus = stol(value);
  1569. X                break;
  1570. X        case EVPALETTE:    strncpy(palstr, value, 48);
  1571. X                spal(palstr);
  1572. X                break;
  1573. X        case EVASAVE:    gasave = atoi(value);
  1574. X                break;
  1575. X        case EVACOUNT:    gacount = atoi(value);
  1576. X                break;
  1577. X        case EVLASTKEY:    lastkey = atoi(value);
  1578. X                break;
  1579. X        case EVCURCHAR:    ldelete(1, FALSE);    /* delete 1 char */
  1580. X                c = atoi(value);
  1581. X                if (c == '\n')
  1582. X                    lnewline(FALSE, 1);
  1583. X                else
  1584. X                    linsert(1, c);
  1585. X                backchar(FALSE, 1);
  1586. X                break;
  1587. X        case EVDISCMD:    discmd = stol(value);
  1588. X                break;
  1589. X        case EVVERSION:    break;
  1590. X        case EVPROGNAME:break;
  1591. X        case EVSEED:    seed = atoi(value);
  1592. X                break;
  1593. X        case EVDISINP:    disinp = stol(value);
  1594. X                break;
  1595. X        case EVWLINE:    status = resize(TRUE, atoi(value));
  1596. X                break;
  1597. X        case EVCWLINE:    status = forwline(TRUE,
  1598. X                        atoi(value) - getwpos());
  1599. X                break;
  1600. X        case EVSEARCH:    strcpy(pat, value);
  1601. X                rvstrcpy(tap, pat);
  1602. X                mcclear();
  1603. X                break;
  1604. X        case EVREPLACE:    strcpy(rpat, value);
  1605. X                break;
  1606. X        case EVMATCH:    break;
  1607. X        case EVKILL:    break;
  1608. X        case EVCMODE:    curbp->b_mode = atoi(value);
  1609. X                curwp->w_flag |= WFMODE;
  1610. X                break;
  1611. X        case EVGMODE:    gmode = atoi(value);
  1612. X                break;
  1613. X        case EVTPAUSE:    term.t_pause = atoi(value);
  1614. X                break;
  1615. X        case EVPENDING:    break;
  1616. X        case EVLWIDTH:    break;
  1617. X        case EVLINE:    putctext(value);
  1618. X        }
  1619. X        break;
  1620. X    }
  1621. X    return(status);
  1622. }
  1623. #endif
  1624. X
  1625. /*    atoi:    ascii string to integer......This is too
  1626. X        inconsistant to use the system's    */
  1627. X
  1628. atoi(st)
  1629. char *st;
  1630. {
  1631. X    int result;    /* resulting number */
  1632. X    int sign;    /* sign of resulting number */
  1633. X    char c;        /* current char being examined */
  1634. X
  1635. X    result = 0;
  1636. X    sign = 1;
  1637. X
  1638. X    /* skip preceding whitespace */
  1639. X    while (isspace(*st))
  1640. X        ++st;
  1641. X
  1642. X    /* check for sign */
  1643. X    if (*st == '-') {
  1644. X        sign = -1;
  1645. X        ++st;
  1646. X    }
  1647. X    if (*st == '+')
  1648. X        ++st;
  1649. X
  1650. X    /* scan digits, build value */
  1651. X    while ((c = *st++))
  1652. X        if (isdigit(c))
  1653. X            result = result * 10 + c - '0';
  1654. X        else
  1655. X            return(0);
  1656. X
  1657. X    return(result * sign);
  1658. }
  1659. X
  1660. #if ! SMALLER
  1661. X
  1662. /*    itoa:    integer to ascii string.......... This is too
  1663. X        inconsistant to use the system's    */
  1664. X
  1665. char *itoa(i)
  1666. int i;    /* integer to translate to a string */
  1667. {
  1668. X    register int digit;        /* current digit being used */
  1669. X    register char *sp;        /* pointer into result */
  1670. X    register int sign;        /* sign of resulting number */
  1671. X    static char result[INTWIDTH+1];    /* resulting string */
  1672. X
  1673. X    /* record the sign...*/
  1674. X    sign = 1;
  1675. X    if (i < 0) {
  1676. X        sign = -1;
  1677. X        i = -i;
  1678. X    }
  1679. X
  1680. X    /* and build the string (backwards!) */
  1681. X    sp = result + INTWIDTH;
  1682. X    *sp = 0;
  1683. X    do {
  1684. X        digit = i % 10;
  1685. X        *(--sp) = '0' + digit;    /* and install the new digit */
  1686. X        i = i / 10;
  1687. X    } while (i);
  1688. X
  1689. X    /* and fix the sign */
  1690. X    if (sign == -1) {
  1691. X        *(--sp) = '-';    /* and install the minus sign */
  1692. X    }
  1693. X
  1694. X    return(sp);
  1695. }
  1696. #endif
  1697. X
  1698. int toktyp(tokn)    /* find the type of a passed token */
  1699. char *tokn;    /* token to analyze */
  1700. {
  1701. X    register char c;    /* first char in token */
  1702. X
  1703. X    /* grab the first char (this is all we need) */
  1704. X    c = *tokn;
  1705. X
  1706. X    /* no blanks!!! */
  1707. X    if (c == 0)
  1708. X        return(TKNUL);
  1709. X
  1710. X    /* a numeric literal? */
  1711. X    if (isdigit(c))
  1712. X        return(TKLIT);
  1713. X
  1714. #if ! SMALLER
  1715. X    switch (c) {
  1716. X        case '"':    return(TKSTR);
  1717. X
  1718. X        case '~':    return(TKDIR);
  1719. X        case '@':    return(TKARG);
  1720. X        case '#':    return(TKBUF);
  1721. X        case '$':    return(TKENV);
  1722. X        case '%':    return(TKVAR);
  1723. X        case '&':    return(TKFUN);
  1724. X        case '*':    return(TKLBL);
  1725. X
  1726. X        default:    return(TKCMD);
  1727. X    }
  1728. #else
  1729. X    return(TKCMD);
  1730. #endif
  1731. }
  1732. X
  1733. char *
  1734. tokval(tokn)    /* find the value of a token */
  1735. char *tokn;        /* token to evaluate */
  1736. {
  1737. #if ! SMALLER
  1738. X    register int status;    /* error return */
  1739. X    register BUFFER *bp;    /* temp buffer pointer */
  1740. X    register int blen;    /* length of buffer argument */
  1741. X    register int distmp;    /* temporary discmd flag */
  1742. X    char pad[20];        /* pad 20 bytes on stack for safety */
  1743. X    char buf[NSTRING];    /* string buffer for some returns */
  1744. X
  1745. X    switch (toktyp(tokn)) {
  1746. X        case TKNUL:    return("");
  1747. X
  1748. X        case TKARG:    /* interactive argument */
  1749. X                strcpy(tokn, tokval(&tokn[1]));
  1750. X                distmp = discmd;    /* echo it always! */
  1751. X                discmd = TRUE;
  1752. X                status = kbd_string(tokn,
  1753. X                       buf, NSTRING, '\n',EXPAND);
  1754. X                discmd = distmp;
  1755. X                if (status == ABORT)
  1756. X                    return(errorm);
  1757. X                return(buf);
  1758. X
  1759. X        case TKBUF:    /* buffer contents fetch */
  1760. X
  1761. X                /* grab the right buffer */
  1762. X                strcpy(tokn, tokval(&tokn[1]));
  1763. X                bp = bfind(tokn, NO_CREAT, 0);
  1764. X                if (bp == NULL)
  1765. X                    return(errorm);
  1766. X        
  1767. X                /* if the buffer is displayed, get the window
  1768. X                   vars instead of the buffer vars */
  1769. X                if (bp->b_nwnd > 0) {
  1770. X                    curbp->b_dotp = curwp->w_dotp;
  1771. X                    curbp->b_doto = curwp->w_doto;
  1772. X                }
  1773. X
  1774. X                /* make sure we are not at the end */
  1775. X                if (bp->b_linep == bp->b_dotp)
  1776. X                    return(errorm);
  1777. X        
  1778. X                /* grab the line as an argument */
  1779. X                blen = bp->b_dotp->l_used - bp->b_doto;
  1780. X                if (blen > NSTRING)
  1781. X                    blen = NSTRING;
  1782. X                strncpy(buf, bp->b_dotp->l_text + bp->b_doto,
  1783. X                    blen);
  1784. X                buf[blen] = 0;
  1785. X        
  1786. X                /* and step the buffer's line ptr ahead a line */
  1787. X                bp->b_dotp = bp->b_dotp->l_fp;
  1788. X                bp->b_doto = 0;
  1789. X
  1790. X                /* if displayed buffer, reset window ptr vars*/
  1791. X                if (bp->b_nwnd > 0) {
  1792. X                    curwp->w_dotp = curbp->b_dotp;
  1793. X                    curwp->w_doto = 0;
  1794. X                    curwp->w_flag |= WFMOVE;
  1795. X                }
  1796. X
  1797. X                /* and return the spoils */
  1798. X                return(buf);        
  1799. X
  1800. X        case TKVAR:    return(gtusr(tokn+1));
  1801. X        case TKENV:    return(gtenv(tokn+1));
  1802. X        case TKFUN:    return(gtfun(tokn+1));
  1803. X        case TKDIR:    return(errorm);
  1804. X        case TKLBL:    return(itoa(gtlbl(tokn)));
  1805. X        case TKLIT:    return(tokn);
  1806. X        case TKSTR:    return(tokn+1);
  1807. X        case TKCMD:    return(tokn);
  1808. X    }
  1809. #else
  1810. X    return tokn;
  1811. #endif
  1812. }
  1813. X
  1814. #if ! SMALLER
  1815. X
  1816. gtlbl(tokn)    /* find the line number of the given label */
  1817. char *tokn;    /* label name to find */
  1818. {
  1819. X    return(1);
  1820. }
  1821. X
  1822. int stol(val)    /* convert a string to a numeric logical */
  1823. char *val;    /* value to check for stol */
  1824. {
  1825. X    /* check for logical values */
  1826. X    if (val[0] == 'F')
  1827. X        return(FALSE);
  1828. X    if (val[0] == 'T')
  1829. X        return(TRUE);
  1830. X
  1831. X    /* check for numeric truth (!= 0) */
  1832. X    return((atoi(val) != 0));
  1833. }
  1834. X
  1835. char *ltos(val)        /* numeric logical to string logical */
  1836. int val;    /* value to translate */
  1837. {
  1838. X    if (val)
  1839. X        return(truem);
  1840. X    else
  1841. X        return(falsem);
  1842. }
  1843. X
  1844. char *mkupper(str)    /* make a string upper case */
  1845. char *str;        /* string to upper case */
  1846. {
  1847. X    char *sp;
  1848. X
  1849. X    sp = str;
  1850. X    while (*sp) {
  1851. X        if (islower(*sp))
  1852. X            *sp += 'A' - 'a';
  1853. X        ++sp;
  1854. X    }
  1855. X    return(str);
  1856. }
  1857. #endif
  1858. X
  1859. #if ! SMALLER || MSDOS
  1860. X
  1861. char *mklower(str)    /* make a string lower case */
  1862. char *str;        /* string to lower case */
  1863. {
  1864. X    char *sp;
  1865. X
  1866. X    sp = str;
  1867. X    while (*sp) {
  1868. X        if (isupper(*sp))
  1869. X            *sp += 'a' - 'A';
  1870. X        ++sp;
  1871. X    }
  1872. X    return(str);
  1873. }
  1874. #endif
  1875. X
  1876. #if ! SMALLER
  1877. X
  1878. int abs(x)    /* take the absolute value of an integer */
  1879. int x;
  1880. {
  1881. X    return(x < 0 ? -x : x);
  1882. }
  1883. X
  1884. int ernd()    /* returns a random integer */
  1885. {
  1886. X    seed = abs(seed * 1721 + 10007);
  1887. X    return(seed);
  1888. }
  1889. X
  1890. int sindex(source, pattern)    /* find pattern within source */
  1891. char *source;    /* source string to search */
  1892. char *pattern;    /* string to look for */
  1893. {
  1894. X    char *sp;    /* ptr to current position to scan */
  1895. X    char *csp;    /* ptr to source string during comparison */
  1896. X    char *cp;    /* ptr to place to check for equality */
  1897. X
  1898. X    /* scanning through the source string */
  1899. X    sp = source;
  1900. X    while (*sp) {
  1901. X        /* scan through the pattern */
  1902. X        cp = pattern;
  1903. X        csp = sp;
  1904. X        while (*cp) {
  1905. X            if (!eq(*cp, *csp))
  1906. X                break;
  1907. X            ++cp;
  1908. X            ++csp;
  1909. X        }
  1910. X
  1911. X        /* was it a match? */
  1912. X        if (*cp == 0)
  1913. X            return((int)(sp - source) + 1);
  1914. X        ++sp;
  1915. X    }
  1916. X
  1917. X    /* no match at all.. */
  1918. X    return(0);
  1919. }
  1920. X
  1921. #endif
  1922. SHAR_EOF
  1923. chmod 0444 eval.c ||
  1924. echo 'restore of eval.c failed'
  1925. Wc_c="`wc -c < 'eval.c'`"
  1926. test 18430 -eq "$Wc_c" ||
  1927.     echo 'eval.c: original size 18430, current size' "$Wc_c"
  1928. # ============= evar.h ==============
  1929. echo 'x - extracting evar.h (Text)'
  1930. sed 's/^X//' << 'SHAR_EOF' > 'evar.h' &&
  1931. /*    EVAR.H:    Environment and user variable definitions
  1932. X        for MicroEMACS (and now vile)
  1933. X
  1934. X        written 1986 by Daniel Lawrence
  1935. */
  1936. X
  1937. #if !SMALLER
  1938. X
  1939. /*    structure to hold user variables and their definitions    */
  1940. X
  1941. typedef struct UVAR {
  1942. X    char u_name[NVSIZE + 1];        /* name of user variable */
  1943. X    char *u_value;                /* value (string) */
  1944. } UVAR;
  1945. X
  1946. /*    current user variables (This structure will probably change)    */
  1947. X
  1948. #define    MAXVARS        255
  1949. X
  1950. UVAR uv[MAXVARS];    /* user variables */
  1951. SHAR_EOF
  1952. true || echo 'restore of evar.h failed'
  1953. echo 'End of Vile part 5'
  1954. echo 'File evar.h is continued in part 6'
  1955. echo 6 > _shar_seq_.tmp
  1956. exit 0
  1957. -- 
  1958.         paul fox, pgf@cayman.com, (617)494-1999
  1959.         Cayman Systems, 26 Landsdowne St., Cambridge, MA 02139
  1960.