/sqlite3cc

# Generated from ltmain.m4sh.

 

# ltmain.sh (GNU libtool) 2.2.6

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

 

# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006, 2007 2008 Free Software Foundation, Inc.

# This is free software; see the source for copying conditions.  There is NO

# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

 

# GNU Libtool 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.

#

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

# if you distribute this file as part of a program or library that

# is built using GNU Libtool, you may include this file under the

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

#

# GNU Libtool 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 GNU Libtool; see the file COPYING.  If not, a copy

# can be downloaded from http://www.gnu.org/licenses/gpl.html,

# or obtained by writing to the Free Software Foundation, Inc.,

# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

 

# Usage: $progname [OPTION]... [MODE-ARG]...

#

# Provide generalized library-building support services.

#

#     --config             show all configuration variables

#     --debug              enable verbose shell tracing

# -n, --dry-run            display commands without modifying any files

#     --features           display basic configuration information and exit

#     --mode=MODE          use operation mode MODE

#     --preserve-dup-deps  don't remove duplicate dependency libraries

#     --quiet, --silent    don't print informational messages

#     --tag=TAG            use configuration variables from tag TAG

# -v, --verbose            print informational messages (default)

#     --version            print version information

# -h, --help               print short or long help message

#

# MODE must be one of the following:

#

#       clean              remove files from the build directory

#       compile            compile a source file into a libtool object

#       execute            automatically set library path, then run a program

#       finish             complete the installation of libtool libraries

#       install            install libraries or executables

#       link               create a library or an executable

#       uninstall          remove libraries from an installed directory

#

# MODE-ARGS vary depending on the MODE.

# Try `$progname --help --mode=MODE' for a more detailed description of MODE.

#

# When reporting a bug, please describe a test case to reproduce it and

# include the following information:

#

#       host-triplet:   $host

#       shell:          $SHELL

#       compiler:               $LTCC

#       compiler flags:         $LTCFLAGS

#       linker:         $LD (gnu? $with_gnu_ld)

#       $progname:              (GNU libtool) 2.2.6 Debian-2.2.6a-4

#       automake:               $automake_version

#       autoconf:               $autoconf_version

#

# Report bugs to <bug-libtool@gnu.org>.

 

PROGRAM=ltmain.sh

PACKAGE=libtool

VERSION="2.2.6 Debian-2.2.6a-4"

TIMESTAMP=""

package_revision=1.3012

 

# Be Bourne compatible

if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then

  emulate sh

  NULLCMD=:

  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which

  # is contrary to our usage.  Disable this feature.

  alias -g '${1+"$@"}'='"$@"'

  setopt NO_GLOB_SUBST

else

  case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac

fi

BIN_SH=xpg4; export BIN_SH # for Tru64

DUALCASE=1; export DUALCASE # for MKS sh

 

# NLS nuisances: We save the old values to restore during execute mode.

# 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).

lt_user_locale=

lt_safe_locale=

for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES

do

  eval "if test \"\${$lt_var+set}\" = set; then

          save_$lt_var=\$$lt_var

          $lt_var=C

          export $lt_var

          lt_user_locale=\"$lt_var=\\\$save_\$lt_var; \$lt_user_locale\"

          lt_safe_locale=\"$lt_var=C; \$lt_safe_locale\"

        fi"

done

 

$lt_unset CDPATH

 

 

 

 

 

: ${CP="cp -f"}

: ${ECHO="echo"}

: ${EGREP="/bin/grep -E"}

: ${FGREP="/bin/grep -F"}

: ${GREP="/bin/grep"}

: ${LN_S="ln -s"}

: ${MAKE="make"}

: ${MKDIR="mkdir"}

: ${MV="mv -f"}

: ${RM="rm -f"}

: ${SED="/bin/sed"}

: ${SHELL="${CONFIG_SHELL-/bin/sh}"}

: ${Xsed="$SED -e 1s/^X//"}

 

# Global variables:

EXIT_SUCCESS=0

EXIT_FAILURE=1

EXIT_MISMATCH=63  # $? = 63 is used to indicate version mismatch to missing.

EXIT_SKIP=77      # $? = 77 is used to indicate a skipped test to automake.

 

exit_status=$EXIT_SUCCESS

 

# Make sure IFS has a sensible default

lt_nl='

'

IFS="   $lt_nl"

 

dirname="s,/[^/]*$,,"

basename="s,^.*/,,"

 

# func_dirname_and_basename file append nondir_replacement

# perform func_basename and func_dirname in a single function

# call:

#   dirname:  Compute the dirname of FILE.  If nonempty,

#             add APPEND to the result, otherwise set result

#             to NONDIR_REPLACEMENT.

#             value returned in "$func_dirname_result"

#   basename: Compute filename of FILE.

#             value retuned in "$func_basename_result"

# Implementation must be kept synchronized with func_dirname

# and func_basename. For efficiency, we do not delegate to

# those functions but instead duplicate the functionality here.

func_dirname_and_basename ()

{

  # Extract subdirectory from the argument.

  func_dirname_result=`$ECHO "X${1}" | $Xsed -e "$dirname"`

  if test "X$func_dirname_result" = "X${1}"; then

    func_dirname_result="${3}"

  else

    func_dirname_result="$func_dirname_result${2}"

  fi

  func_basename_result=`$ECHO "X${1}" | $Xsed -e "$basename"`

}

 

# Generated shell functions inserted here.

 

# Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh

# is ksh but when the shell is invoked as "sh" and the current value of

# the _XPG environment variable is not equal to 1 (one), the special

