home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume25 / pdksh / part07 < prev    next >
Text File  |  1991-11-12  |  56KB  |  2,059 lines
  1. Newsgroups: comp.sources.misc
  2. From: sjg@zen.void.oz.au (Simon J. Gerraty)
  3. Subject:  v25i053:  pdksh - Public Domain Korn Shell, v4, Part07/09
  4. Message-ID: <1991Nov13.031220.16258@sparky.imd.sterling.com>
  5. X-Md4-Signature: 0422b4f08c0fd6aac06682fe010c3e5d
  6. Date: Wed, 13 Nov 1991 03:12:20 GMT
  7. Approved: kent@sparky.imd.sterling.com
  8.  
  9. Submitted-by: sjg@zen.void.oz.au (Simon J. Gerraty)
  10. Posting-number: Volume 25, Issue 53
  11. Archive-name: pdksh/part07
  12. Environment: UNIX
  13.  
  14. #! /bin/sh
  15. # into a shell via "sh file" or similar.  To overwrite existing files,
  16. # type "sh file -c".
  17. # The tool that generated this appeared in the comp.sources.unix newsgroup;
  18. # send mail to comp-sources-unix@uunet.uu.net if you want that tool.
  19. # Contents:  MANIFEST Changes.jrm ReadMe.sjg etc/ksh.kshrc
  20. #   etc/sys_config.sh sh/ReadMe sh/alloc.h sh/edit.h sh/expand.h
  21. #   sh/getopts.c sh/io.c sh/lex.h sh/table.h sh/trace.h sh/trap.c
  22. #   sh/tree.h std/posix/io.h std/stdc/stdio.h_std
  23. # Wrapped by kent@sparky on Tue Nov 12 20:44:34 1991
  24. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  25. echo If this archive is complete, you will see the following message:
  26. echo '          "shar: End of archive 7 (of 9)."'
  27. if test -f 'MANIFEST' -a "${1}" != "-c" ; then 
  28.   echo shar: Will not clobber existing file \"'MANIFEST'\"
  29. else
  30.   echo shar: Extracting \"'MANIFEST'\" \(3689 characters\)
  31.   sed "s/^X//" >'MANIFEST' <<'END_OF_FILE'
  32. X   File Name        Archive #    Description
  33. X-----------------------------------------------------------
  34. X README                    1    Please read
  35. X Changes.jrm               1    
  36. X Changes.mlj               1    
  37. X MANIFEST                  1    This shipping list
  38. X Makefile                  1    
  39. X PATCHDATES                1    C-News style patch tracking
  40. X ReadMe.jrm                1    General info and Install instructions
  41. X ReadMe.sjg                1    
  42. X ReadMe.vimode             1    
  43. X etc                       1    
  44. X etc/ksh.kshrc             1    global .kshrc, WARNING contains ESC chars
  45. X etc/profile               1    
  46. X etc/sys_config.sh         1    
  47. X ksh.1                     2    Manual page
  48. X sh                        1    ksh source
  49. X sh/ChangeLog              1    Current change list
  50. X sh/Changes                1    
  51. X sh/Makefile               1    
  52. X sh/ReadMe                 1    Original ReadMe (out of date)
  53. X sh/alloc.c                1    
  54. X sh/alloc.h                1    
  55. X sh/c_ksh.c                2    
  56. X sh/c_sh.c                 2    
  57. X sh/c_test.c               3    
  58. X sh/config.h               1    
  59. X sh/edit.c                 3    
  60. X sh/edit.h                 1    
  61. X sh/emacs.c                3    
  62. X sh/eval.c                 4    
  63. X sh/exec.c                 4    
  64. X sh/expand.h               1    
  65. X sh/expr.c                 3    
  66. X sh/getopts.c              4    
  67. X sh/history.c              4    
  68. X sh/io.c                   4    
  69. X sh/jobs.c                 5    
  70. X sh/lex.c                  5    
  71. X sh/lex.h                  4    
  72. X sh/mail.c                 4    
  73. X sh/main.c                 5    
  74. X sh/misc.c                 5    
  75. X sh/sh.h                   5    
  76. X sh/syn.c                  6    
  77. X sh/table.c                6    
  78. X sh/table.h                6    
  79. X sh/trace.c                6    Simple trace facilty
  80. X sh/trace.h                6    
  81. X sh/trap.c                 6    
  82. X sh/tree.c                 6    
  83. X sh/tree.h                 6    
  84. X sh/tty.h                  2    
  85. X sh/ulimit.c               6    
  86. X sh/var.c                  7    
  87. X sh/version.c              4    
  88. X sh/vi.c                   7    
  89. X std                       1    libraries
  90. X std/Makefile              5    
  91. X std/posix                 2    
  92. X std/posix                 2    posix lib source
  93. X std/posix/Makefile        6    
  94. X std/posix/dirent.C        6    
  95. X std/posix/dirent.H        6    
  96. X std/posix/dirent.h        2    
  97. X std/posix/dup2.c          4    
  98. X std/posix/fcntl.c         6    
  99. X std/posix/fcntl.h         6    
  100. X std/posix/fixincludes     6    
  101. X std/posix/io.h            6    
  102. X std/posix/time.h          6    
  103. X std/posix/times.c         6    
  104. X std/posix/times.h         6    
  105. X std/posix/unistd.c        6    
  106. X std/posix/unistd.h        7    
  107. X std/posix/wait.h          7    
  108. X std/stdc                  3    stdc lib source
  109. X std/stdc/Makefile         7    
  110. X std/stdc/clock.c          7    
  111. X std/stdc/fprintf.c        7    
  112. X std/stdc/limits.h         7    
  113. X std/stdc/memchr.c         6    
  114. X std/stdc/memcmp.c         7    
  115. X std/stdc/memcpy.c         7    
  116. X std/stdc/memmove.c        7    
  117. X std/stdc/memset.c         7    
  118. X std/stdc/setvbuf.c        7    
  119. X std/stdc/sprintf.c        7    
  120. X std/stdc/stdarg.h         8    
  121. X std/stdc/stddef.h         8    
  122. X std/stdc/stdio.c          8    
  123. X std/stdc/stdio.h_std      8    
  124. X std/stdc/stdio.sed        8    
  125. X std/stdc/stdlib.h         8    
  126. X std/stdc/strcat.c         8    
  127. X std/stdc/strchr.c         8    
  128. X std/stdc/strcmp.c         8    
  129. X std/stdc/strcpy.c         8    
  130. X std/stdc/strcspn.c        8    
  131. X std/stdc/strerror.c       8    
  132. X std/stdc/string.h         8    
  133. X std/stdc/strlen.c         8    
  134. X std/stdc/strncat.c        8    
  135. X std/stdc/strncmp.c        8    
  136. X std/stdc/strncpy.c        8    
  137. X std/stdc/strpbrk.c        8    
  138. X std/stdc/strrchr.c        8    
  139. X std/stdc/strspn.c         8    
  140. X std/stdc/strstr.c         8    
  141. X std/stdc/strtok.c         8    
  142. X std/stdc/time.h           8    
  143. X std/stdc/types.h          8    
  144. X std/stdc/vprintf.c        8    
  145. END_OF_FILE
  146.   if test 3689 -ne `wc -c <'MANIFEST'`; then
  147.     echo shar: \"'MANIFEST'\" unpacked with wrong size!
  148.   fi
  149.   # end of 'MANIFEST'
  150. fi
  151. if test -f 'Changes.jrm' -a "${1}" != "-c" ; then 
  152.   echo shar: Will not clobber existing file \"'Changes.jrm'\"
  153. else
  154.   echo shar: Extracting \"'Changes.jrm'\" \(2367 characters\)
  155.   sed "s/^X//" >'Changes.jrm' <<'END_OF_FILE'
  156. XChanges to the PD ksh since last time:
  157. X
  158. X- clean up the option configuration stuff.  Options in config.h should
  159. X  now just be #define'd or not, not #define'd to 1 if you want them
  160. X  and 0 if you don't
  161. X
  162. X- ksh now uses the shell specified by the variable EXECSHELL to run
  163. X  shell scripts.  If EXECSHELL is unset or null it defaults to
  164. X  /bin/sh.  It does a path lookup on the value, so if you set it to
  165. X  ``ksh'' the ksh will run all scripts that don't start with #!.  It
  166. X  seems to run most sh scripts fine (now).  I'd be very interested to
  167. X  hear your experiences if you try this out, as for my next trick I'd
  168. X  like to make ksh just fork itself to run scripts, which would speed
  169. X  things up, and allow exportable functions and aliases (like he real
  170. X  ksh).  Just to assure you that it can do some hairy sh scripts, both
  171. X  CC and coco work with ksh.
  172. X
  173. X  EXECSHELL won't work if the system's exec(2) call runs scripts...
  174. X
  175. X- the ``let'' builtin now evaluates null or unset vars to 0, as per
  176. X  The Book
  177. X
  178. X- Various memory allocation/use problems were cleaned up.  Hopefully
  179. X  you'll never see the ``freeing free object'' error again (if you've
  180. X  ever seen it).
  181. X
  182. X- the ``test'' builtin is now much more tolerant in parsing its
  183. X  arguments.  This was to make it like the /bin/sh test.
  184. X
  185. X- Temp files (for here documents or ``fc'') are now mode 0600
  186. X
  187. X- Some format strings in the tree printing routines got ``expanded''
  188. X  into SCCS keywords, so the results of``type <function>'' were
  189. X  gave you interesting things like the time I last checked in the
  190. X  file.  This has been fixed.
  191. X
  192. X- ``unset -f'' now really does unset functions.
  193. X
  194. X- the ``trailing blank or tab in alias definition'' feature now works.
  195. X
  196. X- A bug in command completion was fixed.  Note command completion only
  197. X  works on commands that have been hashed, so you want to ``set -h''
  198. X  in your .kshrc, and you may wish to force hashing of some common
  199. X  commands with the ``hash'' builtin.
  200. X
  201. X- ``echo $$ | cat'' now works as in /bin/sh
  202. X
  203. XNot new features, but newly discovered bugs:
  204. X
  205. X- Local functions don't work correctly.  This shouldn't be much
  206. X  problem, since sh doesn't have them.
  207. X
  208. X- Here documents in functions don't work.  This is a problem with the
  209. X  temp file allocation that requires more work to fix than I've gotten
  210. X  around to doing.  So avoid things like:
  211. X
  212. Xfoo() {
  213. X    cat <<- HereDoc
  214. XThis is a test
  215. XHereDoc
  216. X}
  217. END_OF_FILE
  218.   if test 2367 -ne `wc -c <'Changes.jrm'`; then
  219.     echo shar: \"'Changes.jrm'\" unpacked with wrong size!
  220.   fi
  221.   # end of 'Changes.jrm'
  222. fi
  223. if test -f 'ReadMe.sjg' -a "${1}" != "-c" ; then 
  224.   echo shar: Will not clobber existing file \"'ReadMe.sjg'\"
  225. else
  226.   echo shar: Extracting \"'ReadMe.sjg'\" \(2747 characters\)
  227.   sed "s/^X//" >'ReadMe.sjg' <<'END_OF_FILE'
  228. XHORIZONTAL SCROLLING
  229. X====================
  230. X
  231. XI have migrated my 3.2 ksh edit.c mods into the 3.3 ksh
  232. XThis file describes the mods in general and really only applies
  233. X(at this stage) to emacs-mode.  I have not touched vi-mode apart
  234. Xfrom making it use pprompt() so that '!' is correctly expanded
  235. Xas in emacs-mode.
  236. X
  237. XI would prefer to see both vi.c and emacs.c use a common set of
  238. Xprimatives in edit.c - but that looks like a lot of work.
  239. X
  240. XBasically my mods affect the functions that move the cursor
  241. Xabout and redraw the edit line.  
  242. X
  243. XThe input buffer "buf" is pointed to by "xbuf" and its end is
  244. Xpointed to by "xend".  The current position in "xbuf" and end of
  245. Xthe edit line are pointed to by "xcp" and "xep" respectively.
  246. XI have added "xbp" which points to the start of a display window
  247. Xwithin "xbuf".
  248. X
  249. X[A] starting position
  250. X
  251. Xbuf
  252. X|<-------- $COLUMNS --------->|
  253. X|    |<---- x_displen ------->|
  254. X| PS1|
  255. X     +==========+==============--------+.......+
  256. X     |\          \                      \       \
  257. X  xbuf xbp        xcp                    xep     xend
  258. X
  259. X[B] scrolled
  260. X
  261. Xbuf
  262. X|           |<----- COLUMNS -------->|
  263. X|           |<----- x_displen ------>|
  264. X|      
  265. X+-----------+==========+==============--------+.......+
  266. X \           \          \                      \       \
  267. X  xbuf        xbp        xcp                    xep     xend
  268. X
  269. XIn the above -------- represents the current edit line while
  270. X===== represents that portion which is visible on the screen.
  271. XNote that initially xbp == xbuf and PS1 is displayed.
  272. XPS1 uses some of the screen width and thus "x_displen" is less
  273. Xthan $COLUMNS.
  274. X
  275. XAny time that "xcp" moves outside the region bounded by "xbp"
  276. Xand "xbp" + "x_displen", the function x_adjust() is called to
  277. Xrelocate "xbp" appropriately and redraw the line.
  278. X
  279. XExcessive I/O is avoided where possible.  x_goto() for instance
  280. Xcalculates whether the destination is outside the visible
  281. Xregion, and if so simply adjusts "xcp" and calls x_adjust()
  282. Xdirectly.  Normally though x_adjust() is called from x_putc().
  283. X
  284. XThe above mechanism has be updated to use a function x_lastcp()
  285. Xthat returns a pointer that accurately  reflects the last
  286. Xvisible char in the edit buffer.  That is a more accurate
  287. Xversion of xbp + x_displen which does not account for TABS.
  288. X
  289. XOther changes
  290. X=============
  291. X
  292. XI have also added some emacs mode functions.
  293. XM-[0-9]
  294. X    Set a numeric arg (positive only).
  295. X    Used by all word related commands.
  296. XM-_
  297. XM-.
  298. X    Retrieve word from previous command (default is last
  299. X    word).  Use M-[1-9] to select word.
  300. XM-u
  301. XM-l
  302. XM-c
  303. X    UPPER,lower,Capitalize word.
  304. X
  305. X
  306. XCommands like delete-word now push the deleted text so that it
  307. Xmay be yanked back into place.
  308. X
  309. XBUGS?
  310. X=====
  311. X
  312. XThere are bound to be some.  Please report same to me:
  313. X
  314. XSimon J. Gerraty    <sjg@zen.void.oz.au>
  315. X
  316. END_OF_FILE
  317.   if test 2747 -ne `wc -c <'ReadMe.sjg'`; then
  318.     echo shar: \"'ReadMe.sjg'\" unpacked with wrong size!
  319.   fi
  320.   # end of 'ReadMe.sjg'
  321. fi
  322. if test -f 'etc/ksh.kshrc' -a "${1}" != "-c" ; then 
  323.   echo shar: Will not clobber existing file \"'etc/ksh.kshrc'\"
  324. else
  325.   echo shar: Extracting \"'etc/ksh.kshrc'\" \(2425 characters\)
  326.   sed "s/^X//" >'etc/ksh.kshrc' <<'END_OF_FILE'
  327. X:
  328. X# NAME:
  329. X#    ksh.kshrc - global initialization for ksh 
  330. X#
  331. X# DESCRIPTION:
  332. X#    Each invocation of /bin/ksh processes the file pointed
  333. X#    to by $ENV (usually $HOME/.kshrc).
  334. X#    This file is intended as a global .kshrc file for the
  335. X#    Korn shell.  A user's $HOME/.kshrc file simply requires
  336. X#    the line:
  337. X#        . /etc/ksh.kshrc
  338. X#    at or near the start to pick up the defaults in this
  339. X#    file which can then be overridden as desired.
  340. X#
  341. X# SEE ALSO:
  342. X#    $HOME/.kshrc
  343. X#
  344. X# AMENDED:
  345. X#    91/11/12 19:39:44 (sjg)
  346. X#
  347. X# RELEASED:
  348. X#    91/11/12 19:39:46 v2.4
  349. X#
  350. X# SCCSID:
  351. X#    @(#)ksh.kshrc 2.4 91/11/12 19:39:44 (sjg)
  352. X#
  353. X#    @(#)Copyright (c) 1991 Simon J. Gerraty
  354. X#
  355. X#    This file is provided in the hope that it will
  356. X#    be of use.  There is absolutely NO WARRANTY.
  357. X#    Permission to copy, redistribute or otherwise
  358. X#    use this file is hereby granted provided that 
  359. X#    the above copyright notice and this notice are
  360. X#    left intact. 
  361. X
  362. Xcase "$-" in
  363. X*i*)    # we are interactive
  364. X    # we may have su'ed so reset these
  365. X    # NOTE: SCO-UNIX doesn't have whoami,
  366. X    #    install whoami.sh
  367. X    USER=`whoami`
  368. X    PROMPT="<$USER@$HOSTNAME:!>$ "
  369. X    PPROMPT='<$USER@$HOSTNAME:$PWD:!>$ '
  370. X    PS1=$PPROMPT
  371. X    # $TTY is the tty we logged in on,
  372. X    # $tty is that which we are in now (might by pty)
  373. X    tty=`tty`
  374. X    tty=`basename $tty`
  375. X
  376. X    set -o $EDITOR
  377. X
  378. X    alias ls='ls -CF'
  379. X    alias h='fc -l | more'
  380. X    # the PD ksh is not 100% compatible
  381. X    case "$KSH_VERSION" in
  382. X    *PD*)    # PD ksh
  383. X        builtin=builtin
  384. X            bind ^?=delete-char-backward
  385. X            bind ^[^?=delete-word-backward
  386. X        ;;
  387. X    *)    # real ksh ?
  388. X        builtin=""
  389. X        ;;
  390. X    esac
  391. X    case "$TERM" in
  392. X    sun*)
  393. X        # these are not as neat as their csh equivalents
  394. X        if [ "$tty" != console ]; then
  395. X            ilabel () { print -n "\033]L$*\033\\"; }
  396. X            label () { print -n "\033]l$*\033\\"; }
  397. X            alias stripe='label $USER @ $HOSTNAME \($tty\) - $PWD'
  398. X            cds () { "cd" $*; eval stripe; }
  399. X            alias cd=cds
  400. X            eval stripe
  401. X            eval ilabel "$USER@$HOSTNAME"
  402. X            PS1=$PROMPT
  403. X        fi
  404. X        ;;
  405. X    xterm*)
  406. X        # these are not as neat as their csh equivalents
  407. X        ilabel () { print -n "\033]1;$*\007"; }
  408. X        label () { print -n "\033]2;$*\007"; }
  409. X        alias stripe='label xterm: $USER @ $HOSTNAME \($tty\) - $PWD'
  410. X        cds () { "cd" $*; eval stripe; }
  411. X        alias cd=cds
  412. X        eval stripe
  413. X        eval ilabel "$USER@$HOSTNAME"
  414. X        PS1=$PROMPT
  415. X        ;;
  416. X    *)    ;;
  417. X    esac
  418. X    alias quit=exit
  419. X    alias cls=clear
  420. X    alias logout=exit
  421. X    alias bye=exit
  422. X
  423. X
  424. X# add your favourite aliases here
  425. X;;
  426. X*)    # non-interactive
  427. X;;
  428. Xesac
  429. X# commands for both interactive and non-interactive shells
  430. END_OF_FILE
  431.   if test 2425 -ne `wc -c <'etc/ksh.kshrc'`; then
  432.     echo shar: \"'etc/ksh.kshrc'\" unpacked with wrong size!
  433.   fi
  434.   # end of 'etc/ksh.kshrc'
  435. fi
  436. if test -f 'etc/sys_config.sh' -a "${1}" != "-c" ; then 
  437.   echo shar: Will not clobber existing file \"'etc/sys_config.sh'\"
  438. else
  439.   echo shar: Extracting \"'etc/sys_config.sh'\" \(1539 characters\)
  440.   sed "s/^X//" >'etc/sys_config.sh' <<'END_OF_FILE'
  441. X:
  442. X# NAME:
  443. X#    sys_config.sh - set system specific variables
  444. X#
  445. X# SYNOPSIS:
  446. X#    . /etc/sys_config.sh
  447. X#
  448. X# DESCRIPTION:
  449. X#    Source this script into shell scripts that want to handle
  450. X#    various system types.
  451. X#    You may well want to edit this on a particular system replacing 
  452. X#    `uname -s` etc with the result.  So that the facility will work 
  453. X#    even when in single user mode and uname et al are not available.
  454. X#
  455. X# SEE ALSO:
  456. X#    /etc/profile
  457. X#
  458. X# AMENDED:
  459. X#    91/11/05 22:09:08 (rook)
  460. X#
  461. X# RELEASED:
  462. X#    91/11/05 22:09:09 v1.3
  463. X#
  464. X# SCCSID:
  465. X#    @(#)sys_config.sh 1.3 91/11/05 22:09:08 (rook)
  466. X#
  467. X#    @(#)Copyright (c) 1991 Simon J. Gerraty
  468. X#
  469. X#    This file is provided in the hope that it will
  470. X#    be of use.  There is absolutely NO WARRANTY.
  471. X#    Permission to copy, redistribute or otherwise
  472. X#    use this file is hereby granted provided that 
  473. X#    the above copyright notice and this notice are
  474. X#    left intact. 
  475. X#
  476. X
  477. X# determin machine type
  478. Xif [ -f /usr/bin/arch ]; then
  479. X    ARCH=`arch`
  480. Xelif [ -f /usr/bin/uname -o -f /bin/uname ]; then
  481. X    ARCH=`uname -m`
  482. Xfi
  483. X#
  484. Xcase "$ARCH" in
  485. Xsun386)    uname=/usr/5bin/uname
  486. X    OS=SunOS
  487. X    ;;
  488. X*)    uname=uname;;
  489. Xesac
  490. X
  491. X# set the operating system type
  492. X# you can't use `uname -s` with SCO UNIX
  493. X# it returns the same string as `uname -n`
  494. X# so set it manually
  495. X# OS=SCO-UNIX
  496. X# The eval below is a workaround for a bug in the PD ksh.
  497. XOS=${OS:-`eval $uname -s`}
  498. XHOSTNAME=${HOSTNAME:-`eval $uname -n`}
  499. X
  500. X# set which ever is required to not produce a linefeed 
  501. X# in an echo(1)
  502. Xcase $OS in
  503. XSunOS)    C="\c"; N="";
  504. X    ;;
  505. X*)    C="\c"; N=""
  506. X    ;;
  507. Xesac
  508. Xexport OS ARCH HOSTNAME C N uname
  509. END_OF_FILE
  510.   if test 1539 -ne `wc -c <'etc/sys_config.sh'`; then
  511.     echo shar: \"'etc/sys_config.sh'\" unpacked with wrong size!
  512.   fi
  513.   # end of 'etc/sys_config.sh'
  514. fi
  515. if test -f 'sh/ReadMe' -a "${1}" != "-c" ; then 
  516.   echo shar: Will not clobber existing file \"'sh/ReadMe'\"
  517. else
  518.   echo shar: Extracting \"'sh/ReadMe'\" \(1604 characters\)
  519.   sed "s/^X//" >'sh/ReadMe' <<'END_OF_FILE'
  520. X        Public Domain KornShell
  521. X
  522. X    Quick installation notes for PD KornShell
  523. X
  524. XPD KornShell can be installed on 4.2+ BSD systems, System V, and
  525. XPOSIX-compatable systems.  The makefiles all define _BSD, change
  526. Xthis to _SYSV, or _POSIX.  The makefiles also contain CC=gcc,
  527. Xdelete this if you don't have GNU C.  The ksh makefile also
  528. Xcontains some options, including JOBS (BSD/POSIX job control)
  529. Xand EDIT (emacs command editing).
  530. X
  531. XPD KornShell assumes you have standard C (ANSI) and POSIX header
  532. Xfiles and functions. Since you probably don't, they are provided
  533. Xin the "std" directory.
  534. X
  535. XThe Alpha test version will probably come as two tar files.
  536. Xstd.tar contains standard C and POSIX emulation and must be
  537. Xextracted into a directory called std.  ksh.tar contains the ksh
  538. Xsource and should be extracted into a directory called src or
  539. Xksh.
  540. X
  541. XSee std/ReadMe and install it. Only then can you make ksh in the
  542. X"src" directory.
  543. X
  544. XTo clear up questions about the origin of this shell, this shell
  545. Xis NOT based on the "Minix shell".  It is based on Charles
  546. XForsyth's public domain V7 shell, which he later contributed to
  547. XMinix.
  548. X
  549. XI have permission directly from Charles Forsyth to use his shell.
  550. X
  551. X    Eric Gisin, egisin@math.UWaterloo.CA (or Waterloo.EDU)
  552. X
  553. X    Things to do
  554. X- add sxt-based job control (see Brown's contribution on the Usenix 87 tape).
  555. X- add arrays and variable attributes.
  556. X- add MAILPATH and CDPATH.
  557. X- add vi editing mode (apparently someone has a PD version).
  558. X- add new features described in Korn's book.
  559. X
  560. X    Machines ported to
  561. XVAX, 68000, 80386
  562. X
  563. X    OS's ported to
  564. XBSD 4.2, BSD 4.3 (with and without YP and NFS
  565. XSys V.3
  566. END_OF_FILE
  567.   if test 1604 -ne `wc -c <'sh/ReadMe'`; then
  568.     echo shar: \"'sh/ReadMe'\" unpacked with wrong size!
  569.   fi
  570.   # end of 'sh/ReadMe'
  571. fi
  572. if test -f 'sh/alloc.h' -a "${1}" != "-c" ; then 
  573.   echo shar: Will not clobber existing file \"'sh/alloc.h'\"
  574. else
  575.   echo shar: Extracting \"'sh/alloc.h'\" \(455 characters\)
  576.   sed "s/^X//" >'sh/alloc.h' <<'END_OF_FILE'
  577. X/*
  578. X * area-based allocation built on malloc/free
  579. X */
  580. X
  581. Xtypedef struct Area {
  582. X    struct Block *free;    /* free list */
  583. X} Area;
  584. X
  585. XArea   *ainit ARGS((Area *ap));
  586. Xvoid    afreeall ARGS((Area *ap));
  587. Xvoid    ashrink ARGS((Area *ap));
  588. Xvoid    aerror ARGS((Area *ap, const char *msg));
  589. Xvoid    awarn ARGS((Area *ap, const char *msg));
  590. X
  591. XVoid   *alloc ARGS((size_t size, Area *ap));
  592. XVoid   *aresize ARGS((Void *ptr, size_t size, Area *ap));
  593. Xvoid    afree ARGS((Void *ptr, Area *ap));
  594. X
  595. END_OF_FILE
  596.   if test 455 -ne `wc -c <'sh/alloc.h'`; then
  597.     echo shar: \"'sh/alloc.h'\" unpacked with wrong size!
  598.   fi
  599.   # end of 'sh/alloc.h'
  600. fi
  601. if test -f 'sh/edit.h' -a "${1}" != "-c" ; then 
  602.   echo shar: Will not clobber existing file \"'sh/edit.h'\"
  603. else
  604.   echo shar: Extracting \"'sh/edit.h'\" \(2292 characters\)
  605.   sed "s/^X//" >'sh/edit.h' <<'END_OF_FILE'
  606. X/* NAME:
  607. X *      edit.h - globals for edit modes
  608. X *
  609. X * DESCRIPTION:
  610. X *      This header defines various global edit objects.
  611. X *
  612. X * SEE ALSO:
  613. X *      
  614. X *
  615. X * AMENDED:
  616. X *      91/09/17  23:28:04  (sjg)
  617. X *
  618. X * RELEASED:
  619. X *      91/11/09  15:36:18  v1.3
  620. X *
  621. X * SCCSID:
  622. X *      @(#)edit.h  1.3  91/09/17  23:28:04  (sjg)
  623. X *
  624. X */
  625. X
  626. X/* some useful #defines */
  627. X#ifdef EXTERN
  628. X# define _I_(i) = i
  629. X#else
  630. X# define _I_(i)
  631. X# define EXTERN extern
  632. X# define EXTERN_DEFINED
  633. X#endif
  634. X
  635. X#define    BEL        0x07
  636. X
  637. X/*
  638. X * The following are used for my horizontal scrolling stuff
  639. X */
  640. XEXTERN    char   *xbuf;        /* beg input buffer */
  641. XEXTERN    char   *xend;        /* end input buffer */
  642. XEXTERN char    *xcp;        /* current position */
  643. XEXTERN char    *xep;        /* current end */
  644. XEXTERN char    *xbp;        /* start of visible portion of input buffer */
  645. XEXTERN char    *xlp;        /* last char visible on screen */
  646. XEXTERN int    x_adj_ok;
  647. X/*
  648. X * we use x_adj_done so that functions can tell 
  649. X * whether x_adjust() has been called while they are active.
  650. X */
  651. XEXTERN int    x_adj_done;
  652. X
  653. XEXTERN int    x_cols;
  654. XEXTERN int    x_col;
  655. XEXTERN int    x_displen;
  656. XEXTERN int    x_arg;        /* general purpose arg */
  657. X
  658. XEXTERN int    x_do_init;        /* set up tty modes */
  659. XEXTERN int    ed_erase, ed_kill, ed_werase, ed_intr, ed_quit;
  660. X
  661. X#if defined(__STDC__) || defined(PROTO)
  662. X# define _P_(p) p
  663. X#else
  664. X# define _P_(p) ()
  665. X#endif        /* __STDC__ || PROTO */
  666. X#ifdef DEBUG
  667. X# define _D_(x) x
  668. X#else
  669. X# define _D_(x)
  670. X#endif
  671. X
  672. X/****  edit.c  ****/
  673. Xint             x_read      _P_((int fd, char *buf, size_t len));
  674. Xint             x_getc      _P_((void));
  675. Xvoid            x_flush     _P_((void));
  676. Xvoid            x_adjust    _P_((void));
  677. Xvoid            x_putc      _P_((int c));
  678. Xint             x_debug_info _P_((void));
  679. Xvoid            x_puts      _P_((char *s));
  680. Xvoid            x_init      _P_((void));
  681. Xbool_t          x_mode      _P_((bool_t onoff));
  682. Xbool_t          x_mode      _P_((bool_t onoff));
  683. Xint             promptlen   _P_((char *cp));
  684. X
  685. X/****  emacs.c  ****/
  686. Xvoid            x_redraw    _P_((int limit));
  687. Xchar*        x_lastcp    _P_((void));
  688. XEXTERN int xlp_valid _I_(0);
  689. X  
  690. X/* This lot goes at the END */
  691. X/* be sure not to interfere with anyone else's idea about EXTERN */
  692. X#ifdef EXTERN_DEFINED
  693. X# undef EXTERN_DEFINED
  694. X# undef EXTERN
  695. X#endif
  696. X/*
  697. X * Local Variables:
  698. X * version-control:t
  699. X * comment-column:40
  700. X * End:
  701. X */
  702. END_OF_FILE
  703.   if test 2292 -ne `wc -c <'sh/edit.h'`; then
  704.     echo shar: \"'sh/edit.h'\" unpacked with wrong size!
  705.   fi
  706.   # end of 'sh/edit.h'
  707. fi
  708. if test -f 'sh/expand.h' -a "${1}" != "-c" ; then 
  709.   echo shar: Will not clobber existing file \"'sh/expand.h'\"
  710. else
  711.   echo shar: Extracting \"'sh/expand.h'\" \(2216 characters\)
  712.   sed "s/^X//" >'sh/expand.h' <<'END_OF_FILE'
  713. X/*
  714. X * Expanding strings
  715. X */
  716. X
  717. X#if 0                /* Usage */
  718. X    XString xs;
  719. X    char *xp;
  720. X
  721. X    Xinit(xs, xp, 128);    /* allocate initial string */
  722. X    while ((c = generate()) {
  723. X        Xcheck(xs, xp);    /* expand string if neccessary */
  724. X        Xput(xs, xp, c); /* add character */
  725. X    }
  726. X    return Xclose(xs, xp);    /* resize string */
  727. X#endif
  728. X
  729. Xtypedef struct XString {
  730. X    char   *end, *beg;    /* end, begin of string */
  731. X#if 1
  732. X    char   *oth, *old;    /* togo, adjust */
  733. X#endif
  734. X    size_t    len;        /* length */
  735. X} XString;
  736. X
  737. Xtypedef char * XStringP;
  738. X
  739. X/* initialize expandable string */
  740. X#define    Xinit(xs, xp, length) { \
  741. X            (xs).len = length; \
  742. X            (xs).beg = alloc((xs).len + 8, ATEMP); \
  743. X            (xs).end = (xs).beg + (xs).len; \
  744. X            xp = (xs).beg; \
  745. X        }
  746. X
  747. X/* stuff char into string */
  748. X#define    Xput(xs, xp, c)    *xp++ = (c)
  749. X
  750. X/* check for overflow, expand string */
  751. X#define    Xcheck(xs, xp) if (xp >= (xs).end) { \
  752. X            char *old_beg = (xs).beg; \
  753. X            (xs).len += (xs).len; /* double size */ \
  754. X            (xs).beg = aresize((xs).beg, (xs).len + 8, ATEMP); \
  755. X            (xs).end = (xs).beg + (xs).len; \
  756. X            xp = (xs).beg + (xp - old_beg); /* adjust pointer */ \
  757. X        }
  758. X
  759. X/* free string */
  760. X#define    Xfree(xs, xp)    afree((Void*) (xs).beg, ATEMP)
  761. X
  762. X/* close, return string */
  763. X#define    Xclose(xs, xp)    (char*) aresize((Void*)(xs).beg, \
  764. X                    (size_t)(xp - (xs).beg), ATEMP)
  765. X/* begin of string */
  766. X#define    Xstring(xs, xp)    ((xs).beg)
  767. X
  768. X#define    Xsavepos(xs, xp) (xp - (xs).beg)
  769. X#define    Xrestpos(xs, xp, n) ((xs).beg + (n))
  770. X
  771. X/*
  772. X * expandable vector of generic pointers
  773. X */
  774. X
  775. Xtypedef struct XPtrV {
  776. X    Void  **cur;        /* next avail pointer */
  777. X    Void  **beg, **end;    /* begin, end of vector */
  778. X} XPtrV;
  779. X
  780. X#define    XPinit(x, n) { \
  781. X            register Void **vp; \
  782. X            vp = (Void**) alloc(sizeofN(Void*, n), ATEMP); \
  783. X            (x).cur = (x).beg = vp; \
  784. X            (x).end = vp + n; \
  785. X            }
  786. X
  787. X#define    XPput(x, p) { \
  788. X            if ((x).cur >= (x).end) { \
  789. X                int n = XPsize(x); \
  790. X                (x).beg = (Void**) aresize((Void*) (x).beg, \
  791. X                           sizeofN(Void*, n*2), ATEMP); \
  792. X                (x).cur = (x).beg + n; \
  793. X                (x).end = (x).cur + n; \
  794. X            } \
  795. X            *(x).cur++ = (p); \
  796. X            }
  797. X
  798. X#define    XPptrv(x)    ((x).beg)
  799. X#define    XPsize(x)    ((x).cur - (x).beg)
  800. X
  801. X#define    XPclose(x)    (Void**) aresize((Void*)(x).beg, \
  802. X                     sizeofN(Void*, XPsize(x)), ATEMP)
  803. X
  804. X#define    XPfree(x)    afree((Void*) (x).beg, ATEMP)
  805. X
  806. END_OF_FILE
  807.   if test 2216 -ne `wc -c <'sh/expand.h'`; then
  808.     echo shar: \"'sh/expand.h'\" unpacked with wrong size!
  809.   fi
  810.   # end of 'sh/expand.h'
  811. fi
  812. if test -f 'sh/getopts.c' -a "${1}" != "-c" ; then 
  813.   echo shar: Will not clobber existing file \"'sh/getopts.c'\"
  814. else
  815.   echo shar: Extracting \"'sh/getopts.c'\" \(3479 characters\)
  816.   sed "s/^X//" >'sh/getopts.c' <<'END_OF_FILE'
  817. X/*
  818. X * Reimplementation of SysVr3 sh builtin command "getopts" for S5R2 shell.
  819. X *
  820. X * created by Arnold Robbins
  821. X * modified by Doug Gwyn
  822. X * modified for PD ksh by Eric Gisin
  823. X */
  824. X
  825. Xstatic char *RCSid = "$Id: getopts.c,v 3.3 89/03/27 15:50:27 egisin Exp $";
  826. X
  827. X#include <stddef.h>
  828. X#include <string.h>
  829. X#include <errno.h>
  830. X#include <setjmp.h>
  831. X#include "sh.h"
  832. X#include "table.h"
  833. X
  834. X/*
  835. X * The following is derived from getopt() source placed into the public
  836. X * domain by AT&T (the only time they're known to have done that).
  837. X *
  838. X * It has been modified somewhat to fit into the context of the shell.
  839. X *
  840. X * -D"FASCIST" if you really want to strictly enforce ALL the
  841. X * Command Syntax Standard rules (not recommended).
  842. X */
  843. X
  844. X#define GETOPTEOF    (-1)
  845. X#define ERR(S, C)    shellf("%s%c\n", (S), (C))
  846. X
  847. Xstatic    int    optind;
  848. Xstatic char    *optarg;
  849. Xstatic int    sp;
  850. X
  851. Xstatic int
  852. Xgetopt(argc, argv, opts)
  853. X    int argc;
  854. X    register char **argv, *opts;
  855. X{
  856. X    register int c;
  857. X    register char *cp;
  858. X
  859. X    if (sp == 1)
  860. X        if (optind >= argc ||
  861. X           argv[optind][0] != '-' || argv[optind][1] == '\0')
  862. X            return(GETOPTEOF);
  863. X        else if (strcmp(argv[optind], "--") == 0) {
  864. X            optind++;
  865. X            return(GETOPTEOF);
  866. X        }
  867. X    c = argv[optind][sp];
  868. X    if (c == ':' || (cp=strchr(opts, c)) == NULL) {
  869. X        ERR("illegal option -- ", c);
  870. X        if (argv[optind][++sp] == '\0') {
  871. X            optind++;
  872. X            sp = 1;
  873. X        }
  874. X        optarg = NULL;
  875. X        return('?');
  876. X    }
  877. X    if (*++cp == ':') {
  878. X#ifdef FASCIST
  879. X        if (sp != 1) {
  880. X            ERR("option must not be grouped -- ", c );
  881. X            optind++;
  882. X            sp = 1;
  883. X            optarg = NULL;
  884. X            return('?');
  885. X        } else
  886. X#endif
  887. X        if (argv[optind][sp+1] != '\0') {
  888. X#ifdef FASCIST
  889. X            ERR("option must be followed by whitespace -- ", c );
  890. X            optind++;
  891. X            sp = 1;
  892. X            optarg = NULL;
  893. X            return('?');
  894. X#else
  895. X            optarg = &argv[optind++][sp+1];
  896. X#endif
  897. X        } else if (++optind >= argc) {
  898. X            ERR("option requires an argument -- ", c);
  899. X            sp = 1;
  900. X            optarg = NULL;
  901. X            return('?');
  902. X        } else
  903. X            optarg = argv[optind++];
  904. X        sp = 1;
  905. X    } else {
  906. X        if (argv[optind][++sp] == '\0') {
  907. X            sp = 1;
  908. X            optind++;
  909. X        }
  910. X        optarg = NULL;
  911. X    }
  912. X    return(c);
  913. X}
  914. X
  915. X/*
  916. X * The following were created by Arnold Robbins.
  917. X */
  918. X
  919. X/* resetopts --- magic code for when OPTIND is reset to 1 */
  920. X
  921. Xvoid
  922. Xresetopts ()
  923. X{
  924. X    optind = 1;
  925. X    sp = 1;
  926. X}
  927. X
  928. Xint
  929. Xc_getopts(wp)
  930. X    char **wp;
  931. X{
  932. X    int ret;
  933. X    register int argc;
  934. X    char temp[2];
  935. X    char *optstr;            /* list of options */
  936. X    char *name;            /* variable to get flag val */
  937. X    char **argv;
  938. X
  939. X    if ((optstr = *++wp) == NULL || (name = *++wp) == NULL)
  940. X        errorf("missing arguments\n");
  941. X
  942. X    for (argc = 1; wp[argc] != NULL; argc++)
  943. X        ;
  944. X
  945. X    if (argc > 1)
  946. X        ret = getopt(argc, wp, optstr);
  947. X    else {
  948. X        if (**(e.loc->argv) == '\0') {
  949. X            /*
  950. X             * When c_getopts gets called from comexec() it
  951. X             * doesn't set up argc/argv in the local block.
  952. X             * Maybe this should be done in newblock() but
  953. X             * I'm not sure about the implications, and this
  954. X             * is the only place I've been bitten so far...
  955. X             * JRM
  956. X             */
  957. X            argc = e.loc->next->argc;
  958. X            argv = e.loc->next->argv;
  959. X        } else {
  960. X            argc = e.loc->argc;
  961. X            argv = e.loc->argv;
  962. X        }
  963. X        ret = getopt(argc+1, argv, optstr);
  964. X
  965. X    }
  966. X
  967. X    /*
  968. X     * set the OPTIND variable in any case, to handle "--" skipping
  969. X     * unless it's 1, which would trigger a reset
  970. X     */
  971. X
  972. X    if (optind != 1)
  973. X        setint(global("OPTIND"), (long)optind);
  974. X
  975. X    if (ret == GETOPTEOF)        /* end of args */
  976. X        return (1);
  977. X
  978. X    /*
  979. X     * else, got an arg, set the various shell variables
  980. X     */
  981. X
  982. X    if (optarg != NULL)
  983. X        setstr(global("OPTARG"), optarg);
  984. X
  985. X    temp[0] = (char) ret;
  986. X    temp[1] = '\0';
  987. X    setstr(global(name), temp);
  988. X
  989. X    return (0);
  990. X}
  991. END_OF_FILE
  992.   if test 3479 -ne `wc -c <'sh/getopts.c'`; then
  993.     echo shar: \"'sh/getopts.c'\" unpacked with wrong size!
  994.   fi
  995.   # end of 'sh/getopts.c'
  996. fi
  997. if test -f 'sh/io.c' -a "${1}" != "-c" ; then 
  998.   echo shar: Will not clobber existing file \"'sh/io.c'\"
  999. else
  1000.   echo shar: Extracting \"'sh/io.c'\" \(3185 characters\)
  1001.   sed "s/^X//" >'sh/io.c' <<'END_OF_FILE'
  1002. X/*
  1003. X * shell buffered IO and formatted output
  1004. X */
  1005. X
  1006. Xstatic char *RCSid = "$Id: io.c,v 3.4 89/03/27 15:50:52 egisin Exp $";
  1007. X
  1008. X#include <stddef.h>
  1009. X#include <stdlib.h>
  1010. X#include <stdio.h>
  1011. X#include <errno.h>
  1012. X#include <unistd.h>
  1013. X#include <fcntl.h>
  1014. X#include <signal.h>
  1015. X#include <setjmp.h>
  1016. X#if __STDC__
  1017. X#include <stdarg.h>
  1018. X#else
  1019. X#include <varargs.h>
  1020. X#endif
  1021. X#include "sh.h"
  1022. X
  1023. X#if 0
  1024. X/* fputc with ^ escaping */
  1025. Xstatic void
  1026. Xfzotc(c, f)
  1027. X    register int c;
  1028. X    register FILE *f;
  1029. X{
  1030. X    if ((c&0x60) == 0) {        /* C0|C1 */
  1031. X        putc((c&0x80) ? '$' : '^', f);
  1032. X        putc((c&0x7F|0x40), f);
  1033. X    } else if ((c&0x7F) == 0x7F) {    /* DEL */
  1034. X        putc((c&0x80) ? '$' : '^', f);
  1035. X        putc('?', f);
  1036. X    } else
  1037. X        putc(c, f);
  1038. X}
  1039. X#endif
  1040. X
  1041. X/*
  1042. X * formatted output functions
  1043. X */
  1044. X
  1045. X/* shellf(...); error() */
  1046. Xint
  1047. X#if __STDC__
  1048. Xerrorf(Const char *fmt, ...) {
  1049. X#else
  1050. Xerrorf(va_alist) va_dcl
  1051. X{
  1052. X    char *fmt;
  1053. X#endif
  1054. X    va_list va;
  1055. X
  1056. X#if __STDC__
  1057. X    va_start(va, fmt);
  1058. X#else
  1059. X    va_start(va);
  1060. X    fmt = va_arg(va, char *);
  1061. X#endif
  1062. X    vfprintf(shlout, fmt, va);
  1063. X    va_end(va);
  1064. X    /*fflush(shlout);*/
  1065. X    error();
  1066. X}
  1067. X
  1068. X/* printf to shlout (stderr) */
  1069. Xint
  1070. X#if __STDC__
  1071. Xshellf(Const char *fmt, ...) {
  1072. X#else
  1073. Xshellf(va_alist) va_dcl
  1074. X{
  1075. X    char *fmt;
  1076. X#endif
  1077. X    va_list va;
  1078. X
  1079. X#if __STDC__
  1080. X    va_start(va, fmt);
  1081. X#else
  1082. X    va_start(va);
  1083. X    fmt = va_arg(va, char *);
  1084. X#endif
  1085. X    vfprintf(shlout, fmt, va);
  1086. X    va_end(va);
  1087. X    return 0;
  1088. X}
  1089. X
  1090. X/*
  1091. X * We have a stdio stream for any open shell file descriptors (0-9)
  1092. X */
  1093. XFILE *    shf [NUFILE];        /* map shell fd to FILE * */
  1094. X
  1095. X/* open stream for shell fd */
  1096. Xvoid
  1097. Xfopenshf(fd)
  1098. X    int fd;
  1099. X{
  1100. X    if (shf[fd] != NULL)
  1101. X        return;
  1102. X    if (fd <= 2)
  1103. X        _iob[fd]._flag = 0; /* re-use stdin, stdout, stderr */
  1104. X    shf[fd] = fdopen(fd, "r+");
  1105. X    if (shf[fd] == NULL)
  1106. X        return;
  1107. X    setvbuf(shf[fd], (char*)NULL, _IOFBF, (size_t)BUFSIZ);
  1108. X}
  1109. X
  1110. X/* flush stream assoc with fd */
  1111. X/* this must invalidate input and output buffers */
  1112. Xvoid
  1113. Xflushshf(fd)
  1114. X    int fd;
  1115. X{
  1116. X    if (shf[fd] != NULL) {
  1117. X        fseek(shf[fd], 0L, 1); /* V7 derived */
  1118. X        fflush(shf[fd]);    /* standard C */
  1119. X    }
  1120. X}
  1121. X
  1122. X/*
  1123. X * move fd from user space (0<=fd<10) to shell space (fd>=10)
  1124. X */
  1125. Xint
  1126. Xsavefd(fd)
  1127. X    int fd;
  1128. X{
  1129. X    int nfd;
  1130. X
  1131. X    if (fd < FDBASE) {
  1132. X        flushshf(fd);
  1133. X        nfd = fcntl(fd, F_DUPFD, FDBASE);
  1134. X        if (nfd < 0)
  1135. X            if (errno == EBADF)
  1136. X                return -1;
  1137. X            else
  1138. X                errorf("too many files open in shell\n");
  1139. X        (void) fcntl(nfd, F_SETFD, FD_CLEXEC);
  1140. X        close(fd);
  1141. X    } else
  1142. X        nfd = fd;
  1143. X    return nfd;
  1144. X}
  1145. X
  1146. Xvoid
  1147. Xrestfd(fd, ofd)
  1148. X    int fd, ofd;
  1149. X{
  1150. X    if (ofd == 0)        /* not saved (e.savefd) */
  1151. X        return;
  1152. X    flushshf(fd);
  1153. X    close(fd);
  1154. X    if (ofd < 0)        /* original fd closed */
  1155. X        return;
  1156. X    (void) fcntl(ofd, F_DUPFD, fd);
  1157. X    close(ofd);
  1158. X}
  1159. X
  1160. Xvoid
  1161. Xopenpipe(pv)
  1162. X    register int *pv;
  1163. X{
  1164. X    if (pipe(pv) < 0)
  1165. X        errorf("can't create pipe - try again\n");
  1166. X    pv[0] = savefd(pv[0]);
  1167. X    pv[1] = savefd(pv[1]);
  1168. X}
  1169. X
  1170. Xvoid
  1171. Xclosepipe(pv)
  1172. X    register int *pv;
  1173. X{
  1174. X    close(pv[0]);
  1175. X    close(pv[1]);
  1176. X}
  1177. X
  1178. X/*
  1179. X * temporary files
  1180. X */
  1181. X
  1182. Xstruct temp *
  1183. Xmaketemp(ap)
  1184. X    Area *ap;
  1185. X{
  1186. X    register struct temp *tp;
  1187. X    static unsigned int inc = 0;
  1188. X    char path [PATH];
  1189. X
  1190. X    sprintf(path, "/tmp/sh%05u%02u", (unsigned)getpid(), inc++);
  1191. X#if defined(_SYSV) || defined(_BSD)
  1192. X    close(creat(path, 0600));    /* to get appropriate permissions */
  1193. X#endif
  1194. X    tp = (struct temp *) alloc(sizeof(struct temp), ap);
  1195. X    tp->next = NULL;
  1196. X    tp->name = strsave(path, ap);
  1197. X    return tp;
  1198. X}
  1199. END_OF_FILE
  1200.   if test 3185 -ne `wc -c <'sh/io.c'`; then
  1201.     echo shar: \"'sh/io.c'\" unpacked with wrong size!
  1202.   fi
  1203.   # end of 'sh/io.c'
  1204. fi
  1205. if test -f 'sh/lex.h' -a "${1}" != "-c" ; then 
  1206.   echo shar: Will not clobber existing file \"'sh/lex.h'\"
  1207. else
  1208.   echo shar: Extracting \"'sh/lex.h'\" \(3466 characters\)
  1209.   sed "s/^X//" >'sh/lex.h' <<'END_OF_FILE'
  1210. X/*
  1211. X * Source input, lexer and parser
  1212. X */
  1213. X
  1214. X/* Id: /u/egisin/sh/src/RCS/lex.h,v 3.3 89/01/28 15:29:42 egisin Exp $ */
  1215. X
  1216. X#define    IDENT    64
  1217. X
  1218. Xtypedef struct source Source;
  1219. Xstruct source {
  1220. X    char   *str;        /* input pointer */
  1221. X    int    type;        /* input type */
  1222. X    union {
  1223. X        char  **strv;    /* string [] */
  1224. X        FILE   *file;    /* file */
  1225. X        struct tbl *tblp; /* alias */
  1226. X    } u;
  1227. X    int    line;        /* line number */
  1228. X    char   *file;        /* input file name */
  1229. X    int    echo;        /* echo input to shlout */
  1230. X    Source *next;        /* stacked source */
  1231. X};
  1232. X
  1233. X/* Source.type values */
  1234. X#define    SEOF    0        /* input EOF */
  1235. X#define    STTY    1        /* terminal input */
  1236. X#define    SFILE    2        /* file input */
  1237. X#define    SSTRING    4        /* string */
  1238. X#define    SWSTR    3        /* string without \n */
  1239. X#define    SWORDS    5        /* string[] */
  1240. X#define    SWORDSEP 8        /* string[] seperator */
  1241. X#define    SALIAS    6        /* alias expansion */
  1242. X#define    SHIST    7        /* history expansion */
  1243. X
  1244. XSource *pushs ARGS((int stype));     /* push Source */
  1245. Xstruct op *compile ARGS((Source *s));    /* compile tree */
  1246. X
  1247. X/*
  1248. X * states while lexing word
  1249. X */
  1250. X#define    SBASE    0        /* outside any lexical constructs */
  1251. X#define    SWORD    6        /* implicit quoting for substitute() */
  1252. X#define    SDPAREN    7        /* inside (( )), implicit quoting */
  1253. X#define    SSQUOTE    1        /* inside '' */
  1254. X#define    SDQUOTE    2        /* inside "" */
  1255. X#define    SBRACE    3        /* inside ${} */
  1256. X#define    SPAREN    4        /* inside $() */
  1257. X#define    SBQUOTE    5        /* inside `` */
  1258. X
  1259. XExtern    int    multiline;    /* \n changed to ; */
  1260. X
  1261. Xtypedef union {
  1262. X    int    i;
  1263. X    char   *cp;
  1264. X    char  **wp;
  1265. X    struct op *o;
  1266. X    struct ioword *iop;
  1267. X} YYSTYPE;
  1268. X
  1269. X#define    LWORD    256
  1270. X#define    LOGAND    257
  1271. X#define    LOGOR    258
  1272. X#define    BREAK    259
  1273. X#define    IF    260
  1274. X#define    THEN    261
  1275. X#define    ELSE    262
  1276. X#define    ELIF    263
  1277. X#define    FI    264
  1278. X#define    CASE    265
  1279. X#define    ESAC    266
  1280. X#define    FOR    267
  1281. X#define    WHILE    268
  1282. X#define    UNTIL    269
  1283. X#define    DO    270
  1284. X#define    DONE    271
  1285. X#define    IN    272
  1286. X#define    FUNCTION 273
  1287. X#define    TIME    274
  1288. X#define    REDIR    275
  1289. X#define    MPAREN    276        /* () */
  1290. X#define    MDPAREN    277        /* (( )) */
  1291. X#define    YYERRCODE 300
  1292. X
  1293. X/* flags to yylex */
  1294. X#define    CONTIN    BIT(0)        /* skip new lines to complete command */
  1295. X#define    ONEWORD    BIT(1)        /* single word for substitute() */
  1296. X#define    ALIAS    BIT(2)        /* recognize alias */
  1297. X#define    KEYWORD    BIT(3)        /* recognize keywords */
  1298. X#define    LETEXPR    BIT(4)        /* get expression inside (( )) */
  1299. X
  1300. X#define    SYNTAXERR    zzerr()
  1301. X#define    HERES    10        /* max << in line */
  1302. X
  1303. XExtern    char    line [LINE+1];    /* input line */
  1304. XExtern    Source *source;        /* yyparse/yylex source */
  1305. XExtern    YYSTYPE    yylval;        /* result from yylex */
  1306. XExtern    int    yynerrs;
  1307. XExtern    struct ioword *heres [HERES], **herep;
  1308. XExtern    char    ident [IDENT+1];
  1309. X
  1310. Xextern    int    yylex ARGS((int flags));
  1311. Xextern    void    yyerror ARGS((Const char *msg));
  1312. X
  1313. X#define    HISTORY    100        /* size of saved history */
  1314. X
  1315. Xextern    char   *history [HISTORY];    /* saved commands */
  1316. Xextern    char  **histptr;    /* last history item */
  1317. Xextern    int    histpush;    /* number of pushed fc commands */
  1318. X
  1319. Xextern    char    **histget();
  1320. Xextern  char    **histpos();
  1321. Xextern    int    histnum();
  1322. Xextern    char    *findhist();
  1323. Xextern    int    histN();
  1324. X
  1325. X#ifdef EDIT
  1326. X
  1327. Xextern    void    x_init ARGS ((void));    /* setup tty modes */
  1328. Xextern    void    x_init_emacs ARGS ((void));
  1329. Xextern    void    x_emacs_keys ();
  1330. Xextern    void    x_bind();
  1331. X
  1332. Xextern    int    x_read ARGS ((int fd, char *buf, size_t len));
  1333. Xextern    int    x_emacs ARGS ((char *buf, size_t len));
  1334. Xextern    int    x_vi ARGS ((char *buf, size_t len));
  1335. X
  1336. Xextern    bool_t    x_mode ARGS ((bool_t));    /* set/clear cbreak mode */
  1337. Xextern    int    x_getc();        /* get tty char */
  1338. Xextern    void    x_flush(), x_putc(), x_puts(); /* put tty char */
  1339. X
  1340. Xextern    int    x_cols;        /* tty columns */
  1341. X
  1342. X#endif
  1343. END_OF_FILE
  1344.   if test 3466 -ne `wc -c <'sh/lex.h'`; then
  1345.     echo shar: \"'sh/lex.h'\" unpacked with wrong size!
  1346.   fi
  1347.   # end of 'sh/lex.h'
  1348. fi
  1349. if test -f 'sh/table.h' -a "${1}" != "-c" ; then 
  1350.   echo shar: Will not clobber existing file \"'sh/table.h'\"
  1351. else
  1352.   echo shar: Extracting \"'sh/table.h'\" \(3500 characters\)
  1353.   sed "s/^X//" >'sh/table.h' <<'END_OF_FILE'
  1354. X/* $Id: table.h,v 3.2 89/03/27 15:46:52 egisin Exp $ */
  1355. X
  1356. X/*
  1357. X * generic hashed associative table for commands and variables.
  1358. X */
  1359. X
  1360. Xstruct table {
  1361. X    Area   *areap;        /* area to allocate entries */
  1362. X    int    size, free;    /* hash size (always 2^^n), free entries */
  1363. X    struct    tbl **tbls;    /* hashed table items */
  1364. X};
  1365. X
  1366. Xstruct tbl {            /* table item */
  1367. X    int    flag;        /* flags */
  1368. X    int    type;        /* command type or base, see below */
  1369. X    union {
  1370. X        char *s;    /* string */
  1371. X        long i;        /* integer */
  1372. X        int (*f) ARGS ((char**)); /* int function */
  1373. X        struct op *t;    /* "function" tree */
  1374. X    } val;            /* value */
  1375. X    char    name[4];    /* name -- variable length */
  1376. X};
  1377. X
  1378. X/* flag bits */
  1379. X#define    ALLOC    BIT(0)        /* val.s has been allocated */
  1380. X#define    DEFINED    BIT(1)        /* is defined in block */
  1381. X#define    ISSET    BIT(2)        /* has value, vp->val.[si] */
  1382. X#define    SPECIAL    BIT(3)        /* PATH, IFS, SECONDS, etc */
  1383. X#define    INTEGER    BIT(4)        /* val.i contains integer value */
  1384. X#define    RDONLY    BIT(8)        /* read-only variable */
  1385. X#define    EXPORT    BIT(9)        /* exported variable */
  1386. X#define    LOCAL    BIT(10)        /* for local typeset() */
  1387. X#define    TRACE    BIT(11)        /* trace (-t) */
  1388. X#define    FUNCT    BIT(12)        /* function */
  1389. X#define    EXPALIAS BIT(13)    /* expanding this alias */
  1390. X
  1391. X/* command types */
  1392. X#define    CNONE    0        /* undefined */
  1393. X#define    CSHELL    1        /* built-in */
  1394. X#define    CFUNC    2        /* function */
  1395. X#define    CEXEC    4        /* executable command */
  1396. X#define    CALIAS    5        /* alias */
  1397. X#define    CKEYWD    6        /* keyword */
  1398. X
  1399. Xvoid tinit ARGS((struct table *, Area *)); /* initialize table */
  1400. Xunsigned int hash();        /* name hash function */
  1401. Xstruct tbl *tsearch();        /* table lookup primative */
  1402. Xstruct tbl *tenter();        /* table lookup/enter primative */
  1403. Xvoid tdelete();            /* mark tbl entry for deletion */
  1404. Xvoid twalk();            /* initialize walk of table */
  1405. Xstruct tbl *tnext();        /* walk table returning table time */
  1406. Xstruct tbl **tsort();        /* sort table entries by name */
  1407. X
  1408. X/*
  1409. X * activation record for function blocks
  1410. X */
  1411. Xstruct block {
  1412. X    Area    area;        /* area to allocate things */
  1413. X    int    argc;        /* current $# */
  1414. X    char **    argv;        /* current $* */
  1415. X    struct    table vars;    /* local variables */
  1416. X    struct    table funs;    /* local functions */
  1417. X#if 1
  1418. X    char *    error;        /* error handler */
  1419. X    char *    exit;        /* exit handler */
  1420. X#else
  1421. X    struct    trap error, exit;
  1422. X#endif
  1423. X    struct    block *next;    /* enclosing block */
  1424. X};
  1425. X
  1426. XExtern    struct block globals;    /* global variables and functions */
  1427. XExtern    struct table commands;    /* hashed commands */
  1428. XExtern    struct table builtins;    /* built-in commands */
  1429. XExtern    struct table lexicals;    /* keywords and aliases */
  1430. XExtern    struct table homedirs;    /* homedir() cache */
  1431. X
  1432. Xstruct builtin {
  1433. X    char   *name;
  1434. X    int  (*func)();
  1435. X};
  1436. XExtern Const struct builtin shbuiltins [], kshbuiltins [];
  1437. X
  1438. X/* var spec values */
  1439. X#define    V_NONE    0
  1440. X#define    V_PATH    1
  1441. X#define    V_IFS    2
  1442. X#define    V_SECONDS 3
  1443. X#define    V_OPTIND 4
  1444. X#define    V_MAIL    5
  1445. X#define    V_MAILPATH 6
  1446. X#define    V_RANDOM 7
  1447. X
  1448. XExtern    Area   *lastarea;    /* area of last variable/function looked up */
  1449. XExtern    char   *path;        /* PATH value */
  1450. XExtern    char   *prompt;        /* PS1 or PS2 */
  1451. X
  1452. Xvoid    newblock();
  1453. Xvoid    popblock();
  1454. Xstruct tbl *global(/* char *s */);
  1455. Xstruct tbl *local(/* char *s */);
  1456. Xstruct tbl *typeset(/* char *var; int set, clr */);
  1457. Xstruct tbl *setvar(/* struct tbl *vdst, *vsrc */);
  1458. Xstruct tbl *strint(/* struct tbl *vdst, *vsrc */);
  1459. Xlong    intval(/* struct tbl *vp */);
  1460. Xvoid    setint(/* struct tbl *vp; long n */);
  1461. Xchar   *strval(/* struct tbl *vp */);
  1462. Xvoid    setstr(/* struct tbl *vp; char *s */);
  1463. Xvoid    unset(/* struct tbl *vp */);
  1464. Xint    import(/* char *s */);
  1465. Xchar  **makenv();
  1466. Xint    isassign(/* char *s */);
  1467. X
  1468. END_OF_FILE
  1469.   if test 3500 -ne `wc -c <'sh/table.h'`; then
  1470.     echo shar: \"'sh/table.h'\" unpacked with wrong size!
  1471.   fi
  1472.   # end of 'sh/table.h'
  1473. fi
  1474. if test -f 'sh/trace.h' -a "${1}" != "-c" ; then 
  1475.   echo shar: Will not clobber existing file \"'sh/trace.h'\"
  1476. else
  1477.   echo shar: Extracting \"'sh/trace.h'\" \(2121 characters\)
  1478.   sed "s/^X//" >'sh/trace.h' <<'END_OF_FILE'
  1479. X/* NAME:
  1480. X *      trace.h - definitions for a simple trace facility
  1481. X *
  1482. X * SYNOPSIS:
  1483. X *      #include "trace.h"
  1484. X *
  1485. X * DESCRIPTION:
  1486. X *      Defines the macro _TRACE().
  1487. X *      Also declares Trace_log and Trace_level.
  1488. X *
  1489. X * SEE ALSO:
  1490. X *      
  1491. X *
  1492. X * AMENDED:
  1493. X *      %E%  %U%  (%Y%)
  1494. X *
  1495. X * RELEASED:
  1496. X *      %D%  %T%  v%I%
  1497. X *
  1498. X * SCCSID:
  1499. X *      %Z%%M%  %I%  %E%  %U%  (%Y%)
  1500. X *
  1501. X *      @(#)Copyright (c) 1990 Simon J. Gerraty.
  1502. X */
  1503. X
  1504. X/* some useful #defines */
  1505. X#ifndef EXTERN
  1506. X# define EXTERN extern
  1507. X# define EXTERN_DEFINED
  1508. X#endif
  1509. X
  1510. X#ifndef TRUE
  1511. X# define TRUE  1
  1512. X# define FALSE 0
  1513. X#endif
  1514. X#ifndef _P_
  1515. X# if defined(__STDC__) || defined(PROTO)
  1516. X#   define _P_(p) p
  1517. X# else
  1518. X#   define _P_(p) ()
  1519. X# endif
  1520. X#endif
  1521. X
  1522. X/*
  1523. X * this garbage is sometimes needed when mixing
  1524. X * langauges or calling conventions under DOS.
  1525. X */
  1526. X#ifndef _CDECL
  1527. X# if defined(MSDOS) || defined(MSC)
  1528. X#   ifndef NO_EXT_KEYS
  1529. X#     define _CDECL  cdecl
  1530. X#     define _NEAR   near
  1531. X#   else
  1532. X#     define _CDECL
  1533. X#     define _NEAR
  1534. X#   endif
  1535. X# else /* not DrOS */
  1536. X#   define _CDECL
  1537. X#   define _NEAR
  1538. X# endif /* DOS */
  1539. X#endif /* _CDECL */
  1540. X
  1541. X/* manifest constants */
  1542. X
  1543. X/* struct / union */
  1544. X
  1545. X/* macros */
  1546. X
  1547. X
  1548. X#ifdef USE_TRACE
  1549. XEXTERN char * _CDECL    Trace_log;
  1550. XEXTERN int _CDECL     Trace_level;
  1551. X
  1552. Xvoid _CDECL checkpoint    _P_((char *fmt, ...));
  1553. X
  1554. X/*
  1555. X * This macro takes a variabel number of args. 
  1556. X * examples:
  1557. X *     _TRACE(5, ("The current Debug level is %d\n", Debug));
  1558. X * Note that if more than two args are provided, all but the 
  1559. X * first (which should be an integer indicating the Trace-level 
  1560. X * required for this message to be printed) must be enclosed in 
  1561. X * parenthesis. 
  1562. X */
  1563. X# define _TRACE(lev, args) if (Trace_level >= lev) checkpoint args
  1564. X#else     /* don't USE_TRACE */
  1565. X  /*
  1566. X   * this macro evaluates to a harmless no entry
  1567. X   * loop that most optimizers will remove all together.
  1568. X   */
  1569. X# define _TRACE(l, args) while (0)
  1570. X#endif     /* USE_TRACE */
  1571. X
  1572. X
  1573. X/* This lot goes at the END */
  1574. X/* be sure not to interfere with anyone else's idea about EXTERN */
  1575. X#ifdef EXTERN_DEFINED
  1576. X# undef EXTERN_DEFINED
  1577. X# undef EXTERN
  1578. X#endif
  1579. X/*
  1580. X * Local Variables:
  1581. X * version-control:t
  1582. X * comment-column:40
  1583. X * End:
  1584. X */
  1585. END_OF_FILE
  1586.   if test 2121 -ne `wc -c <'sh/trace.h'`; then
  1587.     echo shar: \"'sh/trace.h'\" unpacked with wrong size!
  1588.   fi
  1589.   # end of 'sh/trace.h'
  1590. fi
  1591. if test -f 'sh/trap.c' -a "${1}" != "-c" ; then 
  1592.   echo shar: Will not clobber existing file \"'sh/trap.c'\"
  1593. else
  1594.   echo shar: Extracting \"'sh/trap.c'\" \(3128 characters\)
  1595.   sed "s/^X//" >'sh/trap.c' <<'END_OF_FILE'
  1596. X/*
  1597. X * signal handling
  1598. X */
  1599. X
  1600. Xstatic char *RCSid = "$Id: trap.c,v 3.2 89/03/27 15:52:06 egisin Exp $";
  1601. X
  1602. X#include <stddef.h>
  1603. X#include <string.h>
  1604. X#include <errno.h>
  1605. X#include <signal.h>
  1606. X#include <setjmp.h>
  1607. X#include "sh.h"
  1608. X
  1609. XTrap sigtraps [SIGNALS] = {
  1610. X    {0,    "EXIT", "Signal 0"}, /* todo: belongs in e.loc->exit */
  1611. X    {SIGHUP, "HUP", "Hangup"},
  1612. X    {SIGINT, "INT", "Interrupt"},
  1613. X    {SIGQUIT, "QUIT", "Quit"},
  1614. X    {SIGILL, "ILL", "Illegal instruction"},
  1615. X    {SIGTRAP, "TRAP", "Trace trap"},
  1616. X#ifdef    SIGABRT
  1617. X    {SIGIOT, "ABRT", "Abort"},
  1618. X#else
  1619. X    {SIGIOT, "IOT", "IOT instruction"},
  1620. X#endif
  1621. X    {SIGEMT, "EMT", "EMT trap"},
  1622. X    {SIGFPE, "FPE", "Floating exception"},
  1623. X    {SIGKILL, "KILL", "Killed"},
  1624. X    {SIGBUS, "BUS", "Bus error"},
  1625. X    {SIGSEGV, "SEGV", "Memory fault"},
  1626. X    {SIGSYS, "SYS", "Bad system call"},
  1627. X    {SIGPIPE, "PIPE", "Broken pipe"},
  1628. X    {SIGALRM, "ALRM", "Alarm clock"},
  1629. X    {SIGTERM, "TERM", "Terminated"},
  1630. X#ifdef _SYSV
  1631. X    {SIGUSR1, "USR1", "User defined signal 1"},
  1632. X    {SIGUSR2, "USR2", "User defined signal 2"},
  1633. X    {SIGCLD, "CLD", "Death of a child"},
  1634. X    {SIGPWR, "PWR", "Power-fail restart"},
  1635. X#else
  1636. X#ifdef JOBS            /* todo: need to be more portable */
  1637. X    {SIGURG, "URG", "Urgent condition"}, /* BSDism */
  1638. X    {SIGSTOP, "STOP", "Stop (signal)"},
  1639. X    {SIGTSTP, "TSTP", "Stop"},
  1640. X    {SIGCONT, "CONT", "Continue"},
  1641. X    {SIGCHLD, "CHLD", "Waiting children"},
  1642. X    {SIGTTIN, "TTIN", "Stop (tty input)"},
  1643. X    {SIGTTOU, "TTOU", "Stop (tty output)"},
  1644. X#endif
  1645. X#endif
  1646. X};
  1647. X
  1648. XTrap *
  1649. Xgettrap(name)
  1650. X    char *name;
  1651. X{
  1652. X    int i;
  1653. X    register Trap *p;
  1654. X
  1655. X    if (digit(*name)) {
  1656. X        i = getn(name);
  1657. X        return (0 <= i && i < SIGNALS) ? &sigtraps[getn(name)] : NULL;
  1658. X    }
  1659. X#if 0
  1660. X    if (strcmp("ERR", name) == 0)
  1661. X        return &e.loc->err;
  1662. X    if (strcmp("EXIT", name) == 0)
  1663. X        return &e.loc->exit;
  1664. X#endif
  1665. X    for (p = sigtraps, i = SIGNALS; --i >= 0; p++)
  1666. X        if (p->name != NULL && strcmp(p->name, name) == 0)
  1667. X            return p;
  1668. X    return NULL;
  1669. X}
  1670. X
  1671. X/*
  1672. X * trap signal handler
  1673. X */
  1674. Xvoid
  1675. Xtrapsig(i)
  1676. X    int i;
  1677. X{
  1678. X    trap = sigtraps[i].set = 1;
  1679. X    if (i == SIGINT && e.type == E_PARSE)
  1680. X        /* dangerous but necessary to deal with BSD silly signals */
  1681. X        longjmp(e.jbuf, 1);
  1682. X    (void) signal(i, trapsig); /* todo: use sigact */
  1683. X}
  1684. X
  1685. X/*
  1686. X * run any pending traps
  1687. X */
  1688. Xruntraps()
  1689. X{
  1690. X    int i;
  1691. X    register Trap *p;
  1692. X
  1693. X    for (p = sigtraps, i = SIGNALS; --i >= 0; p++)
  1694. X        if (p->set)
  1695. X            runtrap(p);
  1696. X    trap = 0;
  1697. X}
  1698. X
  1699. Xruntrap(p)
  1700. X    Trap *p;
  1701. X{
  1702. X    char *trapstr;
  1703. X
  1704. X    p->set = 0;
  1705. X    if ((trapstr = p->trap) == NULL)
  1706. X        if (p->signal == SIGINT)
  1707. X            unwind();    /* return to shell() */
  1708. X        else
  1709. X            return;
  1710. X    if (p->signal == 0)    /* ??? */
  1711. X        p->trap = 0;
  1712. X    command(trapstr);
  1713. X}
  1714. X 
  1715. X/* restore signals for children */
  1716. Xcleartraps()
  1717. X{
  1718. X    int i;
  1719. X    register Trap *p;
  1720. X
  1721. X    if ((p = sigtraps)->trap != NULL) {    /* Maybe put in exchild() */
  1722. X        afree((Void *)p->trap,APERM);    /* Necessary? */
  1723. X        p->trap = NULL;
  1724. X    }
  1725. X    for (i = SIGNALS, p = sigtraps; --i >= 0; p++) {
  1726. X        p->set = 0;
  1727. X        if (p->ourtrap && signal(p->signal, SIG_IGN) != SIG_IGN)
  1728. X            (void) signal(p->signal, SIG_DFL);
  1729. X    }
  1730. X}
  1731. X
  1732. Xignoresig(i)
  1733. X    int i;
  1734. X{
  1735. X    if (signal(i, SIG_IGN) != SIG_IGN)
  1736. X        sigtraps[i].sig_dfl = 1;
  1737. X}
  1738. X
  1739. Xrestoresigs()
  1740. X{
  1741. X    int i;
  1742. X    register Trap *p;
  1743. X
  1744. X    for (p = sigtraps, i = SIGNALS; --i >= 0; p++)
  1745. X        if (p->sig_dfl) {
  1746. X            p->sig_dfl = 0;
  1747. X            (void) signal(p->signal, SIG_DFL);
  1748. X        }
  1749. X}
  1750. X
  1751. END_OF_FILE
  1752.   if test 3128 -ne `wc -c <'sh/trap.c'`; then
  1753.     echo shar: \"'sh/trap.c'\" unpacked with wrong size!
  1754.   fi
  1755.   # end of 'sh/trap.c'
  1756. fi
  1757. if test -f 'sh/tree.h' -a "${1}" != "-c" ; then 
  1758.   echo shar: Will not clobber existing file \"'sh/tree.h'\"
  1759. else
  1760.   echo shar: Extracting \"'sh/tree.h'\" \(3570 characters\)
  1761.   sed "s/^X//" >'sh/tree.h' <<'END_OF_FILE'
  1762. X/*
  1763. X * command trees for compile/execute
  1764. X */
  1765. X
  1766. X/* $Id: tree.h,v 3.3 89/03/27 15:46:57 egisin Exp $ */
  1767. X
  1768. X#define    NOBLOCK    ((struct op *)NULL)
  1769. X#define    NOWORD    ((char *)NULL)
  1770. X#define    NOWORDS    ((char **)NULL)
  1771. X
  1772. X/*
  1773. X * Description of a command or an operation on commands.
  1774. X */
  1775. Xstruct op {
  1776. X    int    type;            /* operation type, see below */
  1777. X    char  **args;            /* arguments to a command */
  1778. X    char  **vars;            /* variable assignments */
  1779. X    struct ioword    **ioact;    /* IO actions (eg, < > >>) */
  1780. X    struct op *left, *right;     /* descendents */
  1781. X    char   *str;        /* identifier for case and for (use vars[0]) */
  1782. X};
  1783. X
  1784. X/* Tree.type values */
  1785. X#define    TEOF    0
  1786. X#define    TCOM    1        /* command */
  1787. X#define    TPAREN    2        /* (c-list) */
  1788. X#define    TPIPE    3        /* a | b */
  1789. X#define    TLIST    4        /* a [&;] b */
  1790. X#define    TOR    5        /* || */
  1791. X#define    TAND    6        /* && */
  1792. X#define    TFOR    7
  1793. X#define    TCASE    9
  1794. X#define    TIF    10
  1795. X#define    TWHILE    11
  1796. X#define    TUNTIL    12
  1797. X#define    TELIF    13
  1798. X#define    TPAT    14        /* pattern in case */
  1799. X#define    TBRACE    15        /* {c-list} */
  1800. X#define    TASYNC    16        /* c & */
  1801. X#define    TFUNCT    17        /* function name { command; } */
  1802. X#define    TTIME    18        /* time pipeline */
  1803. X#define    TEXEC    19        /* fork/exec eval'd TCOM */
  1804. X
  1805. X/*
  1806. X * prefix codes for words in command tree
  1807. X */
  1808. X#define    EOS    0        /* end of string */
  1809. X#define    CHAR    1        /* unquoted character */
  1810. X#define    QCHAR    2        /* quoted character */
  1811. X#define    COMSUB    3        /* $() substitution (0 terminated) */
  1812. X#define    OQUOTE    4        /* opening " or ' */
  1813. X#define    CQUOTE    5        /* closing " or ' */
  1814. X#define    OSUBST    6        /* opening ${ substitution */
  1815. X#define    CSUBST    7        /* closing } of above */
  1816. X
  1817. X/*
  1818. X * IO redirection
  1819. X */
  1820. Xstruct ioword {
  1821. X    int    unit;    /* unit affected */
  1822. X    int    flag;    /* action (below) */
  1823. X    char   *name;    /* file name */
  1824. X};
  1825. X
  1826. X/* ioword.flag - type of redirection */
  1827. X#define    IOTYPE    0xF        /* type: bits 0:3 */
  1828. X#define    IOREAD    0x1        /* < */
  1829. X#define    IOWRITE    0x2        /* > */
  1830. X#define    IORDWR    0x3        /* <>: todo */
  1831. X#define    IOHERE    0x4        /* << (here file) */
  1832. X#define    IOCAT    0x5        /* >> */
  1833. X#define    IODUP    0x6        /* <&/>& */
  1834. X#define    IOEVAL    BIT(4)        /* expand in << */
  1835. X#define    IOSKIP    BIT(5)        /* <<-, skip ^\t* */
  1836. X#define    IOCLOB    BIT(6)        /* >!, override -o noclob */
  1837. X
  1838. X/* values for E_LOOP longjmp */
  1839. X#define    LBREAK    1
  1840. X#define    LCONTIN    2
  1841. X
  1842. X/* execute/exchild flags */
  1843. X#define    XEXEC    BIT(0)        /* execute without forking */
  1844. X#define    XFORK    BIT(5)        /* fork before executing */
  1845. X#define    XBGND    BIT(1)        /* command & */
  1846. X#define    XPIPEI    BIT(2)        /* input is pipe */
  1847. X#define    XPIPEO    BIT(3)        /* output is pipe */
  1848. X#define    XPIPE    (XPIPEI|XPIPEO)    /* member of pipe */
  1849. X#define    XXCOM    BIT(4)        /* dup2 xcomfd to 1 */
  1850. X
  1851. X/*
  1852. X * flags to control expansion of words
  1853. X */
  1854. X#define    DOBLANK    BIT(1)        /* perform blank interpretation */
  1855. X#define    DOGLOB    BIT(2)        /* expand [?* */
  1856. X#define    DOPAT    BIT(3)        /* quote *?[ */
  1857. X#define    DOTILDE    BIT(5)        /* expand ~ */
  1858. X
  1859. X/* job.c: job control primatives */
  1860. Xint    execute ARGS((struct op *, int flags));    /* execute tree */
  1861. Xint    exchild ARGS((struct op *, int flags));    /* execute tree as child */
  1862. Xint    waitfor ARGS((int job));         /* wait for job completion */
  1863. Xint    waitlast ARGS((void));            /* wait for last job */
  1864. X
  1865. X/* eval.c: word expansion */
  1866. Xchar  **eval ARGS((char **wv, int flag));     /* expand words */
  1867. Xchar   *evalstr ARGS((char *wp, int flags));    /* expand word */
  1868. Xchar   *substitute ARGS((Const char *s, int flags)); /* compile and expand string */
  1869. X
  1870. X/* tree.c: command trees */
  1871. Xvoid    ptree ARGS((struct op *t, FILE *f));    /* print tree */
  1872. Xchar   *wdscan ARGS((char *wp, int c));        /* scan word for prefix */
  1873. Xchar   *wdcopy ARGS((char *wp, Area *));    /* copy word */
  1874. Xstruct op *tcopy ARGS((struct op *t, Area *));    /* copy tree */
  1875. Xvoid    tfree ARGS((struct op *t, Area *));    /* free tree */
  1876. X
  1877. END_OF_FILE
  1878.   if test 3570 -ne `wc -c <'sh/tree.h'`; then
  1879.     echo shar: \"'sh/tree.h'\" unpacked with wrong size!
  1880.   fi
  1881.   # end of 'sh/tree.h'
  1882. fi
  1883. if test -f 'std/posix/io.h' -a "${1}" != "-c" ; then 
  1884.   echo shar: Will not clobber existing file \"'std/posix/io.h'\"
  1885. else
  1886.   echo shar: Extracting \"'std/posix/io.h'\" \(1499 characters\)
  1887.   sed "s/^X//" >'std/posix/io.h' <<'END_OF_FILE'
  1888. X/* POSIX IO functions */
  1889. X
  1890. X/*
  1891. X * the incomplete type "struct stat"
  1892. X * will get warnings from GCC,
  1893. X * errors from Turbo C. Too bad.
  1894. X */
  1895. X
  1896. X/* include <unistd.h> to get this */
  1897. X
  1898. X#if ! _IO_H
  1899. X#define    _IO_H    1
  1900. X
  1901. X#include <unistd.h>
  1902. X
  1903. X#if _ST                /* dLibs hack */
  1904. X#define    unlink    remove
  1905. X#endif
  1906. X
  1907. Xstruct stat;            /* create global incompletely-typed structure */
  1908. X
  1909. Xint chdir ARGS ((const char *path));
  1910. X#ifndef sparc
  1911. Xint umask ARGS ((int mode));
  1912. X#endif
  1913. X
  1914. Xint open ARGS ((const char *path, int flags, ... /*mode*/));
  1915. Xint creat ARGS ((const char *path, int mode));
  1916. Xint pipe ARGS ((int pv[2]));
  1917. Xint close ARGS ((int fd));
  1918. X
  1919. Xint fcntl ARGS ((int fd, int cmd, int arg));
  1920. Xint dup ARGS ((int fd));
  1921. Xint dup2 ARGS ((int ofd, int nfd));
  1922. X
  1923. Xint link ARGS ((const char *opath, const char *npath));
  1924. Xint unlink ARGS ((const char *path));
  1925. Xint rename ARGS ((const char *opath, const char *npath));
  1926. Xint mkdir ARGS ((const char *path, int mode));
  1927. X
  1928. Xlong lseek ARGS ((int fd, long off, int how));
  1929. Xint read ARGS ((int fd, char *buf, unsigned len));
  1930. Xint write ARGS ((int fd, char *buf, unsigned len));
  1931. X
  1932. Xint access ARGS ((const char *path, int mode));
  1933. Xint stat ARGS ((const char *path, struct stat *sp));
  1934. Xint fstat ARGS ((int fd, struct stat *sp));
  1935. X
  1936. Xint chmod ARGS ((const char *path, int mode));
  1937. Xint chown ARGS ((const char *path, int uid));
  1938. Xint chgrp ARGS ((const char *path, int gid));
  1939. Xint utime ARGS ((const char *path, long tv[2]));
  1940. X
  1941. X#if _BSD || _V7
  1942. Xint ioctl ARGS ((int fd, int cmd, void *argp)); /* BSD is "uns long cmd" */
  1943. X#endif
  1944. X
  1945. X#endif
  1946. END_OF_FILE
  1947.   if test 1499 -ne `wc -c <'std/posix/io.h'`; then
  1948.     echo shar: \"'std/posix/io.h'\" unpacked with wrong size!
  1949.   fi
  1950.   # end of 'std/posix/io.h'
  1951. fi
  1952. if test -f 'std/stdc/stdio.h_std' -a "${1}" != "-c" ; then 
  1953.   echo shar: Will not clobber existing file \"'std/stdc/stdio.h_std'\"
  1954. else
  1955.   echo shar: Extracting \"'std/stdc/stdio.h_std'\" \(2290 characters\)
  1956.   sed "s/^X//" >'std/stdc/stdio.h_std' <<'END_OF_FILE'
  1957. X/*
  1958. X * ANSI stream IO
  1959. X *
  1960. X * Heavily dependent on /usr/include/stdio.h being AT&T derived.
  1961. X * todo: needs L_* constants.
  1962. X */
  1963. X
  1964. X/* $Header: stdio.h,v 1.2 88/06/23 18:32:35 egisin Locked $ */
  1965. X
  1966. X#if ! _STDIO_H
  1967. X#define    _STDIO_H 1
  1968. X
  1969. X#include <stddef.h>
  1970. X
  1971. X/* system stdio.h goes here ... %%% */
  1972. X/* ... end system stdio.h */
  1973. X#line 15 "stdio.h"
  1974. X
  1975. X#ifndef _IOFBF
  1976. X#define    _IOFBF    00000
  1977. X#endif
  1978. X#ifndef _IOLBF
  1979. X#define    _IOLBF    00000        /* same as _IOFBF */
  1980. X#endif
  1981. X
  1982. X#define    SEEK_SET    0
  1983. X#define    SEEK_CUR    1
  1984. X#define    SEEK_END    2
  1985. X
  1986. X#if _SYSV
  1987. X#define    _EXTERN    extern
  1988. X#else
  1989. X#define    _EXTERN    
  1990. X#endif
  1991. X
  1992. X_EXTERN    int    remove ARGS((const char *name));
  1993. X_EXTERN    int    rename ARGS((const char *oname, const char *nname));
  1994. X_EXTERN    FILE   *tmpfile ARGS((void));
  1995. X_EXTERN    char   *tmpnam ARGS((char *s));
  1996. X
  1997. X_EXTERN    FILE   *fopen ARGS((const char *name, const char *mode));
  1998. X_EXTERN    FILE   *freopen ARGS((const char *name, const char *mode, FILE *f));
  1999. X_EXTERN    FILE   *fdopen ARGS((int fd, const char *mode));
  2000. X_EXTERN    int    fflush ARGS((FILE *f));
  2001. X_EXTERN    int    fclose ARGS((FILE *f));
  2002. X_EXTERN    void    setbuf ARGS((FILE *f, char *buf));
  2003. X_EXTERN    int    setvbuf ARGS((FILE *f, char *buf, int flags, size_t len));
  2004. X
  2005. X_EXTERN    int    fseek ARGS((FILE *f, long off, int how));
  2006. X_EXTERN    long    ftell ARGS((FILE *f));
  2007. X_EXTERN    void    rewind ARGS((FILE *f));
  2008. X
  2009. X_EXTERN    int    printf ARGS((const char *fmt, ...));
  2010. X_EXTERN    int    fprintf ARGS((FILE *f, const char *fmt, ...));
  2011. X_EXTERN    int    sprintf ARGS((char *s, const char *fmt, ...));
  2012. X/* we do not include <stdarg.h> to prevent <varargs.h> conflicts */
  2013. X_EXTERN    int    vprintf ARGS((const char *fmt, Void *va));
  2014. X_EXTERN    int    vfprintf ARGS((FILE *f, const char *fmt, Void *va));
  2015. X_EXTERN    int    vsprintf ARGS((char *s, const char *fmt, Void *va));
  2016. X_EXTERN    int    scanf ARGS((const char *fmt, ...));
  2017. X_EXTERN    int    fscanf ARGS((FILE *f, const char *fmt, ...));
  2018. X_EXTERN    int    sscanf ARGS((const char *s, const char *fmt, ...));
  2019. X
  2020. X_EXTERN    size_t    fread ARGS((void *ptr, size_t size, size_t n, FILE *f));
  2021. X_EXTERN    size_t    frwrite ARGS((const void *ptr, size_t size, size_t n, FILE *f));
  2022. X_EXTERN    int    fgetc ARGS((FILE *f));
  2023. X_EXTERN    int    fputc ARGS((int c, FILE *f));
  2024. X_EXTERN    char   *fgets ARGS((char *s, int len, FILE *f));
  2025. X_EXTERN    int    fputs ARGS((const char *s, FILE *f));
  2026. X_EXTERN    char   *gets ARGS((char *s));
  2027. X_EXTERN    int     puts ARGS((const char *s));
  2028. X
  2029. X#endif
  2030. X
  2031. END_OF_FILE
  2032.   if test 2290 -ne `wc -c <'std/stdc/stdio.h_std'`; then
  2033.     echo shar: \"'std/stdc/stdio.h_std'\" unpacked with wrong size!
  2034.   fi
  2035.   # end of 'std/stdc/stdio.h_std'
  2036. fi
  2037. echo shar: End of archive 7 \(of 9\).
  2038. cp /dev/null ark7isdone
  2039. MISSING=""
  2040. for I in 1 2 3 4 5 6 7 8 9 ; do
  2041.     if test ! -f ark${I}isdone ; then
  2042.     MISSING="${MISSING} ${I}"
  2043.     fi
  2044. done
  2045. if test "${MISSING}" = "" ; then
  2046.     echo You have unpacked all 9 archives.
  2047.     rm -f ark[1-9]isdone ark[1-9][0-9]isdone
  2048. else
  2049.     echo You still must unpack the following archives:
  2050.     echo "        " ${MISSING}
  2051. fi
  2052. exit 0
  2053. exit 0 # Just in case...
  2054. -- 
  2055. Kent Landfield                   INTERNET: kent@sparky.IMD.Sterling.COM
  2056. Sterling Software, IMD           UUCP:     uunet!sparky!kent
  2057. Phone:    (402) 291-8300         FAX:      (402) 291-4362
  2058. Please send comp.sources.misc-related mail to kent@uunet.uu.net.
  2059.