开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
ledLib.c
资源名称：vxwork_src.rar　[点击查看]
上传用户：nvosite88
上传日期：2007-01-17
资源大小：4983k
文件大小：49k
源码类别：

VxWorks

开发平台：

C/C++

ledLib.c：源码内容
  1. /* ledLib.c - line-editing library */
  3. /* Copyright 1984-2001 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7. modification history
  8. --------------------
  9. 02w,18oct01,fmk  add routine description to fix doc build errors
  10. 02v,27sep01,dcb  Fix SPR 21697.  Free the ledId that was allocated in ledOpen.
  11.                    Compiler warning clean up.
  12. 02u,14jul97,dgp  doc: change ^ to CTRL- in cursor movement descriptions
  13. 02t,31oct96,elp  Replaced symAdd() call by symSAdd() call (symtbls synchro).
  14. 02s,23nov93,jmm  ledRead now ignores NULL characters (spr 2666)
  15. 02r,20jan93,jdi  documentation cleanup for 5.1.
  16. 02q,19oct92,jcf  fixed esc-space garbage.
  17. 02p,23aug92,jcf  fixed esc-k garbage when first commaned.
  18. 02o,20jul92,jmm  added group parameter to symAdd call
  19. 02n,18jul92,smb  Changed errno.h to errnoLib.h.
  20. 02m,26may92,rrr  the tree shuffle
  21. 02l,19mar92,jmm  fixed problem in histAdd and histAll w/long lines in history
  22.                  SPR #1381
  23. 02k,20dec91,gae  stopped blow ups when using history for first time.
  24.  removed nulls from output stream in histAll().
  25. 02j,10dec91,gae  added includes for ANSI.
  26. 02i,04oct91,rrr  passed through the ansification filter
  27.                   -changed functions to ansi style
  28.   -changed includes to have absolute path from h/
  29.   -fixed #else and #endif
  30.   -changed VOID to void
  31.   -changed copyright notice
  32. 02h,05apr91,jdi  documentation -- removed header parens and x-ref numbers;
  33.  doc review by gae.
  34. 02g,08feb91,jaa  documentation cleanup.
  35. 02f,25oct90,gae  fixed ignoring of previously set ty options - per Hdei Nunoe.
  36. 02e,10aug90,dnw  changed declaration of ledClose from void to STATUS.
  37. 02d,10aug90,kdl  added forward declarations for functions returning void.
  38. 02c,11may90,yao  added missing modification history (02b) for the last checkin.
  39. 02b,09may90,yao  typecasted malloc to (char *).
  40. 02a,15apr90,jcf  changed symbol type to SYM_TYPE.
  41. 01z,14mar90,jdi  documentation cleanup.
  42. 01y,22feb90,dab  fixed glitch in ledRead()'s 's' cmd. documentation.
  43. 01x,10nov89,dab  fixed 'x' cmd bug in ledRead(). fixed bfill() bug in ledRead().
  44.    fixed EOF bug in ledRead(). added 's' cmd to ledRead()'s vi
  45.    interface.
  46. 01w,13jun89,gae  fixed glitch in 01v caused by histSize not being init'd.
  47. 01v,01may89,dab  histInit() now keeps past history when size is changed.
  48. 01u,24sep88,gae  documentation touchup.
  49. 01t,30aug88,gae  documentation.
  50. 01s,10aug88,gae  fixed "static" bug in histInit()
  51. 01r,22jun88,dnw  changed bmove() to bcopy() since bcopy() now handles
  52.    overlapping buffers.
  53. 01q,30may88,dnw  changed to v4 names.
  54. 01p,09nov87,gae  changed name (again) from kornLib.c.
  55. 01o,03nov87,ecs  documenation.
  56. 01n,02nov87,gae  documenation.
  57. 01m,24oct87,gae  changed name from shellLib.c.  Fixed history mechanism:
  58.    added histInit() and removed built-in "h".
  59. 01l,17aug87,gae  Made re-entrant, viz. useable by programs other than the shell.
  60.  Fixed history bug.  Added symbol name completion.
  61. 01k,24jul87,gae  imported ty{Backspace,DeleteLine,Eof}Char's from tyLib.c
  62.    and used instead of constants.
  63. 01j,07apr87,jlf  deleted shHistDelete, which was unused, to appease lint.
  64. 01i,01apr87,ecs  delinted.
  65. 01h,19mar87,jlf  added copyright.
  66.    +gae  minor fixes for mangen.
  67.  documentation.
  68. 01g,12mar87,gae  little fix in shHistFind() for bug with 'n'.
  69. 01f,02feb87,gae  added writex() so control chars will be printed as '?';
  70.    also done in shHistAll().  Improved motion (maybe);
  71.    added redraw (^L); made undo nicer; allowed replace to
  72.    be cancelled with ESC; fixed shHistFind() bug.
  73.  Added UNIX_DEBUG ability.
  74. 01e,19jan87,gae  included memLib.h to appease lint.
  75. 01d,14jan87,gae  made history use a free list, history search works
  76.    within lines not just at beginning, command mode default
  77.    after search, made history number increment properly;
  78.    saved space by making curLn a pointer to the user's string,
  79.    and more...
  80. 01c,20dec86,dnw  changed to not get include files from default directories.
  81.  replaced spaces[] and bksps[] with writen() (vax compiler
  82.    complained about line too long).
  83. 01b,18dec86,gae  various bug fixes & improvements.
  84. 01a,23oct86,gae  written
  85. */
  87. /*
  88. DESCRIPTION
  89. This library provides a line-editing layer on top of a `tty' device.
  90. The shell uses this interface for its history-editing features.
  92. The shell history mechanism is similar to the UNIX Korn shell history
  93. facility, with a built-in line-editor similar to UNIX f3vifP that allows
  94. previously typed commands to be edited.  The command h() displays the 20
  95. most recent commands typed into the shell; old commands fall off the top
  96. as new ones are entered.
  98. To edit a command, type ESC to enter edit mode, and use the commands
  99. listed below.  The ESC key switches the shell to edit mode.  The RETURN
  100. key always gives the line to the shell from either editing or input mode.
  102. The following list is a summary of the commands available in edit mode.
  104. .TS
  105. tab(|);
  106. l s
  107. lf9 l.
  108. Movement and search commands:
  109. .sp .25
  110. <n>G | - Go to command number <n>.
  111. /<s> | - Search for string <s> backward in history.
  112. ?<s> | - Search for string <s> forward in history.
  113. n | - Repeat last search.
  114. N | - Repeat last search in opposite direction.
  115. <n>k | - Get <n>th previous shell command in history.
  116. <n>- | - Same as "k".
  117. <n>j | - Get <n>th next shell command in history.
  118. <n>+ | - Same as "j".
  119. <n>h | - Move left <n> characters.
  120. CTRL-H | - Same as "h".
  121. <n>l | - Move right <n> characters.
  122. f1SPACEfP | - Same as "l".
  123. <n>w | - Move <n> words forward.
  124. <n>W | - Move <n> blank-separated words forward.
  125. <n>e | - Move to end of the <n>th next word.
  126. <n>E | - Move to end of the <n>th next blank-separated word.
  127. <n>b | - Move back <n> words.
  128. <n>B | - Move back <n> blank-separated words.
  129. f<c> | - Find character <c>, searching forward.
  130. F<c> | - Find character <c>, searching backward.
  131. ^ | - Move cursor to first non-blank character in line.
  132. $ | - Go to end of line.
  133. 0 | - Go to beginning of line.
  135. .T&
  136. l s
  137. lf9 l.
  138. Insert commands (input is expected until an ESC is typed):
  139. .sp .25
  140. a | - Append.
  141. A | - Append at end of line.
  142. c f1SPACEfP | - Change character.
  143. cl | - Change character.
  144. cw | - Change word.
  145. cc | - Change entire line.
  146. c$ | - Change everything from cursor to end of line.
  147. C | - Same as "c$".
  148. S | - Same as "cc".
  149. i | - Insert.
  150. I | - Insert at beginning of line.
  151. R | - Type over characters.
  153. .T&
  154. l s
  155. lf9 l.
  156. Editing commands:
  157. .sp .25
  158. <n>r<c> | - Replace the following <n> characters with <c>.
  159. <n>x | - Delete <n> characters starting at cursor.
  160. <n>X | - Delete <n> characters to the left of the cursor.
  161. d f1SPACEfP | - Delete character.
  162. dl | - Delete character.
  163. dw | - Delete word.
  164. dd | - Delete entire line.
  165. d$ | - Delete everything from cursor to end of line.
  166. D | - Same as "d$".
  167. p | - Put last deletion after the cursor.
  168. P | - Put last deletion before the cursor.
  169. u | - Undo last command.
  170. ~ | - Toggle case, lower to upper or vice versa.
  172. .T&
  173. l s
  174. lf9 l.
  175. Special commands:
  176. .sp .25
  177. CTRL-U | - Delete line and leave edit mode.
  178. CTRL-L | - Redraw line.
  179. CTRL-D | - Complete symbol name.
  180. f1RETURNfP | - Give line to shell and leave edit mode.
  181. .TE
  183. The default value for <n> is 1.
  185. DEFICIENCIES
  186. Since the shell toggles between raw mode and line mode, type-ahead can be
  187. lost.  The ESC, redraw, and non-printable characters are built-in.  The
  188. EOF, backspace, and line-delete are not imported well from tyLib.
  189. Instead, tyLib should supply and/or support these characters
  190. via ioctl().
  192. Some commands do not take counts as users might expect.  For example,
  193. "<n>i" will not insert whatever was entered <n> times.
  195. INCLUDE FILES: ledLib.h
  197. SEE ALSO:
  198. .pG "Shell"
  200. INTERNAL
  201. LINE_LEN should be specifed elsewhere.
  202. In an attempt to economize shell stack space, the "string" parameter is
  203. written in up to LINE_LEN!  An EOS is used at the beginning of the string
  204. as well, thus only LINE_LEN-1 places are returned.
  205. */
  207. #include "vxWorks.h"
  208. #include "ctype.h"
  209. #include "errnoLib.h"
  210. #include "ioLib.h"
  211. #include "lstLib.h"
  212. #include "memLib.h"
  213. #include "stdlib.h"
  214. #include "stdio.h"
  215. #include "unistd.h"
  216. #include "string.h"
  217. #include "iosLib.h"
  218. #include "sysSymTbl.h"
  219. #include "symLib.h"
  220. #include "symbol.h"
  223. /* to debug under UNIX:
  224. cc -O -I$vh -DPORTABLE -c bLib.c
  225. cc -O -I$vh -DUNIX_DEBUG -o ledLib ledLib.c $v/lib/host/vxWorks.a symLib.o bLib.o
  226. */
  228. #ifdef UNIX_DEBUG
  230. #undef EOF
  231. #undef NULL
  233. #include "stdio.h"
  235. char tyBackspaceChar = 0x08; /* default is control-H */
  236. char tyDeleteLineChar = 0x15; /* default is control-U */
  237. char tyEofChar = 0x04; /* default is control-D */
  239. SYMTAB_ID sysSymTbl;
  241. #endif /* UNIX_DEBUG */
  243. IMPORT char tyBackspaceChar; /* default is control-H */
  244. IMPORT char tyDeleteLineChar; /* default is control-U */
  245. IMPORT char tyEofChar; /* default is control-D */
  247. #define CMP_CHAR 0x04 /* symbol name completion */
  248. #define BEL_CHAR 0x07 /* bell */
  249. #define RET_CHAR 'n' /* return */
  250. #define ESC_CHAR 0x1b /* escape */
  251. #define NON_CHAR '?' /* non-printable char. representation */
  252. #define RDW_CHAR 0x0c /* redraw */
  254. #define LINE_LEN 128 /* >= MAX_SHELL_LINE! */
  256. #define BACKWARD (-1)
  257. #define FORWARD 1
  259. #define save()     if (strlen (saveLn) == 0) strcpy (saveLn, curLn)
  261. typedef struct /* CMP_ARG */
  262.     {
  263.     int count;
  264.     int nameLen;
  265.     char *name;
  266.     char *match;
  267.     } CMP_ARG;
  269. typedef struct /* HIST */
  270.     {
  271.     NODE node;
  272.     char line [LINE_LEN+1];
  273.     } HIST;
  276. typedef struct /* LED */
  277.     {
  278.     int inFd;
  279.     int outFd;
  280.     int histSize;
  281.     LIST histFreeList;
  282.     LIST histList;
  283.     HIST *pHist;
  285.     /* XXX the following are not needed between ledRead's
  286.      *     but are used in support routines.
  287.      */
  289.     char *buffer; /* hold deletions from curLn */
  290.     int histNum; /* current history number */
  291.     BOOL cmdMode; /* insert or command mode */
  292.     } LED;
  294. typedef LED *LED_ID;
  297. /* forward static functions */
  299. static void setPreempt (FUNCPTR *catchFunc, FUNCPTR func);
  300. static int preempt (FUNCPTR *catchFunc, char ch, char *curLn, int *curPs, int
  301. *number, LED_ID ledId);
  302. static void redraw (int outFd, char *oldLn, int lastPs, char *curLn, int
  303. *curPs);
  304. static BOOL completeName (char *curLn, int *curPs);
  305. static BOOL findName (char *name, char *value, SYM_TYPE type, CMP_ARG *arg);
  306. static void search (BOOL ignorePunct, BOOL endOfWord, char *curLn, int
  307. *curPs, int dir);
  308. static BOOL find (char ch, char *curLn, int *curPs, int dir);
  309. static STATUS findFwd (char ch, char *curLn, int *curPs, int *number);
  310. static STATUS findBwd (char ch, char *curLn, int *curPs, int *number);
  311. static STATUS change (char ch, char *curLn, int *curPs, int *number, LED_ID
  312. ledId);
  313. static STATUS deletec (char ch, char *curLn, int *curPs, int *number, LED_ID
  314. ledId);
  315. static STATUS replace (char ch, char *curLn, int *curPs, int *number);
  316. static void beep (int outFd);
  317. static int writex (int fd, char buffer [ ], int nbytes);
  318. static int writen (int fd, char ch, int nbytes);
  319. static void histInit (LED_ID ledId, int histSize);
  320. static void histAdd (LED_ID ledId, char *line);
  321. static BOOL histNum (LED_ID ledId, char *line, int n);
  322. static STATUS histNext (LED_ID ledId, char *line);
  323. static STATUS histPrev (LED_ID ledId, char *line);
  324. static BOOL histFind (LED_ID ledId, char *match, char *line);
  325. static void histAll (LED_ID ledId);
  328. /*******************************************************************************
  329. *
  330. * ledOpen - create a new line-editor ID
  331. *
  332. * This routine creates the ID that is used by ledRead(), ledClose(), and
  333. * ledControl().  Storage is allocated for up to <histSize> previously read
  334. * lines.
  335. *
  336. * RETURNS: The line-editor ID, or ERROR if the routine runs out of memory.
  337. *
  338. * SEE ALSO: ledRead(), ledClose(), ledControl()
  339. */
  341. int ledOpen
  342.     (
  343.     int inFd,           /* low-level device input fd */
  344.     int outFd,          /* low-level device output fd */
  345.     int histSize        /* size of history list */
  346.     )
  347.     {
  348.     LED_ID ledId = (LED_ID)calloc (1, sizeof (LED));
  350.     if (ledId == NULL)
  351. return (ERROR);
  353.     if ((ledId->buffer = (char *) malloc (LINE_LEN + 1)) == NULL)
  354. return (ERROR);
  356.     ledId->inFd  = inFd;
  357.     ledId->outFd = outFd;
  359.     lstInit (&ledId->histList);
  360.     lstInit (&ledId->histFreeList);
  362.     histInit (ledId, histSize);
  364.     return ((int) ledId);
  365.     }
  366. /*******************************************************************************
  367. *
  368. * ledClose - discard the line-editor ID
  369. *
  370. * This routine frees resources allocated by ledOpen().  The low-level
  371. * input/output file descriptors are not closed.
  372. *
  373. * RETURNS: OK.
  374. *
  375. * SEE ALSO: ledOpen()
  376. */
  378. STATUS ledClose
  379.     (
  380.     int led_id          /* ID returned by ledOpen */
  381.     )
  382.     {
  383.     FAST LED_ID ledId = (LED_ID)led_id;
  385.     lstFree (&ledId->histList);
  386.     lstFree (&ledId->histFreeList);
  388.     free (ledId->buffer);
  389.     free (ledId);
  390.     
  391.     return (OK);
  392.     }
  393. /*******************************************************************************
  394. *
  395. * ledRead - read a line with line-editing
  396. *
  397. * This routine handles line-editing and history substitutions.
  398. * If the low-level input file descriptor is not in OPT_LINE mode,
  399. * only an ordinary read() routine will be performed.
  400. *
  401. * RETURNS: The number of characters read, or EOF.
  402. */
  404. int ledRead
  405.     (
  406.     int led_id,         /* ID returned by ledOpen */
  407.     char *string,       /* where to return line */
  408.     int maxBytes        /* maximum number of chars to read */
  409.     )
  410.     {
  411.     FAST LED_ID ledId = (LED_ID)led_id;
  412.     FAST int ix; /* the ubiquitous */
  413.     char ch; /* last character entered */
  414.     BOOL overStrike = FALSE; /* in over-strike mode */
  415.     BOOL srchMode = FALSE; /* entering search characters */
  416.     BOOL done = FALSE; /* return has been entered */
  417.     int returnVal = EOF; /* number of characters or EOF */
  418.     int result; /* return value from preempt */
  419.     char oldLn  [LINE_LEN+1]; /* current line before most recent input*/
  420.     char saveLn [LINE_LEN+1]; /* saved version of line before changes */
  421.     char histLn [LINE_LEN+1]; /* last version of historical line */
  422.     char *curLn; /* current line, points to user's string*/
  423.     int curPs = 0; /* current cursor position */
  424.     int lastPs = 0; /* last position cursor was at */
  425.     int number = 0; /* repeat factor */
  426.     FUNCPTR catchFunc; /* preempt routine */
  427. #ifndef UNIX_DEBUG
  428.     int oldoptions = ioctl (ledId->inFd, FIOGETOPTIONS, 0 /*XXX*/);
  430.     /* XXX should be check for ERROR except an option might be 0xff,
  431.      * perhaps inspect errno for valid 'fd', or something.
  432.      */
  434.     /* if not in line mode, just do plain read */
  436.     if (!(oldoptions & OPT_LINE))
  437. return (read (ledId->inFd, string, maxBytes));
  439.     /* turn off echo & line mode */
  440.     ioctl (ledId->inFd, FIOSETOPTIONS, oldoptions & ~(OPT_LINE | OPT_ECHO));
  442. #endif /* UNIX_DEBUG */
  444.     bzero (string, maxBytes);
  445.     string [0] = EOS; /* Beginning Of String */
  446.     curLn = &string [1]; /* reserve position 0 for EOS (BOS) */
  447.     saveLn [0] = EOS;
  448.     histLn [0] = EOS;
  449.     setPreempt (&catchFunc, (FUNCPTR) NULL);
  451.     ledId->buffer [0] = EOS;
  452.     ledId->cmdMode = FALSE;
  454.     bfill (oldLn, LINE_LEN+1, EOS);
  455.     bfill (curLn, maxBytes - 1, EOS); /* -1 cause of BOS */
  457.     /* operation:
  458.      *    redraw line,
  459.      *    read next character,
  460.      *    based on command/input mode perform appropriate action,
  461.      *    loop.
  462.      */
  464.     while (! done)
  465. {
  466. redraw (ledId->outFd, oldLn, lastPs, curLn, &curPs);
  468. lastPs = curPs;
  469. strcpy (oldLn, curLn);
  471. if (read (ledId->inFd, &ch, 1) < 1)
  472.     {
  473.     done = TRUE;
  474.     returnVal = EOF;
  475.     break;
  476.     }
  478. /* Ignore NULL in the input stream */
  480. if (ch == (char)NULL)
  481.     continue;
  483. /* some function wants to preempt? */
  485. result = preempt (&catchFunc, ch, curLn, &curPs, &number, ledId);
  487. if (result == ERROR)
  488.     {
  489.     beep (ledId->outFd);
  490.     continue; /* short-cut loop */
  491.     }
  492. else if (result == OK)
  493.     continue; /* short-cut loop */
  495. if (ledId->cmdMode)
  496.     {
  497.     /* parse command */
  499.     if (ch == tyBackspaceChar)
  500. ch = 'h';
  502.     if (ch == tyDeleteLineChar)
  503. {
  504. ledId->cmdMode = FALSE;
  505. curLn [0] = EOS;
  506. curPs = 0;
  507. }
  508.     else switch (ch)
  509. {
  510. case 'G':
  511.     save();
  513.     if (number < 1)
  514. number = 1;
  516.     if (histNum (ledId, curLn, number))
  517. curPs = 0;
  518.     else
  519. beep (ledId->outFd);
  520.     number = 0;
  521.     break;
  523. case '/':
  524. case '?':
  525.     strcpy (saveLn, curLn);
  526.     srchMode = TRUE;
  527.     ledId->cmdMode = FALSE;
  528.     curLn [0] = ch;
  529.     curLn [1] = EOS;
  530.     curPs = 1;
  531.     break;
  533. case 'n':
  534. case 'N':
  535.     if (histLn [0] == EOS)
  536. {
  537. beep (ledId->outFd);
  538. break;
  539. }
  541.     save ();
  543.     if (ch == 'N')
  544. histLn [0] = histLn [0] == '/' ? '?' : '/';
  546.     if (! histFind (ledId, histLn, curLn))
  547. {
  548. beep (ledId->outFd);
  549. curLn [0] = EOS;
  550. }
  552.     curPs = 0;
  553.     break;
  555. case 'k':
  556. case '-':
  557.     save ();
  559.     do
  560. {
  561. if (histPrev (ledId, curLn) == ERROR)
  562.     {
  563.     beep (ledId->outFd);
  564.     break;
  565.     }
  566. }
  567.     while (--number > 0);
  568.     number = 0;
  570.     curPs = 0;
  571.     break;
  573. case 'j':
  574. case '+':
  575.     save ();
  577.     do
  578. {
  579. if (histNext (ledId, curLn) == ERROR)
  580.     {
  581.     beep (ledId->outFd);
  582.     break;
  583.     }
  584. }
  585.     while (--number > 0);
  586.     number = 0;
  588.     curPs = 0;
  589.     break;
  591. case 'h':
  592.     do
  593. {
  594. if (curPs > 0)
  595.     curPs--;
  596. }
  597.     while (--number > 0);
  598.     number = 0;
  599.     break;
  601. case 'l':
  602. case ' ':
  603.     do
  604. {
  605. if ((strlen (curLn) != 0)&&(curPs < strlen (curLn) - 1))
  606.     curPs++;
  607. }
  608.     while (--number > 0);
  609.     number = 0;
  610.     break;
  612. case 'w':
  613. case 'W': /* ignore punctuation */
  614. case 'b':
  615. case 'B': /* ignore punctuation */
  616. case 'e':
  617. case 'E': /* ignore punctuation */
  618.     {
  619.     int origPs = curPs;
  620.     int dir = (ch == 'b' || ch == 'B') ? BACKWARD :FORWARD;
  621.     BOOL word = ch != 'w' && ch != 'W';
  623.     do
  624. {
  625. search (isupper ((int)ch), word, curLn, &curPs, dir);
  626. }
  627.     while (curPs != origPs && --number > 0);
  628.     number = 0;
  629.     break;
  630.     }
  632. case 'f':
  633. case 't': /* doesn't backward step
  634.  * XXX - not implemented */
  635.     setPreempt (&catchFunc, (FUNCPTR)findFwd);
  636.     break;
  638. case 'F':
  639. case 'T': /* doesn't forward step
  640.  * XXX - not implemented */
  641.     setPreempt (&catchFunc, (FUNCPTR)findBwd);
  642.     break;
  644. case 'r':
  645.     strcpy (saveLn, curLn);
  646.     setPreempt (&catchFunc, (FUNCPTR)replace);
  647.     break;
  649. case 'R':
  650.     strcpy (saveLn, curLn);
  651.     overStrike = TRUE;
  652.     ledId->cmdMode = FALSE;
  653.     break;
  655. case 'A':
  656.     curPs = strlen (curLn);
  657.     /* drop thru */
  659. case 'a':
  660.     ledId->cmdMode = FALSE;
  661.     strcpy (saveLn, curLn);
  662.     if (curPs < strlen (curLn))
  663. curPs++;
  664.     break;
  666. case 'x':
  667.     strcpy (saveLn, curLn);
  668.     number = min (number, strlen (curLn) - curPs);
  669.     ix = 0;
  670.     do
  671. {
  672. ledId->buffer [ix++] = curLn [curPs];
  673. if (curPs < strlen (curLn) - 1)
  674.     strcpy (&curLn [curPs], &curLn [curPs + 1]);
  675. else
  676.     {
  677.     curLn [curPs] = EOS;
  678.     if (curPs > 0)
  679. curPs--;
  680.     else
  681. break;
  682.     }
  683. }
  684.     while (--number > 0);
  685.     number = 0;
  686.     ledId->buffer [ix] = EOS;
  687.     break;
  689. case 'X':
  690.     strcpy (saveLn, curLn);
  691.     ix = 0;
  692.     do
  693. {
  694. if (curPs > 0)
  695.     {
  696.     curPs--;
  697.     ledId->buffer [ix++] = curLn [curPs];
  698.     strcpy (&curLn [curPs], &curLn [curPs + 1]);
  699.     }
  700. else if (strlen (curLn) == 1)
  701.     {
  702.     ledId->buffer [ix++] = curLn [curPs];
  703.     curLn [curPs] = EOS;
  704.     }
  705. else
  706.     break;
  707. }
  708.     while (--number > 0);
  709.     number = 0;
  710.     ledId->buffer [ix] = EOS;
  711.     break;
  713. case 'c':
  714.     strcpy (saveLn, curLn);
  715.     setPreempt (&catchFunc, (FUNCPTR)change);
  716.     break;
  718. case 'C':
  719.     strcpy (saveLn, curLn);
  720.     ledId->cmdMode = FALSE;
  721.     curLn [curPs] = EOS;
  722.     break;
  724.                 case 's':
  725.                     strcpy (saveLn, curLn);
  726.     number = number ? number : 1;
  727.     ix = 0;
  728.                     if (number >= strlen (curLn) - curPs)
  729.                         curLn [curPs] = EOS;
  730.                     else
  731.                         {
  732.                         do
  733.                             {
  734.                             ledId->buffer [ix++] = curLn [curPs];
  735.                             if (curPs < strlen (curLn) - 1)
  736.                                 strcpy (&curLn [curPs], &curLn [curPs + 1]);
  737.                             else
  738.                                 {
  739.                                 curLn [curPs] = EOS;
  740.                                 if (curPs > 0)
  741.                                     curPs--;
  742.                                 else
  743.                                     break;
  744.                                 }
  745.                             }
  746.                         while (--number > 0);
  747.                         }
  748.                     number = 0;
  749.                     ledId->buffer [ix] = EOS;
  750.                     ledId->cmdMode = FALSE;
  751.                     break;
  753. case 'S':
  754.     strcpy (saveLn, curLn);
  755.     if (change ('c', curLn, &curPs, &number, ledId) == ERROR)
  756. beep (ledId->outFd);
  757.     break;
  759. case 'd':
  760.     strcpy (saveLn, curLn);
  761.     setPreempt (&catchFunc, (FUNCPTR)deletec);
  762.     break;
  764. case 'D':
  765.     strcpy (saveLn, curLn);
  766.     strncpy (ledId->buffer, &curLn [curPs],
  767.      strlen (&curLn [curPs]) + 1); /* +EOS */
  768.     curLn [curPs] = EOS;
  769.     if (curPs > 0)
  770. curPs--;
  771.     break;
  773. case 'I':
  774.     curPs = 0;
  775.     /* drop thru */
  777. case 'i':
  778.     strcpy (saveLn, curLn);
  779.     number = 0; /* can't handle "count" */
  780.     ledId->cmdMode = FALSE;
  781.     break;
  783. case 'p':
  784.     if (strlen (ledId->buffer) == 0)
  785. break;
  787.     if (strlen (curLn) == 0)
  788. goto caseP; /* treat like 'P' */
  790.     number = 0; /* can't handle "count" */
  792.     if (strlen (curLn) + strlen (ledId->buffer) < maxBytes)
  793. {
  794. strcpy (saveLn, curLn);
  796. if (++curPs < strlen (curLn))
  797.     {
  798.     /* insert buffer into curLn */
  800.     bcopy (&curLn [curPs],
  801.    &curLn [curPs + strlen (ledId->buffer)],
  802.    strlen (&curLn [curPs]) + 1); /* +EOS */
  804.     bcopy (ledId->buffer, &curLn [curPs],
  805.    strlen (ledId->buffer));
  806.     }
  807. else
  808.     /* buffer goes after curLn */
  809.     strcat (curLn, ledId->buffer);
  811. curPs += strlen (ledId->buffer) - 1;
  812. }
  813.     else
  814. beep (ledId->outFd);
  815.     break;
  817. case 'P':
  818. caseP:
  819.     number = 0; /* can't handle "count" */
  821.     if (strlen (ledId->buffer) == 0)
  822. break;
  824.     if (strlen (curLn) + strlen (ledId->buffer) < maxBytes)
  825. {
  826. strcpy (saveLn, curLn);
  828. /* insert buffer into curLn */
  830. bcopy (&curLn [curPs],
  831.        &curLn [curPs + strlen (ledId->buffer)],
  832.        strlen (&curLn [curPs]) + 1); /* +EOS */
  834. bcopy (ledId->buffer, &curLn [curPs],
  835.        strlen (ledId->buffer));
  837. if (curPs == 0)
  838.     curPs--;
  839. curPs += strlen (ledId->buffer);
  840. }
  841.     else
  842. beep (ledId->outFd);
  843.     break;
  845. case 'u':
  846. case 'U': /* restore original line
  847.  * XXX - not implemented */
  848.     if (strlen (saveLn) != 0)
  849. {
  850. bswap (curLn, saveLn,
  851.        max (strlen (curLn), strlen (saveLn)) + 1);
  852.   /* +EOS */
  853. if (curPs == strlen (saveLn) - 1 ||
  854.     curPs > strlen (curLn))
  855.     {
  856.     curPs = strlen (curLn) - 1;
  857.     }
  858. }
  859.     else
  860. beep (ledId->outFd);
  861.     break;
  863. case RET_CHAR:
  864.     done = TRUE;
  865.     returnVal = strlen (curLn);
  866.     break;
  868. case '$':
  869.     curPs = strlen (curLn) - 1;
  870.     break;
  872. case '0':
  873.     if (number == 0)
  874. {
  875. curPs = 0;
  876. break;
  877. }
  878.     /* drop thru */
  880. case '1': case '2': case '3': case '4':
  881. case '5': case '6': case '7': case '8': case '9':
  882.     if (number < 0)
  883. number = 0;
  884.     number = number * 10 + (ch - '0');
  885.     break;
  887. case '~':
  888.     strcpy (saveLn, curLn);
  889.     ch = curLn [curPs];
  890.     if (isalpha ((int)ch))
  891. curLn [curPs] = islower ((int)ch) ? toupper ((int)ch)
  892.     : tolower (ch);
  893.     if (curPs < strlen (curLn) - 1)
  894. curPs++;
  895.     break;
  897. case '^':
  898.     for (curPs = 0;
  899.  curLn [curPs] != EOS && isspace ((int)curLn[curPs]);
  900.  curPs++)
  901.  ;
  902.     break;
  904. case RDW_CHAR:
  905.     write (ledId->outFd, "n", 1);
  906.     (void)writen (ledId->outFd, ' ', curPs);
  907.     strcpy (oldLn, "");
  908.     break;
  910. case CMP_CHAR:
  911.     strcpy (saveLn, curLn);
  913.     if (! completeName (curLn, &curPs))
  914. beep (ledId->outFd);
  915.     break;
  917. default:
  918.     beep (ledId->outFd);
  919.     break;
  920. }
  921.     }
  922. else
  923.     {
  924.     /* input mode */
  926.     if (ch == tyEofChar && curPs == 0)
  927. {
  928. /* only return EOF when used at the beginning of line */
  930. done = TRUE;
  931. returnVal = EOF;
  932. }
  933.     else if (ch == tyBackspaceChar)
  934. {
  935. if (curPs > 0)
  936.     {
  937.     strcpy (&curLn [curPs - 1], &curLn [curPs]);
  938.     curPs--;
  939.     }
  940. }
  941.     else if (ch == tyDeleteLineChar)
  942. {
  943. curLn [0] = EOS;
  944. curPs = 0;
  945. }
  946.     else switch (ch)
  947. {
  948. case ESC_CHAR:
  949.     overStrike = FALSE;
  950.     if (! srchMode)
  951. {
  952. ledId->cmdMode = TRUE;
  953. if (curPs > 0)
  954.     curPs--;
  955. break;
  956. }
  958.     /* drop thru */
  960. case RET_CHAR:
  961.     if (srchMode)
  962. {
  963. if (strcmp (curLn, "/") == 0 || strcmp (curLn, "?") ==0)
  964.     /* just use previous history search */
  965.     strcpy (curLn, histLn);
  966. else
  967.     /* new history search */
  968.     strcpy (histLn, curLn);
  970. if (! histFind (ledId, histLn, curLn))
  971.     {
  972.     curLn [0] = EOS;
  973.     beep (ledId->outFd);
  974.     }
  976. curPs = 0;
  977. srchMode = FALSE;
  978. ledId->cmdMode = TRUE;
  979. }
  980.     else
  981. {
  982. done = TRUE;
  983. returnVal = strlen (curLn);
  984. }
  985.     break;
  987. case CMP_CHAR:
  988.     strcpy (saveLn, curLn);
  990.     if (! completeName (curLn, &curPs))
  991. beep (ledId->outFd);
  992.     else
  993. /*
  994. if (isalpha(curLn [curPs]) || isdigit(curLn[curPs]) ||
  995. curLn [curPs] == '_')
  996. */
  997. while (isalpha((int)curLn [curPs]) ||
  998. isdigit((int)curLn[curPs]) ||
  999. curLn [curPs] == '_')
  1000.     {
  1001.     curPs++;
  1002.     }
  1003.     break;
  1005. default:
  1006.     if (strlen (curLn) < maxBytes)
  1007. {
  1008. if (overStrike && curPs < strlen (curLn))
  1009.     curLn [curPs++] = ch;
  1010. else
  1011.     {
  1012.     bcopy (&curLn [curPs], &curLn [curPs + 1],
  1013.    strlen (&curLn [curPs]) + 1); /* + EOS */
  1014.     curLn [curPs++] = ch;
  1015.     }
  1016. }
  1017.     else
  1018. beep (ledId->outFd);
  1019.     break;
  1020. }
  1021.     }
  1022. }
  1024.     if (returnVal == EOF)
  1025. {
  1026. #ifndef UNIX_DEBUG
  1027. /* turn echo & line mode back on */
  1028. ioctl(ledId->inFd, FIOSETOPTIONS, oldoptions);
  1029. #endif /* UNIX_DEBUG */
  1031. return (EOF);
  1032. }
  1034.     histAdd (ledId, curLn);
  1035.     write (ledId->outFd, "n", 1);
  1037.     /* must fix up BOS */
  1038.     bcopy (&string [1], &string [0], strlen (curLn) + 1); /* +EOS */
  1040. #ifndef UNIX_DEBUG
  1041.     /* turn echo & line mode back on */
  1042.     ioctl (ledId->inFd, FIOSETOPTIONS, oldoptions);
  1043. #endif /* UNIX_DEBUG */
  1045.     return (returnVal);
  1046.     }
  1047. /*******************************************************************************
  1048. *
  1049. * ledControl - change the line-editor ID parameters
  1050. *
  1051. * This routine changes the input/output file
  1052. * descriptor and the size of the history list.
  1053. *
  1054. * RETURNS: N/A
  1055. */
  1057. void ledControl
  1058.     (
  1059.     int led_id,    /* ID returned by ledOpen */
  1060.     int inFd,      /* new input fd (NONE = no change) */
  1061.     int outFd,     /* new output fd (NONE = no change) */
  1062.     int histSize   /* new history list size (NONE = no change), (0 = display) */
  1063.     )
  1064.     {
  1065.     FAST LED_ID ledId = (LED_ID)led_id;
  1067.     if (inFd >= 0)
  1068. ledId->inFd = inFd;
  1069.     if (outFd >= 0)
  1070. ledId->outFd = outFd;
  1071.     if (histSize == 0)
  1072. histAll (ledId);
  1073.     if (histSize > 0)
  1074. histInit (ledId, histSize);
  1075.     }
  1077. /*******************************************************************************
  1078. *
  1079. * setPreempt - set function to use next
  1080. */
  1082. LOCAL void setPreempt
  1083.     (
  1084.     FAST FUNCPTR *catchFunc,
  1085.     FAST FUNCPTR func
  1086.     )
  1087.     {
  1088.     *catchFunc = func;
  1089.     }
  1090. /*******************************************************************************
  1091. *
  1092. * preempt - perform preempt function if set
  1093. *
  1094. * If <catchFunc> is non-NULL then it is called using the
  1095. * remaining arguments.
  1096. *
  1097. * RETURNS:
  1098. *    result of preempt function, or
  1099. *    1 if no function called
  1100. */
  1102. LOCAL int preempt
  1103.     (
  1104.     FAST FUNCPTR *catchFunc,    /* preempting function */
  1105.     char ch,                    /* arguments to be */
  1106.     char *curLn,                /* passed to th */
  1107.     int *curPs,                 /* routine ... */
  1108.     int *number,
  1109.     LED_ID ledId
  1110.     )
  1111.     {
  1112.     FUNCPTR tmpFunc = *catchFunc;
  1114.     if (*catchFunc == (FUNCPTR)NULL)
  1115. return (1); /* no function called */
  1117.     /* clear the catch */
  1119.     *catchFunc = (FUNCPTR) NULL;
  1121.     return ((*tmpFunc) (ch, curLn, curPs, number, ledId));
  1122.     }
  1123. /*******************************************************************************
  1124. *
  1125. * redraw - redraw line
  1126. *
  1127. * From the previous line and position (oldLn & lastPs) redraw line to
  1128. * reflect reality (curLn & curPs).
  1129. *
  1130. * Operation: compare new line with previous line,
  1131. * optimize the number of characters redrawn and cursor motion.
  1132. */
  1134. LOCAL void redraw
  1135.     (
  1136.     int outFd,
  1137.     char *oldLn,
  1138.     int lastPs,
  1139.     char *curLn,
  1140.     int *curPs
  1141.     )
  1142.     {
  1143.     FAST int ok1Ps; /* line is the same up to this position */
  1144.     FAST int ok2Ps; /* line is the same from the far end to here */
  1146.     /* find first difference */
  1147.     for (ok1Ps = 0;
  1148.  curLn [ok1Ps] == oldLn [ok1Ps] && curLn [ok1Ps] != EOS;
  1149.  ok1Ps++)
  1150. ;
  1152.     /* find first difference from the far end if same length */
  1153.     if (strlen (curLn) == strlen (oldLn))
  1154. {
  1155. for (ok2Ps = strlen (curLn);
  1156.      curLn [ok2Ps] == oldLn [ok2Ps] && ok2Ps > 0;
  1157.      ok2Ps--)
  1158.     ;
  1159. if (ok2Ps < strlen (curLn))
  1160.     ok2Ps++;
  1161. }
  1162.     else
  1163. ok2Ps = strlen (curLn);
  1165.     /* line is bad before cursor position */
  1166.     if (ok1Ps < lastPs)
  1167. {
  1168. /* back up */
  1169. (void)writen (outFd, 'b', lastPs - ok1Ps);
  1171. /* redraw line from ok1Ps to the good portion */
  1172. (void)writex (outFd, &curLn [ok1Ps], ok2Ps - ok1Ps);
  1174. lastPs = ok2Ps;
  1175. }
  1177.     /* line is bad after cursor position */
  1178.     else if (ok2Ps > lastPs)
  1179. {
  1180. /* draw line from lastPs to the good portion */
  1181. (void)writex (outFd, &curLn [lastPs], ok2Ps - lastPs);
  1182. lastPs = ok2Ps;
  1183. }
  1185.     /* line is bad at cursor position */
  1186.     else if (ok2Ps == lastPs && lastPs < strlen (curLn))
  1187. {
  1188. /* draw single character */
  1189. (void)writex (outFd, &curLn [lastPs], 1);
  1190. lastPs++;
  1191. }
  1193.     /* blank out remaining junk if we're at the end of the line */
  1194.     if (lastPs == strlen (curLn))
  1195. {
  1196. int i = strlen (oldLn) - strlen (curLn);
  1198. if (i > 0)
  1199.     {
  1200.     (void)writen (outFd, ' ', i);
  1201.     (void)writen (outFd, 'b', i);
  1202.     }
  1203. }
  1205.     /* now get cursor right */
  1207.     if (lastPs > *curPs)
  1208. (void)writen (outFd, 'b', lastPs - *curPs);
  1209.     else
  1210. (void)writex (outFd, &curLn [lastPs], *curPs - lastPs);
  1211.     }
  1213. /*
  1214.  * Definitions used through remaining routines.
  1215.  */
  1216. #define CUR (curLn [*curPs])
  1217. #define PREV (curLn [*curPs-dir])
  1218. #define NEXT (curLn [*curPs+dir])
  1219. #define INC (*curPs+=dir)
  1220. #define ispunct_nospc(c) (ispunct(c) && !isspace(c))
  1221. #define igpunct(c) (ignorePunct ? ispunct_nospc(c) : FALSE)
  1222. #define isword(c) (isalpha(c) || isdigit(c) || index("*?_-.[]~=",c))
  1224. /*******************************************************************************
  1225. *
  1226. * completeName - complete partial symbol name at current position
  1227. *
  1228. * RETURNS: TRUE if symbol name is completed in any way, otherwise FALSE.
  1229. */
  1231. LOCAL BOOL completeName
  1232.     (
  1233.     FAST char *curLn,
  1234.     int *curPs
  1235.     )
  1236.     {
  1237.     CMP_ARG arg;
  1238.     char saveLn [LINE_LEN+1];
  1239.     char string [100];
  1240.     int count;
  1241.     int dir = FORWARD;
  1242.     int startPs = *curPs;
  1243.     int endPs = *curPs;
  1245.     /* operation:
  1246.      *   isolate begin and end of string at current position,
  1247.      *   if begin and end are equal then no string - return error,
  1248.      *   call support routine to see if string is in symbol table,
  1249.      *     if not then - return error
  1250.      *    otherwise determine symbol up to the last unambiguous character,
  1251.      *     then insert extra characters - return ok.
  1252.      */
  1254.     while (isalpha((int)curLn [startPs-1]) ||
  1255.    isdigit((int)curLn[startPs-1])  ||
  1256.    curLn [startPs-1] == '_')
  1257. {
  1258. startPs--;
  1259. }
  1261.     while (isalpha ((int)curLn [endPs]) ||
  1262.    isdigit ((int)curLn [endPs]) ||
  1263.    curLn [endPs] == '_')
  1264. {
  1265. endPs++;
  1266. }
  1268.     if (endPs == startPs)
  1269. return (FALSE);
  1271.     if (curLn [startPs] == '_')
  1272. startPs++; /* ignore leading underscore */
  1274.     strncpy (string, &curLn [startPs], endPs - startPs);
  1275.     string [endPs - startPs] = EOS;
  1277.     arg.name    = string; /* search string */
  1278.     arg.nameLen = strlen (string); /* optimization */
  1279.     arg.count   = 0; /* reset to zero */
  1281.     symEach (sysSymTbl, (FUNCPTR)findName, (int)&arg);
  1282.     count = arg.count;
  1284.     /* keep looking while match is ambiguous */
  1286.     while (arg.count > 1 && count == arg.count)
  1287. {
  1288. if (strcmp (arg.name, arg.match) == 0)
  1289.     {
  1290.     /* just in case more than one entry with same name,
  1291.      * but hope this first match is different, oh well.
  1292.      */
  1293.     count = 1;
  1294.     break;
  1295.     }
  1296. arg.count = 0; /* reset to zero */
  1297. arg.nameLen++; /* optimization */
  1299. strncpy (arg.name, arg.match, arg.nameLen);
  1301. symEach (sysSymTbl, (FUNCPTR)findName, (int)&arg);
  1302. }
  1304.     /* have to admit we didn't find anything */
  1306.     if (count == 0)
  1307. return (FALSE);
  1309.     if (count > 1)
  1310. {
  1311. /* ambiguous match up 'til second last position */
  1312. arg.name [arg.nameLen - 1] = EOS;
  1313. arg.match = arg.name;
  1314. }
  1316.     /* insert new string, don't forget to save original line */
  1318.     if ((endPs - startPs) + strlen (curLn) + strlen (arg.match) < LINE_LEN)
  1319. {
  1320. strcpy (saveLn, curLn);
  1322. strcpy (&curLn [startPs], arg.match);
  1323. strcat (curLn, &saveLn [endPs]);
  1325. if (isalpha((int)CUR) || isdigit((int)CUR) || CUR == '_')
  1326.     {
  1327.     while (isalpha((int)NEXT) || isdigit((int)NEXT) || NEXT == '_')
  1328. {
  1329. INC;
  1330. }
  1331.     }
  1332. }
  1334.     return (TRUE);
  1335.     }
  1336. /*******************************************************************************
  1337. *
  1338. * findName - support routine for completeName
  1339. *
  1340. * This routine is called for each string in the symbol table.
  1341. *
  1342. * RETURNS: TRUE always.
  1343. *
  1344. * ARGSUSED
  1345. */
  1347. LOCAL BOOL findName
  1348.     (
  1349.     char *name,         /* name of this entry */
  1350.     char *value,        /* symbol table junk */
  1351.     SYM_TYPE type,      /* symbol table junk */
  1352.     CMP_ARG *arg        /* what to match, etc. */
  1353.     )
  1354.     {
  1355.     if (name[0] == '_')
  1356. name++; /* ignore leading underscore */
  1358.     if (strncmp (name, arg->name, arg->nameLen) == 0)
  1359. {
  1360. if (++arg->count == 1 || strlen (name) > strlen (arg->match))
  1361.     arg->match = name;
  1362. }
  1364.     return (TRUE);
  1365.     }
  1366. /*******************************************************************************
  1367. *
  1368. * search - move from current position to matched character position
  1369. *
  1370. * RETURNS: new ptr to current position.
  1371. */
  1373. LOCAL void search
  1374.     (
  1375.     FAST BOOL ignorePunct,              /* ignore punctuation or not */
  1376.     FAST BOOL endOfWord,                /* stop at end of word, or
  1377.                                            when BACKWARD stop at beginning */
  1378.     char *curLn,
  1379.     int *curPs,
  1380.     int dir                     /* direction to search */
  1381.     )
  1382.     {
  1383.     /* make sure we're not already at limits */
  1385.     if (CUR == EOS || NEXT == EOS)
  1386. return;
  1388.     if (isspace ((int)CUR))
  1389. {
  1390. /* just get to a non-space */
  1391. while (NEXT != EOS && isspace ((int)CUR))
  1392.     INC;
  1393. }
  1394.     else if (ispunct ((int)CUR))
  1395. {
  1396. /* just get to the next/previous word */
  1397. while (NEXT != EOS && !isalnum ((int)CUR))
  1398.     INC;
  1399. }
  1400.     else if (endOfWord || dir == BACKWARD)
  1401. {
  1402. /* while space coming */
  1403. while (isspace((int)NEXT))
  1404.     INC;
  1406. /* maybe we've got to punctuation */
  1407. if (ispunct_nospc ((int)NEXT))
  1408.     {
  1409.     do
  1410. {
  1411. INC;
  1412. }
  1413.     while (NEXT != EOS && ispunct_nospc ((int)NEXT));
  1415.     /* while we're on a space advance/retreat */
  1416.     while (NEXT != EOS && isspace ((int)CUR))
  1417. INC;
  1419.     return;
  1420.     }
  1422. /* get to end/beginning of word but not past */
  1423. while (NEXT != EOS && (isalnum ((int)NEXT) || igpunct(((int)NEXT))))
  1424.     INC;
  1425. }
  1426.     else
  1427. {
  1428. /* get past end/beginning of word */
  1430. do
  1431.     {
  1432.     INC;
  1433.     }
  1434. while (NEXT != EOS && (isalnum ((int)CUR) || igpunct((int)CUR)));
  1436. /* while we're on a space advance/retreat */
  1437. while (NEXT != EOS && isspace ((int)CUR))
  1438.     INC;
  1439. }
  1440.     }
  1441. /*******************************************************************************
  1442. *
  1443. * find - a particualar character
  1444. *
  1445. * RETURNS:
  1446. * TRUE if `ch' found, or
  1447. * FALSE if end of line reached first.
  1448. */
  1450. LOCAL BOOL find
  1451.     (
  1452.     char ch,                    /* what to find */
  1453.     char *curLn,
  1454.     int *curPs,
  1455.     int dir                     /* direction to search */
  1456.     )
  1457.     {
  1458.     if (CUR == EOS || NEXT == EOS)
  1459. return (FALSE);
  1461.     do
  1462. {
  1463. INC;
  1464. }
  1465.     while (CUR != ch && NEXT != EOS);
  1467.     return (CUR == ch);
  1468.     }
  1469. /*******************************************************************************
  1470. *
  1471. * findFwd - find <ch> some <number> of times looking forwards
  1472. */
  1474. LOCAL STATUS findFwd
  1475.     (
  1476.     FAST char ch,
  1477.     char *curLn,
  1478.     int *curPs,
  1479.     int *number
  1480.     )
  1481.     {
  1482.     while (find (ch, curLn, curPs, FORWARD) && --*number > 0)
  1483. ;
  1485.     *number = 0;
  1487.     return (OK);
  1488.     }
  1489. /*******************************************************************************
  1490. *
  1491. * findBwd - find <ch> some <number> of times looking backwards
  1492. */
  1494. LOCAL STATUS findBwd
  1495.     (
  1496.     char ch,
  1497.     char *curLn,
  1498.     int *curPs,
  1499.     int *number
  1500.     )
  1501.     {
  1502.     while (find (ch, curLn, curPs, BACKWARD) && --*number > 0)
  1503. ;
  1504.     *number = 0;
  1506.     return (OK);
  1507.     }
  1508. /*******************************************************************************
  1509. *
  1510. * change - change as specified by (w/W/e/E/sp/l/h/c/$/0)
  1511. */
  1513. LOCAL STATUS change
  1514.     (
  1515.     FAST char ch,
  1516.     char *curLn,
  1517.     int *curPs,
  1518.     int *number,
  1519.     LED_ID ledId
  1520.     )
  1521.     {
  1522.     STATUS status = OK;
  1524.     switch (ch)
  1525. {
  1526. case '0':
  1527. case ' ':
  1528. case 'l':
  1529. case 'h':
  1530. case 'w':
  1531. case 'W':
  1532. case 'e':
  1533. case 'E':
  1534. case 'b':
  1535. case 'B':
  1536.     ledId->cmdMode = FALSE;
  1537.     status = deletec (ch, curLn, curPs, number, ledId);
  1538.     break;
  1540. case 'c':
  1541.     *curPs = 0;
  1542.     /* drop through */
  1544. case '$':
  1545.     ledId->cmdMode = FALSE;
  1546.     CUR = EOS;
  1547.     break;
  1549. default:
  1550.     status = ERROR;
  1551.     break;
  1552. }
  1554.     return (status);
  1555.     }
  1556. /*******************************************************************************
  1557. *
  1558. * deletec - delete as specified by (w/W/e/E/b/B/sp/l/h/d/$/0) <number> of times
  1559. *
  1560. * RETURNS: OK or ERROR
  1561. */
  1563. LOCAL STATUS deletec
  1564.     (
  1565.     FAST char ch,
  1566.     char *curLn,
  1567.     int *curPs,
  1568.     int *number,
  1569.     LED_ID ledId
  1570.     )
  1571.     {
  1572.     STATUS status = OK;
  1573.     FAST int tmp = *curPs;
  1574.     FAST int i = 0;
  1575.     int dir = (ch == 'b' || ch == 'B' || ch == 'h') ? BACKWARD : FORWARD;
  1576.     BOOL endOfWord = ch != 'w' && ch != 'W';
  1577.     int fudge; /* fudge factor? */
  1579.     do
  1580. {
  1581. switch (ch)
  1582.     {
  1583.     case 'w':
  1584.     case 'W': /* ignore punctuation */
  1585.     case 'e':
  1586.     case 'E': /* ignore punctuation */
  1587.     case 'b':
  1588.     case 'B': /* ignore punctuation */
  1589. {
  1590. int origPs = *curPs;
  1592. search (isupper ((int)ch), endOfWord, curLn, curPs, dir);
  1594. if (*curPs == origPs)
  1595.     *number = 1; /* get out! */
  1597. fudge = (NEXT == EOS) ? 1 : 0;
  1599. if (dir == FORWARD)
  1600.     {
  1601.     i = *curPs - tmp + fudge;
  1602.     strncpy (ledId->buffer, &curLn [tmp], i);
  1603.     strcpy (&curLn [tmp], &curLn [*curPs+fudge]);
  1604.     *curPs = tmp;
  1605.     }
  1606. else
  1607.     {
  1608.     i = tmp - *curPs + fudge;
  1609.     strncpy (ledId->buffer, &CUR, i);
  1610.     strcpy (&CUR, &curLn [tmp+fudge]);
  1611.     tmp = *curPs - fudge;
  1612.     }
  1613. break;
  1614. }
  1616.     case ' ':
  1617.     case 'l':
  1618. ledId->buffer [i++] = CUR;
  1619. if (*curPs < strlen (curLn) - 1)
  1620.     {
  1621.     strcpy (&CUR, &NEXT);
  1622.     break;
  1623.     }
  1624. else if (*curPs == strlen (curLn) - 1)
  1625.     *number = 1; /* get out! */
  1627. CUR = EOS;
  1628. if (*curPs > 0)
  1629.     (*curPs)--;
  1630. break;
  1632.     case 'd':
  1633. strcpy (ledId->buffer, curLn);
  1634. i = strlen (ledId->buffer);
  1635.     /* don't want 'i' to cause any grief */
  1636. *curPs = 0;
  1637. CUR = EOS;
  1638. *number = 1; /* get out! */
  1639. break;
  1641.     case '$':
  1642. i = strlen (curLn) - *curPs + 1;
  1643. strncpy (ledId->buffer, &CUR, i);
  1644. CUR = EOS;
  1645. *number = 1; /* get out! */
  1646. break;
  1648.     case '0':
  1649. i = *curPs + 1;
  1650. strncpy (ledId->buffer, &curLn [0], i);
  1651. bcopy (&CUR, &curLn [0], strlen (&CUR) + 1); /* +EOS */
  1652. *curPs = 0;
  1653. *number = 1; /* get out! */
  1654. break;
  1656.     case 'h': /* XXX - not implemented */
  1657.     default:
  1658. i = strlen (ledId->buffer);
  1659. *number = 1; /* get out! */
  1660. status = ERROR;
  1661. break;
  1662.     }
  1663. }
  1664.     while (--*number > 0);
  1666.     *number = 0;
  1668.     ledId->buffer [i] = EOS;
  1670.     return (status);
  1671.     }
  1672. /*******************************************************************************
  1673. *
  1674. * replace - replace current position thru count with specified character
  1675. */
  1677. LOCAL STATUS replace
  1678.     (
  1679.     char ch,
  1680.     char *curLn,
  1681.     int *curPs,
  1682.     int *number
  1683.     )
  1684.     {
  1685.     if (*number < 1)
  1686. *number = 1;
  1688.     /* don't do replacement if escape */
  1689.     if (ch != ESC_CHAR)
  1690. bfill (&CUR, min (*number, strlen (&CUR)), ch);
  1692.     *number = 0;
  1694.     return (OK);
  1695.     }
  1696. /*******************************************************************************
  1697. *
  1698. * beep - make a noise
  1699. */
  1701. LOCAL void beep
  1702.     (
  1703.     int outFd
  1704.     )
  1705.     {
  1706.     static char bell = BEL_CHAR;
  1708.     write (outFd, &bell, 1);
  1709.     }
  1710. /*******************************************************************************
  1711. *
  1712. * writex - write bytes to a file but change control chars to '?'
  1713. *
  1714. * RETURNS: number of characters actually written, pretty much like write.
  1715. */
  1717. LOCAL int writex
  1718.     (
  1719.     FAST int fd,
  1720.     char buffer [],
  1721.     FAST int nbytes
  1722.     )
  1723.     {
  1724.     FAST int i;
  1725.     FAST char *pBuf = buffer;
  1726.     char non_ch = NON_CHAR;
  1728.     for (i = 0; i < nbytes; i++, pBuf++)
  1729. {
  1730. if (write (fd, (isprint ((int)(*pBuf)) ? pBuf : &non_ch), 1) != 1)
  1731.     return (ERROR);
  1732. }
  1734.     return (nbytes);
  1735.     }
  1736. /*******************************************************************************
  1737. *
  1738. * writen - write a character n times
  1739. *
  1740. * NOTE: requires n <= (LINE_LEN + 1)
  1741. *
  1742. * RETURNS: number of characters actually written, just like write.
  1743. */
  1745. LOCAL int writen
  1746.     (
  1747.     int fd,
  1748.     char ch,
  1749.     int nbytes
  1750.     )
  1751.     {
  1752.     char buf [LINE_LEN + 1];
  1754.     bfill (buf, nbytes, ch);
  1755.     return (write (fd, buf, nbytes));
  1756.     }
  1758. /*******************************************************************************
  1759. *
  1760. * histInit - initialize history list
  1761. *
  1762. * On successive calls, resets history to new size.
  1763. */
  1765. LOCAL void histInit
  1766.     (
  1767.     LED_ID ledId,
  1768.     int histSize        /* amount of history required */
  1769.     )
  1770.     {
  1771.     int histDiff = histSize - ledId->histSize;
  1772.     HIST *pH;
  1774.     if (ledId->histSize == 0)
  1775. {
  1776. lstFree (&ledId->histList);
  1777. lstFree (&ledId->histFreeList);
  1779. ledId->histNum  = 0;
  1781. lstInit (&ledId->histList);
  1782. lstInit (&ledId->histFreeList);
  1783. }
  1785.     if (histDiff >= 0)
  1786. {
  1787. /* add to history free list */
  1789. while (histDiff-- > 0)
  1790.     {
  1791.     /* allocate history space */
  1793.     ledId->pHist = (HIST *) malloc (sizeof (HIST));
  1795.     if (ledId->pHist == NULL)
  1796. return; /* oh, oh! */
  1798.     ledId->pHist->line[0] = EOS;
  1800.     lstAdd (&ledId->histFreeList, &ledId->pHist->node);
  1801.     }
  1802. }
  1804.     else
  1805. {
  1806. /* free excess histories from history free list */
  1807. while (lstCount (&ledId->histFreeList) > 0 && histDiff++ < 0)
  1808.     {
  1809.     pH = (HIST *) lstGet (&ledId->histFreeList);
  1810.     free ((char *) pH);
  1811.     }
  1813. /* free oldest histories from history list */
  1814. while (lstCount (&ledId->histList) > 0 && histDiff++ < 0)
  1815.     {
  1816.     pH = (HIST *) lstGet (&ledId->histList);
  1817.     free ((char *) pH);
  1818.     }
  1819. }
  1821.     ledId->histSize = histSize;
  1822.     }
  1823. /*******************************************************************************
  1824. *
  1825. * histAdd - add line to history
  1826. */
  1828. LOCAL void histAdd
  1829.     (
  1830.     FAST LED_ID ledId,
  1831.     FAST char *line
  1832.     )
  1833.     {
  1834.     FAST HIST *pH = (HIST *) lstLast (&ledId->histList);
  1835.     FAST int i;
  1837.     ledId->pHist = NULL;
  1839.     /* ignore blank lines */
  1840.     for (i = 0; isspace ((int)line[i]); i++)
  1841. ;
  1843.     /* ignore blank lines & consecutive identical commands */
  1845.     if (i >= strlen (line) || (pH != NULL && strcmp (line, pH->line) == 0))
  1846. return;
  1848.     /* try free list or get from top of history list */
  1850.     if ((pH = (HIST *) lstGet (&ledId->histFreeList)) == NULL &&
  1851. (pH = (HIST *) lstGet (&ledId->histList)) == NULL)
  1852. {
  1853. /* history foul-up! */
  1854. return;
  1855. }
  1857.     /* append to end of history list */
  1859.     lstAdd (&ledId->histList, &pH->node);
  1861.     ledId->histNum++;
  1863.     strncpy (pH->line, line, LINE_LEN);
  1864.     pH->line [LINE_LEN - 1] = EOS;
  1865.     }
  1866. /*******************************************************************************
  1867. *
  1868. * histNum - get historical line number
  1869. *
  1870. * RETURNS: FALSE if no history by that number
  1871. */
  1873. LOCAL BOOL histNum
  1874.     (
  1875.     FAST LED_ID ledId,
  1876.     FAST char *line,            /* where to return historical line */
  1877.     FAST int n                  /* history number */
  1878.     )
  1879.     {
  1880.     int histFirst = ledId->histNum - lstCount (&ledId->histList) + 1;
  1881.     FAST HIST *pH;
  1882.     FAST int i;
  1884.     if (n < histFirst || n > ledId->histNum)
  1885. return (FALSE);
  1887.     for (pH = (HIST *) lstFirst (&ledId->histList), i = histFirst;
  1888.  pH != NULL && i != n;
  1889.  pH = (HIST *) lstNext (&pH->node), i++)
  1890. ;
  1892.     if (pH == NULL)
  1893. return (FALSE);
  1895.     strcpy (line, pH->line);
  1897.     ledId->pHist = pH;
  1899.     return (TRUE);
  1900.     }
  1901. /*******************************************************************************
  1902. *
  1903. * histNext - get next entry in history
  1904. *
  1905. * If line == NULL then just forward history.
  1906. *
  1907. * RETURNS: ERROR if no history
  1908. */
  1910. LOCAL STATUS histNext
  1911.     (
  1912.     FAST LED_ID ledId,
  1913.     FAST char *line             /* where to return historical line */
  1914.     )
  1915.     {
  1916.     if (ledId->pHist == NULL)
  1917. ledId->pHist = (HIST *) lstFirst (&ledId->histList);
  1918.     else if ((ledId->pHist = (HIST *) lstNext (&ledId->pHist->node)) == NULL)
  1919. ledId->pHist = (HIST *) lstFirst (&ledId->histList);
  1921.     if (ledId->pHist == NULL)
  1922. return (ERROR);
  1924.     if (line != NULL)
  1925. strcpy (line, ledId->pHist->line);
  1927.     return (OK);
  1928.     }
  1929. /*******************************************************************************
  1930. *
  1931. * histPrev - get previous entry in history
  1932. *
  1933. * If line == NULL then just forward history.
  1934. *
  1935. * RETURNS: ERROR if no history
  1936. */
  1938. LOCAL STATUS histPrev
  1939.     (
  1940.     FAST LED_ID ledId,
  1941.     FAST char *line             /* where to return historical line */
  1942.     )
  1943.     {
  1944.     if (ledId->pHist == NULL)
  1945. ledId->pHist = (HIST *) lstLast (&ledId->histList);
  1946.     else if ((ledId->pHist = (HIST *) lstPrevious (&ledId->pHist->node))
  1947.     == NULL)
  1948. {
  1949. ledId->pHist = (HIST *) lstLast (&ledId->histList);
  1950. }
  1952.     if (ledId->pHist == NULL)
  1953. return (ERROR);
  1955.     if (line != NULL)
  1956. strcpy (line, ledId->pHist->line);
  1958.     return (OK);
  1959.     }
  1960. /*******************************************************************************
  1961. *
  1962. * histFind - find string in history list
  1963. *
  1964. * Match should be of form: "/test", or "?test" for forward or backward searches.
  1965. *
  1966. * RETURNS: TRUE if history found, line is replaced with historical line
  1967. */
  1969. LOCAL BOOL histFind
  1970.     (
  1971.     FAST LED_ID ledId,
  1972.     FAST char *match,           /* what to match */
  1973.     FAST char *line             /* where to return historical line */
  1974.     )
  1975.     {
  1976.     char *pLine;
  1977.     FAST HIST *pH = ledId->pHist;
  1978.     FAST BOOL forward = match [0] == '?';
  1979.     int i = lstCount (&ledId->histList) + 1;
  1980.     BOOL found = FALSE;
  1982.     if (pH == NULL && (pH = (HIST *) lstLast (&ledId->histList)) == NULL)
  1983. return (FALSE);
  1985.     do
  1986. {
  1987. if (forward)
  1988.     {
  1989.     if ((pH = (HIST *) lstNext (&pH->node)) == NULL &&
  1990. (pH = (HIST *) lstFirst (&ledId->histList)) == NULL)
  1991. return (FALSE);
  1992.     }
  1994. pLine = pH->line;
  1996. while ((pLine = index (pLine, match [1])) != 0)
  1997.     {
  1998.     if (strncmp (pLine, &match [1], strlen (match) - 1) == 0)
  1999. {
  2000. found = TRUE;
  2001. break; /* found it! */
  2002. }
  2003.     else if (*(++pLine) == EOS)
  2004. break;
  2005.     }
  2007. if (!found && !forward)
  2008.     {
  2009.     if ((pH = (HIST *) lstPrevious (&pH->node)) == NULL &&
  2010. (pH = (HIST *) lstLast (&ledId->histList)) == NULL)
  2011. return (FALSE);
  2012.     }
  2013. }
  2014.     while (--i > 0 && !found);
  2016.     /* position 'pHist' correctly for next search */
  2018.     if (!forward)
  2019. {
  2020. if ((ledId->pHist = (HIST *) lstPrevious (&pH->node)) == NULL)
  2021.     ledId->pHist = (HIST *) lstLast (&ledId->histList);
  2022. }
  2023.     else
  2024. ledId->pHist = pH;
  2026.     if (i < 1)
  2027. return (FALSE);
  2029.     strcpy (line, pH->line);
  2031.     return (TRUE);
  2032.     }
  2033. /*******************************************************************************
  2034. *
  2035. * histAll - print all historical lines
  2036. */
  2038. LOCAL void histAll
  2039.     (
  2040.     FAST LED_ID ledId
  2041.     )
  2042.     {
  2043.     FAST int histFirst = ledId->histNum - lstCount (&ledId->histList) + 1;
  2044.     FAST HIST *pH;
  2045.     char buffer [LINE_LEN + 10]; /* Need to add padding for the
  2046.   * line number
  2047.   */
  2049.     for (pH = (HIST *) lstFirst (&ledId->histList);
  2050.  pH != NULL;
  2051.  pH = (HIST *) lstNext (&pH->node))
  2052. {
  2053. sprintf (buffer, "%3d  %s", histFirst++, pH->line);
  2054. (void)writex (ledId->outFd, buffer, strlen (buffer));
  2055. write (ledId->outFd, "n", 1);
  2056. }
  2057.     }
  2059. #ifdef UNIX_DEBUG
  2061. /*******************************************************************************
  2062. *
  2063. * main - UNIX debug module
  2064. *
  2065. * NOMANUAL
  2066. */
  2068. void main ()
  2070.     {
  2071.     static char *junk[] =
  2072.     { "one", "two", "three", "four", "five", "six", "seven",
  2073.       "eight", "nine", "ten", "force", "fits", "fight", "several" };
  2074.     char line [LINE_LEN+1];
  2075.     int i;
  2076.     int ledId;
  2079.     setbuf (stdout, NULL);
  2081.     sysSymTbl = symTblCreate (6);
  2083.     for (i = 0; i < NELEMENTS (junk); i++)
  2084. symSAdd (sysSymTbl, junk[i], 0, 0, symGroupDefault);
  2086.     ledId = ledOpen (0, 1, 20);
  2088.     system ("stty cbreak -echo");
  2090.     printf ("ledLib: UNIX Debugn");
  2092.     printf ("-> ");
  2094.     while (ledRead (ledId, line, LINE_LEN) != EOF)
  2095. {
  2096. printf ("-> ");
  2097. }
  2099.     system ("stty -cbreak echo");
  2100.     }
  2101. /*******************************************************************************
  2102. *
  2103. * errnoSet - bogus edition
  2104. *
  2105. * NOMANUAL
  2106. */
  2108. void errnoSet (status)
  2109.     int status;
  2111.     {
  2112.     printf ("errnoSet: new status 0x%x.n", status);
  2113.     }
  2114. #endif /* UNIX_DEBUG */