# ltmain.sh - Provide generalized library-building support services.

# NOTE: Changing this file will not affect anything until you rerun ltconfig.

#

# Copyright (C) 1996-1998 Free Software Foundation, Inc.

# Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996</gord@gnu.ai.mit.edu>

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 2 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful, but

# WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

# General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

#

# As a special exception to the GNU General Public License, if you

# distribute this file as part of a program that contains a

# configuration script generated by Autoconf, you may include it under

# the same distribution terms that you use for the rest of that program.

# The name of this program.

progname=`$echo "$0" | sed 's%^.*/%%'`

modename="$progname"

# Constants.

PROGRAM=ltmain.sh

PACKAGE=libtool

VERSION=1.2

default_mode=

help="Try \`$progname --help' for more information."

magic="%%%MAGIC variable%%%"

mkdir="mkdir"

mv="mv -f"

rm="rm -f"

# Sed substitution that helps us do robust quoting.  It backslashifies

# metacharacters that are still active within double-quoted strings.

Xsed='sed -e s/^X//'

sed_quote_subst='s/\([\\`\\"$\\\\]\)/\\\1/g'

# NLS nuisances.

# Only set LANG and LC_ALL to C if already set.

# These must not be set unconditionally because not all systems understand

# e.g. LANG=C (notably SCO).

if test "${LC_ALL+set}" = set; then LC_ALL=C; export LC_ALL; fi

if test "${LANG+set}"   = set; then LANG=C;   export LANG;   fi

if test "$LTCONFIG_VERSION" != "$VERSION"; then

  echo "$modename: ltconfig version \`$LTCONFIG_VERSION' does not match $PROGRAM version \`$VERSION'" 1>&2

  echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2

  exit 1

fi

if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then

  echo "$modename: not configured to build any kind of library" 1>&2

  echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2

  exit 1

fi

# Global variables.

mode=$default_mode

nonopt=

prev=

prevopt=

run=

show="$echo"

show_help=

execute_dlfiles=

# Parse our command line options once, thoroughly.

while test $# -gt 0

do

  arg="$1"

  shift

  case "$arg" in

  -*=*) optarg=`$echo "X$arg" | $Xsed -e 's/[-_a-zA-Z0-9]*=//'` ;;

  *) optarg= ;;

  esac

  # If the previous option needs an argument, assign it.

  if test -n "$prev"; then

    case "$prev" in

    execute_dlfiles)

      eval "$prev=\"\$$prev \$arg\""

      ;;

    *)

      eval "$prev=\$arg"

      ;;

    esac

    prev=

    prevopt=

    continue

  fi

  # Have we seen a non-optional argument yet?

  case "$arg" in

  --help)

    show_help=yes

    ;;

  --version)

    echo "$PROGRAM (GNU $PACKAGE) $VERSION"

    exit 0

    ;;

  --dry-run | -n)

    run=:

    ;;

  --features)

    echo "host: $host"

    if test "$build_libtool_libs" = yes; then

      echo "enable shared libraries"

    else

      echo "disable shared libraries"

    fi

    if test "$build_old_libs" = yes; then

      echo "enable static libraries"

    else

      echo "disable static libraries"

    fi

    exit 0

    ;;

  --finish) mode="finish" ;;

  --mode) prevopt="--mode" prev=mode ;;

  --mode=*) mode="$optarg" ;;

  --quiet | --silent)

    show=:

    ;;

  -dlopen)

    prevopt="-dlopen"

    prev=execute_dlfiles

    ;;

  -*)

    $echo "$modename: unrecognized option \`$arg'" 1>&2

    $echo "$help" 1>&2

    exit 1

    ;;

  *)

    nonopt="$arg"

    break

    ;;

  esac

done

if test -n "$prevopt"; then

  $echo "$modename: option \`$prevopt' requires an argument" 1>&2

  $echo "$help" 1>&2

  exit 1

fi

