#!/bin/bash
# .bashrc
# written for sh, ksh, bash compatibility

# core file limits
[ `ulimit -c` != unlimited ] && ulimit -c unlimited

# is this bash?
case "x$0" in
  x-bash | xbash | x*/bash)
    BASHRC_SHELL=bash
    ;;
  x-ksh | xksh | x*/ksh)
    BASHRC_SHELL=ksh
    ;;
  x-sh | xsh | x*/sh)
    BASHRC_SHELL=sh
    # the following tests whether the [[ shell built-in is available
    # if so, we should be ksh compatible
    type '[[' > /dev/null 2>&1 && BASHRC_SHELL=ksh
    ;;
  *)
    BASHRC_SHELL=""
    ;;
esac
export BASHRC_SHELL

# ------------------------------------------------------------------------------
# User specific aliases and functions
# ------------------------------------------------------------------------------

# buildpath: This is designed to be sh, ksh, bash compatible
buildpath ()
{
  (
    dbg=false
    if [ $# -gt 0 ]; then
      if [ x"$1" = x-d ]; then
        dbg=true
        shift
      fi
    fi
    export dbg

    if [ $# -eq 0 ]; then
      cat 1>&2 <<-EnD
buildpath [-d] directory-or-search-path [directory-or-search-path] ...
    -d    Produces debug output on the standard error stream
  Search paths are split at colons into directory path elements; these and
  any plain directory path arguments are read in order, checked to make sure
  the directory exists, and added, at most once, with colon separators, to
  the output. The result is a new colon-separated search-path, written to
  the standard output stream.
EnD

    else
      ( for dp in "$@"; do
          case "$dp" in
            *:*)
              # split args containing colons into lines on stdout
              echo "$dp" | tr : '\n'
              ;;
            *)
              # just output non-colon-containing args one per line
              echo "$dp"
              ;;
          esac
        done
      ) |
      (
        IFS=""                      # do not allow space separators inside lines
        i=0
        p=""
        while read d; do            # read a line into $d
          [ "$d" != / ] && d=`echo "$d" | sed -e 's./$..'` # remove trailing /
          case ":${p}:" in
            *:${d}:*)
              # $d has already been seen: ignore duplicate
              $dbg && echo "dupl $d" 1>&2
              ;;
            *)
              if [ -d "$d" ]; then
                # $d is a directory: add it to path $p
                i=`expr $i + 1`
                # or --> i=$(($i + 1))
                $dbg && echo `printf "%4d %s" $i $d` 1>&2
                p="$p$sep$d"
                sep=":"
              else
                # $d is not a directory
                $dbg && echo "! dir $d" 1>&2
              fi
              ;;
          esac
        done
        # all done: echo the new path $p
        echo $p
      )
    fi
  )
}

# ------------------------------------------------------------------------------

### findinpath: look for a file in a set of directories
##findinpath ()
##{
##  if [ $# -eq 0 ]; then
##    cat 1>&2 <<-EnD
##findinpath [-rwxfdhLcbpugks1] search-path file ...
##    -rwxfdhLcbpugks1  Flags acceptable to test(1) or 1; default is -x
##    search-path      A colon-separated list of directories
##  Looks for each file in the search path by taking each directory in the path
##  and concatenating "/" and the file name to it then testing the result using
##  the test flags. Each successfully found file path is written to stdout.
##  If flags are present, all tests must succeed for a file to be considered
##  "found". The flag 1 causes the search for a file to quit when one successful
##  occurrence is found.
##EnD
##    return 1
##  fi
##
##  (
##    flags=
##    while true; do
##      case "x$1" in
##        x--)    shift
##                break
##                ;;
##        x-*)    flags="$flags `echo -- $1 | sed -e 's/-//g' -e 's/./& /g'` "
##                shift
##                ;;
##        *)      break
##                ;;
##      esac
##    done
##    flags="`echo $flags`"
##    [ -z "$flags" -o "$flags" = 1 ] && flags="x $flags"
##
##    if [ $# = 0 ]; then
##      findinpath
##      exit 1
##    fi
##
##    flags=`echo $flags|tr ' ' :`
##    dpath="$1"
##    shift
##
##    #: echo flags="$flags" 1>&2
##    #: echo dpath="$dpath" 1>&2
##
##    IFS=:
##    res=1
##    for f in "$@"; do
##      br=n
##      for d in $dpath; do
##        ok=y
##        for q in $flags; do
##          if [ $q = 1 ]; then
##            br=y
##          elif [ ! -$q $d/$f ]; then
##            ok=n
##            break
##          fi
##        done
##        if [ $ok = y ] && echo "$d/$f" && [ $br = y ]; then
##          res=0
##          break
##        fi
##      done
##    done
##
##    exit $res
##  )
##}