# positional parameter $0, within a function call, is the name of the

# function.

progpath="$0"

 

# The name of this program:

# In the unlikely event $progname began with a '-', it would play havoc with

# func_echo (imagine progname=-n), so we prepend ./ in that case:

func_dirname_and_basename "$progpath"

progname=$func_basename_result

case $progname in

  -*) progname=./$progname ;;

esac

 

# Make sure we have an absolute path for reexecution:

case $progpath in

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

  *[\\/]*)

     progdir=$func_dirname_result

     progdir=`cd "$progdir" && pwd`

     progpath="$progdir/$progname"

     ;;

  *)

     save_IFS="$IFS"

     IFS=:

     for progdir in $PATH; do

       IFS="$save_IFS"

       test -x "$progdir/$progname" && break

     done

     IFS="$save_IFS"

     test -n "$progdir" || progdir=`pwd`

     progpath="$progdir/$progname"

     ;;

esac

 

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

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

Xsed="${SED}"' -e 1s/^X//'

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

 

# Same as above, but do not quote variable references.

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

 

# Re-`\' parameter expansions in output of double_quote_subst that were

# `\'-ed in input to the same.  If an odd number of `\' preceded a '$'

# in input to double_quote_subst, that '$' was protected from expansion.

# Since each input `\' is now two `\'s, look for any number of runs of

# four `\'s followed by two `\'s and then a '$'.  `\' that '$'.

bs='\\'

bs2='\\\\'

bs4='\\\\\\\\'

dollar='\$'

sed_double_backslash="\

  s/$bs4/&\\

/g

  s/^$bs2$dollar/$bs&/

  s/\\([^$bs]\\)$bs2$dollar/\\1$bs2$bs$dollar/g

  s/\n//g"

 

# Standard options:

opt_dry_run=false

opt_help=false

opt_quiet=false

opt_verbose=false

opt_warning=:

 

# func_echo arg...

# Echo program name prefixed message, along with the current mode

# name if it has been set yet.

func_echo ()

{

    $ECHO "$progname${mode+: }$mode: $*"

}

 

# func_verbose arg...

# Echo program name prefixed message in verbose mode only.

func_verbose ()

{

    $opt_verbose && func_echo ${1+"$@"}

 

    # A bug in bash halts the script if the last line of a function

    # fails when set -e is in force, so we need another command to

    # work around that:

    :

}

 

# func_error arg...

# Echo program name prefixed message to standard error.

func_error ()

{

    $ECHO "$progname${mode+: }$mode: "${1+"$@"} 1>&2

}

 

# func_warning arg...

# Echo program name prefixed warning message to standard error.

func_warning ()

{

    $opt_warning && $ECHO "$progname${mode+: }$mode: warning: "${1+"$@"} 1>&2

 

    # bash bug again:

    :

}

 

# func_fatal_error arg...

# Echo program name prefixed message to standard error, and exit.

func_fatal_error ()

{

    func_error ${1+"$@"}

    exit $EXIT_FAILURE

}

 

# func_fatal_help arg...

# Echo program name prefixed message to standard error, followed by

# a help hint, and exit.

func_fatal_help ()

{

    func_error ${1+"$@"}

    func_fatal_error "$help"

}

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

 

 

# func_grep expression filename

# Check whether EXPRESSION matches any line of FILENAME, without output.

func_grep ()

{

    $GREP "$1" "$2" >/dev/null 2>&1

}

 

 

# func_mkdir_p directory-path

# Make sure the entire path to DIRECTORY-PATH is available.

func_mkdir_p ()

