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