# ------------------------------------------------------------------------------

# findinpath: look for a file in a set of directories
findinpath ()
{
  if [ $# -eq 0 ]; then
    cat 1>&2 <<-EnD
findinpath [-rwxfdhLcbpugks1] search-path file ...
    -rwxfdhLcbpugks1  Flags acceptable to test(1) or 1; default is -x
    search-path      A colon-separated list of directories
  Looks for each file in the search path by taking each directory in the path
  and concatenating "/" and the file name to it then testing the result using
  the test flags. Each successfully found file path is written to stdout.
  If flags are present, all tests must succeed for a file to be considered
  "found". The flag 1 causes the search for a file to quit when one successful
  occurrence is found.
EnD
    return 1
  fi

  (
    flags=
    while true; do
      case "x$1" in
        x--)    shift
                break
                ;;
        x-*)    flags="$flags `echo -- $1 | sed -e 's/-//g' -e 's/./& /g'` "
                shift
                ;;
        *)      break
                ;;
      esac
    done
    flags="`echo $flags`"
    [ -z "$flags" -o "$flags" = 1 ] && flags="x $flags"

    if [ $# = 0 ]; then
      findinpath
      exit 1
    fi

    # flags=`echo $flags|tr ' ' :`
    dpath="$1"
    shift

    #: echo flags="$flags" 1>&2
    #: echo dpath="$dpath" 1>&2

    res=1
    for fa in "$@"; do
      br=n
      IFS=:
      for d in $dpath; do
        ff=`echo $d/$fa`     # attempt to glob-out any wildcards
        IFS=' '
        for f in $ff; do
          ok=y
          # IFS=:
          for q in $flags; do
            if [ -z "$q" ]; then
              :
            elif [ $q = 1 ]; then
              br=y
              # return 0
            elif [ ! -$q $f ]; then
              ok=n
              break
            fi
          done
          if [ $ok = y ] && echo "$f" && [ $br = y ]; then
            res=0
          fi
        done
      done
    done

    return $res
  )
}

# ------------------------------------------------------------------------------