{

    my_directory_path="$1"

    my_dir_list=

 

    if test -n "$my_directory_path" && test "$opt_dry_run" != ":"; then

 

      # Protect directory names starting with `-'

      case $my_directory_path in

        -*) my_directory_path="./$my_directory_path" ;;

      esac

 

      # While some portion of DIR does not yet exist...

      while test ! -d "$my_directory_path"; do

        # ...make a list in topmost first order.  Use a colon delimited

        # list incase some portion of path contains whitespace.

        my_dir_list="$my_directory_path:$my_dir_list"

 

        # If the last portion added has no slash in it, the list is done

        case $my_directory_path in */*) ;; *) break ;; esac

 

        # ...otherwise throw away the child directory and loop

        my_directory_path=`$ECHO "X$my_directory_path" | $Xsed -e "$dirname"`

      done

      my_dir_list=`$ECHO "X$my_dir_list" | $Xsed -e 's,:*$,,'`

 

      save_mkdir_p_IFS="$IFS"; IFS=':'

      for my_dir in $my_dir_list; do

        IFS="$save_mkdir_p_IFS"

        # mkdir can fail with a `File exist' error if two processes

        # try to create one of the directories concurrently.  Don't

        # stop in that case!

        $MKDIR "$my_dir" 2>/dev/null || :

      done

      IFS="$save_mkdir_p_IFS"

 

      # Bail out if we (or some other process) failed to create a directory.

      test -d "$my_directory_path" || \

        func_fatal_error "Failed to create \`$1'"

    fi

}

 

 

# func_mktempdir [string]

# Make a temporary directory that won't clash with other running

# libtool processes, and avoids race conditions if possible.  If

# given, STRING is the basename for that directory.

func_mktempdir ()

{

    my_template="${TMPDIR-/tmp}/${1-$progname}"

 

    if test "$opt_dry_run" = ":"; then

      # Return a directory name, but don't create it in dry-run mode

      my_tmpdir="${my_template}-$$"

    else

 

      # If mktemp works, use that first and foremost

      my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`

 

      if test ! -d "$my_tmpdir"; then

        # Failing that, at least try and use $RANDOM to avoid a race

        my_tmpdir="${my_template}-${RANDOM-0}$$"

 

        save_mktempdir_umask=`umask`

        umask 0077

        $MKDIR "$my_tmpdir"

        umask $save_mktempdir_umask

      fi

 

      # If we're not in dry-run mode, bomb out on failure

      test -d "$my_tmpdir" || \

        func_fatal_error "cannot create temporary directory \`$my_tmpdir'"

    fi

 

    $ECHO "X$my_tmpdir" | $Xsed

}

 

 

# func_quote_for_eval arg

# Aesthetically quote ARG to be evaled later.

# This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT

# is double-quoted, suitable for a subsequent eval, whereas

# FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters

# which are still active within double quotes backslashified.

func_quote_for_eval ()

{

    case $1 in

      *[\\\`\"\$]*)

        func_quote_for_eval_unquoted_result=`$ECHO "X$1" | $Xsed -e "$sed_quote_subst"` ;;

      *)

        func_quote_for_eval_unquoted_result="$1" ;;

    esac

 

    case $func_quote_for_eval_unquoted_result in

      # Double-quote args containing shell metacharacters to delay

      # word splitting, command substitution and and variable

      # expansion for a subsequent eval.

      # Many Bourne shells cannot handle close brackets correctly

      # in scan sets, so we specify it separately.

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

        func_quote_for_eval_result="\"$func_quote_for_eval_unquoted_result\""

        ;;

      *)

        func_quote_for_eval_result="$func_quote_for_eval_unquoted_result"

    esac

}

 

 

# func_quote_for_expand arg

# Aesthetically quote ARG to be evaled later; same as above,

# but do not quote variable references.

func_quote_for_expand ()

{

    case $1 in

      *[\\\`\"]*)

        my_arg=`$ECHO "X$1" | $Xsed \

            -e "$double_quote_subst" -e "$sed_double_backslash"` ;;

      *)

        my_arg="$1" ;;

    esac

 

    case $my_arg in

      # Double-quote args containing shell metacharacters to delay

      # word splitting and command substitution for a subsequent eval.

      # Many Bourne shells cannot handle close brackets correctly

      # in scan sets, so we specify it separately.

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

        my_arg="\"$my_arg\""

        ;;

    esac

 

    func_quote_for_expand_result="$my_arg"

}

 

 

# func_show_eval cmd [fail_exp]

# Unless opt_silent is true, then output CMD.  Then, if opt_dryrun is

# not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP

# is given, then evaluate it.

func_show_eval ()

{

    my_cmd="$1"

    my_fail_exp="${2-:}"

 

    ${opt_silent-false} || {

      func_quote_for_expand "$my_cmd"

      eval "func_echo $func_quote_for_expand_result"

    }

 

    if ${opt_dry_run-false}; then :; else

      eval "$my_cmd"

      my_status=$?

      if test "$my_status" -eq 0; then :; else

        eval "(exit $my_status); $my_fail_exp"

      fi

    fi

}

 

 

# func_show_eval_locale cmd [fail_exp]

# Unless opt_silent is true, then output CMD.  Then, if opt_dryrun is

# not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP

# is given, then evaluate it.  Use the saved locale for evaluation.

func_show_eval_locale ()

{

    my_cmd="$1"

    my_fail_exp="${2-:}"

 

    ${opt_silent-false} || {

      func_quote_for_expand "$my_cmd"

      eval "func_echo $func_quote_for_expand_result"

    }

 

    if ${opt_dry_run-false}; then :; else

      eval "$lt_user_locale

            $my_cmd"

      my_status=$?

      eval "$lt_safe_locale"

      if test "$my_status" -eq 0; then :; else

        eval "(exit $my_status); $my_fail_exp"

      fi

    fi

}

 

 

 

 

 

# func_version

# Echo version message to standard output and exit.

func_version ()

{

    $SED -n '/^# '$PROGRAM' (GNU /,/# warranty; / {

        s/^# //

        s/^# *$//

        s/\((C)\)[ 0-9,-]*\( [1-9][0-9]*\)/\1\2/

        p

     }' < "$progpath"

     exit $?

}

 

# func_usage

# Echo short help message to standard output and exit.

func_usage ()

{

    $SED -n '/^# Usage:/,/# -h/ {

        s/^# //

        s/^# *$//

        s/\$progname/'$progname'/

        p

    }' < "$progpath"

    $ECHO

    $ECHO "run \`$progname --help | more' for full usage"

    exit $?

}

 

# func_help

# Echo long help message to standard output and exit.

func_help ()

{

    $SED -n '/^# Usage:/,/# Report bugs to/ {

        s/^# //

        s/^# *$//

        s*\$progname*'$progname'*

        s*\$host*'"$host"'*

        s*\$SHELL*'"$SHELL"'*

        s*\$LTCC*'"$LTCC"'*

        s*\$LTCFLAGS*'"$LTCFLAGS"'*

        s*\$LD*'"$LD"'*

        s/\$with_gnu_ld/'"$with_gnu_ld"'/

        s/\$automake_version/'"`(automake --version) 2>/dev/null |$SED 1q`"'/

        s/\$autoconf_version/'"`(autoconf --version) 2>/dev/null |$SED 1q`"'/

        p

     }' < "$progpath"

    exit $?

}

 

# func_missing_arg argname

# Echo program name prefixed message to standard error and set global

# exit_cmd.

func_missing_arg ()

{

    func_error "missing argument for $1"

    exit_cmd=exit

}

 

exit_cmd=:

 

 

 

 

 

# Check that we have a working $ECHO.

if test "X$1" = X--no-reexec; then

  # Discard the --no-reexec flag, and continue.

  shift

elif test "X$1" = X--fallback-echo; then

  # Avoid inline document here, it may be left over

  :

elif test "X`{ $ECHO '\t'; } 2>/dev/null`" = 'X\t'; then

  # Yippee, $ECHO works!

  :

else

  # Restart under the correct shell, and then maybe $ECHO will work.

  exec $SHELL "$progpath" --no-reexec ${1+"$@"}

fi

 

if test "X$1" = X--fallback-echo; then

  # used as fallback echo

  shift

  cat <<EOF

$*

EOF

  exit $EXIT_SUCCESS

fi

 

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

magic_exe="%%%MAGIC EXE variable%%%"

 

# Global variables.

# $mode is unset

nonopt=

execute_dlfiles=

preserve_args=

lo2o="s/\\.lo\$/.${objext}/"

o2lo="s/\\.${objext}\$/.lo/"

extracted_archives=

extracted_serial=0

 

opt_dry_run=false

opt_duplicate_deps=false

opt_silent=false

opt_debug=:

 

# If this variable is set in any of the actions, the command in it

# will be execed at the end.  This prevents here-documents from being

# left over by shells.

exec_cmd=

 

# func_fatal_configuration arg...

# Echo program name prefixed message to standard error, followed by

# a configuration failure hint, and exit.

func_fatal_configuration ()

{

    func_error ${1+"$@"}

    func_error "See the $PACKAGE documentation for more information."

    func_fatal_error "Fatal configuration error."

}

 

 

# func_config

# Display the configuration for all the tags in this script.

func_config ()

{

    re_begincf='^# ### BEGIN LIBTOOL'

    re_endcf='^# ### END LIBTOOL'

 

    # Default configuration.

    $SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath"

 

    # Now print the configurations for the tags.

    for tagname in $taglist; do

      $SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath"

    done

 

    exit $?

}

 

# func_features

# Display the features supported by this script.

func_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 $?

}

 

# func_enable_tag tagname

# Verify that TAGNAME is valid, and either flag an error and exit, or

# enable the TAGNAME tag.  We also add TAGNAME to the global $taglist

# variable here.

func_enable_tag ()

{

  # Global variable:

  tagname="$1"

 

  re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"

  re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"

  sed_extractcf="/$re_begincf/,/$re_endcf/p"

 

  # Validate tagname.

  case $tagname in

    *[!-_A-Za-z0-9,/]*)

      func_fatal_error "invalid tag name: $tagname"

      ;;

  esac

 

  # Don't test for the "default" C tag, as we know it's

  # there but not specially marked.

  case $tagname in

    CC) ;;

    *)

      if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then

        taglist="$taglist $tagname"

 

        # Evaluate the configuration.  Be careful to quote the path

        # and the sed script, to avoid splitting on whitespace, but

        # also don't use non-portable quotes within backquotes within

        # quotes we have to do it in 2 steps:

        extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`

        eval "$extractedcf"

      else

        func_error "ignoring unknown tag $tagname"

      fi

      ;;

  esac

}

 

# Parse options once, thoroughly.  This comes as soon as possible in

# the script to make things like `libtool --version' happen quickly.

{

 

  # Shorthand for --mode=foo, only valid as the first argument

  case $1 in

  clean|clea|cle|cl)

    shift; set dummy --mode clean ${1+"$@"}; shift

    ;;

  compile|compil|compi|comp|com|co|c)

    shift; set dummy --mode compile ${1+"$@"}; shift

    ;;

  execute|execut|execu|exec|exe|ex|e)

    shift; set dummy --mode execute ${1+"$@"}; shift

    ;;

  finish|finis|fini|fin|fi|f)

    shift; set dummy --mode finish ${1+"$@"}; shift

    ;;

  install|instal|insta|inst|ins|in|i)

    shift; set dummy --mode install ${1+"$@"}; shift

    ;;

  link|lin|li|l)

    shift; set dummy --mode link ${1+"$@"}; shift

    ;;

  uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)

    shift; set dummy --mode uninstall ${1+"$@"}; shift

    ;;

  esac

 

  # Parse non-mode specific arguments:

  while test "$#" -gt 0; do

    opt="$1"

    shift

 

    case $opt in

      --config)         func_config                                     ;;

 

      --debug)          preserve_args="$preserve_args $opt"

                        func_echo "enabling shell trace mode"

                        opt_debug='set -x'

                        $opt_debug

                        ;;

 

      -dlopen)          test "$#" -eq 0 && func_missing_arg "$opt" && break

                        execute_dlfiles="$execute_dlfiles $1"

                        shift

                        ;;

 

      --dry-run | -n)   opt_dry_run=:                                   ;;

      --features)       func_features                                   ;;

      --finish)         mode="finish"                                   ;;

 

      --mode)           test "$#" -eq 0 && func_missing_arg "$opt" && break

                        case $1 in

                          # Valid mode arguments:

                          clean)        ;;

                          compile)      ;;

                          execute)      ;;

                          finish)       ;;

                          install)      ;;

                          link)         ;;

                          relink)       ;;

                          uninstall)    ;;

 

                          # Catch anything else as an error

                          *) func_error "invalid argument for $opt"

                             exit_cmd=exit

                             break

                             ;;

                        esac

 

                        mode="$1"

                        shift

                        ;;

 

      --preserve-dup-deps)

                        opt_duplicate_deps=:                            ;;

 

      --quiet|--silent) preserve_args="$preserve_args $opt"

                        opt_silent=:

                        ;;

 

      --verbose| -v)    preserve_args="$preserve_args $opt"

                        opt_silent=false

                        ;;

 

      --tag)            test "$#" -eq 0 && func_missing_arg "$opt" && break

                        preserve_args="$preserve_args $opt $1"

                        func_enable_tag "$1"    # tagname is set here

                        shift

                        ;;

 

      # Separate optargs to long options:

      -dlopen=*|--mode=*|--tag=*)

                        func_opt_split "$opt"

                        set dummy "$func_opt_split_opt" "$func_opt_split_arg" ${1+"$@"}

                        shift

                        ;;

 

      -\?|-h)           func_usage                                      ;;

      --help)           opt_help=:                                      ;;

      --version)        func_version                                    ;;

 

      -*)               func_fatal_help "unrecognized option \`$opt'"   ;;

 

      *)                nonopt="$opt"

                        break

                        ;;

    esac

  done

 

 

  case $host in

    *cygwin* | *mingw* | *pw32* | *cegcc*)

      # don't eliminate duplications in $postdeps and $predeps

      opt_duplicate_compiler_generated_deps=:

      ;;

    *)

      opt_duplicate_compiler_generated_deps=$opt_duplicate_deps

      ;;

  esac

 

  # Having warned about all mis-specified options, bail out if

  # anything was wrong.

  $exit_cmd $EXIT_FAILURE

}

 

# func_check_version_match

# Ensure that we are using m4 macros, and libtool script from the same

# release of libtool.

func_check_version_match ()

{

  if test "$package_revision" != "$macro_revision"; then

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

      if test -z "$macro_version"; then

        cat >&2 <<_LT_EOF

$progname: Version mismatch error.  This is $PACKAGE $VERSION, but the

$progname: definition of this LT_INIT comes from an older release.

$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION

$progname: and run autoconf again.

_LT_EOF

      else

        cat >&2 <<_LT_EOF

$progname: Version mismatch error.  This is $PACKAGE $VERSION, but the

$progname: definition of this LT_INIT comes from $PACKAGE $macro_version.

$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION

$progname: and run autoconf again.

_LT_EOF

      fi

    else

      cat >&2 <<_LT_EOF

$progname: Version mismatch error.  This is $PACKAGE $VERSION, revision $package_revision,

$progname: but the definition of this LT_INIT comes from revision $macro_revision.

$progname: You should recreate aclocal.m4 with macros from revision $package_revision

$progname: of $PACKAGE $VERSION and run autoconf again.

_LT_EOF

    fi

 

    exit $EXIT_MISMATCH

  fi

}

 

 

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

##    Main.    ##

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

 

$opt_help || {

  # Sanity checks first:

  func_check_version_match

 

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

    func_fatal_configuration "not configured to build any kind of library"

  fi

 

  test -z "$mode" && func_fatal_error "error: you must specify a MODE."

 

 

  # Darwin sucks

  eval std_shrext=\"$shrext_cmds\"

 

 

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

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

    func_error "unrecognized option \`-dlopen'"

    $ECHO "$help" 1>&2

    exit $EXIT_FAILURE

  fi

 

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

  generic_help="$help"

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

}

 

 

# func_lalib_p file

# True iff FILE is a libtool `.la' library or `.lo' object file.

# This function is only a basic sanity check; it will hardly flush out

# determined imposters.

func_lalib_p ()

{

    test -f "$1" &&

      $SED -e 4q "$1" 2>/dev/null \

        | $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1

}

 

# func_lalib_unsafe_p file

# True iff FILE is a libtool `.la' library or `.lo' object file.

# This function implements the same check as func_lalib_p without

# resorting to external programs.  To this end, it redirects stdin and

# closes it afterwards, without saving the original file descriptor.

# As a safety measure, use it only where a negative result would be

# fatal anyway.  Works if `file' does not exist.

func_lalib_unsafe_p ()

{

    lalib_p=no

    if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then

        for lalib_p_l in 1 2 3 4

        do

            read lalib_p_line

            case "$lalib_p_line" in

                \#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;

            esac

        done

        exec 0<&5 5<&-

    fi

    test "$lalib_p" = yes

}

 

# func_ltwrapper_script_p file

# True iff FILE is a libtool wrapper script

# This function is only a basic sanity check; it will hardly flush out

# determined imposters.

func_ltwrapper_script_p ()

{

    func_lalib_p "$1"

}

 

# func_ltwrapper_executable_p file

# True iff FILE is a libtool wrapper executable

# This function is only a basic sanity check; it will hardly flush out

# determined imposters.

func_ltwrapper_executable_p ()

{

    func_ltwrapper_exec_suffix=

    case $1 in

    *.exe) ;;

    *) func_ltwrapper_exec_suffix=.exe ;;

    esac

    $GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1

}

 

# func_ltwrapper_scriptname file

# Assumes file is an ltwrapper_executable

# uses $file to determine the appropriate filename for a

# temporary ltwrapper_script.

func_ltwrapper_scriptname ()

{

    func_ltwrapper_scriptname_result=""

    if func_ltwrapper_executable_p "$1"; then

        func_dirname_and_basename "$1" "" "."

        func_stripname '' '.exe' "$func_basename_result"

        func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper"

    fi

}

 

# func_ltwrapper_p file

# True iff FILE is a libtool wrapper script or wrapper executable

# This function is only a basic sanity check; it will hardly flush out

# determined imposters.

func_ltwrapper_p ()

{

    func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1"

}

 

 

# func_execute_cmds commands fail_cmd

# Execute tilde-delimited COMMANDS.

# If FAIL_CMD is given, eval that upon failure.

# FAIL_CMD may read-access the current command in variable CMD!

func_execute_cmds ()

{

    $opt_debug

    save_ifs=$IFS; IFS='~'

    for cmd in $1; do

      IFS=$save_ifs

      eval cmd=\"$cmd\"

      func_show_eval "$cmd" "${2-:}"

    done

    IFS=$save_ifs

}

 

 

# func_source file

# Source FILE, adding directory component if necessary.

# Note that it is not necessary on cygwin/mingw to append a dot to

# FILE even if both FILE and FILE.exe exist: automatic-append-.exe

# behavior happens only for exec(3), not for open(2)!  Also, sourcing

# `FILE.' does not work on cygwin managed mounts.

func_source ()

{

    $opt_debug

    case $1 in

    */* | *\\*) . "$1" ;;

    *)          . "./$1" ;;

    esac

}

 

 