if test -z "$show_help"; then

  # Infer the operation mode.

  if test -z "$mode"; then

    case "$nonopt" in

    *cc | *++ | gcc* | *-gcc*)

      mode=link

      for arg

      do

        case "$arg" in

        -c)

           mode=compile

           break

           ;;

        esac

      done

      ;;

    *db | *dbx)

      mode=execute

      ;;

    *install*|cp|mv)

      mode=install

      ;;

    *rm)

      mode=uninstall

      ;;

    *)

      # If we have no mode, but dlfiles were specified, then do execute mode.

      test -n "$execute_dlfiles" && mode=execute

      # Just use the default operation mode.

      if test -z "$mode"; then

        if test -n "$nonopt"; then

          $echo "$modename: warning: cannot infer operation mode from \`$nonopt'" 1>&2

        else

          $echo "$modename: warning: cannot infer operation mode without MODE-ARGS" 1>&2

        fi

      fi

      ;;

    esac

  fi

  # Only execute mode is allowed to have -dlopen flags.

  if test -n "$execute_dlfiles" && test "$mode" != execute; then

    $echo "$modename: unrecognized option \`-dlopen'" 1>&2

    $echo "$help" 1>&2

    exit 1

  fi

  # Change the help message to a mode-specific one.

  generic_help="$help"

  help="Try \`$modename --help --mode=$mode' for more information."

  # These modes are in order of execution frequency so that they run quickly.

  case "$mode" in

  # libtool compile mode

  compile)

    modename="$modename: compile"

    # Get the compilation command and the source file.

    base_compile=

    lastarg=

    srcfile="$nonopt"

    suppress_output=

    for arg

    do

      # Accept any command-line options.

      case "$arg" in

      -o)

	$echo "$modename: you cannot specify the output filename with \`-o'" 1>&2

	$echo "$help" 1>&2

	exit 1

	;;

      -static)

	build_libtool_libs=no

	build_old_libs=yes

	continue

	;;

      esac

      # Accept the current argument as the source file.

      lastarg="$srcfile"

      srcfile="$arg"

      # Aesthetically quote the previous argument.

      # Backslashify any backslashes, double quotes, and dollar signs.

      # These are the only characters that are still specially

      # interpreted inside of double-quoted scrings.

      lastarg=`$echo "X$lastarg" | $Xsed -e "$sed_quote_subst"`

      # Double-quote args containing other shell metacharacters.

      # Many Bourne shells cannot handle close brackets correctly in scan

      # sets, so we specify it separately.

      case "$lastarg" in

      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*)

	lastarg="\"$lastarg\""

	;;

      esac

      # Add the previous argument to base_compile.

      if test -z "$base_compile"; then

	base_compile="$lastarg"

      else

	base_compile="$base_compile $lastarg"

      fi

    done

    # Get the name of the library object.

    libobj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%'`

    # Recognize several different file suffixes.

    xform='[cCFSfms]'

    case "$libobj" in

    *.ada) xform=ada ;;

    *.adb) xform=adb ;;

    *.ads) xform=ads ;;

    *.asm) xform=asm ;;

    *.c++) xform=c++ ;;

    *.cc) xform=cc ;;

    *.cpp) xform=cpp ;;

    *.cxx) xform=cxx ;;

    *.f90) xform=f90 ;;

    *.for) xform=for ;;

    esac

    libobj=`$echo "X$libobj" | $Xsed -e "s/\.$xform$/.lo/"`

    case "$libobj" in

    *.lo) obj=`$echo "X$libobj" | $Xsed -e 's/\.lo$/.o/'` ;;

    *)

      $echo "$modename: cannot determine name of library object from \`$srcfile'" 1>&2

      exit 1

      ;;

    esac

    if test -z "$base_compile"; then

      $echo "$modename: you must specify a compilation command" 1>&2

      $echo "$help" 1>&2

      exit 1

    fi

    # Delete any leftover library objects.

    if test "$build_old_libs" = yes; then

      $run $rm $obj $libobj

      trap "$run $rm $obj $libobj; exit 1" 1 2 15

    else

      $run $rm $libobj

      trap "$run $rm $libobj; exit 1" 1 2 15

    fi

    # Only build a PIC object if we are building libtool libraries.

    if test "$build_libtool_libs" = yes; then

      # Without this assignment, base_compile gets emptied.

      fbsd_hideous_sh_bug=$base_compile

      # All platforms use -DPIC, to notify preprocessed assembler code.

      $show "$base_compile$pic_flag -DPIC $srcfile"

      if $run eval "$base_compile\$pic_flag -DPIC \$srcfile"; then :

      else

        test -n "$obj" && $run $rm $obj

        exit 1

      fi

      # If we have no pic_flag, then copy the object into place and finish.

      if test -z "$pic_flag"; then

        $show "$LN_S $obj $libobj"

        $run $LN_S $obj $libobj

        exit $?

      fi

      # Just move the object, then go on to compile the next one

      $show "$mv $obj $libobj"

      $run $mv $obj $libobj || exit 1

      # Allow error messages only from the first compilation.

      suppress_output=' >/dev/null 2>&1'

    fi

    # Only build a position-dependent object if we build old libraries.

    if test "$build_old_libs" = yes; then

      # Suppress compiler output if we already did a PIC compilation.

      $show "$base_compile $srcfile$suppress_output"

      if $run eval "$base_compile \$srcfile$suppress_output"; then :

      else

        $run $rm $obj $libobj

        exit 1

      fi

    fi

    # Create an invalid libtool object if no PIC, so that we do not

    # accidentally link it into a program.

    if test "$build_libtool_libs" != yes; then

      $show "echo timestamp > $libobj"

      $run eval "echo timestamp > \$libobj" || exit $?

    fi

    exit 0

    ;;

  # libtool link mode

  link)

    modename="$modename: link"

    CC="$nonopt"

    allow_undefined=yes

    compile_command="$CC"

    finalize_command="$CC"

    compile_shlibpath=

    finalize_shlibpath=

    deplibs=

    dlfiles=

    dlprefiles=

    export_dynamic=no

    hardcode_libdirs=

    libobjs=

    link_against_libtool_libs=

    ltlibs=

    objs=

    prev=

    prevarg=

    release=

    rpath=

    perm_rpath=

    temp_rpath=

    vinfo=

    # We need to know -static, to get the right output filenames.

    for arg

    do

      case "$arg" in

      -all-static | -static)

        if test "X$arg" = "X-all-static" && test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then

	    $echo "$modename: warning: complete static linking is impossible in this configuration" 1>&2

        fi

        build_libtool_libs=no

	build_old_libs=yes

        break

        ;;

      esac

    done

    # See if our shared archives depend on static archives.

    test -n "$old_archive_from_new_cmds" && build_old_libs=yes

    # Go through the arguments, transforming them on the way.

    for arg

    do

      # If the previous option needs an argument, assign it.

      if test -n "$prev"; then

        case "$prev" in

        output)

          compile_command="$compile_command @OUTPUT@"

          finalize_command="$finalize_command @OUTPUT@"

          ;;

        esac

        case "$prev" in

        dlfiles|dlprefiles)

          case "$arg" in

          *.la | *.lo) ;;  # We handle these cases below.

          *)

            dlprefiles="$dlprefiles $arg"

            test "$prev" = dlfiles && dlfiles="$dlfiles $arg"

            prev=

            ;;

          esac

          ;;

	release)

	  release="-$arg"

	  prev=

	  continue

	  ;;

        rpath)

          rpath="$rpath $arg"

	  prev=

	  continue

	  ;;

        *)

          eval "$prev=\"\$arg\""

          prev=

          continue

          ;;

        esac

      fi

      prevarg="$arg"

      case "$arg" in

      -all-static)

	if test -n "$link_static_flag"; then

          compile_command="$compile_command $link_static_flag"

	  finalize_command="$finalize_command $link_static_flag"

        fi

        continue

	;;

      -allow-undefined)

	# FIXME: remove this flag sometime in the future.

	$echo "$modename: \`-allow-undefined' is deprecated because it is the default" 1>&2

	continue

	;;

      -dlopen)

        prev=dlfiles

        continue

        ;;

      -dlpreopen)

        prev=dlprefiles

        continue

        ;;

      -export-dynamic)

        if test "$export_dynamic" != yes; then

          export_dynamic=yes

	  if test -n "$export_dynamic_flag_spec"; then

	    eval arg=\"$export_dynamic_flag_spec\"

	  else

	    arg=

	  fi

          # Add the symbol object into the linking commands.

	  compile_command="$compile_command @SYMFILE@"

	  finalize_command="$finalize_command @SYMFILE@"

        fi

        ;;

      -L*)

        dir=`$echo "X$arg" | $Xsed -e 's%^-L\(.*\)$%\1%'`

        case "$dir" in

        /* | [A-Za-z]:\\*)

	  # Add the corresponding hardcode_libdir_flag, if it is not identical.

          ;;

        *)

          $echo "$modename: \`-L$dir' cannot specify a relative directory" 1>&2

          exit 1

          ;;

        esac

        deplibs="$deplibs $arg"

        ;;

      -l*) deplibs="$deplibs $arg" ;;

      -no-undefined)

	allow_undefined=no

	continue

	;;

      -o) prev=output ;;

      -release)

	prev=release

	continue

	;;

      -rpath)

        prev=rpath

        continue

        ;;

      -static)

	# If we have no pic_flag, then this is the same as -all-static.

	if test -z "$pic_flag" && test -n "$link_static_flag"; then

          compile_command="$compile_command $link_static_flag"

	  finalize_command="$finalize_command $link_static_flag"

        fi

	continue

	;;

      -version-info)

        prev=vinfo

        continue

        ;;

      # Some other compiler flag.

      -* | +*)

	# Unknown arguments in both finalize_command and compile_command need

	# to be aesthetically quoted because they are evaled later.

	arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`

	case "$arg" in

	*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*)

	  arg="\"$arg\""

	  ;;

	esac

        ;;

      *.o | *.a)

        # A standard object.

        objs="$objs $arg"

        ;;

      *.lo)

        # A library object.

	if test "$prev" = dlfiles; then

	  dlfiles="$dlfiles $arg"

	  if test "$build_libtool_libs" = yes; then

	    prev=

	    continue

	  else

	    # If libtool objects are unsupported, then we need to preload.

	    prev=dlprefiles

	  fi

	fi

	if test "$prev" = dlprefiles; then

	  # Preload the old-style object.

	  dlprefiles="$dlprefiles "`$echo "X$arg" | $Xsed -e 's/\.lo$/\.o/'`

	  prev=

	fi

	libobjs="$libobjs $arg"

        ;;

      *.la)

        # A libtool-controlled library.

        dlname=

        libdir=

        library_names=

        old_library=

        # Check to see that this really is a libtool archive.

        if (sed -e '2q' $arg | egrep '^# Generated by ltmain\.sh') >/dev/null 2>&1; then :

        else

          $echo "$modename: \`$arg' is not a valid libtool archive" 1>&2

          exit 1

        fi

        # If there is no directory component, then add one.

        case "$arg" in

        */* | *\\*) . $arg ;;

        *) . ./$arg ;;

        esac

        if test -z "$libdir"; then

          $echo "$modename: \`$arg' contains no -rpath information" 1>&2

          exit 1

        fi

        # Get the name of the library we link against.

        linklib=

        for l in $old_library $library_names; do

          linklib="$l"

        done

        if test -z "$linklib"; then

          $echo "$modename: cannot find name of link library for \`$arg'" 1>&2

          exit 1

        fi

        # Find the relevant object directory and library name.

        name=`$echo "X$arg" | $Xsed -e 's%^.*/%%' -e 's/\.la$//' -e 's/^lib//'`

        dir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`

        if test "X$dir" = "X$arg"; then

          dir="$objdir"

        else

          dir="$dir/$objdir"

        fi

        # This library was specified with -dlopen.

        if test "$prev" = dlfiles; then

          dlfiles="$dlfiles $arg"

          if test -z "$dlname"; then

            # If there is no dlname, we need to preload.

            prev=dlprefiles

          else

            # We should not create a dependency on this library, but we

	    # may need any libraries it requires.

	    compile_command="$compile_command$dependency_libs"

	    finalize_command="$finalize_command$dependency_libs"

            prev=

            continue

          fi

        fi

        # The library was specified with -dlpreopen.

        if test "$prev" = dlprefiles; then

          # Prefer using a static library (so that no silly _DYNAMIC symbols

          # are required to link).

          if test -n "$old_library"; then

            dlprefiles="$dlprefiles $dir/$old_library"

          else

            dlprefiles="$dlprefiles $dir/$linklib"

          fi

          prev=

        fi

        if test "$build_libtool_libs" = yes && test -n "$library_names"; then

          link_against_libtool_libs="$link_against_libtool_libs $arg"

          if test -n "$shlibpath_var"; then

            # Make sure the rpath contains only unique directories.

            case "$temp_rpath " in

            *" $dir "*) ;;

            *) temp_rpath="$temp_rpath $dir" ;;

            esac

          fi

	  # This is the magic to use -rpath.

          if test -n "$hardcode_libdir_flag_spec"; then

            if test -n "$hardcode_libdir_separator"; then

              if test -z "$hardcode_libdirs"; then

                # Put the magic libdir with the hardcode flag.

                hardcode_libdirs="$libdir"

                libdir="@HARDCODE_LIBDIRS@"

              else

                # Just accumulate the unique libdirs.

		case "$hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator" in

		*"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)

		  ;;

		*)

		  hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"

		  ;;

		esac

                libdir=

              fi

            fi

            if test -n "$libdir"; then

              eval flag=\"$hardcode_libdir_flag_spec\"

              compile_command="$compile_command $flag"

              finalize_command="$finalize_command $flag"

            fi

          elif test -n "$runpath_var"; then

            # Do the same for the permanent run path.

            case "$perm_rpath " in

            *" $libdir "*) ;;

            *) perm_rpath="$perm_rpath $libdir" ;;

            esac

          fi

          case "$hardcode_action" in

          immediate)

            if test "$hardcode_direct" = no; then

              compile_command="$compile_command $dir/$linklib"

            elif test "$hardcode_minus_L" = no; then

              compile_command="$compile_command -L$dir -l$name"

            elif test "$hardcode_shlibpath_var" = no; then

              compile_shlibpath="$compile_shlibpath$dir:"

              compile_command="$compile_command -l$name"

            fi

            ;;

          relink)

            # We need an absolute path.

            case "$dir" in

            /* | [A-Za-z]:\\*) ;;

            *)

              absdir=`cd "$dir" && pwd`

              if test -z "$absdir"; then

                $echo "$modename: cannot determine absolute directory name of \`$dir'" 1>&2

                exit 1

              fi

              dir="$absdir"

              ;;

            esac

            if test "$hardcode_direct" = yes; then

              compile_command="$compile_command $dir/$linklib"

            elif test "$hardcode_minus_L" = yes; then

              compile_command="$compile_command -L$dir -l$name"

            elif test "$hardcode_shlibpath_var" = yes; then

              compile_shlibpath="$compile_shlibpath$dir:"

              compile_command="$compile_command -l$name"

            fi

            ;;

          *)

            $echo "$modename: \`$hardcode_action' is an unknown hardcode action" 1>&2

            exit 1

            ;;

          esac

          # Finalize command for both is simple: just hardcode it.

          if test "$hardcode_direct" = yes; then

            finalize_command="$finalize_command $libdir/$linklib"

          elif test "$hardcode_minus_L" = yes; then

            finalize_command="$finalize_command -L$libdir -l$name"

          elif test "$hardcode_shlibpath_var" = yes; then

            finalize_shlibpath="$finalize_shlibpath$libdir:"

            finalize_command="$finalize_command -l$name"

          else

            # We cannot seem to hardcode it, guess we'll fake it.

            finalize_command="$finalize_command -L$libdir -l$name"

          fi

        else

          # Transform directly to old archives if we don't build new libraries.

          if test -n "$pic_flag" && test -z "$old_library"; then

            $echo "$modename: cannot find static library for \`$arg'" 1>&2

            exit 1

          fi

	  # Here we assume that one of hardcode_direct or hardcode_minus_L

	  # is not unsupported.  This is valid on all known static and

	  # shared platforms.

	  if test "$hardcode_direct" != unsupported; then

	    test -n "$old_library" && linklib="$old_library"

	    compile_command="$compile_command $dir/$linklib"

	    finalize_command="$finalize_command $dir/$linklib"

	  else

	    compile_command="$compile_command -L$dir -l$name"

	    finalize_command="$finalize_command -L$dir -l$name"

	  fi

        fi

	# Add in any libraries that this one depends upon.

	compile_command="$compile_command$dependency_libs"

	finalize_command="$finalize_command$dependency_libs"

	continue

        ;;

      # Some other compiler argument.

      *)

	# Unknown arguments in both finalize_command and compile_command need

	# to be aesthetically quoted because they are evaled later.

	arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`

	case "$arg" in

	*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*)

	  arg="\"$arg\""

	  ;;

	esac

        ;;

      esac

      # Now actually substitute the argument into the commands.

      if test -n "$arg"; then

	compile_command="$compile_command $arg"

	finalize_command="$finalize_command $arg"

      fi

    done

    if test -n "$prev"; then

      $echo "$modename: the \`$prevarg' option requires an argument" 1>&2

      $echo "$help" 1>&2

      exit 1

    fi

    if test -n "$vinfo" && test -n "$release"; then

      $echo "$modename: you cannot specify both \`-version-info' and \`-release'" 1>&2

      $echo "$help" 1>&2

      exit 1

    fi

    oldlib=

    oldobjs=

    case "$output" in

    "")

      $echo "$modename: you must specify an output file" 1>&2

      $echo "$help" 1>&2

      exit 1

      ;;

    */* | *\\*)

      $echo "$modename: output file \`$output' must have no directory components" 1>&2

      exit 1

      ;;

    *.a)

      # Now set the variables for building old libraries.

      build_libtool_libs=no

      build_old_libs=yes

      oldlib="$output"

      $show "$rm $oldlib"

      $run $rm $oldlib

      ;;

    *.la)

      # Make sure we only generate libraries of the form `libNAME.la'.

      case "$output" in

      lib*) ;;

      *)

	$echo "$modename: libtool library \`$arg' must begin with \`lib'" 1>&2

	$echo "$help" 1>&2

	exit 1

	;;

      esac

      name=`$echo "X$output" | $Xsed -e 's/\.la$//' -e 's/^lib//'`

      eval libname=\"$libname_spec\"

      # All the library-specific variables (install_libdir is set above).

      library_names=

      old_library=

      dlname=

      current=0

      revision=0

      age=0

      if test -n "$objs"; then

        $echo "$modename: cannot build libtool library \`$output' from non-libtool objects:$objs" 2>&1

        exit 1

      fi

      # How the heck are we supposed to write a wrapper for a shared library?

      if test -n "$link_against_libtool_libs"; then

        $echo "$modename: libtool library \`$output' may not depend on uninstalled libraries:$link_against_libtool_libs" 1>&2

        exit 1

      fi

      if test -n "$dlfiles$dlprefiles"; then

        $echo "$modename: warning: \`-dlopen' is ignored while creating libtool libraries" 1>&2

        # Nullify the symbol file.

        compile_command=`$echo "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`

        finalize_command=`$echo "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`

      fi

      if test -z "$rpath"; then

        $echo "$modename: you must specify an installation directory with \`-rpath'" 1>&2

	$echo "$help" 1>&2

        exit 1

      fi