+ 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"
+}
+
+
+
+# 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 lets 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
+ ;;
+
+ --*)
+ _name=$(option_name $arg)
+ if validate_arg wxconfig flag "$_name" yes ||
+ validate_arg wxconfig output "$_name" yes
+ then
+ continue
+ fi
+ ;;
+
+ *)
+ # FIXME Surely we can validate the parameters too ...
+ input_parameters="${input_parameters:+$input_parameters }$arg"
+ 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 debug debugtype debug release
+check_yesno_option static linkage '-static'
+
+
+# Dump everything we just read in debug mode.
+if [ -n "$WXDEBUG" ]; then
+
+ decho
+ decho " input parameters = $input_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
+
+fi
+
+
+
+# Everything came in as a legal argument then, lets 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 psuedo-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
+ eval echo "\${$1_host}\${$1_toolkit}\${$1_widgetset}-\${$1_chartype}-\${$1_debugtype}\${$1_linkage}-\${$1_version}\${$1_flavour}"
+}
+
+# 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="@WX_CHARTYPE@"
+this_debugtype="@WX_DEBUGTYPE@"
+this_flavour="@WX_FLAVOUR@"
+this_version="@WX_RELEASE@"
+this_linkage=$( [ "x@SHARED@" = "x1" ] || echo '-static' )
+
+this_config=$(get_mask this)
+
+# Extract the user specification from the options parsed.
+m_host=${input_option_host:+${input_option_host}-?}
+m_host=${m_host:-${input_option_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)?}
+
+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" ]; }
+
+# 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 lets 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 [ "x\${$1_debugtype}" != "xdebug" ] || _debug_flag=d
+ eval echo "wx\${$1_toolkit}${_unicode_flag}${_debug_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)
projects / wxWidgets.git / blobdiff