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