#!/bin/sh

#

# Name: wx-config{.in,}

# Purpose: wx configuration search and query tool {template,}

# Author: Ron <[email protected]>

# Modified by:

# Created: 8/9/2004

# Copyright: (c) 2004 Ron <[email protected]>

# 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()

}

# 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

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()

}

# remove_field _value _list

# Returns _list minus any field(s) that match _value.

remove_field()

}

# 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()

}

# 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()

}

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="@WX_CHARTYPE@"

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"

echo $_preload $_util

exit

fi