Softpanorama (slightly skeptical) Open Source Software Educational Society

May the source be with you, but remember the KISS principle ;-) Softpanorama Search

Bash as an Enterprise-level Shell

Bash is a standard shell on Linux and with version 3.2 available on all enterprise platform and installed on Solaris and AIX it make sense to make it standard shell on all enterprise-class Unixes. Only HP-UX does not include bash by-default.  Bash 3.2 and later has important enhancements that make it a better shell (see Annotated List of Bash Enhancements) although scripts should be generally limited to small to medium size as Perl represents much better scripting environment then bash. 

While bash has a humble start and much weaker designer then ksh93 and was at times extremely buggy, the gap narrowed in version 3.2 to the extent that better command line user friendliness of bash make it more attractive. Most ksh93 innovations are now present in some form in bash 3.2.  As bash is standard shell on Linux and is installed by default in Solaris it status as an enterprise shell is almost as strong as ksh93 (which is mostly present in old, weaker versions. Current bash has the best debugger and from this point of view represents the best shell. 

Bash 3.2 and later is the one of the most portable advanced shell around (ksh93 and zsh are still a strong competition; ksh93 is definitely more reliable for scripts and does not contain such design blunders as the last stage of the pipe belonging to subshell instead of the invoking shell ). 

Bash-related books dominates shell-related publications and as such the level of known-how for bash is higher then for other shells (see Best Shell Books). The advantage of bash for large enterprise environment is that it comes by default with linux, Solaris and AIX. Only HP-UX does not have installed by default. Also it is the best portable interactive shell , much closer to tcsh then any competition. 

Still you need some efforts to make the default shell. Unfortunately the default shell for Solaris is the "Bourne shell" or /usr/bin/sh

Bourne shell is a pretty weak outdated shell and attempt to base shell scripting portability on this outdated shell is a serious strategic error (bash probably should be used instead). It is still used as root shell in Solaris but that's due to Solaris legacy not because it gives anything but disadvantages; attempts to claim that this somehow increases the security of root due to the fact that it is static linked are weak and the argumentation is open for discussion. All-in-all usage of Bourne shell as a default root shell in Solaris might be considered to be a blunder: system administrators definitely need a better shell.

Usage of Borne shall as a default shell might slightly increase the chances of recovery in case /usr  partition is damaged, but this is a pretty serious case and usually means serious troubles with other partitions on the disk anyway (unless this is the case when in Solaris link /bin -> usr/bin is destroyed, but such cases are simple to fight by refereeing shell as /usr/bin/ksh in /etc/passwd). If this is a serious trouble than booting from a CD a mounting the damaged volume is always a good idea and in this case it does not matter what shell root is using; you can change it anyway.

The bash archive contains a main directory and a set of files and subdirectories. Among the first files you should examine are:

CHANGES A comprehensive list of bug fixes and new features since the last version

COPYING The GNU Copyleft for bash

MANIFEST A list of all the files and directories in the archive

NEWS A list of new features since the last version

README A short introduction and instructions for compiling bash

doc Directory with information related to bash in various formats

examples Directory with examples of startup files, scripts, and functions

The doc directory contains a few articles that are worth reading. You can print man page for reference with command  nroff-man bash.1 | more  It is convenient to have a hardcopy so you can write notes all over it. Also valuable, FAQ is a Frequently Asked Questions document with answers, readline.3 is the manual entry for the readline facility, and article.ms is an article about the shell that appeared in Linux Journal, and was written by the current bash maintainer Chet Ramey.  An examples directory that is well worth exploring (after you've finished reading this book, of course). It includes sample code, scripts, functions, and startup files. See Examples shipped with bash 3.2 and newer

Some interesting features of bash include:

• Special COMMAND_PROMPT built-in variable makes it easy to use functions for command prompt generation. For example the color of the prompt can be changed dynamically depending of the whether you are root or not and what was the return code of the last command.  See Bash Prompt HOWTO
• A lot of borrowing from tcsh including:
  • built-in-in pushd/popd/dirs commands (implementation leaves much to be desired as there is no way to avoid duplicates like in tcsh, but still it is slightly better then nothing ;-). References to directories based on content of DIRSTACK are also implemented (cd ~1; cd ~2; etc)
  • C-shell style history info retrieval:
    • Arrows based browsing of history works out of the box.
    • ! C-shell style history retrieval.  !$ is the last argument of the previous line
    • HISTCONTROL may now include the erasedups option (version 3.0 and higher)
    • C-shell style arrows keys history browsing
    • "bang commands" repeatedly, saving you some typing (via the "!<digit> syntax).
• Indexed arrays of unlimited size
• Integer arithmetic in any base from two to sixty-four
• Availability of =~ operator that permits using more or less normal regular expressions (it's incredible stupidity to use a dozen of regular expression definitions in a single OS like is the case with Unix and Linux).
  Note: bash before version 3.2.17 has extremely buggy and unreliable support of this feature. Generally it should never be used in production before version of 3.2.17.
   
• Normal for loop with index. for (( expr1 ; expr2 ; expr3 )) ; do list ; done
• Process substitution  (  > (command) and < (command) ). It's not enabled by default. and need to be enabled by the command set +o posix  Two forms of process substitution are: 
  • <(list) To substitute a command pipeline for an input file
  • >(list) To substitute a command pipeline for an output file

  In the case of the < and > forms, the shell will run process list asynchronously, connected to a named pipe (FIFO). The name of this pipe will become the argument to the command.

   

  Please visit  Heiner Steven SHELLdorado  the best shell scripting site on the Internet

  
  If the form with < is selected then result of execution of the process list will serve as an input file. This, for allows you to use the output of one or several commands as parameters to the utilities that accepts file. For instance you can compare the contents of two directories by typing:

  diff <( ls dir1 ) <( ls dir2 )

  That can be used for concatenating input in pipes:

  cat <(echo hello) <(echo world) | echo

  If < is used, then the file passed as an argument will be a named pipe connected to the output of the list process.

  Another, more complex,  example,

  paste <(cut -f1 file1) < (cut -f3 file2) | tee >(process1) >(process2) >/dev/null

  cuts fields 1 and 3 from the files file1 and file2 respectively, pastes the results together, and sends it to the processes process1 and process2. Note that the file, which is passed as an argument to the command, is a system pipe so programs that expect to lseek(2) on the file will not work. Also note that the previous example can be more compactly and efficiently written as:

  paste <(cut -f1 file1) <(cut -f3 file2) >>(process1) >>(process2)

  The shell uses pipes instead of FIFOs to implement the latter two process substitutions in the above example.

  See also the article in Linux Journal: Bash Process Substitution
   

• Other interesting features include (from the FAQ):
  • new `time' reserved word to time pipelines, shell built-ins, and shell functions
  • one-dimensional arrays with a new compound assignment statement,
  • appropriate expansion constructs and modifications to some of the built-ins (read, declare, etc.)
  • new quoting syntaxes for ANSI-C string expansion and locale-specific string translation
  • new expansions to do substring extraction, pattern replacement, and indirect variable expansion
  • new built-ins: `disown' and `shopt'
  • new variables: HISTIGNORE, SHELLOPTS, PIPESTATUS, DIRSTACK, GLOBIGNORE, MACHTYPE, BASH_VERSINFO
  • new prompt expansions: \a, \e, \n, \H, \T, \@, \v, \V
  • history and aliases can be used in shell scripts, not only in interective sessions. 
  • new readline variables: enable-keypad, mark-directories, input-meta, visible-stats, disable-completion, comment-begin
  • new readline commands to manipulate the mark and operate on the region
  • new DEBUG trap
  • expanded (and now documented) restricted shell mode

Due to this bash shell is gradually gaining grounds as the preferred interactive shell for Solaris and other enterprize class Unixes.

Older version of bash (2.x series) are obsolete and should not be used. The recommended version is 3.2 patch level 3 or above.  The latter is a recommended version as it's more compatible with ksh93. It supports many important enhancements introduced by ksh93.

Old News ;-)

• The `read' builtin has a new -i option which inserts text into the reply buffer when using readline.
• The `declare' builtin now has new -l (convert value to lowercase upon assignment) and -u (convert value to uppercase upon assignment) options. There is an optionally-configurable -c option to capitalize a value at    assignment.
• The -p option to `declare' now displays all variable values and attributes
      (or function values and attributes if used with -f).
• There is a new `coproc' reserved word that specifies a coprocess: an asynchronous command run with two pipes connected to the creating shell. Coprocs can be named.  The input and output file descriptors and the PID of the coprocess are available to the calling shell in variables  with coproc-specific names.
• There is a new `autocd' option that, when enabled, causes bash to attempt  to `cd' to a directory name that is supplied as the first word of a simple command. [you can now type ls /bin/ and get equvalent of ls /bin; cd /bin. Is not this stupid ? NNB]
• There is a new `checkjobs' option that causes the shell to check for and   report any running or stopped jobs at exit.
•  The programmable completion code exports a new COMP_TYPE variable, set to  a character describing the type of completion being attempted.
• The shell now has the notion of a `compatibility level', controlled by
      new variables settable by `shopt'.  Setting this variable currently
      restores the bash-3.1 behavior when processing quoted strings on the rhs
      of the `=~' operator to the `[[' command.
• There is a new shell option: `globstar'.  When enabled, the globbing code  treats `**' specially -- it matches all directories (and files within  them, when appropriate) recursively.
• There is a new shell option: `dirspell'.  When enabled, the filename  completion code performs spelling correction on directory names during   completion.
• There is a new bash-specific bindable readline function: `dabbrev-expand'.  It uses menu completion on a set of words taken from the history list.
• The parser now understands `|&' as a synonym for `2>&1 |', which redirects  the standard error for a command through a pipe.
• The new `;&' case statement action list terminator causes execution to  continue with the action associated with the next pattern in the  statement rather than terminating the command.
• The new `;;&' case statement action list terminator causes the shell to  test the next set of patterns after completing execution of the current  action, rather than terminating the command.
• There are new case-modifying word expansions: uppercase (^[^]) and    lowercase (,[,]).  They can work on either the first character or  array element, or globally.  They accept an optional shell pattern  that determines which characters to modify.  There is an optionally-configured feature to include capitalization operators.
• The shell provides associative array variables, with the appropriate support to create, delete, assign values to, and expand them.
• CDPATH and GLOBIGNORE are ignored when the shell is running in privileged  mode.
• New Features in Readline

  a.  A new variable, rl_sort_completion_matches; allows applications to inhibit  match list sorting (but beware: some things don't work right if applications do this).
  
  b.  A new variable, rl_completion_invoking_key; allows applications to discover  the key that invoked rl_complete or rl_menu_complete.
  
  c.  The functions rl_block_sigint and rl_release_sigint are now public and  available to calling applications who want to protect critical sections  (like redisplay).
  
  d.  The functions rl_save_state and rl_restore_state are now public and  available to calling applications; documented rest of readline's state flag values.
  
  e.  A new user-settable variable, `history-size', allows setting the maximum number of entries in the history list.
  
  f.  There is a new implementation of menu completion, with several improvements  over the old; the most notable improvement is a better `completions browsing' mode.
  
  g.  The menu completion code now uses the rl_menu_completion_entry_function variable, allowing applications to provide their own menu completion generators.
  
  h.  There is support for replacing a prefix  of a pathname with a `...' when displaying possible completions.  This is controllable by setting the  `completion-prefix-display-length' variable.  Matches with a common prefix longer than this value have the common prefix replaced with `...'.
  
  i.  There is a new `revert-all-at-newline' variable.  If enabled, readline will undo all outstanding changes to all history lines when `accept-line' is executed.
  
  j.  If the kernel supports it, readline displays special characters  corresponding to a keyboard-generated signal when the signal is received.

The Advanced Bash Scripting Guide is both a reference and a tutorial on shell scripting. This comprehensive book (the equivalent of about 646 print pages) covers almost every aspect of shell scripting. It contains over 300 profusely commented illustrative examples, and a number of tables. Not just a shell scripting tutorial, this book also provides an introduction to basic programming techniques, such as sorting and recursion. It is well suited for either individual study or classroom use.

GeSHi - Generic Syntax Highlighter Home

Can be used for shell scripts and bash initrc

Bash Config Files

How Bash executes startup files.

For Login shells (subject to the -noprofile option):

On logging in:
If `/etc/profile' exists, then source it.

If `~/.bash_profile' exists, then source it,
else if `~/.bash_login' exists, then source it,
else if `~/.profile' exists, then source it.

On logging out:
If `~/.bash_logout' exists, source it.

For non-login interactive shells (subject to the -norc and -rcfile options):
On starting up:
If `~/.bashrc' exists, then source it.

For non-interactive shells:
On starting up:
If the environment variable `ENV' is non-null, expand the variable and source the file named by the value. If Bash is not started in Posix mode, it looks for `BASH_ENV' before `ENV'.

So, typically, your `~/.bash_profile' contains the line
`if [ -f `~/.bashrc' ]; then source `~/.bashrc'; fi' after (or before) any login specific initializations.

If Bash is invoked as `sh', it tries to mimic the behavior of `sh' as closely as possible. For a login shell, it attempts to source only `/etc/profile' and `~/.profile', in that order. The `-noprofile' option may still be used to disable this behavior. A shell invoked as `sh' does not attempt to source any other startup files.

When Bash is started in POSIX mode, as with the `-posix' command line option, it follows the Posix 1003.2 standard for startup files. In this mode, the `ENV' variable is expanded and that file sourced; no other startup files are read.

My .bashrc can be found here.

My .bash_profile can be found here.

.inputrc (readline)

Although the Readline library comes with a set of Emacs-like key bindings installed by default, it is possible that you would like to use a different set of keybindings. You can customize programs that use Readline by putting commands in an "init" file in your home directory. The name of this file is taken from the value of the shell variable `INPUTRC'. If that variable is unset, the default is `~/.inputrc'.

When a program which uses the Readline library starts up, the init file is read, and the key bindings are set.

In addition, the `C-x C-r' command re-reads this init file, thus incorporating any changes that you might have made to it.

Conditional Init Constructs within readline

Readline implements a facility similar in spirit to the conditional compilation features of the C preprocessor which allows key bindings and variable settings to be performed as the result of tests. There are three parser directives used.

`$if'	The `$if' construct allows bindings to be made based on the editing mode, the terminal being used, or the application using Readline. The text of the test extends to the end of the line; no characters are required to isolate it.
`mode'	The `mode=' form of the `$if' directive is used to test whether Readline is in `emacs' or `vi' mode. This may be used in conjunction with the `set keymap' command, for instance, to set bindings in the `emacs-standard' and `emacs-ctlx' keymaps only if Readline is starting out in `emacs' mode.
`term'	The `term=' form may be used to include terminal-specific key bindings, perhaps to bind the key sequences output by the terminal's function keys. The word on the right side of the `=' is tested against the full name of the terminal and the portion of the terminal name before the first `-'. This allows SUN to match both SUN and SUN-CMD, for instance.
`application'	The APPLICATION construct is used to include application-specific settings. Each program using the Readline library sets the APPLICATION NAME, and you can test for it. This could be used to bind key sequences to functions useful for a specific program.
`$endif'	This command terminates an `$if' command.
`$else'	Commands in this branch of the `$if' directive are executed if the test fails.

The following command adds a key sequence that quotes the current or previous word in Bash:
$if bash
# Quote the current or previous word
"\C-xq": "\eb\"\ef\""
$endif
 

My .inputrc file is here

Last update by Hermann Heimhardt on October 7, 2001

Patch against 2.05 Bash to make cd take 2 Args like ksh

From:	Eli
Subject:	Patch against 2.05 Bash to make cd take 2 Args like ksh
Date:	Fri, 22 Jun 2001 14:38:17 -0400

---

*** origBash/bash-2.05/builtins/cd.def  Wed Oct 11 11:10:20 2000
--- bash-2.05/builtins/cd.def   Fri Jun 22 14:31:08 2001
***************
*** 187,192 ****
--- 187,225 ----
        }
        lflag = interactive ? LCD_PRINTPATH : 0;
      }
+   else if (list->next)
+     {
+       /* if next then 2 args, so replace in PWD arg1 with arg2 */
+       int beginLen, oldLen, newLen, endLen;
+       char *replace;
+       path = get_string_value ("PWD");
+       if (( replace = strstr( path,list->word->word)) == (char *)0 )
+         {
+          builtin_error ("Couldn't find arg1 in PWD");
+          return (EXECUTION_FAILURE);
+       }
+       beginLen = replace - path;
+       oldLen = strlen( list->word->word);
+       newLen = strlen( list->next->word->word);
+       endLen = strlen( path + beginLen + oldLen ) + 1 ;
+ 
+       dirname = xmalloc( beginLen + newLen + endLen );
+       /* copy path up to begining of string to replace */
+       memcpy( dirname, path, beginLen );
+ 
+       /* then add new replacement string */
+       memcpy( dirname + beginLen, list->next->word->word, newLen );
+ 
+       /* finally add end of path after replacement */
+       memcpy( dirname + beginLen + newLen, path + beginLen+
oldLen,endLen);
+ 
+       printf("%s\n",dirname);
+       if (change_to_directory (dirname, no_symlinks))
+       {
+          free(dirname);
+          return (bindpwd (posixly_correct || no_symlinks));
+       }
+     }
    else if (absolute_pathname (list->word->word))
      dirname = list->word->word;
    else if (cdpath = get_string_value ("CDPATH"))

[Nov 26, 2004] kcd Home Page

kcd is a directory change utility under Linux or any other Unix clones. It helps you navigate the directory tree. You can supply the desired directory name in the command line and let kcd find it for you or let kcd show the entire directory tree and use arrow keys to go to the destination directory.

Here is a list some features available in kcd:

• Fast directory rescanning. All directory timestamp is saved so that certain directories do not need rescanning if they are not changed.
• When supply directory in command line and kcd find too many matches. kcd shows all of them and let you select using cursor keys.
• You can tell kcd to skip some directory. You can also chose whether you want the whole directory tree, inside your home directory, etc. They can be set in kcd configuration file.
• Supports bash, ash, pdksh, zsh and tcsh.
• Multiple configuration profiles.
• Priority directory matching via bookmark.
• Fuzzy directory searching (Contributed by Robert Sandilands).
• Supports UTF-8 Unicode encoding with combining characters.
• Supports localization.
• Default, vi, and emacs key binding modes.
• Partial directory tree display.
• Display directory tree without saved data.

kcd is available as stable version and development version. You can distinguish development version from stable version by looking at its version number. Beginning from version 5.0.0, any version x.y.z where y is even is a stable version. Those where y is odd is a development version. Features currently present in the development version will eventually appear in the future stable version 8.0.0.

kcd is distributed in source form under General Public License (GPL).

The program and this web page is maintained by Kriang Lerdsuwanakij

[Nov 15, 2004] Erwin Waterlander, WCD Wherever Change Directory

Another Norton Change Directory (NCD) clone with more features.

Wcd is a program to change directory fast. It saves time typing at the keyboard. One needs to type only a part of a directory name and wcd will jump to it. By default wcd searches for a directory with a name that begins with what has been typed, but the use of wildcards is also fully supported.
For instance:

wcd Desk

will change to directory /home/waterlan/Desktop

But also

wcd *top

will do that.

Wcd is free to use and you can get the source code too.

Some features of wcd:

Full screen interactive directory browser with speed search.

Present the user a list in case of multiple matches.

Wildcards *, ? and [SET] supported.

Directory stack, push pop.

Subdir definition possible. E.g. wcd subdira/subdirb

Long directory names support in Win95/98/NT DOS-box

Windows LAN UNC paths supported.

Change drive and directory at once.

Alias directories.

Ban directories.

'cd' behaviour

Free portable source-code, no special libraries required

Multi platform:
DOS 16 bit, DOS 32 bit, DOS bash, Windows 3.1/95/NT DOS-box, Cygwin bash, Unix ksh, csh, bash and zsh.

Wcd has been tested on: FreeDOS, MS-DOS 6.2, Win95, Win98, Windows NT 4.0, Linux, FreeBSD, HP-UX, SunOS, Solaris, SGI IRIX. Wcd works on any PC and can be ported to any Unix system.

WCD is free software, distributed under GNU General Public License.

[Nov 11, 2004]  Freeware List for SPARC

• Solaris 9
  • bash-3.0-sol9-sparc-local.gz Bash is an sh-compatible shell that incorporates useful features from the Korn shell (ksh) and C shell (csh) - installs in /usr/local.
• Solaris 8
  • bash-3.0-sol8-sparc-local.gz Bash is an sh-compatible shell that incorporates useful features from the Korn shell (ksh) and C shell (csh) - installs in /usr/local.
• bash-3.0.tar.gz Source Code. [Details]

[Nov 5, 2004] Bash 3.0 now has degugger

This is a terse description of the new features added to bash-3.0 since the release of bash-2.05b.  As always, the manual page (doc/bash.1) is the place to look for complete descriptions.

cc. The [[ ... ]] command has a new binary `=~' operator that performs  extended regular expression (egrep-like) matching.

l.  New invocation option:  --debugger.  Enables debugging and turns on new  `extdebug' shell option.

f.  HISTCONTROL may now include the `erasedups' option, which causes all lines matching a line being added to be removed from the history list.

j.  for, case, select, arithmetic commands now keep line number information for the debugger.

p.  `declare -F' now prints out extra line number and source file information if the `extdebug' option is set.

r.  New `caller' builtin to provide a call stack for the bash debugger.

t.  `for', `select', and `case' command heads are printed when `set -x' is enabled.

u.  There is a new {x..y} brace expansion, which is shorthand for {x.x+1, x+2,...,y}.  x and y can be integers or single characters; the sequence  may ascend or descend; the increment is always 1.

v.  New ksh93-like ${!array[@]} expansion, expands to all the keys (indices)  of array.

z.  New `-o plusdirs' option to complete and compgen; if set, causes directory  name completion to be performed and the results added to the rest of the possible completions.

ee. Subexpressions matched by the =~ operator are placed in the new BASH_REMATCH array variable.

gg. New `set -o pipefail' option that causes a pipeline to return a failure status if any of the processes in the pipeline fail, not just the last   one.

kk. The `\W' prompt expansion now abbreviates $HOME as `~', like `\w'.

ll. The error message printed when bash cannot open a shell script supplied as argument 1 now includes the name of the shell, to better identify the error as coming from bash.

2.  New Features in Readline

a.  History expansion has a new `a' modifier equivalent to the `g' modifier for compatibility with the BSD csh.

b.  History expansion has a new `G' modifier equivalent to the BSD csh `g'
    modifier, which performs a substitution once per word.

c.  All non-incremental search operations may now undo the operation of replacing the current line with the history line.

d.  The text inserted by an `a' command in vi mode can be reinserted with  `.'.

e.  New bindable variable, `show-all-if-unmodified'.  If set, the readline completer will list possible completions immediately if there is more  than one completion and partial completion cannot be performed.

g.  History list entries now contain timestamp information; the history file functions know how to read and write timestamp information associated with each entry.

n.  When listing completions, directories have a `/' appended if the  `mark-directories' option has been enabled.

Not much changed (Score:5, Insightful) by opk (149665) on Thursday July 29, @10:28AM (#9831965)

Doesn't seem to be much changed given the version number increase. [[ =~ ]] can match regexes and it can do zsh style {1..3} expansions. Improved multibyte support too. There were bigger changes in some of the 2.0x updates.

Re:First "zsh rules" post! by Anonymous Coward (Score:3) Thursday July 29, @10:30AM Re:First "zsh rules" post! (Score:5, Informative) by opk (149665) on Thursday July 29, @10:46AM (#9832230) Globs are more powerful: **/*.c will recursively search for .c files: much quicker to type than find. You can match file types: e.g. *(@) will get you symlinks. *(U) gets files owned by you. Syntax for alternation is a lot easier. No @(this|that) or !(*.f). Instead, it is (this|that) and ^*.f Next point is completion. It includes a vast range of definitions so completion works well for lots of commands. The completion system handles completing parts of words so it better handles user@host completion. You get descriptions with completion match listings. Completion also has a really powerful context sensitive configuration system so you can make it work the way you like. It has modules. For running a simple shell script it will actually use less space than bash because it doesn't need to load the line editor and other interactive related code into memory. There is much much more. It takes a while to learn everything but if you just enable the completion functions (autoload -U compinit; compinit) you'll find it better than bash or tcsh from day 1.

Re:Just wondering... (Score:5, Informative) by opk (149665) on Thursday July 29, @11:05AM (#9832448)

Zsh is still the best. Bash developers have different priorities. Bash became the default primarily because it is GNU. Zsh has some ugly but powerful features like nested expansions. The two areas where bash is better than zsh is multibyte support and POSIX compliance. Much of that was contributed by IBM and Apple respectively. But if you use the shell a lot, you'll find zsh does a lot of things better. The completion is amazing. And when it isn't emulating sh/posix, it fixes some of the broken design decisions (like word splitting of variables) which saves you from doing stupid things. The FSF actually does development in a very closed manner when it can (the gcc egcs split was partly because of this). Bash is a good example of this. That perhaps a good thing because it is probably good that bash doesn't get some of zsh's nasty (but powerful) features. And if zsh didn't exist, bash might have been forked by now. If you care about your shell, you'll find much more of a community on the zsh lists than the spam filled bug-bash list. You can't even get at alpha releases of bash without being one of the chosen few.

Can arrow key history be like Matlab's? (Score:3, Interesting) by dara (119068) on Thursday July 29, @10:54AM (#9832323)

I read the announcement and it mentions "History traversal with arrow keys", but what I would really like doesn't seem to be mentioned (but perhaps it is possible with bash-2.05, I'm not much of a shell expert). In Matlab, the up-arrow key searches the history for commands that match all the characters on the line. No characters and it acts like a normal bash arrow, if "figure, plot" is at the beginning of the line, it will quickly scroll through all plotting commands that have been entered at the shell. Any idea if this is possible? Dara Parsavand

TThe Fine Print: The following comments are owned by whoever posted them. We are not responsible for them in any way. Re:Can arrow key history be like Matlab's? (Score:2) by Atzanteol (99067) on Thursday July 29, @11:10AM (#9832500) (http://www.edespot.com/~amackenz/) Try 'ctrl+r'. Not *exactly* what you're looking for, but it lets you search through your history. i.e. on an empty line hit ctrl+r, then start typing. [ Parent ] It's not necessary to start on an empty line [n/t] by piranha(jpl) (Score:1) Thursday July 29, @07:25PM Re:Can arrow key history be like Matlab's? (Score:3, Informative) by Anonymous Coward on Thursday July 29, @12:38PM (#9833770) cat >> ~/.inputrc "\e[A": history-search-backward "\e[B": history-search-forward ^D

Re:Can arrow key history be like Matlab's? (Score:1, Informative) by Anonymous Coward on Thursday July 29, @01:17PM (#9834391)

Here you are,put this in .inputrc: "\e[6~": history-search-forward "\e[5~": history-search-backward and use page-up pagge-down to search I can live whithout it since 4dos

Autocompletion like W2K? (Score:2) by tstoneman (589372) on Thursday July 29, @01:12PM (#9834316)

I like bash, but the one thing that it doesn't support (out-of-the-box anyway) is auto-completion a la W2K. In NT, when you hit tab, you can cycle through all the words that can complete the letters you typed... on bash, it shows you a list. Is there a way to make bash behave more like W2K in this sense?

bash completion getting better (Score:3, Informative) by AT (21754) on Thursday July 29, @11:08AM (#9832478)

The completion ability of bash has been steadily improving. There is a nice script here [caliban.org] that sets up a lot of good completion rules for bash.

Re:First "zsh rules" post! (Score:2) by Just Some Guy (3352) <`kirk+slashdot' `at' `strauser.com'> on Thursday July 29, @05:30PM (#9837797) (http://subwiki.honeypot.net/ | Last Journal: Monday September 27, @09:09AM)

That's just... I mean... Wow. Really. I just patched my .zshenv with - export SSH_AUTH_SOCK=$(find 2>/dev/null /tmp -maxdepth 2 -type s -user $USER -regex '/tmp/ssh-.*/agent\..*') + export SSH_AUTH_SOCK=$(echo /tmp/ssh-*/agent.*(=UN)) That's sweet. Thanks for the pointer! The more I learn about zsh, the more I love it.

Re:First "zsh rules" post! (Score:1) by sorbits (516598) on Saturday July 31, @01:09PM (#9853305) (http://macromates.com/)

I will certainly give it a try then! Until now I have sticked with tcsh for one single reason: history substition [go.dlr.de]! Basically it lets me insert text from my history (including the current line) using few symbols (e.g. !$ is the last argument of the previous line) -- it's extremely powerful, e.g. it allows to search in the history and can do substitutions in results, or head/tail for paths etc. I use it a lot to keep down the number of characters I need to type, and I have even assigned hotkeys to some of the substitutions I use the most. This is really the make-or-break feature for wether or not I want to use a shell, so I really hope zsh has something similar!?!

Re:First "zsh rules" post! (Score:5, Informative) by Just Some Guy (3352) <`kirk+slashdot' `at' `strauser.com'> on Thursday July 29, @10:50AM (#9832279) (http://subwiki.honeypot.net/ | Last Journal: Monday September 27, @09:09AM)

Bigs ones for me: A sane auto-completion system. That is, "cvs <tab>" gives a list of all of the commands that cvs understands. "cvs -<tab>" (same as above but tabbing after typing "-") gives a list of all of the options that cvs understands. These are good things. Now, in fairness, bash also has a command completion library. Unfortunately, it's implemented as a huge set of Bash functions. In zsh, "set|wc" returns 179 lines. In bash, "set|wc" returns 3,961 lines. The net effect is that zsh's system is noticeably faster and less polluting to the local environment. Modules. Wrappers for TCP connections, a built-in cron thingy, and PCRE are all loadable modules to do tricky things easily. Lots of pre-defined things. Load the "colors" and "zsh/terminfo" modules and you get defined associative arrays like $fg, which emits terminal-appropriate escape codes to set the foreground color of printed text. The command "echo ${fg[red]}red text${fg[default]}normal text" prints "red text" in red, and "normal text" in your default color. Bash is a good shell, and I have nothing bad to say about it. However, zsh seems to have been designed from the ground up by power users and for power users. I absolutely love it and everyone that I've given a example config file to (to get them running with little hassle) has permanently switched.

Re:First "zsh rules" post! (Score:5, Informative) by Just Some Guy (3352) <`kirk+slashdot' `at' `strauser.com'> on Thursday July 29, @11:21AM (#9832638) (http://subwiki.honeypot.net/ | Last Journal: Monday September 27, @09:09AM)

As the maintainer of FreeBSD's bash-completion [freshports.org] port, I'm reasonably familiar with it. Yes, it's approximately as powerful as zsh's completion module. Still, have you ever looked at it? It's a giant set of defined functions and glue. Seriously, get to a bash prompt and type "set" to see all of the things that've been stuffed into your shell's namespace. Now, try that with zsh and be pleasantly surprised. As I said in another post, a big side effect is that zsh's completions seem to be much faster than bash's. That alone is worth the price of admission for me.

Re:Dear Apple haters... (Score:5, Informative) by Jahf (21968) on Thursday July 29, @10:58AM (#9832361) (Last Journal: Thursday August 05, @03:55PM)

Believe it or not, -most- of the large companies that use GPL'ed tools give back to the community. Apple has done numerous fixes, not just on BASH. Sun (disclaimer: for whom I work) has done -tons- of work on GNOME, Mozilla and don't forget Open Office (just to name a few). IBM works on many projects and gives back ... plus contributing all new things like JFS. All the distro makers like Red Hat, Novell, etc give back tons. Each of those companies pay engineers to fix pieces not done in Open Source projects as well as to extend them for their customers. The patches are covered under GPL just like the main code, and these companies know it and yet knowingly dedicate serious money and hours to these projects. And then they satisfy the GPL by putting them out on source CDs or submitting them back to the main projects. The big problem for getting submitted code accepted is that these companies are usually fixing and developing on a codebase that is aging. For instance, Sun did numerous I18N fixes for GNOME 2.6, but by the time they were ready the main GNOME organization had moved on to 2.8. That means there is a disconnect between the two and the changes have to be ported forward before they will hit the main code branch. The same problem can happen with kernel patches and just about any other codebase that changes versions so quickly. Sorry, you were doing the good thing and pointing out Apple's contributions. But so many people think these companies violate the GPL (in spirit if not in law) when they are very large contributors to open source. Sure, some do, and the community usually find out about it and shame them into minimal compliance (Linksys and Sveasoft come to mind after my delving into alternate WRT54G firmwares last night), but generally speaking the big companies have been a good part of the community.

Re:On the list of changes: (Score:5, Informative) by Prowl (554277) on Thursday July 29, @11:12AM (#9832526)

GNU or Unix would seem to be the most appropriate bash has been around since 1989 (according to copywrite on man page). Linux 1.0 came around 5 years later. The editors should know better, unless they're intentionally trying to piss off RMS

Looks great, but prefer Ash for scripts (Score:3, Interesting) by Etcetera (14711) * <<cleaver> <at> <rohan.sdsu.edu>> on Thursday July 29, @10:41AM (#9832171) (http://www-rohan.sdsu.edu/~cleaver/software/)

Looks like a nice Unicode-savvy release that should help with dealing with international languages at the command line. And yay to Apple for giving back (again). When will people finally accept that Apple is indeed helping out the OSS community through GCC, bash, and other tools...? Kind of off-topic, but for speed purposes in scripts that have to run fast, I find nothing better or more convenient than Ash, especially on systems where /bin/sh is a symlink to /bin/bash. Does anyone know any history on this shell? Is it a clone of the original bourne shell or of bash? I can't seem to find anything useful on Google ...

Re:Looks great, but prefer Ash for scripts (Score:2) by mihalis (28146) on Thursday July 29, @10:52AM (#9832301) (http://www.mihalis.net)

As I understand it, ash was written by Kenneth Almquist. I used to see his name on some of the Ada related mailing lists and newsgroups.

Re:Looks great, but prefer Ash for scripts (Score:2, Informative) by Stephen Williams (23750) on Thursday July 29, @11:46AM (#9832931) (http://nysa.cx/journal/ | Last Journal: Thursday December 05, @05:02AM)

Ash (or dash, as it's called nowadays) is a Linux port of NetBSD's /bin/sh. It's a POSIX shell with separate lineage from bash. http://gondor.apana.org.au/~herbert/dash/ It's /bin/sh on my system too. Faster and smaller than bash; watch those configure scripts fly! -Stephen

Some people don't agree. (Score:2) by emil (695) on Thursday July 29, @12:48PM (#9833940) (http://rhadmin.org/)

Ash appears to consume large amounts of memory, and some people in BSD circles have serious objections to it. See the discussion here [undeadly.org] (scroll down a bit into the postings). I don't have an opinion on the issue one way or another.

And can I set up bash so I can, for instance, move from rc2.d to rc3.d by typing

$ cd 2 3

[May 16, 2004] freshmeat.net Project details for BASH Debugger

BASH Debugger provides a patched BASH that enables better debugging support as well as improved error reporting. It also contains the most comprehensive source code debugger for BASH that has been written. It can be used as a springboard for other experimental features (such as a timestamped history file), since dnter"

• Advanced Bash-Scripting Guide

• Freeware for Solaris -- downloadable version of bash for Solaris on SPARC and Intel

• Solaris 9 Software companion disk

• Solaris 8 Software companion disk - Download
• The Bourne-Again Shell -- bash homepage
• Bash Features -- explained from what shell each feature originated and how it was extended and integrated. Recommended.
• Bash Prompt HOWTO
• BASH Programming - Introduction HOW-TO
• Bash Reference Manual - Table of Contents -- Edition 2.2, for bash Version 2.02. 1 April 1998
• Bourne Again Shell (bash)
• Bash Features - Table of Contents
• Bash Features
• Bash FAQ  [another mirror]
• Bash(1) manual page
• Bash Features - Keyboard Macros

Recommended Links

---

In case of broken links please try to use Google search. If you find the page please notify us about new location

Advanced Bash-Scripting Guide

• The URL of the preferred download site for the pdf version of the ABS Guide is:
  
  http://personal.riverusers.com/~thegrendel/abs-guide.pdf
  
  This version is specially book-formatted for duplex printing and is usually more up-to-date than the version you can download from the LDP site. Note that it's a 2.6 MB download.
• http://personal.riverusers.com/~thegrendel/abs-guide-5.2.tar.bz2 The "bleeding edge" branch is the 'tar/BZ2' link. It will generally run anywhere from a few days to a couple of months ahead of the main release on the LDP site.

Reference

Things bash has or uses that ksh88 does not:

long invocation options

[-+]O invocation option

`!' reserved word

arithmetic for command: for ((expr1 ; expr2; expr3 )); do list; done

posix mode and posix conformance

command hashing

tilde expansion for assignment statements that look like $PATH

process substitution with named pipes if /dev/fd is not available

the ${!param} indirect parameter expansion operator

the ${!param*} prefix expansion operator

the ${param:offset[:length]} parameter substring operator

the ${param/pat[/string]} parameter pattern substitution operator

variables: BASH, BASH_VERSION, BASH_VERSINFO, UID, EUID, SHLVL,

   TIMEFORMAT, HISTCMD, HOSTTYPE, OSTYPE, MACHTYPE,

   HISTFILESIZE, HISTIGNORE, HISTCONTROL, PROMPT_COMMAND,

   IGNOREEOF, FIGNORE, INPUTRC, HOSTFILE, DIRSTACK,

   PIPESTATUS, HOSTNAME, OPTERR, SHELLOPTS, GLOBIGNORE,

   GROUPS, FUNCNAME, histchars, auto_resume

prompt expansion with backslash escapes and command substitution

redirection: &> (stdout and stderr)

more extensive and extensible editing and programmable completion

builtins: bind, builtin, command, declare, dirs, echo -e/-E, enable,

  exec -l/-c/-a, fc -s, export -n/-f/-p, hash, help, history,

  jobs -x/-r/-s, kill -s/-n/-l, local, logout, popd, pushd,

  read -e/-p/-a/-t/-n/-d/-s, readonly -a/-n/-f/-p,

  set -o braceexpand/-o histexpand/-o interactive-comments/

  -o notify/-o physical/-o posix/-o hashall/-o onecmd/

  -h/-B/-C/-b/-H/-P, set +o, suspend, trap -l, type,

  typeset -a/-F/-p, ulimit -u, umask -S, alias -p, shopt,

  disown, printf, complete, compgen

`!' csh-style history expansion

POSIX.2-style globbing character classes

POSIX.2-style globbing equivalence classes

POSIX.2-style globbing collating symbols

egrep-like extended pattern matching operators

case-insensitive pattern matching and globbing

`**' arithmetic operator to do exponentiation

redirection to /dev/fd/N, /dev/stdin, /dev/stdout, /dev/stderr

arrays of unlimited size

Things ksh88 has or uses that bash does not:

tracked aliases (alias -t)

variables: ERRNO, FPATH, EDITOR, VISUAL

co-processes (|&, >&p, <&p)

weirdly-scoped functions

typeset +f to list all function names without definitions

text of command history kept in a file, not memory

builtins: alias -x, cd old new, fc -e -, newgrp, print,

  read -p/-s/-u/var?prompt, set -A/-o gmacs/

  -o bgnice/-o markdirs/-o nolog/-o trackall/-o viraw/-s,

  typeset -H/-L/-R/-Z/-A/-ft/-fu/-fx/-l/-u/-t, whence

using environment to pass attributes of exported variables

arithmetic evaluation done on arguments to some builtins

reads .profile from $PWD when invoked as login shell

Implementation differences:

• ksh runs last command of a pipeline in parent shell context
• bash has brace expansion by default (ksh88 compile-time option)
• bash has fixed startup file for all interactive shells; ksh reads $ENV
• bash has exported functions
• bash command search finds functions before builtins
• bash waits for all commands in pipeline to exit before returning status
• emacs-mode editing has some slightly different key bindings

Bash Scripting

FAQs

[gnu.bash.bug] BASH Frequently-Asked Questions (FAQ version 3.29)

FAQ This is the Bash FAQ, version 3.29, for Bash version 3.0.

Etc

Re Suggestions for corrections to executable.el - use of PATHEXT

From: "Eli Zaretskii" <address@bogus.example.com>

> First, I'm not sure we should look at PATHEXT.  That variable is AFAIK
> looked at by the shell, so if we want Emacs behave _exactly_ like the
> shell does, we should at least look at the value of SHELL and/or
> ComSpec (and COMSPEC for older systems).  I mean, what if the user's
> shell is Bash, which AFAIK doesn't look at PATHEXT at all?  And if the
> shell is COMMAND.COM, then ".cmd" should not be in the list.  Etc.,
> etc.

PATHEXT is looked at by cmd.exe (the default shell on the NT hereditary
line). I do not know if it is used by command.com (the default shell on the
95 line) but I doubt it. When I tested now I found that the Run entry in
Windows Start menu honor the default extensions for PATHEXT (.com, .exe.,
.bat, .cmd). It does not however not recognize .pl which I have in my
PATHEXT (cmd.exe recognize it). I am using NT4 when testing this.

So perhaps not even ms windows is consistent here. What seems clear however
is that the main purpose of PATHEXT is as far as I can see to make it easier
for the user when entering a command interactively. The user may for example
type "notepad" instead of "notepad.exe".

PATHEXT is set by the user and expresses the users wish to type less. It
seems reasonable to use PATHEXT for this purpose in Emacs too. The variable
executable-binary-suffixes is (if I understand this correctly) used for this
purpose by executable-find. This is however not clearly expressed in the
documentation.

A note: w32-shell-execute does something quite different. It calls the ms
windows API ShellExecute to do the action associated with a certain "verb"
on a file type (on windows this means file extension). Typical verbs are
"open" and "print". Windows Explorer uses this.

Having said all this I just want to say that I regret that I took this issue
up without looking closer at the problem.

- Lennart