wx-config.in

   1 #!/bin/sh
   2 #
   3 # Name:        wx-config{.in,}
   4 # Purpose:     wx configuration search and query tool {template,}
   5 # Author:      Ron <ron@debian.org>
   6 # Modified by:
   7 # Created:     8/9/2004
   8 # RCS-ID:      $Id$
   9 # Copyright:   (c) 2004 Ron <ron@debian.org>
  10 #              Essentially a fresh start this time around, but for maximum
  11 #              compatibility basic code was taken from, and heavy reference
  12 #              made to, the previously unattributed wx-config from cvs.
  13 #              All the usual suspects contributed to the dicussion that led
  14 #              to this new work and likewise to the ideas and content in the
  15 #              original (which was probably influenced by gtk), among them:
  16 #              Robert Roebling, Vadim Zeitlin, Vaclav Slavik, Robin Dunn
  17 # Licence:     wxWindows licence
  18 ############################################################################
  19
  20 # Extra^2 debug mode, for if things ever get really weird.
  21 [ -z "$WXDEBUG_X" ] || set -x
  22
  23 # We expect a posix shell, so if this is a Bourne shell,
  24 # and apparently a few still exist, try for bash or ksh.
  25
  26 if [ ~ = '~' ]
  27 then
  28     if (bash -c echo) >/dev/null 2>&1
  29     then
  30         exec bash "$0" "$@"
  31     fi
  32     if (ksh -c echo) >/dev/null 2>&1
  33     then
  34         exec ksh "$0" "$@"
  35     fi
  36     echo "$0: this script requires bash or ksh"
  37     exit 1
  38 fi
  39
  40
  41 # On with some basic stuff, like the ability to die gracefully,
  42 # and to tell people what we are about.
  43 # ------------------------------------------------------------------
  44
  45 # decho _message
  46 # Output a message to stderr.
  47 decho() { echo "$*" 1>&2; }
  48
  49 # usage _exitcode
  50 # Outputs a usage message to stderr and exits with _exitcode.
  51 # Try to keep this to a single page (ie. < 25 lines).  We can add
  52 # alternate or interactive help targets if people want more detail.
  53 #
  54 # Exit codes are now subject to a more strict interpretation.
  55 # wx-config should return 0 upon successful operation, 1 if the
  56 # reqested operation could not be completed successfully, and 2
  57 # if the requested operation is not supported by this version of
  58 # wx-config.
  59 usage()
  60 {
  61     cat 1>&2 <<EOF
  62
  63  wx-config [--prefix[=DIR]] [--exec-prefix[=DIR]] [--release] [--version-full]
  64            [--list] [--host=HOST] [--toolkit=TOOLKIT] [--universal[=yes|no]]
  65            [--unicode[=yes|no]] [--debug[=yes|no]] [--static[=yes|no]]
  66            [--version[=VERSION]] [--basename] [--cc] [--cppflags] [--cflags]
  67            [--cxxflags] [--rezflags] [--libs] [--cxx] [--ld] [--linkdeps]
  68            [--utility=UTIL] [LIB ...]
  69
  70    wx-config returns  information about  the wxWidgets libraries available
  71    on your system.  It may be used to retrieve the information you require
  72    to build applications using these libraries.
  73
  74     If alternative builds of wxWidgets exist on the system, you can use the
  75   options:  --prefix,  --host,  --toolkit,  --unicode,  --debug,  --static,
  76   --version and --universal, to select from them.  Use the --list option to
  77   show alternatives available which match specified criteria.   The unicode,
  78   debug, and universal options  take an  optional yes or no  argument, while
  79   host and version  accept posix extended regex.   The --utility option will
  80   return the correct version of UTIL to use with the selected library build.
  81   --linkdeps returns only static libraries for your makefile link rule deps.
  82
  83     Optional LIB arguments (comma or space separated) may be used to specify
  84   the wxWidgets libraries that  you wish  to use.  The magic "std" label may
  85   be used to import all libraries that would be used by default if none were
  86   specified explicitly.  eg. wx-config --libs core,base.
  87
  88 EOF
  89
  90     exit $1
  91 }
  92
  93 # Unfussy people are the easiest to deal with, get them out of the way now.
  94 [ $# -gt 0 ] || usage 1
  95
  96
  97 # Contentious tools determined by configure.
  98 EGREP="@EGREP@"
  99
 100
 101 # For the people who know what they want, or think they do:
 102 # Divide the valid arguments into functional groups for later examination,
 103 # then parse all command line arguments completely, deferring action on
 104 # output options until all significant input has been processed and any
 105 # decision about delegation has been taken.
 106
 107 # Note early, that '-' is a complete no-no for use in option names below.
 108 # It totally falls apart as soon as it becomes part of a variable name.
 109 # Use '_' instead, and by the magic of it all just being bits, you'll
 110 # be able to use --my-option or --my_option from the command line at
 111 # your discretion.  They are synonymous as user input, but _ALWAYS_ use
 112 # underscores for compound names in the code here, never a dash.
 113
 114
 115 # The list of all options we recognise.  If it is not in here, then
 116 # it is not something we want to handle.
 117 # ------------------------------------------------------------------
 118
 119 # Options that specify a distinct library build.
 120 #
 121 # Note also that order in this list is significant later on, as this sets
 122 # the precedence with which we will try to gauge the similarity of other
 123 # configs to this one.  Options earlier in the list should be more crucial
 124 # to match well than those that follow.  Options specified by the user will
 125 # always take precedence and are not subject to any partial ordering here.
 126 wxconfig_schema="host toolkit widgetset chartype debugtype flavour version linkage"
 127
 128 # Options that are expected to generate some output.
 129 wxconfig_output_options="prefix exec_prefix
 130                          list
 131                          release version version_full
 132                          basename
 133                          cppflags cflags cxxflags
 134                          rezflags
 135                          libs
 136                          linkdeps
 137                          cc cxx ld
 138                          gl_libs"
 139
 140 # Options that permit the user to supply hints that may affect the output.
 141 # These options all accept arbitrary values, to interpret as they please.
 142 wxconfig_input_options="prefix exec_prefix utility $wxconfig_schema"
 143
 144 # Input options that accept only a yes or no argument.
 145 wxconfig_yesno_options="universal unicode debug static"
 146
 147 # Boolean options that do something or not.
 148 wxconfig_flag_options="$wxconfig_yesno_options selected_config no_rpath inplace"
 149
 150
 151
 152 # Some simple sugar coating to keep things more readable below.
 153 # --------------------------------------------------------------
 154
 155 # option_name _string
 156 # Returns NAME if _string is of the form: --NAME[=...]
 157 option_name()
 158 {
 159     _option_name_temp=${1%%=*}
 160     echo ${_option_name_temp#--} | tr '-' '_'
 161 }
 162
 163 # option_value _string
 164 # Returns FOO if _string is of the form: --option=FOO
 165 option_value()
 166 {
 167     echo "${1#*=}"
 168 }
 169
 170 # match_field _value _list
 171 # Returns true if _value is a field in _list
 172 match_field()
 173 {
 174     _match_field_match="$1"
 175     shift
 176     for _match_field_i; do
 177         [ "x$_match_field_i" != "x$_match_field_match" ] || return 0
 178     done
 179     false
 180 }
 181
 182 # remove_field _value _list
 183 # Returns _list minus any field(s) that match _value.
 184 remove_field()
 185 {
 186     _remf_value="$1"
 187     _remf_list=''
 188     shift
 189     if [ -n "$_remf_value" ]; then
 190         for _remf_item; do
 191             [ "x$_remf_item" = "x$_remf_value" ] ||
 192                 _remf_list="${_remf_list:+$_remf_list }$_remf_item"
 193         done
 194         echo "$_remf_list"
 195     else
 196         echo $*
 197     fi
 198 }
 199
 200 # validate_arg _domain _set _name _value
 201 # Boilerplate to validate an argument and initialise a psuedo-hash.
 202 # This one is almost reduction into absurdity, and perhaps makes the
 203 # precise action of the argument parser below just a little more
 204 # obscure, but oh so neat and compact to use for multiple option
 205 # groups.  It expands to replace repetitive clauses of the form:
 206 #
 207 #        i="$(option_name $arg)"
 208 #        if match_field "$i" $wxconfig_input_options; then
 209 #            input_options="${input_options:+$input_options }$i"
 210 #            eval "input_option_$i=$(option_value $arg)"
 211 #            continue
 212 #        fi
 213 #
 214 # with the one liners you see on the page below.
 215 validate_arg()
 216 {
 217     if match_field "$3" $(eval echo \"\$$1_$2_options\"); then
 218         eval "$2_options=\"\${$2_options:+\$$2_options }$3\""
 219         eval "$2_option_$3=\"$4\""
 220         return
 221     fi
 222     false
 223 }
 224
 225 # check_yesno_option _ynoption _option _yesval _noval
 226 # This one might be made more generic and/or incorporated into
 227 # validate_arg above at some later stage, but right now we just
 228 # condition any specialist options into a generic one for later
 229 # handling.  Once they are sanity checked there is no difference
 230 # in any case.
 231 check_yesno_option()
 232 {
 233     eval "case \${yesno_option_$1-\${flag_option_$1-unset}} in
 234             unset)                          ;;
 235             y*|Y*)  input_option_$2=\"$3\"  ;;
 236             n*|N*)  input_option_$2=\"$4\"  ;;
 237             *)
 238                 decho
 239                 decho \" *** Error: Invalid request '--$1=\$yesno_option_$1'\"
 240                 decho \" Valid arguments for --$1 are: [ yes, no ]\"
 241                 decho
 242                 exit 1
 243                 ;;
 244          esac"
 245 }
 246
 247
 248
 249 # Now we are ready to find out what the user wants from us.
 250 # --------------------------------------------------------------
 251
 252 # With just a little more complexity here we could have shortest
 253 # unique string matching for options, but that is probably overkill
 254 # today, so lets just get the job done.
 255 #
 256 # The important thing now then is that we simply read all input from
 257 # the user and don't try to act prematurely on partial information.
 258 # --help or an illegal argument are the only shortcuts out of here
 259 # at this point, otherwise, it's time to just shut up and listen for
 260 # a moment.
 261
 262 for arg; do
 263   case "$arg" in
 264     --help|-h)
 265         usage
 266         ;;
 267
 268     --*=*)
 269         _name=$(option_name $arg)
 270         _value=$(option_value $arg)
 271         if validate_arg wxconfig input "$_name" "$_value" ||
 272            validate_arg wxconfig yesno "$_name" "$_value"
 273         then
 274             continue
 275         fi
 276         ;;
 277
 278     --*)
 279         _name=$(option_name $arg)
 280         if validate_arg wxconfig flag   "$_name" yes ||
 281            validate_arg wxconfig output "$_name" yes
 282         then
 283             continue
 284         fi
 285         ;;
 286
 287     *)
 288         # FIXME Surely we can validate the parameters too ...
 289         input_parameters="${input_parameters:+$input_parameters }$arg"
 290         continue
 291         ;;
 292   esac
 293   decho "  *** Error: Unrecognised option: '$arg'"
 294   decho "Use wx-config --help for information on command line options."
 295   exit 2
 296 done
 297
 298 # validate_arg only checks and decomposes form.  Sanity check the yes/no
 299 # options now too and push their respective mask values into place.
 300
 301 check_yesno_option universal widgetset univ
 302 check_yesno_option unicode chartype unicode ansi
 303 check_yesno_option debug debugtype debug release
 304 check_yesno_option static linkage '-static'
 305
 306
 307 # Dump everything we just read in debug mode.
 308 if [ -n "$WXDEBUG" ]; then
 309
 310     decho
 311     decho "  input parameters  = $input_parameters"
 312     decho "  input options     = $input_options"
 313     for i in $input_options; do
 314         decho "    $i = $(eval echo \"\$input_option_$i\")"
 315     done
 316     decho "  yes/no options    = $yesno_options"
 317     for y in $yesno_options; do
 318         decho "    $y = $(eval echo \"\$yesno_option_$y\")"
 319     done
 320     decho "  flag options      = $flag_options"
 321     for f in $flag_options; do
 322         decho "    $f = $(eval echo \"\$flag_option_$f\")"
 323     done
 324     decho "  output options    = $output_options"
 325     for o in $output_options; do
 326         decho "    $o = $(eval echo \"\$output_option_$o\")"
 327     done
 328
 329 fi
 330
 331
 332
 333 # Everything came in as a legal argument then, lets put some of
 334 # the pieces together with a little self knowledge to see what
 335 # we should do next.
 336 # --------------------------------------------------------------
 337
 338 # get_mask [ _hash ]
 339 # Construct a config filename mask from a psuedo-hash of component variables.
 340 # The optional argument is the prefix of the hash to use.  If not specified
 341 # this will return a mask derived from the command line options that were used.
 342 get_mask()
 343 {
 344     [ $# -gt 0 ] || set m
 345     eval echo "\${$1_host}\${$1_toolkit}\${$1_widgetset}-\${$1_chartype}-\${$1_debugtype}\${$1_linkage}-\${$1_version}\${$1_flavour}"
 346 }
 347
 348 # Returns true if this script is for a cross compiled config.
 349 is_cross()  { [ "x@cross_compiling@" = "xyes" ]; }
 350
 351
 352 # Determine the base directories we require.
 353 prefix=${input_option_prefix-${this_prefix:-@prefix@}}
 354 exec_prefix=${input_option_exec_prefix-${input_option_prefix-${this_exec_prefix:-@exec_prefix@}}}
 355 wxconfdir="@libdir@/wx/config"
 356
 357 installed_configs=$( cd "$wxconfdir" 2> /dev/null && ls | grep -v "^inplace-" )
 358
 359 is_cross && target="@host_alias@"
 360
 361 # Define a pseudo-hash to contain the specification of this wx-config
 362 # instance and its associated library.
 363 this_host="${target:+${target}-}"
 364 this_toolkit="@TOOLKIT_DIR@@TOOLKIT_VERSION@"
 365 this_widgetset="@WIDGET_SET@"
 366 this_chartype="@WX_CHARTYPE@"
 367 this_debugtype="@WX_DEBUGTYPE@"
 368 this_flavour="@WX_FLAVOUR@"
 369 this_version="@WX_RELEASE@"
 370 this_linkage=$( [ "x@SHARED@" = "x1" ] || echo '-static' )
 371
 372 this_config=$(get_mask this)
 373
 374 # Extract the user specification from the options parsed.
 375 m_host=${input_option_host:+${input_option_host}-?}
 376 m_host=${m_host:-${input_option_host-$this_host}}
 377 m_toolkit=${input_option_toolkit:-[^-]+}
 378 m_widgetset=${input_option_widgetset-(univ)?}
 379 m_chartype=${input_option_chartype:-(unicode|ansi)}
 380 m_debugtype=${input_option_debugtype:-(debug|release)}
 381 m_flavour=${input_option_flavour:+-$input_option_flavour}
 382 m_flavour=${m_flavour:-${input_option_flavour-(-[^-]+)?}}
 383 m_version=${input_option_version:-[0-9]+\.[0-9]+}
 384 m_linkage=${input_option_linkage-(-static)?}
 385
 386 configmask="^$(get_mask)$"
 387
 388
 389 # Dump the user specification in debug mode.
 390 if [ -n "$WXDEBUG" ]; then
 391
 392     decho
 393     decho "  prefix       = '$prefix'"
 394     decho "  exec_prefix  = '$exec_prefix'"
 395     decho "  wxconfdir    = '$wxconfdir'"
 396
 397     decho "  m_host       = '$m_host'"
 398     decho "  m_toolkit    = '$m_toolkit'"
 399     decho "  m_widgetset  = '$m_widgetset'"
 400     decho "  m_chartype   = '$m_chartype'"
 401     decho "  m_debugtype  = '$m_debugtype'"
 402     decho "  m_flavour    = '$m_flavour'"
 403     decho "  m_version    = '$m_version'"
 404     decho "  m_linkage    = '$m_linkage'"
 405
 406     decho "  configmask   = '$configmask'"
 407     decho "  this config  = '$this_config'"
 408     decho
 409
 410 fi
 411
 412
 413
 414 # From here on, we'll need to be able to figure out a delegation target.
 415 # -----------------------------------------------------------------------
 416
 417 # The rules for delegation are:
 418 #
 419 # 1. If the specification is so general that it matches the default config
 420 #    (ie. this one on a first pass), then the default config will be used
 421 #    even if other installed libs would also match the spec.
 422 #
 423 # 2. If the default config does not match, find a list of all installed
 424 #    libraries that do match.
 425 #       a. If that list is empty, the specification is incompatible
 426 #          with any installed lib.  Warn and abort.
 427 #       b. If that list contains exactly one candidate.  Delegate to
 428 #          that candidate.
 429 #       c. If the list contains multiple candidates, pass on to step 3.
 430 #
 431 # 3. Attempt to discriminate among rival candidates by their similarity
 432 #    to the default configuration (ie. this one).  If we can find a unique
 433 #    candidate in this way, delegate to it.  If not, present a list of
 434 #    options to the user and request that they disambiguate it with one or
 435 #    more additional fields.
 436 #
 437 #    To refine the specified pattern, we specialise each unbound field
 438 #    using the default value from this config file.  If that results in
 439 #    no matches, we unbind it again and try the next field.  If it still
 440 #    results in multiple matches we try binding the next field as well
 441 #    until a unique or null result again occurs.
 442 #
 443 # A more general way to look at this, is the feature specifiers are all
 444 # modifiers of the wx-config you are calling.  If you supply none, the
 445 # default for that build configuration will be used.  If you supply one
 446 # or more that the default build cannot satisfy, it will try to find the
 447 # config most like itself with the desired feature(s) enabled.
 448 # The features configured into the first wx-config called will be taken
 449 # as implicitly specified if it is necessary to disambiguate likely
 450 # candidates from the information that was explicitly provided.
 451
 452
 453 # But first, more sugar to keep what follows clear and legible.
 454 # --------------------------------------------------------------
 455
 456 # find_eligible_delegates _mask
 457 # Outputs all the config files installed which match the
 458 # (extended regex) _mask passed as an argument.
 459 find_eligible_delegates() { echo "$installed_configs" | $EGREP "$1" 2> /dev/null; }
 460
 461 # user_mask_fits _config
 462 # Returns true if the string _config satisfies the user specified mask.
 463 user_mask_fits()          { echo "$1" | $EGREP "$configmask" > /dev/null 2>&1; }
 464
 465 # count_fields _word
 466 # Returns the number of IFS split fields in _word
 467 count_fields()      { return $#; }
 468
 469 # count_delegates _mask
 470 # Return the number of eligible config files that match _mask
 471 count_delegates()   { count_fields $(find_eligible_delegates $1); }
 472
 473 # is_set _variablename
 474 # Returns true if $_variablename is initialised.
 475 is_set()            { [ "x$(eval echo \"\${$1-unset}\")" != "xunset" ]; }
 476
 477 # do_find_best_delegate _unbound-options
 478 # The real worker part of find_best_delegate below.  Recurses though all
 479 # unbound options binding them one at a time to the default derived from
 480 # this file until a unique match is made or no alternatives remain that
 481 # may be sensibly guessed at.  It will preferentially bind the unspecified
 482 # options in the order they are listed in wxconfig_schema.  Using this
 483 # partial ordering it should find the first match with the most significant
 484 # similarity to this file that unambiguously meets the user specification.
 485 # If such a match exists it will be output to stdout.
 486 #
 487 # Be careful if you modify this function.  If the pruning logic is rendered
 488 # inoperative it will simply recurse over every permutation in the search
 489 # space, which may still appear to work, but add a couple more options (or
 490 # explicitly specify a few less) and you may not live long enough to learn
 491 # the result.  WXDEBUG=findprogress is your friend here, it will show you
 492 # how many nodes get searched before a result.  If you start seeing
 493 # increases in that number for the same input, check your work.
 494 # Raising the number of discriminating options from 6 to 8 raised the worst
 495 # case time for this to run (without pruning) from 3 to nearly 15 seconds
 496 # and its downhill fast from here if we have to ride that boat.
 497 # Early pruning still gets that down to under half a second (up from about
 498 # .25), so we have some breathing space yet before a different search method
 499 # will be called for, but lets not squander it.
 500 do_find_best_delegate()
 501 {
 502   (
 503     if [ "x$WXDEBUG" = "xverbose" ]; then
 504         _fbd_indent="${_fbd_indent}. "
 505         decho "  $_fbd_indent---> unbound options: $*"
 506     fi
 507
 508     for i; do
 509
 510         if [ "x$WXDEBUG" = "xverbose" ]; then
 511             decho "  ${_fbd_indent}binding '$i' with '$(remove_field $i $*)' still free"
 512             [ -z "$_pruned" ] || decho "  ${_fbd_indent}  --- pruned: $_pruned ---"
 513         fi
 514
 515         if (
 516             eval m_$i=\$this_$i
 517             _mask="^$(get_mask)$"
 518
 519             if [ "x$WXDEBUG" = "xverbose" ]; then
 520                 decho "  ${_fbd_indent}  checking: $_mask"
 521                 count_delegates "$_mask"
 522                 decho "  $_fbd_indent  $? eligible delegates"
 523                 for d in $(find_eligible_delegates "$_mask"); do
 524                     decho "  ${_fbd_indent}    $d"
 525                 done
 526             fi
 527
 528             count_delegates "$_mask"
 529             _still_eligible=$?
 530
 531             if [ $_still_eligible -eq 1 ]; then
 532                 echo $(find_eligible_delegates "$_mask")
 533                 return
 534             fi
 535
 536             [ "x$WXDEBUG" != "xfindprogress" ] || printf "." 1>&2
 537
 538             [ $_still_eligible -gt 1 ] && [ $# -gt 1 ] &&
 539                 do_find_best_delegate $(remove_field $i $*)
 540            )
 541         then
 542
 543             return
 544
 545         elif [ $# -gt 1 ]; then
 546
 547             if [ "x$WXDEBUG" = "xverbose" ]; then
 548                 decho "  ${_fbd_indent}pruning: $i"
 549                 _pruned="${_pruned:+$_pruned }$i"
 550             fi
 551             set $(remove_field $i $*)
 552
 553         fi
 554
 555     done
 556     false
 557   )
 558 }
 559
 560 # find_best_delegate
 561 # A simple wrapper around do_find_best_delegate that first determines
 562 # the unbound options (ie. the ones that the user did not explicitly
 563 # declare a preference for on the command line)
 564 find_best_delegate()
 565 {
 566     for _fbdi in $wxconfig_schema; do
 567         is_set input_option_$_fbdi ||
 568             _unbound_options="${_unbound_options:+$_unbound_options }$_fbdi"
 569     done
 570     do_find_best_delegate $_unbound_options
 571 }
 572
 573
 574 # Legacy wx-config helpers.
 575 # -------------------------
 576
 577 # get_legacy_mask
 578 # Returns a mask in the format used by wx2.4.
 579 get_legacy_mask()
 580 {
 581     [ $# -gt 0 ] || set m
 582     eval [ "x\${$1_chartype}" != "xunicode" ] || _unicode_flag=u
 583     eval [ "x\${$1_debugtype}" != "xdebug" ] || _debug_flag=d
 584     eval echo "wx\${$1_toolkit}${_unicode_flag}${_debug_flag}-\${$1_version}\${$1_host}-config"
 585 }
 586
 587 # find_legacy_configs
 588 # Returns a list of configs installed by wx2.4 releases.
 589 find_legacy_configs()
 590 {
 591   (
 592     cd "$prefix/bin" &&
 593       {
 594         ls wx*-2.4-config | grep -v ^wxbase
 595         ls wx*-2.4-config | grep ^wxbase
 596       }
 597   ) 2> /dev/null
 598 }
 599
 600 # find_best_legacy_config
 601 # Returns the best legacy config for a given specification.
 602 # This assumes no matching new style config has been found.
 603 find_best_legacy_config()
 604 {
 605     _legacy_configs=$(find_legacy_configs)
 606     if [ -n "$_legacy_configs" ]; then
 607         _legacy_mask=$(get_legacy_mask)
 608         for d in $_legacy_configs; do
 609             if echo $d | $EGREP $_legacy_mask > /dev/null 2>&1 ; then
 610                 echo "$d"
 611                 return
 612             fi
 613         done
 614     fi
 615     false
 616 }
 617
 618
 619
 620 # The only action we can perform authoritatively prior to delegation
 621 # is to list all the possible delegates.
 622 # --------------------------------------------------------------
 623
 624 config_spec="$0 $*"
 625 [ -z "$WXDEBUG" ] || config_spec=$configmask
 626
 627 # Next chance for another satisfied customer then
 628 #
 629 # If we want to get really polished here we can do plural checking,
 630 # but we should probably leave that until the day we gettextise it.
 631 if [ -n "$output_option_list" ]; then
 632
 633     _remains_in_prefix=$installed_configs
 634     _delegates=$(find_eligible_delegates $configmask)
 635     _best_delegate=$(find_best_delegate)
 636
 637     if [ "x$WXDEBUG" = "xverbose" ]; then
 638         decho
 639         decho " all      = $_remains_in_prefix"
 640         decho " matching = $_delegates"
 641         decho " best     = $_best_delegate"
 642         decho " this     = $this_config"
 643     fi
 644
 645     for d in $_delegates; do
 646         _remains_in_prefix=$(remove_field $d $_remains_in_prefix)
 647     done
 648
 649     echo
 650     echo "    Default config is $this_config"
 651     echo
 652
 653     if user_mask_fits "$this_config" ; then
 654
 655         echo "  Default config ${this_exec_prefix+in $this_exec_prefix }will be used for output"
 656
 657         if match_field "$this_config" $_delegates ; then
 658             _delegates=$(remove_field $this_config $_delegates)
 659         else
 660             echo "  though it is not installed in: $prefix"
 661             if [ -n "$_best_delegate" ] && [ "x$_best_delegate" != "x$this_config" ]; then
 662                 echo
 663                 echo "  Best alternate in $prefix:"
 664                 echo "    $_best_delegate"
 665             fi
 666         fi
 667
 668     elif [ -n "$_best_delegate" ]; then
 669
 670         echo "  Specification best match: $_best_delegate"
 671
 672     elif [ -z "$_delegates" ]; then
 673
 674         _last_chance=$(find_best_legacy_config)
 675         if [ -n "$_last_chance" ]; then
 676
 677             echo "  Specification matches legacy config: $_last_chance"
 678
 679         else
 680
 681             cat <<-EOF
 682           No config found to match: $config_spec
 683           in $wxconfdir
 684
 685           Please install the desired library build, or specify a different
 686           prefix where it may be found.  If the library is not installed
 687           you may call its wx-config directly by specifying its full path.
 688
 689         EOF
 690
 691         fi
 692
 693     else
 694         echo " Specification was ambiguous.  Use additional feature options"
 695         echo " to choose between alternate matches."
 696     fi
 697
 698     _delegates=$(remove_field "$_best_delegate" $_delegates)
 699
 700     if [ -n "$_delegates" ]; then
 701         echo
 702         echo "  Alternate matches:"
 703         for d in $_delegates; do
 704             echo "    $d"
 705         done
 706     fi
 707     if [ -n "$_remains_in_prefix" ]; then
 708         echo
 709         echo "  Also available in $prefix:"
 710         for d in $_remains_in_prefix; do
 711             echo "    $d"
 712         done
 713     fi
 714
 715     _legacy_configs=$(find_legacy_configs)
 716     if [ -n "$_legacy_configs" ]; then
 717         echo
 718         echo "  Legacy configs available in $prefix:"
 719         for d in $_legacy_configs; do
 720             echo "    ${d%-config}"
 721         done
 722     fi
 723
 724     echo
 725     exit
 726 fi
 727
 728
 729
 730 # ... so if that wasn't what they wanted, then we need to know for
 731 # certain, can this config satisfy the user specification?
 732 # --------------------------------------------------------------
 733
 734 if ! user_mask_fits "$this_config" ; then
 735
 736     # No?  Then lets see if it knows anybody who can.
 737     # But first, just be sure someone hasn't typo'd us into a loop.
 738     # In present day wx, correct delegation should never need more
 739     # than one hop so this is trivial to detect.
 740
 741     if [ -n "$WXCONFIG_DELEGATED" ]; then
 742         decho
 743         decho " *** Error: Bad config delegation"
 744         decho
 745         decho " to: $0"
 746         decho " ($this_config) cannot satisfy:"
 747         decho " $config_spec"
 748         decho " Someone has been terribly careless."
 749         decho
 750         exit 1
 751     fi
 752
 753     count_delegates "$configmask"
 754     _numdelegates=$?
 755
 756     if [ -n "$WXDEBUG" ]; then
 757         decho "  must delegate to an alternate config"
 758         decho "  potential delegates ($_numdelegates):"
 759         for i in $(find_eligible_delegates "$configmask"); do
 760             decho "    $i"
 761         done
 762     fi
 763
 764     if [ $_numdelegates -eq 0 ]; then
 765
 766         _last_chance=$(find_best_legacy_config)
 767         if [ -n "$_last_chance" ]; then
 768
 769             for arg; do
 770                 case "$arg" in
 771                     --prefix*|--exec-prefix*|               \
 772                     --version|--release|--basename|         \
 773                     --static|--libs|--gl_libs|              \
 774                     --cppflags|--cflags|--cxxflags|         \
 775                     --cc|--cxx|--ld|                        \
 776                     --rezflags|--inplace)
 777                         _legacy_args="$_legacy_args $arg"
 778                         ;;
 779
 780                     --static|--static=y*|--static=Y*)
 781                         _legacy_args="$_legacy_args --static"
 782                         ;;
 783                 esac
 784             done
 785
 786             if [ -n "$WXDEBUG" ]; then
 787                 decho "  found a suitable legacy delegate: $_last_chance"
 788                 decho "--> $prefix/bin/$_last_chance $_legacy_args"
 789             fi
 790
 791             export WXCONFIG_DELEGATED=yes
 792             $prefix/bin/$_last_chance $_legacy_args
 793             exit
 794
 795         else
 796
 797             cat 1>&2 <<-EOF
 798
 799           Warning: No config found to match: $config_spec
 800                    in $wxconfdir
 801           If you require this configuration, please install the desired
 802           library build.  If this is part of an automated configuration
 803           test and no other errors occur, you may safely ignore it.
 804           You may use wx-config --list to see all configs available in
 805           the default prefix.
 806
 807         EOF
 808
 809             # PIPEDREAM: from here we are actually just a teensy step
 810             # from simply building the missing config for the user
 811             # on the fly if this is an in tree wx-config.
 812
 813             exit 1
 814         fi
 815     fi
 816
 817     if [ $_numdelegates -gt 1 ]; then
 818
 819         [ -z "$WXDEBUG" ] || decho "  must prune the list of eligible delegates"
 820
 821         best_delegate=$(find_best_delegate)
 822
 823         if [ -n "$best_delegate" ]; then
 824
 825             if [ -n "$WXDEBUG" ]; then
 826                 decho "  found a suitable delegate: $best_delegate"
 827                 decho "--> $wxconfdir/$best_delegate $*"
 828             fi
 829
 830             export WXCONFIG_DELEGATED=yes
 831             $wxconfdir/$best_delegate $*
 832             exit
 833         fi
 834
 835         decho
 836         decho " *** Error: Specification is ambiguous"
 837         decho "            as $config_spec"
 838         decho " Use additional feature options to choose between:"
 839         for i in $(find_eligible_delegates "$configmask"); do
 840             decho "  $i"
 841         done
 842         decho
 843
 844         exit 1
 845     fi
 846
 847     if [ -n "$WXDEBUG" ]; then
 848         decho "  using the only suitable delegate"
 849         decho "--> $wxconfdir/$(find_eligible_delegates $configmask) $*"
 850     fi
 851
 852     export WXCONFIG_DELEGATED=yes
 853     $wxconfdir/$(find_eligible_delegates $configmask) $*
 854     exit
 855 fi
 856
 857
 858
 859 # If we are still here, then from now on we are responsible for
 860 # all the user's needs.  Time to rustle up some output for them.
 861 # --------------------------------------------------------------
 862
 863 [ -z "$WXDEBUG" ] || decho "  using this config"
 864
 865 # If the user supplied a prefix, and the in tree config did not
 866 # delegate out to anything in that prefix, then reset the build
 867 # tree prefix to provide the correct output for using this
 868 # uninstalled wx build.  Or put more simply:
 869 prefix=${this_prefix-$prefix}
 870 exec_prefix=${this_exec_prefix-$exec_prefix}
 871
 872 includedir="@includedir@"
 873 libdir="@libdir@"
 874 bindir="@bindir@"
 875
 876 # Trivial queries we can answer now.
 877 [ -z "$output_option_prefix"        ] || echo $prefix
 878 [ -z "$output_option_exec_prefix"   ] || echo $exec_prefix
 879 [ -z "$output_option_release"       ] || echo "@WX_RELEASE@"
 880 [ -z "$output_option_version"       ] || echo "@WX_VERSION@"
 881 [ -z "$output_option_version_full"  ] || echo "@WX_SUBVERSION@"
 882 [ -z "$output_option_basename"      ] || echo "@WX_LIBRARY_BASENAME_GUI@"
 883 [ -z "$output_option_rezflags"      ] || echo $(eval echo "@MACRESWXCONFIG@")
 884 [ -z "$output_option_cc"            ] || echo "@CC@"
 885 [ -z "$output_option_cxx"           ] || echo "@CXX@"
 886 [ -z "$output_option_ld"            ] || echo "@EXE_LINKER@"
 887 [ -z "$flag_option_selected_config" ] || echo "$this_config"
 888
 889
 890 # The rest are going to need a little more work.
 891 # --------------------------------------------------------------
 892
 893 is_monolithic() { [ "x@MONOLITHIC@" = "x1" ]; }
 894 is_static()     { [ -n "$this_linkage" ]; }
 895 is_installed()  { [ -z "$this_prefix" ]; }
 896
 897
 898 # Is the user after a support utility?
 899 # If this is a cross build, we need to find and return a suitable
 900 # native utility for the job, so we search:
 901 #
 902 #   1. local build dir (for native uninstalled builds only).
 903 #   2. (optional) user supplied prefix.
 904 #   3. configured install prefix.
 905 #   4. environment $PATH.
 906 #
 907 # and if such a thing still cannot be found, exit signalling an error.
 908 if [ -n "$input_option_utility" ]; then
 909
 910     # This is dumb, in tree binaries should be in a standard location
 911     # like the libs, but work with what we've got for now.
 912     is_cross || _util="$exec_prefix/utils/$input_option_utility/$input_option_utility"
 913
 914     if ! is_installed && [ -x "$_util" ]; then
 915         is_static || _preload="eval LD_LIBRARY_PATH=$exec_prefix/lib"
 916         echo $_preload $_util
 917         exit
 918     fi
 919
 920     IFS=':'
 921     _user_prefix=${input_option_exec_prefix:-$input_option_prefix}
 922
 923     for _util in "${input_option_utility}-@WX_RELEASE@@WX_FLAVOUR@" \
 924                  "${input_option_utility}-@WX_RELEASE@"             \
 925                  "${input_option_utility}"
 926     do
 927         for p in ${_user_prefix:+$_user_prefix/bin} $bindir $PATH; do
 928
 929             [ -z "$WXDEBUG" ] || decho "  checking for: '$p/$_util'"
 930
 931             if [ -x "$p/$_util" ]; then
 932                 echo "$p/$_util"
 933                 exit
 934             fi
 935
 936         done
 937     done
 938     exit 1
 939
 940 fi
 941
 942
 943 # Still here?  Then get the options together for building an app.
 944 # ----------------------------------------------------------------
 945
 946 # Additional configuration for individual library components.
 947 ldflags_gl="@LDFLAGS_GL@"
 948
 949 ldlibs_base="@WXCONFIG_EXTRALIBS@"
 950 ldlibs_core="@EXTRALIBS_GUI@"
 951 ldlibs_gl="@OPENGL_LIBS@"
 952 ldlibs_html="@EXTRALIBS_HTML@"
 953 ldlibs_xml="@EXTRALIBS_XML@"
 954 ldlibs_odbc="@EXTRALIBS_ODBC@"
 955 ldlibs_adv="@EXTRALIBS_SDL@"
 956
 957
 958 # lib_flags_for _liblist
 959 # This function returns a list of flags suitable to return with the
 960 # output of --libs for all of the libraries in _liblist.  You can
 961 # add support for a new library by adding an entry for it in the
 962 # psuedo-hashes above if it requires additional linker options.
 963 lib_flags_for()
 964 {
 965     [ -z "$WXDEBUG" ] || decho "  fetching lib flags for: '$*'"
 966
 967     _all_ldflags=''
 968     _all_libs=''
 969     _wxlibs=''
 970
 971     is_cross && _target="-${target}"
 972
 973     for lib; do
 974
 975         # We evidently can't trust people not to duplicate things in
 976         # configure, or to keep them in any sort of sane order overall,
 977         # so only add unique new fields here even if it takes us a while.
 978         # In the case of libs, we bubble any duplicates to the end,
 979         # because if multiple libs require it, static linking at least
 980         # will require it to come after all of them.  So long as local
 981         # order is ok in configure then we should always be able to
 982         # massage a correct result here like this.
 983         #
 984         # FIXME: ldlibs_core is totally bogus.  Fix the duplication
 985         # there independently of this.  This covers for it, but we
 986         # want to do this anyway because some libs may share common
 987         # deps without a common ancestor in wx.  This is not a licence
 988         # for sloppy work elsewhere though and @GUI_TK_LIBRARY should
 989         # be fixed.
 990
 991         for f in $(eval echo \"\$ldflags_$lib\"); do
 992             match_field "$f" $_all_ldflags || _all_ldflags="$_all_ldflags $f"
 993         done
 994
 995         if match_field "$lib" @CORE_BASE_LIBS@ ; then
 996             _libname="@WX_LIBRARY_BASENAME_NOGUI@"
 997         else
 998             _libname="@WX_LIBRARY_BASENAME_GUI@"
 999         fi
1000         [ $lib = base ] || _libname="${_libname}_$lib"
1001         _libname="${_libname}-@WX_RELEASE@$_target"
1002
1003         if is_static; then
1004             _wxlibs="$_wxlibs ${libdir}/lib${_libname}.a"
1005             for f in $(eval echo \"\$ldlibs_$lib\"); do
1006
1007                 # Only propagate duplicate -libraries to their latest
1008                 # possible position.  Do not eliminate any other
1009                 # duplicates that might occur.  They should be fixed
1010                 # in configure long before they get here.
1011                 # This started as a workaround for Mac -framework,
1012                 # but it seems like a better policy in general, which
1013                 # will let the more heinous bugs in configure shake out.
1014                 # We should maybe filter *.a here too, but not unless
1015                 # we have to.
1016                 case "$f" in
1017                   -l*)  _all_libs="$(remove_field $f $_all_libs) $f"    ;;
1018                     *)  _all_libs="$_all_libs $f"                       ;;
1019                 esac
1020
1021             done
1022         else
1023             _wxlibs="$_wxlibs -l${_libname}"
1024         fi
1025
1026     done
1027
1028     if [ -n "$WXDEBUG" ]; then
1029         decho "  retrieved: ldflags = $_all_ldflags"
1030         decho "             wxlibs  = $_wxlibs"
1031         decho "             alllibs = $_all_libs"
1032     fi
1033
1034     echo $_all_ldflags $_wxlibs $_all_libs
1035 }
1036
1037 # this is the strict subset of the above function which returns only the
1038 # (static) libraries themselves: this is used for linkdeps output which should
1039 # output the list of libraries the main program should depend on
1040 #
1041 # of course, this duplication is bad but I'll leave to somebody else the care
1042 # of refactoring this as I don't see any way to do it - VZ.
1043
1044 # This (and the other cruft to support it) should be removed with
1045 # reference to the FIXME above when configure stops piping us a slurry
1046 # of options that need to be decomposed again for most practical uses - RL.
1047 link_deps_for()
1048 {
1049     _wxlibs=''
1050
1051     is_cross && _target="-${target}"
1052
1053     for lib; do
1054         if match_field "$lib" @CORE_BASE_LIBS@ ; then
1055             _libname="@WX_LIBRARY_BASENAME_NOGUI@"
1056         else
1057             _libname="@WX_LIBRARY_BASENAME_GUI@"
1058         fi
1059         [ $lib = base ] || _libname="${_libname}_$lib"
1060         _libname="${_libname}-@WX_RELEASE@$_target"
1061
1062         _wxlibs="$_wxlibs ${libdir}/lib${_libname}.a"
1063     done
1064
1065     echo $_wxlibs
1066 }
1067
1068 # Sanity check the list of libs the user provided us, if any.
1069 # --------------------------------------------------------------
1070
1071 wx_libs=$(echo "$input_parameters" | tr ',' ' ')
1072
1073 [ -z "$WXDEBUG" ] || decho "  user supplied libs: '$wx_libs'"
1074
1075 if is_monolithic; then
1076
1077     # Core libs are already built into the blob.
1078     for i in std @CORE_GUI_LIBS@ @CORE_BASE_LIBS@; do
1079         wx_libs=$(remove_field $i $wx_libs)
1080     done
1081
1082     wx_libs="@WXCONFIG_LDFLAGS_GUI@ $(lib_flags_for $wx_libs)"
1083
1084     # We still need the core lib deps for a static build though
1085     if is_static; then
1086         link_deps="${libdir}/libwx_@TOOLCHAIN_NAME@.a"
1087         wx_libs="$wx_libs $link_deps $ldlibs_core @LIBS@"
1088     else
1089         wx_libs="$wx_libs -lwx_@TOOLCHAIN_NAME@"
1090     fi
1091
1092     using_gui=yes
1093
1094 else    # MONOLITHIC = 0
1095
1096     # Import everything by default, expand std if specified, or add base if omitted.
1097     if [ -z "$wx_libs" ]; then
1098         wx_libs="@CORE_GUI_LIBS@ @CORE_BASE_LIBS@"
1099     elif match_field std $wx_libs; then
1100         # Bubble any libs that were already specified to the end
1101         # of the list and ensure static linking order is retained.
1102         wx_libs=$(remove_field std $wx_libs)
1103         for i in @CORE_GUI_LIBS@ @CORE_BASE_LIBS@; do
1104             wx_libs="$(remove_field $i $wx_libs) $i"
1105         done
1106     elif ! match_field base $wx_libs ; then
1107         wx_libs="$wx_libs base"
1108     fi
1109
1110     using_gui=no
1111     for i in $wx_libs ; do
1112         if match_field "$i" @CORE_GUI_LIBS@ ; then
1113             _guildflags="@WXCONFIG_LDFLAGS_GUI@"
1114             using_gui=yes
1115             break
1116         fi
1117         match_field "$i" @CORE_BASE_LIBS@ || using_gui=yes
1118     done
1119
1120     if is_static; then
1121         link_deps=$(link_deps_for $wx_libs)
1122     fi
1123     wx_libs="$_guildflags $(lib_flags_for $wx_libs)"
1124 fi
1125
1126
1127 if [ -n "$WXDEBUG" ]; then
1128     decho
1129     decho "  using libs: '$wx_libs'"
1130     decho "  using_gui = $using_gui"
1131     decho
1132 fi
1133
1134
1135 # Endgame.  Nothing left to discover now.
1136 # --------------------------------------------------------------
1137
1138 [ "$using_gui" = "yes" ] || _gui_cppflags="-DwxUSE_GUI=0"
1139
1140 if is_installed; then
1141     _include_cppflags="-I${includedir}/wx-@WX_RELEASE@@WX_FLAVOUR@"
1142 else
1143     _include_cppflags="-I${includedir} -I${prefix}/contrib/include"
1144 fi
1145
1146 _cppflags=$(echo "-I${libdir}/wx/include/@TOOLCHAIN_FULLNAME@" $_include_cppflags "@WXDEBUG_DEFINE@" "@TOOLCHAIN_DEFS@" "@TOOLCHAIN_DLL_DEFS@" $_gui_cppflags "@WXCONFIG_INCLUDE@" "@WX_LARGEFILE_FLAGS@" "@GCC_PRAGMA_FLAGS@")
1147
1148 # now without further ado, we can answer these too.
1149 [ -z "$output_option_cppflags" ] || echo $_cppflags
1150 [ -z "$output_option_cflags"   ] || echo $_cppflags "@CODE_GEN_FLAGS@"
1151 [ -z "$output_option_cxxflags" ] || echo $_cppflags "@CODE_GEN_FLAGS@" "@CODE_GEN_FLAGS_CXX@"
1152 [ -z "$output_option_gl_libs"  ] || echo $(lib_flags_for gl)
1153 [ -z "$output_option_linkdeps" ] || echo $link_deps
1154
1155 if [ -n "$output_option_libs" ]; then
1156
1157     is_cross                                    &&
1158         [ "x$libdir" = "x/usr/${target}/lib" ]  ||
1159         [ "x$libdir" = "x/usr/lib" ]            ||
1160         _ldflags="-L$libdir"
1161
1162     is_installed || [ -n "$flag_option_no_rpath" ] || _rpath="@WXCONFIG_RPATH@"
1163
1164     echo $_ldflags "@LDFLAGS@" $_rpath $wx_libs "@DMALLOC_LIBS@"
1165 fi
1166
1167 # And so that's it, we're done.  Have a nice build.
1168
1169 exit 0
1170
1171