home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1994 March / Source_Code_CD-ROM_Walnut_Creek_March_1994.iso / compsrcs / misc / volume31 / pdksh / patch06b < prev    next >
Encoding:
Text File  |  1992-08-13  |  44.3 KB  |  2,101 lines
  1. Newsgroups: comp.sources.misc
  2. From: sjg@zen.void.oz.au (Simon J. Gerraty)
  3. Subject:  v31i075:  pdksh - Public Domain Korn Shell, Patch06b/2
  4. Message-ID: <1992Aug14.144322.21706@sparky.imd.sterling.com>
  5. X-Md4-Signature: f152eb945962077c781d4f85dc9ac548
  6. Date: Fri, 14 Aug 1992 14:43:22 GMT
  7. Approved: kent@sparky.imd.sterling.com
  8.  
  9. Submitted-by: sjg@zen.void.oz.au (Simon J. Gerraty)
  10. Posting-number: Volume 31, Issue 75
  11. Archive-name: pdksh/patch06b
  12. Environment: UNIX
  13. Patch-To: pdksh: Volume 25, Issue 47-55
  14.  
  15. This is the second part of patch06.
  16.  
  17. Apply this patch by changing directory to the root
  18. of the source tree and using the command:
  19.  
  20.     patch -p0 < this_file
  21.  
  22. *** sh/history.c.old    Tue May 12 13:42:00 1992
  23. --- sh/history.c    Mon Aug 10 22:02:44 1992
  24. ***************
  25. *** 5,12 ****
  26.    */
  27.   
  28.   #ifndef lint
  29. ! static char *RCSid = "$Id: history.c,v 1.2 1992/04/25 08:33:28 sjg Exp $";
  30.   #endif
  31.   
  32.   #include "stdh.h"
  33.   #include <errno.h>
  34. --- 5,23 ----
  35.    */
  36.   
  37.   #ifndef lint
  38. ! static char *RCSid = "$Id: history.c,v 1.3 1992/08/10 12:02:44 sjg Exp $";
  39.   #endif
  40. + /*
  41. +  *    This file contains
  42. +  *    a)    the original in-memory history  mechanism
  43. +  *    b)    a simple file saving history mechanism done by  sjg@zen
  44. +  *        define EASY_HISTORY to get this
  45. +  *    c)    a more complicated mechanism done by  pc@hillside.co.uk
  46. +  *        that more closely follows the real ksh way of doing
  47. +  *        things. You need to have the mmap system call for this
  48. +  *        to work on your system
  49. +  */
  50. + #ifdef EASY_HISTORY
  51.   
  52.   #include "stdh.h"
  53.   #include <errno.h>
  54. ***************
  55. *** 13,22 ****
  56.   #include <setjmp.h>
  57.   #include "sh.h"
  58.   
  59. - char   *histrpl();
  60. - char  **current;
  61. - int    curpos;
  62. - 
  63.   static FILE *hist_fh = NULL;
  64.   static FILE *hist_open ARGS((char *mode));
  65.   #ifndef HISTFILE
  66. --- 24,29 ----
  67. ***************
  68. *** 23,29 ****
  69. --- 30,80 ----
  70.   # define HISTFILE ".pdksh_hist"
  71.   #endif
  72.   
  73. + #else
  74. + /*    Defines and includes for the complicated case */
  75. + 
  76. + #include "stdh.h"
  77. + #include <sys/types.h>
  78. + #include <sys/stat.h>
  79. + #include <sys/file.h>
  80. + #include <sys/mman.h>
  81. + #include <errno.h>
  82. + #include <setjmp.h>
  83. + #include "sh.h"
  84. + 
  85. + int    histsize = HISTORY;    /* size of saved history */
  86. + char   **history;        /* saved commands */
  87. + char  **histptr;        /* last history item */
  88. + int    histpush;        /* number of pushed fc commands */
  89. + /*
  90. +  *    variables for handling the data file
  91. +  */
  92. + static char    *hname;
  93. + static int    histfd;
  94. + static int    hsize;
  95. + static int    hstarted;
  96. + 
  97. + static int hist_count_lines ARGS((unsigned char *, int));
  98. + static int hist_shrink ARGS((unsigned char *, int));
  99. + static unsigned char *hist_skip_back ARGS((unsigned char *,int *,int));
  100. + static void histload ARGS((Source *, unsigned char *, int));
  101. + static void histinsert ARGS((Source *, int, unsigned char *));
  102. + static void writehistfile ARGS((int, char *));
  103. + static int sprinkle ARGS((int));
  104. + 
  105. + #ifdef MAP_FILE
  106. + #define    MAP_FLAGS    MAP_FILE|MAP_PRIVATE
  107. + #else
  108. + #define    MAP_FLAGS    MAP_PRIVATE
  109. + #endif
  110. + 
  111. + #endif    /* of EASY_HISTORY */
  112. + 
  113.     
  114. + char   *histrpl();
  115. + char  **current;
  116. + int    curpos;
  117. + 
  118.   c_fc(wp)
  119.       register char **wp;
  120.   {
  121. ***************
  122. *** 93,99 ****
  123. --- 144,154 ----
  124.           else
  125.               histrpl(*hp, pat, rep, gflag);
  126.           histbackup();
  127. + #ifdef EASY_HISTORY
  128.           histsave(line); 
  129. + #else
  130. +         histsave(source->line+1, line, 1);
  131. + #endif
  132.           histpush--; 
  133.           line[0] = '\0';
  134.           return 0;
  135. ***************
  136. *** 155,161 ****
  137. --- 210,220 ----
  138.       setvbuf(f, (char *)NULL, _IOFBF, BUFSIZ);
  139.       /* we push the editted lines onto the history list */
  140.       while (fgets(line, sizeof(line), f) != NULL) {
  141. + #ifdef EASY_HISTORY
  142.           histsave(line); 
  143. + #else
  144. +         histsave(source->line, line, 1); 
  145. + #endif
  146.           histpush--; 
  147.       }
  148.       line[0] = '\0';
  149. ***************
  150. *** 181,207 ****
  151.   }
  152.   
  153.   /*
  154. -  * save command in history
  155. -  */
  156. - void
  157. - histsave(cmd)
  158. -     char *cmd;
  159. - {
  160. -     register char **hp = histptr;
  161. -     char *cp;
  162. - 
  163. -     if (++hp >= history + HISTORY) { /* remove oldest command */
  164. -         afree((void*)*history, APERM);
  165. -         for (hp = history; hp < history + HISTORY - 1; hp++)
  166. -             hp[0] = hp[1];
  167. -     }
  168. -     *hp = strsave(cmd, APERM);
  169. -     if ((cp = strchr(*hp, '\n')) != NULL)
  170. -         *cp = '\0';
  171. -     histptr = hp;
  172. - }
  173. - 
  174. - /*
  175.    * get pointer to history given pattern
  176.    * pattern is a number or string
  177.    */
  178. --- 240,245 ----
  179. ***************
  180. *** 260,265 ****
  181. --- 298,397 ----
  182.   }
  183.   
  184.   /*
  185. +  * Return the current position.
  186. +  */
  187. + char **
  188. + histpos()
  189. + {
  190. +     return current;
  191. + }
  192. + 
  193. + int
  194. + histN()
  195. + {
  196. +     return curpos;
  197. + }
  198. + 
  199. + int
  200. + histnum(n)
  201. + {
  202. +     int    last = histptr - history;
  203. + 
  204. +     if (n < 0 || n >= last) {
  205. +         current = histptr;
  206. +         curpos = last;
  207. +         return last;
  208. +     }  else {
  209. +         current = &history[n];
  210. +         curpos = n;
  211. +         return n;
  212. +     }
  213. + }
  214. + 
  215. + /*
  216. +  * This will become unecessary if histget is modified to allow
  217. +  * searching from positions other than the end, and in either 
  218. +  * direction.
  219. +  */
  220. + char *
  221. + findhist(start, fwd, str)
  222. +     int    start;
  223. +     int    fwd;
  224. +     char     *str;
  225. + {
  226. +     int     pos = start;
  227. +     char     *line, *last;
  228. + 
  229. +     /* XXX check that we are valid after this */
  230. +     if (fwd)
  231. +         pos++;
  232. +     else
  233. +         pos--;
  234. +     histnum(pos);
  235. +     line = *histpos();
  236. +     do {
  237. +         last = line;
  238. +         if (strstr(line, str) != 0) {
  239. +             /* keep position current */
  240. +             return (line);
  241. +         }
  242. +         if (fwd)
  243. +             pos++;
  244. +         else
  245. +             pos--;
  246. +         histnum(pos);
  247. +         line = *histpos();
  248. +     } while (line && *line && line != last && pos>0);
  249. + 
  250. +     histnum(start);
  251. +     if (pos <= 0)
  252. +         return (char*)-1; /* TODO */
  253. +     return NULL;
  254. + }
  255. + 
  256. + #ifdef EASY_HISTORY
  257. + /*
  258. +  * save command in history
  259. +  */
  260. + void
  261. + histsave(cmd)
  262. +     char *cmd;
  263. + {
  264. +     register char **hp = histptr;
  265. +     char *cp;
  266. + 
  267. +     if (++hp >= history + HISTORY) { /* remove oldest command */
  268. +         afree((void*)*history, APERM);
  269. +         for (hp = history; hp < history + HISTORY - 1; hp++)
  270. +             hp[0] = hp[1];
  271. +     }
  272. +     *hp = strsave(cmd, APERM);
  273. +     if ((cp = strchr(*hp, '\n')) != NULL)
  274. +         *cp = '\0';
  275. +     histptr = hp;
  276. + }
  277. + 
  278. + /*
  279.    * 92-04-25 <sjg@zen>
  280.    * A simple history file implementation.
  281.    * At present we only save the history when we exit.
  282. ***************
  283. *** 293,298 ****
  284. --- 425,433 ----
  285.     
  286.   }
  287.   
  288. + void
  289. + init_histvec()
  290. + {    ;    }
  291.   
  292.   /*
  293.    * save our history.
  294. ***************
  295. *** 351,426 ****
  296.     return fopen(rcp, mode);
  297.   }
  298.   
  299.   
  300.   
  301.   /*
  302. !  * Return the current position.
  303.    */
  304. ! char **
  305. ! histpos()
  306.   {
  307. !     return current;
  308.   }
  309.   
  310. ! int
  311. ! histN()
  312.   {
  313. !     return curpos;
  314.   }
  315.   
  316. ! int
  317. ! histnum(n)
  318.   {
  319. !     int    last = histptr - history;
  320.   
  321. !     if (n < 0 || n >= last) {
  322. !         current = histptr;
  323. !         curpos = last;
  324. !         return last;
  325. !     }  else {
  326. !         current = &history[n];
  327. !         curpos = n;
  328. !         return n;
  329.       }
  330.   }
  331.   
  332.   /*
  333. !  * This will become unecessary if histget is modified to allow
  334. !  * searching from positions other than the end, and in either 
  335. !  * direction.
  336.    */
  337. ! char *
  338. ! findhist(start, fwd, str)
  339. !     int    start;
  340. !     int    fwd;
  341. !     char     *str;
  342.   {
  343. !     int     pos = start;
  344. !     char     *line, *last;
  345.   
  346. !     /* XXX check that we are valid after this */
  347. !     if (fwd)
  348. !         pos++;
  349. !     else
  350. !         pos--;
  351. !     histnum(pos);
  352. !     line = *histpos();
  353. !     do {
  354. !         last = line;
  355. !         if (strstr(line, str) != 0) {
  356. !             /* keep position current */
  357. !             return (line);
  358.           }
  359. !         if (fwd)
  360. !             pos++;
  361. !         else
  362. !             pos--;
  363. !         histnum(pos);
  364. !         line = *histpos();
  365. !     } while (line && *line && line != last && pos>0);
  366.   
  367. !     histnum(start);
  368. !     if (pos <= 0)
  369. !         return (char*)-1; /* TODO */
  370.       return NULL;
  371.   }
  372. --- 486,974 ----
  373.     return fopen(rcp, mode);
  374.   }
  375.   
  376. + #else /* EASY_HISTORY */
  377.   
  378. + /*
  379. +  *    Routines added by Peter Collinson BSDI(Europe)/Hillside Systems to
  380. +  *    a) permit HISTSIZE to control number of lines of history stored
  381. +  *    b) maintain a physical history file
  382. +  *
  383. +  *    It turns out that there is a lot of ghastly hackery here
  384. +  */
  385.   
  386. + 
  387.   /*
  388. !  * save command in history
  389.    */
  390. ! void
  391. ! histsave(lno, cmd, dowrite)
  392. !     int lno;
  393. !     char *cmd;
  394. !     int dowrite;
  395.   {
  396. !     register char **hp;
  397. !     char *cp;
  398. ! 
  399. !     cmd = strsave(cmd, APERM);
  400. !     if ((cp = strchr(cmd, '\n')) != NULL)
  401. !         *cp = '\0';
  402. ! 
  403. !     if (histfd && dowrite)
  404. !         writehistfile(lno, cmd);
  405. ! 
  406. !     hp = histptr;
  407. !         
  408. !     if (++hp >= history + histsize) { /* remove oldest command */
  409. !         afree((void*)*history, APERM);
  410. !         for (hp = history; hp < history + histsize - 1; hp++)
  411. !             hp[0] = hp[1];
  412. !     }
  413. !     *hp = cmd;
  414. !     histptr = hp;
  415.   }
  416.   
  417. ! /*
  418. !  *    set history
  419. !  *    this means reallocating the dataspace
  420. !  */
  421. ! void
  422. ! sethistsize(n)
  423. !     int n;
  424.   {
  425. !     int    offset;
  426. !     
  427. !     if (n != histsize) {
  428. !         offset = histptr - history;
  429. !         history = (char **)aresize(history, n*sizeof(char *), APERM);
  430. ! 
  431. !         if (n < histsize && offset > histsize)
  432. !             offset = histsize;
  433. ! 
  434. !         histsize = n;
  435. !         histptr = history + offset;
  436. !     }
  437.   }
  438.   
  439. ! /*
  440. !  *    set history file
  441. !  *    This can mean reloading/resetting/starting history file
  442. !  *    maintenance
  443. !  */
  444. ! void
  445. ! sethistfile(name)
  446. !     char *name;
  447.   {
  448. !     /* if not started then nothing to do */
  449. !     if (hstarted == 0)
  450. !         return;
  451.   
  452. !     /* if the name is the same as the name we have */
  453. !     if (hname && strcmp(hname, name) == 0)
  454. !         return;
  455. ! 
  456. !     /*
  457. !      * its a new name - possibly
  458. !      */
  459. !     if (histfd) {
  460. !         /* yes the file is open */
  461. !         (void) close(histfd);
  462. !         histfd = 0;
  463. !         hsize = 0;
  464. !         afree(hname, APERM);
  465. !         hname = NULL;
  466. !         /* let's reset the history */
  467. !         histptr = history - 1;
  468. !         source->line = 0;
  469.       }
  470. + 
  471. +     hist_init(source);
  472.   }
  473.   
  474.   /*
  475. !  *    initialise the history vector
  476.    */
  477. ! void
  478. ! init_histvec()
  479.   {
  480. !     if (history == (char **)NULL) {
  481. !         history = (char **)alloc(histsize*sizeof (char *), APERM);
  482. !         histptr = history-1;
  483. !     }
  484. ! }
  485. !     
  486. ! /*
  487. !  *    Write history data to a file nominated by HISTFILE
  488. !  *    if HISTFILE is unset then history still happens, but
  489. !  *    the data is not written to a file
  490. !  *    All copies of ksh looking at the file will maintain the
  491. !  *    same history. This is ksh behaviour.
  492. !  *
  493. !  *    This stuff uses mmap()
  494. !  *    if your system ain't got it - then you'll have to undef HISTORYFILE
  495. !  */
  496. !     
  497. ! /*
  498. !  *    Open a history file
  499. !  *    Format is:
  500. !  *    Bytes 1, 2: HMAGIC - just to check that we are dealing with
  501. !  *            the correct object
  502. !  *    Then follows a number of stored commands
  503. !  *    Each command is
  504. !  *    <command byte><command number(4 bytes)><bytes><null>
  505. !  */
  506. ! #define HMAGIC1        0xab
  507. ! #define HMAGIC2        0xcd
  508. ! #define COMMAND        0xff
  509.   
  510. ! void
  511. ! hist_init(s)
  512. !     Source *s;
  513. ! {
  514. !     unsigned char    *base;
  515. !     int    lines;
  516. !     int    bytes;
  517. !     
  518. !     hstarted = 1;
  519. !     
  520. !     if (flag[FTALKING] == 0)
  521. !         return;
  522. ! 
  523. !     hname = strval(global("HISTFILE"));
  524. !     if (hname == NULL)
  525. !         return;
  526. !     hname = strsave(hname, APERM);
  527. ! 
  528. !   retry:
  529. !     /* we have a file and are interactive */
  530. !     if ((histfd = open(hname, O_RDWR|O_CREAT|O_APPEND, 0600)) < 0)
  531. !         return;
  532. ! 
  533. !     histfd = fcntl(histfd, F_DUPFD, FDBASE);
  534. !     
  535. !     (void) fcntl(histfd, F_SETFD, 1); /* close on exec */
  536. !     
  537. !     (void) flock(histfd, LOCK_EX);
  538. ! 
  539. !     hsize = lseek(histfd, 0L, L_XTND);
  540. ! 
  541. !     if (hsize == 0) {
  542. !         /* add magic */
  543. !         if (sprinkle(histfd)) {
  544. !             hist_finish();
  545. !             return;
  546.           }
  547. !     }
  548. !     else if (hsize > 0) {
  549. !         /*
  550. !          * we have some data
  551. !          */
  552. !         base = (unsigned char *)mmap(0, hsize, PROT_READ, MAP_FLAGS, histfd, 0);
  553. !         /*
  554. !          * check on its validity
  555. !          */
  556. !         if ((int)base == -1 || *base != HMAGIC1 || base[1] != HMAGIC2) {
  557. !             if ((int)base !=  -1)
  558. !                 munmap((caddr_t)base, hsize);
  559. !             hist_finish();
  560. !             unlink(hname);
  561. !             goto retry;
  562. !         }
  563. !         if (hsize > 2) {
  564. !             lines = hist_count_lines(base+2, hsize-2);
  565. !             if (lines > histsize) {
  566. !                 /* we need to make the file smaller */
  567. !                 if (hist_shrink(base, hsize))
  568. !                     unlink(hname);
  569. !                 munmap((caddr_t)base, hsize);
  570. !                 hist_finish();
  571. !                 goto retry;
  572. !             }
  573. !         }
  574. !         histload(s, base+2, hsize-2);
  575. !         munmap((caddr_t)base, hsize);
  576. !     }
  577. !     (void) flock(histfd, LOCK_UN);
  578. !     hsize = lseek(histfd, 0L, L_XTND);
  579. ! }
  580.   
  581. ! typedef enum state {
  582. !     shdr,        /* expecting a header */
  583. !     sline,        /* looking for a null byte to end the line */
  584. !     sn1,        /* bytes 1 to 4 of a line no */
  585. !     sn2, sn3, sn4,
  586. ! } State;
  587. ! 
  588. ! static int
  589. ! hist_count_lines(base, bytes)
  590. !     register unsigned char *base;
  591. !     register int bytes;
  592. ! {
  593. !     State state = shdr;
  594. !     register lines = 0;
  595. !     
  596. !     while (bytes--) {
  597. !         switch (state)
  598. !         {
  599. !         case shdr:
  600. !             if (*base == COMMAND)
  601. !                 state = sn1;
  602. !             break;
  603. !         case sn1:
  604. !             state = sn2; break;
  605. !         case sn2:
  606. !             state = sn3; break;
  607. !         case sn3:
  608. !             state = sn4; break;
  609. !         case sn4:
  610. !             state = sline; break;
  611. !         case sline:
  612. !             if (*base == '\0')
  613. !                 lines++, state = shdr;
  614. !         }
  615. !         base++;
  616. !     }
  617. !     return lines;
  618. ! }
  619. ! 
  620. ! /*
  621. !  *    Shrink the history file to histsize lines
  622. !  */
  623. ! static int
  624. ! hist_shrink(oldbase, oldbytes)
  625. !     unsigned char *oldbase;
  626. !     int oldbytes;
  627. ! {
  628. !     int fd;
  629. !     char    nfile[1024];
  630. !     struct    stat statb;
  631. !     unsigned char *nbase = oldbase;
  632. !     int nbytes = oldbytes;
  633. ! 
  634. !     nbase = hist_skip_back(nbase, &nbytes, histsize);
  635. !     if (nbase == NULL)
  636. !         return 1;
  637. !     if (nbase == oldbase)
  638. !         return 0;
  639. !     
  640. !     /*
  641. !      *    create temp file
  642. !      */
  643. !     (void) sprintf(nfile, "%s.%d", hname, getpid());
  644. !     if ((fd = creat(nfile, 0600)) < 0)
  645. !         return 1;
  646. ! 
  647. !     if (sprinkle(fd)) {
  648. !         close(fd);
  649. !         unlink(nfile);
  650. !         return 1;
  651. !     }
  652. !     if (write(fd, nbase, nbytes) != nbytes) {
  653. !         close(fd);
  654. !         unlink(nfile);
  655. !         return 1;
  656. !     }
  657. !     /*
  658. !      *    worry about who owns this file
  659. !      */
  660. !     if (fstat(histfd, &statb) >= 0)
  661. !         fchown(fd, statb.st_uid, statb.st_gid);
  662. !     close(fd);
  663. !     
  664. !     /*
  665. !      *    rename
  666. !      */
  667. !     if (rename(nfile, hname) < 0)
  668. !         return 1;
  669. !     return 0;
  670. ! }
  671. !     
  672. ! 
  673. ! /*
  674. !  *    find a pointer to the data `no' back from the end of the file
  675. !  *    return the pointer and the number of bytes left
  676. !  */
  677. ! static unsigned char *
  678. ! hist_skip_back(base, bytes, no)
  679. !     unsigned char *base;
  680. !     int *bytes;
  681. !     int no;
  682. ! {
  683. !     register int lines = 0;
  684. !     register unsigned char *ep;
  685. ! 
  686. !     
  687. ! 
  688. !     for (ep = base + *bytes; ep > base; ep--)
  689. !     {
  690. !         while (*ep != COMMAND) {
  691. !             if (--ep == base)
  692. !                 break;
  693. !         }
  694. !         if (++lines == no) {
  695. !             *bytes = *bytes - ((char *)ep - (char *)base);
  696. !             return ep;
  697. !         }
  698. !     }
  699. !     if (ep > base)
  700. !         return base;
  701.       return NULL;
  702.   }
  703. + 
  704. + /*
  705. +  *    load the history structure from the stored data
  706. +  */
  707. + static void
  708. + histload(s, base, bytes)
  709. +     Source *s;
  710. +     register unsigned char *base;
  711. +     register int bytes;
  712. + {
  713. +     State state;
  714. +     int    lno;
  715. +     unsigned char    *line;
  716. +     
  717. +     for (state = shdr; bytes-- > 0; base++) {
  718. +         switch (state) {
  719. +         case shdr:
  720. +             if (*base == COMMAND)
  721. +                 state = sn1;
  722. +             break;
  723. +         case sn1:
  724. +             lno = (((*base)&0xff)<<24);
  725. +             state = sn2;
  726. +             break;
  727. +         case sn2:
  728. +             lno |= (((*base)&0xff)<<16);
  729. +             state = sn3;
  730. +             break;
  731. +         case sn3:
  732. +             lno |= (((*base)&0xff)<<8);
  733. +             state = sn4;
  734. +             break;
  735. +         case sn4:
  736. +             lno |= (*base)&0xff;
  737. +             line = base+1;
  738. +             state = sline;
  739. +             break;
  740. +         case sline:
  741. +             if (*base == '\0') {
  742. +                 /* worry about line numbers */
  743. +                 if (histptr >= history && lno-1 != s->line) {
  744. +                     /* a replacement ? */
  745. +                     histinsert(s, lno, line);
  746. +                 }
  747. +                 else {
  748. +                     s->line = lno;
  749. +                     histsave(lno, (char *)line, 0);
  750. +                 }
  751. +                 state = shdr;
  752. +             }
  753. +         }
  754. +     }
  755. + }
  756. +                 
  757. + /*
  758. +  *    Insert a line into the history at a specified number
  759. +  */
  760. + static void
  761. + histinsert(s, lno, line)
  762. +     Source *s;
  763. +     int lno;
  764. +     unsigned char *line;
  765. + {
  766. +     register char **hp;
  767. +     
  768. +     if (lno >= s->line-(histptr-history) && lno <= s->line) {
  769. +         hp = &histptr[lno-s->line];
  770. +         if (*hp)
  771. +             afree((void*)*hp, APERM);
  772. +         *hp = strsave((char *)line, APERM);
  773. +     }
  774. + }
  775. + 
  776. + /*
  777. +  *    write a command to the end of the history file
  778. +  *    This *MAY* seem easy but it's also necessary to check
  779. +  *    that the history file has not changed in size.
  780. +  *    If it has - then some other shell has written to it
  781. +  *    and we should read those commands to update our history
  782. +  */
  783. + static void
  784. + writehistfile(lno, cmd)
  785. +     int lno;
  786. +     char *cmd;
  787. + {
  788. +     int    sizenow;
  789. +     unsigned char    *base;
  790. +     unsigned char    *new;
  791. +     int    bytes;
  792. +     char    hdr[5];
  793. +     
  794. +     (void) flock(histfd, LOCK_EX);
  795. +     sizenow = lseek(histfd, 0L, L_XTND);
  796. +     if (sizenow != hsize) {
  797. +         /*
  798. +          *    Things have changed
  799. +          */
  800. +         if (sizenow > hsize) {
  801. +             /* someone has added some lines */
  802. +             bytes = sizenow - hsize;
  803. +             base = (unsigned char *)mmap(0, sizenow, PROT_READ, MAP_FLAGS, histfd, 0);
  804. +             if ((int)base == -1)
  805. +                 goto bad;
  806. +             new = base + hsize;
  807. +             if (*new != COMMAND) {
  808. +                 munmap((caddr_t)base, sizenow);
  809. +                 goto bad;
  810. +             }
  811. +             source->line--;
  812. +             histload(source, new, bytes);
  813. +             source->line++;
  814. +             lno = source->line;
  815. +             munmap((caddr_t)base, sizenow);
  816. +             hsize = sizenow;
  817. +         } else {
  818. +             /* it has shrunk */
  819. +             /* but to what? */
  820. +             /* we'll give up for now */
  821. +             goto bad;
  822. +         }
  823. +     }
  824. +     /*
  825. +      *    we can write our bit now
  826. +      */
  827. +     hdr[0] = COMMAND;
  828. +     hdr[1] = (lno>>24)&0xff;
  829. +     hdr[2] = (lno>>16)&0xff;
  830. +     hdr[3] = (lno>>8)&0xff;
  831. +     hdr[4] = lno&0xff;
  832. +     (void) write(histfd, hdr, 5);
  833. +     (void) write(histfd, cmd, strlen(cmd)+1);
  834. +     hsize = lseek(histfd, 0L, L_XTND);
  835. +     (void) flock(histfd, LOCK_UN);
  836. +     return;
  837. + bad:
  838. +     hist_finish();
  839. + }
  840. + 
  841. + void
  842. + hist_finish()
  843. + {
  844. +     (void) flock(histfd, LOCK_UN);
  845. +     (void) close(histfd);
  846. +     histfd = 0;
  847. + }
  848. + 
  849. + /*
  850. +  *    add magic to the history file
  851. +  */
  852. + static int
  853. + sprinkle(fd)
  854. +     int fd;
  855. + {
  856. +     static char mag[] = { HMAGIC1, HMAGIC2 };
  857. + 
  858. +     return(write(fd, mag, 2) != 2);
  859. + }
  860. + 
  861. + #endif
  862. *** sh/io.c.old    Tue May 12 13:42:00 1992
  863. --- sh/io.c    Mon Aug 10 22:02:49 1992
  864. ***************
  865. *** 3,9 ****
  866.    */
  867.   
  868.   #ifndef lint
  869. ! static char *RCSid = "$Id: io.c,v 1.2 1992/04/25 08:33:28 sjg Exp $";
  870.   #endif
  871.   
  872.   #include "stdh.h"
  873. --- 3,9 ----
  874.    */
  875.   
  876.   #ifndef lint
  877. ! static char *RCSid = "$Id: io.c,v 1.3 1992/08/10 12:02:49 sjg Exp $";
  878.   #endif
  879.   
  880.   #include "stdh.h"
  881. ***************
  882. *** 99,109 ****
  883. --- 99,114 ----
  884.       if (shf[fd] != NULL)
  885.           return;
  886.       if (fd <= 2)
  887. + #ifndef _BSDI
  888.   #ifdef _MINIX
  889.           /* ? */;
  890.   #else
  891.           _iob[fd]._flag = 0; /* re-use stdin, stdout, stderr */
  892.   #endif
  893. + #else
  894. +         /* Chris Torek's stdio replacement */
  895. +         __sF[fd]._flags = 0;
  896. + #endif
  897.       shf[fd] = fdopen(fd, "r+");
  898.       if (shf[fd] == NULL)
  899.           return;
  900. ***************
  901. *** 117,123 ****
  902. --- 122,131 ----
  903.       int fd;
  904.   {
  905.       if (shf[fd] != NULL) {
  906. + #ifndef _BSDI
  907. +         /* Chris Torek's stdio replacement */
  908.           fseek(shf[fd], 0L, 1); /* V7 derived */
  909. + #endif
  910.           fflush(shf[fd]);    /* standard C */
  911.       }
  912.   }
  913. *** sh/jobs.c.old    Tue May 12 13:42:00 1992
  914. --- sh/jobs.c    Mon Aug 10 22:02:52 1992
  915. ***************
  916. *** 2,8 ****
  917.    * Process and job control
  918.    */
  919.   #ifndef lint
  920. ! static char *RCSid = "$Id: jobs.c,v 1.4 1992/04/27 07:14:26 sjg Exp $";
  921.   #endif
  922.   
  923.   /*
  924. --- 2,8 ----
  925.    * Process and job control
  926.    */
  927.   #ifndef lint
  928. ! static char *RCSid = "$Id: jobs.c,v 1.5 1992/08/10 12:02:52 sjg Exp $";
  929.   #endif
  930.   
  931.   /*
  932. ***************
  933. *** 14,23 ****
  934.    *    make %+ be jobs, %- be jobs->next.
  935.    *    do not JFREE members of pipeline.
  936.    *    consider procs[] related critical sections.
  937. -  *    signal(SIGCHLD, j_sigchld) should be
  938. -  *    sigaction(SIGCHLD, sigchld, NULL),
  939. -  *    with sigchld.sa_flags = SA_RESTART.
  940. -  *    There is a simple work-around if there is no SA_RESTART.
  941.    */
  942.   
  943.   #include "stdh.h"
  944. --- 14,19 ----
  945. ***************
  946. *** 29,34 ****
  947. --- 25,34 ----
  948.   #include <sys/wait.h>
  949.   #include "sh.h"
  950.   #ifdef JOBS
  951. + #ifdef _BSDI
  952. + #define _BSD
  953. + #define WIFCORED(x) WCOREDUMP(x)
  954. + #endif
  955.   #ifdef _BSD
  956.   #include <sys/ioctl.h>
  957.   #else
  958. ***************
  959. *** 101,107 ****
  960. --- 101,111 ----
  961.   #else
  962.   #define WAIT_T int
  963.   #endif
  964. + #ifdef _BSDI
  965. + #undef WAIT_T
  966. + #define WAIT_T int
  967.   #endif
  968. + #endif
  969.   #ifndef SA_RESTART
  970.   #define SA_RESTART    0
  971.   #endif
  972. ***************
  973. *** 313,319 ****
  974.       j->state = JRUN;
  975.   
  976.       /* stdio buffer must be flushed and invalidated */
  977. !     for (i = 0; i < NUFILE; i++)
  978.           flushshf(i);
  979.   
  980.       /* create child process */
  981. --- 317,323 ----
  982.       j->state = JRUN;
  983.   
  984.       /* stdio buffer must be flushed and invalidated */
  985. !     for (i = (flags&XXWHL) ? 1 : 0; i < NUFILE; i++)
  986.           flushshf(i);
  987.   
  988.       /* create child process */
  989. *** sh/lex.c.old    Tue May 12 13:42:00 1992
  990. --- sh/lex.c    Mon Aug 10 22:02:55 1992
  991. ***************
  992. *** 3,9 ****
  993.    */
  994.   
  995.   #ifndef lint
  996. ! static char *RCSid = "$Id: lex.c,v 1.2 1992/04/25 08:33:28 sjg Exp $";
  997.   #endif
  998.   
  999.   #include "stdh.h"
  1000. --- 3,9 ----
  1001.    */
  1002.   
  1003.   #ifndef lint
  1004. ! static char *RCSid = "$Id: lex.c,v 1.3 1992/08/10 12:02:55 sjg Exp $";
  1005.   #endif
  1006.   
  1007.   #include "stdh.h"
  1008. ***************
  1009. *** 15,23 ****
  1010. --- 15,25 ----
  1011.   #include "expand.h"
  1012.   
  1013.       int    ttyfd = -1;        /* tty fd for edit and jobs */
  1014. + #ifdef EASY_HISTORY
  1015.       char   *history[HISTORY];    /* saved commands */
  1016.       char  **histptr = history - 1;    /* last history item */
  1017.       int    histpush;        /* number of pushed fc commands */
  1018. + #endif
  1019.   
  1020.   /* we set s->str to NULLSTR instead of "", so that ungetsc() works */
  1021.   static    char    nullstr [] = {0, 0};
  1022. ***************
  1023. *** 561,567 ****
  1024. --- 563,573 ----
  1025.                       s->line--;
  1026.                   } else {
  1027.                       s->str = &line[c];
  1028. + #ifdef EASY_HISTORY
  1029.                       histsave(s->str);
  1030. + #else
  1031. +                     histsave(s->line, s->str, 1);
  1032. + #endif
  1033.                   }
  1034.               }
  1035.               break;
  1036. *** sh/lex.h.old    Tue May 12 13:42:00 1992
  1037. --- sh/lex.h    Mon Aug 10 22:02:58 1992
  1038. ***************
  1039. *** 2,8 ****
  1040.    * Source input, lexer and parser
  1041.    */
  1042.   
  1043. ! /* $Id: lex.h,v 1.2 1992/04/25 08:33:28 sjg Exp $ */
  1044.   
  1045.   #define    IDENT    64
  1046.   
  1047. --- 2,8 ----
  1048.    * Source input, lexer and parser
  1049.    */
  1050.   
  1051. ! /* $Id: lex.h,v 1.3 1992/08/10 12:02:58 sjg Exp $ */
  1052.   
  1053.   #define    IDENT    64
  1054.   
  1055. ***************
  1056. *** 79,84 ****
  1057. --- 79,85 ----
  1058.   #define    REDIR    275
  1059.   #define    MPAREN    276        /* () */
  1060.   #define    MDPAREN    277        /* (( )) */
  1061. + #define SELECT    278        /* ksh */
  1062.   #define    YYERRCODE 300
  1063.   
  1064.   /* flags to yylex */
  1065. ***************
  1066. *** 103,109 ****
  1067. --- 104,115 ----
  1068.   
  1069.   #define    HISTORY    100        /* size of saved history */
  1070.   
  1071. + #ifdef EASY_HISTORY
  1072.   extern    char   *history [HISTORY];    /* saved commands */
  1073. + #else
  1074. + extern    int    histsize;    /* history size */
  1075. + extern    char  **history;    /* saved commands */
  1076. + #endif
  1077.   extern    char  **histptr;    /* last history item */
  1078.   extern    int    histpush;    /* number of pushed fc commands */
  1079.   
  1080. *** sh/main.c.old    Tue May 12 13:42:00 1992
  1081. --- sh/main.c    Mon Aug 10 22:03:00 1992
  1082. ***************
  1083. *** 3,9 ****
  1084.    */
  1085.   
  1086.   #ifndef lint
  1087. ! static char *RCSid = "$Id: main.c,v 1.4 1992/04/29 06:25:47 sjg Exp $";
  1088.   #endif
  1089.   
  1090.   #define    Extern                /* define Externs in sh.h */
  1091. --- 3,9 ----
  1092.    */
  1093.   
  1094.   #ifndef lint
  1095. ! static char *RCSid = "$Id: main.c,v 1.5 1992/08/10 12:03:00 sjg Exp $";
  1096.   #endif
  1097.   
  1098.   #define    Extern                /* define Externs in sh.h */
  1099. ***************
  1100. *** 37,45 ****
  1101.   
  1102.   static    const    char   initsubs [] = 
  1103.   #ifdef sun                /* sun's don't have a real /bin */
  1104. !   "${SHELL:=/bin/sh} ${PATH:=/usr/bin:/usr/ucb:.} ${HOME:=/} ${PS1:=$ } ${PS2:=> } ${MAILCHECK:=600}";
  1105.   #else
  1106. !   "${SHELL:=/bin/sh} ${PATH:=/bin:/usr/bin:.} ${HOME:=/} ${PS1:=$ } ${PS2:=> } ${MAILCHECK:=600}";
  1107.   #endif
  1108.   
  1109.   static    const    char *initcoms [] = {
  1110. --- 37,45 ----
  1111.   
  1112.   static    const    char   initsubs [] = 
  1113.   #ifdef sun                /* sun's don't have a real /bin */
  1114. !   "${SHELL:=/bin/sh} ${PATH:=/usr/bin:/usr/ucb:.} ${HOME:=/} ${PS1:=$ } ${PS2:=> } ${PS3:=#? } ${MAILCHECK:=600}";
  1115.   #else
  1116. !   "${SHELL:=/bin/sh} ${PATH:=/bin:/usr/bin:.} ${HOME:=/} ${PS1:=$ } ${PS2:=> } ${PS3:=#? } ${MAILCHECK:=600}";
  1117.   #endif
  1118.   
  1119.   static    const    char *initcoms [] = {
  1120. ***************
  1121. *** 52,58 ****
  1122.         "history=fc -l", "r=fc -e -", "nohup=nohup ",
  1123.         "login=exec login", "newgrp=exec newgrp",
  1124.         "type=whence -v", "functions=typeset -f",
  1125. !       "echo=print", "true=:", "false=let", "[=\\[", NULL,
  1126.       NULL
  1127.   };
  1128.   
  1129. --- 52,64 ----
  1130.         "history=fc -l", "r=fc -e -", "nohup=nohup ",
  1131.         "login=exec login", "newgrp=exec newgrp",
  1132.         "type=whence -v", "functions=typeset -f",
  1133. !       "echo=print", "true=:", "false=let", "[=\\[",
  1134. ! #ifdef JOBS
  1135. !       "suspend=kill -STOP $$",
  1136. ! #endif
  1137. !       NULL,
  1138. ! 
  1139. !     
  1140.       NULL
  1141.   };
  1142.   
  1143. ***************
  1144. *** 135,140 ****
  1145. --- 141,148 ----
  1146.       tinit(&lexicals, APERM);
  1147.       tinit(&homedirs, APERM);
  1148.   
  1149. +     init_histvec();
  1150. +     
  1151.       /* import enviroment */
  1152.       if (envp != NULL)
  1153.           for (wp = envp; *wp != NULL; wp++)
  1154. ***************
  1155. *** 236,242 ****
  1156.           (void) fd_clexec(ttyfd);
  1157.   #endif
  1158.   #ifdef EMACS
  1159. !         x_init_emacs();
  1160.   #endif
  1161.       }
  1162.   
  1163. --- 244,250 ----
  1164.           (void) fd_clexec(ttyfd);
  1165.   #endif
  1166.   #ifdef EMACS
  1167. !           x_init_emacs();
  1168.   #endif
  1169.       }
  1170.   
  1171. *** sh/patchlevel.h.old    Tue May 12 13:42:00 1992
  1172. --- sh/patchlevel.h    Mon Aug 10 22:03:03 1992
  1173. ***************
  1174. *** 1,6 ****
  1175.   /*
  1176.    * PD KSH
  1177. !  * $Id: patchlevel.h,v 4.5 1992/05/12 09:30:34 sjg Exp $
  1178.    */
  1179.   #define VERSION        4
  1180. ! #define PATCHLEVEL    5
  1181. --- 1,6 ----
  1182.   /*
  1183.    * PD KSH
  1184. !  * $Id: patchlevel.h,v 4.6 1992/08/10 12:03:03 sjg Exp $
  1185.    */
  1186.   #define VERSION        4
  1187. ! #define PATCHLEVEL    6
  1188. *** sh/proto.h.old    Tue May 12 13:42:00 1992
  1189. --- sh/proto.h    Mon Aug 10 22:03:05 1992
  1190. ***************
  1191. *** 1,7 ****
  1192.   /*
  1193.    * prototypes for PD-KSH
  1194.    * originally generated using "cproto.c 3.5 92/04/11 19:28:01 cthuang "
  1195. !  * $Id: proto.h,v 1.1 1992/04/25 08:29:02 sjg Exp $
  1196.    */
  1197.   #ifndef ARGS
  1198.   #if defined(__STDC__) || defined(__cplusplus)
  1199. --- 1,7 ----
  1200.   /*
  1201.    * prototypes for PD-KSH
  1202.    * originally generated using "cproto.c 3.5 92/04/11 19:28:01 cthuang "
  1203. !  * $Id: proto.h,v 1.2 1992/08/10 12:03:05 sjg Exp $
  1204.    */
  1205.   #ifndef ARGS
  1206.   #if defined(__STDC__) || defined(__cplusplus)
  1207. ***************
  1208. *** 74,79 ****
  1209. --- 74,80 ----
  1210.   bool_t     x_mode         ARGS((bool_t onoff));
  1211.   int     promptlen     ARGS((char *cp));
  1212.   int     init_editmode     ARGS((void));
  1213. + void     set_editmode     ARGS((char *ed));
  1214.   /* emacs.c */
  1215.   int     x_emacs         ARGS((char *buf, size_t len));
  1216.   void     x_redraw     ARGS((int limit));
  1217. ***************
  1218. *** 85,90 ****
  1219. --- 86,92 ----
  1220.   char *    substitute     ARGS((char const *cp, int f));
  1221.   char **    eval         ARGS((char **ap, int f));
  1222.   char *    evalstr         ARGS((char *cp, int f));
  1223. + char *    evalonestr     ARGS((char *cp, int f));
  1224.   /* exec.c */
  1225.   int     execute         ARGS((struct op *t, volatile int flags));
  1226.   int     shcomexec     ARGS((char **wp));
  1227. ***************
  1228. *** 93,98 ****
  1229. --- 95,101 ----
  1230.   struct tbl *    findcom     ARGS((char *name, int insert));
  1231.   int     flushcom     ARGS((int all));
  1232.   char *    search         ARGS((char *name, char *path, int mode));
  1233. + int    pr_menu         ARGS((char **ap, int usestored));
  1234.   /* expr.c */
  1235.   void     evalerr         ARGS((char *err));
  1236.   long     evaluate     ARGS((const char *expr));
  1237. ***************
  1238. *** 102,108 ****
  1239. --- 105,117 ----
  1240.   /* history.c */
  1241.   int     c_fc          ARGS((register char **wp));
  1242.   void     histbackup     ARGS((void));
  1243. + #ifdef EASY_HISTORY
  1244.   void     histsave     ARGS((char *cmd));
  1245. + #else
  1246. + void    sethistsize     ARGS((int n));
  1247. + void    sethistfile     ARGS((char *name));
  1248. + void    histsave     ARGS((int lno, char *cmd, int dowrite));
  1249. + #endif
  1250.   char **    histget          ARGS((char *str));
  1251.   char *    histrpl          ARGS((char *s, char *pat, char *rep, int global));
  1252.   void     hist_init     ARGS((Source *s));
  1253. *** sh/sh.h.old    Tue May 12 13:42:00 1992
  1254. --- sh/sh.h    Mon Aug 10 22:03:08 1992
  1255. ***************
  1256. *** 2,8 ****
  1257.    * Public Domain Bourne/Korn shell
  1258.    */
  1259.   
  1260. ! /* $Id: sh.h,v 1.3 1992/04/25 08:29:52 sjg Exp $ */
  1261.   
  1262.   #include "config.h"
  1263.   
  1264. --- 2,8 ----
  1265.    * Public Domain Bourne/Korn shell
  1266.    */
  1267.   
  1268. ! /* $Id: sh.h,v 1.4 1992/08/10 12:03:08 sjg Exp $ */
  1269.   
  1270.   #include "config.h"
  1271.   
  1272. ***************
  1273. *** 15,20 ****
  1274. --- 15,24 ----
  1275.   #define    SHELL    "/bin/sh"    /* shell to exec scripts */
  1276.   #endif
  1277.   
  1278. + #ifdef _BSD
  1279. + #define memmove(dst, src, n)    bcopy((src), (dst), (n))
  1280. + #endif
  1281. + 
  1282.   /* some people object to this use of __STDC__ */
  1283.   #ifdef __STDC__
  1284.   #define    ARGS(args)    args    /* prototype declaration */
  1285. ***************
  1286. *** 143,148 ****
  1287. --- 147,153 ----
  1288.   void    resetopts();
  1289.   void    histsave();
  1290.   void    histlist();
  1291. + int    pr_menu ARGS((char **, int));
  1292.   
  1293.   void    j_init ARGS((void));
  1294.   void    j_exit ARGS((void));
  1295. *** sh/syn.c.old    Tue May 12 13:42:00 1992
  1296. --- sh/syn.c    Mon Aug 10 22:03:10 1992
  1297. ***************
  1298. *** 3,9 ****
  1299.    */
  1300.   
  1301.   #ifndef lint
  1302. ! static char *RCSid = "$Id: syn.c,v 1.2 1992/04/25 08:33:28 sjg Exp $";
  1303.   #endif
  1304.   
  1305.   #include "stdh.h"
  1306. --- 3,9 ----
  1307.    */
  1308.   
  1309.   #ifndef lint
  1310. ! static char *RCSid = "$Id: syn.c,v 1.3 1992/08/10 12:03:10 sjg Exp $";
  1311.   #endif
  1312.   
  1313.   #include "stdh.h"
  1314. ***************
  1315. *** 258,264 ****
  1316.           break;
  1317.   
  1318.         case FOR:
  1319. !         t = newtp(TFOR);
  1320.           musthave(LWORD, 0);
  1321.           t->str = strsave(ident, ATEMP);
  1322.           multiline++;
  1323. --- 258,265 ----
  1324.           break;
  1325.   
  1326.         case FOR:
  1327. !       case SELECT:
  1328. !         t = newtp((c == FOR) ? TFOR: TSELECT);
  1329.           musthave(LWORD, 0);
  1330.           t->str = strsave(ident, ATEMP);
  1331.           multiline++;
  1332. ***************
  1333. *** 505,510 ****
  1334. --- 506,512 ----
  1335.       int    val;
  1336.   } restab[] = {
  1337.       "for",        FOR,
  1338. +     "select",    SELECT,
  1339.       "case",        CASE,
  1340.       "esac",        ESAC,
  1341.       "while",    WHILE,
  1342. *** sh/table.h.old    Tue May 12 13:42:00 1992
  1343. --- sh/table.h    Mon Aug 10 22:03:13 1992
  1344. ***************
  1345. *** 1,4 ****
  1346. ! /* $Id: table.h,v 1.2 1992/04/25 08:33:28 sjg Exp $ */
  1347.   
  1348.   /*
  1349.    * generic hashed associative table for commands and variables.
  1350. --- 1,4 ----
  1351. ! /* $Id: table.h,v 1.3 1992/08/10 12:03:13 sjg Exp $ */
  1352.   
  1353.   /*
  1354.    * generic hashed associative table for commands and variables.
  1355. ***************
  1356. *** 94,99 ****
  1357. --- 94,105 ----
  1358.   #define    V_MAIL    5
  1359.   #define    V_MAILPATH 6
  1360.   #define    V_RANDOM 7
  1361. + #ifndef EASY_HISTORY
  1362. + #define V_HISTSIZE 8
  1363. + #define V_HISTFILE 9
  1364. + #endif
  1365. + #define V_FCEDIT 10
  1366. + #define V_COLUMNS 11
  1367.   
  1368.   Extern    Area   *lastarea;    /* area of last variable/function looked up */
  1369.   Extern    char   *path;        /* PATH value */
  1370. *** sh/trap.c.old    Tue May 12 13:42:00 1992
  1371. --- sh/trap.c    Mon Aug 10 22:03:15 1992
  1372. ***************
  1373. *** 3,9 ****
  1374.    */
  1375.   
  1376.   #ifndef lint
  1377. ! static char *RCSid = "$Id: trap.c,v 1.2 1992/04/24 12:01:38 sjg Exp $";
  1378.   #endif
  1379.   
  1380.   #include "stdh.h"
  1381. --- 3,9 ----
  1382.    */
  1383.   
  1384.   #ifndef lint
  1385. ! static char *RCSid = "$Id: trap.c,v 1.3 1992/08/10 12:03:15 sjg Exp $";
  1386.   #endif
  1387.   
  1388.   #include "stdh.h"
  1389. ***************
  1390. *** 101,107 ****
  1391.       int i;
  1392.   {
  1393.       trap = sigtraps[i].set = 1;
  1394. !     if (i == SIGINT && e.type == E_PARSE)
  1395.           /* dangerous but necessary to deal with BSD silly signals */
  1396.           longjmp(e.jbuf, 1);
  1397.   #ifdef USE_SIGACT
  1398. --- 101,107 ----
  1399.       int i;
  1400.   {
  1401.       trap = sigtraps[i].set = 1;
  1402. !     if (i == SIGINT && (e.type == E_PARSE || e.type == E_LOOP))
  1403.           /* dangerous but necessary to deal with BSD silly signals */
  1404.           longjmp(e.jbuf, 1);
  1405.   #ifdef USE_SIGACT
  1406. *** sh/tree.h.old    Tue May 12 13:42:00 1992
  1407. --- sh/tree.h    Mon Aug 10 22:03:18 1992
  1408. ***************
  1409. *** 2,8 ****
  1410.    * command trees for compile/execute
  1411.    */
  1412.   
  1413. ! /* $Id: tree.h,v 1.2 1992/04/25 08:33:28 sjg Exp $ */
  1414.   
  1415.   #define    NOBLOCK    ((struct op *)NULL)
  1416.   #define    NOWORD    ((char *)NULL)
  1417. --- 2,8 ----
  1418.    * command trees for compile/execute
  1419.    */
  1420.   
  1421. ! /* $Id: tree.h,v 1.3 1992/08/10 12:03:18 sjg Exp $ */
  1422.   
  1423.   #define    NOBLOCK    ((struct op *)NULL)
  1424.   #define    NOWORD    ((char *)NULL)
  1425. ***************
  1426. *** 40,45 ****
  1427. --- 40,46 ----
  1428.   #define    TFUNCT    17        /* function name { command; } */
  1429.   #define    TTIME    18        /* time pipeline */
  1430.   #define    TEXEC    19        /* fork/exec eval'd TCOM */
  1431. + #define TSELECT    20        /* select */
  1432.   
  1433.   /*
  1434.    * prefix codes for words in command tree
  1435. ***************
  1436. *** 86,91 ****
  1437. --- 87,93 ----
  1438.   #define    XPIPEO    BIT(3)        /* output is pipe */
  1439.   #define    XPIPE    (XPIPEI|XPIPEO)    /* member of pipe */
  1440.   #define    XXCOM    BIT(4)        /* dup2 xcomfd to 1 */
  1441. + #define XXWHL    BIT(6)        /* don't flush stdin before fork */
  1442.   
  1443.   /*
  1444.    * flags to control expansion of words
  1445. *** sh/tty.h.old    Tue May 12 13:42:00 1992
  1446. --- sh/tty.h    Mon Aug 10 22:03:23 1992
  1447. ***************
  1448. *** 28,34 ****
  1449.   #include <sys/ioctl.h>
  1450.   #endif
  1451.   #else
  1452. ! #ifdef    mips
  1453.   #include <termios.h>
  1454.   #else
  1455.   #include <termio.h>
  1456. --- 28,34 ----
  1457.   #include <sys/ioctl.h>
  1458.   #endif
  1459.   #else
  1460. ! #ifdef    _POSIX_TERM
  1461.   #include <termios.h>
  1462.   #else
  1463.   #include <termio.h>
  1464. *** sh/do_ulimit.c.old    Tue May 12 13:42:00 1992
  1465. --- sh/do_ulimit.c    Mon Aug 10 22:02:23 1992
  1466. ***************
  1467. *** 13,19 ****
  1468.   */
  1469.   
  1470.   #ifndef lint
  1471. ! static char *RCSid = "$Id: do_ulimit.c,v 1.2 1992/04/25 08:33:28 sjg Exp $";
  1472.   #endif
  1473.   
  1474.   #include "stdh.h"
  1475. --- 13,23 ----
  1476.   */
  1477.   
  1478.   #ifndef lint
  1479. ! static char *RCSid = "$Id: do_ulimit.c,v 1.3 1992/08/10 12:02:23 sjg Exp $";
  1480. ! #endif
  1481. ! 
  1482. ! #ifdef _BSDI
  1483. ! #define _BSD    1
  1484.   #endif
  1485.   
  1486.   #include "stdh.h"
  1487. *** sh/var.c.old    Tue May 12 13:42:00 1992
  1488. --- sh/var.c    Mon Aug 10 22:03:25 1992
  1489. ***************
  1490. *** 1,5 ****
  1491.   #ifndef lint
  1492. ! static char *RCSid = "$Id: var.c,v 1.2 1992/04/25 08:33:28 sjg Exp $";
  1493.   #endif
  1494.   
  1495.   #include "stdh.h"
  1496. --- 1,5 ----
  1497.   #ifndef lint
  1498. ! static char *RCSid = "$Id: var.c,v 1.3 1992/08/10 12:03:25 sjg Exp $";
  1499.   #endif
  1500.   
  1501.   #include "stdh.h"
  1502. ***************
  1503. *** 491,515 ****
  1504.   /*
  1505.    * handle special variables with side effects - PATH, SECONDS.
  1506.    */
  1507. ! 
  1508.   static int
  1509.   special(name)
  1510.       register char * name;
  1511.   {
  1512. !     if (strcmp("PATH", name) == 0)
  1513.           return V_PATH;
  1514. !     if (strcmp("IFS", name) == 0)
  1515.           return V_IFS;
  1516. !     if (strcmp("SECONDS", name) == 0)
  1517.           return V_SECONDS;
  1518. !     if (strcmp("OPTIND", name) == 0)
  1519.           return V_OPTIND;
  1520. !     if (strcmp("MAIL", name) == 0)
  1521.           return V_MAIL;
  1522. !     if (strcmp("MAILPATH", name) == 0)
  1523.           return V_MAILPATH;
  1524. !     if (strcmp("RANDOM", name) == 0)
  1525.           return V_RANDOM;
  1526.       return V_NONE;
  1527.   }
  1528.   
  1529. --- 491,525 ----
  1530.   /*
  1531.    * handle special variables with side effects - PATH, SECONDS.
  1532.    */
  1533. ! #define STREQ(a, b) ((*a) == (*b) && strcmp((a), (b)) == 0)
  1534.   static int
  1535.   special(name)
  1536.       register char * name;
  1537.   {
  1538. !     if (STREQ("PATH", name))
  1539.           return V_PATH;
  1540. !     if (STREQ("IFS", name))
  1541.           return V_IFS;
  1542. !     if (STREQ("SECONDS", name))
  1543.           return V_SECONDS;
  1544. !     if (STREQ("OPTIND", name))
  1545.           return V_OPTIND;
  1546. !     if (STREQ("MAIL", name))
  1547.           return V_MAIL;
  1548. !     if (STREQ("MAILPATH", name))
  1549.           return V_MAILPATH;
  1550. !     if (STREQ("RANDOM", name))
  1551.           return V_RANDOM;
  1552. + #ifndef EASY_HISTORY
  1553. +     if (STREQ("HISTSIZE", name))
  1554. +         return V_HISTSIZE;
  1555. +     if (STREQ("HISTFILE", name))
  1556. +         return V_HISTFILE;
  1557. + #endif
  1558. +     if (STREQ("FCEDIT", name))
  1559. +         return V_FCEDIT;
  1560. +     if (STREQ("COLUMNS", name))
  1561. +         return V_COLUMNS;
  1562.       return V_NONE;
  1563.   }
  1564.   
  1565. ***************
  1566. *** 535,540 ****
  1567. --- 545,557 ----
  1568.           setint(vp, (rand() & 0x7fff));
  1569.           vp->flag |= SPECIAL;
  1570.           break;
  1571. + #ifndef EASY_HISTORY
  1572. +     case V_HISTSIZE:
  1573. +         vp->flag &= ~ SPECIAL;
  1574. +         setint(vp, histsize);
  1575. +         vp->flag |= SPECIAL;
  1576. +         break;
  1577. + #endif
  1578.       }
  1579.   }
  1580.   
  1581. ***************
  1582. *** 569,574 ****
  1583. --- 586,608 ----
  1584.           vp->flag &= ~ SPECIAL;
  1585.           srand((unsigned int)intval(vp));
  1586.           vp->flag |= SPECIAL;
  1587. +         break;
  1588. + #ifndef EASY_HISTORY
  1589. +       case V_HISTSIZE:
  1590. +         vp->flag &= ~ SPECIAL;
  1591. +         sethistsize(intval(vp));
  1592. +         vp->flag |= SPECIAL;
  1593. +         break;
  1594. +       case V_HISTFILE:
  1595. +         sethistfile(strval(vp));
  1596. +         break;
  1597. + #endif
  1598. +       case V_FCEDIT:
  1599. +         set_editmode(strval(vp));
  1600. +         break;
  1601. +       case V_COLUMNS:
  1602. +         if ((x_cols = intval(vp)) <= 0)
  1603. +           x_cols=80;
  1604.           break;
  1605.       }
  1606.   }
  1607. *** sh/version.c.old    Tue May 12 13:42:00 1992
  1608. --- sh/version.c    Mon Aug 10 22:03:29 1992
  1609. ***************
  1610. *** 3,9 ****
  1611.    */
  1612.   
  1613.   #ifndef lint
  1614. ! static char *RCSid = "$Id: version.c,v 1.4 1992/05/12 09:30:37 sjg Exp $";
  1615.   #endif
  1616.   
  1617.   #include "stdh.h"
  1618. --- 3,9 ----
  1619.    */
  1620.   
  1621.   #ifndef lint
  1622. ! static char *RCSid = "$Id: version.c,v 1.5 1992/08/10 12:03:29 sjg Exp $";
  1623.   #endif
  1624.   
  1625.   #include "stdh.h"
  1626. ***************
  1627. *** 12,21 ****
  1628.   #include "patchlevel.h"
  1629.   
  1630.   char ksh_version [] =
  1631. !     "KSH_VERSION=@(#)PD KSH v4.5 92/05/12";
  1632.   
  1633.   /***
  1634.   $Log: version.c,v $
  1635.    * Revision 1.4  1992/05/12  09:30:37  sjg
  1636.    * see ChangeLog
  1637.    *
  1638. --- 12,25 ----
  1639.   #include "patchlevel.h"
  1640.   
  1641.   char ksh_version [] =
  1642. !     "KSH_VERSION=@(#)PD KSH v4.6 92/08/10";
  1643.   
  1644.   /***
  1645.   $Log: version.c,v $
  1646. +  * Revision 1.5  1992/08/10  12:03:29  sjg
  1647. +  * Update for patch06.
  1648. +  * Contributions from Peter Collinson, Neil Smithline and sjg
  1649. +  *
  1650.    * Revision 1.4  1992/05/12  09:30:37  sjg
  1651.    * see ChangeLog
  1652.    *
  1653. *** sh/vi.c.old    Tue May 12 13:42:00 1992
  1654. --- sh/vi.c    Mon Aug 10 22:03:31 1992
  1655. ***************
  1656. *** 9,15 ****
  1657.   #ifdef VI
  1658.   
  1659.   #ifndef lint
  1660. ! static char *RCSid = "$Id: vi.c,v 1.2 1992/04/25 08:33:28 sjg Exp $";
  1661.   #endif
  1662.   
  1663.   #include "stdh.h"
  1664. --- 9,15 ----
  1665.   #ifdef VI
  1666.   
  1667.   #ifndef lint
  1668. ! static char *RCSid = "$Id: vi.c,v 1.3 1992/08/10 12:03:31 sjg Exp $";
  1669.   #endif
  1670.   
  1671.   #include "stdh.h"
  1672. ***************
  1673. *** 25,31 ****
  1674.   
  1675.   #define CMDLEN        256
  1676.   #define Ctrl(c)        (c&0x1f)
  1677. - #define    bcopy(src, dst, len)    memmove(dst, src, len)
  1678.   extern    int    histN();
  1679.   
  1680.   static int      nextstate   ARGS((int ch));
  1681. --- 25,30 ----
  1682. ***************
  1683. *** 90,96 ****
  1684.   #endif
  1685.       0,    0,    C_,    C_,    M_,    C_,    0,    C_|S_,
  1686.       M_,    0,    0,    0,    0,    0,    0,    0,
  1687. !     0,    0,    0,    M_,    0,    0,    0,    C_|S_,
  1688.       0,    C_,    M_,    C_,    C_,    M_,    M_|X_,    C_,
  1689.       0,    C_,    0,    0,    0,    0,    C_,    0,
  1690.       C_,    0,    C_,    C_,    M_|X_,    0,    0,    M_,
  1691. --- 89,95 ----
  1692.   #endif
  1693.       0,    0,    C_,    C_,    M_,    C_,    0,    C_|S_,
  1694.       M_,    0,    0,    0,    0,    0,    0,    0,
  1695. !     0,    0,    0,    M_,    0,    C_,    0,    C_|S_,
  1696.       0,    C_,    M_,    C_,    C_,    M_,    M_|X_,    C_,
  1697.       0,    C_,    0,    0,    0,    0,    C_,    0,
  1698.       C_,    0,    C_,    C_,    M_|X_,    0,    0,    M_,
  1699. ***************
  1700. *** 478,485 ****
  1701.                   inslen--;
  1702.               es->cursor--;
  1703.               if (insert != REPLACE) {
  1704. !                 bcopy(&es->cbuf[es->cursor+1],
  1705. !                         &es->cbuf[es->cursor],
  1706.                           es->linelen - es->cursor);
  1707.                   es->linelen--;
  1708.               }
  1709. --- 477,484 ----
  1710.                   inslen--;
  1711.               es->cursor--;
  1712.               if (insert != REPLACE) {
  1713. !                 memmove(&es->cbuf[es->cursor],
  1714. !                         &es->cbuf[es->cursor+1],
  1715.                           es->linelen - es->cursor);
  1716.                   es->linelen--;
  1717.               }
  1718. ***************
  1719. *** 489,495 ****
  1720.       case Ctrl('U'):
  1721.           if (es->cursor != 0) {
  1722.               inslen = 0;
  1723. !             bcopy(&es->cbuf[es->cursor], es->cbuf,
  1724.                           es->linelen - es->cursor);
  1725.               es->linelen -= es->cursor;
  1726.               es->cursor = 0;
  1727. --- 488,494 ----
  1728.       case Ctrl('U'):
  1729.           if (es->cursor != 0) {
  1730.               inslen = 0;
  1731. !             memmove(es->cbuf, &es->cbuf[es->cursor],
  1732.                           es->linelen - es->cursor);
  1733.               es->linelen -= es->cursor;
  1734.               es->cursor = 0;
  1735. ***************
  1736. *** 499,505 ****
  1737.       case Ctrl('W'):
  1738.           if (es->cursor != 0) {
  1739.               tcursor = backword(1);
  1740. !             bcopy(&es->cbuf[es->cursor], &es->cbuf[tcursor],
  1741.                           es->linelen - es->cursor);
  1742.               es->linelen -= es->cursor - tcursor;
  1743.               if (inslen < es->cursor - tcursor)
  1744. --- 498,504 ----
  1745.       case Ctrl('W'):
  1746.           if (es->cursor != 0) {
  1747.               tcursor = backword(1);
  1748. !             memmove(&es->cbuf[tcursor], &es->cbuf[es->cursor],
  1749.                           es->linelen - es->cursor);
  1750.               es->linelen -= es->cursor - tcursor;
  1751.               if (inslen < es->cursor - tcursor)
  1752. ***************
  1753. *** 515,521 ****
  1754.               return -1;
  1755.           ibuf[inslen++] = ch;
  1756.           if (insert == INSERT) {
  1757. !             bcopy(&es->cbuf[es->cursor], &es->cbuf[es->cursor+1],
  1758.                       es->linelen - es->cursor);
  1759.               es->linelen++;
  1760.           }
  1761. --- 514,520 ----
  1762.               return -1;
  1763.           ibuf[inslen++] = ch;
  1764.           if (insert == INSERT) {
  1765. !             memmove(&es->cbuf[es->cursor+1], &es->cbuf[es->cursor],
  1766.                       es->linelen - es->cursor);
  1767.               es->linelen++;
  1768.           }
  1769. ***************
  1770. *** 553,563 ****
  1771.       } else {
  1772.           if (isundoable(*cmd)) {
  1773.               undo->winleft = es->winleft;
  1774. !             bcopy(es->cbuf, undo->cbuf, es->linelen);
  1775.               undo->linelen = es->linelen;
  1776.               undo->cursor = es->cursor;
  1777.               lastac = argcnt;
  1778. !             bcopy(cmd, lastcmd, MAXVICMD);
  1779.           }
  1780.           switch (*cmd) {
  1781.   
  1782. --- 552,562 ----
  1783.       } else {
  1784.           if (isundoable(*cmd)) {
  1785.               undo->winleft = es->winleft;
  1786. !             memmove(undo->cbuf, es->cbuf, es->linelen);
  1787.               undo->linelen = es->linelen;
  1788.               undo->cursor = es->cursor;
  1789.               lastac = argcnt;
  1790. !             memmove(lastcmd, cmd, MAXVICMD);
  1791.           }
  1792.           switch (*cmd) {
  1793.   
  1794. ***************
  1795. *** 849,855 ****
  1796.                   return -1;
  1797.               return 1;
  1798.   
  1799. !         case '*': {
  1800.               int    rval = 0;
  1801.               int    start, end;
  1802.               char    *toglob = undo->cbuf;
  1803. --- 848,855 ----
  1804.                   return -1;
  1805.               return 1;
  1806.   
  1807. !         case '*':
  1808. !         case '=': {
  1809.               int    rval = 0;
  1810.               int    start, end;
  1811.               char    *toglob = undo->cbuf;
  1812. ***************
  1813. *** 867,874 ****
  1814.               while (end < es->linelen && !isspace(es->cbuf[end]))
  1815.                   end++;
  1816.               /* use undo buffer to build word up in */
  1817. !             bcopy(&es->cbuf[start], toglob, end-start);
  1818. !             if (*toglob != '~' && toglob[end-start-1] != '*') {
  1819.                   toglob[end-start] = '*';
  1820.                   toglob[end-start+1] = '\0';
  1821.               } else
  1822. --- 867,874 ----
  1823.               while (end < es->linelen && !isspace(es->cbuf[end]))
  1824.                   end++;
  1825.               /* use undo buffer to build word up in */
  1826. !             memmove(toglob, &es->cbuf[start], end-start);
  1827. !             if (toglob[end-start-1] != '*') {
  1828.                   toglob[end-start] = '*';
  1829.                   toglob[end-start+1] = '\0';
  1830.               } else
  1831. ***************
  1832. *** 878,913 ****
  1833.               if (strcmp(ap[0], toglob) == 0 && ap[1] == (char *) 0)
  1834.                   rval = -1;
  1835.               /* restore undo buffer that we used temporarily */
  1836. !             bcopy(es->cbuf, toglob, es->linelen);
  1837.               if (rval < 0)
  1838.                   return rval;
  1839. !             del_range(start, end);
  1840. !             es->cursor = start;
  1841. !             while (1) {
  1842. !                 if (putbuf(*ap, strlen(*ap), 0) != 0) {
  1843. !                     rval = -1;
  1844. !                     break;
  1845.                   }
  1846. -                 if (*++ap == (char *) 0)
  1847. -                     break;
  1848. -                 if (putbuf(" ", 1, 0) != 0) {
  1849. -                     rval = -1;
  1850. -                     break;
  1851. -                 }
  1852. -             }
  1853.   #if 0
  1854. !             /*
  1855. !              * this is definitely wrong
  1856. !              */
  1857. !             for (ap = ap2; *ap; ap++)
  1858. !                 free(*ap);
  1859.   
  1860. !             free(ap2);
  1861.   #endif
  1862.   
  1863. !             modified = 1;
  1864. !             insert = INSERT;
  1865. !             refresh(0);
  1866.               if (rval != 0)
  1867.                   return rval;
  1868.               }
  1869. --- 878,926 ----
  1870.               if (strcmp(ap[0], toglob) == 0 && ap[1] == (char *) 0)
  1871.                   rval = -1;
  1872.               /* restore undo buffer that we used temporarily */
  1873. !             memmove(toglob, es->cbuf, es->linelen);
  1874.               if (rval < 0)
  1875.                   return rval;
  1876. !             if (*cmd == '=') {
  1877. !                 fputc('\n', shlout);
  1878. !                 pr_menu(ap2, 0);
  1879. !                 fflush(shlout);
  1880. !                 if (es->linelen != 0)
  1881. !                     es->cursor++;
  1882. !                 redraw_line();
  1883. !                 insert = INSERT;
  1884. !                 state = VNORMAL;
  1885. !                 return 0;
  1886. !             } else {
  1887. !                 del_range(start, end);
  1888. !                 es->cursor = start;
  1889. !                 while (1) {
  1890. !                     if (putbuf(*ap, strlen(*ap), 0) != 0) {
  1891. !                         rval = -1;
  1892. !                         break;
  1893. !                     }
  1894. !                     if (*++ap == (char *) 0)
  1895. !                         break;
  1896. !                     if (putbuf(" ", 1, 0) != 0) {
  1897. !                         rval = -1;
  1898. !                         break;
  1899. !                     }
  1900. ! 
  1901.                   }
  1902.   #if 0
  1903. !                 /*
  1904. !                  * this is definitely wrong
  1905. !                  */
  1906. !                 for (ap = ap2; *ap; ap++)
  1907. !                     free(*ap);
  1908.   
  1909. !                 free(ap2);
  1910.   #endif
  1911.   
  1912. !                 modified = 1;
  1913. !                 insert = INSERT;
  1914. !                 refresh(0);
  1915. !             }
  1916.               if (rval != 0)
  1917.                   return rval;
  1918.               }
  1919. ***************
  1920. *** 1081,1087 ****
  1921.   {
  1922.       yanklen = b - a;
  1923.       if (yanklen != 0)
  1924. !         bcopy(&es->cbuf[a], ybuf, yanklen);
  1925.   }
  1926.   
  1927.   static int
  1928. --- 1094,1100 ----
  1929.   {
  1930.       yanklen = b - a;
  1931.       if (yanklen != 0)
  1932. !         memmove(ybuf, &es->cbuf[a], yanklen);
  1933.   }
  1934.   
  1935.   static int
  1936. ***************
  1937. *** 1130,1136 ****
  1938.   
  1939.   save_cbuf()
  1940.   {
  1941. !     bcopy(es->cbuf, holdbuf, es->linelen);
  1942.       holdlen = es->linelen;
  1943.       holdbuf[holdlen] = '\0';
  1944.   }
  1945. --- 1143,1149 ----
  1946.   
  1947.   save_cbuf()
  1948.   {
  1949. !     memmove(holdbuf, es->cbuf, es->linelen);
  1950.       holdlen = es->linelen;
  1951.       holdbuf[holdlen] = '\0';
  1952.   }
  1953. ***************
  1954. *** 1139,1145 ****
  1955.   {
  1956.       es->cursor = 0;
  1957.       es->linelen = holdlen;
  1958. !     bcopy(holdbuf, es->cbuf, holdlen);
  1959.   }
  1960.   
  1961.   static
  1962. --- 1152,1158 ----
  1963.   {
  1964.       es->cursor = 0;
  1965.       es->linelen = holdlen;
  1966. !     memmove(es->cbuf, holdbuf, holdlen);
  1967.   }
  1968.   
  1969.   static
  1970. ***************
  1971. *** 1184,1194 ****
  1972.       } else {
  1973.           if (es->linelen + len >= es->cbufsize - 1)
  1974.               return -1;
  1975. !         bcopy(&es->cbuf[es->cursor], &es->cbuf[es->cursor + len],
  1976.               es->linelen - es->cursor);
  1977.           es->linelen += len;
  1978.       }
  1979. !     bcopy(buf, &es->cbuf[es->cursor], len);
  1980.       es->cursor += len;
  1981.       return 0;
  1982.   }
  1983. --- 1197,1207 ----
  1984.       } else {
  1985.           if (es->linelen + len >= es->cbufsize - 1)
  1986.               return -1;
  1987. !         memmove(&es->cbuf[es->cursor + len], &es->cbuf[es->cursor],
  1988.               es->linelen - es->cursor);
  1989.           es->linelen += len;
  1990.       }
  1991. !     memmove(&es->cbuf[es->cursor], buf, len);
  1992.       es->cursor += len;
  1993.       return 0;
  1994.   }
  1995. ***************
  1996. *** 1209,1215 ****
  1997.       int    a, b;
  1998.   {
  1999.       if (es->linelen != b)
  2000. !         bcopy(&es->cbuf[b], &es->cbuf[a], es->linelen - b);
  2001.       es->linelen -= b - a;
  2002.   }
  2003.   
  2004. --- 1222,1228 ----
  2005.       int    a, b;
  2006.   {
  2007.       if (es->linelen != b)
  2008. !         memmove(&es->cbuf[a], &es->cbuf[b], es->linelen - b);
  2009.       es->linelen -= b - a;
  2010.   }
  2011.   
  2012. ***************
  2013. *** 1396,1402 ****
  2014.       if (save)
  2015.           save_cbuf();
  2016.       es->linelen = strlen(hptr);
  2017. !     bcopy(hptr, es->cbuf, es->linelen);
  2018.       es->cursor = 0;
  2019.       return 0;
  2020.   }
  2021. --- 1409,1415 ----
  2022.       if (save)
  2023.           save_cbuf();
  2024.       es->linelen = strlen(hptr);
  2025. !     memmove(es->cbuf, hptr, es->linelen);
  2026.       es->cursor = 0;
  2027.       return 0;
  2028.   }
  2029. ***************
  2030. *** 1423,1429 ****
  2031.       if (save)
  2032.           save_cbuf();
  2033.       es->linelen = strlen(hptr);
  2034. !     bcopy(hptr, es->cbuf, es->linelen);
  2035.       es->cursor = 0;
  2036.       return histN();
  2037.   }
  2038. --- 1436,1442 ----
  2039.       if (save)
  2040.           save_cbuf();
  2041.       es->linelen = strlen(hptr);
  2042. !     memmove(es->cbuf, hptr, es->linelen);
  2043.       es->cursor = 0;
  2044.       return histN();
  2045.   }
  2046. ***************
  2047. *** 1435,1441 ****
  2048.       x_putc('\n');
  2049.       x_flush();
  2050.       pprompt(prompt);
  2051. !     cur_col = 2;
  2052.       morec = ' ';
  2053.   }
  2054.   
  2055. --- 1448,1454 ----
  2056.       x_putc('\n');
  2057.       x_flush();
  2058.       pprompt(prompt);
  2059. !     cur_col = pwidth;
  2060.       morec = ' ';
  2061.   }
  2062.   
  2063. ***************
  2064. *** 1640,1646 ****
  2065.           return -1;
  2066.   
  2067.       if (es->cbuf != buf) {
  2068. !         bcopy(es->cbuf, buf, es->linelen);
  2069.           buf[es->linelen] = '\n';
  2070.       } else
  2071.           es->cbuf[es->linelen] = '\n';
  2072. --- 1653,1659 ----
  2073.           return -1;
  2074.   
  2075.       if (es->cbuf != buf) {
  2076. !         memmove(buf, es->cbuf, es->linelen);
  2077.           buf[es->linelen] = '\n';
  2078.       } else
  2079.           es->cbuf[es->linelen] = '\n';
  2080. *** /tmp/pdksh/bug-report    Tue May 12 13:42:00 1992
  2081. --- bug-report    Mon Aug 10 22:59:11 1992
  2082. ***************
  2083. *** 2,8 ****
  2084.   Subject: [area]: [synopsis]   [replace with actual area and short description]
  2085.   
  2086.   VERSION:
  2087. !     PD KSH: 4.5 12-May-1992
  2088.       [Official patches will edit this line to indicate the patch level]
  2089.   
  2090.   MACHINE and OPERATING SYSTEM:
  2091. --- 2,8 ----
  2092.   Subject: [area]: [synopsis]   [replace with actual area and short description]
  2093.   
  2094.   VERSION:
  2095. !     PD KSH: 4.6 02-Aug-92
  2096.       [Official patches will edit this line to indicate the patch level]
  2097.   
  2098.   MACHINE and OPERATING SYSTEM:
  2099.  
  2100. exit 0 # Just in case...
  2101.