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