Current Path : /compat/linux/usr/share/doc/bash-3.2/scripts/ |
FreeBSD hs32.drive.ne.jp 9.1-RELEASE FreeBSD 9.1-RELEASE #1: Wed Jan 14 12:18:08 JST 2015 root@hs32.drive.ne.jp:/sys/amd64/compile/hs32 amd64 |
Current File : //compat/linux/usr/share/doc/bash-3.2/scripts/bcsh.sh |
#!/bin/bash # 1-Feb-86 09:37:35-MST,30567;000000000001 # Return-Path: <unix-sources-request@BRL.ARPA> # Received: from BRL-TGR.ARPA by SIMTEL20.ARPA with TCP; Sat 1 Feb 86 09:36:16-MST # Received: from usenet by TGR.BRL.ARPA id a002623; 1 Feb 86 9:33 EST # From: chris <chris@globetek.uucp> # Newsgroups: net.sources # Subject: Improved Bcsh (Bourne Shell Cshell-Emulator) # Message-ID: <219@globetek.UUCP> # Date: 30 Jan 86 17:34:26 GMT # To: unix-sources@BRL-TGR.ARPA # # This is a new, improved version of my Bourne shell cshell-emulator. # The code has been cleaned up quite a bit, and a couple of new features # added (now supports 'noclobber' and 'iclobber' variables). A bug with # 'eval' that caused "illegal I/O" error messages on vanilla V7 shells has # also been fixed. # I have posted the program in its entirety because a context diff of the # old and new versions was longer than the new version... # --Chris # Bcsh -- A Simple Cshell-Like Command Pre-Processor For The Bourne Shell # # "Copyright (c) Chris Robertson, December 1985" # # This software may be used for any purpose provided the original # copyright notice and this notice are affixed thereto. No warranties of # any kind whatsoever are provided with this software, and it is hereby # understood that the author is not liable for any damagages arising # from the use of this software. # # Features Which the Cshell Does Not Have: # ---------------------------------------- # # + command history persists across bcsh sessions # + global last-command editing via 'g^string1^string2^' syntax # + edit any command via $EDITOR or $VISUAL editors # + history file name, .bcshrc file name, alias file name, and number # of commands saved on termination can be set by environment variables # + prompt may evaluate commands, such as `pwd`, `date`, etc. # + the whole text of interactive 'for' and 'while' loops and 'if' # statements goes into the history list and may be re-run or edited # + multiple copies of commands and requests to see command history # are not added to the history list # + the history mechanism actually stores all commands entered in a # current session, not just $history of them. This means that you # can increase $history on the fly and at once have a larger history. # # # Synonyms: # --------- # # logout, exit, bye write out history file and exit # h, history show current history list # # # Aliases: # -------- # # alias NAME CMND create an alias called NAME to run CMND # unalias NAME remove the alias NAME # # There are no 'current-session only' aliases -- all alias and unalias # commands are permanent, and stored in the $aliasfile. # # If an alias contains positional variables -- $1, $2, $*, etc. -- any # arguments following the alias name are considered to be values for # those variables, and the alias is turned into a command of the form # 'set - arguments;alias'. Otherwise, a simple substitution is performed # for the alias and the rest of the command preserved. The cshell # convention of using '\!:n' in an alias to get bits of the current # command is mercifully abandoned. # # Quotes are not necessary around the commands comprising an alias; # in fact, any enclosing quotes are stripped when the alias is added # to the file. # # A couple of typical aliases might be: # # goto cd $1;pwd # l ls -F # # Note that aliasing something to "commands;logout" will not work -- if # you want something to happen routinely on logout put it in the file # specified by $logoutfile, default = $HOME/.blogout. # # # Command Substitutions: # ---------------------- # # !! substitute last command from history list # !!:N substitute Nth element of last command from # history list -- 0 = command name, 1 = 1st arg # !!:$ substitute last element of last command from # history list # !!:* substitute all arguments to last command # from history list # !NUMBER substitute command NUMBER from the history list # !NUMBER:N as above, but substitute Nth element, where # 0 = command name, 1 = 1st arg, etc. # !NUMBER:$ as above, but substitute last element # !NUMBER:* as above, but substitute all arguments # !-NUMBER substitute the command NUMBER lines from the # end of the history list; 1 = last command # !-NUMBER:N as above, but substitute Nth element, where # 0 = command name, 1 = 1st arg, etc. # !-NUMBER:$ as above, but substitute last element # !-NUMBER:* as above, but substitute all arguments # !?STRING substitute most-recent command from history list # containing STRING -- STRING must be enclosed in # braces if followed by any other characters # !?STRING:N as above, but substitute Nth element, where # 0 = command name, 1 = 1st arg, etc. # !?STRING:$ as above, but substitute last element # !?STRING:* as above, but substitute all arguments # # # Command Editing: # ---------------- # # CMND~e edit CMND using $EDITOR, where CMND may be found # using a history substitution # CMND~v edit CMND using $VISUAL, where CMND may be found # using a history substitution # " ^string1^string2^ substitute string2 for string1 in last command" # command and run it # " g^string1^string2^ globally substitute string2 for string1 in " # last command and run it # !NUMBER:s/string1/string2/ # substitute string2 for string1 in # command NUMBER and run it # !NUMBER:gs/string1/string2/ # globally substitute string2 for string1 in # command NUMBER and run it # !?STRING:s/string1/string2/ # substitute string2 for string1 in last command # containing STRING and run it # !?STRING:gs/string1/string2/ # globally substitute string2 for string1 in last # command containing STRING and run it # # Any command which ends in the string ":p" is treated as a normal # command until all substitutions have been completed. The trailing # ":p" is then stripped, and the command is simply echoed and added to # the history list instead of being executed. # # None of the other colon extensions of the cshell are supported. # # # Shell Environment Variables: # ---------------------------- # # EDITOR editor used by ~e command, default = "ed" # VISUAL editor used by ~v command, default = "vi" # MAIL your system mailbox # PAGER paging program used by history command, default = "more" # PS1 primary prompt # PS2 secondary prompt # history number of commands in history list, default = 22 # histfile file history list is saved in, default = $HOME/.bhistory # savehist number of commands remembered from last bcsh session # aliasfile file of aliased commands, default = $HOME/.baliases # logoutfile file of commands to be executed before termination # inc_cmdno yes/no -- keep track of command numbers or not # noclobber if set, existing files are not overwritten by '>' # iclobber if both noclobber and iclobber are set, the user is # prompted for confirmation before existing files are # overwritten by '>' # # Note: if you are setting either noclobber or iclobber mid-session, # set them to 'yes' # # # Regular Shell Variables: # ------------------------ # # Shell variables may be set via Bourne or cshell syntax, e.g., both # "set foo=bar" and "foo=bar" set a variable called "foo" with the value # "bar". However, all variables are automatically set as environment # variables, so there is no need to export them. Conversely, there # are NO local variables. Sorry, folks. # # A cshell-style "setenv" command is turned into a regular "set" command. # # # The Prompt: # ---------- # # You may, if you wish, have a command executed in your prompt. If # the variable PS1 contains a dollar sign or a backquote, it is # evaluated and the result used as the prompt, provided the evaluation # did not produce a "not found" error message. The two special cases # of PS1 consisting solely of "$" or "$ " are handled correctly. For # example, to have the prompt contain the current directory followed # by a space, enter: # # PS1=\'echo "`pwd` "\' # # You need the backslashed single quotes to prevent the command being # evaluated by the variable-setting mechanism and the shell before it # is assigned to PS1. # # To include the command number in your prompt, enter the command: # # PS1=\'echo "$cmdno "\' # # # Shell Control-Flow Syntax: # -------------------------- # # 'While', 'for', 'case', and 'if' commands entered in Bourne shell # syntax are executed as normal. # # A valiant attempt is made to convert 'foreach' loops into 'for' loops, # cshell-syntax 'while' loops into Bourne shell syntax, and 'switch' # statements into 'case' statements. I cannot guarantee to always get it # right. If you forget the 'do' in a 'while' or 'for' loop, or finish # them with 'end' instead of 'done', this will be corrected. # # Note that cshell-to-Bourne control flow conversions do not take place # if control is nested -- e.g., a 'foreach' inside a 'while' will fail. # # The simple-case cshell "if (condition) command" is turned into Bourne # syntax. Other 'if' statements are left alone apart from making the # 'then' a separate statement, because constructing a valid interactive # cshell 'if' statement is essentially an exercise in frustration anyway. # The cshell and Bourne shell have sufficiently different ideas about # conditions that if is probably best to resign yourself to learning # the Bourne shell conventions. # # Note that since most of the testing built-ins of the cshell are # not available in the Bourne shell, a complex condition in a 'while' # loop or an 'if' statement will probably fail. # # # Bugs, Caveats, etc.: # -------------------- # # This is not a super-speedy program. Be patient, especially on startup. # # To the best of my knowledge this program should work on ANY Bourne # shell -- note that if your shell does not understand 'echo -n' you # will have to re-set the values of '$n' and '$c'. # # This program may run out of stack space on a 16-bit machine where # /bin/sh is not split-space. # # Mail checking is done every 10 commands if $MAIL is set in your # environment. For anything fancier, you will have to hack the code. # # Because commands are stuffed in a file before sh is invoked on them, # error messages from failed commands are ugly. # # Failed history substitutions either give nothing at all, or a # "not found" style of error message. # # A command history is kept whether you want it or not. This may be # perceived as a bug or a feature, depending on which side of bed you # got out on. # # If you want a real backslash in a command, you will have to type two # of them because the shell swallows the first backslash in the initial # command pickup. This means that to include a non-history '!' in a # command you need '\\!' -- a real wart, especially for net mail, # but unavoidable. # # Commands containing an '@' will break all sorts of things. # # Very complex history substitutions may fail. # # File names containing numbers may break numeric history sustitutions. # # Commands containing bizzare sequences of characters may conflict # with internal kludges. # # Aliasing something to "commands;logout" will not work -- if you # want something to happen routinely on logout, put it in the file # specified by $logoutfile, default = $HOME/.blogout. # # Please send all bug reports to ihnp4!utzoo!globetek!chris. # Flames will be posted to net.general with 'Reply-to' set to your # ' path... :-) ' # # # # ************* VERY IMPORTANT NOTICE ************* # # If your shell supports # comments, then REPLACE all the colon 'comments' # with # comments. If it does not, then REMOVE all the 'comment' lines from the # working copy of the file, as it will run MUCH faster -- the shell evaluates # lines starting with a colon but does not actually execute them, so you will # save the read-and-evaluate time by removing them. case "`echo -n foo`" in -n*) n= c="\c" ;; foo) n=-n c= ;; *) echo "Your 'echo' command is broken." exit 1 ;; esac history=${history-22} savehist=${savehist-22} histfile=${histfile-$HOME/.bhistory} logoutfile=${logoutfile-$HOME/.blogout} EDITOR=${EDITOR-ed} VISUAL=${VISUAL-vi} PAGER=${PAGER-more} aliasfile=${aliasfile-$HOME/.baliases} # the alias file may contain 1 blank line, so a test -s will not work case "`cat $aliasfile 2> /dev/null`" in "") doalias=no ;; *) doalias=yes ;; esac if test -s "${sourcefile-$HOME/.bcshrc}" then . ${sourcefile-$HOME/.bcshrc} fi if test -s "$histfile" then cmdno="`set - \`wc -l $histfile\`;echo $1`" cmdno="`expr \"$cmdno\" + 1`" lastcmd="`sed -n '$p' $histfile`" copy=false ohist=$histfile while test ! -w "$histfile" do echo "Cannot write to history file '$histfile'." echo $n "Please enter a new history filename: $c" read histfile copy=true done if $copy then cp $ohist $histfile fi else cat /dev/null > $histfile cmdno=1 lastcmd= fi # keep track of command number as the default inc_cmdno=${inc_cmdo-yes} # default prompts -- PS1 and PS2 may be SET but EMPTY, so '${PS1-% }' syntax # is not used here case "$PS1" in "") PS1="% " ;; esac case "$PS2" in "") PS2="> " ;; esac export histfile savehist history aliasfile EDITOR VISUAL PAGER cmdno PS1 PS2 case "$MAIL" in "") ;; *) if [ -f $MAIL ]; then mailsize=`set - \`wc -c $MAIL\`;echo $1` else mailsize=0 fi ;; esac trap ':' 2 trap exit 3 trap "tail -n $savehist $histfile>/tmp/hist$$;uniq /tmp/hist$$ > $histfile;\ rm -f /tmp/*$$;exit 0" 15 getcmd=yes mailcheck= exclaim= echoit= mailprompt= while : do run=yes case "$mailprompt" in "") ;; *) echo "$mailprompt" ;; esac case "$getcmd" in yes) : guess if the prompt should be evaluated or not case "$PS1" in \$|\$\ ) echo $n "$PS1$c" ;; *\`*|*\$*) tmp="`(eval $PS1) 2>&1`" case "$tmp" in *not\ found) echo $n "$PS1$c" ;; *) echo $n "$tmp$c" ;; esac ;; *) echo $n "$PS1$c" ;; esac read cmd || cmd="exit" ;; *) ;; esac case "$MAIL" in "") ;; *) : check for mail every 10 commands case "$mailcheck" in 1111111111) mailcheck= if [ -f $MAIL ]; then newsize="`set - \`wc -c $MAIL\`;echo $1`" else newsize=0 fi if test "$newsize" -gt "$mailsize"; then mailprompt="You have new mail" else mailprompt= fi mailsize=$newsize ;; *) mailcheck=1$mailcheck ;; esac ;; esac hist=no case "$cmd" in "") continue ;; sh) sh run=no ;; !!) cmd=$lastcmd echoit=yes getcmd=no continue ;; *:p) cmd="`expr \"$cmd\" : '\(.*\):p'` +~+p" getcmd=no continue ;; foreach[\ \ ]*) while test "$line" != "end"; do echo $n "$PS2$c" read line cmd="${cmd};$line" done echo "$cmd" > /tmp/bcsh$$ ed - /tmp/bcsh$$ << ++++ s/end/done/ s/foreach[ ]\(.*\)(/for \1 in / s/)// s/;/;do / w ++++ ;; for[\ \ ]*|while[\ \ ]*) # try to catch the most common cshell-to-Bourne-shell # mistakes echo $n "$PS2$c" read line case "$line" in *do) line="do :" ;; *do*) ;; *) line="do $line" ;; esac cmd="${cmd};$line" while test "$line" != "done" && test "$line" != "end" do echo $n "$PS2$c" read line case "$line" in end) line=done ;; esac cmd="${cmd};$line" done echo "$cmd" > /tmp/bcsh$$ ;; if[\ \ ]*) while test "$line" != "fi" && test "$line" != "endif" do echo $n "$PS2$c" read line case "$line" in *[a-z]*then) line="`expr \"$line\" : '\(.*\)then'`;then" ;; endif) line=fi ;; esac cmd="${cmd};$line" done echo "$cmd" > /tmp/bcsh$$ case "`grep then /tmp/bcsh$$`" in "") # fix 'if foo bar' cases ed - /tmp/bcsh$$ << ++++ s/)/);then/ s/.*/;fi/ w ++++ ;; esac ;; case[\ \ ]*) while test "$line" != "esac" do echo $n "$PS2$c" read line cmd="${cmd}@$line" done cmd="`echo \"$cmd\" | tr '@' ' '`" echo "$cmd" > /tmp/bcsh$$ ;; switch[\ \ ]*) while test "$line" != "endsw" do echo $n "$PS2$c" read line cmd="${cmd}@$line" done echo "$cmd" > /tmp/bcsh$$ ed - /tmp/bcsh$$ << '++++' 1,$s/@/\ /g g/switch.*(/s//case "/ s/)/" in/ 1,$s/case[ ]\(.*\):$/;;\ \1)/ 2d 1,$s/endsw/;;\ esac/ g/breaksw/s/// 1,$s/default.*/;;\ *)/ w ++++ cmd="`cat /tmp/bcsh$$`" ;; *!*) hist=yes ;; esac case "$hist" in yes) # deal with genuine exclamation marks, go back and parse again case "$cmd" in *\>![\ \ ]*|*\\!*) cmd="`echo \"$cmd\" | sed -e 's@\\!@REALEXCLAMATIONMARK@g'`" exclaim=yes getcmd=no continue ;; esac # break command into elements, parse each one tmp= for i in $cmd do # find element with !, peel off stuff up to ! case "$i" in !) # most likely a typo for !!, so fix it front= $i=!! ;; !!*) front= i="`expr \"$i\" : '.*\(!!.*\)'`" ;; *!!*) front="`expr \"$i\" : '\(.*\)!!.*'`" i="`expr \"$i\" : '.*\(!!.*\)'`" ;; !*) front= i="`expr \"$i\" : '.*!\(.*\)'`" ;; *) tmp="$tmp$i " continue ;; esac case "$i" in !!*) # want last command rest="`expr \"$i\" : '!!\(.*\)'`" i=$lastcmd ;; -*) # we want to search back through the history list case "$i" in -) rest="`expr \"$i\" : '-\(.*\)'`" i=$lastcmd ;; -[0-9]*) wanted="`expr \"$i\" : '-\([0-9][0-9]*\).*'`" rest="`expr \"$i\" : '-[0-9][0-9]*\(.*\)'`" i="`tail -n $wanted $histfile | sed -e "1q"`" ;; esac ;; [0-9]*) # find which number command is wanted wanted="`expr \"$i\" : '\([0-9][0-9]*\).*'`" rest="`expr \"$i\" : '[0-9][0-9]*\(.*\)'`" i="`grep -n . $histfile | grep \"^$wanted\"`" i="`expr \"$i\" : \"${wanted}.\(.*\)\"`" ;; \?*) # find which 'command-contains' match is wanted case "$i" in \?{*}*) wanted="`expr \"$i\" : '?{\(.*\)}.*'`" rest="`expr \"$i\" : '?.*}\(.*\)'`" ;; \?*:*) wanted="`expr \"$i\" : '?\(.*\):.*'`" rest="`expr \"$i\" : '?.*\(:.*\)'`" ;; \?*) wanted="`expr \"$i\" : '?\(.*\)'`" rest= ;; esac i="`grep \"$wanted\" $histfile | sed -n '$p'`" ;; *) # find which 'start-of-command' match is wanted case "$i" in {*}*) wanted="`expr \"$i\" : '{\(.*\)}.*'`" rest="`expr \"$i\" : '.*}\(.*\)'`" ;; *:*) wanted="`expr \"$i\" : '\(.*\):.*'`" rest="`expr \"$i\" : '.*\(:.*\)'`" ;; *) wanted="$i" rest= ;; esac i="`grep \"^$wanted\" $histfile | sed -n '$p'`" ;; esac # see if we actually found anything to substitute case "$i" in "") badsub="Event not found" break ;; *) badsub=no ;; esac case "$rest" in "") tmp="$front$tmp$i " continue ;; :[0-9]*) # find which element of $i is wanted number="`expr \"$rest\" : ':\([0-9][0-9]*\).*'`" rest="`expr \"$rest\" : ':[0-9][0-9]*\(.*\)'`" # count through $i till we get to the # right element counter=0 for element in $i do case "$counter" in $number) break ;; *) counter="`expr \"$counter\" + 1`" # counter=$[ $counter + 1 ] ;; esac done case "$counter" in $number) badsub=no ;; *) badsub="Bad command element" break ;; esac tmp="$tmp$front$element$rest " continue ;; :\$*) # spin through $i till we hit the last element rest="`expr \"$rest\" : ':\$\(.*\)'`" for element in $i do : done tmp="$tmp$front$element$rest " continue ;; :\**) # we want all elements except the command itself rest="`expr \"$rest\" : ':\*\(.*\)'`" save=$i set - $i shift case "$*" in "") badsub="No arguments to command '$save'" break ;; *) badsub=no ;; esac tmp="$tmp$front$*$rest " continue ;; :s*|:gs*) # we are doing a substitution # put / on end if needed case "$rest" in :s/*/*/*|:gs/*/*/*) ;; :s/*/*|:gs/*/*) rest="${rest}/" ;; esac # find what substitution is wanted first="`expr \"$rest\" : ':*s\/\(.*\)\/.*\/.*'`" second="`expr \"$i\" : ':*s/.*/\(.*\)/.*'`" # see if it is a global substitution case "$rest" in :gs*) global=g ;; :s*) global= ;; esac rest="`expr \"$rest\" : '.*/.*/.*/\(.*\)'`" i="`echo \"$i\" | sed -e \"s@$first@$second@$global\"`" # see if subsitution worked case "$i" in "") badsub="Substiution failed" break ;; *) badsub=no ;; esac tmp="$tmp$front$i$rest " continue ;; *) tmp="$tmp$front$i$rest " ;; esac done case "$badsub" in no) ;; *) echo "$badsub" badsub=no continue ;; esac cmd="$tmp" echoit=yes getcmd=no continue ;; *) run=yes ;; esac case "$cmd" in *\^*\^*\^*) # see if the substitution is global case "$cmd" in g*) global=g ;; *) global= ;; esac # put a '^' on the end if necessary case "$cmd" in *\^) ;; *) cmd="${cmd}^" ;; esac # find what substitution is wanted first="`expr \"$cmd\" : '*\^\(.*\)\^.*\^.*'`" second="`expr \"$cmd\" : '*\^.*\^\(.*\)\^.*'`" rest="`expr \"$cmd\" : '*\^.*\^.*\^\(.*\)'`" cmd="`echo \"$lastcmd\" | sed -e \"s@$first@$second@$global\"`$rest" # see if the substitution worked case "$cmd" in "") echo "Substitution failed" continue ;; esac echoit=yes getcmd=no continue ;; *~e) echo "$cmd" | sed -e "s@~e@@" > /tmp/bcsh$$ $EDITOR /tmp/bcsh$$ cmd="`cat /tmp/bcsh$$`" getcmd=no continue ;; *~v) echo "$cmd" | sed -e "s@~v@@" > /tmp/bcsh$$ echo "$lastcmd" > /tmp/bcsh$$ $VISUAL /tmp/bcsh$$ cmd="`cat /tmp/bcsh$$`" getcmd=no continue ;; exec[\ \ ]*) tail -n $savehist $histfile>/tmp/hist$$ uniq /tmp/hist$$ > $histfile rm -f /tmp/*$$ echo $cmd > /tmp/cmd$$ . /tmp/cmd$$ ;; login[\ \ ]*|newgrp[\ \ ]*) tail -n $savehist $histfile>/tmp/hist$$ uniq /tmp/hist$$ > $histfile rm -f /tmp/*$$ echo $cmd > /tmp/cmd$$ . /tmp/cmd$$ ;; logout|exit|bye) if test -s "$logoutfile" then # sh $logoutfile $SHELL $logoutfile fi tail -n $savehist $histfile > /tmp/hist$$ uniq /tmp/hist$$ > $histfile rm -f /tmp/*$$ exit 0 ;; h|history) grep -n . $histfile | tail -n $history | sed -e 's@:@ @' | $PAGER continue ;; h[\ \ ]\|*|h[\ \ ]\>*|h\|*|h\>*) cmd="`echo \"$cmd\" | sed -e \"s@h@grep -n . $histfile | tail -n $history | sed -e 's@:@ @'@\"`" getcmd=no continue ;; history[\ \ ]*\|*|history[\ \ ]*\>*) cmd="`echo \"$cmd\" | sed -e \"s@history@grep -n . $histfile | tail -n $history | sed -e 's@:@ @'@\"`" getcmd=no continue ;; source[\ \ ]*) set - $cmd shift echo . $* > /tmp/cmd$$ . /tmp/cmd$$ run=no ;; wait) wait run=no ;; .[\ \ ]*) echo $cmd > /tmp/cmd$$ . /tmp/cmd$$ run=no ;; cd|cd[\ \ ]*) # check if it will work first, or else this shell will terminate # if the cd dies. If you have a built-in test, you might want # to replace the try-it-and-see below with a couple of tests, # but it is probably just as fast like this. echo $cmd > /tmp/cmd$$ if ($SHELL /tmp/cmd$$) ; then . /tmp/cmd$$ fi run=no ;; awk[\ \ ]*|dd[\ \ ]*|cc[\ \ ]*|make[\ \ ]*) # these are the only commands I can think of whose syntax # includes an equals sign. Add others as you find them. echo "$cmd" > /tmp/bcsh$$ ;; setenv*|*=*) # handle setting shell variables, turning cshell syntax to Bourne # syntax -- note all variables must be exported or they will not # be usable in other commands echo "$cmd" > /tmp/cmd$$ ed - /tmp/cmd$$ << ++++ g/^setenv[ ]/s/[ ]/@/ g/^setenv@/s/[ ]/=/ g/^setenv@/s/// g/^set/s/// .t. \$s/=.*// s/^/export / w ++++ . /tmp/cmd$$ rm -f /tmp/cmd$$ run=no ;; unset[\ \ ]*|umask[\ \ ]*|export[\ \ ]*|set[\ \ ]*) # handle commands which twiddle current environment $cmd run=no ;; alias|alias[\ \ ]) if [ -f $aliasfile ]; then $PAGER $aliasfile fi lastcmd=$cmd run=no continue ;; alias[\ \ ]*) case "$cmd" in alias[\ \ ]\|*|alias[\ \ ]\>*) cmd="`echo \"$cmd\" | sed -e \"s@alias@cat $aliasfile@\"`" getcmd=no continue ;; alias[\ \ ]*[\ \ ]*) ;; *) echo "Syntax: alias name command" cmd= continue ;; esac set - $cmd shift cmd="$*" # make sure there is always 1 blank line in file so # unaliasing will always work -- ed normally refuses # to write an empty file echo "" >> $aliasfile cat << ++++ >> $aliasfile $cmd ++++ # ed - $aliasfile << '++++' # g/alias[ ]/s/// # g/^['"]\(.*\)['"]$/s//\1/ # g/^/s//alias / # w #++++ sort -u -o $aliasfile $aliasfile doalias=yes cmd="alias $cmd" run=no ;; unalias[\ \ ]*) set - $cmd case "$#" in 2) cmd=$2 ;; *) echo "Syntax: unalias alias_name" continue ;; esac ed - $aliasfile << ++++ /^$cmd[ ]/d w ++++ case "`set - \`wc -l $aliasfile\`;echo $1`" in 1) # just removed last alias doalias=no ;; esac run=no ;; *) case "$doalias" in yes) set - $cmd tmp="`grep \"^$1 \" $aliasfile`" case "$tmp" in $1[\ \ ]*) shift cmd=$* set - $tmp shift tmp=$* case "$tmp" in *\$*) # uses positional variables cmd="set - $cmd ; $tmp" getcmd=no continue ;; *) cmd="$tmp $cmd" getcmd=no continue ;; esac ;; *) echo "$cmd" > /tmp/bcsh$$ ;; esac ;; no) echo "$cmd" > /tmp/bcsh$$ ;; esac ;; esac case "$cmd" in *+~+p) cmd="`expr \"$cmd\" : '\(.*\)+~+p'`" echoit=yes run=no ;; esac case "$cmd" in "") continue ;; *) case "$exclaim" in yes) cmd="`echo \"$cmd\" | sed -e 's@REALEXCLAMATIONMARK@!@g'`" echo "$cmd" > /tmp/bcsh$$ ;; esac case "$echoit" in yes) echo $cmd ;; esac case "$run" in yes) case "${noclobber+yes}" in yes) case "$cmd" in *\>![\ \ ]*) ed - /tmp/bcsh$$ << ++++ g/>!/s//>/ w ++++ ;; *\>\>*) ;; *\>*) outfile="`expr \"$cmd\" : '.*>\(.*\)'`" case "$outfile" in \&*) ;; *) set - $outfile outfile="$1" if test -s "$outfile" then case "${iclobber+yes}" in yes) echo $n "Overwrite ${outfile}? $c" read answer case "$answer" in y*) ;; *) echo ':' > /tmp/bcsh$$ ;; esac ;; *) echo "${outfile}: file exists" echo ':' > /tmp/bcsh$$ ;; esac fi ;; esac ;; esac ;; *) case "$cmd" in *\>![\ \ ]*) ed - /tmp/bcsh$$ << ++++ g/>!/s//>/g w ++++ ;; esac ;; esac (trap 'exit 1' 2 3; $BASH /tmp/bcsh$$) ;; esac case "$cmd" in $lastcmd) ;; *) case "$exclaim" in yes) cmd="`echo \"$cmd\" | sed -e 's@!@\\\\!@g'`" ;; esac cat << ++++ >> $histfile $cmd ++++ lastcmd=$cmd case "$inc_cmdno" in yes) cmdno="`expr \"$cmdno\" + 1`" # cmdno=$[$cmdno + 1] ;; esac ;; esac ;; esac # The next commented-out line sets the prompt to include the command # number -- you should only un-comment this if it is the ONLY thing # you ever want as your prompt, because it will override attempts # to set PS1 from the command level. If you want the command number # in your prompt without sacrificing the ability to change the prompt # later, replace the default setting for PS1 before the beginning of # the main loop with the following: PS1='echo -n "${cmdno}% "' # Doing it this way is, however, slower than the simple version below. PS1="${cmdno}% " getcmd=yes echoit=no exclaim=no done exit 0 # Christine Robertson {linus, ihnp4, decvax}!utzoo!globetek!chris