| 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 wierd. |
| 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 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 | |
| 888 | |
| 889 | # The rest are going to need a little more work. |
| 890 | # -------------------------------------------------------------- |
| 891 | |
| 892 | is_monolithic() { [ "x@MONOLITHIC@" = "x1" ]; } |
| 893 | is_static() { [ -n "$this_linkage" ]; } |
| 894 | is_installed() { [ -z "$this_prefix" ]; } |
| 895 | |
| 896 | |
| 897 | # Is the user after a support utility? |
| 898 | # If this is a cross build, we need to find and return a suitable |
| 899 | # native utility for the job, so we search: |
| 900 | # |
| 901 | # 1. local build dir (for native uninstalled builds only). |
| 902 | # 2. (optional) user supplied prefix. |
| 903 | # 3. configured install prefix. |
| 904 | # 4. environment $PATH. |
| 905 | # |
| 906 | # and if such a thing still cannot be found, exit signalling an error. |
| 907 | if [ -n "$input_option_utility" ]; then |
| 908 | |
| 909 | # This is dumb, in tree binaries should be in a standard location |
| 910 | # like the libs, but work with what we've got for now. |
| 911 | is_cross || _util="$exec_prefix/utils/$input_option_utility/$input_option_utility" |
| 912 | |
| 913 | if ! is_installed && [ -x "$_util" ]; then |
| 914 | is_static || _preload="eval LD_LIBRARY_PATH=$exec_prefix/lib" |
| 915 | echo $_preload $_util |
| 916 | exit |
| 917 | fi |
| 918 | |
| 919 | IFS=':' |
| 920 | _user_prefix=${input_option_exec_prefix:-$input_option_prefix} |
| 921 | |
| 922 | for _util in "${input_option_utility}-@WX_RELEASE@@WX_FLAVOUR@" \ |
| 923 | "${input_option_utility}-@WX_RELEASE@" \ |
| 924 | "${input_option_utility}" |
| 925 | do |
| 926 | for p in ${_user_prefix:+$_user_prefix/bin} $bindir $PATH; do |
| 927 | |
| 928 | [ -z "$WXDEBUG" ] || decho " checking for: '$p/$_util'" |
| 929 | |
| 930 | if [ -x "$p/$_util" ]; then |
| 931 | echo "$p/$_util" |
| 932 | exit |
| 933 | fi |
| 934 | |
| 935 | done |
| 936 | done |
| 937 | exit 1 |
| 938 | |
| 939 | fi |
| 940 | |
| 941 | |
| 942 | # Still here? Then get the options together for building an app. |
| 943 | # ---------------------------------------------------------------- |
| 944 | |
| 945 | # Additional configuration for individual library components. |
| 946 | ldflags_gl="@LDFLAGS_GL@" |
| 947 | |
| 948 | ldlibs_base="@WXCONFIG_EXTRALIBS@" |
| 949 | ldlibs_core="@EXTRALIBS_GUI@" |
| 950 | ldlibs_gl="@OPENGL_LIBS@" |
| 951 | ldlibs_html="@EXTRALIBS_HTML@" |
| 952 | ldlibs_xml="@EXTRALIBS_XML@" |
| 953 | ldlibs_odbc="@EXTRALIBS_ODBC@" |
| 954 | ldlibs_adv="@EXTRALIBS_SDL@" |
| 955 | |
| 956 | |
| 957 | # lib_flags_for _liblist |
| 958 | # This function returns a list of flags suitable to return with the |
| 959 | # output of --libs for all of the libraries in _liblist. You can |
| 960 | # add support for a new library by adding an entry for it in the |
| 961 | # psuedo-hashes above if it requires additional linker options. |
| 962 | lib_flags_for() |
| 963 | { |
| 964 | [ -z "$WXDEBUG" ] || decho " fetching lib flags for: '$*'" |
| 965 | |
| 966 | _all_ldflags='' |
| 967 | _all_libs='' |
| 968 | _wxlibs='' |
| 969 | |
| 970 | is_cross && _target="-${target}" |
| 971 | |
| 972 | for lib; do |
| 973 | |
| 974 | # We evidently can't trust people not to duplicate things in |
| 975 | # configure, or to keep them in any sort of sane order overall, |
| 976 | # so only add unique new fields here even if it takes us a while. |
| 977 | # In the case of libs, we bubble any duplicates to the end, |
| 978 | # because if multiple libs require it, static linking at least |
| 979 | # will require it to come after all of them. So long as local |
| 980 | # order is ok in configure then we should always be able to |
| 981 | # massage a correct result here like this. |
| 982 | # |
| 983 | # FIXME: ldlibs_core is totally bogus. Fix the duplication |
| 984 | # there independently of this. This covers for it, but we |
| 985 | # want to do this anyway because some libs may share common |
| 986 | # deps without a common ancestor in wx. This is not a licence |
| 987 | # for sloppy work elsewhere though and @GUI_TK_LIBRARY should |
| 988 | # be fixed. |
| 989 | |
| 990 | for f in $(eval echo \"\$ldflags_$lib\"); do |
| 991 | match_field "$f" $_all_ldflags || _all_ldflags="$_all_ldflags $f" |
| 992 | done |
| 993 | |
| 994 | if match_field "$lib" @CORE_BASE_LIBS@ ; then |
| 995 | _libname="@WX_LIBRARY_BASENAME_NOGUI@" |
| 996 | else |
| 997 | _libname="@WX_LIBRARY_BASENAME_GUI@" |
| 998 | fi |
| 999 | [ $lib = base ] || _libname="${_libname}_$lib" |
| 1000 | _libname="${_libname}-@WX_RELEASE@$_target" |
| 1001 | |
| 1002 | if is_static; then |
| 1003 | _wxlibs="$_wxlibs ${libdir}/lib${_libname}.a" |
| 1004 | for f in $(eval echo \"\$ldlibs_$lib\"); do |
| 1005 | |
| 1006 | # Only propagate duplicate -libraries to their latest |
| 1007 | # possible position. Do not eliminate any other |
| 1008 | # duplicates that might occur. They should be fixed |
| 1009 | # in configure long before they get here. |
| 1010 | # This started as a workaround for Mac -framework, |
| 1011 | # but it seems like a better policy in general, which |
| 1012 | # will let the more heinous bugs in configure shake out. |
| 1013 | # We should maybe filter *.a here too, but not unless |
| 1014 | # we have to. |
| 1015 | case "$f" in |
| 1016 | -l*) _all_libs="$(remove_field $f $_all_libs) $f" ;; |
| 1017 | *) _all_libs="$_all_libs $f" ;; |
| 1018 | esac |
| 1019 | |
| 1020 | done |
| 1021 | else |
| 1022 | _wxlibs="$_wxlibs -l${_libname}" |
| 1023 | fi |
| 1024 | |
| 1025 | done |
| 1026 | |
| 1027 | if [ -n "$WXDEBUG" ]; then |
| 1028 | decho " retrieved: ldflags = $_all_ldflags" |
| 1029 | decho " wxlibs = $_wxlibs" |
| 1030 | decho " alllibs = $_all_libs" |
| 1031 | fi |
| 1032 | |
| 1033 | echo $_all_ldflags $_wxlibs $_all_libs |
| 1034 | } |
| 1035 | |
| 1036 | # this is the strict subset of the above function which returns only the |
| 1037 | # (static) libraries themselves: this is used for linkdeps output which should |
| 1038 | # output the list of libraries the main program should depend on |
| 1039 | # |
| 1040 | # of course, this duplication is bad but I'll leave to somebody else the care |
| 1041 | # of refactoring this as I don't see any way to do it - VZ. |
| 1042 | |
| 1043 | # This (and the other cruft to support it) should be removed with |
| 1044 | # reference to the FIXME above when configure stops piping us a slurry |
| 1045 | # of options that need to be decomposed again for most practical uses - RL. |
| 1046 | link_deps_for() |
| 1047 | { |
| 1048 | _wxlibs='' |
| 1049 | |
| 1050 | is_cross && _target="-${target}" |
| 1051 | |
| 1052 | for lib; do |
| 1053 | if match_field "$lib" @CORE_BASE_LIBS@ ; then |
| 1054 | _libname="@WX_LIBRARY_BASENAME_NOGUI@" |
| 1055 | else |
| 1056 | _libname="@WX_LIBRARY_BASENAME_GUI@" |
| 1057 | fi |
| 1058 | [ $lib = base ] || _libname="${_libname}_$lib" |
| 1059 | _libname="${_libname}-@WX_RELEASE@$_target" |
| 1060 | |
| 1061 | _wxlibs="$_wxlibs ${libdir}/lib${_libname}.a" |
| 1062 | done |
| 1063 | |
| 1064 | echo $_wxlibs |
| 1065 | } |
| 1066 | |
| 1067 | # Sanity check the list of libs the user provided us, if any. |
| 1068 | # -------------------------------------------------------------- |
| 1069 | |
| 1070 | wx_libs=$(echo "$input_parameters" | tr ',' ' ') |
| 1071 | |
| 1072 | [ -z "$WXDEBUG" ] || decho " user supplied libs: '$wx_libs'" |
| 1073 | |
| 1074 | if is_monolithic; then |
| 1075 | |
| 1076 | # Core libs are already built into the blob. |
| 1077 | for i in std @CORE_GUI_LIBS@ @CORE_BASE_LIBS@; do |
| 1078 | wx_libs=$(remove_field $i $wx_libs) |
| 1079 | done |
| 1080 | |
| 1081 | wx_libs="@WXCONFIG_LDFLAGS_GUI@ $(lib_flags_for $wx_libs)" |
| 1082 | |
| 1083 | # We still need the core lib deps for a static build though |
| 1084 | if is_static; then |
| 1085 | link_deps="${libdir}/libwx_@TOOLCHAIN_NAME@.a" |
| 1086 | wx_libs="$wx_libs $link_deps $ldlibs_core @LIBS@" |
| 1087 | else |
| 1088 | wx_libs="$wx_libs -lwx_@TOOLCHAIN_NAME@" |
| 1089 | fi |
| 1090 | |
| 1091 | using_gui=yes |
| 1092 | |
| 1093 | else # MONOLITHIC = 0 |
| 1094 | |
| 1095 | # Import everything by default, expand std if specified, or add base if omitted. |
| 1096 | if [ -z "$wx_libs" ]; then |
| 1097 | wx_libs="@CORE_GUI_LIBS@ @CORE_BASE_LIBS@" |
| 1098 | elif match_field std $wx_libs; then |
| 1099 | # Bubble any libs that were already specified to the end |
| 1100 | # of the list and ensure static linking order is retained. |
| 1101 | wx_libs=$(remove_field std $wx_libs) |
| 1102 | for i in @CORE_GUI_LIBS@ @CORE_BASE_LIBS@; do |
| 1103 | wx_libs="$(remove_field $i $wx_libs) $i" |
| 1104 | done |
| 1105 | elif ! match_field base $wx_libs ; then |
| 1106 | wx_libs="$wx_libs base" |
| 1107 | fi |
| 1108 | |
| 1109 | using_gui=no |
| 1110 | for i in $wx_libs ; do |
| 1111 | if match_field "$i" @CORE_GUI_LIBS@ ; then |
| 1112 | _guildflags="@WXCONFIG_LDFLAGS_GUI@" |
| 1113 | using_gui=yes |
| 1114 | break |
| 1115 | fi |
| 1116 | match_field "$i" @CORE_BASE_LIBS@ || using_gui=yes |
| 1117 | done |
| 1118 | |
| 1119 | if is_static; then |
| 1120 | link_deps=$(link_deps_for $wx_libs) |
| 1121 | fi |
| 1122 | wx_libs="$_guildflags $(lib_flags_for $wx_libs)" |
| 1123 | fi |
| 1124 | |
| 1125 | |
| 1126 | if [ -n "$WXDEBUG" ]; then |
| 1127 | decho |
| 1128 | decho " using libs: '$wx_libs'" |
| 1129 | decho " using_gui = $using_gui" |
| 1130 | decho |
| 1131 | fi |
| 1132 | |
| 1133 | |
| 1134 | # Endgame. Nothing left to discover now. |
| 1135 | # -------------------------------------------------------------- |
| 1136 | |
| 1137 | [ "$using_gui" = "yes" ] || _gui_cppflags="-DwxUSE_GUI=0" |
| 1138 | |
| 1139 | if is_installed; then |
| 1140 | _include_cppflags="-I${includedir}/wx-@WX_RELEASE@@WX_FLAVOUR@" |
| 1141 | else |
| 1142 | _include_cppflags="-I${includedir} -I${prefix}/contrib/include" |
| 1143 | fi |
| 1144 | |
| 1145 | _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@") |
| 1146 | |
| 1147 | # now without further ado, we can answer these too. |
| 1148 | [ -z "$output_option_cppflags" ] || echo $_cppflags |
| 1149 | [ -z "$output_option_cflags" ] || echo $_cppflags "@CODE_GEN_FLAGS@" |
| 1150 | [ -z "$output_option_cxxflags" ] || echo $_cppflags "@CODE_GEN_FLAGS@" "@CODE_GEN_FLAGS_CXX@" |
| 1151 | [ -z "$output_option_gl_libs" ] || echo $(lib_flags_for gl) |
| 1152 | [ -z "$output_option_linkdeps" ] || echo $link_deps |
| 1153 | |
| 1154 | if [ -n "$output_option_libs" ]; then |
| 1155 | |
| 1156 | is_cross && |
| 1157 | [ "x$libdir" = "x/usr/${target}/lib" ] || |
| 1158 | [ "x$libdir" = "x/usr/lib" ] || |
| 1159 | _ldflags="-L$libdir" |
| 1160 | |
| 1161 | is_installed || [ -n "$flag_option_no_rpath" ] || _rpath="@WXCONFIG_RPATH@" |
| 1162 | |
| 1163 | echo $_ldflags "@LDFLAGS@" $_rpath $wx_libs "@DMALLOC_LIBS@" |
| 1164 | fi |
| 1165 | |
| 1166 | # And so that's it, we're done. Have a nice build. |
| 1167 | |
| 1168 | exit 0 |
| 1169 | |
| 1170 | |