# where is like which but has no csh dependencies. It uses findinpath to do the
# real work.
where ()
{
  (
  doMan=n doLib=n doType=n doHash=n doBasicType=n doCst=n doUsage=n
  opts='th'
  [ $BASHRC_SHELL != bash ] && opts='t'

  OPTIND=1
  while getopts a${opts}mlxqp: opt "$@"
  do
    case "$opt" in
      m)
        doMan=y
        [ -z "$doExe" ] && doExe=n
        [ -z "$show" ] && show=echo
        ;;
      l)
        doLib=y
        [ -z "$doExe" ] && doExe=n
        [ -z "$show" ] && show=echo
        ;;
      x)
        doExe=y
        [ -z "$show" ] && show=echo
        ;;
      t)
        doType=y
        [ -z "$doExe" ] && doExe=n
        [ -z "$show" ] && show=echo
        ;;
      h)
        doHash=y
        [ -z "$doExe" ] && doExe=n
        [ -z "$show" ] && show=echo
        ;;
      p)
        cpath="$OPTARG"
        doCst=y
        [ -z "$doExe" ] && doExe=n
        [ -z "$show" ] && show=echo
        ;;
      a)
        doExe=y doMan=y doLib=y doType=y doHash=y
        [ -z "$show" ] && show='echo'
        ;;
      q)
        show=:
        ;;
      *)
        doUsage=y
        ;;
    esac
  done
  shift `expr $OPTIND - 1`

  [ -z "$doExe" ] && doExe=y
  [ -z "$show" ] && show=:

  # need arguments!
  [ $# = 0 ] && doUsage=y

  # type -atp supported only in bash
  if [ $BASHRC_SHELL != bash ]; then
    if [ "$doType" = y ] || [ "$doHash" = y ]; then
      doType=n
      doHash=n
      doBasicType=y
    fi
  fi

  if [ "$doUsage" != y ]; then
    mans="${MANPATH:-/usr/man:/usr/contrib/man:/usr/local/man}"
    libs="${LD_LIBRARY_PATH:-/usr/lib:/usr/local/lib}"
    showsep=:
    for f in "$@"; do
      if [ "$doBasicType" = y ]; then
        res=`type "$f" 2>&1`
        [ -n "$res" ] && $showsep "" \
                      && $show "type ${f}" && echo "$res"
        showsep=$show
      fi
      if [ "$doType" = y ]; then
        res=`type -at "$f" 2>&1`
        [ -n "$res" ] && $showsep "" \
                      && $show "type -at ${f}" && echo "$res"
        showsep=$show
      fi
      if [ "$doHash" = y ]; then
        res=`type -p "$f" 2>&1`
        [ -n "$res" ] && $showsep "" \
                      && $show "type -p ${f}" && echo "$res"
        showsep=$show
      fi
      if [ "$doExe" = y ]; then
        res=`findinpath -x "$PATH" "$f"`
        [ -n "$res" ] && $showsep "" \
                      && $show "\$PATH: ${f}" && echo "$res"
        showsep=$show
      fi
      if [ "$doMan" = y ]; then
        res=`findinpath -f "$mans" "*/$f.*"`
        [ -n "$res" ] && $showsep "" \
                      && $show "\$MANPATH: ${f}" && echo "$res"
        showsep=$show
      fi
      if [ "$doLib" = y ]; then
        res=`findinpath -f "$libs" "$f" "$f.*"`
        [ -n "$res" ] && $showsep "" \
                      && $show "\$LD_LIBRARY_PATH: ${f}" && echo "$res"
        showsep=$show
      fi
      if [ "$doCst" = y ]; then
        res=`findinpath -f "$cpath" "$f"`
        [ -n "$res" ] && $showsep "" \
                      && $show "${cpath}: ${f}" && echo "$res"
        showsep=$show
      fi
    done
  fi

  if [ "$doUsage" = y ]; then
    aopts="${opts}xml"
    opts="[-a${aopts}xmlq]"
    echo "Usage: where ${opts} [-p search-path] file-name-or-prefix" 1>&2
    echo "  -a      \"all\": apply options -$aopts" 1>&2
    if [ $BASHRC_SHELL == bash ]; then
      echo "  -t      use type -at to show command interpretation" 1>&2
      echo "  -h      use type -p to show hashed path to executable file" 1>&2
    else
      echo "  -t      use the type built-in to show command interpretation" 1>&2
    fi
    echo "  -x      search for executable files in \$PATH" 1>&2
    echo "  -m      search for matching manual page files in \$MANPATH" 1>&2
    echo "  -l      search for matching files in \$LD_LIBRARY_PATH" 1>&2
    echo "  -p path search for files in path" 1>&2
    echo "  -q      quiet: do not mention which search is executing" 1>&2
    echo "File names must match exactly for -x, -p; -x is the default." 1>&2
  fi
  )
}

# ------------------------------------------------------------------------------

# Source global definitions
if [ "$BASHRC_SHELL" = bash ] && [ -f /etc/bashrc ]; then
  . /etc/bashrc
fi
if [ -f "$HOME/tmpBashSettings" ]; then
  . "$HOME/tmpBashSettings"
fi

# file creation mask
umask 022

# logname
LOGNAME=${LOGNAME:-${USER}}

    # Set local environment for users (for CVS, etc.)
    if [ -z "$CVSROOT" ]; then
      export CVS_RSH=ssh
      export CVSROOT=:ext:${USER}@cvs:/usr/local/cvs/cvsrep
      export ENGHOME=/home/tools/eng
    fi
    if [ -z "$local_env_set" ]; then
      export local_env_set=/home/tools/local-env-set
      if [ -f /home/tools/local-env-set ]; then
        . /home/tools/local-env-set
      fi
    fi

# system specifics
UNAME=`uname`
export UNAME
MAIL=/usr/mail/${LOGNAME:?}

