home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / altsrcs / 2 / 2321 < prev    next >
Encoding:
Internet Message Format  |  1990-12-28  |  75.1 KB
  1. From: pfalstad@phoenix.Princeton.EDU (Paul John Falstad)
  2. Newsgroups: alt.sources
  3. Subject: zsh - ksh/tcsh-like shell (part 2 of 8)
  4. Message-ID: <4743@idunno.Princeton.EDU>
  5. Date: 14 Dec 90 23:29:51 GMT
  6.  
  7. ---cut here---cut here---cut here---
  8. -bash(1),
  9. -ksh(1),
  10. -cat(1),
  11. -cd(1),
  12. -chmod(1),
  13. -cut(1),
  14. -echo(1),
  15. -emacs(1),
  16. -env(1),
  17. -gmacs(1),
  18. -newgrp(1),
  19. -stty(1),
  20. -test(1),
  21. -umask(1),
  22. -vi(1),
  23. -dup(2),
  24. -exec(2),
  25. -fork(2),
  26. -ioctl(2),
  27. -lseek(2),
  28. -paste(1),
  29. -pipe(2),
  30. -signal(2),
  31. -umask(2),
  32. -ulimit(2),
  33. -wait(2),
  34. -rand(3),
  35. -a.out(5),
  36. -profile(5),
  37. -environ(7),
  38. -xtetris(6).
  39. -.SH AUTHOR
  40. -Paul Falstad <pfalstad@phoenix.princeton.edu>
  41. -.PP
  42. -The command line editor is a hacked-up version
  43. -of the GNU readline library,
  44. -written by Brian Fox (<bfox@ai.MIT.Edu>) of the Free
  45. -Software Foundation.  This shell is therefore
  46. -under the GNU public license.  I eventually plan
  47. -to write my own command line editor to make everything
  48. -my own code, but \fBzsh\fP will probably still be under
  49. -the GPL, or perhaps something less restrictive.
  50. -.SH CAVEATS
  51. -.PP
  52. -Using
  53. -.B fc
  54. -built-in command within a compound command will cause the whole
  55. -command to disappear from the history file.
  56. -.PP
  57. -Shell functions are put in the function table when their declarations
  58. -are parsed, not when they are executed.  Thus function declarations
  59. -inside \fBif\fP clauses, for example, will not work as expected.
  60. -(This is a bug, not a caveat.)
  61. -.PP
  62. -The command line editor gets confused if you have termcap sequences
  63. -(like %S) in your prompt.
  64. -.PP
  65. -The main shell does not get along with the command line editor.
  66. -One of them will have to go.
  67. -.PP
  68. -Use of this shell is reserved for faculty, staff,
  69. -graduate students,
  70. -and special guests
  71. -of the Princeton University 
  72. -Computer Science department.
  73. End of zsh.1
  74. echo COPYING 1>&2
  75. sed 's/^-//' >COPYING <<'End of COPYING'
  76. -
  77. -            GNU GENERAL PUBLIC LICENSE
  78. -             Version 1, February 1989
  79. -
  80. - Copyright (C) 1989 Free Software Foundation, Inc.
  81. -                    675 Mass Ave, Cambridge, MA 02139, USA
  82. - Everyone is permitted to copy and distribute verbatim copies
  83. - of this license document, but changing it is not allowed.
  84. -
  85. -                Preamble
  86. -
  87. -  The license agreements of most software companies try to keep users
  88. -at the mercy of those companies.  By contrast, our General Public
  89. -License is intended to guarantee your freedom to share and change free
  90. -software--to make sure the software is free for all its users.  The
  91. -General Public License applies to the Free Software Foundation's
  92. -software and to any other program whose authors commit to using it.
  93. -You can use it for your programs, too.
  94. -
  95. -  When we speak of free software, we are referring to freedom, not
  96. -price.  Specifically, the General Public License is designed to make
  97. -sure that you have the freedom to give away or sell copies of free
  98. -software, that you receive source code or can get it if you want it,
  99. -that you can change the software or use pieces of it in new free
  100. -programs; and that you know you can do these things.
  101. -
  102. -  To protect your rights, we need to make restrictions that forbid
  103. -anyone to deny you these rights or to ask you to surrender the rights.
  104. -These restrictions translate to certain responsibilities for you if you
  105. -distribute copies of the software, or if you modify it.
  106. -
  107. -  For example, if you distribute copies of a such a program, whether
  108. -gratis or for a fee, you must give the recipients all the rights that
  109. -you have.  You must make sure that they, too, receive or can get the
  110. -source code.  And you must tell them their rights.
  111. -
  112. -  We protect your rights with two steps: (1) copyright the software, and
  113. -(2) offer you this license which gives you legal permission to copy,
  114. -distribute and/or modify the software.
  115. -
  116. -  Also, for each author's protection and ours, we want to make certain
  117. -that everyone understands that there is no warranty for this free
  118. -software.  If the software is modified by someone else and passed on, we
  119. -want its recipients to know that what they have is not the original, so
  120. -that any problems introduced by others will not reflect on the original
  121. -authors' reputations.
  122. -
  123. -  The precise terms and conditions for copying, distribution and
  124. -modification follow.
  125. -
  126. -            GNU GENERAL PUBLIC LICENSE
  127. -   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
  128. -
  129. -  0. This License Agreement applies to any program or other work which
  130. -contains a notice placed by the copyright holder saying it may be
  131. -distributed under the terms of this General Public License.  The
  132. -"Program", below, refers to any such program or work, and a "work based
  133. -on the Program" means either the Program or any work containing the
  134. -Program or a portion of it, either verbatim or with modifications.  Each
  135. -licensee is addressed as "you".
  136. -
  137. -  1. You may copy and distribute verbatim copies of the Program's source
  138. -code as you receive it, in any medium, provided that you conspicuously and
  139. -appropriately publish on each copy an appropriate copyright notice and
  140. -disclaimer of warranty; keep intact all the notices that refer to this
  141. -General Public License and to the absence of any warranty; and give any
  142. -other recipients of the Program a copy of this General Public License
  143. -along with the Program.  You may charge a fee for the physical act of
  144. -transferring a copy.
  145. -
  146. -  2. You may modify your copy or copies of the Program or any portion of
  147. -it, and copy and distribute such modifications under the terms of Paragraph
  148. -1 above, provided that you also do the following:
  149. -
  150. -    a) cause the modified files to carry prominent notices stating that
  151. -    you changed the files and the date of any change; and
  152. -
  153. -    b) cause the whole of any work that you distribute or publish, that
  154. -    in whole or in part contains the Program or any part thereof, either
  155. -    with or without modifications, to be licensed at no charge to all
  156. -    third parties under the terms of this General Public License (except
  157. -    that you may choose to grant warranty protection to some or all
  158. -    third parties, at your option).
  159. -
  160. -    c) If the modified program normally reads commands interactively when
  161. -    run, you must cause it, when started running for such interactive use
  162. -    in the simplest and most usual way, to print or display an
  163. -    announcement including an appropriate copyright notice and a notice
  164. -    that there is no warranty (or else, saying that you provide a
  165. -    warranty) and that users may redistribute the program under these
  166. -    conditions, and telling the user how to view a copy of this General
  167. -    Public License.
  168. -
  169. -    d) You may charge a fee for the physical act of transferring a
  170. -    copy, and you may at your option offer warranty protection in
  171. -    exchange for a fee.
  172. -
  173. -Mere aggregation of another independent work with the Program (or its
  174. -derivative) on a volume of a storage or distribution medium does not bring
  175. -the other work under the scope of these terms.
  176. -
  177. -  3. You may copy and distribute the Program (or a portion or derivative of
  178. -it, under Paragraph 2) in object code or executable form under the terms of
  179. -Paragraphs 1 and 2 above provided that you also do one of the following:
  180. -
  181. -    a) accompany it with the complete corresponding machine-readable
  182. -    source code, which must be distributed under the terms of
  183. -    Paragraphs 1 and 2 above; or,
  184. -
  185. -    b) accompany it with a written offer, valid for at least three
  186. -    years, to give any third party free (except for a nominal charge
  187. -    for the cost of distribution) a complete machine-readable copy of the
  188. -    corresponding source code, to be distributed under the terms of
  189. -    Paragraphs 1 and 2 above; or,
  190. -
  191. -    c) accompany it with the information you received as to where the
  192. -    corresponding source code may be obtained.  (This alternative is
  193. -    allowed only for noncommercial distribution and only if you
  194. -    received the program in object code or executable form alone.)
  195. -
  196. -Source code for a work means the preferred form of the work for making
  197. -modifications to it.  For an executable file, complete source code means
  198. -all the source code for all modules it contains; but, as a special
  199. -exception, it need not include source code for modules which are standard
  200. -libraries that accompany the operating system on which the executable
  201. -file runs, or for standard header files or definitions files that
  202. -accompany that operating system.
  203. -
  204. -  4. You may not copy, modify, sublicense, distribute or transfer the
  205. -Program except as expressly provided under this General Public License.
  206. -Any attempt otherwise to copy, modify, sublicense, distribute or transfer
  207. -the Program is void, and will automatically terminate your rights to use
  208. -the Program under this License.  However, parties who have received
  209. -copies, or rights to use copies, from you under this General Public
  210. -License will not have their licenses terminated so long as such parties
  211. -remain in full compliance.
  212. -
  213. -  5. By copying, distributing or modifying the Program (or any work based
  214. -on the Program) you indicate your acceptance of this license to do so,
  215. -and all its terms and conditions.
  216. -
  217. -  6. Each time you redistribute the Program (or any work based on the
  218. -Program), the recipient automatically receives a license from the original
  219. -licensor to copy, distribute or modify the Program subject to these
  220. -terms and conditions.  You may not impose any further restrictions on the
  221. -recipients' exercise of the rights granted herein.
  222. -
  223. -  7. The Free Software Foundation may publish revised and/or new versions
  224. -of the General Public License from time to time.  Such new versions will
  225. -be similar in spirit to the present version, but may differ in detail to
  226. -address new problems or concerns.
  227. -
  228. -Each version is given a distinguishing version number.  If the Program
  229. -specifies a version number of the license which applies to it and "any
  230. -later version", you have the option of following the terms and conditions
  231. -either of that version or of any later version published by the Free
  232. -Software Foundation.  If the Program does not specify a version number of
  233. -the license, you may choose any version ever published by the Free Software
  234. -Foundation.
  235. -
  236. -  8. If you wish to incorporate parts of the Program into other free
  237. -programs whose distribution conditions are different, write to the author
  238. -to ask for permission.  For software which is copyrighted by the Free
  239. -Software Foundation, write to the Free Software Foundation; we sometimes
  240. -make exceptions for this.  Our decision will be guided by the two goals
  241. -of preserving the free status of all derivatives of our free software and
  242. -of promoting the sharing and reuse of software generally.
  243. -
  244. -                NO WARRANTY
  245. -
  246. -  9. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
  247. -FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
  248. -OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
  249. -PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
  250. -OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  251. -MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
  252. -TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
  253. -PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
  254. -REPAIR OR CORRECTION.
  255. -
  256. -  10. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
  257. -WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
  258. -REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
  259. -INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
  260. -OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
  261. -TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
  262. -YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
  263. -PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
  264. -POSSIBILITY OF SUCH DAMAGES.
  265. -
  266. -             END OF TERMS AND CONDITIONS
  267. -
  268. -    Appendix: How to Apply These Terms to Your New Programs
  269. -
  270. -  If you develop a new program, and you want it to be of the greatest
  271. -possible use to humanity, the best way to achieve this is to make it
  272. -free software which everyone can redistribute and change under these
  273. -terms.
  274. -
  275. -  To do so, attach the following notices to the program.  It is safest to
  276. -attach them to the start of each source file to most effectively convey
  277. -the exclusion of warranty; and each file should have at least the
  278. -"copyright" line and a pointer to where the full notice is found.
  279. -
  280. -    <one line to give the program's name and a brief idea of what it does.>
  281. -    Copyright (C) 19yy  <name of author>
  282. -
  283. -    This program is free software; you can redistribute it and/or modify
  284. -    it under the terms of the GNU General Public License as published by
  285. -    the Free Software Foundation; either version 1, or (at your option)
  286. -    any later version.
  287. -
  288. -    This program is distributed in the hope that it will be useful,
  289. -    but WITHOUT ANY WARRANTY; without even the implied warranty of
  290. -    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  291. -    GNU General Public License for more details.
  292. -
  293. -    You should have received a copy of the GNU General Public License
  294. -    along with this program; if not, write to the Free Software
  295. -    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  296. -
  297. -Also add information on how to contact you by electronic and paper mail.
  298. -
  299. -If the program is interactive, make it output a short notice like this
  300. -when it starts in an interactive mode:
  301. -
  302. -    Gnomovision version 69, Copyright (C) 19xx name of author
  303. -    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
  304. -    This is free software, and you are welcome to redistribute it
  305. -    under certain conditions; type `show c' for details.
  306. -
  307. -The hypothetical commands `show w' and `show c' should show the
  308. -appropriate parts of the General Public License.  Of course, the
  309. -commands you use may be called something other than `show w' and `show
  310. -c'; they could even be mouse-clicks or menu items--whatever suits your
  311. -program.
  312. -
  313. -You should also get your employer (if you work as a programmer) or your
  314. -school, if any, to sign a "copyright disclaimer" for the program, if
  315. -necessary.  Here a sample; alter the names:
  316. -
  317. -  Yoyodyne, Inc., hereby disclaims all copyright interest in the
  318. -  program `Gnomovision' (a program to direct compilers to make passes
  319. -  at assemblers) written by James Hacker.
  320. -
  321. -  <signature of Ty Coon>, 1 April 1989
  322. -  Ty Coon, President of Vice
  323. -
  324. -That's all there is to it!
  325. End of COPYING
  326. echo README 1>&2
  327. sed 's/^-//' >README <<'End of README'
  328. -Read "INSTALL" for information on getting this shell running.
  329. -
  330. -zsh is free software.  See the file COPYING for copying permission.
  331. -
  332. -    This shell was "developed" by me, Paul Falstad, a sophomore at Princeton
  333. -University.  I borrowed _heavily_ from ksh, bash, tcsh, sh, and csh, as
  334. -well as adding a few (IMHO) useful features.  zsh was at first intended
  335. -to be a subset of csh for the Commodore Amiga, but the project sort of
  336. -ballooned; now I want it to be a cross between ksh and tcsh.  It should
  337. -be a powerful "command and programming language" that is well-designed
  338. -and logical (like ksh), but it should also be built for humans (like
  339. -tcsh), with all the neat features like spell checking, login/logout
  340. -watching and termcap support that are probably too weird to make it into
  341. -an AT&T product.  This version of the shell has fallen far short of that
  342. -goal; I just wanted to release _something_, because this is obviously
  343. -going to be an extremely long project.
  344. -
  345. -    This is version v1.0 of zsh.  I incorporated the GNU "readline"
  346. -editor, written by Brian Fox, into the shell, just to make my life
  347. -temporarily easier.  I made lots of changes to it, so if there are any
  348. -bugs in the editor, they're probably my fault.  readline will not be a
  349. -part of the next version of zsh.
  350. -
  351. -    If anyone has any questions, suggestions, comments, bugs, flames, or
  352. -any other mail of any kind, send it to pfalstad@phoenix.princeton.edu.
  353. -Thanks to Kartik Subbarao, Daniel Bernstein ("Yay.  So sell it."),
  354. -Kennedy Lemke, Chet Ramey (for the bash man page, and for putting features
  355. -in the man page that weren't in our version of bash), Brian Fox (for
  356. -helping me put off a lot of work, and for writing bash), Richard M. Stallman
  357. -(for gdb and gcc; not for emacs though ;-) ) and many others.
  358. -
  359. End of README
  360. echo INSTALL 1>&2
  361. sed 's/^-//' >INSTALL <<'End of INSTALL'
  362. -I was not able to port zsh to many platforms because I don't have
  363. -accounts on many platforms.  It shouldn't be too much trouble if you
  364. -manage to decipher my code.  I have tested zsh on SunOS 4.1, SunOS 4.0.3,
  365. -4.3BSD UNIX.
  366. -
  367. -You need to edit the files config.h, config.local.h, makefile, and
  368. -readline/Makefile.  The comments should make clear what you have to do.
  369. -Note that the files in the readline directory have been greatly
  370. -modified, so you can't just copy over your changes from bash if you
  371. -have it installed.
  372. -
  373. -Once you have done that, you might be able to do a make without any
  374. -problem.  If you have trouble, and can't get zsh to work, send me mail,
  375. -and I'll try to help.  If anyone manages to get zsh ported to some other
  376. -platform, please mail me so I can tell other people about your changes
  377. -and incorporate them into the next version.
  378. -
  379. End of INSTALL
  380. echo makefile 1>&2
  381. sed 's/^-//' >makefile <<'End of makefile'
  382. -#! /bin/make -f
  383. -#
  384. -#    makefile for zsh
  385. -#
  386. -#    This file is part of zsh, the Z shell.
  387. -#
  388. -#  zsh is free software; no one can prevent you from reading the source
  389. -#  code, or giving it to someone else.
  390. -#  This file is copyrighted under the GNU General Public License, which
  391. -#  can be found in the file called COPYING.
  392. -#
  393. -#  Copyright (C) 1990 Paul Falstad
  394. -#
  395. -#  zsh is distributed in the hope that it will be useful, but
  396. -#  WITHOUT ANY WARRANTY.  No author or distributor accepts
  397. -#  responsibility to anyone for the consequences of using it or for
  398. -#  whether it serves any particular purpose or works at all, unless he
  399. -#  says so in writing.  Refer to the GNU General Public License
  400. -#  for full details.
  401. -#
  402. -#  Everyone is granted permission to copy, modify and redistribute
  403. -#  zsh, but only under the conditions described in the GNU General Public
  404. -#  License.   A copy of this license is supposed to have been given to you
  405. -#  along with zsh so you can know your rights and responsibilities.
  406. -#  It should be in a file named COPYING.
  407. -#
  408. -#  Among other things, the copyright notice and this notice must be
  409. -#  preserved on all copies.
  410. -#
  411. -OBJS=hist.o glob.o table.o subst.o builtin.o loop.o vars.o\
  412. -parse.o lex.o init.o jobs.o exec.o zhistory.o utils.o math.o test.o
  413. -READLINE=readline/funmap.o readline/keymaps.o readline/readline.o
  414. -BINDIR=/usr/local/bin
  415. -MANDIR=/usr/local/man/man1
  416. -CFLAGS=-O -fstrength-reduce -fomit-frame-pointer -finline-functions \
  417. -    -fsigned-char -fdelayed-branch
  418. -CC=gcc
  419. -ZSHPATH=zsh
  420. -THINGS_TO_TAR=zsh.1 COPYING README INSTALL makefile sample.zshrc \
  421. -sample.zlogin sample.zshrc.mine sample.zlogin.mine \
  422. -alias.pro builtin.c builtin.pro config.h config.local.h \
  423. -exec.c exec.pro funcs.h glob.c glob.pro hist.c hist.pro init.c \
  424. -init.pro jobs.c jobs.pro lex.c lex.pro loop.c loop.pro math.c \
  425. -math.pro parse.c parse.pro subst.c subst.pro table.c \
  426. -table.pro test.c test.pro utils.c utils.pro vars.c vars.pro zhistory.c \
  427. -readline/chardefs.h readline/emacs_keymap.c \
  428. -readline/funmap.c readline/history.h readline/keymaps.c \
  429. -readline/keymaps.h readline/readline.c readline/readline.h \
  430. -readline/vi_keymap.c readline/vi_mode.c readline/Makefile \
  431. -zsh.h proto
  432. -
  433. -.c.o:
  434. -    $(CC) $(CFLAGS) -c -o $*.o $<
  435. -
  436. -$(ZSHPATH): $(OBJS) $(READLINE)
  437. -    $(CC) -o $(ZSHPATH) $(OBJS) $(READLINE) -s -ltermcap
  438. -
  439. -$(OBJS): config.h
  440. -
  441. -zhistory.o: readline/history.h
  442. -
  443. -$(READLINE):
  444. -    cd readline;make
  445. -
  446. -clean:
  447. -    rm -f *.o zsh core readline/*.o
  448. -
  449. -install: zsh
  450. -    install -s -m 755 zsh $(BINDIR)
  451. -    install -m 444 zsh.1 $(MANDIR)
  452. -
  453. -tar: zsh.tar.Z
  454. -
  455. -zsh.tar: $(THINGS_TO_TAR)
  456. -    tar -cf zsh.tar $(THINGS_TO_TAR)
  457. -
  458. -zsh.tar.Z: zsh.tar
  459. -    compress -f zsh.tar
  460. -
  461. -shar: $(THINGS_TO_TAR)
  462. -    bundle $(THINGS_TO_TAR) > zsh.shar
  463. -
  464. End of makefile
  465. echo sample.zshrc 1>&2
  466. sed 's/^-//' >sample.zshrc <<'End of sample.zshrc'
  467. -setenv() { export $1=$2 }
  468. -
  469. -umask 022
  470. -
  471. -PATH=$HOME/scr:$HOME/bin/$HOSTTYPE:/usr/local/bin:/usr/ucb:\
  472. -/usr/bin:/bin:/usr/local/bin/X11:/usr/etc:/etc
  473. -CDPATH=$HOME:/usr:/
  474. -export MANPATH=/usr/man:/usr/local/man
  475. -
  476. -HISTSIZE=50
  477. -setopt ignoreeof
  478. -
  479. -PROMPT='%n@%m [%h] %# '
  480. -
  481. -alias a alias
  482. -
  483. -a vi.     'vi ~/.cshrc'
  484. -a s.     '. ~/.cshrc'
  485. -a more. 'more ~/.cshrc'
  486. -
  487. -chpwd() { pwd; ls -F }
  488. -lsl() { ls -algF $* | more }
  489. -
  490. -a back cd -
  491. -a h history
  492. -a cls     /usr/ucb/clear
  493. -a type     cat
  494. -a copy     cp
  495. -a move     mv
  496. -a del     rm
  497. -a lo     exit
  498. -a lsa     'ls -aF'
  499. -a dir   'ls -l'
  500. -a ll    'ls -F'
  501. -
  502. End of sample.zshrc
  503. echo sample.zlogin 1>&2
  504. sed 's/^-//' >sample.zlogin <<'End of sample.zlogin'
  505. -eval $(tset -Q -s '?xterm')
  506. -stty dec crt kill ^U dsusp ^X
  507. -msgs -q
  508. -date
  509. -biff y
  510. -
  511. -WATCH=$(echo $(<~/.friends) | tr ' ' :)
  512. -MAIL=/usr/spool/mail/$USERNAME
  513. -export DISPLAY=$(hostname):0.0
  514. -
  515. -limit coredumpsize 0
  516. -/usr/games/fortune
  517. -uptime
  518. End of sample.zlogin
  519. echo sample.zshrc.mine 1>&2
  520. sed 's/^-//' >sample.zshrc.mine <<'End of sample.zshrc.mine'
  521. -#
  522. -# my rc file for zsh
  523. -#
  524. -PATH=~/scr:~/bin/$HOSTTYPE:/usr/princeton/bin:/usr/ucb:/usr/bin:/bin:\
  525. -/u/maruchck/scr:/u/cs320/bin:/u/maruchck/bin:\
  526. -/usr/princeton/bin/X11:/usr/etc:/etc
  527. -CDPATH=~:~/src/cs320:~/src
  528. -umask 022
  529. -alias a alias
  530. -a pd pushd
  531. -a pop popd
  532. -limit core 0
  533. -a c cp
  534. -a grep egrep
  535. -a ps sps
  536. -a j jobs
  537. -a hide 'ARGV0=$(randline ~/pub/strings) '
  538. -a rn hide /usr/princeton/bin/rn.4.1
  539. -a v mv
  540. -a t cat
  541. -a where hostname'; echo >/dev/null'
  542. -a l ls -AF
  543. -a m make
  544. -a mm hide less 
  545. -a talk hide talk
  546. -a h history
  547. -a a.out ./a.out
  548. -a more less
  549. -a strings strings -
  550. -a lock lock -p
  551. -a nw 'l -ltr | tail'
  552. -a -a 'M' \| less
  553. -a -a 'GF' \| fgrep -f ~/.friends
  554. -a -a 'sub' subbarao
  555. -a -a 'mjm' maruchck
  556. -a -a 'paswd' '<(ypcat passwd)'
  557. -a -a 'cex' '/u/pup/centrex'
  558. -a rable ls -AFltrd '*(R)'
  559. -a nrable ls -AFltrd '*(^R)'
  560. -a ';' vi
  561. -a 0 vi
  562. -a '<<' more
  563. -mostglob egrep sed
  564. -noglob find
  565. -PROMPT='Z %h %M:%~ '
  566. -FCEDIT=vi
  567. -LESSTERM=$(echo $TERMCAP | sed s/:ti=[^:]*:te=[^:]*:/:ti=:te=:/)
  568. -a less TERMCAP='"$LESSTERM"' /usr/princeton/bin/less
  569. -zsh=~/src/zsh
  570. -a k9 kill -9
  571. -cx() { chmod +x $* }
  572. -acx() { chmod 755 $* }
  573. -mere() { nroff -man -Tman $1 | less -s }
  574. -
  575. -[ `tty` = /dev/console ] || {
  576. -    PERIOD=40
  577. -    periodic() {
  578. -        echo checking news...  # check news every 40 minutes
  579. -        rn -c
  580. -    }
  581. -}
  582. -
  583. -randline() {
  584. -    integer z;
  585. -    z=$(wc -l <$1)
  586. -    sed -n $[RANDOM%z+1]p $1
  587. -    unset z
  588. -}
  589. -
  590. -eval "proto () { $(grep -v '^#' ~/scr/proto) }"
  591. -
  592. -snoop() {
  593. -    (( $# )) || set `users`
  594. -    fgrep -i -f </u/pup/st{udents,aff} <(
  595. -        for i
  596. -        do
  597. -            ypmatch $i passwd
  598. -        done | cut -d: -f5 | cut -d, -f1 |
  599. -            awk '{ printf "%s,%s\n",$NF,substr($1,1,1) }') 
  600. -}
  601. -
  602. -MAIL=/usr/spool/mail/pfalstad
  603. -MAILCHECK=30
  604. -HISTSIZE=600
  605. -setopt notify globdots autolist correct dextract pushdtohome cdablevars
  606. -unsetopt bgnice
  607. -WATCH=$(echo $(<~/.friends) | tr ' ' :)
  608. -WATCHFMT='%n %a %l from %m at %t.'
  609. -LOGCHECK=0
  610. -
  611. -[ -t ] && {
  612. -    (cd ; hostname >! .where)
  613. -}
  614. -
  615. -export MANPATH=/usr/man:/usr/princeton/man:/u/cad/man
  616. -
  617. -setenv() { export $1=$2 }
  618. -
  619. End of sample.zshrc.mine
  620. echo sample.zlogin.mine 1>&2
  621. sed 's/^-//' >sample.zlogin.mine <<'End of sample.zlogin.mine'
  622. -#
  623. -# my login file for zsh
  624. -#
  625. -cd
  626. -ls -l /etc/motd
  627. -stty dec new cr0
  628. -eval $(tset -s -Q '?xterm')
  629. -stty -tabs
  630. -umask 022
  631. -export MAIL=/usr/spool/mail/$USER
  632. -MAILCHECK=60
  633. -# biff y
  634. -msgs -fp
  635. -uptime
  636. -/usr/games/fortune
  637. -log
  638. -echo Thought for the day: $(randline ~/pub/commands)
  639. -from 2>/dev/null
  640. -cat .todo
  641. -cat '. '
  642. -echo last login $(date) on $(hostname) >! .' '
  643. End of sample.zlogin.mine
  644. echo alias.pro 1>&2
  645. sed 's/^-//' >alias.pro <<'End of alias.pro'
  646. -char *dynread(char stop);
  647. -int filesub(void **namptr);
  648. -char *gethome(char *user,int len);
  649. -char *completehome(char *user,int len);
  650. -char *getsparmval(char *s,int len);
  651. -void setparml(char *s,int len,char *v);
  652. -void parmsub(table list);
  653. -void parminsall(table l,Node *nn,char **aptr,char **bptr);
  654. -void comminsall(table l,Node *nn,char **aptr,char **bptr);
  655. -void parmsuber(void **aptr,char **bptr);
  656. -void modify(void **str,char **ptr);
  657. -void tabmodify(table tab,char **ptr);
  658. -int napply(int (*func)(void **),table list);
  659. -int napplysplit(int (*func)(void **),table list);
  660. -void split(Node node,table list);
  661. -char *dstackent(int val);
  662. -void doshfuncs(comm comm);
  663. -void execshfunc(comm comm);
  664. -struct anode *mkanode(char *txt,int cmflag);
  665. -char *docompsubs(char *str,int *i);
  666. -void docmdsubs(char **str);
  667. -void dovarsubs(char **str);
  668. End of alias.pro
  669. echo builtin.c 1>&2
  670. sed 's/^-//' >builtin.c <<'End of builtin.c'
  671. -/*
  672. -
  673. -    builtin.c - handles builtin commands
  674. -
  675. -    This file is part of zsh, the Z shell.
  676. -
  677. -   zsh is free software; no one can prevent you from reading the source
  678. -   code, or giving it to someone else.
  679. -   This file is copyrighted under the GNU General Public License, which
  680. -   can be found in the file called COPYING.
  681. -
  682. -   Copyright (C) 1990 Paul Falstad
  683. -
  684. -   zsh is distributed in the hope that it will be useful, but
  685. -   WITHOUT ANY WARRANTY.  No author or distributor accepts
  686. -   responsibility to anyone for the consequences of using it or for
  687. -   whether it serves any particular purpose or works at all, unless he
  688. -   says so in writing.  Refer to the GNU General Public License
  689. -   for full details.
  690. -
  691. -   Everyone is granted permission to copy, modify and redistribute
  692. -   zsh, but only under the conditions described in the GNU General Public
  693. -   License.   A copy of this license is supposed to have been given to you
  694. -   along with zsh so you can know your rights and responsibilities.
  695. -   It should be in a file named COPYING.
  696. -
  697. -   Among other things, the copyright notice and this notice must be
  698. -   preserved on all copies.
  699. -
  700. -*/
  701. -
  702. -#include "zsh.h"
  703. -#include "funcs.h"
  704. -#include <sys/signal.h>
  705. -#include <sys/fcntl.h>
  706. -#include <sys/errno.h>
  707. -#include <utmp.h>
  708. -#define MAXPATHLEN 1024
  709. -
  710. -int echo(comm comm)
  711. -{
  712. -table list;
  713. -char *str;
  714. -int nline = 1;
  715. - 
  716. -    list = comm->args;
  717. -    if (full(list))
  718. -        if (!strcmp("--",list->first->dat))
  719. -            free(getnode(list));
  720. -        else if (!strcmp("-n",list->first->dat))
  721. -            {
  722. -            free(getnode(list));
  723. -            nline = 0;
  724. -            }
  725. -    if (str = getnode(list))
  726. -        {
  727. -        printf("%s",str);
  728. -        free(str);
  729. -        while (str = getnode(list))
  730. -            {
  731. -            printf(" %s",str);
  732. -            free(str);
  733. -            }
  734. -        }
  735. -    if (nline)
  736. -        printf("\n");
  737. -    return 0;
  738. -}
  739. -
  740. -/* print the directory stack */
  741. -
  742. -void pdstack(void)
  743. -{
  744. -Node node;
  745. -
  746. -    printdir(cwd);
  747. -    for (node = dirstack->first; node; node = node->next)
  748. -        {
  749. -        putchar(' ');
  750. -        printdir(node->dat);
  751. -        }
  752. -    putchar('\n');
  753. -}
  754. -
  755. -/* exit */
  756. -
  757. -int zexit(comm comm)
  758. -{
  759. -    if (interact)
  760. -        if (!stopmsg)
  761. -            {
  762. -            checkjobs();
  763. -            if (stopmsg)
  764. -                {
  765. -                stopmsg = 2;
  766. -                return 1;
  767. -                }
  768. -            }
  769. -        else
  770. -            killrunjobs();
  771. -    if (islogin && unset(NORCS))
  772. -        sourcehome(".zlogout");
  773. -    if (comm && full(comm->args))
  774. -        lastval = atoi(getnode(comm->args));
  775. -    if (sigtrapped[SIGEXIT])
  776. -        dotrap(SIGEXIT);
  777. -    exit(lastval); return 0;
  778. -}
  779. -
  780. -/* return */
  781. -
  782. -int zreturn(comm comm)
  783. -{
  784. -    if (full(comm->args))
  785. -        lastval = atoi(getnode(comm->args));
  786. -    retflag = 1;
  787. -    return lastval;
  788. -}
  789. -
  790. -int logout(comm comm)
  791. -{
  792. -    if (!islogin)
  793. -        {
  794. -        zerrnam("logout","not login shell");
  795. -        return 1;
  796. -        }
  797. -    return zexit(comm);
  798. -}
  799. -
  800. -int Unset(comm comm)
  801. -{
  802. -table list = comm->args;
  803. -char *s;
  804. - 
  805. -    while (full(list))
  806. -        {
  807. -        s = getnode(list);
  808. -        unsetparm(s);
  809. -        free(s);
  810. -        }
  811. -    return 0;
  812. -}
  813. -
  814. -int set(comm comm)
  815. -{
  816. -char *s,*t;
  817. -
  818. -    if (!full(comm->args))
  819. -        {
  820. -        char **p = environ;
  821. -
  822. -        while (*p)
  823. -            puts(*p++);
  824. -        listhtable(parmhtab,(void (*)(char *,char *)) pparm);
  825. -        return 0;
  826. -        }
  827. -    s = getnode(comm->args);
  828. -    t = getnode(pparms);
  829. -    freetable(pparms,freestr);
  830. -    pparms = newtable();
  831. -    addnode(pparms,t);
  832. -    while (s)
  833. -        {
  834. -        addnode(pparms,s);
  835. -        s = getnode(comm->args);
  836. -        }
  837. -    return 0;
  838. -}
  839. -
  840. -struct option {
  841. -    char *name;
  842. -    char id;
  843. -    };
  844. -
  845. -static struct option optns[] = {
  846. -    "clobber",'1',
  847. -    "nobadpattern",'2',
  848. -    "nonomatch",'3',
  849. -    "globdots",'4',
  850. -    "notify",'5',
  851. -    "allexport",'a',
  852. -    "errexit",'e',
  853. -    "bgnice",'6',
  854. -    "ignoreeof",'7',
  855. -    "keyword",'k',
  856. -    "markdirs",'8',
  857. -    "monitor",'m',
  858. -    "noexec",'n',
  859. -    "noglob",'F',
  860. -    "norcs",'f',
  861. -    "shinstdin",'s',
  862. -    "nounset",'u',
  863. -    "verbose",'v',
  864. -    "xtrace",'x',
  865. -    "interactive",'i',
  866. -    "autolist",'9',
  867. -    "correct",'0',
  868. -    "dextract",'A',
  869. -    "nobeep",'B',
  870. -    "printexitvalue",'C',
  871. -    "pushdtohome",'D',
  872. -    "pushdsilent",'E',
  873. -    "nullglob",'G',
  874. -    "rmstarsilent",'H',
  875. -    "ignorebraces",'I',
  876. -    "cdablevars",'J',
  877. -    "nobanghist",'K',
  878. -    NULL,0
  879. -};
  880. -
  881. -int setopt(comm comm)
  882. -{
  883. -    return csetopt(comm,0);
  884. -}
  885. -
  886. -int unsetopt(comm comm)
  887. -{
  888. -    return csetopt(comm,1);
  889. -}
  890. -
  891. -/* common code for setopt and unsetopt */
  892. -
  893. -int csetopt(comm comm,int isun)
  894. -{
  895. -char *s,*os,*cmd;
  896. -int flag;
  897. -struct option *opp;
  898. -
  899. -    cmd = (isun) ? "unsetopt" : "setopt";
  900. -    if (!full(comm->args))
  901. -        {
  902. -        if (isun)
  903. -            return 0;
  904. -        for (opp = optns; opp->name; opp++)
  905. -            if (opts[opp->id] == OPT_SET)
  906. -                puts(opp->name);
  907. -        return 0;
  908. -        }
  909. -    while ((os = s = getnode(comm->args)) && ((flag = *s == '-') || *s == '+'))
  910. -        {
  911. -        while (*++s)
  912. -            if (*s == INTERACTIVE || *s == MONITOR)
  913. -                zerrnam(cmd,"can't change that option");
  914. -            else if (opts[*s & 0x7f] != OPT_INVALID)
  915. -                opts[*s & 0x7f] = (flag^isun) ? OPT_SET : OPT_UNSET;
  916. -            else
  917. -                zerrnam(cmd,"illegal option: %c",*s);
  918. -        free(os);
  919. -        }
  920. -    if (!s)
  921. -        return 0;
  922. -    while (s)
  923. -        {
  924. -        for (opp = optns; opp->name; opp++)
  925. -            if (!strcmp(opp->name,s))
  926. -                break;
  927. -        if (opp->name)
  928. -            {
  929. -            if (opp->id == INTERACTIVE || opp->id == MONITOR)
  930. -                zerrnam(cmd,"can't change that option");
  931. -            else
  932. -                opts[opp->id] = (isun) ? OPT_UNSET : OPT_SET;
  933. -            }
  934. -        else
  935. -            {
  936. -            zerrnam(cmd,"no such option: %s",s);
  937. -            free(s);
  938. -            return 1;
  939. -            }
  940. -        free(s);
  941. -        s = getnode(comm->args);
  942. -        }
  943. -    return 0;
  944. -}
  945. -
  946. -/* print a positional parameter */
  947. -
  948. -void pparm(char *s,struct pmnode *t)
  949. -{
  950. -    if (s && t)
  951. -        if (t->isint)
  952. -            printf("%s=%ld\n",s,t->u.val);
  953. -        else
  954. -            {
  955. -            printf("%s=",s);
  956. -            niceprint(t->u.str);
  957. -            putchar('\n');
  958. -            }
  959. -}
  960. -
  961. -int dirs(comm comm)
  962. -{
  963. -    if (comm->args->first)
  964. -        {
  965. -        if (dirstack)
  966. -            freetable(dirstack,freestr);
  967. -        dirstack = comm->args;
  968. -        comm->args = NULL;
  969. -        }
  970. -    else
  971. -        pdstack();
  972. -    return 0;
  973. -}
  974. -
  975. -/* call func once for each entry in a hash table */
  976. -
  977. -void listhtable(htable ht,void (*func)(char *,char *))
  978. -{
  979. -int t0;
  980. -struct hnode *hn;
  981. -
  982. -    for (t0 = ht->hsize-1; t0 >= 0; t0--)
  983. -        for (hn = ht->nodes[t0]; hn; hn = hn->hchain)
  984. -            func(hn->nam,hn->dat);
  985. -}
  986. -
  987. -/* print an alias (used with listhtable) */
  988. -
  989. -void palias(char *s,struct anode *t)
  990. -{
  991. -    if (t && t->cmd >= 0)
  992. -        {
  993. -        printf((t->cmd) ? "alias %-13s " : "alias -a %-10s ",s);
  994. -        niceprint(t->text);
  995. -        putchar('\n');
  996. -        }
  997. -}
  998. -
  999. -/* print a shell function (used with listhtable) */
  1000. -
  1001. -void pshfunc(char *s,list l)
  1002. -{
  1003. -char *t;
  1004. -
  1005. -    t = getltext(l);
  1006. -    untokenize(t);
  1007. -    printf("%s() {\n%s\n}\n",s,t);
  1008. -    free(t);
  1009. -}
  1010. -
  1011. -void niceprint(char *s)
  1012. -{
  1013. -    niceprintf(s,stdout);
  1014. -}
  1015. -
  1016. -void niceprintf(char *s,FILE *f)
  1017. -{
  1018. -    for (; *s; s++)
  1019. -        {
  1020. -        if (*s >= 32 && *s <= 126)
  1021. -            fputc(*s,f);
  1022. -        else if (*s == '\n')
  1023. -            {
  1024. -            putc('\\',f);
  1025. -            putc('n',f);
  1026. -            }
  1027. -        else
  1028. -            {
  1029. -            putc('^',f);
  1030. -            fputc(*s | 0x40,f);
  1031. -            }
  1032. -        }
  1033. -}
  1034. -
  1035. -/* build a command line from a linked list */
  1036. -
  1037. -char *buildline(table t)
  1038. -{
  1039. -char *str = strdup(""),*s,*os;
  1040. -
  1041. -    while (s = getnode(t))
  1042. -        {
  1043. -        os = str;
  1044. -        str = (*os) ? tricat(os," ",s) : strdup(s);
  1045. -        free(s);
  1046. -        free(os);
  1047. -        }
  1048. -    return str;
  1049. -}
  1050. -
  1051. -int Alias(comm comm)
  1052. -{
  1053. -char *s1,*s2;
  1054. -int anyflag = 0;
  1055. -
  1056. -    if (!(s1 = getnode(comm->args)))
  1057. -        {
  1058. -        listhtable(alhtab,(void (*)(char *,char *)) palias);
  1059. -        return 0;
  1060. -        }
  1061. -    if (!strcmp(s1,"-a"))
  1062. -        {
  1063. -        anyflag = 1;
  1064. -        free(s1);
  1065. -        if (!(s1 = getnode(comm->args)))
  1066. -            {
  1067. -            zerrnam("alias","alias -a requires 2 arguments");
  1068. -            return 1;
  1069. -            }
  1070. -        }
  1071. -    if (!comm->args->first)
  1072. -        {
  1073. -        palias(s1,gethnode(s1,alhtab));
  1074. -        free(s1);
  1075. -        return 0;
  1076. -        }
  1077. -    s2 = buildline(comm->args);
  1078. -    addhnode(s1,mkanode(s2,!anyflag),alhtab,freeanode);
  1079. -    return 0;
  1080. -}
  1081. -
  1082. -int cd(comm comm)
  1083. -{
  1084. -    if (!full(comm->args))
  1085. -        return chcd("cd",strdup(getparm("HOME")));
  1086. -    if (comm->args->first->next)
  1087. -        {
  1088. -        char *s,*t,*u,*v;
  1089. -        int sl,tl;
  1090. -
  1091. -        if (comm->args->first->next->next)
  1092. -            {
  1093. -            zerrnam("cd","too many arguments");
  1094. -            return 1;
  1095. -            }
  1096. -        s = getnode(comm->args);
  1097. -        t = getnode(comm->args);
  1098. -        if (!(u = (char *) strstr(cwd,s)))
  1099. -            {
  1100. -            zerrnam("cd","string not in pwd: %s",s);
  1101. -            return 1;
  1102. -            }
  1103. -        sl = strlen(s);
  1104. -        tl = strlen(t);
  1105. -        v = zalloc((u-cwd)+tl+strlen(u+sl)+1);
  1106. -        strncpy(v,cwd,u-cwd);
  1107. -        strcpy(v+(u-cwd),t);
  1108. -        strcat(v,u+sl);
  1109. -        free(s);
  1110. -        free(t);
  1111. -        return chcd("cd",v);
  1112. -        }
  1113. -    return chcd("cd",getnode(comm->args));
  1114. -}
  1115. -
  1116. -int dot(comm comm)
  1117. -{
  1118. -char *s;
  1119. -
  1120. -    if (!full(comm->args))
  1121. -        return 1;
  1122. -    s = getnode(comm->args);
  1123. -    if (source(s))
  1124. -        {
  1125. -        zerrnam(".","%e: %s",errno,s);
  1126. -        free(s);
  1127. -        return 1;
  1128. -        }
  1129. -    free(s);
  1130. -    return 0;
  1131. -}
  1132. -
  1133. -int Umask(comm comm)
  1134. -{
  1135. -char *s,*t;
  1136. -int t0;
  1137. -
  1138. -    if (!full(comm->args))
  1139. -        {
  1140. -        t0 = umask(0);
  1141. -        umask(t0);
  1142. -        printf("%03o\n",t0);
  1143. -        return 0;
  1144. -        }
  1145. -    s = getnode(comm->args);
  1146. -    t0 = strtol(s,&t,8);
  1147. -    if (*t)
  1148. -        {
  1149. -        zerrnam("umask","bad umask");
  1150. -        free(s);
  1151. -        return 1;
  1152. -        }
  1153. -    umask(t0);
  1154. -    free(s);
  1155. -    return 0;
  1156. -}
  1157. -
  1158. -int which(comm comm)
  1159. -{
  1160. -struct chnode *chn;
  1161. -struct anode *a;
  1162. -char *str = getnode(comm->args),*cnam;
  1163. -
  1164. -    if (!str)
  1165. -        {
  1166. -        zerrnam("which","argument required");
  1167. -        return 1;
  1168. -        }
  1169. -    if ((a = gethnode(str,alhtab)) && a->cmd)
  1170. -        {
  1171. -        if (a->cmd < 0)
  1172. -            printf("%s: shell reserved word\n",str);
  1173. -        else
  1174. -            printf("%s: aliased to %s\n",str,a->text);
  1175. -        free(str);
  1176. -        return 0;
  1177. -        }
  1178. -    if (gethnode(str,shfunchtab))
  1179. -        printf("%s: shell function\n",str);
  1180. -    else if (chn = gethnode(str,chtab))
  1181. -        {
  1182. -        if (chn->type != BUILTIN)
  1183. -            puts(chn->u.nam);
  1184. -        else
  1185. -            printf("%s: shell built-in command\n",str);
  1186. -        }
  1187. -    else if (!(cnam = findcmd(str)))
  1188. -        {
  1189. -        zerr("command not found: %s",str);
  1190. -        free(str);
  1191. -        return 1;
  1192. -        }
  1193. -    else
  1194. -        puts(cnam);
  1195. -    free(str);
  1196. -    return 0;
  1197. -}
  1198. - 
  1199. -int popd(comm comm)
  1200. -{
  1201. -int val = 0;
  1202. -char *s;
  1203. -Node node;
  1204. -
  1205. -    if (comm->args->first && *(s = comm->args->first->dat) == '+')
  1206. -        val = atoi(s+1);
  1207. -    if (val--)
  1208. -        {
  1209. -        if (val < 0)
  1210. -            node = dirstack->last;
  1211. -        else
  1212. -            for (node = dirstack->first; val && node; node = node->next,
  1213. -                val--);
  1214. -        free(remnode(dirstack,node));
  1215. -        if (unset(PUSHDSILENT))
  1216. -            pdstack();
  1217. -        return 0;
  1218. -        }
  1219. -    else
  1220. -        {
  1221. -        if (!full(dirstack))
  1222. -            {
  1223. -            zerrnam("popd","dir stack empty");
  1224. -            return 1;
  1225. -            }
  1226. -        val = chcd("popd",getnode(dirstack));
  1227. -        if (unset(PUSHDSILENT))
  1228. -            pdstack();
  1229. -        return val;
  1230. -        }
  1231. -}
  1232. - 
  1233. -int pushd(comm comm)
  1234. -{
  1235. -char *s;
  1236. -int num;
  1237. -
  1238. -    if (comm->args->first)
  1239. -        {
  1240. -        s = getnode(comm->args);
  1241. -        
  1242. -        if (*s == '+')
  1243. -            {
  1244. -            if (!(num = atoi(s+1)))
  1245. -                {
  1246. -                free(s);
  1247. -                return 0;
  1248. -                }
  1249. -            free(s);
  1250. -            if (isset(DEXTRACT))
  1251. -                {
  1252. -                Node n = dirstack->first;
  1253. -
  1254. -                insnode(dirstack,(Node) dirstack,strdup(cwd));
  1255. -                while (--num && n)
  1256. -                    n = n->next;
  1257. -                if (!n)
  1258. -                    {
  1259. -                    zerrnam("pushd","not that many dir stack entries");
  1260. -                    return 1;
  1261. -                    }
  1262. -                insnode(dirstack,(Node) dirstack,remnode(dirstack,n));
  1263. -                }
  1264. -            else
  1265. -                {
  1266. -                addnode(dirstack,strdup(cwd));
  1267. -                while(--num)
  1268. -                    addnode(dirstack,getnode(dirstack));
  1269. -                }
  1270. -            num = chcd("pushd",getnode(dirstack));
  1271. -            if (unset(PUSHDSILENT))
  1272. -                pdstack();
  1273. -            return num;
  1274. -            }
  1275. -        pushnode(dirstack,strdup(cwd));
  1276. -        num = chcd("pushd",s);
  1277. -        if (num)
  1278. -            free(getnode(dirstack));
  1279. -        else if (unset(PUSHDSILENT))
  1280. -            pdstack();
  1281. -        return num;
  1282. -        }
  1283. -    else
  1284. -        {
  1285. -        char *s;
  1286. -        
  1287. -        if (isset(PUSHDTOHOME))
  1288. -            s = strdup(getparm("HOME"));
  1289. -        else
  1290. -            s = getnode(dirstack);
  1291. -        if (!s)
  1292. -            {
  1293. -            zerrnam("pushd","dir stack empty");
  1294. -            return 1;
  1295. -            }
  1296. -        pushnode(dirstack,strdup(cwd));
  1297. -        num = chcd("pushd",s);
  1298. -        if (num)
  1299. -            free(getnode(dirstack));
  1300. -        else if (unset(PUSHDSILENT))
  1301. -            pdstack();
  1302. -        return num;
  1303. -        }
  1304. -}
  1305. -
  1306. -/* common code for pushd, popd, cd */
  1307. -
  1308. -int chcd(char *cnam,char *cd)
  1309. -{
  1310. -char *s,*t;
  1311. -char buf[MAXPATHLEN],*new = cd;
  1312. -int t0,val,esav,pnew = 0;
  1313. -
  1314. -    if (cd[0] == '-' && !cd[1])
  1315. -        {
  1316. -        free(cd);
  1317. -        cd = getparm("OLDPWD");
  1318. -        cd = strdup((cd) ? cd : ".");
  1319. -        }
  1320. -    if (*cd == '/')
  1321. -        {
  1322. -        val = chdir(new = cd);
  1323. -        esav = errno;
  1324. -        }
  1325. -    else
  1326. -        for (t0 = 0; t0 != cdpathct; t0++)
  1327. -            {
  1328. -            sprintf(buf,"%s/%s",cdpath[t0],cd);
  1329. -            if ((val = chdir(new = buf)) != -1)
  1330. -                {
  1331. -                if (t0)
  1332. -                    pnew = 1;
  1333. -                break;
  1334. -                }
  1335. -            if (t0 && errno != ENOENT && errno != ENOTDIR)
  1336. -                zerrnam(cnam,"warning: %e: %s",errno,buf);
  1337. -            if (!t0)
  1338. -                esav = errno;
  1339. -            }
  1340. -    if (val == -1 && errno == ENOENT)
  1341. -        {
  1342. -        t = strdup(cd);
  1343. -        if (isset(CDABLEVARS) && (s = getparm(t)) && *s == '/')
  1344. -            if (chdir(new = s) != -1)
  1345. -                {
  1346. -                val = 0;
  1347. -                pnew = 1;
  1348. -                goto goneto;
  1349. -                }
  1350. -        free(t);
  1351. -        zerrnam(cnam,"%e: %s",esav,cd);
  1352. -        free(cd);
  1353. -        return 1;
  1354. -        }
  1355. -goneto:
  1356. -    if (val == -1)
  1357. -        {
  1358. -        zerrnam(cnam,"%e: %s",esav,cd);
  1359. -        free(cd);
  1360. -        return 1;
  1361. -        }
  1362. -    else
  1363. -        {
  1364. -        list l;
  1365. -
  1366. -        if (cwd)
  1367. -            setparm(strdup("OLDPWD"),cwd,0,0);
  1368. -        cwd = findcwd(new);
  1369. -        setparm(strdup("PWD"),strdup(cwd),0,0);
  1370. -        if (pnew)
  1371. -            {
  1372. -            printdir(cwd);
  1373. -            putchar('\n');
  1374. -            }
  1375. -        if (l = gethnode("chpwd",shfunchtab))
  1376. -            newrunlist(l);
  1377. -        }
  1378. -    return 0;
  1379. -}
  1380. - 
  1381. -int shift(comm comm)
  1382. -{
  1383. -char *s;
  1384. -int sh = 1;
  1385. - 
  1386. -    if (comm->args->first && (s = comm->args->first->dat))
  1387. -        sh = atoi(s);
  1388. -    while (sh-- && pparms->first->next)
  1389. -        remnode(pparms,pparms->first->next);
  1390. -    return 0;
  1391. -}
  1392. - 
  1393. -int unhash(comm comm)
  1394. -{
  1395. -char *s;
  1396. - 
  1397. -    if (!(s = getnode(comm->args)))
  1398. -        {
  1399. -        zerrnam("unhash","argument required");
  1400. -        return 1;
  1401. -        }
  1402. -    while (s)
  1403. -        {
  1404. -        if (!gethnode(s,chtab))
  1405. -            {
  1406. -            zerrnam("unhash","not in command table: %s",s);
  1407. -            return 1;
  1408. -            }
  1409. -        free(remhnode(s,chtab));
  1410. -        free(s);
  1411. -        s = getnode(comm->args);
  1412. -        }
  1413. -    return 0;
  1414. -}
  1415. -
  1416. -int rehash(comm comm)
  1417. -{
  1418. -    parsepath();
  1419. -    return 0;
  1420. -}
  1421. -
  1422. -int hash(comm comm)
  1423. -{
  1424. -char *s,*t;
  1425. -struct chnode *chn;
  1426. -
  1427. -    if (!(s = getnode(comm->args)) || !(t = getnode(comm->args)))
  1428. -        {
  1429. -        zerrnam("hash","not enough arguments");
  1430. -        if (s)
  1431. -            free(s);
  1432. -        return 1;
  1433. -        }
  1434. -    chn = alloc(sizeof(struct chnode));
  1435. -    chn->type = EXCMD_PREDOT;
  1436. -    chn->globstat = GLOB;
  1437. -    chn->u.nam = t;
  1438. -    addhnode(s,chn,chtab,freechnode);
  1439. -    return 0;
  1440. -}
  1441. -
  1442. -int Break(comm comm)
  1443. -{
  1444. -char *s;
  1445. - 
  1446. -    if (!loops)
  1447. -        {
  1448. -        zerrnam("break","not in loop");
  1449. -        return 1;
  1450. -        }
  1451. -    if (!(s = getnode(comm->args)))
  1452. -        breaks = 1;
  1453. -    else if (atoi(s))
  1454. -        {
  1455. -        breaks = atoi(s);
  1456. -        free(s);
  1457. -        }
  1458. -    else
  1459. -        {
  1460. -        zerrnam("break","numeric argument required");
  1461. -        free(s);
  1462. -        return 1;
  1463. -        }
  1464. -    return 0;
  1465. -}
  1466. - 
  1467. -int colon(comm comm)
  1468. -{
  1469. -    return 0;
  1470. -}
  1471. - 
  1472. -int Glob(comm comm)
  1473. -{
  1474. -struct chnode *chn;
  1475. -char *s;
  1476. - 
  1477. -    while (s = getnode(comm->args))
  1478. -        {
  1479. -        chn = gethnode(s,chtab);
  1480. -        free(s);
  1481. -        if (chn)
  1482. -            chn->globstat = GLOB;
  1483. -        }
  1484. -    return 0;
  1485. -}
  1486. - 
  1487. -int noglob(comm comm)
  1488. -{
  1489. -struct chnode *chn;
  1490. -char *s;
  1491. - 
  1492. -    while (s = getnode(comm->args))
  1493. -        {
  1494. -        chn = gethnode(s,chtab);
  1495. -        free(s);
  1496. -        if (chn)
  1497. -            chn->globstat = NOGLOB;
  1498. -        }
  1499. -    return 0;
  1500. -}
  1501. - 
  1502. -int mostglob(comm comm)
  1503. -{
  1504. -struct chnode *chn;
  1505. -char *s;
  1506. - 
  1507. -    while (s = getnode(comm->args))
  1508. -        {
  1509. -        chn = gethnode(s,chtab);
  1510. -        free(s);
  1511. -        if (chn)
  1512. -            chn->globstat = MOSTGLOB;
  1513. -        }
  1514. -    return 0;
  1515. -}
  1516. -
  1517. -int unfunction(comm comm)
  1518. -{
  1519. -char *s1;
  1520. -list l;
  1521. -
  1522. -    while (s1 = getnode(comm->args))
  1523. -        {
  1524. -        unsettrap(s1);
  1525. -        if (l = remhnode(s1,shfunchtab))
  1526. -            freelist(l);
  1527. -        free(s1);
  1528. -        }
  1529. -    return 0;
  1530. -}
  1531. -
  1532. -int unalias(comm comm)
  1533. -{
  1534. -char *s1;
  1535. -struct anode *an;
  1536. -
  1537. -    while (s1 = getnode(comm->args))
  1538. -        {
  1539. -        if (an = remhnode(s1,alhtab))
  1540. -            freeanode(an);
  1541. -        free(s1);
  1542. -        }
  1543. -    return 0;
  1544. -}
  1545. -
  1546. -/* != 0 if s is a prefix of t */
  1547. -
  1548. -int prefix(char *s,char *t)
  1549. -{
  1550. -    while (*s && *t && *s == *t) s++,t++;
  1551. -    return (!*s);
  1552. -}
  1553. -
  1554. -/* convert %%, %1, %foo, %?bar? to a job number */
  1555. -
  1556. -int getjob(char *s,char *prog)
  1557. -{
  1558. -int t0,retval;
  1559. -char *os = s;
  1560. -
  1561. -    if (*s++ != '%')
  1562. -        {
  1563. -        zerrnam(prog,"bad job specifier");
  1564. -        retval = -1; goto done;
  1565. -        }
  1566. -    if (*s == '%' || *s == '+' || !*s)
  1567. -        {
  1568. -        if (topjob == -1)
  1569. -            {
  1570. -            zerrnam(prog,"no current job");
  1571. -            retval = -1; goto done;
  1572. -            }
  1573. -        retval = topjob; goto done;
  1574. -        }
  1575. -    if (*s == '-')
  1576. -        {
  1577. -        if (prevjob == -1)
  1578. -            {
  1579. -            zerrnam(prog,"no previous job");
  1580. -            retval = -1; goto done;
  1581. -            }
  1582. -        retval = prevjob; goto done;
  1583. -        }
  1584. -    if (isdigit(*s))
  1585. -        {
  1586. -        t0 = atoi(s);
  1587. -        if (t0 && t0 < MAXJOB && jobtab[t0].stat && t0 != curjob)
  1588. -            { retval = t0; goto done; }
  1589. -        zerrnam(prog,"no such job");
  1590. -        retval = -1; goto done;
  1591. -        }
  1592. -    if (*s == '?')
  1593. -        {
  1594. -        struct procnode *pn;
  1595. -
  1596. -        for (t0 = 0; t0 != MAXJOB; t0++)
  1597. -            if (jobtab[t0].stat && t0 != curjob)
  1598. -                for (pn = jobtab[t0].procs; pn; pn = pn->next)
  1599. -                    if (strstr(pn->text,s+1))
  1600. -                        { retval = t0; goto done; }
  1601. -        zerrnam(prog,"job not found: %s",s);
  1602. -        retval = -1; goto done;
  1603. -        }
  1604. -    for (t0 = 0; t0 != MAXJOB; t0++)
  1605. -        if (jobtab[t0].stat && jobtab[t0].procs && t0 != curjob && 
  1606. -                prefix(s,jobtab[t0].procs->text))
  1607. -            { retval = t0; goto done; }
  1608. -    zerrnam(prog,"job not found: %s",s);
  1609. -    retval = -1;
  1610. -done:
  1611. -    free(os);
  1612. -    return retval;
  1613. -}
  1614. -
  1615. -int fg(comm comm)
  1616. -{
  1617. -char *s1;
  1618. -int ocj = curjob,job;
  1619. -
  1620. -    scanjobs();
  1621. -    if (!jobbing)
  1622. -        {
  1623. -        zerr("no job control in this shell.");
  1624. -        return 1;
  1625. -        }
  1626. -    if (s1 = getnode(comm->args))
  1627. -        job = getjob(s1,"fg");
  1628. -    else
  1629. -        {
  1630. -        if (topjob == -1 || topjob == curjob)
  1631. -            {
  1632. -            zerrnam("fg","no current job");
  1633. -            return 1;
  1634. -            }
  1635. -        job = topjob;
  1636. -        }
  1637. -    if (job == -1)
  1638. -        return 1;
  1639. -    makerunning(jobtab+job);
  1640. -    if (topjob == job)
  1641. -        {
  1642. -        topjob = prevjob;
  1643. -        prevjob = job;
  1644. -        }
  1645. -    if (prevjob == job)
  1646. -        setprevjob();
  1647. -    printjob(jobtab+job,-1);
  1648. -    curjob = job;
  1649. -    if (strcmp(jobtab[job].cwd,cwd))
  1650. -        {
  1651. -        printf("(pwd: ");
  1652. -        printdir(jobtab[job].cwd);
  1653. -        printf(")\n");
  1654. -        }
  1655. -    settyinfo(&jobtab[job].ttyinfo);
  1656. -    attachtty(jobtab[job].gleader);
  1657. -    killpg(jobtab[job].gleader,SIGCONT);
  1658. -    waitjobs();
  1659. -    curjob = ocj;
  1660. -    return 0;
  1661. -}
  1662. -
  1663. -int bg(comm comm)
  1664. -{
  1665. -char *s1;
  1666. -int job,stopped;
  1667. -
  1668. -    scanjobs();
  1669. -    if (!jobbing)
  1670. -        {
  1671. -        zerr("no job control in this shell.");
  1672. -        return 1;
  1673. -        }
  1674. -    if (s1 = getnode(comm->args))
  1675. -        job = getjob(s1,"bg");
  1676. -    else
  1677. -        {
  1678. -        if (topjob == -1 || topjob == curjob)
  1679. -            {
  1680. -            zerrnam("bg","no current job");
  1681. -            return 1;
  1682. -            }
  1683. -        job = topjob;
  1684. -        }
  1685. -    if (job == -1)
  1686. -        return 1;
  1687. -    if (!(jobtab[job].stat & STAT_STOPPED))
  1688. -        {
  1689. -        zerrnam("bg","job already in background");
  1690. -        return 1;
  1691. -        }
  1692. -    stopped = jobtab[job].stat & STAT_STOPPED;
  1693. -    if (stopped)
  1694. -        makerunning(jobtab+job);
  1695. -    if (topjob == job)
  1696. -        {
  1697. -        topjob = prevjob;
  1698. -        prevjob = -1;
  1699. -        }
  1700. -    if (prevjob == job)
  1701. -        prevjob = -1;
  1702. -    if (prevjob == -1)
  1703. -        setprevjob();
  1704. -    if (topjob == -1)
  1705. -        {
  1706. -        topjob = prevjob;
  1707. -        setprevjob();
  1708. -        }
  1709. -    printjob(jobtab+job,(stopped) ? -1 : 0);
  1710. -    if (stopped)
  1711. -        killpg(jobtab[job].gleader,SIGCONT);
  1712. -    return 0;
  1713. -}
  1714. -
  1715. -int jobs(comm comm)
  1716. -{
  1717. -int job,lng = 0;
  1718. -
  1719. -    if (full(comm->args))
  1720. -        {
  1721. -        if (comm->args->first->next || (strcmp(comm->args->first->dat,"-l")
  1722. -                && strcmp(comm->args->first->dat,"-p")))
  1723. -            {
  1724. -            zerrnam("jobs","usage: jobs [ -lp ]");
  1725. -            return 1;
  1726. -            }
  1727. -        lng = (strcmp(comm->args->first->dat,"-l")) ? 2 : 1;
  1728. -        }
  1729. -    for (job = 0; job != MAXJOB; job++)
  1730. -        if (job != curjob && jobtab[job].stat)
  1731. -            printjob(job+jobtab,lng);
  1732. -    stopmsg = 2;
  1733. -    return 0;
  1734. -}
  1735. -
  1736. -int Kill(comm comm)
  1737. -{
  1738. -int sig = SIGTERM;
  1739. -char *s;
  1740. -
  1741. -    s = getnode(comm->args);
  1742. -    if (s && *s == '-')
  1743. -        {
  1744. -        if (isdigit(s[1]))
  1745. -            sig = atoi(s+1);
  1746. -        else
  1747. -            {
  1748. -            if (s[1] == 'l' && s[2] == '\0')
  1749. -                {
  1750. -                printf("%s",sigs[0]);
  1751. -                for (sig = 1; sig != SIGCOUNT; sig++)
  1752. -                    printf(" %s",sigs[sig]);
  1753. -                putchar('\n');
  1754. -                return 0;
  1755. -                }
  1756. -            for (sig = 0; sig != SIGCOUNT; sig++)
  1757. -                if (!strcmp(sigs[sig],s+1))
  1758. -                    break;
  1759. -            if (sig == SIGCOUNT)
  1760. -                {
  1761. -                zerrnam("kill","unknown signal: SIG%s",s+1);
  1762. -                zerrnam("kill","type kill -l for a list of signals");
  1763. -                return 1;
  1764. -                }
  1765. -            }
  1766. -        s = getnode(comm->args);
  1767. -        }
  1768. -    while (s)
  1769. -        {
  1770. -        if (*s == '%')
  1771. -            {
  1772. -            int job = getjob(s,"kill");
  1773. -
  1774. -            if (killjb(jobtab+job,sig) == -1)
  1775. -                {
  1776. -                zerrnam("kill","kill failed: %e",errno);
  1777. -                return 1;
  1778. -                }
  1779. -            if (jobtab[job].stat & STAT_STOPPED && sig == SIGCONT)
  1780. -                jobtab[job].stat &= ~STAT_STOPPED;
  1781. -            if (sig != SIGKILL)
  1782. -                killpg(jobtab[job].gleader,SIGCONT);
  1783. -            }
  1784. -        else
  1785. -            if (kill(atoi(s),sig) == -1)
  1786. -                {
  1787. -                zerrnam("kill","kill failed: %e");
  1788. -                return 1;
  1789. -                }
  1790. -        s = getnode(comm->args);
  1791. -        }
  1792. -    return 0;
  1793. -}
  1794. -
  1795. -int export(comm comm)
  1796. -{
  1797. -char *s,*t;
  1798. -struct pmnode *pm;
  1799. -
  1800. -    while (s = getnode(comm->args))
  1801. -        {
  1802. -        if (t = strchr(s,'='))
  1803. -            {
  1804. -            *t = '\0';
  1805. -            if (pm = gethnode(s,parmhtab))
  1806. -                freepm(remhnode(s,parmhtab));
  1807. -            *t = '=';
  1808. -            putenv(s);
  1809. -            }
  1810. -        else
  1811. -            {
  1812. -            if (!(pm = gethnode(s,parmhtab)))
  1813. -                {
  1814. -                if (!getenv(s))
  1815. -                    {
  1816. -                    zerrnam("export","parameter not set: %s",s);
  1817. -                    free(s);
  1818. -                    return 1;
  1819. -                    }
  1820. -                }
  1821. -            else if (pm->isint)
  1822. -                {
  1823. -                zerrnam("export","can't export integer parameters");
  1824. -                free(s);
  1825. -                return 1;
  1826. -                }
  1827. -            else
  1828. -                {
  1829. -                t = tricat(s,"=",pm->u.str);
  1830. -                putenv(t);
  1831. -                free(remhnode(s,parmhtab));
  1832. -                }
  1833. -            }
  1834. -        }
  1835. -    return 0;
  1836. -}
  1837. -
  1838. -int integer(comm comm)
  1839. -{
  1840. -char *s,*t;
  1841. -struct pmnode *uu;
  1842. -
  1843. -    while (s = getnode(comm->args))
  1844. -        {
  1845. -        if (t = strchr(s,'='))
  1846. -            {
  1847. -            *t = '\0';
  1848. -            setparm(s,t+1,0,1);
  1849. -            *t = '=';
  1850. -            }
  1851. -        else
  1852. -            {
  1853. -            uu = gethnode(s,parmhtab);
  1854. -            if (uu)
  1855. -                {
  1856. -                if (!uu->isint)
  1857. -                    {
  1858. -                    uu->isint = 1;
  1859. -                    uu->u.val = matheval(uu->u.str);
  1860. -                    }
  1861. -                }
  1862. -            else
  1863. -                setiparm(s,0,1);
  1864. -            }
  1865. -        }
  1866. -    return 0;
  1867. -}
  1868. -
  1869. -static char *recs[] = {
  1870. -    "cputime","filesize","datasize","stacksize","coredumpsize",
  1871. -    "resident","descriptors"
  1872. -    };
  1873. -
  1874. -int limit(comm comm)
  1875. -{
  1876. -char *s;
  1877. -int hard = 0,t0,lim;
  1878. -long val;
  1879. -
  1880. -    if (!(s = getnode(comm->args)))
  1881. -        {
  1882. -        showlimits(0,-1);
  1883. -        return 0;
  1884. -        }
  1885. -    if (!strcmp(s,"-s"))
  1886. -        {
  1887. -        if (full(comm->args))
  1888. -            zerr("limit","arguments after -s ignored");
  1889. -        for (t0 = 0; t0 != RLIM_NLIMITS; t0++)
  1890. -            if (setrlimit(t0,limits+t0) < 0)
  1891. -                zerr("limit","setrlimit failed: %e",errno);
  1892. -        return 0;
  1893. -        }
  1894. -    if (!strcmp(s,"-h"))
  1895. -        {
  1896. -        hard = 1;
  1897. -        free(s);
  1898. -        if (!(s = getnode(comm->args)))
  1899. -            {
  1900. -            showlimits(1,-1);
  1901. -            return 0;
  1902. -            }
  1903. -        }
  1904. -    while (s)
  1905. -        {
  1906. -        for (lim = -1, t0 = 0; t0 != RLIM_NLIMITS; t0++)
  1907. -            if (!strncmp(recs[t0],s,strlen(s)))
  1908. -                {
  1909. -                if (lim != -1)
  1910. -                    lim = -2;
  1911. -                else
  1912. -                    lim = t0;
  1913. -                }
  1914. -        if (lim < 0)
  1915. -            {
  1916. -            zerrnam("limit",
  1917. -                (lim == -2) ? "ambiguous resource specification: %s"
  1918. -                                : "no such resource: %s",s);
  1919. -            free(s);
  1920. -            return 1;
  1921. -            }
  1922. -        free(s);
  1923. -        if (!(s = getnode(comm->args)))
  1924. -            {
  1925. -            showlimits(hard,lim);
  1926. -            return 0;
  1927. -            }
  1928. -        if (!lim)
  1929. -            {
  1930. -            char *ss = s;
  1931. -            
  1932. -            val = strtol(s,&s,10);
  1933. -            if (*s)
  1934. -                if ((*s == 'h' || *s == 'H') && !s[1])
  1935. -                    val *= 3600L;
  1936. -                else if ((*s == 'm' || *s == 'M') && !s[1])
  1937. -                    val *= 60L;
  1938. -                else if (*s == ':')
  1939. -                    val = val*60+strtol(s+1,&s,10);
  1940. -                else
  1941. -                    {
  1942. -                    zerrnam("limit","unknown scaling factor: %s",s);
  1943. -                    free(ss);
  1944. -                    return 1;
  1945. -                    }
  1946. -            }
  1947. -#ifdef RLIMIT_NOFILE
  1948. -        else if (lim == RLIMIT_NOFILE)
  1949. -            val = strtol(s,&s,10);
  1950. -#endif
  1951. -        else
  1952. -            {
  1953. -            char *ss = s;
  1954. -            
  1955. -            val = strtol(s,&s,10);
  1956. -            if (!*s || ((*s == 'k' || *s == 'K') && !s[1]))
  1957. -                val *= 1024L;
  1958. -            else if ((*s == 'M' || *s == 'm') && !s[1])
  1959. -                val *= 1024L*1024;
  1960. -            else
  1961. -                {
  1962. -                zerrnam("limit","unknown scaling factor: %s",s);
  1963. -                free(ss);
  1964. -                return 1;
  1965. -                }
  1966. -            free(ss);
  1967. -            }
  1968. -        if (hard)
  1969. -            if (val > limits[lim].rlim_max && geteuid())
  1970. -                {
  1971. -                zerrnam("limit","can't raise hard limits");
  1972. -                return 1;
  1973. -                }
  1974. -            else
  1975. -                {
  1976. -                limits[lim].rlim_max = val;
  1977. -                if (limits[lim].rlim_max < limits[lim].rlim_cur)
  1978. -                    limits[lim].rlim_cur = limits[lim].rlim_max;
  1979. -                }
  1980. -        else
  1981. -            if (val > limits[lim].rlim_max)
  1982. -                {
  1983. -                zerrnam("limit","limit exceeds hard limit");
  1984. -                return 1;
  1985. -                }
  1986. -            else
  1987. -                limits[lim].rlim_cur = val;
  1988. -        s = getnode(comm->args);
  1989. -        }
  1990. -    return 0;
  1991. -}
  1992. -
  1993. -int unlimit(comm comm)
  1994. -{
  1995. -char *s = getnode(comm->args);
  1996. -int hard = 0,t0,lim;
  1997. -
  1998. -    if (s && !strcmp(s,"-h"))
  1999. -        {
  2000. -        hard = 1;
  2001. -        if (geteuid())
  2002. -            {
  2003. -            zerrnam("unlimit","can't remove hard limits");
  2004. -            return 1;
  2005. -            }
  2006. -        free(s);
  2007. -        s = getnode(comm->args);
  2008. -        }
  2009. -    if (!s)
  2010. -        {
  2011. -        for (t0 = 0; t0 != RLIM_NLIMITS; t0++)
  2012. -            {
  2013. -            if (hard)
  2014. -                limits[t0].rlim_max = RLIM_INFINITY;
  2015. -            else
  2016. -                limits[t0].rlim_cur = limits[t0].rlim_max;
  2017. -            }
  2018. -        return 0;
  2019. -        }
  2020. -    while (s)
  2021. -        {
  2022. -        for (lim = -1, t0 = 0; t0 != RLIM_NLIMITS; t0++)
  2023. -            if (!strncmp(recs[t0],s,strlen(s)))
  2024. -                {
  2025. -                if (lim != -1)
  2026. -                    lim = -2;
  2027. -                else
  2028. -                    lim = t0;
  2029. -                }
  2030. -        if (lim < 0)
  2031. -            {
  2032. -            zerrnam("unlimit",
  2033. -                (lim == -2) ? "ambiguous resource specification: %s"
  2034. -                                : "no such resource: %s",s);
  2035. -            free(s);
  2036. -            return 1;
  2037. -            }
  2038. -        free(s);
  2039. -        if (hard)
  2040. -            limits[lim].rlim_max = RLIM_INFINITY;
  2041. -        else
  2042. -            limits[lim].rlim_cur = limits[lim].rlim_max;
  2043. -        s = getnode(comm->args);
  2044. -        }
  2045. -    return 0;
  2046. -}
  2047. -
  2048. -void showlimits(int hard,int lim)
  2049. -{
  2050. -int t0;
  2051. -long val;
  2052. -
  2053. -    for (t0 = 0; t0 != RLIM_NLIMITS; t0++)
  2054. -        if (t0 == lim || lim == -1)
  2055. -            {
  2056. -            printf("%-16s",recs[t0]);
  2057. -            val = (hard) ? limits[t0].rlim_max : limits[t0].rlim_cur;
  2058. -            if (val == RLIM_INFINITY)
  2059. -                printf("unlimited\n");
  2060. -            else if (!t0)
  2061. -                printf("%d:%02d:%02d\n",(int) (val/3600),
  2062. -                    (int) (val/60) % 60,(int) (val % 60));
  2063. -#ifdef RLIMIT_NOFILE
  2064. -            else if (t0 == RLIMIT_NOFILE)
  2065. -                printf("%d\n",(int) val);
  2066. -#endif
  2067. -            else if (val >= 1024L*1024L)
  2068. -                printf("%ldMb\n",val/(1024L*1024L));
  2069. -            else
  2070. -                printf("%ldKb\n",val/1024L);
  2071. -            }
  2072. -}
  2073. -
  2074. -int sched(comm comm)
  2075. -{
  2076. -char *s = getnode(comm->args);
  2077. -time_t t;
  2078. -long h,m;
  2079. -struct tm *tm;
  2080. -struct schnode *sch,*sch2,*schl;
  2081. -int t0;
  2082. -
  2083. -    if (s && *s == '-')
  2084. -        {
  2085. -        t0 = atoi(s+1);
  2086. -
  2087. -        if (!t0)
  2088. -            {
  2089. -            zerrnam("sched","usage for delete: sched -<item#>.");
  2090. -            return 1;
  2091. -            }
  2092. -        for (schl = (struct schnode *) &scheds, sch = scheds, t0--;
  2093. -                sch && t0; sch = (schl = sch)->next, t0--);
  2094. -        if (!sch)
  2095. -            {
  2096. -            zerrnam("sched","not that many entries");
  2097. -            return 1;
  2098. -            }
  2099. -        schl->next = sch->next;
  2100. -        free(sch->cmd);
  2101. -        free(sch);
  2102. -        return 0;
  2103. -        }
  2104. -    if (s && !full(comm->args))
  2105. -        {
  2106. -        zerrnam("sched","not enough arguments");
  2107. -        return 1;
  2108. -        }
  2109. -    if (!s)
  2110. -        {
  2111. -        char tbuf[40];
  2112. -
  2113. -        for (t0 = 1, sch = scheds; sch; sch = sch->next,t0++)
  2114. -            {
  2115. -            t = sch->time;
  2116. -            tm = localtime(&t);
  2117. -            strftime(tbuf,20,"%a %b %e %k:%M:%S",tm);
  2118. -            printf("%3d %s %s\n",t0,tbuf,sch->cmd);
  2119. -            }
  2120. -        return 0;
  2121. -        }
  2122. -    if (*s == '+')
  2123. -        {
  2124. -        h = strtol(s+1,&s,10);
  2125. -        if (*s != ':')
  2126. -            {
  2127. -            zerrnam("sched","bad time specifier");
  2128. -            return 1;
  2129. -            }
  2130. -        m = strtol(s+1,&s,10);
  2131. -        if (*s)
  2132. -            {
  2133. -            zerrnam("sched","bad time specifier");
  2134. -            return 1;
  2135. -            }
  2136. -        t = time(NULL)+h*3600+m*60;
  2137. -        }
  2138. -    else
  2139. -        {
  2140. -        h = strtol(s,&s,10);
  2141. -        if (*s != ':')
  2142. -            {
  2143. -            zerrnam("sched","bad time specifier");
  2144. -            return 1;
  2145. -            }
  2146. -        m = strtol(s+1,&s,10);
  2147. -        if (*s && *s != 'a' && *s != 'p')
  2148. -            {
  2149. -            zerrnam("sched","bad time specifier");
  2150. -            return 1;
  2151. -            }
  2152. -        t = time(NULL);
  2153. -        tm = localtime(&t);
  2154. -        t -= tm->tm_sec+tm->tm_min*60+tm->tm_hour*3600;
  2155. -        if (*s == 'p')
  2156. -            h += 12;
  2157. -        t += h*3600+m*60;
  2158. -        if (t < time(NULL))
  2159. -            t += 3600*24;
  2160. -        }
  2161. -    sch = alloc(sizeof(struct schnode));
  2162. -    sch->time = t;
  2163. -    sch->cmd = buildline(comm->args);
  2164. -    sch->next = NULL;
  2165. -    for (sch2 = (struct schnode *) &scheds; sch2->next; sch2 = sch2->next);
  2166. -    sch2->next = sch;
  2167. -    return 0;
  2168. -}
  2169. -
  2170. -int eval(comm comm)
  2171. -{
  2172. -char *s = buildline(comm->args);
  2173. -list list;
  2174. -
  2175. -    hungets(s);
  2176. -    strinbeg();
  2177. -    if (!(list = parlist(1)))
  2178. -        {
  2179. -        hflush();
  2180. -        strinend();
  2181. -        return 1;
  2182. -        }
  2183. -    strinend();
  2184. -    runlist(list);
  2185. -    return lastval;
  2186. -}
  2187. -
  2188. -int Brk(comm comm)
  2189. -{
  2190. -    printf("%lx\n",(long) sbrk(0));
  2191. -    return 0;
  2192. -}
  2193. -
  2194. -static struct utmp *wtab;
  2195. -static int wtabsz;
  2196. -
  2197. -int log(comm comm)
  2198. -{
  2199. -    if (!getparm("WATCH"))
  2200. -        return 1;
  2201. -    if (wtab)
  2202. -        free(wtab);
  2203. -    wtab = (struct utmp *) zalloc(1);
  2204. -    wtabsz = 0;
  2205. -    watch();
  2206. -    return 0;
  2207. -}
  2208. -
  2209. -int let(comm comm)
  2210. -{
  2211. -char *str;
  2212. -long val;
  2213. -
  2214. -    while (str = getnode(comm->args))
  2215. -        val = matheval(str);
  2216. -    return !val;
  2217. -}
  2218. -
  2219. -int Read(comm comm)
  2220. -{
  2221. -char *str,*pmpt;
  2222. -int r = 0,bsiz,c,gotnl = 0;
  2223. -char *buf,*bptr;
  2224. -char cc;
  2225. -
  2226. -    str = getnode(comm->args);
  2227. -    if (str && !strcmp(str,"-r"))
  2228. -        {
  2229. -        r = 1;
  2230. -        str = getnode(comm->args);
  2231. -        }
  2232. -    if (!str)
  2233. -        str = strdup("REPLY");
  2234. -    if (interact)
  2235. -        {
  2236. -        for (pmpt = str; *pmpt && *pmpt != '?'; pmpt++);
  2237. -        if (*pmpt++)
  2238. -            {
  2239. -            write(2,pmpt,strlen(pmpt));
  2240. -            *pmpt = '\0';
  2241. -            }
  2242. -        }
  2243. -    while (full(comm->args))
  2244. -        {
  2245. -        buf = bptr = zalloc(bsiz = 64);
  2246. -        FOREVER
  2247. -            {
  2248. -            if (gotnl)
  2249. -                break;
  2250. -            if (read(0,&cc,1) == 1)
  2251. -                c = cc;
  2252. -            else
  2253. -                c = EOF;
  2254. -            if (c == EOF || znspace(c))
  2255. -                break;
  2256. -            *bptr++ = c;
  2257. -            if (bptr == buf+bsiz)
  2258. -                {
  2259. -                buf = realloc(buf,bsiz *= 2);
  2260. -                bptr = buf+(bsiz/2);
  2261. -                }
  2262. -            }
  2263. -        if (c == EOF)
  2264. -            return 1;
  2265. -        if (c == '\n')
  2266. -            gotnl = 1;
  2267. -        *bptr = '\0';
  2268. -        setparm(str,buf,0,0);
  2269. -        str = getnode(comm->args);
  2270. -        }
  2271. -    buf = bptr = zalloc(bsiz = 64);
  2272. -    if (!gotnl)
  2273. -        FOREVER
  2274. -            {
  2275. -            if (read(0,&cc,1) == 1)
  2276. -                c = cc;
  2277. -            else
  2278. -                c = EOF;
  2279. -            if (c == EOF || c == '\n')
  2280. -                break;
  2281. -            *bptr++ = c;
  2282. -            if (bptr == buf+bsiz)
  2283. -                {
  2284. -                buf = realloc(buf,bsiz *= 2);
  2285. -                bptr = buf+(bsiz/2);
  2286. -                }
  2287. -            *bptr = '\0';
  2288. -            }
  2289. -    if (c == EOF)
  2290. -        return 1;
  2291. -    setparm(str,buf,0,0);
  2292. -    return 0;
  2293. -}
  2294. -
  2295. -int fc(comm comm)
  2296. -{
  2297. -char *ename = getparm("FCEDIT"),*str,*s;
  2298. -int n = 0,l = 0,r = 0,first = -1,last = -1,retval;
  2299. -table subs = NULL;
  2300. -
  2301. -    if (!interact)
  2302. -        {
  2303. -        zerrnam("fc","not interactive shell");
  2304. -        return 1;
  2305. -        }
  2306. -    remhist();
  2307. -    if (!ename)
  2308. -        ename = DEFFCEDIT;
  2309. -    str = getnode(comm->args);
  2310. -    for (; str && *str == '-' && str[1] && !isdigit(str[1]);
  2311. -            str = getnode(comm->args))
  2312. -        while (str[1])
  2313. -            switch(*++str)
  2314. -                {
  2315. -                case 'e':
  2316. -                    if (str[1])
  2317. -                        {
  2318. -                        zerrnam("fc","editor name expected after -e");
  2319. -                        return 1;
  2320. -                        }
  2321. -                    ename = getnode(comm->args);
  2322. -                    if (!ename)
  2323. -                        {
  2324. -                        zerrnam("fc","editor name expected after -e");
  2325. -                        return 1;
  2326. -                        }
  2327. -                    break;
  2328. -                case 'n':
  2329. -                    n = 1;
  2330. -                    break;
  2331. -                case 'l':
  2332. -                    l = 1;
  2333. -                    break;
  2334. -                case 'r':
  2335. -                    r = 1;
  2336. -                    break;
  2337. -                default:
  2338. -                    zerrnam("fc","bad option: %c",*str);
  2339. -                    return 1;
  2340. -                }
  2341. -    subs = newtable();
  2342. -    while (str)
  2343. -        {
  2344. -        for (s = str; *s && *s != '='; s++);
  2345. -        if (!*s)
  2346. -            break;
  2347. -        *s++ = '\0';
  2348. -        addnode(subs,str);
  2349. -        addnode(subs,s);
  2350. -        str = getnode(comm->args);
  2351. -        }
  2352. -    if (str)
  2353. -        {
  2354. -        first = fcgetcomm(str);
  2355. -        if (first == -1)
  2356. -            {
  2357. -            freetable(subs,freestr);
  2358. -            return 1;
  2359. -            }
  2360. -        str = getnode(comm->args);
  2361. -        }
  2362. -    if (str)
  2363. -        {
  2364. -        last = fcgetcomm(str);
  2365. -        if (last == -1)
  2366. -            {
  2367. -            freetable(subs,freestr);
  2368. -            return 1;
  2369. -            }
  2370. -        if (full(comm->args))
  2371. -            {
  2372. -            zerrnam("fc","too many arguments");
  2373. -            freetable(subs,freestr);
  2374. -            return 1;
  2375. -            }
  2376. -        }
  2377. -    if (first == -1)
  2378. -        {
  2379. -        first = (l) ? cev-16 : cev;
  2380. -        if (last == -1)
  2381. -            last = cev;
  2382. -        }
  2383. -    if (first < tfev)
  2384. -        first = tfev;
  2385. -    if (last == -1)
  2386. -        last = first;
  2387. -    if (l)
  2388. -        retval = fclist(stdout,!n,r,first,last,subs);
  2389. -    else
  2390. -        {
  2391. -        FILE *out;
  2392. -        char *fn = gettemp();
  2393. -
  2394. -        out = fopen(fn,"w");
  2395. -        if (!out)
  2396. -            zerrnam("fc","can't open temp file: %e",errno);
  2397. -        else
  2398. -            {
  2399. -            retval = 1;
  2400. -            if (!fclist(out,0,r,first,last,subs))
  2401. -                if (fcedit(ename,fn))
  2402. -                    if (stuff(fn))
  2403. -                        zerrnam("fc","%e: %s",errno,s);
  2404. -                    else
  2405. -                        retval = 0;
  2406. -            }
  2407. -        unlink(fn);
  2408. -        free(fn);
  2409. -        }
  2410. -    freetable(subs,freestr);
  2411. -    return retval;
  2412. -}
  2413. -
  2414. -/* get the history event associated with s */
  2415. -
  2416. -int fcgetcomm(char *s)
  2417. -{
  2418. -int cmd;
  2419. -
  2420. -    if (cmd = atoi(s))
  2421. -        {
  2422. -        if (cmd < 0)
  2423. -            cmd = cev+cmd+1;
  2424. -        return cmd;
  2425. -        }
  2426. -    cmd = hcomsearch(s);
  2427. -    if (cmd == -1)
  2428. -        zerrnam("fc","event not found: %s",s);
  2429. -    return cmd;
  2430. -}
  2431. -
  2432. -/* list a series of history events to a file */
  2433. -
  2434. -int fclist(FILE *f,int n,int r,int first,int last,table subs)
  2435. -{
  2436. -int done = 0,ct;
  2437. -Node node;
  2438. -char *s;
  2439. -
  2440. -    if (!subs->first)
  2441. -        done = 1;
  2442. -    last -= first;
  2443. -    first -= tfev;
  2444. -    if (r)
  2445. -        first += last;
  2446. -    for (node = histlist->first,ct = first; ct && node;
  2447. -        node = node->next, ct--);
  2448. -    first += tfev;
  2449. -    while (last-- >= 0)
  2450. -        {
  2451. -        if (!node)
  2452. -            {
  2453. -            zerrnam("fc","no such event: %d",first);
  2454. -            return 1;
  2455. -            }
  2456. -        s = makehlist(node->dat,0);
  2457. -        done |= fcsubs(&s,subs);
  2458. -        if (n)
  2459. -            fprintf(f,"%5d  ",first);
  2460. -        if (f == stdout)
  2461. -            {
  2462. -            niceprintf(s,f);
  2463. -            putc('\n',f);
  2464. -            }
  2465. -        else
  2466. -            fprintf(f,"%s\n",s);
  2467. -        node = (r) ? node->last : node->next;
  2468. -        (r) ? first-- : first++;
  2469. -        }
  2470. -    if (f != stdout)
  2471. -        fclose(f);
  2472. -    if (!done)
  2473. -        {
  2474. -        zerrnam("fc","no substitutions performed");
  2475. -        return 1;
  2476. -        }
  2477. -    return 0;
  2478. -}
  2479. -
  2480. -/* perform old=new substituion */
  2481. -
  2482. -int fcsubs(char **sp,table tab)
  2483. -{
  2484. -Node n;
  2485. -char *s1,*s2,*s3,*s4,*s = *sp,*s5;
  2486. -int subbed = 0;
  2487. -
  2488. -    for (n = tab->first; n; )
  2489. -        {
  2490. -        s1 = n->dat;
  2491. -        n = n->next;
  2492. -        s2 = n->dat;
  2493. -        n = n->next;
  2494. -        s5 = s;
  2495. -        while (s3 = (char *) strstr(s5,s1))
  2496. -            {
  2497. -            s4 = zalloc(1+(s3-s)+strlen(s2)+strlen(s3+strlen(s1)));
  2498. -            strncpy(s4,s,s3-s);
  2499. -            s4[s3-s] = '\0';
  2500. -            strcat(s4,s2);
  2501. -            s5 = s4+strlen(s4);
  2502. -            strcat(s4,s3+strlen(s1));
  2503. -            free(s);
  2504. -            s = s4;
  2505. -            subbed = 1;
  2506. -            }
  2507. -        }
  2508. -    *sp = s;
  2509. -    return subbed;
  2510. -}
  2511. -
  2512. -int fcedit(char *ename,char *fn)
  2513. -{
  2514. -    if (!strcmp(ename,"-"))
  2515. -        return 1;
  2516. -    return !zyztem(ename,fn);
  2517. -}
  2518. -
  2519. -int disown(comm comm)
  2520. -{
  2521. -char *str;
  2522. -int t0;
  2523. -static struct jobnode zero;
  2524. -
  2525. -    while (str = getnode(comm->args))
  2526. -        {
  2527. -        t0 = getjob(str,"disown");
  2528. -        if (t0 == -1)
  2529. -            return 1;
  2530. -        jobtab[t0] = zero;
  2531. -        }
  2532. -    return 0;
  2533. -}
  2534. -
  2535. -int function(comm comm)
  2536. -{
  2537. -    if (full(comm->args))
  2538. -        {
  2539. -        zerrnam("function","too many arguments");
  2540. -        return 1;
  2541. -        }
  2542. -    listhtable(shfunchtab,(void (*)(char *,char *)) pshfunc);
  2543. -    return 0;
  2544. -}
  2545. -
  2546. -int (*funcs[])(comm) = {
  2547. -    echo,zexit,logout,Unset,dirs,
  2548. -    Alias,cd,which,popd,
  2549. -   dot,pushd,shift,unhash,Break,
  2550. -    colon,Glob,noglob,mostglob,unalias,
  2551. -    fg,bg,jobs,Kill,export,
  2552. -    Umask,cd,limit,unlimit,eval,
  2553. -    unfunction,set,Brk,log,builtin,
  2554. -    sched,let,fc,
  2555. -    rehash,hash,disown,test,Read,
  2556. -    integer,setopt,unsetopt,zreturn,function,
  2557. -    test,
  2558. -    NULL
  2559. -    };
  2560. -char *funcnams[] = {
  2561. -    "echo","exit","logout","unset","dirs",
  2562. -    "alias","cd","which","popd",
  2563. -    ".","pushd","shift","unhash","break",
  2564. -    ":","glob","noglob","mostglob","unalias",
  2565. -    "fg","bg","jobs","kill","export",
  2566. -    "umask","chdir","limit","unlimit","eval",
  2567. -    "unfunction","set","brk","log","builtin",
  2568. -    "sched","let","fc",
  2569. -    "rehash","hash","disown","test","read",
  2570. -    "integer","setopt","unsetopt","return","function",
  2571. -    "["
  2572. -    };
  2573. -
  2574. -int builtin(comm comm)
  2575. -{
  2576. -char *s;
  2577. -int t0;
  2578. -
  2579. -    s = getnode(comm->args);
  2580. -    if (!s)
  2581. -        {
  2582. -        zerrnam("builtin","not enough arguments");
  2583. -        return 1;
  2584. -        }
  2585. -    for (t0 = 0; funcs[t0]; t0++)
  2586. -        if (!strcmp(funcnams[t0],s))
  2587. -            break;
  2588. -    if (!funcs[t0])
  2589. -        {
  2590. -        zerrnam("builtin","no such builtin: %s",s);
  2591. -        return 1;
  2592. -        }
  2593. -    return (funcs[t0])(comm);
  2594. -}
  2595. -
  2596. -/* add builtins to the command hash table */
  2597. -
  2598. -void addintern(htable ht)
  2599. -{
  2600. -int (**ptr)(comm);
  2601. -struct chnode *ch;
  2602. -char **nam;
  2603. - 
  2604. -    for (ptr = funcs, nam = funcnams; *ptr; ptr++,nam++)
  2605. -        {
  2606. -        ch = alloc(sizeof(struct chnode));
  2607. -        ch->type = BUILTIN;
  2608. -        ch->u.func = *ptr;
  2609. -        addhnode(strdup(*nam),ch,ht,freechnode);
  2610. -        }
  2611. -}
  2612. -
  2613. -/* get the time of login/logout for WATCH */
  2614. -
  2615. -static time_t getlogtime(struct utmp *u,int inout)
  2616. -{
  2617. -FILE *in;
  2618. -struct utmp uu;
  2619. -int first = 1;
  2620. -
  2621. -    if (inout)
  2622. -        return u->ut_time;
  2623. -    if (!(in = fopen(WTMP_FILE,"r")))
  2624. -        return time(NULL);
  2625. -    fseek(in,0,2);
  2626. -    do
  2627. -        {
  2628. -        if (fseek(in,((first) ? -1 : -2)*sizeof(struct utmp),1))
  2629. -            {
  2630. -            fclose(in);
  2631. -            return time(NULL);
  2632. -            }
  2633. -        first = 0;
  2634. -        if (!fread(&uu,sizeof(struct utmp),1,in))
  2635. -            {
  2636. -            fclose(in);
  2637. -            return time(NULL);
  2638. -            }
  2639. -        }
  2640. -    while (memcmp(&uu,u,sizeof(struct utmp)));
  2641. -    do
  2642. -        if (!fread(&uu,sizeof(struct utmp),1,in))
  2643. -            {
  2644. -            fclose(in);
  2645. -            return time(NULL);
  2646. -            }
  2647. -    while (strncmp(uu.ut_line,u->ut_line,8));
  2648. -    fclose(in);
  2649. -    return uu.ut_time;
  2650. -}
  2651. -
  2652. -/* print a login/logout event */
  2653. -
  2654. -static void watchlog2(int inout,struct utmp *u,char *fmt)
  2655. -{
  2656. -char *p,buf[40],*bf;
  2657. -int i;
  2658. -time_t timet;
  2659. -struct tm *tm = NULL;
  2660. -
  2661. -    while (*fmt)
  2662. -        if (*fmt != '%')
  2663. -            putchar(*fmt++);
  2664. -        else
  2665. -            {
  2666. -            fmt++;
  2667. -            switch(*fmt++)
  2668. -                {
  2669. -                case 'n':
  2670. -                    printf("%.*s",8,u->ut_name);
  2671. -                    break;
  2672. -                case 'a':
  2673. -                    printf("%s",(!inout) ? "logged off" : "logged on");
  2674. -                    break;
  2675. -                case 'l':
  2676. -                    printf("%.*s",5,u->ut_line+3);
  2677. -                    break;
  2678. -                case 'm':
  2679. -                    for (p = u->ut_host,i = 16; i && *p;i--,p++)
  2680. -                        {
  2681. -                        if (*p == '.' && !isdigit(p[1]))
  2682. -                            break;
  2683. -                        putchar(*p);
  2684. -                        }
  2685. -                    break;
  2686. -                case 'M':
  2687. -                    printf("%.*s",16,u->ut_host);
  2688. -                    break;
  2689. -                case 't':
  2690. -                case '@':
  2691. -                    timet = getlogtime(u,inout);
  2692. -                    tm = localtime(&timet);
  2693. -                    strftime(buf,40,"%l:%M%p",tm);
  2694. -                    printf("%s",(*buf == ' ') ? buf+1 : buf);
  2695. -                    break;
  2696. -                case 'T':
  2697. -                    timet = getlogtime(u,inout);
  2698. -                    tm = localtime(&timet);
  2699. -                    strftime(buf,40,"%k:%M",tm);
  2700. -                    printf("%s",buf);
  2701. -                    break;
  2702. -                case 'w':
  2703. -                    timet = getlogtime(u,inout);
  2704. -                    tm = localtime(&timet);
  2705. -                    strftime(buf,40,"%a %e",tm);
  2706. -                    printf("%s",buf);
  2707. -                    break;
  2708. -                case 'W':
  2709. -                    timet = getlogtime(u,inout);
  2710. -                    tm = localtime(&timet);
  2711. -                    strftime(buf,40,"%m/%d/%y",tm);
  2712. -                    printf("%s",buf);
  2713. -                    break;
  2714. -                case 'D':
  2715. -                    timet = getlogtime(u,inout);
  2716. -                    tm = localtime(&timet);
  2717. -                    strftime(buf,40,"%y-%m-%d",tm);
  2718. -                    printf("%s",buf);
  2719. -                    break;
  2720. -                case '%':
  2721. -                    putchar('%');
  2722. -                    break;
  2723. -                case 'S':
  2724. -                    bf = buf;
  2725. -                    if (tgetstr("so",&bf))
  2726. -                        fputs(buf,stdout);
  2727. -                    break;
  2728. -                case 's':
  2729. -                    bf = buf;
  2730. -                    if (tgetstr("se",&bf))
  2731. -                        fputs(buf,stdout);
  2732. -                    break;
  2733. -                case 'B':
  2734. -                    bf = buf;
  2735. -                    if (tgetstr("md",&bf))
  2736. -                        fputs(buf,stdout);
  2737. -                    break;
  2738. -                case 'b':
  2739. -                    bf = buf;
  2740. -                    if (tgetstr("me",&bf))
  2741. -                        fputs(buf,stdout);
  2742. -                    break;
  2743. -                case 'U':
  2744. -                    bf = buf;
  2745. -                    if (tgetstr("us",&bf))
  2746. -                        fputs(buf,stdout);
  2747. -                    break;
  2748. -                case 'u':
  2749. -                    bf = buf;
  2750. -                    if (tgetstr("ue",&bf))
  2751. -                        fputs(buf,stdout);
  2752. -                    break;
  2753. -                default:
  2754. -                    putchar('%');
  2755. -                    putchar(fmt[-1]);
  2756. -                    break;
  2757. -                }
  2758. -            }
  2759. -    putchar('\n');
  2760. -}
  2761. -
  2762. -/* check the list for login/logouts */
  2763. -
  2764. -static void watchlog(int inout,struct utmp *u,char *w,char *fmt)
  2765. -{
  2766. -char *v;
  2767. -
  2768. -    if (!strcmp(w,"all"))
  2769. -        {
  2770. -        watchlog2(inout,u,fmt);
  2771. -        return;
  2772. -        }
  2773. -    for(;;)
  2774. -        if (v = strchr(w,':'))
  2775. -            {
  2776. -            if (!strncmp(u->ut_name,w,v-w))
  2777. -                watchlog2(inout,u,fmt);
  2778. -            w = v+1;
  2779. -            }
  2780. -        else
  2781. -            {
  2782. -            if (!strncmp(u->ut_name,w,8))
  2783. -                watchlog2(inout,u,fmt);
  2784. -            break;
  2785. -            }
  2786. -}
  2787. -
  2788. -/* compare 2 utmp entries */
  2789. -
  2790. -static int ucmp(struct utmp *u,struct utmp *v)
  2791. -{
  2792. -    if (u->ut_time == v->ut_time)
  2793. -        return strncmp(u->ut_line,v->ut_line,8);
  2794. -    return u->ut_time - v->ut_time;
  2795. -}
  2796. -
  2797. -/* initialize the user list */
  2798. -
  2799. -void readwtab(void)
  2800. -{
  2801. -struct utmp *uptr;
  2802. -int wtabmax = 32;
  2803. -FILE *in;
  2804. -
  2805. -    wtabsz = 0;
  2806. -    uptr = wtab = (struct utmp *) zalloc(wtabmax*sizeof(struct utmp));
  2807. -    in = fopen(UTMP_FILE,"r");
  2808. -    while (fread(uptr,sizeof(struct utmp),1,in))
  2809. -        if (uptr->ut_host[0])
  2810. -            {
  2811. -            uptr++;
  2812. -            if (++wtabsz == wtabmax)
  2813. -                uptr = (wtab = (struct utmp *) realloc(wtab,(wtabmax*=2)*
  2814. -                    sizeof(struct utmp)))+wtabsz;
  2815. -            }
  2816. -    fclose(in);
  2817. -    if (wtabsz)
  2818. -        qsort(wtab,wtabsz,sizeof(struct utmp),ucmp);
  2819. -}
  2820. -
  2821. -/* check for login/logout events; executed before each prompt
  2822. -    if WATCH is set */
  2823. -
  2824. -void watch(void)
  2825. -{
  2826. -char *s = getparm("WATCH");
  2827. -char *fmt = getparm("WATCHFMT");
  2828. -FILE *in;
  2829. -int utabsz = 0,utabmax = wtabsz+4,uct,wct;
  2830. -struct utmp *utab,*uptr,*wptr;
  2831. -
  2832. -    holdintr();
  2833. -    if (!fmt)
  2834. -        fmt = "%n has %a %l from %m.";
  2835. -    if (!wtab)
  2836. -        {
  2837. -        readwtab();
  2838. -        noholdintr();
  2839. -        return;
  2840. -        }
  2841. -    uptr = utab = (struct utmp *) zalloc(utabmax*sizeof(struct utmp));
  2842. -    in = fopen(UTMP_FILE,"r");
  2843. -    while (fread(uptr,sizeof *uptr,1,in))
  2844. -        if (uptr->ut_host[0])
  2845. -            {
  2846. -            uptr++;
  2847. -            if (++utabsz == utabmax)
  2848. -                uptr = (utab = (struct utmp *) realloc(utab,(utabmax*=2)*
  2849. -                    sizeof(struct utmp)))+utabsz;
  2850. -            }
  2851. -    fclose(in);
  2852. -    noholdintr();
  2853. -    if (errflag)
  2854. -        {
  2855. -        free(utab);
  2856. -        return;
  2857. -        }
  2858. -    if (utabsz)
  2859. -        qsort(utab,utabsz,sizeof(struct utmp),ucmp);
  2860. -
  2861. -    wct = wtabsz; uct = utabsz;
  2862. -    uptr = utab; wptr = wtab;
  2863. -    if (errflag)
  2864. -        {
  2865. -        free(utab);
  2866. -        return;
  2867. -        }
  2868. -    while ((uct || wct) && !errflag)
  2869. -        if (!uct || (wct && ucmp(uptr,wptr) > 0))
  2870. -            wct--,watchlog(0,wptr++,s,fmt);
  2871. -        else if (!wct || (uct && ucmp(uptr,wptr) < 0))
  2872. -            uct--,watchlog(1,uptr++,s,fmt);
  2873. -        else
  2874. -            uptr++,wptr++,wct--,uct--;
  2875. -    free(wtab);
  2876. -    wtab = utab;
  2877. -    wtabsz = utabsz;
  2878. -    fflush(stdout);
  2879. -}
  2880. -
  2881. End of builtin.c
  2882. echo builtin.pro 1>&2
  2883. sed 's/^-//' >builtin.pro <<'End of builtin.pro'
  2884. -int echo(comm comm);
  2885. -void pdstack(void);
  2886. -int zexit(comm comm);
  2887. -int zreturn(comm comm);
  2888. -int logout(comm comm);
  2889. -int Unset(comm comm);
  2890. -int set(comm comm);
  2891. -int setopt(comm comm);
  2892. -int unsetopt(comm comm);
  2893. -int csetopt(comm comm,int isun);
  2894. -void pparm(char *s,struct pmnode *t);
  2895. -int dirs(comm comm);
  2896. -void listhtable(htable ht,void (*func)(char *,char *));
  2897. -void palias(char *s,struct anode *t);
  2898. -void pshfunc(char *s,list l);
  2899. -void niceprint(char *s);
  2900. -void niceprintf(char *s,FILE *f);
  2901. -char *buildline(table t);
  2902. -int Alias(comm comm);
  2903. -int cd(comm comm);
  2904. -int dot(comm comm);
  2905. -int Umask(comm comm);
  2906. -int which(comm comm);
  2907. -int popd(comm comm);
  2908. -int pushd(comm comm);
  2909. -int chcd(char *cnam,char *cd);
  2910. -int shift(comm comm);
  2911. -int unhash(comm comm);
  2912. -int rehash(comm comm);
  2913. -int hash(comm comm);
  2914. -int Break(comm comm);
  2915. -int colon(comm comm);
  2916. -int Glob(comm comm);
  2917. -int noglob(comm comm);
  2918. -int mostglob(comm comm);
  2919. -int unfunction(comm comm);
  2920. -int unalias(comm comm);
  2921. -int prefix(char *s,char *t);
  2922. -int getjob(char *s,char *prog);
  2923. -int fg(comm comm);
  2924. -int bg(comm comm);
  2925. -int jobs(comm comm);
  2926. -int Kill(comm comm);
  2927. -int export(comm comm);
  2928. -int integer(comm comm);
  2929. -int limit(comm comm);
  2930. -int unlimit(comm comm);
  2931. -void showlimits(int hard,int lim);
  2932. -int sched(comm comm);
  2933. -int eval(comm comm);
  2934. -int Brk(comm comm);
  2935. -int log(comm comm);
  2936. -int let(comm comm);
  2937. -int Read(comm comm);
  2938. -int fc(comm comm);
  2939. -int fcgetcomm(char *s);
  2940. -int fclist(FILE *f,int n,int r,int first,int last,table subs);
  2941. -int fcsubs(char **sp,table tab);
  2942. -int fcedit(char *ename,char *fn);
  2943. -int disown(comm comm);
  2944. -int function(comm comm);
  2945. -int builtin(comm comm);
  2946. -void addintern(htable ht);
  2947. -void readwtab(void);
  2948. -void watch(void);
  2949. End of builtin.pro
  2950. echo config.h 1>&2
  2951. sed 's/^-//' >config.h <<'End of config.h'
  2952. -/*
  2953. -
  2954. -    config.h - configuration file
  2955. -
  2956. -    This file is part of zsh, the Z shell.
  2957. -
  2958. -   zsh is free software; no one can prevent you from reading the source
  2959. -   code, or giving it to someone else.
  2960. -   This file is copyrighted under the GNU General Public License, which
  2961. -   can be found in the file called COPYING.
  2962. -
  2963. -   Copyright (C) 1990 Paul Falstad
  2964. -
  2965. -   zsh is distributed in the hope that it will be useful, but
  2966. -   WITHOUT ANY WARRANTY.  No author or distributor accepts
  2967. -   responsibility to anyone for the consequences of using it or for
  2968. -   whether it serves any particular purpose or works at all, unless he
  2969. -   says so in writing.  Refer to the GNU General Public License
  2970. -   for full details.
  2971. -
  2972. -   Everyone is granted permission to copy, modify and redistribute
  2973. -   zsh, but only under the conditions described in the GNU General Public
  2974. -   License.   A copy of this license is supposed to have been given to you
  2975. -   along with zsh so you can know your rights and responsibilities.
  2976. -   It should be in a file named COPYING.
  2977. -
  2978. -   Among other things, the copyright notice and this notice must be
  2979. -   preserved on all copies.
  2980. -
  2981. -*/
  2982. -
  2983. -/* define this if you have WAITPID */
  2984. -
  2985. -#define WAITPID
  2986. -
  2987. -/* define if the return type of signal handlers is int */
  2988. -
  2989. -/* #define INTHANDTYPE  */
  2990. -
  2991. -/* the return type of handlers */
  2992. -
  2993. -#define HANDTYPE void
  2994. -
  2995. -/* define this if you have putenv */
  2996. -
  2997. -#define PUTENV 
  2998. -
  2999. -/* define this if you have strstr */
  3000. -
  3001. -#define STRSTR
  3002. -
  3003. -/* define this if you have strftime */
  3004. -
  3005. -/* #define STRFTIME */
  3006. -
  3007. -/* define if you have struct termios, else struct sgttyb */
  3008. -
  3009. -#define TERMIOS
  3010. -
  3011. -#include "config.local.h"
  3012. -
  3013. End of config.h
  3014. echo config.local.h 1>&2
  3015. sed 's/^-//' >config.local.h <<'End of config.local.h'
  3016. -/*
  3017. -
  3018. -    config.local.h - local machine configuration file
  3019. -
  3020. -    This file is part of zsh, the Z shell.
  3021. -
  3022. -   zsh is free software; no one can prevent you from reading the source
  3023. -   code, or giving it to someone else.
  3024. -   This file is copyrighted under the GNU General Public License, which
  3025. -   can be found in the file called COPYING.
  3026. -
  3027. -   Copyright (C) 1990 Paul Falstad
  3028. -
  3029. -   zsh is distributed in the hope that it will be useful, but
  3030. -   WITHOUT ANY WARRANTY.  No author or distributor accepts
  3031. -   responsibility to anyone for the consequences of using it or for
  3032. -   whether it serves any particular purpose or works at all, unless he
  3033. -   says so in writing.  Refer to the GNU General Public License
  3034. -   for full details.
  3035. -
  3036. -   Everyone is granted permission to copy, modify and redistribute
  3037. -   zsh, but only under the conditions described in the GNU General Public
  3038. -   License.   A copy of this license is supposed to have been given to you
  3039. -   along with zsh so you can know your rights and responsibilities.
  3040. -   It should be in a file named COPYING.
  3041. -
  3042. -   Among other things, the copyright notice and this notice must be
  3043. -   preserved on all copies.
  3044. -
  3045. -*/
  3046. -
  3047. -/* a string corresponding to the host type */
  3048. -
  3049. -#define HOSTTYP "sun4"
  3050. -
  3051. -/* define if you prefer "suspended" to "stopped" */
  3052. -
  3053. -#define USE_SUSPENDED
  3054. -
  3055. -/* the path of zsh in the file system */
  3056. -
  3057. -#define MYSELF "/usr/princeton/bin/zsh"
  3058. -
  3059. -/* the default editor for the fc builtin */
  3060. -
  3061. -#define DEFFCEDIT "/usr/ucb/vi"
  3062. -
  3063. -/* the file to source whenever zsh is run; if undefined, don't source
  3064. -    anything */
  3065. -
  3066. -#define GLOBALZSHRC "/etc/zshrc"
  3067. -
  3068. -/* the file to source whenever zsh is run as a login shell; if
  3069. -    undefined, don't source anything */
  3070. -
  3071. -#define GLOBALZLOGIN "/etc/zlogin"
  3072. -
  3073. -/* the default HISTSIZE */
  3074. -
  3075. -#define DEFAULT_HISTSIZE 128
  3076. -
  3077. -/* the path of utmp */
  3078. -
  3079. -#define UTMP_FILE "/etc/utmp"
  3080. -
  3081. -/* the path of wtmp */
  3082. -
  3083. -#define WTMP_FILE "/var/adm/wtmp"
  3084. -
  3085. -/* define if you have problems with job control or tty modes.
  3086. -    gcc-cpp does not seem to handle ioctls correctly. */
  3087. -
  3088. -/*#define BUGGY_GCC*/
  3089. -
  3090. -/* define if you like interactive comments */
  3091. -
  3092. -/*#define INTERACTIVE_COMMENTS*/
  3093. -
  3094. -/* define if you want warnings about nonexistent path components */
  3095. -
  3096. -#define PATH_WARNINGS
  3097. -
  3098. End of config.local.h
  3099. echo exec.c 1>&2
  3100. sed 's/^-//' >exec.c <<'End of exec.c'
  3101. -/*
  3102. -
  3103. -    exec.c - command execution
  3104. -
  3105. -    This file is part of zsh, the Z shell.
  3106. -
  3107. -   zsh is free software; no one can prevent you from reading the source
  3108. -   code, or giving it to someone else.
  3109. -   This file is copyrighted under the GNU General Public License, which
  3110. -   can be found in the file called COPYING.
  3111. -
  3112. -   Copyright (C) 1990 Paul Falstad
  3113. -
  3114. -   zsh is distributed in the hope that it will be useful, but
  3115. -   WITHOUT ANY WARRANTY.  No author or distributor accepts
  3116. -   responsibility to anyone for the consequences of using it or for
  3117. -   whether it serves any particular purpose or works at all, unless he
  3118. -   says so in writing.  Refer to the GNU General Public License
  3119. -   for full details.
  3120. -
  3121. -   Everyone is granted permission to copy, modify and redistribute
  3122. -   zsh, but only under the conditions described in the GNU General Public
  3123. -   License.   A copy of this license is supposed to have been given to you
  3124. -   along with zsh so you can know your rights and responsibilities.
  3125. -   It should be in a file named COPYING.
  3126. -
  3127. -   Among other things, the copyright notice and this notice must be
  3128. -   preserved on all copies.
  3129. -
  3130. -*/
  3131. -
  3132. -#include "zsh.h"
  3133. -#include "funcs.h"
  3134. -#include <sys/errno.h>
  3135. -#include <sys/dir.h>
  3136. -
  3137. -#define execerr() { if (forked) exit(1); freecmd(comm); \
  3138. -    closemnodes(mfds); errflag = 1; return; }
  3139. -#define magicerr() { if (magic) putc('\n',stderr); errflag = 1; }
  3140. -
  3141. -/* execute a string */
  3142. -
  3143. -void execstring(char *s)
  3144. -{
  3145. -list l;
  3146. -
  3147. -    hungets(strdup("\n"));
  3148. -    hungets(s);
  3149. -    strinbeg();
  3150. -    if (!(l = parlist(1)))
  3151. -        {
  3152. -        strinend();
  3153. -        hflush();
  3154. -        return;
  3155. -        }
  3156. -    if (peek != EOF && peek != EMPTY)
  3157. -        {
  3158. -        strinend();
  3159. -        hflush();
  3160. -        return;
  3161. -        }
  3162. -    strinend();
  3163. -    execlist(l);
  3164. -}
  3165. -
  3166. -/* duplicate a list and run it */
  3167. -
  3168. -void newrunlist(list l)
  3169. -{
  3170. -list a = duplist(l); runlist(a);
  3171. -}
  3172. -
  3173. -/* fork and set limits */
  3174. -
  3175. -int phork(void)
  3176. -{
  3177. -int pid = fork(),t0;
  3178. -
  3179. -    if (pid == -1)
  3180. -        {
  3181. -        zerr("fork failed: %e",errno);
  3182. -        return -1;
  3183. -        }
  3184. -    if (!pid)
  3185. -        for (t0 = 0; t0 != RLIM_NLIMITS; t0++)
  3186. -            setrlimit(t0,limits+t0);
  3187. -    return pid;
  3188. -}
  3189. -
  3190. -/* execute a current shell command */
  3191. -
  3192. -void execcursh(comm comm)
  3193. -{
  3194. -    runlist(comm->left);
  3195. -    comm->left = NULL;
  3196. -}
  3197. -
  3198. -/* execve an external command */
  3199. -
  3200. -void execute(char *arg0,table args)
  3201. -{
  3202. -char **argv;
  3203. -char *z,*s,buf[MAXPATHLEN],buf2[MAXPATHLEN];
  3204. -struct chnode *cn;
  3205. -int t0,tl,ee = 0;
  3206. -
  3207. -#define zexecve(X,Y,Z) {execve(z=(X),Y,Z);\
  3208. -    if(errno!=ENOENT){ee = errno;strcpy(buf2,buf);}}
  3209. -
  3210. -    cn = gethnode(arg0,chtab);
  3211. -    if (s = getenv("STTY"))
  3212. -        zyztem("stty",s);
  3213. -    if (z = getenv("ARGV0"))
  3214. -        z = strdup(z);
  3215. -    else
  3216. -        z = arg0;
  3217. -    argv = makecline(z,args);
  3218. -    fixsigs();
  3219. -    if (cn)
  3220. -        {
  3221. -        if (cn->type == EXCMD_POSTDOT)
  3222. -            {zexecve(arg0,argv,environ);}
  3223. -        {zexecve(cn->u.nam,argv,environ);}
  3224. -        }
  3225. -    for (s = arg0; *s; s++)
  3226. -        if (*s == '/')
  3227. -            {
  3228. -            execve(arg0,argv,environ);
  3229. -            zerr("%e: %s",errno,arg0);
  3230. -            _exit(1);
  3231. -            }
  3232. -    for (t0 = pathct; t0; t0--,path++)
  3233. -        if (**path == '.')
  3234. -            {zexecve(arg0,argv,environ);}
  3235. -        else
  3236. -            {
  3237. -            tl = strlen(*path);
  3238. -            strcpy(buf,*path);
  3239. -            buf[tl] = '/';
  3240. -            if (strlen(arg0)+strlen(buf)+1 >= MAXPATHLEN)
  3241. -                {
  3242. -                zerr("command too long: %s",arg0);
  3243. -                _exit(1);
  3244. -                }
  3245. -            strcpy(buf+tl+1,arg0);
  3246. -            {zexecve(buf,argv,environ);}
  3247. -            }
  3248. -    if (ee)
  3249. -        {
  3250. -        z = buf2;
  3251. -        errno = ee;
  3252. -        goto errs;
  3253. -        }
  3254. -    zerr("command not found: %s",arg0);
  3255. -    _exit(1);
  3256. -errs:
  3257. -    zerr("%e: %s",errno,z);
  3258. -    _exit(1);
  3259. -}
  3260. -
  3261. -#define try(X) { if (!access(X,X_OK)) return strdup(X); }
  3262. -
  3263. -/* get the pathname of a command */
  3264. -
  3265. -char *findcmd(char *arg0)
  3266. -{
  3267. -char *s,buf[MAXPATHLEN];
  3268. -int t0,tl;
  3269. -struct chnode *cn = gethnode(arg0,chtab);
  3270. -char **pp = path;
  3271. -
  3272. -    if (cn)
  3273. -        {
  3274. -        if (cn->type == EXCMD_POSTDOT)
  3275. -            {
  3276. -            strcpy(buf,"./");
  3277. -            strcat(buf,arg0);
  3278. -            try(buf);
  3279. -            }
  3280. -        try(cn->u.nam);
  3281. -        }
  3282. -    for (s = arg0; *s; s++)
  3283. -        if (*s == '/')
  3284. -            {
  3285. -            try(arg0);
  3286. -            goto failed;
  3287. -            }
  3288. -    for (t0 = pathct; t0; t0--,pp++)
  3289. -        if (**pp == '.')
  3290. -            {
  3291. -            strcpy(buf,"./");
  3292. -            strcat(buf,arg0);
  3293. -            try(buf);
  3294. -            }
  3295. -        else
  3296. -            {
  3297. -            tl = strlen(*pp);
  3298. -            strcpy(buf,*pp);
  3299. -            buf[tl] = '/';
  3300. -            strcpy(buf+tl+1,arg0);
  3301. -            try(buf);
  3302. -            }
  3303. -failed:
  3304. -    return NULL;
  3305. -}
  3306. -
  3307. -void execlist(list list)
  3308. -{
  3309. -    execlist1(list);
  3310. -    freelist(list);
  3311. -}
  3312. -
  3313. -void execlist1(list list)
  3314. -{
  3315. -    if (breaks)
  3316. -        return;
  3317. -    switch(list->type)
  3318. -        {
  3319. -        case SYNC:
  3320. -        case ASYNC:
  3321. -            execlist2(list->left,list->type,!list->right);
  3322. -            if (sigtrapped[SIGDEBUG])
  3323. -                dotrap(SIGDEBUG);
  3324. -            if (sigtrapped[SIGERR] && lastval)
  3325. -                dotrap(SIGERR);
  3326. -            if (list->right && !retflag)
  3327. -                execlist1(list->right);
  3328. -            break;
  3329. -        }
  3330. -}
  3331. -
  3332. -void execlist2(list2 list,int type,int last1)
  3333. -{
  3334. -    switch(list->type)
  3335. -        {
  3336. -        case END:
  3337. -            execpline(list,type,last1);
  3338. -            break;
  3339. -        case ORNEXT:
  3340. -            if (!execpline(list,SYNC,0))
  3341. -                execlist2(list->right,type,last1);
  3342. -            break;
  3343. -        case ANDNEXT:
  3344. -            if (execpline(list,SYNC,0))
  3345. -                execlist2(list->right,type,last1);
  3346. -            break;
  3347. -        }
  3348. -}
  3349. -
  3350. -int execpline(list2 l,int how,int last1)
  3351. -{
  3352. -int ipipe[2] = {0,0},opipe[2] = {0,0};
  3353. -
  3354. -    sigblock(sigmask(SIGCHLD));
  3355. -    curjob = getfreejob(); 
  3356. -    initjob(l->flags);
  3357. -    if (l->flags & PFLAG_COPROC)
  3358. -        {
  3359. -        how = ASYNC;
  3360. -        mpipe(ipipe);
  3361. -        mpipe(opipe);
  3362. -        if (spin)
  3363. -            {
  3364. -            close(spin);
  3365. -            close(spout);
  3366. -            }
  3367. -        spin = ipipe[0];
  3368. -        spout = opipe[1];
  3369. -        }
  3370. -    execpline2(l->left,how,opipe[0],ipipe[1],last1);
  3371. -    if (how == ASYNC)
  3372. -        {
  3373. -        spawnjob();
  3374. -        sigsetmask(0);
  3375. -        return 1;
  3376. -        }
  3377. -    else
  3378. -        {
  3379. -        waitjobs();
  3380. -        sigsetmask(0);
  3381. -        if (l->flags & PFLAG_NOT)
  3382. -            lastval = !lastval;
  3383. -        return !lastval;
  3384. -        }
  3385. -}
  3386. -
  3387. -void execpline2(pline pline,int how,int input,int output,int last1)
  3388. -{
  3389. -int pid;
  3390. -int pipes[2];
  3391. -
  3392. -    if (breaks)
  3393. -        return;
  3394. -    if (!pline)
  3395. -        return;
  3396. -    if (pline->type == END)
  3397. -        {
  3398. -        execcomm(pline->left,input,output,how==ASYNC,last1);
  3399. -        pline->left = NULL;
  3400. -        }
  3401. -    else
  3402. -        {
  3403. -        mpipe(pipes);
  3404. -
  3405. -        /* if we are doing "foo | bar" where foo is a current
  3406. -            shell command, do foo in the current shell and do
  3407. -            the rest of the pipeline in a subshell. */
  3408. -
  3409. -        if (pline->left->type >= CURSH && how == SYNC)
  3410. -            {
  3411. -            if (!(pid = fork()))
  3412. -                {
  3413. ---cut here---cut here---cut here---
  3414.