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