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