Annotation of tme/ltmain.sh, revision 1.1.1.1

1.1       root        1: # ltmain.sh - Provide generalized library-building support services.
                      2: # NOTE: Changing this file will not affect anything until you rerun configure.
                      3: #
                      4: # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003
                      5: # Free Software Foundation, Inc.
                      6: # Originally by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
                      7: #
                      8: # This program is free software; you can redistribute it and/or modify
                      9: # it under the terms of the GNU General Public License as published by
                     10: # the Free Software Foundation; either version 2 of the License, or
                     11: # (at your option) any later version.
                     12: #
                     13: # This program is distributed in the hope that it will be useful, but
                     14: # WITHOUT ANY WARRANTY; without even the implied warranty of
                     15: # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
                     16: # General Public License for more details.
                     17: #
                     18: # You should have received a copy of the GNU General Public License
                     19: # along with this program; if not, write to the Free Software
                     20: # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
                     21: #
                     22: # As a special exception to the GNU General Public License, if you
                     23: # distribute this file as part of a program that contains a
                     24: # configuration script generated by Autoconf, you may include it under
                     25: # the same distribution terms that you use for the rest of that program.
                     26: 
                     27: # Check that we have a working $echo.
                     28: if test "X$1" = X--no-reexec; then
                     29:   # Discard the --no-reexec flag, and continue.
                     30:   shift
                     31: elif test "X$1" = X--fallback-echo; then
                     32:   # Avoid inline document here, it may be left over
                     33:   :
                     34: elif test "X`($echo '\t') 2>/dev/null`" = 'X\t'; then
                     35:   # Yippee, $echo works!
                     36:   :
                     37: else
                     38:   # Restart under the correct shell, and then maybe $echo will work.
                     39:   exec $SHELL "$0" --no-reexec ${1+"$@"}
                     40: fi
                     41: 
                     42: if test "X$1" = X--fallback-echo; then
                     43:   # used as fallback echo
                     44:   shift
                     45:   cat <<EOF
                     46: $*
                     47: EOF
                     48:   exit 0
                     49: fi
                     50: 
                     51: # The name of this program.
                     52: progname=`$echo "$0" | ${SED} 's%^.*/%%'`
                     53: modename="$progname"
                     54: 
                     55: # Constants.
                     56: PROGRAM=ltmain.sh
                     57: PACKAGE=libtool
                     58: VERSION=1.5
                     59: TIMESTAMP=" (1.1220 2003/04/05 19:32:58)"
                     60: 
                     61: default_mode=
                     62: help="Try \`$progname --help' for more information."
                     63: magic="%%%MAGIC variable%%%"
                     64: mkdir="mkdir"
                     65: mv="mv -f"
                     66: rm="rm -f"
                     67: 
                     68: # Sed substitution that helps us do robust quoting.  It backslashifies
                     69: # metacharacters that are still active within double-quoted strings.
                     70: Xsed="${SED}"' -e 1s/^X//'
                     71: sed_quote_subst='s/\([\\`\\"$\\\\]\)/\\\1/g'
                     72: # test EBCDIC or ASCII
                     73: case `echo A|od -x` in
                     74:  *[Cc]1*) # EBCDIC based system
                     75:   SP2NL="tr '\100' '\n'"
                     76:   NL2SP="tr '\r\n' '\100\100'"
                     77:   ;;
                     78:  *) # Assume ASCII based system
                     79:   SP2NL="tr '\040' '\012'"
                     80:   NL2SP="tr '\015\012' '\040\040'"
                     81:   ;;
                     82: esac
                     83: 
                     84: # NLS nuisances.
                     85: # Only set LANG and LC_ALL to C if already set.
                     86: # These must not be set unconditionally because not all systems understand
                     87: # e.g. LANG=C (notably SCO).
                     88: # We save the old values to restore during execute mode.
                     89: if test "${LC_ALL+set}" = set; then
                     90:   save_LC_ALL="$LC_ALL"; LC_ALL=C; export LC_ALL
                     91: fi
                     92: if test "${LANG+set}" = set; then
                     93:   save_LANG="$LANG"; LANG=C; export LANG
                     94: fi
                     95: 
                     96: # Make sure IFS has a sensible default
                     97: : ${IFS="      "}
                     98: 
                     99: if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
                    100:   $echo "$modename: not configured to build any kind of library" 1>&2
                    101:   $echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
                    102:   exit 1
                    103: fi
                    104: 
                    105: # Global variables.
                    106: mode=$default_mode
                    107: nonopt=
                    108: prev=
                    109: prevopt=
                    110: run=
                    111: show="$echo"
                    112: show_help=
                    113: execute_dlfiles=
                    114: lo2o="s/\\.lo\$/.${objext}/"
                    115: o2lo="s/\\.${objext}\$/.lo/"
                    116: 
                    117: #####################################
                    118: # Shell function definitions:
                    119: # This seems to be the best place for them
                    120: 
                    121: # Need a lot of goo to handle *both* DLLs and import libs
                    122: # Has to be a shell function in order to 'eat' the argument
                    123: # that is supplied when $file_magic_command is called.
                    124: win32_libid () {
                    125:   win32_libid_type="unknown"
                    126:   win32_fileres=`file -L $1 2>/dev/null`
                    127:   case $win32_fileres in
                    128:   *ar\ archive\ import\ library*) # definitely import
                    129:     win32_libid_type="x86 archive import"
                    130:     ;;
                    131:   *ar\ archive*) # could be an import, or static
                    132:     if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null | \
                    133:       grep -E 'file format pe-i386(.*architecture: i386)?' >/dev/null ; then
                    134:       win32_nmres=`eval $NM -f posix -A $1 | \
                    135:        sed -n -e '1,100{/ I /{x;/import/!{s/^/import/;h;p;};x;};}'`
                    136:       if test "X$win32_nmres" = "Ximport" ; then
                    137:         win32_libid_type="x86 archive import"
                    138:       else
                    139:         win32_libid_type="x86 archive static"
                    140:       fi
                    141:     fi
                    142:     ;;
                    143:   *DLL*) 
                    144:     win32_libid_type="x86 DLL"
                    145:     ;;
                    146:   *executable*) # but shell scripts are "executable" too...
                    147:     case $win32_fileres in
                    148:     *MS\ Windows\ PE\ Intel*)
                    149:       win32_libid_type="x86 DLL"
                    150:       ;;
                    151:     esac
                    152:     ;;
                    153:   esac
                    154:   $echo $win32_libid_type
                    155: }
                    156: 
                    157: # End of Shell function definitions
                    158: #####################################
                    159: 
                    160: # Parse our command line options once, thoroughly.
                    161: while test "$#" -gt 0
                    162: do
                    163:   arg="$1"
                    164:   shift
                    165: 
                    166:   case $arg in
                    167:   -*=*) optarg=`$echo "X$arg" | $Xsed -e 's/[-_a-zA-Z0-9]*=//'` ;;
                    168:   *) optarg= ;;
                    169:   esac
                    170: 
                    171:   # If the previous option needs an argument, assign it.
                    172:   if test -n "$prev"; then
                    173:     case $prev in
                    174:     execute_dlfiles)
                    175:       execute_dlfiles="$execute_dlfiles $arg"
                    176:       ;;
                    177:     tag)
                    178:       tagname="$arg"
                    179: 
                    180:       # Check whether tagname contains only valid characters
                    181:       case $tagname in
                    182:       *[!-_A-Za-z0-9,/]*)
                    183:        $echo "$progname: invalid tag name: $tagname" 1>&2
                    184:        exit 1
                    185:        ;;
                    186:       esac
                    187: 
                    188:       case $tagname in
                    189:       CC)
                    190:        # Don't test for the "default" C tag, as we know, it's there, but
                    191:        # not specially marked.
                    192:        ;;
                    193:       *)
                    194:        if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$" < "$0" > /dev/null; then
                    195:          taglist="$taglist $tagname"
                    196:          # Evaluate the configuration.
                    197:          eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$tagname'$/,/^# ### END LIBTOOL TAG CONFIG: '$tagname'$/p' < $0`"
                    198:        else
                    199:          $echo "$progname: ignoring unknown tag $tagname" 1>&2
                    200:        fi
                    201:        ;;
                    202:       esac
                    203:       ;;
                    204:     *)
                    205:       eval "$prev=\$arg"
                    206:       ;;
                    207:     esac
                    208: 
                    209:     prev=
                    210:     prevopt=
                    211:     continue
                    212:   fi
                    213: 
                    214:   # Have we seen a non-optional argument yet?
                    215:   case $arg in
                    216:   --help)
                    217:     show_help=yes
                    218:     ;;
                    219: 
                    220:   --version)
                    221:     $echo "$PROGRAM (GNU $PACKAGE) $VERSION$TIMESTAMP"
                    222:     $echo
                    223:     $echo "Copyright (C) 2003  Free Software Foundation, Inc."
                    224:     $echo "This is free software; see the source for copying conditions.  There is NO"
                    225:     $echo "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
                    226:     exit 0
                    227:     ;;
                    228: 
                    229:   --config)
                    230:     ${SED} -e '1,/^# ### BEGIN LIBTOOL CONFIG/d' -e '/^# ### END LIBTOOL CONFIG/,$d' $0
                    231:     # Now print the configurations for the tags.
                    232:     for tagname in $taglist; do
                    233:       ${SED} -n -e "/^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$/,/^# ### END LIBTOOL TAG CONFIG: $tagname$/p" < "$0"
                    234:     done
                    235:     exit 0
                    236:     ;;
                    237: 
                    238:   --debug)
                    239:     $echo "$progname: enabling shell trace mode"
                    240:     set -x
                    241:     ;;
                    242: 
                    243:   --dry-run | -n)
                    244:     run=:
                    245:     ;;
                    246: 
                    247:   --features)
                    248:     $echo "host: $host"
                    249:     if test "$build_libtool_libs" = yes; then
                    250:       $echo "enable shared libraries"
                    251:     else
                    252:       $echo "disable shared libraries"
                    253:     fi
                    254:     if test "$build_old_libs" = yes; then
                    255:       $echo "enable static libraries"
                    256:     else
                    257:       $echo "disable static libraries"
                    258:     fi
                    259:     exit 0
                    260:     ;;
                    261: 
                    262:   --finish) mode="finish" ;;
                    263: 
                    264:   --mode) prevopt="--mode" prev=mode ;;
                    265:   --mode=*) mode="$optarg" ;;
                    266: 
                    267:   --preserve-dup-deps) duplicate_deps="yes" ;;
                    268: 
                    269:   --quiet | --silent)
                    270:     show=:
                    271:     ;;
                    272: 
                    273:   --tag) prevopt="--tag" prev=tag ;;
                    274:   --tag=*)
                    275:     set tag "$optarg" ${1+"$@"}
                    276:     shift
                    277:     prev=tag
                    278:     ;;
                    279: 
                    280:   -dlopen)
                    281:     prevopt="-dlopen"
                    282:     prev=execute_dlfiles
                    283:     ;;
                    284: 
                    285:   -*)
                    286:     $echo "$modename: unrecognized option \`$arg'" 1>&2
                    287:     $echo "$help" 1>&2
                    288:     exit 1
                    289:     ;;
                    290: 
                    291:   *)
                    292:     nonopt="$arg"
                    293:     break
                    294:     ;;
                    295:   esac
                    296: done
                    297: 
                    298: if test -n "$prevopt"; then
                    299:   $echo "$modename: option \`$prevopt' requires an argument" 1>&2
                    300:   $echo "$help" 1>&2
                    301:   exit 1
                    302: fi
                    303: 
                    304: # If this variable is set in any of the actions, the command in it
                    305: # will be execed at the end.  This prevents here-documents from being
                    306: # left over by shells.
                    307: exec_cmd=
                    308: 
                    309: if test -z "$show_help"; then
                    310: 
                    311:   # Infer the operation mode.
                    312:   if test -z "$mode"; then
                    313:     $echo "*** Warning: inferring the mode of operation is deprecated." 1>&2
                    314:     $echo "*** Future versions of Libtool will require -mode=MODE be specified." 1>&2
                    315:     case $nonopt in
                    316:     *cc | cc* | *++ | gcc* | *-gcc* | g++* | xlc*)
                    317:       mode=link
                    318:       for arg
                    319:       do
                    320:        case $arg in
                    321:        -c)
                    322:           mode=compile
                    323:           break
                    324:           ;;
                    325:        esac
                    326:       done
                    327:       ;;
                    328:     *db | *dbx | *strace | *truss)
                    329:       mode=execute
                    330:       ;;
                    331:     *install*|cp|mv)
                    332:       mode=install
                    333:       ;;
                    334:     *rm)
                    335:       mode=uninstall
                    336:       ;;
                    337:     *)
                    338:       # If we have no mode, but dlfiles were specified, then do execute mode.
                    339:       test -n "$execute_dlfiles" && mode=execute
                    340: 
                    341:       # Just use the default operation mode.
                    342:       if test -z "$mode"; then
                    343:        if test -n "$nonopt"; then
                    344:          $echo "$modename: warning: cannot infer operation mode from \`$nonopt'" 1>&2
                    345:        else
                    346:          $echo "$modename: warning: cannot infer operation mode without MODE-ARGS" 1>&2
                    347:        fi
                    348:       fi
                    349:       ;;
                    350:     esac
                    351:   fi
                    352: 
                    353:   # Only execute mode is allowed to have -dlopen flags.
                    354:   if test -n "$execute_dlfiles" && test "$mode" != execute; then
                    355:     $echo "$modename: unrecognized option \`-dlopen'" 1>&2
                    356:     $echo "$help" 1>&2
                    357:     exit 1
                    358:   fi
                    359: 
                    360:   # Change the help message to a mode-specific one.
                    361:   generic_help="$help"
                    362:   help="Try \`$modename --help --mode=$mode' for more information."
                    363: 
                    364:   # These modes are in order of execution frequency so that they run quickly.
                    365:   case $mode in
                    366:   # libtool compile mode
                    367:   compile)
                    368:     modename="$modename: compile"
                    369:     # Get the compilation command and the source file.
                    370:     base_compile=
                    371:     srcfile="$nonopt"  #  always keep a non-empty value in "srcfile"
                    372:     suppress_output=
                    373:     arg_mode=normal
                    374:     libobj=
                    375: 
                    376:     for arg
                    377:     do
                    378:       case "$arg_mode" in
                    379:       arg  )
                    380:        # do not "continue".  Instead, add this to base_compile
                    381:        lastarg="$arg"
                    382:        arg_mode=normal
                    383:        ;;
                    384: 
                    385:       target )
                    386:        libobj="$arg"
                    387:        arg_mode=normal
                    388:        continue
                    389:        ;;
                    390: 
                    391:       normal )
                    392:        # Accept any command-line options.
                    393:        case $arg in
                    394:        -o)
                    395:          if test -n "$libobj" ; then
                    396:            $echo "$modename: you cannot specify \`-o' more than once" 1>&2
                    397:            exit 1
                    398:          fi
                    399:          arg_mode=target
                    400:          continue
                    401:          ;;
                    402: 
                    403:        -static)
                    404:          build_old_libs=yes
                    405:          continue
                    406:          ;;
                    407: 
                    408:        -prefer-pic)
                    409:          pic_mode=yes
                    410:          continue
                    411:          ;;
                    412: 
                    413:        -prefer-non-pic)
                    414:          pic_mode=no
                    415:          continue
                    416:          ;;
                    417: 
                    418:        -Xcompiler)
                    419:          arg_mode=arg  #  the next one goes into the "base_compile" arg list
                    420:          continue      #  The current "srcfile" will either be retained or
                    421:          ;;            #  replaced later.  I would guess that would be a bug.
                    422: 
                    423:        -Wc,*)
                    424:          args=`$echo "X$arg" | $Xsed -e "s/^-Wc,//"`
                    425:          lastarg=
                    426:          save_ifs="$IFS"; IFS=','
                    427:          for arg in $args; do
                    428:            IFS="$save_ifs"
                    429: 
                    430:            # Double-quote args containing other shell metacharacters.
                    431:            # Many Bourne shells cannot handle close brackets correctly
                    432:            # in scan sets, so we specify it separately.
                    433:            case $arg in
                    434:              *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
                    435:              arg="\"$arg\""
                    436:              ;;
                    437:            esac
                    438:            lastarg="$lastarg $arg"
                    439:          done
                    440:          IFS="$save_ifs"
                    441:          lastarg=`$echo "X$lastarg" | $Xsed -e "s/^ //"`
                    442: 
                    443:          # Add the arguments to base_compile.
                    444:          base_compile="$base_compile $lastarg"
                    445:          continue
                    446:          ;;
                    447: 
                    448:        * )
                    449:          # Accept the current argument as the source file.
                    450:          # The previous "srcfile" becomes the current argument.
                    451:          #
                    452:          lastarg="$srcfile"
                    453:          srcfile="$arg"
                    454:          ;;
                    455:        esac  #  case $arg
                    456:        ;;
                    457:       esac    #  case $arg_mode
                    458: 
                    459:       # Aesthetically quote the previous argument.
                    460:       lastarg=`$echo "X$lastarg" | $Xsed -e "$sed_quote_subst"`
                    461: 
                    462:       case $lastarg in
                    463:       # Double-quote args containing other shell metacharacters.
                    464:       # Many Bourne shells cannot handle close brackets correctly
                    465:       # in scan sets, so we specify it separately.
                    466:       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \    ]*|*]*|"")
                    467:        lastarg="\"$lastarg\""
                    468:        ;;
                    469:       esac
                    470: 
                    471:       base_compile="$base_compile $lastarg"
                    472:     done # for arg
                    473: 
                    474:     case $arg_mode in
                    475:     arg)
                    476:       $echo "$modename: you must specify an argument for -Xcompile"
                    477:       exit 1
                    478:       ;;
                    479:     target)
                    480:       $echo "$modename: you must specify a target with \`-o'" 1>&2
                    481:       exit 1
                    482:       ;;
                    483:     *)
                    484:       # Get the name of the library object.
                    485:       [ -z "$libobj" ] && libobj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%'`
                    486:       ;;
                    487:     esac
                    488: 
                    489:     # Recognize several different file suffixes.
                    490:     # If the user specifies -o file.o, it is replaced with file.lo
                    491:     xform='[cCFSifmso]'
                    492:     case $libobj in
                    493:     *.ada) xform=ada ;;
                    494:     *.adb) xform=adb ;;
                    495:     *.ads) xform=ads ;;
                    496:     *.asm) xform=asm ;;
                    497:     *.c++) xform=c++ ;;
                    498:     *.cc) xform=cc ;;
                    499:     *.ii) xform=ii ;;
                    500:     *.class) xform=class ;;
                    501:     *.cpp) xform=cpp ;;
                    502:     *.cxx) xform=cxx ;;
                    503:     *.f90) xform=f90 ;;
                    504:     *.for) xform=for ;;
                    505:     *.java) xform=java ;;
                    506:     esac
                    507: 
                    508:     libobj=`$echo "X$libobj" | $Xsed -e "s/\.$xform$/.lo/"`
                    509: 
                    510:     case $libobj in
                    511:     *.lo) obj=`$echo "X$libobj" | $Xsed -e "$lo2o"` ;;
                    512:     *)
                    513:       $echo "$modename: cannot determine name of library object from \`$libobj'" 1>&2
                    514:       exit 1
                    515:       ;;
                    516:     esac
                    517: 
                    518:     # Infer tagged configuration to use if any are available and
                    519:     # if one wasn't chosen via the "--tag" command line option.
                    520:     # Only attempt this if the compiler in the base compile
                    521:     # command doesn't match the default compiler.
                    522:     if test -n "$available_tags" && test -z "$tagname"; then
                    523:       case $base_compile in
                    524:       # Blanks in the command may have been stripped by the calling shell,
                    525:       # but not from the CC environment variable when configure was run.
                    526:       " $CC "* | "$CC "* | " `$echo $CC` "* | "`$echo $CC` "*) ;;
                    527:       # Blanks at the start of $base_compile will cause this to fail
                    528:       # if we don't check for them as well.
                    529:       *)
                    530:        for z in $available_tags; do
                    531:          if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$0" > /dev/null; then
                    532:            # Evaluate the configuration.
                    533:            eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $0`"
                    534:            case "$base_compile " in
                    535:            "$CC "* | " $CC "* | "`$echo $CC` "* | " `$echo $CC` "*)
                    536:              # The compiler in the base compile command matches
                    537:              # the one in the tagged configuration.
                    538:              # Assume this is the tagged configuration we want.
                    539:              tagname=$z
                    540:              break
                    541:              ;;
                    542:            esac
                    543:          fi
                    544:        done
                    545:        # If $tagname still isn't set, then no tagged configuration
                    546:        # was found and let the user know that the "--tag" command
                    547:        # line option must be used.
                    548:        if test -z "$tagname"; then
                    549:          $echo "$modename: unable to infer tagged configuration"
                    550:          $echo "$modename: specify a tag with \`--tag'" 1>&2
                    551:          exit 1
                    552: #        else
                    553: #          $echo "$modename: using $tagname tagged configuration"
                    554:        fi
                    555:        ;;
                    556:       esac
                    557:     fi
                    558: 
                    559:     objname=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`
                    560:     xdir=`$echo "X$obj" | $Xsed -e 's%/[^/]*$%%'`
                    561:     if test "X$xdir" = "X$obj"; then
                    562:       xdir=
                    563:     else
                    564:       xdir=$xdir/
                    565:     fi
                    566:     lobj=${xdir}$objdir/$objname
                    567: 
                    568:     if test -z "$base_compile"; then
                    569:       $echo "$modename: you must specify a compilation command" 1>&2
                    570:       $echo "$help" 1>&2
                    571:       exit 1
                    572:     fi
                    573: 
                    574:     # Delete any leftover library objects.
                    575:     if test "$build_old_libs" = yes; then
                    576:       removelist="$obj $lobj $libobj ${libobj}T"
                    577:     else
                    578:       removelist="$lobj $libobj ${libobj}T"
                    579:     fi
                    580: 
                    581:     $run $rm $removelist
                    582:     trap "$run $rm $removelist; exit 1" 1 2 15
                    583: 
                    584:     # On Cygwin there's no "real" PIC flag so we must build both object types
                    585:     case $host_os in
                    586:     cygwin* | mingw* | pw32* | os2*)
                    587:       pic_mode=default
                    588:       ;;
                    589:     esac
                    590:     if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
                    591:       # non-PIC code in shared libraries is not supported
                    592:       pic_mode=default
                    593:     fi
                    594: 
                    595:     # Calculate the filename of the output object if compiler does
                    596:     # not support -o with -c
                    597:     if test "$compiler_c_o" = no; then
                    598:       output_obj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext}
                    599:       lockfile="$output_obj.lock"
                    600:       removelist="$removelist $output_obj $lockfile"
                    601:       trap "$run $rm $removelist; exit 1" 1 2 15
                    602:     else
                    603:       output_obj=
                    604:       need_locks=no
                    605:       lockfile=
                    606:     fi
                    607: 
                    608:     # Lock this critical section if it is needed
                    609:     # We use this script file to make the link, it avoids creating a new file
                    610:     if test "$need_locks" = yes; then
                    611:       until $run ln "$0" "$lockfile" 2>/dev/null; do
                    612:        $show "Waiting for $lockfile to be removed"
                    613:        sleep 2
                    614:       done
                    615:     elif test "$need_locks" = warn; then
                    616:       if test -f "$lockfile"; then
                    617:        $echo "\
                    618: *** ERROR, $lockfile exists and contains:
                    619: `cat $lockfile 2>/dev/null`
                    620: 
                    621: This indicates that another process is trying to use the same
                    622: temporary object file, and libtool could not work around it because
                    623: your compiler does not support \`-c' and \`-o' together.  If you
                    624: repeat this compilation, it may succeed, by chance, but you had better
                    625: avoid parallel builds (make -j) in this platform, or get a better
                    626: compiler."
                    627: 
                    628:        $run $rm $removelist
                    629:        exit 1
                    630:       fi
                    631:       $echo $srcfile > "$lockfile"
                    632:     fi
                    633: 
                    634:     if test -n "$fix_srcfile_path"; then
                    635:       eval srcfile=\"$fix_srcfile_path\"
                    636:     fi
                    637: 
                    638:     $run $rm "$libobj" "${libobj}T"
                    639: 
                    640:     # Create a libtool object file (analogous to a ".la" file),
                    641:     # but don't create it if we're doing a dry run.
                    642:     test -z "$run" && cat > ${libobj}T <<EOF
                    643: # $libobj - a libtool object file
                    644: # Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
                    645: #
                    646: # Please DO NOT delete this file!
                    647: # It is necessary for linking the library.
                    648: 
                    649: # Name of the PIC object.
                    650: EOF
                    651: 
                    652:     # Only build a PIC object if we are building libtool libraries.
                    653:     if test "$build_libtool_libs" = yes; then
                    654:       # Without this assignment, base_compile gets emptied.
                    655:       fbsd_hideous_sh_bug=$base_compile
                    656: 
                    657:       if test "$pic_mode" != no; then
                    658:        command="$base_compile $srcfile $pic_flag"
                    659:       else
                    660:        # Don't build PIC code
                    661:        command="$base_compile $srcfile"
                    662:       fi
                    663: 
                    664:       if test ! -d "${xdir}$objdir"; then
                    665:        $show "$mkdir ${xdir}$objdir"
                    666:        $run $mkdir ${xdir}$objdir
                    667:        status=$?
                    668:        if test "$status" -ne 0 && test ! -d "${xdir}$objdir"; then
                    669:          exit $status
                    670:        fi
                    671:       fi
                    672: 
                    673:       if test -z "$output_obj"; then
                    674:        # Place PIC objects in $objdir
                    675:        command="$command -o $lobj"
                    676:       fi
                    677: 
                    678:       $run $rm "$lobj" "$output_obj"
                    679: 
                    680:       $show "$command"
                    681:       if $run eval "$command"; then :
                    682:       else
                    683:        test -n "$output_obj" && $run $rm $removelist
                    684:        exit 1
                    685:       fi
                    686: 
                    687:       if test "$need_locks" = warn &&
                    688:         test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
                    689:        $echo "\
                    690: *** ERROR, $lockfile contains:
                    691: `cat $lockfile 2>/dev/null`
                    692: 
                    693: but it should contain:
                    694: $srcfile
                    695: 
                    696: This indicates that another process is trying to use the same
                    697: temporary object file, and libtool could not work around it because
                    698: your compiler does not support \`-c' and \`-o' together.  If you
                    699: repeat this compilation, it may succeed, by chance, but you had better
                    700: avoid parallel builds (make -j) in this platform, or get a better
                    701: compiler."
                    702: 
                    703:        $run $rm $removelist
                    704:        exit 1
                    705:       fi
                    706: 
                    707:       # Just move the object if needed, then go on to compile the next one
                    708:       if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
                    709:        $show "$mv $output_obj $lobj"
                    710:        if $run $mv $output_obj $lobj; then :
                    711:        else
                    712:          error=$?
                    713:          $run $rm $removelist
                    714:          exit $error
                    715:        fi
                    716:       fi
                    717: 
                    718:       # Append the name of the PIC object to the libtool object file.
                    719:       test -z "$run" && cat >> ${libobj}T <<EOF
                    720: pic_object='$objdir/$objname'
                    721: 
                    722: EOF
                    723: 
                    724:       # Allow error messages only from the first compilation.
                    725:       suppress_output=' >/dev/null 2>&1'
                    726:     else
                    727:       # No PIC object so indicate it doesn't exist in the libtool
                    728:       # object file.
                    729:       test -z "$run" && cat >> ${libobj}T <<EOF
                    730: pic_object=none
                    731: 
                    732: EOF
                    733:     fi
                    734: 
                    735:     # Only build a position-dependent object if we build old libraries.
                    736:     if test "$build_old_libs" = yes; then
                    737:       if test "$pic_mode" != yes; then
                    738:        # Don't build PIC code
                    739:        command="$base_compile $srcfile"
                    740:       else
                    741:        command="$base_compile $srcfile $pic_flag"
                    742:       fi
                    743:       if test "$compiler_c_o" = yes; then
                    744:        command="$command -o $obj"
                    745:       fi
                    746: 
                    747:       # Suppress compiler output if we already did a PIC compilation.
                    748:       command="$command$suppress_output"
                    749:       $run $rm "$obj" "$output_obj"
                    750:       $show "$command"
                    751:       if $run eval "$command"; then :
                    752:       else
                    753:        $run $rm $removelist
                    754:        exit 1
                    755:       fi
                    756: 
                    757:       if test "$need_locks" = warn &&
                    758:         test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
                    759:        $echo "\
                    760: *** ERROR, $lockfile contains:
                    761: `cat $lockfile 2>/dev/null`
                    762: 
                    763: but it should contain:
                    764: $srcfile
                    765: 
                    766: This indicates that another process is trying to use the same
                    767: temporary object file, and libtool could not work around it because
                    768: your compiler does not support \`-c' and \`-o' together.  If you
                    769: repeat this compilation, it may succeed, by chance, but you had better
                    770: avoid parallel builds (make -j) in this platform, or get a better
                    771: compiler."
                    772: 
                    773:        $run $rm $removelist
                    774:        exit 1
                    775:       fi
                    776: 
                    777:       # Just move the object if needed
                    778:       if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
                    779:        $show "$mv $output_obj $obj"
                    780:        if $run $mv $output_obj $obj; then :
                    781:        else
                    782:          error=$?
                    783:          $run $rm $removelist
                    784:          exit $error
                    785:        fi
                    786:       fi
                    787: 
                    788:       # Append the name of the non-PIC object the libtool object file.
                    789:       # Only append if the libtool object file exists.
                    790:       test -z "$run" && cat >> ${libobj}T <<EOF
                    791: # Name of the non-PIC object.
                    792: non_pic_object='$objname'
                    793: 
                    794: EOF
                    795:     else
                    796:       # Append the name of the non-PIC object the libtool object file.
                    797:       # Only append if the libtool object file exists.
                    798:       test -z "$run" && cat >> ${libobj}T <<EOF
                    799: # Name of the non-PIC object.
                    800: non_pic_object=none
                    801: 
                    802: EOF
                    803:     fi
                    804: 
                    805:     $run $mv "${libobj}T" "${libobj}"
                    806: 
                    807:     # Unlock the critical section if it was locked
                    808:     if test "$need_locks" != no; then
                    809:       $run $rm "$lockfile"
                    810:     fi
                    811: 
                    812:     exit 0
                    813:     ;;
                    814: 
                    815:   # libtool link mode
                    816:   link | relink)
                    817:     modename="$modename: link"
                    818:     case $host in
                    819:     *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
                    820:       # It is impossible to link a dll without this setting, and
                    821:       # we shouldn't force the makefile maintainer to figure out
                    822:       # which system we are compiling for in order to pass an extra
                    823:       # flag for every libtool invocation.
                    824:       # allow_undefined=no
                    825: 
                    826:       # FIXME: Unfortunately, there are problems with the above when trying
                    827:       # to make a dll which has undefined symbols, in which case not
                    828:       # even a static library is built.  For now, we need to specify
                    829:       # -no-undefined on the libtool link line when we can be certain
                    830:       # that all symbols are satisfied, otherwise we get a static library.
                    831:       allow_undefined=yes
                    832:       ;;
                    833:     *)
                    834:       allow_undefined=yes
                    835:       ;;
                    836:     esac
                    837:     libtool_args="$nonopt"
                    838:     base_compile="$nonopt"
                    839:     compile_command="$nonopt"
                    840:     finalize_command="$nonopt"
                    841: 
                    842:     compile_rpath=
                    843:     finalize_rpath=
                    844:     compile_shlibpath=
                    845:     finalize_shlibpath=
                    846:     convenience=
                    847:     old_convenience=
                    848:     deplibs=
                    849:     old_deplibs=
                    850:     compiler_flags=
                    851:     linker_flags=
                    852:     dllsearchpath=
                    853:     lib_search_path=`pwd`
                    854:     inst_prefix_dir=
                    855: 
                    856:     avoid_version=no
                    857:     dlfiles=
                    858:     dlprefiles=
                    859:     dlself=no
                    860:     export_dynamic=no
                    861:     export_symbols=
                    862:     export_symbols_regex=
                    863:     generated=
                    864:     libobjs=
                    865:     ltlibs=
                    866:     module=no
                    867:     no_install=no
                    868:     objs=
                    869:     non_pic_objects=
                    870:     prefer_static_libs=no
                    871:     preload=no
                    872:     prev=
                    873:     prevarg=
                    874:     release=
                    875:     rpath=
                    876:     xrpath=
                    877:     perm_rpath=
                    878:     temp_rpath=
                    879:     thread_safe=no
                    880:     vinfo=
                    881:     vinfo_number=no
                    882: 
                    883:     # We need to know -static, to get the right output filenames.
                    884:     for arg
                    885:     do
                    886:       case $arg in
                    887:       -all-static | -static)
                    888:        if test "X$arg" = "X-all-static"; then
                    889:          if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
                    890:            $echo "$modename: warning: complete static linking is impossible in this configuration" 1>&2
                    891:          fi
                    892:          if test -n "$link_static_flag"; then
                    893:            dlopen_self=$dlopen_self_static
                    894:          fi
                    895:        else
                    896:          if test -z "$pic_flag" && test -n "$link_static_flag"; then
                    897:            dlopen_self=$dlopen_self_static
                    898:          fi
                    899:        fi
                    900:        build_libtool_libs=no
                    901:        build_old_libs=yes
                    902:        prefer_static_libs=yes
                    903:        break
                    904:        ;;
                    905:       esac
                    906:     done
                    907: 
                    908:     # See if our shared archives depend on static archives.
                    909:     test -n "$old_archive_from_new_cmds" && build_old_libs=yes
                    910: 
                    911:     # Go through the arguments, transforming them on the way.
                    912:     while test "$#" -gt 0; do
                    913:       arg="$1"
                    914:       base_compile="$base_compile $arg"
                    915:       shift
                    916:       case $arg in
                    917:       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \    ]*|*]*|"")
                    918:        qarg=\"`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`\" ### testsuite: skip nested quoting test
                    919:        ;;
                    920:       *) qarg=$arg ;;
                    921:       esac
                    922:       libtool_args="$libtool_args $qarg"
                    923: 
                    924:       # If the previous option needs an argument, assign it.
                    925:       if test -n "$prev"; then
                    926:        case $prev in
                    927:        output)
                    928:          compile_command="$compile_command @OUTPUT@"
                    929:          finalize_command="$finalize_command @OUTPUT@"
                    930:          ;;
                    931:        esac
                    932: 
                    933:        case $prev in
                    934:        dlfiles|dlprefiles)
                    935:          if test "$preload" = no; then
                    936:            # Add the symbol object into the linking commands.
                    937:            compile_command="$compile_command @SYMFILE@"
                    938:            finalize_command="$finalize_command @SYMFILE@"
                    939:            preload=yes
                    940:          fi
                    941:          case $arg in
                    942:          *.la | *.lo) ;;  # We handle these cases below.
                    943:          force)
                    944:            if test "$dlself" = no; then
                    945:              dlself=needless
                    946:              export_dynamic=yes
                    947:            fi
                    948:            prev=
                    949:            continue
                    950:            ;;
                    951:          self)
                    952:            if test "$prev" = dlprefiles; then
                    953:              dlself=yes
                    954:            elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
                    955:              dlself=yes
                    956:            else
                    957:              dlself=needless
                    958:              export_dynamic=yes
                    959:            fi
                    960:            prev=
                    961:            continue
                    962:            ;;
                    963:          *)
                    964:            if test "$prev" = dlfiles; then
                    965:              dlfiles="$dlfiles $arg"
                    966:            else
                    967:              dlprefiles="$dlprefiles $arg"
                    968:            fi
                    969:            prev=
                    970:            continue
                    971:            ;;
                    972:          esac
                    973:          ;;
                    974:        expsyms)
                    975:          export_symbols="$arg"
                    976:          if test ! -f "$arg"; then
                    977:            $echo "$modename: symbol file \`$arg' does not exist"
                    978:            exit 1
                    979:          fi
                    980:          prev=
                    981:          continue
                    982:          ;;
                    983:        expsyms_regex)
                    984:          export_symbols_regex="$arg"
                    985:          prev=
                    986:          continue
                    987:          ;;
                    988:        inst_prefix)
                    989:          inst_prefix_dir="$arg"
                    990:          prev=
                    991:          continue
                    992:          ;;
                    993:        release)
                    994:          release="-$arg"
                    995:          prev=
                    996:          continue
                    997:          ;;
                    998:        objectlist)
                    999:          if test -f "$arg"; then
                   1000:            save_arg=$arg
                   1001:            moreargs=
                   1002:            for fil in `cat $save_arg`
                   1003:            do
                   1004: #            moreargs="$moreargs $fil"
                   1005:              arg=$fil
                   1006:              # A libtool-controlled object.
                   1007: 
                   1008:              # Check to see that this really is a libtool object.
                   1009:              if (${SED} -e '2q' $arg | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
                   1010:                pic_object=
                   1011:                non_pic_object=
                   1012: 
                   1013:                # Read the .lo file
                   1014:                # If there is no directory component, then add one.
                   1015:                case $arg in
                   1016:                */* | *\\*) . $arg ;;
                   1017:                *) . ./$arg ;;
                   1018:                esac
                   1019: 
                   1020:                if test -z "$pic_object" || \
                   1021:                   test -z "$non_pic_object" ||
                   1022:                   test "$pic_object" = none && \
                   1023:                   test "$non_pic_object" = none; then
                   1024:                  $echo "$modename: cannot find name of object for \`$arg'" 1>&2
                   1025:                  exit 1
                   1026:                fi
                   1027: 
                   1028:                # Extract subdirectory from the argument.
                   1029:                xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
                   1030:                if test "X$xdir" = "X$arg"; then
                   1031:                  xdir=
                   1032:                else
                   1033:                  xdir="$xdir/"
                   1034:                fi
                   1035: 
                   1036:                if test "$pic_object" != none; then
                   1037:                  # Prepend the subdirectory the object is found in.
                   1038:                  pic_object="$xdir$pic_object"
                   1039: 
                   1040:                  if test "$prev" = dlfiles; then
                   1041:                    if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
                   1042:                      dlfiles="$dlfiles $pic_object"
                   1043:                      prev=
                   1044:                      continue
                   1045:                    else
                   1046:                      # If libtool objects are unsupported, then we need to preload.
                   1047:                      prev=dlprefiles
                   1048:                    fi
                   1049:                  fi
                   1050: 
                   1051:                  # CHECK ME:  I think I busted this.  -Ossama
                   1052:                  if test "$prev" = dlprefiles; then
                   1053:                    # Preload the old-style object.
                   1054:                    dlprefiles="$dlprefiles $pic_object"
                   1055:                    prev=
                   1056:                  fi
                   1057: 
                   1058:                  # A PIC object.
                   1059:                  libobjs="$libobjs $pic_object"
                   1060:                  arg="$pic_object"
                   1061:                fi
                   1062: 
                   1063:                # Non-PIC object.
                   1064:                if test "$non_pic_object" != none; then
                   1065:                  # Prepend the subdirectory the object is found in.
                   1066:                  non_pic_object="$xdir$non_pic_object"
                   1067: 
                   1068:                  # A standard non-PIC object
                   1069:                  non_pic_objects="$non_pic_objects $non_pic_object"
                   1070:                  if test -z "$pic_object" || test "$pic_object" = none ; then
                   1071:                    arg="$non_pic_object"
                   1072:                  fi
                   1073:                fi
                   1074:              else
                   1075:                # Only an error if not doing a dry-run.
                   1076:                if test -z "$run"; then
                   1077:                  $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
                   1078:                  exit 1
                   1079:                else
                   1080:                  # Dry-run case.
                   1081: 
                   1082:                  # Extract subdirectory from the argument.
                   1083:                  xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
                   1084:                  if test "X$xdir" = "X$arg"; then
                   1085:                    xdir=
                   1086:                  else
                   1087:                    xdir="$xdir/"
                   1088:                  fi
                   1089: 
                   1090:                  pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
                   1091:                  non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
                   1092:                  libobjs="$libobjs $pic_object"
                   1093:                  non_pic_objects="$non_pic_objects $non_pic_object"
                   1094:                fi
                   1095:              fi
                   1096:            done
                   1097:          else
                   1098:            $echo "$modename: link input file \`$save_arg' does not exist"
                   1099:            exit 1
                   1100:          fi
                   1101:          arg=$save_arg
                   1102:          prev=
                   1103:          continue
                   1104:          ;;
                   1105:        rpath | xrpath)
                   1106:          # We need an absolute path.
                   1107:          case $arg in
                   1108:          [\\/]* | [A-Za-z]:[\\/]*) ;;
                   1109:          *)
                   1110:            $echo "$modename: only absolute run-paths are allowed" 1>&2
                   1111:            exit 1
                   1112:            ;;
                   1113:          esac
                   1114:          if test "$prev" = rpath; then
                   1115:            case "$rpath " in
                   1116:            *" $arg "*) ;;
                   1117:            *) rpath="$rpath $arg" ;;
                   1118:            esac
                   1119:          else
                   1120:            case "$xrpath " in
                   1121:            *" $arg "*) ;;
                   1122:            *) xrpath="$xrpath $arg" ;;
                   1123:            esac
                   1124:          fi
                   1125:          prev=
                   1126:          continue
                   1127:          ;;
                   1128:        xcompiler)
                   1129:          compiler_flags="$compiler_flags $qarg"
                   1130:          prev=
                   1131:          compile_command="$compile_command $qarg"
                   1132:          finalize_command="$finalize_command $qarg"
                   1133:          continue
                   1134:          ;;
                   1135:        xlinker)
                   1136:          linker_flags="$linker_flags $qarg"
                   1137:          compiler_flags="$compiler_flags $wl$qarg"
                   1138:          prev=
                   1139:          compile_command="$compile_command $wl$qarg"
                   1140:          finalize_command="$finalize_command $wl$qarg"
                   1141:          continue
                   1142:          ;;
                   1143:        xcclinker)
                   1144:          linker_flags="$linker_flags $qarg"
                   1145:          compiler_flags="$compiler_flags $qarg"
                   1146:          prev=
                   1147:          compile_command="$compile_command $qarg"
                   1148:          finalize_command="$finalize_command $qarg"
                   1149:          continue
                   1150:          ;;
                   1151:        *)
                   1152:          eval "$prev=\"\$arg\""
                   1153:          prev=
                   1154:          continue
                   1155:          ;;
                   1156:        esac
                   1157:       fi # test -n "$prev"
                   1158: 
                   1159:       prevarg="$arg"
                   1160: 
                   1161:       case $arg in
                   1162:       -all-static)
                   1163:        if test -n "$link_static_flag"; then
                   1164:          compile_command="$compile_command $link_static_flag"
                   1165:          finalize_command="$finalize_command $link_static_flag"
                   1166:        fi
                   1167:        continue
                   1168:        ;;
                   1169: 
                   1170:       -allow-undefined)
                   1171:        # FIXME: remove this flag sometime in the future.
                   1172:        $echo "$modename: \`-allow-undefined' is deprecated because it is the default" 1>&2
                   1173:        continue
                   1174:        ;;
                   1175: 
                   1176:       -avoid-version)
                   1177:        avoid_version=yes
                   1178:        continue
                   1179:        ;;
                   1180: 
                   1181:       -dlopen)
                   1182:        prev=dlfiles
                   1183:        continue
                   1184:        ;;
                   1185: 
                   1186:       -dlpreopen)
                   1187:        prev=dlprefiles
                   1188:        continue
                   1189:        ;;
                   1190: 
                   1191:       -export-dynamic)
                   1192:        export_dynamic=yes
                   1193:        continue
                   1194:        ;;
                   1195: 
                   1196:       -export-symbols | -export-symbols-regex)
                   1197:        if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
                   1198:          $echo "$modename: more than one -exported-symbols argument is not allowed"
                   1199:          exit 1
                   1200:        fi
                   1201:        if test "X$arg" = "X-export-symbols"; then
                   1202:          prev=expsyms
                   1203:        else
                   1204:          prev=expsyms_regex
                   1205:        fi
                   1206:        continue
                   1207:        ;;
                   1208: 
                   1209:       -inst-prefix-dir)
                   1210:        prev=inst_prefix
                   1211:        continue
                   1212:        ;;
                   1213: 
                   1214:       # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
                   1215:       # so, if we see these flags be careful not to treat them like -L
                   1216:       -L[A-Z][A-Z]*:*)
                   1217:        case $with_gcc/$host in
                   1218:        no/*-*-irix* | /*-*-irix*)
                   1219:          compile_command="$compile_command $arg"
                   1220:          finalize_command="$finalize_command $arg"
                   1221:          ;;
                   1222:        esac
                   1223:        continue
                   1224:        ;;
                   1225: 
                   1226:       -L*)
                   1227:        dir=`$echo "X$arg" | $Xsed -e 's/^-L//'`
                   1228:        # We need an absolute path.
                   1229:        case $dir in
                   1230:        [\\/]* | [A-Za-z]:[\\/]*) ;;
                   1231:        *)
                   1232:          absdir=`cd "$dir" && pwd`
                   1233:          if test -z "$absdir"; then
                   1234:            $echo "$modename: cannot determine absolute directory name of \`$dir'" 1>&2
                   1235:            exit 1
                   1236:          fi
                   1237:          dir="$absdir"
                   1238:          ;;
                   1239:        esac
                   1240:        case "$deplibs " in
                   1241:        *" -L$dir "*) ;;
                   1242:        *)
                   1243:          deplibs="$deplibs -L$dir"
                   1244:          lib_search_path="$lib_search_path $dir"
                   1245:          ;;
                   1246:        esac
                   1247:        case $host in
                   1248:        *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
                   1249:          case :$dllsearchpath: in
                   1250:          *":$dir:"*) ;;
                   1251:          *) dllsearchpath="$dllsearchpath:$dir";;
                   1252:          esac
                   1253:          ;;
                   1254:        esac
                   1255:        continue
                   1256:        ;;
                   1257: 
                   1258:       -l*)
                   1259:        if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
                   1260:          case $host in
                   1261:          *-*-cygwin* | *-*-pw32* | *-*-beos*)
                   1262:            # These systems don't actually have a C or math library (as such)
                   1263:            continue
                   1264:            ;;
                   1265:          *-*-mingw* | *-*-os2*)
                   1266:            # These systems don't actually have a C library (as such)
                   1267:            test "X$arg" = "X-lc" && continue
                   1268:            ;;
                   1269:          *-*-openbsd* | *-*-freebsd*)
                   1270:            # Do not include libc due to us having libc/libc_r.
                   1271:            test "X$arg" = "X-lc" && continue
                   1272:            ;;
                   1273:          *-*-rhapsody* | *-*-darwin1.[012])
                   1274:            # Rhapsody C and math libraries are in the System framework
                   1275:            deplibs="$deplibs -framework System"
                   1276:            continue
                   1277:          esac
                   1278:        elif test "X$arg" = "X-lc_r"; then
                   1279:         case $host in
                   1280:         *-*-openbsd* | *-*-freebsd*)
                   1281:           # Do not include libc_r directly, use -pthread flag.
                   1282:           continue
                   1283:           ;;
                   1284:         esac
                   1285:        fi
                   1286:        deplibs="$deplibs $arg"
                   1287:        continue
                   1288:        ;;
                   1289: 
                   1290:       -module)
                   1291:        module=yes
                   1292:        continue
                   1293:        ;;
                   1294: 
                   1295:       # gcc -m* arguments should be passed to the linker via $compiler_flags
                   1296:       # in order to pass architecture information to the linker
                   1297:       # (e.g. 32 vs 64-bit).  This may also be accomplished via -Wl,-mfoo
                   1298:       # but this is not reliable with gcc because gcc may use -mfoo to
                   1299:       # select a different linker, different libraries, etc, while
                   1300:       # -Wl,-mfoo simply passes -mfoo to the linker.
                   1301:       -m*)
                   1302:        # Unknown arguments in both finalize_command and compile_command need
                   1303:        # to be aesthetically quoted because they are evaled later.
                   1304:        arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
                   1305:        case $arg in
                   1306:        *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
                   1307:          arg="\"$arg\""
                   1308:          ;;
                   1309:        esac
                   1310:         compile_command="$compile_command $arg"
                   1311:         finalize_command="$finalize_command $arg"
                   1312:         if test "$with_gcc" = "yes" ; then
                   1313:           compiler_flags="$compiler_flags $arg"
                   1314:         fi
                   1315:         continue
                   1316:         ;;
                   1317: 
                   1318:       -shrext)
                   1319:        prev=shrext
                   1320:        continue
                   1321:        ;;
                   1322: 
                   1323:       -no-fast-install)
                   1324:        fast_install=no
                   1325:        continue
                   1326:        ;;
                   1327: 
                   1328:       -no-install)
                   1329:        case $host in
                   1330:        *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
                   1331:          # The PATH hackery in wrapper scripts is required on Windows
                   1332:          # in order for the loader to find any dlls it needs.
                   1333:          $echo "$modename: warning: \`-no-install' is ignored for $host" 1>&2
                   1334:          $echo "$modename: warning: assuming \`-no-fast-install' instead" 1>&2
                   1335:          fast_install=no
                   1336:          ;;
                   1337:        *) no_install=yes ;;
                   1338:        esac
                   1339:        continue
                   1340:        ;;
                   1341: 
                   1342:       -no-undefined)
                   1343:        allow_undefined=no
                   1344:        continue
                   1345:        ;;
                   1346: 
                   1347:       -objectlist)
                   1348:        prev=objectlist
                   1349:        continue
                   1350:        ;;
                   1351: 
                   1352:       -o) prev=output ;;
                   1353: 
                   1354:       -release)
                   1355:        prev=release
                   1356:        continue
                   1357:        ;;
                   1358: 
                   1359:       -rpath)
                   1360:        prev=rpath
                   1361:        continue
                   1362:        ;;
                   1363: 
                   1364:       -R)
                   1365:        prev=xrpath
                   1366:        continue
                   1367:        ;;
                   1368: 
                   1369:       -R*)
                   1370:        dir=`$echo "X$arg" | $Xsed -e 's/^-R//'`
                   1371:        # We need an absolute path.
                   1372:        case $dir in
                   1373:        [\\/]* | [A-Za-z]:[\\/]*) ;;
                   1374:        *)
                   1375:          $echo "$modename: only absolute run-paths are allowed" 1>&2
                   1376:          exit 1
                   1377:          ;;
                   1378:        esac
                   1379:        case "$xrpath " in
                   1380:        *" $dir "*) ;;
                   1381:        *) xrpath="$xrpath $dir" ;;
                   1382:        esac
                   1383:        continue
                   1384:        ;;
                   1385: 
                   1386:       -static)
                   1387:        # The effects of -static are defined in a previous loop.
                   1388:        # We used to do the same as -all-static on platforms that
                   1389:        # didn't have a PIC flag, but the assumption that the effects
                   1390:        # would be equivalent was wrong.  It would break on at least
                   1391:        # Digital Unix and AIX.
                   1392:        continue
                   1393:        ;;
                   1394: 
                   1395:       -thread-safe)
                   1396:        thread_safe=yes
                   1397:        continue
                   1398:        ;;
                   1399: 
                   1400:       -version-info)
                   1401:        prev=vinfo
                   1402:        continue
                   1403:        ;;
                   1404:       -version-number)
                   1405:        prev=vinfo
                   1406:        vinfo_number=yes
                   1407:        continue
                   1408:        ;;
                   1409: 
                   1410:       -Wc,*)
                   1411:        args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wc,//'`
                   1412:        arg=
                   1413:        save_ifs="$IFS"; IFS=','
                   1414:        for flag in $args; do
                   1415:          IFS="$save_ifs"
                   1416:          case $flag in
                   1417:            *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
                   1418:            flag="\"$flag\""
                   1419:            ;;
                   1420:          esac
                   1421:          arg="$arg $wl$flag"
                   1422:          compiler_flags="$compiler_flags $flag"
                   1423:        done
                   1424:        IFS="$save_ifs"
                   1425:        arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
                   1426:        ;;
                   1427: 
                   1428:       -Wl,*)
                   1429:        args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wl,//'`
                   1430:        arg=
                   1431:        save_ifs="$IFS"; IFS=','
                   1432:        for flag in $args; do
                   1433:          IFS="$save_ifs"
                   1434:          case $flag in
                   1435:            *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
                   1436:            flag="\"$flag\""
                   1437:            ;;
                   1438:          esac
                   1439:          arg="$arg $wl$flag"
                   1440:          compiler_flags="$compiler_flags $wl$flag"
                   1441:          linker_flags="$linker_flags $flag"
                   1442:        done
                   1443:        IFS="$save_ifs"
                   1444:        arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
                   1445:        ;;
                   1446: 
                   1447:       -Xcompiler)
                   1448:        prev=xcompiler
                   1449:        continue
                   1450:        ;;
                   1451: 
                   1452:       -Xlinker)
                   1453:        prev=xlinker
                   1454:        continue
                   1455:        ;;
                   1456: 
                   1457:       -XCClinker)
                   1458:        prev=xcclinker
                   1459:        continue
                   1460:        ;;
                   1461: 
                   1462:       # Some other compiler flag.
                   1463:       -* | +*)
                   1464:        # Unknown arguments in both finalize_command and compile_command need
                   1465:        # to be aesthetically quoted because they are evaled later.
                   1466:        arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
                   1467:        case $arg in
                   1468:        *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
                   1469:          arg="\"$arg\""
                   1470:          ;;
                   1471:        esac
                   1472:        ;;
                   1473: 
                   1474:       *.$objext)
                   1475:        # A standard object.
                   1476:        objs="$objs $arg"
                   1477:        ;;
                   1478: 
                   1479:       *.lo)
                   1480:        # A libtool-controlled object.
                   1481: 
                   1482:        # Check to see that this really is a libtool object.
                   1483:        if (${SED} -e '2q' $arg | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
                   1484:          pic_object=
                   1485:          non_pic_object=
                   1486: 
                   1487:          # Read the .lo file
                   1488:          # If there is no directory component, then add one.
                   1489:          case $arg in
                   1490:          */* | *\\*) . $arg ;;
                   1491:          *) . ./$arg ;;
                   1492:          esac
                   1493: 
                   1494:          if test -z "$pic_object" || \
                   1495:             test -z "$non_pic_object" ||
                   1496:             test "$pic_object" = none && \
                   1497:             test "$non_pic_object" = none; then
                   1498:            $echo "$modename: cannot find name of object for \`$arg'" 1>&2
                   1499:            exit 1
                   1500:          fi
                   1501: 
                   1502:          # Extract subdirectory from the argument.
                   1503:          xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
                   1504:          if test "X$xdir" = "X$arg"; then
                   1505:            xdir=
                   1506:          else
                   1507:            xdir="$xdir/"
                   1508:          fi
                   1509: 
                   1510:          if test "$pic_object" != none; then
                   1511:            # Prepend the subdirectory the object is found in.
                   1512:            pic_object="$xdir$pic_object"
                   1513: 
                   1514:            if test "$prev" = dlfiles; then
                   1515:              if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
                   1516:                dlfiles="$dlfiles $pic_object"
                   1517:                prev=
                   1518:                continue
                   1519:              else
                   1520:                # If libtool objects are unsupported, then we need to preload.
                   1521:                prev=dlprefiles
                   1522:              fi
                   1523:            fi
                   1524: 
                   1525:            # CHECK ME:  I think I busted this.  -Ossama
                   1526:            if test "$prev" = dlprefiles; then
                   1527:              # Preload the old-style object.
                   1528:              dlprefiles="$dlprefiles $pic_object"
                   1529:              prev=
                   1530:            fi
                   1531: 
                   1532:            # A PIC object.
                   1533:            libobjs="$libobjs $pic_object"
                   1534:            arg="$pic_object"
                   1535:          fi
                   1536: 
                   1537:          # Non-PIC object.
                   1538:          if test "$non_pic_object" != none; then
                   1539:            # Prepend the subdirectory the object is found in.
                   1540:            non_pic_object="$xdir$non_pic_object"
                   1541: 
                   1542:            # A standard non-PIC object
                   1543:            non_pic_objects="$non_pic_objects $non_pic_object"
                   1544:            if test -z "$pic_object" || test "$pic_object" = none ; then
                   1545:              arg="$non_pic_object"
                   1546:            fi
                   1547:          fi
                   1548:        else
                   1549:          # Only an error if not doing a dry-run.
                   1550:          if test -z "$run"; then
                   1551:            $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
                   1552:            exit 1
                   1553:          else
                   1554:            # Dry-run case.
                   1555: 
                   1556:            # Extract subdirectory from the argument.
                   1557:            xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
                   1558:            if test "X$xdir" = "X$arg"; then
                   1559:              xdir=
                   1560:            else
                   1561:              xdir="$xdir/"
                   1562:            fi
                   1563: 
                   1564:            pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
                   1565:            non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
                   1566:            libobjs="$libobjs $pic_object"
                   1567:            non_pic_objects="$non_pic_objects $non_pic_object"
                   1568:          fi
                   1569:        fi
                   1570:        ;;
                   1571: 
                   1572:       *.$libext)
                   1573:        # An archive.
                   1574:        deplibs="$deplibs $arg"
                   1575:        old_deplibs="$old_deplibs $arg"
                   1576:        continue
                   1577:        ;;
                   1578: 
                   1579:       *.la)
                   1580:        # A libtool-controlled library.
                   1581: 
                   1582:        if test "$prev" = dlfiles; then
                   1583:          # This library was specified with -dlopen.
                   1584:          dlfiles="$dlfiles $arg"
                   1585:          prev=
                   1586:        elif test "$prev" = dlprefiles; then
                   1587:          # The library was specified with -dlpreopen.
                   1588:          dlprefiles="$dlprefiles $arg"
                   1589:          prev=
                   1590:        else
                   1591:          deplibs="$deplibs $arg"
                   1592:        fi
                   1593:        continue
                   1594:        ;;
                   1595: 
                   1596:       # Some other compiler argument.
                   1597:       *)
                   1598:        # Unknown arguments in both finalize_command and compile_command need
                   1599:        # to be aesthetically quoted because they are evaled later.
                   1600:        arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
                   1601:        case $arg in
                   1602:        *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
                   1603:          arg="\"$arg\""
                   1604:          ;;
                   1605:        esac
                   1606:        ;;
                   1607:       esac # arg
                   1608: 
                   1609:       # Now actually substitute the argument into the commands.
                   1610:       if test -n "$arg"; then
                   1611:        compile_command="$compile_command $arg"
                   1612:        finalize_command="$finalize_command $arg"
                   1613:       fi
                   1614:     done # argument parsing loop
                   1615: 
                   1616:     if test -n "$prev"; then
                   1617:       $echo "$modename: the \`$prevarg' option requires an argument" 1>&2
                   1618:       $echo "$help" 1>&2
                   1619:       exit 1
                   1620:     fi
                   1621: 
                   1622:     # Infer tagged configuration to use if any are available and
                   1623:     # if one wasn't chosen via the "--tag" command line option.
                   1624:     # Only attempt this if the compiler in the base link
                   1625:     # command doesn't match the default compiler.
                   1626:     if test -n "$available_tags" && test -z "$tagname"; then
                   1627:       case $base_compile in
                   1628:       # Blanks in the command may have been stripped by the calling shell,
                   1629:       # but not from the CC environment variable when configure was run.
                   1630:       "$CC "* | " $CC "* | "`$echo $CC` "* | " `$echo $CC` "*) ;;
                   1631:       # Blanks at the start of $base_compile will cause this to fail
                   1632:       # if we don't check for them as well.
                   1633:       *)
                   1634:        for z in $available_tags; do
                   1635:          if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$0" > /dev/null; then
                   1636:            # Evaluate the configuration.
                   1637:            eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $0`"
                   1638:            case $base_compile in
                   1639:            "$CC "* | " $CC "* | "`$echo $CC` "* | " `$echo $CC` "*)
                   1640:              # The compiler in $compile_command matches
                   1641:              # the one in the tagged configuration.
                   1642:              # Assume this is the tagged configuration we want.
                   1643:              tagname=$z
                   1644:              break
                   1645:              ;;
                   1646:            esac
                   1647:          fi
                   1648:        done
                   1649:        # If $tagname still isn't set, then no tagged configuration
                   1650:        # was found and let the user know that the "--tag" command
                   1651:        # line option must be used.
                   1652:        if test -z "$tagname"; then
                   1653:          $echo "$modename: unable to infer tagged configuration"
                   1654:          $echo "$modename: specify a tag with \`--tag'" 1>&2
                   1655:          exit 1
                   1656: #       else
                   1657: #         $echo "$modename: using $tagname tagged configuration"
                   1658:        fi
                   1659:        ;;
                   1660:       esac
                   1661:     fi
                   1662: 
                   1663:     if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
                   1664:       eval arg=\"$export_dynamic_flag_spec\"
                   1665:       compile_command="$compile_command $arg"
                   1666:       finalize_command="$finalize_command $arg"
                   1667:     fi
                   1668: 
                   1669:     oldlibs=
                   1670:     # calculate the name of the file, without its directory
                   1671:     outputname=`$echo "X$output" | $Xsed -e 's%^.*/%%'`
                   1672:     libobjs_save="$libobjs"
                   1673: 
                   1674:     if test -n "$shlibpath_var"; then
                   1675:       # get the directories listed in $shlibpath_var
                   1676:       eval shlib_search_path=\`\$echo \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
                   1677:     else
                   1678:       shlib_search_path=
                   1679:     fi
                   1680:     eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
                   1681:     eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
                   1682: 
                   1683:     output_objdir=`$echo "X$output" | $Xsed -e 's%/[^/]*$%%'`
                   1684:     if test "X$output_objdir" = "X$output"; then
                   1685:       output_objdir="$objdir"
                   1686:     else
                   1687:       output_objdir="$output_objdir/$objdir"
                   1688:     fi
                   1689:     # Create the object directory.
                   1690:     if test ! -d "$output_objdir"; then
                   1691:       $show "$mkdir $output_objdir"
                   1692:       $run $mkdir $output_objdir
                   1693:       status=$?
                   1694:       if test "$status" -ne 0 && test ! -d "$output_objdir"; then
                   1695:        exit $status
                   1696:       fi
                   1697:     fi
                   1698: 
                   1699:     # Determine the type of output
                   1700:     case $output in
                   1701:     "")
                   1702:       $echo "$modename: you must specify an output file" 1>&2
                   1703:       $echo "$help" 1>&2
                   1704:       exit 1
                   1705:       ;;
                   1706:     *.$libext) linkmode=oldlib ;;
                   1707:     *.lo | *.$objext) linkmode=obj ;;
                   1708:     *.la) linkmode=lib ;;
                   1709:     *) linkmode=prog ;; # Anything else should be a program.
                   1710:     esac
                   1711: 
                   1712:     case $host in
                   1713:     *cygwin* | *mingw* | *pw32*)
                   1714:       # don't eliminate duplcations in $postdeps and $predeps
                   1715:       duplicate_compiler_generated_deps=yes
                   1716:       ;;
                   1717:     *)
                   1718:       duplicate_compiler_generated_deps=$duplicate_deps
                   1719:       ;;
                   1720:     esac
                   1721:     specialdeplibs=
                   1722: 
                   1723:     libs=
                   1724:     # Find all interdependent deplibs by searching for libraries
                   1725:     # that are linked more than once (e.g. -la -lb -la)
                   1726:     for deplib in $deplibs; do
                   1727:       if test "X$duplicate_deps" = "Xyes" ; then
                   1728:        case "$libs " in
                   1729:        *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
                   1730:        esac
                   1731:       fi
                   1732:       libs="$libs $deplib"
                   1733:     done
                   1734: 
                   1735:     if test "$linkmode" = lib; then
                   1736:       libs="$predeps $libs $compiler_lib_search_path $postdeps"
                   1737: 
                   1738:       # Compute libraries that are listed more than once in $predeps
                   1739:       # $postdeps and mark them as special (i.e., whose duplicates are
                   1740:       # not to be eliminated).
                   1741:       pre_post_deps=
                   1742:       if test "X$duplicate_compiler_generated_deps" = "Xyes" ; then
                   1743:        for pre_post_dep in $predeps $postdeps; do
                   1744:          case "$pre_post_deps " in
                   1745:          *" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
                   1746:          esac
                   1747:          pre_post_deps="$pre_post_deps $pre_post_dep"
                   1748:        done
                   1749:       fi
                   1750:       pre_post_deps=
                   1751:     fi
                   1752: 
                   1753:     deplibs=
                   1754:     newdependency_libs=
                   1755:     newlib_search_path=
                   1756:     need_relink=no # whether we're linking any uninstalled libtool libraries
                   1757:     notinst_deplibs= # not-installed libtool libraries
                   1758:     notinst_path= # paths that contain not-installed libtool libraries
                   1759:     case $linkmode in
                   1760:     lib)
                   1761:        passes="conv link"
                   1762:        for file in $dlfiles $dlprefiles; do
                   1763:          case $file in
                   1764:          *.la) ;;
                   1765:          *)
                   1766:            $echo "$modename: libraries can \`-dlopen' only libtool libraries: $file" 1>&2
                   1767:            exit 1
                   1768:            ;;
                   1769:          esac
                   1770:        done
                   1771:        ;;
                   1772:     prog)
                   1773:        compile_deplibs=
                   1774:        finalize_deplibs=
                   1775:        alldeplibs=no
                   1776:        newdlfiles=
                   1777:        newdlprefiles=
                   1778:        passes="conv scan dlopen dlpreopen link"
                   1779:        ;;
                   1780:     *)  passes="conv"
                   1781:        ;;
                   1782:     esac
                   1783:     for pass in $passes; do
                   1784:       if test "$linkmode,$pass" = "lib,link" ||
                   1785:         test "$linkmode,$pass" = "prog,scan"; then
                   1786:        libs="$deplibs"
                   1787:        deplibs=
                   1788:       fi
                   1789:       if test "$linkmode" = prog; then
                   1790:        case $pass in
                   1791:        dlopen) libs="$dlfiles" ;;
                   1792:        dlpreopen) libs="$dlprefiles" ;;
                   1793:        link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
                   1794:        esac
                   1795:       fi
                   1796:       if test "$pass" = dlopen; then
                   1797:        # Collect dlpreopened libraries
                   1798:        save_deplibs="$deplibs"
                   1799:        deplibs=
                   1800:       fi
                   1801:       for deplib in $libs; do
                   1802:        lib=
                   1803:        found=no
                   1804:        case $deplib in
                   1805:        -l*)
                   1806:          if test "$linkmode" != lib && test "$linkmode" != prog; then
                   1807:            $echo "$modename: warning: \`-l' is ignored for archives/objects" 1>&2
                   1808:            continue
                   1809:          fi
                   1810:          if test "$pass" = conv; then
                   1811:            deplibs="$deplib $deplibs"
                   1812:            continue
                   1813:          fi
                   1814:          name=`$echo "X$deplib" | $Xsed -e 's/^-l//'`
                   1815:          for searchdir in $newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path; do
                   1816:            # Search the libtool library
                   1817:            lib="$searchdir/lib${name}.la"
                   1818:            if test -f "$lib"; then
                   1819:              found=yes
                   1820:              break
                   1821:            fi
                   1822:          done
                   1823:          if test "$found" != yes; then
                   1824:            # deplib doesn't seem to be a libtool library
                   1825:            if test "$linkmode,$pass" = "prog,link"; then
                   1826:              compile_deplibs="$deplib $compile_deplibs"
                   1827:              finalize_deplibs="$deplib $finalize_deplibs"
                   1828:            else
                   1829:              deplibs="$deplib $deplibs"
                   1830:              test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
                   1831:            fi
                   1832:            continue
                   1833:          else # deplib is a libtool library
                   1834:            # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
                   1835:            # We need to do some special things here, and not later.
                   1836:            if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
                   1837:              case " $predeps $postdeps " in
                   1838:              *" $deplib "*)
                   1839:                if (${SED} -e '2q' $lib |
                   1840:                     grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
                   1841:                  library_names=
                   1842:                  old_library=
                   1843:                  case $lib in
                   1844:                  */* | *\\*) . $lib ;;
                   1845:                  *) . ./$lib ;;
                   1846:                  esac
                   1847:                  for l in $old_library $library_names; do
                   1848:                    ll="$l"
                   1849:                  done
                   1850:                  if test "X$ll" = "X$old_library" ; then # only static version available
                   1851:                    found=no
                   1852:                    ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
                   1853:                    test "X$ladir" = "X$lib" && ladir="."
                   1854:                    lib=$ladir/$old_library
                   1855:                    if test "$linkmode,$pass" = "prog,link"; then
                   1856:                      compile_deplibs="$deplib $compile_deplibs"
                   1857:                      finalize_deplibs="$deplib $finalize_deplibs"
                   1858:                    else
                   1859:                      deplibs="$deplib $deplibs"
                   1860:                      test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
                   1861:                    fi
                   1862:                    continue
                   1863:                  fi
                   1864:                fi
                   1865:                ;;
                   1866:              *) ;;
                   1867:              esac
                   1868:            fi
                   1869:          fi
                   1870:          ;; # -l
                   1871:        -L*)
                   1872:          case $linkmode in
                   1873:          lib)
                   1874:            deplibs="$deplib $deplibs"
                   1875:            test "$pass" = conv && continue
                   1876:            newdependency_libs="$deplib $newdependency_libs"
                   1877:            newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
                   1878:            ;;
                   1879:          prog)
                   1880:            if test "$pass" = conv; then
                   1881:              deplibs="$deplib $deplibs"
                   1882:              continue
                   1883:            fi
                   1884:            if test "$pass" = scan; then
                   1885:              deplibs="$deplib $deplibs"
                   1886:              newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
                   1887:            else
                   1888:              compile_deplibs="$deplib $compile_deplibs"
                   1889:              finalize_deplibs="$deplib $finalize_deplibs"
                   1890:            fi
                   1891:            ;;
                   1892:          *)
                   1893:            $echo "$modename: warning: \`-L' is ignored for archives/objects" 1>&2
                   1894:            ;;
                   1895:          esac # linkmode
                   1896:          continue
                   1897:          ;; # -L
                   1898:        -R*)
                   1899:          if test "$pass" = link; then
                   1900:            dir=`$echo "X$deplib" | $Xsed -e 's/^-R//'`
                   1901:            # Make sure the xrpath contains only unique directories.
                   1902:            case "$xrpath " in
                   1903:            *" $dir "*) ;;
                   1904:            *) xrpath="$xrpath $dir" ;;
                   1905:            esac
                   1906:          fi
                   1907:          deplibs="$deplib $deplibs"
                   1908:          continue
                   1909:          ;;
                   1910:        *.la) lib="$deplib" ;;
                   1911:        *.$libext)
                   1912:          if test "$pass" = conv; then
                   1913:            deplibs="$deplib $deplibs"
                   1914:            continue
                   1915:          fi
                   1916:          case $linkmode in
                   1917:          lib)
                   1918:            if test "$deplibs_check_method" != pass_all; then
                   1919:              $echo
                   1920:              $echo "*** Warning: Trying to link with static lib archive $deplib."
                   1921:              $echo "*** I have the capability to make that library automatically link in when"
                   1922:              $echo "*** you link to this library.  But I can only do this if you have a"
                   1923:              $echo "*** shared version of the library, which you do not appear to have"
                   1924:              $echo "*** because the file extensions .$libext of this argument makes me believe"
                   1925:              $echo "*** that it is just a static archive that I should not used here."
                   1926:            else
                   1927:              $echo
                   1928:              $echo "*** Warning: Linking the shared library $output against the"
                   1929:              $echo "*** static library $deplib is not portable!"
                   1930:              deplibs="$deplib $deplibs"
                   1931:            fi
                   1932:            continue
                   1933:            ;;
                   1934:          prog)
                   1935:            if test "$pass" != link; then
                   1936:              deplibs="$deplib $deplibs"
                   1937:            else
                   1938:              compile_deplibs="$deplib $compile_deplibs"
                   1939:              finalize_deplibs="$deplib $finalize_deplibs"
                   1940:            fi
                   1941:            continue
                   1942:            ;;
                   1943:          esac # linkmode
                   1944:          ;; # *.$libext
                   1945:        *.lo | *.$objext)
                   1946:          if test "$pass" = conv; then
                   1947:            deplibs="$deplib $deplibs"
                   1948:          elif test "$linkmode" = prog; then
                   1949:            if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
                   1950:              # If there is no dlopen support or we're linking statically,
                   1951:              # we need to preload.
                   1952:              newdlprefiles="$newdlprefiles $deplib"
                   1953:              compile_deplibs="$deplib $compile_deplibs"
                   1954:              finalize_deplibs="$deplib $finalize_deplibs"
                   1955:            else
                   1956:              newdlfiles="$newdlfiles $deplib"
                   1957:            fi
                   1958:          fi
                   1959:          continue
                   1960:          ;;
                   1961:        %DEPLIBS%)
                   1962:          alldeplibs=yes
                   1963:          continue
                   1964:          ;;
                   1965:        esac # case $deplib
                   1966:        if test "$found" = yes || test -f "$lib"; then :
                   1967:        else
                   1968:          $echo "$modename: cannot find the library \`$lib'" 1>&2
                   1969:          exit 1
                   1970:        fi
                   1971: 
                   1972:        # Check to see that this really is a libtool archive.
                   1973:        if (${SED} -e '2q' $lib | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
                   1974:        else
                   1975:          $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
                   1976:          exit 1
                   1977:        fi
                   1978: 
                   1979:        ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
                   1980:        test "X$ladir" = "X$lib" && ladir="."
                   1981: 
                   1982:        dlname=
                   1983:        dlopen=
                   1984:        dlpreopen=
                   1985:        libdir=
                   1986:        library_names=
                   1987:        old_library=
                   1988:        # If the library was installed with an old release of libtool,
                   1989:        # it will not redefine variables installed, or shouldnotlink
                   1990:        installed=yes
                   1991:        shouldnotlink=no
                   1992: 
                   1993:        # Read the .la file
                   1994:        case $lib in
                   1995:        */* | *\\*) . $lib ;;
                   1996:        *) . ./$lib ;;
                   1997:        esac
                   1998: 
                   1999:        if test "$linkmode,$pass" = "lib,link" ||
                   2000:           test "$linkmode,$pass" = "prog,scan" ||
                   2001:           { test "$linkmode" != prog && test "$linkmode" != lib; }; then
                   2002:          test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
                   2003:          test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
                   2004:        fi
                   2005: 
                   2006:        if test "$pass" = conv; then
                   2007:          # Only check for convenience libraries
                   2008:          deplibs="$lib $deplibs"
                   2009:          if test -z "$libdir"; then
                   2010:            if test -z "$old_library"; then
                   2011:              $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
                   2012:              exit 1
                   2013:            fi
                   2014:            # It is a libtool convenience library, so add in its objects.
                   2015:            convenience="$convenience $ladir/$objdir/$old_library"
                   2016:            old_convenience="$old_convenience $ladir/$objdir/$old_library"
                   2017:            tmp_libs=
                   2018:            for deplib in $dependency_libs; do
                   2019:              deplibs="$deplib $deplibs"
                   2020:               if test "X$duplicate_deps" = "Xyes" ; then
                   2021:                case "$tmp_libs " in
                   2022:                *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
                   2023:                esac
                   2024:               fi
                   2025:              tmp_libs="$tmp_libs $deplib"
                   2026:            done
                   2027:          elif test "$linkmode" != prog && test "$linkmode" != lib; then
                   2028:            $echo "$modename: \`$lib' is not a convenience library" 1>&2
                   2029:            exit 1
                   2030:          fi
                   2031:          continue
                   2032:        fi # $pass = conv
                   2033: 
                   2034:     
                   2035:        # Get the name of the library we link against.
                   2036:        linklib=
                   2037:        for l in $old_library $library_names; do
                   2038:          linklib="$l"
                   2039:        done
                   2040:        if test -z "$linklib"; then
                   2041:          $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
                   2042:          exit 1
                   2043:        fi
                   2044: 
                   2045:        # This library was specified with -dlopen.
                   2046:        if test "$pass" = dlopen; then
                   2047:          if test -z "$libdir"; then
                   2048:            $echo "$modename: cannot -dlopen a convenience library: \`$lib'" 1>&2
                   2049:            exit 1
                   2050:          fi
                   2051:          if test -z "$dlname" || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
                   2052:            # If there is no dlname, no dlopen support or we're linking
                   2053:            # statically, we need to preload.  We also need to preload any
                   2054:            # dependent libraries so libltdl's deplib preloader doesn't
                   2055:            # bomb out in the load deplibs phase.
                   2056:            dlprefiles="$dlprefiles $lib $dependency_libs"
                   2057:          else
                   2058:            newdlfiles="$newdlfiles $lib"
                   2059:          fi
                   2060:          continue
                   2061:        fi # $pass = dlopen
                   2062: 
                   2063:        # We need an absolute path.
                   2064:        case $ladir in
                   2065:        [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
                   2066:        *)
                   2067:          abs_ladir=`cd "$ladir" && pwd`
                   2068:          if test -z "$abs_ladir"; then
                   2069:            $echo "$modename: warning: cannot determine absolute directory name of \`$ladir'" 1>&2
                   2070:            $echo "$modename: passing it literally to the linker, although it might fail" 1>&2
                   2071:            abs_ladir="$ladir"
                   2072:          fi
                   2073:          ;;
                   2074:        esac
                   2075:        laname=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
                   2076: 
                   2077:        # Find the relevant object directory and library name.
                   2078:        if test "X$installed" = Xyes; then
                   2079:          if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
                   2080:            $echo "$modename: warning: library \`$lib' was moved." 1>&2
                   2081:            dir="$ladir"
                   2082:            absdir="$abs_ladir"
                   2083:            libdir="$abs_ladir"
                   2084:          else
                   2085:            dir="$libdir"
                   2086:            absdir="$libdir"
                   2087:          fi
                   2088:        else
                   2089:          dir="$ladir/$objdir"
                   2090:          absdir="$abs_ladir/$objdir"
                   2091:          # Remove this search path later
                   2092:          notinst_path="$notinst_path $abs_ladir"
                   2093:        fi # $installed = yes
                   2094:        name=`$echo "X$laname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
                   2095: 
                   2096:        # This library was specified with -dlpreopen.
                   2097:        if test "$pass" = dlpreopen; then
                   2098:          if test -z "$libdir"; then
                   2099:            $echo "$modename: cannot -dlpreopen a convenience library: \`$lib'" 1>&2
                   2100:            exit 1
                   2101:          fi
                   2102:          # Prefer using a static library (so that no silly _DYNAMIC symbols
                   2103:          # are required to link).
                   2104:          if test -n "$old_library"; then
                   2105:            newdlprefiles="$newdlprefiles $dir/$old_library"
                   2106:          # Otherwise, use the dlname, so that lt_dlopen finds it.
                   2107:          elif test -n "$dlname"; then
                   2108:            newdlprefiles="$newdlprefiles $dir/$dlname"
                   2109:          else
                   2110:            newdlprefiles="$newdlprefiles $dir/$linklib"
                   2111:          fi
                   2112:        fi # $pass = dlpreopen
                   2113: 
                   2114:        if test -z "$libdir"; then
                   2115:          # Link the convenience library
                   2116:          if test "$linkmode" = lib; then
                   2117:            deplibs="$dir/$old_library $deplibs"
                   2118:          elif test "$linkmode,$pass" = "prog,link"; then
                   2119:            compile_deplibs="$dir/$old_library $compile_deplibs"
                   2120:            finalize_deplibs="$dir/$old_library $finalize_deplibs"
                   2121:          else
                   2122:            deplibs="$lib $deplibs" # used for prog,scan pass
                   2123:          fi
                   2124:          continue
                   2125:        fi
                   2126: 
                   2127:     
                   2128:        if test "$linkmode" = prog && test "$pass" != link; then
                   2129:          newlib_search_path="$newlib_search_path $ladir"
                   2130:          deplibs="$lib $deplibs"
                   2131: 
                   2132:          linkalldeplibs=no
                   2133:          if test "$link_all_deplibs" != no || test -z "$library_names" ||
                   2134:             test "$build_libtool_libs" = no; then
                   2135:            linkalldeplibs=yes
                   2136:          fi
                   2137: 
                   2138:          tmp_libs=
                   2139:          for deplib in $dependency_libs; do
                   2140:            case $deplib in
                   2141:            -L*) newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`;; ### testsuite: skip nested quoting test
                   2142:            esac
                   2143:            # Need to link against all dependency_libs?
                   2144:            if test "$linkalldeplibs" = yes; then
                   2145:              deplibs="$deplib $deplibs"
                   2146:            else
                   2147:              # Need to hardcode shared library paths
                   2148:              # or/and link against static libraries
                   2149:              newdependency_libs="$deplib $newdependency_libs"
                   2150:            fi
                   2151:            if test "X$duplicate_deps" = "Xyes" ; then
                   2152:              case "$tmp_libs " in
                   2153:              *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
                   2154:              esac
                   2155:            fi
                   2156:            tmp_libs="$tmp_libs $deplib"
                   2157:          done # for deplib
                   2158:          continue
                   2159:        fi # $linkmode = prog...
                   2160: 
                   2161:        if test "$linkmode,$pass" = "prog,link"; then
                   2162:          if test -n "$library_names" &&
                   2163:             { test "$prefer_static_libs" = no || test -z "$old_library"; }; then
                   2164:            # We need to hardcode the library path
                   2165:            if test -n "$shlibpath_var"; then
                   2166:              # Make sure the rpath contains only unique directories.
                   2167:              case "$temp_rpath " in
                   2168:              *" $dir "*) ;;
                   2169:              *" $absdir "*) ;;
                   2170:              *) temp_rpath="$temp_rpath $dir" ;;
                   2171:              esac
                   2172:            fi
                   2173: 
                   2174:            # Hardcode the library path.
                   2175:            # Skip directories that are in the system default run-time
                   2176:            # search path.
                   2177:            case " $sys_lib_dlsearch_path " in
                   2178:            *" $absdir "*) ;;
                   2179:            *)
                   2180:              case "$compile_rpath " in
                   2181:              *" $absdir "*) ;;
                   2182:              *) compile_rpath="$compile_rpath $absdir"
                   2183:              esac
                   2184:              ;;
                   2185:            esac
                   2186:            case " $sys_lib_dlsearch_path " in
                   2187:            *" $libdir "*) ;;
                   2188:            *)
                   2189:              case "$finalize_rpath " in
                   2190:              *" $libdir "*) ;;
                   2191:              *) finalize_rpath="$finalize_rpath $libdir"
                   2192:              esac
                   2193:              ;;
                   2194:            esac
                   2195:          fi # $linkmode,$pass = prog,link...
                   2196: 
                   2197:          if test "$alldeplibs" = yes &&
                   2198:             { test "$deplibs_check_method" = pass_all ||
                   2199:               { test "$build_libtool_libs" = yes &&
                   2200:                 test -n "$library_names"; }; }; then
                   2201:            # We only need to search for static libraries
                   2202:            continue
                   2203:          fi
                   2204:        fi
                   2205: 
                   2206:        link_static=no # Whether the deplib will be linked statically
                   2207:        if test -n "$library_names" &&
                   2208:           { test "$prefer_static_libs" = no || test -z "$old_library"; }; then
                   2209:          if test "$installed" = no; then
                   2210:            notinst_deplibs="$notinst_deplibs $lib"
                   2211:            need_relink=yes
                   2212:          fi
                   2213:          # This is a shared library
                   2214:        
                   2215:       # Warn about portability, can't link against -module's on some systems (darwin)
                   2216:       if test "$shouldnotlink" = yes && test "$pass" = link ; then
                   2217:            $echo
                   2218:            if test "$linkmode" = prog; then
                   2219:              $echo "*** Warning: Linking the executable $output against the loadable module"
                   2220:            else
                   2221:              $echo "*** Warning: Linking the shared library $output against the loadable module"
                   2222:            fi
                   2223:            $echo "*** $linklib is not portable!"    
                   2224:       fi         
                   2225:          if test "$linkmode" = lib &&
                   2226:             test "$hardcode_into_libs" = yes; then
                   2227:            # Hardcode the library path.
                   2228:            # Skip directories that are in the system default run-time
                   2229:            # search path.
                   2230:            case " $sys_lib_dlsearch_path " in
                   2231:            *" $absdir "*) ;;
                   2232:            *)
                   2233:              case "$compile_rpath " in
                   2234:              *" $absdir "*) ;;
                   2235:              *) compile_rpath="$compile_rpath $absdir"
                   2236:              esac
                   2237:              ;;
                   2238:            esac
                   2239:            case " $sys_lib_dlsearch_path " in
                   2240:            *" $libdir "*) ;;
                   2241:            *)
                   2242:              case "$finalize_rpath " in
                   2243:              *" $libdir "*) ;;
                   2244:              *) finalize_rpath="$finalize_rpath $libdir"
                   2245:              esac
                   2246:              ;;
                   2247:            esac
                   2248:          fi
                   2249: 
                   2250:          if test -n "$old_archive_from_expsyms_cmds"; then
                   2251:            # figure out the soname
                   2252:            set dummy $library_names
                   2253:            realname="$2"
                   2254:            shift; shift
                   2255:            libname=`eval \\$echo \"$libname_spec\"`
                   2256:            # use dlname if we got it. it's perfectly good, no?
                   2257:            if test -n "$dlname"; then
                   2258:              soname="$dlname"
                   2259:            elif test -n "$soname_spec"; then
                   2260:              # bleh windows
                   2261:              case $host in
                   2262:              *cygwin* | mingw*)
                   2263:                major=`expr $current - $age`
                   2264:                versuffix="-$major"
                   2265:                ;;
                   2266:              esac
                   2267:              eval soname=\"$soname_spec\"
                   2268:            else
                   2269:              soname="$realname"
                   2270:            fi
                   2271: 
                   2272:            # Make a new name for the extract_expsyms_cmds to use
                   2273:            soroot="$soname"
                   2274:            soname=`$echo $soroot | ${SED} -e 's/^.*\///'`
                   2275:            newlib="libimp-`$echo $soname | ${SED} 's/^lib//;s/\.dll$//'`.a"
                   2276: 
                   2277:            # If the library has no export list, then create one now
                   2278:            if test -f "$output_objdir/$soname-def"; then :
                   2279:            else
                   2280:              $show "extracting exported symbol list from \`$soname'"
                   2281:              save_ifs="$IFS"; IFS='~'
                   2282:              eval cmds=\"$extract_expsyms_cmds\"
                   2283:              for cmd in $cmds; do
                   2284:                IFS="$save_ifs"
                   2285:                $show "$cmd"
                   2286:                $run eval "$cmd" || exit $?
                   2287:              done
                   2288:              IFS="$save_ifs"
                   2289:            fi
                   2290: 
                   2291:            # Create $newlib
                   2292:            if test -f "$output_objdir/$newlib"; then :; else
                   2293:              $show "generating import library for \`$soname'"
                   2294:              save_ifs="$IFS"; IFS='~'
                   2295:              eval cmds=\"$old_archive_from_expsyms_cmds\"
                   2296:              for cmd in $cmds; do
                   2297:                IFS="$save_ifs"
                   2298:                $show "$cmd"
                   2299:                $run eval "$cmd" || exit $?
                   2300:              done
                   2301:              IFS="$save_ifs"
                   2302:            fi
                   2303:            # make sure the library variables are pointing to the new library
                   2304:            dir=$output_objdir
                   2305:            linklib=$newlib
                   2306:          fi # test -n "$old_archive_from_expsyms_cmds"
                   2307: 
                   2308:          if test "$linkmode" = prog || test "$mode" != relink; then
                   2309:            add_shlibpath=
                   2310:            add_dir=
                   2311:            add=
                   2312:            lib_linked=yes
                   2313:            case $hardcode_action in
                   2314:            immediate | unsupported)
                   2315:              if test "$hardcode_direct" = no; then
                   2316:                add="$dir/$linklib"
                   2317:                case $host in
                   2318:                  *-*-sco3.2v5* ) add_dir="-L$dir" ;;
                   2319:                  *-*-darwin* )
                   2320:                    # if the lib is a module then we can not link against it, someone
                   2321:                    # is ignoring the new warnings I added
                   2322:                    if /usr/bin/file -L $add 2> /dev/null | grep "bundle" >/dev/null ; then
                   2323:                      $echo "** Warning, lib $linklib is a module, not a shared library"
                   2324:                      if test -z "$old_library" ; then
                   2325:                        $echo
                   2326:                        $echo "** And there doesn't seem to be a static archive available"
                   2327:                        $echo "** The link will probably fail, sorry"
                   2328:                      else
                   2329:                        add="$dir/$old_library"
                   2330:                      fi 
                   2331:                    fi
                   2332:                esac
                   2333:              elif test "$hardcode_minus_L" = no; then
                   2334:                case $host in
                   2335:                *-*-sunos*) add_shlibpath="$dir" ;;
                   2336:                esac
                   2337:                add_dir="-L$dir"
                   2338:                add="-l$name"
                   2339:              elif test "$hardcode_shlibpath_var" = no; then
                   2340:                add_shlibpath="$dir"
                   2341:                add="-l$name"
                   2342:              else
                   2343:                lib_linked=no
                   2344:              fi
                   2345:              ;;
                   2346:            relink)
                   2347:              if test "$hardcode_direct" = yes; then
                   2348:                add="$dir/$linklib"
                   2349:              elif test "$hardcode_minus_L" = yes; then
                   2350:                add_dir="-L$dir"
                   2351:                # Try looking first in the location we're being installed to.
                   2352:                if test -n "$inst_prefix_dir"; then
                   2353:                  case "$libdir" in
                   2354:                    [\\/]*)
                   2355:                      add_dir="-L$inst_prefix_dir$libdir $add_dir"
                   2356:                      ;;
                   2357:                  esac
                   2358:                fi
                   2359:                add="-l$name"
                   2360:              elif test "$hardcode_shlibpath_var" = yes; then
                   2361:                add_shlibpath="$dir"
                   2362:                add="-l$name"
                   2363:              else
                   2364:                lib_linked=no
                   2365:              fi
                   2366:              ;;
                   2367:            *) lib_linked=no ;;
                   2368:            esac
                   2369: 
                   2370:            if test "$lib_linked" != yes; then
                   2371:              $echo "$modename: configuration error: unsupported hardcode properties"
                   2372:              exit 1
                   2373:            fi
                   2374: 
                   2375:            if test -n "$add_shlibpath"; then
                   2376:              case :$compile_shlibpath: in
                   2377:              *":$add_shlibpath:"*) ;;
                   2378:              *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
                   2379:              esac
                   2380:            fi
                   2381:            if test "$linkmode" = prog; then
                   2382:              test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
                   2383:              test -n "$add" && compile_deplibs="$add $compile_deplibs"
                   2384:            else
                   2385:              test -n "$add_dir" && deplibs="$add_dir $deplibs"
                   2386:              test -n "$add" && deplibs="$add $deplibs"
                   2387:              if test "$hardcode_direct" != yes && \
                   2388:                 test "$hardcode_minus_L" != yes && \
                   2389:                 test "$hardcode_shlibpath_var" = yes; then
                   2390:                case :$finalize_shlibpath: in
                   2391:                *":$libdir:"*) ;;
                   2392:                *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
                   2393:                esac
                   2394:              fi
                   2395:            fi
                   2396:          fi
                   2397: 
                   2398:          if test "$linkmode" = prog || test "$mode" = relink; then
                   2399:            add_shlibpath=
                   2400:            add_dir=
                   2401:            add=
                   2402:            # Finalize command for both is simple: just hardcode it.
                   2403:            if test "$hardcode_direct" = yes; then
                   2404:              add="$libdir/$linklib"
                   2405:            elif test "$hardcode_minus_L" = yes; then
                   2406:              add_dir="-L$libdir"
                   2407:              add="-l$name"
                   2408:            elif test "$hardcode_shlibpath_var" = yes; then
                   2409:              case :$finalize_shlibpath: in
                   2410:              *":$libdir:"*) ;;
                   2411:              *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
                   2412:              esac
                   2413:              add="-l$name"
                   2414:            elif test "$hardcode_automatic" = yes; then
                   2415:              if test -n "$inst_prefix_dir" && test -f "$inst_prefix_dir$libdir/$linklib" ; then
                   2416:                add="$inst_prefix_dir$libdir/$linklib"
                   2417:              else
                   2418:                add="$libdir/$linklib"
                   2419:              fi
                   2420:            else
                   2421:              # We cannot seem to hardcode it, guess we'll fake it.
                   2422:              add_dir="-L$libdir"
                   2423:              # Try looking first in the location we're being installed to.
                   2424:              if test -n "$inst_prefix_dir"; then
                   2425:                case "$libdir" in
                   2426:                  [\\/]*)
                   2427:                    add_dir="-L$inst_prefix_dir$libdir $add_dir"
                   2428:                    ;;
                   2429:                esac
                   2430:              fi
                   2431:              add="-l$name"
                   2432:            fi
                   2433: 
                   2434:            if test "$linkmode" = prog; then
                   2435:              test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
                   2436:              test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
                   2437:            else
                   2438:              test -n "$add_dir" && deplibs="$add_dir $deplibs"
                   2439:              test -n "$add" && deplibs="$add $deplibs"
                   2440:            fi
                   2441:          fi
                   2442:        elif test "$linkmode" = prog; then
                   2443:          # Here we assume that one of hardcode_direct or hardcode_minus_L
                   2444:          # is not unsupported.  This is valid on all known static and
                   2445:          # shared platforms.
                   2446:          if test "$hardcode_direct" != unsupported; then
                   2447:            test -n "$old_library" && linklib="$old_library"
                   2448:            compile_deplibs="$dir/$linklib $compile_deplibs"
                   2449:            finalize_deplibs="$dir/$linklib $finalize_deplibs"
                   2450:          else
                   2451:            compile_deplibs="-l$name -L$dir $compile_deplibs"
                   2452:            finalize_deplibs="-l$name -L$dir $finalize_deplibs"
                   2453:          fi
                   2454:        elif test "$build_libtool_libs" = yes; then
                   2455:          # Not a shared library
                   2456:          if test "$deplibs_check_method" != pass_all; then
                   2457:            # We're trying link a shared library against a static one
                   2458:            # but the system doesn't support it.
                   2459: 
                   2460:            # Just print a warning and add the library to dependency_libs so
                   2461:            # that the program can be linked against the static library.
                   2462:            $echo
                   2463:            $echo "*** Warning: This system can not link to static lib archive $lib."
                   2464:            $echo "*** I have the capability to make that library automatically link in when"
                   2465:            $echo "*** you link to this library.  But I can only do this if you have a"
                   2466:            $echo "*** shared version of the library, which you do not appear to have."
                   2467:            if test "$module" = yes; then
                   2468:              $echo "*** But as you try to build a module library, libtool will still create "
                   2469:              $echo "*** a static module, that should work as long as the dlopening application"
                   2470:              $echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
                   2471:              if test -z "$global_symbol_pipe"; then
                   2472:                $echo
                   2473:                $echo "*** However, this would only work if libtool was able to extract symbol"
                   2474:                $echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
                   2475:                $echo "*** not find such a program.  So, this module is probably useless."
                   2476:                $echo "*** \`nm' from GNU binutils and a full rebuild may help."
                   2477:              fi
                   2478:              if test "$build_old_libs" = no; then
                   2479:                build_libtool_libs=module
                   2480:                build_old_libs=yes
                   2481:              else
                   2482:                build_libtool_libs=no
                   2483:              fi
                   2484:            fi
                   2485:          else
                   2486:            convenience="$convenience $dir/$old_library"
                   2487:            old_convenience="$old_convenience $dir/$old_library"
                   2488:            deplibs="$dir/$old_library $deplibs"
                   2489:            link_static=yes
                   2490:          fi
                   2491:        fi # link shared/static library?
                   2492: 
                   2493:        if test "$linkmode" = lib; then
                   2494:          if test -n "$dependency_libs" &&
                   2495:             { test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes ||
                   2496:               test "$link_static" = yes; }; then
                   2497:            # Extract -R from dependency_libs
                   2498:            temp_deplibs=
                   2499:            for libdir in $dependency_libs; do
                   2500:              case $libdir in
                   2501:              -R*) temp_xrpath=`$echo "X$libdir" | $Xsed -e 's/^-R//'`
                   2502:                   case " $xrpath " in
                   2503:                   *" $temp_xrpath "*) ;;
                   2504:                   *) xrpath="$xrpath $temp_xrpath";;
                   2505:                   esac;;
                   2506:              *) temp_deplibs="$temp_deplibs $libdir";;
                   2507:              esac
                   2508:            done
                   2509:            dependency_libs="$temp_deplibs"
                   2510:          fi
                   2511: 
                   2512:          newlib_search_path="$newlib_search_path $absdir"
                   2513:          # Link against this library
                   2514:          test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
                   2515:          # ... and its dependency_libs
                   2516:          tmp_libs=
                   2517:          for deplib in $dependency_libs; do
                   2518:            newdependency_libs="$deplib $newdependency_libs"
                   2519:            if test "X$duplicate_deps" = "Xyes" ; then
                   2520:              case "$tmp_libs " in
                   2521:              *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
                   2522:              esac
                   2523:            fi
                   2524:            tmp_libs="$tmp_libs $deplib"
                   2525:          done
                   2526: 
                   2527:          if test "$link_all_deplibs" != no; then
                   2528:            # Add the search paths of all dependency libraries
                   2529:            for deplib in $dependency_libs; do
                   2530:              case $deplib in
                   2531:              -L*) path="$deplib" ;;
                   2532:              *.la)
                   2533:                dir=`$echo "X$deplib" | $Xsed -e 's%/[^/]*$%%'`
                   2534:                test "X$dir" = "X$deplib" && dir="."
                   2535:                # We need an absolute path.
                   2536:                case $dir in
                   2537:                [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
                   2538:                *)
                   2539:                  absdir=`cd "$dir" && pwd`
                   2540:                  if test -z "$absdir"; then
                   2541:                    $echo "$modename: warning: cannot determine absolute directory name of \`$dir'" 1>&2
                   2542:                    absdir="$dir"
                   2543:                  fi
                   2544:                  ;;
                   2545:                esac
                   2546:                if grep "^installed=no" $deplib > /dev/null; then
                   2547:                  path="$absdir/$objdir"
                   2548:                else
                   2549:                  eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
                   2550:                  if test -z "$libdir"; then
                   2551:                    $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
                   2552:                    exit 1
                   2553:                  fi
                   2554:                  if test "$absdir" != "$libdir"; then
                   2555:                    $echo "$modename: warning: \`$deplib' seems to be moved" 1>&2
                   2556:                  fi
                   2557:                  path="$absdir"
                   2558:                fi
                   2559:                depdepl=
                   2560:                case $host in
                   2561:                *-*-darwin*)
                   2562:                  # we do not want to link against static libs, but need to link against shared
                   2563:                  eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
                   2564:                  if test -n "$deplibrary_names" ; then
                   2565:                    for tmp in $deplibrary_names ; do
                   2566:                      depdepl=$tmp
                   2567:                    done
                   2568:                    if test -f "$path/$depdepl" ; then
                   2569:                      depdepl="$path/$depdepl"
                   2570:                   fi
                   2571:                    newlib_search_path="$newlib_search_path $path"
                   2572:                    path=""
                   2573:                  fi
                   2574:                  ;;
                   2575:                *)
                   2576:                path="-L$path"
                   2577:                ;;
                   2578:                esac 
                   2579:                
                   2580:                ;;
                   2581:                  -l*)
                   2582:                case $host in
                   2583:                *-*-darwin*)
                   2584:                 # Again, we only want to link against shared libraries
                   2585:                 eval tmp_libs=`$echo "X$deplib" | $Xsed -e "s,^\-l,,"`
                   2586:                 for tmp in $newlib_search_path ; do
                   2587:                     if test -f "$tmp/lib$tmp_libs.dylib" ; then
                   2588:                       eval depdepl="$tmp/lib$tmp_libs.dylib"
                   2589:                       break
                   2590:                     fi  
                   2591:          done
                   2592:          path=""
                   2593:                  ;;
                   2594:                *) continue ;;
                   2595:                esac              
                   2596:                ;;
                   2597:              *) continue ;;
                   2598:              esac
                   2599:              case " $deplibs " in
                   2600:              *" $depdepl "*) ;;
                   2601:              *) deplibs="$deplibs $depdepl" ;;
                   2602:              esac            
                   2603:              case " $deplibs " in
                   2604:              *" $path "*) ;;
                   2605:              *) deplibs="$deplibs $path" ;;
                   2606:              esac
                   2607:            done
                   2608:          fi # link_all_deplibs != no
                   2609:        fi # linkmode = lib
                   2610:       done # for deplib in $libs
                   2611:       dependency_libs="$newdependency_libs"
                   2612:       if test "$pass" = dlpreopen; then
                   2613:        # Link the dlpreopened libraries before other libraries
                   2614:        for deplib in $save_deplibs; do
                   2615:          deplibs="$deplib $deplibs"
                   2616:        done
                   2617:       fi
                   2618:       if test "$pass" != dlopen; then
                   2619:        if test "$pass" != conv; then
                   2620:          # Make sure lib_search_path contains only unique directories.
                   2621:          lib_search_path=
                   2622:          for dir in $newlib_search_path; do
                   2623:            case "$lib_search_path " in
                   2624:            *" $dir "*) ;;
                   2625:            *) lib_search_path="$lib_search_path $dir" ;;
                   2626:            esac
                   2627:          done
                   2628:          newlib_search_path=
                   2629:        fi
                   2630: 
                   2631:        if test "$linkmode,$pass" != "prog,link"; then
                   2632:          vars="deplibs"
                   2633:        else
                   2634:          vars="compile_deplibs finalize_deplibs"
                   2635:        fi
                   2636:        for var in $vars dependency_libs; do
                   2637:          # Add libraries to $var in reverse order
                   2638:          eval tmp_libs=\"\$$var\"
                   2639:          new_libs=
                   2640:          for deplib in $tmp_libs; do
                   2641:            # FIXME: Pedantically, this is the right thing to do, so
                   2642:            #        that some nasty dependency loop isn't accidentally
                   2643:            #        broken:
                   2644:            #new_libs="$deplib $new_libs"
                   2645:            # Pragmatically, this seems to cause very few problems in
                   2646:            # practice:
                   2647:            case $deplib in
                   2648:            -L*) new_libs="$deplib $new_libs" ;;
                   2649:            -R*) ;;
                   2650:            *)
                   2651:              # And here is the reason: when a library appears more
                   2652:              # than once as an explicit dependence of a library, or
                   2653:              # is implicitly linked in more than once by the
                   2654:              # compiler, it is considered special, and multiple
                   2655:              # occurrences thereof are not removed.  Compare this
                   2656:              # with having the same library being listed as a
                   2657:              # dependency of multiple other libraries: in this case,
                   2658:              # we know (pedantically, we assume) the library does not
                   2659:              # need to be listed more than once, so we keep only the
                   2660:              # last copy.  This is not always right, but it is rare
                   2661:              # enough that we require users that really mean to play
                   2662:              # such unportable linking tricks to link the library
                   2663:              # using -Wl,-lname, so that libtool does not consider it
                   2664:              # for duplicate removal.
                   2665:              case " $specialdeplibs " in
                   2666:              *" $deplib "*) new_libs="$deplib $new_libs" ;;
                   2667:              *)
                   2668:                case " $new_libs " in
                   2669:                *" $deplib "*) ;;
                   2670:                *) new_libs="$deplib $new_libs" ;;
                   2671:                esac
                   2672:                ;;
                   2673:              esac
                   2674:              ;;
                   2675:            esac
                   2676:          done
                   2677:          tmp_libs=
                   2678:          for deplib in $new_libs; do
                   2679:            case $deplib in
                   2680:            -L*)
                   2681:              case " $tmp_libs " in
                   2682:              *" $deplib "*) ;;
                   2683:              *) tmp_libs="$tmp_libs $deplib" ;;
                   2684:              esac
                   2685:              ;;
                   2686:            *) tmp_libs="$tmp_libs $deplib" ;;
                   2687:            esac
                   2688:          done
                   2689:          eval $var=\"$tmp_libs\"
                   2690:        done # for var
                   2691:       fi
                   2692:       # Last step: remove runtime libs from dependency_libs (they stay in deplibs)
                   2693:       tmp_libs=
                   2694:       for i in $dependency_libs ; do
                   2695:        case " $predeps $postdeps $compiler_lib_search_path " in
                   2696:        *" $i "*)
                   2697:          i=""
                   2698:          ;;
                   2699:        esac
                   2700:        if test -n "$i" ; then
                   2701:          tmp_libs="$tmp_libs $i"
                   2702:        fi
                   2703:       done
                   2704:       dependency_libs=$tmp_libs
                   2705:     done # for pass
                   2706:     if test "$linkmode" = prog; then
                   2707:       dlfiles="$newdlfiles"
                   2708:       dlprefiles="$newdlprefiles"
                   2709:     fi
                   2710: 
                   2711:     case $linkmode in
                   2712:     oldlib)
                   2713:       if test -n "$deplibs"; then
                   2714:        $echo "$modename: warning: \`-l' and \`-L' are ignored for archives" 1>&2
                   2715:       fi
                   2716: 
                   2717:       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
                   2718:        $echo "$modename: warning: \`-dlopen' is ignored for archives" 1>&2
                   2719:       fi
                   2720: 
                   2721:       if test -n "$rpath"; then
                   2722:        $echo "$modename: warning: \`-rpath' is ignored for archives" 1>&2
                   2723:       fi
                   2724: 
                   2725:       if test -n "$xrpath"; then
                   2726:        $echo "$modename: warning: \`-R' is ignored for archives" 1>&2
                   2727:       fi
                   2728: 
                   2729:       if test -n "$vinfo"; then
                   2730:        $echo "$modename: warning: \`-version-info/-version-number' is ignored for archives" 1>&2
                   2731:       fi
                   2732: 
                   2733:       if test -n "$release"; then
                   2734:        $echo "$modename: warning: \`-release' is ignored for archives" 1>&2
                   2735:       fi
                   2736: 
                   2737:       if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
                   2738:        $echo "$modename: warning: \`-export-symbols' is ignored for archives" 1>&2
                   2739:       fi
                   2740: 
                   2741:       # Now set the variables for building old libraries.
                   2742:       build_libtool_libs=no
                   2743:       oldlibs="$output"
                   2744:       objs="$objs$old_deplibs"
                   2745:       ;;
                   2746: 
                   2747:     lib)
                   2748:       # Make sure we only generate libraries of the form `libNAME.la'.
                   2749:       case $outputname in
                   2750:       lib*)
                   2751:        name=`$echo "X$outputname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
                   2752:        eval shared_ext=\"$shrext\"
                   2753:        eval libname=\"$libname_spec\"
                   2754:        ;;
                   2755:       *)
                   2756:        if test "$module" = no; then
                   2757:          $echo "$modename: libtool library \`$output' must begin with \`lib'" 1>&2
                   2758:          $echo "$help" 1>&2
                   2759:          exit 1
                   2760:        fi
                   2761:        if test "$need_lib_prefix" != no; then
                   2762:          # Add the "lib" prefix for modules if required
                   2763:          name=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
                   2764:          eval shared_ext=\"$shrext\"
                   2765:          eval libname=\"$libname_spec\"
                   2766:        else
                   2767:          libname=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
                   2768:        fi
                   2769:        ;;
                   2770:       esac
                   2771: 
                   2772:       if test -n "$objs"; then
                   2773:        if test "$deplibs_check_method" != pass_all; then
                   2774:          $echo "$modename: cannot build libtool library \`$output' from non-libtool objects on this host:$objs" 2>&1
                   2775:          exit 1
                   2776:        else
                   2777:          $echo
                   2778:          $echo "*** Warning: Linking the shared library $output against the non-libtool"
                   2779:          $echo "*** objects $objs is not portable!"
                   2780:          libobjs="$libobjs $objs"
                   2781:        fi
                   2782:       fi
                   2783: 
                   2784:       if test "$dlself" != no; then
                   2785:        $echo "$modename: warning: \`-dlopen self' is ignored for libtool libraries" 1>&2
                   2786:       fi
                   2787: 
                   2788:       set dummy $rpath
                   2789:       if test "$#" -gt 2; then
                   2790:        $echo "$modename: warning: ignoring multiple \`-rpath's for a libtool library" 1>&2
                   2791:       fi
                   2792:       install_libdir="$2"
                   2793: 
                   2794:       oldlibs=
                   2795:       if test -z "$rpath"; then
                   2796:        if test "$build_libtool_libs" = yes; then
                   2797:          # Building a libtool convenience library.
                   2798:          # Some compilers have problems with a `.al' extension so
                   2799:          # convenience libraries should have the same extension an
                   2800:          # archive normally would.
                   2801:          oldlibs="$output_objdir/$libname.$libext $oldlibs"
                   2802:          build_libtool_libs=convenience
                   2803:          build_old_libs=yes
                   2804:        fi
                   2805: 
                   2806:        if test -n "$vinfo"; then
                   2807:          $echo "$modename: warning: \`-version-info/-version-number' is ignored for convenience libraries" 1>&2
                   2808:        fi
                   2809: 
                   2810:        if test -n "$release"; then
                   2811:          $echo "$modename: warning: \`-release' is ignored for convenience libraries" 1>&2
                   2812:        fi
                   2813:       else
                   2814: 
                   2815:        # Parse the version information argument.
                   2816:        save_ifs="$IFS"; IFS=':'
                   2817:        set dummy $vinfo 0 0 0
                   2818:        IFS="$save_ifs"
                   2819: 
                   2820:        if test -n "$8"; then
                   2821:          $echo "$modename: too many parameters to \`-version-info'" 1>&2
                   2822:          $echo "$help" 1>&2
                   2823:          exit 1
                   2824:        fi
                   2825: 
                   2826:        # convert absolute version numbers to libtool ages
                   2827:        # this retains compatibility with .la files and attempts
                   2828:        # to make the code below a bit more comprehensible
                   2829:        
                   2830:        case $vinfo_number in
                   2831:        yes)
                   2832:          number_major="$2"
                   2833:          number_minor="$3"
                   2834:          number_revision="$4"
                   2835:          #
                   2836:          # There are really only two kinds -- those that
                   2837:          # use the current revision as the major version
                   2838:          # and those that subtract age and use age as
                   2839:          # a minor version.  But, then there is irix
                   2840:          # which has an extra 1 added just for fun
                   2841:          #
                   2842:          case $version_type in
                   2843:          darwin|linux|osf|windows)
                   2844:            current=`expr $number_major + $number_minor`
                   2845:            age="$number_minor"
                   2846:            revision="$number_revision"
                   2847:            ;;
                   2848:          freebsd-aout|freebsd-elf|sunos)
                   2849:            current="$number_major"
                   2850:            revision="$number_minor"
                   2851:            age="0"
                   2852:            ;;
                   2853:          irix|nonstopux)
                   2854:            current=`expr $number_major + $number_minor - 1`
                   2855:            age="$number_minor"
                   2856:            revision="$number_minor"
                   2857:            ;;
                   2858:          esac
                   2859:          ;;
                   2860:        no)
                   2861:          current="$2"
                   2862:          revision="$3"
                   2863:          age="$4"
                   2864:          ;;
                   2865:        esac
                   2866: 
                   2867:        # Check that each of the things are valid numbers.
                   2868:        case $current in
                   2869:        0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;
                   2870:        *)
                   2871:          $echo "$modename: CURRENT \`$current' is not a nonnegative integer" 1>&2
                   2872:          $echo "$modename: \`$vinfo' is not valid version information" 1>&2
                   2873:          exit 1
                   2874:          ;;
                   2875:        esac
                   2876: 
                   2877:        case $revision in
                   2878:        0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;
                   2879:        *)
                   2880:          $echo "$modename: REVISION \`$revision' is not a nonnegative integer" 1>&2
                   2881:          $echo "$modename: \`$vinfo' is not valid version information" 1>&2
                   2882:          exit 1
                   2883:          ;;
                   2884:        esac
                   2885: 
                   2886:        case $age in
                   2887:        0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;
                   2888:        *)
                   2889:          $echo "$modename: AGE \`$age' is not a nonnegative integer" 1>&2
                   2890:          $echo "$modename: \`$vinfo' is not valid version information" 1>&2
                   2891:          exit 1
                   2892:          ;;
                   2893:        esac
                   2894: 
                   2895:        if test "$age" -gt "$current"; then
                   2896:          $echo "$modename: AGE \`$age' is greater than the current interface number \`$current'" 1>&2
                   2897:          $echo "$modename: \`$vinfo' is not valid version information" 1>&2
                   2898:          exit 1
                   2899:        fi
                   2900: 
                   2901:        # Calculate the version variables.
                   2902:        major=
                   2903:        versuffix=
                   2904:        verstring=
                   2905:        case $version_type in
                   2906:        none) ;;
                   2907: 
                   2908:        darwin)
                   2909:          # Like Linux, but with the current version available in
                   2910:          # verstring for coding it into the library header
                   2911:          major=.`expr $current - $age`
                   2912:          versuffix="$major.$age.$revision"
                   2913:          # Darwin ld doesn't like 0 for these options...
                   2914:          minor_current=`expr $current + 1`
                   2915:          verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
                   2916:          ;;
                   2917: 
                   2918:        freebsd-aout)
                   2919:          major=".$current"
                   2920:          versuffix=".$current.$revision";
                   2921:          ;;
                   2922: 
                   2923:        freebsd-elf)
                   2924:          major=".$current"
                   2925:          versuffix=".$current";
                   2926:          ;;
                   2927: 
                   2928:        irix | nonstopux)
                   2929:          major=`expr $current - $age + 1`
                   2930: 
                   2931:          case $version_type in
                   2932:            nonstopux) verstring_prefix=nonstopux ;;
                   2933:            *)         verstring_prefix=sgi ;;
                   2934:          esac
                   2935:          verstring="$verstring_prefix$major.$revision"
                   2936: 
                   2937:          # Add in all the interfaces that we are compatible with.
                   2938:          loop=$revision
                   2939:          while test "$loop" -ne 0; do
                   2940:            iface=`expr $revision - $loop`
                   2941:            loop=`expr $loop - 1`
                   2942:            verstring="$verstring_prefix$major.$iface:$verstring"
                   2943:          done
                   2944: 
                   2945:          # Before this point, $major must not contain `.'.
                   2946:          major=.$major
                   2947:          versuffix="$major.$revision"
                   2948:          ;;
                   2949: 
                   2950:        linux)
                   2951:          major=.`expr $current - $age`
                   2952:          versuffix="$major.$age.$revision"
                   2953:          ;;
                   2954: 
                   2955:        osf)
                   2956:          major=.`expr $current - $age`
                   2957:          versuffix=".$current.$age.$revision"
                   2958:          verstring="$current.$age.$revision"
                   2959: 
                   2960:          # Add in all the interfaces that we are compatible with.
                   2961:          loop=$age
                   2962:          while test "$loop" -ne 0; do
                   2963:            iface=`expr $current - $loop`
                   2964:            loop=`expr $loop - 1`
                   2965:            verstring="$verstring:${iface}.0"
                   2966:          done
                   2967: 
                   2968:          # Make executables depend on our current version.
                   2969:          verstring="$verstring:${current}.0"
                   2970:          ;;
                   2971: 
                   2972:        sunos)
                   2973:          major=".$current"
                   2974:          versuffix=".$current.$revision"
                   2975:          ;;
                   2976: 
                   2977:        windows)
                   2978:          # Use '-' rather than '.', since we only want one
                   2979:          # extension on DOS 8.3 filesystems.
                   2980:          major=`expr $current - $age`
                   2981:          versuffix="-$major"
                   2982:          ;;
                   2983: 
                   2984:        *)
                   2985:          $echo "$modename: unknown library version type \`$version_type'" 1>&2
                   2986:          $echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
                   2987:          exit 1
                   2988:          ;;
                   2989:        esac
                   2990: 
                   2991:        # Clear the version info if we defaulted, and they specified a release.
                   2992:        if test -z "$vinfo" && test -n "$release"; then
                   2993:          major=
                   2994:          case $version_type in
                   2995:          darwin)
                   2996:            # we can't check for "0.0" in archive_cmds due to quoting
                   2997:            # problems, so we reset it completely
                   2998:            verstring=
                   2999:            ;;
                   3000:          *)
                   3001:            verstring="0.0"
                   3002:            ;;
                   3003:          esac
                   3004:          if test "$need_version" = no; then
                   3005:            versuffix=
                   3006:          else
                   3007:            versuffix=".0.0"
                   3008:          fi
                   3009:        fi
                   3010: 
                   3011:        # Remove version info from name if versioning should be avoided
                   3012:        if test "$avoid_version" = yes && test "$need_version" = no; then
                   3013:          major=
                   3014:          versuffix=
                   3015:          verstring=""
                   3016:        fi
                   3017: 
                   3018:        # Check to see if the archive will have undefined symbols.
                   3019:        if test "$allow_undefined" = yes; then
                   3020:          if test "$allow_undefined_flag" = unsupported; then
                   3021:            $echo "$modename: warning: undefined symbols not allowed in $host shared libraries" 1>&2
                   3022:            build_libtool_libs=no
                   3023:            build_old_libs=yes
                   3024:          fi
                   3025:        else
                   3026:          # Don't allow undefined symbols.
                   3027:          allow_undefined_flag="$no_undefined_flag"
                   3028:        fi
                   3029:       fi
                   3030: 
                   3031:       if test "$mode" != relink; then
                   3032:        # Remove our outputs, but don't remove object files since they
                   3033:        # may have been created when compiling PIC objects.
                   3034:        removelist=
                   3035:        tempremovelist=`$echo "$output_objdir/*"`
                   3036:        for p in $tempremovelist; do
                   3037:          case $p in
                   3038:            *.$objext)
                   3039:               ;;
                   3040:            $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
                   3041:               removelist="$removelist $p"
                   3042:               ;;
                   3043:            *) ;;
                   3044:          esac
                   3045:        done
                   3046:        if test -n "$removelist"; then
                   3047:          $show "${rm}r $removelist"
                   3048:          $run ${rm}r $removelist
                   3049:        fi
                   3050:       fi
                   3051: 
                   3052:       # Now set the variables for building old libraries.
                   3053:       if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
                   3054:        oldlibs="$oldlibs $output_objdir/$libname.$libext"
                   3055: 
                   3056:        # Transform .lo files to .o files.
                   3057:        oldobjs="$objs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
                   3058:       fi
                   3059: 
                   3060:       # Eliminate all temporary directories.
                   3061:       for path in $notinst_path; do
                   3062:        lib_search_path=`$echo "$lib_search_path " | ${SED} -e 's% $path % %g'`
                   3063:        deplibs=`$echo "$deplibs " | ${SED} -e 's% -L$path % %g'`
                   3064:        dependency_libs=`$echo "$dependency_libs " | ${SED} -e 's% -L$path % %g'`
                   3065:       done
                   3066: 
                   3067:       if test -n "$xrpath"; then
                   3068:        # If the user specified any rpath flags, then add them.
                   3069:        temp_xrpath=
                   3070:        for libdir in $xrpath; do
                   3071:          temp_xrpath="$temp_xrpath -R$libdir"
                   3072:          case "$finalize_rpath " in
                   3073:          *" $libdir "*) ;;
                   3074:          *) finalize_rpath="$finalize_rpath $libdir" ;;
                   3075:          esac
                   3076:        done
                   3077:        if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
                   3078:          dependency_libs="$temp_xrpath $dependency_libs"
                   3079:        fi
                   3080:       fi
                   3081: 
                   3082:       # Make sure dlfiles contains only unique files that won't be dlpreopened
                   3083:       old_dlfiles="$dlfiles"
                   3084:       dlfiles=
                   3085:       for lib in $old_dlfiles; do
                   3086:        case " $dlprefiles $dlfiles " in
                   3087:        *" $lib "*) ;;
                   3088:        *) dlfiles="$dlfiles $lib" ;;
                   3089:        esac
                   3090:       done
                   3091: 
                   3092:       # Make sure dlprefiles contains only unique files
                   3093:       old_dlprefiles="$dlprefiles"
                   3094:       dlprefiles=
                   3095:       for lib in $old_dlprefiles; do
                   3096:        case "$dlprefiles " in
                   3097:        *" $lib "*) ;;
                   3098:        *) dlprefiles="$dlprefiles $lib" ;;
                   3099:        esac
                   3100:       done
                   3101: 
                   3102:       if test "$build_libtool_libs" = yes; then
                   3103:        if test -n "$rpath"; then
                   3104:          case $host in
                   3105:          *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos*)
                   3106:            # these systems don't actually have a c library (as such)!
                   3107:            ;;
                   3108:          *-*-rhapsody* | *-*-darwin1.[012])
                   3109:            # Rhapsody C library is in the System framework
                   3110:            deplibs="$deplibs -framework System"
                   3111:            ;;
                   3112:          *-*-netbsd*)
                   3113:            # Don't link with libc until the a.out ld.so is fixed.
                   3114:            ;;
                   3115:          *-*-openbsd* | *-*-freebsd*)
                   3116:            # Do not include libc due to us having libc/libc_r.
                   3117:            test "X$arg" = "X-lc" && continue
                   3118:            ;;
                   3119:          *)
                   3120:            # Add libc to deplibs on all other systems if necessary.
                   3121:            if test "$build_libtool_need_lc" = "yes"; then
                   3122:              deplibs="$deplibs -lc"
                   3123:            fi
                   3124:            ;;
                   3125:          esac
                   3126:        fi
                   3127: 
                   3128:        # Transform deplibs into only deplibs that can be linked in shared.
                   3129:        name_save=$name
                   3130:        libname_save=$libname
                   3131:        release_save=$release
                   3132:        versuffix_save=$versuffix
                   3133:        major_save=$major
                   3134:        # I'm not sure if I'm treating the release correctly.  I think
                   3135:        # release should show up in the -l (ie -lgmp5) so we don't want to
                   3136:        # add it in twice.  Is that correct?
                   3137:        release=""
                   3138:        versuffix=""
                   3139:        major=""
                   3140:        newdeplibs=
                   3141:        droppeddeps=no
                   3142:        case $deplibs_check_method in
                   3143:        pass_all)
                   3144:          # Don't check for shared/static.  Everything works.
                   3145:          # This might be a little naive.  We might want to check
                   3146:          # whether the library exists or not.  But this is on
                   3147:          # osf3 & osf4 and I'm not really sure... Just
                   3148:          # implementing what was already the behavior.
                   3149:          newdeplibs=$deplibs
                   3150:          ;;
                   3151:        test_compile)
                   3152:          # This code stresses the "libraries are programs" paradigm to its
                   3153:          # limits. Maybe even breaks it.  We compile a program, linking it
                   3154:          # against the deplibs as a proxy for the library.  Then we can check
                   3155:          # whether they linked in statically or dynamically with ldd.
                   3156:          $rm conftest.c
                   3157:          cat > conftest.c <<EOF
                   3158:          int main() { return 0; }
                   3159: EOF
                   3160:          $rm conftest
                   3161:          $LTCC -o conftest conftest.c $deplibs
                   3162:          if test "$?" -eq 0 ; then
                   3163:            ldd_output=`ldd conftest`
                   3164:            for i in $deplibs; do
                   3165:              name="`expr $i : '-l\(.*\)'`"
                   3166:              # If $name is empty we are operating on a -L argument.
                   3167:               if test "$name" != "" && test "$name" -ne "0"; then
                   3168:                if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
                   3169:                  case " $predeps $postdeps " in
                   3170:                  *" $i "*)
                   3171:                    newdeplibs="$newdeplibs $i"
                   3172:                    i=""
                   3173:                    ;;
                   3174:                  esac
                   3175:                fi
                   3176:                if test -n "$i" ; then
                   3177:                  libname=`eval \\$echo \"$libname_spec\"`
                   3178:                  deplib_matches=`eval \\$echo \"$library_names_spec\"`
                   3179:                  set dummy $deplib_matches
                   3180:                  deplib_match=$2
                   3181:                  if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
                   3182:                    newdeplibs="$newdeplibs $i"
                   3183:                  else
                   3184:                    droppeddeps=yes
                   3185:                    $echo
                   3186:                    $echo "*** Warning: dynamic linker does not accept needed library $i."
                   3187:                    $echo "*** I have the capability to make that library automatically link in when"
                   3188:                    $echo "*** you link to this library.  But I can only do this if you have a"
                   3189:                    $echo "*** shared version of the library, which I believe you do not have"
                   3190:                    $echo "*** because a test_compile did reveal that the linker did not use it for"
                   3191:                    $echo "*** its dynamic dependency list that programs get resolved with at runtime."
                   3192:                  fi
                   3193:                fi
                   3194:              else
                   3195:                newdeplibs="$newdeplibs $i"
                   3196:              fi
                   3197:            done
                   3198:          else
                   3199:            # Error occurred in the first compile.  Let's try to salvage
                   3200:            # the situation: Compile a separate program for each library.
                   3201:            for i in $deplibs; do
                   3202:              name="`expr $i : '-l\(.*\)'`"
                   3203:              # If $name is empty we are operating on a -L argument.
                   3204:               if test "$name" != "" && test "$name" != "0"; then
                   3205:                $rm conftest
                   3206:                $LTCC -o conftest conftest.c $i
                   3207:                # Did it work?
                   3208:                if test "$?" -eq 0 ; then
                   3209:                  ldd_output=`ldd conftest`
                   3210:                  if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
                   3211:                    case " $predeps $postdeps " in
                   3212:                    *" $i "*)
                   3213:                      newdeplibs="$newdeplibs $i"
                   3214:                      i=""
                   3215:                      ;;
                   3216:                    esac
                   3217:                  fi
                   3218:                  if test -n "$i" ; then
                   3219:                    libname=`eval \\$echo \"$libname_spec\"`
                   3220:                    deplib_matches=`eval \\$echo \"$library_names_spec\"`
                   3221:                    set dummy $deplib_matches
                   3222:                    deplib_match=$2
                   3223:                    if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
                   3224:                      newdeplibs="$newdeplibs $i"
                   3225:                    else
                   3226:                      droppeddeps=yes
                   3227:                      $echo
                   3228:                      $echo "*** Warning: dynamic linker does not accept needed library $i."
                   3229:                      $echo "*** I have the capability to make that library automatically link in when"
                   3230:                      $echo "*** you link to this library.  But I can only do this if you have a"
                   3231:                      $echo "*** shared version of the library, which you do not appear to have"
                   3232:                      $echo "*** because a test_compile did reveal that the linker did not use this one"
                   3233:                      $echo "*** as a dynamic dependency that programs can get resolved with at runtime."
                   3234:                    fi
                   3235:                  fi
                   3236:                else
                   3237:                  droppeddeps=yes
                   3238:                  $echo
                   3239:                  $echo "*** Warning!  Library $i is needed by this library but I was not able to"
                   3240:                  $echo "***  make it link in!  You will probably need to install it or some"
                   3241:                  $echo "*** library that it depends on before this library will be fully"
                   3242:                  $echo "*** functional.  Installing it before continuing would be even better."
                   3243:                fi
                   3244:              else
                   3245:                newdeplibs="$newdeplibs $i"
                   3246:              fi
                   3247:            done
                   3248:          fi
                   3249:          ;;
                   3250:        file_magic*)
                   3251:          set dummy $deplibs_check_method
                   3252:          file_magic_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
                   3253:          for a_deplib in $deplibs; do
                   3254:            name="`expr $a_deplib : '-l\(.*\)'`"
                   3255:            # If $name is empty we are operating on a -L argument.
                   3256:             if test "$name" != "" && test  "$name" != "0"; then
                   3257:              if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
                   3258:                case " $predeps $postdeps " in
                   3259:                *" $a_deplib "*)
                   3260:                  newdeplibs="$newdeplibs $a_deplib"
                   3261:                  a_deplib=""
                   3262:                  ;;
                   3263:                esac
                   3264:              fi
                   3265:              if test -n "$a_deplib" ; then
                   3266:                libname=`eval \\$echo \"$libname_spec\"`
                   3267:                for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
                   3268:                  potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
                   3269:                  for potent_lib in $potential_libs; do
                   3270:                      # Follow soft links.
                   3271:                      if ls -lLd "$potent_lib" 2>/dev/null \
                   3272:                         | grep " -> " >/dev/null; then
                   3273:                        continue
                   3274:                      fi
                   3275:                      # The statement above tries to avoid entering an
                   3276:                      # endless loop below, in case of cyclic links.
                   3277:                      # We might still enter an endless loop, since a link
                   3278:                      # loop can be closed while we follow links,
                   3279:                      # but so what?
                   3280:                      potlib="$potent_lib"
                   3281:                      while test -h "$potlib" 2>/dev/null; do
                   3282:                        potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
                   3283:                        case $potliblink in
                   3284:                        [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
                   3285:                        *) potlib=`$echo "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
                   3286:                        esac
                   3287:                      done
                   3288:                      if eval $file_magic_cmd \"\$potlib\" 2>/dev/null \
                   3289:                         | ${SED} 10q \
                   3290:                         | $EGREP "$file_magic_regex" > /dev/null; then
                   3291:                        newdeplibs="$newdeplibs $a_deplib"
                   3292:                        a_deplib=""
                   3293:                        break 2
                   3294:                      fi
                   3295:                  done
                   3296:                done
                   3297:              fi
                   3298:              if test -n "$a_deplib" ; then
                   3299:                droppeddeps=yes
                   3300:                $echo
                   3301:                $echo "*** Warning: linker path does not have real file for library $a_deplib."
                   3302:                $echo "*** I have the capability to make that library automatically link in when"
                   3303:                $echo "*** you link to this library.  But I can only do this if you have a"
                   3304:                $echo "*** shared version of the library, which you do not appear to have"
                   3305:                $echo "*** because I did check the linker path looking for a file starting"
                   3306:                if test -z "$potlib" ; then
                   3307:                  $echo "*** with $libname but no candidates were found. (...for file magic test)"
                   3308:                else
                   3309:                  $echo "*** with $libname and none of the candidates passed a file format test"
                   3310:                  $echo "*** using a file magic. Last file checked: $potlib"
                   3311:                fi
                   3312:              fi
                   3313:            else
                   3314:              # Add a -L argument.
                   3315:              newdeplibs="$newdeplibs $a_deplib"
                   3316:            fi
                   3317:          done # Gone through all deplibs.
                   3318:          ;;
                   3319:        match_pattern*)
                   3320:          set dummy $deplibs_check_method
                   3321:          match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
                   3322:          for a_deplib in $deplibs; do
                   3323:            name="`expr $a_deplib : '-l\(.*\)'`"
                   3324:            # If $name is empty we are operating on a -L argument.
                   3325:            if test -n "$name" && test "$name" != "0"; then
                   3326:              if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
                   3327:                case " $predeps $postdeps " in
                   3328:                *" $a_deplib "*)
                   3329:                  newdeplibs="$newdeplibs $a_deplib"
                   3330:                  a_deplib=""
                   3331:                  ;;
                   3332:                esac
                   3333:              fi
                   3334:              if test -n "$a_deplib" ; then
                   3335:                libname=`eval \\$echo \"$libname_spec\"`
                   3336:                for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
                   3337:                  potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
                   3338:                  for potent_lib in $potential_libs; do
                   3339:                    potlib="$potent_lib" # see symlink-check above in file_magic test
                   3340:                    if eval $echo \"$potent_lib\" 2>/dev/null \
                   3341:                        | ${SED} 10q \
                   3342:                        | $EGREP "$match_pattern_regex" > /dev/null; then
                   3343:                      newdeplibs="$newdeplibs $a_deplib"
                   3344:                      a_deplib=""
                   3345:                      break 2
                   3346:                    fi
                   3347:                  done
                   3348:                done
                   3349:              fi
                   3350:              if test -n "$a_deplib" ; then
                   3351:                droppeddeps=yes
                   3352:                $echo
                   3353:                $echo "*** Warning: linker path does not have real file for library $a_deplib."
                   3354:                $echo "*** I have the capability to make that library automatically link in when"
                   3355:                $echo "*** you link to this library.  But I can only do this if you have a"
                   3356:                $echo "*** shared version of the library, which you do not appear to have"
                   3357:                $echo "*** because I did check the linker path looking for a file starting"
                   3358:                if test -z "$potlib" ; then
                   3359:                  $echo "*** with $libname but no candidates were found. (...for regex pattern test)"
                   3360:                else
                   3361:                  $echo "*** with $libname and none of the candidates passed a file format test"
                   3362:                  $echo "*** using a regex pattern. Last file checked: $potlib"
                   3363:                fi
                   3364:              fi
                   3365:            else
                   3366:              # Add a -L argument.
                   3367:              newdeplibs="$newdeplibs $a_deplib"
                   3368:            fi
                   3369:          done # Gone through all deplibs.
                   3370:          ;;
                   3371:        none | unknown | *)
                   3372:          newdeplibs=""
                   3373:          tmp_deplibs=`$echo "X $deplibs" | $Xsed -e 's/ -lc$//' \
                   3374:            -e 's/ -[LR][^ ]*//g'`
                   3375:          if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
                   3376:            for i in $predeps $postdeps ; do
                   3377:              # can't use Xsed below, because $i might contain '/'
                   3378:              tmp_deplibs=`$echo "X $tmp_deplibs" | ${SED} -e "1s,^X,," -e "s,$i,,"`
                   3379:            done
                   3380:          fi
                   3381:          if $echo "X $tmp_deplibs" | $Xsed -e 's/[     ]//g' \
                   3382:            | grep . >/dev/null; then
                   3383:            $echo
                   3384:            if test "X$deplibs_check_method" = "Xnone"; then
                   3385:              $echo "*** Warning: inter-library dependencies are not supported in this platform."
                   3386:            else
                   3387:              $echo "*** Warning: inter-library dependencies are not known to be supported."
                   3388:            fi
                   3389:            $echo "*** All declared inter-library dependencies are being dropped."
                   3390:            droppeddeps=yes
                   3391:          fi
                   3392:          ;;
                   3393:        esac
                   3394:        versuffix=$versuffix_save
                   3395:        major=$major_save
                   3396:        release=$release_save
                   3397:        libname=$libname_save
                   3398:        name=$name_save
                   3399: 
                   3400:        case $host in
                   3401:        *-*-rhapsody* | *-*-darwin1.[012])
                   3402:          # On Rhapsody replace the C library is the System framework
                   3403:          newdeplibs=`$echo "X $newdeplibs" | $Xsed -e 's/ -lc / -framework System /'`
                   3404:          ;;
                   3405:        esac
                   3406: 
                   3407:        if test "$droppeddeps" = yes; then
                   3408:          if test "$module" = yes; then
                   3409:            $echo
                   3410:            $echo "*** Warning: libtool could not satisfy all declared inter-library"
                   3411:            $echo "*** dependencies of module $libname.  Therefore, libtool will create"
                   3412:            $echo "*** a static module, that should work as long as the dlopening"
                   3413:            $echo "*** application is linked with the -dlopen flag."
                   3414:            if test -z "$global_symbol_pipe"; then
                   3415:              $echo
                   3416:              $echo "*** However, this would only work if libtool was able to extract symbol"
                   3417:              $echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
                   3418:              $echo "*** not find such a program.  So, this module is probably useless."
                   3419:              $echo "*** \`nm' from GNU binutils and a full rebuild may help."
                   3420:            fi
                   3421:            if test "$build_old_libs" = no; then
                   3422:              oldlibs="$output_objdir/$libname.$libext"
                   3423:              build_libtool_libs=module
                   3424:              build_old_libs=yes
                   3425:            else
                   3426:              build_libtool_libs=no
                   3427:            fi
                   3428:          else
                   3429:            $echo "*** The inter-library dependencies that have been dropped here will be"
                   3430:            $echo "*** automatically added whenever a program is linked with this library"
                   3431:            $echo "*** or is declared to -dlopen it."
                   3432: 
                   3433:            if test "$allow_undefined" = no; then
                   3434:              $echo
                   3435:              $echo "*** Since this library must not contain undefined symbols,"
                   3436:              $echo "*** because either the platform does not support them or"
                   3437:              $echo "*** it was explicitly requested with -no-undefined,"
                   3438:              $echo "*** libtool will only create a static version of it."
                   3439:              if test "$build_old_libs" = no; then
                   3440:                oldlibs="$output_objdir/$libname.$libext"
                   3441:                build_libtool_libs=module
                   3442:                build_old_libs=yes
                   3443:              else
                   3444:                build_libtool_libs=no
                   3445:              fi
                   3446:            fi
                   3447:          fi
                   3448:        fi
                   3449:        # Done checking deplibs!
                   3450:        deplibs=$newdeplibs
                   3451:       fi
                   3452: 
                   3453:       # All the library-specific variables (install_libdir is set above).
                   3454:       library_names=
                   3455:       old_library=
                   3456:       dlname=
                   3457: 
                   3458:       # Test again, we may have decided not to build it any more
                   3459:       if test "$build_libtool_libs" = yes; then
                   3460:        if test "$hardcode_into_libs" = yes; then
                   3461:          # Hardcode the library paths
                   3462:          hardcode_libdirs=
                   3463:          dep_rpath=
                   3464:          rpath="$finalize_rpath"
                   3465:          test "$mode" != relink && rpath="$compile_rpath$rpath"
                   3466:          for libdir in $rpath; do
                   3467:            if test -n "$hardcode_libdir_flag_spec"; then
                   3468:              if test -n "$hardcode_libdir_separator"; then
                   3469:                if test -z "$hardcode_libdirs"; then
                   3470:                  hardcode_libdirs="$libdir"
                   3471:                else
                   3472:                  # Just accumulate the unique libdirs.
                   3473:                  case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
                   3474:                  *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
                   3475:                    ;;
                   3476:                  *)
                   3477:                    hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
                   3478:                    ;;
                   3479:                  esac
                   3480:                fi
                   3481:              else
                   3482:                eval flag=\"$hardcode_libdir_flag_spec\"
                   3483:                dep_rpath="$dep_rpath $flag"
                   3484:              fi
                   3485:            elif test -n "$runpath_var"; then
                   3486:              case "$perm_rpath " in
                   3487:              *" $libdir "*) ;;
                   3488:              *) perm_rpath="$perm_rpath $libdir" ;;
                   3489:              esac
                   3490:            fi
                   3491:          done
                   3492:          # Substitute the hardcoded libdirs into the rpath.
                   3493:          if test -n "$hardcode_libdir_separator" &&
                   3494:             test -n "$hardcode_libdirs"; then
                   3495:            libdir="$hardcode_libdirs"
                   3496:            if test -n "$hardcode_libdir_flag_spec_ld"; then
                   3497:              eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\"
                   3498:            else
                   3499:              eval dep_rpath=\"$hardcode_libdir_flag_spec\"
                   3500:            fi
                   3501:          fi
                   3502:          if test -n "$runpath_var" && test -n "$perm_rpath"; then
                   3503:            # We should set the runpath_var.
                   3504:            rpath=
                   3505:            for dir in $perm_rpath; do
                   3506:              rpath="$rpath$dir:"
                   3507:            done
                   3508:            eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
                   3509:          fi
                   3510:          test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
                   3511:        fi
                   3512: 
                   3513:        shlibpath="$finalize_shlibpath"
                   3514:        test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
                   3515:        if test -n "$shlibpath"; then
                   3516:          eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
                   3517:        fi
                   3518: 
                   3519:        # Get the real and link names of the library.
                   3520:        eval shared_ext=\"$shrext\"
                   3521:        eval library_names=\"$library_names_spec\"
                   3522:        set dummy $library_names
                   3523:        realname="$2"
                   3524:        shift; shift
                   3525: 
                   3526:        if test -n "$soname_spec"; then
                   3527:          eval soname=\"$soname_spec\"
                   3528:        else
                   3529:          soname="$realname"
                   3530:        fi
                   3531:        if test -z "$dlname"; then
                   3532:          dlname=$soname
                   3533:        fi
                   3534: 
                   3535:        lib="$output_objdir/$realname"
                   3536:        for link
                   3537:        do
                   3538:          linknames="$linknames $link"
                   3539:        done
                   3540: 
                   3541:        # Use standard objects if they are pic
                   3542:        test -z "$pic_flag" && libobjs=`$echo "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
                   3543: 
                   3544:        # Prepare the list of exported symbols
                   3545:        if test -z "$export_symbols"; then
                   3546:          if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
                   3547:            $show "generating symbol list for \`$libname.la'"
                   3548:            export_symbols="$output_objdir/$libname.exp"
                   3549:            $run $rm $export_symbols
                   3550:            eval cmds=\"$export_symbols_cmds\"
                   3551:            save_ifs="$IFS"; IFS='~'
                   3552:            for cmd in $cmds; do
                   3553:              IFS="$save_ifs"
                   3554:              if len=`expr "X$cmd" : ".*"` &&
                   3555:               test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
                   3556:                $show "$cmd"
                   3557:                $run eval "$cmd" || exit $?
                   3558:                skipped_export=false
                   3559:              else
                   3560:                # The command line is too long to execute in one step.
                   3561:                $show "using reloadable object file for export list..."
                   3562:                skipped_export=:
                   3563:              fi
                   3564:            done
                   3565:            IFS="$save_ifs"
                   3566:            if test -n "$export_symbols_regex"; then
                   3567:              $show "$EGREP -e \"$export_symbols_regex\" \"$export_symbols\" > \"${export_symbols}T\""
                   3568:              $run eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
                   3569:              $show "$mv \"${export_symbols}T\" \"$export_symbols\""
                   3570:              $run eval '$mv "${export_symbols}T" "$export_symbols"'
                   3571:            fi
                   3572:          fi
                   3573:        fi
                   3574: 
                   3575:        if test -n "$export_symbols" && test -n "$include_expsyms"; then
                   3576:          $run eval '$echo "X$include_expsyms" | $SP2NL >> "$export_symbols"'
                   3577:        fi
                   3578: 
                   3579:        tmp_deplibs=
                   3580:        for test_deplib in $deplibs; do
                   3581:                case " $convenience " in
                   3582:                *" $test_deplib "*) ;;
                   3583:                *) 
                   3584:                        tmp_deplibs="$tmp_deplibs $test_deplib"
                   3585:                        ;;
                   3586:                esac
                   3587:        done
                   3588:        deplibs="$tmp_deplibs" 
                   3589: 
                   3590:        if test -n "$convenience"; then
                   3591:          if test -n "$whole_archive_flag_spec"; then
                   3592:            save_libobjs=$libobjs
                   3593:            eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
                   3594:          else
                   3595:            gentop="$output_objdir/${outputname}x"
                   3596:            $show "${rm}r $gentop"
                   3597:            $run ${rm}r "$gentop"
                   3598:            $show "$mkdir $gentop"
                   3599:            $run $mkdir "$gentop"
                   3600:            status=$?
                   3601:            if test "$status" -ne 0 && test ! -d "$gentop"; then
                   3602:              exit $status
                   3603:            fi
                   3604:            generated="$generated $gentop"
                   3605: 
                   3606:            for xlib in $convenience; do
                   3607:              # Extract the objects.
                   3608:              case $xlib in
                   3609:              [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;
                   3610:              *) xabs=`pwd`"/$xlib" ;;
                   3611:              esac
                   3612:              xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
                   3613:              xdir="$gentop/$xlib"
                   3614: 
                   3615:              $show "${rm}r $xdir"
                   3616:              $run ${rm}r "$xdir"
                   3617:              $show "$mkdir $xdir"
                   3618:              $run $mkdir "$xdir"
                   3619:              status=$?
                   3620:              if test "$status" -ne 0 && test ! -d "$xdir"; then
                   3621:                exit $status
                   3622:              fi
                   3623:              # We will extract separately just the conflicting names and we will no
                   3624:              # longer touch any unique names. It is faster to leave these extract
                   3625:              # automatically by $AR in one run.
                   3626:              $show "(cd $xdir && $AR x $xabs)"
                   3627:              $run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
                   3628:              if ($AR t "$xabs" | sort | sort -uc >/dev/null 2>&1); then
                   3629:                :
                   3630:              else
                   3631:                $echo "$modename: warning: object name conflicts; renaming object files" 1>&2
                   3632:                $echo "$modename: warning: to ensure that they will not overwrite" 1>&2
                   3633:                $AR t "$xabs" | sort | uniq -cd | while read -r count name
                   3634:                do
                   3635:                  i=1
                   3636:                  while test "$i" -le "$count"
                   3637:                  do
                   3638:                   # Put our $i before any first dot (extension)
                   3639:                   # Never overwrite any file
                   3640:                   name_to="$name"
                   3641:                   while test "X$name_to" = "X$name" || test -f "$xdir/$name_to"
                   3642:                   do
                   3643:                     name_to=`$echo "X$name_to" | $Xsed -e "s/\([^.]*\)/\1-$i/"`
                   3644:                   done
                   3645:                   $show "(cd $xdir && $AR xN $i $xabs '$name' && $mv '$name' '$name_to')"
                   3646:                   $run eval "(cd \$xdir && $AR xN $i \$xabs '$name' && $mv '$name' '$name_to')" || exit $?
                   3647:                   i=`expr $i + 1`
                   3648:                  done
                   3649:                done
                   3650:              fi
                   3651: 
                   3652:              libobjs="$libobjs "`find $xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
                   3653:            done
                   3654:          fi
                   3655:        fi
                   3656: 
                   3657:        if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
                   3658:          eval flag=\"$thread_safe_flag_spec\"
                   3659:          linker_flags="$linker_flags $flag"
                   3660:        fi
                   3661: 
                   3662:        # Make a backup of the uninstalled library when relinking
                   3663:        if test "$mode" = relink; then
                   3664:          $run eval '(cd $output_objdir && $rm ${realname}U && $mv $realname ${realname}U)' || exit $?
                   3665:        fi
                   3666: 
                   3667:        # Do each of the archive commands.
                   3668:        if test "$module" = yes && test -n "$module_cmds" ; then
                   3669:          if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
                   3670:            eval cmds=\"$module_expsym_cmds\"
                   3671:          else
                   3672:            eval cmds=\"$module_cmds\"
                   3673:          fi
                   3674:        else
                   3675:        if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
                   3676:          eval cmds=\"$archive_expsym_cmds\"
                   3677:        else
                   3678:          eval cmds=\"$archive_cmds\"
                   3679:          fi
                   3680:        fi
                   3681: 
                   3682:        if test "X$skipped_export" != "X:" && len=`expr "X$cmds" : ".*"` &&
                   3683:           test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
                   3684:          :
                   3685:        else
                   3686:          # The command line is too long to link in one step, link piecewise.
                   3687:          $echo "creating reloadable object files..."
                   3688: 
                   3689:          # Save the value of $output and $libobjs because we want to
                   3690:          # use them later.  If we have whole_archive_flag_spec, we
                   3691:          # want to use save_libobjs as it was before
                   3692:          # whole_archive_flag_spec was expanded, because we can't
                   3693:          # assume the linker understands whole_archive_flag_spec.
                   3694:          # This may have to be revisited, in case too many
                   3695:          # convenience libraries get linked in and end up exceeding
                   3696:          # the spec.
                   3697:          if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
                   3698:            save_libobjs=$libobjs
                   3699:          fi
                   3700:          save_output=$output
                   3701: 
                   3702:          # Clear the reloadable object creation command queue and
                   3703:          # initialize k to one.
                   3704:          test_cmds=
                   3705:          concat_cmds=
                   3706:          objlist=
                   3707:          delfiles=
                   3708:          last_robj=
                   3709:          k=1
                   3710:          output=$output_objdir/$save_output-${k}.$objext
                   3711:          # Loop over the list of objects to be linked.
                   3712:          for obj in $save_libobjs
                   3713:          do
                   3714:            eval test_cmds=\"$reload_cmds $objlist $last_robj\"
                   3715:            if test "X$objlist" = X ||
                   3716:               { len=`expr "X$test_cmds" : ".*"` &&
                   3717:                 test "$len" -le "$max_cmd_len"; }; then
                   3718:              objlist="$objlist $obj"
                   3719:            else
                   3720:              # The command $test_cmds is almost too long, add a
                   3721:              # command to the queue.
                   3722:              if test "$k" -eq 1 ; then
                   3723:                # The first file doesn't have a previous command to add.
                   3724:                eval concat_cmds=\"$reload_cmds $objlist $last_robj\"
                   3725:              else
                   3726:                # All subsequent reloadable object files will link in
                   3727:                # the last one created.
                   3728:                eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj\"
                   3729:              fi
                   3730:              last_robj=$output_objdir/$save_output-${k}.$objext
                   3731:              k=`expr $k + 1`
                   3732:              output=$output_objdir/$save_output-${k}.$objext
                   3733:              objlist=$obj
                   3734:              len=1
                   3735:            fi
                   3736:          done
                   3737:          # Handle the remaining objects by creating one last
                   3738:          # reloadable object file.  All subsequent reloadable object
                   3739:          # files will link in the last one created.
                   3740:          test -z "$concat_cmds" || concat_cmds=$concat_cmds~
                   3741:          eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"
                   3742: 
                   3743:          if ${skipped_export-false}; then
                   3744:            $show "generating symbol list for \`$libname.la'"
                   3745:            export_symbols="$output_objdir/$libname.exp"
                   3746:            $run $rm $export_symbols
                   3747:            libobjs=$output
                   3748:            # Append the command to create the export file.
                   3749:            eval concat_cmds=\"\$concat_cmds~$export_symbols_cmds\"
                   3750:           fi
                   3751: 
                   3752:          # Set up a command to remove the reloadale object files
                   3753:          # after they are used.
                   3754:          i=0
                   3755:          while test "$i" -lt "$k"
                   3756:          do
                   3757:            i=`expr $i + 1`
                   3758:            delfiles="$delfiles $output_objdir/$save_output-${i}.$objext"
                   3759:          done
                   3760: 
                   3761:          $echo "creating a temporary reloadable object file: $output"
                   3762: 
                   3763:          # Loop through the commands generated above and execute them.
                   3764:          save_ifs="$IFS"; IFS='~'
                   3765:          for cmd in $concat_cmds; do
                   3766:            IFS="$save_ifs"
                   3767:            $show "$cmd"
                   3768:            $run eval "$cmd" || exit $?
                   3769:          done
                   3770:          IFS="$save_ifs"
                   3771: 
                   3772:          libobjs=$output
                   3773:          # Restore the value of output.
                   3774:          output=$save_output
                   3775: 
                   3776:          if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
                   3777:            eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
                   3778:          fi
                   3779:          # Expand the library linking commands again to reset the
                   3780:          # value of $libobjs for piecewise linking.
                   3781: 
                   3782:          # Do each of the archive commands.
                   3783:          if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
                   3784:            eval cmds=\"$archive_expsym_cmds\"
                   3785:          else
                   3786:            eval cmds=\"$archive_cmds\"
                   3787:          fi
                   3788: 
                   3789:          # Append the command to remove the reloadable object files
                   3790:          # to the just-reset $cmds.
                   3791:          eval cmds=\"\$cmds~$rm $delfiles\"
                   3792:        fi
                   3793:        save_ifs="$IFS"; IFS='~'
                   3794:        for cmd in $cmds; do
                   3795:          IFS="$save_ifs"
                   3796:          $show "$cmd"
                   3797:          $run eval "$cmd" || exit $?
                   3798:        done
                   3799:        IFS="$save_ifs"
                   3800: 
                   3801:        # Restore the uninstalled library and exit
                   3802:        if test "$mode" = relink; then
                   3803:          $run eval '(cd $output_objdir && $rm ${realname}T && $mv $realname ${realname}T && $mv "$realname"U $realname)' || exit $?
                   3804:          exit 0
                   3805:        fi
                   3806: 
                   3807:        # Create links to the real library.
                   3808:        for linkname in $linknames; do
                   3809:          if test "$realname" != "$linkname"; then
                   3810:            $show "(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)"
                   3811:            $run eval '(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)' || exit $?
                   3812:          fi
                   3813:        done
                   3814: 
                   3815:        # If -module or -export-dynamic was specified, set the dlname.
                   3816:        if test "$module" = yes || test "$export_dynamic" = yes; then
                   3817:          # On all known operating systems, these are identical.
                   3818:          dlname="$soname"
                   3819:        fi
                   3820:       fi
                   3821:       ;;
                   3822: 
                   3823:     obj)
                   3824:       if test -n "$deplibs"; then
                   3825:        $echo "$modename: warning: \`-l' and \`-L' are ignored for objects" 1>&2
                   3826:       fi
                   3827: 
                   3828:       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
                   3829:        $echo "$modename: warning: \`-dlopen' is ignored for objects" 1>&2
                   3830:       fi
                   3831: 
                   3832:       if test -n "$rpath"; then
                   3833:        $echo "$modename: warning: \`-rpath' is ignored for objects" 1>&2
                   3834:       fi
                   3835: 
                   3836:       if test -n "$xrpath"; then
                   3837:        $echo "$modename: warning: \`-R' is ignored for objects" 1>&2
                   3838:       fi
                   3839: 
                   3840:       if test -n "$vinfo"; then
                   3841:        $echo "$modename: warning: \`-version-info' is ignored for objects" 1>&2
                   3842:       fi
                   3843: 
                   3844:       if test -n "$release"; then
                   3845:        $echo "$modename: warning: \`-release' is ignored for objects" 1>&2
                   3846:       fi
                   3847: 
                   3848:       case $output in
                   3849:       *.lo)
                   3850:        if test -n "$objs$old_deplibs"; then
                   3851:          $echo "$modename: cannot build library object \`$output' from non-libtool objects" 1>&2
                   3852:          exit 1
                   3853:        fi
                   3854:        libobj="$output"
                   3855:        obj=`$echo "X$output" | $Xsed -e "$lo2o"`
                   3856:        ;;
                   3857:       *)
                   3858:        libobj=
                   3859:        obj="$output"
                   3860:        ;;
                   3861:       esac
                   3862: 
                   3863:       # Delete the old objects.
                   3864:       $run $rm $obj $libobj
                   3865: 
                   3866:       # Objects from convenience libraries.  This assumes
                   3867:       # single-version convenience libraries.  Whenever we create
                   3868:       # different ones for PIC/non-PIC, this we'll have to duplicate
                   3869:       # the extraction.
                   3870:       reload_conv_objs=
                   3871:       gentop=
                   3872:       # reload_cmds runs $LD directly, so let us get rid of
                   3873:       # -Wl from whole_archive_flag_spec
                   3874:       wl=
                   3875: 
                   3876:       if test -n "$convenience"; then
                   3877:        if test -n "$whole_archive_flag_spec"; then
                   3878:          eval reload_conv_objs=\"\$reload_objs $whole_archive_flag_spec\"
                   3879:        else
                   3880:          gentop="$output_objdir/${obj}x"
                   3881:          $show "${rm}r $gentop"
                   3882:          $run ${rm}r "$gentop"
                   3883:          $show "$mkdir $gentop"
                   3884:          $run $mkdir "$gentop"
                   3885:          status=$?
                   3886:          if test "$status" -ne 0 && test ! -d "$gentop"; then
                   3887:            exit $status
                   3888:          fi
                   3889:          generated="$generated $gentop"
                   3890: 
                   3891:          for xlib in $convenience; do
                   3892:            # Extract the objects.
                   3893:            case $xlib in
                   3894:            [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;
                   3895:            *) xabs=`pwd`"/$xlib" ;;
                   3896:            esac
                   3897:            xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
                   3898:            xdir="$gentop/$xlib"
                   3899: 
                   3900:            $show "${rm}r $xdir"
                   3901:            $run ${rm}r "$xdir"
                   3902:            $show "$mkdir $xdir"
                   3903:            $run $mkdir "$xdir"
                   3904:            status=$?
                   3905:            if test "$status" -ne 0 && test ! -d "$xdir"; then
                   3906:              exit $status
                   3907:            fi
                   3908:            # We will extract separately just the conflicting names and we will no
                   3909:            # longer touch any unique names. It is faster to leave these extract
                   3910:            # automatically by $AR in one run.
                   3911:            $show "(cd $xdir && $AR x $xabs)"
                   3912:            $run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
                   3913:            if ($AR t "$xabs" | sort | sort -uc >/dev/null 2>&1); then
                   3914:              :
                   3915:            else
                   3916:              $echo "$modename: warning: object name conflicts; renaming object files" 1>&2
                   3917:              $echo "$modename: warning: to ensure that they will not overwrite" 1>&2
                   3918:              $AR t "$xabs" | sort | uniq -cd | while read -r count name
                   3919:              do
                   3920:                i=1
                   3921:                while test "$i" -le "$count"
                   3922:                do
                   3923:                 # Put our $i before any first dot (extension)
                   3924:                 # Never overwrite any file
                   3925:                 name_to="$name"
                   3926:                 while test "X$name_to" = "X$name" || test -f "$xdir/$name_to"
                   3927:                 do
                   3928:                   name_to=`$echo "X$name_to" | $Xsed -e "s/\([^.]*\)/\1-$i/"`
                   3929:                 done
                   3930:                 $show "(cd $xdir && $AR xN $i $xabs '$name' && $mv '$name' '$name_to')"
                   3931:                 $run eval "(cd \$xdir && $AR xN $i \$xabs '$name' && $mv '$name' '$name_to')" || exit $?
                   3932:                 i=`expr $i + 1`
                   3933:                done
                   3934:              done
                   3935:            fi
                   3936: 
                   3937:            reload_conv_objs="$reload_objs "`find $xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
                   3938:          done
                   3939:        fi
                   3940:       fi
                   3941: 
                   3942:       # Create the old-style object.
                   3943:       reload_objs="$objs$old_deplibs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}$'/d' -e '/\.lib$/d' -e "$lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test
                   3944: 
                   3945:       output="$obj"
                   3946:       eval cmds=\"$reload_cmds\"
                   3947:       save_ifs="$IFS"; IFS='~'
                   3948:       for cmd in $cmds; do
                   3949:        IFS="$save_ifs"
                   3950:        $show "$cmd"
                   3951:        $run eval "$cmd" || exit $?
                   3952:       done
                   3953:       IFS="$save_ifs"
                   3954: 
                   3955:       # Exit if we aren't doing a library object file.
                   3956:       if test -z "$libobj"; then
                   3957:        if test -n "$gentop"; then
                   3958:          $show "${rm}r $gentop"
                   3959:          $run ${rm}r $gentop
                   3960:        fi
                   3961: 
                   3962:        exit 0
                   3963:       fi
                   3964: 
                   3965:       if test "$build_libtool_libs" != yes; then
                   3966:        if test -n "$gentop"; then
                   3967:          $show "${rm}r $gentop"
                   3968:          $run ${rm}r $gentop
                   3969:        fi
                   3970: 
                   3971:        # Create an invalid libtool object if no PIC, so that we don't
                   3972:        # accidentally link it into a program.
                   3973:        # $show "echo timestamp > $libobj"
                   3974:        # $run eval "echo timestamp > $libobj" || exit $?
                   3975:        exit 0
                   3976:       fi
                   3977: 
                   3978:       if test -n "$pic_flag" || test "$pic_mode" != default; then
                   3979:        # Only do commands if we really have different PIC objects.
                   3980:        reload_objs="$libobjs $reload_conv_objs"
                   3981:        output="$libobj"
                   3982:        eval cmds=\"$reload_cmds\"
                   3983:        save_ifs="$IFS"; IFS='~'
                   3984:        for cmd in $cmds; do
                   3985:          IFS="$save_ifs"
                   3986:          $show "$cmd"
                   3987:          $run eval "$cmd" || exit $?
                   3988:        done
                   3989:        IFS="$save_ifs"
                   3990:       fi
                   3991: 
                   3992:       if test -n "$gentop"; then
                   3993:        $show "${rm}r $gentop"
                   3994:        $run ${rm}r $gentop
                   3995:       fi
                   3996: 
                   3997:       exit 0
                   3998:       ;;
                   3999: 
                   4000:     prog)
                   4001:       case $host in
                   4002:        *cygwin*) output=`$echo $output | ${SED} -e 's,.exe$,,;s,$,.exe,'` ;;
                   4003:       esac
                   4004:       if test -n "$vinfo"; then
                   4005:        $echo "$modename: warning: \`-version-info' is ignored for programs" 1>&2
                   4006:       fi
                   4007: 
                   4008:       if test -n "$release"; then
                   4009:        $echo "$modename: warning: \`-release' is ignored for programs" 1>&2
                   4010:       fi
                   4011: 
                   4012:       if test "$preload" = yes; then
                   4013:        if test "$dlopen_support" = unknown && test "$dlopen_self" = unknown &&
                   4014:           test "$dlopen_self_static" = unknown; then
                   4015:          $echo "$modename: warning: \`AC_LIBTOOL_DLOPEN' not used. Assuming no dlopen support."
                   4016:        fi
                   4017:       fi
                   4018: 
                   4019:       case $host in
                   4020:       *-*-rhapsody* | *-*-darwin1.[012])
                   4021:        # On Rhapsody replace the C library is the System framework
                   4022:        compile_deplibs=`$echo "X $compile_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
                   4023:        finalize_deplibs=`$echo "X $finalize_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
                   4024:        ;;
                   4025:       esac
                   4026: 
                   4027:       case $host in
                   4028:       *darwin*)
                   4029:         # Don't allow lazy linking, it breaks C++ global constructors
                   4030:         if test "$tagname" = CXX ; then
                   4031:         compile_command="$compile_command ${wl}-bind_at_load"
                   4032:         finalize_command="$finalize_command ${wl}-bind_at_load"
                   4033:         fi
                   4034:         ;;
                   4035:       esac
                   4036: 
                   4037:       compile_command="$compile_command $compile_deplibs"
                   4038:       finalize_command="$finalize_command $finalize_deplibs"
                   4039: 
                   4040:       if test -n "$rpath$xrpath"; then
                   4041:        # If the user specified any rpath flags, then add them.
                   4042:        for libdir in $rpath $xrpath; do
                   4043:          # This is the magic to use -rpath.
                   4044:          case "$finalize_rpath " in
                   4045:          *" $libdir "*) ;;
                   4046:          *) finalize_rpath="$finalize_rpath $libdir" ;;
                   4047:          esac
                   4048:        done
                   4049:       fi
                   4050: 
                   4051:       # Now hardcode the library paths
                   4052:       rpath=
                   4053:       hardcode_libdirs=
                   4054:       for libdir in $compile_rpath $finalize_rpath; do
                   4055:        if test -n "$hardcode_libdir_flag_spec"; then
                   4056:          if test -n "$hardcode_libdir_separator"; then
                   4057:            if test -z "$hardcode_libdirs"; then
                   4058:              hardcode_libdirs="$libdir"
                   4059:            else
                   4060:              # Just accumulate the unique libdirs.
                   4061:              case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
                   4062:              *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
                   4063:                ;;
                   4064:              *)
                   4065:                hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
                   4066:                ;;
                   4067:              esac
                   4068:            fi
                   4069:          else
                   4070:            eval flag=\"$hardcode_libdir_flag_spec\"
                   4071:            rpath="$rpath $flag"
                   4072:          fi
                   4073:        elif test -n "$runpath_var"; then
                   4074:          case "$perm_rpath " in
                   4075:          *" $libdir "*) ;;
                   4076:          *) perm_rpath="$perm_rpath $libdir" ;;
                   4077:          esac
                   4078:        fi
                   4079:        case $host in
                   4080:        *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
                   4081:          case :$dllsearchpath: in
                   4082:          *":$libdir:"*) ;;
                   4083:          *) dllsearchpath="$dllsearchpath:$libdir";;
                   4084:          esac
                   4085:          ;;
                   4086:        esac
                   4087:       done
                   4088:       # Substitute the hardcoded libdirs into the rpath.
                   4089:       if test -n "$hardcode_libdir_separator" &&
                   4090:         test -n "$hardcode_libdirs"; then
                   4091:        libdir="$hardcode_libdirs"
                   4092:        eval rpath=\" $hardcode_libdir_flag_spec\"
                   4093:       fi
                   4094:       compile_rpath="$rpath"
                   4095: 
                   4096:       rpath=
                   4097:       hardcode_libdirs=
                   4098:       for libdir in $finalize_rpath; do
                   4099:        if test -n "$hardcode_libdir_flag_spec"; then
                   4100:          if test -n "$hardcode_libdir_separator"; then
                   4101:            if test -z "$hardcode_libdirs"; then
                   4102:              hardcode_libdirs="$libdir"
                   4103:            else
                   4104:              # Just accumulate the unique libdirs.
                   4105:              case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
                   4106:              *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
                   4107:                ;;
                   4108:              *)
                   4109:                hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
                   4110:                ;;
                   4111:              esac
                   4112:            fi
                   4113:          else
                   4114:            eval flag=\"$hardcode_libdir_flag_spec\"
                   4115:            rpath="$rpath $flag"
                   4116:          fi
                   4117:        elif test -n "$runpath_var"; then
                   4118:          case "$finalize_perm_rpath " in
                   4119:          *" $libdir "*) ;;
                   4120:          *) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;
                   4121:          esac
                   4122:        fi
                   4123:       done
                   4124:       # Substitute the hardcoded libdirs into the rpath.
                   4125:       if test -n "$hardcode_libdir_separator" &&
                   4126:         test -n "$hardcode_libdirs"; then
                   4127:        libdir="$hardcode_libdirs"
                   4128:        eval rpath=\" $hardcode_libdir_flag_spec\"
                   4129:       fi
                   4130:       finalize_rpath="$rpath"
                   4131: 
                   4132:       if test -n "$libobjs" && test "$build_old_libs" = yes; then
                   4133:        # Transform all the library objects into standard objects.
                   4134:        compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
                   4135:        finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
                   4136:       fi
                   4137: 
                   4138:       dlsyms=
                   4139:       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
                   4140:        if test -n "$NM" && test -n "$global_symbol_pipe"; then
                   4141:          dlsyms="${outputname}S.c"
                   4142:        else
                   4143:          $echo "$modename: not configured to extract global symbols from dlpreopened files" 1>&2
                   4144:        fi
                   4145:       fi
                   4146: 
                   4147:       if test -n "$dlsyms"; then
                   4148:        case $dlsyms in
                   4149:        "") ;;
                   4150:        *.c)
                   4151:          # Discover the nlist of each of the dlfiles.
                   4152:          nlist="$output_objdir/${outputname}.nm"
                   4153: 
                   4154:          $show "$rm $nlist ${nlist}S ${nlist}T"
                   4155:          $run $rm "$nlist" "${nlist}S" "${nlist}T"
                   4156: 
                   4157:          # Parse the name list into a source file.
                   4158:          $show "creating $output_objdir/$dlsyms"
                   4159: 
                   4160:          test -z "$run" && $echo > "$output_objdir/$dlsyms" "\
                   4161: /* $dlsyms - symbol resolution table for \`$outputname' dlsym emulation. */
                   4162: /* Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP */
                   4163: 
                   4164: #ifdef __cplusplus
                   4165: extern \"C\" {
                   4166: #endif
                   4167: 
                   4168: /* Prevent the only kind of declaration conflicts we can make. */
                   4169: #define lt_preloaded_symbols some_other_symbol
                   4170: 
                   4171: /* External symbol declarations for the compiler. */\
                   4172: "
                   4173: 
                   4174:          if test "$dlself" = yes; then
                   4175:            $show "generating symbol list for \`$output'"
                   4176: 
                   4177:            test -z "$run" && $echo ': @PROGRAM@ ' > "$nlist"
                   4178: 
                   4179:            # Add our own program objects to the symbol list.
                   4180:            progfiles=`$echo "X$objs$old_deplibs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
                   4181:            for arg in $progfiles; do
                   4182:              $show "extracting global C symbols from \`$arg'"
                   4183:              $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
                   4184:            done
                   4185: 
                   4186:            if test -n "$exclude_expsyms"; then
                   4187:              $run eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
                   4188:              $run eval '$mv "$nlist"T "$nlist"'
                   4189:            fi
                   4190: 
                   4191:            if test -n "$export_symbols_regex"; then
                   4192:              $run eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
                   4193:              $run eval '$mv "$nlist"T "$nlist"'
                   4194:            fi
                   4195: 
                   4196:            # Prepare the list of exported symbols
                   4197:            if test -z "$export_symbols"; then
                   4198:              export_symbols="$output_objdir/$output.exp"
                   4199:              $run $rm $export_symbols
                   4200:              $run eval "${SED} -n -e '/^: @PROGRAM@$/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
                   4201:            else
                   4202:              $run eval "${SED} -e 's/\([][.*^$]\)/\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$output.exp"'
                   4203:              $run eval 'grep -f "$output_objdir/$output.exp" < "$nlist" > "$nlist"T'
                   4204:              $run eval 'mv "$nlist"T "$nlist"'
                   4205:            fi
                   4206:          fi
                   4207: 
                   4208:          for arg in $dlprefiles; do
                   4209:            $show "extracting global C symbols from \`$arg'"
                   4210:            name=`$echo "$arg" | ${SED} -e 's%^.*/%%'`
                   4211:            $run eval '$echo ": $name " >> "$nlist"'
                   4212:            $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
                   4213:          done
                   4214: 
                   4215:          if test -z "$run"; then
                   4216:            # Make sure we have at least an empty file.
                   4217:            test -f "$nlist" || : > "$nlist"
                   4218: 
                   4219:            if test -n "$exclude_expsyms"; then
                   4220:              $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
                   4221:              $mv "$nlist"T "$nlist"
                   4222:            fi
                   4223: 
                   4224:            # Try sorting and uniquifying the output.
                   4225:            if grep -v "^: " < "$nlist" |
                   4226:                if sort -k 3 </dev/null >/dev/null 2>&1; then
                   4227:                  sort -k 3
                   4228:                else
                   4229:                  sort +2
                   4230:                fi |
                   4231:                uniq > "$nlist"S; then
                   4232:              :
                   4233:            else
                   4234:              grep -v "^: " < "$nlist" > "$nlist"S
                   4235:            fi
                   4236: 
                   4237:            if test -f "$nlist"S; then
                   4238:              eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$dlsyms"'
                   4239:            else
                   4240:              $echo '/* NONE */' >> "$output_objdir/$dlsyms"
                   4241:            fi
                   4242: 
                   4243:            $echo >> "$output_objdir/$dlsyms" "\
                   4244: 
                   4245: #undef lt_preloaded_symbols
                   4246: 
                   4247: #if defined (__STDC__) && __STDC__
                   4248: # define lt_ptr void *
                   4249: #else
                   4250: # define lt_ptr char *
                   4251: # define const
                   4252: #endif
                   4253: 
                   4254: /* The mapping between symbol names and symbols. */
                   4255: const struct {
                   4256:   const char *name;
                   4257:   lt_ptr address;
                   4258: }
                   4259: lt_preloaded_symbols[] =
                   4260: {\
                   4261: "
                   4262: 
                   4263:            eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$dlsyms"
                   4264: 
                   4265:            $echo >> "$output_objdir/$dlsyms" "\
                   4266:   {0, (lt_ptr) 0}
                   4267: };
                   4268: 
                   4269: /* This works around a problem in FreeBSD linker */
                   4270: #ifdef FREEBSD_WORKAROUND
                   4271: static const void *lt_preloaded_setup() {
                   4272:   return lt_preloaded_symbols;
                   4273: }
                   4274: #endif
                   4275: 
                   4276: #ifdef __cplusplus
                   4277: }
                   4278: #endif\
                   4279: "
                   4280:          fi
                   4281: 
                   4282:          pic_flag_for_symtable=
                   4283:          case $host in
                   4284:          # compiling the symbol table file with pic_flag works around
                   4285:          # a FreeBSD bug that causes programs to crash when -lm is
                   4286:          # linked before any other PIC object.  But we must not use
                   4287:          # pic_flag when linking with -static.  The problem exists in
                   4288:          # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
                   4289:          *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
                   4290:            case "$compile_command " in
                   4291:            *" -static "*) ;;
                   4292:            *) pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND";;
                   4293:            esac;;
                   4294:          *-*-hpux*)
                   4295:            case "$compile_command " in
                   4296:            *" -static "*) ;;
                   4297:            *) pic_flag_for_symtable=" $pic_flag";;
                   4298:            esac
                   4299:          esac
                   4300: 
                   4301:          # Now compile the dynamic symbol file.
                   4302:          $show "(cd $output_objdir && $LTCC -c$no_builtin_flag$pic_flag_for_symtable \"$dlsyms\")"
                   4303:          $run eval '(cd $output_objdir && $LTCC -c$no_builtin_flag$pic_flag_for_symtable "$dlsyms")' || exit $?
                   4304: 
                   4305:          # Clean up the generated files.
                   4306:          $show "$rm $output_objdir/$dlsyms $nlist ${nlist}S ${nlist}T"
                   4307:          $run $rm "$output_objdir/$dlsyms" "$nlist" "${nlist}S" "${nlist}T"
                   4308: 
                   4309:          # Transform the symbol file into the correct name.
                   4310:          compile_command=`$echo "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
                   4311:          finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
                   4312:          ;;
                   4313:        *)
                   4314:          $echo "$modename: unknown suffix for \`$dlsyms'" 1>&2
                   4315:          exit 1
                   4316:          ;;
                   4317:        esac
                   4318:       else
                   4319:        # We keep going just in case the user didn't refer to
                   4320:        # lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
                   4321:        # really was required.
                   4322: 
                   4323:        # Nullify the symbol file.
                   4324:        compile_command=`$echo "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
                   4325:        finalize_command=`$echo "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
                   4326:       fi
                   4327: 
                   4328:       if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
                   4329:        # Replace the output file specification.
                   4330:        compile_command=`$echo "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
                   4331:        link_command="$compile_command$compile_rpath"
                   4332: 
                   4333:        # We have no uninstalled library dependencies, so finalize right now.
                   4334:        $show "$link_command"
                   4335:        $run eval "$link_command"
                   4336:        status=$?
                   4337: 
                   4338:        # Delete the generated files.
                   4339:        if test -n "$dlsyms"; then
                   4340:          $show "$rm $output_objdir/${outputname}S.${objext}"
                   4341:          $run $rm "$output_objdir/${outputname}S.${objext}"
                   4342:        fi
                   4343: 
                   4344:        exit $status
                   4345:       fi
                   4346: 
                   4347:       if test -n "$shlibpath_var"; then
                   4348:        # We should set the shlibpath_var
                   4349:        rpath=
                   4350:        for dir in $temp_rpath; do
                   4351:          case $dir in
                   4352:          [\\/]* | [A-Za-z]:[\\/]*)
                   4353:            # Absolute path.
                   4354:            rpath="$rpath$dir:"
                   4355:            ;;
                   4356:          *)
                   4357:            # Relative path: add a thisdir entry.
                   4358:            rpath="$rpath\$thisdir/$dir:"
                   4359:            ;;
                   4360:          esac
                   4361:        done
                   4362:        temp_rpath="$rpath"
                   4363:       fi
                   4364: 
                   4365:       if test -n "$compile_shlibpath$finalize_shlibpath"; then
                   4366:        compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
                   4367:       fi
                   4368:       if test -n "$finalize_shlibpath"; then
                   4369:        finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
                   4370:       fi
                   4371: 
                   4372:       compile_var=
                   4373:       finalize_var=
                   4374:       if test -n "$runpath_var"; then
                   4375:        if test -n "$perm_rpath"; then
                   4376:          # We should set the runpath_var.
                   4377:          rpath=
                   4378:          for dir in $perm_rpath; do
                   4379:            rpath="$rpath$dir:"
                   4380:          done
                   4381:          compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
                   4382:        fi
                   4383:        if test -n "$finalize_perm_rpath"; then
                   4384:          # We should set the runpath_var.
                   4385:          rpath=
                   4386:          for dir in $finalize_perm_rpath; do
                   4387:            rpath="$rpath$dir:"
                   4388:          done
                   4389:          finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
                   4390:        fi
                   4391:       fi
                   4392: 
                   4393:       if test "$no_install" = yes; then
                   4394:        # We don't need to create a wrapper script.
                   4395:        link_command="$compile_var$compile_command$compile_rpath"
                   4396:        # Replace the output file specification.
                   4397:        link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
                   4398:        # Delete the old output file.
                   4399:        $run $rm $output
                   4400:        # Link the executable and exit
                   4401:        $show "$link_command"
                   4402:        $run eval "$link_command" || exit $?
                   4403:        exit 0
                   4404:       fi
                   4405: 
                   4406:       if test "$hardcode_action" = relink; then
                   4407:        # Fast installation is not supported
                   4408:        link_command="$compile_var$compile_command$compile_rpath"
                   4409:        relink_command="$finalize_var$finalize_command$finalize_rpath"
                   4410: 
                   4411:        $echo "$modename: warning: this platform does not like uninstalled shared libraries" 1>&2
                   4412:        $echo "$modename: \`$output' will be relinked during installation" 1>&2
                   4413:       else
                   4414:        if test "$fast_install" != no; then
                   4415:          link_command="$finalize_var$compile_command$finalize_rpath"
                   4416:          if test "$fast_install" = yes; then
                   4417:            relink_command=`$echo "X$compile_var$compile_command$compile_rpath" | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g'`
                   4418:          else
                   4419:            # fast_install is set to needless
                   4420:            relink_command=
                   4421:          fi
                   4422:        else
                   4423:          link_command="$compile_var$compile_command$compile_rpath"
                   4424:          relink_command="$finalize_var$finalize_command$finalize_rpath"
                   4425:        fi
                   4426:       fi
                   4427: 
                   4428:       # Replace the output file specification.
                   4429:       link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
                   4430: 
                   4431:       # Delete the old output files.
                   4432:       $run $rm $output $output_objdir/$outputname $output_objdir/lt-$outputname
                   4433: 
                   4434:       $show "$link_command"
                   4435:       $run eval "$link_command" || exit $?
                   4436: 
                   4437:       # Now create the wrapper script.
                   4438:       $show "creating $output"
                   4439: 
                   4440:       # Quote the relink command for shipping.
                   4441:       if test -n "$relink_command"; then
                   4442:        # Preserve any variables that may affect compiler behavior
                   4443:        for var in $variables_saved_for_relink; do
                   4444:          if eval test -z \"\${$var+set}\"; then
                   4445:            relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"
                   4446:          elif eval var_value=\$$var; test -z "$var_value"; then
                   4447:            relink_command="$var=; export $var; $relink_command"
                   4448:          else
                   4449:            var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
                   4450:            relink_command="$var=\"$var_value\"; export $var; $relink_command"
                   4451:          fi
                   4452:        done
                   4453:        relink_command="(cd `pwd`; $relink_command)"
                   4454:        relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"`
                   4455:       fi
                   4456: 
                   4457:       # Quote $echo for shipping.
                   4458:       if test "X$echo" = "X$SHELL $0 --fallback-echo"; then
                   4459:        case $0 in
                   4460:        [\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $0 --fallback-echo";;
                   4461:        *) qecho="$SHELL `pwd`/$0 --fallback-echo";;
                   4462:        esac
                   4463:        qecho=`$echo "X$qecho" | $Xsed -e "$sed_quote_subst"`
                   4464:       else
                   4465:        qecho=`$echo "X$echo" | $Xsed -e "$sed_quote_subst"`
                   4466:       fi
                   4467: 
                   4468:       # Only actually do things if our run command is non-null.
                   4469:       if test -z "$run"; then
                   4470:        # win32 will think the script is a binary if it has
                   4471:        # a .exe suffix, so we strip it off here.
                   4472:        case $output in
                   4473:          *.exe) output=`$echo $output|${SED} 's,.exe$,,'` ;;
                   4474:        esac
                   4475:        # test for cygwin because mv fails w/o .exe extensions
                   4476:        case $host in
                   4477:          *cygwin*)
                   4478:            exeext=.exe
                   4479:            outputname=`$echo $outputname|${SED} 's,.exe$,,'` ;;
                   4480:          *) exeext= ;;
                   4481:        esac
                   4482:        case $host in
                   4483:          *cygwin* | *mingw* )
                   4484:            cwrappersource=`$echo ${objdir}/lt-${output}.c`
                   4485:            cwrapper=`$echo ${output}.exe`
                   4486:            $rm $cwrappersource $cwrapper
                   4487:            trap "$rm $cwrappersource $cwrapper; exit 1" 1 2 15
                   4488: 
                   4489:            cat > $cwrappersource <<EOF
                   4490: 
                   4491: /* $cwrappersource - temporary wrapper executable for $objdir/$outputname
                   4492:    Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
                   4493: 
                   4494:    The $output program cannot be directly executed until all the libtool
                   4495:    libraries that it depends on are installed.
                   4496:    
                   4497:    This wrapper executable should never be moved out of the build directory.
                   4498:    If it is, it will not operate correctly.
                   4499: 
                   4500:    Currently, it simply execs the wrapper *script* "/bin/sh $output",
                   4501:    but could eventually absorb all of the scripts functionality and
                   4502:    exec $objdir/$outputname directly.
                   4503: */
                   4504: EOF
                   4505:            cat >> $cwrappersource<<"EOF"
                   4506: #include <stdio.h>
                   4507: #include <stdlib.h>
                   4508: #include <unistd.h>
                   4509: #include <malloc.h>
                   4510: #include <stdarg.h>
                   4511: #include <assert.h>
                   4512: 
                   4513: #if defined(PATH_MAX)
                   4514: # define LT_PATHMAX PATH_MAX
                   4515: #elif defined(MAXPATHLEN)
                   4516: # define LT_PATHMAX MAXPATHLEN
                   4517: #else
                   4518: # define LT_PATHMAX 1024
                   4519: #endif
                   4520: 
                   4521: #ifndef DIR_SEPARATOR
                   4522: #define DIR_SEPARATOR '/'
                   4523: #endif
                   4524: 
                   4525: #if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
                   4526:   defined (__OS2__)
                   4527: #define HAVE_DOS_BASED_FILE_SYSTEM
                   4528: #ifndef DIR_SEPARATOR_2 
                   4529: #define DIR_SEPARATOR_2 '\\'
                   4530: #endif
                   4531: #endif
                   4532: 
                   4533: #ifndef DIR_SEPARATOR_2
                   4534: # define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
                   4535: #else /* DIR_SEPARATOR_2 */
                   4536: # define IS_DIR_SEPARATOR(ch) \
                   4537:         (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
                   4538: #endif /* DIR_SEPARATOR_2 */
                   4539: 
                   4540: #define XMALLOC(type, num)      ((type *) xmalloc ((num) * sizeof(type)))
                   4541: #define XFREE(stale) do { \
                   4542:   if (stale) { free ((void *) stale); stale = 0; } \
                   4543: } while (0)
                   4544: 
                   4545: const char *program_name = NULL;
                   4546: 
                   4547: void * xmalloc (size_t num);
                   4548: char * xstrdup (const char *string);
                   4549: char * basename (const char *name);
                   4550: char * fnqualify(const char *path);
                   4551: char * strendzap(char *str, const char *pat);
                   4552: void lt_fatal (const char *message, ...);
                   4553: 
                   4554: int
                   4555: main (int argc, char *argv[])
                   4556: {
                   4557:   char **newargz;
                   4558:   int i;
                   4559:   
                   4560:   program_name = (char *) xstrdup ((char *) basename (argv[0]));
                   4561:   newargz = XMALLOC(char *, argc+2);
                   4562: EOF
                   4563: 
                   4564:            cat >> $cwrappersource <<EOF
                   4565:   newargz[0] = "$SHELL";
                   4566: EOF
                   4567: 
                   4568:            cat >> $cwrappersource <<"EOF"
                   4569:   newargz[1] = fnqualify(argv[0]);
                   4570:   /* we know the script has the same name, without the .exe */
                   4571:   /* so make sure newargz[1] doesn't end in .exe */
                   4572:   strendzap(newargz[1],".exe"); 
                   4573:   for (i = 1; i < argc; i++)
                   4574:     newargz[i+1] = xstrdup(argv[i]);
                   4575:   newargz[argc+1] = NULL;
                   4576: EOF
                   4577: 
                   4578:            cat >> $cwrappersource <<EOF
                   4579:   execv("$SHELL",newargz);
                   4580: EOF
                   4581: 
                   4582:            cat >> $cwrappersource <<"EOF"
                   4583: }
                   4584: 
                   4585: void *
                   4586: xmalloc (size_t num)
                   4587: {
                   4588:   void * p = (void *) malloc (num);
                   4589:   if (!p)
                   4590:     lt_fatal ("Memory exhausted");
                   4591: 
                   4592:   return p;
                   4593: }
                   4594: 
                   4595: char * 
                   4596: xstrdup (const char *string)
                   4597: {
                   4598:   return string ? strcpy ((char *) xmalloc (strlen (string) + 1), string) : NULL
                   4599: ;
                   4600: }
                   4601: 
                   4602: char *
                   4603: basename (const char *name)
                   4604: {
                   4605:   const char *base;
                   4606: 
                   4607: #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
                   4608:   /* Skip over the disk name in MSDOS pathnames. */
                   4609:   if (isalpha (name[0]) && name[1] == ':') 
                   4610:     name += 2;
                   4611: #endif
                   4612: 
                   4613:   for (base = name; *name; name++)
                   4614:     if (IS_DIR_SEPARATOR (*name))
                   4615:       base = name + 1;
                   4616:   return (char *) base;
                   4617: }
                   4618: 
                   4619: char * 
                   4620: fnqualify(const char *path)
                   4621: {
                   4622:   size_t size;
                   4623:   char *p;
                   4624:   char tmp[LT_PATHMAX + 1];
                   4625: 
                   4626:   assert(path != NULL);
                   4627: 
                   4628:   /* Is it qualified already? */
                   4629: #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
                   4630:   if (isalpha (path[0]) && path[1] == ':')
                   4631:     return xstrdup (path);
                   4632: #endif
                   4633:   if (IS_DIR_SEPARATOR (path[0]))
                   4634:     return xstrdup (path);
                   4635: 
                   4636:   /* prepend the current directory */
                   4637:   /* doesn't handle '~' */
                   4638:   if (getcwd (tmp, LT_PATHMAX) == NULL)
                   4639:     lt_fatal ("getcwd failed");
                   4640:   size = strlen(tmp) + 1 + strlen(path) + 1; /* +2 for '/' and '\0' */
                   4641:   p = XMALLOC(char, size);
                   4642:   sprintf(p, "%s%c%s", tmp, DIR_SEPARATOR, path);
                   4643:   return p;
                   4644: }
                   4645: 
                   4646: char *
                   4647: strendzap(char *str, const char *pat) 
                   4648: {
                   4649:   size_t len, patlen;
                   4650: 
                   4651:   assert(str != NULL);
                   4652:   assert(pat != NULL);
                   4653: 
                   4654:   len = strlen(str);
                   4655:   patlen = strlen(pat);
                   4656: 
                   4657:   if (patlen <= len)
                   4658:   {
                   4659:     str += len - patlen;
                   4660:     if (strcmp(str, pat) == 0)
                   4661:       *str = '\0';
                   4662:   }
                   4663:   return str;
                   4664: }
                   4665: 
                   4666: static void
                   4667: lt_error_core (int exit_status, const char * mode, 
                   4668:           const char * message, va_list ap)
                   4669: {
                   4670:   fprintf (stderr, "%s: %s: ", program_name, mode);
                   4671:   vfprintf (stderr, message, ap);
                   4672:   fprintf (stderr, ".\n");
                   4673: 
                   4674:   if (exit_status >= 0)
                   4675:     exit (exit_status);
                   4676: }
                   4677: 
                   4678: void
                   4679: lt_fatal (const char *message, ...)
                   4680: {
                   4681:   va_list ap;
                   4682:   va_start (ap, message);
                   4683:   lt_error_core (EXIT_FAILURE, "FATAL", message, ap);
                   4684:   va_end (ap);
                   4685: }
                   4686: EOF
                   4687:          # we should really use a build-platform specific compiler
                   4688:          # here, but OTOH, the wrappers (shell script and this C one)
                   4689:          # are only useful if you want to execute the "real" binary.
                   4690:          # Since the "real" binary is built for $host, then this
                   4691:          # wrapper might as well be built for $host, too.
                   4692:          $run $LTCC -s -o $cwrapper $cwrappersource
                   4693:          ;;
                   4694:        esac
                   4695:        $rm $output
                   4696:        trap "$rm $output; exit 1" 1 2 15
                   4697: 
                   4698:        $echo > $output "\
                   4699: #! $SHELL
                   4700: 
                   4701: # $output - temporary wrapper script for $objdir/$outputname
                   4702: # Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
                   4703: #
                   4704: # The $output program cannot be directly executed until all the libtool
                   4705: # libraries that it depends on are installed.
                   4706: #
                   4707: # This wrapper script should never be moved out of the build directory.
                   4708: # If it is, it will not operate correctly.
                   4709: 
                   4710: # Sed substitution that helps us do robust quoting.  It backslashifies
                   4711: # metacharacters that are still active within double-quoted strings.
                   4712: Xsed='${SED} -e 1s/^X//'
                   4713: sed_quote_subst='$sed_quote_subst'
                   4714: 
                   4715: # The HP-UX ksh and POSIX shell print the target directory to stdout
                   4716: # if CDPATH is set.
                   4717: if test \"\${CDPATH+set}\" = set; then CDPATH=:; export CDPATH; fi
                   4718: 
                   4719: relink_command=\"$relink_command\"
                   4720: 
                   4721: # This environment variable determines our operation mode.
                   4722: if test \"\$libtool_install_magic\" = \"$magic\"; then
                   4723:   # install mode needs the following variable:
                   4724:   notinst_deplibs='$notinst_deplibs'
                   4725: else
                   4726:   # When we are sourced in execute mode, \$file and \$echo are already set.
                   4727:   if test \"\$libtool_execute_magic\" != \"$magic\"; then
                   4728:     echo=\"$qecho\"
                   4729:     file=\"\$0\"
                   4730:     # Make sure echo works.
                   4731:     if test \"X\$1\" = X--no-reexec; then
                   4732:       # Discard the --no-reexec flag, and continue.
                   4733:       shift
                   4734:     elif test \"X\`(\$echo '\t') 2>/dev/null\`\" = 'X\t'; then
                   4735:       # Yippee, \$echo works!
                   4736:       :
                   4737:     else
                   4738:       # Restart under the correct shell, and then maybe \$echo will work.
                   4739:       exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}
                   4740:     fi
                   4741:   fi\
                   4742: "
                   4743:        $echo >> $output "\
                   4744: 
                   4745:   # Find the directory that this script lives in.
                   4746:   thisdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
                   4747:   test \"x\$thisdir\" = \"x\$file\" && thisdir=.
                   4748: 
                   4749:   # Follow symbolic links until we get to the real thisdir.
                   4750:   file=\`ls -ld \"\$file\" | ${SED} -n 's/.*-> //p'\`
                   4751:   while test -n \"\$file\"; do
                   4752:     destdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`
                   4753: 
                   4754:     # If there was a directory component, then change thisdir.
                   4755:     if test \"x\$destdir\" != \"x\$file\"; then
                   4756:       case \"\$destdir\" in
                   4757:       [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
                   4758:       *) thisdir=\"\$thisdir/\$destdir\" ;;
                   4759:       esac
                   4760:     fi
                   4761: 
                   4762:     file=\`\$echo \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
                   4763:     file=\`ls -ld \"\$thisdir/\$file\" | ${SED} -n 's/.*-> //p'\`
                   4764:   done
                   4765: 
                   4766:   # Try to get the absolute directory name.
                   4767:   absdir=\`cd \"\$thisdir\" && pwd\`
                   4768:   test -n \"\$absdir\" && thisdir=\"\$absdir\"
                   4769: "
                   4770: 
                   4771:        if test "$fast_install" = yes; then
                   4772:          $echo >> $output "\
                   4773:   program=lt-'$outputname'$exeext
                   4774:   progdir=\"\$thisdir/$objdir\"
                   4775: 
                   4776:   if test ! -f \"\$progdir/\$program\" || \\
                   4777:      { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
                   4778:        test \"X\$file\" != \"X\$progdir/\$program\"; }; then
                   4779: 
                   4780:     file=\"\$\$-\$program\"
                   4781: 
                   4782:     if test ! -d \"\$progdir\"; then
                   4783:       $mkdir \"\$progdir\"
                   4784:     else
                   4785:       $rm \"\$progdir/\$file\"
                   4786:     fi"
                   4787: 
                   4788:          $echo >> $output "\
                   4789: 
                   4790:     # relink executable if necessary
                   4791:     if test -n \"\$relink_command\"; then
                   4792:       if relink_command_output=\`eval \$relink_command 2>&1\`; then :
                   4793:       else
                   4794:        $echo \"\$relink_command_output\" >&2
                   4795:        $rm \"\$progdir/\$file\"
                   4796:        exit 1
                   4797:       fi
                   4798:     fi
                   4799: 
                   4800:     $mv \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
                   4801:     { $rm \"\$progdir/\$program\";
                   4802:       $mv \"\$progdir/\$file\" \"\$progdir/\$program\"; }
                   4803:     $rm \"\$progdir/\$file\"
                   4804:   fi"
                   4805:        else
                   4806:          $echo >> $output "\
                   4807:   program='$outputname'
                   4808:   progdir=\"\$thisdir/$objdir\"
                   4809: "
                   4810:        fi
                   4811: 
                   4812:        $echo >> $output "\
                   4813: 
                   4814:   if test -f \"\$progdir/\$program\"; then"
                   4815: 
                   4816:        # Export our shlibpath_var if we have one.
                   4817:        if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
                   4818:          $echo >> $output "\
                   4819:     # Add our own library path to $shlibpath_var
                   4820:     $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
                   4821: 
                   4822:     # Some systems cannot cope with colon-terminated $shlibpath_var
                   4823:     # The second colon is a workaround for a bug in BeOS R4 sed
                   4824:     $shlibpath_var=\`\$echo \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`
                   4825: 
                   4826:     export $shlibpath_var
                   4827: "
                   4828:        fi
                   4829: 
                   4830:        # fixup the dll searchpath if we need to.
                   4831:        if test -n "$dllsearchpath"; then
                   4832:          $echo >> $output "\
                   4833:     # Add the dll search path components to the executable PATH
                   4834:     PATH=$dllsearchpath:\$PATH
                   4835: "
                   4836:        fi
                   4837: 
                   4838:        $echo >> $output "\
                   4839:     if test \"\$libtool_execute_magic\" != \"$magic\"; then
                   4840:       # Run the actual program with our arguments.
                   4841: "
                   4842:        case $host in
                   4843:        # Backslashes separate directories on plain windows
                   4844:        *-*-mingw | *-*-os2*)
                   4845:          $echo >> $output "\
                   4846:       exec \$progdir\\\\\$program \${1+\"\$@\"}
                   4847: "
                   4848:          ;;
                   4849: 
                   4850:        *)
                   4851:          $echo >> $output "\
                   4852:       exec \$progdir/\$program \${1+\"\$@\"}
                   4853: "
                   4854:          ;;
                   4855:        esac
                   4856:        $echo >> $output "\
                   4857:       \$echo \"\$0: cannot exec \$program \${1+\"\$@\"}\"
                   4858:       exit 1
                   4859:     fi
                   4860:   else
                   4861:     # The program doesn't exist.
                   4862:     \$echo \"\$0: error: \$progdir/\$program does not exist\" 1>&2
                   4863:     \$echo \"This script is just a wrapper for \$program.\" 1>&2
                   4864:     $echo \"See the $PACKAGE documentation for more information.\" 1>&2
                   4865:     exit 1
                   4866:   fi
                   4867: fi\
                   4868: "
                   4869:        chmod +x $output
                   4870:       fi
                   4871:       exit 0
                   4872:       ;;
                   4873:     esac
                   4874: 
                   4875:     # See if we need to build an old-fashioned archive.
                   4876:     for oldlib in $oldlibs; do
                   4877: 
                   4878:       if test "$build_libtool_libs" = convenience; then
                   4879:        oldobjs="$libobjs_save"
                   4880:        addlibs="$convenience"
                   4881:        build_libtool_libs=no
                   4882:       else
                   4883:        if test "$build_libtool_libs" = module; then
                   4884:          oldobjs="$libobjs_save"
                   4885:          build_libtool_libs=no
                   4886:        else
                   4887:          oldobjs="$old_deplibs $non_pic_objects"
                   4888:        fi
                   4889:        addlibs="$old_convenience"
                   4890:       fi
                   4891: 
                   4892:       if test -n "$addlibs"; then
                   4893:        gentop="$output_objdir/${outputname}x"
                   4894:        $show "${rm}r $gentop"
                   4895:        $run ${rm}r "$gentop"
                   4896:        $show "$mkdir $gentop"
                   4897:        $run $mkdir "$gentop"
                   4898:        status=$?
                   4899:        if test "$status" -ne 0 && test ! -d "$gentop"; then
                   4900:          exit $status
                   4901:        fi
                   4902:        generated="$generated $gentop"
                   4903: 
                   4904:        # Add in members from convenience archives.
                   4905:        for xlib in $addlibs; do
                   4906:          # Extract the objects.
                   4907:          case $xlib in
                   4908:          [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;
                   4909:          *) xabs=`pwd`"/$xlib" ;;
                   4910:          esac
                   4911:          xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
                   4912:          xdir="$gentop/$xlib"
                   4913: 
                   4914:          $show "${rm}r $xdir"
                   4915:          $run ${rm}r "$xdir"
                   4916:          $show "$mkdir $xdir"
                   4917:          $run $mkdir "$xdir"
                   4918:          status=$?
                   4919:          if test "$status" -ne 0 && test ! -d "$xdir"; then
                   4920:            exit $status
                   4921:          fi
                   4922:          # We will extract separately just the conflicting names and we will no
                   4923:          # longer touch any unique names. It is faster to leave these extract
                   4924:          # automatically by $AR in one run.
                   4925:          $show "(cd $xdir && $AR x $xabs)"
                   4926:          $run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
                   4927:          if ($AR t "$xabs" | sort | sort -uc >/dev/null 2>&1); then
                   4928:            :
                   4929:          else
                   4930:            $echo "$modename: warning: object name conflicts; renaming object files" 1>&2
                   4931:            $echo "$modename: warning: to ensure that they will not overwrite" 1>&2
                   4932:            $AR t "$xabs" | sort | uniq -cd | while read -r count name
                   4933:            do
                   4934:              i=1
                   4935:              while test "$i" -le "$count"
                   4936:              do
                   4937:               # Put our $i before any first dot (extension)
                   4938:               # Never overwrite any file
                   4939:               name_to="$name"
                   4940:               while test "X$name_to" = "X$name" || test -f "$xdir/$name_to"
                   4941:               do
                   4942:                 name_to=`$echo "X$name_to" | $Xsed -e "s/\([^.]*\)/\1-$i/"`
                   4943:               done
                   4944:               $show "(cd $xdir && $AR xN $i $xabs '$name' && $mv '$name' '$name_to')"
                   4945:               $run eval "(cd \$xdir && $AR xN $i \$xabs '$name' && $mv '$name' '$name_to')" || exit $?
                   4946:               i=`expr $i + 1`
                   4947:              done
                   4948:            done
                   4949:          fi
                   4950: 
                   4951:          oldobjs="$oldobjs "`find $xdir -name \*.${objext} -print -o -name \*.lo -print | $NL2SP`
                   4952:        done
                   4953:       fi
                   4954: 
                   4955:       # Do each command in the archive commands.
                   4956:       if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
                   4957:        eval cmds=\"$old_archive_from_new_cmds\"
                   4958:       else
                   4959:        eval cmds=\"$old_archive_cmds\"
                   4960: 
                   4961:        if len=`expr "X$cmds" : ".*"` &&
                   4962:             test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
                   4963:          :
                   4964:        else
                   4965:          # the command line is too long to link in one step, link in parts
                   4966:          $echo "using piecewise archive linking..."
                   4967:          save_RANLIB=$RANLIB
                   4968:          RANLIB=:
                   4969:          objlist=
                   4970:          concat_cmds=
                   4971:          save_oldobjs=$oldobjs
                   4972:          # GNU ar 2.10+ was changed to match POSIX; thus no paths are
                   4973:          # encoded into archives.  This makes 'ar r' malfunction in
                   4974:          # this piecewise linking case whenever conflicting object
                   4975:          # names appear in distinct ar calls; check, warn and compensate.
                   4976:            if (for obj in $save_oldobjs
                   4977:            do
                   4978:              $echo "X$obj" | $Xsed -e 's%^.*/%%'
                   4979:            done | sort | sort -uc >/dev/null 2>&1); then
                   4980:            :
                   4981:          else
                   4982:            $echo "$modename: warning: object name conflicts; overriding AR_FLAGS to 'cq'" 1>&2
                   4983:            $echo "$modename: warning: to ensure that POSIX-compatible ar will work" 1>&2
                   4984:            AR_FLAGS=cq
                   4985:          fi
                   4986:          # Is there a better way of finding the last object in the list?
                   4987:          for obj in $save_oldobjs
                   4988:          do
                   4989:            last_oldobj=$obj
                   4990:          done  
                   4991:          for obj in $save_oldobjs
                   4992:          do
                   4993:            oldobjs="$objlist $obj"
                   4994:            objlist="$objlist $obj"
                   4995:            eval test_cmds=\"$old_archive_cmds\"
                   4996:            if len=`expr "X$test_cmds" : ".*"` &&
                   4997:               test "$len" -le "$max_cmd_len"; then
                   4998:              :
                   4999:            else
                   5000:              # the above command should be used before it gets too long
                   5001:              oldobjs=$objlist
                   5002:              if test "$obj" = "$last_oldobj" ; then
                   5003:                RANLIB=$save_RANLIB
                   5004:              fi  
                   5005:              test -z "$concat_cmds" || concat_cmds=$concat_cmds~
                   5006:              eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"
                   5007:              objlist=
                   5008:            fi
                   5009:          done
                   5010:          RANLIB=$save_RANLIB
                   5011:          oldobjs=$objlist
                   5012:          if test "X$oldobjs" = "X" ; then
                   5013:            eval cmds=\"\$concat_cmds\"
                   5014:          else
                   5015:            eval cmds=\"\$concat_cmds~$old_archive_cmds\"
                   5016:          fi
                   5017:        fi
                   5018:       fi
                   5019:       save_ifs="$IFS"; IFS='~'
                   5020:       for cmd in $cmds; do
                   5021:        IFS="$save_ifs"
                   5022:        $show "$cmd"
                   5023:        $run eval "$cmd" || exit $?
                   5024:       done
                   5025:       IFS="$save_ifs"
                   5026:     done
                   5027: 
                   5028:     if test -n "$generated"; then
                   5029:       $show "${rm}r$generated"
                   5030:       $run ${rm}r$generated
                   5031:     fi
                   5032: 
                   5033:     # Now create the libtool archive.
                   5034:     case $output in
                   5035:     *.la)
                   5036:       old_library=
                   5037:       test "$build_old_libs" = yes && old_library="$libname.$libext"
                   5038:       $show "creating $output"
                   5039: 
                   5040:       # Preserve any variables that may affect compiler behavior
                   5041:       for var in $variables_saved_for_relink; do
                   5042:        if eval test -z \"\${$var+set}\"; then
                   5043:          relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"
                   5044:        elif eval var_value=\$$var; test -z "$var_value"; then
                   5045:          relink_command="$var=; export $var; $relink_command"
                   5046:        else
                   5047:          var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
                   5048:          relink_command="$var=\"$var_value\"; export $var; $relink_command"
                   5049:        fi
                   5050:       done
                   5051:       # Quote the link command for shipping.
                   5052:       relink_command="(cd `pwd`; $SHELL $0 --mode=relink $libtool_args @inst_prefix_dir@)"
                   5053:       relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"`
                   5054: 
                   5055:       # Only create the output if not a dry run.
                   5056:       if test -z "$run"; then
                   5057:        for installed in no yes; do
                   5058:          if test "$installed" = yes; then
                   5059:            if test -z "$install_libdir"; then
                   5060:              break
                   5061:            fi
                   5062:            output="$output_objdir/$outputname"i
                   5063:            # Replace all uninstalled libtool libraries with the installed ones
                   5064:            newdependency_libs=
                   5065:            for deplib in $dependency_libs; do
                   5066:              case $deplib in
                   5067:              *.la)
                   5068:                name=`$echo "X$deplib" | $Xsed -e 's%^.*/%%'`
                   5069:                eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
                   5070:                if test -z "$libdir"; then
                   5071:                  $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
                   5072:                  exit 1
                   5073:                fi
                   5074:                newdependency_libs="$newdependency_libs $libdir/$name"
                   5075:                ;;
                   5076:              *) newdependency_libs="$newdependency_libs $deplib" ;;
                   5077:              esac
                   5078:            done
                   5079:            dependency_libs="$newdependency_libs"
                   5080:            newdlfiles=
                   5081:            for lib in $dlfiles; do
                   5082:              name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
                   5083:              eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
                   5084:              if test -z "$libdir"; then
                   5085:                $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
                   5086:                exit 1
                   5087:              fi
                   5088:              newdlfiles="$newdlfiles $libdir/$name"
                   5089:            done
                   5090:            dlfiles="$newdlfiles"
                   5091:            newdlprefiles=
                   5092:            for lib in $dlprefiles; do
                   5093:              name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
                   5094:              eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
                   5095:              if test -z "$libdir"; then
                   5096:                $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
                   5097:                exit 1
                   5098:              fi
                   5099:              newdlprefiles="$newdlprefiles $libdir/$name"
                   5100:            done
                   5101:            dlprefiles="$newdlprefiles"
                   5102:          fi
                   5103:          $rm $output
                   5104:          # place dlname in correct position for cygwin
                   5105:          tdlname=$dlname
                   5106:          case $host,$output,$installed,$module,$dlname in
                   5107:            *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll) tdlname=../bin/$dlname ;;
                   5108:          esac
                   5109:          $echo > $output "\
                   5110: # $outputname - a libtool library file
                   5111: # Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
                   5112: #
                   5113: # Please DO NOT delete this file!
                   5114: # It is necessary for linking the library.
                   5115: 
                   5116: # The name that we can dlopen(3).
                   5117: dlname='$tdlname'
                   5118: 
                   5119: # Names of this library.
                   5120: library_names='$library_names'
                   5121: 
                   5122: # The name of the static archive.
                   5123: old_library='$old_library'
                   5124: 
                   5125: # Libraries that this one depends upon.
                   5126: dependency_libs='$dependency_libs'
                   5127: 
                   5128: # Version information for $libname.
                   5129: current=$current
                   5130: age=$age
                   5131: revision=$revision
                   5132: 
                   5133: # Is this an already installed library?
                   5134: installed=$installed
                   5135: 
                   5136: # Should we warn about portability when linking against -modules?
                   5137: shouldnotlink=$module
                   5138: 
                   5139: # Files to dlopen/dlpreopen
                   5140: dlopen='$dlfiles'
                   5141: dlpreopen='$dlprefiles'
                   5142: 
                   5143: # Directory that this library needs to be installed in:
                   5144: libdir='$install_libdir'"
                   5145:          if test "$installed" = no && test "$need_relink" = yes; then
                   5146:            $echo >> $output "\
                   5147: relink_command=\"$relink_command\""
                   5148:          fi
                   5149:        done
                   5150:       fi
                   5151: 
                   5152:       # Do a symbolic link so that the libtool archive can be found in
                   5153:       # LD_LIBRARY_PATH before the program is installed.
                   5154:       $show "(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)"
                   5155:       $run eval '(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)' || exit $?
                   5156:       ;;
                   5157:     esac
                   5158:     exit 0
                   5159:     ;;
                   5160: 
                   5161:   # libtool install mode
                   5162:   install)
                   5163:     modename="$modename: install"
                   5164: 
                   5165:     # There may be an optional sh(1) argument at the beginning of
                   5166:     # install_prog (especially on Windows NT).
                   5167:     if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
                   5168:        # Allow the use of GNU shtool's install command.
                   5169:        $echo "X$nonopt" | $Xsed | grep shtool > /dev/null; then
                   5170:       # Aesthetically quote it.
                   5171:       arg=`$echo "X$nonopt" | $Xsed -e "$sed_quote_subst"`
                   5172:       case $arg in
                   5173:       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \    ]*|*]*)
                   5174:        arg="\"$arg\""
                   5175:        ;;
                   5176:       esac
                   5177:       install_prog="$arg "
                   5178:       arg="$1"
                   5179:       shift
                   5180:     else
                   5181:       install_prog=
                   5182:       arg="$nonopt"
                   5183:     fi
                   5184: 
                   5185:     # The real first argument should be the name of the installation program.
                   5186:     # Aesthetically quote it.
                   5187:     arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
                   5188:     case $arg in
                   5189:     *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \      ]*|*]*)
                   5190:       arg="\"$arg\""
                   5191:       ;;
                   5192:     esac
                   5193:     install_prog="$install_prog$arg"
                   5194: 
                   5195:     # We need to accept at least all the BSD install flags.
                   5196:     dest=
                   5197:     files=
                   5198:     opts=
                   5199:     prev=
                   5200:     install_type=
                   5201:     isdir=no
                   5202:     stripme=
                   5203:     for arg
                   5204:     do
                   5205:       if test -n "$dest"; then
                   5206:        files="$files $dest"
                   5207:        dest="$arg"
                   5208:        continue
                   5209:       fi
                   5210: 
                   5211:       case $arg in
                   5212:       -d) isdir=yes ;;
                   5213:       -f) prev="-f" ;;
                   5214:       -g) prev="-g" ;;
                   5215:       -m) prev="-m" ;;
                   5216:       -o) prev="-o" ;;
                   5217:       -s)
                   5218:        stripme=" -s"
                   5219:        continue
                   5220:        ;;
                   5221:       -*) ;;
                   5222: 
                   5223:       *)
                   5224:        # If the previous option needed an argument, then skip it.
                   5225:        if test -n "$prev"; then
                   5226:          prev=
                   5227:        else
                   5228:          dest="$arg"
                   5229:          continue
                   5230:        fi
                   5231:        ;;
                   5232:       esac
                   5233: 
                   5234:       # Aesthetically quote the argument.
                   5235:       arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
                   5236:       case $arg in
                   5237:       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \    ]*|*]*)
                   5238:        arg="\"$arg\""
                   5239:        ;;
                   5240:       esac
                   5241:       install_prog="$install_prog $arg"
                   5242:     done
                   5243: 
                   5244:     if test -z "$install_prog"; then
                   5245:       $echo "$modename: you must specify an install program" 1>&2
                   5246:       $echo "$help" 1>&2
                   5247:       exit 1
                   5248:     fi
                   5249: 
                   5250:     if test -n "$prev"; then
                   5251:       $echo "$modename: the \`$prev' option requires an argument" 1>&2
                   5252:       $echo "$help" 1>&2
                   5253:       exit 1
                   5254:     fi
                   5255: 
                   5256:     if test -z "$files"; then
                   5257:       if test -z "$dest"; then
                   5258:        $echo "$modename: no file or destination specified" 1>&2
                   5259:       else
                   5260:        $echo "$modename: you must specify a destination" 1>&2
                   5261:       fi
                   5262:       $echo "$help" 1>&2
                   5263:       exit 1
                   5264:     fi
                   5265: 
                   5266:     # Strip any trailing slash from the destination.
                   5267:     dest=`$echo "X$dest" | $Xsed -e 's%/$%%'`
                   5268: 
                   5269:     # Check to see that the destination is a directory.
                   5270:     test -d "$dest" && isdir=yes
                   5271:     if test "$isdir" = yes; then
                   5272:       destdir="$dest"
                   5273:       destname=
                   5274:     else
                   5275:       destdir=`$echo "X$dest" | $Xsed -e 's%/[^/]*$%%'`
                   5276:       test "X$destdir" = "X$dest" && destdir=.
                   5277:       destname=`$echo "X$dest" | $Xsed -e 's%^.*/%%'`
                   5278: 
                   5279:       # Not a directory, so check to see that there is only one file specified.
                   5280:       set dummy $files
                   5281:       if test "$#" -gt 2; then
                   5282:        $echo "$modename: \`$dest' is not a directory" 1>&2
                   5283:        $echo "$help" 1>&2
                   5284:        exit 1
                   5285:       fi
                   5286:     fi
                   5287:     case $destdir in
                   5288:     [\\/]* | [A-Za-z]:[\\/]*) ;;
                   5289:     *)
                   5290:       for file in $files; do
                   5291:        case $file in
                   5292:        *.lo) ;;
                   5293:        *)
                   5294:          $echo "$modename: \`$destdir' must be an absolute directory name" 1>&2
                   5295:          $echo "$help" 1>&2
                   5296:          exit 1
                   5297:          ;;
                   5298:        esac
                   5299:       done
                   5300:       ;;
                   5301:     esac
                   5302: 
                   5303:     # This variable tells wrapper scripts just to set variables rather
                   5304:     # than running their programs.
                   5305:     libtool_install_magic="$magic"
                   5306: 
                   5307:     staticlibs=
                   5308:     future_libdirs=
                   5309:     current_libdirs=
                   5310:     for file in $files; do
                   5311: 
                   5312:       # Do each installation.
                   5313:       case $file in
                   5314:       *.$libext)
                   5315:        # Do the static libraries later.
                   5316:        staticlibs="$staticlibs $file"
                   5317:        ;;
                   5318: 
                   5319:       *.la)
                   5320:        # Check to see that this really is a libtool archive.
                   5321:        if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
                   5322:        else
                   5323:          $echo "$modename: \`$file' is not a valid libtool archive" 1>&2
                   5324:          $echo "$help" 1>&2
                   5325:          exit 1
                   5326:        fi
                   5327: 
                   5328:        library_names=
                   5329:        old_library=
                   5330:        relink_command=
                   5331:        # If there is no directory component, then add one.
                   5332:        case $file in
                   5333:        */* | *\\*) . $file ;;
                   5334:        *) . ./$file ;;
                   5335:        esac
                   5336: 
                   5337:        # Add the libdir to current_libdirs if it is the destination.
                   5338:        if test "X$destdir" = "X$libdir"; then
                   5339:          case "$current_libdirs " in
                   5340:          *" $libdir "*) ;;
                   5341:          *) current_libdirs="$current_libdirs $libdir" ;;
                   5342:          esac
                   5343:        else
                   5344:          # Note the libdir as a future libdir.
                   5345:          case "$future_libdirs " in
                   5346:          *" $libdir "*) ;;
                   5347:          *) future_libdirs="$future_libdirs $libdir" ;;
                   5348:          esac
                   5349:        fi
                   5350: 
                   5351:        dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`/
                   5352:        test "X$dir" = "X$file/" && dir=
                   5353:        dir="$dir$objdir"
                   5354: 
                   5355:        if test -n "$relink_command"; then
                   5356:          # Determine the prefix the user has applied to our future dir.
                   5357:          inst_prefix_dir=`$echo "$destdir" | $SED "s%$libdir\$%%"`
                   5358: 
                   5359:          # Don't allow the user to place us outside of our expected
                   5360:          # location b/c this prevents finding dependent libraries that
                   5361:          # are installed to the same prefix.
                   5362:          # At present, this check doesn't affect windows .dll's that
                   5363:          # are installed into $libdir/../bin (currently, that works fine)
                   5364:          # but it's something to keep an eye on.
                   5365:          if test "$inst_prefix_dir" = "$destdir"; then
                   5366:            $echo "$modename: error: cannot install \`$file' to a directory not ending in $libdir" 1>&2
                   5367:            exit 1
                   5368:          fi
                   5369: 
                   5370:          if test -n "$inst_prefix_dir"; then
                   5371:            # Stick the inst_prefix_dir data into the link command.
                   5372:            relink_command=`$echo "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
                   5373:          else
                   5374:            relink_command=`$echo "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
                   5375:          fi
                   5376: 
                   5377:          $echo "$modename: warning: relinking \`$file'" 1>&2
                   5378:          $show "$relink_command"
                   5379:          if $run eval "$relink_command"; then :
                   5380:          else
                   5381:            $echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
                   5382:            exit 1
                   5383:          fi
                   5384:        fi
                   5385: 
                   5386:        # See the names of the shared library.
                   5387:        set dummy $library_names
                   5388:        if test -n "$2"; then
                   5389:          realname="$2"
                   5390:          shift
                   5391:          shift
                   5392: 
                   5393:          srcname="$realname"
                   5394:          test -n "$relink_command" && srcname="$realname"T
                   5395: 
                   5396:          # Install the shared library and build the symlinks.
                   5397:          $show "$install_prog $dir/$srcname $destdir/$realname"
                   5398:          $run eval "$install_prog $dir/$srcname $destdir/$realname" || exit $?
                   5399:          if test -n "$stripme" && test -n "$striplib"; then
                   5400:            $show "$striplib $destdir/$realname"
                   5401:            $run eval "$striplib $destdir/$realname" || exit $?
                   5402:          fi
                   5403: 
                   5404:          if test "$#" -gt 0; then
                   5405:            # Delete the old symlinks, and create new ones.
                   5406:            for linkname
                   5407:            do
                   5408:              if test "$linkname" != "$realname"; then
                   5409:                $show "(cd $destdir && $rm $linkname && $LN_S $realname $linkname)"
                   5410:                $run eval "(cd $destdir && $rm $linkname && $LN_S $realname $linkname)"
                   5411:              fi
                   5412:            done
                   5413:          fi
                   5414: 
                   5415:          # Do each command in the postinstall commands.
                   5416:          lib="$destdir/$realname"
                   5417:          eval cmds=\"$postinstall_cmds\"
                   5418:          save_ifs="$IFS"; IFS='~'
                   5419:          for cmd in $cmds; do
                   5420:            IFS="$save_ifs"
                   5421:            $show "$cmd"
                   5422:            $run eval "$cmd" || exit $?
                   5423:          done
                   5424:          IFS="$save_ifs"
                   5425:        fi
                   5426: 
                   5427:        # Install the pseudo-library for information purposes.
                   5428:        name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
                   5429:        instname="$dir/$name"i
                   5430:        $show "$install_prog $instname $destdir/$name"
                   5431:        $run eval "$install_prog $instname $destdir/$name" || exit $?
                   5432: 
                   5433:        # Maybe install the static library, too.
                   5434:        test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
                   5435:        ;;
                   5436: 
                   5437:       *.lo)
                   5438:        # Install (i.e. copy) a libtool object.
                   5439: 
                   5440:        # Figure out destination file name, if it wasn't already specified.
                   5441:        if test -n "$destname"; then
                   5442:          destfile="$destdir/$destname"
                   5443:        else
                   5444:          destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
                   5445:          destfile="$destdir/$destfile"
                   5446:        fi
                   5447: 
                   5448:        # Deduce the name of the destination old-style object file.
                   5449:        case $destfile in
                   5450:        *.lo)
                   5451:          staticdest=`$echo "X$destfile" | $Xsed -e "$lo2o"`
                   5452:          ;;
                   5453:        *.$objext)
                   5454:          staticdest="$destfile"
                   5455:          destfile=
                   5456:          ;;
                   5457:        *)
                   5458:          $echo "$modename: cannot copy a libtool object to \`$destfile'" 1>&2
                   5459:          $echo "$help" 1>&2
                   5460:          exit 1
                   5461:          ;;
                   5462:        esac
                   5463: 
                   5464:        # Install the libtool object if requested.
                   5465:        if test -n "$destfile"; then
                   5466:          $show "$install_prog $file $destfile"
                   5467:          $run eval "$install_prog $file $destfile" || exit $?
                   5468:        fi
                   5469: 
                   5470:        # Install the old object if enabled.
                   5471:        if test "$build_old_libs" = yes; then
                   5472:          # Deduce the name of the old-style object file.
                   5473:          staticobj=`$echo "X$file" | $Xsed -e "$lo2o"`
                   5474: 
                   5475:          $show "$install_prog $staticobj $staticdest"
                   5476:          $run eval "$install_prog \$staticobj \$staticdest" || exit $?
                   5477:        fi
                   5478:        exit 0
                   5479:        ;;
                   5480: 
                   5481:       *)
                   5482:        # Figure out destination file name, if it wasn't already specified.
                   5483:        if test -n "$destname"; then
                   5484:          destfile="$destdir/$destname"
                   5485:        else
                   5486:          destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
                   5487:          destfile="$destdir/$destfile"
                   5488:        fi
                   5489: 
                   5490:        # If the file is missing, and there is a .exe on the end, strip it
                   5491:        # because it is most likely a libtool script we actually want to
                   5492:        # install
                   5493:        stripped_ext=""
                   5494:        case $file in
                   5495:          *.exe)
                   5496:            if test ! -f "$file"; then
                   5497:              file=`$echo $file|${SED} 's,.exe$,,'`
                   5498:              stripped_ext=".exe"
                   5499:            fi
                   5500:            ;;
                   5501:        esac
                   5502: 
                   5503:        # Do a test to see if this is really a libtool program.
                   5504:        case $host in
                   5505:        *cygwin*|*mingw*)
                   5506:            wrapper=`$echo $file | ${SED} -e 's,.exe$,,'`
                   5507:            ;;
                   5508:        *)
                   5509:            wrapper=$file
                   5510:            ;;
                   5511:        esac
                   5512:        if (${SED} -e '4q' $wrapper | grep "^# Generated by .*$PACKAGE")>/dev/null 2>&1; then
                   5513:          notinst_deplibs=
                   5514:          relink_command=
                   5515: 
                   5516:          # To insure that "foo" is sourced, and not "foo.exe",
                   5517:          # finese the cygwin/MSYS system by explicitly sourcing "foo."
                   5518:          # which disallows the automatic-append-.exe behavior.
                   5519:          case $build in
                   5520:          *cygwin* | *mingw*) wrapperdot=${wrapper}. ;;
                   5521:          *) wrapperdot=${wrapper} ;;
                   5522:          esac
                   5523:          # If there is no directory component, then add one.
                   5524:          case $file in
                   5525:          */* | *\\*) . ${wrapperdot} ;;
                   5526:          *) . ./${wrapperdot} ;;
                   5527:          esac
                   5528: 
                   5529:          # Check the variables that should have been set.
                   5530:          if test -z "$notinst_deplibs"; then
                   5531:            $echo "$modename: invalid libtool wrapper script \`$wrapper'" 1>&2
                   5532:            exit 1
                   5533:          fi
                   5534: 
                   5535:          finalize=yes
                   5536:          for lib in $notinst_deplibs; do
                   5537:            # Check to see that each library is installed.
                   5538:            libdir=
                   5539:            if test -f "$lib"; then
                   5540:              # If there is no directory component, then add one.
                   5541:              case $lib in
                   5542:              */* | *\\*) . $lib ;;
                   5543:              *) . ./$lib ;;
                   5544:              esac
                   5545:            fi
                   5546:            libfile="$libdir/"`$echo "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test
                   5547:            if test -n "$libdir" && test ! -f "$libfile"; then
                   5548:              $echo "$modename: warning: \`$lib' has not been installed in \`$libdir'" 1>&2
                   5549:              finalize=no
                   5550:            fi
                   5551:          done
                   5552: 
                   5553:          relink_command=
                   5554:          # To insure that "foo" is sourced, and not "foo.exe",
                   5555:          # finese the cygwin/MSYS system by explicitly sourcing "foo."
                   5556:          # which disallows the automatic-append-.exe behavior.
                   5557:          case $build in
                   5558:          *cygwin* | *mingw*) wrapperdot=${wrapper}. ;;
                   5559:          *) wrapperdot=${wrapper} ;;
                   5560:          esac
                   5561:          # If there is no directory component, then add one.
                   5562:          case $file in
                   5563:          */* | *\\*) . ${wrapperdot} ;;
                   5564:          *) . ./${wrapperdot} ;;
                   5565:          esac
                   5566: 
                   5567:          outputname=
                   5568:          if test "$fast_install" = no && test -n "$relink_command"; then
                   5569:            if test "$finalize" = yes && test -z "$run"; then
                   5570:              tmpdir="/tmp"
                   5571:              test -n "$TMPDIR" && tmpdir="$TMPDIR"
                   5572:              tmpdir="$tmpdir/libtool-$$"
                   5573:              if $mkdir -p "$tmpdir" && chmod 700 "$tmpdir"; then :
                   5574:              else
                   5575:                $echo "$modename: error: cannot create temporary directory \`$tmpdir'" 1>&2
                   5576:                continue
                   5577:              fi
                   5578:              file=`$echo "X$file$stripped_ext" | $Xsed -e 's%^.*/%%'`
                   5579:              outputname="$tmpdir/$file"
                   5580:              # Replace the output file specification.
                   5581:              relink_command=`$echo "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'`
                   5582: 
                   5583:              $show "$relink_command"
                   5584:              if $run eval "$relink_command"; then :
                   5585:              else
                   5586:                $echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
                   5587:                ${rm}r "$tmpdir"
                   5588:                continue
                   5589:              fi
                   5590:              file="$outputname"
                   5591:            else
                   5592:              $echo "$modename: warning: cannot relink \`$file'" 1>&2
                   5593:            fi
                   5594:          else
                   5595:            # Install the binary that we compiled earlier.
                   5596:            file=`$echo "X$file$stripped_ext" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
                   5597:          fi
                   5598:        fi
                   5599: 
                   5600:        # remove .exe since cygwin /usr/bin/install will append another
                   5601:        # one anyways
                   5602:        case $install_prog,$host in
                   5603:        */usr/bin/install*,*cygwin*)
                   5604:          case $file:$destfile in
                   5605:          *.exe:*.exe)
                   5606:            # this is ok
                   5607:            ;;
                   5608:          *.exe:*)
                   5609:            destfile=$destfile.exe
                   5610:            ;;
                   5611:          *:*.exe)
                   5612:            destfile=`$echo $destfile | ${SED} -e 's,.exe$,,'`
                   5613:            ;;
                   5614:          esac
                   5615:          ;;
                   5616:        esac
                   5617:        $show "$install_prog$stripme $file $destfile"
                   5618:        $run eval "$install_prog\$stripme \$file \$destfile" || exit $?
                   5619:        test -n "$outputname" && ${rm}r "$tmpdir"
                   5620:        ;;
                   5621:       esac
                   5622:     done
                   5623: 
                   5624:     for file in $staticlibs; do
                   5625:       name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
                   5626: 
                   5627:       # Set up the ranlib parameters.
                   5628:       oldlib="$destdir/$name"
                   5629: 
                   5630:       $show "$install_prog $file $oldlib"
                   5631:       $run eval "$install_prog \$file \$oldlib" || exit $?
                   5632: 
                   5633:       if test -n "$stripme" && test -n "$striplib"; then
                   5634:        $show "$old_striplib $oldlib"
                   5635:        $run eval "$old_striplib $oldlib" || exit $?
                   5636:       fi
                   5637: 
                   5638:       # Do each command in the postinstall commands.
                   5639:       eval cmds=\"$old_postinstall_cmds\"
                   5640:       save_ifs="$IFS"; IFS='~'
                   5641:       for cmd in $cmds; do
                   5642:        IFS="$save_ifs"
                   5643:        $show "$cmd"
                   5644:        $run eval "$cmd" || exit $?
                   5645:       done
                   5646:       IFS="$save_ifs"
                   5647:     done
                   5648: 
                   5649:     if test -n "$future_libdirs"; then
                   5650:       $echo "$modename: warning: remember to run \`$progname --finish$future_libdirs'" 1>&2
                   5651:     fi
                   5652: 
                   5653:     if test -n "$current_libdirs"; then
                   5654:       # Maybe just do a dry run.
                   5655:       test -n "$run" && current_libdirs=" -n$current_libdirs"
                   5656:       exec_cmd='$SHELL $0 --finish$current_libdirs'
                   5657:     else
                   5658:       exit 0
                   5659:     fi
                   5660:     ;;
                   5661: 
                   5662:   # libtool finish mode
                   5663:   finish)
                   5664:     modename="$modename: finish"
                   5665:     libdirs="$nonopt"
                   5666:     admincmds=
                   5667: 
                   5668:     if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
                   5669:       for dir
                   5670:       do
                   5671:        libdirs="$libdirs $dir"
                   5672:       done
                   5673: 
                   5674:       for libdir in $libdirs; do
                   5675:        if test -n "$finish_cmds"; then
                   5676:          # Do each command in the finish commands.
                   5677:          eval cmds=\"$finish_cmds\"
                   5678:          save_ifs="$IFS"; IFS='~'
                   5679:          for cmd in $cmds; do
                   5680:            IFS="$save_ifs"
                   5681:            $show "$cmd"
                   5682:            $run eval "$cmd" || admincmds="$admincmds
                   5683:        $cmd"
                   5684:          done
                   5685:          IFS="$save_ifs"
                   5686:        fi
                   5687:        if test -n "$finish_eval"; then
                   5688:          # Do the single finish_eval.
                   5689:          eval cmds=\"$finish_eval\"
                   5690:          $run eval "$cmds" || admincmds="$admincmds
                   5691:        $cmds"
                   5692:        fi
                   5693:       done
                   5694:     fi
                   5695: 
                   5696:     # Exit here if they wanted silent mode.
                   5697:     test "$show" = : && exit 0
                   5698: 
                   5699:     $echo "----------------------------------------------------------------------"
                   5700:     $echo "Libraries have been installed in:"
                   5701:     for libdir in $libdirs; do
                   5702:       $echo "   $libdir"
                   5703:     done
                   5704:     $echo
                   5705:     $echo "If you ever happen to want to link against installed libraries"
                   5706:     $echo "in a given directory, LIBDIR, you must either use libtool, and"
                   5707:     $echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
                   5708:     $echo "flag during linking and do at least one of the following:"
                   5709:     if test -n "$shlibpath_var"; then
                   5710:       $echo "   - add LIBDIR to the \`$shlibpath_var' environment variable"
                   5711:       $echo "     during execution"
                   5712:     fi
                   5713:     if test -n "$runpath_var"; then
                   5714:       $echo "   - add LIBDIR to the \`$runpath_var' environment variable"
                   5715:       $echo "     during linking"
                   5716:     fi
                   5717:     if test -n "$hardcode_libdir_flag_spec"; then
                   5718:       libdir=LIBDIR
                   5719:       eval flag=\"$hardcode_libdir_flag_spec\"
                   5720: 
                   5721:       $echo "   - use the \`$flag' linker flag"
                   5722:     fi
                   5723:     if test -n "$admincmds"; then
                   5724:       $echo "   - have your system administrator run these commands:$admincmds"
                   5725:     fi
                   5726:     if test -f /etc/ld.so.conf; then
                   5727:       $echo "   - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
                   5728:     fi
                   5729:     $echo
                   5730:     $echo "See any operating system documentation about shared libraries for"
                   5731:     $echo "more information, such as the ld(1) and ld.so(8) manual pages."
                   5732:     $echo "----------------------------------------------------------------------"
                   5733:     exit 0
                   5734:     ;;
                   5735: 
                   5736:   # libtool execute mode
                   5737:   execute)
                   5738:     modename="$modename: execute"
                   5739: 
                   5740:     # The first argument is the command name.
                   5741:     cmd="$nonopt"
                   5742:     if test -z "$cmd"; then
                   5743:       $echo "$modename: you must specify a COMMAND" 1>&2
                   5744:       $echo "$help"
                   5745:       exit 1
                   5746:     fi
                   5747: 
                   5748:     # Handle -dlopen flags immediately.
                   5749:     for file in $execute_dlfiles; do
                   5750:       if test ! -f "$file"; then
                   5751:        $echo "$modename: \`$file' is not a file" 1>&2
                   5752:        $echo "$help" 1>&2
                   5753:        exit 1
                   5754:       fi
                   5755: 
                   5756:       dir=
                   5757:       case $file in
                   5758:       *.la)
                   5759:        # Check to see that this really is a libtool archive.
                   5760:        if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
                   5761:        else
                   5762:          $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
                   5763:          $echo "$help" 1>&2
                   5764:          exit 1
                   5765:        fi
                   5766: 
                   5767:        # Read the libtool library.
                   5768:        dlname=
                   5769:        library_names=
                   5770: 
                   5771:        # If there is no directory component, then add one.
                   5772:        case $file in
                   5773:        */* | *\\*) . $file ;;
                   5774:        *) . ./$file ;;
                   5775:        esac
                   5776: 
                   5777:        # Skip this library if it cannot be dlopened.
                   5778:        if test -z "$dlname"; then
                   5779:          # Warn if it was a shared library.
                   5780:          test -n "$library_names" && $echo "$modename: warning: \`$file' was not linked with \`-export-dynamic'"
                   5781:          continue
                   5782:        fi
                   5783: 
                   5784:        dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
                   5785:        test "X$dir" = "X$file" && dir=.
                   5786: 
                   5787:        if test -f "$dir/$objdir/$dlname"; then
                   5788:          dir="$dir/$objdir"
                   5789:        else
                   5790:          $echo "$modename: cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'" 1>&2
                   5791:          exit 1
                   5792:        fi
                   5793:        ;;
                   5794: 
                   5795:       *.lo)
                   5796:        # Just add the directory containing the .lo file.
                   5797:        dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
                   5798:        test "X$dir" = "X$file" && dir=.
                   5799:        ;;
                   5800: 
                   5801:       *)
                   5802:        $echo "$modename: warning \`-dlopen' is ignored for non-libtool libraries and objects" 1>&2
                   5803:        continue
                   5804:        ;;
                   5805:       esac
                   5806: 
                   5807:       # Get the absolute pathname.
                   5808:       absdir=`cd "$dir" && pwd`
                   5809:       test -n "$absdir" && dir="$absdir"
                   5810: 
                   5811:       # Now add the directory to shlibpath_var.
                   5812:       if eval "test -z \"\$$shlibpath_var\""; then
                   5813:        eval "$shlibpath_var=\"\$dir\""
                   5814:       else
                   5815:        eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
                   5816:       fi
                   5817:     done
                   5818: 
                   5819:     # This variable tells wrapper scripts just to set shlibpath_var
                   5820:     # rather than running their programs.
                   5821:     libtool_execute_magic="$magic"
                   5822: 
                   5823:     # Check if any of the arguments is a wrapper script.
                   5824:     args=
                   5825:     for file
                   5826:     do
                   5827:       case $file in
                   5828:       -*) ;;
                   5829:       *)
                   5830:        # Do a test to see if this is really a libtool program.
                   5831:        if (${SED} -e '4q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
                   5832:          # If there is no directory component, then add one.
                   5833:          case $file in
                   5834:          */* | *\\*) . $file ;;
                   5835:          *) . ./$file ;;
                   5836:          esac
                   5837: 
                   5838:          # Transform arg to wrapped name.
                   5839:          file="$progdir/$program"
                   5840:        fi
                   5841:        ;;
                   5842:       esac
                   5843:       # Quote arguments (to preserve shell metacharacters).
                   5844:       file=`$echo "X$file" | $Xsed -e "$sed_quote_subst"`
                   5845:       args="$args \"$file\""
                   5846:     done
                   5847: 
                   5848:     if test -z "$run"; then
                   5849:       if test -n "$shlibpath_var"; then
                   5850:        # Export the shlibpath_var.
                   5851:        eval "export $shlibpath_var"
                   5852:       fi
                   5853: 
                   5854:       # Restore saved environment variables
                   5855:       if test "${save_LC_ALL+set}" = set; then
                   5856:        LC_ALL="$save_LC_ALL"; export LC_ALL
                   5857:       fi
                   5858:       if test "${save_LANG+set}" = set; then
                   5859:        LANG="$save_LANG"; export LANG
                   5860:       fi
                   5861: 
                   5862:       # Now prepare to actually exec the command.
                   5863:       exec_cmd="\$cmd$args"
                   5864:     else
                   5865:       # Display what would be done.
                   5866:       if test -n "$shlibpath_var"; then
                   5867:        eval "\$echo \"\$shlibpath_var=\$$shlibpath_var\""
                   5868:        $echo "export $shlibpath_var"
                   5869:       fi
                   5870:       $echo "$cmd$args"
                   5871:       exit 0
                   5872:     fi
                   5873:     ;;
                   5874: 
                   5875:   # libtool clean and uninstall mode
                   5876:   clean | uninstall)
                   5877:     modename="$modename: $mode"
                   5878:     rm="$nonopt"
                   5879:     files=
                   5880:     rmforce=
                   5881:     exit_status=0
                   5882: 
                   5883:     # This variable tells wrapper scripts just to set variables rather
                   5884:     # than running their programs.
                   5885:     libtool_install_magic="$magic"
                   5886: 
                   5887:     for arg
                   5888:     do
                   5889:       case $arg in
                   5890:       -f) rm="$rm $arg"; rmforce=yes ;;
                   5891:       -*) rm="$rm $arg" ;;
                   5892:       *) files="$files $arg" ;;
                   5893:       esac
                   5894:     done
                   5895: 
                   5896:     if test -z "$rm"; then
                   5897:       $echo "$modename: you must specify an RM program" 1>&2
                   5898:       $echo "$help" 1>&2
                   5899:       exit 1
                   5900:     fi
                   5901: 
                   5902:     rmdirs=
                   5903: 
                   5904:     origobjdir="$objdir"
                   5905:     for file in $files; do
                   5906:       dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
                   5907:       if test "X$dir" = "X$file"; then
                   5908:        dir=.
                   5909:        objdir="$origobjdir"
                   5910:       else
                   5911:        objdir="$dir/$origobjdir"
                   5912:       fi
                   5913:       name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
                   5914:       test "$mode" = uninstall && objdir="$dir"
                   5915: 
                   5916:       # Remember objdir for removal later, being careful to avoid duplicates
                   5917:       if test "$mode" = clean; then
                   5918:        case " $rmdirs " in
                   5919:          *" $objdir "*) ;;
                   5920:          *) rmdirs="$rmdirs $objdir" ;;
                   5921:        esac
                   5922:       fi
                   5923: 
                   5924:       # Don't error if the file doesn't exist and rm -f was used.
                   5925:       if (test -L "$file") >/dev/null 2>&1 \
                   5926:        || (test -h "$file") >/dev/null 2>&1 \
                   5927:        || test -f "$file"; then
                   5928:        :
                   5929:       elif test -d "$file"; then
                   5930:        exit_status=1
                   5931:        continue
                   5932:       elif test "$rmforce" = yes; then
                   5933:        continue
                   5934:       fi
                   5935: 
                   5936:       rmfiles="$file"
                   5937: 
                   5938:       case $name in
                   5939:       *.la)
                   5940:        # Possibly a libtool archive, so verify it.
                   5941:        if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
                   5942:          . $dir/$name
                   5943: 
                   5944:          # Delete the libtool libraries and symlinks.
                   5945:          for n in $library_names; do
                   5946:            rmfiles="$rmfiles $objdir/$n"
                   5947:          done
                   5948:          test -n "$old_library" && rmfiles="$rmfiles $objdir/$old_library"
                   5949:          test "$mode" = clean && rmfiles="$rmfiles $objdir/$name $objdir/${name}i"
                   5950: 
                   5951:          if test "$mode" = uninstall; then
                   5952:            if test -n "$library_names"; then
                   5953:              # Do each command in the postuninstall commands.
                   5954:              eval cmds=\"$postuninstall_cmds\"
                   5955:              save_ifs="$IFS"; IFS='~'
                   5956:              for cmd in $cmds; do
                   5957:                IFS="$save_ifs"
                   5958:                $show "$cmd"
                   5959:                $run eval "$cmd"
                   5960:                if test "$?" -ne 0 && test "$rmforce" != yes; then
                   5961:                  exit_status=1
                   5962:                fi
                   5963:              done
                   5964:              IFS="$save_ifs"
                   5965:            fi
                   5966: 
                   5967:            if test -n "$old_library"; then
                   5968:              # Do each command in the old_postuninstall commands.
                   5969:              eval cmds=\"$old_postuninstall_cmds\"
                   5970:              save_ifs="$IFS"; IFS='~'
                   5971:              for cmd in $cmds; do
                   5972:                IFS="$save_ifs"
                   5973:                $show "$cmd"
                   5974:                $run eval "$cmd"
                   5975:                if test "$?" -ne 0 && test "$rmforce" != yes; then
                   5976:                  exit_status=1
                   5977:                fi
                   5978:              done
                   5979:              IFS="$save_ifs"
                   5980:            fi
                   5981:            # FIXME: should reinstall the best remaining shared library.
                   5982:          fi
                   5983:        fi
                   5984:        ;;
                   5985: 
                   5986:       *.lo)
                   5987:        # Possibly a libtool object, so verify it.
                   5988:        if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
                   5989: 
                   5990:          # Read the .lo file
                   5991:          . $dir/$name
                   5992: 
                   5993:          # Add PIC object to the list of files to remove.
                   5994:          if test -n "$pic_object" \
                   5995:             && test "$pic_object" != none; then
                   5996:            rmfiles="$rmfiles $dir/$pic_object"
                   5997:          fi
                   5998: 
                   5999:          # Add non-PIC object to the list of files to remove.
                   6000:          if test -n "$non_pic_object" \
                   6001:             && test "$non_pic_object" != none; then
                   6002:            rmfiles="$rmfiles $dir/$non_pic_object"
                   6003:          fi
                   6004:        fi
                   6005:        ;;
                   6006: 
                   6007:       *)
                   6008:        if test "$mode" = clean ; then
                   6009:          noexename=$name
                   6010:          case $file in
                   6011:          *.exe) 
                   6012:            file=`$echo $file|${SED} 's,.exe$,,'`
                   6013:            noexename=`$echo $name|${SED} 's,.exe$,,'`
                   6014:            # $file with .exe has already been added to rmfiles,
                   6015:            # add $file without .exe
                   6016:            rmfiles="$rmfiles $file"
                   6017:            ;;
                   6018:          esac
                   6019:          # Do a test to see if this is a libtool program.
                   6020:          if (${SED} -e '4q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
                   6021:            relink_command=
                   6022:            . $dir/$noexename
                   6023: 
                   6024:            # note $name still contains .exe if it was in $file originally
                   6025:            # as does the version of $file that was added into $rmfiles
                   6026:            rmfiles="$rmfiles $objdir/$name $objdir/${name}S.${objext}"
                   6027:            if test "$fast_install" = yes && test -n "$relink_command"; then
                   6028:              rmfiles="$rmfiles $objdir/lt-$name"
                   6029:            fi
                   6030:            if test "X$noexename" != "X$name" ; then
                   6031:              rmfiles="$rmfiles $objdir/lt-${noexename}.c"
                   6032:            fi
                   6033:          fi
                   6034:        fi
                   6035:        ;;
                   6036:       esac
                   6037:       $show "$rm $rmfiles"
                   6038:       $run $rm $rmfiles || exit_status=1
                   6039:     done
                   6040:     objdir="$origobjdir"
                   6041: 
                   6042:     # Try to remove the ${objdir}s in the directories where we deleted files
                   6043:     for dir in $rmdirs; do
                   6044:       if test -d "$dir"; then
                   6045:        $show "rmdir $dir"
                   6046:        $run rmdir $dir >/dev/null 2>&1
                   6047:       fi
                   6048:     done
                   6049: 
                   6050:     exit $exit_status
                   6051:     ;;
                   6052: 
                   6053:   "")
                   6054:     $echo "$modename: you must specify a MODE" 1>&2
                   6055:     $echo "$generic_help" 1>&2
                   6056:     exit 1
                   6057:     ;;
                   6058:   esac
                   6059: 
                   6060:   if test -z "$exec_cmd"; then
                   6061:     $echo "$modename: invalid operation mode \`$mode'" 1>&2
                   6062:     $echo "$generic_help" 1>&2
                   6063:     exit 1
                   6064:   fi
                   6065: fi # test -z "$show_help"
                   6066: 
                   6067: if test -n "$exec_cmd"; then
                   6068:   eval exec $exec_cmd
                   6069:   exit 1
                   6070: fi
                   6071: 
                   6072: # We need to display help for each of the modes.
                   6073: case $mode in
                   6074: "") $echo \
                   6075: "Usage: $modename [OPTION]... [MODE-ARG]...
                   6076: 
                   6077: Provide generalized library-building support services.
                   6078: 
                   6079:     --config          show all configuration variables
                   6080:     --debug           enable verbose shell tracing
                   6081: -n, --dry-run         display commands without modifying any files
                   6082:     --features        display basic configuration information and exit
                   6083:     --finish          same as \`--mode=finish'
                   6084:     --help            display this help message and exit
                   6085:     --mode=MODE       use operation mode MODE [default=inferred from MODE-ARGS]
                   6086:     --quiet           same as \`--silent'
                   6087:     --silent          don't print informational messages
                   6088:     --tag=TAG         use configuration variables from tag TAG
                   6089:     --version         print version information
                   6090: 
                   6091: MODE must be one of the following:
                   6092: 
                   6093:       clean           remove files from the build directory
                   6094:       compile         compile a source file into a libtool object
                   6095:       execute         automatically set library path, then run a program
                   6096:       finish          complete the installation of libtool libraries
                   6097:       install         install libraries or executables
                   6098:       link            create a library or an executable
                   6099:       uninstall       remove libraries from an installed directory
                   6100: 
                   6101: MODE-ARGS vary depending on the MODE.  Try \`$modename --help --mode=MODE' for
                   6102: a more detailed description of MODE.
                   6103: 
                   6104: Report bugs to <bug-libtool@gnu.org>."
                   6105:   exit 0
                   6106:   ;;
                   6107: 
                   6108: clean)
                   6109:   $echo \
                   6110: "Usage: $modename [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
                   6111: 
                   6112: Remove files from the build directory.
                   6113: 
                   6114: RM is the name of the program to use to delete files associated with each FILE
                   6115: (typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
                   6116: to RM.
                   6117: 
                   6118: If FILE is a libtool library, object or program, all the files associated
                   6119: with it are deleted. Otherwise, only FILE itself is deleted using RM."
                   6120:   ;;
                   6121: 
                   6122: compile)
                   6123:   $echo \
                   6124: "Usage: $modename [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
                   6125: 
                   6126: Compile a source file into a libtool library object.
                   6127: 
                   6128: This mode accepts the following additional options:
                   6129: 
                   6130:   -o OUTPUT-FILE    set the output file name to OUTPUT-FILE
                   6131:   -prefer-pic       try to building PIC objects only
                   6132:   -prefer-non-pic   try to building non-PIC objects only
                   6133:   -static           always build a \`.o' file suitable for static linking
                   6134: 
                   6135: COMPILE-COMMAND is a command to be used in creating a \`standard' object file
                   6136: from the given SOURCEFILE.
                   6137: 
                   6138: The output file name is determined by removing the directory component from
                   6139: SOURCEFILE, then substituting the C source code suffix \`.c' with the
                   6140: library object suffix, \`.lo'."
                   6141:   ;;
                   6142: 
                   6143: execute)
                   6144:   $echo \
                   6145: "Usage: $modename [OPTION]... --mode=execute COMMAND [ARGS]...
                   6146: 
                   6147: Automatically set library path, then run a program.
                   6148: 
                   6149: This mode accepts the following additional options:
                   6150: 
                   6151:   -dlopen FILE      add the directory containing FILE to the library path
                   6152: 
                   6153: This mode sets the library path environment variable according to \`-dlopen'
                   6154: flags.
                   6155: 
                   6156: If any of the ARGS are libtool executable wrappers, then they are translated
                   6157: into their corresponding uninstalled binary, and any of their required library
                   6158: directories are added to the library path.
                   6159: 
                   6160: Then, COMMAND is executed, with ARGS as arguments."
                   6161:   ;;
                   6162: 
                   6163: finish)
                   6164:   $echo \
                   6165: "Usage: $modename [OPTION]... --mode=finish [LIBDIR]...
                   6166: 
                   6167: Complete the installation of libtool libraries.
                   6168: 
                   6169: Each LIBDIR is a directory that contains libtool libraries.
                   6170: 
                   6171: The commands that this mode executes may require superuser privileges.  Use
                   6172: the \`--dry-run' option if you just want to see what would be executed."
                   6173:   ;;
                   6174: 
                   6175: install)
                   6176:   $echo \
                   6177: "Usage: $modename [OPTION]... --mode=install INSTALL-COMMAND...
                   6178: 
                   6179: Install executables or libraries.
                   6180: 
                   6181: INSTALL-COMMAND is the installation command.  The first component should be
                   6182: either the \`install' or \`cp' program.
                   6183: 
                   6184: The rest of the components are interpreted as arguments to that command (only
                   6185: BSD-compatible install options are recognized)."
                   6186:   ;;
                   6187: 
                   6188: link)
                   6189:   $echo \
                   6190: "Usage: $modename [OPTION]... --mode=link LINK-COMMAND...
                   6191: 
                   6192: Link object files or libraries together to form another library, or to
                   6193: create an executable program.
                   6194: 
                   6195: LINK-COMMAND is a command using the C compiler that you would use to create
                   6196: a program from several object files.
                   6197: 
                   6198: The following components of LINK-COMMAND are treated specially:
                   6199: 
                   6200:   -all-static       do not do any dynamic linking at all
                   6201:   -avoid-version    do not add a version suffix if possible
                   6202:   -dlopen FILE      \`-dlpreopen' FILE if it cannot be dlopened at runtime
                   6203:   -dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols
                   6204:   -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
                   6205:   -export-symbols SYMFILE
                   6206:                    try to export only the symbols listed in SYMFILE
                   6207:   -export-symbols-regex REGEX
                   6208:                    try to export only the symbols matching REGEX
                   6209:   -LLIBDIR          search LIBDIR for required installed libraries
                   6210:   -lNAME            OUTPUT-FILE requires the installed library libNAME
                   6211:   -module           build a library that can dlopened
                   6212:   -no-fast-install  disable the fast-install mode
                   6213:   -no-install       link a not-installable executable
                   6214:   -no-undefined     declare that a library does not refer to external symbols
                   6215:   -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
                   6216:   -objectlist FILE  Use a list of object files found in FILE to specify objects
                   6217:   -release RELEASE  specify package release information
                   6218:   -rpath LIBDIR     the created library will eventually be installed in LIBDIR
                   6219:   -R[ ]LIBDIR       add LIBDIR to the runtime path of programs and libraries
                   6220:   -static           do not do any dynamic linking of libtool libraries
                   6221:   -version-info CURRENT[:REVISION[:AGE]]
                   6222:                    specify library version info [each variable defaults to 0]
                   6223: 
                   6224: All other options (arguments beginning with \`-') are ignored.
                   6225: 
                   6226: Every other argument is treated as a filename.  Files ending in \`.la' are
                   6227: treated as uninstalled libtool libraries, other files are standard or library
                   6228: object files.
                   6229: 
                   6230: If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
                   6231: only library objects (\`.lo' files) may be specified, and \`-rpath' is
                   6232: required, except when creating a convenience library.
                   6233: 
                   6234: If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
                   6235: using \`ar' and \`ranlib', or on Windows using \`lib'.
                   6236: 
                   6237: If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
                   6238: is created, otherwise an executable program is created."
                   6239:   ;;
                   6240: 
                   6241: uninstall)
                   6242:   $echo \
                   6243: "Usage: $modename [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
                   6244: 
                   6245: Remove libraries from an installation directory.
                   6246: 
                   6247: RM is the name of the program to use to delete files associated with each FILE
                   6248: (typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
                   6249: to RM.
                   6250: 
                   6251: If FILE is a libtool library, all the files associated with it are deleted.
                   6252: Otherwise, only FILE itself is deleted using RM."
                   6253:   ;;
                   6254: 
                   6255: *)
                   6256:   $echo "$modename: invalid operation mode \`$mode'" 1>&2
                   6257:   $echo "$help" 1>&2
                   6258:   exit 1
                   6259:   ;;
                   6260: esac
                   6261: 
                   6262: $echo
                   6263: $echo "Try \`$modename --help' for more information about other modes."
                   6264: 
                   6265: exit 0
                   6266: 
                   6267: # The TAGs below are defined such that we never get into a situation
                   6268: # in which we disable both kinds of libraries.  Given conflicting
                   6269: # choices, we go for a static library, that is the most portable,
                   6270: # since we can't tell whether shared libraries were disabled because
                   6271: # the user asked for that or because the platform doesn't support
                   6272: # them.  This is particularly important on AIX, because we don't
                   6273: # support having both static and shared libraries enabled at the same
                   6274: # time on that platform, so we default to a shared-only configuration.
                   6275: # If a disable-shared tag is given, we'll fallback to a static-only
                   6276: # configuration.  But we'll never go from static-only to shared-only.
                   6277: 
                   6278: # ### BEGIN LIBTOOL TAG CONFIG: disable-shared
                   6279: build_libtool_libs=no
                   6280: build_old_libs=yes
                   6281: # ### END LIBTOOL TAG CONFIG: disable-shared
                   6282: 
                   6283: # ### BEGIN LIBTOOL TAG CONFIG: disable-static
                   6284: build_old_libs=`case $build_libtool_libs in yes) $echo no;; *) $echo yes;; esac`
                   6285: # ### END LIBTOOL TAG CONFIG: disable-static
                   6286: 
                   6287: # Local Variables:
                   6288: # mode:shell-script
                   6289: # sh-indentation:2
                   6290: # End:

unix.superglobalmegacorp.com