# func_infer_tag arg

# Infer tagged configuration to use if any are available and

# if one wasn't chosen via the "--tag" command line option.

# Only attempt this if the compiler in the base compile

# command doesn't match the default compiler.

# arg is usually of the form 'gcc ...'

func_infer_tag ()

{

    $opt_debug

    if test -n "$available_tags" && test -z "$tagname"; then

      CC_quoted=

      for arg in $CC; do

        func_quote_for_eval "$arg"

        CC_quoted="$CC_quoted $func_quote_for_eval_result"

      done

      case $@ in

      # Blanks in the command may have been stripped by the calling shell,

      # but not from the CC environment variable when configure was run.

      " $CC "* | "$CC "* | " `$ECHO $CC` "* | "`$ECHO $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$ECHO $CC_quoted` "* | "`$ECHO $CC_quoted` "*) ;;

      # Blanks at the start of $base_compile will cause this to fail

      # if we don't check for them as well.

      *)

        for z in $available_tags; do

          if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then

            # Evaluate the configuration.

            eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"

            CC_quoted=

            for arg in $CC; do

              # Double-quote args containing other shell metacharacters.

              func_quote_for_eval "$arg"

              CC_quoted="$CC_quoted $func_quote_for_eval_result"

            done

            case "$@ " in

              " $CC "* | "$CC "* | " `$ECHO $CC` "* | "`$ECHO $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$ECHO $CC_quoted` "* | "`$ECHO $CC_quoted` "*)

              # The compiler in the base compile command matches

              # the one in the tagged configuration.

              # Assume this is the tagged configuration we want.

              tagname=$z

              break

              ;;

            esac

          fi

        done

        # If $tagname still isn't set, then no tagged configuration

        # was found and let the user know that the "--tag" command

        # line option must be used.

        if test -z "$tagname"; then

          func_echo "unable to infer tagged configuration"

          func_fatal_error "specify a tag with \`--tag'"

