3 # Name: wx-config{.in,}
4 # Purpose: wx configuration search and query tool {template,}
5 # Author: Ron <ron@debian.org>
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 ############################################################################
20 # We expect a posix shell, so if this is a Bourne shell,
21 # and apparently a few still exist, try for bash or ksh.
25 if (bash
-c echo) >/dev
/null
2>&1
29 if (ksh
-c echo) >/dev
/null
2>&1
33 echo "$0: this script requires bash or ksh"
38 # On with some basic stuff, like the ability to die gracefully,
39 # and to tell people what we are about.
40 # ------------------------------------------------------------------
43 # Output a message to stderr.
44 decho
() { echo "$*" 1>&2; }
47 # Outputs a usage message to stderr and exits with _exitcode.
48 # Try to keep this to a single page (ie. < 25 lines). We can add
49 # alternate or interactive help targets if people want more detail.
51 # Exit codes are now subject to a more strict interpretation.
52 # wx-config should return 0 upon successful operation, 1 if the
53 # reqested operation could not be completed successfully, and 2
54 # if the requested operation is not supported by this version of
60 wx-config [--prefix[=DIR]] [--exec-prefix[=DIR]] [--release] [--version-full]
61 [--list] [--host=HOST] [--toolkit=TOOLKIT] [--universal[=yes|no]]
62 [--unicode[=yes|no]] [--debug[=yes|no]] [--static[=yes|no]]
63 [--version[=VERSION]] [--basename] [--cc] [--cppflags] [--cflags]
64 [--cxxflags] [--rezflags] [--libs] [--cxx] [--ld] [--linkdeps]
65 [--utility=UTIL] [LIB ...]
67 wx-config returns information about the wxWidgets libraries available
68 on your system. It may be used to retrieve the information you require
69 to build applications using these libraries.
71 If alternative builds of wxWidgets exist on the system, you can use the
72 options: --prefix, --host, --toolkit, --unicode, --debug, --static,
73 --version and --universal, to select from them. Use the --list option to
74 show alternatives available which match specified criteria. The unicode,
75 debug, and universal options take an optional yes or no argument, while
76 host and version accept posix extended regex. The --utility option will
77 return the correct version of UTIL to use with the selected library build.
78 --linkdeps returns only static libraries for your makefile link rule deps.
80 Optional LIB arguments (comma or space separated) may be used to specify
81 the wxWidgets libraries that you wish to use. The magic "std" label may
82 be used to import all libraries that would be used by default if none were
83 specified explicitly. eg. wx-config --libs core,base.
90 # Unfussy people are the easiest to deal with, get them out of the way now.
91 [ $# -gt 0 ] || usage
1
95 # For the people who know what they want, or think they do:
96 # Divide the valid arguments into functional groups for later examination,
97 # then parse all command line arguments completely, deferring action on
98 # output options until all significant input has been processed and any
99 # decision about delegation has been taken.
101 # Note early, that '-' is a complete no-no for use in option names below.
102 # It totally falls apart as soon as it becomes part of a variable name.
103 # Use '_' instead, and by the magic of it all just being bits, you'll
104 # be able to use --my-option or --my_option from the command line at
105 # your discretion. They are synonymous as user input, but _ALWAYS_ use
106 # underscores for compound names in the code here, never a dash.
109 # The list of all options we recognise. If it is not in here, then
110 # it is not something we want to handle.
111 # ------------------------------------------------------------------
113 # Options that specify a distinct library build.
115 # Note also that order in this list is significant later on, as this sets
116 # the precedence with which we will try to gauge the similarity of other
117 # configs to this one. Options earlier in the list should be more crucial
118 # to match well than those that follow. Options specified by the user will
119 # always take precedence and are not subject to any partial ordering here.
120 wxconfig_schema
="host toolkit widgetset chartype debugtype flavour version linkage"
122 # Options that are expected to generate some output.
123 wxconfig_output_options
="prefix exec_prefix \
125 release version version_full \
127 cppflags cflags cxxflags \
134 # Options that permit the user to supply hints that may affect the output.
135 # These options all accept arbitrary values, to interpret as they please.
136 wxconfig_input_options
="prefix exec_prefix utility $wxconfig_schema"
138 # Input options that accept only a yes or no argument.
139 wxconfig_yesno_options
="universal unicode debug static"
141 # Boolean options that do something or not.
142 wxconfig_flag_options
="$wxconfig_yesno_options no_rpath inplace"
146 # Some simple sugar coating to keep things more readable below.
147 # --------------------------------------------------------------
149 # option_name _string
150 # Returns NAME if _string is of the form: --NAME[=...]
153 _option_name_temp
=${1%%=*}
154 echo "${_option_name_temp#--}" | tr '-' '_'
157 # option_value _string
158 # Returns FOO if _string is of the form: --option=FOO
164 # match_field _value _list
165 # Returns true if _value is a field in _list
168 _match_field_match
="$1"
170 for _match_field_i
; do
171 [ "x$_match_field_i" != "x$_match_field_match" ] || return 0
176 # remove_field _value _list
177 # Returns _list minus any field(s) that match _value.
183 if [ -n "$_remf_value" ]; then
185 [ "x$_remf_item" = "x$_remf_value" ] || \
186 _remf_list
="${_remf_list:+$_remf_list }$_remf_item"
194 # validate_arg _domain _set _name _value
195 # Boilerplate to validate an argument and initialise a psuedo-hash.
196 # This one is almost reduction into absurdity, and perhaps makes the
197 # precise action of the argument parser below just a little more
198 # obscure, but oh so neat and compact to use for multiple option
199 # groups. It expands to replace repetitive clauses of the form:
201 # i="$(option_name $arg)"
202 # if match_field "$i" $wxconfig_input_options; then
203 # input_options="${input_options:+$input_options }$i"
204 # eval "input_option_$i=$(option_value $arg)"
208 # with the one liners you see on the page below.
211 if match_field
"$3" $(eval echo \"\$$1_$2_options\"); then
212 eval "$2_options=\"\${$2_options:+\$$2_options }$3\""
213 eval "$2_option_$3=\"$4\""
219 # check_yesno_option _ynoption _option _yesval _noval
220 # This one might be made more generic and/or incorporated into
221 # validate_arg above at some later stage, but right now we just
222 # condition any specialist options into a generic one for later
223 # handling. Once they are sanity checked there is no difference
227 eval "case \${yesno_option_$1-\${flag_option_$1-unset}} in \
229 y*|Y*) input_option_$2=\"$3\" ;; \
230 n*|N*) input_option_$2=\"$4\" ;; \
233 decho \" *** Error: Invalid request '--$1=\$yesno_option_$1'\"; \
234 decho \" Valid arguments for --$1 are: [ yes, no ]\"; \
242 # Now we are ready to find out what the user wants from us.
243 # --------------------------------------------------------------
245 # With just a little more complexity here we could have shortest
246 # unique string matching for options, but that is probably overkill
247 # today, so lets just get the job done.
249 # The important thing now then is that we simply read all input from
250 # the user and don't try to act prematurely on partial information.
251 # --help or an illegal argument are the only shortcuts out of here
252 # at this point, otherwise, it's time to just shut up and listen for
262 _name
=$(option_name $arg)
263 _value
=$(option_value $arg)
264 if validate_arg wxconfig input
"$_name" "$_value" \
265 || validate_arg wxconfig yesno
"$_name" "$_value"; \
272 _name
=$(option_name $arg)
273 if validate_arg wxconfig flag
"$_name" yes \
274 || validate_arg wxconfig output
"$_name" yes;
281 # FIXME Surely we can validate the parameters too ...
282 input_parameters
="${input_parameters:+$input_parameters }$arg"
286 decho
" *** Error: Unrecognised option: '$arg'"
287 decho
"Use wx-config --help for information on command line options."
291 # validate_arg only checks and decomposes form. Sanity check the yes/no
292 # options now too and push their respective mask values into place.
294 check_yesno_option universal widgetset univ
295 check_yesno_option unicode chartype unicode ansi
296 check_yesno_option debug debugtype debug release
297 check_yesno_option static linkage
'-static'
300 # Dump everything we just read in debug mode.
301 if [ -n "$WXDEBUG" ]; then
304 decho
" input parameters = $input_parameters"
305 decho
" input options = $input_options"
306 for i
in $input_options; do
307 decho
" $i = $(eval echo \"\$input_option_$i\")"
309 decho
" yes/no options = $yesno_options"
310 for y
in $yesno_options; do
311 decho
" $y = $(eval echo \"\$yesno_option_$y\")"
313 decho
" flag options = $flag_options"
314 for f
in $flag_options; do
315 decho
" $f = $(eval echo \"\$flag_option_$f\")"
317 decho
" output options = $output_options"
318 for o
in $output_options; do
319 decho
" $o = $(eval echo \"\$output_option_$o\")"
326 # Everything came in as a legal argument then, lets put some of
327 # the pieces together with a little self knowledge to see what
329 # --------------------------------------------------------------
332 # Construct a config filename mask from a psuedo-hash of component variables.
333 # The optional argument is the prefix of the hash to use. If not specified
334 # this will return a mask derived from the command line options that were used.
337 [ $# -gt 0 ] || set m
338 eval echo "\${$1_host}\${$1_toolkit}\${$1_widgetset}-\${$1_chartype}-\${$1_debugtype}\${$1_linkage}-\${$1_version}\${$1_flavour}"
342 # Determine the base directories we require.
343 prefix
=${input_option_prefix-${this_prefix:-@prefix@}}
344 exec_prefix
=${input_option_exec_prefix-${input_option_prefix-${this_exec_prefix:-@exec_prefix@}}}
345 wxconfdir
="@libdir@/wx/config"
347 installed_configs
=$( cd "$wxconfdir" 2> /dev/null && ls | grep -v "^inplace-" )
349 target
="@host_alias@"
351 # Define a pseudo-hash to contain the specification of this wx-config
352 # instance and its associated library.
353 this_host
="${target:+${target}-}"
354 this_toolkit
="@TOOLKIT_DIR@@TOOLKIT_VERSION@"
355 this_widgetset
="@WIDGET_SET@"
356 this_chartype
="@WX_CHARTYPE@"
357 this_debugtype
="@WX_DEBUGTYPE@"
358 this_flavour
="@WX_FLAVOUR@"
359 this_version
="@WX_RELEASE@"
360 this_linkage
=$( [ "x@SHARED@" = "x1" ] || echo '-static' )
362 this_config
=$(get_mask this)
364 # Extract the user specification from the options parsed.
365 m_host
=${input_option_host:+${input_option_host}-?}
366 m_host
=${m_host:-${input_option_host-$this_host}}
367 m_toolkit
=${input_option_toolkit:-[^-]+}
368 m_widgetset
=${input_option_widgetset-(univ)?}
369 m_chartype
=${input_option_chartype:-(unicode|ansi)}
370 m_debugtype
=${input_option_debugtype:-(debug|release)}
371 m_flavour
=${input_option_flavour:+-$input_option_flavour}
372 m_flavour
=${m_flavour:-${input_option_flavour-(-[^-]+)?}}
373 m_version
=${input_option_version:-[0-9]+\.[0-9]+}
374 m_linkage
=${input_option_linkage-(-static)?}
376 configmask
="^$(get_mask)$"
379 # Dump the user specification in debug mode.
380 if [ -n "$WXDEBUG" ]; then
383 decho
" prefix = '$prefix'"
384 decho
" exec_prefix = '$exec_prefix'"
385 decho
" wxconfdir = '$wxconfdir'"
387 decho
" m_host = '$m_host'"
388 decho
" m_toolkit = '$m_toolkit'"
389 decho
" m_widgetset = '$m_widgetset'"
390 decho
" m_chartype = '$m_chartype'"
391 decho
" m_debugtype = '$m_debugtype'"
392 decho
" m_flavour = '$m_flavour'"
393 decho
" m_version = '$m_version'"
394 decho
" m_linkage = '$m_linkage'"
396 decho
" configmask = '$configmask'"
397 decho
" this config = '$this_config'"
404 # From here on, we'll need to be able to figure out a delegation target.
405 # -----------------------------------------------------------------------
407 # The rules for delegation are:
409 # 1. If the specification is so general that it matches the default config
410 # (ie. this one on a first pass), then the default config will be used
411 # even if other installed libs would also match the spec.
413 # 2. If the default config does not match, find a list of all installed
414 # libraries that do match.
415 # a. If that list is empty, the specification is incompatible
416 # with any installed lib. Warn and abort.
417 # b. If that list contains exactly one candidate. Delegate to
419 # c. If the list contains multiple candidates, pass on to step 3.
421 # 3. Attempt to discriminate among rival candidates by their similarity
422 # to the default configuration (ie. this one). If we can find a unique
423 # candidate in this way, delegate to it. If not, present a list of
424 # options to the user and request that they disambiguate it with one or
425 # more additional fields.
427 # To refine the specified pattern, we specialise each unbound field
428 # using the default value from this config file. If that results in
429 # no matches, we unbind it again and try the next field. If it still
430 # results in multiple matches we try binding the next field as well
431 # until a unique or null result again occurs.
433 # A more general way to look at this, is the feature specifiers are all
434 # modifiers of the wx-config you are calling. If you supply none, the
435 # default for that build configuration will be used. If you supply one
436 # or more that the default build cannot satisfy, it will try to find the
437 # config most like itself with the desired feature(s) enabled.
438 # The features configured into the first wx-config called will be taken
439 # as implicitly specified if it is necessary to disambiguate likely
440 # candidates from the information that was explicitly provided.
443 # But first, more sugar to keep what follows clear and legible.
444 # --------------------------------------------------------------
446 # find_eligible_delegates _mask
447 # Outputs all the config files installed which match the
448 # (extended regex) _mask passed as an argument.
449 find_eligible_delegates
() { echo "$installed_configs" | grep -E "$1" 2> /dev
/null
; }
451 # user_mask_fits _config
452 # Returns true if the string _config satisfies the user specified mask.
453 user_mask_fits
() { echo "$1" | grep -E "$configmask" > /dev
/null
2>&1; }
456 # Returns the number of IFS split fields in _word
457 count_fields
() { return $#; }
459 # count_delegates _mask
460 # Return the number of eligible config files that match _mask
461 count_delegates
() { count_fields
$(find_eligible_delegates $1); }
463 # is_set _variablename
464 # Returns true if $_variablename is initialised.
465 is_set
() { [ "x$(eval echo \"\${$1-unset}\")" != "xunset" ]; }
467 # do_find_best_delegate _unbound-options
468 # The real worker part of find_best_delegate below. Recurses though all
469 # unbound options binding them one at a time to the default derived from
470 # this file until a unique match is made or no alternatives remain that
471 # may be sensibly guessed at. It will preferentially bind the unspecified
472 # options in the order they are listed in wxconfig_schema. Using this
473 # partial ordering it should find the first match with the most significant
474 # similarity to this file that unambiguously meets the user specification.
475 # If such a match exists it will be output to stdout.
477 # Be careful if you modify this function. If the pruning logic is rendered
478 # inoperative it will simply recurse over every permutation in the search
479 # space, which may still appear to work, but add a couple more options (or
480 # explicitly specify a few less) and you may not live long enough to learn
481 # the result. WXDEBUG=findprogress is your friend here, it will show you
482 # how many nodes get searched before a result. If you start seeing
483 # increases in that number for the same input, check your work.
484 # Raising the number of discriminating options from 6 to 8 raised the worst
485 # case time for this to run (without pruning) from 3 to nearly 15 seconds
486 # and its downhill fast from here if we have to ride that boat.
487 # Early pruning still gets that down to under half a second (up from about
488 # .25), so we have some breathing space yet before a different search method
489 # will be called for, but lets not squander it.
490 do_find_best_delegate
()
493 if [ "x$WXDEBUG" = "xverbose" ]; then
494 _fbd_indent
="${_fbd_indent}. "
495 decho
" $_fbd_indent---> unbound options: $*"
500 if [ "x$WXDEBUG" = "xverbose" ]; then
501 decho
" ${_fbd_indent}binding '$i' with '$(remove_field $i $*)' still free"
502 [ -z "$_pruned" ] || decho
" ${_fbd_indent} --- pruned: $_pruned ---"
507 _mask
="^$(get_mask)$"
509 if [ "x$WXDEBUG" = "xverbose" ]; then
510 decho
" ${_fbd_indent} checking: $_mask"
511 count_delegates
"$_mask"
512 decho
" $_fbd_indent $? eligible delegates"
513 for d
in $(find_eligible_delegates "$_mask"); do
514 decho
" ${_fbd_indent} $d"
518 count_delegates
"$_mask"
521 if [ $_still_eligible -eq 1 ]; then
522 echo $(find_eligible_delegates "$_mask")
526 [ "x$WXDEBUG" != "xfindprogress" ] || printf "." 1>&2
528 [ $_still_eligible -gt 1 ] && [ $# -gt 1 ] && \
529 do_find_best_delegate
$(remove_field $i $*)
535 elif [ $# -gt 1 ]; then
537 if [ "x$WXDEBUG" = "xverbose" ]; then
538 decho
" ${_fbd_indent}pruning: $i"
539 _pruned
="${_pruned:+$_pruned }$i"
541 set $(remove_field $i $*)
551 # A simple wrapper around do_find_best_delegate that first determines
552 # the unbound options (ie. the ones that the user did not explicitly
553 # declare a preference for on the command line)
556 for _fbdi
in $wxconfig_schema; do
557 is_set input_option_
$_fbdi || \
558 _unbound_options
="${_unbound_options:+$_unbound_options }$_fbdi"
560 do_find_best_delegate
$_unbound_options
564 # Legacy wx-config helpers.
565 # -------------------------
568 # Returns a mask in the format used by wx2.4.
571 [ $# -gt 0 ] || set m
572 eval [ "x\${$1_chartype}" != "xunicode" ] || _unicode_flag
=u
573 eval [ "x\${$1_debugtype}" != "xdebug" ] || _debug_flag
=d
574 eval echo "wx\${$1_toolkit}${_unicode_flag}${_debug_flag}-\${$1_version}\${$1_host}-config"
577 # find_legacy_configs
578 # Returns a list of configs installed by wx2.4 releases.
579 find_legacy_configs
()
581 cd "$prefix/bin" 2> /dev
/null
&& \
582 ls wx
*-2.4
-config 2> /dev
/null
| grep -v ^wxbase
; \
583 ls wx
*-2.4
-config 2> /dev
/null
| grep ^wxbase
586 # find_best_legacy_config
587 # Returns the best legacy config for a given specification.
588 # This assumes no matching new style config has been found.
589 find_best_legacy_config
()
591 _legacy_configs
=$(find_legacy_configs)
592 if [ -n "$_legacy_configs" ]; then
593 _legacy_mask
=$(get_legacy_mask)
594 for d
in $_legacy_configs; do
595 if echo $d | grep -E $_legacy_mask > /dev
/null
2>&1 ; then
606 # The only action we can perform authoritatively prior to delegation
607 # is to list all the possible delegates.
608 # --------------------------------------------------------------
611 [ -z "$WXDEBUG" ] || config_spec
=$configmask
613 # Next chance for another satisfied customer then
615 # If we want to get really polished here we can do plural checking,
616 # but we should probably leave that until the day we gettextise it.
617 if [ -n "$output_option_list" ]; then
619 _remains_in_prefix
=$installed_configs
620 _delegates
=$(find_eligible_delegates $configmask)
621 _best_delegate
=$(find_best_delegate)
623 if [ "x$WXDEBUG" = "xverbose" ]; then
625 decho
" all = $_remains_in_prefix"
626 decho
" matching = $_delegates"
627 decho
" best = $_best_delegate"
628 decho
" this = $this_config"
631 for d
in $_delegates; do
632 _remains_in_prefix
=$(remove_field $d $_remains_in_prefix)
636 echo " Default config is $this_config"
639 if user_mask_fits
"$this_config" ; then
641 echo " Default config ${this_exec_prefix+in $this_exec_prefix }will be used for output"
643 if match_field
"$this_config" $_delegates ; then
644 _delegates
=$(remove_field $this_config $_delegates)
646 echo " though it is not installed in: $prefix"
647 if [ -n "$_best_delegate" ] && [ "x$_best_delegate" != "x$this_config" ]; then
649 echo " Best alternate in $prefix:"
650 echo " $_best_delegate"
654 elif [ -n "$_best_delegate" ]; then
656 echo " Specification best match: $_best_delegate"
658 elif [ -z "$_delegates" ]; then
660 _last_chance
=$(find_best_legacy_config)
661 if [ -n "$_last_chance" ]; then
663 echo " Specification matches legacy config: $_last_chance"
668 No config found to match: $config_spec
671 Please install the desired library build, or specify a different
672 prefix where it may be found. If the library is not installed
673 you may call its wx-config directly by specifying its full path.
680 echo " Specification was ambiguous. Use additional feature options"
681 echo " to choose between alternate matches."
684 _delegates
=$(remove_field "$_best_delegate" $_delegates)
686 if [ -n "$_delegates" ]; then
688 echo " Alternate matches:"
689 for d
in $_delegates; do
693 if [ -n "$_remains_in_prefix" ]; then
695 echo " Also available in $prefix:"
696 for d
in $_remains_in_prefix; do
701 _legacy_configs
=$(find_legacy_configs)
702 if [ -n "$_legacy_configs" ]; then
704 echo " Legacy configs available in $prefix:"
705 for d
in $_legacy_configs; do
716 # ... so if that wasn't what they wanted, then we need to know for
717 # certain, can this config satisfy the user specification?
718 # --------------------------------------------------------------
720 if ! user_mask_fits
"$this_config" ; then
722 # No? Then lets see if it knows anybody who can.
723 # But first, just be sure someone hasn't typo'd us into a loop.
724 # In present day wx, correct delegation should never need more
725 # than one hop so this is trivial to detect.
727 if [ -n "$WXCONFIG_DELEGATED" ]; then
729 decho
" *** Error: Bad config delegation"
732 decho
" ($this_config) cannot satisfy:"
733 decho
" $config_spec"
734 decho
" Someone has been terribly careless."
739 count_delegates
"$configmask"
742 if [ -n "$WXDEBUG" ]; then
743 decho
" must delegate to an alternate config"
744 decho
" potential delegates ($_numdelegates):"
745 for i
in $(find_eligible_delegates "$configmask"); do
750 if [ $_numdelegates -eq 0 ]; then
752 _last_chance
=$(find_best_legacy_config)
753 if [ -n "$_last_chance" ]; then
757 --prefix*|--exec-prefix*| \
758 --version|--release|--basename| \
759 --static|--libs|--gl_libs| \
760 --cppflags|--cflags|--cxxflags| \
762 --rezflags|--inplace)
763 _legacy_args
="$_legacy_args $arg"
766 --static|--static=y
*|--static=Y
*)
767 _legacy_args
="$_legacy_args --static"
772 if [ -n "$WXDEBUG" ]; then
773 decho
" found a suitable legacy delegate: $_last_chance"
774 decho
"--> $prefix/bin/$_last_chance $_legacy_args"
777 export WXCONFIG_DELEGATED
=yes
778 $prefix/bin
/$_last_chance $_legacy_args
785 Warning: No config found to match: $config_spec
787 If you require this configuration, please install the desired
788 library build. If this is part of an automated configuration
789 test and no other errors occur, you may safely ignore it.
790 You may use wx-config --list to see all configs available in
795 # PIPEDREAM: This will probably give Vadim an aneurysm if I
796 # mention it out of context, but from here we are actually
797 # just a teensy step from simply building the missing config
798 # for the user on the fly if this is an in tree wx-config.
804 if [ $_numdelegates -gt 1 ]; then
806 [ -z "$WXDEBUG" ] || decho
" must prune the list of eligible delegates"
808 best_delegate
=$(find_best_delegate)
810 if [ -n "$best_delegate" ]; then
812 if [ -n "$WXDEBUG" ]; then
813 decho
" found a suitable delegate: $best_delegate"
814 decho
"--> $wxconfdir/$best_delegate $*"
817 export WXCONFIG_DELEGATED
=yes
818 $wxconfdir/$best_delegate $
*
823 decho
" *** Error: Specification is ambiguous"
824 decho
" as $config_spec"
825 decho
" Use additional feature options to choose between:"
826 for i
in $(find_eligible_delegates "$configmask"); do
834 if [ -n "$WXDEBUG" ]; then
835 decho
" using the only suitable delegate"
836 decho
"--> $wxconfdir/$(find_eligible_delegates $configmask) $*"
839 export WXCONFIG_DELEGATED
=yes
840 $wxconfdir/$(find_eligible_delegates $configmask) $
*
846 # If we are still here, then from now on we are responsible for
847 # all the user's needs. Time to rustle up some output for them.
848 # --------------------------------------------------------------
850 [ -z "$WXDEBUG" ] || decho
" using this config"
852 # If the user supplied a prefix, and the in tree config did not
853 # delegate out to anything in that prefix, then reset the build
854 # tree prefix to provide the correct output for using this
855 # uninstalled wx build. Or put more simply:
856 prefix
=${this_prefix-$prefix}
857 exec_prefix
=${this_exec_prefix-$exec_prefix}
859 includedir
="@includedir@"
863 # Trivial queries we can answer now.
864 [ -z "$output_option_prefix" ] || echo $prefix
865 [ -z "$output_option_exec_prefix" ] || echo $exec_prefix
866 [ -z "$output_option_release" ] || echo "@WX_RELEASE@"
867 [ -z "$output_option_version" ] || echo "@WX_VERSION@"
868 [ -z "$output_option_version_full" ] || echo "@WX_SUBVERSION@"
869 [ -z "$output_option_basename" ] || echo "@WX_LIBRARY_BASENAME_GUI@"
870 [ -z "$output_option_rezflags" ] || echo $(eval echo "@MACRESWXCONFIG@")
871 [ -z "$output_option_cc" ] || echo "@CC@"
872 [ -z "$output_option_cxx" ] || echo "@CXX@"
873 [ -z "$output_option_ld" ] || echo "@EXE_LINKER@"
876 # The rest are going to need a little more work.
877 # --------------------------------------------------------------
879 is_cross
() { [ "x@cross_compiling@" = "xyes" ]; }
880 is_monolithic
() { [ "x@MONOLITHIC@" = "x1" ]; }
881 is_static
() { [ -n "$this_linkage" ]; }
882 is_installed
() { [ -z "$this_prefix" ]; }
885 # Is the user after a support utility?
886 # If this is a cross build, we need to find and return a suitable
887 # native utility for the job, so we search:
889 # 1. local build dir (for native uninstalled builds only).
890 # 2. (optional) user supplied prefix.
891 # 3. configured install prefix.
892 # 4. environment $PATH.
894 # and if such a thing still cannot be found, exit signalling an error.
895 if [ -n "$input_option_utility" ]; then
897 # This is dumb, in tree binaries should be in a standard location
898 # like the libs, but work with what we've got for now.
899 is_cross
|| _util
="$exec_prefix/utils/$input_option_utility/$input_option_utility"
901 if ! is_installed
&& [ -x "$_util" ]; then
902 is_static
|| _preload
="eval LD_LIBRARY_PATH=$exec_prefix/lib"
903 echo $_preload $_util
908 _user_prefix
=${input_option_exec_prefix:-$input_option_prefix}
910 for _util
in "${input_option_utility}-@WX_RELEASE@@WX_FLAVOUR@" \
911 "${input_option_utility}-@WX_RELEASE@" \
912 "${input_option_utility}";
914 for p
in ${_user_prefix:+$_user_prefix/bin} $bindir $PATH; do
916 [ -z "$WXDEBUG" ] || decho
" checking for: '$p/$_util'"
918 if [ -x "$p/$_util" ]; then
930 # Still here? Then get the options together for building an app.
931 # ----------------------------------------------------------------
933 # Additional configuration for individual library components.
934 ldflags_gl
="@LDFLAGS_GL@"
936 ldlibs_base
="@WXCONFIG_EXTRALIBS@"
937 ldlibs_core
="@EXTRALIBS_GUI@"
938 ldlibs_gl
="@OPENGL_LIBS@"
939 ldlibs_html
="@EXTRALIBS_HTML@"
940 ldlibs_xml
="@EXTRALIBS_XML@"
941 ldlibs_odbc
="@EXTRALIBS_ODBC@"
942 ldlibs_adv
="@EXTRALIBS_SDL@"
945 # lib_flags_for _liblist
946 # This function returns a list of flags suitable to return with the
947 # output of --libs for all of the libraries in _liblist. You can
948 # add support for a new library by adding an entry for it in the
949 # psuedo-hashes above if it requires additional linker options.
952 [ -z "$WXDEBUG" ] || decho
" fetching lib flags for: '$*'"
958 ! is_cross
|| _target
="-${target}"
962 # We evidently can't trust people not to duplicate things in
963 # configure, or to keep them in any sort of sane order overall,
964 # so only add unique new fields here even if it takes us a while.
965 # In the case of libs, we bubble any duplicates to the end,
966 # because if multiple libs require it, static linking at least
967 # will require it to come after all of them. So long as local
968 # order is ok in configure then we should always be able to
969 # massage a correct result here like this.
971 # FIXME: ldlibs_core is totally bogus. Fix the duplication
972 # there independently of this. This covers for it, but we
973 # want to do this anyway because some libs may share common
974 # deps without a common ancestor in wx. This is not a licence
975 # for sloppy work elsewhere though and @GUI_TK_LIBRARY should
978 for f
in $(eval echo \"\$ldflags_$lib\"); do
979 match_field
"$f" $_all_ldflags || _all_ldflags
="$_all_ldflags $f"
982 if match_field
"$lib" @CORE_BASE_LIBS@
; then
983 _libname
="@WX_LIBRARY_BASENAME_NOGUI@"
985 _libname
="@WX_LIBRARY_BASENAME_GUI@"
987 [ $lib = base
] || _libname
="${_libname}_$lib"
988 _libname
="${_libname}-@WX_RELEASE@$_target"
991 _wxlibs
="$_wxlibs ${libdir}/lib${_libname}.a"
992 for f
in $(eval echo \"\$ldlibs_$lib\"); do
993 _all_libs
="$(remove_field $f $_all_libs) $f"
996 _wxlibs
="$_wxlibs -l${_libname}"
1001 if [ -n "$WXDEBUG" ]; then
1002 decho
" retrieved: ldflags = $_all_ldflags"
1003 decho
" wxlibs = $_wxlibs"
1004 decho
" alllibs = $_all_libs"
1007 echo $_all_ldflags $_wxlibs $_all_libs
1010 # this is the strict subset of the above function which returns only the
1011 # (static) libraries themselves: this is used for linkdeps output which should
1012 # output the list of libraries the main program should depend on
1014 # of course, this duplication is bad but I'll leave to somebody else the care
1015 # of refactoring this as I don't see any way to do it
1020 ! is_cross
|| _target
="-${target}"
1023 if match_field
"$lib" @CORE_BASE_LIBS@
; then
1024 _libname
="@WX_LIBRARY_BASENAME_NOGUI@"
1026 _libname
="@WX_LIBRARY_BASENAME_GUI@"
1028 [ $lib = base
] || _libname
="${_libname}_$lib"
1029 _libname
="${_libname}-@WX_RELEASE@$_target"
1031 _wxlibs
="$_wxlibs ${libdir}/lib${_libname}.a"
1037 # Sanity check the list of libs the user provided us, if any.
1038 # --------------------------------------------------------------
1040 wx_libs
=$(echo "$input_parameters" | tr ',' ' ')
1042 [ -z "$WXDEBUG" ] || decho
" user supplied libs: '$wx_libs'"
1044 if is_monolithic
; then
1046 # Core libs are already built into the blob.
1047 for i
in std @CORE_GUI_LIBS@ @CORE_BASE_LIBS@
; do
1048 wx_libs
=$(remove_field $i $wx_libs)
1051 wx_libs
="@WXCONFIG_LDFLAGS_GUI@ $(lib_flags_for $wx_libs)"
1053 # We still need the core lib deps for a static build though
1055 link_deps
="${libdir}/libwx_@TOOLCHAIN_NAME@.a"
1056 wx_libs
="$wx_libs $link_deps $ldlibs_core @LIBS@"
1058 wx_libs
="$wx_libs -lwx_@TOOLCHAIN_NAME@"
1063 else # MONOLITHIC = 0
1065 # Import everything by default, expand std if specified, or add base if omitted.
1066 if [ -z "$wx_libs" ]; then
1067 wx_libs
="@CORE_GUI_LIBS@ @CORE_BASE_LIBS@"
1068 elif match_field std
$wx_libs; then
1069 # Bubble any libs that were already specified to the end
1070 # of the list and ensure static linking order is retained.
1071 wx_libs
=$(remove_field std $wx_libs)
1072 for i
in @CORE_GUI_LIBS@ @CORE_BASE_LIBS@
; do
1073 wx_libs
="$(remove_field $i $wx_libs) $i"
1075 elif ! match_field base
$wx_libs ; then
1076 wx_libs
="$wx_libs base"
1080 for i
in $wx_libs ; do
1081 if match_field
"$i" @CORE_GUI_LIBS@
; then
1082 _guildflags
="@WXCONFIG_LDFLAGS_GUI@"
1086 match_field
"$i" @CORE_BASE_LIBS@
|| using_gui
=yes
1090 link_deps
=$(link_deps_for $wx_libs)
1092 wx_libs
="$_guildflags $(lib_flags_for $wx_libs)"
1096 if [ -n "$WXDEBUG" ]; then
1098 decho
" using libs: '$wx_libs'"
1099 decho
" using_gui = $using_gui"
1104 # Endgame. Nothing left to discover now.
1105 # --------------------------------------------------------------
1107 [ "$using_gui" = "yes" ] || _gui_cppflags
="-DwxUSE_GUI=0"
1109 if is_installed
; then
1110 _include_cppflags
="-I${includedir}/wx-@WX_RELEASE@@WX_FLAVOUR@"
1112 _include_cppflags
="-I${includedir} -I${prefix}/contrib/include"
1115 _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@")
1117 # now without further ado, we can answer these too.
1118 [ -z "$output_option_cppflags" ] || echo $_cppflags
1119 [ -z "$output_option_cflags" ] || echo $_cppflags "@CODE_GEN_FLAGS@"
1120 [ -z "$output_option_cxxflags" ] || echo $_cppflags "@CODE_GEN_FLAGS@" "@CODE_GEN_FLAGS_CXX@"
1121 [ -z "$output_option_gl_libs" ] || echo $(lib_flags_for gl)
1122 [ -z "$output_option_linkdeps" ] || echo $link_deps
1124 if [ -n "$output_option_libs" ]; then
1126 is_cross
&& [ "x$libdir" = "x/usr/${target}/lib" ] \
1127 || [ "x$libdir" = "x/usr/lib" ] \
1128 || _ldflags
="-L$libdir"
1130 is_installed
|| [ -n "$flag_option_no_rpath" ] || _rpath
="@WXCONFIG_RPATH@"
1132 echo $_ldflags "@LDFLAGS@" $_rpath $wx_libs "@DMALLOC_LIBS@"
1135 # And so that's it, we're done. Have a nice build.