forked from wxWidgets/wxWidgets
-
Notifications
You must be signed in to change notification settings - Fork 1
/
wx-config.in
executable file
·1401 lines (1148 loc) · 47.5 KB
/
wx-config.in
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
#!/bin/sh
#
# Name: wx-config{.in,}
# Purpose: wx configuration search and query tool {template,}
# Author: Ron <ron@debian.org>
# Modified by:
# Created: 8/9/2004
# Copyright: (c) 2004 Ron <ron@debian.org>
# Essentially a fresh start this time around, but for maximum
# compatibility basic code was taken from, and heavy reference
# made to, the previously unattributed wx-config from cvs.
# All the usual suspects contributed to the dicussion that led
# to this new work and likewise to the ideas and content in the
# original (which was probably influenced by gtk), among them:
# Robert Roebling, Vadim Zeitlin, Vaclav Slavik, Robin Dunn
# Licence: wxWindows licence
############################################################################
# Extra^2 debug mode, for if things ever get really weird.
[ -z "$WXDEBUG_X" ] || set -x
# On with some basic stuff, like the ability to die gracefully,
# and to tell people what we are about.
# ------------------------------------------------------------------
# decho _message
# Output a message to stderr.
decho() { echo "$*" 1>&2; }
# usage _exitcode
# Outputs a usage message to stderr and exits with _exitcode.
# Try to keep this to a single page (ie. < 25 lines). We can add
# alternate or interactive help targets if people want more detail.
#
# Exit codes are now subject to a more strict interpretation.
# wx-config should return 0 upon successful operation, 1 if the
# reqested operation could not be completed successfully, and 2
# if the requested operation is not supported by this version of
# wx-config.
usage()
{
cat 1>&2 <<EOF
wx-config [--prefix[=DIR]] [--exec-prefix[=DIR]] [--release] [--version-full]
[--list] [--selected-config] [--host=HOST] [--toolkit=TOOLKIT]
[--universal[=yes|no]] [--unicode[=yes|no]] [--static[=yes|no]]
[--debug[=yes|no]] [--version[=VERSION]] [--flavour=FLAVOUR]
[--basename] [--cc] [--cxx]
[--cppflags [base]] [--cxxflags [base]] [--cflags]
[--rescomp] [--linkdeps] [--ld] [--utility=UTIL]
[--libs [LIBS...]] [--optional-libs [LIBS...]]
wx-config returns information about the wxWidgets libraries available on
your system. It may be used to retrieve the information required to build
applications using these libraries using --cppflags, --cxxflags, --cflags,
and --libs options. And you may query the properties of this configuration
using --query-{host,toolkit,widgetset,chartype,debugtype,version,flavour,
linkage}.
NOTE: Usage of --debug and --query-debugtype are only relevant if you
have any versions prior to 2.9 installed and use the --version option to
select an earlier version. Similarly, usage of --unicode is only relevant
if a version prior to 3.3 is used, as all later ones always use Unicode.
If multiple builds of wxWidgets are available, you can use the options
--prefix, --host, --toolkit, --unicode, --static, --universal, --version
or --flavour to select from them. The --selected-config option shows the
name of the current configuration and --list shows available alternatives
which match specified criteria. The --utility option returns the correct
version of UTIL to use with the selected build. The --linkdeps option
returns only static libraries for your makefile link rule dependencies.
The LIBS arguments (comma or space separated) may be used to specify the
wxWidgets libraries that you wish to use. The "std" label may be used to
import all libraries that would be used by default if none were specified
explicitly, e.g. wx-config --libs core,base. The "all" label may be used
to import all libraries that have been compiled which are shown in the
list below. The --optional-libs parameter should be followed by a list
of libs that should be linked to, but only if they are available.
Available libraries in this build are:
@BUILT_WX_LIBS@
EOF
exit $1
}
# Unfussy people are the easiest to deal with, get them out of the way now.
[ $# -gt 0 ] || usage 1
# Contentious tools determined by configure.
EGREP="@EGREP@"
# For the people who know what they want, or think they do:
# Divide the valid arguments into functional groups for later examination,
# then parse all command line arguments completely, deferring action on
# output options until all significant input has been processed and any
# decision about delegation has been taken.
# Note early, that '-' is a complete no-no for use in option names below.
# It totally falls apart as soon as it becomes part of a variable name.
# Use '_' instead, and by the magic of it all just being bits, you'll
# be able to use --my-option or --my_option from the command line at
# your discretion. They are synonymous as user input, but _ALWAYS_ use
# underscores for compound names in the code here, never a dash.
# The list of all options we recognise. If it is not in here, then
# it is not something we want to handle.
# ------------------------------------------------------------------
# Options that specify a distinct library build.
#
# Note also that order in this list is significant later on, as this sets
# the precedence with which we will try to gauge the similarity of other
# configs to this one. Options earlier in the list should be more crucial
# to match well than those that follow. Options specified by the user will
# always take precedence and are not subject to any partial ordering here.
wxconfig_schema="host toolkit widgetset chartype debugtype flavour version linkage"
# Options that are expected to generate some output.
wxconfig_output_options="prefix exec_prefix
list
release version version_full
basename
cppflags cflags cxxflags
rescomp
rezflags
libs
optional_libs
linkdeps
cc cxx ld
gl_libs"
# Options that permit the user to supply hints that may affect the output.
# These options all accept arbitrary values, to interpret as they please.
wxconfig_input_options="prefix exec_prefix utility $wxconfig_schema"
# Input options that accept only a yes or no argument.
#
# Notice that this includes "debug" but it is done only for compatibility, this
# options (i.e. --debug[=yes] or --debug=no) is completely ignored as there is
# no distinction between debug and release builds in wx any more
#
# For "unicode", the situation is similar except that specifying --unicode=no
# will always fail with this wxWidgets version.
wxconfig_yesno_options="universal unicode debug static"
# Boolean options that do something or not.
wxconfig_flag_options="$wxconfig_yesno_options selected_config no_rpath inplace"
# Some simple sugar coating to keep things more readable below.
# --------------------------------------------------------------
# option_name _string
# Returns NAME if _string is of the form: --NAME[=...]
option_name()
{
echo "$1" | sed -e 's/^--//' -e 's/=.*//' -e s/-/_/g
}
# option_value _string
# Returns FOO if _string is of the form: --option=FOO
option_value()
{
echo "$1" | sed 's/^[^=]*=//'
}
# match_field _value _list
# Returns true if _value is a field in _list
match_field()
{
_match_field_match="$1"
shift
for _match_field_i do
[ "x$_match_field_i" != "x$_match_field_match" ] || return 0
done
false
}
# remove_field _value _list
# Returns _list minus any field(s) that match _value.
remove_field()
{
_remf_value="$1"
_remf_list=''
shift
if [ -n "$_remf_value" ]; then
for _remf_item do
[ "x$_remf_item" = "x$_remf_value" ] ||
_remf_list="${_remf_list:+$_remf_list }$_remf_item"
done
echo "$_remf_list"
else
echo $*
fi
}
# validate_arg _domain _set _name _value
# Boilerplate to validate an argument and initialise a pseudo-hash.
# This one is almost reduction into absurdity, and perhaps makes the
# precise action of the argument parser below just a little more
# obscure, but oh so neat and compact to use for multiple option
# groups. It expands to replace repetitive clauses of the form:
#
# i="$(option_name $arg)"
# if match_field "$i" $wxconfig_input_options; then
# input_options="${input_options:+$input_options }$i"
# eval "input_option_$i=$(option_value $arg)"
# continue
# fi
#
# with the one liners you see on the page below.
validate_arg()
{
if match_field "$3" `eval echo \"\\\$$1_$2_options\"`; then
eval "$2_options=\"\${$2_options:+\$$2_options }$3\""
eval "$2_option_$3=\"$4\""
return
fi
false
}
# check_yesno_option _ynoption _option _yesval _noval
# This one might be made more generic and/or incorporated into
# validate_arg above at some later stage, but right now we just
# condition any specialist options into a generic one for later
# handling. Once they are sanity checked there is no difference
# in any case.
check_yesno_option()
{
eval "case \${yesno_option_$1-\${flag_option_$1-unset}} in
unset) ;;
y*|Y*) input_option_$2=\"$3\" ;;
n*|N*) input_option_$2=\"$4\" ;;
*)
decho
decho \" *** Error: Invalid request '--$1=\$yesno_option_$1'\"
decho \" Valid arguments for --$1 are: [ yes, no ]\"
decho
exit 1
;;
esac"
}
MAC_FRAMEWORK=
MAC_FRAMEWORK_PREFIX=
# Now we are ready to find out what the user wants from us.
# --------------------------------------------------------------
# With just a little more complexity here we could have shortest
# unique string matching for options, but that is probably overkill
# today, so let's just get the job done.
#
# The important thing now then is that we simply read all input from
# the user and don't try to act prematurely on partial information.
# --help or an illegal argument are the only shortcuts out of here
# at this point, otherwise, it's time to just shut up and listen for
# a moment.
for arg do
case "$arg" in
--help|-h)
usage
;;
--*=*)
_name=`option_name $arg`
_value=`option_value $arg`
if validate_arg wxconfig input "$_name" "$_value" ||
validate_arg wxconfig yesno "$_name" "$_value"
then
continue
fi
;;
--query-*)
_name=`echo $arg | sed 's/^--query-//'`
if match_field "$_name" $wxconfig_schema
then
query_options="${query_options:+$query_options }$_name"
continue
fi
;;
--*)
_name=`option_name $arg`
if validate_arg wxconfig flag "$_name" yes ||
validate_arg wxconfig output "$_name" yes
then
continue
fi
;;
*)
# We validate the parameters later ...
if [ "$_name" = "cxxflags" ] || [ "$_name" = "cppflags" ] || [ "$_name" = "cflags" ]; then
cxx_parameters="${cxx_parameters:+$cxx_parameters }$arg"
elif [ "$_name" = "libs" ]; then
libs_parameters="${libs_parameters:+$libs_parameters }$arg"
elif [ "$_name" = "optional_libs" ]; then
optional_libs_parameters="${optional_libs_parameters:+$optional_libs_parameters }$arg"
else
# normally anything here are unattached arguments and signify an
# error but for compatibility with the 2.8 wx-config and,
# especially, configure scripts generated using 2.8 wxwin.m4 and
# hence doing `wx-config --version base,std`, we ignore anything
# following this option, just as 2.8 version used to do
if [ "$_name" != "version" ]; then
input_parameters="${input_parameters:+$input_parameters }$arg"
fi
fi
continue
;;
esac
decho " *** Error: Unrecognised option: '$arg'"
decho "Use wx-config --help for information on command line options."
exit 2
done
# validate_arg only checks and decomposes form. Sanity check the yes/no
# options now too and push their respective mask values into place.
check_yesno_option universal widgetset univ
check_yesno_option unicode chartype unicode ansi
check_yesno_option static linkage static
check_yesno_option debug debugtype debug release
# Dump everything we just read in debug mode.
if [ -n "$WXDEBUG" ]; then
decho
decho " input parameters = $input_parameters"
decho " libs parameters = $libs_parameters"
decho " optional-libs parameters = $optional_libs_parameters"
decho " input options = $input_options"
for i in $input_options; do
decho " $i = `eval echo \"\\\$input_option_$i\"`"
done
decho " yes/no options = $yesno_options"
for y in $yesno_options; do
decho " $y = `eval echo \"\\\$yesno_option_$y\"`"
done
decho " flag options = $flag_options"
for f in $flag_options; do
decho " $f = `eval echo \"\\\$flag_option_$f\"`"
done
decho " output options = $output_options"
for o in $output_options; do
decho " $o = `eval echo \"\\\$output_option_$o\"`"
done
decho " query options = $query_options"
fi
# Everything came in as a legal argument then, let's put some of
# the pieces together with a little self knowledge to see what
# we should do next.
# --------------------------------------------------------------
# get_mask [ _hash ]
# Construct a config filename mask from a pseudo-hash of component variables.
# The optional argument is the prefix of the hash to use. If not specified
# this will return a mask derived from the command line options that were used.
get_mask()
{
[ $# -gt 0 ] || set m
case "$m_ourversion" in
2.9)
is29orlater=1
;;
2.*)
# there is no 2.10 so currently everything else is <= 2.8
is29orlater=0
;;
*)
# 3.x and later "is29orlater" too
is29orlater=1
;;
esac
# use 2.8 or 2.9 version of the mask: the difference is the presence of
# debug type in pre-2.9
if [ $is29orlater = 1 ]; then
eval echo "\${$1_host:+\$$1_host-}\${$1_toolkit}\${$1_widgetset}-\${$1_chartype}\${$1_linkage:+-\$$1_linkage}-\${$1_version}\${$1_flavour}"
else
eval echo "\${$1_host:+\$$1_host-}\${$1_toolkit}\${$1_widgetset}-\${$1_chartype}-\${$1_debugtype}\${$1_linkage:+-\$$1_linkage}-\${$1_version}\${$1_flavour}"
fi
}
# Returns true if this script is for a cross compiled config.
is_cross() { [ "x@cross_compiling@" = "xyes" ]; }
# Determine the base directories we require.
prefix=${input_option_prefix-${this_prefix:-@prefix@}}
exec_prefix=${input_option_exec_prefix-${input_option_prefix-${this_exec_prefix:-@exec_prefix@}}}
wxconfdir="@libdir@/wx/config"
installed_configs=`cd "$wxconfdir" 2> /dev/null && ls | grep -v "^inplace-"`
is_cross && target="@host_alias@"
# Define a pseudo-hash to contain the specification of this wx-config
# instance and its associated library.
this_host="${target:+${target}}"
this_toolkit="@TOOLKIT_DIR@@TOOLKIT_VERSION@"
this_widgetset="@WIDGET_SET@"
this_chartype="unicode"
this_debugtype="release"
this_flavour="@WX_FLAVOUR@"
this_version="@WX_RELEASE@"
this_linkage=`[ "x@SHARED@" = "x1" ] || echo 'static'`
# Extract the user specification from the options parsed.
m_host=${input_option_host:+"${input_option_host}-?"}
m_host=${m_host:-$this_host}
m_toolkit=${input_option_toolkit:-'[^-]+'}
m_widgetset=${input_option_widgetset-'(univ)?'}
m_chartype=${input_option_chartype:-'(unicode|ansi)'}
m_debugtype=${input_option_debugtype:-'(debug|release)'}
m_flavour=${input_option_flavour:+-$input_option_flavour}
m_flavour=${m_flavour:-${input_option_flavour-'(-[^-]+)?'}}
m_version=${input_option_version:-'[0-9]+\.[0-9]+'}
m_linkage=${input_option_linkage-'?(static)?'}
# Test whether or not --version has been specified
#
# This must be done after getting the input options so get_mask works correctly
# since it is version-dependent
if [ -z "$input_option_version" ]; then
m_ourversion="2.9"
else
m_ourversion=$m_version
fi
this_config=`get_mask this`
configmask="^`get_mask`$"
# Dump the user specification in debug mode.
if [ -n "$WXDEBUG" ]; then
decho
decho " prefix = '$prefix'"
decho " exec_prefix = '$exec_prefix'"
decho " wxconfdir = '$wxconfdir'"
decho " m_host = '$m_host'"
decho " m_toolkit = '$m_toolkit'"
decho " m_widgetset = '$m_widgetset'"
decho " m_chartype = '$m_chartype'"
decho " m_debugtype = '$m_debugtype'"
decho " m_flavour = '$m_flavour'"
decho " m_version = '$m_version'"
decho " m_linkage = '$m_linkage'"
decho " configmask = '$configmask'"
decho " this config = '$this_config'"
decho
fi
# From here on, we'll need to be able to figure out a delegation target.
# -----------------------------------------------------------------------
# The rules for delegation are:
#
# 1. If the specification is so general that it matches the default config
# (ie. this one on a first pass), then the default config will be used
# even if other installed libs would also match the spec.
#
# 2. If the default config does not match, find a list of all installed
# libraries that do match.
# a. If that list is empty, the specification is incompatible
# with any installed lib. Warn and abort.
# b. If that list contains exactly one candidate. Delegate to
# that candidate.
# c. If the list contains multiple candidates, pass on to step 3.
#
# 3. Attempt to discriminate among rival candidates by their similarity
# to the default configuration (ie. this one). If we can find a unique
# candidate in this way, delegate to it. If not, present a list of
# options to the user and request that they disambiguate it with one or
# more additional fields.
#
# To refine the specified pattern, we specialise each unbound field
# using the default value from this config file. If that results in
# no matches, we unbind it again and try the next field. If it still
# results in multiple matches we try binding the next field as well
# until a unique or null result again occurs.
#
# A more general way to look at this, is the feature specifiers are all
# modifiers of the wx-config you are calling. If you supply none, the
# default for that build configuration will be used. If you supply one
# or more that the default build cannot satisfy, it will try to find the
# config most like itself with the desired feature(s) enabled.
# The features configured into the first wx-config called will be taken
# as implicitly specified if it is necessary to disambiguate likely
# candidates from the information that was explicitly provided.
# But first, more sugar to keep what follows clear and legible.
# --------------------------------------------------------------
# find_eligible_delegates _mask
# Outputs all the config files installed which match the
# (extended regex) _mask passed as an argument.
find_eligible_delegates() { echo "$installed_configs" | $EGREP "$1" 2> /dev/null; }
# user_mask_fits _config
# Returns true if the string _config satisfies the user specified mask.
user_mask_fits() { echo "$1" | $EGREP "$configmask" > /dev/null 2>&1; }
# count_fields _word
# Returns the number of IFS split fields in _word
count_fields() { return $#; }
# count_delegates _mask
# Return the number of eligible config files that match _mask
count_delegates() { count_fields `find_eligible_delegates $1`; }
# is_set _variablename
# Returns true if $_variablename is initialised.
is_set() { [ "x`eval echo \"\\\${$1-unset}\"`" != "xunset" ]; }
# not _cmd _args...
# true iff _cmd is false
not() { if "$@"; then false; else true; fi; }
# do_find_best_delegate _unbound-options
# The real worker part of find_best_delegate below. Recurses though all
# unbound options binding them one at a time to the default derived from
# this file until a unique match is made or no alternatives remain that
# may be sensibly guessed at. It will preferentially bind the unspecified
# options in the order they are listed in wxconfig_schema. Using this
# partial ordering it should find the first match with the most significant
# similarity to this file that unambiguously meets the user specification.
# If such a match exists it will be output to stdout.
#
# Be careful if you modify this function. If the pruning logic is rendered
# inoperative it will simply recurse over every permutation in the search
# space, which may still appear to work, but add a couple more options (or
# explicitly specify a few less) and you may not live long enough to learn
# the result. WXDEBUG=findprogress is your friend here, it will show you
# how many nodes get searched before a result. If you start seeing
# increases in that number for the same input, check your work.
# Raising the number of discriminating options from 6 to 8 raised the worst
# case time for this to run (without pruning) from 3 to nearly 15 seconds
# and its downhill fast from here if we have to ride that boat.
# Early pruning still gets that down to under half a second (up from about
# .25), so we have some breathing space yet before a different search method
# will be called for, but let's not squander it.
do_find_best_delegate()
{
(
if [ "x$WXDEBUG" = "xverbose" ]; then
_fbd_indent="${_fbd_indent}. "
decho " $_fbd_indent---> unbound options: $*"
fi
for i do
if [ "x$WXDEBUG" = "xverbose" ]; then
decho " ${_fbd_indent}binding '$i' with '`remove_field $i $*`' still free"
[ -z "$_pruned" ] || decho " ${_fbd_indent} --- pruned: $_pruned ---"
fi
if (
eval m_$i=\$this_$i
_mask="^`get_mask`$"
if [ "x$WXDEBUG" = "xverbose" ]; then
decho " ${_fbd_indent} checking: $_mask"
count_delegates "$_mask"
decho " $_fbd_indent $? eligible delegates"
for d in `find_eligible_delegates "$_mask"`; do
decho " ${_fbd_indent} $d"
done
fi
count_delegates "$_mask"
_still_eligible=$?
if [ $_still_eligible -eq 1 ]; then
echo `find_eligible_delegates "$_mask"`
return
fi
[ "x$WXDEBUG" != "xfindprogress" ] || printf "." 1>&2
[ $_still_eligible -gt 1 ] && [ $# -gt 1 ] &&
do_find_best_delegate `remove_field $i $*`
)
then
return
elif [ $# -gt 1 ]; then
if [ "x$WXDEBUG" = "xverbose" ]; then
decho " ${_fbd_indent}pruning: $i"
_pruned="${_pruned:+$_pruned }$i"
fi
set `remove_field $i $*`
fi
done
false
)
}
# find_best_delegate
# A simple wrapper around do_find_best_delegate that first determines
# the unbound options (ie. the ones that the user did not explicitly
# declare a preference for on the command line)
find_best_delegate()
{
for _fbdi in $wxconfig_schema; do
is_set input_option_$_fbdi ||
_unbound_options="${_unbound_options:+$_unbound_options }$_fbdi"
done
do_find_best_delegate $_unbound_options
}
# Legacy wx-config helpers.
# -------------------------
# get_legacy_mask
# Returns a mask in the format used by wx2.4.
get_legacy_mask()
{
[ $# -gt 0 ] || set m
eval [ "x\${$1_chartype}" != "xunicode" ] || _unicode_flag=u
eval echo "wx\${$1_toolkit}${_unicode_flag}-\${$1_version}\${$1_host}-config"
}
# find_legacy_configs
# Returns a list of configs installed by wx2.4 releases.
find_legacy_configs()
{
(
cd "$prefix/bin" &&
{
ls wx*-2.4-config | grep -v ^wxbase
ls wx*-2.4-config | grep ^wxbase
}
) 2> /dev/null
}
# find_best_legacy_config
# Returns the best legacy config for a given specification.
# This assumes no matching new style config has been found.
find_best_legacy_config()
{
_legacy_configs=`find_legacy_configs`
if [ -n "$_legacy_configs" ]; then
_legacy_mask=`get_legacy_mask`
for d in $_legacy_configs; do
if echo $d | $EGREP $_legacy_mask > /dev/null 2>&1 ; then
echo "$d"
return
fi
done
fi
false
}
# The only action we can perform authoritatively prior to delegation
# is to list all the possible delegates.
# --------------------------------------------------------------
config_spec="$0 $*"
[ -z "$WXDEBUG" ] || config_spec=$configmask
# Next chance for another satisfied customer then
#
# If we want to get really polished here we can do plural checking,
# but we should probably leave that until the day we gettextise it.
if [ -n "$output_option_list" ]; then
_remains_in_prefix=$installed_configs
_delegates=`find_eligible_delegates $configmask`
_best_delegate=`find_best_delegate`
if [ "x$WXDEBUG" = "xverbose" ]; then
decho
decho " all = $_remains_in_prefix"
decho " matching = $_delegates"
decho " best = $_best_delegate"
decho " this = $this_config"
fi
for d in $_delegates; do
_remains_in_prefix=`remove_field $d $_remains_in_prefix`
done
echo
echo " Default config is $this_config"
echo
if user_mask_fits "$this_config" ; then
echo " Default config ${this_exec_prefix+in $this_exec_prefix }will be used for output"
if match_field "$this_config" $_delegates ; then
_delegates=`remove_field $this_config $_delegates`
else
echo " though it is not installed in: $prefix"
if [ -n "$_best_delegate" ] && [ "x$_best_delegate" != "x$this_config" ]; then
echo
echo " Best alternate in $prefix:"
echo " $_best_delegate"
fi
fi
elif [ -n "$_best_delegate" ]; then
echo " Specification best match: $_best_delegate"
elif [ -z "$_delegates" ]; then
_last_chance=`find_best_legacy_config`
if [ -n "$_last_chance" ]; then
echo " Specification matches legacy config: $_last_chance"
else
cat <<-EOF
No config found to match: $config_spec
in $wxconfdir
Please install the desired library build, or specify a different
prefix where it may be found. If the library is not installed
you may call its wx-config directly by specifying its full path.
EOF
fi
else
echo " Specification was ambiguous. Use additional feature options"
echo " to choose between alternate matches."
fi
_delegates=`remove_field "$_best_delegate" $_delegates`
if [ -n "$_delegates" ]; then
echo
echo " Alternate matches:"
for d in $_delegates; do
echo " $d"
done
fi
if [ -n "$_remains_in_prefix" ]; then
echo
echo " Also available in $prefix:"
for d in $_remains_in_prefix; do
echo " $d"
done
fi
_legacy_configs=`find_legacy_configs`
if [ -n "$_legacy_configs" ]; then
echo
echo " Legacy configs available in $prefix:"
for d in $_legacy_configs; do
echo " $d" | sed 's/-config$//'
done
fi
echo
exit
fi
# ... so if that wasn't what they wanted, then we need to know for
# certain, can this config satisfy the user specification?
# --------------------------------------------------------------
if not user_mask_fits "$this_config" ; then
# No? Then let's see if it knows anybody who can.
# But first, just be sure someone hasn't typo'd us into a loop.
# In present day wx, correct delegation should never need more
# than one hop so this is trivial to detect.
if [ -n "$WXCONFIG_DELEGATED" ]; then
decho
decho " *** Error: Bad config delegation"
decho
decho " to: $0"
decho " ($this_config) cannot satisfy:"
decho " $config_spec"
decho " Someone has been terribly careless."
decho
exit 1
fi
count_delegates "$configmask"
_numdelegates=$?
if [ -n "$WXDEBUG" ]; then
decho " must delegate to an alternate config"
decho " potential delegates ($_numdelegates):"
for i in `find_eligible_delegates "$configmask"`; do
decho " $i"
done
fi
if [ $_numdelegates -eq 0 ]; then
_last_chance=`find_best_legacy_config`
if [ -n "$_last_chance" ]; then
for arg do
case "$arg" in
--prefix*|--exec-prefix*| \
--version|--release|--basename| \
--static|--libs|--gl_libs| \
--cppflags|--cflags|--cxxflags| \
--cc|--cxx|--ld| \
--rezflags|--inplace)
_legacy_args="$_legacy_args $arg"
;;
--static|--static=y*|--static=Y*)
_legacy_args="$_legacy_args --static"
;;
esac
done
if [ -n "$WXDEBUG" ]; then
decho " found a suitable legacy delegate: $_last_chance"
decho "--> $prefix/bin/$_last_chance $_legacy_args"
fi
WXCONFIG_DELEGATED=yes
export WXCONFIG_DELEGATED
$prefix/bin/$_last_chance $_legacy_args
exit
else
cat 1>&2 <<-EOF
Warning: No config found to match: $config_spec
in $wxconfdir
If you require this configuration, please install the desired
library build. If this is part of an automated configuration
test and no other errors occur, you may safely ignore it.
You may use wx-config --list to see all configs available in
the default prefix.
EOF
# PIPEDREAM: from here we are actually just a teensy step
# from simply building the missing config for the user
# on the fly if this is an in tree wx-config.
exit 1
fi
fi
if [ $_numdelegates -gt 1 ]; then
[ -z "$WXDEBUG" ] || decho " must prune the list of eligible delegates"
best_delegate=`find_best_delegate`
if [ -n "$best_delegate" ]; then
if [ -n "$WXDEBUG" ]; then
decho " found a suitable delegate: $best_delegate"
decho "--> $wxconfdir/$best_delegate $*"
fi
WXCONFIG_DELEGATED=yes
export WXCONFIG_DELEGATED
$wxconfdir/$best_delegate $*
exit
fi
decho
decho " *** Error: Specification is ambiguous"
decho " as $config_spec"
decho " Use additional feature options to choose between:"
for i in `find_eligible_delegates "$configmask"`; do
decho " $i"
done
decho
exit 1
fi
if [ -n "$WXDEBUG" ]; then
decho " using the only suitable delegate"
decho "--> $wxconfdir/`find_eligible_delegates $configmask` $*"
fi
WXCONFIG_DELEGATED=yes
export WXCONFIG_DELEGATED
$wxconfdir/`find_eligible_delegates $configmask` $*
exit
fi
# If we are still here, then from now on we are responsible for
# all the user's needs. Time to rustle up some output for them.
# --------------------------------------------------------------
[ -z "$WXDEBUG" ] || decho " using this config"
# If the user supplied a prefix, and the in tree config did not
# delegate out to anything in that prefix, then reset the build
# tree prefix to provide the correct output for using this
# uninstalled wx build. Or put more simply:
prefix=${this_prefix-$prefix}
exec_prefix=${this_exec_prefix-$exec_prefix}
includedir="@includedir@"
libdir="@libdir@"
bindir="@bindir@"
# Trivial queries we can answer now.
[ -z "$output_option_prefix" ] || echo $prefix
[ -z "$output_option_exec_prefix" ] || echo $exec_prefix
[ -z "$output_option_release" ] || echo "@WX_RELEASE@"
[ -z "$output_option_version" ] || echo "@WX_VERSION@"
[ -z "$output_option_version_full" ] || echo "@WX_SUBVERSION@"
[ -z "$output_option_basename" ] || echo "@WX_LIBRARY_BASENAME_GUI@"
[ -z "$output_option_cc" ] || echo "@CC@"
[ -z "$output_option_cxx" ] || echo "@CXX@"
[ -z "$output_option_ld" ] || echo "@CXX@ -o"
[ -z "$flag_option_selected_config" ] || echo "$this_config"
for q in $query_options; do
eval echo "\$this_$q"
done
# --rezflags is deprecated and disabled (2005/11/29)
if [ -n "$output_option_rezflags" ]; then
echo "@true"
decho "Warning: --rezflags, along with Mac OS classic resource building" \
"is deprecated. You should remove this from your Makefile and" \
"build .app bundles instead."
fi
# The rest are going to need a little more work.
# --------------------------------------------------------------
is_monolithic() { [ "x@MONOLITHIC@" = "x1" ]; }
is_static() { [ -n "$this_linkage" ]; }
is_installed() { [ -z "$this_prefix" ]; }
# Is the user after a support utility?
# If this is a cross build, we need to find and return a suitable
# native utility for the job, so we search:
#
# 1. local build dir (for native uninstalled builds only).
# 2. (optional) user supplied prefix.
# 3. configured install prefix.
# 4. environment $PATH.
#
# and if such a thing still cannot be found, exit signalling an error.
if [ -n "$input_option_utility" ]; then
# This is dumb, in tree binaries should be in a standard location
# like the libs, but work with what we've got for now.
is_cross || _util="$exec_prefix/utils/$input_option_utility/$input_option_utility"
if not is_installed && [ -x "$_util" ]; then
is_static || _preload="eval LD_LIBRARY_PATH=$exec_prefix/lib"