#       else

#         func_verbose "using $tagname tagged configuration"

        fi

        ;;

      esac

    fi

}

 

 

 

# func_write_libtool_object output_name pic_name nonpic_name

# Create a libtool object file (analogous to a ".la" file),

# but don't create it if we're doing a dry run.

func_write_libtool_object ()

{

    write_libobj=${1}

    if test "$build_libtool_libs" = yes; then

      write_lobj=\'${2}\'

    else

      write_lobj=none

    fi

 

    if test "$build_old_libs" = yes; then

      write_oldobj=\'${3}\'

    else

      write_oldobj=none

    fi

 

    $opt_dry_run || {

      cat >${write_libobj}T <<EOF

# $write_libobj - a libtool object file

# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION

#

# Please DO NOT delete this file!

# It is necessary for linking the library.

 

# Name of the PIC object.

pic_object=$write_lobj

 

# Name of the non-PIC object

non_pic_object=$write_oldobj

 

EOF

      $MV "${write_libobj}T" "${write_libobj}"

    }

}

 

# func_mode_compile arg...

func_mode_compile ()

{

    $opt_debug

    # Get the compilation command and the source file.

    base_compile=

    srcfile="$nonopt"  #  always keep a non-empty value in "srcfile"

    suppress_opt=yes

    suppress_output=

    arg_mode=normal

    libobj=

    later=

    pie_flag=

 

    for arg

    do

      case $arg_mode in

      arg  )

        # do not "continue".  Instead, add this to base_compile

        lastarg="$arg"

        arg_mode=normal

        ;;

 

      target )

        libobj="$arg"

        arg_mode=normal

        continue

        ;;

 

      normal )

        # Accept any command-line options.

        case $arg in

        -o)

          test -n "$libobj" && \

            func_fatal_error "you cannot specify \`-o' more than once"

          arg_mode=target

          continue

          ;;

 

        -pie | -fpie | -fPIE)

          pie_flag="$pie_flag $arg"

          continue

          ;;

 

        -shared | -static | -prefer-pic | -prefer-non-pic)

          later="$later $arg"

          continue

          ;;

 

        -no-suppress)

          suppress_opt=no

          continue

          ;;

 

        -Xcompiler)

          arg_mode=arg  #  the next one goes into the "base_compile" arg list

          continue      #  The current "srcfile" will either be retained or

          ;;            #  replaced later.  I would guess that would be a bug.

 

        -Wc,*)

          func_stripname '-Wc,' '' "$arg"

          args=$func_stripname_result

          lastarg=

          save_ifs="$IFS"; IFS=','

          for arg in $args; do

            IFS="$save_ifs"

            func_quote_for_eval "$arg"

            lastarg="$lastarg $func_quote_for_eval_result"

          done

          IFS="$save_ifs"

          func_stripname ' ' '' "$lastarg"

          lastarg=$func_stripname_result

 

          # Add the arguments to base_compile.

          base_compile="$base_compile $lastarg"

          continue

          ;;

 

        *)

          # Accept the current argument as the source file.

          # The previous "srcfile" becomes the current argument.

          #

          lastarg="$srcfile"

          srcfile="$arg"

          ;;

        esac  #  case $arg

        ;;

      esac    #  case $arg_mode

 

      # Aesthetically quote the previous argument.

      func_quote_for_eval "$lastarg"

      base_compile="$base_compile $func_quote_for_eval_result"

    done # for arg

 

    case $arg_mode in

    arg)

      func_fatal_error "you must specify an argument for -Xcompile"

      ;;

    target)

      func_fatal_error "you must specify a target with \`-o'"

      ;;

    *)

      # Get the name of the library object.

      test -z "$libobj" && {

        func_basename "$srcfile"

        libobj="$func_basename_result"

      }

      ;;

    esac

 

    # Recognize several different file suffixes.

    # If the user specifies -o file.o, it is replaced with file.lo

    case $libobj in

    *.[cCFSifmso] | \

    *.ada | *.adb | *.ads | *.asm | \

    *.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \

    *.[fF][09]? | *.for | *.java | *.obj | *.sx)

      func_xform "$libobj"

      libobj=$func_xform_result

      ;;

    esac

 

    case $libobj in

    *.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;

    *)

      func_fatal_error "cannot determine name of library object from \`$libobj'"

      ;;

    esac

 

    func_infer_tag $base_compile

 

    for arg in $later; do

      case $arg in

      -shared)

        test "$build_libtool_libs" != yes && \

          func_fatal_configuration "can not build a shared library"

        build_old_libs=no

        continue

        ;;

 

      -static)

        build_libtool_libs=no

        build_old_libs=yes

        continue

        ;;

 

      -prefer-pic)

        pic_mode=yes

        continue

        ;;

 

      -prefer-non-pic)

        pic_mode=no

        continue

        ;;

      esac

    done

 

    func_quote_for_eval "$libobj"

    test "X$libobj" != "X$func_quote_for_eval_result" \

      && $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"'    &()|`$[]' \

      && func_warning "libobj name \`$libobj' may not contain shell special characters."

    func_dirname_and_basename "$obj" "/" ""

    objname="$func_basename_result"

    xdir="$func_dirname_result"

    lobj=${xdir}$objdir/$objname

 

    test -z "$base_compile" && \

      func_fatal_help "you must specify a compilation command"

 

    # Delete any leftover library objects.

    if test "$build_old_libs" = yes; then

      removelist="$obj $lobj $libobj ${libobj}T"

    else

      removelist="$lobj $libobj ${libobj}T"

    fi

 

    # On Cygwin there's no "real" PIC flag so we must build both object types

    case $host_os in

    cygwin* | mingw* | pw32* | os2* | cegcc*)

      pic_mode=default

      ;;

    esac

    if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then

      # non-PIC code in shared libraries is not supported

      pic_mode=default

    fi

 

    # Calculate the filename of the output object if compiler does

    # not support -o with -c

    if test "$compiler_c_o" = no; then

      output_obj=`$ECHO "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext}

      lockfile="$output_obj.lock"

    else

      output_obj=

      need_locks=no

      lockfile=

    fi

 

    # Lock this critical section if it is needed

    # We use this script file to make the link, it avoids creating a new file

    if test "$need_locks" = yes; then

      until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do

        func_echo "Waiting for $lockfile to be removed"

        sleep 2

      done

    elif test "$need_locks" = warn; then

      if test -f "$lockfile"; then

        $ECHO "\

*** ERROR, $lockfile exists and contains:

`cat $lockfile 2>/dev/null`

 

This indicates that another process is trying to use the same

temporary object file, and libtool could not work around it because

your compiler does not support \`-c' and \`-o' together.  If you

repeat this compilation, it may succeed, by chance, but you had better

avoid parallel builds (make -j) in this platform, or get a better

compiler."

 

        $opt_dry_run || $RM $removelist

        exit $EXIT_FAILURE

      fi

      removelist="$removelist $output_obj"

      $ECHO "$srcfile" > "$lockfile"

    fi

 

    $opt_dry_run || $RM $removelist

    removelist="$removelist $lockfile"

    trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15

 

    if test -n "$fix_srcfile_path"; then

      eval srcfile=\"$fix_srcfile_path\"

    fi

    func_quote_for_eval "$srcfile"

    qsrcfile=$func_quote_for_eval_result

 

    # 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

 

      if test "$pic_mode" != no; then

        command="$base_compile $qsrcfile $pic_flag"

      else

        # Don't build PIC code

        command="$base_compile $qsrcfile"

      fi

 

      func_mkdir_p "$xdir$objdir"

 

      if test -z "$output_obj"; then

        # Place PIC objects in $objdir

        command="$command -o $lobj"

      fi

 

      func_show_eval_locale "$command"  \

          'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'

 

      if test "$need_locks" = warn &&

         test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then

        $ECHO "\

*** ERROR, $lockfile contains:

`cat $lockfile 2>/dev/null`

 

but it should contain:

$srcfile

 

This indicates that another process is trying to use the same

temporary object file, and libtool could not work around it because

your compiler does not support \`-c' and \`-o' together.  If you

repeat this compilation, it may succeed, by chance, but you had better

avoid parallel builds (make -j) in this platform, or get a better

compiler."

 

        $opt_dry_run || $RM $removelist

        exit $EXIT_FAILURE

      fi

 

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

      if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then

        func_show_eval '$MV "$output_obj" "$lobj"' \

          'error=$?; $opt_dry_run || $RM $removelist; exit $error'

      fi

 

      # Allow error messages only from the first compilation.

      if test "$suppress_opt" = yes; then

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

      fi

    fi

 

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

    if test "$build_old_libs" = yes; then

      if test "$pic_mode" != yes; then

        # Don't build PIC code

        command="$base_compile $qsrcfile$pie_flag"

      else

        command="$base_compile $qsrcfile $pic_flag"

      fi

      if test "$compiler_c_o" = yes; then

        command="$command -o $obj"

      fi

 

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

      command="$command$suppress_output"

      func_show_eval_locale "$command" \

        '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'

 

      if test "$need_locks" = warn &&

         test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then

        $ECHO "\

*** ERROR, $lockfile contains:

`cat $lockfile 2>/dev/null`

 

but it should contain:

$srcfile

 

This indicates that another process is trying to use the same

temporary object file, and libtool could not work around it because

your compiler does not support \`-c' and \`-o' together.  If you

repeat this compilation, it may succeed, by chance, but you had better

avoid parallel builds (make -j) in this platform, or get a better

compiler."

 

        $opt_dry_run || $RM $removelist

        exit $EXIT_FAILURE

      fi

 

      # Just move the object if needed

      if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then

        func_show_eval '$MV "$output_obj" "$obj"' \

          'error=$?; $opt_dry_run || $RM $removelist; exit $error'

      fi

    fi

 

    $opt_dry_run || {

      func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"

 

      # Unlock the critical section if it was locked

      if test "$need_locks" != no; then

        removelist=$lockfile

        $RM "$lockfile"

      fi

    }

 

    exit $EXIT_SUCCESS

}

 

$opt_help || {

test "$mode" = compile && func_mode_compile ${1+"$@"}

}

 

func_mode_help ()

{

    # We need to display help for each of the modes.

    case $mode in

      "")

        # Generic help is extracted from the usage comments

        # at the start of this file.

        func_help

        ;;

 

      clean)

        $ECHO \

"Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE...

 

Remove files from the build directory.

 

RM is the name of the program to use to delete files associated with each FILE

(typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed

to RM.

 

If FILE is a libtool library, object or program, all the files associated

with it are deleted. Otherwise, only FILE itself is deleted using RM."

        ;;

 

      compile)

      $ECHO \

"Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE

 

Compile a source file into a libtool library object.

 

This mode accepts the following additional options:

 

  -o OUTPUT-FILE    set the output file name to OUTPUT-FILE

  -no-suppress      do not suppress compiler output for multiple passes

  -prefer-pic       try to building PIC objects only

  -prefer-non-pic   try to building non-PIC objects only

  -shared           do not build a \`.o' file suitable for static linking

  -static           only build a \`.o' file suitable for static linking

 

COMPILE-COMMAND is a command to be used in creating a \`standard' object file

from the given SOURCEFILE.

 

The output file name is determined by removing the directory component from

SOURCEFILE, then substituting the C source code suffix \`.c' with the

library object suffix, \`.lo'."

        ;;

 

      execute)

        $ECHO \

"Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]...

 

Automatically set library path, then run a program.

 

This mode accepts the following additional options:

 

  -dlopen FILE      add the directory containing FILE to the library path

 

This mode sets the library path environment variable according to \`-dlopen'

flags.

 

If any of the ARGS are libtool executable wrappers, then they are translated

into their corresponding uninstalled binary, and any of their required library

directories are added to the library path.

 

Then, COMMAND is executed, with ARGS as arguments."

        ;;

 

      finish)

        $ECHO \

"Usage: $progname [OPTION]... --mode=finish [LIBDIR]...

 

Complete the installation of libtool libraries.

 

Each LIBDIR is a directory that contains libtool libraries.

 

The commands that this mode executes may require superuser privileges.  Use

the \`--dry-run' option if you just want to see what would be executed."

        ;;

 

      install)

        $ECHO \

"Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...

 

Install executables or libraries.

 

INSTALL-COMMAND is the installation command.  The first component should be

either the \`install' or \`cp' program.

 

The following components of INSTALL-COMMAND are treated specially:

 

  -inst-prefix PREFIX-DIR  Use PREFIX-DIR as a staging area for installation

 

The rest of the components are interpreted as arguments to that command (only

BSD-compatible install options are recognized)."

        ;;

 

      link)

        $ECHO \

"Usage: $progname [OPTION]... --mode=link LINK-COMMAND...

 

Link object files or libraries together to form another library, or to

create an executable program.

 

LINK-COMMAND is a command using the C compiler that you would use to create

a program from several object files.

 

The following components of LINK-COMMAND are treated specially:

 

  -all-static       do not do any dynamic linking at all

  -avoid-version    do not add a version suffix if possible

  -dlopen FILE      \`-dlpreopen' FILE if it cannot be dlopened at runtime

  -dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols

  -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)

  -export-symbols SYMFILE

                    try to export only the symbols listed in SYMFILE

  -export-symbols-regex REGEX

                    try to export only the symbols matching REGEX

  -LLIBDIR          search LIBDIR for required installed libraries

  -lNAME            OUTPUT-FILE requires the installed library libNAME