PageRenderTime 2599ms CodeModel.GetById 1ms RepoModel.GetById 5ms app.codeStats 1ms

/recipes/binutils/binutils-2.20.1/libtool-2.4-update.patch

https://bitbucket.org/lokkju/openpli-oe
Patch | 1571 lines | 1502 code | 69 blank | 0 comment | 0 complexity | 0a9753e47834d64dd31b70452911c1a5 MD5 | raw file
Possible License(s): BSD-3-Clause, GPL-2.0, GPL-3.0, LGPL-2.0, LGPL-2.1, LGPL-3.0 
    

  1. Index: binutils-2.20.1/ltmain.sh
    2. 

  2. ===================================================================
    3. 

  3. --- binutils-2.20.1.orig/ltmain.sh
    4. 

  4. +++ binutils-2.20.1/ltmain.sh
    5. 

  5. @@ -1,9 +1,9 @@
    6. 

  6. -# Generated from ltmain.m4sh.
    7. 

  7.  
    8. 

  8. -# ltmain.sh (GNU libtool) 2.2.6
    9. 

  9. +# libtool (GNU libtool) 2.4
    10. 

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

  11.  
    12. 

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

  13. +# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006,
    14. 

  14. +# 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
    15. 

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

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

  17.  
    18. 

  18. @@ -32,50 +32,56 @@
    19. 

  19.  #
    20. 

  20.  # Provide generalized library-building support services.
    21. 

  21.  #
    22. 

  22. -#     --config             show all configuration variables
    23. 

  23. -#     --debug              enable verbose shell tracing
    24. 

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

  25. -#     --features           display basic configuration information and exit
    26. 

  26. -#     --mode=MODE          use operation mode MODE
    27. 

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

  28. -#     --quiet, --silent    don't print informational messages
    29. 

  29. -#     --tag=TAG            use configuration variables from tag TAG
    30. 

  30. -# -v, --verbose            print informational messages (default)
    31. 

  31. -#     --version            print version information
    32. 

  32. -# -h, --help               print short or long help message
    33. 

  33. +#       --config             show all configuration variables
    34. 

  34. +#       --debug              enable verbose shell tracing
    35. 

  35. +#   -n, --dry-run            display commands without modifying any files
    36. 

  36. +#       --features           display basic configuration information and exit
    37. 

  37. +#       --mode=MODE          use operation mode MODE
    38. 

  38. +#       --preserve-dup-deps  don't remove duplicate dependency libraries
    39. 

  39. +#       --quiet, --silent    don't print informational messages
    40. 

  40. +#       --no-quiet, --no-silent
    41. 

  41. +#                            print informational messages (default)
    42. 

  42. +#       --tag=TAG            use configuration variables from tag TAG
    43. 

  43. +#   -v, --verbose            print more informational messages than default
    44. 

  44. +#       --no-verbose         don't print the extra informational messages
    45. 

  45. +#       --version            print version information
    46. 

  46. +#   -h, --help, --help-all   print short, long, or detailed help message
    47. 

  47.  #
    48. 

  48.  # MODE must be one of the following:
    49. 

  49.  #
    50. 

  50. -#       clean              remove files from the build directory
    51. 

  51. -#       compile            compile a source file into a libtool object
    52. 

  52. -#       execute            automatically set library path, then run a program
    53. 

  53. -#       finish             complete the installation of libtool libraries
    54. 

  54. -#       install            install libraries or executables
    55. 

  55. -#       link               create a library or an executable
    56. 

  56. -#       uninstall          remove libraries from an installed directory
    57. 

  57. +#         clean              remove files from the build directory
    58. 

  58. +#         compile            compile a source file into a libtool object
    59. 

  59. +#         execute            automatically set library path, then run a program
    60. 

  60. +#         finish             complete the installation of libtool libraries
    61. 

  61. +#         install            install libraries or executables
    62. 

  62. +#         link               create a library or an executable
    63. 

  63. +#         uninstall          remove libraries from an installed directory
    64. 

  64.  #
    65. 

  65. -# MODE-ARGS vary depending on the MODE.
    66. 

  66. +# MODE-ARGS vary depending on the MODE.  When passed as first option,
    67. 

  67. +# `--mode=MODE' may be abbreviated as `MODE' or a unique abbreviation of that.
    68. 

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

  69.  #
    70. 

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

  71.  # include the following information:
    72. 

  72.  #
    73. 

  73. -#       host-triplet:	$host
    74. 

  74. -#       shell:		$SHELL
    75. 

  75. -#       compiler:		$LTCC
    76. 

  76. -#       compiler flags:		$LTCFLAGS
    77. 

  77. -#       linker:		$LD (gnu? $with_gnu_ld)
    78. 

  78. -#       $progname:		(GNU libtool) 2.2.6
    79. 

  79. -#       automake:		$automake_version
    80. 

  80. -#       autoconf:		$autoconf_version
    81. 

  81. +#         host-triplet:	$host
    82. 

  82. +#         shell:		$SHELL
    83. 

  83. +#         compiler:		$LTCC
    84. 

  84. +#         compiler flags:		$LTCFLAGS
    85. 

  85. +#         linker:		$LD (gnu? $with_gnu_ld)
    86. 

  86. +#         $progname:	(GNU libtool) 2.4
    87. 

  87. +#         automake:	$automake_version
    88. 

  88. +#         autoconf:	$autoconf_version
    89. 

  89.  #
    90. 

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

  91. +# GNU libtool home page: <http://www.gnu.org/software/libtool/>.
    92. 

  92. +# General help using GNU software: <http://www.gnu.org/gethelp/>.
    93. 

  93.  
    94. 

  94. -PROGRAM=ltmain.sh
    95. 

  95. +PROGRAM=libtool
    96. 

  96.  PACKAGE=libtool
    97. 

  97. -VERSION=2.2.6
    98. 

  98. +VERSION=2.4
    99. 

  99.  TIMESTAMP=""
    100. 

  100. -package_revision=1.3012
    101. 

  101. +package_revision=1.3293
    102. 

  102.  
    103. 

  103.  # Be Bourne compatible
    104. 

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

  105. @@ -91,10 +97,15 @@ fi
    106. 

  106.  BIN_SH=xpg4; export BIN_SH # for Tru64
    107. 

  107.  DUALCASE=1; export DUALCASE # for MKS sh
    108. 

  108.  
    109. 

  109. +# A function that is used when there is no print builtin or printf.
    110. 

  110. +func_fallback_echo ()
    111. 

  111. +{
    112. 

  112. +  eval 'cat <<_LTECHO_EOF
    113. 

  113. +$1
    114. 

  114. +_LTECHO_EOF'
    115. 

  115. +}
    116. 

  116. +
    117. 

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

  118. -# Only set LANG and LC_ALL to C if already set.
    119. 

  119. -# These must not be set unconditionally because not all systems understand
    120. 

  120. -# e.g. LANG=C (notably SCO).
    121. 

  121.  lt_user_locale=
    122. 

  122.  lt_safe_locale=
    123. 

  123.  for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
    124. 

  124. @@ -107,24 +118,33 @@ do
    125. 

  125.  	  lt_safe_locale=\"$lt_var=C; \$lt_safe_locale\"
    126. 

  126.  	fi"
    127. 

  127.  done
    128. 

  128. +LC_ALL=C
    129. 

  129. +LANGUAGE=C
    130. 

  130. +export LANGUAGE LC_ALL
    131. 

  131.  
    132. 

  132.  $lt_unset CDPATH
    133. 

  133.  
    134. 

  134.  
    135. 

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

  136. +# is ksh but when the shell is invoked as "sh" and the current value of
    137. 

  137. +# the _XPG environment variable is not equal to 1 (one), the special
    138. 

  138. +# positional parameter $0, within a function call, is the name of the
    139. 

  139. +# function.
    140. 

  140. +progpath="$0"
    141. 

  141.  
    142. 

  142.  
    143. 

  143.  
    144. 

  144.  : ${CP="cp -f"}
    145. 

  145. -: ${ECHO="echo"}
    146. 

  146. -: ${EGREP="/usr/bin/grep -E"}
    147. 

  147. -: ${FGREP="/usr/bin/grep -F"}
    148. 

  148. -: ${GREP="/usr/bin/grep"}
    149. 

  149. +test "${ECHO+set}" = set || ECHO=${as_echo-'printf %s\n'}
    150. 

  150. +: ${EGREP="/bin/grep -E"}
    151. 

  151. +: ${FGREP="/bin/grep -F"}
    152. 

  152. +: ${GREP="/bin/grep"}
    153. 

  153.  : ${LN_S="ln -s"}
    154. 

  154.  : ${MAKE="make"}
    155. 

  155.  : ${MKDIR="mkdir"}
    156. 

  156.  : ${MV="mv -f"}
    157. 

  157.  : ${RM="rm -f"}
    158. 

  158. -: ${SED="/opt/local/bin/gsed"}
    159. 

  159. +: ${SED="/bin/sed"}
    160. 

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

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

  162.  
    163. 

  163. @@ -144,6 +164,27 @@ IFS=" 	$lt_nl"
    164. 

  164.  dirname="s,/[^/]*$,,"
    165. 

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

  166.  
    167. 

  167. +# func_dirname file append nondir_replacement
    168. 

  168. +# Compute the dirname of FILE.  If nonempty, add APPEND to the result,
    169. 

  169. +# otherwise set result to NONDIR_REPLACEMENT.
    170. 

  170. +func_dirname ()
    171. 

  171. +{
    172. 

  172. +    func_dirname_result=`$ECHO "${1}" | $SED "$dirname"`
    173. 

  173. +    if test "X$func_dirname_result" = "X${1}"; then
    174. 

  174. +      func_dirname_result="${3}"
    175. 

  175. +    else
    176. 

  176. +      func_dirname_result="$func_dirname_result${2}"
    177. 

  177. +    fi
    178. 

  178. +} # func_dirname may be replaced by extended shell implementation
    179. 

  179. +
    180. 

  180. +
    181. 

  181. +# func_basename file
    182. 

  182. +func_basename ()
    183. 

  183. +{
    184. 

  184. +    func_basename_result=`$ECHO "${1}" | $SED "$basename"`
    185. 

  185. +} # func_basename may be replaced by extended shell implementation
    186. 

  186. +
    187. 

  187. +
    188. 

  188.  # func_dirname_and_basename file append nondir_replacement
    189. 

  189.  # perform func_basename and func_dirname in a single function
    190. 

  190.  # call:
    191. 

  191. @@ -158,24 +199,41 @@ basename="s,^.*/,,"
    192. 

  192.  # those functions but instead duplicate the functionality here.
    193. 

  193.  func_dirname_and_basename ()
    194. 

  194.  {
    195. 

  195. -  # Extract subdirectory from the argument.
    196. 

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

  197. -  if test "X$func_dirname_result" = "X${1}"; then
    198. 

  198. -    func_dirname_result="${3}"
    199. 

  199. -  else
    200. 

  200. -    func_dirname_result="$func_dirname_result${2}"
    201. 

  201. -  fi
    202. 

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

  203. -}
    204. 

  204. +    # Extract subdirectory from the argument.
    205. 

  205. +    func_dirname_result=`$ECHO "${1}" | $SED -e "$dirname"`
    206. 

  206. +    if test "X$func_dirname_result" = "X${1}"; then
    207. 

  207. +      func_dirname_result="${3}"
    208. 

  208. +    else
    209. 

  209. +      func_dirname_result="$func_dirname_result${2}"
    210. 

  210. +    fi
    211. 

  211. +    func_basename_result=`$ECHO "${1}" | $SED -e "$basename"`
    212. 

  212. +} # func_dirname_and_basename may be replaced by extended shell implementation
    213. 

  213. +
    214. 

  214. +
    215. 

  215. +# func_stripname prefix suffix name
    216. 

  216. +# strip PREFIX and SUFFIX off of NAME.
    217. 

  217. +# PREFIX and SUFFIX must not contain globbing or regex special
    218. 

  218. +# characters, hashes, percent signs, but SUFFIX may contain a leading
    219. 

  219. +# dot (in which case that matches only a dot).
    220. 

  220. +# func_strip_suffix prefix name
    221. 

  221. +func_stripname ()
    222. 

  222. +{
    223. 

  223. +    case ${2} in
    224. 

  224. +      .*) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%\\\\${2}\$%%"`;;
    225. 

  225. +      *)  func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%${2}\$%%"`;;
    226. 

  226. +    esac
    227. 

  227. +} # func_stripname may be replaced by extended shell implementation
    228. 

  228.  
    229. 

  229. -# Generated shell functions inserted here.
    230. 

  230.  
    231. 

  231.  # These SED scripts presuppose an absolute path with a trailing slash.
    232. 

  232. -pathcar="s,^/\([^/]*\).*$,\1,"
    233. 

  233. -pathcdr="s,^/[^/]*,,"
    234. 

  234. -removedotparts="s@/\(\./\)\{1,\}@/@g;s,/\.$,/,"
    235. 

  235. -collapseslashes="s@/\{1,\}@/@g"
    236. 

  236. -finalslash="s,/*$,/,"
    237. 

  237. +pathcar='s,^/\([^/]*\).*$,\1,'
    238. 

  238. +pathcdr='s,^/[^/]*,,'
    239. 

  239. +removedotparts=':dotsl
    240. 

  240. +		s@/\./@/@g
    241. 

  241. +		t dotsl
    242. 

  242. +		s,/\.$,/,'
    243. 

  243. +collapseslashes='s@/\{1,\}@/@g'
    244. 

  244. +finalslash='s,/*$,/,'
    245. 

  245.  
    246. 

  246.  # func_normal_abspath PATH
    247. 

  247.  # Remove doubled-up and trailing slashes, "." path components,
    248. 

  248. @@ -315,21 +373,9 @@ func_relative_path ()
    249. 

  249.    fi
    250. 

  250.  }
    251. 

  251.  
    252. 

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

  253. -# is ksh but when the shell is invoked as "sh" and the current value of
    254. 

  254. -# the _XPG environment variable is not equal to 1 (one), the special
    255. 

  255. -# positional parameter $0, within a function call, is the name of the
    256. 

  256. -# function.
    257. 

  257. -progpath="$0"
    258. 

  258. -
    259. 

  259.  # The name of this program:
    260. 

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

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

  262.  func_dirname_and_basename "$progpath"
    263. 

  263.  progname=$func_basename_result
    264. 

  264. -case $progname in
    265. 

  265. -  -*) progname=./$progname ;;
    266. 

  266. -esac
    267. 

  267.  
    268. 

  268.  # Make sure we have an absolute path for reexecution:
    269. 

  269.  case $progpath in
    270. 

  270. @@ -360,6 +406,15 @@ sed_quote_subst='s/\([`"$\\]\)/\\\1/g'
    271. 

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

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

  273.  
    274. 

  274. +# Sed substitution that turns a string into a regex matching for the
    275. 

  275. +# string literally.
    276. 

  276. +sed_make_literal_regex='s,[].[^$\\*\/],\\&,g'
    277. 

  277. +
    278. 

  278. +# Sed substitution that converts a w32 file name or path
    279. 

  279. +# which contains forward slashes, into one that contains
    280. 

  280. +# (escaped) backslashes.  A very naive implementation.
    281. 

  281. +lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
    282. 

  282. +
    283. 

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

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

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

  286. @@ -388,7 +443,7 @@ opt_warning=:
    287. 

  287.  # name if it has been set yet.
    288. 

  288.  func_echo ()
    289. 

  289.  {
    290. 

  290. -    $ECHO "$progname${mode+: }$mode: $*"
    291. 

  291. +    $ECHO "$progname: ${opt_mode+$opt_mode: }$*"
    292. 

  292.  }
    293. 

  293.  
    294. 

  294.  # func_verbose arg...
    295. 

  295. @@ -403,18 +458,25 @@ func_verbose ()
    296. 

  296.      :
    297. 

  297.  }
    298. 

  298.  
    299. 

  299. +# func_echo_all arg...
    300. 

  300. +# Invoke $ECHO with all args, space-separated.
    301. 

  301. +func_echo_all ()
    302. 

  302. +{
    303. 

  303. +    $ECHO "$*"
    304. 

  304. +}
    305. 

  305. +
    306. 

  306.  # func_error arg...
    307. 

  307.  # Echo program name prefixed message to standard error.
    308. 

  308.  func_error ()
    309. 

  309.  {
    310. 

  310. -    $ECHO "$progname${mode+: }$mode: "${1+"$@"} 1>&2
    311. 

  311. +    $ECHO "$progname: ${opt_mode+$opt_mode: }"${1+"$@"} 1>&2
    312. 

  312.  }
    313. 

  313.  
    314. 

  314.  # func_warning arg...
    315. 

  315.  # Echo program name prefixed warning message to standard error.
    316. 

  316.  func_warning ()
    317. 

  317.  {
    318. 

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

  319. +    $opt_warning && $ECHO "$progname: ${opt_mode+$opt_mode: }warning: "${1+"$@"} 1>&2
    320. 

  320.  
    321. 

  321.      # bash bug again:
    322. 

  322.      :
    323. 

  323. @@ -471,9 +533,9 @@ func_mkdir_p ()
    324. 

  324.          case $my_directory_path in */*) ;; *) break ;; esac
    325. 

  325.  
    326. 

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

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

  328. +        my_directory_path=`$ECHO "$my_directory_path" | $SED -e "$dirname"`
    329. 

  329.        done
    330. 

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

  331. +      my_dir_list=`$ECHO "$my_dir_list" | $SED 's,:*$,,'`
    332. 

  332.  
    333. 

  333.        save_mkdir_p_IFS="$IFS"; IFS=':'
    334. 

  334.        for my_dir in $my_dir_list; do
    335. 

  335. @@ -523,7 +585,7 @@ func_mktempdir ()
    336. 

  336.          func_fatal_error "cannot create temporary directory \`$my_tmpdir'"
    337. 

  337.      fi
    338. 

  338.  
    339. 

  339. -    $ECHO "X$my_tmpdir" | $Xsed
    340. 

  340. +    $ECHO "$my_tmpdir"
    341. 

  341.  }
    342. 

  342.  
    343. 

  343.  
    344. 

  344. @@ -537,7 +599,7 @@ func_quote_for_eval ()
    345. 

  345.  {
    346. 

  346.      case $1 in
    347. 

  347.        *[\\\`\"\$]*)
    348. 

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

  349. +	func_quote_for_eval_unquoted_result=`$ECHO "$1" | $SED "$sed_quote_subst"` ;;
    350. 

  350.        *)
    351. 

  351.          func_quote_for_eval_unquoted_result="$1" ;;
    352. 

  352.      esac
    353. 

  353. @@ -564,7 +626,7 @@ func_quote_for_expand ()
    354. 

  354.  {
    355. 

  355.      case $1 in
    356. 

  356.        *[\\\`\"]*)
    357. 

  357. -	my_arg=`$ECHO "X$1" | $Xsed \
    358. 

  358. +	my_arg=`$ECHO "$1" | $SED \
    359. 

  359.  	    -e "$double_quote_subst" -e "$sed_double_backslash"` ;;
    360. 

  360.        *)
    361. 

  361.          my_arg="$1" ;;
    362. 

  362. @@ -633,15 +695,39 @@ func_show_eval_locale ()
    363. 

  363.      fi
    364. 

  364.  }
    365. 

  365.  
    366. 

  366. -
    367. 

  367. -
    368. 

  368. +# func_tr_sh
    369. 

  369. +# Turn $1 into a string suitable for a shell variable name.
    370. 

  370. +# Result is stored in $func_tr_sh_result.  All characters
    371. 

  371. +# not in the set a-zA-Z0-9_ are replaced with '_'. Further,
    372. 

  372. +# if $1 begins with a digit, a '_' is prepended as well.
    373. 

  373. +func_tr_sh ()
    374. 

  374. +{
    375. 

  375. +  case $1 in
    376. 

  376. +  [0-9]* | *[!a-zA-Z0-9_]*)
    377. 

  377. +    func_tr_sh_result=`$ECHO "$1" | $SED 's/^\([0-9]\)/_\1/; s/[^a-zA-Z0-9_]/_/g'`
    378. 

  378. +    ;;
    379. 

  379. +  * )
    380. 

  380. +    func_tr_sh_result=$1
    381. 

  381. +    ;;
    382. 

  382. +  esac
    383. 

  383. +}
    384. 

  384.  
    385. 

  385.  
    386. 

  386.  # func_version
    387. 

  387.  # Echo version message to standard output and exit.
    388. 

  388.  func_version ()
    389. 

  389.  {
    390. 

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

  391. +    $opt_debug
    392. 

  392. +
    393. 

  393. +    $SED -n '/(C)/!b go
    394. 

  394. +	:more
    395. 

  395. +	/\./!{
    396. 

  396. +	  N
    397. 

  397. +	  s/\n# / /
    398. 

  398. +	  b more
    399. 

  399. +	}
    400. 

  400. +	:go
    401. 

  401. +	/^# '$PROGRAM' (GNU /,/# warranty; / {
    402. 

  402.          s/^# //
    403. 

  403.  	s/^# *$//
    404. 

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

  405. @@ -654,22 +740,28 @@ func_version ()
    406. 

  406.  # Echo short help message to standard output and exit.
    407. 

  407.  func_usage ()
    408. 

  408.  {
    409. 

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

  410. +    $opt_debug
    411. 

  411. +
    412. 

  412. +    $SED -n '/^# Usage:/,/^#  *.*--help/ {
    413. 

  413.          s/^# //
    414. 

  414.  	s/^# *$//
    415. 

  415.  	s/\$progname/'$progname'/
    416. 

  416.  	p
    417. 

  417.      }' < "$progpath"
    418. 

  418. -    $ECHO
    419. 

  419. +    echo
    420. 

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

  421.      exit $?
    422. 

  422.  }
    423. 

  423.  
    424. 

  424. -# func_help
    425. 

  425. -# Echo long help message to standard output and exit.
    426. 

  426. +# func_help [NOEXIT]
    427. 

  427. +# Echo long help message to standard output and exit,
    428. 

  428. +# unless 'noexit' is passed as argument.
    429. 

  429.  func_help ()
    430. 

  430.  {
    431. 

  431. +    $opt_debug
    432. 

  432. +
    433. 

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

  434. +	:print
    435. 

  435.          s/^# //
    436. 

  436.  	s/^# *$//
    437. 

  437.  	s*\$progname*'$progname'*
    438. 

  438. @@ -682,8 +774,15 @@ func_help ()
    439. 

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

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

  441.  	p
    442. 

  442. -     }' < "$progpath"
    443. 

  443. -    exit $?
    444. 

  444. +	d
    445. 

  445. +     }
    446. 

  446. +     /^# .* home page:/b print
    447. 

  447. +     /^# General help using/b print
    448. 

  448. +     ' < "$progpath"
    449. 

  449. +    ret=$?
    450. 

  450. +    if test -z "$1"; then
    451. 

  451. +      exit $ret
    452. 

  452. +    fi
    453. 

  453.  }
    454. 

  454.  
    455. 

  455.  # func_missing_arg argname
    456. 

  456. @@ -691,63 +790,106 @@ func_help ()
    457. 

  457.  # exit_cmd.
    458. 

  458.  func_missing_arg ()
    459. 

  459.  {
    460. 

  460. -    func_error "missing argument for $1"
    461. 

  461. +    $opt_debug
    462. 

  462. +
    463. 

  463. +    func_error "missing argument for $1."
    464. 

  464.      exit_cmd=exit
    465. 

  465.  }
    466. 

  466.  
    467. 

  467. -exit_cmd=:
    468. 

  468.  
    469. 

  469. +# func_split_short_opt shortopt
    470. 

  470. +# Set func_split_short_opt_name and func_split_short_opt_arg shell
    471. 

  471. +# variables after splitting SHORTOPT after the 2nd character.
    472. 

  472. +func_split_short_opt ()
    473. 

  473. +{
    474. 

  474. +    my_sed_short_opt='1s/^\(..\).*$/\1/;q'
    475. 

  475. +    my_sed_short_rest='1s/^..\(.*\)$/\1/;q'
    476. 

  476. +
    477. 

  477. +    func_split_short_opt_name=`$ECHO "$1" | $SED "$my_sed_short_opt"`
    478. 

  478. +    func_split_short_opt_arg=`$ECHO "$1" | $SED "$my_sed_short_rest"`
    479. 

  479. +} # func_split_short_opt may be replaced by extended shell implementation
    480. 

  480. +
    481. 

  481. +
    482. 

  482. +# func_split_long_opt longopt
    483. 

  483. +# Set func_split_long_opt_name and func_split_long_opt_arg shell
    484. 

  484. +# variables after splitting LONGOPT at the `=' sign.
    485. 

  485. +func_split_long_opt ()
    486. 

  486. +{
    487. 

  487. +    my_sed_long_opt='1s/^\(--[^=]*\)=.*/\1/;q'
    488. 

  488. +    my_sed_long_arg='1s/^--[^=]*=//'
    489. 

  489. +
    490. 

  490. +    func_split_long_opt_name=`$ECHO "$1" | $SED "$my_sed_long_opt"`
    491. 

  491. +    func_split_long_opt_arg=`$ECHO "$1" | $SED "$my_sed_long_arg"`
    492. 

  492. +} # func_split_long_opt may be replaced by extended shell implementation
    493. 

  493.  
    494. 

  494. +exit_cmd=:
    495. 

  495.  
    496. 

  496.  
    497. 

  497.  
    498. 

  498. -# Check that we have a working $ECHO.
    499. 

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

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

  501. -  shift
    502. 

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

  503. -  # Avoid inline document here, it may be left over
    504. 

  504. -  :
    505. 

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

  506. -  # Yippee, $ECHO works!
    507. 

  507. -  :
    508. 

  508. -else
    509. 

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

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

  511. -fi
    512. 

  512.  
    513. 

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

  514. -  # used as fallback echo
    515. 

  515. -  shift
    516. 

  516. -  cat <<EOF
    517. 

  517. -$*
    518. 

  518. -EOF
    519. 

  519. -  exit $EXIT_SUCCESS
    520. 

  520. -fi
    521. 

  521.  
    522. 

  522.  magic="%%%MAGIC variable%%%"
    523. 

  523.  magic_exe="%%%MAGIC EXE variable%%%"
    524. 

  524.  
    525. 

  525.  # Global variables.
    526. 

  526. -# $mode is unset
    527. 

  527.  nonopt=
    528. 

  528. -execute_dlfiles=
    529. 

  529.  preserve_args=
    530. 

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

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

  532.  extracted_archives=
    533. 

  533.  extracted_serial=0
    534. 

  534.  
    535. 

  535. -opt_dry_run=false
    536. 

  536. -opt_duplicate_deps=false
    537. 

  537. -opt_silent=false
    538. 

  538. -opt_debug=:
    539. 

  539. -
    540. 

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

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

  542.  # left over by shells.
    543. 

  543.  exec_cmd=
    544. 

  544.  
    545. 

  545. +# func_append var value
    546. 

  546. +# Append VALUE to the end of shell variable VAR.
    547. 

  547. +func_append ()
    548. 

  548. +{
    549. 

  549. +    eval "${1}=\$${1}\${2}"
    550. 

  550. +} # func_append may be replaced by extended shell implementation
    551. 

  551. +
    552. 

  552. +# func_append_quoted var value
    553. 

  553. +# Quote VALUE and append to the end of shell variable VAR, separated
    554. 

  554. +# by a space.
    555. 

  555. +func_append_quoted ()
    556. 

  556. +{
    557. 

  557. +    func_quote_for_eval "${2}"
    558. 

  558. +    eval "${1}=\$${1}\\ \$func_quote_for_eval_result"
    559. 

  559. +} # func_append_quoted may be replaced by extended shell implementation
    560. 

  560. +
    561. 

  561. +
    562. 

  562. +# func_arith arithmetic-term...
    563. 

  563. +func_arith ()
    564. 

  564. +{
    565. 

  565. +    func_arith_result=`expr "${@}"`
    566. 

  566. +} # func_arith may be replaced by extended shell implementation
    567. 

  567. +
    568. 

  568. +
    569. 

  569. +# func_len string
    570. 

  570. +# STRING may not start with a hyphen.
    571. 

  571. +func_len ()
    572. 

  572. +{
    573. 

  573. +    func_len_result=`expr "${1}" : ".*" 2>/dev/null || echo $max_cmd_len`
    574. 

  574. +} # func_len may be replaced by extended shell implementation
    575. 

  575. +
    576. 

  576. +
    577. 

  577. +# func_lo2o object
    578. 

  578. +func_lo2o ()
    579. 

  579. +{
    580. 

  580. +    func_lo2o_result=`$ECHO "${1}" | $SED "$lo2o"`
    581. 

  581. +} # func_lo2o may be replaced by extended shell implementation
    582. 

  582. +
    583. 

  583. +
    584. 

  584. +# func_xform libobj-or-source
    585. 

  585. +func_xform ()
    586. 

  586. +{
    587. 

  587. +    func_xform_result=`$ECHO "${1}" | $SED 's/\.[^.]*$/.lo/'`
    588. 

  588. +} # func_xform may be replaced by extended shell implementation
    589. 

  589. +
    590. 

  590. +
    591. 

  591.  # func_fatal_configuration arg...
    592. 

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

  593.  # a configuration failure hint, and exit.
    594. 

  594. @@ -781,16 +923,16 @@ func_config ()
    595. 

  595.  # Display the features supported by this script.
    596. 

  596.  func_features ()
    597. 

  597.  {
    598. 

  598. -    $ECHO "host: $host"
    599. 

  599. +    echo "host: $host"
    600. 

  600.      if test "$build_libtool_libs" = yes; then
    601. 

  601. -      $ECHO "enable shared libraries"
    602. 

  602. +      echo "enable shared libraries"
    603. 

  603.      else
    604. 

  604. -      $ECHO "disable shared libraries"
    605. 

  605. +      echo "disable shared libraries"
    606. 

  606.      fi
    607. 

  607.      if test "$build_old_libs" = yes; then
    608. 

  608. -      $ECHO "enable static libraries"
    609. 

  609. +      echo "enable static libraries"
    610. 

  610.      else
    611. 

  611. -      $ECHO "disable static libraries"
    612. 

  612. +      echo "disable static libraries"
    613. 

  613.      fi
    614. 

  614.  
    615. 

  615.      exit $?
    616. 

  616. @@ -837,117 +979,204 @@ func_enable_tag ()
    617. 

  617.    esac
    618. 

  618.  }
    619. 

  619.  
    620. 

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

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

  622. +# func_check_version_match
    623. 

  623. +# Ensure that we are using m4 macros, and libtool script from the same
    624. 

  624. +# release of libtool.
    625. 

  625. +func_check_version_match ()
    626. 

  626.  {
    627. 

  627. +  if test "$package_revision" != "$macro_revision"; then
    628. 

  628. +    if test "$VERSION" != "$macro_version"; then
    629. 

  629. +      if test -z "$macro_version"; then
    630. 

  630. +        cat >&2 <<_LT_EOF
    631. 

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

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

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

  634. +$progname: and run autoconf again.
    635. 

  635. +_LT_EOF
    636. 

  636. +      else
    637. 

  637. +        cat >&2 <<_LT_EOF
    638. 

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

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

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

  641. +$progname: and run autoconf again.
    642. 

  642. +_LT_EOF
    643. 

  643. +      fi
    644. 

  644. +    else
    645. 

  645. +      cat >&2 <<_LT_EOF
    646. 

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

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

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

  649. +$progname: of $PACKAGE $VERSION and run autoconf again.
    650. 

  650. +_LT_EOF
    651. 

  651. +    fi
    652. 

  652. +
    653. 

  653. +    exit $EXIT_MISMATCH
    654. 

  654. +  fi
    655. 

  655. +}
    656. 

  656. +
    657. 

  657. +
    658. 

  658. +# Shorthand for --mode=foo, only valid as the first argument
    659. 

  659. +case $1 in
    660. 

  660. +clean|clea|cle|cl)
    661. 

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

  662. +  ;;
    663. 

  663. +compile|compil|compi|comp|com|co|c)
    664. 

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

  665. +  ;;
    666. 

  666. +execute|execut|execu|exec|exe|ex|e)
    667. 

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

  668. +  ;;
    669. 

  669. +finish|finis|fini|fin|fi|f)
    670. 

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

  671. +  ;;
    672. 

  672. +install|instal|insta|inst|ins|in|i)
    673. 

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

  674. +  ;;
    675. 

  675. +link|lin|li|l)
    676. 

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

  677. +  ;;
    678. 

  678. +uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
    679. 

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

  680. +  ;;
    681. 

  681. +esac
    682. 

  682. +
    683. 

  683. +
    684. 

  684. +
    685. 

  685. +# Option defaults:
    686. 

  686. +opt_debug=:
    687. 

  687. +opt_dry_run=false
    688. 

  688. +opt_config=false
    689. 

  689. +opt_preserve_dup_deps=false
    690. 

  690. +opt_features=false
    691. 

  691. +opt_finish=false
    692. 

  692. +opt_help=false
    693. 

  693. +opt_help_all=false
    694. 

  694. +opt_silent=:
    695. 

  695. +opt_verbose=:
    696. 

  696. +opt_silent=false
    697. 

  697. +opt_verbose=false
    698. 

  698.  
    699. 

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

  700. -  case $1 in
    701. 

  701. -  clean|clea|cle|cl)
    702. 

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

  703. -    ;;
    704. 

  704. -  compile|compil|compi|comp|com|co|c)
    705. 

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

  706. -    ;;
    707. 

  707. -  execute|execut|execu|exec|exe|ex|e)
    708. 

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

  709. -    ;;
    710. 

  710. -  finish|finis|fini|fin|fi|f)
    711. 

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

  712. -    ;;
    713. 

  713. -  install|instal|insta|inst|ins|in|i)
    714. 

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

  715. -    ;;
    716. 

  716. -  link|lin|li|l)
    717. 

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

  718. -    ;;
    719. 

  719. -  uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
    720. 

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

  721. -    ;;
    722. 

  722. -  esac
    723. 

  723.  
    724. 

  724. -  # Parse non-mode specific arguments:
    725. 

  725. -  while test "$#" -gt 0; do
    726. 

  726. +# Parse options once, thoroughly.  This comes as soon as possible in the
    727. 

  727. +# script to make things like `--version' happen as quickly as we can.
    728. 

  728. +{
    729. 

  729. +  # this just eases exit handling
    730. 

  730. +  while test $# -gt 0; do
    731. 

  731.      opt="$1"
    732. 

  732.      shift
    733. 

  733. -
    734. 

  734.      case $opt in
    735. 

  735. -      --config)		func_config					;;
    736. 

  736. -
    737. 

  737. -      --debug)		preserve_args="$preserve_args $opt"
    738. 

  738. +      --debug|-x)	opt_debug='set -x'
    739. 

  739.  			func_echo "enabling shell trace mode"
    740. 

  740. -			opt_debug='set -x'
    741. 

  741.  			$opt_debug
    742. 

  742.  			;;
    743. 

  743. -
    744. 

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

  745. -			execute_dlfiles="$execute_dlfiles $1"
    746. 

  746. -			shift
    747. 

  747. +      --dry-run|--dryrun|-n)
    748. 

  748. +			opt_dry_run=:
    749. 

  749.  			;;
    750. 

  750. -
    751. 

  751. -      --dry-run | -n)	opt_dry_run=:					;;
    752. 

  752. -      --features)       func_features					;;
    753. 

  753. -      --finish)		mode="finish"					;;
    754. 

  754. -
    755. 

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

  756. -			case $1 in
    757. 

  757. -			  # Valid mode arguments:
    758. 

  758. -			  clean)	;;
    759. 

  759. -			  compile)	;;
    760. 

  760. -			  execute)	;;
    761. 

  761. -			  finish)	;;
    762. 

  762. -			  install)	;;
    763. 

  763. -			  link)		;;
    764. 

  764. -			  relink)	;;
    765. 

  765. -			  uninstall)	;;
    766. 

  766. -
    767. 

  767. -			  # Catch anything else as an error
    768. 

  768. -			  *) func_error "invalid argument for $opt"
    769. 

  769. -			     exit_cmd=exit
    770. 

  770. -			     break
    771. 

  771. -			     ;;
    772. 

  772. -		        esac
    773. 

  773. -
    774. 

  774. -			mode="$1"
    775. 

  775. +      --config)
    776. 

  776. +			opt_config=:
    777. 

  777. +func_config
    778. 

  778. +			;;
    779. 

  779. +      --dlopen|-dlopen)
    780. 

  780. +			optarg="$1"
    781. 

  781. +			opt_dlopen="${opt_dlopen+$opt_dlopen
    782. 

  782. +}$optarg"
    783. 

  783.  			shift
    784. 

  784.  			;;
    785. 

  785. -
    786. 

  786.        --preserve-dup-deps)
    787. 

  787. -			opt_duplicate_deps=:				;;
    788. 

  788. -
    789. 

  789. -      --quiet|--silent)	preserve_args="$preserve_args $opt"
    790. 

  790. -			opt_silent=:
    791. 

  791. +			opt_preserve_dup_deps=:
    792. 

  792.  			;;
    793. 

  793. -
    794. 

  794. -      --verbose| -v)	preserve_args="$preserve_args $opt"
    795. 

  795. +      --features)
    796. 

  796. +			opt_features=:
    797. 

  797. +func_features
    798. 

  798. +			;;
    799. 

  799. +      --finish)
    800. 

  800. +			opt_finish=:
    801. 

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

  802. +			;;
    803. 

  803. +      --help)
    804. 

  804. +			opt_help=:
    805. 

  805. +			;;
    806. 

  806. +      --help-all)
    807. 

  807. +			opt_help_all=:
    808. 

  808. +opt_help=': help-all'
    809. 

  809. +			;;
    810. 

  810. +      --mode)
    811. 

  811. +			test $# = 0 && func_missing_arg $opt && break
    812. 

  812. +			optarg="$1"
    813. 

  813. +			opt_mode="$optarg"
    814. 

  814. +case $optarg in
    815. 

  815. +  # Valid mode arguments:
    816. 

  816. +  clean|compile|execute|finish|install|link|relink|uninstall) ;;
    817. 

  817. +
    818. 

  818. +  # Catch anything else as an error
    819. 

  819. +  *) func_error "invalid argument for $opt"
    820. 

  820. +     exit_cmd=exit
    821. 

  821. +     break
    822. 

  822. +     ;;
    823. 

  823. +esac
    824. 

  824. +			shift
    825. 

  825. +			;;
    826. 

  826. +      --no-silent|--no-quiet)
    827. 

  827.  			opt_silent=false
    828. 

  828. +func_append preserve_args " $opt"
    829. 

  829.  			;;
    830. 

  830. -
    831. 

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

  832. -			preserve_args="$preserve_args $opt $1"
    833. 

  833. -			func_enable_tag "$1"	# tagname is set here
    834. 

  834. +      --no-verbose)
    835. 

  835. +			opt_verbose=false
    836. 

  836. +func_append preserve_args " $opt"
    837. 

  837. +			;;
    838. 

  838. +      --silent|--quiet)
    839. 

  839. +			opt_silent=:
    840. 

  840. +func_append preserve_args " $opt"
    841. 

  841. +        opt_verbose=false
    842. 

  842. +			;;
    843. 

  843. +      --verbose|-v)
    844. 

  844. +			opt_verbose=:
    845. 

  845. +func_append preserve_args " $opt"
    846. 

  846. +opt_silent=false
    847. 

  847. +			;;
    848. 

  848. +      --tag)
    849. 

  849. +			test $# = 0 && func_missing_arg $opt && break
    850. 

  850. +			optarg="$1"
    851. 

  851. +			opt_tag="$optarg"
    852. 

  852. +func_append preserve_args " $opt $optarg"
    853. 

  853. +func_enable_tag "$optarg"
    854. 

  854.  			shift
    855. 

  855.  			;;
    856. 

  856.  
    857. 

  857. +      -\?|-h)		func_usage				;;
    858. 

  858. +      --help)		func_help				;;
    859. 

  859. +      --version)	func_version				;;
    860. 

  860. +
    861. 

  861.        # Separate optargs to long options:
    862. 

  862. -      -dlopen=*|--mode=*|--tag=*)
    863. 

  863. -			func_opt_split "$opt"
    864. 

  864. -			set dummy "$func_opt_split_opt" "$func_opt_split_arg" ${1+"$@"}
    865. 

  865. +      --*=*)
    866. 

  866. +			func_split_long_opt "$opt"
    867. 

  867. +			set dummy "$func_split_long_opt_name" "$func_split_long_opt_arg" ${1+"$@"}
    868. 

  868.  			shift
    869. 

  869.  			;;
    870. 

  870.  
    871. 

  871. -      -\?|-h)		func_usage					;;
    872. 

  872. -      --help)		opt_help=:					;;
    873. 

  873. -      --version)	func_version					;;
    874. 

  874. -
    875. 

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

  876. -
    877. 

  877. -      *)		nonopt="$opt"
    878. 

  878. -			break
    879. 

  879. +      # Separate non-argument short options:
    880. 

  880. +      -\?*|-h*|-n*|-v*)
    881. 

  881. +			func_split_short_opt "$opt"
    882. 

  882. +			set dummy "$func_split_short_opt_name" "-$func_split_short_opt_arg" ${1+"$@"}
    883. 

  883. +			shift
    884. 

  884.  			;;
    885. 

  885. +
    886. 

  886. +      --)		break					;;
    887. 

  887. +      -*)		func_fatal_help "unrecognized option \`$opt'" ;;
    888. 

  888. +      *)		set dummy "$opt" ${1+"$@"};	shift; break  ;;
    889. 

  889.      esac
    890. 

  890.    done
    891. 

  891.  
    892. 

  892. +  # Validate options:
    893. 

  893. +
    894. 

  894. +  # save first non-option argument
    895. 

  895. +  if test "$#" -gt 0; then
    896. 

  896. +    nonopt="$opt"
    897. 

  897. +    shift
    898. 

  898. +  fi
    899. 

  899. +
    900. 

  900. +  # preserve --debug
    901. 

  901. +  test "$opt_debug" = : || func_append preserve_args " --debug"
    902. 

  902.  
    903. 

  903.    case $host in
    904. 

  904.      *cygwin* | *mingw* | *pw32* | *cegcc*)
    905. 

  905. @@ -955,82 +1184,44 @@ func_enable_tag ()
    906. 

  906.        opt_duplicate_compiler_generated_deps=:
    907. 

  907.        ;;
    908. 

  908.      *)
    909. 

  909. -      opt_duplicate_compiler_generated_deps=$opt_duplicate_deps
    910. 

  910. +      opt_duplicate_compiler_generated_deps=$opt_preserve_dup_deps
    911. 

  911.        ;;
    912. 

  912.    esac
    913. 

  913.  
    914. 

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

  915. -  # anything was wrong.
    916. 

  916. -  $exit_cmd $EXIT_FAILURE
    917. 

  917. -}
    918. 

  918. +  $opt_help || {
    919. 

  919. +    # Sanity checks first:
    920. 

  920. +    func_check_version_match
    921. 

  921.  
    922. 

  922. -# func_check_version_match
    923. 

  923. -# Ensure that we are using m4 macros, and libtool script from the same
    924. 

  924. -# release of libtool.
    925. 

  925. -func_check_version_match ()
    926. 

  926. -{
    927. 

  927. -  if test "$package_revision" != "$macro_revision"; then
    928. 

  928. -    if test "$VERSION" != "$macro_version"; then
    929. 

  929. -      if test -z "$macro_version"; then
    930. 

  930. -        cat >&2 <<_LT_EOF
    931. 

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

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

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

  934. -$progname: and run autoconf again.
    935. 

  935. -_LT_EOF
    936. 

  936. -      else
    937. 

  937. -        cat >&2 <<_LT_EOF
    938. 

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

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

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

  941. -$progname: and run autoconf again.
    942. 

  942. -_LT_EOF
    943. 

  943. -      fi
    944. 

  944. -    else
    945. 

  945. -      cat >&2 <<_LT_EOF
    946. 

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

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

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

  949. -$progname: of $PACKAGE $VERSION and run autoconf again.
    950. 

  950. -_LT_EOF
    951. 

  951. +    if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
    952. 

  952. +      func_fatal_configuration "not configured to build any kind of library"
    953. 

  953.      fi
    954. 

  954.  
    955. 

  955. -    exit $EXIT_MISMATCH
    956. 

  956. -  fi
    957. 

  957. -}
    958. 

  958. -
    959. 

  959. +    # Darwin sucks
    960. 

  960. +    eval std_shrext=\"$shrext_cmds\"
    961. 

  961.  
    962. 

  962. -## ----------- ##
    963. 

  963. -##    Main.    ##
    964. 

  964. -## ----------- ##
    965. 

  965. -
    966. 

  966. -$opt_help || {
    967. 

  967. -  # Sanity checks first:
    968. 

  968. -  func_check_version_match
    969. 

  969. -
    970. 

  970. -  if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
    971. 

  971. -    func_fatal_configuration "not configured to build any kind of library"
    972. 

  972. -  fi
    973. 

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

  974. +    if test -n "$opt_dlopen" && test "$opt_mode" != execute; then
    975. 

  975. +      func_error "unrecognized option \`-dlopen'"
    976. 

  976. +      $ECHO "$help" 1>&2
    977. 

  977. +      exit $EXIT_FAILURE
    978. 

  978. +    fi
    979. 

  979.  
    980. 

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

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

  982. +    generic_help="$help"
    983. 

  983. +    help="Try \`$progname --help --mode=$opt_mode' for more information."
    984. 

  984. +  }
    985. 

  985.  
    986. 

  986.  
    987. 

  987. -  # Darwin sucks
    988. 

  988. -  eval std_shrext=\"$shrext_cmds\"
    989. 

  989. +  # Bail if the options were screwed
    990. 

  990. +  $exit_cmd $EXIT_FAILURE
    991. 

  991. +}
    992. 

  992.  
    993. 

  993.  
    994. 

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

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

  996. -    func_error "unrecognized option \`-dlopen'"
    997. 

  997. -    $ECHO "$help" 1>&2
    998. 

  998. -    exit $EXIT_FAILURE
    999. 

  999. -  fi
    1000. 

  1000.  
    1001. 

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

  1002. -  generic_help="$help"
    1003. 

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

  1004. -}
    1005. 

  1005.  
    1006. 

  1006. +## ----------- ##
    1007. 

  1007. +##    Main.    ##
    1008. 

  1008. +## ----------- ##
    1009. 

  1009.  
    1010. 

  1010.  # func_lalib_p file
    1011. 

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

  1012. @@ -1095,12 +1286,9 @@ func_ltwrapper_executable_p ()
    1013. 

  1013.  # temporary ltwrapper_script.
    1014. 

  1014.  func_ltwrapper_scriptname ()
    1015. 

  1015.  {
    1016. 

  1016. -    func_ltwrapper_scriptname_result=""
    1017. 

  1017. -    if func_ltwrapper_executable_p "$1"; then
    1018. 

  1018. -	func_dirname_and_basename "$1" "" "."
    1019. 

  1019. -	func_stripname '' '.exe' "$func_basename_result"
    1020. 

  1020. -	func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper"
    1021. 

  1021. -    fi
    1022. 

  1022. +    func_dirname_and_basename "$1" "" "."
    1023. 

  1023. +    func_stripname '' '.exe' "$func_basename_result"
    1024. 

  1024. +    func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper"
    1025. 

  1025.  }
    1026. 

  1026.  
    1027. 

  1027.  # func_ltwrapper_p file
    1028. 

  1028. @@ -1146,6 +1334,37 @@ func_source ()
    1029. 

  1029.  }
    1030. 

  1030.  
    1031. 

  1031.  
    1032. 

  1032. +# func_resolve_sysroot PATH
    1033. 

  1033. +# Replace a leading = in PATH with a sysroot.  Store the result into
    1034. 

  1034. +# func_resolve_sysroot_result
    1035. 

  1035. +func_resolve_sysroot ()
    1036. 

  1036. +{
    1037. 

  1037. +  func_resolve_sysroot_result=$1
    1038. 

  1038. +  case $func_resolve_sysroot_result in
    1039. 

  1039. +  =*)
    1040. 

  1040. +    func_stripname '=' '' "$func_resolve_sysroot_result"
    1041. 

  1041. +    func_resolve_sysroot_result=$lt_sysroot$func_stripname_result
    1042. 

  1042. +    ;;
    1043. 

  1043. +  esac
    1044. 

  1044. +}
    1045. 

  1045. +
    1046. 

  1046. +# func_replace_sysroot PATH
    1047. 

  1047. +# If PATH begins with the sysroot, replace it with = and
    1048. 

  1048. +# store the result into func_replace_sysroot_result.
    1049. 

  1049. +func_replace_sysroot ()
    1050. 

  1050. +{
    1051. 

  1051. +  case "$lt_sysroot:$1" in
    1052. 

  1052. +  ?*:"$lt_sysroot"*)
    1053. 

  1053. +    func_stripname "$lt_sysroot" '' "$1"
    1054. 

  1054. +    func_replace_sysroot_result="=$func_stripname_result"
    1055. 

  1055. +    ;;
    1056. 

  1056. +  *)
    1057. 

  1057. +    # Including no sysroot.
    1058. 

  1058. +    func_replace_sysroot_result=$1
    1059. 

  1059. +    ;;
    1060. 

  1060. +  esac
    1061. 

  1061. +}
    1062. 

  1062. +
    1063. 

  1063.  # func_infer_tag arg
    1064. 

  1064.  # Infer tagged configuration to use if any are available and
    1065. 

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

  1066. @@ -1158,13 +1377,15 @@ func_infer_tag ()
    1067. 

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

  1068.        CC_quoted=
    1069. 

  1069.        for arg in $CC; do
    1070. 

  1070. -        func_quote_for_eval "$arg"
    1071. 

  1071. -	CC_quoted="$CC_quoted $func_quote_for_eval_result"
    1072. 

  1072. +	func_append_quoted CC_quoted "$arg"
    1073. 

  1073.        done
    1074. 

  1074. +      CC_expanded=`func_echo_all $CC`
    1075. 

  1075. +      CC_quoted_expanded=`func_echo_all $CC_quoted`
    1076. 

  1076.        case $@ in
    1077. 

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

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

  1079. -      " $CC "* | "$CC "* | " `$ECHO $CC` "* | "`$ECHO $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$ECHO $CC_quoted` "* | "`$ECHO $CC_quoted` "*) ;;
    1080. 

  1080. +      " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
    1081. 

  1081. +      " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) ;;
    1082. 

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

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

  1084.        *)
    1085. 

  1085. @@ -1175,11 +1396,13 @@ func_infer_tag ()
    1086. 

  1086.  	    CC_quoted=
    1087. 

  1087.  	    for arg in $CC; do
    1088. 

  1088.  	      # Double-quote args containing other shell metacharacters.
    1089. 

  1089. -	      func_quote_for_eval "$arg"
    1090. 

  1090. -	      CC_quoted="$CC_quoted $func_quote_for_eval_result"
    1091. 

  1091. +	      func_append_quoted CC_quoted "$arg"
    1092. 

  1092.  	    done
    1093. 

  1093. +	    CC_expanded=`func_echo_all $CC`
    1094. 

  1094. +	    CC_quoted_expanded=`func_echo_all $CC_quoted`
    1095. 

  1095.  	    case "$@ " in
    1096. 

  1096. -	      " $CC "* | "$CC "* | " `$ECHO $CC` "* | "`$ECHO $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$ECHO $CC_quoted` "* | "`$ECHO $CC_quoted` "*)
    1097. 

  1097. +	    " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
    1098. 

  1098. +	    " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*)
    1099. 

  1099.  	      # The compiler in the base compile command matches
    1100. 

  1100.  	      # the one in the tagged configuration.
    1101. 

  1101.  	      # Assume this is the tagged configuration we want.
    1102. 

  1102. @@ -1242,6 +1465,486 @@ EOF
    1103. 

  1103.      }
    1104. 

  1104.  }
    1105. 

  1105.  
    1106. 

  1106. +
    1107. 

  1107. +##################################################
    1108. 

  1108. +# FILE NAME AND PATH CONVERSION HELPER FUNCTIONS #
    1109. 

  1109. +##################################################
    1110. 

  1110. +
    1111. 

  1111. +# func_convert_core_file_wine_to_w32 ARG
    1112. 

  1112. +# Helper function used by file name conversion functions when $build is *nix,
    1113. 

  1113. +# and $host is mingw, cygwin, or some other w32 environment. Relies on a
    1114. 

  1114. +# correctly configured wine environment available, with the winepath program
    1115. 

  1115. +# in $build's $PATH.
    1116. 

  1116. +#
    1117. 

  1117. +# ARG is the $build file name to be converted to w32 format.
    1118. 

  1118. +# Result is available in $func_convert_core_file_wine_to_w32_result, and will
    1119. 

  1119. +# be empty on error (or when ARG is empty)
    1120. 

  1120. +func_convert_core_file_wine_to_w32 ()
    1121. 

  1121. +{
    1122. 

  1122. +  $opt_debug
    1123. 

  1123. +  func_convert_core_file_wine_to_w32_result="$1"
    1124. 

  1124. +  if test -n "$1"; then
    1125. 

  1125. +    # Unfortunately, winepath does not exit with a non-zero error code, so we
    1126. 

  1126. +    # are forced to check the contents of stdout. On the other hand, if the
    1127. 

  1127. +    # command is not found, the shell will set an exit code of 127 and print
    1128. 

  1128. +    # *an error message* to stdout. So we must check for both error code of
    1129. 

  1129. +    # zero AND non-empty stdout, which explains the odd construction:
    1130. 

  1130. +    func_convert_core_file_wine_to_w32_tmp=`winepath -w "$1" 2>/dev/null`
    1131. 

  1131. +    if test "$?" -eq 0 && test -n "${func_convert_core_file_wine_to_w32_tmp}"; then
    1132. 

  1132. +      func_convert_core_file_wine_to_w32_result=`$ECHO "$func_convert_core_file_wine_to_w32_tmp" |
    1133. 

  1133. +        $SED -e "$lt_sed_naive_backslashify"`
    1134. 

  1134. +    else
    1135. 

  1135. +      func_convert_core_file_wine_to_w32_result=
    1136. 

  1136. +    fi
    1137. 

  1137. +  fi
    1138. 

  1138. +}
    1139. 

  1139. +# end: func_convert_core_file_wine_to_w32
    1140. 

  1140. +
    1141. 

  1141. +
    1142. 

  1142. +# func_convert_core_path_wine_to_w32 ARG
    1143. 

  1143. +# Helper function used by path conversion functions when $build is *nix, and
    1144. 

  1144. +# $host is mingw, cygwin, or some other w32 environment. Relies on a correctly
    1145. 

  1145. +# configured wine environment available, with the winepath program in $build's
    1146. 

  1146. +# $PATH. Assumes ARG has no leading or trailing path separator characters.
    1147. 

  1147. +#
    1148. 

  1148. +# ARG is path to be converted from $build format to win32.
    1149. 

  1149. +# Result is available in $func_convert_core_path_wine_to_w32_result.
    1150. 

  1150. +# Unconvertible file (directory) names in ARG are skipped; if no directory names
    1151. 

  1151. +# are convertible, then the result may be empty.
    1152. 

  1152. +func_convert_core_path_wine_to_w32 ()
    1153. 

  1153. +{
    1154. 

  1154. +  $opt_debug
    1155. 

  1155. +  # unfortunately, winepath doesn't convert paths, only file names
    1156. 

  1156. +  func_convert_core_path_wine_to_w32_result=""
    1157. 

  1157. +  if test -n "$1"; then
    1158. 

  1158. +    oldIFS=$IFS
    1159. 

  1159. +    IFS=:
    1160. 

  1160. +    for func_convert_core_path_wine_to_w32_f in $1; do
    1161. 

  1161. +      IFS=$oldIFS
    1162. 

  1162. +      func_convert_core_file_wine_to_w32 "$func_convert_core_path_wine_to_w32_f"
    1163. 

  1163. +      if test -n "$func_convert_core_file_wine_to_w32_result" ; then
    1164. 

  1164. +        if test -z "$func_convert_core_path_wine_to_w32_result"; then
    1165. 

  1165. +          func_convert_core_path_wine_to_w32_result="$func_convert_core_file_wine_to_w32_result"
    1166. 

  1166. +        else
    1167. 

  1167. +          func_append func_convert_core_path_wine_to_w32_result ";$func_convert_core_file_wine_to_w32_result"
    1168. 

  1168. +        fi
    1169. 

  1169. +      fi
    1170. 

  1170. +    done
    1171. 

  1171. +    IFS=$oldIFS
    1172. 

  1172. +  fi
    1173. 

  1173. +}
    1174. 

  1174. +# end: func_convert_core_path_wine_to_w32
    1175. 

  1175. +
    1176. 

  1176. +
    1177. 

  1177. +# func_cygpath ARGS...
    1178. 

  1178. +# Wrapper around calling the cygpath program via LT_CYGPATH. This is used when
    1179. 

  1179. +# when (1) $build is *nix and Cygwin is hosted via a wine environment; or (2)
    1180. 

  1180. +# $build is MSYS and $host is Cygwin, or (3) $build is Cygwin. In case (1) or
    1181. 

  1181. +# (2), returns the Cygwin file name or path in func_cygpath_result (input
    1182. 

  1182. +# file name or path is assumed to be in w32 format, as previously converted
    1183. 

  1183. +# from $build's *nix or MSYS format). In case (3), returns the w32 file name
    1184. 

  1184. +# or path in func_cygpath_result (input file name or path is assumed to be in
    1185. 

  1185. +# Cygwin format). Returns an empty string on error.
    1186. 

  1186. +#
    1187. 

  1187. +# ARGS are passed to cygpath, with the last one being the file name or path to
    1188. 

  1188. +# be converted.
    1189. 

  1189. +#
    1190. 

  1190. +# Specify the absolute *nix (or w32) name to cygpath in the LT_CYGPATH
    1191. 

  1191. +# environment variable; do not put it in $PATH.
    1192. 

  1192. +func_cygpath ()
    1193. 

  1193. +{
    1194. 

  1194. +  $opt_debug
    1195. 

  1195. +  if test -n "$LT_CYGPATH" && test -f "$LT_CYGPATH"; then
    1196. 

  1196. +    func_cygpath_result=`$LT_CYGPATH "$@" 2>/dev/null`
    1197. 

  1197. +    if test "$?" -ne 0; then
    1198. 

  1198. +      # on failure, ensure result is empty
    1199. 

  1199. +      func_cygpath_result=
    1200. 

  1200. +    fi
    1201. 

  1201. +  else
    1202. 

  1202. +    func_cygpath_result=
    1203. 

  1203. +    func_error "LT_CYGPATH is empty or specifies non-existent file: \`$LT_CYGPATH'"
    1204. 

  1204. +  fi
    1205. 

  1205. +}
    1206. 

  1206. +#end: func_cygpath
    1207. 

  1207. +
    1208. 

  1208. +
    1209. 

  1209. +# func_convert_core_msys_to_w32 ARG
    1210. 

  1210. +# Convert file name or path ARG from MSYS format to w32 format.  Return
    1211. 

  1211. +# result in func_convert_core_msys_to_w32_result.
    1212. 

  1212. +func_convert_core_msys_to_w32 ()
    1213. 

  1213. +{
    1214. 

  1214. +  $opt_debug
    1215. 

  1215. +  # awkward: cmd appends spaces to result
    1216. 

  1216. +  func_convert_core_msys_to_w32_result=`( cmd //c echo "$1" ) 2>/dev/null |
    1217. 

  1217. +    $SED -e 's/[ ]*$//' -e "$lt_sed_naive_backslashify"`
    1218. 

  1218. +}
    1219. 

  1219. +#end: func_convert_core_msys_to_w32
    1220. 

  1220. +
    1221. 

  1221. +
    1222. 

  1222. +# func_convert_file_check ARG1 ARG2
    1223. 

  1223. +# Verify that ARG1 (a file name in $build format) was converted to $host
    1224. 

  1224. +# format in ARG2. Otherwise, emit an error message, but continue (resetting
    1225. 

  1225. +# func_to_host_file_result to ARG1).
    1226. 

  1226. +func_convert_file_check ()
    1227. 

  1227. +{
    1228. 

  1228. +  $opt_debug
    1229. 

  1229. +  if test -z "$2" && test -n "$1" ; then
    1230. 

  1230. +    func_error "Could not determine host file name corresponding to"
    1231. 

  1231. +    func_error "  \`$1'"
    1232. 

  1232. +    func_error "Continuing, but uninstalled executables may not work."
    1233. 

  1233. +    # Fallback:
    1234. 

  1234. +    func_to_host_file_result="$1"
    1235. 

  1235. +  fi
    1236. 

  1236. +}
    1237. 

  1237. +# end func_convert_file_check
    1238. 

  1238. +
    1239. 

  1239. +
    1240. 

  1240. +# func_convert_path_check FROM_PATHSEP TO_PATHSEP FROM_PATH TO_PATH
    1241. 

  1241. +# Verify that FROM_PATH (a path in $build format) was converted to $host
    1242. 

  1242. +# format in TO_PATH. Otherwise, emit an error message, but continue, resetting
    1243. 

  1243. +# func_to_host_file_result to a simplistic fallback value (see below).
    1244. 

  1244. +func_convert_path_check ()
    1245. 

  1245. +{
    1246. 

  1246. +  $opt_debug
    1247. 

  1247. +  if test -z "$4" && test -n "$3"; then
    1248. 

  1248. +    func_error "Could not determine the host path corresponding to"
    1249. 

  1249. +    func_error "  \`$3'"
    1250. 

  1250. +    func_error "Continuing, but uninstalled executables may not work."
    1251. 

  1251. +    # Fallback.  This is a deliberately simplistic "conversion" and
    1252. 

  1252. +    # should not be "improved".  See libtool.info.
    1253. 

  1253. +    if test "x$1" != "x$2"; then
    1254. 

  1254. +      lt_replace_pathsep_chars="s|$1|$2|g"
    1255. 

  1255. +      func_to_host_path_result=`echo "$3" |
    1256. 

  1256. +        $SED -e "$lt_replace_pathsep_chars"`
    1257. 

  1257. +    else
    1258. 

  1258. +      func_to_host_path_result="$3"
    1259. 

  1259. +    fi
    1260. 

  1260. +  fi
    1261. 

  1261. +}
    1262. 

  1262. +# end func_convert_path_check
    1263. 

  1263. +
    1264. 

  1264. +
    1265. 

  1265. +# func_convert_path_front_back_pathsep FRONTPAT BACKPAT REPL ORIG
    1266. 

  1266. +# Modifies func_to_host_path_result by prepending REPL if ORIG matches FRONTPAT
    1267. 

  1267. +# and appending REPL if ORIG matches BACKPAT.
    1268. 

  1268. +func_convert_path_front_back_pathsep ()
    1269. 

  1269. +{
    1270. 

  1270. +  $opt_debug
    1271. 

  1271. +  case $4 in
    1272. 

  1272. +  $1 ) func_to_host_path_result="$3$func_to_host_path_result"
    1273. 

  1273. +    ;;
    1274. 

  1274. +  esac
    1275. 

  1275. +  case $4 in
    1276. 

  1276. +  $2 ) func_append func_to_host_path_result "$3"
    1277. 

  1277. +    ;;
    1278. 

  1278. +  esac
    1279. 

  1279. +}
    1280. 

  1280. +# end func_convert_path_front_back_pathsep
    1281. 

  1281. +
    1282. 

  1282. +
    1283. 

  1283. +##################################################
    1284. 

  1284. +# $build to $host FILE NAME CONVERSION FUNCTIONS #
    1285. 

  1285. +##################################################
    1286. 

  1286. +# invoked via `$to_host_file_cmd ARG'
    1287. 

  1287. +#
    1288. 

  1288. +# In each case, ARG is the path to be converted from $build to $host format.
    1289. 

  1289. +# Result will be available in $func_to_host_file_result.
    1290. 

  1290. +
    1291. 

  1291. +
    1292. 

  1292. +# func_to_host_file ARG
    1293. 

  1293. +# Converts the file name ARG from $build format to $host format. Return result
    1294. 

  1294. +# in func_to_host_file_result.
    1295. 

  1295. +func_to_host_file ()
    1296. 

  1296. +{
    1297. 

  1297. +  $opt_debug
    1298. 

  1298. +  $to_host_file_cmd "$1"
    1299. 

  1299. +}
    1300. 

  1300. +# end func_to_host_file
    1301. 

  1301. +
    1302. 

  1302. +
    1303. 

  1303. +# func_to_tool_file ARG LAZY
    1304. 

  1304. +# converts the file name ARG from $build format to toolchain format. Return
    1305. 

  1305. +# result in func_to_tool_file_result.  If the conversion in use is listed
    1306. 

  1306. +# in (the comma separated) LAZY, no conversion takes place.
    1307. 

  1307. +func_to_tool_file ()
    1308. 

  1308. +{
    1309. 

  1309. +  $opt_debug
    1310. 

  1310. +  case ,$2, in
    1311. 

  1311. +    *,"$to_tool_file_cmd",*)
    1312. 

  1312. +      func_to_tool_file_result=$1
    1313. 

  1313. +      ;;
    1314. 

  1314. +    *)
    1315. 

  1315. +      $to_tool_file_cmd "$1"
    1316. 

  1316. +      func_to_tool_file_result=$func_to_host_file_result
    1317. 

  1317. +      ;;
    1318. 

  1318. +  esac
    1319. 

  1319. +}
    1320. 

  1320. +# end func_to_tool_file
    1321. 

  1321. +
    1322. 

  1322. +
    1323. 

  1323. +# func_convert_file_noop ARG
    1324. 

  1324. +# Copy ARG to func_to_host_file_result.
    1325. 

  1325. +func_convert_file_noop ()
    1326. 

  1326. +{
    1327. 

  1327. +  func_to_host_file_result="$1"
    1328. 

  1328. +}
    1329. 

  1329. +# end func_convert_file_noop
    1330. 

  1330. +
    1331. 

  1331. +
    1332. 

  1332. +# func_convert_file_msys_to_w32 ARG
    1333. 

  1333. +# Convert file name ARG from (mingw) MSYS to (mingw) w32 format; automatic
    1334. 

  1334. +# conversion to w32 is not available inside the cwrapper.  Returns result in
    1335. 

  1335. +# func_to_host_file_result.
    1336. 

  1336. +func_convert_file_msys_to_w32 ()
    1337. 

  1337. +{
    1338. 

  1338. +  $opt_debug
    1339. 

  1339. +  func_to_host_file_result="$1"
    1340. 

  1340. +  if test -n "$1"; then
    1341. 

  1341. +    func_convert_core_msys_to_w32 "$1"
    1342. 

  1342. +    func_to_host_file_result="$func_convert_core_msys_to_w32_result"
    1343. 

  1343. +  fi
    1344. 

  1344. +  func_convert_file_check "$1" "$func_to_host_file_result"
    1345. 

  1345. +}
    1346. 

  1346. +# end func_convert_file_msys_to_w32
    1347. 

  1347. +
    1348. 

  1348. +
    1349. 

  1349. +# func_convert_file_cygwin_to_w32 ARG
    1350. 

  1350. +# Convert file name ARG from Cygwin to w32 format.  Returns result in
    1351. 

  1351. +# func_to_host_file_result.
    1352. 

  1352. +func_convert_file_cygwin_to_w32 ()
    1353. 

  1353. +{
    1354. 

  1354. +  $opt_debug
    1355. 

  1355. +  func_to_host_file_result="$1"
    1356. 

  1356. +  if test -n "$1"; then
    1357. 

  1357. +    # because $build is cygwin, we call "the" cygpath in $PATH; no need to use
    1358. 

  1358. +    # LT_CYGPATH in this case.
    1359. 

  1359. +    func_to_host_file_result=`cygpath -m "$1"`
    1360. 

  1360. +  fi
    1361. 

  1361. +  func_convert_file_check "$1" "$func_to_host_file_result"
    1362. 

  1362. +}
    1363. 

  1363. +# end func_convert_file_cygwin_to_w32
    1364. 

  1364. +
    1365. 

  1365. +
    1366. 

  1366. +# func_convert_file_nix_to_w32 ARG
    1367. 

  1367. +# Convert file name ARG from *nix to w32 format.  Requires a wine environment
    1368. 

  1368. +# and a working winepath. Returns result in func_to_host_file_result.
    1369. 

  1369. +func_convert_file_nix_to_w32 ()
    1370. 

  1370. +{
    1371. 

  1371. +  $opt_debug
    1372. 

  1372. +  func_to_host_file_result="$1"
    1373. 

  1373. +  if test -n "$1"; then
    1374. 

  1374. +    func_convert_core_file_wine_to_w32 "$1"
    1375. 

  1375. +    func_to_host_file_result="$func_convert_core_file_wine_to_w32_result"
    1376. 

  1376. +  fi
    1377. 

  1377. +  func_convert_file_check "$1" "$func_to_host_file_result"
    1378. 

  1378. +}
    1379. 

  1379. +# end func_convert_file_nix_to_w32
    1380. 

  1380. +
    1381. 

  1381. +
    1382. 

  1382. +# func_convert_file_msys_to_cygwin ARG
    1383. 

  1383. +# Convert file name ARG from MSYS to Cygwin format.  Requires LT_CYGPATH set.
    1384. 

  1384. +# Returns result in func_to_host_file_result.
    1385. 

  1385. +func_convert_file_msys_to_cygwin ()
    1386. 

  1386. +{
    1387. 

  1387. +  $opt_debug
    1388. 

  1388. +  func_to_host_file_result="$1"
    1389. 

  1389. +  if test -n "$1"; then
    1390. 

  1390. +    func_convert_core_msys_to_w32 "$1"
    1391. 

  1391. +    func_cygpath -u "$func_convert_core_msys_to_w32_result"
    1392. 

  1392. +    func_to_host_file_result="$func_cygpath_result"
    1393. 

  1393. +  fi
    1394. 

  1394. +  func_convert_file_check "$1" "$func_to_host_file_result"
    1395. 

  1395. +}
    1396. 

  1396. +# end func_convert_file_msys_to_cygwin
    1397. 

  1397. +
    1398. 

  1398. +
    1399. 

  1399. +# func_convert_file_nix_to_cygwin ARG
    1400. 

  1400. +# Convert file name ARG from *nix to Cygwin format.  Requires Cygwin installed
    1401. 

  1401. +# in a wine environment, working winepath, and LT_CYGPATH set.  Returns result
    1402. 

  1402. +# in func_to_host_file_result.
    1403. 

  1403. +func_convert_file_nix_to_cygwin ()
    1404. 

  1404. +{
    1405. 

  1405. +  $opt_debug
    1406. 

  1406. +  func_to_host_file_result="$1"
    1407. 

  1407. +  if test -n "$1"; then
    1408. 

  1408. +    # convert from *nix to w32, then use cygpath to convert from w32 to cygwin.
    1409. 

  1409. +    func_convert_core_file_wine_to_w32 "$1"
    1410. 

  1410. +    func_cygpath -u "$func_convert_core_file_wine_to_w32_result"
    1411. 

  1411. +    func_to_host_file_result="$func_cygpath_result"
    1412. 

  1412. +  fi
    1413. 

  1413. +  func_convert_file_check "$1" "$func_to_host_file_result"
    1414. 

  1414. +}
    1415. 

  1415. +# end func_convert_file_nix_to_cygwin
    1416. 

  1416. +
    1417. 

  1417. +
    1418. 

  1418. +#############################################
    1419. 

  1419. +# $build to $host PATH CONVERSION FUNCTIONS #
    1420. 

  1420. +#############################################
    1421. 

  1421. +# invoked via `$to_host_path_cmd ARG'
    1422. 

  1422. +#
    1423. 

  1423. +# In each case, ARG is the path to be converted from $build to $host format.
    1424. 

  1424. +# The result will be available in $func_to_host_path_result.
    1425. 

  1425. +#
    1426. 

  1426. +# Path separators are also converted from $build format to $host format.  If
    1427. 

  1427. +# ARG begins or ends with a path separator character, it is preserved (but
    1428. 

  1428. +# converted to $host format) on output.
    1429. 

  1429. +#
    1430. 

  1430. +# All path conversion functions are named using the following convention:
    1431. 

  1431. +#   file name conversion function    : func_convert_file_X_to_Y ()
    1432. 

  1432. +#   path conversion function         : func_convert_path_X_to_Y ()
    1433. 

  1433. +# where, for any given $build/$host combination the 'X_to_Y' value is the
    1434. 

  1434. +# same.  If conversion functions are added for new $build/$host combinations,
    1435. 

  1435. +# the two new functions must follow this pattern, or func_init_to_host_path_cmd
    1436. 

  1436. +# will break.
    1437. 

  1437. +
    1438. 

  1438. +
    1439. 

  1439. +# func_init_to_host_path_cmd
    1440. 

  1440. +# Ensures that function "pointer" variable $to_host_path_cmd is set to the
    1441. 

  1441. +# appropriate value, based on the value of $to_host_file_cmd.
    1442. 

  1442. +to_host_path_cmd=
    1443. 

  1443. +func_init_to_host_path_cmd ()
    1444. 

  1444. +{
    1445. 

  1445. +  $opt_debug
    1446. 

  1446. +  if test -z "$to_host_path_cmd"; then
    1447. 

  1447. +    func_stripname 'func_convert_file_' '' "$to_host_file_cmd"
    1448. 

  1448. +    to_host_path_cmd="func_convert_path_${func_stripname_result}"
    1449. 

  1449. +  fi
    1450. 

  1450. +}
    1451. 

  1451. +
    1452. 

  1452. +
    1453. 

  1453. +# func_to_host_path ARG
    1454. 

  1454. +# Converts the path ARG from $build format to $host format. Return result
    1455. 

  1455. +# in func_to_host_path_result.
    1456. 

  1456. +func_to_host_path ()
    1457. 

  1457. +{
    1458. 

  1458. +  $opt_debug
    1459. 

  1459. +  func_init_to_host_path_cmd
    1460. 

  1460. +  $to_host_path_cmd "$1"
    1461. 

  1461. +}
    1462. 

  1462. +# end func_to_host_path
    1463. 

  1463. +
    1464. 

  1464. +
    1465. 

  1465. +# func_convert_path_noop ARG
    1466. 

  1466. +# Copy ARG to func_to_host_path_result.
    1467. 

  1467. +func_convert_path_noop ()
    1468. 

  1468. +{
    1469. 

  1469. +  func_to_host_path_result="$1"
    1470. 

  1470. +}
    1471. 

  1471. +# end func_convert_path_noop
    1472. 

  1472. +
    1473. 

  1473. +
    1474. 

  1474. +# func_convert_path_msys_to_w32 ARG
    1475. 

  1475. +# Convert path ARG from (mingw) MSYS to (mingw) w32 format; automatic
    1476. 

  1476. +# conversion to w32 is not available inside the cwrapper.  Returns result in
    1477. 

  1477. +# func_to_host_path_result.
    1478. 

  1478. +func_convert_path_msys_to_w32 ()
    1479. 

  1479. +{
    1480. 

  1480. +  $opt_debug
    1481. 

  1481. +  func_to_host_path_result="$1"
    1482. 

  1482. +  if test -n "$1"; then
    1483. 

  1483. +    # Remove leading and trailing path separator characters from ARG.  MSYS
    1484. 

  1484. +    # behavior is inconsistent here; cygpath turns them into '.;' and ';.';
    1485. 

  1485. +    # and winepath ignores them completely.
    1486. 

  1486. +    func_stripname : : "$1"
    1487. 

  1487. +    func_to_host_path_tmp1=$func_stripname_result
    1488. 

  1488. +    func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
    1489. 

  1489. +    func_to_host_path_result="$func_convert_core_msys_to_w32_result"
    1490. 

  1490. +    func_convert_path_check : ";" \
    1491. 

  1491. +      "$func_to_host_path_tmp1" "$func_to_host_path_result"
    1492. 

  1492. +    func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
    1493. 

  1493. +  fi
    1494. 

  1494. +}
    1495. 

  1495. +# end func_convert_path_msys_to_w32
    1496. 

  1496. +
    1497. 

  1497. +
    1498. 

  1498. +# func_convert_path_cygwin_to_w32 ARG
    1499. 

  1499. +# Convert path ARG from Cygwin to w32 format.  Returns result in
    1500. 

  1500. +# func_to_host_file_result.
    1501. 

  1501. +func_convert_path_cygwin_to_w32 ()
    1502. 

  1502. +{
    1503. 

  1503. +  $opt_debug
    1504. 

  1504. +  func_to_host_path_result="$1"
    1505. 

  1505. +  if test -n "$1"; then
    1506. 

  1506. +    # See func_convert_path_msys_to_w32:
    1507. 

  1507. +    func_stripname : : "$1"
    1508. 

  1508. +    func_to_host_path_tmp1=$func_stripname_result
    1509. 

  1509. +    func_to_host_path_result=`cygpath -m -p "$func_to_host_path_tmp1"`
    1510. 

  1510. +    func_convert_path_check : ";" \
    1511. 

  1511. +      "$func_to_host_path_tmp1" "$func_to_host_path_result"
    1512. 

  1512. +    func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
    1513. 

  1513. +  fi
    1514. 

  1514. +}
    1515. 

  1515. +# end func_convert_path_cygwin_to_w32
    1516. 

  1516. +
    1517. 

  1517. +
    1518. 

  1518. +# func_convert_path_nix_to_w32 ARG
    1519. 

  1519. +# Convert path ARG from *nix to w32 format.  Requires a wine environment and
    1520. 

  1520. +# a working winepath.  Returns result in func_to_host_file_result.
    1521. 

  1521. +func_convert_path_nix_to_w32 ()
    1522. 

  1522. +{
    1523. 

  1523. +  $opt_debug
    1524. 

  1524. +  func_to_host_path_result="$1"
    1525. 

  1525. +  if test -n "$1"; then
    1526. 

  1526. +    # See func_convert_path_msys_to_w32:
    1527. 

  1527. +    func_stripname : : "$1"
    1528. 

  1528. +    func_to_host_path_tmp1=$func_stripname_result
    1529. 

  1529. +    func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
    1530. 

  1530. +    func_to_host_path_result="$func_convert_core_path_wine_to_w32_result"
    1531. 

  1531. +    func_convert_path_check : ";" \
    1532. 

  1532. +      "$func_to_host_path_tmp1" "$func_to_host_path_result"
    1533. 

  1533. +    func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
    1534. 

  1534. +  fi
    1535. 

  1535. +}
    1536. 

  1536. +# end func_convert_path_nix_to_w32
    1537. 

  1537. +
    1538. 

  1538. +
    1539. 

  1539. +# func_convert_path_msys_to_cygwin ARG
    1540. 

  1540. +# Convert path ARG from MSYS to Cygwin format.  Requires LT_CYGPATH set.
    1541. 

  1541. +# Returns result in func_to_host_file_result.
    1542. 

  1542. +func_convert_path_msys_to_cygwin ()
    1543. 

  1543. +{
    1544. 

  1544. +  $opt_debug
    1545. 

  1545. +  func_to_host_path_result="$1"
    1546. 

  1546. +  if test -n "$1"; then
    1547. 

  1547. +    # See func_convert_path_msys_to_w32:
    1548. 

  1548. +    func_stripname : : "$1"
    1549. 

  1549. +    func_to_host_path_tmp1=$func_stripname_result
    1550. 

  1550. +    func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
    1551. 

  1551. +    func_cygpath -u -p "$func_convert_core_msys_to_w32_result"
    1552. 

  1552. +    func_to_host_path_result="$func_cygpath_result"
    1553. 

  1553. +    func_convert_path_check : : \
    1554. 

  1554. +      "$func_to_host_path_tmp1" "$func_to_host_path_result"
    1555. 

  1555. +    func_convert_path_front_back_pathsep ":*" "*:" : "$1"
    1556. 

  1556. +  fi
    1557. 

  1557. +}
    1558. 

  1558. +# end func_convert_path_msys_to_cygwin
    1559. 

  1559. +
    1560. 

  1560. +
    1561. 

  1561. +# func_convert_path_nix_to_cygwin ARG
    1562. 

  1562. +# Convert path ARG from *nix to Cygwin format.  Requires Cygwin installed in a
    1563. 

  1563. +# a wine environment, working winepath, and LT_CYGPATH set.  Returns result in
    1564. 

  1564. +# func_to_host_file_result.
    1565. 

  1565. +func_convert_path_nix_to_cygwin ()
    1566. 

  1566. +{
    1567. 

  1567. +  $opt_debug
    1568. 

  1568. +  func_to_host_path_result="$1"
    1569. 

  1569. +  if test -n "$1"; then
    1570. 

  1570. +    # Remove leading and trailing path separator characters from
    1571. 

  1571. +    # ARG. msys beha
    1572.