if [ -z "$BASH_PATHS_SET" ]; then

    case "$UNAME" in
        SunOS)
            # Sun development tools
            [ -d /opt/SUNWspro/bin ] && SunOSPATH=/opt/SUNWspro/bin
            [ -d /opt/SUNWspro/man ] && SunOSMANPATH=/opt/SUNWspro/man
            [ -d /opt/SUNWspro/lib ] && SunOSLIBPATH=/opt/SUNWspro/lib
            ;;
    esac

    # PATH -------------------------------------------------
    PATH=`buildpath "$HOME"/.util \
                    "$HOME"/.util/"$UNAME" \
                    "$HOME"/usr/bin/"$UNAME" \
                    "$HOME"/usr/sbin \
                    "$HOME"/usr/bin \
                    $SunOSPATH \
                    "$HOME"/sqsh \
                    $SunOSPATH \
                    /usr/java4/bin \
                    /usr/xpg4/bin \
                    /usr/bin \
                    /bin \
                    /usr/sbin \
                    /sbin \
                    /usr/local/bin \
                    /usr/local/sbin \
                    . \
                    /usr/ccs/bin \
                    /usr/ucb \
                    /usr/dt/bin \
                    /usr/X/bin \
                    /usr/X/demo \
                    /opt/SUNWspro/bin \
                    /etc \
                    "$PATH"`
    export PATH
    BASH_PATHS_SET="$BASH_PATHS_SET PATH "
    export BASH_PATHS_SET

    # LD_LIBRARY_PATH --------------------------------------
    # add Hyperfeed, Tib, Triarch
    # NB for libdacs.so: /opt/triarch/ssl4.1.3.L3.sink_infra.solaris.tis.rri/lib
    LD_LIBRARY_PATH=`buildpath \
                    $LD_LIBRARY_PATH \
                    $SunOSLIBPATH \
                    /usr/local/lib \
                    /usr/lib \
                    /lib`
    export LD_LIBRARY_PATH
    BASH_PATHS_SET="$BASH_PATHS_SET LD_LIBRARY_PATH "
    export BASH_PATHS_SET

    # MANPATH ----------------------------------------------
    MANPATH=`buildpath \
                    ${HOME}/usr/man \
                    $SunOSMANPATH \
                    /usr/share/man \
                    /usr/openwin/man \
                    /usr/local/man \
                    /usr/X/man \
                    /usr/dt/man \
                    /usr/openwin/man \
                    $MANPATH`
    export MANPATH
    BASH_PATHS_SET="$BASH_PATHS_SET MANPATH "
    export BASH_PATHS_SET

    # ------------------------------------------------------
fi

# ------------------------------------------------------------------------------

# is our shell interactive?
if [ -z "$NO_INTERACTIVE_CHECK" ]; then
  case "$-" in
    *i*)
      INTERACTIVE=y
      ;;
    *)
      INTERACTIVE=
      ;;
  esac
fi

# ------------------------------------------------------------------------------

today_file=`date +today=%d-%m-%Y`
(
    IFS=;
    today_files=`cd "$HOME"; ls | grep 'today=.*'`
    if [ "$today_files" != "" ]; then
        for today_file_rm in $today_files; do
            [ "$today_file" != "$today_file_rm" ] && rm -f $HOME/$today_file_rm
        done
    fi
)
[ -f "$HOME/$today_file" ] || touch "$HOME/$today_file"

if [ -d "$HOME/.app-defaults" ]; then
  XAPPLRESDIR="$HOME/.app-defaults"
  export XAPPLRESDIR
fi

# ------------------------------------------------------------------------------

# aliases and functions
if [ "$BASHRC_SHELL" = bash -o "$BASHRC_SHELL" = ksh ]; then
  [ -r ${HOME}/.util/bashaliasrc ] && . ${HOME}/.util/bashaliasrc
fi

# localised definitions
[ -r $HOME/.localrc ] && . $HOME/.localrc

# ------------------------------------------------------------------------------

if [ -f "$HOME/.bashrc.$UNAME" ]; then
  . "$HOME/.bashrc.$UNAME"
fi

# ------------------------------------------------------------------------------

