Advanced Bash-Scripting Guide:
Prev |  | Next

# Appendix L. Sample `.bashrc` and `.bash_profile` Files

The `~/.bashrc` file determines the behavior of interactive shells. A good look at this file can lead to a better understanding of Bash.

Emmanuel Rouat contributed the following very elaborate `.bashrc` file, written for a Linux system. He welcomes reader feedback on it.

Study the file carefully, and feel free to reuse code snippets and functions from it in your own `.bashrc` file or even in your scripts.

Example L-1. Sample `.bashrc` file

    #=============================================================
    #
    # PERSONAL $HOME/.bashrc FILE for bash-3.0 (or later)
    # By Emmanuel Rouat <no-email>
    #
    # Last modified: Sun Nov 30 16:27:45 CET 2008
    # This file is read (normally) by interactive shells only.
    # Here is the place to define your aliases, functions and
    # other interactive features like your prompt.
    #
    # The majority of the code here assumes you are on a GNU
    # system (most likely a Linux box) and is based on code found
    # on Usenet or internet. See for instance:
    #
    # http://tldp.org/LDP/abs/html/index.html
    # http://www.caliban.org/bash/
    # http://www.shelldorado.com/scripts/categories.html
    # http://www.dotfiles.org/
    #
    # This bashrc file is a bit overcrowded -- remember it is just
    # just an example. Tailor it to your needs.
    #
    #
    #=============================================================

    # --> Comments added by HOWTO author.

    #-------------------------------------------------------------
    # Source global definitions (if any)
    #-------------------------------------------------------------

    if [ -f /etc/bashrc ]; then
            . /etc/bashrc   # --> Read /etc/bashrc, if present.
    fi

    #-------------------------------------------------------------
    # Automatic setting of $DISPLAY (if not set already).
    # This works for linux - your mileage may vary. ...
    # The problem is that different types of terminals give
    # different answers to 'who am i' (rxvt in particular can be
    # troublesome).
    # I have not found a 'universal' method yet.
    #-------------------------------------------------------------

    function get_xserver ()
    {
        case $TERM in
           xterm )
                XSERVER=$(who am i | awk '{print $NF}' | tr -d ')''(' )
                # Ane-Pieter Wieringa suggests the following alternative:
                # I_AM=$(who am i)
                # SERVER=${I_AM#*(}
                # SERVER=${SERVER%*)}

                XSERVER=${XSERVER%%:*}
                ;;
            aterm | rxvt)
            # Find some code that works here. ...
                ;;
        esac
    }

    if [ -z ${DISPLAY:=""} ]; then
        get_xserver
        if [[ -z ${XSERVER}  || ${XSERVER} == $(hostname) || \
          ${XSERVER} == "unix" ]]; then
            DISPLAY=":0.0"          # Display on local host.
        else
            DISPLAY=${XSERVER}:0.0  # Display on remote host.
        fi
    fi

    export DISPLAY

    #-------------------------------------------------------------
    # Some settings
    #-------------------------------------------------------------

    ulimit -S -c 0          # Don't want any coredumps.
    set -o notify
    set -o noclobber
    set -o ignoreeof
    set -o nounset
    #set -o xtrace          # Useful for debuging.

    # Enable options:
    shopt -s cdspell
    shopt -s cdable_vars
    shopt -s checkhash
    shopt -s checkwinsize
    shopt -s sourcepath
    shopt -s no_empty_cmd_completion
    shopt -s cmdhist
    shopt -s histappend histreedit histverify
    shopt -s extglob        # Necessary for programmable completion.

    # Disable options:
    shopt -u mailwarn
    unset MAILCHECK         # Don't want my shell to warn me of incoming mail.

    export TIMEFORMAT=$'\nreal %3R\tuser %3U\tsys %3S\tpcpu %P\n'
    export HISTTIMEFORMAT="%H:%M > "
    export HISTIGNORE="&:bg:fg:ll:h"
    export HOSTFILE=$HOME/.hosts    # Put list of remote hosts in ~/.hosts ...

    #-------------------------------------------------------------
    # Greeting, motd etc...
    #-------------------------------------------------------------

    # Define some colors first:
    red='\e[0;31m'
    RED='\e[1;31m'
    blue='\e[0;34m'
    BLUE='\e[1;34m'
    cyan='\e[0;36m'
    CYAN='\e[1;36m'
    NC='\e[0m'              # No Color
    # --> Nice. Has the same effect as using "ansi.sys" in DOS.

    # Looks best on a terminal with black background.....
    echo -e "${CYAN}This is BASH ${RED}${BASH_VERSION%.*}\
    ${CYAN} - DISPLAY on ${RED}$DISPLAY${NC}\n"
    date
    if [ -x /usr/games/fortune ]; then
        /usr/games/fortune -s     # Makes our day a bit more fun.... :-)
    fi

    function _exit()        # Function to run upon exit of shell.
    {
        echo -e "${RED}Hasta la vista, baby${NC}"
    }
    trap _exit EXIT

    #-------------------------------------------------------------
    # Shell Prompt
    #-------------------------------------------------------------

    if [[ "${DISPLAY%%:0*}" != "" ]]; then
        HILIT=${red}   # remote machine: prompt will be partly red
    else
        HILIT=${cyan}  # local machine: prompt will be partly cyan
    fi

    #  --> Replace instances of \W with \w in prompt functions below
    #+ --> to get display of full path name.

    function fastprompt()
    {
        unset PROMPT_COMMAND
        case $TERM in
            *term | rxvt )
                PS1="${HILIT}[\h]$NC \W > \[\033]0;\${TERM} [\u@\h] \w\007\]" ;;
            linux )
                PS1="${HILIT}[\h]$NC \W > " ;;
            *)
                PS1="[\h] \W > " ;;
        esac
    }

    _powerprompt()
    {
        LOAD=$(uptime|sed -e "s/.*: \([^,]*\).*/\1/" -e "s/ //g")
    }

    function powerprompt()
    {

        PROMPT_COMMAND=_powerprompt
        case $TERM in
            *term | rxvt  )
                PS1="${HILIT}[\A - \$LOAD]$NC\n[\u@\h \#] \W > \
                     \[\033]0;\${TERM} [\u@\h] \w\007\]" ;;
            linux )
                PS1="${HILIT}[\A - \$LOAD]$NC\n[\u@\h \#] \W > " ;;
            * )
                PS1="[\A - \$LOAD]\n[\u@\h \#] \W > " ;;
        esac
    }

    powerprompt     # This is the default prompt -- might be slow.
                    # If too slow, use fastprompt instead. ...

    #===============================================================
    #
    # ALIASES AND FUNCTIONS
    #
    # Arguably, some functions defined here are quite big.
    # If you want to make this file smaller, these functions can
    # be converted into scripts and removed from here.
    #
    # Many functions were taken (almost) straight from the bash-2.04
    # examples.
    #
    #===============================================================

    #-------------------
    # Personnal Aliases
    #-------------------

    alias rm='rm -i'
    alias cp='cp -i'
    alias mv='mv -i'
    # -> Prevents accidentally clobbering files.
    alias mkdir='mkdir -p'

    alias h='history'
    alias j='jobs -l'
    alias which='type -a'
    alias ..='cd ..'
    alias path='echo -e ${PATH//:/\\n}'
    alias libpath='echo -e ${LD_LIBRARY_PATH//:/\\n}'
    alias print='/usr/bin/lp -o nobanner -d $LPDEST'
                # Assumes LPDEST is defined (default printer)
    alias pjet='enscript -h -G -fCourier9 -d $LPDEST'
                # Pretty-print using enscript

    alias du='du -kh'       # Makes a more readable output.
    alias df='df -kTh'

    #-------------------------------------------------------------
    # The 'ls' family (this assumes you use a recent GNU ls)
    #-------------------------------------------------------------
    alias ll="ls -l --group-directories-first"
    alias ls='ls -hF --color'  # add colors for filetype recognition
    alias la='ls -Al'          # show hidden files
    alias lx='ls -lXB'         # sort by extension
    alias lk='ls -lSr'         # sort by size, biggest last
    alias lc='ls -ltcr'        # sort by and show change time, most recent last
    alias lu='ls -ltur'        # sort by and show access time, most recent last
    alias lt='ls -ltr'         # sort by date, most recent last
    alias lm='ls -al |more'    # pipe through 'more'
    alias lr='ls -lR'          # recursive ls
    alias tree='tree -Csu'     # nice alternative to 'recursive ls'

    # If your version of 'ls' doesn't support --group-directories-first try this:
    # function ll(){ ls -l "$@"| egrep "^d" ; ls -lXB "$@" 2>&-| \
    #                egrep -v "^d|total "; }

    #-------------------------------------------------------------
    # tailoring 'less'
    #-------------------------------------------------------------

    alias more='less'
    export PAGER=less
    export LESSCHARSET='latin1'
    export LESSOPEN='|/usr/bin/lesspipe.sh %s 2>&-'
       # Use this if lesspipe.sh exists
    export LESS='-i -N -w  -z-4 -g -e -M -X -F -R -P%t?f%f \
    :stdin .?pb%pb\%:?lbLine %lb:?bbByte %bb:-...'

    #-------------------------------------------------------------
    # spelling typos - highly personnal and keyboard-dependent :-)
    #-------------------------------------------------------------

    alias xs='cd'
    alias vf='cd'
    alias moer='more'
    alias moew='more'
    alias kk='ll'

    #-------------------------------------------------------------
    # A few fun ones
    #-------------------------------------------------------------

    function xtitle()      # Adds some text in the terminal frame.
    {
        case "$TERM" in
            *term | rxvt)
                echo -n -e "\033]0;$*\007" ;;
            *)
                ;;
        esac
    }

    # aliases that use xtitle
    alias top='xtitle Processes on $HOST && top'
    alias make='xtitle Making $(basename $PWD) ; make'
    alias ncftp="xtitle ncFTP ; ncftp"

    # .. and functions
    function man()
    {
        for i ; do
            xtitle The $(basename $1|tr -d .[:digit:]) manual
            command man -F -a "$i"
        done
    }

    #-------------------------------------------------------------
    # Make the following commands run in background automatically:
    #-------------------------------------------------------------

    function te()  # Wrapper around xemacs/gnuserv ...
    {
        if [ "$(gnuclient -batch -eval t 2>&-)" == "t" ]; then
            gnuclient -q "$@";
        else
            ( xemacs "$@" &);
        fi
    }

    function soffice() { command soffice "$@" & }
    function firefox() { command firefox "$@" & }
    function xpdf() { command xpdf "$@" & }

    #-------------------------------------------------------------
    # File & string-related functions:
    #-------------------------------------------------------------

    # Find a file with a pattern in name:
    function ff() { find . -type f -iname '*'$*'*' -ls ; }

    # Find a file with pattern $1 in name and Execute $2 on it:
    function fe()
    { find . -type f -iname '*'${1:-}'*' -exec ${2:-file} {} \;  ; }

    # Find a pattern in a set of files and highlight them:
    # (needs a recent version of egrep)
    function fstr()
    {
        OPTIND=1
        local case=""
        local usage="fstr: find string in files.
    Usage: fstr [-i] \"pattern\" [\"filename pattern\"] "
        while getopts :it opt
        do
            case "$opt" in
            i) case="-i " ;;
            *) echo "$usage"; return;;
            esac
        done
        shift $(( $OPTIND - 1 ))
        if [ "$#" -lt 1 ]; then
            echo "$usage"
            return;
        fi
        find . -type f -name "${2:-*}" -print0 | \
        xargs -0 egrep --color=always -sn ${case} "$1" 2>&- | more

    }

    function cuttail() # cut last n lines in file, 10 by default
    {
        nlines=${2:-10}
        sed -n -e :a -e "1,${nlines}!{P;N;D;};N;ba" $1
    }

    function lowercase()  # move filenames to lowercase
    {
        for file ; do
            filename=${file##*/}
            case "$filename" in
            */*) dirname==${file%/*} ;;
            *) dirname=.;;
            esac
            nf=$(echo $filename | tr A-Z a-z)
            newname="${dirname}/${nf}"
            if [ "$nf" != "$filename" ]; then
                mv "$file" "$newname"
                echo "lowercase: $file --> $newname"
            else
                echo "lowercase: $file not changed."
            fi
        done
    }

    function swap()  # Swap 2 filenames around, if they exist
    {                #(from Uzi's bashrc).
        local TMPFILE=tmp.$$

        [ $# -ne 2 ] && echo "swap: 2 arguments needed" && return 1
        [ ! -e $1 ] && echo "swap: $1 does not exist" && return 1
        [ ! -e $2 ] && echo "swap: $2 does not exist" && return 1

        mv "$1" $TMPFILE
        mv "$2" "$1"
        mv $TMPFILE "$2"
    }

    function extract()      # Handy Extract Program.
    {
         if [ -f $1 ] ; then
             case $1 in
                 *.tar.bz2)   tar xvjf $1     ;;
                 *.tar.gz)    tar xvzf $1     ;;
                 *.bz2)       bunzip2 $1      ;;
                 *.rar)       unrar x $1      ;;
                 *.gz)        gunzip $1       ;;
                 *.tar)       tar xvf $1      ;;
                 *.tbz2)      tar xvjf $1     ;;
                 *.tgz)       tar xvzf $1     ;;
                 *.zip)       unzip $1        ;;
                 *.Z)         uncompress $1   ;;
                 *.7z)        7z x $1         ;;
                 *)           echo "'$1' cannot be extracted via >extract<" ;;
             esac
         else
             echo "'$1' is not a valid file"
         fi
    }

    #-------------------------------------------------------------
    # Process/system related functions:
    #-------------------------------------------------------------

    function my_ps() { ps $@ -u $USER -o pid,%cpu,%mem,bsdtime,command ; }
    function pp() { my_ps f | awk '!/awk/ && $0~var' var=${1:-".*"} ; }

    function killps()                 # Kill by process name.
    {
        local pid pname sig="-TERM"   # Default signal.
        if [ "$#" -lt 1 ] || [ "$#" -gt 2 ]; then
            echo "Usage: killps [-SIGNAL] pattern"
            return;
        fi
        if [ $# = 2 ]; then sig=$1 ; fi
        for pid in $(my_ps| awk '!/awk/ && $0~pat { print $1 }' pat=${!#} ) ; do
            pname=$(my_ps | awk '$1~var { print $5 }' var=$pid )
            if ask "Kill process $pid <$pname> with signal $sig?"
                then kill $sig $pid
            fi
        done
    }

    function my_ip() # Get IP adresses.
    {
        MY_IP=$(/sbin/ifconfig ppp0 | awk '/inet/ { print $2 } ' | \
    sed -e s/addr://)
        MY_ISP=$(/sbin/ifconfig ppp0 | awk '/P-t-P/ { print $3 } ' | \
    sed -e s/P-t-P://)
    }

    function ii()   # Get current host related info.
    {
        echo -e "\nYou are logged on ${RED}$HOST"
        echo -e "\nAdditionnal information:$NC " ; uname -a
        echo -e "\n${RED}Users logged on:$NC " ; w -h
        echo -e "\n${RED}Current date :$NC " ; date
        echo -e "\n${RED}Machine stats :$NC " ; uptime
        echo -e "\n${RED}Memory stats :$NC " ; free
        my_ip 2>&- ;
        echo -e "\n${RED}Local IP Address :$NC" ; echo ${MY_IP:-"Not connected"}
        echo -e "\n${RED}ISP Address :$NC" ; echo ${MY_ISP:-"Not connected"}
        echo -e "\n${RED}Open connections :$NC "; netstat -pan --inet;
        echo
    }

    #-------------------------------------------------------------
    # Misc utilities:
    #-------------------------------------------------------------

    function repeat()       # Repeat n times command.
    {
        local i max
        max=$1; shift;
        for ((i=1; i <= max ; i++)); do  # --> C-like syntax
            eval "$@";
        done
    }

    function ask()          # See 'killps' for example of use.
    {
        echo -n "$@" '[y/n] ' ; read ans
        case "$ans" in
            y*|Y*) return 0 ;;
            *) return 1 ;;
        esac
    }

    function corename()   # Get name of app that created a corefile.
    {
        for file ; do
            echo -n $file : ; gdb --core=$file --batch | head -1
        done
    }

    #=========================================================================
    # PROGRAMMABLE COMPLETION - ONLY SINCE BASH-2.04
    # Most are taken from the bash 2.05 documentation and from Ian McDonald's
    # 'Bash completion' package (http://www.caliban.org/bash/#completion).
    # You will in fact need bash more recent than 3.0 for some features.
    #=========================================================================

    if [ "${BASH_VERSION%.*}" \< "3.0" ]; then
        echo "You will need to upgrade to version 3.0 \
    for full programmable completion features."
        return
    fi

    shopt -s extglob         # Necessary,
    #set +o nounset          # otherwise some completions will fail.

    complete -A hostname   rsh rcp telnet rlogin r ftp ping disk
    complete -A export     printenv
    complete -A variable   export local readonly unset
    complete -A enabled    builtin
    complete -A alias      alias unalias
    complete -A function   function
    complete -A user       su mail finger

    complete -A helptopic  help     # Currently, same as builtins.
    complete -A shopt      shopt
    complete -A stopped -P '%' bg
    complete -A job -P '%'     fg jobs disown

    complete -A directory  mkdir rmdir
    complete -A directory   -o default cd

    # Compression
    complete -f -o default -X '*.+(zip|ZIP)'  zip
    complete -f -o default -X '!*.+(zip|ZIP)' unzip
    complete -f -o default -X '*.+(z|Z)'      compress
    complete -f -o default -X '!*.+(z|Z)'     uncompress
    complete -f -o default -X '*.+(gz|GZ)'    gzip
    complete -f -o default -X '!*.+(gz|GZ)'   gunzip
    complete -f -o default -X '*.+(bz2|BZ2)'  bzip2
    complete -f -o default -X '!*.+(bz2|BZ2)' bunzip2
    complete -f -o default -X '!*.+(zip|ZIP|z|Z|gz|GZ|bz2|BZ2)' extract

    # Documents - Postscript,pdf,dvi.....
    complete -f -o default -X '!*.+(ps|PS)'  gs ghostview ps2pdf ps2ascii
    complete -f -o default -X '!*.+(dvi|DVI)' dvips dvipdf xdvi dviselect dvitype
    complete -f -o default -X '!*.+(pdf|PDF)' acroread pdf2ps
    complete -f -o default -X \
    '!*.@(@(?(e)ps|?(E)PS|pdf|PDF)?(.gz|.GZ|.bz2|.BZ2|.Z))' gv ggv
    complete -f -o default -X '!*.texi*' makeinfo texi2dvi texi2html texi2pdf
    complete -f -o default -X '!*.tex' tex latex slitex
    complete -f -o default -X '!*.lyx' lyx
    complete -f -o default -X '!*.+(htm*|HTM*)' lynx html2ps
    complete -f -o default -X \
    '!*.+(doc|DOC|xls|XLS|ppt|PPT|sx?|SX?|csv|CSV|od?|OD?|ott|OTT)' soffice

    # Multimedia
    complete -f -o default -X \
    '!*.+(gif|GIF|jp*g|JP*G|bmp|BMP|xpm|XPM|png|PNG)' xv gimp ee gqview
    complete -f -o default -X '!*.+(mp3|MP3)' mpg123 mpg321
    complete -f -o default -X '!*.+(ogg|OGG)' ogg123
    complete -f -o default -X \
    '!*.@(mp[23]|MP[23]|ogg|OGG|wav|WAV|pls|m3u|xm|mod|s[3t]m|it|mtm|ult|flac)' xmms
    complete -f -o default -X \
    '!*.@(mp?(e)g|MP?(E)G|wma|avi|AVI|asf|vob|VOB|bin|dat|vcd|\
    ps|pes|fli|viv|rm|ram|yuv|mov|MOV|qt|QT|wmv|mp3|MP3|ogg|OGG|\
    ogm|OGM|mp4|MP4|wav|WAV|asx|ASX)' xine

    complete -f -o default -X '!*.pl'  perl perl5

    # This is a 'universal' completion function - it works when commands have
    # a so-called 'long options' mode , ie: 'ls --all' instead of 'ls -a'
    # Needs the '-o' option of grep
    #  (try the commented-out version if not available).

    # First, remove '=' from completion word separators
    # (this will allow completions like 'ls --color=auto' to work correctly).

    COMP_WORDBREAKS=${COMP_WORDBREAKS/=/}

    _get_longopts()
    {
        #$1 --help | sed  -e '/--/!d' -e 's/.*--\([^[:space:].,]*\).*/--\1/'| \
    #grep ^"$2" |sort -u ;
        $1 --help | grep -o -e "--[^[:space:].,]*" | grep -e "$2" |sort -u
    }

    _longopts()
    {
        local cur
        cur=${COMP_WORDS[COMP_CWORD]}

        case "${cur:-*}" in
           -*)      ;;
            *)      return ;;
        esac

        case "$1" in
          \~*)      eval cmd="$1" ;;
            *)      cmd="$1" ;;
        esac
        COMPREPLY=( $(_get_longopts ${1} ${cur} ) )
    }
    complete  -o default -F _longopts configure bash
    complete  -o default -F _longopts wget id info a2ps ls recode

    _tar()
    {
        local cur ext regex tar untar

        COMPREPLY=()
        cur=${COMP_WORDS[COMP_CWORD]}

        # If we want an option, return the possible long options.
        case "$cur" in
            -*)     COMPREPLY=( $(_get_longopts $1 $cur ) ); return 0;;
        esac

        if [ $COMP_CWORD -eq 1 ]; then
            COMPREPLY=( $( compgen -W 'c t x u r d A' -- $cur ) )
            return 0
        fi

        case "${COMP_WORDS[1]}" in
            ?(-)c*f)
                COMPREPLY=( $( compgen -f $cur ) )
                return 0
                ;;
                +([^Izjy])f)
                ext='tar'
                regex=$ext
                ;;
            *z*f)
                ext='tar.gz'
                regex='t\(ar\.\)\(gz\|Z\)'
                ;;
            *[Ijy]*f)
                ext='t?(ar.)bz?(2)'
                regex='t\(ar\.\)bz2\?'
                ;;
            *)
                COMPREPLY=( $( compgen -f $cur ) )
                return 0
                ;;

        esac

        if [[ "$COMP_LINE" == tar*.$ext' '* ]]; then
            # Complete on files in tar file.
            #
            # Get name of tar file from command line.
            tar=$( echo "$COMP_LINE" | \
                   sed -e 's|^.* \([^ ]*'$regex'\) .*$|\1|' )
            # Devise how to untar and list it.
            untar=t${COMP_WORDS[1]//[^Izjyf]/}

            COMPREPLY=( $( compgen -W "$( echo $( tar $untar $tar \
                        2>/dev/null ) )" -- "$cur" ) )
            return 0

        else
            # File completion on relevant files.
            COMPREPLY=( $( compgen -G $cur\*.$ext ) )

        fi

        return 0

    }

    complete -F _tar -o default tar

    _make()
    {
        local mdef makef makef_dir="." makef_inc gcmd cur prev i;
        COMPREPLY=();
        cur=${COMP_WORDS[COMP_CWORD]};
        prev=${COMP_WORDS[COMP_CWORD-1]};
        case "$prev" in
            -*f)
                COMPREPLY=($(compgen -f $cur ));
                return 0
            ;;
        esac;
        case "$cur" in
            -*)
                COMPREPLY=($(_get_longopts $1 $cur ));
                return 0
            ;;
        esac;

        # make reads `GNUmakefile', then `makefile', then `Makefile'
        if [ -f ${makef_dir}/GNUmakefile ]; then
            makef=${makef_dir}/GNUmakefile
        elif [ -f ${makef_dir}/makefile ]; then
            makef=${makef_dir}/makefile
        elif [ -f ${makef_dir}/Makefile ]; then
            makef=${makef_dir}/Makefile
        else
            makef=${makef_dir}/*.mk        # Local convention.
        fi

        # Before we scan for targets, see if a Makefile name was
        # specified with -f ...
        for (( i=0; i < ${#COMP_WORDS[@]}; i++ )); do
            if [[ ${COMP_WORDS[i]} == -f ]]; then
               # eval for tilde expansion
               eval makef=${COMP_WORDS[i+1]}
               break
            fi
        done
        [ ! -f $makef ] && return 0

        # deal with included Makefiles
        makef_inc=$( grep -E '^-?include' $makef | \
        sed -e "s,^.* ,"$makef_dir"/," )
        for file in $makef_inc; do
            [ -f $file ] && makef="$makef $file"
        done

        # If we have a partial word to complete, restrict completions to
        # matches of that word.
        if [ -n "$cur" ]; then gcmd='grep "^$cur"' ; else gcmd=cat ; fi

        COMPREPLY=( $( awk -F':' '/^[a-zA-Z0-9][^$#\/\t=]*:([^=]|$)/ \
                                    {split($1,A,/ /);for(i in A)print A[i]}' \
                                    $makef 2>/dev/null | eval $gcmd  ))

    }

    complete -F _make -X '+($*|*.[cho])' make gmake pmake

    _killall()
    {
        local cur prev
        COMPREPLY=()
        cur=${COMP_WORDS[COMP_CWORD]}

        # get a list of processes (the first sed evaluation
        # takes care of swapped out processes, the second
        # takes care of getting the basename of the process)
        COMPREPLY=( $( /usr/bin/ps -u $USER -o comm  | \
            sed -e '1,1d' -e 's#[]\[]##g' -e 's#^.*/##'| \
            awk '{if ($0 ~ /^'$cur'/) print $0}' ))

        return 0
    }

    complete -F _killall killall killps

    # A meta-command completion function for commands like sudo(8), which need to
    # first complete on a command, then complete according to that command's own
    # completion definition - currently not quite foolproof,
    # but still quite useful (By Ian McDonald, modified by me).

    _meta_comp()
    {
        local cur func cline cspec

        COMPREPLY=()
        cur=${COMP_WORDS[COMP_CWORD]}
        cmdline=${COMP_WORDS[@]}
        if [ $COMP_CWORD = 1 ]; then
             COMPREPLY=( $( compgen -c $cur ) )
        else
            cmd=${COMP_WORDS[1]}            # Find command.
            cspec=$( complete -p ${cmd} )   # Find spec of that command.

            # COMP_CWORD and COMP_WORDS() are not read-only,
            # so we can set them before handing off to regular
            # completion routine:
            # Get current command line minus initial command,
            cline="${COMP_LINE#$1 }"
            # split current command line tokens into array,
            COMP_WORDS=( $cline )
            # set current token number to 1 less than now.
            COMP_CWORD=$(( $COMP_CWORD - 1 ))
            # If current arg is empty, add it to COMP_WORDS array
            # (otherwise that information will be lost).
            if [ -z $cur ]; then COMP_WORDS[COMP_CWORD]=""  ; fi

            if [ "${cspec%%-F *}" != "${cspec}" ]; then
          # if -F then get function:
                func=${cspec#*-F }
                func=${func%% *}
                eval $func $cline   # Evaluate it.
            else
                func=$( echo $cspec | sed -e 's/^complete//' -e 's/[^ ]*$//' )
                COMPREPLY=( $( eval compgen $func $cur ) )
            fi

        fi

    }

    complete -o default -F _meta_comp nohup \
    eval exec trace truss strace sotruss gdb
    complete -o default -F _meta_comp command type which man nice time

    # Local Variables:
    # mode:shell-script
    # sh-shell:bash
    # End:

And, here is a snippet from Andrzej Szelachowski's instructive `.bash_profile` file.

Example L-2. `.bash_profile` file

    # From Andrzej Szelachowski's ~/.bash_profile:

    #  Note that a variable may require special treatment
    #+ if it will be exported.

    DARKGRAY='\e[1;30m'
    LIGHTRED='\e[1;31m'
    GREEN='\e[32m'
    YELLOW='\e[1;33m'
    LIGHTBLUE='\e[1;34m'
    NC='\e[m'

    PCT="\`if [[ \$EUID -eq 0 ]]; then T='$LIGHTRED' ; else T='$LIGHTBLUE'; fi;
    echo \$T \`"

    #  For "literal" command substitution to be assigned to a variable,
    #+ use escapes and double quotes:
    #+       PCT="\` ... \`" . . .
    #  Otherwise, the value of PCT variable is assigned only once,
    #+ when the variable is exported/read from .bash_profile,
    #+ and it will not change afterwards even if the user ID changes.

    PS1="\n$GREEN[\w] \n$DARKGRAY($PCT\t$DARKGRAY)-($PCT\u$DARKGRAY)-($PCT\!
    $DARKGRAY)$YELLOW-> $NC"

    #  Escape a variables whose value changes:
    #        if [[ \$EUID -eq 0 ]],
    #  Otherwise the value of the EUID variable will be assigned only once,
    #+ as above.

    #  When a variable is assigned, it should be called escaped:
    #+       echo \$T,
    #  Otherwise the value of the T variable is taken from the moment the PCT
    #+ variable is exported/read from .bash_profile.
    #  So, in this example it would be null.

    #  When a variable's value contains a semicolon it should be strong quoted:
    #        T='$LIGHTRED',
    #  Otherwise, the semicolon will be interpreted as a command separator.

    #  Variables PCT and PS1 can be merged into a new PS1 variable:

    PS1="\`if [[ \$EUID -eq 0 ]]; then PCT='$LIGHTRED';
    else PCT='$LIGHTBLUE'; fi;
    echo '\n$GREEN[\w] \n$DARKGRAY('\$PCT'\t$DARKGRAY)-\
    ('\$PCT'\u$DARKGRAY)-('\$PCT'\!$DARKGRAY)$YELLOW-> $NC'\`"

    # The trick is to use strong quoting for parts of old PS1 variable.

Prev | Home | Next
History Commands |  | Converting DOS Batch Files to Shell Scripts