Changeset 322 for trunk/autoconf


Ignore:
Timestamp:
Jun 1, 2012 10:14:26 AM (9 years ago)
Author:
awalther
Message:

delete timings in uni5_for.c

Location:
trunk/autoconf
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/autoconf/config.guess

    r321 r322  
    22# Attempt to guess a canonical system name.
    33#   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
    4 #   2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
     4#   2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
    55#   Free Software Foundation, Inc.
    66
    7 timestamp='2009-11-20'
     7timestamp='2009-12-30'
    88
    99# This file is free software; you can redistribute it and/or modify it
     
    5757
    5858Originally written by Per Bothner.
    59 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
    60 2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
     59Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
     602001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free
     61Software Foundation, Inc.
    6162
    6263This is free software; see the source for copying conditions.  There is NO
     
    139140UNAME_SYSTEM=`(uname -s) 2>/dev/null`  || UNAME_SYSTEM=unknown
    140141UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown
    141 
    142 case "${UNAME_MACHINE}" in
    143     i?86)
    144         test -z "$VENDOR" && VENDOR=pc
    145         ;;
    146     *)
    147         test -z "$VENDOR" && VENDOR=unknown
    148         ;;
    149 esac
    150 test -f /etc/SuSE-release -o -f /.buildenv && VENDOR=suse
    151142
    152143# Note: order is significant - the case branches are not exclusive.
     
    214205    *:OpenBSD:*:*)
    215206        UNAME_MACHINE_ARCH=`arch | sed 's/OpenBSD.//'`
    216         echo ${UNAME_MACHINE_ARCH}-${VENDOR}-openbsd${UNAME_RELEASE}
     207        echo ${UNAME_MACHINE_ARCH}-unknown-openbsd${UNAME_RELEASE}
    217208        exit ;;
    218209    *:ekkoBSD:*:*)
    219         echo ${UNAME_MACHINE}-${VENDOR}-ekkobsd${UNAME_RELEASE}
     210        echo ${UNAME_MACHINE}-unknown-ekkobsd${UNAME_RELEASE}
    220211        exit ;;
    221212    *:SolidBSD:*:*)
    222         echo ${UNAME_MACHINE}-${VENDOR}-solidbsd${UNAME_RELEASE}
     213        echo ${UNAME_MACHINE}-unknown-solidbsd${UNAME_RELEASE}
    223214        exit ;;
    224215    macppc:MirBSD:*:*)
    225         echo powerpc-${VENDOR}-mirbsd${UNAME_RELEASE}
     216        echo powerpc-unknown-mirbsd${UNAME_RELEASE}
    226217        exit ;;
    227218    *:MirBSD:*:*)
    228         echo ${UNAME_MACHINE}-${VENDOR}-mirbsd${UNAME_RELEASE}
     219        echo ${UNAME_MACHINE}-unknown-mirbsd${UNAME_RELEASE}
    229220        exit ;;
    230221    alpha:OSF1:*:*)
     
    291282        exit ;;
    292283    Amiga*:UNIX_System_V:4.0:*)
    293         echo m68k-${VENDOR}-sysv4
     284        echo m68k-unknown-sysv4
    294285        exit ;;
    295286    *:[Aa]miga[Oo][Ss]:*:*)
    296         echo ${UNAME_MACHINE}-${VENDOR}-amigaos
     287        echo ${UNAME_MACHINE}-unknown-amigaos
    297288        exit ;;
    298289    *:[Mm]orph[Oo][Ss]:*:*)
    299         echo ${UNAME_MACHINE}-${VENDOR}-morphos
     290        echo ${UNAME_MACHINE}-unknown-morphos
    300291        exit ;;
    301292    *:OS/390:*:*)
     
    312303        exit ;;
    313304    arm:riscos:*:*|arm:RISCOS:*:*)
    314         echo arm-${VENDOR}-riscos
     305        echo arm-unknown-riscos
    315306        exit ;;
    316307    SR2?01:HI-UX/MPP:*:* | SR8000:HI-UX/MPP:*:*)
     
    420411        exit ;;
    421412    *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*)
    422         echo m68k-${VENDOR}-mint${UNAME_RELEASE}
     413        echo m68k-unknown-mint${UNAME_RELEASE}
    423414        exit ;;
    424415    m68k:machten:*:*)
     
    731722    i*86:OSF1:*:*)
    732723        if [ -x /usr/sbin/sysversion ] ; then
    733             echo ${UNAME_MACHINE}-${VENDOR}-osf1mk
     724            echo ${UNAME_MACHINE}-unknown-osf1mk
    734725        else
    735             echo ${UNAME_MACHINE}-${VENDOR}-osf1
     726            echo ${UNAME_MACHINE}-unknown-osf1
    736727        fi
    737728        exit ;;
     
    793784        exit ;;
    794785    sparc*:BSD/OS:*:*)
    795         echo sparc-${VENDOR}-bsdi${UNAME_RELEASE}
     786        echo sparc-unknown-bsdi${UNAME_RELEASE}
    796787        exit ;;
    797788    *:BSD/OS:*:*)
    798         echo ${UNAME_MACHINE}-${VENDOR}-bsdi${UNAME_RELEASE}
     789        echo ${UNAME_MACHINE}-unknown-bsdi${UNAME_RELEASE}
    799790        exit ;;
    800791    *:FreeBSD:*:*)
    801792        case ${UNAME_MACHINE} in
    802793            pc98)
    803                 echo i386-${VENDOR}-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;;
     794                echo i386-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;;
    804795            amd64)
    805                 echo x86_64-${VENDOR}-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;;
     796                echo x86_64-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;;
    806797            *)
    807                 echo ${UNAME_MACHINE}-${VENDOR}-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;;
     798                echo ${UNAME_MACHINE}-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;;
    808799        esac
    809800        exit ;;
     
    827818                exit ;;
    828819            authenticamd | genuineintel | EM64T)
    829                 echo x86_64-${VENDOR}-interix${UNAME_RELEASE}
     820                echo x86_64-unknown-interix${UNAME_RELEASE}
    830821                exit ;;
    831822            IA64)
    832                 echo ia64-${VENDOR}-interix${UNAME_RELEASE}
     823                echo ia64-unknown-interix${UNAME_RELEASE}
    833824                exit ;;
    834825        esac ;;
     
    849840        exit ;;
    850841    amd64:CYGWIN*:*:* | x86_64:CYGWIN*:*:*)
    851         echo x86_64-${VENDOR}-cygwin
     842        echo x86_64-unknown-cygwin
    852843        exit ;;
    853844    p*:CYGWIN*:*)
    854         echo powerpcle-${VENDOR}-cygwin
     845        echo powerpcle-unknown-cygwin
    855846        exit ;;
    856847    prep*:SunOS:5.*:*)
    857         echo powerpcle-${VENDOR}-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
     848        echo powerpcle-unknown-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
    858849        exit ;;
    859850    *:GNU:*:*)
    860851        # the GNU system
    861         echo `echo ${UNAME_MACHINE}|sed -e 's,[-/].*$,,'`-${VENDOR}-gnu`echo ${UNAME_RELEASE}|sed -e 's,/.*$,,'`
     852        echo `echo ${UNAME_MACHINE}|sed -e 's,[-/].*$,,'`-unknown-gnu`echo ${UNAME_RELEASE}|sed -e 's,/.*$,,'`
    862853        exit ;;
    863854    *:GNU/*:*:*)
    864855        # other systems with GNU libc and userland
    865         echo ${UNAME_MACHINE}-${VENDOR}-`echo ${UNAME_SYSTEM} | sed 's,^[^/]*/,,' | tr '[A-Z]' '[a-z]'``echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`-gnu
     856        echo ${UNAME_MACHINE}-unknown-`echo ${UNAME_SYSTEM} | sed 's,^[^/]*/,,' | tr '[A-Z]' '[a-z]'``echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`-gnu
    866857        exit ;;
    867858    i*86:Minix:*:*)
     
    880871        objdump --private-headers /bin/sh | grep -q ld.so.1
    881872        if test "$?" = 0 ; then LIBC="libc1" ; else LIBC="" ; fi
    882         echo ${UNAME_MACHINE}-${VENDOR}-linux-gnu${LIBC}
     873        echo ${UNAME_MACHINE}-unknown-linux-gnu${LIBC}
    883874        exit ;;
    884875    arm*:Linux:*:*)
     
    887878            | grep -q __ARM_EABI__
    888879        then
    889             echo ${UNAME_MACHINE}-${VENDOR}-linux-gnu
     880            echo ${UNAME_MACHINE}-unknown-linux-gnu
    890881        else
    891             echo ${UNAME_MACHINE}-${VENDOR}-linux-gnueabi
     882            echo ${UNAME_MACHINE}-unknown-linux-gnueabi
    892883        fi
    893884        exit ;;
    894885    avr32*:Linux:*:*)
    895         echo ${UNAME_MACHINE}-${VENDOR}-linux-gnu
     886        echo ${UNAME_MACHINE}-unknown-linux-gnu
    896887        exit ;;
    897888    cris:Linux:*:*)
     
    902893        exit ;;
    903894    frv:Linux:*:*)
    904         echo frv-${VENDOR}-linux-gnu
     895        echo frv-unknown-linux-gnu
    905896        exit ;;
    906897    i*86:Linux:*:*)
     
    913904EOF
    914905        eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep '^LIBC'`
    915         echo "${UNAME_MACHINE}-${VENDOR}-linux-${LIBC}"
     906        echo "${UNAME_MACHINE}-pc-linux-${LIBC}"
    916907        exit ;;
    917908    ia64:Linux:*:*)
    918         echo ${UNAME_MACHINE}-${VENDOR}-linux-gnu
     909        echo ${UNAME_MACHINE}-unknown-linux-gnu
    919910        exit ;;
    920911    m32r*:Linux:*:*)
    921         echo ${UNAME_MACHINE}-${VENDOR}-linux-gnu
     912        echo ${UNAME_MACHINE}-unknown-linux-gnu
    922913        exit ;;
    923914    m68*:Linux:*:*)
    924         echo ${UNAME_MACHINE}-${VENDOR}-linux-gnu
     915        echo ${UNAME_MACHINE}-unknown-linux-gnu
    925916        exit ;;
    926917    mips:Linux:*:* | mips64:Linux:*:*)
     
    941932EOF
    942933        eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep '^CPU'`
    943         test x"${CPU}" != x && { echo "${CPU}-${VENDOR}-linux-gnu"; exit; }
     934        test x"${CPU}" != x && { echo "${CPU}-unknown-linux-gnu"; exit; }
    944935        ;;
    945936    or32:Linux:*:*)
    946         echo or32-${VENDOR}-linux-gnu
     937        echo or32-unknown-linux-gnu
    947938        exit ;;
    948939    padre:Linux:*:*)
    949         echo sparc-${VENDOR}-linux-gnu
     940        echo sparc-unknown-linux-gnu
    950941        exit ;;
    951942    parisc64:Linux:*:* | hppa64:Linux:*:*)
    952         echo hppa64-${VENDOR}-linux-gnu
     943        echo hppa64-unknown-linux-gnu
    953944        exit ;;
    954945    parisc:Linux:*:* | hppa:Linux:*:*)
    955946        # Look for CPU level
    956947        case `grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2` in
    957           PA7*) echo hppa1.1-${VENDOR}-linux-gnu ;;
    958           PA8*) echo hppa2.0-${VENDOR}-linux-gnu ;;
    959           *)    echo hppa-${VENDOR}-linux-gnu ;;
     948          PA7*) echo hppa1.1-unknown-linux-gnu ;;
     949          PA8*) echo hppa2.0-unknown-linux-gnu ;;
     950          *)    echo hppa-unknown-linux-gnu ;;
    960951        esac
    961952        exit ;;
    962953    ppc64:Linux:*:*)
    963         echo powerpc64-${VENDOR}-linux-gnu
     954        echo powerpc64-unknown-linux-gnu
    964955        exit ;;
    965956    ppc:Linux:*:*)
    966         echo powerpc-${VENDOR}-linux-gnu
     957        echo powerpc-unknown-linux-gnu
    967958        exit ;;
    968959    s390:Linux:*:* | s390x:Linux:*:*)
     
    970961        exit ;;
    971962    sh64*:Linux:*:*)
    972         echo ${UNAME_MACHINE}-${VENDOR}-linux-gnu
     963        echo ${UNAME_MACHINE}-unknown-linux-gnu
    973964        exit ;;
    974965    sh*:Linux:*:*)
    975         echo ${UNAME_MACHINE}-${VENDOR}-linux-gnu
     966        echo ${UNAME_MACHINE}-unknown-linux-gnu
    976967        exit ;;
    977968    sparc:Linux:*:* | sparc64:Linux:*:*)
    978         echo ${UNAME_MACHINE}-${VENDOR}-linux-gnu
     969        echo ${UNAME_MACHINE}-unknown-linux-gnu
    979970        exit ;;
    980971    vax:Linux:*:*)
     
    982973        exit ;;
    983974    x86_64:Linux:*:*)
    984         echo x86_64-${VENDOR}-linux-gnu
     975        echo x86_64-unknown-linux-gnu
    985976        exit ;;
    986977    xtensa*:Linux:*:*)
    987         echo ${UNAME_MACHINE}-${VENDOR}-linux-gnu
     978        echo ${UNAME_MACHINE}-unknown-linux-gnu
    988979        exit ;;
    989980    i*86:DYNIX/ptx:4*:*)
     
    1007998        exit ;;
    1008999    i*86:XTS-300:*:STOP)
    1009         echo ${UNAME_MACHINE}-${VENDOR}-stop
     1000        echo ${UNAME_MACHINE}-unknown-stop
    10101001        exit ;;
    10111002    i*86:atheos:*:*)
    1012         echo ${UNAME_MACHINE}-${VENDOR}-atheos
     1003        echo ${UNAME_MACHINE}-unknown-atheos
    10131004        exit ;;
    10141005    i*86:syllable:*:*)
     
    10161007        exit ;;
    10171008    i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.[02]*:*)
    1018         echo i386-${VENDOR}-lynxos${UNAME_RELEASE}
     1009        echo i386-unknown-lynxos${UNAME_RELEASE}
    10191010        exit ;;
    10201011    i*86:*DOS:*:*)
     
    10361027            *Pent*|*Celeron) UNAME_MACHINE=i686 ;;
    10371028        esac
    1038         echo ${UNAME_MACHINE}-${VENDOR}-sysv${UNAME_RELEASE}${UNAME_SYSTEM}${UNAME_VERSION}
     1029        echo ${UNAME_MACHINE}-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}${UNAME_VERSION}
    10391030        exit ;;
    10401031    i*86:*:3.2:*)
     
    10751066          echo i860-stardent-sysv${UNAME_RELEASE} # Stardent Vistra i860-SVR4
    10761067        else # Add other i860-SVR4 vendors below as they are discovered.
    1077           echo i860-${VENDOR}-sysv${UNAME_RELEASE}  # Unknown i860-SVR4
     1068          echo i860-unknown-sysv${UNAME_RELEASE}  # Unknown i860-SVR4
    10781069        fi
    10791070        exit ;;
     
    11121103            && { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;;
    11131104    m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*)
    1114         echo m68k-${VENDOR}-lynxos${UNAME_RELEASE}
     1105        echo m68k-unknown-lynxos${UNAME_RELEASE}
    11151106        exit ;;
    11161107    mc68030:UNIX_System_V:4.*:*)
     
    11181109        exit ;;
    11191110    TSUNAMI:LynxOS:2.*:*)
    1120         echo sparc-${VENDOR}-lynxos${UNAME_RELEASE}
     1111        echo sparc-unknown-lynxos${UNAME_RELEASE}
    11211112        exit ;;
    11221113    rs6000:LynxOS:2.*:*)
    1123         echo rs6000-${VENDOR}-lynxos${UNAME_RELEASE}
     1114        echo rs6000-unknown-lynxos${UNAME_RELEASE}
    11241115        exit ;;
    11251116    PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.[02]*:*)
    1126         echo powerpc-${VENDOR}-lynxos${UNAME_RELEASE}
     1117        echo powerpc-unknown-lynxos${UNAME_RELEASE}
    11271118        exit ;;
    11281119    SM[BE]S:UNIX_SV:*:*)
     
    11741165                echo mips-nec-sysv${UNAME_RELEASE}
    11751166        else
    1176                 echo mips-${VENDOR}-sysv${UNAME_RELEASE}
     1167                echo mips-unknown-sysv${UNAME_RELEASE}
    11771168        fi
    11781169        exit ;;
     
    12651256            UNAME_MACHINE="$cputype"
    12661257        fi
    1267         echo ${UNAME_MACHINE}-${VENDOR}-plan9
     1258        echo ${UNAME_MACHINE}-unknown-plan9
    12681259        exit ;;
    12691260    *:TOPS-10:*:*)
    1270         echo pdp10-${VENDOR}-tops10
     1261        echo pdp10-unknown-tops10
    12711262        exit ;;
    12721263    *:TENEX:*:*)
    1273         echo pdp10-${VENDOR}-tenex
     1264        echo pdp10-unknown-tenex
    12741265        exit ;;
    12751266    KS10:TOPS-20:*:* | KL10:TOPS-20:*:* | TYPE4:TOPS-20:*:*)
     
    12801271        exit ;;
    12811272    *:TOPS-20:*:*)
    1282         echo pdp10-${VENDOR}-tops20
     1273        echo pdp10-unknown-tops20
    12831274        exit ;;
    12841275    *:ITS:*:*)
    1285         echo pdp10-${VENDOR}-its
     1276        echo pdp10-unknown-its
    12861277        exit ;;
    12871278    SEI:*:*:SEIUX)
     
    12891280        exit ;;
    12901281    *:DragonFly:*:*)
    1291         echo ${UNAME_MACHINE}-${VENDOR}-dragonfly`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`
     1282        echo ${UNAME_MACHINE}-unknown-dragonfly`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`
    12921283        exit ;;
    12931284    *:*VMS:*:*)
  • trunk/autoconf/config.sub

    r321 r322  
    22# Configuration validation subroutine script.
    33#   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
    4 #   2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
     4#   2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
    55#   Free Software Foundation, Inc.
    66
    7 timestamp='2009-11-20'
     7timestamp='2010-01-22'
    88
    99# This file is (in principle) common to ALL GNU software.
     
    7676GNU config.sub ($timestamp)
    7777
    78 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
    79 2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
     78Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
     792001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free
     80Software Foundation, Inc.
    8081
    8182This is free software; see the source for copying conditions.  There is NO
     
    381382        | sparcv8-* | sparcv9-* | sparcv9b-* | sparcv9v-* | strongarm-* | sv1-* | sx?-* \
    382383        | tahoe-* | thumb-* \
    383         | tic30-* | tic4x-* | tic54x-* | tic55x-* | tic6x-* | tic80-* | tile-* \
     384        | tic30-* | tic4x-* | tic54x-* | tic55x-* | tic6x-* | tic80-* \
     385        | tile-* | tilegx-* \
    384386        | tron-* \
    385387        | ubicom32-* \
     
    10851087                basic_machine=tic6x-unknown
    10861088                os=-coff
     1089                ;;
     1090        # This must be matched before tile*.
     1091        tilegx*)
     1092                basic_machine=tilegx-unknown
     1093                os=-linux-gnu
    10871094                ;;
    10881095        tile*)
     
    14361443                os=-dicos
    14371444                ;;
     1445        -nacl*)
     1446                ;;
    14381447        -none)
    14391448                ;;
  • trunk/autoconf/ltmain.sh

    r321 r322  
    1 
    2 # libtool (GNU libtool) 2.4
     1# Generated from ltmain.m4sh.
     2
     3# ltmain.sh (GNU libtool) 2.2.6b
    34# Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
    45
    5 # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006,
    6 # 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
     6# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006, 2007 2008 Free Software Foundation, Inc.
    77# This is free software; see the source for copying conditions.  There is NO
    88# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
     
    3333# Provide generalized library-building support services.
    3434#
    35 #       --config             show all configuration variables
    36 #       --debug              enable verbose shell tracing
    37 #   -n, --dry-run            display commands without modifying any files
    38 #       --features           display basic configuration information and exit
    39 #       --mode=MODE          use operation mode MODE
    40 #       --preserve-dup-deps  don't remove duplicate dependency libraries
    41 #       --quiet, --silent    don't print informational messages
    42 #       --no-quiet, --no-silent
    43 #                            print informational messages (default)
    44 #       --tag=TAG            use configuration variables from tag TAG
    45 #   -v, --verbose            print more informational messages than default
    46 #       --no-verbose         don't print the extra informational messages
    47 #       --version            print version information
    48 #   -h, --help, --help-all   print short, long, or detailed help message
     35#     --config             show all configuration variables
     36#     --debug              enable verbose shell tracing
     37# -n, --dry-run            display commands without modifying any files
     38#     --features           display basic configuration information and exit
     39#     --mode=MODE          use operation mode MODE
     40#     --preserve-dup-deps  don't remove duplicate dependency libraries
     41#     --quiet, --silent    don't print informational messages
     42#     --tag=TAG            use configuration variables from tag TAG
     43# -v, --verbose            print informational messages (default)
     44#     --version            print version information
     45# -h, --help               print short or long help message
    4946#
    5047# MODE must be one of the following:
    5148#
    52 #         clean              remove files from the build directory
    53 #         compile            compile a source file into a libtool object
    54 #         execute            automatically set library path, then run a program
    55 #         finish             complete the installation of libtool libraries
    56 #         install            install libraries or executables
    57 #         link               create a library or an executable
    58 #         uninstall          remove libraries from an installed directory
     49#       clean              remove files from the build directory
     50#       compile            compile a source file into a libtool object
     51#       execute            automatically set library path, then run a program
     52#       finish             complete the installation of libtool libraries
     53#       install            install libraries or executables
     54#       link               create a library or an executable
     55#       uninstall          remove libraries from an installed directory
    5956#
    60 # MODE-ARGS vary depending on the MODE.  When passed as first option,
    61 # `--mode=MODE' may be abbreviated as `MODE' or a unique abbreviation of that.
     57# MODE-ARGS vary depending on the MODE.
    6258# Try `$progname --help --mode=MODE' for a more detailed description of MODE.
    6359#
     
    6561# include the following information:
    6662#
    67 #         host-triplet: $host
    68 #         shell:                $SHELL
    69 #         compiler:             $LTCC
    70 #         compiler flags:               $LTCFLAGS
    71 #         linker:               $LD (gnu? $with_gnu_ld)
    72 #         $progname:    (GNU libtool) 2.4
    73 #         automake:     $automake_version
    74 #         autoconf:     $autoconf_version
     63#       host-triplet:   $host
     64#       shell:          $SHELL
     65#       compiler:               $LTCC
     66#       compiler flags:         $LTCFLAGS
     67#       linker:         $LD (gnu? $with_gnu_ld)
     68#       $progname:              (GNU libtool) 2.2.6b Debian-2.2.6b-2
     69#       automake:               $automake_version
     70#       autoconf:               $autoconf_version
    7571#
    7672# Report bugs to <bug-libtool@gnu.org>.
    77 # GNU libtool home page: <http://www.gnu.org/software/libtool/>.
    78 # General help using GNU software: <http://www.gnu.org/gethelp/>.
    79 
    80 PROGRAM=libtool
     73
     74PROGRAM=ltmain.sh
    8175PACKAGE=libtool
    82 VERSION=2.4
     76VERSION="2.2.6b Debian-2.2.6b-2"
    8377TIMESTAMP=""
    84 package_revision=1.3293
     78package_revision=1.3017
    8579
    8680# Be Bourne compatible
     
    9892DUALCASE=1; export DUALCASE # for MKS sh
    9993
    100 # A function that is used when there is no print builtin or printf.
    101 func_fallback_echo ()
    102 {
    103   eval 'cat <<_LTECHO_EOF
    104 $1
    105 _LTECHO_EOF'
    106 }
    107 
    10894# NLS nuisances: We save the old values to restore during execute mode.
     95# Only set LANG and LC_ALL to C if already set.
     96# These must not be set unconditionally because not all systems understand
     97# e.g. LANG=C (notably SCO).
    10998lt_user_locale=
    11099lt_safe_locale=
     
    119108        fi"
    120109done
    121 LC_ALL=C
    122 LANGUAGE=C
    123 export LANGUAGE LC_ALL
    124110
    125111$lt_unset CDPATH
    126112
    127113
    128 # Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
    129 # is ksh but when the shell is invoked as "sh" and the current value of
    130 # the _XPG environment variable is not equal to 1 (one), the special
    131 # positional parameter $0, within a function call, is the name of the
    132 # function.
    133 progpath="$0"
    134114
    135115
    136116
    137117: ${CP="cp -f"}
    138 test "${ECHO+set}" = set || ECHO=${as_echo-'printf %s\n'}
    139 : ${EGREP="grep -E"}
    140 : ${FGREP="grep -F"}
    141 : ${GREP="grep"}
     118: ${ECHO="echo"}
     119: ${EGREP="/bin/grep -E"}
     120: ${FGREP="/bin/grep -F"}
     121: ${GREP="/bin/grep"}
    142122: ${LN_S="ln -s"}
    143123: ${MAKE="make"}
     
    145125: ${MV="mv -f"}
    146126: ${RM="rm -f"}
    147 : ${SED="sed"}
     127: ${SED="/bin/sed"}
    148128: ${SHELL="${CONFIG_SHELL-/bin/sh}"}
    149129: ${Xsed="$SED -e 1s/^X//"}
     
    164144dirname="s,/[^/]*$,,"
    165145basename="s,^.*/,,"
    166 
    167 # func_dirname file append nondir_replacement
    168 # Compute the dirname of FILE.  If nonempty, add APPEND to the result,
    169 # otherwise set result to NONDIR_REPLACEMENT.
    170 func_dirname ()
    171 {
    172     func_dirname_result=`$ECHO "${1}" | $SED "$dirname"`
    173     if test "X$func_dirname_result" = "X${1}"; then
    174       func_dirname_result="${3}"
    175     else
    176       func_dirname_result="$func_dirname_result${2}"
    177     fi
    178 } # func_dirname may be replaced by extended shell implementation
    179 
    180 
    181 # func_basename file
    182 func_basename ()
    183 {
    184     func_basename_result=`$ECHO "${1}" | $SED "$basename"`
    185 } # func_basename may be replaced by extended shell implementation
    186 
    187146
    188147# func_dirname_and_basename file append nondir_replacement
     
    200159func_dirname_and_basename ()
    201160{
    202     # Extract subdirectory from the argument.
    203     func_dirname_result=`$ECHO "${1}" | $SED -e "$dirname"`
    204     if test "X$func_dirname_result" = "X${1}"; then
    205       func_dirname_result="${3}"
    206     else
    207       func_dirname_result="$func_dirname_result${2}"
    208     fi
    209     func_basename_result=`$ECHO "${1}" | $SED -e "$basename"`
    210 } # func_dirname_and_basename may be replaced by extended shell implementation
    211 
    212 
    213 # func_stripname prefix suffix name
    214 # strip PREFIX and SUFFIX off of NAME.
    215 # PREFIX and SUFFIX must not contain globbing or regex special
    216 # characters, hashes, percent signs, but SUFFIX may contain a leading
    217 # dot (in which case that matches only a dot).
    218 # func_strip_suffix prefix name
    219 func_stripname ()
    220 {
    221     case ${2} in
    222       .*) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%\\\\${2}\$%%"`;;
    223       *)  func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%${2}\$%%"`;;
    224     esac
    225 } # func_stripname may be replaced by extended shell implementation
    226 
    227 
    228 # These SED scripts presuppose an absolute path with a trailing slash.
    229 pathcar='s,^/\([^/]*\).*$,\1,'
    230 pathcdr='s,^/[^/]*,,'
    231 removedotparts=':dotsl
    232                 s@/\./@/@g
    233                 t dotsl
    234                 s,/\.$,/,'
    235 collapseslashes='s@/\{1,\}@/@g'
    236 finalslash='s,/*$,/,'
    237 
    238 # func_normal_abspath PATH
    239 # Remove doubled-up and trailing slashes, "." path components,
    240 # and cancel out any ".." path components in PATH after making
    241 # it an absolute path.
    242 #             value returned in "$func_normal_abspath_result"
    243 func_normal_abspath ()
    244 {
    245   # Start from root dir and reassemble the path.
    246   func_normal_abspath_result=
    247   func_normal_abspath_tpath=$1
    248   func_normal_abspath_altnamespace=
    249   case $func_normal_abspath_tpath in
    250     "")
    251       # Empty path, that just means $cwd.
    252       func_stripname '' '/' "`pwd`"
    253       func_normal_abspath_result=$func_stripname_result
    254       return
    255     ;;
    256     # The next three entries are used to spot a run of precisely
    257     # two leading slashes without using negated character classes;
    258     # we take advantage of case's first-match behaviour.
    259     ///*)
    260       # Unusual form of absolute path, do nothing.
    261     ;;
    262     //*)
    263       # Not necessarily an ordinary path; POSIX reserves leading '//'
    264       # and for example Cygwin uses it to access remote file shares
    265       # over CIFS/SMB, so we conserve a leading double slash if found.
    266       func_normal_abspath_altnamespace=/
    267     ;;
    268     /*)
    269       # Absolute path, do nothing.
    270     ;;
    271     *)
    272       # Relative path, prepend $cwd.
    273       func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath
    274     ;;
    275   esac
    276   # Cancel out all the simple stuff to save iterations.  We also want
    277   # the path to end with a slash for ease of parsing, so make sure
    278   # there is one (and only one) here.
    279   func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
    280         -e "$removedotparts" -e "$collapseslashes" -e "$finalslash"`
    281   while :; do
    282     # Processed it all yet?
    283     if test "$func_normal_abspath_tpath" = / ; then
    284       # If we ascended to the root using ".." the result may be empty now.
    285       if test -z "$func_normal_abspath_result" ; then
    286         func_normal_abspath_result=/
    287       fi
    288       break
    289     fi
    290     func_normal_abspath_tcomponent=`$ECHO "$func_normal_abspath_tpath" | $SED \
    291         -e "$pathcar"`
    292     func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
    293         -e "$pathcdr"`
    294     # Figure out what to do with it
    295     case $func_normal_abspath_tcomponent in
    296       "")
    297         # Trailing empty path component, ignore it.
    298       ;;
    299       ..)
    300         # Parent dir; strip last assembled component from result.
    301         func_dirname "$func_normal_abspath_result"
    302         func_normal_abspath_result=$func_dirname_result
    303       ;;
    304       *)
    305         # Actual path component, append it.
    306         func_normal_abspath_result=$func_normal_abspath_result/$func_normal_abspath_tcomponent
    307       ;;
    308     esac
    309   done
    310   # Restore leading double-slash if one was found on entry.
    311   func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result
     161  # Extract subdirectory from the argument.
     162  func_dirname_result=`$ECHO "X${1}" | $Xsed -e "$dirname"`
     163  if test "X$func_dirname_result" = "X${1}"; then
     164    func_dirname_result="${3}"
     165  else
     166    func_dirname_result="$func_dirname_result${2}"
     167  fi
     168  func_basename_result=`$ECHO "X${1}" | $Xsed -e "$basename"`
    312169}
    313170
    314 # func_relative_path SRCDIR DSTDIR
    315 # generates a relative path from SRCDIR to DSTDIR, with a trailing
    316 # slash if non-empty, suitable for immediately appending a filename
    317 # without needing to append a separator.
    318 #             value returned in "$func_relative_path_result"
    319 func_relative_path ()
    320 {
    321   func_relative_path_result=
    322   func_normal_abspath "$1"
    323   func_relative_path_tlibdir=$func_normal_abspath_result
    324   func_normal_abspath "$2"
    325   func_relative_path_tbindir=$func_normal_abspath_result
    326 
    327   # Ascend the tree starting from libdir
    328   while :; do
    329     # check if we have found a prefix of bindir
    330     case $func_relative_path_tbindir in
    331       $func_relative_path_tlibdir)
    332         # found an exact match
    333         func_relative_path_tcancelled=
    334         break
    335         ;;
    336       $func_relative_path_tlibdir*)
    337         # found a matching prefix
    338         func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir"
    339         func_relative_path_tcancelled=$func_stripname_result
    340         if test -z "$func_relative_path_result"; then
    341           func_relative_path_result=.
    342         fi
    343         break
    344         ;;
    345       *)
    346         func_dirname $func_relative_path_tlibdir
    347         func_relative_path_tlibdir=${func_dirname_result}
    348         if test "x$func_relative_path_tlibdir" = x ; then
    349           # Have to descend all the way to the root!
    350           func_relative_path_result=../$func_relative_path_result
    351           func_relative_path_tcancelled=$func_relative_path_tbindir
    352           break
    353         fi
    354         func_relative_path_result=../$func_relative_path_result
    355         ;;
    356     esac
    357   done
    358 
    359   # Now calculate path; take care to avoid doubling-up slashes.
    360   func_stripname '' '/' "$func_relative_path_result"
    361   func_relative_path_result=$func_stripname_result
    362   func_stripname '/' '/' "$func_relative_path_tcancelled"
    363   if test "x$func_stripname_result" != x ; then
    364     func_relative_path_result=${func_relative_path_result}/${func_stripname_result}
    365   fi
    366 
    367   # Normalisation. If bindir is libdir, return empty string,
    368   # else relative path ending with a slash; either way, target
    369   # file name can be directly appended.
    370   if test ! -z "$func_relative_path_result"; then
    371     func_stripname './' '' "$func_relative_path_result/"
    372     func_relative_path_result=$func_stripname_result
    373   fi
    374 }
     171# Generated shell functions inserted here.
     172
     173# Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
     174# is ksh but when the shell is invoked as "sh" and the current value of
     175# the _XPG environment variable is not equal to 1 (one), the special
     176# positional parameter $0, within a function call, is the name of the
     177# function.
     178progpath="$0"
    375179
    376180# The name of this program:
     181# In the unlikely event $progname began with a '-', it would play havoc with
     182# func_echo (imagine progname=-n), so we prepend ./ in that case:
    377183func_dirname_and_basename "$progpath"
    378184progname=$func_basename_result
     185case $progname in
     186  -*) progname=./$progname ;;
     187esac
    379188
    380189# Make sure we have an absolute path for reexecution:
     
    407216double_quote_subst='s/\(["`\\]\)/\\\1/g'
    408217
    409 # Sed substitution that turns a string into a regex matching for the
    410 # string literally.
    411 sed_make_literal_regex='s,[].[^$\\*\/],\\&,g'
    412 
    413 # Sed substitution that converts a w32 file name or path
    414 # which contains forward slashes, into one that contains
    415 # (escaped) backslashes.  A very naive implementation.
    416 lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
    417 
    418218# Re-`\' parameter expansions in output of double_quote_subst that were
    419219# `\'-ed in input to the same.  If an odd number of `\' preceded a '$'
     
    444244func_echo ()
    445245{
    446     $ECHO "$progname: ${opt_mode+$opt_mode: }$*"
     246    $ECHO "$progname${mode+: }$mode: $*"
    447247}
    448248
     
    459259}
    460260
    461 # func_echo_all arg...
    462 # Invoke $ECHO with all args, space-separated.
    463 func_echo_all ()
    464 {
    465     $ECHO "$*"
    466 }
    467 
    468261# func_error arg...
    469262# Echo program name prefixed message to standard error.
    470263func_error ()
    471264{
    472     $ECHO "$progname: ${opt_mode+$opt_mode: }"${1+"$@"} 1>&2
     265    $ECHO "$progname${mode+: }$mode: "${1+"$@"} 1>&2
    473266}
    474267
     
    477270func_warning ()
    478271{
    479     $opt_warning && $ECHO "$progname: ${opt_mode+$opt_mode: }warning: "${1+"$@"} 1>&2
     272    $opt_warning && $ECHO "$progname${mode+: }$mode: warning: "${1+"$@"} 1>&2
    480273
    481274    # bash bug again:
     
    534327
    535328        # ...otherwise throw away the child directory and loop
    536         my_directory_path=`$ECHO "$my_directory_path" | $SED -e "$dirname"`
     329        my_directory_path=`$ECHO "X$my_directory_path" | $Xsed -e "$dirname"`
    537330      done
    538       my_dir_list=`$ECHO "$my_dir_list" | $SED 's,:*$,,'`
     331      my_dir_list=`$ECHO "X$my_dir_list" | $Xsed -e 's,:*$,,'`
    539332
    540333      save_mkdir_p_IFS="$IFS"; IFS=':'
     
    586379    fi
    587380
    588     $ECHO "$my_tmpdir"
     381    $ECHO "X$my_tmpdir" | $Xsed
    589382}
    590383
     
    600393    case $1 in
    601394      *[\\\`\"\$]*)
    602         func_quote_for_eval_unquoted_result=`$ECHO "$1" | $SED "$sed_quote_subst"` ;;
     395        func_quote_for_eval_unquoted_result=`$ECHO "X$1" | $Xsed -e "$sed_quote_subst"` ;;
    603396      *)
    604397        func_quote_for_eval_unquoted_result="$1" ;;
     
    627420    case $1 in
    628421      *[\\\`\"]*)
    629         my_arg=`$ECHO "$1" | $SED \
     422        my_arg=`$ECHO "X$1" | $Xsed \
    630423            -e "$double_quote_subst" -e "$sed_double_backslash"` ;;
    631424      *)
     
    696489}
    697490
    698 # func_tr_sh
    699 # Turn $1 into a string suitable for a shell variable name.
    700 # Result is stored in $func_tr_sh_result.  All characters
    701 # not in the set a-zA-Z0-9_ are replaced with '_'. Further,
    702 # if $1 begins with a digit, a '_' is prepended as well.
    703 func_tr_sh ()
    704 {
    705   case $1 in
    706   [0-9]* | *[!a-zA-Z0-9_]*)
    707     func_tr_sh_result=`$ECHO "$1" | $SED 's/^\([0-9]\)/_\1/; s/[^a-zA-Z0-9_]/_/g'`
    708     ;;
    709   * )
    710     func_tr_sh_result=$1
    711     ;;
    712   esac
    713 }
     491
     492
    714493
    715494
     
    718497func_version ()
    719498{
    720     $opt_debug
    721 
    722     $SED -n '/(C)/!b go
    723         :more
    724         /\./!{
    725           N
    726           s/\n# / /
    727           b more
    728         }
    729         :go
    730         /^# '$PROGRAM' (GNU /,/# warranty; / {
     499    $SED -n '/^# '$PROGRAM' (GNU /,/# warranty; / {
    731500        s/^# //
    732501        s/^# *$//
     
    741510func_usage ()
    742511{
    743     $opt_debug
    744 
    745     $SED -n '/^# Usage:/,/^#  *.*--help/ {
     512    $SED -n '/^# Usage:/,/# -h/ {
    746513        s/^# //
    747514        s/^# *$//
     
    749516        p
    750517    }' < "$progpath"
    751     echo
     518    $ECHO
    752519    $ECHO "run \`$progname --help | more' for full usage"
    753520    exit $?
    754521}
    755522
    756 # func_help [NOEXIT]
    757 # Echo long help message to standard output and exit,
    758 # unless 'noexit' is passed as argument.
     523# func_help
     524# Echo long help message to standard output and exit.
    759525func_help ()
    760526{
    761     $opt_debug
    762 
    763527    $SED -n '/^# Usage:/,/# Report bugs to/ {
    764         :print
    765528        s/^# //
    766529        s/^# *$//
     
    775538        s/\$autoconf_version/'"`(autoconf --version) 2>/dev/null |$SED 1q`"'/
    776539        p
    777         d
    778      }
    779      /^# .* home page:/b print
    780      /^# General help using/b print
    781      ' < "$progpath"
    782     ret=$?
    783     if test -z "$1"; then
    784       exit $ret
    785     fi
     540     }' < "$progpath"
     541    exit $?
    786542}
    787543
     
    791547func_missing_arg ()
    792548{
    793     $opt_debug
    794 
    795     func_error "missing argument for $1."
     549    func_error "missing argument for $1"
    796550    exit_cmd=exit
    797551}
    798552
    799 
    800 # func_split_short_opt shortopt
    801 # Set func_split_short_opt_name and func_split_short_opt_arg shell
    802 # variables after splitting SHORTOPT after the 2nd character.
    803 func_split_short_opt ()
    804 {
    805     my_sed_short_opt='1s/^\(..\).*$/\1/;q'
    806     my_sed_short_rest='1s/^..\(.*\)$/\1/;q'
    807 
    808     func_split_short_opt_name=`$ECHO "$1" | $SED "$my_sed_short_opt"`
    809     func_split_short_opt_arg=`$ECHO "$1" | $SED "$my_sed_short_rest"`
    810 } # func_split_short_opt may be replaced by extended shell implementation
    811 
    812 
    813 # func_split_long_opt longopt
    814 # Set func_split_long_opt_name and func_split_long_opt_arg shell
    815 # variables after splitting LONGOPT at the `=' sign.
    816 func_split_long_opt ()
    817 {
    818     my_sed_long_opt='1s/^\(--[^=]*\)=.*/\1/;q'
    819     my_sed_long_arg='1s/^--[^=]*=//'
    820 
    821     func_split_long_opt_name=`$ECHO "$1" | $SED "$my_sed_long_opt"`
    822     func_split_long_opt_arg=`$ECHO "$1" | $SED "$my_sed_long_arg"`
    823 } # func_split_long_opt may be replaced by extended shell implementation
    824 
    825553exit_cmd=:
    826554
     
    828556
    829557
     558
     559# Check that we have a working $ECHO.
     560if test "X$1" = X--no-reexec; then
     561  # Discard the --no-reexec flag, and continue.
     562  shift
     563elif test "X$1" = X--fallback-echo; then
     564  # Avoid inline document here, it may be left over
     565  :
     566elif test "X`{ $ECHO '\t'; } 2>/dev/null`" = 'X\t'; then
     567  # Yippee, $ECHO works!
     568  :
     569else
     570  # Restart under the correct shell, and then maybe $ECHO will work.
     571  exec $SHELL "$progpath" --no-reexec ${1+"$@"}
     572fi
     573
     574if test "X$1" = X--fallback-echo; then
     575  # used as fallback echo
     576  shift
     577  cat <<EOF
     578$*
     579EOF
     580  exit $EXIT_SUCCESS
     581fi
    830582
    831583magic="%%%MAGIC variable%%%"
     
    833585
    834586# Global variables.
     587# $mode is unset
    835588nonopt=
     589execute_dlfiles=
    836590preserve_args=
    837591lo2o="s/\\.lo\$/.${objext}/"
     
    840594extracted_serial=0
    841595
     596opt_dry_run=false
     597opt_duplicate_deps=false
     598opt_silent=false
     599opt_debug=:
     600
    842601# If this variable is set in any of the actions, the command in it
    843602# will be execed at the end.  This prevents here-documents from being
    844603# left over by shells.
    845604exec_cmd=
    846 
    847 # func_append var value
    848 # Append VALUE to the end of shell variable VAR.
    849 func_append ()
    850 {
    851     eval "${1}=\$${1}\${2}"
    852 } # func_append may be replaced by extended shell implementation
    853 
    854 # func_append_quoted var value
    855 # Quote VALUE and append to the end of shell variable VAR, separated
    856 # by a space.
    857 func_append_quoted ()
    858 {
    859     func_quote_for_eval "${2}"
    860     eval "${1}=\$${1}\\ \$func_quote_for_eval_result"
    861 } # func_append_quoted may be replaced by extended shell implementation
    862 
    863 
    864 # func_arith arithmetic-term...
    865 func_arith ()
    866 {
    867     func_arith_result=`expr "${@}"`
    868 } # func_arith may be replaced by extended shell implementation
    869 
    870 
    871 # func_len string
    872 # STRING may not start with a hyphen.
    873 func_len ()
    874 {
    875     func_len_result=`expr "${1}" : ".*" 2>/dev/null || echo $max_cmd_len`
    876 } # func_len may be replaced by extended shell implementation
    877 
    878 
    879 # func_lo2o object
    880 func_lo2o ()
    881 {
    882     func_lo2o_result=`$ECHO "${1}" | $SED "$lo2o"`
    883 } # func_lo2o may be replaced by extended shell implementation
    884 
    885 
    886 # func_xform libobj-or-source
    887 func_xform ()
    888 {
    889     func_xform_result=`$ECHO "${1}" | $SED 's/\.[^.]*$/.lo/'`
    890 } # func_xform may be replaced by extended shell implementation
    891 
    892605
    893606# func_fatal_configuration arg...
     
    924637func_features ()
    925638{
    926     echo "host: $host"
     639    $ECHO "host: $host"
    927640    if test "$build_libtool_libs" = yes; then
    928       echo "enable shared libraries"
     641      $ECHO "enable shared libraries"
    929642    else
    930       echo "disable shared libraries"
     643      $ECHO "disable shared libraries"
    931644    fi
    932645    if test "$build_old_libs" = yes; then
    933       echo "enable static libraries"
     646      $ECHO "enable static libraries"
    934647    else
    935       echo "disable static libraries"
     648      $ECHO "disable static libraries"
    936649    fi
    937650
     
    978691      ;;
    979692  esac
     693}
     694
     695# Parse options once, thoroughly.  This comes as soon as possible in
     696# the script to make things like `libtool --version' happen quickly.
     697{
     698
     699  # Shorthand for --mode=foo, only valid as the first argument
     700  case $1 in
     701  clean|clea|cle|cl)
     702    shift; set dummy --mode clean ${1+"$@"}; shift
     703    ;;
     704  compile|compil|compi|comp|com|co|c)
     705    shift; set dummy --mode compile ${1+"$@"}; shift
     706    ;;
     707  execute|execut|execu|exec|exe|ex|e)
     708    shift; set dummy --mode execute ${1+"$@"}; shift
     709    ;;
     710  finish|finis|fini|fin|fi|f)
     711    shift; set dummy --mode finish ${1+"$@"}; shift
     712    ;;
     713  install|instal|insta|inst|ins|in|i)
     714    shift; set dummy --mode install ${1+"$@"}; shift
     715    ;;
     716  link|lin|li|l)
     717    shift; set dummy --mode link ${1+"$@"}; shift
     718    ;;
     719  uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
     720    shift; set dummy --mode uninstall ${1+"$@"}; shift
     721    ;;
     722  esac
     723
     724  # Parse non-mode specific arguments:
     725  while test "$#" -gt 0; do
     726    opt="$1"
     727    shift
     728
     729    case $opt in
     730      --config)         func_config                                     ;;
     731
     732      --debug)          preserve_args="$preserve_args $opt"
     733                        func_echo "enabling shell trace mode"
     734                        opt_debug='set -x'
     735                        $opt_debug
     736                        ;;
     737
     738      -dlopen)          test "$#" -eq 0 && func_missing_arg "$opt" && break
     739                        execute_dlfiles="$execute_dlfiles $1"
     740                        shift
     741                        ;;
     742
     743      --dry-run | -n)   opt_dry_run=:                                   ;;
     744      --features)       func_features                                   ;;
     745      --finish)         mode="finish"                                   ;;
     746
     747      --mode)           test "$#" -eq 0 && func_missing_arg "$opt" && break
     748                        case $1 in
     749                          # Valid mode arguments:
     750                          clean)        ;;
     751                          compile)      ;;
     752                          execute)      ;;
     753                          finish)       ;;
     754                          install)      ;;
     755                          link)         ;;
     756                          relink)       ;;
     757                          uninstall)    ;;
     758
     759                          # Catch anything else as an error
     760                          *) func_error "invalid argument for $opt"
     761                             exit_cmd=exit
     762                             break
     763                             ;;
     764                        esac
     765
     766                        mode="$1"
     767                        shift
     768                        ;;
     769
     770      --preserve-dup-deps)
     771                        opt_duplicate_deps=:                            ;;
     772
     773      --quiet|--silent) preserve_args="$preserve_args $opt"
     774                        opt_silent=:
     775                        ;;
     776
     777      --verbose| -v)    preserve_args="$preserve_args $opt"
     778                        opt_silent=false
     779                        ;;
     780
     781      --tag)            test "$#" -eq 0 && func_missing_arg "$opt" && break
     782                        preserve_args="$preserve_args $opt $1"
     783                        func_enable_tag "$1"    # tagname is set here
     784                        shift
     785                        ;;
     786
     787      # Separate optargs to long options:
     788      -dlopen=*|--mode=*|--tag=*)
     789                        func_opt_split "$opt"
     790                        set dummy "$func_opt_split_opt" "$func_opt_split_arg" ${1+"$@"}
     791                        shift
     792                        ;;
     793
     794      -\?|-h)           func_usage                                      ;;
     795      --help)           opt_help=:                                      ;;
     796      --version)        func_version                                    ;;
     797
     798      -*)               func_fatal_help "unrecognized option \`$opt'"   ;;
     799
     800      *)                nonopt="$opt"
     801                        break
     802                        ;;
     803    esac
     804  done
     805
     806
     807  case $host in
     808    *cygwin* | *mingw* | *pw32* | *cegcc*)
     809      # don't eliminate duplications in $postdeps and $predeps
     810      opt_duplicate_compiler_generated_deps=:
     811      ;;
     812    *)
     813      opt_duplicate_compiler_generated_deps=$opt_duplicate_deps
     814      ;;
     815  esac
     816
     817  # Having warned about all mis-specified options, bail out if
     818  # anything was wrong.
     819  $exit_cmd $EXIT_FAILURE
    980820}
    981821
     
    1016856
    1017857
    1018 # Shorthand for --mode=foo, only valid as the first argument
    1019 case $1 in
    1020 clean|clea|cle|cl)
    1021   shift; set dummy --mode clean ${1+"$@"}; shift
    1022   ;;
    1023 compile|compil|compi|comp|com|co|c)
    1024   shift; set dummy --mode compile ${1+"$@"}; shift
    1025   ;;
    1026 execute|execut|execu|exec|exe|ex|e)
    1027   shift; set dummy --mode execute ${1+"$@"}; shift
    1028   ;;
    1029 finish|finis|fini|fin|fi|f)
    1030   shift; set dummy --mode finish ${1+"$@"}; shift
    1031   ;;
    1032 install|instal|insta|inst|ins|in|i)
    1033   shift; set dummy --mode install ${1+"$@"}; shift
    1034   ;;
    1035 link|lin|li|l)
    1036   shift; set dummy --mode link ${1+"$@"}; shift
    1037   ;;
    1038 uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
    1039   shift; set dummy --mode uninstall ${1+"$@"}; shift
    1040   ;;
    1041 esac
    1042 
    1043 
    1044 
    1045 # Option defaults:
    1046 opt_debug=:
    1047 opt_dry_run=false
    1048 opt_config=false
    1049 opt_preserve_dup_deps=false
    1050 opt_features=false
    1051 opt_finish=false
    1052 opt_help=false
    1053 opt_help_all=false
    1054 opt_silent=:
    1055 opt_verbose=:
    1056 opt_silent=false
    1057 opt_verbose=false
    1058 
    1059 
    1060 # Parse options once, thoroughly.  This comes as soon as possible in the
    1061 # script to make things like `--version' happen as quickly as we can.
    1062 {
    1063   # this just eases exit handling
    1064   while test $# -gt 0; do
    1065     opt="$1"
    1066     shift
    1067     case $opt in
    1068       --debug|-x)       opt_debug='set -x'
    1069                         func_echo "enabling shell trace mode"
    1070                         $opt_debug
    1071                         ;;
    1072       --dry-run|--dryrun|-n)
    1073                         opt_dry_run=:
    1074                         ;;
    1075       --config)
    1076                         opt_config=:
    1077 func_config
    1078                         ;;
    1079       --dlopen|-dlopen)
    1080                         optarg="$1"
    1081                         opt_dlopen="${opt_dlopen+$opt_dlopen
    1082 }$optarg"
    1083                         shift
    1084                         ;;
    1085       --preserve-dup-deps)
    1086                         opt_preserve_dup_deps=:
    1087                         ;;
    1088       --features)
    1089                         opt_features=:
    1090 func_features
    1091                         ;;
    1092       --finish)
    1093                         opt_finish=:
    1094 set dummy --mode finish ${1+"$@"}; shift
    1095                         ;;
    1096       --help)
    1097                         opt_help=:
    1098                         ;;
    1099       --help-all)
    1100                         opt_help_all=:
    1101 opt_help=': help-all'
    1102                         ;;
    1103       --mode)
    1104                         test $# = 0 && func_missing_arg $opt && break
    1105                         optarg="$1"
    1106                         opt_mode="$optarg"
    1107 case $optarg in
    1108   # Valid mode arguments:
    1109   clean|compile|execute|finish|install|link|relink|uninstall) ;;
    1110 
    1111   # Catch anything else as an error
    1112   *) func_error "invalid argument for $opt"
    1113      exit_cmd=exit
    1114      break
    1115      ;;
    1116 esac
    1117                         shift
    1118                         ;;
    1119       --no-silent|--no-quiet)
    1120                         opt_silent=false
    1121 func_append preserve_args " $opt"
    1122                         ;;
    1123       --no-verbose)
    1124                         opt_verbose=false
    1125 func_append preserve_args " $opt"
    1126                         ;;
    1127       --silent|--quiet)
    1128                         opt_silent=:
    1129 func_append preserve_args " $opt"
    1130         opt_verbose=false
    1131                         ;;
    1132       --verbose|-v)
    1133                         opt_verbose=:
    1134 func_append preserve_args " $opt"
    1135 opt_silent=false
    1136                         ;;
    1137       --tag)
    1138                         test $# = 0 && func_missing_arg $opt && break
    1139                         optarg="$1"
    1140                         opt_tag="$optarg"
    1141 func_append preserve_args " $opt $optarg"
    1142 func_enable_tag "$optarg"
    1143                         shift
    1144                         ;;
    1145 
    1146       -\?|-h)           func_usage                              ;;
    1147       --help)           func_help                               ;;
    1148       --version)        func_version                            ;;
    1149 
    1150       # Separate optargs to long options:
    1151       --*=*)
    1152                         func_split_long_opt "$opt"
    1153                         set dummy "$func_split_long_opt_name" "$func_split_long_opt_arg" ${1+"$@"}
    1154                         shift
    1155                         ;;
    1156 
    1157       # Separate non-argument short options:
    1158       -\?*|-h*|-n*|-v*)
    1159                         func_split_short_opt "$opt"
    1160                         set dummy "$func_split_short_opt_name" "-$func_split_short_opt_arg" ${1+"$@"}
    1161                         shift
    1162                         ;;
    1163 
    1164       --)               break                                   ;;
    1165       -*)               func_fatal_help "unrecognized option \`$opt'" ;;
    1166       *)                set dummy "$opt" ${1+"$@"};     shift; break  ;;
    1167     esac
    1168   done
    1169 
    1170   # Validate options:
    1171 
    1172   # save first non-option argument
    1173   if test "$#" -gt 0; then
    1174     nonopt="$opt"
    1175     shift
    1176   fi
    1177 
    1178   # preserve --debug
    1179   test "$opt_debug" = : || func_append preserve_args " --debug"
    1180 
    1181   case $host in
    1182     *cygwin* | *mingw* | *pw32* | *cegcc*)
    1183       # don't eliminate duplications in $postdeps and $predeps
    1184       opt_duplicate_compiler_generated_deps=:
    1185       ;;
    1186     *)
    1187       opt_duplicate_compiler_generated_deps=$opt_preserve_dup_deps
    1188       ;;
    1189   esac
    1190 
    1191   $opt_help || {
    1192     # Sanity checks first:
    1193     func_check_version_match
    1194 
    1195     if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
    1196       func_fatal_configuration "not configured to build any kind of library"
    1197     fi
    1198 
    1199     # Darwin sucks
    1200     eval std_shrext=\"$shrext_cmds\"
    1201 
    1202     # Only execute mode is allowed to have -dlopen flags.
    1203     if test -n "$opt_dlopen" && test "$opt_mode" != execute; then
    1204       func_error "unrecognized option \`-dlopen'"
    1205       $ECHO "$help" 1>&2
    1206       exit $EXIT_FAILURE
    1207     fi
    1208 
    1209     # Change the help message to a mode-specific one.
    1210     generic_help="$help"
    1211     help="Try \`$progname --help --mode=$opt_mode' for more information."
    1212   }
    1213 
    1214 
    1215   # Bail if the options were screwed
    1216   $exit_cmd $EXIT_FAILURE
    1217 }
    1218 
    1219 
    1220 
    1221 
    1222858## ----------- ##
    1223859##    Main.    ##
    1224860## ----------- ##
     861
     862$opt_help || {
     863  # Sanity checks first:
     864  func_check_version_match
     865
     866  if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
     867    func_fatal_configuration "not configured to build any kind of library"
     868  fi
     869
     870  test -z "$mode" && func_fatal_error "error: you must specify a MODE."
     871
     872
     873  # Darwin sucks
     874  eval std_shrext=\"$shrext_cmds\"
     875
     876
     877  # Only execute mode is allowed to have -dlopen flags.
     878  if test -n "$execute_dlfiles" && test "$mode" != execute; then
     879    func_error "unrecognized option \`-dlopen'"
     880    $ECHO "$help" 1>&2
     881    exit $EXIT_FAILURE
     882  fi
     883
     884  # Change the help message to a mode-specific one.
     885  generic_help="$help"
     886  help="Try \`$progname --help --mode=$mode' for more information."
     887}
     888
    1225889
    1226890# func_lalib_p file
     
    1287951func_ltwrapper_scriptname ()
    1288952{
    1289     func_dirname_and_basename "$1" "" "."
    1290     func_stripname '' '.exe' "$func_basename_result"
    1291     func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper"
     953    func_ltwrapper_scriptname_result=""
     954    if func_ltwrapper_executable_p "$1"; then
     955        func_dirname_and_basename "$1" "" "."
     956        func_stripname '' '.exe' "$func_basename_result"
     957        func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper"
     958    fi
    1292959}
    1293960
     
    13351002
    13361003
    1337 # func_resolve_sysroot PATH
    1338 # Replace a leading = in PATH with a sysroot.  Store the result into
    1339 # func_resolve_sysroot_result
    1340 func_resolve_sysroot ()
    1341 {
    1342   func_resolve_sysroot_result=$1
    1343   case $func_resolve_sysroot_result in
    1344   =*)
    1345     func_stripname '=' '' "$func_resolve_sysroot_result"
    1346     func_resolve_sysroot_result=$lt_sysroot$func_stripname_result
    1347     ;;
    1348   esac
    1349 }
    1350 
    1351 # func_replace_sysroot PATH
    1352 # If PATH begins with the sysroot, replace it with = and
    1353 # store the result into func_replace_sysroot_result.
    1354 func_replace_sysroot ()
    1355 {
    1356   case "$lt_sysroot:$1" in
    1357   ?*:"$lt_sysroot"*)
    1358     func_stripname "$lt_sysroot" '' "$1"
    1359     func_replace_sysroot_result="=$func_stripname_result"
    1360     ;;
    1361   *)
    1362     # Including no sysroot.
    1363     func_replace_sysroot_result=$1
    1364     ;;
    1365   esac
    1366 }
    1367 
    13681004# func_infer_tag arg
    13691005# Infer tagged configuration to use if any are available and
     
    13781014      CC_quoted=
    13791015      for arg in $CC; do
    1380         func_append_quoted CC_quoted "$arg"
     1016        func_quote_for_eval "$arg"
     1017        CC_quoted="$CC_quoted $func_quote_for_eval_result"
    13811018      done
    1382       CC_expanded=`func_echo_all $CC`
    1383       CC_quoted_expanded=`func_echo_all $CC_quoted`
    13841019      case $@ in
    13851020      # Blanks in the command may have been stripped by the calling shell,
    13861021      # but not from the CC environment variable when configure was run.
    1387       " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
    1388       " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) ;;
     1022      " $CC "* | "$CC "* | " `$ECHO $CC` "* | "`$ECHO $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$ECHO $CC_quoted` "* | "`$ECHO $CC_quoted` "*) ;;
    13891023      # Blanks at the start of $base_compile will cause this to fail
    13901024      # if we don't check for them as well.
     
    13971031            for arg in $CC; do
    13981032              # Double-quote args containing other shell metacharacters.
    1399               func_append_quoted CC_quoted "$arg"
     1033              func_quote_for_eval "$arg"
     1034              CC_quoted="$CC_quoted $func_quote_for_eval_result"
    14001035            done
    1401             CC_expanded=`func_echo_all $CC`
    1402             CC_quoted_expanded=`func_echo_all $CC_quoted`
    14031036            case "$@ " in
    1404             " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
    1405             " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*)
     1037              " $CC "* | "$CC "* | " `$ECHO $CC` "* | "`$ECHO $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$ECHO $CC_quoted` "* | "`$ECHO $CC_quoted` "*)
    14061038              # The compiler in the base compile command matches
    14071039              # the one in the tagged configuration.
     
    14661098}
    14671099
    1468 
    1469 ##################################################
    1470 # FILE NAME AND PATH CONVERSION HELPER FUNCTIONS #
    1471 ##################################################
    1472 
    1473 # func_convert_core_file_wine_to_w32 ARG
    1474 # Helper function used by file name conversion functions when $build is *nix,
    1475 # and $host is mingw, cygwin, or some other w32 environment. Relies on a
    1476 # correctly configured wine environment available, with the winepath program
    1477 # in $build's $PATH.
    1478 #
    1479 # ARG is the $build file name to be converted to w32 format.
    1480 # Result is available in $func_convert_core_file_wine_to_w32_result, and will
    1481 # be empty on error (or when ARG is empty)
    1482 func_convert_core_file_wine_to_w32 ()
    1483 {
    1484   $opt_debug
    1485   func_convert_core_file_wine_to_w32_result="$1"
    1486   if test -n "$1"; then
    1487     # Unfortunately, winepath does not exit with a non-zero error code, so we
    1488     # are forced to check the contents of stdout. On the other hand, if the
    1489     # command is not found, the shell will set an exit code of 127 and print
    1490     # *an error message* to stdout. So we must check for both error code of
    1491     # zero AND non-empty stdout, which explains the odd construction:
    1492     func_convert_core_file_wine_to_w32_tmp=`winepath -w "$1" 2>/dev/null`
    1493     if test "$?" -eq 0 && test -n "${func_convert_core_file_wine_to_w32_tmp}"; then
    1494       func_convert_core_file_wine_to_w32_result=`$ECHO "$func_convert_core_file_wine_to_w32_tmp" |
    1495         $SED -e "$lt_sed_naive_backslashify"`
    1496     else
    1497       func_convert_core_file_wine_to_w32_result=
    1498     fi
    1499   fi
    1500 }
    1501 # end: func_convert_core_file_wine_to_w32
    1502 
    1503 
    1504 # func_convert_core_path_wine_to_w32 ARG
    1505 # Helper function used by path conversion functions when $build is *nix, and
    1506 # $host is mingw, cygwin, or some other w32 environment. Relies on a correctly
    1507 # configured wine environment available, with the winepath program in $build's
    1508 # $PATH. Assumes ARG has no leading or trailing path separator characters.
    1509 #
    1510 # ARG is path to be converted from $build format to win32.
    1511 # Result is available in $func_convert_core_path_wine_to_w32_result.
    1512 # Unconvertible file (directory) names in ARG are skipped; if no directory names
    1513 # are convertible, then the result may be empty.
    1514 func_convert_core_path_wine_to_w32 ()
    1515 {
    1516   $opt_debug
    1517   # unfortunately, winepath doesn't convert paths, only file names
    1518   func_convert_core_path_wine_to_w32_result=""
    1519   if test -n "$1"; then
    1520     oldIFS=$IFS
    1521     IFS=:
    1522     for func_convert_core_path_wine_to_w32_f in $1; do
    1523       IFS=$oldIFS
    1524       func_convert_core_file_wine_to_w32 "$func_convert_core_path_wine_to_w32_f"
    1525       if test -n "$func_convert_core_file_wine_to_w32_result" ; then
    1526         if test -z "$func_convert_core_path_wine_to_w32_result"; then
    1527           func_convert_core_path_wine_to_w32_result="$func_convert_core_file_wine_to_w32_result"
    1528         else
    1529           func_append func_convert_core_path_wine_to_w32_result ";$func_convert_core_file_wine_to_w32_result"
    1530         fi
    1531       fi
    1532     done
    1533     IFS=$oldIFS
    1534   fi
    1535 }
    1536 # end: func_convert_core_path_wine_to_w32
    1537 
    1538 
    1539 # func_cygpath ARGS...
    1540 # Wrapper around calling the cygpath program via LT_CYGPATH. This is used when
    1541 # when (1) $build is *nix and Cygwin is hosted via a wine environment; or (2)
    1542 # $build is MSYS and $host is Cygwin, or (3) $build is Cygwin. In case (1) or
    1543 # (2), returns the Cygwin file name or path in func_cygpath_result (input
    1544 # file name or path is assumed to be in w32 format, as previously converted
    1545 # from $build's *nix or MSYS format). In case (3), returns the w32 file name
    1546 # or path in func_cygpath_result (input file name or path is assumed to be in
    1547 # Cygwin format). Returns an empty string on error.
    1548 #
    1549 # ARGS are passed to cygpath, with the last one being the file name or path to
    1550 # be converted.
    1551 #
    1552 # Specify the absolute *nix (or w32) name to cygpath in the LT_CYGPATH
    1553 # environment variable; do not put it in $PATH.
    1554 func_cygpath ()
    1555 {
    1556   $opt_debug
    1557   if test -n "$LT_CYGPATH" && test -f "$LT_CYGPATH"; then
    1558     func_cygpath_result=`$LT_CYGPATH "$@" 2>/dev/null`
    1559     if test "$?" -ne 0; then
    1560       # on failure, ensure result is empty
    1561       func_cygpath_result=
    1562     fi
    1563   else
    1564     func_cygpath_result=
    1565     func_error "LT_CYGPATH is empty or specifies non-existent file: \`$LT_CYGPATH'"
    1566   fi
    1567 }
    1568 #end: func_cygpath
    1569 
    1570 
    1571 # func_convert_core_msys_to_w32 ARG
    1572 # Convert file name or path ARG from MSYS format to w32 format.  Return
    1573 # result in func_convert_core_msys_to_w32_result.
    1574 func_convert_core_msys_to_w32 ()
    1575 {
    1576   $opt_debug
    1577   # awkward: cmd appends spaces to result
    1578   func_convert_core_msys_to_w32_result=`( cmd //c echo "$1" ) 2>/dev/null |
    1579     $SED -e 's/[ ]*$//' -e "$lt_sed_naive_backslashify"`
    1580 }
    1581 #end: func_convert_core_msys_to_w32
    1582 
    1583 
    1584 # func_convert_file_check ARG1 ARG2
    1585 # Verify that ARG1 (a file name in $build format) was converted to $host
    1586 # format in ARG2. Otherwise, emit an error message, but continue (resetting
    1587 # func_to_host_file_result to ARG1).
    1588 func_convert_file_check ()
    1589 {
    1590   $opt_debug
    1591   if test -z "$2" && test -n "$1" ; then
    1592     func_error "Could not determine host file name corresponding to"
    1593     func_error "  \`$1'"
    1594     func_error "Continuing, but uninstalled executables may not work."
    1595     # Fallback:
    1596     func_to_host_file_result="$1"
    1597   fi
    1598 }
    1599 # end func_convert_file_check
    1600 
    1601 
    1602 # func_convert_path_check FROM_PATHSEP TO_PATHSEP FROM_PATH TO_PATH
    1603 # Verify that FROM_PATH (a path in $build format) was converted to $host
    1604 # format in TO_PATH. Otherwise, emit an error message, but continue, resetting
    1605 # func_to_host_file_result to a simplistic fallback value (see below).
    1606 func_convert_path_check ()
    1607 {
    1608   $opt_debug
    1609   if test -z "$4" && test -n "$3"; then
    1610     func_error "Could not determine the host path corresponding to"
    1611     func_error "  \`$3'"
    1612     func_error "Continuing, but uninstalled executables may not work."
    1613     # Fallback.  This is a deliberately simplistic "conversion" and
    1614     # should not be "improved".  See libtool.info.
    1615     if test "x$1" != "x$2"; then
    1616       lt_replace_pathsep_chars="s|$1|$2|g"
    1617       func_to_host_path_result=`echo "$3" |
    1618         $SED -e "$lt_replace_pathsep_chars"`
    1619     else
    1620       func_to_host_path_result="$3"
    1621     fi
    1622   fi
    1623 }
    1624 # end func_convert_path_check
    1625 
    1626 
    1627 # func_convert_path_front_back_pathsep FRONTPAT BACKPAT REPL ORIG
    1628 # Modifies func_to_host_path_result by prepending REPL if ORIG matches FRONTPAT
    1629 # and appending REPL if ORIG matches BACKPAT.
    1630 func_convert_path_front_back_pathsep ()
    1631 {
    1632   $opt_debug
    1633   case $4 in
    1634   $1 ) func_to_host_path_result="$3$func_to_host_path_result"
    1635     ;;
    1636   esac
    1637   case $4 in
    1638   $2 ) func_append func_to_host_path_result "$3"
    1639     ;;
    1640   esac
    1641 }
    1642 # end func_convert_path_front_back_pathsep
    1643 
    1644 
    1645 ##################################################
    1646 # $build to $host FILE NAME CONVERSION FUNCTIONS #
    1647 ##################################################
    1648 # invoked via `$to_host_file_cmd ARG'
    1649 #
    1650 # In each case, ARG is the path to be converted from $build to $host format.
    1651 # Result will be available in $func_to_host_file_result.
    1652 
    1653 
    1654 # func_to_host_file ARG
    1655 # Converts the file name ARG from $build format to $host format. Return result
    1656 # in func_to_host_file_result.
    1657 func_to_host_file ()
    1658 {
    1659   $opt_debug
    1660   $to_host_file_cmd "$1"
    1661 }
    1662 # end func_to_host_file
    1663 
    1664 
    1665 # func_to_tool_file ARG LAZY
    1666 # converts the file name ARG from $build format to toolchain format. Return
    1667 # result in func_to_tool_file_result.  If the conversion in use is listed
    1668 # in (the comma separated) LAZY, no conversion takes place.
    1669 func_to_tool_file ()
    1670 {
    1671   $opt_debug
    1672   case ,$2, in
    1673     *,"$to_tool_file_cmd",*)
    1674       func_to_tool_file_result=$1
    1675       ;;
    1676     *)
    1677       $to_tool_file_cmd "$1"
    1678       func_to_tool_file_result=$func_to_host_file_result
    1679       ;;
    1680   esac
    1681 }
    1682 # end func_to_tool_file
    1683 
    1684 
    1685 # func_convert_file_noop ARG
    1686 # Copy ARG to func_to_host_file_result.
    1687 func_convert_file_noop ()
    1688 {
    1689   func_to_host_file_result="$1"
    1690 }
    1691 # end func_convert_file_noop
    1692 
    1693 
    1694 # func_convert_file_msys_to_w32 ARG
    1695 # Convert file name ARG from (mingw) MSYS to (mingw) w32 format; automatic
    1696 # conversion to w32 is not available inside the cwrapper.  Returns result in
    1697 # func_to_host_file_result.
    1698 func_convert_file_msys_to_w32 ()
    1699 {
    1700   $opt_debug
    1701   func_to_host_file_result="$1"
    1702   if test -n "$1"; then
    1703     func_convert_core_msys_to_w32 "$1"
    1704     func_to_host_file_result="$func_convert_core_msys_to_w32_result"
    1705   fi
    1706   func_convert_file_check "$1" "$func_to_host_file_result"
    1707 }
    1708 # end func_convert_file_msys_to_w32
    1709 
    1710 
    1711 # func_convert_file_cygwin_to_w32 ARG
    1712 # Convert file name ARG from Cygwin to w32 format.  Returns result in
    1713 # func_to_host_file_result.
    1714 func_convert_file_cygwin_to_w32 ()
    1715 {
    1716   $opt_debug
    1717   func_to_host_file_result="$1"
    1718   if test -n "$1"; then
    1719     # because $build is cygwin, we call "the" cygpath in $PATH; no need to use
    1720     # LT_CYGPATH in this case.
    1721     func_to_host_file_result=`cygpath -m "$1"`
    1722   fi
    1723   func_convert_file_check "$1" "$func_to_host_file_result"
    1724 }
    1725 # end func_convert_file_cygwin_to_w32
    1726 
    1727 
    1728 # func_convert_file_nix_to_w32 ARG
    1729 # Convert file name ARG from *nix to w32 format.  Requires a wine environment
    1730 # and a working winepath. Returns result in func_to_host_file_result.
    1731 func_convert_file_nix_to_w32 ()
    1732 {
    1733   $opt_debug
    1734   func_to_host_file_result="$1"
    1735   if test -n "$1"; then
    1736     func_convert_core_file_wine_to_w32 "$1"
    1737     func_to_host_file_result="$func_convert_core_file_wine_to_w32_result"
    1738   fi
    1739   func_convert_file_check "$1" "$func_to_host_file_result"
    1740 }
    1741 # end func_convert_file_nix_to_w32
    1742 
    1743 
    1744 # func_convert_file_msys_to_cygwin ARG
    1745 # Convert file name ARG from MSYS to Cygwin format.  Requires LT_CYGPATH set.
    1746 # Returns result in func_to_host_file_result.
    1747 func_convert_file_msys_to_cygwin ()
    1748 {
    1749   $opt_debug
    1750   func_to_host_file_result="$1"
    1751   if test -n "$1"; then
    1752     func_convert_core_msys_to_w32 "$1"
    1753     func_cygpath -u "$func_convert_core_msys_to_w32_result"
    1754     func_to_host_file_result="$func_cygpath_result"
    1755   fi
    1756   func_convert_file_check "$1" "$func_to_host_file_result"
    1757 }
    1758 # end func_convert_file_msys_to_cygwin
    1759 
    1760 
    1761 # func_convert_file_nix_to_cygwin ARG
    1762 # Convert file name ARG from *nix to Cygwin format.  Requires Cygwin installed
    1763 # in a wine environment, working winepath, and LT_CYGPATH set.  Returns result
    1764 # in func_to_host_file_result.
    1765 func_convert_file_nix_to_cygwin ()
    1766 {
    1767   $opt_debug
    1768   func_to_host_file_result="$1"
    1769   if test -n "$1"; then
    1770     # convert from *nix to w32, then use cygpath to convert from w32 to cygwin.
    1771     func_convert_core_file_wine_to_w32 "$1"
    1772     func_cygpath -u "$func_convert_core_file_wine_to_w32_result"
    1773     func_to_host_file_result="$func_cygpath_result"
    1774   fi
    1775   func_convert_file_check "$1" "$func_to_host_file_result"
    1776 }
    1777 # end func_convert_file_nix_to_cygwin
    1778 
    1779 
    1780 #############################################
    1781 # $build to $host PATH CONVERSION FUNCTIONS #
    1782 #############################################
    1783 # invoked via `$to_host_path_cmd ARG'
    1784 #
    1785 # In each case, ARG is the path to be converted from $build to $host format.
    1786 # The result will be available in $func_to_host_path_result.
    1787 #
    1788 # Path separators are also converted from $build format to $host format.  If
    1789 # ARG begins or ends with a path separator character, it is preserved (but
    1790 # converted to $host format) on output.
    1791 #
    1792 # All path conversion functions are named using the following convention:
    1793 #   file name conversion function    : func_convert_file_X_to_Y ()
    1794 #   path conversion function         : func_convert_path_X_to_Y ()
    1795 # where, for any given $build/$host combination the 'X_to_Y' value is the
    1796 # same.  If conversion functions are added for new $build/$host combinations,
    1797 # the two new functions must follow this pattern, or func_init_to_host_path_cmd
    1798 # will break.
    1799 
    1800 
    1801 # func_init_to_host_path_cmd
    1802 # Ensures that function "pointer" variable $to_host_path_cmd is set to the
    1803 # appropriate value, based on the value of $to_host_file_cmd.
    1804 to_host_path_cmd=
    1805 func_init_to_host_path_cmd ()
    1806 {
    1807   $opt_debug
    1808   if test -z "$to_host_path_cmd"; then
    1809     func_stripname 'func_convert_file_' '' "$to_host_file_cmd"
    1810     to_host_path_cmd="func_convert_path_${func_stripname_result}"
    1811   fi
    1812 }
    1813 
    1814 
    1815 # func_to_host_path ARG
    1816 # Converts the path ARG from $build format to $host format. Return result
    1817 # in func_to_host_path_result.
    1818 func_to_host_path ()
    1819 {
    1820   $opt_debug
    1821   func_init_to_host_path_cmd
    1822   $to_host_path_cmd "$1"
    1823 }
    1824 # end func_to_host_path
    1825 
    1826 
    1827 # func_convert_path_noop ARG
    1828 # Copy ARG to func_to_host_path_result.
    1829 func_convert_path_noop ()
    1830 {
    1831   func_to_host_path_result="$1"
    1832 }
    1833 # end func_convert_path_noop
    1834 
    1835 
    1836 # func_convert_path_msys_to_w32 ARG
    1837 # Convert path ARG from (mingw) MSYS to (mingw) w32 format; automatic
    1838 # conversion to w32 is not available inside the cwrapper.  Returns result in
    1839 # func_to_host_path_result.
    1840 func_convert_path_msys_to_w32 ()
    1841 {
    1842   $opt_debug
    1843   func_to_host_path_result="$1"
    1844   if test -n "$1"; then
    1845     # Remove leading and trailing path separator characters from ARG.  MSYS
    1846     # behavior is inconsistent here; cygpath turns them into '.;' and ';.';
    1847     # and winepath ignores them completely.
    1848     func_stripname : : "$1"
    1849     func_to_host_path_tmp1=$func_stripname_result
    1850     func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
    1851     func_to_host_path_result="$func_convert_core_msys_to_w32_result"
    1852     func_convert_path_check : ";" \
    1853       "$func_to_host_path_tmp1" "$func_to_host_path_result"
    1854     func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
    1855   fi
    1856 }
    1857 # end func_convert_path_msys_to_w32
    1858 
    1859 
    1860 # func_convert_path_cygwin_to_w32 ARG
    1861 # Convert path ARG from Cygwin to w32 format.  Returns result in
    1862 # func_to_host_file_result.
    1863 func_convert_path_cygwin_to_w32 ()
    1864 {
    1865   $opt_debug
    1866   func_to_host_path_result="$1"
    1867   if test -n "$1"; then
    1868     # See func_convert_path_msys_to_w32:
    1869     func_stripname : : "$1"
    1870     func_to_host_path_tmp1=$func_stripname_result
    1871     func_to_host_path_result=`cygpath -m -p "$func_to_host_path_tmp1"`
    1872     func_convert_path_check : ";" \
    1873       "$func_to_host_path_tmp1" "$func_to_host_path_result"
    1874     func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
    1875   fi
    1876 }
    1877 # end func_convert_path_cygwin_to_w32
    1878 
    1879 
    1880 # func_convert_path_nix_to_w32 ARG
    1881 # Convert path ARG from *nix to w32 format.  Requires a wine environment and
    1882 # a working winepath.  Returns result in func_to_host_file_result.
    1883 func_convert_path_nix_to_w32 ()
    1884 {
    1885   $opt_debug
    1886   func_to_host_path_result="$1"
    1887   if test -n "$1"; then
    1888     # See func_convert_path_msys_to_w32:
    1889     func_stripname : : "$1"
    1890     func_to_host_path_tmp1=$func_stripname_result
    1891     func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
    1892     func_to_host_path_result="$func_convert_core_path_wine_to_w32_result"
    1893     func_convert_path_check : ";" \
    1894       "$func_to_host_path_tmp1" "$func_to_host_path_result"
    1895     func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
    1896   fi
    1897 }
    1898 # end func_convert_path_nix_to_w32
    1899 
    1900 
    1901 # func_convert_path_msys_to_cygwin ARG
    1902 # Convert path ARG from MSYS to Cygwin format.  Requires LT_CYGPATH set.
    1903 # Returns result in func_to_host_file_result.
    1904 func_convert_path_msys_to_cygwin ()
    1905 {
    1906   $opt_debug
    1907   func_to_host_path_result="$1"
    1908   if test -n "$1"; then
    1909     # See func_convert_path_msys_to_w32:
    1910     func_stripname : : "$1"
    1911     func_to_host_path_tmp1=$func_stripname_result
    1912     func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
    1913     func_cygpath -u -p "$func_convert_core_msys_to_w32_result"
    1914     func_to_host_path_result="$func_cygpath_result"
    1915     func_convert_path_check : : \
    1916       "$func_to_host_path_tmp1" "$func_to_host_path_result"
    1917     func_convert_path_front_back_pathsep ":*" "*:" : "$1"
    1918   fi
    1919 }
    1920 # end func_convert_path_msys_to_cygwin
    1921 
    1922 
    1923 # func_convert_path_nix_to_cygwin ARG
    1924 # Convert path ARG from *nix to Cygwin format.  Requires Cygwin installed in a
    1925 # a wine environment, working winepath, and LT_CYGPATH set.  Returns result in
    1926 # func_to_host_file_result.
    1927 func_convert_path_nix_to_cygwin ()
    1928 {
    1929   $opt_debug
    1930   func_to_host_path_result="$1"
    1931   if test -n "$1"; then
    1932     # Remove leading and trailing path separator characters from
    1933     # ARG. msys behavior is inconsistent here, cygpath turns them
    1934     # into '.;' and ';.', and winepath ignores them completely.
    1935     func_stripname : : "$1"
    1936     func_to_host_path_tmp1=$func_stripname_result
    1937     func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
    1938     func_cygpath -u -p "$func_convert_core_path_wine_to_w32_result"
    1939     func_to_host_path_result="$func_cygpath_result"
    1940     func_convert_path_check : : \
    1941       "$func_to_host_path_tmp1" "$func_to_host_path_result"
    1942     func_convert_path_front_back_pathsep ":*" "*:" : "$1"
    1943   fi
    1944 }
    1945 # end func_convert_path_nix_to_cygwin
    1946 
    1947 
    19481100# func_mode_compile arg...
    19491101func_mode_compile ()
     
    19861138
    19871139        -pie | -fpie | -fPIE)
    1988           func_append pie_flag " $arg"
     1140          pie_flag="$pie_flag $arg"
    19891141          continue
    19901142          ;;
    19911143
    19921144        -shared | -static | -prefer-pic | -prefer-non-pic)
    1993           func_append later " $arg"
     1145          later="$later $arg"
    19941146          continue
    19951147          ;;
     
    20121164          for arg in $args; do
    20131165            IFS="$save_ifs"
    2014             func_append_quoted lastarg "$arg"
     1166            func_quote_for_eval "$arg"
     1167            lastarg="$lastarg $func_quote_for_eval_result"
    20151168          done
    20161169          IFS="$save_ifs"
     
    20191172
    20201173          # Add the arguments to base_compile.
    2021           func_append base_compile " $lastarg"
     1174          base_compile="$base_compile $lastarg"
    20221175          continue
    20231176          ;;
     
    20351188
    20361189      # Aesthetically quote the previous argument.
    2037       func_append_quoted base_compile "$lastarg"
     1190      func_quote_for_eval "$lastarg"
     1191      base_compile="$base_compile $func_quote_for_eval_result"
    20381192    done # for arg
    20391193
     
    20601214    *.ada | *.adb | *.ads | *.asm | \
    20611215    *.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \
    2062     *.[fF][09]? | *.for | *.java | *.obj | *.sx | *.cu | *.cup)
     1216    *.[fF][09]? | *.for | *.java | *.obj | *.sx)
    20631217      func_xform "$libobj"
    20641218      libobj=$func_xform_result
     
    21351289    # not support -o with -c
    21361290    if test "$compiler_c_o" = no; then
    2137       output_obj=`$ECHO "$srcfile" | $SED 's%^.*/%%; s%\.[^.]*$%%'`.${objext}
     1291      output_obj=`$ECHO "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext}
    21381292      lockfile="$output_obj.lock"
    21391293    else
     
    21661320        exit $EXIT_FAILURE
    21671321      fi
    2168       func_append removelist " $output_obj"
     1322      removelist="$removelist $output_obj"
    21691323      $ECHO "$srcfile" > "$lockfile"
    21701324    fi
    21711325
    21721326    $opt_dry_run || $RM $removelist
    2173     func_append removelist " $lockfile"
     1327    removelist="$removelist $lockfile"
    21741328    trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15
    21751329
    2176     func_to_tool_file "$srcfile" func_convert_file_msys_to_w32
    2177     srcfile=$func_to_tool_file_result
     1330    if test -n "$fix_srcfile_path"; then
     1331      eval srcfile=\"$fix_srcfile_path\"
     1332    fi
    21781333    func_quote_for_eval "$srcfile"
    21791334    qsrcfile=$func_quote_for_eval_result
     
    21951350      if test -z "$output_obj"; then
    21961351        # Place PIC objects in $objdir
    2197         func_append command " -o $lobj"
     1352        command="$command -o $lobj"
    21981353      fi
    21991354
     
    22421397      fi
    22431398      if test "$compiler_c_o" = yes; then
    2244         func_append command " -o $obj"
     1399        command="$command -o $obj"
    22451400      fi
    22461401
    22471402      # Suppress compiler output if we already did a PIC compilation.
    2248       func_append command "$suppress_output"
     1403      command="$command$suppress_output"
    22491404      func_show_eval_locale "$command" \
    22501405        '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
     
    22911446
    22921447$opt_help || {
    2293   test "$opt_mode" = compile && func_mode_compile ${1+"$@"}
     1448test "$mode" = compile && func_mode_compile ${1+"$@"}
    22941449}
    22951450
     
    22971452{
    22981453    # We need to display help for each of the modes.
    2299     case $opt_mode in
     1454    case $mode in
    23001455      "")
    23011456        # Generic help is extracted from the usage comments
     
    23281483  -o OUTPUT-FILE    set the output file name to OUTPUT-FILE
    23291484  -no-suppress      do not suppress compiler output for multiple passes
    2330   -prefer-pic       try to build PIC objects only
    2331   -prefer-non-pic   try to build non-PIC objects only
     1485  -prefer-pic       try to building PIC objects only
     1486  -prefer-non-pic   try to building non-PIC objects only
    23321487  -shared           do not build a \`.o' file suitable for static linking
    23331488  -static           only build a \`.o' file suitable for static linking
    2334   -Wc,FLAG          pass FLAG directly to the compiler
    23351489
    23361490COMPILE-COMMAND is a command to be used in creating a \`standard' object file
     
    23851539The following components of INSTALL-COMMAND are treated specially:
    23861540
    2387   -inst-prefix-dir PREFIX-DIR  Use PREFIX-DIR as a staging area for installation
     1541  -inst-prefix PREFIX-DIR  Use PREFIX-DIR as a staging area for installation
    23881542
    23891543The rest of the components are interpreted as arguments to that command (only
     
    24051559  -all-static       do not do any dynamic linking at all
    24061560  -avoid-version    do not add a version suffix if possible
    2407   -bindir BINDIR    specify path to binaries directory (for systems where
    2408                     libraries must be found in the PATH setting at runtime)
    24091561  -dlopen FILE      \`-dlpreopen' FILE if it cannot be dlopened at runtime
    24101562  -dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols
     
    24351587                    specify library version info [each variable defaults to 0]
    24361588  -weak LIBNAME     declare that the target provides the LIBNAME interface
    2437   -Wc,FLAG
    2438   -Xcompiler FLAG   pass linker-specific FLAG directly to the compiler
    2439   -Wl,FLAG
    2440   -Xlinker FLAG     pass linker-specific FLAG directly to the linker
    2441   -XCClinker FLAG   pass link-specific FLAG to the compiler driver (CC)
    24421589
    24431590All other options (arguments beginning with \`-') are ignored.
     
    24731620
    24741621      *)
    2475         func_fatal_help "invalid operation mode \`$opt_mode'"
     1622        func_fatal_help "invalid operation mode \`$mode'"
    24761623        ;;
    24771624    esac
    24781625
    2479     echo
     1626    $ECHO
    24801627    $ECHO "Try \`$progname --help' for more information about other modes."
     1628
     1629    exit $?
    24811630}
    24821631
    2483 # Now that we've collected a possible --mode arg, show help if necessary
    2484 if $opt_help; then
    2485   if test "$opt_help" = :; then
    2486     func_mode_help
    2487   else
    2488     {
    2489       func_help noexit
    2490       for opt_mode in compile link execute install finish uninstall clean; do
    2491         func_mode_help
    2492       done
    2493     } | sed -n '1p; 2,$s/^Usage:/  or: /p'
    2494     {
    2495       func_help noexit
    2496       for opt_mode in compile link execute install finish uninstall clean; do
    2497         echo
    2498         func_mode_help
    2499       done
    2500     } |
    2501     sed '1d
    2502       /^When reporting/,/^Report/{
    2503         H
    2504         d
    2505       }
    2506       $x
    2507       /information about other modes/d
    2508       /more detailed .*MODE/d
    2509       s/^Usage:.*--mode=\([^ ]*\) .*/Description of \1 mode:/'
    2510   fi
    2511   exit $?
    2512 fi
     1632  # Now that we've collected a possible --mode arg, show help if necessary
     1633  $opt_help && func_mode_help
    25131634
    25141635
     
    25231644
    25241645    # Handle -dlopen flags immediately.
    2525     for file in $opt_dlopen; do
     1646    for file in $execute_dlfiles; do
    25261647      test -f "$file" \
    25271648        || func_fatal_help "\`$file' is not a file"
     
    25301651      case $file in
    25311652      *.la)
    2532         func_resolve_sysroot "$file"
    2533         file=$func_resolve_sysroot_result
    2534 
    25351653        # Check to see that this really is a libtool archive.
    25361654        func_lalib_unsafe_p "$file" \
     
    25541672
    25551673        if test -f "$dir/$objdir/$dlname"; then
    2556           func_append dir "/$objdir"
     1674          dir="$dir/$objdir"
    25571675        else
    25581676          if test ! -f "$dir/$dlname"; then
     
    25951713    do
    25961714      case $file in
    2597       -* | *.la | *.lo ) ;;
     1715      -*) ;;
    25981716      *)
    25991717        # Do a test to see if this is really a libtool program.
     
    26111729      esac
    26121730      # Quote arguments (to preserve shell metacharacters).
    2613       func_append_quoted args "$file"
     1731      func_quote_for_eval "$file"
     1732      args="$args $func_quote_for_eval_result"
    26141733    done
    26151734
     
    26361755      if test -n "$shlibpath_var"; then
    26371756        eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
    2638         echo "export $shlibpath_var"
     1757        $ECHO "export $shlibpath_var"
    26391758      fi
    26401759      $ECHO "$cmd$args"
     
    26431762}
    26441763
    2645 test "$opt_mode" = execute && func_mode_execute ${1+"$@"}
     1764test "$mode" = execute && func_mode_execute ${1+"$@"}
    26461765
    26471766
     
    26501769{
    26511770    $opt_debug
    2652     libs=
    2653     libdirs=
     1771    libdirs="$nonopt"
    26541772    admincmds=
    26551773
    2656     for opt in "$nonopt" ${1+"$@"}
    2657     do
    2658       if test -d "$opt"; then
    2659         func_append libdirs " $opt"
    2660 
    2661       elif test -f "$opt"; then
    2662         if func_lalib_unsafe_p "$opt"; then
    2663           func_append libs " $opt"
    2664         else
    2665           func_warning "\`$opt' is not a valid libtool archive"
    2666         fi
    2667 
    2668       else
    2669         func_fatal_error "invalid argument \`$opt'"
    2670       fi
    2671     done
    2672 
    2673     if test -n "$libs"; then
    2674       if test -n "$lt_sysroot"; then
    2675         sysroot_regex=`$ECHO "$lt_sysroot" | $SED "$sed_make_literal_regex"`
    2676         sysroot_cmd="s/\([ ']\)$sysroot_regex/\1/g;"
    2677       else
    2678         sysroot_cmd=
    2679       fi
    2680 
    2681       # Remove sysroot references
    2682       if $opt_dry_run; then
    2683         for lib in $libs; do
    2684           echo "removing references to $lt_sysroot and \`=' prefixes from $lib"
    2685         done
    2686       else
    2687         tmpdir=`func_mktempdir`
    2688         for lib in $libs; do
    2689           sed -e "${sysroot_cmd} s/\([ ']-[LR]\)=/\1/g; s/\([ ']\)=/\1/g" $lib \
    2690             > $tmpdir/tmp-la
    2691           mv -f $tmpdir/tmp-la $lib
    2692         done
    2693         ${RM}r "$tmpdir"
    2694       fi
    2695     fi
    2696 
    26971774    if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
     1775      for dir
     1776      do
     1777        libdirs="$libdirs $dir"
     1778      done
     1779
    26981780      for libdir in $libdirs; do
    26991781        if test -n "$finish_cmds"; then
     
    27051787          # Do the single finish_eval.
    27061788          eval cmds=\"$finish_eval\"
    2707           $opt_dry_run || eval "$cmds" || func_append admincmds "
     1789          $opt_dry_run || eval "$cmds" || admincmds="$admincmds
    27081790       $cmds"
    27091791        fi
     
    27141796    $opt_silent && exit $EXIT_SUCCESS
    27151797
    2716     if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
    2717       echo "----------------------------------------------------------------------"
    2718       echo "Libraries have been installed in:"
    2719       for libdir in $libdirs; do
    2720         $ECHO "   $libdir"
    2721       done
    2722       echo
    2723       echo "If you ever happen to want to link against installed libraries"
    2724       echo "in a given directory, LIBDIR, you must either use libtool, and"
    2725       echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
    2726       echo "flag during linking and do at least one of the following:"
    2727       if test -n "$shlibpath_var"; then
    2728         echo "   - add LIBDIR to the \`$shlibpath_var' environment variable"
    2729         echo "     during execution"
    2730       fi
    2731       if test -n "$runpath_var"; then
    2732         echo "   - add LIBDIR to the \`$runpath_var' environment variable"
    2733         echo "     during linking"
    2734       fi
    2735       if test -n "$hardcode_libdir_flag_spec"; then
    2736         libdir=LIBDIR
    2737         eval flag=\"$hardcode_libdir_flag_spec\"
    2738 
    2739         $ECHO "   - use the \`$flag' linker flag"
    2740       fi
    2741       if test -n "$admincmds"; then
    2742         $ECHO "   - have your system administrator run these commands:$admincmds"
    2743       fi
    2744       if test -f /etc/ld.so.conf; then
    2745         echo "   - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
    2746       fi
    2747       echo
    2748 
    2749       echo "See any operating system documentation about shared libraries for"
    2750       case $host in
    2751         solaris2.[6789]|solaris2.1[0-9])
    2752           echo "more information, such as the ld(1), crle(1) and ld.so(8) manual"
    2753           echo "pages."
    2754           ;;
    2755         *)
    2756           echo "more information, such as the ld(1) and ld.so(8) manual pages."
    2757           ;;
    2758       esac
    2759       echo "----------------------------------------------------------------------"
     1798    $ECHO "X----------------------------------------------------------------------" | $Xsed
     1799    $ECHO "Libraries have been installed in:"
     1800    for libdir in $libdirs; do
     1801      $ECHO "   $libdir"
     1802    done
     1803    $ECHO
     1804    $ECHO "If you ever happen to want to link against installed libraries"
     1805    $ECHO "in a given directory, LIBDIR, you must either use libtool, and"
     1806    $ECHO "specify the full pathname of the library, or use the \`-LLIBDIR'"
     1807    $ECHO "flag during linking and do at least one of the following:"
     1808    if test -n "$shlibpath_var"; then
     1809      $ECHO "   - add LIBDIR to the \`$shlibpath_var' environment variable"
     1810      $ECHO "     during execution"
    27601811    fi
     1812    if test -n "$runpath_var"; then
     1813      $ECHO "   - add LIBDIR to the \`$runpath_var' environment variable"
     1814      $ECHO "     during linking"
     1815    fi
     1816    if test -n "$hardcode_libdir_flag_spec"; then
     1817      libdir=LIBDIR
     1818      eval flag=\"$hardcode_libdir_flag_spec\"
     1819
     1820      $ECHO "   - use the \`$flag' linker flag"
     1821    fi
     1822    if test -n "$admincmds"; then
     1823      $ECHO "   - have your system administrator run these commands:$admincmds"
     1824    fi
     1825    if test -f /etc/ld.so.conf; then
     1826      $ECHO "   - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
     1827    fi
     1828    $ECHO
     1829
     1830    $ECHO "See any operating system documentation about shared libraries for"
     1831    case $host in
     1832      solaris2.[6789]|solaris2.1[0-9])
     1833        $ECHO "more information, such as the ld(1), crle(1) and ld.so(8) manual"
     1834        $ECHO "pages."
     1835        ;;
     1836      *)
     1837        $ECHO "more information, such as the ld(1) and ld.so(8) manual pages."
     1838        ;;
     1839    esac
     1840    $ECHO "X----------------------------------------------------------------------" | $Xsed
    27611841    exit $EXIT_SUCCESS
    27621842}
    27631843
    2764 test "$opt_mode" = finish && func_mode_finish ${1+"$@"}
     1844test "$mode" = finish && func_mode_finish ${1+"$@"}
    27651845
    27661846
     
    27731853    if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
    27741854       # Allow the use of GNU shtool's install command.
    2775        case $nonopt in *shtool*) :;; *) false;; esac; then
     1855       $ECHO "X$nonopt" | $GREP shtool >/dev/null; then
    27761856      # Aesthetically quote it.
    27771857      func_quote_for_eval "$nonopt"
     
    27871867    # Aesthetically quote it.
    27881868    func_quote_for_eval "$arg"
    2789     func_append install_prog "$func_quote_for_eval_result"
    2790     install_shared_prog=$install_prog
    2791     case " $install_prog " in
    2792       *[\\\ /]cp\ *) install_cp=: ;;
    2793       *) install_cp=false ;;
    2794     esac
     1869    install_prog="$install_prog$func_quote_for_eval_result"
    27951870
    27961871    # We need to accept at least all the BSD install flags.
     
    28021877    isdir=no
    28031878    stripme=
    2804     no_mode=:
    28051879    for arg
    28061880    do
    2807       arg2=
    28081881      if test -n "$dest"; then
    2809         func_append files " $dest"
     1882        files="$files $dest"
    28101883        dest=$arg
    28111884        continue
     
    28151888      -d) isdir=yes ;;
    28161889      -f)
    2817         if $install_cp; then :; else
    2818           prev=$arg
    2819         fi
     1890        case " $install_prog " in
     1891        *[\\\ /]cp\ *) ;;
     1892        *) prev=$arg ;;
     1893        esac
    28201894        ;;
    28211895      -g | -m | -o)
     
    28311905        # If the previous option needed an argument, then skip it.
    28321906        if test -n "$prev"; then
    2833           if test "x$prev" = x-m && test -n "$install_override_mode"; then
    2834             arg2=$install_override_mode
    2835             no_mode=false
    2836           fi
    28371907          prev=
    28381908        else
     
    28451915      # Aesthetically quote the argument.
    28461916      func_quote_for_eval "$arg"
    2847       func_append install_prog " $func_quote_for_eval_result"
    2848       if test -n "$arg2"; then
    2849         func_quote_for_eval "$arg2"
    2850       fi
    2851       func_append install_shared_prog " $func_quote_for_eval_result"
     1917      install_prog="$install_prog $func_quote_for_eval_result"
    28521918    done
    28531919
     
    28571923    test -n "$prev" && \
    28581924      func_fatal_help "the \`$prev' option requires an argument"
    2859 
    2860     if test -n "$install_override_mode" && $no_mode; then
    2861       if $install_cp; then :; else
    2862         func_quote_for_eval "$install_override_mode"
    2863         func_append install_shared_prog " -m $func_quote_for_eval_result"
    2864       fi
    2865     fi
    28661925
    28671926    if test -z "$files"; then
     
    29191978      *.$libext)
    29201979        # Do the static libraries later.
    2921         func_append staticlibs " $file"
     1980        staticlibs="$staticlibs $file"
    29221981        ;;
    29231982
    29241983      *.la)
    2925         func_resolve_sysroot "$file"
    2926         file=$func_resolve_sysroot_result
    2927 
    29281984        # Check to see that this really is a libtool archive.
    29291985        func_lalib_unsafe_p "$file" \
     
    29391995          case "$current_libdirs " in
    29401996          *" $libdir "*) ;;
    2941           *) func_append current_libdirs " $libdir" ;;
     1997          *) current_libdirs="$current_libdirs $libdir" ;;
    29421998          esac
    29431999        else
     
    29452001          case "$future_libdirs " in
    29462002          *" $libdir "*) ;;
    2947           *) func_append future_libdirs " $libdir" ;;
     2003          *) future_libdirs="$future_libdirs $libdir" ;;
    29482004          esac
    29492005        fi
     
    29512007        func_dirname "$file" "/" ""
    29522008        dir="$func_dirname_result"
    2953         func_append dir "$objdir"
     2009        dir="$dir$objdir"
    29542010
    29552011        if test -n "$relink_command"; then
    29562012          # Determine the prefix the user has applied to our future dir.
    2957           inst_prefix_dir=`$ECHO "$destdir" | $SED -e "s%$libdir\$%%"`
     2013          inst_prefix_dir=`$ECHO "X$destdir" | $Xsed -e "s%$libdir\$%%"`
    29582014
    29592015          # Don't allow the user to place us outside of our expected
     
    29682024          if test -n "$inst_prefix_dir"; then
    29692025            # Stick the inst_prefix_dir data into the link command.
    2970             relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
     2026            relink_command=`$ECHO "X$relink_command" | $Xsed -e "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
    29712027          else
    2972             relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
     2028            relink_command=`$ECHO "X$relink_command" | $Xsed -e "s%@inst_prefix_dir@%%"`
    29732029          fi
    29742030
     
    29882044
    29892045          # Install the shared library and build the symlinks.
    2990           func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \
     2046          func_show_eval "$install_prog $dir/$srcname $destdir/$realname" \
    29912047              'exit $?'
    29922048          tstripme="$stripme"
     
    30282084
    30292085        # Maybe install the static library, too.
    3030         test -n "$old_library" && func_append staticlibs " $dir/$old_library"
     2086        test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
    30312087        ;;
    30322088
     
    31282184              func_source "$lib"
    31292185            fi
    3130             libfile="$libdir/"`$ECHO "$lib" | $SED 's%^.*/%%g'` ### testsuite: skip nested quoting test
     2186            libfile="$libdir/"`$ECHO "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test
    31312187            if test -n "$libdir" && test ! -f "$libfile"; then
    31322188              func_warning "\`$lib' has not been installed in \`$libdir'"
     
    31472203                outputname="$tmpdir/$file"
    31482204                # Replace the output file specification.
    3149                 relink_command=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'`
     2205                relink_command=`$ECHO "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'`
    31502206
    31512207                $opt_silent || {
     
    31662222          else
    31672223            # Install the binary that we compiled earlier.
    3168             file=`$ECHO "$file$stripped_ext" | $SED "s%\([^/]*\)$%$objdir/\1%"`
     2224            file=`$ECHO "X$file$stripped_ext" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
    31692225          fi
    31702226        fi
     
    32252281}
    32262282
    3227 test "$opt_mode" = install && func_mode_install ${1+"$@"}
     2283test "$mode" = install && func_mode_install ${1+"$@"}
    32282284
    32292285
     
    32682324#endif
    32692325
    3270 #if defined(__GNUC__) && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4))
    3271 #pragma GCC diagnostic ignored \"-Wstrict-prototypes\"
    3272 #endif
    3273 
    3274 /* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests.  */
    3275 #if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE)
    3276 /* DATA imports from DLLs on WIN32 con't be const, because runtime
    3277    relocations are performed -- see ld's documentation on pseudo-relocs.  */
    3278 # define LT_DLSYM_CONST
    3279 #elif defined(__osf__)
    3280 /* This system does not cope well with relocations in const data.  */
    3281 # define LT_DLSYM_CONST
    3282 #else
    3283 # define LT_DLSYM_CONST const
    3284 #endif
    3285 
    32862326/* External symbol declarations for the compiler. */\
    32872327"
     
    32932333
    32942334          # Add our own program objects to the symbol list.
    3295           progfiles=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP`
     2335          progfiles=`$ECHO "X$objs$old_deplibs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
    32962336          for progfile in $progfiles; do
    3297             func_to_tool_file "$progfile" func_convert_file_msys_to_w32
    3298             func_verbose "extracting global C symbols from \`$func_to_tool_file_result'"
    3299             $opt_dry_run || eval "$NM $func_to_tool_file_result | $global_symbol_pipe >> '$nlist'"
     2337            func_verbose "extracting global C symbols from \`$progfile'"
     2338            $opt_dry_run || eval "$NM $progfile | $global_symbol_pipe >> '$nlist'"
    33002339          done
    33012340
     
    33332372              eval '$MV "$nlist"T "$nlist"'
    33342373              case $host in
    3335                 *cygwin* | *mingw* | *cegcc* )
     2374                *cygwin | *mingw* | *cegcc* )
    33362375                  eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
    33372376                  eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
     
    33462385          func_basename "$dlprefile"
    33472386          name="$func_basename_result"
    3348           case $host in
    3349             *cygwin* | *mingw* | *cegcc* )
    3350               # if an import library, we need to obtain dlname
    3351               if func_win32_import_lib_p "$dlprefile"; then
    3352                 func_tr_sh "$dlprefile"
    3353                 eval "curr_lafile=\$libfile_$func_tr_sh_result"
    3354                 dlprefile_dlbasename=""
    3355                 if test -n "$curr_lafile" && func_lalib_p "$curr_lafile"; then
    3356                   # Use subshell, to avoid clobbering current variable values
    3357                   dlprefile_dlname=`source "$curr_lafile" && echo "$dlname"`
    3358                   if test -n "$dlprefile_dlname" ; then
    3359                     func_basename "$dlprefile_dlname"
    3360                     dlprefile_dlbasename="$func_basename_result"
    3361                   else
    3362                     # no lafile. user explicitly requested -dlpreopen <import library>.
    3363                     $sharedlib_from_linklib_cmd "$dlprefile"
    3364                     dlprefile_dlbasename=$sharedlib_from_linklib_result
    3365                   fi
    3366                 fi
    3367                 $opt_dry_run || {
    3368                   if test -n "$dlprefile_dlbasename" ; then
    3369                     eval '$ECHO ": $dlprefile_dlbasename" >> "$nlist"'
    3370                   else
    3371                     func_warning "Could not compute DLL name from $name"
    3372                     eval '$ECHO ": $name " >> "$nlist"'
    3373                   fi
    3374                   func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
    3375                   eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe |
    3376                     $SED -e '/I __imp/d' -e 's/I __nm_/D /;s/_nm__//' >> '$nlist'"
    3377                 }
    3378               else # not an import lib
    3379                 $opt_dry_run || {
    3380                   eval '$ECHO ": $name " >> "$nlist"'
    3381                   func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
    3382                   eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
    3383                 }
    3384               fi
    3385             ;;
    3386             *)
    3387               $opt_dry_run || {
    3388                 eval '$ECHO ": $name " >> "$nlist"'
    3389                 func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
    3390                 eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
    3391               }
    3392             ;;
    3393           esac
     2387          $opt_dry_run || {
     2388            eval '$ECHO ": $name " >> "$nlist"'
     2389            eval "$NM $dlprefile 2>/dev/null | $global_symbol_pipe >> '$nlist'"
     2390          }
    33942391        done
    33952392
     
    34192416            eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
    34202417          else
    3421             echo '/* NONE */' >> "$output_objdir/$my_dlsyms"
     2418            $ECHO '/* NONE */' >> "$output_objdir/$my_dlsyms"
    34222419          fi
    34232420
    3424           echo >> "$output_objdir/$my_dlsyms" "\
     2421          $ECHO >> "$output_objdir/$my_dlsyms" "\
    34252422
    34262423/* The mapping between symbol names and symbols.  */
     
    34292426  void *address;
    34302427} lt_dlsymlist;
    3431 extern LT_DLSYM_CONST lt_dlsymlist
     2428"
     2429          case $host in
     2430          *cygwin* | *mingw* | *cegcc* )
     2431            $ECHO >> "$output_objdir/$my_dlsyms" "\
     2432/* DATA imports from DLLs on WIN32 con't be const, because
     2433   runtime relocations are performed -- see ld's documentation
     2434   on pseudo-relocs.  */"
     2435            lt_dlsym_const= ;;
     2436          *osf5*)
     2437            echo >> "$output_objdir/$my_dlsyms" "\
     2438/* This system does not cope well with relocations in const data */"
     2439            lt_dlsym_const= ;;
     2440          *)
     2441            lt_dlsym_const=const ;;
     2442          esac
     2443
     2444          $ECHO >> "$output_objdir/$my_dlsyms" "\
     2445extern $lt_dlsym_const lt_dlsymlist
    34322446lt_${my_prefix}_LTX_preloaded_symbols[];
    3433 LT_DLSYM_CONST lt_dlsymlist
     2447$lt_dlsym_const lt_dlsymlist
    34342448lt_${my_prefix}_LTX_preloaded_symbols[] =
    34352449{\
     
    34442458            ;;
    34452459          esac
    3446           echo >> "$output_objdir/$my_dlsyms" "\
     2460          $ECHO >> "$output_objdir/$my_dlsyms" "\
    34472461  {0, (void *) 0}
    34482462};
     
    34872501          case $arg in
    34882502          -pie | -fpie | -fPIE) ;;
    3489           *) func_append symtab_cflags " $arg" ;;
     2503          *) symtab_cflags="$symtab_cflags $arg" ;;
    34902504          esac
    34912505        done
     
    35022516        *cygwin* | *mingw* | *cegcc* )
    35032517          if test -f "$output_objdir/$my_outputname.def"; then
    3504             compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
    3505             finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
     2518            compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
     2519            finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
    35062520          else
    3507             compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
    3508             finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
     2521            compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
     2522            finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
    35092523          fi
    35102524          ;;
    35112525        *)
    3512           compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
    3513           finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
     2526          compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
     2527          finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
    35142528          ;;
    35152529        esac
     
    35252539
    35262540      # Nullify the symbol file.
    3527       compile_command=`$ECHO "$compile_command" | $SED "s% @SYMFILE@%%"`
    3528       finalize_command=`$ECHO "$finalize_command" | $SED "s% @SYMFILE@%%"`
     2541      compile_command=`$ECHO "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
     2542      finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
    35292543    fi
    35302544}
     
    35362550# Has to be a shell function in order to 'eat' the argument
    35372551# that is supplied when $file_magic_command is called.
    3538 # Despite the name, also deal with 64 bit binaries.
    35392552func_win32_libid ()
    35402553{
     
    35472560    ;;
    35482561  *ar\ archive*) # could be an import, or static
    3549     # Keep the egrep pattern in sync with the one in _LT_CHECK_MAGIC_METHOD.
    35502562    if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |
    3551        $EGREP 'file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev/null; then
    3552       func_to_tool_file "$1" func_convert_file_msys_to_w32
    3553       win32_nmres=`eval $NM -f posix -A \"$func_to_tool_file_result\" |
     2563       $EGREP 'file format pe-i386(.*architecture: i386)?' >/dev/null ; then
     2564      win32_nmres=`eval $NM -f posix -A $1 |
    35542565        $SED -n -e '
    35552566            1,100{
     
    35802591}
    35812592
    3582 # func_cygming_dll_for_implib ARG
    3583 #
    3584 # Platform-specific function to extract the
    3585 # name of the DLL associated with the specified
    3586 # import library ARG.
    3587 # Invoked by eval'ing the libtool variable
    3588 #    $sharedlib_from_linklib_cmd
    3589 # Result is available in the variable
    3590 #    $sharedlib_from_linklib_result
    3591 func_cygming_dll_for_implib ()
    3592 {
    3593   $opt_debug
    3594   sharedlib_from_linklib_result=`$DLLTOOL --identify-strict --identify "$1"`
    3595 }
    3596 
    3597 # func_cygming_dll_for_implib_fallback_core SECTION_NAME LIBNAMEs
    3598 #
    3599 # The is the core of a fallback implementation of a
    3600 # platform-specific function to extract the name of the
    3601 # DLL associated with the specified import library LIBNAME.
    3602 #
    3603 # SECTION_NAME is either .idata$6 or .idata$7, depending
    3604 # on the platform and compiler that created the implib.
    3605 #
    3606 # Echos the name of the DLL associated with the
    3607 # specified import library.
    3608 func_cygming_dll_for_implib_fallback_core ()
    3609 {
    3610   $opt_debug
    3611   match_literal=`$ECHO "$1" | $SED "$sed_make_literal_regex"`
    3612   $OBJDUMP -s --section "$1" "$2" 2>/dev/null |
    3613     $SED '/^Contents of section '"$match_literal"':/{
    3614       # Place marker at beginning of archive member dllname section
    3615       s/.*/====MARK====/
    3616       p
    3617       d
    3618     }
    3619     # These lines can sometimes be longer than 43 characters, but
    3620     # are always uninteresting
    3621     /:[  ]*file format pe[i]\{,1\}-/d
    3622     /^In archive [^:]*:/d
    3623     # Ensure marker is printed
    3624     /^====MARK====/p
    3625     # Remove all lines with less than 43 characters
    3626     /^.\{43\}/!d
    3627     # From remaining lines, remove first 43 characters
    3628     s/^.\{43\}//' |
    3629     $SED -n '
    3630       # Join marker and all lines until next marker into a single line
    3631       /^====MARK====/ b para
    3632       H
    3633       $ b para
    3634       b
    3635       :para
    3636       x
    3637       s/\n//g
    3638       # Remove the marker
    3639       s/^====MARK====//
    3640       # Remove trailing dots and whitespace
    3641       s/[\. \t]*$//
    3642       # Print
    3643       /./p' |
    3644     # we now have a list, one entry per line, of the stringified
    3645     # contents of the appropriate section of all members of the
    3646     # archive which possess that section. Heuristic: eliminate
    3647     # all those which have a first or second character that is
    3648     # a '.' (that is, objdump's representation of an unprintable
    3649     # character.) This should work for all archives with less than
    3650     # 0x302f exports -- but will fail for DLLs whose name actually
    3651     # begins with a literal '.' or a single character followed by
    3652     # a '.'.
    3653     #
    3654     # Of those that remain, print the first one.
    3655     $SED -e '/^\./d;/^.\./d;q'
    3656 }
    3657 
    3658 # func_cygming_gnu_implib_p ARG
    3659 # This predicate returns with zero status (TRUE) if
    3660 # ARG is a GNU/binutils-style import library. Returns
    3661 # with nonzero status (FALSE) otherwise.
    3662 func_cygming_gnu_implib_p ()
    3663 {
    3664   $opt_debug
    3665   func_to_tool_file "$1" func_convert_file_msys_to_w32
    3666   func_cygming_gnu_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $EGREP ' (_head_[A-Za-z0-9_]+_[ad]l*|[A-Za-z0-9_]+_[ad]l*_iname)$'`
    3667   test -n "$func_cygming_gnu_implib_tmp"
    3668 }
    3669 
    3670 # func_cygming_ms_implib_p ARG
    3671 # This predicate returns with zero status (TRUE) if
    3672 # ARG is an MS-style import library. Returns
    3673 # with nonzero status (FALSE) otherwise.
    3674 func_cygming_ms_implib_p ()
    3675 {
    3676   $opt_debug
    3677   func_to_tool_file "$1" func_convert_file_msys_to_w32
    3678   func_cygming_ms_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $GREP '_NULL_IMPORT_DESCRIPTOR'`
    3679   test -n "$func_cygming_ms_implib_tmp"
    3680 }
    3681 
    3682 # func_cygming_dll_for_implib_fallback ARG
    3683 # Platform-specific function to extract the
    3684 # name of the DLL associated with the specified
    3685 # import library ARG.
    3686 #
    3687 # This fallback implementation is for use when $DLLTOOL
    3688 # does not support the --identify-strict option.
    3689 # Invoked by eval'ing the libtool variable
    3690 #    $sharedlib_from_linklib_cmd
    3691 # Result is available in the variable
    3692 #    $sharedlib_from_linklib_result
    3693 func_cygming_dll_for_implib_fallback ()
    3694 {
    3695   $opt_debug
    3696   if func_cygming_gnu_implib_p "$1" ; then
    3697     # binutils import library
    3698     sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$7' "$1"`
    3699   elif func_cygming_ms_implib_p "$1" ; then
    3700     # ms-generated import library
    3701     sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$6' "$1"`
    3702   else
    3703     # unknown
    3704     sharedlib_from_linklib_result=""
    3705   fi
    3706 }
    37072593
    37082594
     
    37132599    f_ex_an_ar_dir="$1"; shift
    37142600    f_ex_an_ar_oldlib="$1"
    3715     if test "$lock_old_archive_extraction" = yes; then
    3716       lockfile=$f_ex_an_ar_oldlib.lock
    3717       until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
    3718         func_echo "Waiting for $lockfile to be removed"
    3719         sleep 2
    3720       done
    3721     fi
    3722     func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \
    3723                    'stat=$?; rm -f "$lockfile"; exit $stat'
    3724     if test "$lock_old_archive_extraction" = yes; then
    3725       $opt_dry_run || rm -f "$lockfile"
    3726     fi
     2601    func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" 'exit $?'
    37272602    if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
    37282603     :
     
    37952670            darwin_files=
    37962671            for darwin_file in $darwin_filelist; do
    3797               darwin_files=`find unfat-$$ -name $darwin_file -print | sort | $NL2SP`
     2672              darwin_files=`find unfat-$$ -name $darwin_file -print | $NL2SP`
    37982673              $LIPO -create -output "$darwin_file" $darwin_files
    37992674            done # $darwin_filelist
     
    38102685        ;;
    38112686      esac
    3812       my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | sort | $NL2SP`
     2687      my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
    38132688    done
    38142689
    38152690    func_extract_archives_result="$my_oldobjs"
    38162691}
     2692
     2693
     2694
     2695# func_emit_wrapper_part1 [arg=no]
     2696#
     2697# Emit the first part of a libtool wrapper script on stdout.
     2698# For more information, see the description associated with
     2699# func_emit_wrapper(), below.
     2700func_emit_wrapper_part1 ()
     2701{
     2702        func_emit_wrapper_part1_arg1=no
     2703        if test -n "$1" ; then
     2704          func_emit_wrapper_part1_arg1=$1
     2705        fi
     2706
     2707        $ECHO "\
     2708#! $SHELL
     2709
     2710# $output - temporary wrapper script for $objdir/$outputname
     2711# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
     2712#
     2713# The $output program cannot be directly executed until all the libtool
     2714# libraries that it depends on are installed.
     2715#
     2716# This wrapper script should never be moved out of the build directory.
     2717# If it is, it will not operate correctly.
     2718
     2719# Sed substitution that helps us do robust quoting.  It backslashifies
     2720# metacharacters that are still active within double-quoted strings.
     2721Xsed='${SED} -e 1s/^X//'
     2722sed_quote_subst='$sed_quote_subst'
     2723
     2724# Be Bourne compatible
     2725if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
     2726  emulate sh
     2727  NULLCMD=:
     2728  # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
     2729  # is contrary to our usage.  Disable this feature.
     2730  alias -g '\${1+\"\$@\"}'='\"\$@\"'
     2731  setopt NO_GLOB_SUBST
     2732else
     2733  case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
     2734fi
     2735BIN_SH=xpg4; export BIN_SH # for Tru64
     2736DUALCASE=1; export DUALCASE # for MKS sh
     2737
     2738# The HP-UX ksh and POSIX shell print the target directory to stdout
     2739# if CDPATH is set.
     2740(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
     2741
     2742relink_command=\"$relink_command\"
     2743
     2744# This environment variable determines our operation mode.
     2745if test \"\$libtool_install_magic\" = \"$magic\"; then
     2746  # install mode needs the following variables:
     2747  generated_by_libtool_version='$macro_version'
     2748  notinst_deplibs='$notinst_deplibs'
     2749else
     2750  # When we are sourced in execute mode, \$file and \$ECHO are already set.
     2751  if test \"\$libtool_execute_magic\" != \"$magic\"; then
     2752    ECHO=\"$qecho\"
     2753    file=\"\$0\"
     2754    # Make sure echo works.
     2755    if test \"X\$1\" = X--no-reexec; then
     2756      # Discard the --no-reexec flag, and continue.
     2757      shift
     2758    elif test \"X\`{ \$ECHO '\t'; } 2>/dev/null\`\" = 'X\t'; then
     2759      # Yippee, \$ECHO works!
     2760      :
     2761    else
     2762      # Restart under the correct shell, and then maybe \$ECHO will work.
     2763      exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}
     2764    fi
     2765  fi\
     2766"
     2767        $ECHO "\
     2768
     2769  # Find the directory that this script lives in.
     2770  thisdir=\`\$ECHO \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
     2771  test \"x\$thisdir\" = \"x\$file\" && thisdir=.
     2772
     2773  # Follow symbolic links until we get to the real thisdir.
     2774  file=\`ls -ld \"\$file\" | ${SED} -n 's/.*-> //p'\`
     2775  while test -n \"\$file\"; do
     2776    destdir=\`\$ECHO \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`
     2777
     2778    # If there was a directory component, then change thisdir.
     2779    if test \"x\$destdir\" != \"x\$file\"; then
     2780      case \"\$destdir\" in
     2781      [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
     2782      *) thisdir=\"\$thisdir/\$destdir\" ;;
     2783      esac
     2784    fi
     2785
     2786    file=\`\$ECHO \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
     2787    file=\`ls -ld \"\$thisdir/\$file\" | ${SED} -n 's/.*-> //p'\`
     2788  done
     2789"
     2790}
     2791# end: func_emit_wrapper_part1
     2792
     2793# func_emit_wrapper_part2 [arg=no]
     2794#
     2795# Emit the second part of a libtool wrapper script on stdout.
     2796# For more information, see the description associated with
     2797# func_emit_wrapper(), below.
     2798func_emit_wrapper_part2 ()
     2799{
     2800        func_emit_wrapper_part2_arg1=no
     2801        if test -n "$1" ; then
     2802          func_emit_wrapper_part2_arg1=$1
     2803        fi
     2804
     2805        $ECHO "\
     2806
     2807  # Usually 'no', except on cygwin/mingw when embedded into
     2808  # the cwrapper.
     2809  WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_part2_arg1
     2810  if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
     2811    # special case for '.'
     2812    if test \"\$thisdir\" = \".\"; then
     2813      thisdir=\`pwd\`
     2814    fi
     2815    # remove .libs from thisdir
     2816    case \"\$thisdir\" in
     2817    *[\\\\/]$objdir ) thisdir=\`\$ECHO \"X\$thisdir\" | \$Xsed -e 's%[\\\\/][^\\\\/]*$%%'\` ;;
     2818    $objdir )   thisdir=. ;;
     2819    esac
     2820  fi
     2821
     2822  # Try to get the absolute directory name.
     2823  absdir=\`cd \"\$thisdir\" && pwd\`
     2824  test -n \"\$absdir\" && thisdir=\"\$absdir\"
     2825"
     2826
     2827        if test "$fast_install" = yes; then
     2828          $ECHO "\
     2829  program=lt-'$outputname'$exeext
     2830  progdir=\"\$thisdir/$objdir\"
     2831
     2832  if test ! -f \"\$progdir/\$program\" ||
     2833     { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
     2834       test \"X\$file\" != \"X\$progdir/\$program\"; }; then
     2835
     2836    file=\"\$\$-\$program\"
     2837
     2838    if test ! -d \"\$progdir\"; then
     2839      $MKDIR \"\$progdir\"
     2840    else
     2841      $RM \"\$progdir/\$file\"
     2842    fi"
     2843
     2844          $ECHO "\
     2845
     2846    # relink executable if necessary
     2847    if test -n \"\$relink_command\"; then
     2848      if relink_command_output=\`eval \$relink_command 2>&1\`; then :
     2849      else
     2850        $ECHO \"\$relink_command_output\" >&2
     2851        $RM \"\$progdir/\$file\"
     2852        exit 1
     2853      fi
     2854    fi
     2855
     2856    $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
     2857    { $RM \"\$progdir/\$program\";
     2858      $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
     2859    $RM \"\$progdir/\$file\"
     2860  fi"
     2861        else
     2862          $ECHO "\
     2863  program='$outputname'
     2864  progdir=\"\$thisdir/$objdir\"
     2865"
     2866        fi
     2867
     2868        $ECHO "\
     2869
     2870  if test -f \"\$progdir/\$program\"; then"
     2871
     2872        # Export our shlibpath_var if we have one.
     2873        if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
     2874          $ECHO "\
     2875    # Add our own library path to $shlibpath_var
     2876    $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
     2877
     2878    # Some systems cannot cope with colon-terminated $shlibpath_var
     2879    # The second colon is a workaround for a bug in BeOS R4 sed
     2880    $shlibpath_var=\`\$ECHO \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`
     2881
     2882    export $shlibpath_var
     2883"
     2884        fi
     2885
     2886        # fixup the dll searchpath if we need to.
     2887        if test -n "$dllsearchpath"; then
     2888          $ECHO "\
     2889    # Add the dll search path components to the executable PATH
     2890    PATH=$dllsearchpath:\$PATH
     2891"
     2892        fi
     2893
     2894        $ECHO "\
     2895    if test \"\$libtool_execute_magic\" != \"$magic\"; then
     2896      # Run the actual program with our arguments.
     2897"
     2898        case $host in
     2899        # Backslashes separate directories on plain windows
     2900        *-*-mingw | *-*-os2* | *-cegcc*)
     2901          $ECHO "\
     2902      exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
     2903"
     2904          ;;
     2905
     2906        *)
     2907          $ECHO "\
     2908      exec \"\$progdir/\$program\" \${1+\"\$@\"}
     2909"
     2910          ;;
     2911        esac
     2912        $ECHO "\
     2913      \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
     2914      exit 1
     2915    fi
     2916  else
     2917    # The program doesn't exist.
     2918    \$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
     2919    \$ECHO \"This script is just a wrapper for \$program.\" 1>&2
     2920    $ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
     2921    exit 1
     2922  fi
     2923fi\
     2924"
     2925}
     2926# end: func_emit_wrapper_part2
    38172927
    38182928
     
    38332943func_emit_wrapper ()
    38342944{
    3835         func_emit_wrapper_arg1=${1-no}
    3836 
    3837         $ECHO "\
    3838 #! $SHELL
    3839 
    3840 # $output - temporary wrapper script for $objdir/$outputname
    3841 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
     2945        func_emit_wrapper_arg1=no
     2946        if test -n "$1" ; then
     2947          func_emit_wrapper_arg1=$1
     2948        fi
     2949
     2950        # split this up so that func_emit_cwrapperexe_src
     2951        # can call each part independently.
     2952        func_emit_wrapper_part1 "${func_emit_wrapper_arg1}"
     2953        func_emit_wrapper_part2 "${func_emit_wrapper_arg1}"
     2954}
     2955
     2956
     2957# func_to_host_path arg
    38422958#
    3843 # The $output program cannot be directly executed until all the libtool
    3844 # libraries that it depends on are installed.
     2959# Convert paths to host format when used with build tools.
     2960# Intended for use with "native" mingw (where libtool itself
     2961# is running under the msys shell), or in the following cross-
     2962# build environments:
     2963#    $build          $host
     2964#    mingw (msys)    mingw  [e.g. native]
     2965#    cygwin          mingw
     2966#    *nix + wine     mingw
     2967# where wine is equipped with the `winepath' executable.
     2968# In the native mingw case, the (msys) shell automatically
     2969# converts paths for any non-msys applications it launches,
     2970# but that facility isn't available from inside the cwrapper.
     2971# Similar accommodations are necessary for $host mingw and
     2972# $build cygwin.  Calling this function does no harm for other
     2973# $host/$build combinations not listed above.
    38452974#
    3846 # This wrapper script should never be moved out of the build directory.
    3847 # If it is, it will not operate correctly.
    3848 
    3849 # Sed substitution that helps us do robust quoting.  It backslashifies
    3850 # metacharacters that are still active within double-quoted strings.
    3851 sed_quote_subst='$sed_quote_subst'
    3852 
    3853 # Be Bourne compatible
    3854 if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
    3855   emulate sh
    3856   NULLCMD=:
    3857   # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
    3858   # is contrary to our usage.  Disable this feature.
    3859   alias -g '\${1+\"\$@\"}'='\"\$@\"'
    3860   setopt NO_GLOB_SUBST
    3861 else
    3862   case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
    3863 fi
    3864 BIN_SH=xpg4; export BIN_SH # for Tru64
    3865 DUALCASE=1; export DUALCASE # for MKS sh
    3866 
    3867 # The HP-UX ksh and POSIX shell print the target directory to stdout
    3868 # if CDPATH is set.
    3869 (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
    3870 
    3871 relink_command=\"$relink_command\"
    3872 
    3873 # This environment variable determines our operation mode.
    3874 if test \"\$libtool_install_magic\" = \"$magic\"; then
    3875   # install mode needs the following variables:
    3876   generated_by_libtool_version='$macro_version'
    3877   notinst_deplibs='$notinst_deplibs'
    3878 else
    3879   # When we are sourced in execute mode, \$file and \$ECHO are already set.
    3880   if test \"\$libtool_execute_magic\" != \"$magic\"; then
    3881     file=\"\$0\""
    3882 
    3883     qECHO=`$ECHO "$ECHO" | $SED "$sed_quote_subst"`
    3884     $ECHO "\
    3885 
    3886 # A function that is used when there is no print builtin or printf.
    3887 func_fallback_echo ()
     2975# ARG is the path (on $build) that should be converted to
     2976# the proper representation for $host. The result is stored
     2977# in $func_to_host_path_result.
     2978func_to_host_path ()
    38882979{
    3889   eval 'cat <<_LTECHO_EOF
    3890 \$1
    3891 _LTECHO_EOF'
    3892 }
    3893     ECHO=\"$qECHO\"
    3894   fi
    3895 
    3896 # Very basic option parsing. These options are (a) specific to
    3897 # the libtool wrapper, (b) are identical between the wrapper
    3898 # /script/ and the wrapper /executable/ which is used only on
    3899 # windows platforms, and (c) all begin with the string "--lt-"
    3900 # (application programs are unlikely to have options which match
    3901 # this pattern).
    3902 #
    3903 # There are only two supported options: --lt-debug and
    3904 # --lt-dump-script. There is, deliberately, no --lt-help.
    3905 #
    3906 # The first argument to this parsing function should be the
    3907 # script's $0 value, followed by "$@".
    3908 lt_option_debug=
    3909 func_parse_lt_options ()
    3910 {
    3911   lt_script_arg0=\$0
    3912   shift
    3913   for lt_opt
    3914   do
    3915     case \"\$lt_opt\" in
    3916     --lt-debug) lt_option_debug=1 ;;
    3917     --lt-dump-script)
    3918         lt_dump_D=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%/[^/]*$%%'\`
    3919         test \"X\$lt_dump_D\" = \"X\$lt_script_arg0\" && lt_dump_D=.
    3920         lt_dump_F=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%^.*/%%'\`
    3921         cat \"\$lt_dump_D/\$lt_dump_F\"
    3922         exit 0
    3923       ;;
    3924     --lt-*)
    3925         \$ECHO \"Unrecognized --lt- option: '\$lt_opt'\" 1>&2
    3926         exit 1
    3927       ;;
     2980  func_to_host_path_result="$1"
     2981  if test -n "$1" ; then
     2982    case $host in
     2983      *mingw* )
     2984        lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
     2985        case $build in
     2986          *mingw* ) # actually, msys
     2987            # awkward: cmd appends spaces to result
     2988            lt_sed_strip_trailing_spaces="s/[ ]*\$//"
     2989            func_to_host_path_tmp1=`( cmd //c echo "$1" |\
     2990              $SED -e "$lt_sed_strip_trailing_spaces" ) 2>/dev/null || echo ""`
     2991            func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\
     2992              $SED -e "$lt_sed_naive_backslashify"`
     2993            ;;
     2994          *cygwin* )
     2995            func_to_host_path_tmp1=`cygpath -w "$1"`
     2996            func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\
     2997              $SED -e "$lt_sed_naive_backslashify"`
     2998            ;;
     2999          * )
     3000            # Unfortunately, winepath does not exit with a non-zero
     3001            # error code, so we are forced to check the contents of
     3002            # stdout. On the other hand, if the command is not
     3003            # found, the shell will set an exit code of 127 and print
     3004            # *an error message* to stdout. So we must check for both
     3005            # error code of zero AND non-empty stdout, which explains
     3006            # the odd construction:
     3007            func_to_host_path_tmp1=`winepath -w "$1" 2>/dev/null`
     3008            if test "$?" -eq 0 && test -n "${func_to_host_path_tmp1}"; then
     3009              func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\
     3010                $SED -e "$lt_sed_naive_backslashify"`
     3011            else
     3012              # Allow warning below.
     3013              func_to_host_path_result=""
     3014            fi
     3015            ;;
     3016        esac
     3017        if test -z "$func_to_host_path_result" ; then
     3018          func_error "Could not determine host path corresponding to"
     3019          func_error "  '$1'"
     3020          func_error "Continuing, but uninstalled executables may not work."
     3021          # Fallback:
     3022          func_to_host_path_result="$1"
     3023        fi
     3024        ;;
    39283025    esac
    3929   done
    3930 
    3931   # Print the debug banner immediately:
    3932   if test -n \"\$lt_option_debug\"; then
    3933     echo \"${outputname}:${output}:\${LINENO}: libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\" 1>&2
    39343026  fi
    39353027}
    3936 
    3937 # Used when --lt-debug. Prints its arguments to stdout
    3938 # (redirection is the responsibility of the caller)
    3939 func_lt_dump_args ()
     3028# end: func_to_host_path
     3029
     3030# func_to_host_pathlist arg
     3031#
     3032# Convert pathlists to host format when used with build tools.
     3033# See func_to_host_path(), above. This function supports the
     3034# following $build/$host combinations (but does no harm for
     3035# combinations not listed here):
     3036#    $build          $host
     3037#    mingw (msys)    mingw  [e.g. native]
     3038#    cygwin          mingw
     3039#    *nix + wine     mingw
     3040#
     3041# Path separators are also converted from $build format to
     3042# $host format. If ARG begins or ends with a path separator
     3043# character, it is preserved (but converted to $host format)
     3044# on output.
     3045#
     3046# ARG is a pathlist (on $build) that should be converted to
     3047# the proper representation on $host. The result is stored
     3048# in $func_to_host_pathlist_result.
     3049func_to_host_pathlist ()
    39403050{
    3941   lt_dump_args_N=1;
    3942   for lt_arg
    3943   do
    3944     \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[\$lt_dump_args_N]: \$lt_arg\"
    3945     lt_dump_args_N=\`expr \$lt_dump_args_N + 1\`
    3946   done
    3947 }
    3948 
    3949 # Core function for launching the target application
    3950 func_exec_program_core ()
    3951 {
    3952 "
    3953   case $host in
    3954   # Backslashes separate directories on plain windows
    3955   *-*-mingw | *-*-os2* | *-cegcc*)
    3956     $ECHO "\
    3957       if test -n \"\$lt_option_debug\"; then
    3958         \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir\\\\\$program\" 1>&2
    3959         func_lt_dump_args \${1+\"\$@\"} 1>&2
    3960       fi
    3961       exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
    3962 "
    3963     ;;
    3964 
    3965   *)
    3966     $ECHO "\
    3967       if test -n \"\$lt_option_debug\"; then
    3968         \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir/\$program\" 1>&2
    3969         func_lt_dump_args \${1+\"\$@\"} 1>&2
    3970       fi
    3971       exec \"\$progdir/\$program\" \${1+\"\$@\"}
    3972 "
    3973     ;;
    3974   esac
    3975   $ECHO "\
    3976       \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
    3977       exit 1
    3978 }
    3979 
    3980 # A function to encapsulate launching the target application
    3981 # Strips options in the --lt-* namespace from \$@ and
    3982 # launches target application with the remaining arguments.
    3983 func_exec_program ()
    3984 {
    3985   for lt_wr_arg
    3986   do
    3987     case \$lt_wr_arg in
    3988     --lt-*) ;;
    3989     *) set x \"\$@\" \"\$lt_wr_arg\"; shift;;
    3990     esac
    3991     shift
    3992   done
    3993   func_exec_program_core \${1+\"\$@\"}
    3994 }
    3995 
    3996   # Parse options
    3997   func_parse_lt_options \"\$0\" \${1+\"\$@\"}
    3998 
    3999   # Find the directory that this script lives in.
    4000   thisdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*$%%'\`
    4001   test \"x\$thisdir\" = \"x\$file\" && thisdir=.
    4002 
    4003   # Follow symbolic links until we get to the real thisdir.
    4004   file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\`
    4005   while test -n \"\$file\"; do
    4006     destdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*\$%%'\`
    4007 
    4008     # If there was a directory component, then change thisdir.
    4009     if test \"x\$destdir\" != \"x\$file\"; then
    4010       case \"\$destdir\" in
    4011       [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
    4012       *) thisdir=\"\$thisdir/\$destdir\" ;;
    4013       esac
    4014     fi
    4015 
    4016     file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\`
    4017     file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\`
    4018   done
    4019 
    4020   # Usually 'no', except on cygwin/mingw when embedded into
    4021   # the cwrapper.
    4022   WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1
    4023   if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
    4024     # special case for '.'
    4025     if test \"\$thisdir\" = \".\"; then
    4026       thisdir=\`pwd\`
    4027     fi
    4028     # remove .libs from thisdir
    4029     case \"\$thisdir\" in
    4030     *[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%[\\\\/][^\\\\/]*$%%'\` ;;
    4031     $objdir )   thisdir=. ;;
     3051  func_to_host_pathlist_result="$1"
     3052  if test -n "$1" ; then
     3053    case $host in
     3054      *mingw* )
     3055        lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
     3056        # Remove leading and trailing path separator characters from
     3057        # ARG. msys behavior is inconsistent here, cygpath turns them
     3058        # into '.;' and ';.', and winepath ignores them completely.
     3059        func_to_host_pathlist_tmp2="$1"
     3060        # Once set for this call, this variable should not be
     3061        # reassigned. It is used in tha fallback case.
     3062        func_to_host_pathlist_tmp1=`echo "$func_to_host_pathlist_tmp2" |\
     3063          $SED -e 's|^:*||' -e 's|:*$||'`
     3064        case $build in
     3065          *mingw* ) # Actually, msys.
     3066            # Awkward: cmd appends spaces to result.
     3067            lt_sed_strip_trailing_spaces="s/[ ]*\$//"
     3068            func_to_host_pathlist_tmp2=`( cmd //c echo "$func_to_host_pathlist_tmp1" |\
     3069              $SED -e "$lt_sed_strip_trailing_spaces" ) 2>/dev/null || echo ""`
     3070            func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp2" |\
     3071              $SED -e "$lt_sed_naive_backslashify"`
     3072            ;;
     3073          *cygwin* )
     3074            func_to_host_pathlist_tmp2=`cygpath -w -p "$func_to_host_pathlist_tmp1"`
     3075            func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp2" |\
     3076              $SED -e "$lt_sed_naive_backslashify"`
     3077            ;;
     3078          * )
     3079            # unfortunately, winepath doesn't convert pathlists
     3080            func_to_host_pathlist_result=""
     3081            func_to_host_pathlist_oldIFS=$IFS
     3082            IFS=:
     3083            for func_to_host_pathlist_f in $func_to_host_pathlist_tmp1 ; do
     3084              IFS=$func_to_host_pathlist_oldIFS
     3085              if test -n "$func_to_host_pathlist_f" ; then
     3086                func_to_host_path "$func_to_host_pathlist_f"
     3087                if test -n "$func_to_host_path_result" ; then
     3088                  if test -z "$func_to_host_pathlist_result" ; then
     3089                    func_to_host_pathlist_result="$func_to_host_path_result"
     3090                  else
     3091                    func_to_host_pathlist_result="$func_to_host_pathlist_result;$func_to_host_path_result"
     3092                  fi
     3093                fi
     3094              fi
     3095              IFS=:
     3096            done
     3097            IFS=$func_to_host_pathlist_oldIFS
     3098            ;;
     3099        esac
     3100        if test -z "$func_to_host_pathlist_result" ; then
     3101          func_error "Could not determine the host path(s) corresponding to"
     3102          func_error "  '$1'"
     3103          func_error "Continuing, but uninstalled executables may not work."
     3104          # Fallback. This may break if $1 contains DOS-style drive
     3105          # specifications. The fix is not to complicate the expression
     3106          # below, but for the user to provide a working wine installation
     3107          # with winepath so that path translation in the cross-to-mingw
     3108          # case works properly.
     3109          lt_replace_pathsep_nix_to_dos="s|:|;|g"
     3110          func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp1" |\
     3111            $SED -e "$lt_replace_pathsep_nix_to_dos"`
     3112        fi
     3113        # Now, add the leading and trailing path separators back
     3114        case "$1" in
     3115          :* ) func_to_host_pathlist_result=";$func_to_host_pathlist_result"
     3116            ;;
     3117        esac
     3118        case "$1" in
     3119          *: ) func_to_host_pathlist_result="$func_to_host_pathlist_result;"
     3120            ;;
     3121        esac
     3122        ;;
    40323123    esac
    40333124  fi
    4034 
    4035   # Try to get the absolute directory name.
    4036   absdir=\`cd \"\$thisdir\" && pwd\`
    4037   test -n \"\$absdir\" && thisdir=\"\$absdir\"
    4038 "
    4039 
    4040         if test "$fast_install" = yes; then
    4041           $ECHO "\
    4042   program=lt-'$outputname'$exeext
    4043   progdir=\"\$thisdir/$objdir\"
    4044 
    4045   if test ! -f \"\$progdir/\$program\" ||
    4046      { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
    4047        test \"X\$file\" != \"X\$progdir/\$program\"; }; then
    4048 
    4049     file=\"\$\$-\$program\"
    4050 
    4051     if test ! -d \"\$progdir\"; then
    4052       $MKDIR \"\$progdir\"
    4053     else
    4054       $RM \"\$progdir/\$file\"
    4055     fi"
    4056 
    4057           $ECHO "\
    4058 
    4059     # relink executable if necessary
    4060     if test -n \"\$relink_command\"; then
    4061       if relink_command_output=\`eval \$relink_command 2>&1\`; then :
    4062       else
    4063         $ECHO \"\$relink_command_output\" >&2
    4064         $RM \"\$progdir/\$file\"
    4065         exit 1
    4066       fi
    4067     fi
    4068 
    4069     $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
    4070     { $RM \"\$progdir/\$program\";
    4071       $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
    4072     $RM \"\$progdir/\$file\"
    4073   fi"
    4074         else
    4075           $ECHO "\
    4076   program='$outputname'
    4077   progdir=\"\$thisdir/$objdir\"
    4078 "
    4079         fi
    4080 
    4081         $ECHO "\
    4082 
    4083   if test -f \"\$progdir/\$program\"; then"
    4084 
    4085         # fixup the dll searchpath if we need to.
    4086         #
    4087         # Fix the DLL searchpath if we need to.  Do this before prepending
    4088         # to shlibpath, because on Windows, both are PATH and uninstalled
    4089         # libraries must come first.
    4090         if test -n "$dllsearchpath"; then
    4091           $ECHO "\
    4092     # Add the dll search path components to the executable PATH
    4093     PATH=$dllsearchpath:\$PATH
    4094 "
    4095         fi
    4096 
    4097         # Export our shlibpath_var if we have one.
    4098         if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
    4099           $ECHO "\
    4100     # Add our own library path to $shlibpath_var
    4101     $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
    4102 
    4103     # Some systems cannot cope with colon-terminated $shlibpath_var
    4104     # The second colon is a workaround for a bug in BeOS R4 sed
    4105     $shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\`
    4106 
    4107     export $shlibpath_var
    4108 "
    4109         fi
    4110 
    4111         $ECHO "\
    4112     if test \"\$libtool_execute_magic\" != \"$magic\"; then
    4113       # Run the actual program with our arguments.
    4114       func_exec_program \${1+\"\$@\"}
    4115     fi
    4116   else
    4117     # The program doesn't exist.
    4118     \$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
    4119     \$ECHO \"This script is just a wrapper for \$program.\" 1>&2
    4120     \$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
    4121     exit 1
    4122   fi
    4123 fi\
    4124 "
    41253125}
    4126 
     3126# end: func_to_host_pathlist
    41273127
    41283128# func_emit_cwrapperexe_src
     
    41423142   This wrapper executable should never be moved out of the build directory.
    41433143   If it is, it will not operate correctly.
     3144
     3145   Currently, it simply execs the wrapper *script* "$SHELL $output",
     3146   but could eventually absorb all of the scripts functionality and
     3147   exec $objdir/$outputname directly.
    41443148*/
    41453149EOF
    41463150            cat <<"EOF"
    4147 #ifdef _MSC_VER
    4148 # define _CRT_SECURE_NO_DEPRECATE 1
    4149 #endif
    41503151#include <stdio.h>
    41513152#include <stdlib.h>
     
    41543155# include <process.h>
    41553156# include <io.h>
     3157# define setmode _setmode
    41563158#else
    41573159# include <unistd.h>
     
    41593161# ifdef __CYGWIN__
    41603162#  include <io.h>
     3163#  define HAVE_SETENV
     3164#  ifdef __STRICT_ANSI__
     3165char *realpath (const char *, char *);
     3166int putenv (char *);
     3167int setenv (const char *, const char *, int);
     3168#  endif
    41613169# endif
    41623170#endif
     
    41703178#include <sys/stat.h>
    41713179
    4172 /* declarations of non-ANSI functions */
    4173 #if defined(__MINGW32__)
    4174 # ifdef __STRICT_ANSI__
    4175 int _putenv (const char *);
    4176 # endif
    4177 #elif defined(__CYGWIN__)
    4178 # ifdef __STRICT_ANSI__
    4179 char *realpath (const char *, char *);
    4180 int putenv (char *);
    4181 int setenv (const char *, const char *, int);
    4182 # endif
    4183 /* #elif defined (other platforms) ... */
    4184 #endif
    4185 
    4186 /* portability defines, excluding path handling macros */
    4187 #if defined(_MSC_VER)
    4188 # define setmode _setmode
    4189 # define stat    _stat
    4190 # define chmod   _chmod
    4191 # define getcwd  _getcwd
    4192 # define putenv  _putenv
    4193 # define S_IXUSR _S_IEXEC
    4194 # ifndef _INTPTR_T_DEFINED
    4195 #  define _INTPTR_T_DEFINED
    4196 #  define intptr_t int
    4197 # endif
    4198 #elif defined(__MINGW32__)
    4199 # define setmode _setmode
    4200 # define stat    _stat
    4201 # define chmod   _chmod
    4202 # define getcwd  _getcwd
    4203 # define putenv  _putenv
    4204 #elif defined(__CYGWIN__)
    4205 # define HAVE_SETENV
    4206 # define FOPEN_WB "wb"
    4207 /* #elif defined (other platforms) ... */
    4208 #endif
    4209 
    42103180#if defined(PATH_MAX)
    42113181# define LT_PATHMAX PATH_MAX
     
    42233193#endif
    42243194
    4225 /* path handling portability macros */
     3195#ifdef _MSC_VER
     3196# define S_IXUSR _S_IEXEC
     3197# define stat _stat
     3198# ifndef _INTPTR_T_DEFINED
     3199#  define intptr_t int
     3200# endif
     3201#endif
     3202
    42263203#ifndef DIR_SEPARATOR
    42273204# define DIR_SEPARATOR '/'
     
    42543231#endif /* PATH_SEPARATOR_2 */
    42553232
     3233#ifdef __CYGWIN__
     3234# define FOPEN_WB "wb"
     3235#endif
     3236
    42563237#ifndef FOPEN_WB
    42573238# define FOPEN_WB "w"
     
    42663247} while (0)
    42673248
    4268 #if defined(LT_DEBUGWRAPPER)
    4269 static int lt_debug = 1;
     3249#undef LTWRAPPER_DEBUGPRINTF
     3250#if defined DEBUGWRAPPER
     3251# define LTWRAPPER_DEBUGPRINTF(args) ltwrapper_debugprintf args
     3252static void
     3253ltwrapper_debugprintf (const char *fmt, ...)
     3254{
     3255    va_list args;
     3256    va_start (args, fmt);
     3257    (void) vfprintf (stderr, fmt, args);
     3258    va_end (args);
     3259}
    42703260#else
    4271 static int lt_debug = 0;
     3261# define LTWRAPPER_DEBUGPRINTF(args)
    42723262#endif
    42733263
    4274 const char *program_name = "libtool-wrapper"; /* in case xstrdup fails */
     3264const char *program_name = NULL;
    42753265
    42763266void *xmalloc (size_t num);
     
    42823272int check_executable (const char *path);
    42833273char *strendzap (char *str, const char *pat);
    4284 void lt_debugprintf (const char *file, int line, const char *fmt, ...);
    4285 void lt_fatal (const char *file, int line, const char *message, ...);
    4286 static const char *nonnull (const char *s);
    4287 static const char *nonempty (const char *s);
     3274void lt_fatal (const char *message, ...);
    42883275void lt_setenv (const char *name, const char *value);
    42893276char *lt_extend_str (const char *orig_value, const char *add, int to_end);
     3277void lt_opt_process_env_set (const char *arg);
     3278void lt_opt_process_env_prepend (const char *arg);
     3279void lt_opt_process_env_append (const char *arg);
     3280int lt_split_name_value (const char *arg, char** name, char** value);
    42903281void lt_update_exe_path (const char *name, const char *value);
    42913282void lt_update_lib_path (const char *name, const char *value);
    4292 char **prepare_spawn (char **argv);
    4293 void lt_dump_script (FILE *f);
     3283
     3284static const char *script_text_part1 =
    42943285EOF
    42953286
     3287            func_emit_wrapper_part1 yes |
     3288                $SED -e 's/\([\\"]\)/\\\1/g' \
     3289                     -e 's/^/  "/' -e 's/$/\\n"/'
     3290            echo ";"
    42963291            cat <<EOF
    4297 volatile const char * MAGIC_EXE = "$magic_exe";
     3292
     3293static const char *script_text_part2 =
     3294EOF
     3295            func_emit_wrapper_part2 yes |
     3296                $SED -e 's/\([\\"]\)/\\\1/g' \
     3297                     -e 's/^/  "/' -e 's/$/\\n"/'
     3298            echo ";"
     3299
     3300            cat <<EOF
     3301const char * MAGIC_EXE = "$magic_exe";
    42983302const char * LIB_PATH_VARNAME = "$shlibpath_var";
    42993303EOF
    43003304
    43013305            if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
    4302               func_to_host_path "$temp_rpath"
     3306              func_to_host_pathlist "$temp_rpath"
    43033307              cat <<EOF
    4304 const char * LIB_PATH_VALUE   = "$func_to_host_path_result";
     3308const char * LIB_PATH_VALUE   = "$func_to_host_pathlist_result";
    43053309EOF
    43063310            else
     
    43113315
    43123316            if test -n "$dllsearchpath"; then
    4313               func_to_host_path "$dllsearchpath:"
     3317              func_to_host_pathlist "$dllsearchpath:"
    43143318              cat <<EOF
    43153319const char * EXE_PATH_VARNAME = "PATH";
    4316 const char * EXE_PATH_VALUE   = "$func_to_host_path_result";
     3320const char * EXE_PATH_VALUE   = "$func_to_host_pathlist_result";
    43173321EOF
    43183322            else
     
    43373341
    43383342#define LTWRAPPER_OPTION_PREFIX         "--lt-"
    4339 
     3343#define LTWRAPPER_OPTION_PREFIX_LENGTH  5
     3344
     3345static const size_t opt_prefix_len         = LTWRAPPER_OPTION_PREFIX_LENGTH;
    43403346static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;
     3347
    43413348static const char *dumpscript_opt       = LTWRAPPER_OPTION_PREFIX "dump-script";
    4342 static const char *debug_opt            = LTWRAPPER_OPTION_PREFIX "debug";
     3349
     3350static const size_t env_set_opt_len     = LTWRAPPER_OPTION_PREFIX_LENGTH + 7;
     3351static const char *env_set_opt          = LTWRAPPER_OPTION_PREFIX "env-set";
     3352  /* argument is putenv-style "foo=bar", value of foo is set to bar */
     3353
     3354static const size_t env_prepend_opt_len = LTWRAPPER_OPTION_PREFIX_LENGTH + 11;
     3355static const char *env_prepend_opt      = LTWRAPPER_OPTION_PREFIX "env-prepend";
     3356  /* argument is putenv-style "foo=bar", new value of foo is bar${foo} */
     3357
     3358static const size_t env_append_opt_len  = LTWRAPPER_OPTION_PREFIX_LENGTH + 10;
     3359static const char *env_append_opt       = LTWRAPPER_OPTION_PREFIX "env-append";
     3360  /* argument is putenv-style "foo=bar", new value of foo is ${foo}bar */
    43433361
    43443362int
     
    43573375
    43583376  program_name = (char *) xstrdup (base_name (argv[0]));
    4359   newargz = XMALLOC (char *, argc + 1);
    4360 
    4361   /* very simple arg parsing; don't want to rely on getopt
    4362    * also, copy all non cwrapper options to newargz, except
    4363    * argz[0], which is handled differently
    4364    */
    4365   newargc=0;
     3377  LTWRAPPER_DEBUGPRINTF (("(main) argv[0]      : %s\n", argv[0]));
     3378  LTWRAPPER_DEBUGPRINTF (("(main) program_name : %s\n", program_name));
     3379
     3380  /* very simple arg parsing; don't want to rely on getopt */
    43663381  for (i = 1; i < argc; i++)
    43673382    {
     
    43773392
    43783393            cat <<"EOF"
    4379           lt_dump_script (stdout);
     3394          printf ("%s", script_text_part1);
     3395          printf ("%s", script_text_part2);
    43803396          return 0;
    43813397        }
    4382       if (strcmp (argv[i], debug_opt) == 0)
    4383         {
    4384           lt_debug = 1;
    4385           continue;
    4386         }
    4387       if (strcmp (argv[i], ltwrapper_option_prefix) == 0)
    4388         {
    4389           /* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
    4390              namespace, but it is not one of the ones we know about and
    4391              have already dealt with, above (inluding dump-script), then
    4392              report an error. Otherwise, targets might begin to believe
    4393              they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
    4394              namespace. The first time any user complains about this, we'll
    4395              need to make LTWRAPPER_OPTION_PREFIX a configure-time option
    4396              or a configure.ac-settable value.
    4397            */
    4398           lt_fatal (__FILE__, __LINE__,
    4399                     "unrecognized %s option: '%s'",
    4400                     ltwrapper_option_prefix, argv[i]);
    4401         }
    4402       /* otherwise ... */
    4403       newargz[++newargc] = xstrdup (argv[i]);
    44043398    }
    4405   newargz[++newargc] = NULL;
    4406 
    4407 EOF
    4408             cat <<EOF
    4409   /* The GNU banner must be the first non-error debug message */
    4410   lt_debugprintf (__FILE__, __LINE__, "libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\n");
    4411 EOF
    4412             cat <<"EOF"
    4413   lt_debugprintf (__FILE__, __LINE__, "(main) argv[0]: %s\n", argv[0]);
    4414   lt_debugprintf (__FILE__, __LINE__, "(main) program_name: %s\n", program_name);
    4415 
     3399
     3400  newargz = XMALLOC (char *, argc + 1);
    44163401  tmp_pathspec = find_executable (argv[0]);
    44173402  if (tmp_pathspec == NULL)
    4418     lt_fatal (__FILE__, __LINE__, "couldn't find %s", argv[0]);
    4419   lt_debugprintf (__FILE__, __LINE__,
    4420                   "(main) found exe (before symlink chase) at: %s\n",
    4421                   tmp_pathspec);
     3403    lt_fatal ("Couldn't find %s", argv[0]);
     3404  LTWRAPPER_DEBUGPRINTF (("(main) found exe (before symlink chase) at : %s\n",
     3405                          tmp_pathspec));
    44223406
    44233407  actual_cwrapper_path = chase_symlinks (tmp_pathspec);
    4424   lt_debugprintf (__FILE__, __LINE__,
    4425                   "(main) found exe (after symlink chase) at: %s\n",
    4426                   actual_cwrapper_path);
     3408  LTWRAPPER_DEBUGPRINTF (("(main) found exe (after symlink chase) at : %s\n",
     3409                          actual_cwrapper_path));
    44273410  XFREE (tmp_pathspec);
    44283411
    4429   actual_cwrapper_name = xstrdup (base_name (actual_cwrapper_path));
     3412  actual_cwrapper_name = xstrdup( base_name (actual_cwrapper_path));
    44303413  strendzap (actual_cwrapper_path, actual_cwrapper_name);
    44313414
     
    44453428  tmp_pathspec = 0;
    44463429
    4447   lt_debugprintf (__FILE__, __LINE__,
    4448                   "(main) libtool target name: %s\n",
    4449                   target_name);
     3430  LTWRAPPER_DEBUGPRINTF (("(main) libtool target name: %s\n",
     3431                          target_name));
    44503432EOF
    44513433
     
    44973479  lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */
    44983480  lt_setenv ("DUALCASE", "1");  /* for MSK sh */
    4499   /* Update the DLL searchpath.  EXE_PATH_VALUE ($dllsearchpath) must
    4500      be prepended before (that is, appear after) LIB_PATH_VALUE ($temp_rpath)
    4501      because on Windows, both *_VARNAMEs are PATH but uninstalled
    4502      libraries must come first. */
     3481  lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);
    45033482  lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
    4504   lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);
    4505 
    4506   lt_debugprintf (__FILE__, __LINE__, "(main) lt_argv_zero: %s\n",
    4507                   nonnull (lt_argv_zero));
     3483
     3484  newargc=0;
     3485  for (i = 1; i < argc; i++)
     3486    {
     3487      if (strncmp (argv[i], env_set_opt, env_set_opt_len) == 0)
     3488        {
     3489          if (argv[i][env_set_opt_len] == '=')
     3490            {
     3491              const char *p = argv[i] + env_set_opt_len + 1;
     3492              lt_opt_process_env_set (p);
     3493            }
     3494          else if (argv[i][env_set_opt_len] == '\0' && i + 1 < argc)
     3495            {
     3496              lt_opt_process_env_set (argv[++i]); /* don't copy */
     3497            }
     3498          else
     3499            lt_fatal ("%s missing required argument", env_set_opt);
     3500          continue;
     3501        }
     3502      if (strncmp (argv[i], env_prepend_opt, env_prepend_opt_len) == 0)
     3503        {
     3504          if (argv[i][env_prepend_opt_len] == '=')
     3505            {
     3506              const char *p = argv[i] + env_prepend_opt_len + 1;
     3507              lt_opt_process_env_prepend (p);
     3508            }
     3509          else if (argv[i][env_prepend_opt_len] == '\0' && i + 1 < argc)
     3510            {
     3511              lt_opt_process_env_prepend (argv[++i]); /* don't copy */
     3512            }
     3513          else
     3514            lt_fatal ("%s missing required argument", env_prepend_opt);
     3515          continue;
     3516        }
     3517      if (strncmp (argv[i], env_append_opt, env_append_opt_len) == 0)
     3518        {
     3519          if (argv[i][env_append_opt_len] == '=')
     3520            {
     3521              const char *p = argv[i] + env_append_opt_len + 1;
     3522              lt_opt_process_env_append (p);
     3523            }
     3524          else if (argv[i][env_append_opt_len] == '\0' && i + 1 < argc)
     3525            {
     3526              lt_opt_process_env_append (argv[++i]); /* don't copy */
     3527            }
     3528          else
     3529            lt_fatal ("%s missing required argument", env_append_opt);
     3530          continue;
     3531        }
     3532      if (strncmp (argv[i], ltwrapper_option_prefix, opt_prefix_len) == 0)
     3533        {
     3534          /* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
     3535             namespace, but it is not one of the ones we know about and
     3536             have already dealt with, above (inluding dump-script), then
     3537             report an error. Otherwise, targets might begin to believe
     3538             they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
     3539             namespace. The first time any user complains about this, we'll
     3540             need to make LTWRAPPER_OPTION_PREFIX a configure-time option
     3541             or a configure.ac-settable value.
     3542           */
     3543          lt_fatal ("Unrecognized option in %s namespace: '%s'",
     3544                    ltwrapper_option_prefix, argv[i]);
     3545        }
     3546      /* otherwise ... */
     3547      newargz[++newargc] = xstrdup (argv[i]);
     3548    }
     3549  newargz[++newargc] = NULL;
     3550
     3551  LTWRAPPER_DEBUGPRINTF     (("(main) lt_argv_zero : %s\n", (lt_argv_zero ? lt_argv_zero : "<NULL>")));
    45083552  for (i = 0; i < newargc; i++)
    45093553    {
    4510       lt_debugprintf (__FILE__, __LINE__, "(main) newargz[%d]: %s\n",
    4511                       i, nonnull (newargz[i]));
     3554      LTWRAPPER_DEBUGPRINTF (("(main) newargz[%d]   : %s\n", i, (newargz[i] ? newargz[i] : "<NULL>")));
    45123555    }
    45133556
     
    45183561                cat <<"EOF"
    45193562  /* execv doesn't actually work on mingw as expected on unix */
    4520   newargz = prepare_spawn (newargz);
    45213563  rval = _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);
    45223564  if (rval == -1)
    45233565    {
    45243566      /* failed to start process */
    4525       lt_debugprintf (__FILE__, __LINE__,
    4526                       "(main) failed to launch target \"%s\": %s\n",
    4527                       lt_argv_zero, nonnull (strerror (errno)));
     3567      LTWRAPPER_DEBUGPRINTF (("(main) failed to launch target \"%s\": errno = %d\n", lt_argv_zero, errno));
    45283568      return 127;
    45293569    }
     
    45473587  void *p = (void *) malloc (num);
    45483588  if (!p)
    4549     lt_fatal (__FILE__, __LINE__, "memory exhausted");
     3589    lt_fatal ("Memory exhausted");
    45503590
    45513591  return p;
     
    45813621  struct stat st;
    45823622
    4583   lt_debugprintf (__FILE__, __LINE__, "(check_executable): %s\n",
    4584                   nonempty (path));
     3623  LTWRAPPER_DEBUGPRINTF (("(check_executable)  : %s\n",
     3624                          path ? (*path ? path : "EMPTY!") : "NULL!"));
    45853625  if ((!path) || (!*path))
    45863626    return 0;
     
    45993639  struct stat st;
    46003640
    4601   lt_debugprintf (__FILE__, __LINE__, "(make_executable): %s\n",
    4602                   nonempty (path));
     3641  LTWRAPPER_DEBUGPRINTF (("(make_executable)   : %s\n",
     3642                          path ? (*path ? path : "EMPTY!") : "NULL!"));
    46033643  if ((!path) || (!*path))
    46043644    return 0;
     
    46263666  char *concat_name;
    46273667
    4628   lt_debugprintf (__FILE__, __LINE__, "(find_executable): %s\n",
    4629                   nonempty (wrapper));
     3668  LTWRAPPER_DEBUGPRINTF (("(find_executable)   : %s\n",
     3669                          wrapper ? (*wrapper ? wrapper : "EMPTY!") : "NULL!"));
    46303670
    46313671  if ((wrapper == NULL) || (*wrapper == '\0'))
     
    46803720                  /* empty path: current directory */
    46813721                  if (getcwd (tmp, LT_PATHMAX) == NULL)
    4682                     lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
    4683                               nonnull (strerror (errno)));
     3722                    lt_fatal ("getcwd failed");
    46843723                  tmp_len = strlen (tmp);
    46853724                  concat_name =
     
    47063745  /* Relative path | not found in path: prepend cwd */
    47073746  if (getcwd (tmp, LT_PATHMAX) == NULL)
    4708     lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
    4709               nonnull (strerror (errno)));
     3747    lt_fatal ("getcwd failed");
    47103748  tmp_len = strlen (tmp);
    47113749  concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
     
    47333771  while (strlen (tmp_pathspec) && !has_symlinks)
    47343772    {
    4735       lt_debugprintf (__FILE__, __LINE__,
    4736                       "checking path component for symlinks: %s\n",
    4737                       tmp_pathspec);
     3773      LTWRAPPER_DEBUGPRINTF (("checking path component for symlinks: %s\n",
     3774                              tmp_pathspec));
    47383775      if (lstat (tmp_pathspec, &s) == 0)
    47393776        {
     
    47573794      else
    47583795        {
    4759           lt_fatal (__FILE__, __LINE__,
    4760                     "error accessing file \"%s\": %s",
    4761                     tmp_pathspec, nonnull (strerror (errno)));
     3796          char *errstr = strerror (errno);
     3797          lt_fatal ("Error accessing file %s (%s)", tmp_pathspec, errstr);
    47623798        }
    47633799    }
     
    47723808  if (tmp_pathspec == 0)
    47733809    {
    4774       lt_fatal (__FILE__, __LINE__,
    4775                 "could not follow symlinks for %s", pathspec);
     3810      lt_fatal ("Could not follow symlinks for %s", pathspec);
    47763811    }
    47773812  return xstrdup (tmp_pathspec);
     
    47993834}
    48003835
    4801 void
    4802 lt_debugprintf (const char *file, int line, const char *fmt, ...)
    4803 {
    4804   va_list args;
    4805   if (lt_debug)
    4806     {
    4807       (void) fprintf (stderr, "%s:%s:%d: ", program_name, file, line);
    4808       va_start (args, fmt);
    4809       (void) vfprintf (stderr, fmt, args);
    4810       va_end (args);
    4811     }
    4812 }
    4813 
    48143836static void
    4815 lt_error_core (int exit_status, const char *file,
    4816                int line, const char *mode,
     3837lt_error_core (int exit_status, const char *mode,
    48173838               const char *message, va_list ap)
    48183839{
    4819   fprintf (stderr, "%s:%s:%d: %s: ", program_name, file, line, mode);
     3840  fprintf (stderr, "%s: %s: ", program_name, mode);
    48203841  vfprintf (stderr, message, ap);
    48213842  fprintf (stderr, ".\n");
     
    48263847
    48273848void
    4828 lt_fatal (const char *file, int line, const char *message, ...)
     3849lt_fatal (const char *message, ...)
    48293850{
    48303851  va_list ap;
    48313852  va_start (ap, message);
    4832   lt_error_core (EXIT_FAILURE, file, line, "FATAL", message, ap);
     3853  lt_error_core (EXIT_FAILURE, "FATAL", message, ap);
    48333854  va_end (ap);
    4834 }
    4835 
    4836 static const char *
    4837 nonnull (const char *s)
    4838 {
    4839   return s ? s : "(null)";
    4840 }
    4841 
    4842 static const char *
    4843 nonempty (const char *s)
    4844 {
    4845   return (s && !*s) ? "(empty)" : nonnull (s);
    48463855}
    48473856
     
    48493858lt_setenv (const char *name, const char *value)
    48503859{
    4851   lt_debugprintf (__FILE__, __LINE__,
    4852                   "(lt_setenv) setting '%s' to '%s'\n",
    4853                   nonnull (name), nonnull (value));
     3860  LTWRAPPER_DEBUGPRINTF (("(lt_setenv) setting '%s' to '%s'\n",
     3861                          (name ? name : "<NULL>"),
     3862                          (value ? value : "<NULL>")));
    48543863  {
    48553864#ifdef HAVE_SETENV
     
    48963905}
    48973906
     3907int
     3908lt_split_name_value (const char *arg, char** name, char** value)
     3909{
     3910  const char *p;
     3911  int len;
     3912  if (!arg || !*arg)
     3913    return 1;
     3914
     3915  p = strchr (arg, (int)'=');
     3916
     3917  if (!p)
     3918    return 1;
     3919
     3920  *value = xstrdup (++p);
     3921
     3922  len = strlen (arg) - strlen (*value);
     3923  *name = XMALLOC (char, len);
     3924  strncpy (*name, arg, len-1);
     3925  (*name)[len - 1] = '\0';
     3926
     3927  return 0;
     3928}
     3929
     3930void
     3931lt_opt_process_env_set (const char *arg)
     3932{
     3933  char *name = NULL;
     3934  char *value = NULL;
     3935
     3936  if (lt_split_name_value (arg, &name, &value) != 0)
     3937    {
     3938      XFREE (name);
     3939      XFREE (value);
     3940      lt_fatal ("bad argument for %s: '%s'", env_set_opt, arg);
     3941    }
     3942
     3943  lt_setenv (name, value);
     3944  XFREE (name);
     3945  XFREE (value);
     3946}
     3947
     3948void
     3949lt_opt_process_env_prepend (const char *arg)
     3950{
     3951  char *name = NULL;
     3952  char *value = NULL;
     3953  char *new_value = NULL;
     3954
     3955  if (lt_split_name_value (arg, &name, &value) != 0)
     3956    {
     3957      XFREE (name);
     3958      XFREE (value);
     3959      lt_fatal ("bad argument for %s: '%s'", env_prepend_opt, arg);
     3960    }
     3961
     3962  new_value = lt_extend_str (getenv (name), value, 0);
     3963  lt_setenv (name, new_value);
     3964  XFREE (new_value);
     3965  XFREE (name);
     3966  XFREE (value);
     3967}
     3968
     3969void
     3970lt_opt_process_env_append (const char *arg)
     3971{
     3972  char *name = NULL;
     3973  char *value = NULL;
     3974  char *new_value = NULL;
     3975
     3976  if (lt_split_name_value (arg, &name, &value) != 0)
     3977    {
     3978      XFREE (name);
     3979      XFREE (value);
     3980      lt_fatal ("bad argument for %s: '%s'", env_append_opt, arg);
     3981    }
     3982
     3983  new_value = lt_extend_str (getenv (name), value, 1);
     3984  lt_setenv (name, new_value);
     3985  XFREE (new_value);
     3986  XFREE (name);
     3987  XFREE (value);
     3988}
     3989
    48983990void
    48993991lt_update_exe_path (const char *name, const char *value)
    49003992{
    4901   lt_debugprintf (__FILE__, __LINE__,
    4902                   "(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
    4903                   nonnull (name), nonnull (value));
     3993  LTWRAPPER_DEBUGPRINTF (("(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
     3994                          (name ? name : "<NULL>"),
     3995                          (value ? value : "<NULL>")));
    49043996
    49053997  if (name && *name && value && *value)
     
    49204012lt_update_lib_path (const char *name, const char *value)
    49214013{
    4922   lt_debugprintf (__FILE__, __LINE__,
    4923                   "(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
    4924                   nonnull (name), nonnull (value));
     4014  LTWRAPPER_DEBUGPRINTF (("(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
     4015                          (name ? name : "<NULL>"),
     4016                          (value ? value : "<NULL>")));
    49254017
    49264018  if (name && *name && value && *value)
     
    49324024}
    49334025
    4934 EOF
    4935             case $host_os in
    4936               mingw*)
    4937                 cat <<"EOF"
    4938 
    4939 /* Prepares an argument vector before calling spawn().
    4940    Note that spawn() does not by itself call the command interpreter
    4941      (getenv ("COMSPEC") != NULL ? getenv ("COMSPEC") :
    4942       ({ OSVERSIONINFO v; v.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
    4943          GetVersionEx(&v);
    4944          v.dwPlatformId == VER_PLATFORM_WIN32_NT;
    4945       }) ? "cmd.exe" : "command.com").
    4946    Instead it simply concatenates the arguments, separated by ' ', and calls
    4947    CreateProcess().  We must quote the arguments since Win32 CreateProcess()
    4948    interprets characters like ' ', '\t', '\\', '"' (but not '<' and '>') in a
    4949    special way:
    4950    - Space and tab are interpreted as delimiters. They are not treated as
    4951      delimiters if they are surrounded by double quotes: "...".
    4952    - Unescaped double quotes are removed from the input. Their only effect is
    4953      that within double quotes, space and tab are treated like normal
    4954      characters.
    4955    - Backslashes not followed by double quotes are not special.
    4956    - But 2*n+1 backslashes followed by a double quote become
    4957      n backslashes followed by a double quote (n >= 0):
    4958        \" -> "
    4959        \\\" -> \"
    4960        \\\\\" -> \\"
    4961  */
    4962 #define SHELL_SPECIAL_CHARS "\"\\ \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"
    4963 #define SHELL_SPACE_CHARS " \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"
    4964 char **
    4965 prepare_spawn (char **argv)
    4966 {
    4967   size_t argc;
    4968   char **new_argv;
    4969   size_t i;
    4970 
    4971   /* Count number of arguments.  */
    4972   for (argc = 0; argv[argc] != NULL; argc++)
    4973     ;
    4974 
    4975   /* Allocate new argument vector.  */
    4976   new_argv = XMALLOC (char *, argc + 1);
    4977 
    4978   /* Put quoted arguments into the new argument vector.  */
    4979   for (i = 0; i < argc; i++)
    4980     {
    4981       const char *string = argv[i];
    4982 
    4983       if (string[0] == '\0')
    4984         new_argv[i] = xstrdup ("\"\"");
    4985       else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL)
    4986         {
    4987           int quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL);
    4988           size_t length;
    4989           unsigned int backslashes;
    4990           const char *s;
    4991           char *quoted_string;
    4992           char *p;
    4993 
    4994           length = 0;
    4995           backslashes = 0;
    4996           if (quote_around)
    4997             length++;
    4998           for (s = string; *s != '\0'; s++)
    4999             {
    5000               char c = *s;
    5001               if (c == '"')
    5002                 length += backslashes + 1;
    5003               length++;
    5004               if (c == '\\')
    5005                 backslashes++;
    5006               else
    5007                 backslashes = 0;
    5008             }
    5009           if (quote_around)
    5010             length += backslashes + 1;
    5011 
    5012           quoted_string = XMALLOC (char, length + 1);
    5013 
    5014           p = quoted_string;
    5015           backslashes = 0;
    5016           if (quote_around)
    5017             *p++ = '"';
    5018           for (s = string; *s != '\0'; s++)
    5019             {
    5020               char c = *s;
    5021               if (c == '"')
    5022                 {
    5023                   unsigned int j;
    5024                   for (j = backslashes + 1; j > 0; j--)
    5025                     *p++ = '\\';
    5026                 }
    5027               *p++ = c;
    5028               if (c == '\\')
    5029                 backslashes++;
    5030               else
    5031                 backslashes = 0;
    5032             }
    5033           if (quote_around)
    5034             {
    5035               unsigned int j;
    5036               for (j = backslashes; j > 0; j--)
    5037                 *p++ = '\\';
    5038               *p++ = '"';
    5039             }
    5040           *p = '\0';
    5041 
    5042           new_argv[i] = quoted_string;
    5043         }
    5044       else
    5045         new_argv[i] = (char *) string;
    5046     }
    5047   new_argv[argc] = NULL;
    5048 
    5049   return new_argv;
    5050 }
    5051 EOF
    5052                 ;;
    5053             esac
    5054 
    5055             cat <<"EOF"
    5056 void lt_dump_script (FILE* f)
    5057 {
    5058 EOF
    5059             func_emit_wrapper yes |
    5060               $SED -e 's/\([\\"]\)/\\\1/g' \
    5061                    -e 's/^/  fputs ("/' -e 's/$/\\n", f);/'
    5062 
    5063             cat <<"EOF"
    5064 }
     4026
    50654027EOF
    50664028}
    50674029# end: func_emit_cwrapperexe_src
    5068 
    5069 # func_win32_import_lib_p ARG
    5070 # True if ARG is an import lib, as indicated by $file_magic_cmd
    5071 func_win32_import_lib_p ()
    5072 {
    5073     $opt_debug
    5074     case `eval $file_magic_cmd \"\$1\" 2>/dev/null | $SED -e 10q` in
    5075     *import*) : ;;
    5076     *) false ;;
    5077     esac
    5078 }
    50794030
    50804031# func_mode_link arg...
     
    51224073
    51234074    avoid_version=no
    5124     bindir=
    51254075    dlfiles=
    51264076    dlprefiles=
     
    52154165
    52164166        case $prev in
    5217         bindir)
    5218           bindir="$arg"
    5219           prev=
    5220           continue
    5221           ;;
    52224167        dlfiles|dlprefiles)
    52234168          if test "$preload" = no; then
     
    52514196          *)
    52524197            if test "$prev" = dlfiles; then
    5253               func_append dlfiles " $arg"
     4198              dlfiles="$dlfiles $arg"
    52544199            else
    5255               func_append dlprefiles " $arg"
     4200              dlprefiles="$dlprefiles $arg"
    52564201            fi
    52574202            prev=
     
    52774222              case "$deplibs " in
    52784223                *" $qarg.ltframework "*) ;;
    5279                 *) func_append deplibs " $qarg.ltframework" # this is fixed later
     4224                *) deplibs="$deplibs $qarg.ltframework" # this is fixed later
    52804225                   ;;
    52814226              esac
     
    52964241            for fil in `cat "$save_arg"`
    52974242            do
    5298 #             func_append moreargs " $fil"
     4243#             moreargs="$moreargs $fil"
    52994244              arg=$fil
    53004245              # A libtool-controlled object.
     
    53254270                  if test "$prev" = dlfiles; then
    53264271                    if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
    5327                       func_append dlfiles " $pic_object"
     4272                      dlfiles="$dlfiles $pic_object"
    53284273                      prev=
    53294274                      continue
     
    53374282                  if test "$prev" = dlprefiles; then
    53384283                    # Preload the old-style object.
    5339                     func_append dlprefiles " $pic_object"
     4284                    dlprefiles="$dlprefiles $pic_object"
    53404285                    prev=
    53414286                  fi
     
    54074352            case "$rpath " in
    54084353            *" $arg "*) ;;
    5409             *) func_append rpath " $arg" ;;
     4354            *) rpath="$rpath $arg" ;;
    54104355            esac
    54114356          else
    54124357            case "$xrpath " in
    54134358            *" $arg "*) ;;
    5414             *) func_append xrpath " $arg" ;;
     4359            *) xrpath="$xrpath $arg" ;;
    54154360            esac
    54164361          fi
     
    54244369          ;;
    54254370        weak)
    5426           func_append weak_libs " $arg"
     4371          weak_libs="$weak_libs $arg"
    54274372          prev=
    54284373          continue
    54294374          ;;
    54304375        xcclinker)
    5431           func_append linker_flags " $qarg"
    5432           func_append compiler_flags " $qarg"
     4376          linker_flags="$linker_flags $qarg"
     4377          compiler_flags="$compiler_flags $qarg"
    54334378          prev=
    54344379          func_append compile_command " $qarg"
     
    54374382          ;;
    54384383        xcompiler)
    5439           func_append compiler_flags " $qarg"
     4384          compiler_flags="$compiler_flags $qarg"
    54404385          prev=
    54414386          func_append compile_command " $qarg"
     
    54444389          ;;
    54454390        xlinker)
    5446           func_append linker_flags " $qarg"
    5447           func_append compiler_flags " $wl$qarg"
     4391          linker_flags="$linker_flags $qarg"
     4392          compiler_flags="$compiler_flags $wl$qarg"
    54484393          prev=
    54494394          func_append compile_command " $wl$qarg"
     
    54814426        ;;
    54824427
    5483       -bindir)
    5484         prev=bindir
    5485         continue
    5486         ;;
    5487 
    54884428      -dlopen)
    54894429        prev=dlfiles
     
    55364476
    55374477      -L*)
    5538         func_stripname "-L" '' "$arg"
    5539         if test -z "$func_stripname_result"; then
     4478        func_stripname '-L' '' "$arg"
     4479        dir=$func_stripname_result
     4480        if test -z "$dir"; then
    55404481          if test "$#" -gt 0; then
    55414482            func_fatal_error "require no space between \`-L' and \`$1'"
     
    55444485          fi
    55454486        fi
    5546         func_resolve_sysroot "$func_stripname_result"
    5547         dir=$func_resolve_sysroot_result
    55484487        # We need an absolute path.
    55494488        case $dir in
     
    55574496        esac
    55584497        case "$deplibs " in
    5559         *" -L$dir "* | *" $arg "*)
    5560           # Will only happen for absolute or sysroot arguments
    5561           ;;
     4498        *" -L$dir "*) ;;
    55624499        *)
    5563           # Preserve sysroot, but never include relative directories
    5564           case $dir in
    5565             [\\/]* | [A-Za-z]:[\\/]* | =*) func_append deplibs " $arg" ;;
    5566             *) func_append deplibs " -L$dir" ;;
    5567           esac
    5568           func_append lib_search_path " $dir"
     4500          deplibs="$deplibs -L$dir"
     4501          lib_search_path="$lib_search_path $dir"
    55694502          ;;
    55704503        esac
    55714504        case $host in
    55724505        *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
    5573           testbindir=`$ECHO "$dir" | $SED 's*/lib$*/bin*'`
     4506          testbindir=`$ECHO "X$dir" | $Xsed -e 's*/lib$*/bin*'`
    55744507          case :$dllsearchpath: in
    55754508          *":$dir:"*) ;;
    55764509          ::) dllsearchpath=$dir;;
    5577           *) func_append dllsearchpath ":$dir";;
     4510          *) dllsearchpath="$dllsearchpath:$dir";;
    55784511          esac
    55794512          case :$dllsearchpath: in
    55804513          *":$testbindir:"*) ;;
    55814514          ::) dllsearchpath=$testbindir;;
    5582           *) func_append dllsearchpath ":$testbindir";;
     4515          *) dllsearchpath="$dllsearchpath:$testbindir";;
    55834516          esac
    55844517          ;;
     
    55904523        if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
    55914524          case $host in
    5592           *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc* | *-*-haiku*)
     4525          *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc*)
    55934526            # These systems don't actually have a C or math library (as such)
    55944527            continue
     
    56044537          *-*-rhapsody* | *-*-darwin1.[012])
    56054538            # Rhapsody C and math libraries are in the System framework
    5606             func_append deplibs " System.ltframework"
     4539            deplibs="$deplibs System.ltframework"
    56074540            continue
    56084541            ;;
     
    56244557         esac
    56254558        fi
    5626         func_append deplibs " $arg"
     4559        deplibs="$deplibs $arg"
    56274560        continue
    56284561        ;;
     
    56364569      # classes, name mangling, and exception handling.
    56374570      # Darwin uses the -arch flag to determine output architecture.
    5638       -model|-arch|-isysroot|--sysroot)
    5639         func_append compiler_flags " $arg"
     4571      -model|-arch|-isysroot)
     4572        compiler_flags="$compiler_flags $arg"
    56404573        func_append compile_command " $arg"
    56414574        func_append finalize_command " $arg"
     
    56454578
    56464579      -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
    5647         func_append compiler_flags " $arg"
     4580        compiler_flags="$compiler_flags $arg"
    56484581        func_append compile_command " $arg"
    56494582        func_append finalize_command " $arg"
    56504583        case "$new_inherited_linker_flags " in
    56514584            *" $arg "*) ;;
    5652             * ) func_append new_inherited_linker_flags " $arg" ;;
     4585            * ) new_inherited_linker_flags="$new_inherited_linker_flags $arg" ;;
    56534586        esac
    56544587        continue
     
    57174650        case $dir in
    57184651        [\\/]* | [A-Za-z]:[\\/]*) ;;
    5719         =*)
    5720           func_stripname '=' '' "$dir"
    5721           dir=$lt_sysroot$func_stripname_result
    5722           ;;
    57234652        *)
    57244653          func_fatal_error "only absolute run-paths are allowed"
     
    57274656        case "$xrpath " in
    57284657        *" $dir "*) ;;
    5729         *) func_append xrpath " $dir" ;;
     4658        *) xrpath="$xrpath $dir" ;;
    57304659        esac
    57314660        continue
     
    57804709          IFS="$save_ifs"
    57814710          func_quote_for_eval "$flag"
    5782           func_append arg " $func_quote_for_eval_result"
    5783           func_append compiler_flags " $func_quote_for_eval_result"
     4711          arg="$arg $wl$func_quote_for_eval_result"
     4712          compiler_flags="$compiler_flags $func_quote_for_eval_result"
    57844713        done
    57854714        IFS="$save_ifs"
     
    57964725          IFS="$save_ifs"
    57974726          func_quote_for_eval "$flag"
    5798           func_append arg " $wl$func_quote_for_eval_result"
    5799           func_append compiler_flags " $wl$func_quote_for_eval_result"
    5800           func_append linker_flags " $func_quote_for_eval_result"
     4727          arg="$arg $wl$func_quote_for_eval_result"
     4728          compiler_flags="$compiler_flags $wl$func_quote_for_eval_result"
     4729          linker_flags="$linker_flags $func_quote_for_eval_result"
    58014730        done
    58024731        IFS="$save_ifs"
     
    58264755        ;;
    58274756
    5828       # Flags to be passed through unchanged, with rationale:
    5829       # -64, -mips[0-9]      enable 64-bit mode for the SGI compiler
    5830       # -r[0-9][0-9]*        specify processor for the SGI compiler
    5831       # -xarch=*, -xtarget=* enable 64-bit mode for the Sun compiler
    5832       # +DA*, +DD*           enable 64-bit mode for the HP compiler
    5833       # -q*                  compiler args for the IBM compiler
    5834       # -m*, -t[45]*, -txscale* architecture-specific flags for GCC
    5835       # -F/path              path to uninstalled frameworks, gcc on darwin
    5836       # -p, -pg, --coverage, -fprofile-*  profiling flags for GCC
    5837       # @file                GCC response files
    5838       # -tp=*                Portland pgcc target processor selection
    5839       # --sysroot=*          for sysroot support
    5840       # -O*, -flto*, -fwhopr*, -fuse-linker-plugin GCC link-time optimization
     4757      # -64, -mips[0-9] enable 64-bit mode on the SGI compiler
     4758      # -r[0-9][0-9]* specifies the processor on the SGI compiler
     4759      # -xarch=*, -xtarget=* enable 64-bit mode on the Sun compiler
     4760      # +DA*, +DD* enable 64-bit mode on the HP compiler
     4761      # -q* pass through compiler args for the IBM compiler
     4762      # -m*, -t[45]*, -txscale* pass through architecture-specific
     4763      # compiler args for GCC
     4764      # -F/path gives path to uninstalled frameworks, gcc on darwin
     4765      # -p, -pg, --coverage, -fprofile-* pass through profiling flag for GCC
     4766      # @file GCC response files
    58414767      -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
    5842       -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*|--sysroot=*| \
    5843       -O*|-flto*|-fwhopr*|-fuse-linker-plugin)
     4768      -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*)
    58444769        func_quote_for_eval "$arg"
    58454770        arg="$func_quote_for_eval_result"
    58464771        func_append compile_command " $arg"
    58474772        func_append finalize_command " $arg"
    5848         func_append compiler_flags " $arg"
     4773        compiler_flags="$compiler_flags $arg"
    58494774        continue
    58504775        ;;
     
    58584783      *.$objext)
    58594784        # A standard object.
    5860         func_append objs " $arg"
     4785        objs="$objs $arg"
    58614786        ;;
    58624787
     
    58894814            if test "$prev" = dlfiles; then
    58904815              if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
    5891                 func_append dlfiles " $pic_object"
     4816                dlfiles="$dlfiles $pic_object"
    58924817                prev=
    58934818                continue
     
    59014826            if test "$prev" = dlprefiles; then
    59024827              # Preload the old-style object.
    5903               func_append dlprefiles " $pic_object"
     4828              dlprefiles="$dlprefiles $pic_object"
    59044829              prev=
    59054830            fi
     
    59464871      *.$libext)
    59474872        # An archive.
    5948         func_append deplibs " $arg"
    5949         func_append old_deplibs " $arg"
     4873        deplibs="$deplibs $arg"
     4874        old_deplibs="$old_deplibs $arg"
    59504875        continue
    59514876        ;;
     
    59544879        # A libtool-controlled library.
    59554880
    5956         func_resolve_sysroot "$arg"
    59574881        if test "$prev" = dlfiles; then
    59584882          # This library was specified with -dlopen.
    5959           func_append dlfiles " $func_resolve_sysroot_result"
     4883          dlfiles="$dlfiles $arg"
    59604884          prev=
    59614885        elif test "$prev" = dlprefiles; then
    59624886          # The library was specified with -dlpreopen.
    5963           func_append dlprefiles " $func_resolve_sysroot_result"
     4887          dlprefiles="$dlprefiles $arg"
    59644888          prev=
    59654889        else
    5966           func_append deplibs " $func_resolve_sysroot_result"
     4890          deplibs="$deplibs $arg"
    59674891        fi
    59684892        continue
     
    60024926    if test -n "$shlibpath_var"; then
    60034927      # get the directories listed in $shlibpath_var
    6004       eval shlib_search_path=\`\$ECHO \"\${$shlibpath_var}\" \| \$SED \'s/:/ /g\'\`
     4928      eval shlib_search_path=\`\$ECHO \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
    60054929    else
    60064930      shlib_search_path=
     
    60114935    func_dirname "$output" "/" ""
    60124936    output_objdir="$func_dirname_result$objdir"
    6013     func_to_tool_file "$output_objdir/"
    6014     tool_output_objdir=$func_to_tool_file_result
    60154937    # Create the object directory.
    60164938    func_mkdir_p "$output_objdir"
     
    60334955    # that are linked more than once (e.g. -la -lb -la)
    60344956    for deplib in $deplibs; do
    6035       if $opt_preserve_dup_deps ; then
     4957      if $opt_duplicate_deps ; then
    60364958        case "$libs " in
    6037         *" $deplib "*) func_append specialdeplibs " $deplib" ;;
     4959        *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
    60384960        esac
    60394961      fi
    6040       func_append libs " $deplib"
     4962      libs="$libs $deplib"
    60414963    done
    60424964
     
    60514973        for pre_post_dep in $predeps $postdeps; do
    60524974          case "$pre_post_deps " in
    6053           *" $pre_post_dep "*) func_append specialdeplibs " $pre_post_deps" ;;
     4975          *" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
    60544976          esac
    6055           func_append pre_post_deps " $pre_post_dep"
     4977          pre_post_deps="$pre_post_deps $pre_post_dep"
    60564978        done
    60574979      fi
     
    61125034        dlopen) libs="$dlfiles" ;;
    61135035        dlpreopen) libs="$dlprefiles" ;;
    6114         link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
     5036        link)
     5037          libs="$deplibs %DEPLIBS%"
     5038          test "X$link_all_deplibs" != Xno && libs="$libs $dependency_libs"
     5039          ;;
    61155040        esac
    61165041      fi
     
    61205045          # Ignore non-libtool-libs
    61215046          dependency_libs=
    6122           func_resolve_sysroot "$lib"
    61235047          case $lib in
    6124           *.la) func_source "$func_resolve_sysroot_result" ;;
     5048          *.la) func_source "$lib" ;;
    61255049          esac
    61265050
     
    61285052          # has declared as weak libs
    61295053          for deplib in $dependency_libs; do
    6130             func_basename "$deplib"
    6131             deplib_base=$func_basename_result
     5054            deplib_base=`$ECHO "X$deplib" | $Xsed -e "$basename"`
    61325055            case " $weak_libs " in
    61335056            *" $deplib_base "*) ;;
    6134             *) func_append deplibs " $deplib" ;;
     5057            *) deplibs="$deplibs $deplib" ;;
    61355058            esac
    61365059          done
     
    61535076            finalize_deplibs="$deplib $finalize_deplibs"
    61545077          else
    6155             func_append compiler_flags " $deplib"
     5078            compiler_flags="$compiler_flags $deplib"
    61565079            if test "$linkmode" = lib ; then
    61575080                case "$new_inherited_linker_flags " in
    61585081                    *" $deplib "*) ;;
    6159                     * ) func_append new_inherited_linker_flags " $deplib" ;;
     5082                    * ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
    61605083                esac
    61615084            fi
     
    62425165                case "$new_inherited_linker_flags " in
    62435166                    *" $deplib "*) ;;
    6244                     * ) func_append new_inherited_linker_flags " $deplib" ;;
     5167                    * ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
    62455168                esac
    62465169            fi
     
    62555178            newdependency_libs="$deplib $newdependency_libs"
    62565179            func_stripname '-L' '' "$deplib"
    6257             func_resolve_sysroot "$func_stripname_result"
    6258             func_append newlib_search_path " $func_resolve_sysroot_result"
     5180            newlib_search_path="$newlib_search_path $func_stripname_result"
    62595181            ;;
    62605182          prog)
     
    62705192            fi
    62715193            func_stripname '-L' '' "$deplib"
    6272             func_resolve_sysroot "$func_stripname_result"
    6273             func_append newlib_search_path " $func_resolve_sysroot_result"
     5194            newlib_search_path="$newlib_search_path $func_stripname_result"
    62745195            ;;
    62755196          *)
     
    62825203          if test "$pass" = link; then
    62835204            func_stripname '-R' '' "$deplib"
    6284             func_resolve_sysroot "$func_stripname_result"
    6285             dir=$func_resolve_sysroot_result
     5205            dir=$func_stripname_result
    62865206            # Make sure the xrpath contains only unique directories.
    62875207            case "$xrpath " in
    62885208            *" $dir "*) ;;
    6289             *) func_append xrpath " $dir" ;;
     5209            *) xrpath="$xrpath $dir" ;;
    62905210            esac
    62915211          fi
     
    62935213          continue
    62945214          ;;
    6295         *.la)
    6296           func_resolve_sysroot "$deplib"
    6297           lib=$func_resolve_sysroot_result
    6298           ;;
     5215        *.la) lib="$deplib" ;;
    62995216        *.$libext)
    63005217          if test "$pass" = conv; then
     
    63145231                  set dummy $deplibs_check_method; shift
    63155232                  match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
    6316                   if eval "\$ECHO \"$deplib\"" 2>/dev/null | $SED 10q \
     5233                  if eval "\$ECHO \"X$deplib\"" 2>/dev/null | $Xsed -e 10q \
    63175234                    | $EGREP "$match_pattern_regex" > /dev/null; then
    63185235                    valid_a_lib=yes
     
    63245241              esac
    63255242              if test "$valid_a_lib" != yes; then
    6326                 echo
     5243                $ECHO
    63275244                $ECHO "*** Warning: Trying to link with static lib archive $deplib."
    6328                 echo "*** I have the capability to make that library automatically link in when"
    6329                 echo "*** you link to this library.  But I can only do this if you have a"
    6330                 echo "*** shared version of the library, which you do not appear to have"
    6331                 echo "*** because the file extensions .$libext of this argument makes me believe"
    6332                 echo "*** that it is just a static archive that I should not use here."
     5245                $ECHO "*** I have the capability to make that library automatically link in when"
     5246                $ECHO "*** you link to this library.  But I can only do this if you have a"
     5247                $ECHO "*** shared version of the library, which you do not appear to have"
     5248                $ECHO "*** because the file extensions .$libext of this argument makes me believe"
     5249                $ECHO "*** that it is just a static archive that I should not use here."
    63335250              else
    6334                 echo
     5251                $ECHO
    63355252                $ECHO "*** Warning: Linking the shared library $output against the"
    63365253                $ECHO "*** static library $deplib is not portable!"
     
    63595276              # If there is no dlopen support or we're linking statically,
    63605277              # we need to preload.
    6361               func_append newdlprefiles " $deplib"
     5278              newdlprefiles="$newdlprefiles $deplib"
    63625279              compile_deplibs="$deplib $compile_deplibs"
    63635280              finalize_deplibs="$deplib $finalize_deplibs"
    63645281            else
    6365               func_append newdlfiles " $deplib"
     5282              newdlfiles="$newdlfiles $deplib"
    63665283            fi
    63675284          fi
     
    64055322        # Convert "-framework foo" to "foo.ltframework"
    64065323        if test -n "$inherited_linker_flags"; then
    6407           tmp_inherited_linker_flags=`$ECHO "$inherited_linker_flags" | $SED 's/-framework \([^ $]*\)/\1.ltframework/g'`
     5324          tmp_inherited_linker_flags=`$ECHO "X$inherited_linker_flags" | $Xsed -e 's/-framework \([^ $]*\)/\1.ltframework/g'`
    64085325          for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
    64095326            case " $new_inherited_linker_flags " in
    64105327              *" $tmp_inherited_linker_flag "*) ;;
    6411               *) func_append new_inherited_linker_flags " $tmp_inherited_linker_flag";;
     5328              *) new_inherited_linker_flags="$new_inherited_linker_flags $tmp_inherited_linker_flag";;
    64125329            esac
    64135330          done
    64145331        fi
    6415         dependency_libs=`$ECHO " $dependency_libs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
     5332        dependency_libs=`$ECHO "X $dependency_libs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
    64165333        if test "$linkmode,$pass" = "lib,link" ||
    64175334           test "$linkmode,$pass" = "prog,scan" ||
    64185335           { test "$linkmode" != prog && test "$linkmode" != lib; }; then
    6419           test -n "$dlopen" && func_append dlfiles " $dlopen"
    6420           test -n "$dlpreopen" && func_append dlprefiles " $dlpreopen"
     5336          test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
     5337          test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
    64215338        fi
    64225339
     
    64295346            fi
    64305347            # It is a libtool convenience library, so add in its objects.
    6431             func_append convenience " $ladir/$objdir/$old_library"
    6432             func_append old_convenience " $ladir/$objdir/$old_library"
     5348            convenience="$convenience $ladir/$objdir/$old_library"
     5349            old_convenience="$old_convenience $ladir/$objdir/$old_library"
     5350            tmp_libs=
     5351            for deplib in $dependency_libs; do
     5352              deplibs="$deplib $deplibs"
     5353              if $opt_duplicate_deps ; then
     5354                case "$tmp_libs " in
     5355                *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
     5356                esac
     5357              fi
     5358              tmp_libs="$tmp_libs $deplib"
     5359            done
    64335360          elif test "$linkmode" != prog && test "$linkmode" != lib; then
    64345361            func_fatal_error "\`$lib' is not a convenience library"
    64355362          fi
    6436           tmp_libs=
    6437           for deplib in $dependency_libs; do
    6438             deplibs="$deplib $deplibs"
    6439             if $opt_preserve_dup_deps ; then
    6440               case "$tmp_libs " in
    6441               *" $deplib "*) func_append specialdeplibs " $deplib" ;;
    6442               esac
    6443             fi
    6444             func_append tmp_libs " $deplib"
    6445           done
    64465363          continue
    64475364        fi # $pass = conv
     
    64505367        # Get the name of the library we link against.
    64515368        linklib=
    6452         if test -n "$old_library" &&
    6453            { test "$prefer_static_libs" = yes ||
    6454              test "$prefer_static_libs,$installed" = "built,no"; }; then
    6455           linklib=$old_library
    6456         else
    6457           for l in $old_library $library_names; do
    6458             linklib="$l"
    6459           done
    6460         fi
     5369        for l in $old_library $library_names; do
     5370          linklib="$l"
     5371        done
    64615372        if test -z "$linklib"; then
    64625373          func_fatal_error "cannot find name of link library for \`$lib'"
     
    64755386            # dependent libraries so libltdl's deplib preloader doesn't
    64765387            # bomb out in the load deplibs phase.
    6477             func_append dlprefiles " $lib $dependency_libs"
     5388            dlprefiles="$dlprefiles $lib $dependency_libs"
    64785389          else
    6479             func_append newdlfiles " $lib"
     5390            newdlfiles="$newdlfiles $lib"
    64805391          fi
    64815392          continue
     
    64995410        # Find the relevant object directory and library name.
    65005411        if test "X$installed" = Xyes; then
    6501           if test ! -f "$lt_sysroot$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
     5412          if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
    65025413            func_warning "library \`$lib' was moved."
    65035414            dir="$ladir"
     
    65055416            libdir="$abs_ladir"
    65065417          else
    6507             dir="$lt_sysroot$libdir"
    6508             absdir="$lt_sysroot$libdir"
     5418            dir="$libdir"
     5419            absdir="$libdir"
    65095420          fi
    65105421          test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
     
    65145425            absdir="$abs_ladir"
    65155426            # Remove this search path later
    6516             func_append notinst_path " $abs_ladir"
     5427            notinst_path="$notinst_path $abs_ladir"
    65175428          else
    65185429            dir="$ladir/$objdir"
    65195430            absdir="$abs_ladir/$objdir"
    65205431            # Remove this search path later
    6521             func_append notinst_path " $abs_ladir"
     5432            notinst_path="$notinst_path $abs_ladir"
    65225433          fi
    65235434        fi # $installed = yes
     
    65305441            func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'"
    65315442          fi
    6532           case "$host" in
    6533             # special handling for platforms with PE-DLLs.
    6534             *cygwin* | *mingw* | *cegcc* )
    6535               # Linker will automatically link against shared library if both
    6536               # static and shared are present.  Therefore, ensure we extract
    6537               # symbols from the import library if a shared library is present
    6538               # (otherwise, the dlopen module name will be incorrect).  We do
    6539               # this by putting the import library name into $newdlprefiles.
    6540               # We recover the dlopen module name by 'saving' the la file
    6541               # name in a special purpose variable, and (later) extracting the
    6542               # dlname from the la file.
    6543               if test -n "$dlname"; then
    6544                 func_tr_sh "$dir/$linklib"
    6545                 eval "libfile_$func_tr_sh_result=\$abs_ladir/\$laname"
    6546                 func_append newdlprefiles " $dir/$linklib"
    6547               else
    6548                 func_append newdlprefiles " $dir/$old_library"
    6549                 # Keep a list of preopened convenience libraries to check
    6550                 # that they are being used correctly in the link pass.
    6551                 test -z "$libdir" && \
    6552                   func_append dlpreconveniencelibs " $dir/$old_library"
    6553               fi
    6554             ;;
    6555             * )
    6556               # Prefer using a static library (so that no silly _DYNAMIC symbols
    6557               # are required to link).
    6558               if test -n "$old_library"; then
    6559                 func_append newdlprefiles " $dir/$old_library"
    6560                 # Keep a list of preopened convenience libraries to check
    6561                 # that they are being used correctly in the link pass.
    6562                 test -z "$libdir" && \
    6563                   func_append dlpreconveniencelibs " $dir/$old_library"
    6564               # Otherwise, use the dlname, so that lt_dlopen finds it.
    6565               elif test -n "$dlname"; then
    6566                 func_append newdlprefiles " $dir/$dlname"
    6567               else
    6568                 func_append newdlprefiles " $dir/$linklib"
    6569               fi
    6570             ;;
    6571           esac
     5443          # Prefer using a static library (so that no silly _DYNAMIC symbols
     5444          # are required to link).
     5445          if test -n "$old_library"; then
     5446            newdlprefiles="$newdlprefiles $dir/$old_library"
     5447            # Keep a list of preopened convenience libraries to check
     5448            # that they are being used correctly in the link pass.
     5449            test -z "$libdir" && \
     5450                dlpreconveniencelibs="$dlpreconveniencelibs $dir/$old_library"
     5451          # Otherwise, use the dlname, so that lt_dlopen finds it.
     5452          elif test -n "$dlname"; then
     5453            newdlprefiles="$newdlprefiles $dir/$dlname"
     5454          else
     5455            newdlprefiles="$newdlprefiles $dir/$linklib"
     5456          fi
    65725457        fi # $pass = dlpreopen
    65735458
     
    65875472
    65885473        if test "$linkmode" = prog && test "$pass" != link; then
    6589           func_append newlib_search_path " $ladir"
     5474          newlib_search_path="$newlib_search_path $ladir"
    65905475          deplibs="$lib $deplibs"
    65915476
     
    66005485            case $deplib in
    66015486            -L*) func_stripname '-L' '' "$deplib"
    6602                  func_resolve_sysroot "$func_stripname_result"
    6603                  func_append newlib_search_path " $func_resolve_sysroot_result"
     5487                 newlib_search_path="$newlib_search_path $func_stripname_result"
    66045488                 ;;
    66055489            esac
     
    66125496              newdependency_libs="$deplib $newdependency_libs"
    66135497            fi
    6614             if $opt_preserve_dup_deps ; then
     5498            if $opt_duplicate_deps ; then
    66155499              case "$tmp_libs " in
    6616               *" $deplib "*) func_append specialdeplibs " $deplib" ;;
     5500              *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
    66175501              esac
    66185502            fi
    6619             func_append tmp_libs " $deplib"
     5503            tmp_libs="$tmp_libs $deplib"
    66205504          done # for deplib
    66215505          continue
     
    66325516              case "$temp_rpath:" in
    66335517              *"$absdir:"*) ;;
    6634               *) func_append temp_rpath "$absdir:" ;;
     5518              *) temp_rpath="$temp_rpath$absdir:" ;;
    66355519              esac
    66365520            fi
     
    66445528              case "$compile_rpath " in
    66455529              *" $absdir "*) ;;
    6646               *) func_append compile_rpath " $absdir" ;;
     5530              *) compile_rpath="$compile_rpath $absdir"
    66475531              esac
    66485532              ;;
     
    66535537              case "$finalize_rpath " in
    66545538              *" $libdir "*) ;;
    6655               *) func_append finalize_rpath " $libdir" ;;
     5539              *) finalize_rpath="$finalize_rpath $libdir"
    66565540              esac
    66575541              ;;
     
    66785562          *cygwin* | *mingw* | *cegcc*)
    66795563              # No point in relinking DLLs because paths are not encoded
    6680               func_append notinst_deplibs " $lib"
     5564              notinst_deplibs="$notinst_deplibs $lib"
    66815565              need_relink=no
    66825566            ;;
    66835567          *)
    66845568            if test "$installed" = no; then
    6685               func_append notinst_deplibs " $lib"
     5569              notinst_deplibs="$notinst_deplibs $lib"
    66865570              need_relink=yes
    66875571            fi
     
    67005584          done
    67015585          if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then
    6702             echo
     5586            $ECHO
    67035587            if test "$linkmode" = prog; then
    67045588              $ECHO "*** Warning: Linking the executable $output against the loadable module"
     
    67185602              case "$compile_rpath " in
    67195603              *" $absdir "*) ;;
    6720               *) func_append compile_rpath " $absdir" ;;
     5604              *) compile_rpath="$compile_rpath $absdir"
    67215605              esac
    67225606              ;;
     
    67275611              case "$finalize_rpath " in
    67285612              *" $libdir "*) ;;
    6729               *) func_append finalize_rpath " $libdir" ;;
     5613              *) finalize_rpath="$finalize_rpath $libdir"
    67305614              esac
    67315615              ;;
     
    67815665          fi # test -n "$old_archive_from_expsyms_cmds"
    67825666
    6783           if test "$linkmode" = prog || test "$opt_mode" != relink; then
     5667          if test "$linkmode" = prog || test "$mode" != relink; then
    67845668            add_shlibpath=
    67855669            add_dir=
     
    68035687                        $ECHO "*** Warning: lib $linklib is a module, not a shared library"
    68045688                        if test -z "$old_library" ; then
    6805                           echo
    6806                           echo "*** And there doesn't seem to be a static archive available"
    6807                           echo "*** The link will probably fail, sorry"
     5689                          $ECHO
     5690                          $ECHO "*** And there doesn't seem to be a static archive available"
     5691                          $ECHO "*** The link will probably fail, sorry"
    68085692                        else
    68095693                          add="$dir/$old_library"
     
    68375721                  case $libdir in
    68385722                    [\\/]*)
    6839                       func_append add_dir " -L$inst_prefix_dir$libdir"
     5723                      add_dir="$add_dir -L$inst_prefix_dir$libdir"
    68405724                      ;;
    68415725                  esac
     
    68595743              case :$compile_shlibpath: in
    68605744              *":$add_shlibpath:"*) ;;
    6861               *) func_append compile_shlibpath "$add_shlibpath:" ;;
     5745              *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
    68625746              esac
    68635747            fi
     
    68735757                case :$finalize_shlibpath: in
    68745758                *":$libdir:"*) ;;
    6875                 *) func_append finalize_shlibpath "$libdir:" ;;
     5759                *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
    68765760                esac
    68775761              fi
     
    68795763          fi
    68805764
    6881           if test "$linkmode" = prog || test "$opt_mode" = relink; then
     5765          if test "$linkmode" = prog || test "$mode" = relink; then
    68825766            add_shlibpath=
    68835767            add_dir=
     
    68935777              case :$finalize_shlibpath: in
    68945778              *":$libdir:"*) ;;
    6895               *) func_append finalize_shlibpath "$libdir:" ;;
     5779              *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
    68965780              esac
    68975781              add="-l$name"
     
    69105794                case $libdir in
    69115795                  [\\/]*)
    6912                     func_append add_dir " -L$inst_prefix_dir$libdir"
     5796                    add_dir="$add_dir -L$inst_prefix_dir$libdir"
    69135797                    ;;
    69145798                esac
     
    69455829            # Just print a warning and add the library to dependency_libs so
    69465830            # that the program can be linked against the static library.
    6947             echo
     5831            $ECHO
    69485832            $ECHO "*** Warning: This system can not link to static lib archive $lib."
    6949             echo "*** I have the capability to make that library automatically link in when"
    6950             echo "*** you link to this library.  But I can only do this if you have a"
    6951             echo "*** shared version of the library, which you do not appear to have."
     5833            $ECHO "*** I have the capability to make that library automatically link in when"
     5834            $ECHO "*** you link to this library.  But I can only do this if you have a"
     5835            $ECHO "*** shared version of the library, which you do not appear to have."
    69525836            if test "$module" = yes; then
    6953               echo "*** But as you try to build a module library, libtool will still create "
    6954               echo "*** a static module, that should work as long as the dlopening application"
    6955               echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
     5837              $ECHO "*** But as you try to build a module library, libtool will still create "
     5838              $ECHO "*** a static module, that should work as long as the dlopening application"
     5839              $ECHO "*** is linked with the -dlopen flag to resolve symbols at runtime."
    69565840              if test -z "$global_symbol_pipe"; then
    6957                 echo
    6958                 echo "*** However, this would only work if libtool was able to extract symbol"
    6959                 echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
    6960                 echo "*** not find such a program.  So, this module is probably useless."
    6961                 echo "*** \`nm' from GNU binutils and a full rebuild may help."
     5841                $ECHO
     5842                $ECHO "*** However, this would only work if libtool was able to extract symbol"
     5843                $ECHO "*** lists from a program, using \`nm' or equivalent, but libtool could"
     5844                $ECHO "*** not find such a program.  So, this module is probably useless."
     5845                $ECHO "*** \`nm' from GNU binutils and a full rebuild may help."
    69625846              fi
    69635847              if test "$build_old_libs" = no; then
     
    69875871                   case " $xrpath " in
    69885872                   *" $temp_xrpath "*) ;;
    6989                    *) func_append xrpath " $temp_xrpath";;
     5873                   *) xrpath="$xrpath $temp_xrpath";;
    69905874                   esac;;
    6991               *) func_append temp_deplibs " $libdir";;
     5875              *) temp_deplibs="$temp_deplibs $libdir";;
    69925876              esac
    69935877            done
     
    69955879          fi
    69965880
    6997           func_append newlib_search_path " $absdir"
     5881          newlib_search_path="$newlib_search_path $absdir"
    69985882          # Link against this library
    69995883          test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
     
    70025886          for deplib in $dependency_libs; do
    70035887            newdependency_libs="$deplib $newdependency_libs"
    7004             case $deplib in
    7005               -L*) func_stripname '-L' '' "$deplib"
    7006                    func_resolve_sysroot "$func_stripname_result";;
    7007               *) func_resolve_sysroot "$deplib" ;;
    7008             esac
    7009             if $opt_preserve_dup_deps ; then
     5888            if $opt_duplicate_deps ; then
    70105889              case "$tmp_libs " in
    7011               *" $func_resolve_sysroot_result "*)
    7012                 func_append specialdeplibs " $func_resolve_sysroot_result" ;;
     5890              *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
    70135891              esac
    70145892            fi
    7015             func_append tmp_libs " $func_resolve_sysroot_result"
     5893            tmp_libs="$tmp_libs $deplib"
    70165894          done
    70175895
     
    70235901              -L*) path="$deplib" ;;
    70245902              *.la)
    7025                 func_resolve_sysroot "$deplib"
    7026                 deplib=$func_resolve_sysroot_result
    70275903                func_dirname "$deplib" "" "."
    7028                 dir=$func_dirname_result
     5904                dir="$func_dirname_result"
    70295905                # We need an absolute path.
    70305906                case $dir in
     
    70535929                          darwin_install_name=`${OTOOL64} -L $depdepl  | awk '{if (NR == 2) {print $1;exit}}'`
    70545930                      fi
    7055                       func_append compiler_flags " ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"
    7056                       func_append linker_flags " -dylib_file ${darwin_install_name}:${depdepl}"
     5931                      compiler_flags="$compiler_flags ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"
     5932                      linker_flags="$linker_flags -dylib_file ${darwin_install_name}:${depdepl}"
    70575933                      path=
    70585934                    fi
     
    70875963          finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
    70885964        else
    7089           compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
     5965          compiler_flags="$compiler_flags "`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
    70905966        fi
    70915967      fi
     
    71045980            case "$lib_search_path " in
    71055981            *" $dir "*) ;;
    7106             *) func_append lib_search_path " $dir" ;;
     5982            *) lib_search_path="$lib_search_path $dir" ;;
    71075983            esac
    71085984          done
     
    71626038              case " $tmp_libs " in
    71636039              *" $deplib "*) ;;
    7164               *) func_append tmp_libs " $deplib" ;;
     6040              *) tmp_libs="$tmp_libs $deplib" ;;
    71656041              esac
    71666042              ;;
    7167             *) func_append tmp_libs " $deplib" ;;
     6043            *) tmp_libs="$tmp_libs $deplib" ;;
    71686044            esac
    71696045          done
     
    71816057        esac
    71826058        if test -n "$i" ; then
    7183           func_append tmp_libs " $i"
     6059          tmp_libs="$tmp_libs $i"
    71846060        fi
    71856061      done
     
    72226098      build_libtool_libs=no
    72236099      oldlibs="$output"
    7224       func_append objs "$old_deplibs"
     6100      objs="$objs$old_deplibs"
    72256101      ;;
    72266102
     
    72556131          func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"
    72566132        else
    7257           echo
     6133          $ECHO
    72586134          $ECHO "*** Warning: Linking the shared library $output against the non-libtool"
    72596135          $ECHO "*** objects $objs is not portable!"
    7260           func_append libobjs " $objs"
     6136          libobjs="$libobjs $objs"
    72616137        fi
    72626138      fi
     
    73236199            revision="$number_revision"
    73246200            ;;
    7325           freebsd-aout|freebsd-elf|qnx|sunos)
     6201          freebsd-aout|freebsd-elf|sunos)
    73266202            current="$number_major"
    73276203            revision="$number_minor"
     
    73346210            revision="$number_minor"
    73356211            lt_irix_increment=no
     6212            ;;
     6213          *)
     6214            func_fatal_configuration "$modename: unknown library version type \`$version_type'"
    73366215            ;;
    73376216          esac
     
    74566335
    74576336          # Make executables depend on our current version.
    7458           func_append verstring ":${current}.0"
     6337          verstring="$verstring:${current}.0"
    74596338          ;;
    74606339
     
    75246403
    75256404      func_generate_dlsyms "$libname" "$libname" "yes"
    7526       func_append libobjs " $symfileobj"
     6405      libobjs="$libobjs $symfileobj"
    75276406      test "X$libobjs" = "X " && libobjs=
    75286407
    7529       if test "$opt_mode" != relink; then
     6408      if test "$mode" != relink; then
    75306409        # Remove our outputs, but don't remove object files since they
    75316410        # may have been created when compiling PIC objects.
     
    75436422                 fi
    75446423               fi
    7545                func_append removelist " $p"
     6424               removelist="$removelist $p"
    75466425               ;;
    75476426            *) ;;
     
    75546433      # Now set the variables for building old libraries.
    75556434      if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
    7556         func_append oldlibs " $output_objdir/$libname.$libext"
     6435        oldlibs="$oldlibs $output_objdir/$libname.$libext"
    75576436
    75586437        # Transform .lo files to .o files.
    7559         oldobjs="$objs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; $lo2o" | $NL2SP`
     6438        oldobjs="$objs "`$ECHO "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
    75606439      fi
    75616440
    75626441      # Eliminate all temporary directories.
    75636442      #for path in $notinst_path; do
    7564       # lib_search_path=`$ECHO "$lib_search_path " | $SED "s% $path % %g"`
    7565       # deplibs=`$ECHO "$deplibs " | $SED "s% -L$path % %g"`
    7566       # dependency_libs=`$ECHO "$dependency_libs " | $SED "s% -L$path % %g"`
     6443      # lib_search_path=`$ECHO "X$lib_search_path " | $Xsed -e "s% $path % %g"`
     6444      # deplibs=`$ECHO "X$deplibs " | $Xsed -e "s% -L$path % %g"`
     6445      # dependency_libs=`$ECHO "X$dependency_libs " | $Xsed -e "s% -L$path % %g"`
    75676446      #done
    75686447
     
    75716450        temp_xrpath=
    75726451        for libdir in $xrpath; do
    7573           func_replace_sysroot "$libdir"
    7574           func_append temp_xrpath " -R$func_replace_sysroot_result"
     6452          temp_xrpath="$temp_xrpath -R$libdir"
    75756453          case "$finalize_rpath " in
    75766454          *" $libdir "*) ;;
    7577           *) func_append finalize_rpath " $libdir" ;;
     6455          *) finalize_rpath="$finalize_rpath $libdir" ;;
    75786456          esac
    75796457        done
     
    75896467        case " $dlprefiles $dlfiles " in
    75906468        *" $lib "*) ;;
    7591         *) func_append dlfiles " $lib" ;;
     6469        *) dlfiles="$dlfiles $lib" ;;
    75926470        esac
    75936471      done
     
    75996477        case "$dlprefiles " in
    76006478        *" $lib "*) ;;
    7601         *) func_append dlprefiles " $lib" ;;
     6479        *) dlprefiles="$dlprefiles $lib" ;;
    76026480        esac
    76036481      done
     
    76066484        if test -n "$rpath"; then
    76076485          case $host in
    7608           *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc* | *-*-haiku*)
     6486          *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc*)
    76096487            # these systems don't actually have a c library (as such)!
    76106488            ;;
    76116489          *-*-rhapsody* | *-*-darwin1.[012])
    76126490            # Rhapsody C library is in the System framework
    7613             func_append deplibs " System.ltframework"
     6491            deplibs="$deplibs System.ltframework"
    76146492            ;;
    76156493          *-*-netbsd*)
     
    76286506            # Add libc to deplibs on all other systems if necessary.
    76296507            if test "$build_libtool_need_lc" = "yes"; then
    7630               func_append deplibs " -lc"
     6508              deplibs="$deplibs -lc"
    76316509            fi
    76326510            ;;
     
    76776555                  case " $predeps $postdeps " in
    76786556                  *" $i "*)
    7679                     func_append newdeplibs " $i"
     6557                    newdeplibs="$newdeplibs $i"
    76806558                    i=""
    76816559                    ;;
     
    76886566                  deplib_match=$1
    76896567                  if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
    7690