if [ "$INTERACTIVE" = "y" ]; then
    CDPATH=`buildpath . ${HOME}/cvs ${HOME}`
    if tty -s; then
      if [ -z "$BASHRC_SHOW_REMINDER" ] && [ -f ${HOME}/reminder ]; then
          echo "";
          echo ===== Reminder file ${HOME}/reminder: =====
          cat ${HOME}/reminder
          echo "";
          echo ===== Reminder file ${HOME}/reminder: ===== | sed -e s/./=/g
          echo "";
        fi
      BASHRC_SHOW_REMINDER="done"
      export BASHRC_SHOW_REMINDER
      # unless on Sun or DEC keyboards, with xterm we want Backspace to erase
      if [ "$TERM" = xterm ] || [ "$TERM" = vt100 ]; then
        stty erase ^H
      fi
      # use less with man if we have it
      if type less > /dev/null 2>&1; then
        PAGER=less
        LESS='-egmqsX'
        export PAGER LESS
      fi
      # if we don't have more, use less instead
      if type more > /dev/null 2>&1; then
        :
      else
        alias more=less
      fi
    fi

  # use custom cd (if we're using a terminal)
  if [ "$BASHRC_SHELL" = bash ] && tty -s; then
    [ -r ${HOME}/.util/bashcd ] && . ${HOME}/.util/bashcd && setcd c
  fi

  # ignore repeats and space-leading commands in history
  HISTCONTROL=ignoreboth      # ignorespace, ignoredups, ignoreboth

  [ -z "$tty" ] && tty=`tty | sed -e s./dev/..`

  # - try to avoid a DISPLAY with "localhost" in its name
  if [ -n "$DISPLAY" ]; then
    display="$DISPLAY"
    if [ "$display" = *localhost* ]; then
      OLD_DISPLAY="$DISPLAY"
      unset display
      export OLD_DISPLAY
    fi
  fi
  if [ -z "$display" ] && type last > /dev/null 2>&1; then
    # use last to pick up current "terminal" IP address
    #   case `uname` in
    #   SunOS)
    #       nlast="-n 1 -a"
    #       ;;
    #   *)
    #       nlast="-1 -l"
    #       ;;
    #   esac
    nlast="-n 1 -a"
    # pick up the terminal
    # take the last word of the first line of last(1) as an IP address
    last=`last $nlast $USER | awk '{ print $NF; exit }'`
    # see if we can find the same thing in who(1) (in comments field)
    if who -uT | fgrep "$tty" | fgrep "$last" >& /dev/null; then
      # looks like we have the connecting terminal (if any)
      if echo "$last" | grep '[^.0-9]' >& /dev/null; then
        # we have a name: try to resolve its address
        display=`nslookup "$last" | \
                 awk '
                 /^Name:/       { nextln = 0; if ($2 == "'"$last"'") nextln++; }
                 /^Address:/    { if (nextln) print $2; }
                 ' | head -n 1`
        if [ -n "$display" ]; then
          DISPLAY="${display}:0"
        else
          DISPLAY="${last}:0"
        fi
        unset display
      else
        DISPLAY="${last}:0"
      fi
      export DISPLAY
    fi
  fi
fi

# ------------------------------------------------------------------------------

# and X?
if [ -n "$DISPLAY" ]; then
  if [ "$INTERACTIVE" = "y" ] && [ -z "$XEDITOR" ]; then
    echo "Display: export DISPLAY=${DISPLAY}"
  fi
  # do we support CDE?
  if [ -d ~/.dt ] && [ -d /usr/dt/bin ]; then
    [ -z "$DTSCREENSAVERLIST" ] && \
        { DTSCREENSAVERLIST=`echo StartDtscreenSwarm \
                                  StartDtscreenQix \
                                  StartDtscreenFlame \
                                  StartDtscreenHop \
                                  StartDtscreenImage \
                                  StartDtscreenLife \
                                  StartDtscreenRotor \
                                  StartDtscreenPyro \
                                  StartDtscreenWorm \
                                  StartDtscreenBlank`
          export DTSCREENSAVERLIST; }
#   [ -z "$dtstart_sessionlogfile" ] && \
#       export dtstart_sessionlogfile=/dev/null
#   [ -z "$XMBINDDIR" ] && \
#       export XMBINDDIR=/usr/dt/lib/bindings
    [ -z "$DTUSERSESSION" ] && \
        export DTUSERSESSION="${USER}-`echo $DISPLAY | \
                                       sed -e s/:/-/ | sed -e s/\\.0\$/-0/`"
#   [ -z "$DTDATABASESEARCHPATH" ] && \
#       export DTDATABASESEARCHPATH=`echo ~/.dt/types \
#                                         /usr/dt/appconfig/types/%L \
#                                         /usr/dt/appconfig/types/C | \
#                                    tr ' ' ,`
#   # export DTXSERVERLOCATION=remote
#   [ -z "$XFILESEARCHPATH" ] && \
#       export XFILESEARCHPATH=`echo /usr/openwin/lib/locale/%L/%T/%N%S \
#                                    /usr/openwin/lib/%T/%N%S | \
#                               tr ' ' :`
#   [ -z "$XMICONSEARCHPATH" ] && \
#       export XMICONSEARCHPATH=`echo ~/.dt/icons/%B%M.pm \
#                                     ~/.dt/icons/%B%M.bm \
#                                     ~/.dt/icons/%B \
#                                     /usr/dt/appconfig/icons/%L/%B%M.pm \
#                                     /usr/dt/appconfig/icons/%L/%B%M.bm \
#                                     /usr/dt/appconfig/icons/%L/%B \
#                                     /usr/dt/appconfig/icons/C/%B%M.pm \
#                                     /usr/dt/appconfig/icons/C/%B%M.bm \
#                                     /usr/dt/appconfig/icons/C/%B | \
#                                tr ' ' :`
#   [ -z "$XMICONBMSEARCHPATH" ] && \
#       export XMICONBMSEARCHPATH=`echo ~/.dt/icons/%B%M.bm \
#                                       ~/.dt/icons/%B%M.pm \
#                                       ~/.dt/icons/%B \
#                                       /usr/dt/appconfig/icons/%L/%B%M.bm \
#                                       /usr/dt/appconfig/icons/%L/%B%M.pm \
#                                       /usr/dt/appconfig/icons/%L/%B \
#                                       /usr/dt/appconfig/icons/C/%B%M.bm \
#                                       /usr/dt/appconfig/icons/C/%B%M.pm \
#                                       /usr/dt/appconfig/icons/C/%B | \
#                                  tr ' ' :`
#   [ -z "$DTSOURCEPROFILE" ] && export DTSOURCEPROFILE=true
#   [ -z "$DTHELPSEARCHPATH" ] && \
#       export DTHELPSEARCHPATH=\
#           `echo ~/.dt/help/$DTUSERSESSION/%H \
#                 ~/.dt/help/$DTUSERSESSION/%H.sdl \
#                 ~/.dt/help/$DTUSERSESSION/%H.hv \
#                 ~/.dt/help/%H \
#                 ~/.dt/help/%H.sdl \
#                 ~/.dt/help/%H.hv \
#                 /usr/dt/appconfig/help/%L/%H \
#                 /usr/dt/appconfig/help/%L/%H.sdl \
#                 /usr/dt/appconfig/help/%L/%H.hv \
#                 /usr/dt/appconfig/help/C/%H \
#                 /usr/dt/appconfig/help/C/%H.sdl \
#                 /usr/dt/appconfig/help/C/%H.hv | \
#            tr ' ' :`
    [ -z "$DTAPPSEARCHPATH" ] && \
        { DTAPPSEARCHPATH=`echo $HOME/.dt/appmanager \
                                /usr/dt/appconfig/appmanager/%L \
                                /usr/dt/appconfig/appmanager/C | \
                           tr ' ' :`
          export DTAPPSEARCHPATH; }
    [ -z "$TERMINAL_EMULATOR" ] && \
        { TERMINAL_EMULATOR=xterm
           export TERMINAL_EMULATOR; }
  fi

  # use NEdit
  XEDITOR="nc -noask"
  export XEDITOR
  if [ -z "$NEDIT_INCLUDE_PATH" ]; then
    # put "standard" include paths here
    case "$UNAME" in
      SunOS)
        NEDIT_INCLUDE_PATH=`find /opt/SUNWspro/WS6U2/include/CC/ \
                                     -type d -print`
        ;;
    esac
    NEDIT_INCLUDE_PATH=`buildpath \
                         . \
                         /opt/SUNWspro/WS6U2/include/CC/Cstd \
                         $NEDIT_INCLUDE_PATH \
                         /usr/include`
    export NEDIT_INCLUDE_PATH
  fi

  if [ -d "$HOME/.app-defaults" ]; then
    app_defaults=~/.app-defaults
    XAPPLRESDIR=$app_defaults
    app_defaults=$app_defaults/%N
    if [ -n "$XUSERFILESEARCHPATH" ]; then
      case "${XUSERFILESEARCHPATH}:" in
      *:${app_defaults}:*)
          # echo not Resetting XUSERFILESEARCHPATH
          ;;
      *)
          # echo Resetting XUSERFILESEARCHPATH
          XUSERFILESEARCHPATH=${XUSERFILESEARCHPATH}:$app_defaults
          ;;
      esac
    else
      XUSERFILESEARCHPATH=$app_defaults
    fi
    export XAPPLRESDIR XUSERFILESEARCHPATH
  fi
fi