mirror of
https://github.com/gnustep/libs-base.git
synced 2025-04-19 22:41:31 +00:00
3950 lines
148 KiB
Text
3950 lines
148 KiB
Text
# configure.ac for GNU Objective-C library
|
|
# Process this file with autoconf to produce a configure script.
|
|
#
|
|
# Copyright (C) 1993,1994, 1995, 1996, 1997 Free Software Foundation, Inc.
|
|
#
|
|
# Written by: Andrew Kachites McCallum <mccallum@cs.rochester.edu>
|
|
# Dept. of Computer Science, U. of Rochester, Rochester, NY 14627
|
|
#
|
|
# This file is part of the GNU Objective-C library.
|
|
#
|
|
# This library is free software; you can redistribute it and/or
|
|
# modify it under the terms of the GNU General Public
|
|
# License as published by the Free Software Foundation; either
|
|
# version 2 of the License, or (at your option) any later version.
|
|
#
|
|
# This library is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
# General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public
|
|
# License along with this library; if not, write to the Free
|
|
# Software Foundation, Inc., 31 Milk Street #960789 Boston, MA 02196 USA
|
|
|
|
#
|
|
# DEPENDENCIES POLICY
|
|
#
|
|
# Generally the aim in the base library is to minimise dependencies on
|
|
# external libraries which may not come as standard on all systems, and
|
|
# you should not, as a rule, add such dependencies.
|
|
#
|
|
# However, in some cases there are large areas of functionality where it
|
|
# would just be too much effort to implement things ourselves and it makes
|
|
# sense to use external software to do the job.
|
|
#
|
|
# In such cases this configure.ac script should include options to allow
|
|
# people to build with the dependency or to disable those parts of the
|
|
# base library which require the external dependency and build without it.
|
|
# The configure script should support a --disable-xxx option in such a case,
|
|
# where 'xxx' is the name of the dependency.
|
|
#
|
|
# If a major dependency is NOT specifically disabled, the configuration
|
|
# process must fail with an error message ... all builds of gnustep-base
|
|
# should support all expected functionality unless the person configuring
|
|
# and building is very certain they don't want it.
|
|
#
|
|
# Where a dependency is introduced this script should do this by setting
|
|
# HAVE_XXX to 1 or 0 and calling AC_SUBST(XXX) to substitute the information
|
|
# into the make files:
|
|
# config.mak.in: used to build the base library itsself
|
|
# base.make.in: the makefile fragment used to build software which uses base
|
|
# These files then define GNUSTEP_BASE_HAVE_XXX to 1 or 0 so that the variable
|
|
# may be used to control conditional compilation of particular files.
|
|
#
|
|
# In addition the values should be substituted into the header file
|
|
# Headers/GNUstepBase/GSConfig.h.in so that it can define a
|
|
# preprocessor constant of the form GS_USE_XXX to 1 or 0, providing a
|
|
# standard mechanism for parts of a particular file to compile to make
|
|
# use of the external code or not.
|
|
# This file is included by all the base library source code, and may also
|
|
# be included by code which uses the base library.
|
|
#
|
|
|
|
builtin(include, config/objc-con-autoload.m4)dnl
|
|
builtin(include, config/objc-sys-dynamic.m4)dnl
|
|
builtin(include, config/procfs-exe-link.m4)dnl
|
|
builtin(include, config/procfs.m4)dnl
|
|
builtin(include, config/pathxml.m4)dnl
|
|
builtin(include, config/pathtls.m4)dnl
|
|
builtin(include, config/codeset.m4)dnl
|
|
builtin(include, config/addlibrarypath.m4)dnl
|
|
builtin(include, config/pkg.m4)dnl
|
|
|
|
AC_INIT
|
|
AC_PREREQ([2.71])
|
|
AC_CONFIG_SRCDIR([Source/NSArray.m])
|
|
|
|
# If GNUSTEP_MAKEFILES is undefined, try to use gnustep-config to determine it.
|
|
if test -z "$GNUSTEP_MAKEFILES"; then
|
|
GNUSTEP_MAKEFILES=`gnustep-config --variable=GNUSTEP_MAKEFILES 2>&5`
|
|
fi
|
|
|
|
if test -z "$GNUSTEP_MAKEFILES"; then
|
|
AC_MSG_ERROR([You must have the gnustep-make package installed and set up the GNUSTEP_MAKEFILES environment variable to contain the path to the makefiles directory before configuring!])
|
|
fi
|
|
|
|
# If LIBRARY_COMBO is undefined, try to use gnustep-config to determine it.
|
|
if test -z "$LIBRARY_COMBO"; then
|
|
LIBRARY_COMBO=`gnustep-config --variable=LIBRARY_COMBO 2>&5`
|
|
fi
|
|
OBJC_RUNTIME_LIB=`echo $LIBRARY_COMBO | tr '-' ' ' | awk '{print $1}'`
|
|
|
|
if test "$OBJC_RUNTIME_LIB" = "ng" -o "$OBJC_RUNTIME_LIB" = "apple"; then
|
|
nonfragile=yes
|
|
BASE_NONFRAGILE_ABI=1
|
|
else
|
|
nonfragile=`gnustep-config --objc-flags | grep _NONFRAGILE_ABI 2>&5`
|
|
if test -z "$nonfragile"; then
|
|
nonfragile=no
|
|
BASE_NONFRAGILE_ABI=0
|
|
else
|
|
nonfragile=yes
|
|
BASE_NONFRAGILE_ABI=1
|
|
fi
|
|
fi
|
|
AC_SUBST(BASE_NONFRAGILE_ABI)
|
|
|
|
MAKECPPFLAGS=`gnustep-config --variable=CPPFLAGS`
|
|
if test "$CPPFLAGS" = ""; then
|
|
CPPFLAGS=$MAKECPPFLAGS
|
|
export CPPFLAGS
|
|
else
|
|
if test "$CPPFLAGS" != "$MAKECPPFLAGS"; then
|
|
AC_MSG_WARN([You are running configure with the preprocessor options ($CPPFLAGS) set to a different value from that used by gnustep-make ($MAKECPPFLAGS). To avoid conflicts/problems, reconfigure/reinstall gnustep-make to use CPPFLAGS=$CPPFLAGS or run the gnustep-base configure again with your CPPFLAGS environment variable set to $MAKECPPFLAGS])
|
|
fi
|
|
fi
|
|
|
|
MAKELDFLAGS=`gnustep-config --variable=LDFLAGS`
|
|
if test "$LDFLAGS" = ""; then
|
|
LDFLAGS=$MAKELDFLAGS
|
|
export LDFLAGS
|
|
else
|
|
if test "$LDFLAGS" != "$MAKELDFLAGS"; then
|
|
AC_MSG_WARN([You are running configure with the link options ($LDFLAGS) set to a different value from that used by gnustep-make ($MAKELDFLAGS). To avoid conflicts/problems, reconfigure/reinstall gnustep-make to use LDFLAGS=$LDFLAGS or run the gnustep-base configure again with your LDFLAGS environment variable set to $MAKELDFLAGS])
|
|
fi
|
|
fi
|
|
|
|
AC_SUBST(BASEFLAGS, `gnustep-config --objc-flags`)
|
|
AC_SUBST(BASELIBS, `gnustep-config --base-libs`)
|
|
|
|
# We shouldn't be loading GNUstep.sh here. It would load in a lot of
|
|
# variables which might get confused with the ones that will be used
|
|
# at runtime. We will load it later once we have determined (and
|
|
# saved) the runtime configuration.
|
|
|
|
# This variable might get temporarily overwritten with the
|
|
# GNUSTEP_MAKEFILES of the runtime configuration, make sure we keep
|
|
# track of the original one. CURRENT_GNUSTEP_MAKEFILES is the one
|
|
# that we use to locate the actual gnustep-make installation that
|
|
# will build the software.
|
|
CURRENT_GNUSTEP_MAKEFILES="$GNUSTEP_MAKEFILES"
|
|
|
|
#--------------------------------------------------------------------
|
|
# Use config.guess, config.sub and install-sh provided by gnustep-make
|
|
# Evaluation order of the configure script means we can not depend on
|
|
# GNUSTEP_MAKEFILES being set for simple variable substitution, so we
|
|
# execute a bit of shell code to dynamically get the directory.
|
|
#--------------------------------------------------------------------
|
|
AC_CONFIG_AUX_DIR([`if test -z "$GNUSTEP_MAKEFILES"; then
|
|
gnustep-config --variable=GNUSTEP_MAKEFILES 2>&5
|
|
else
|
|
echo $GNUSTEP_MAKEFILES
|
|
fi`])
|
|
|
|
|
|
#--------------------------------------------------------------------
|
|
# Use a .h file with #define's, instead of -D command-line switches
|
|
#--------------------------------------------------------------------
|
|
AC_CONFIG_HEADERS([Headers/GNUstepBase/config.h:Headers/GNUstepBase/config.h.in])
|
|
|
|
#--------------------------------------------------------------------
|
|
# Determine the host, build, and target systems
|
|
#--------------------------------------------------------------------
|
|
AC_CANONICAL_TARGET([])
|
|
|
|
#--------------------------------------------------------------------
|
|
# Setup cross-compilation-information
|
|
#--------------------------------------------------------------------
|
|
|
|
AC_ARG_WITH(cross-compilation-info,
|
|
[ --with-cross-compilation-info=PATH
|
|
Specify path to the configuration file that
|
|
contains information for the configure script in
|
|
case of cross compilation. This information
|
|
replaces those obtained from running programmes
|
|
during the configuration phase.],
|
|
cross_result="$withval",
|
|
cross_result="no"
|
|
)
|
|
CROSS_CONFIG="$srcdir/cross.config"
|
|
if test "$cross_result" != "no"
|
|
then
|
|
if test -f "$cross_result" && test -r "$cross_result"
|
|
then
|
|
CROSS_CONFIG="$cross_result"
|
|
else
|
|
AC_MSG_ERROR(["Could not load cross-compilation variables from $cross_result"])
|
|
fi
|
|
fi
|
|
|
|
# import information from the cross-config.
|
|
. "$CROSS_CONFIG"
|
|
|
|
|
|
|
|
#---------------------------------------------------------------------
|
|
# Location of the GNUstep.conf config file (--with-config-file)
|
|
#---------------------------------------------------------------------
|
|
AC_MSG_CHECKING([for GNUstep configuration file to use at runtime])
|
|
|
|
# This requires gnustep-make > 1.13.0 to work. For gnustep-make =
|
|
# 1.13.0 we would have to parse
|
|
# $CURRENT_GNUSTEP_MAKEFILES/$obj_dir/config.make, but $obj_dir is not defined
|
|
# yet at this stage in config, not sure if it's worth trying to make
|
|
# it work. For gnustep-make < 1.13.0 we would have to parse
|
|
# $CURRENT_GNUSTEP_MAKEFILES/config.make.
|
|
GNUSTEP_MAKE_CONFIG=`(grep '^GNUSTEP_CONFIG_FILE *=' $CURRENT_GNUSTEP_MAKEFILES/config-noarch.make | sed -e 's/GNUSTEP_CONFIG_FILE *= *\(.*\)/\1/') 2>&5`
|
|
|
|
# So, for backwards compatiblity, we try the plain config.make too.
|
|
# This should work with gnustep-make < 1.13.0, and with 1.13.0 too if
|
|
# they haven't deleted the file.
|
|
if test "$GNUSTEP_MAKE_CONFIG" = ""; then
|
|
GNUSTEP_MAKE_CONFIG=`(grep '^GNUSTEP_CONFIG_FILE *=' $CURRENT_GNUSTEP_MAKEFILES/config.make | sed -e 's/GNUSTEP_CONFIG_FILE *= *\(.*\)/\1/') 2>&5`
|
|
fi
|
|
|
|
AC_ARG_WITH(config-file,
|
|
[ --with-config-file=PATH Specify path to the GNUstep config file.
|
|
This is the location to be used by the base
|
|
library to locate path information at
|
|
application or tool runtime.
|
|
This file might not even exist now; it is
|
|
not read at configure time. The base library
|
|
will only read it at runtime.
|
|
If unspecified, this uses the same value as
|
|
the GNUstep make package on unix-like systems,
|
|
but uses ./GNUstep.conf on mingw so that
|
|
it is relative to the location of the
|
|
base library DLL.
|
|
If a leading './' is specified, the path
|
|
is taken to be relative to the base library
|
|
linked runtime, not all operating systems
|
|
can support this, so on some platforms you
|
|
may need to specify the location of the
|
|
config file using the GNUSTEP_CONFIG_FILE
|
|
environment variable at runtime.
|
|
If a trailing '/' is specified, the path is
|
|
used for locating domains but no GNUstep
|
|
config file is read at runtime.],
|
|
result="$withval",
|
|
result="no"
|
|
)
|
|
if test "$result" != "no"
|
|
then
|
|
GNUSTEP_TARGET_CONFIG_FILE="$result"
|
|
fi
|
|
if test x"$GNUSTEP_TARGET_CONFIG_FILE" = x""; then
|
|
case "$target_os" in
|
|
mingw*|windows)
|
|
GNUSTEP_TARGET_CONFIG_FILE=./GNUstep.conf ;;
|
|
*)
|
|
GNUSTEP_TARGET_CONFIG_FILE="$GNUSTEP_MAKE_CONFIG" ;;
|
|
esac
|
|
fi
|
|
AC_MSG_RESULT($GNUSTEP_TARGET_CONFIG_FILE)
|
|
|
|
#-----------------------------------------------------------------
|
|
# Whether the GNUstep.conf file path can be set in the environment
|
|
# By default this is enabled on unix, but disabled on mswindows
|
|
# since the normal setup on mswindows is to have the config file
|
|
# located with the base library dll for runtime configuration and
|
|
# use the environment variable to control the developer config file
|
|
# location (used by gnustep-make when building).
|
|
#-----------------------------------------------------------------
|
|
case "$target_os" in
|
|
mingw*|windows) enable_env_config=no;;
|
|
*) enable_env_config=yes;;
|
|
esac
|
|
AC_MSG_CHECKING([whether the GNUstep.conf file path can be set in the environment])
|
|
AC_ARG_ENABLE(environment-config-file,
|
|
[ --disable-environment-config-file
|
|
Disables the use of the GNUSTEP_CONFIG_FILE
|
|
environment variable to specify/override
|
|
the location of the GNUstep config file
|
|
at runtime. This option is occasionally
|
|
useful to disable the environment variable
|
|
for sites which wish to 'lock down' users
|
|
to always work with a specific system-wide
|
|
configuration. On unix-like systems the
|
|
default is for this option to be enabled.
|
|
It is disabled by default on windows systems
|
|
so that the base library will not use a
|
|
config file intended for the gnustep-make
|
|
system (and containing unix-style paths
|
|
which cannot be used by windows apps).
|
|
Normally this should be left at its default
|
|
setting.],
|
|
ac_cv_environment_config_file=$enableval,
|
|
ac_cv_environment_config_file=$enable_env_config)
|
|
if test "$ac_cv_environment_config_file" = "yes"; then
|
|
AC_DEFINE(OPTION_NO_ENVIRONMENT, 0,
|
|
[Enable GNUSTEP_CONFIG_FILE environment variable])
|
|
AC_MSG_RESULT([yes])
|
|
else
|
|
AC_DEFINE(OPTION_NO_ENVIRONMENT, 1,
|
|
[Disable GNUSTEP_CONFIG_FILE environment variable])
|
|
AC_MSG_RESULT([no: disabled from the command-line])
|
|
fi
|
|
|
|
#--------------------------------------------------------------------
|
|
# We are now trying to determine the default GNUstep paths to be
|
|
# used at runtime. So all GNUSTEP_xxx variables from now on are to be
|
|
# considered as 'runtime' ones. They refer to paths that might not
|
|
# make any sense now, but might make sense once gnustep-base is
|
|
# installed in its final location.
|
|
#---------------------------------------------------------------------
|
|
|
|
#
|
|
# Set 'standard' defaults for values from configuration file.
|
|
#
|
|
case "$target_os" in
|
|
*)
|
|
GNUSTEP_SYSTEM_ROOT=/usr/GNUstep/System
|
|
GNUSTEP_LOCAL_ROOT=/usr/GNUstep/Local
|
|
GNUSTEP_NETWORK_ROOT=/usr/GNUstep/Local
|
|
GNUSTEP_USER_DEFAULTS_DIR=GNUstep/Defaults
|
|
GNUSTEP_USER_CONFIG_FILE=.GNUstep.conf
|
|
;;
|
|
esac
|
|
|
|
#---------------------------------------------------------------------
|
|
# Now read/import the existing configuration file, if any
|
|
#---------------------------------------------------------------------
|
|
|
|
# Reading/importing an existing configuration file is good as it means
|
|
# the built-in default paths in the code will match those of your
|
|
# installation (or of the config file you specify).
|
|
# It can be annoying in certain cases though; this option lets you
|
|
# turn it off.
|
|
AC_MSG_CHECKING([if we should import an existing configuration file now])
|
|
AC_ARG_ENABLE(importing-config-file,
|
|
[ --disable-importing-config-file
|
|
Disable importing of an existing GNUstep config
|
|
file and use inbuilt defaults instead.],
|
|
ac_cv_importing_config_file=$enableval,
|
|
ac_cv_importing_config_file="yes")
|
|
if test "$ac_cv_importing_config_file" = "no"; then
|
|
AC_MSG_RESULT([no: disabled from the command-line])
|
|
else
|
|
AC_MSG_RESULT([yes])
|
|
fi
|
|
|
|
|
|
if test "$ac_cv_importing_config_file" = "yes" ;
|
|
then
|
|
AC_MSG_CHECKING([for default GNUstep configuration file to use])
|
|
AC_ARG_WITH(default-config,
|
|
[ --with-default-config=PATH Specify path to a GNUstep config file to be
|
|
imported at configure time (now) and used to
|
|
provide default values for the base library
|
|
to use at runtime if no GNUstep config file
|
|
is found at runtime. If this is not specified
|
|
then the path from the gnustep-make package
|
|
is used.],
|
|
result="$withval",
|
|
result="no"
|
|
)
|
|
if test "$result" != "no"
|
|
then
|
|
GNUSTEP_DEFAULT_CONFIG="$result"
|
|
fi
|
|
if test "$GNUSTEP_DEFAULT_CONFIG" = ""; then
|
|
# No file to import has been specified. We need to read the paths
|
|
# from somewhere though! GNUstep.sh might not have been sourced,
|
|
# so at this stage we have no knowledge of what the paths must be.
|
|
# The only place that we can read them from is the gnustep-make
|
|
# GNUstep.conf file.
|
|
# So we fall back to useing the make settings for the built-in ones.
|
|
# However, on mingw these will be msys style paths, and we don't
|
|
# want that ... so later on we convert these to portable relative
|
|
# paths based on the directory in which the base library will be
|
|
# installed.
|
|
GNUSTEP_DEFAULT_CONFIG="$GNUSTEP_MAKE_CONFIG"
|
|
fi
|
|
AC_MSG_RESULT($GNUSTEP_DEFAULT_CONFIG)
|
|
|
|
#
|
|
# Only try importing if the default config file has been specified.
|
|
#
|
|
if test "$GNUSTEP_DEFAULT_CONFIG" != ""; then
|
|
# Make sure we have a slash in the path so that '.' will source it
|
|
case $GNUSTEP_DEFAULT_CONFIG in
|
|
/*) ;;
|
|
*) GNUSTEP_DEFAULT_CONFIG="./$GNUSTEP_DEFAULT_CONFIG" ;;
|
|
esac
|
|
#
|
|
# Use the default config file to override standard values.
|
|
#
|
|
if test ! -f "$GNUSTEP_DEFAULT_CONFIG"; then
|
|
AC_MSG_RESULT([fail: file "$GNUSTEP_DEFAULT_CONFIG" does not exist])
|
|
# Ohoh ... things are not going well. We are asked to import
|
|
# a config file that doesn't exist. So all paths might be unset
|
|
# and who knows what we'll end up hardcoding into gnustep-base.
|
|
# It looks like we need to make sure the user knows what they
|
|
# are doing, as there is a high chance they don't and might end
|
|
# up with a confused/non-working system. As far as we know, the
|
|
# system might be already screwed. If they don't want to import
|
|
# a config file (eg, they don't have one and they don't care about
|
|
# the hardcoded paths) they should just say so. ;-)
|
|
AC_MSG_ERROR([Please run configure again with the --disable-importing-config-file option or specifying an alternative file using the --with-default-config= option])
|
|
exit 1
|
|
else
|
|
AC_MSG_RESULT([trying to import "$GNUSTEP_DEFAULT_CONFIG"])
|
|
if test -r "$GNUSTEP_DEFAULT_CONFIG"
|
|
then
|
|
AC_MSG_NOTICE([If this fails, please run configure again with the --disable-importing-config-file option or specifying an alternative file using the --with-default-config= option])
|
|
. "$GNUSTEP_DEFAULT_CONFIG"
|
|
else
|
|
AC_MSG_RESULT([fail: file "$GNUSTEP_DEFAULT_CONFIG" is not readable])
|
|
AC_MSG_ERROR([Unable to import configuration file at $GNUSTEP_DEFAULT_CONFIG. Please run configure again with a revised/corrected --with-default-config= option or with --disable-importing-config-file.])
|
|
exit 1
|
|
fi
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
# Now we have the problem of what to do if some of the paths were not
|
|
# set by GNUstep.conf (eg, old gnustep-make), or if no config file was
|
|
# read, or if the config file was corrupt. We decide that the most
|
|
# likely case is an old gnustep-make, so by default we configure the
|
|
# other paths basing on GNUSTEP_*_ROOT.
|
|
|
|
# TODO/FIXME: We should really have better checks once the situation
|
|
# has stabilized. This is a reasonable hack for now.
|
|
|
|
if test x"$GNUSTEP_MAKEFILES" = x""; then GNUSTEP_MAKEFILES=$GNUSTEP_SYSTEM_ROOT/Library/Makefiles; fi
|
|
|
|
if test x"$GNUSTEP_SYSTEM_USERS_DIR" = x""; then GNUSTEP_SYSTEM_USERS_DIR=/home; fi
|
|
if test x"$GNUSTEP_NETWORK_USERS_DIR" = x""; then GNUSTEP_NETWORK_USERS_DIR=/home; fi
|
|
if test x"$GNUSTEP_LOCAL_USERS_DIR" = x""; then GNUSTEP_LOCAL_USERS_DIR=/home; fi
|
|
|
|
if test x"$GNUSTEP_SYSTEM_APPS" = x""; then GNUSTEP_SYSTEM_APPS=$GNUSTEP_SYSTEM_ROOT/Applications; fi
|
|
if test x"$GNUSTEP_SYSTEM_ADMIN_APPS" = x""; then GNUSTEP_SYSTEM_ADMIN_APPS=$GNUSTEP_SYSTEM_ROOT/Applications/Admin; fi
|
|
if test x"$GNUSTEP_SYSTEM_WEB_APPS" = x""; then GNUSTEP_SYSTEM_WEB_APPS=$GNUSTEP_SYSTEM_ROOT/WebApplications; fi
|
|
if test x"$GNUSTEP_SYSTEM_TOOLS" = x""; then GNUSTEP_SYSTEM_TOOLS=$GNUSTEP_SYSTEM_ROOT/Tools; fi
|
|
if test x"$GNUSTEP_SYSTEM_ADMIN_TOOLS" = x""; then GNUSTEP_SYSTEM_ADMIN_TOOLS=$GNUSTEP_SYSTEM_ROOT/Tools/Admin; fi
|
|
if test x"$GNUSTEP_SYSTEM_LIBRARY" = x""; then GNUSTEP_SYSTEM_LIBRARY=$GNUSTEP_SYSTEM_ROOT/Library; fi
|
|
if test x"$GNUSTEP_SYSTEM_LIBRARIES" = x""; then GNUSTEP_SYSTEM_LIBRARIES=$GNUSTEP_SYSTEM_LIBRARY/Libraries; fi
|
|
if test x"$GNUSTEP_SYSTEM_HEADERS" = x""; then GNUSTEP_SYSTEM_HEADERS=$GNUSTEP_SYSTEM_LIBRARY/Headers; fi
|
|
if test x"$GNUSTEP_SYSTEM_DOC" = x""; then GNUSTEP_SYSTEM_DOC=$GNUSTEP_SYSTEM_LIBRARY/Documentation; fi
|
|
if test x"$GNUSTEP_SYSTEM_DOC_MAN" = x""; then GNUSTEP_SYSTEM_DOC_MAN=$GNUSTEP_SYSTEM_LIBRARY/Documentation/man; fi
|
|
if test x"$GNUSTEP_SYSTEM_DOC_INFO" = x""; then GNUSTEP_SYSTEM_DOC_INFO=$GNUSTEP_SYSTEM_LIBRARY/Documentation/info; fi
|
|
|
|
if test x"$GNUSTEP_NETWORK_APPS" = x""; then GNUSTEP_NETWORK_APPS=$GNUSTEP_NETWORK_ROOT/Applications; fi
|
|
if test x"$GNUSTEP_NETWORK_ADMIN_APPS" = x""; then GNUSTEP_NETWORK_ADMIN_APPS=$GNUSTEP_NETWORK_ROOT/Applications/Admin; fi
|
|
if test x"$GNUSTEP_NETWORK_WEB_APPS" = x""; then GNUSTEP_NETWORK_APPS=$GNUSTEP_NETWORK_ROOT/WebApplications; fi
|
|
if test x"$GNUSTEP_NETWORK_TOOLS" = x""; then GNUSTEP_NETWORK_TOOLS=$GNUSTEP_NETWORK_ROOT/Tools; fi
|
|
if test x"$GNUSTEP_NETWORK_ADMIN_TOOLS" = x""; then GNUSTEP_NETWORK_ADMIN_TOOLS=$GNUSTEP_NETWORK_ROOT/Tools/Admin; fi
|
|
if test x"$GNUSTEP_NETWORK_LIBRARY" = x""; then GNUSTEP_NETWORK_LIBRARY=$GNUSTEP_NETWORK_ROOT/Library; fi
|
|
if test x"$GNUSTEP_NETWORK_LIBRARIES" = x""; then GNUSTEP_NETWORK_LIBRARIES=$GNUSTEP_NETWORK_LIBRARY/Libraries; fi
|
|
if test x"$GNUSTEP_NETWORK_HEADERS" = x""; then GNUSTEP_NETWORK_HEADERS=$GNUSTEP_NETWORK_LIBRARY/Headers; fi
|
|
if test x"$GNUSTEP_NETWORK_DOC" = x""; then GNUSTEP_NETWORK_DOC=$GNUSTEP_NETWORK_LIBRARY/Documentation; fi
|
|
if test x"$GNUSTEP_NETWORK_DOC_MAN" = x""; then GNUSTEP_NETWORK_DOC_MAN=$GNUSTEP_NETWORK_LIBRARY/Documentation/man; fi
|
|
if test x"$GNUSTEP_NETWORK_DOC_INFO" = x""; then GNUSTEP_NETWORK_DOC_INFO=$GNUSTEP_NETWORK_LIBRARY/Documentation/info; fi
|
|
|
|
if test x"$GNUSTEP_LOCAL_APPS" = x""; then GNUSTEP_LOCAL_APPS=$GNUSTEP_LOCAL_ROOT/Applications; fi
|
|
if test x"$GNUSTEP_LOCAL_ADMIN_APPS" = x""; then GNUSTEP_LOCAL_ADMIN_APPS=$GNUSTEP_LOCAL_ROOT/Applications/Admin; fi
|
|
if test x"$GNUSTEP_LOCAL_WEB_APPS" = x""; then GNUSTEP_LOCAL_APPS=$GNUSTEP_LOCAL_ROOT/WebApplications; fi
|
|
if test x"$GNUSTEP_LOCAL_TOOLS" = x""; then GNUSTEP_LOCAL_TOOLS=$GNUSTEP_LOCAL_ROOT/Tools; fi
|
|
if test x"$GNUSTEP_LOCAL_ADMIN_TOOLS" = x""; then GNUSTEP_LOCAL_ADMIN_TOOLS=$GNUSTEP_LOCAL_ROOT/Tools/Admin; fi
|
|
if test x"$GNUSTEP_LOCAL_LIBRARY" = x""; then GNUSTEP_LOCAL_LIBRARY=$GNUSTEP_LOCAL_ROOT/Library; fi
|
|
if test x"$GNUSTEP_LOCAL_LIBRARIES" = x""; then GNUSTEP_LOCAL_LIBRARIES=$GNUSTEP_LOCAL_LIBRARY/Libraries; fi
|
|
if test x"$GNUSTEP_LOCAL_HEADERS" = x""; then GNUSTEP_LOCAL_HEADERS=$GNUSTEP_LOCAL_LIBRARY/Headers; fi
|
|
if test x"$GNUSTEP_LOCAL_DOC" = x""; then GNUSTEP_LOCAL_DOC=$GNUSTEP_LOCAL_LIBRARY/Documentation; fi
|
|
if test x"$GNUSTEP_LOCAL_DOC_MAN" = x""; then GNUSTEP_LOCAL_DOC_MAN=$GNUSTEP_LOCAL_LIBRARY/Documentation/man; fi
|
|
if test x"$GNUSTEP_LOCAL_DOC_INFO" = x""; then GNUSTEP_LOCAL_DOC_INFO=$GNUSTEP_LOCAL_LIBRARY/Documentation/info; fi
|
|
|
|
if test x"$GNUSTEP_USER_DIR_APPS" = x""; then GNUSTEP_USER_DIR_APPS=$GNUSTEP_USER_DIR/Applications; fi
|
|
if test x"$GNUSTEP_USER_DIR_ADMIN_APPS" = x""; then GNUSTEP_USER_DIR_ADMIN_APPS=$GNUSTEP_USER_DIR/Applications/Admin; fi
|
|
if test x"$GNUSTEP_USER_DIR_WEB_APPS" = x""; then GNUSTEP_USER_DIR_APPS=$GNUSTEP_USER_DIR/WebApplications; fi
|
|
if test x"$GNUSTEP_USER_DIR_TOOLS" = x""; then GNUSTEP_USER_DIR_TOOLS=$GNUSTEP_USER_DIR/Tools; fi
|
|
if test x"$GNUSTEP_USER_DIR_ADMIN_TOOLS" = x""; then GNUSTEP_USER_DIR_ADMIN_TOOLS=$GNUSTEP_USER_DIR/Tools/Admin; fi
|
|
if test x"$GNUSTEP_USER_DIR_LIBRARY" = x""; then GNUSTEP_USER_DIR_LIBRARY=$GNUSTEP_USER_DIR/Library; fi
|
|
if test x"$GNUSTEP_USER_DIR_LIBRARIES" = x""; then GNUSTEP_USER_DIR_LIBRARIES=$GNUSTEP_USER_DIR/Libraries; fi
|
|
if test x"$GNUSTEP_USER_DIR_HEADERS" = x""; then GNUSTEP_USER_DIR_HEADERS=$GNUSTEP_USER_DIR/Headers; fi
|
|
if test x"$GNUSTEP_USER_DIR_DOC" = x""; then GNUSTEP_USER_DIR_DOC=$GNUSTEP_USER_DIR/Documentation; fi
|
|
if test x"$GNUSTEP_USER_DIR_DOC_MAN" = x""; then GNUSTEP_USER_DIR_DOC_MAN=$GNUSTEP_USER_DIR/Documentation/man; fi
|
|
if test x"$GNUSTEP_USER_DIR_DOC_INFO" = x""; then GNUSTEP_USER_DIR_DOC_INFO=$GNUSTEP_USER_DIR/Documentation/info; fi
|
|
|
|
AC_MSG_CHECKING([for GNUstep-base installation domain])
|
|
AC_ARG_WITH(installation-domain,
|
|
[ --with-installation-domain=DOMAIN
|
|
Specify the domain (SYSTEM, LOCAL,
|
|
NETWORK or USER) into which
|
|
gnustep-base will be installed.
|
|
Whenever relative paths are hardcoded
|
|
into gnustep-base (at the moment, this
|
|
happens only on MinGW) this option
|
|
must be used and must match the domain
|
|
where you will be installing
|
|
gnustep-base.
|
|
If this is not specified, the output of
|
|
gnustep-config --installation-domain-for=gnustep-base
|
|
(which should normally be LOCAL) is used.],
|
|
result="$withval",
|
|
result="no"
|
|
)
|
|
if test "$result" = "no"
|
|
then
|
|
# Check if gnustep-config supports the option
|
|
# --installation-domain-for, and use it if available. That option
|
|
# will automatically use the shell variable GNUSTEP_INSTALLATION_DOMAIN or
|
|
# the installation-domains.conf files (or the LOCAL default) as appropriate.
|
|
# Otherwise, if that option is not available just fall back to
|
|
# using GNUSTEP_INSTALLATION_DOMAIN or (if that was not defiend) LOCAL.
|
|
if (gnustep-config --help | grep installation-domain) >&5 2>&5
|
|
then
|
|
result=`gnustep-config --installation-domain-for=gnustep-base 2>&5`
|
|
else
|
|
AC_MSG_WARN([The 'gnustep-config' script was not found or out of date.])
|
|
result=$GNUSTEP_INSTALLATION_DOMAIN
|
|
if test "$result" = ""
|
|
then
|
|
# This case was added on December 2008 and is only for backwards
|
|
# compatibility with older versions of gnustep-make.
|
|
result=LOCAL
|
|
fi
|
|
fi
|
|
fi
|
|
case "$result" in
|
|
SYSTEM)
|
|
AC_MSG_RESULT([SYSTEM])
|
|
GNUSTEP_BASE_PATH="$GNUSTEP_SYSTEM_TOOLS";;
|
|
LOCAL)
|
|
AC_MSG_RESULT([LOCAL])
|
|
GNUSTEP_BASE_PATH="$GNUSTEP_LOCAL_TOOLS";;
|
|
NETWORK)
|
|
AC_MSG_RESULT([NETWORK])
|
|
GNUSTEP_BASE_PATH="$GNUSTEP_NETWORK_TOOLS";;
|
|
USER)
|
|
AC_MSG_RESULT([USER])
|
|
GNUSTEP_BASE_PATH="$GNUSTEP_USER_TOOLS";;
|
|
*)
|
|
AC_MSG_ERROR([Unknown installation domain '$result' (it should be SYSTEM, LOCAL, NETWORK or USER). Please run configure again with the option --with-installation-domain=LOCAL (or whatever domain you want to install into).])
|
|
exit 1;;
|
|
esac
|
|
# We store GNUSTEP_BASE_DOMAIN in config.mak so that we can check
|
|
# at runtime and make sure it is consistent with the
|
|
# GNUSTEP_INSTALLATION_DOMAIN that is used at runtime.
|
|
GNUSTEP_BASE_DOMAIN=$result
|
|
AC_SUBST(GNUSTEP_BASE_DOMAIN)
|
|
|
|
#
|
|
# If we are on mingw, we now want to convert the paths to relative
|
|
# paths (relative to libgnustep-base.dll).
|
|
#
|
|
case "$target_os" in
|
|
mingw*|windows)
|
|
GNUSTEP_SYSTEM_USERS_DIR="C:\Users"
|
|
GNUSTEP_NETWORK_USERS_DIR="C:\Users"
|
|
GNUSTEP_LOCAL_USERS_DIR="C:\Users"
|
|
|
|
GNUSTEP_SYSTEM_APPS=`$GNUSTEP_MAKEFILES/relative_path.sh $GNUSTEP_BASE_PATH $GNUSTEP_SYSTEM_APPS short`
|
|
GNUSTEP_SYSTEM_ADMIN_APPS=`$GNUSTEP_MAKEFILES/relative_path.sh $GNUSTEP_BASE_PATH $GNUSTEP_SYSTEM_ADMIN_APPS short`
|
|
GNUSTEP_SYSTEM_WEB_APPS=`$GNUSTEP_MAKEFILES/relative_path.sh $GNUSTEP_BASE_PATH $GNUSTEP_SYSTEM_WEB_APPS short`
|
|
GNUSTEP_SYSTEM_TOOLS=`$GNUSTEP_MAKEFILES/relative_path.sh $GNUSTEP_BASE_PATH $GNUSTEP_SYSTEM_TOOLS short`
|
|
GNUSTEP_SYSTEM_ADMIN_TOOLS=`$GNUSTEP_MAKEFILES/relative_path.sh $GNUSTEP_BASE_PATH $GNUSTEP_SYSTEM_ADMIN_TOOLS short`
|
|
GNUSTEP_SYSTEM_LIBRARY=`$GNUSTEP_MAKEFILES/relative_path.sh $GNUSTEP_BASE_PATH $GNUSTEP_SYSTEM_LIBRARY short`
|
|
GNUSTEP_SYSTEM_LIBRARIES=`$GNUSTEP_MAKEFILES/relative_path.sh $GNUSTEP_BASE_PATH $GNUSTEP_SYSTEM_LIBRARIES short`
|
|
GNUSTEP_SYSTEM_HEADERS=`$GNUSTEP_MAKEFILES/relative_path.sh $GNUSTEP_BASE_PATH $GNUSTEP_SYSTEM_HEADERS short`
|
|
GNUSTEP_SYSTEM_DOC=`$GNUSTEP_MAKEFILES/relative_path.sh $GNUSTEP_BASE_PATH $GNUSTEP_SYSTEM_DOC short`
|
|
GNUSTEP_SYSTEM_DOC_MAN=`$GNUSTEP_MAKEFILES/relative_path.sh $GNUSTEP_BASE_PATH $GNUSTEP_SYSTEM_DOC_MAN short`
|
|
GNUSTEP_SYSTEM_DOC_INFO=`$GNUSTEP_MAKEFILES/relative_path.sh $GNUSTEP_BASE_PATH $GNUSTEP_SYSTEM_DOC_INFO short`
|
|
|
|
GNUSTEP_NETWORK_APPS=`$GNUSTEP_MAKEFILES/relative_path.sh $GNUSTEP_BASE_PATH $GNUSTEP_NETWORK_APPS short`
|
|
GNUSTEP_NETWORK_ADMIN_APPS=`$GNUSTEP_MAKEFILES/relative_path.sh $GNUSTEP_BASE_PATH $GNUSTEP_NETWORK_ADMIN_APPS short`
|
|
GNUSTEP_NETWORK_WEB_APPS=`$GNUSTEP_MAKEFILES/relative_path.sh $GNUSTEP_BASE_PATH $GNUSTEP_NETWORK_WEB_APPS short`
|
|
GNUSTEP_NETWORK_TOOLS=`$GNUSTEP_MAKEFILES/relative_path.sh $GNUSTEP_BASE_PATH $GNUSTEP_NETWORK_TOOLS short`
|
|
GNUSTEP_NETWORK_ADMIN_TOOLS=`$GNUSTEP_MAKEFILES/relative_path.sh $GNUSTEP_BASE_PATH $GNUSTEP_NETWORK_ADMIN_TOOLS short`
|
|
GNUSTEP_NETWORK_LIBRARY=`$GNUSTEP_MAKEFILES/relative_path.sh $GNUSTEP_BASE_PATH $GNUSTEP_NETWORK_LIBRARY short`
|
|
GNUSTEP_NETWORK_LIBRARIES=`$GNUSTEP_MAKEFILES/relative_path.sh $GNUSTEP_BASE_PATH $GNUSTEP_NETWORK_LIBRARIES short`
|
|
GNUSTEP_NETWORK_HEADERS=`$GNUSTEP_MAKEFILES/relative_path.sh $GNUSTEP_BASE_PATH $GNUSTEP_NETWORK_HEADERS short`
|
|
GNUSTEP_NETWORK_DOC=`$GNUSTEP_MAKEFILES/relative_path.sh $GNUSTEP_BASE_PATH $GNUSTEP_NETWORK_DOC short`
|
|
GNUSTEP_NETWORK_DOC_MAN=`$GNUSTEP_MAKEFILES/relative_path.sh $GNUSTEP_BASE_PATH $GNUSTEP_NETWORK_DOC_MAN short`
|
|
GNUSTEP_NETWORK_DOC_INFO=`$GNUSTEP_MAKEFILES/relative_path.sh $GNUSTEP_BASE_PATH $GNUSTEP_NETWORK_DOC_INFO short`
|
|
|
|
GNUSTEP_LOCAL_APPS=`$GNUSTEP_MAKEFILES/relative_path.sh $GNUSTEP_BASE_PATH $GNUSTEP_LOCAL_APPS short`
|
|
GNUSTEP_LOCAL_ADMIN_APPS=`$GNUSTEP_MAKEFILES/relative_path.sh $GNUSTEP_BASE_PATH $GNUSTEP_LOCAL_ADMIN_APPS short`
|
|
GNUSTEP_LOCAL_WEB_APPS=`$GNUSTEP_MAKEFILES/relative_path.sh $GNUSTEP_BASE_PATH $GNUSTEP_LOCAL_WEB_APPS short`
|
|
GNUSTEP_LOCAL_TOOLS=`$GNUSTEP_MAKEFILES/relative_path.sh $GNUSTEP_BASE_PATH $GNUSTEP_LOCAL_TOOLS short`
|
|
GNUSTEP_LOCAL_ADMIN_TOOLS=`$GNUSTEP_MAKEFILES/relative_path.sh $GNUSTEP_BASE_PATH $GNUSTEP_LOCAL_ADMIN_TOOLS short`
|
|
GNUSTEP_LOCAL_LIBRARY=`$GNUSTEP_MAKEFILES/relative_path.sh $GNUSTEP_BASE_PATH $GNUSTEP_LOCAL_LIBRARY short`
|
|
GNUSTEP_LOCAL_LIBRARIES=`$GNUSTEP_MAKEFILES/relative_path.sh $GNUSTEP_BASE_PATH $GNUSTEP_LOCAL_LIBRARIES short`
|
|
GNUSTEP_LOCAL_HEADERS=`$GNUSTEP_MAKEFILES/relative_path.sh $GNUSTEP_BASE_PATH $GNUSTEP_LOCAL_HEADERS short`
|
|
GNUSTEP_LOCAL_DOC=`$GNUSTEP_MAKEFILES/relative_path.sh $GNUSTEP_BASE_PATH $GNUSTEP_LOCAL_DOC short`
|
|
GNUSTEP_LOCAL_DOC_MAN=`$GNUSTEP_MAKEFILES/relative_path.sh $GNUSTEP_BASE_PATH $GNUSTEP_LOCAL_DOC_MAN short`
|
|
GNUSTEP_LOCAL_DOC_INFO=`$GNUSTEP_MAKEFILES/relative_path.sh $GNUSTEP_BASE_PATH $GNUSTEP_LOCAL_DOC_INFO short`
|
|
# It would be nice to now store this stuff into a ./GNUstep.conf file
|
|
# installed with gnustep-base.dll. This would clarify.
|
|
;;
|
|
esac
|
|
|
|
GNUSTEP_BASE_RELATIVE_PATHS=no
|
|
|
|
# Now, check if any of the paths is a relative path.
|
|
for path in \
|
|
"$GNUSTEP_SYSTEM_APPS" "$GNUSTEP_SYSTEM_ADMIN_APPS" "$GNUSTEP_SYSTEM_WEB_APPS" \
|
|
"$GNUSTEP_SYSTEM_TOOLS" "$GNUSTEP_SYSTEM_ADMIN_TOOLS" \
|
|
"$GNUSTEP_SYSTEM_LIBRARY" "$GNUSTEP_SYSTEM_LIBRARIES" "$GNUSTEP_SYSTEM_HEADERS" \
|
|
"$GNUSTEP_SYSTEM_DOC" "$GNUSTEP_SYSTEM_DOC_MAN" "$GNUSTEP_SYSTEM_DOC_INFO" \
|
|
"$GNUSTEP_NETWORK_APPS" "$GNUSTEP_NETWORK_ADMIN_APPS" "$GNUSTEP_NETWORK_WEB_APPS" \
|
|
"$GNUSTEP_NETWORK_TOOLS" "$GNUSTEP_NETWORK_ADMIN_TOOLS" \
|
|
"$GNUSTEP_NETWORK_LIBRARY" "$GNUSTEP_NETWORK_LIBRARIES" "$GNUSTEP_NETWORK_HEADERS" \
|
|
"$GNUSTEP_NETWORK_DOC" "$GNUSTEP_NETWORK_DOC_MAN" "$GNUSTEP_NETWORK_DOC_INFO" \
|
|
"$GNUSTEP_LOCAL_APPS" "$GNUSTEP_LOCAL_ADMIN_APPS" "$GNUSTEP_LOCAL_WEB_APPS" \
|
|
"$GNUSTEP_LOCAL_TOOLS" "$GNUSTEP_LOCAL_ADMIN_TOOLS" \
|
|
"$GNUSTEP_LOCAL_LIBRARY" "$GNUSTEP_LOCAL_LIBRARIES" "$GNUSTEP_LOCAL_HEADERS" \
|
|
"$GNUSTEP_LOCAL_DOC" "$GNUSTEP_LOCAL_DOC_MAN" "$GNUSTEP_LOCAL_DOC_INFO"; do
|
|
case "$path" in
|
|
./*) GNUSTEP_BASE_RELATIVE_PATHS=yes ;;
|
|
../*) GNUSTEP_BASE_RELATIVE_PATHS=yes ;;
|
|
esac
|
|
done
|
|
|
|
AC_MSG_CHECKING([if we are hardcoding any relative paths in gnustep-base])
|
|
AC_MSG_RESULT($GNUSTEP_BASE_RELATIVE_PATHS)
|
|
AC_SUBST(GNUSTEP_BASE_RELATIVE_PATHS)
|
|
|
|
#
|
|
# Now, we want to print out the paths that we're going to hardcode
|
|
# into gnustep-base. This is to help users in finding
|
|
# misconfigurations.
|
|
#
|
|
AC_MSG_NOTICE([We store the following filesystem layout into gnustep-base, to be used when no config file is found])
|
|
AC_MSG_CHECKING([for Makefiles directory])
|
|
AC_MSG_RESULT($GNUSTEP_MAKEFILES)
|
|
AC_MSG_CHECKING([for user defaults directory])
|
|
AC_MSG_RESULT($GNUSTEP_USER_DEFAULTS_DIR)
|
|
AC_MSG_CHECKING([for user config file])
|
|
AC_MSG_RESULT($GNUSTEP_USER_CONFIG_FILE)
|
|
|
|
AC_MSG_CHECKING([for System Applications directory])
|
|
AC_MSG_RESULT($GNUSTEP_SYSTEM_APPS)
|
|
AC_MSG_CHECKING([for System Admin Applications directory])
|
|
AC_MSG_RESULT($GNUSTEP_SYSTEM_ADMIN_APPS)
|
|
AC_MSG_CHECKING([for System Web Applications directory])
|
|
AC_MSG_RESULT($GNUSTEP_SYSTEM_WEB_APPS)
|
|
AC_MSG_CHECKING([for System Tools directory])
|
|
AC_MSG_RESULT($GNUSTEP_SYSTEM_TOOLS)
|
|
AC_MSG_CHECKING([for System Admin Tools directory])
|
|
AC_MSG_RESULT($GNUSTEP_SYSTEM_ADMIN_TOOLS)
|
|
AC_MSG_CHECKING([for System Library directory])
|
|
AC_MSG_RESULT($GNUSTEP_SYSTEM_LIBRARY)
|
|
AC_MSG_CHECKING([for System Libraries directory])
|
|
AC_MSG_RESULT($GNUSTEP_SYSTEM_LIBRARIES)
|
|
AC_MSG_CHECKING([for System Headers directory])
|
|
AC_MSG_RESULT($GNUSTEP_SYSTEM_HEADERS)
|
|
AC_MSG_CHECKING([for System Documentation directory])
|
|
AC_MSG_RESULT($GNUSTEP_SYSTEM_DOC)
|
|
AC_MSG_CHECKING([for System Info Documentation directory])
|
|
AC_MSG_RESULT($GNUSTEP_SYSTEM_DOC_INFO)
|
|
AC_MSG_CHECKING([for System Man Documentation directory])
|
|
AC_MSG_RESULT($GNUSTEP_SYSTEM_DOC_MAN)
|
|
|
|
AC_MSG_CHECKING([for Network Applications directory])
|
|
AC_MSG_RESULT($GNUSTEP_NETWORK_APPS)
|
|
AC_MSG_CHECKING([for Network Admin Applications directory])
|
|
AC_MSG_RESULT($GNUSTEP_NETWORK_ADMIN_APPS)
|
|
AC_MSG_CHECKING([for Network Web Applications directory])
|
|
AC_MSG_RESULT($GNUSTEP_NETWORK_WEB_APPS)
|
|
AC_MSG_CHECKING([for Network Tools directory])
|
|
AC_MSG_RESULT($GNUSTEP_NETWORK_TOOLS)
|
|
AC_MSG_CHECKING([for Network Admin Tools directory])
|
|
AC_MSG_RESULT($GNUSTEP_NETWORK_ADMIN_TOOLS)
|
|
AC_MSG_CHECKING([for Network Library directory])
|
|
AC_MSG_RESULT($GNUSTEP_NETWORK_LIBRARY)
|
|
AC_MSG_CHECKING([for Network Libraries directory])
|
|
AC_MSG_RESULT($GNUSTEP_NETWORK_LIBRARIES)
|
|
AC_MSG_CHECKING([for Network Headers directory])
|
|
AC_MSG_RESULT($GNUSTEP_NETWORK_HEADERS)
|
|
AC_MSG_CHECKING([for Network Documentation directory])
|
|
AC_MSG_RESULT($GNUSTEP_NETWORK_DOC)
|
|
AC_MSG_CHECKING([for Network Info Documentation directory])
|
|
AC_MSG_RESULT($GNUSTEP_NETWORK_DOC_INFO)
|
|
AC_MSG_CHECKING([for Network Man Documentation directory])
|
|
AC_MSG_RESULT($GNUSTEP_NETWORK_DOC_MAN)
|
|
|
|
AC_MSG_CHECKING([for Local Applications directory])
|
|
AC_MSG_RESULT($GNUSTEP_LOCAL_APPS)
|
|
AC_MSG_CHECKING([for Local Admin Applications directory])
|
|
AC_MSG_RESULT($GNUSTEP_LOCAL_ADMIN_APPS)
|
|
AC_MSG_CHECKING([for Local Web Applications directory])
|
|
AC_MSG_RESULT($GNUSTEP_LOCAL_WEB_APPS)
|
|
AC_MSG_CHECKING([for Local Tools directory])
|
|
AC_MSG_RESULT($GNUSTEP_LOCAL_TOOLS)
|
|
AC_MSG_CHECKING([for Local Admin Tools directory])
|
|
AC_MSG_RESULT($GNUSTEP_LOCAL_ADMIN_TOOLS)
|
|
AC_MSG_CHECKING([for Local Library directory])
|
|
AC_MSG_RESULT($GNUSTEP_LOCAL_LIBRARY)
|
|
AC_MSG_CHECKING([for Local Libraries directory])
|
|
AC_MSG_RESULT($GNUSTEP_LOCAL_LIBRARIES)
|
|
AC_MSG_CHECKING([for Local Headers directory])
|
|
AC_MSG_RESULT($GNUSTEP_LOCAL_HEADERS)
|
|
AC_MSG_CHECKING([for Local Documentation directory])
|
|
AC_MSG_RESULT($GNUSTEP_LOCAL_DOC)
|
|
AC_MSG_CHECKING([for Local Info Documentation directory])
|
|
AC_MSG_RESULT($GNUSTEP_LOCAL_DOC_INFO)
|
|
AC_MSG_CHECKING([for Local Man Documentation directory])
|
|
AC_MSG_RESULT($GNUSTEP_LOCAL_DOC_MAN)
|
|
|
|
AC_MSG_CHECKING([for User Applications directory])
|
|
AC_MSG_RESULT($GNUSTEP_USER_DIR_APPS)
|
|
AC_MSG_CHECKING([for User Admin Applications directory])
|
|
AC_MSG_RESULT($GNUSTEP_USER_DIR_ADMIN_APPS)
|
|
AC_MSG_CHECKING([for User Web Applications directory])
|
|
AC_MSG_RESULT($GNUSTEP_USER_DIR_WEB_APPS)
|
|
AC_MSG_CHECKING([for User Tools directory])
|
|
AC_MSG_RESULT($GNUSTEP_USER_DIR_TOOLS)
|
|
AC_MSG_CHECKING([for User Admin Tools directory])
|
|
AC_MSG_RESULT($GNUSTEP_USER_DIR_ADMIN_TOOLS)
|
|
AC_MSG_CHECKING([for User Library directory])
|
|
AC_MSG_RESULT($GNUSTEP_USER_DIR_LIBRARY)
|
|
AC_MSG_CHECKING([for User Libraries directory])
|
|
AC_MSG_RESULT($GNUSTEP_USER_DIR_LIBRARIES)
|
|
AC_MSG_CHECKING([for User Headers directory])
|
|
AC_MSG_RESULT($GNUSTEP_USER_DIR_HEADERS)
|
|
AC_MSG_CHECKING([for User Documentation directory])
|
|
AC_MSG_RESULT($GNUSTEP_USER_DIR_DOC)
|
|
AC_MSG_CHECKING([for User Info Documentation directory])
|
|
AC_MSG_RESULT($GNUSTEP_USER_DIR_DOC_INFO)
|
|
AC_MSG_CHECKING([for User Man Documentation directory])
|
|
AC_MSG_RESULT($GNUSTEP_USER_DIR_DOC_MAN)
|
|
|
|
AC_MSG_CHECKING([for System User directory])
|
|
AC_MSG_RESULT($GNUSTEP_SYSTEM_USERS_DIR)
|
|
AC_MSG_CHECKING([for Network User directory])
|
|
AC_MSG_RESULT($GNUSTEP_NETWORK_USERS_DIR)
|
|
AC_MSG_CHECKING([for Local User directory])
|
|
AC_MSG_RESULT($GNUSTEP_LOCAL_USERS_DIR)
|
|
|
|
#
|
|
# Set the default configuration file values in config.h to be hard-coded
|
|
# into NSPathUtilities.m
|
|
#
|
|
GNUSTEP_MAKEFILES=`echo $GNUSTEP_MAKEFILES|sed -e 's/\\\\/\\\\\\\\/g'`
|
|
AC_DEFINE_UNQUOTED(GNUSTEP_TARGET_MAKEFILES,
|
|
"$GNUSTEP_MAKEFILES",
|
|
[Built in default value for GNUstep Makefiles])
|
|
GNUSTEP_USER_DEFAULTS_DIR=`echo $GNUSTEP_USER_DEFAULTS_DIR|sed -e 's/\\\\/\\\\\\\\/g'`
|
|
AC_DEFINE_UNQUOTED(GNUSTEP_TARGET_USER_DEFAULTS_DIR,
|
|
"$GNUSTEP_USER_DEFAULTS_DIR",
|
|
[Built in default value for GNUstep user defaults directory])
|
|
GNUSTEP_USER_CONFIG_FILE=`echo $GNUSTEP_USER_CONFIG_FILE|sed -e 's/\\\\/\\\\\\\\/g'`
|
|
AC_DEFINE_UNQUOTED(GNUSTEP_TARGET_USER_CONFIG_FILE,
|
|
"$GNUSTEP_USER_CONFIG_FILE",
|
|
[Built in default value for GNUstep user config file])
|
|
GNUSTEP_TARGET_CONFIG_FILE=`echo $GNUSTEP_TARGET_CONFIG_FILE|sed -e 's/\\\\/\\\\\\\\/g'`
|
|
AC_DEFINE_UNQUOTED(GNUSTEP_TARGET_CONFIG_FILE,
|
|
"$GNUSTEP_TARGET_CONFIG_FILE",
|
|
[Built in default value for GNUstep config file])
|
|
|
|
#
|
|
# SYSTEM domain paths
|
|
#
|
|
GNUSTEP_SYSTEM_APPS=`echo $GNUSTEP_SYSTEM_APPS|sed -e 's/\\\\/\\\\\\\\/g'`
|
|
AC_DEFINE_UNQUOTED(GNUSTEP_TARGET_SYSTEM_APPS,
|
|
"$GNUSTEP_SYSTEM_APPS",
|
|
[Built in default value for GNUstep system apps])
|
|
|
|
GNUSTEP_SYSTEM_ADMIN_APPS=`echo $GNUSTEP_SYSTEM_ADMIN_APPS|sed -e 's/\\\\/\\\\\\\\/g'`
|
|
AC_DEFINE_UNQUOTED(GNUSTEP_TARGET_SYSTEM_ADMIN_APPS,
|
|
"$GNUSTEP_SYSTEM_ADMIN_APPS",
|
|
[Built in default value for GNUstep system apps])
|
|
|
|
GNUSTEP_SYSTEM_WEB_APPS=`echo $GNUSTEP_SYSTEM_WEB_APPS|sed -e 's/\\\\/\\\\\\\\/g'`
|
|
AC_DEFINE_UNQUOTED(GNUSTEP_TARGET_SYSTEM_WEB_APPS,
|
|
"$GNUSTEP_SYSTEM_WEB_APPS",
|
|
[Built in default value for GNUstep web apps])
|
|
|
|
GNUSTEP_SYSTEM_TOOLS=`echo $GNUSTEP_SYSTEM_TOOLS|sed -e 's/\\\\/\\\\\\\\/g'`
|
|
AC_DEFINE_UNQUOTED(GNUSTEP_TARGET_SYSTEM_TOOLS,
|
|
"$GNUSTEP_SYSTEM_TOOLS",
|
|
[Built in default value for GNUstep system tools])
|
|
|
|
GNUSTEP_SYSTEM_ADMIN_TOOLS=`echo $GNUSTEP_SYSTEM_ADMIN_TOOLS|sed -e 's/\\\\/\\\\\\\\/g'`
|
|
AC_DEFINE_UNQUOTED(GNUSTEP_TARGET_SYSTEM_ADMIN_TOOLS,
|
|
"$GNUSTEP_SYSTEM_ADMIN_TOOLS",
|
|
[Built in default value for GNUstep system tools])
|
|
|
|
GNUSTEP_SYSTEM_LIBRARY=`echo $GNUSTEP_SYSTEM_LIBRARY|sed -e 's/\\\\/\\\\\\\\/g'`
|
|
AC_DEFINE_UNQUOTED(GNUSTEP_TARGET_SYSTEM_LIBRARY,
|
|
"$GNUSTEP_SYSTEM_LIBRARY",
|
|
[Built in default value for GNUstep system library])
|
|
|
|
GNUSTEP_SYSTEM_LIBRARIES=`echo $GNUSTEP_SYSTEM_LIBRARIES|sed -e 's/\\\\/\\\\\\\\/g'`
|
|
AC_DEFINE_UNQUOTED(GNUSTEP_TARGET_SYSTEM_LIBRARIES,
|
|
"$GNUSTEP_SYSTEM_LIBRARIES",
|
|
[Built in default value for GNUstep system libraries])
|
|
|
|
GNUSTEP_SYSTEM_HEADERS=`echo $GNUSTEP_SYSTEM_HEADERS|sed -e 's/\\\\/\\\\\\\\/g'`
|
|
AC_DEFINE_UNQUOTED(GNUSTEP_TARGET_SYSTEM_HEADERS,
|
|
"$GNUSTEP_SYSTEM_HEADERS",
|
|
[Built in default value for GNUstep system headers])
|
|
|
|
GNUSTEP_SYSTEM_DOC=`echo $GNUSTEP_SYSTEM_DOC|sed -e 's/\\\\/\\\\\\\\/g'`
|
|
AC_DEFINE_UNQUOTED(GNUSTEP_TARGET_SYSTEM_DOC,
|
|
"$GNUSTEP_SYSTEM_DOC",
|
|
[Built in default value for GNUstep system documentation])
|
|
|
|
GNUSTEP_SYSTEM_DOC_MAN=`echo $GNUSTEP_SYSTEM_DOC_MAN|sed -e 's/\\\\/\\\\\\\\/g'`
|
|
AC_DEFINE_UNQUOTED(GNUSTEP_TARGET_SYSTEM_DOC_MAN,
|
|
"$GNUSTEP_SYSTEM_DOC_MAN",
|
|
[Built in default value for GNUstep system manpages documentation])
|
|
|
|
GNUSTEP_SYSTEM_DOC_INFO=`echo $GNUSTEP_SYSTEM_DOC_INFO|sed -e 's/\\\\/\\\\\\\\/g'`
|
|
AC_DEFINE_UNQUOTED(GNUSTEP_TARGET_SYSTEM_DOC_INFO,
|
|
"$GNUSTEP_SYSTEM_DOC_INFO",
|
|
[Built in default value for GNUstep system info documentation])
|
|
|
|
#
|
|
# NETWORK domain paths
|
|
#
|
|
GNUSTEP_NETWORK_APPS=`echo $GNUSTEP_NETWORK_APPS|sed -e 's/\\\\/\\\\\\\\/g'`
|
|
AC_DEFINE_UNQUOTED(GNUSTEP_TARGET_NETWORK_APPS,
|
|
"$GNUSTEP_NETWORK_APPS",
|
|
[Built in default value for GNUstep network apps])
|
|
|
|
GNUSTEP_NETWORK_ADMIN_APPS=`echo $GNUSTEP_NETWORK_ADMIN_APPS|sed -e 's/\\\\/\\\\\\\\/g'`
|
|
AC_DEFINE_UNQUOTED(GNUSTEP_TARGET_NETWORK_ADMIN_APPS,
|
|
"$GNUSTEP_NETWORK_ADMIN_APPS",
|
|
[Built in default value for GNUstep network apps])
|
|
|
|
GNUSTEP_NETWORK_WEB_APPS=`echo $GNUSTEP_NETWORK_WEB_APPS|sed -e 's/\\\\/\\\\\\\\/g'`
|
|
AC_DEFINE_UNQUOTED(GNUSTEP_TARGET_NETWORK_WEB_APPS,
|
|
"$GNUSTEP_NETWORK_WEB_APPS",
|
|
[Built in default value for GNUstep network web apps])
|
|
|
|
GNUSTEP_NETWORK_TOOLS=`echo $GNUSTEP_NETWORK_TOOLS|sed -e 's/\\\\/\\\\\\\\/g'`
|
|
AC_DEFINE_UNQUOTED(GNUSTEP_TARGET_NETWORK_TOOLS,
|
|
"$GNUSTEP_NETWORK_TOOLS",
|
|
[Built in default value for GNUstep network tools])
|
|
|
|
GNUSTEP_NETWORK_ADMIN_TOOLS=`echo $GNUSTEP_NETWORK_ADMIN_TOOLS|sed -e 's/\\\\/\\\\\\\\/g'`
|
|
AC_DEFINE_UNQUOTED(GNUSTEP_TARGET_NETWORK_ADMIN_TOOLS,
|
|
"$GNUSTEP_NETWORK_ADMIN_TOOLS",
|
|
[Built in default value for GNUstep system tools])
|
|
|
|
GNUSTEP_NETWORK_LIBRARY=`echo $GNUSTEP_NETWORK_LIBRARY|sed -e 's/\\\\/\\\\\\\\/g'`
|
|
AC_DEFINE_UNQUOTED(GNUSTEP_TARGET_NETWORK_LIBRARY,
|
|
"$GNUSTEP_NETWORK_LIBRARY",
|
|
[Built in default value for GNUstep network library])
|
|
|
|
GNUSTEP_NETWORK_LIBRARIES=`echo $GNUSTEP_NETWORK_LIBRARIES|sed -e 's/\\\\/\\\\\\\\/g'`
|
|
AC_DEFINE_UNQUOTED(GNUSTEP_TARGET_NETWORK_LIBRARIES,
|
|
"$GNUSTEP_NETWORK_LIBRARIES",
|
|
[Built in default value for GNUstep network libraries])
|
|
|
|
GNUSTEP_NETWORK_HEADERS=`echo $GNUSTEP_NETWORK_HEADERS|sed -e 's/\\\\/\\\\\\\\/g'`
|
|
AC_DEFINE_UNQUOTED(GNUSTEP_TARGET_NETWORK_HEADERS,
|
|
"$GNUSTEP_NETWORK_HEADERS",
|
|
[Built in default value for GNUstep network headers])
|
|
|
|
GNUSTEP_NETWORK_DOC=`echo $GNUSTEP_NETWORK_DOC|sed -e 's/\\\\/\\\\\\\\/g'`
|
|
AC_DEFINE_UNQUOTED(GNUSTEP_TARGET_NETWORK_DOC,
|
|
"$GNUSTEP_NETWORK_DOC",
|
|
[Built in default value for GNUstep network documentation])
|
|
|
|
GNUSTEP_NETWORK_DOC_MAN=`echo $GNUSTEP_NETWORK_DOC_MAN|sed -e 's/\\\\/\\\\\\\\/g'`
|
|
AC_DEFINE_UNQUOTED(GNUSTEP_TARGET_NETWORK_DOC_MAN,
|
|
"$GNUSTEP_NETWORK_DOC_MAN",
|
|
[Built in default value for GNUstep network manpages documentation])
|
|
|
|
GNUSTEP_NETWORK_DOC_INFO=`echo $GNUSTEP_NETWORK_DOC_INFO|sed -e 's/\\\\/\\\\\\\\/g'`
|
|
AC_DEFINE_UNQUOTED(GNUSTEP_TARGET_NETWORK_DOC_INFO,
|
|
"$GNUSTEP_NETWORK_DOC_INFO",
|
|
[Built in default value for GNUstep network info documentation])
|
|
|
|
#
|
|
# LOCAL domain paths
|
|
#
|
|
GNUSTEP_LOCAL_APPS=`echo $GNUSTEP_LOCAL_APPS|sed -e 's/\\\\/\\\\\\\\/g'`
|
|
AC_DEFINE_UNQUOTED(GNUSTEP_TARGET_LOCAL_APPS,
|
|
"$GNUSTEP_LOCAL_APPS",
|
|
[Built in default value for GNUstep local apps])
|
|
|
|
GNUSTEP_LOCAL_ADMIN_APPS=`echo $GNUSTEP_LOCAL_ADMIN_APPS|sed -e 's/\\\\/\\\\\\\\/g'`
|
|
AC_DEFINE_UNQUOTED(GNUSTEP_TARGET_LOCAL_ADMIN_APPS,
|
|
"$GNUSTEP_LOCAL_ADMIN_APPS",
|
|
[Built in default value for GNUstep local apps])
|
|
|
|
GNUSTEP_LOCAL_WEB_APPS=`echo $GNUSTEP_LOCAL_WEB_APPS|sed -e 's/\\\\/\\\\\\\\/g'`
|
|
AC_DEFINE_UNQUOTED(GNUSTEP_TARGET_LOCAL_WEB_APPS,
|
|
"$GNUSTEP_LOCAL_WEB_APPS",
|
|
[Built in default value for GNUstep local web apps])
|
|
|
|
GNUSTEP_LOCAL_TOOLS=`echo $GNUSTEP_LOCAL_TOOLS|sed -e 's/\\\\/\\\\\\\\/g'`
|
|
AC_DEFINE_UNQUOTED(GNUSTEP_TARGET_LOCAL_TOOLS,
|
|
"$GNUSTEP_LOCAL_TOOLS",
|
|
[Built in default value for GNUstep local tools])
|
|
|
|
GNUSTEP_LOCAL_ADMIN_TOOLS=`echo $GNUSTEP_LOCAL_ADMIN_TOOLS|sed -e 's/\\\\/\\\\\\\\/g'`
|
|
AC_DEFINE_UNQUOTED(GNUSTEP_TARGET_LOCAL_ADMIN_TOOLS,
|
|
"$GNUSTEP_LOCAL_ADMIN_TOOLS",
|
|
[Built in default value for GNUstep local tools])
|
|
|
|
GNUSTEP_LOCAL_LIBRARY=`echo $GNUSTEP_LOCAL_LIBRARY|sed -e 's/\\\\/\\\\\\\\/g'`
|
|
AC_DEFINE_UNQUOTED(GNUSTEP_TARGET_LOCAL_LIBRARY,
|
|
"$GNUSTEP_LOCAL_LIBRARY",
|
|
[Built in default value for GNUstep local library])
|
|
|
|
GNUSTEP_LOCAL_LIBRARIES=`echo $GNUSTEP_LOCAL_LIBRARIES|sed -e 's/\\\\/\\\\\\\\/g'`
|
|
AC_DEFINE_UNQUOTED(GNUSTEP_TARGET_LOCAL_LIBRARIES,
|
|
"$GNUSTEP_LOCAL_LIBRARIES",
|
|
[Built in default value for GNUstep local libraries])
|
|
|
|
GNUSTEP_LOCAL_HEADERS=`echo $GNUSTEP_LOCAL_HEADERS|sed -e 's/\\\\/\\\\\\\\/g'`
|
|
AC_DEFINE_UNQUOTED(GNUSTEP_TARGET_LOCAL_HEADERS,
|
|
"$GNUSTEP_LOCAL_HEADERS",
|
|
[Built in default value for GNUstep local headers])
|
|
|
|
GNUSTEP_LOCAL_DOC=`echo $GNUSTEP_LOCAL_DOC|sed -e 's/\\\\/\\\\\\\\/g'`
|
|
AC_DEFINE_UNQUOTED(GNUSTEP_TARGET_LOCAL_DOC,
|
|
"$GNUSTEP_LOCAL_DOC",
|
|
[Built in default value for GNUstep local documentation])
|
|
|
|
GNUSTEP_LOCAL_DOC_MAN=`echo $GNUSTEP_LOCAL_DOC_MAN|sed -e 's/\\\\/\\\\\\\\/g'`
|
|
AC_DEFINE_UNQUOTED(GNUSTEP_TARGET_LOCAL_DOC_MAN,
|
|
"$GNUSTEP_LOCAL_DOC_MAN",
|
|
[Built in default value for GNUstep local manpages documentation])
|
|
|
|
GNUSTEP_LOCAL_DOC_INFO=`echo $GNUSTEP_LOCAL_DOC_INFO|sed -e 's/\\\\/\\\\\\\\/g'`
|
|
AC_DEFINE_UNQUOTED(GNUSTEP_TARGET_LOCAL_DOC_INFO,
|
|
"$GNUSTEP_LOCAL_DOC_INFO",
|
|
[Built in default value for GNUstep local info documentation])
|
|
|
|
#
|
|
# USER_DIR domain paths
|
|
#
|
|
GNUSTEP_USER_DIR_APPS=`echo $GNUSTEP_USER_DIR_APPS|sed -e 's/\\\\/\\\\\\\\/g'`
|
|
AC_DEFINE_UNQUOTED(GNUSTEP_TARGET_USER_DIR_APPS,
|
|
"$GNUSTEP_USER_DIR_APPS",
|
|
[Built in default value for GNUstep user_dir apps])
|
|
|
|
GNUSTEP_USER_DIR_ADMIN_APPS=`echo $GNUSTEP_USER_DIR_ADMIN_APPS|sed -e 's/\\\\/\\\\\\\\/g'`
|
|
AC_DEFINE_UNQUOTED(GNUSTEP_TARGET_USER_DIR_ADMIN_APPS,
|
|
"$GNUSTEP_USER_DIR_ADMIN_APPS",
|
|
[Built in default value for GNUstep user_dir admin apps])
|
|
|
|
GNUSTEP_USER_DIR_WEB_APPS=`echo $GNUSTEP_USER_DIR_WEB_APPS|sed -e 's/\\\\/\\\\\\\\/g'`
|
|
AC_DEFINE_UNQUOTED(GNUSTEP_TARGET_USER_DIR_WEB_APPS,
|
|
"$GNUSTEP_USER_DIR_WEB_APPS",
|
|
[Built in default value for GNUstep user_dir web apps])
|
|
|
|
GNUSTEP_USER_DIR_TOOLS=`echo $GNUSTEP_USER_DIR_TOOLS|sed -e 's/\\\\/\\\\\\\\/g'`
|
|
AC_DEFINE_UNQUOTED(GNUSTEP_TARGET_USER_DIR_TOOLS,
|
|
"$GNUSTEP_USER_DIR_TOOLS",
|
|
[Built in default value for GNUstep user_dir tools])
|
|
|
|
GNUSTEP_USER_DIR_ADMIN_TOOLS=`echo $GNUSTEP_USER_DIR_ADMIN_TOOLS|sed -e 's/\\\\/\\\\\\\\/g'`
|
|
AC_DEFINE_UNQUOTED(GNUSTEP_TARGET_USER_DIR_ADMIN_TOOLS,
|
|
"$GNUSTEP_USER_DIR_ADMIN_TOOLS",
|
|
[Built in default value for GNUstep user_dir tools])
|
|
|
|
GNUSTEP_USER_DIR_LIBRARY=`echo $GNUSTEP_USER_DIR_LIBRARY|sed -e 's/\\\\/\\\\\\\\/g'`
|
|
AC_DEFINE_UNQUOTED(GNUSTEP_TARGET_USER_DIR_LIBRARY,
|
|
"$GNUSTEP_USER_DIR_LIBRARY",
|
|
[Built in default value for GNUstep user_dir library])
|
|
|
|
GNUSTEP_USER_DIR_LIBRARIES=`echo $GNUSTEP_USER_DIR_LIBRARIES|sed -e 's/\\\\/\\\\\\\\/g'`
|
|
AC_DEFINE_UNQUOTED(GNUSTEP_TARGET_USER_DIR_LIBRARIES,
|
|
"$GNUSTEP_USER_DIR_LIBRARIES",
|
|
[Built in default value for GNUstep user_dir libraries])
|
|
|
|
GNUSTEP_USER_DIR_HEADERS=`echo $GNUSTEP_USER_DIR_HEADERS|sed -e 's/\\\\/\\\\\\\\/g'`
|
|
AC_DEFINE_UNQUOTED(GNUSTEP_TARGET_USER_DIR_HEADERS,
|
|
"$GNUSTEP_USER_DIR_HEADERS",
|
|
[Built in default value for GNUstep user_dir headers])
|
|
|
|
GNUSTEP_USER_DIR_DOC=`echo $GNUSTEP_USER_DIR_DOC|sed -e 's/\\\\/\\\\\\\\/g'`
|
|
AC_DEFINE_UNQUOTED(GNUSTEP_TARGET_USER_DIR_DOC,
|
|
"$GNUSTEP_USER_DIR_DOC",
|
|
[Built in default value for GNUstep user_dir documentation])
|
|
|
|
GNUSTEP_USER_DIR_DOC_MAN=`echo $GNUSTEP_USER_DIR_DOC_MAN|sed -e 's/\\\\/\\\\\\\\/g'`
|
|
AC_DEFINE_UNQUOTED(GNUSTEP_TARGET_USER_DIR_DOC_MAN,
|
|
"$GNUSTEP_USER_DIR_DOC_MAN",
|
|
[Built in default value for GNUstep user_dir manpages documentation])
|
|
|
|
GNUSTEP_USER_DIR_DOC_INFO=`echo $GNUSTEP_USER_DIR_DOC_INFO|sed -e 's/\\\\/\\\\\\\\/g'`
|
|
AC_DEFINE_UNQUOTED(GNUSTEP_TARGET_USER_DIR_DOC_INFO,
|
|
"$GNUSTEP_USER_DIR_DOC_INFO",
|
|
[Built in default value for GNUstep user_dir info documentation])
|
|
|
|
GNUSTEP_TARGET_SYSTEM_USERS_DIR=`echo $GNUSTEP_TARGET_SYSTEM_USERS_DIR|sed -e 's/\\\\/\\\\\\\\/g'`
|
|
AC_DEFINE_UNQUOTED(GNUSTEP_TARGET_SYSTEM_USERS_DIR,
|
|
"$GNUSTEP_TARGET_SYSTEM_USERS_DIR",
|
|
[Built in default value for GNUstep System Users directory])
|
|
GNUSTEP_TARGET_NETWORK_USERS_DIR=`echo $GNUSTEP_TARGET_NETWORK_USERS_DIR|sed -e 's/\\\\/\\\\\\\\/g'`
|
|
AC_DEFINE_UNQUOTED(GNUSTEP_TARGET_NETWORK_USERS_DIR,
|
|
"$GNUSTEP_TARGET_NETWORK_USERS_DIR",
|
|
[Built in default value for GNUstep Network Users directory])
|
|
GNUSTEP_TARGET_LOCAL_USERS_DIR=`echo $GNUSTEP_TARGET_LOCAL_USERS_DIR|sed -e 's/\\\\/\\\\\\\\/g'`
|
|
AC_DEFINE_UNQUOTED(GNUSTEP_TARGET_LOCAL_USERS_DIR,
|
|
"$GNUSTEP_TARGET_LOCAL_USERS_DIR",
|
|
[Built in default value for GNUstep Local Users directory])
|
|
|
|
#
|
|
# Now load the values to be used in locating libraries etc used when
|
|
# building the base library ... as supplied by the gnustep-make package
|
|
#
|
|
# It looks like we ought to source the whole GNUstep.sh here, and even
|
|
# ask it to output all variables! That way we have access to (eg)
|
|
# GNUSTEP_SYSTEM_HEADERS below.
|
|
#
|
|
# We need to unset any values that we really need, or existing settings
|
|
# would be used by GNUstep.sh
|
|
#
|
|
unset GNUSTEP_SYSTEM_HEADERS
|
|
unset GNUSTEP_SYSTEM_LIBRARIES
|
|
unset GNUSTEP_NETWORK_HEADERS
|
|
unset GNUSTEP_NETWORK_LIBRARIES
|
|
unset GNUSTEP_LOCAL_HEADERS
|
|
unset GNUSTEP_LOCAL_LIBRARIES
|
|
GNUSTEP_MAKEFILES="$CURRENT_GNUSTEP_MAKEFILES"
|
|
GNUSTEP_SH_EXPORT_ALL_VARIABLES=yes
|
|
. "$CURRENT_GNUSTEP_MAKEFILES/GNUstep.sh"
|
|
unset GNUSTEP_SH_EXPORT_ALL_VARIABLES
|
|
|
|
# For backwards compatibility, define GNUSTEP_SYSTEM_HEADERS from
|
|
# GNUSTEP_SYSTEM_ROOT if not set yet.
|
|
if test x"$GNUSTEP_SYSTEM_HEADERS" = x""; then
|
|
GNUSTEP_SYSTEM_HEADERS="$GNUSTEP_SYSTEM_ROOT/Library/Headers"
|
|
fi
|
|
|
|
if test x"$GNUSTEP_SYSTEM_LIBRARIES" = x""; then
|
|
GNUSTEP_SYSTEM_LIBRARIES="$GNUSTEP_SYSTEM_ROOT/Library/Libraries"
|
|
fi
|
|
|
|
if test x"$GNUSTEP_NETWORK_HEADERS" = x""; then
|
|
GNUSTEP_NETWORK_HEADERS="$GNUSTEP_NETWORK_ROOT/Library/Headers"
|
|
fi
|
|
|
|
if test x"$GNUSTEP_NETWORK_LIBRARIES" = x""; then
|
|
GNUSTEP_NETWORK_LIBRARIES="$GNUSTEP_NETWORK_ROOT/Library/Libraries"
|
|
fi
|
|
|
|
if test x"$GNUSTEP_LOCAL_HEADERS" = x""; then
|
|
GNUSTEP_LOCAL_HEADERS="$GNUSTEP_LOCAL_ROOT/Library/Headers"
|
|
fi
|
|
|
|
if test x"$GNUSTEP_LOCAL_LIBRARIES" = x""; then
|
|
GNUSTEP_LOCAL_LIBRARIES="$GNUSTEP_LOCAL_ROOT/Library/Libraries"
|
|
fi
|
|
|
|
#
|
|
# Add standard library and header directories for configure to use to locate
|
|
# plain C developer headers/libraries which have been installed in the
|
|
# GNUstep hierarchy. These take precedence
|
|
#
|
|
if test x"$GNUSTEP_IS_FLATTENED" = x"yes"; then
|
|
CPPFLAGS="$CPPFLAGS -I$GNUSTEP_LOCAL_HEADERS"
|
|
CPPFLAGS="$CPPFLAGS -I$GNUSTEP_NETWORK_HEADERS"
|
|
CPPFLAGS="$CPPFLAGS -I$GNUSTEP_SYSTEM_HEADERS"
|
|
LDFLAGS="$LDFLAGS -L$GNUSTEP_LOCAL_LIBRARIES"
|
|
LDFLAGS="$LDFLAGS -L$GNUSTEP_NETWORK_LIBRARIES"
|
|
LDFLAGS="$LDFLAGS -L$GNUSTEP_SYSTEM_LIBRARIES"
|
|
else
|
|
# FIXME: Cross-compiling should read the target from the configure
|
|
# options and use it. GNUSTEP_TARGET_* variables do not exist in
|
|
# this context (so "$GNUSTEP_TARGET_CPU" will always be "")
|
|
if test x"$GNUSTEP_TARGET_CPU" = x""; then
|
|
ARCH="$GNUSTEP_HOST_CPU-$GNUSTEP_HOST_OS"
|
|
else
|
|
ARCH=$GNUSTEP_TARGET_CPU-$GNUSTEP_TARGET_OS
|
|
fi
|
|
ALIB="$ARCH/$LIBRARY_COMBO"
|
|
CPPFLAGS="$CPPFLAGS -I$GNUSTEP_LOCAL_HEADERS/$ALIB"
|
|
CPPFLAGS="$CPPFLAGS -I$GNUSTEP_LOCAL_HEADERS/$ARCH"
|
|
CPPFLAGS="$CPPFLAGS -I$GNUSTEP_LOCAL_HEADERS"
|
|
CPPFLAGS="$CPPFLAGS -I$GNUSTEP_NETWORK_HEADERS/$ALIB"
|
|
CPPFLAGS="$CPPFLAGS -I$GNUSTEP_NETWORK_HEADERS/$ARCH"
|
|
CPPFLAGS="$CPPFLAGS -I$GNUSTEP_NETWORK_HEADERS"
|
|
CPPFLAGS="$CPPFLAGS -I$GNUSTEP_SYSTEM_HEADERS/$ALIB"
|
|
CPPFLAGS="$CPPFLAGS -I$GNUSTEP_SYSTEM_HEADERS/$ARCH"
|
|
CPPFLAGS="$CPPFLAGS -I$GNUSTEP_SYSTEM_HEADERS"
|
|
LDFLAGS="$LDFLAGS -L$GNUSTEP_LOCAL_LIBRARIES/$ALIB"
|
|
LDFLAGS="$LDFLAGS -L$GNUSTEP_LOCAL_LIBRARIES/$ARCH"
|
|
LDFLAGS="$LDFLAGS -L$GNUSTEP_LOCAL_LIBRARIES"
|
|
LDFLAGS="$LDFLAGS -L$GNUSTEP_NETWORK_LIBRARIES/$ALIB"
|
|
LDFLAGS="$LDFLAGS -L$GNUSTEP_NETWORK_LIBRARIES/$ARCH"
|
|
LDFLAGS="$LDFLAGS -L$GNUSTEP_NETWORK_LIBRARIES"
|
|
LDFLAGS="$LDFLAGS -L$GNUSTEP_SYSTEM_LIBRARIES/$ALIB"
|
|
LDFLAGS="$LDFLAGS -L$GNUSTEP_SYSTEM_LIBRARIES/$ARCH"
|
|
LDFLAGS="$LDFLAGS -L$GNUSTEP_SYSTEM_LIBRARIES"
|
|
fi
|
|
|
|
|
|
#--------------------------------------------------------------------
|
|
# Find the compiler
|
|
#--------------------------------------------------------------------
|
|
MAKECC=`gnustep-config --variable=CC`
|
|
MAKECPP=`gnustep-config --variable=CPP`
|
|
MAKECXX=`gnustep-config --variable=CXX`
|
|
if test "$CC" = ""; then
|
|
CC=$MAKECC
|
|
export CC
|
|
else
|
|
if test "$CC" != "$MAKECC"; then
|
|
AC_MSG_WARN([You are running configure with the compiler ($CC) set to a different value from that used by gnustep-make ($MAKECC). To avoid conflicts/problems, reconfigure/reinstall gnustep-make to use CC=$CC or run the gnustep-base configure again with your CC environment variable set to $MAKECC])
|
|
fi
|
|
fi
|
|
if test "$CPP" = ""; then
|
|
CPP=$MAKECPP
|
|
export CPP
|
|
else
|
|
if test "$CPP" != "$MAKECPP"; then
|
|
AC_MSG_WARN([You are running configure with the preprocessor ($CPP) set to a different value from that used by gnustep-make ($MAKECPP). To avoid conflicts/problems, reconfigure/reinstall gnustep-make to use CPP=$CPP or run the gnustep-base configure again with your CPP environment variable set to $MAKECPP])
|
|
fi
|
|
fi
|
|
if test "$CXX" = ""; then
|
|
CXX=$MAKECXX
|
|
export CXX
|
|
else
|
|
if test "$CXX" != "$MAKECXX"; then
|
|
AC_MSG_WARN([You are running configure with the compiler ($CXX) set to a different value from that used by gnustep-make ($MAKECXX). To avoid conflicts/problems, reconfigure/reinstall gnustep-make to use CXX=$CXX or run the gnustep-base configure again with your CXX environment variable set to $MAKECXX])
|
|
fi
|
|
fi
|
|
AC_PROG_CC
|
|
AC_PROG_CPP
|
|
AC_USE_SYSTEM_EXTENSIONS
|
|
|
|
AC_MSG_CHECKING(whether the compiler is clang)
|
|
# CC may have flags appended to it, so we need to extract the actual
|
|
# compiler name.
|
|
if "$(echo "${CC}" | awk '{print $1}')" -v 2>&1 | grep -q 'clang version'; then
|
|
CLANG_CC=yes
|
|
AC_MSG_RESULT(yes)
|
|
else
|
|
CLANG_CC=no
|
|
AC_MSG_RESULT(no)
|
|
fi
|
|
AC_SUBST(CLANG_CC)
|
|
|
|
|
|
# Large file support needed by NSData/NSFileHandle.
|
|
# These macros must be called after AC_USE_SYSTEM_EXTENSIONS because
|
|
# the `fseeko' declaration may be hidden by default on some systems.
|
|
AC_FUNC_FSEEKO
|
|
AH_BOTTOM([
|
|
/* Define `fseeko' to `fseek' if the former is missing.
|
|
Likewise for `ftello'. */
|
|
#if !HAVE_FSEEKO
|
|
# define fseeko fseek
|
|
# define ftello ftell
|
|
#endif
|
|
])
|
|
AC_SYS_LARGEFILE
|
|
AC_TYPE_OFF_T
|
|
|
|
#--------------------------------------------------------------------
|
|
# Check how to enable builtins for atomic operations
|
|
#--------------------------------------------------------------------
|
|
|
|
AC_LANG_PUSH(C)
|
|
AC_MSG_CHECKING([whether the compiler supports atomic operations]);
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM([[typedef int atomic;]],
|
|
[[atomic x; atomic y; __sync_bool_compare_and_swap(&x, y, y + 1);]])],
|
|
have_atomic=yes,
|
|
have_atomic=no);
|
|
if test "$have_atomic" = "yes"; then
|
|
AC_MSG_RESULT([yes]);
|
|
AC_DEFINE(USE_ATOMIC_BUILTINS,1,
|
|
[Define if the compiler provides builtins for atomic operations])
|
|
else
|
|
AC_MSG_RESULT([no]);
|
|
if test "$CC" = "gcc"; then
|
|
saved_CFLAGS="$CFLAGS";
|
|
ATOMIC_CFLAGS="";
|
|
|
|
# FIXME: Forcing -march=i568 for any i568 or later CPU is a
|
|
# stop gap measure to make the compiler emit native assembly
|
|
# for atomic operations on i586 or latter processors (GCC by
|
|
# default emits code compatible with the original i386 and
|
|
# requires library functions to emulate atomic operations).
|
|
# When gnustep-make takes care of this kind of target setting,
|
|
# the check can safely be removed.
|
|
case "$target_cpu" in
|
|
i586*|i686*|i786*)
|
|
ATOMIC_CFLAGS="-march=i586"
|
|
CFLAGS="$saved_CFLAGS $ATOMIC_CFLAGS"
|
|
;;
|
|
x86_64)
|
|
ATOMIC_CFLAGS="-march=x86-64"
|
|
CFLAGS="$saved_CFLAGS $ATOMIC_CFLAGS"
|
|
;;
|
|
esac
|
|
AC_MSG_CHECKING([whether CC supports atomic operations with -march]);
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM([[typedef int atomic;]],
|
|
[[atomic x; atomic y; __sync_bool_compare_and_swap(&x, y, y+1);]])],
|
|
need_march=yes,
|
|
need_march=no);
|
|
|
|
if test "$need_march" = "yes"; then
|
|
AC_MSG_RESULT([yes]);
|
|
OBJCFLAGS="$OBJCFLAGS $ATOMIC_CFLAGS";
|
|
AC_DEFINE(USE_ATOMIC_BUILTINS,1,
|
|
[Define if the compiler provides builtins for atomic operations])
|
|
else
|
|
AC_MSG_RESULT([no]);
|
|
saved_LDFLAGS="$LDFLAGS";
|
|
LDFLAGS="$saved_LDFLAGS -lgcc";
|
|
AC_MSG_CHECKING([whether CC supports atomic operations using libgcc]);
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM([[typedef int atomic;]],
|
|
[[atomic x; atomic y; __sync_bool_compare_and_swap(&x, y, y+1);]])],
|
|
atomic_in_libgcc=yes,
|
|
atomic_in_libgcc=no);
|
|
if test "$atomic_in_libgcc" = "yes"; then
|
|
AC_MSG_RESULT([yes]);
|
|
LIBS="$LIBS -lgcc";
|
|
AC_DEFINE(USE_ATOMIC_BUILTINS,1,
|
|
[Define if the compiler provides builtins for atomic operations])
|
|
else
|
|
LDFLAGS="$saved_LDFLAGS";
|
|
AC_MSG_RESULT([no]);
|
|
fi
|
|
fi
|
|
fi
|
|
fi
|
|
AC_LANG_POP(C)
|
|
|
|
|
|
AC_PATH_PROG(WHOAMI, whoami, echo, $PATH:/usr/ucb)
|
|
PKG_PROG_PKG_CONFIG
|
|
# If the modern mechanism fails we may have an older pkg-config
|
|
# so try looking it up the old fashioned way.
|
|
if test -z "$PKG_CONFIG"; then
|
|
AC_PATH_PROG(PKG_CONFIG,pkg-config,,)
|
|
fi
|
|
|
|
|
|
#--------------------------------------------------------------------
|
|
# specific target_os options
|
|
#--------------------------------------------------------------------
|
|
INCLUDE_FLAGS="$CPPFLAGS"
|
|
LDIR_FLAGS="$LDFLAGS"
|
|
# This is just for configuring. Later, in config.make, INCLUDE_FLAGS
|
|
# goes in CONFIG_SYSTEM_INCL and LIBS goes in CONFIG_SYSTEM_LIBS
|
|
case "$target_os" in
|
|
freebsd* | openbsd* )
|
|
CPPFLAGS="$CPPFLAGS -I/usr/local/include"
|
|
LDFLAGS="$LDFLAGS -L/usr/local/lib";;
|
|
netbsd*) CPPFLAGS="$CPPFLAGS -I/usr/pkg/include"
|
|
LDFLAGS="$LDFLAGS -Wl,-R/usr/pkg/lib -L/usr/pkg/lib";;
|
|
linux-android* )
|
|
# link against libandroid for native application APIs
|
|
LIBS="$LIBS -landroid";;
|
|
esac
|
|
|
|
#--------------------------------------------------------------------
|
|
# Set Apple/Darwin/OSX/NeXT information for other tests
|
|
#--------------------------------------------------------------------
|
|
AC_MSG_CHECKING(the Objective-C runtime)
|
|
if test "$OBJC_RUNTIME_LIB" = "nx" -o "$OBJC_RUNTIME_LIB" = "apple"; then
|
|
AC_MSG_RESULT(NeXT)
|
|
OBJCFLAGS="$OBJCFLAGS -fnext-runtime -DNeXT_RUNTIME"
|
|
elif test "$OBJC_RUNTIME_LIB" = "ng"; then
|
|
AC_MSG_RESULT(Next Gen)
|
|
else
|
|
AC_MSG_RESULT(GNU)
|
|
if test "$CLANG_CC" = "yes"; then
|
|
OBJCFLAGS="$OBJCFLAGS -fobjc-runtime=gcc"
|
|
fi
|
|
fi
|
|
LIBOBJC=`gnustep-config --objc-libs`
|
|
if test "$LIBOBJC" = ""; then
|
|
AC_MSG_ERROR([The command 'gnustep-config --objc-libs' (provided by the gnustep-make package) returned no Objective-C library. Unable to continue configuring without Objective-C support.])
|
|
exit 1
|
|
fi
|
|
|
|
#--------------------------------------------------------------------
|
|
# Miscellaneous flags
|
|
#--------------------------------------------------------------------
|
|
|
|
# Check to see if the libobjc library is in our GNUSTEP_SYSTEM_LIBRARIES.
|
|
# If so, there are probably other libraries that we want there also, so
|
|
# leave the proper includes in CPPFLAGS and LDFLAGS
|
|
AC_MSG_CHECKING(for custom shared objc library)
|
|
AC_CACHE_VAL(gs_cv_objc_libdir,
|
|
[dnl
|
|
gs_cv_objc_libdir=NONE
|
|
gs_cv_objc_incdir=NONE
|
|
# Try GNUSTEP_SYSTEM_LIBRARIES first
|
|
if test "$GNUSTEP_IS_FLATTENED" = yes; then
|
|
GNUSTEP_LDIR="$GNUSTEP_SYSTEM_LIBRARIES"
|
|
GNUSTEP_HDIR="$GNUSTEP_SYSTEM_HEADERS"
|
|
else
|
|
GNUSTEP_LDIR="$GNUSTEP_SYSTEM_LIBRARIES/$obj_dir"
|
|
GNUSTEP_HDIR="$GNUSTEP_SYSTEM_HEADERS/$LIBRARY_COMBO"
|
|
fi
|
|
|
|
if test -f "$GNUSTEP_HDIR/objc/objc.h"; then
|
|
if test -f "$GNUSTEP_LDIR/libobjc.a" -o -f "$GNUSTEP_LDIR/libobjc.so" -o -f "$GNUSTEP_LDIR/libobjc.dll.a" -o -f "$GNUSTEP_LDIR/libobjc-gnu.dylib" -o -f "$GNUSTEP_LDIR/objc.lib"; then
|
|
gs_cv_objc_libdir="$GNUSTEP_LDIR"
|
|
gs_cv_objc_incdir="$GNUSTEP_HDIR"
|
|
fi
|
|
fi
|
|
|
|
# Try GNUSTEP_NETWORK_LIBRARIES second (override GNUSTEP_SYSTEM if
|
|
# found)
|
|
if test "$GNUSTEP_IS_FLATTENED" = yes; then
|
|
GNUSTEP_LDIR="$GNUSTEP_NETWORK_LIBRARIES"
|
|
GNUSTEP_HDIR="$GNUSTEP_NETWORK_HEADERS"
|
|
else
|
|
GNUSTEP_LDIR="$GNUSTEP_NETWORK_LIBRARIES/$obj_dir"
|
|
GNUSTEP_HDIR="$GNUSTEP_NETWORK_HEADERS/$LIBRARY_COMBO"
|
|
fi
|
|
|
|
if test -f "$GNUSTEP_HDIR/objc/objc.h"; then
|
|
if test -f "$GNUSTEP_LDIR/libobjc.a" -o -f "$GNUSTEP_LDIR/libobjc.so" -o -f "$GNUSTEP_LDIR/libobjc.dll.a" -o -f "$GNUSTEP_LDIR/libobjc-gnu.dylib" -o -f "$GNUSTEP_LDIR/objc.lib"; then
|
|
gs_cv_objc_libdir="$GNUSTEP_LDIR"
|
|
gs_cv_objc_incdir="$GNUSTEP_HDIR"
|
|
fi
|
|
fi
|
|
|
|
# Try GNUSTEP_LOCAL_LIBRARIES third (override GNUSTEP_SYSTEM and
|
|
# GNUSTEP_NETWORK if found)
|
|
if test "$GNUSTEP_IS_FLATTENED" = yes; then
|
|
GNUSTEP_LDIR="$GNUSTEP_LOCAL_LIBRARIES"
|
|
GNUSTEP_HDIR="$GNUSTEP_LOCAL_HEADERS"
|
|
else
|
|
GNUSTEP_LDIR="$GNUSTEP_LOCAL_LIBRARIES/$obj_dir"
|
|
GNUSTEP_HDIR="$GNUSTEP_LOCAL_HEADERS/$LIBRARY_COMBO"
|
|
fi
|
|
|
|
if test -f "$GNUSTEP_HDIR/objc/objc.h"; then
|
|
if test -f "$GNUSTEP_LDIR/libobjc.a" -o -f "$GNUSTEP_LDIR/libobjc.so" -o -f "$GNUSTEP_LDIR/libobjc.dll.a" -o -f "$GNUSTEP_LDIR/libobjc-gnu.dylib" -o -f "$GNUSTEP_LDIR/objc.lib"; then
|
|
gs_cv_objc_libdir="$GNUSTEP_LDIR"
|
|
gs_cv_objc_incdir="$GNUSTEP_HDIR"
|
|
fi
|
|
fi
|
|
])
|
|
AC_MSG_RESULT($gs_cv_objc_libdir)
|
|
|
|
if test "$gs_cv_objc_libdir" != "NONE"; then
|
|
#
|
|
# The following one is so that headers of custom libraries into
|
|
# $GNUSTEP_HDIR are used before the standard ones
|
|
#
|
|
INCLUDE_FLAGS="$INCLUDE_FLAGS -I$gs_cv_objc_incdir"
|
|
LDIR_FLAGS="$LDIR_FLAGS -L$gs_cv_objc_libdir/$LIBRARY_COMBO -L$gs_cv_objc_libdir"
|
|
CPPFLAGS="$CPPFLAGS -I$gs_cv_objc_incdir"
|
|
LDFLAGS="$LDFLAGS -L$gs_cv_objc_libdir"
|
|
|
|
# add to path on Windows for config checks to find DLL at runtime
|
|
case $host_os in
|
|
mingw*|windows) PATH=$PATH:$gs_cv_objc_libdir;;
|
|
esac
|
|
fi
|
|
|
|
#--------------------------------------------------------------------
|
|
# Check if Objective-C is installed
|
|
#--------------------------------------------------------------------
|
|
AC_CHECK_HEADERS(objc/runtime.h)
|
|
AC_CHECK_HEADERS(objc/objc.h)
|
|
if test $ac_cv_header_objc_objc_h = no; then
|
|
echo "Check to make sure you have the Objective-C runtime library"
|
|
echo "and its headers installed."
|
|
AC_MSG_ERROR(Could not find Objective-C headers)
|
|
fi
|
|
|
|
#--------------------------------------------------------------------
|
|
# Check for strange network stuff used by gdomap
|
|
#--------------------------------------------------------------------
|
|
AC_MSG_NOTICE(for gdomap network details)
|
|
AC_MSG_CHECKING(for variable length socket addresses)
|
|
AC_LANG(C)
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
|
|
#include <sys/types.h>
|
|
#include <sys/socket.h>
|
|
#include <net/if.h>]],
|
|
[[struct ifreq s; s.ifr_addr.sa_len = 0;]])],
|
|
sa_len=1, sa_len=0)
|
|
if test $sa_len = 1; then
|
|
AC_MSG_RESULT([found])
|
|
AC_DEFINE(HAVE_SA_LEN,1,
|
|
[Define if your system has variable length network addresses])
|
|
else
|
|
AC_MSG_RESULT([not found])
|
|
fi
|
|
|
|
AC_MSG_CHECKING(for compiler visibility attribute support)
|
|
saved_CFLAGS="$CFLAGS"
|
|
CFLAGS="$CFLAGS -Werror"
|
|
AC_COMPILE_IFELSE([AC_LANG_SOURCE([
|
|
#include <stdio.h>
|
|
int foo() __attribute__ ((visibility("internal")));
|
|
int foo(){ return 1; }
|
|
int main(){ return foo(); }])],
|
|
AC_MSG_RESULT([found])
|
|
gs_visibility=1,
|
|
AC_MSG_RESULT([not present])
|
|
gs_visibility=0
|
|
)
|
|
AC_DEFINE_UNQUOTED(HAVE_VISIBILITY_ATTRIBUTE,$gs_visibility,
|
|
[Says whether the visibility attribute works])
|
|
CFLAGS="$saved_CFLAGS"
|
|
|
|
|
|
#--------------------------------------------------------------------
|
|
# Check if system has buggy SO_REUSEADDR
|
|
#--------------------------------------------------------------------
|
|
AC_MSG_CHECKING(whether SO_REUSEADDR is broken)
|
|
AC_RUN_IFELSE(
|
|
[AC_LANG_SOURCE([[#include "$srcdir/config/config.reuseaddr.c"]])],
|
|
[reuseaddr_ok=1],
|
|
[reuseaddr_ok=0],
|
|
[reuseaddr_ok="$cross_reuseaddr_ok"])
|
|
if test $reuseaddr_ok = 0; then
|
|
AC_DEFINE(BROKEN_SO_REUSEADDR,1,
|
|
[Define if SO_REUSEADDR is broken on this system])
|
|
echo
|
|
echo "The SO_REUSEADDR socket option for controlling re-use of network"
|
|
echo "sockets immediately after shutdown appears to be broken on this"
|
|
echo "machine. Networking code will be built without using this"
|
|
echo "feature."
|
|
echo "The effect of this lack is that when a network service is shut"
|
|
echo "down, it cannot be re-started on the same network port until"
|
|
echo "an operating-system timeout has expired."
|
|
echo "For servers other than gdomap, GNUstep does not normally need"
|
|
echo "a particular network port, so the problem is unlikely to arise."
|
|
AC_MSG_RESULT(yes)
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
fi
|
|
|
|
#--------------------------------------------------------------------
|
|
# Check for thread flags for libobjc.
|
|
#--------------------------------------------------------------------
|
|
#
|
|
AC_MSG_CHECKING(for objc threading flags)
|
|
#
|
|
# Get them from gnustep-make which contains the real code to get them
|
|
#
|
|
objc_threaded=`grep objc_threaded: $CURRENT_GNUSTEP_MAKEFILES/$lobj_dir/config.make | sed -e 's/objc_threaded:=//'`
|
|
#
|
|
AC_MSG_RESULT($objc_threaded)
|
|
|
|
#--------------------------------------------------------------------
|
|
# Byte order information needed for foundation headers.
|
|
#--------------------------------------------------------------------
|
|
AC_C_BIGENDIAN
|
|
if test $ac_cv_c_bigendian = yes; then
|
|
GS_WORDS_BIGENDIAN=1
|
|
else
|
|
GS_WORDS_BIGENDIAN=0
|
|
fi
|
|
AC_SUBST(GS_WORDS_BIGENDIAN)
|
|
|
|
#--------------------------------------------------------------------
|
|
# Type size information needed for foundation headers.
|
|
#--------------------------------------------------------------------
|
|
AC_CHECK_SIZEOF(void*)
|
|
|
|
GS_SINT8="signed char"
|
|
GS_UINT8="unsigned char"
|
|
AC_SUBST(GS_SINT8)
|
|
AC_SUBST(GS_UINT8)
|
|
|
|
AC_CHECK_SIZEOF(short)
|
|
AC_SUBST(ac_cv_sizeof_short)
|
|
|
|
AC_CHECK_SIZEOF(int)
|
|
AC_SUBST(ac_cv_sizeof_int)
|
|
|
|
AC_CHECK_SIZEOF(long)
|
|
AC_SUBST(ac_cv_sizeof_long)
|
|
|
|
AC_CHECK_SIZEOF(long long)
|
|
AC_SUBST(ac_cv_sizeof_long_long)
|
|
|
|
AC_CHECK_SIZEOF(float)
|
|
AC_SUBST(ac_cv_sizeof_float)
|
|
|
|
AC_CHECK_SIZEOF(double)
|
|
AC_SUBST(ac_cv_sizeof_double)
|
|
|
|
AC_SUBST(ac_cv_sizeof_voidp)
|
|
if test $ac_cv_sizeof_voidp = $ac_cv_sizeof_int; then
|
|
GS_SADDR="int"
|
|
GS_UADDR="unsigned int"
|
|
else
|
|
if test $ac_cv_sizeof_voidp = $ac_cv_sizeof_long; then
|
|
GS_SADDR="long"
|
|
GS_UADDR="unsigned long"
|
|
else
|
|
if test $ac_cv_sizeof_voidp = $ac_cv_sizeof_long_long; then
|
|
GS_SADDR="long long"
|
|
GS_UADDR="unsigned long long"
|
|
else
|
|
AC_MSG_ERROR([Unable to find integer of same size as void*])
|
|
fi
|
|
fi
|
|
fi
|
|
AC_SUBST(GS_SADDR)
|
|
AC_SUBST(GS_UADDR)
|
|
|
|
if test $ac_cv_sizeof_short = 2; then
|
|
GS_SINT16="signed short"
|
|
GS_UINT16="unsigned short"
|
|
else
|
|
if test $ac_cv_sizeof_int = 2; then
|
|
GS_SINT16="signed int"
|
|
GS_UINT16="unsigned int"
|
|
else
|
|
AC_MSG_ERROR([Unable to determine type for 16-bit integer])
|
|
fi
|
|
fi
|
|
AC_SUBST(GS_SINT16)
|
|
AC_SUBST(GS_UINT16)
|
|
|
|
if test $ac_cv_sizeof_int = 4; then
|
|
GS_SINT32="signed int"
|
|
GS_UINT32="unsigned int"
|
|
else
|
|
if test $ac_cv_sizeof_long = 4; then
|
|
GS_SINT32="signed long"
|
|
GS_UINT32="unsigned long"
|
|
else
|
|
if test $ac_cv_sizeof_short = 4; then
|
|
GS_SINT32="signed short"
|
|
GS_UINT32="unsigned short"
|
|
else
|
|
AC_MSG_ERROR([Unable to determine type for 32-bit integer])
|
|
fi
|
|
fi
|
|
fi
|
|
AC_SUBST(GS_SINT32)
|
|
AC_SUBST(GS_UINT32)
|
|
|
|
GS_HAVE_I64=1
|
|
if test $ac_cv_sizeof_int = 8; then
|
|
GS_SINT64="signed int"
|
|
GS_UINT64="unsigned int"
|
|
else
|
|
if test $ac_cv_sizeof_long = 8; then
|
|
GS_SINT64="signed long"
|
|
GS_UINT64="unsigned long"
|
|
else
|
|
if test $ac_cv_sizeof_long_long = 8; then
|
|
GS_SINT64="signed long long"
|
|
GS_UINT64="unsigned long long"
|
|
else
|
|
# 64-bit ints not supported - but we need a dummy type for byte-swapping
|
|
# of 64-bit values arriving from another system.
|
|
GS_SINT64="struct { gsu8 a[8]; }"
|
|
GS_UINT64="struct { gsu8 a[8]; }"
|
|
GS_HAVE_I64=0
|
|
fi
|
|
fi
|
|
fi
|
|
AC_SUBST(GS_SINT64)
|
|
AC_SUBST(GS_UINT64)
|
|
AC_SUBST(GS_HAVE_I64)
|
|
|
|
GS_HAVE_I128=1
|
|
if test $ac_cv_sizeof_long = 16; then
|
|
GS_SINT128="signed long"
|
|
GS_UINT128="unsigned long"
|
|
else
|
|
if test $ac_cv_sizeof_long_long = 16; then
|
|
GS_SINT128="signed long long"
|
|
GS_UINT128="unsigned long long"
|
|
else
|
|
# 128-bit ints not supported - but we need a dummy type for byte-swapping
|
|
# of 128-bit values arriving from another system.
|
|
GS_SINT128="struct { gsu8 a[[16]]; }"
|
|
GS_UINT128="struct { gsu8 a[[16]]; }"
|
|
GS_HAVE_I128=0
|
|
fi
|
|
fi
|
|
AC_SUBST(GS_SINT128)
|
|
AC_SUBST(GS_UINT128)
|
|
AC_SUBST(GS_HAVE_I128)
|
|
|
|
if test $ac_cv_sizeof_float = 4; then
|
|
GS_FLT32="float"
|
|
else
|
|
AC_MSG_ERROR([Unable to determine type for 32-bit float])
|
|
fi
|
|
AC_SUBST(GS_FLT32)
|
|
|
|
if test $ac_cv_sizeof_double = 8; then
|
|
GS_FLT64="double"
|
|
else
|
|
AC_MSG_ERROR([Unable to determine type for 64-bit float])
|
|
fi
|
|
AC_SUBST(GS_FLT64)
|
|
|
|
#--------------------------------------------------------------------
|
|
# Type-size information for encoding into archives using NSArchiver etc.
|
|
#--------------------------------------------------------------------
|
|
if test $ac_cv_sizeof_short = 2; then
|
|
_GSC_S_SHT=_GSC_I16
|
|
else
|
|
_GSC_S_SHT=_GSC_I32
|
|
fi
|
|
AC_SUBST(_GSC_S_SHT)
|
|
|
|
if test $ac_cv_sizeof_int = 2; then
|
|
_GSC_S_INT=_GSC_I16
|
|
else
|
|
if test $ac_cv_sizeof_int = 4; then
|
|
_GSC_S_INT=_GSC_I32
|
|
else
|
|
if test $ac_cv_sizeof_int = 8; then
|
|
_GSC_S_INT=_GSC_I64
|
|
else
|
|
if test $ac_cv_sizeof_int = 16; then
|
|
_GSC_S_INT=_GSC_I128
|
|
fi
|
|
fi
|
|
fi
|
|
fi
|
|
AC_SUBST(_GSC_S_INT)
|
|
|
|
if test $ac_cv_sizeof_long = 4; then
|
|
_GSC_S_LNG=_GSC_I32
|
|
else
|
|
if test $ac_cv_sizeof_long = 8; then
|
|
_GSC_S_LNG=_GSC_I64
|
|
else
|
|
if test $ac_cv_sizeof_long = 16; then
|
|
_GSC_S_LNG=_GSC_I128
|
|
fi
|
|
fi
|
|
fi
|
|
AC_SUBST(_GSC_S_LNG)
|
|
|
|
if test $ac_cv_sizeof_long_long = 4; then
|
|
_GSC_S_LNG_LNG=_GSC_I32
|
|
else
|
|
if test $ac_cv_sizeof_long_long = 8; then
|
|
_GSC_S_LNG_LNG=_GSC_I64
|
|
else
|
|
if test $ac_cv_sizeof_long_long = 16; then
|
|
_GSC_S_LNG_LNG=_GSC_I128
|
|
fi
|
|
fi
|
|
fi
|
|
AC_SUBST(_GSC_S_LNG_LNG)
|
|
|
|
|
|
#--------------------------------------------------------------------
|
|
# Limit information needed for foundation headers.
|
|
#--------------------------------------------------------------------
|
|
AC_LANG_PUSH(C)
|
|
AC_MSG_CHECKING([for working INTPTR_MAX, INTPTR_MIN, UINTPTR_MAX]);
|
|
AC_COMPILE_IFELSE(
|
|
[AC_LANG_PROGRAM([[#include <inttypes.h>]],
|
|
[[int imax = INTPTR_MAX; int imin = INTPTR_MIN; unsigned umax = UINTPTR_MAX;]])],
|
|
have_valid_ptr_limits=yes,
|
|
have_valid_ptr_limits=no);
|
|
if test "$have_valid_ptr_limits" = "yes"; then
|
|
AC_MSG_RESULT([yes]);
|
|
BUGGY_PTR_LIMITS=0
|
|
else
|
|
AC_MSG_RESULT([no]);
|
|
BUGGY_PTR_LIMITS=1
|
|
case "$target_os" in
|
|
solaris*)
|
|
case "$target_cpu" in
|
|
sparc64*|x86_64*)
|
|
GS_INTPTR_MAX="INT64_MAX"
|
|
GS_INTPTR_MIN="INT64_MIN"
|
|
GS_UINTPTR_MAX="UINT64_MAX"
|
|
;;
|
|
sparc*|i386*|i586*|i686*)
|
|
GS_INTPTR_MAX="INT32_MAX"
|
|
GS_INTPTR_MIN="INT32_MIN"
|
|
GS_UINTPTR_MAX="UINT32_MAX"
|
|
;;
|
|
*) ;;
|
|
esac ;;
|
|
# support for other OS's with broken macros to be added here (HP-UX, IRIX being known)
|
|
*)
|
|
;;
|
|
esac
|
|
AC_SUBST(GS_INTPTR_MAX)
|
|
AC_SUBST(GS_INTPTR_MIN)
|
|
AC_SUBST(GS_UINTPTR_MAX)
|
|
fi
|
|
AC_SUBST(BUGGY_PTR_LIMITS)
|
|
AC_LANG_POP(C)
|
|
|
|
#--------------------------------------------------------------------
|
|
# Setup dynamic linking
|
|
#--------------------------------------------------------------------
|
|
OBJC_SYS_DYNAMIC_LINKER()
|
|
# NOTE: libdl should be in LIBS now if it's available.
|
|
AC_CHECK_FUNCS(dladdr)
|
|
|
|
AC_CHECK_FUNCS(gethostbyname)
|
|
if test "$ac_cv_func_gethostbyname" = "no"; then
|
|
# QNX has gethostbyname and friends in libsocket
|
|
AC_CHECK_LIB(socket, gethostbyname)
|
|
fi
|
|
|
|
AC_CHECK_FUNCS(getaddrinfo)
|
|
|
|
#--------------------------------------------------------------------
|
|
# Windows: check if we have native threading APIs and SRW locks
|
|
#--------------------------------------------------------------------
|
|
HAVE_WIN32_THREADS_AND_LOCKS=0
|
|
if test "$CLANG_CC" = "yes"; then
|
|
case "$target_os" in
|
|
mingw*|windows)
|
|
AC_MSG_CHECKING(for native Windows threads and locks)
|
|
AC_COMPILE_IFELSE(
|
|
[AC_LANG_SOURCE([
|
|
#define GS_USE_WIN32_THREADS_AND_LOCKS 1
|
|
#include "$srcdir/Source/GSPThread.h"
|
|
])],
|
|
AC_MSG_RESULT([yes])
|
|
HAVE_WIN32_THREADS_AND_LOCKS=1,
|
|
AC_MSG_RESULT([no]))
|
|
;;
|
|
esac
|
|
fi
|
|
AC_SUBST(HAVE_WIN32_THREADS_AND_LOCKS)
|
|
|
|
#--------------------------------------------------------------------
|
|
# Check for pthread.h
|
|
#--------------------------------------------------------------------
|
|
if test $HAVE_WIN32_THREADS_AND_LOCKS = 0; then
|
|
AC_CHECK_HEADERS([pthread.h])
|
|
AC_CHECK_HEADERS([pthread_np.h],[],[],[AC_INCLUDES_DEFAULT
|
|
#ifdef HAVE_PTHREAD_H
|
|
#include <pthread.h>
|
|
#endif
|
|
])
|
|
if test $ac_cv_header_pthread_h = yes ; then
|
|
AC_CHECK_SIZEOF(pthread_mutex_t,,[AC_INCLUDES_DEFAULT
|
|
#include <pthread.h>])
|
|
GS_SIZEOF_MUTEX_T=$ac_cv_sizeof_pthread_mutex_t
|
|
if test $ac_cv_sizeof_pthread_mutex_t = 0 ; then
|
|
AC_MSG_ERROR([Unable to find size of pthread_mutex_t (required).])
|
|
fi
|
|
AC_SUBST(GS_SIZEOF_MUTEX_T)
|
|
GS_SIZEOF_COND_MUTEX_T=$ac_cv_sizeof_pthread_mutex_t
|
|
AC_SUBST(GS_SIZEOF_COND_MUTEX_T)
|
|
|
|
# pthread_mutex_t.__data.__owner is non-standard since pthread_mutex_t is
|
|
# nominally an opaque type. We must not rely on this for anything other
|
|
# than debug output!
|
|
AC_CHECK_MEMBER([pthread_mutex_t.__data.__owner],,,[AC_INCLUDES_DEFAULT
|
|
#include <pthread.h>])
|
|
if test $ac_cv_member_pthread_mutex_t___data___owner = yes ; then
|
|
AC_DEFINE(HAVE_PTHREAD_MUTEX_OWNER, 1,
|
|
[Define if you have pthread_mutex_t.__data.__owner])
|
|
fi
|
|
|
|
AC_CHECK_SIZEOF(pthread_cond_t,,[AC_INCLUDES_DEFAULT
|
|
#include <pthread.h>])
|
|
if test $ac_cv_sizeof_pthread_cond_t = 0 ; then
|
|
AC_MSG_ERROR([Unable to find size of pthread_cond_t (required).])
|
|
fi
|
|
GS_SIZEOF_COND_T=$ac_cv_sizeof_pthread_cond_t
|
|
AC_SUBST(GS_SIZEOF_COND_T)
|
|
|
|
AC_CHECK_ALIGNOF(pthread_mutex_t,[AC_INCLUDES_DEFAULT
|
|
#include <pthread.h>])
|
|
GS_ALIGNOF_MUTEX_T=$ac_cv_alignof_pthread_mutex_t
|
|
if test $ac_cv_alignof_pthread_mutex_t = 0 ; then
|
|
AC_MSG_ERROR([Unable to find align of pthread_mutex_t (required).])
|
|
fi
|
|
AC_SUBST(GS_ALIGNOF_MUTEX_T)
|
|
GS_ALIGNOF_COND_MUTEX_T=$ac_cv_alignof_pthread_mutex_t
|
|
AC_SUBST(GS_ALIGNOF_COND_MUTEX_T)
|
|
|
|
AC_CHECK_ALIGNOF(pthread_cond_t,[AC_INCLUDES_DEFAULT
|
|
#include <pthread.h>])
|
|
if test $ac_cv_alignof_pthread_cond_t = 0 ; then
|
|
AC_MSG_ERROR([Unable to find align of pthread_cond_t (required).])
|
|
fi
|
|
GS_ALIGNOF_COND_T=$ac_cv_alignof_pthread_cond_t
|
|
AC_SUBST(GS_ALIGNOF_COND_T)
|
|
else
|
|
AC_MSG_ERROR([Unable to find pthread.h (needed for thread support).])
|
|
fi
|
|
AC_CHECK_LIB(pthread, pthread_join, pthread_ok=yes, pthread_ok=no)
|
|
|
|
if test $pthread_ok = yes ; then
|
|
LIBS="$LIBS -lpthread"
|
|
else
|
|
case "$target_os" in
|
|
mingw*)
|
|
AC_CHECK_LIB(pthreadGC2, pthread_join, pthread_ok=yes, pthread_ok=no)
|
|
if test $pthread_ok = yes ; then
|
|
LIBS="$LIBS -lpthreadGC2"
|
|
fi
|
|
;;
|
|
windows)
|
|
AC_CHECK_LIB(pthreadVC2, pthread_join, pthread_ok=yes, pthread_ok=no)
|
|
if test $pthread_ok = yes ; then
|
|
LIBS="$LIBS -lpthreadVC2"
|
|
fi
|
|
;;
|
|
nto*|qnx*|*android*)
|
|
# Android and QNX have pthread in libc instead of libpthread
|
|
AC_CHECK_LIB(c, pthread_join, pthread_ok=yes, pthread_ok=no)
|
|
if test $pthread_ok = yes ; then
|
|
LIBS="$LIBS -lc"
|
|
fi
|
|
;;
|
|
esac
|
|
fi
|
|
if test $pthread_ok = no ; then
|
|
AC_MSG_ERROR([Unable to find pthread library (needed for thread support).])
|
|
fi
|
|
|
|
# Check threading extensions
|
|
AC_CHECK_FUNCS(pthread_getthreadid_np pthread_main_np)
|
|
|
|
# Typically need librt on Solaris for sched_yield
|
|
AC_CHECK_LIB(rt, sched_yield)
|
|
|
|
# Check if we can name pthreads
|
|
AC_CACHE_CHECK([for pthread_setname_np()], gs_cv_pthread_setname_np,
|
|
[AC_LINK_IFELSE(
|
|
[AC_LANG_PROGRAM([#include <pthread.h>],
|
|
[pthread_setname_np("name");])],
|
|
[gs_cv_pthread_setname_np=darwin],
|
|
[AC_LINK_IFELSE(
|
|
[AC_LANG_PROGRAM([#include <pthread.h>],
|
|
[pthread_setname_np(pthread_self(), "name");])],
|
|
[gs_cv_pthread_setname_np=glibc],
|
|
[AC_LINK_IFELSE(
|
|
[AC_LANG_PROGRAM([#include <pthread.h>],
|
|
[pthread_setname_np(pthread_self(), "%s", "name");])],
|
|
[gs_cv_pthread_setname_np=netbsd],
|
|
[gs_cv_pthread_setname_np=none])])])])
|
|
case $gs_cv_pthread_setname_np in
|
|
darwin)
|
|
AC_DEFINE(PTHREAD_SETNAME(a), pthread_setname_np(a),
|
|
[Description: Define set name function for pthread with one arg])
|
|
;;
|
|
glibc)
|
|
AC_DEFINE(PTHREAD_SETNAME(a), pthread_setname_np(pthread_self(),a),
|
|
[Description: Define setname function for pthread with two args])
|
|
;;
|
|
netbsd)
|
|
AC_DEFINE(PTHREAD_SETNAME(a), pthread_setname_np(pthread_self(),"%s",a),
|
|
[Description: Define setname function for pthread with three args])
|
|
;;
|
|
esac
|
|
|
|
# Check if we can get names of pthreads
|
|
AC_CACHE_CHECK([for pthread_getname_np()], gs_cv_pthread_getname_np,
|
|
[AC_LINK_IFELSE(
|
|
[AC_LANG_PROGRAM([#include <pthread.h>],
|
|
[char name[16]; pthread_getname_np(pthread_self(), name, 16);])],
|
|
[gs_cv_pthread_getname_np=generic])])
|
|
case $gs_cv_pthread_getname_np in
|
|
generic)
|
|
AC_DEFINE(PTHREAD_GETNAME(b,c), pthread_getname_np(pthread_self(),b,c),
|
|
[Description: Define getname function for pthread with two args (generic style)])
|
|
;;
|
|
esac
|
|
|
|
# Check if we have spinlock support
|
|
AC_CHECK_FUNCS(pthread_spin_lock)
|
|
fi
|
|
|
|
#--------------------------------------------------------------------
|
|
# Check Win32 lock sizes
|
|
#--------------------------------------------------------------------
|
|
if test $HAVE_WIN32_THREADS_AND_LOCKS = 1; then
|
|
AC_CHECK_SIZEOF(gs_mutex_t,,[AC_INCLUDES_DEFAULT
|
|
#define GS_USE_WIN32_THREADS_AND_LOCKS 1
|
|
#include "$srcdir/Source/GSPThread.h"])
|
|
GS_SIZEOF_MUTEX_T=$ac_cv_sizeof_gs_mutex_t
|
|
if test $ac_cv_sizeof_gs_mutex_t = 0 ; then
|
|
AC_MSG_ERROR([Unable to find size of gs_mutex_t (required).])
|
|
fi
|
|
AC_SUBST(GS_SIZEOF_MUTEX_T)
|
|
|
|
AC_CHECK_ALIGNOF(gs_mutex_t,[AC_INCLUDES_DEFAULT
|
|
#define GS_USE_WIN32_THREADS_AND_LOCKS 1
|
|
#include "$srcdir/Source/GSPThread.h"])
|
|
GS_ALIGNOF_MUTEX_T=$ac_cv_alignof_gs_mutex_t
|
|
if test $ac_cv_alignof_gs_mutex_t = 0 ; then
|
|
AC_MSG_ERROR([Unable to find align of gs_mutex_t (required).])
|
|
fi
|
|
AC_SUBST(GS_ALIGNOF_MUTEX_T)
|
|
|
|
AC_CHECK_SIZEOF(CONDITION_VARIABLE,,[AC_INCLUDES_DEFAULT
|
|
#include <windows.h>])
|
|
GS_SIZEOF_COND_T=$ac_cv_sizeof_CONDITION_VARIABLE
|
|
if test $ac_cv_sizeof_CONDITION_VARIABLE = 0 ; then
|
|
AC_MSG_ERROR([Unable to find size of CONDITION_VARIABLE (required).])
|
|
fi
|
|
AC_SUBST(GS_SIZEOF_COND_T)
|
|
|
|
AC_CHECK_ALIGNOF(CONDITION_VARIABLE,[AC_INCLUDES_DEFAULT
|
|
#include <windows.h>])
|
|
GS_ALIGNOF_COND_T=$ac_cv_alignof_CONDITION_VARIABLE
|
|
if test $ac_cv_alignof_CONDITION_VARIABLE = 0 ; then
|
|
AC_MSG_ERROR([Unable to find align of CONDITION_VARIABLE (required).])
|
|
fi
|
|
AC_SUBST(GS_ALIGNOF_COND_T)
|
|
|
|
AC_CHECK_SIZEOF(SRWLOCK,,[AC_INCLUDES_DEFAULT
|
|
#include <windows.h>])
|
|
GS_SIZEOF_COND_MUTEX_T=$ac_cv_sizeof_SRWLOCK
|
|
if test $ac_cv_sizeof_SRWLOCK = 0 ; then
|
|
AC_MSG_ERROR([Unable to find size of SRWLOCK (required).])
|
|
fi
|
|
AC_SUBST(GS_SIZEOF_COND_MUTEX_T)
|
|
|
|
AC_CHECK_ALIGNOF(SRWLOCK,[AC_INCLUDES_DEFAULT
|
|
#include <windows.h>])
|
|
GS_ALIGNOF_COND_MUTEX_T=$ac_cv_alignof_SRWLOCK
|
|
if test $ac_cv_alignof_SRWLOCK = 0 ; then
|
|
AC_MSG_ERROR([Unable to find align of SRWLOCK (required).])
|
|
fi
|
|
AC_SUBST(GS_ALIGNOF_COND_MUTEX_T)
|
|
fi
|
|
|
|
#--------------------------------------------------------------------
|
|
# One of these function needed by NSThread.m and objc initialize test
|
|
#--------------------------------------------------------------------
|
|
AC_CHECK_FUNCS(nanosleep usleep Sleep)
|
|
|
|
AC_MSG_CHECKING(for objc_root_class attribute support)
|
|
saved_CFLAGS="$CFLAGS"
|
|
CFLAGS="$CFLAGS -Werror $OBJCFLAGS -x objective-c"
|
|
AC_COMPILE_IFELSE([AC_LANG_SOURCE([
|
|
__attribute__((objc_root_class)) @interface RootObject
|
|
@end
|
|
@implementation RootObject
|
|
@end])],
|
|
AC_MSG_RESULT([found])
|
|
gs_objc_root_class_attr=1,
|
|
AC_MSG_RESULT([not present])
|
|
gs_objc_root_class_attr=0
|
|
)
|
|
|
|
GS_HAVE_OBJC_ROOT_CLASS_ATTR=$gs_objc_root_class_attr
|
|
AC_SUBST(GS_HAVE_OBJC_ROOT_CLASS_ATTR)
|
|
AC_DEFINE_UNQUOTED(HAVE_OBJC_ROOT_CLASS_ATTRIBUTE,$gs_objc_root_class_attr,
|
|
[Says whether the objc_root_class attribute works])
|
|
CFLAGS=$saved_CFLAGS
|
|
|
|
#--------------------------------------------------------------------
|
|
# Check whether we can get the system thread ID
|
|
#--------------------------------------------------------------------
|
|
AC_CACHE_CHECK([for gettid()], ac_cv_gettid,
|
|
[AC_RUN_IFELSE(
|
|
[AC_LANG_SOURCE([[#define _GNU_SOURCE
|
|
#include <unistd.h>
|
|
#include <sys/syscall.h>
|
|
#include <sys/types.h>
|
|
int main(int argc, char **argv) {
|
|
pid_t t = syscall(SYS_gettid); return t == -1 ? 1 : 0; }]])],
|
|
[ac_cv_gettid=yes],
|
|
[ac_cv_gettid=no],
|
|
[ac_cv_gettid=no])])
|
|
if test "$ac_cv_gettid" = "yes"; then
|
|
AC_DEFINE(HAVE_GETTID, 1, [Define if you have gettid()])
|
|
fi
|
|
|
|
#--------------------------------------------------------------------
|
|
# Check whether Objective-C /really/ works
|
|
#--------------------------------------------------------------------
|
|
AC_MSG_CHECKING(whether objc really works)
|
|
saved_LIBS="$LIBS"
|
|
saved_CPPFLAGS="$CPPFLAGS"
|
|
LIBS="$LIBS $LIBOBJC"
|
|
CPPFLAGS="$CPPFLAGS $OBJCFLAGS -x objective-c"
|
|
if test x"$objc_threaded" != x""; then
|
|
LIBS="$LIBS $objc_threaded"
|
|
fi
|
|
LIBS="$LIBS $extra_LIBS"
|
|
AC_CACHE_VAL(gs_cv_objc_works,
|
|
AC_RUN_IFELSE(
|
|
[AC_LANG_SOURCE([[#include "$srcdir/config/config.objc.m"]])],
|
|
[gs_cv_objc_works=yes],
|
|
[gs_cv_objc_works=no],
|
|
[gs_cv_objc_works="$cross_gs_cv_objc_works"])
|
|
)
|
|
if test $gs_cv_objc_works = yes; then
|
|
AC_MSG_RESULT(yes)
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
echo "I don't seem to be able to use your Objective-C compiler to produce"
|
|
echo "working binaries! Please check your Objective-C compiler installation."
|
|
echo "If you are using gcc-3.x make sure that your compiler's libgcc_s and libobjc"
|
|
echo "can be found by the dynamic linker - usually that requires you to play"
|
|
echo "with LD_LIBRARY_PATH or /etc/ld.so.conf."
|
|
echo "Please refer to your compiler installation instructions for more help."
|
|
AC_MSG_ERROR(The Objective-C compiler does not work or is not installed properly.)
|
|
fi
|
|
|
|
# Don't revert any Objective-C flags as they are used in the next test
|
|
|
|
#---------------------------------------------------------------------
|
|
# See if we are using a compiler which allows us to change the class
|
|
# to be used for constant strings by using the -fconstant-string-class
|
|
# option. If that is the case, we change it to NSConstantString.
|
|
# Unless we are building for the apple runtime (ie only building base
|
|
# additions library and not implementing a constant string class).
|
|
#---------------------------------------------------------------------
|
|
if test "$OBJC_RUNTIME_LIB" = "nx" -o "$OBJC_RUNTIME_LIB" = "apple"; then
|
|
NX_CONST_STRING_OBJCFLAGS=""
|
|
NX_CONST_STRING_CLASS=NXConstantString
|
|
else
|
|
strclass_CPPFLAGS="$CPPFLAGS"
|
|
CPPFLAGS="$CPPFLAGS -fconstant-string-class=FooConstantString"
|
|
AC_MSG_CHECKING(if the compiler supports -fconstant-string-class)
|
|
AC_CACHE_VAL(gs_cv_objc_compiler_supports_constant_string_class,
|
|
AC_RUN_IFELSE(
|
|
[AC_LANG_SOURCE(
|
|
[[#include "$srcdir/config/config.constant-string-class.m"]])],
|
|
[gs_cv_objc_compiler_supports_constant_string_class=yes],
|
|
[gs_cv_objc_compiler_supports_constant_string_class=no],
|
|
[gs_cv_objc_compiler_supports_constant_string_class="$cross_gs_cv_objc_compiler_supports_constant_string_class"])
|
|
)
|
|
if test $gs_cv_objc_compiler_supports_constant_string_class = yes; then
|
|
NX_CONST_STRING_OBJCFLAGS="-fconstant-string-class=NSConstantString"
|
|
NX_CONST_STRING_CLASS=NSConstantString
|
|
AC_MSG_RESULT(yes)
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
AC_ARG_ENABLE(nxconstantstring,
|
|
[ --enable-nxconstantstring
|
|
Enables the use of the NXConstantString class for old compilers.],,
|
|
enable_nxconstantstring=no)
|
|
if test $enable_nxconstantstring = yes; then
|
|
NX_CONST_STRING_OBJCFLAGS=""
|
|
NX_CONST_STRING_CLASS=NXConstantString
|
|
AC_MSG_WARN([You have enabled the use of NXConstantString as the string class in gnustep-base. The objective-c runtime library typically implements its own class of the same name, so you must either enforce a link order which ensures that the gnustep-base implementation is used, or (better) you must remove the class from the runtime library!])
|
|
else
|
|
AC_MSG_ERROR([Your compiler does not appear to implement the -fconstant-string-class option needed for support of strings. Please check for a more recent version or consider using --enable-nxconstantstring])
|
|
fi
|
|
fi
|
|
CPPFLAGS="$strclass_CPPFLAGS"
|
|
fi
|
|
|
|
AC_SUBST(NX_CONST_STRING_OBJCFLAGS)
|
|
AC_SUBST(NX_CONST_STRING_CLASS)
|
|
|
|
# Don't revert any Objective-C flags as they are used in the next test
|
|
|
|
#---------------------------------------------------------------------
|
|
# Guess if we are using a compiler which has the (GNU extension) +load
|
|
# method which is executed before main.
|
|
# Defines HAVE_LOAD_METHOD if +load methods are called before main.
|
|
# Needed by NSProcessInfo.m
|
|
#---------------------------------------------------------------------
|
|
AC_MSG_CHECKING(if +load method is executed before main)
|
|
AC_CACHE_VAL(gs_cv_objc_load_method_worked,
|
|
AC_RUN_IFELSE(
|
|
[AC_LANG_SOURCE([[#include "$srcdir/config/config.loadtest.m"]])],
|
|
[gs_cv_objc_load_method_worked=yes],
|
|
[gs_cv_objc_load_method_worked=no],
|
|
[gs_cv_objc_load_method_worked="$cross_gs_cv_objc_load_method_worked"])
|
|
)
|
|
if test $gs_cv_objc_load_method_worked = yes; then
|
|
AC_DEFINE(HAVE_LOAD_METHOD,1,
|
|
[Define if your Obj-C compiler calls +load methods before main])
|
|
AC_MSG_RESULT(yes)
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
fi
|
|
|
|
# Don't revert any Objective-C flags as they are used in the next test
|
|
|
|
#--------------------------------------------------------------------
|
|
# Check for thread synchronisation support in runtime
|
|
#--------------------------------------------------------------------
|
|
if test "$host_os" = windows -a "$OBJC_RUNTIME_LIB" = "ng"; then
|
|
# On Windows MSVC, AC_CHECK_FUNCS() will throw linker errors ("relocation
|
|
# against symbol in discarded section") as the file won't contain any actual
|
|
# ObjC code, so we just assume the function is there.
|
|
AC_MSG_NOTICE([assuming objc_sync_enter() on Windows MSVC])
|
|
OBJCSYNC=1
|
|
else
|
|
AC_CHECK_FUNCS(objc_sync_enter)
|
|
if test $ac_cv_func_objc_sync_enter = yes ; then
|
|
OBJCSYNC=1
|
|
else
|
|
OBJCSYNC=0
|
|
if test "$OBJC_RUNTIME_LIB" = "ng"; then
|
|
AC_MSG_ERROR([The objc runtime library does not appear to have synchronisation support. Try re-configuring gnustep-make with a CPPFLAGS variable containing a -L point to specify the directory containing the correct libobjc, or using the --with-objc-lib-flag=... option.])
|
|
fi
|
|
fi
|
|
fi
|
|
AC_SUBST(OBJCSYNC)
|
|
|
|
# Don't revert any Objective-C flags as they are used in the next test
|
|
|
|
#--------------------------------------------------------------------
|
|
# Check for ObjC2 support in runtime
|
|
#--------------------------------------------------------------------
|
|
if test "$cross_compiling" = "yes"; then
|
|
AC_MSG_NOTICE(["Cross compiling! Using predefined OBJC2RUNTIME variable"])
|
|
OBJC2RUNTIME="$cross_objc2_runtime"
|
|
elif test "$host_os" = windows -a "$OBJC_RUNTIME_LIB" = "ng"; then
|
|
# On Windows MSVC, AC_CHECK_FUNCS() will throw linker errors ("relocation
|
|
# against symbol in discarded section") as the file won't contain any actual
|
|
# ObjC code, so we just assume the function is there.
|
|
AC_MSG_NOTICE([assuming objc_setProperty() on Windows MSVC])
|
|
OBJC2RUNTIME=1
|
|
else
|
|
AC_CHECK_FUNCS(objc_setProperty)
|
|
if test $ac_cv_func_objc_setProperty = yes ; then
|
|
OBJC2RUNTIME=1
|
|
else
|
|
OBJC2RUNTIME=0
|
|
if test "$OBJC_RUNTIME_LIB" = "ng"; then
|
|
AC_MSG_ERROR([The objc runtime library does not appear to have property support. Try re-configuring gnustep-make with a CPPFLAGS variable containing a -L point to specify the directory containing the correct libobjc, or using the --with-objc-lib-flag=... option.])
|
|
fi
|
|
fi
|
|
fi
|
|
AC_SUBST(OBJC2RUNTIME)
|
|
|
|
#--------------------------------------------------------------------
|
|
# Check for blocks support in runtime
|
|
#--------------------------------------------------------------------
|
|
if test "$host_os" = windows -a "$OBJC_RUNTIME_LIB" = "ng"; then
|
|
# On Windows MSVC, AC_CHECK_FUNCS() will throw linker errors ("relocation
|
|
# against symbol in discarded section") as the file won't contain any actual
|
|
# ObjC code, so we just assume the function is there.
|
|
AC_MSG_NOTICE([assuming _Block_copy() on Windows MSVC])
|
|
HAVE_BLOCKS=1
|
|
else
|
|
AC_CHECK_FUNCS(_Block_copy)
|
|
if test $ac_cv_func__Block_copy = yes ; then
|
|
HAVE_BLOCKS=1
|
|
else
|
|
HAVE_BLOCKS=0
|
|
if test "$OBJC_RUNTIME_LIB" = "ng"; then
|
|
AC_MSG_ERROR([The objc runtime library does not appear to have blocks support. Try re-configuring gnustep-make with a CPPFLAGS variable containing a -L point to specify the directory containing the correct libobjc, or using the --with-objc-lib-flag=... option.])
|
|
fi
|
|
fi
|
|
fi
|
|
AC_SUBST(HAVE_BLOCKS)
|
|
|
|
# Don't revert any Objective-C flags as they are used in the next test
|
|
|
|
GS_NONFRAGILE=0
|
|
if test "$nonfragile" = "yes"; then
|
|
if test "$host_os" = windows -a "$OBJC_RUNTIME_LIB" = "ng"; then
|
|
# On Windows MSVC, AC_CHECK_FUNCS() will throw linker errors ("relocation
|
|
# against symbol in discarded section") as the file won't contain any actual
|
|
# ObjC code, so we just assume the function is there.
|
|
AC_MSG_NOTICE([assuming non-fragile-abi support on Windows MSVC])
|
|
GS_NONFRAGILE=1
|
|
else
|
|
saved_CPPFLAGS="$CPPFLAGS"
|
|
CPPFLAGS="$CPPFLAGS $OBJCFLAGS -x objective-c"
|
|
AC_MSG_CHECKING(for non-fragile-abi support)
|
|
AC_RUN_IFELSE([AC_LANG_SOURCE(
|
|
[[#include "$srcdir/config/config.non-fragile-ivars.m"]])],
|
|
non_fragile=yes, non_fragile=no,
|
|
non_fragile="$cross_non_fragile")
|
|
CPPFLAGS="$saved_CPPFLAGS"
|
|
if test $non_fragile = yes; then
|
|
GS_NONFRAGILE=1
|
|
fi
|
|
AC_MSG_RESULT($non_fragile)
|
|
fi
|
|
fi
|
|
AC_SUBST(GS_NONFRAGILE)
|
|
|
|
|
|
# Don't revert any Objective-C flags as they are used in the next test
|
|
|
|
#--------------------------------------------------------------------
|
|
# get_uninstalled_dtable used by behavior.m and objc-load.m
|
|
#--------------------------------------------------------------------
|
|
AC_EGREP_HEADER(objc_get_uninstalled_dtable, objc/objc-api.h,
|
|
AC_DEFINE(HAVE_OBJC_GET_UNINSTALLED_DTABLE,1,
|
|
[ Define if objc-api.h defines this function]),)
|
|
|
|
# Don't revert any Objective-C flags as they are used in the next test
|
|
|
|
|
|
#--------------------------------------------------------------------
|
|
# Native Objective-C exceptions
|
|
#--------------------------------------------------------------------
|
|
|
|
if test "$OBJC_RUNTIME_LIB" = "ng"; then
|
|
exceptions=yes
|
|
else
|
|
# Determine if native Objective-C exceptions are enabled
|
|
# in gnustep-make. They are enabled if the compiler supports it; they
|
|
# are disabled if it doesn't. And, of course, the user may have
|
|
# forced one behaviour or the other. Note that we go and look at the
|
|
# actual config.make file to be able to know what was configured in
|
|
# gnustep-make regardless of any gnustep-base that is currently
|
|
# installed. We can't use `gnustep-config --objc-flags` because that
|
|
# may report native exceptions as disabled because the currently
|
|
# installed gnustep-base has them disabled.
|
|
if grep USE_OBJC_EXCEPTIONS $CURRENT_GNUSTEP_MAKEFILES/$lobj_dir/config.make | grep yes >&5 2>&5; then
|
|
exceptions=yes
|
|
else
|
|
exceptions=no
|
|
fi
|
|
fi
|
|
|
|
# At this point, if exceptions=no, then native exceptions are disabled
|
|
# and won't be used. If exceptions=yes, we need to check if they work
|
|
# and if the runtime has proper support for them. If it does, we'll
|
|
# happily use them; if it doesn't, we'll automatically disable them
|
|
# because they don't work. ;-)
|
|
|
|
#--------------------------------------------------------------------
|
|
# One of these is needed by for handling uncaught exceptions
|
|
#--------------------------------------------------------------------
|
|
|
|
# TODO: These checks are not really needed if native exceptions are
|
|
# disabled. So maybe we should not run them at all in that case. On
|
|
# the other hand, that case is going to become more and more unusual.
|
|
|
|
AC_MSG_CHECKING(for objc_setUncaughtExceptionHandler() in runtime)
|
|
AC_LINK_IFELSE([AC_LANG_SOURCE(
|
|
[[#include "$srcdir/config/config.setUncaughtExceptionHandler.m"]])],
|
|
have_set_uncaught_exception_handler=yes, have_set_uncaught_exception_handler=no)
|
|
if test $have_set_uncaught_exception_handler = yes; then
|
|
AC_DEFINE(HAVE_SET_UNCAUGHT_EXCEPTION_HANDLER,1,
|
|
[Define if libobjc has the objc_setUncaughtExceptionHandler() function])
|
|
fi
|
|
AC_MSG_RESULT($have_set_uncaught_exception_handler)
|
|
|
|
# Don't revert any Objective-C flags as they are used in the next test
|
|
|
|
AC_MSG_CHECKING(for objc_set_unexpected() in runtime)
|
|
AC_LINK_IFELSE(
|
|
[AC_LANG_SOURCE([[#include "$srcdir/config/config.set_unexpected.m"]])],
|
|
have_set_unexpected=yes, have_set_unexpected=no)
|
|
if test $have_set_unexpected = yes; then
|
|
AC_DEFINE(HAVE_SET_UNEXPECTED,1,
|
|
[Define if libobjc has the objc_set_unexpected() function])
|
|
fi
|
|
AC_MSG_RESULT($have_set_unexpected)
|
|
|
|
# Don't revert any Objective-C flags as they are used in the next test
|
|
|
|
AC_MSG_CHECKING(for _objc_unexpected_exception in runtime)
|
|
if test "$host_os" = windows -a "$OBJC_RUNTIME_LIB" = "ng"; then
|
|
# On Windows MSVC, AC_CHECK_FUNCS() will throw linker errors ("relocation
|
|
# against symbol in discarded section") as the file won't contain any actual
|
|
# ObjC code, so we just assume the function is there.
|
|
AC_MSG_NOTICE([assuming _objc_unexpected_exception() on Windows MSVC])
|
|
have_unexpected=yes
|
|
else
|
|
AC_RUN_IFELSE(
|
|
[AC_LANG_SOURCE([[#include "$srcdir/config/config.unexpected.m"]])],
|
|
have_unexpected=yes,
|
|
have_unexpected=no,
|
|
have_unexpected="$cross_have_unexpected")
|
|
fi
|
|
if test $have_unexpected = yes; then
|
|
AC_DEFINE(HAVE_UNEXPECTED,1,
|
|
[Define if libobjc has the _objc_unexpected_exception callback])
|
|
fi
|
|
AC_MSG_RESULT($have_unexpected)
|
|
|
|
# TODO: It would also be nice to actually test that native Objective-C
|
|
# exceptions work.
|
|
|
|
if test "$exceptions" = "yes"; then
|
|
if test x"$have_set_uncaught_exception_handler" = x"no"; then
|
|
if test x"$have_set_unexpected" = x"no"; then
|
|
if test x"$have_unexpected" = x"no"; then
|
|
AC_MSG_NOTICE([Disabling native Objective-C exceptions because the ObjC runtime])
|
|
AC_MSG_NOTICE([has no way to set an uncaught exception handler. Please install])
|
|
AC_MSG_NOTICE([a recent Objective-C runtime if you want to use them.])
|
|
exceptions="no";
|
|
fi
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
AC_MSG_CHECKING(whether to enable native Objective-C exceptions)
|
|
if test "$exceptions" = "yes"; then
|
|
AC_MSG_RESULT(yes)
|
|
BASE_NATIVE_OBJC_EXCEPTIONS=1
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
BASE_NATIVE_OBJC_EXCEPTIONS=0
|
|
fi
|
|
AC_SUBST(BASE_NATIVE_OBJC_EXCEPTIONS)
|
|
|
|
# Don't revert any Objective-C flags as they are used in the next test
|
|
|
|
#--------------------------------------------------------------------
|
|
# Function needed by @synchronize directive
|
|
#--------------------------------------------------------------------
|
|
HAVE_OBJC_SYNC_ENTER=no
|
|
if test "$host_os" = windows -a "$OBJC_RUNTIME_LIB" = "ng"; then
|
|
# On Windows MSVC, AC_CHECK_FUNCS() will throw linker errors ("relocation
|
|
# against symbol in discarded section") as the file won't contain any actual
|
|
# ObjC code, so we just assume the function is there.
|
|
AC_MSG_NOTICE([assuming objc_sync_enter() on Windows MSVC])
|
|
HAVE_OBJC_SYNC_ENTER=yes
|
|
else
|
|
AC_CHECK_FUNCS(objc_sync_enter)
|
|
if test $ac_cv_func_objc_sync_enter = yes ; then
|
|
HAVE_OBJC_SYNC_ENTER=yes
|
|
fi
|
|
fi
|
|
AC_SUBST(HAVE_OBJC_SYNC_ENTER)
|
|
|
|
# Don't revert any Objective-C flags as they are used in the next test
|
|
|
|
AC_MSG_CHECKING(for thread-safe +initialize in runtime)
|
|
AC_RUN_IFELSE(
|
|
[AC_LANG_SOURCE([[#include "$srcdir/config/config.initialize.m"]])],
|
|
safe_initialize=yes, safe_initialize=no, safe_initialize="$cross_safe_initialize")
|
|
if test $safe_initialize = yes; then
|
|
AC_DEFINE(HAVE_INITIALIZE,1,
|
|
[Define if libobjc has thread-safe +initialize support])
|
|
else
|
|
AC_MSG_WARN([Your ObjectiveC runtime does not support thread-safe class initialisation. Please use a different runtime if you intend to use threads.])
|
|
fi
|
|
AC_MSG_RESULT($safe_initialize)
|
|
|
|
LIBS="$saved_LIBS"
|
|
CPPFLAGS="$saved_CPPFLAGS"
|
|
|
|
AC_SUBST(OBJCFLAGS)
|
|
|
|
#--------------------------------------------------------------------
|
|
# Generic settings needed by NSZone.m
|
|
#--------------------------------------------------------------------
|
|
AC_TYPE_SIZE_T
|
|
AC_C_INLINE
|
|
|
|
#--------------------------------------------------------------------
|
|
# Following header checks needed for bzero in Storage.m and other places
|
|
#--------------------------------------------------------------------
|
|
|
|
AC_CHECK_HEADERS(string.h memory.h alloca.h)
|
|
|
|
#--------------------------------------------------------------------
|
|
# Following header check needed NSConnection.h
|
|
#--------------------------------------------------------------------
|
|
AC_CHECK_HEADERS(float.h)
|
|
|
|
#--------------------------------------------------------------------
|
|
# Header files and functions for files and filesystems
|
|
#--------------------------------------------------------------------
|
|
AC_CHECK_HEADERS(sys/stat.h sys/vfs.h sys/statfs.h sys/statvfs.h pwd.h grp.h)
|
|
AC_CHECK_HEADERS(sys/cdefs.h sys/syslimits.h sys/param.h)
|
|
# Twisted header checks for some BSDs with stupid interdependencies
|
|
AC_CHECK_HEADERS([sys/syslimits.h], [], [],
|
|
[#if HAVE_SYS_CDEFS_H
|
|
#include <sys/cdefs.h>
|
|
#endif
|
|
#include <sys/syslimits.h>
|
|
])
|
|
AC_CHECK_HEADERS([sys/param.h], [], [],
|
|
[#if HAVE_SYS_CDEFS_H
|
|
#include <sys/cdefs.h>
|
|
#endif
|
|
#if HAVE_SYS_SYSLIMITS_H
|
|
#include <sys/syslimits.h>
|
|
#endif
|
|
])
|
|
AC_CHECK_HEADERS([sys/mount.h], [], [],
|
|
[#if HAVE_SYS_CDEFS_H
|
|
#include <sys/cdefs.h>
|
|
#endif
|
|
#if HAVE_SYS_SYSLIMITS_H
|
|
#include <sys/syslimits.h>
|
|
#endif
|
|
#if HAVE_SYS_PARAM_H
|
|
#include <sys/param.h>
|
|
#endif
|
|
])
|
|
AC_CHECK_HEADERS(sys/types.h windows.h locale.h langinfo.h)
|
|
saved_LIBS="$LIBS"
|
|
AC_CHECK_LIB(m, main)
|
|
AC_CHECK_FUNCS(utimensat statvfs link symlink readlink geteuid getlogin getpwnam getpwnam_r getpwuid getpwuid_r getgrgid getgrgid_r getgrnam getgrnam_r rint getopt malloc_usable_size)
|
|
LIBS="$saved_LIBS"
|
|
|
|
AC_CACHE_CHECK([for pw_gecos field in struct passwd],
|
|
ac_cv_have_pw_gecos_in_struct_passwd, [
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ #include <pwd.h> ]],
|
|
[[ struct passwd p; p.pw_gecos = 0; ]])],
|
|
[ ac_cv_have_pw_gecos_in_struct_passwd="yes" ],
|
|
[ ac_cv_have_pw_gecos_in_struct_passwd="no"
|
|
])
|
|
])
|
|
if test "x$ac_cv_have_pw_gecos_in_struct_passwd" = "xyes" ; then
|
|
AC_DEFINE([HAVE_PW_GECOS_IN_PASSWD], [1],
|
|
[Define if you have pw_gecos field in struct passwd])
|
|
fi
|
|
|
|
AC_CACHE_CHECK([for currency_symbol field in struct lconv],
|
|
ac_cv_have_currency_symbol_in_struct_lconv, [
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ #include <locale.h> ]],
|
|
[[ struct lconv l; l.currency_symbol = NULL; ]])],
|
|
[ ac_cv_have_currency_symbol_in_struct_lconv="yes" ],
|
|
[ ac_cv_have_currency_symbol_in_struct_lconv="no"
|
|
])
|
|
])
|
|
if test "x$ac_cv_have_currency_symbol_in_struct_lconv" = "xyes" ; then
|
|
AC_DEFINE([HAVE_CURRENCY_SYMBOL_IN_LCONV], [1],
|
|
[Define if you have currency_symbol field in struct lconv])
|
|
fi
|
|
|
|
#--------------------------------------------------------------------
|
|
# These two headers (functions) needed by Time.m
|
|
#--------------------------------------------------------------------
|
|
dnl AC_REPLACE_FUNCS(getrusage gettimeofday)
|
|
|
|
AC_CHECK_HEADERS(time.h sys/time.h tzfile.h sys/rusage.h ucbinclude/sys/resource.h)
|
|
AC_CHECK_FUNCS(time ctime tzset)
|
|
|
|
#--------------------------------------------------------------------
|
|
# These headers/functions needed by GSTcpPort.m
|
|
#--------------------------------------------------------------------
|
|
AC_CHECK_HEADERS(sys/socket.h netinet/in.h)
|
|
AC_CHECK_TYPES([socklen_t])
|
|
|
|
#--------------------------------------------------------------------
|
|
# This needed by GSSocketStream.h
|
|
#--------------------------------------------------------------------
|
|
AC_CHECK_TYPE([struct sockaddr_storage],
|
|
AC_DEFINE(HAVE_STRUCT_SOCKADDR_STORAGE, 1,
|
|
[if struct sockaddr_storage is defined]), ,[
|
|
#undef inline
|
|
#ifdef HAVE_WINDOWS_H
|
|
#include <windows.h>
|
|
#ifdef HAVE_WINSOCK2_H
|
|
#include <winsock2.h>
|
|
#endif
|
|
#else
|
|
#ifdef HAVE_SYS_TYPES_H
|
|
#include <sys/types.h>
|
|
#endif
|
|
#ifdef HAVE_SYS_SOCKET_H
|
|
#include <sys/socket.h>
|
|
#endif
|
|
#ifdef HAVE_NETINET_IN_H
|
|
#include <netinet/in.h>
|
|
#endif
|
|
#ifdef HAVE_ARPA_INET_H
|
|
#include <arpa/inet.h>
|
|
#endif
|
|
#endif
|
|
])
|
|
|
|
dnl AC_REPLACE_FUNCS(recvfrom)
|
|
|
|
#--------------------------------------------------------------------
|
|
# These headers/functions needed for stacktrace in NSException.m
|
|
#--------------------------------------------------------------------
|
|
AC_ARG_ENABLE(bfd,
|
|
[ --enable-bfd
|
|
Enables the use of libbfd to provide symbolic stack traces.
|
|
Enabling this option provides support for symbolic stack traces
|
|
on platforms where the backtrace_symbols() function is not
|
|
available or does not work properly.
|
|
Enabling this option also has the effect of changing the license
|
|
of gnustep-base from LGPL to GPL since libbfd uses the GPL license],,
|
|
enable_bfd=no)
|
|
if test $enable_bfd = yes ; then
|
|
AC_DEFINE(USE_BFD,1, [Define to use bfd library for stack traces])
|
|
AC_MSG_WARN([You enabled bfd, which causes gnustep-base to link with libbfd. This makes the license GPL rather than the normal LGPL.])
|
|
fi
|
|
|
|
AC_CHECK_HEADERS(bfd.h)
|
|
AC_CHECK_LIB(intl, libintl_fprintf)
|
|
AC_CHECK_LIB(zstd, ZSTD_compress)
|
|
AC_CHECK_LIB(iberty, dyn_string_append)
|
|
AC_CHECK_LIB(z, gzseek)
|
|
AC_SEARCH_LIBS(sframe, sframe_decode)
|
|
AC_CHECK_LIB(bfd, bfd_openr)
|
|
|
|
AC_COMPILE_IFELSE(
|
|
[AC_LANG_PROGRAM([[#include <bfd.h>]],[[bfd_section_vma(0);]])],
|
|
[bfd_section_vma=1],
|
|
[bfd_section_vma=0])
|
|
if test $bfd_section_vma = 1; then
|
|
AC_MSG_RESULT([bfd_section_vma found])
|
|
AC_DEFINE([HAVE_BFD_SECTION_VMA], [1], [Have bfd_section_vma])
|
|
fi
|
|
|
|
|
|
case "$target_os" in
|
|
mingw*)
|
|
AC_CHECK_HEADERS(dbghelp.h)
|
|
;;
|
|
*)
|
|
AC_CHECK_HEADERS(execinfo.h)
|
|
AC_CHECK_FUNCS(backtrace)
|
|
;;
|
|
esac
|
|
|
|
AC_CHECK_FUNCS(__builtin_extract_return_address)
|
|
|
|
# Enable unwind if found by default
|
|
AC_ARG_WITH(unwind,
|
|
AS_HELP_STRING([--without-unwind], [Ignore unwind if found and disable it]))
|
|
|
|
AS_IF([test "x$with_unwind" != "xno"],
|
|
[AC_CHECK_HEADERS(unwind.h)] [AC_CHECK_FUNCS(_Unwind_GetIP)],
|
|
[have_unwind=no])
|
|
|
|
AS_IF([test "x$ac_cv_func__Unwind_GetIP" = "xyes"],
|
|
[have_unwind=yes],
|
|
[have_unwind=no])
|
|
|
|
AS_IF([test "x$have_unwind" = "xyes"],
|
|
[AC_DEFINE([WITH_UNWIND], [1], [Have and use Unwind library])],
|
|
[AS_IF([test "x$with_unwind" = "xyes"],
|
|
[AC_MSG_ERROR([unwind requested but not found])
|
|
])
|
|
])
|
|
|
|
#--------------------------------------------------------------------
|
|
# These headers/functions needed by NSLog.m
|
|
#--------------------------------------------------------------------
|
|
AC_CHECK_HEADERS(syslog.h sys/slog.h sys/slogcodes.h)
|
|
AC_CHECK_FUNCS(syslog)
|
|
if test "$ac_cv_header_sys_slog_h" = "yes"; then
|
|
oldLibs="$LIBS";
|
|
LIBS="$LIBS -l:libc.a";
|
|
AC_CHECK_FUNCS(slogf)
|
|
if test "$ac_cv_func_slogf" = "no"; then
|
|
LIBS="$oldLibs"
|
|
fi
|
|
fi
|
|
#--------------------------------------------------------------------
|
|
# These headers/functions needed by NSRunLoop.m
|
|
#--------------------------------------------------------------------
|
|
AC_CHECK_HEADERS(poll.h)
|
|
AC_CHECK_FUNCS(poll)
|
|
have_poll=no
|
|
if test $ac_cv_header_poll_h = yes; then
|
|
have_poll=yes
|
|
AC_MSG_CHECKING(for poll emulation)
|
|
AC_EGREP_CPP(emulating_poll, [#include "config/config.poll.c"],
|
|
have_poll=no,)
|
|
if test $have_poll = yes; then
|
|
AC_MSG_RESULT(no)
|
|
AC_MSG_CHECKING([if poll supports devices])
|
|
AC_RUN_IFELSE(
|
|
[AC_LANG_SOURCE([[#include "$srcdir/config/config.poll-dev.c"]])],
|
|
,
|
|
[have_poll=no],
|
|
[have_poll="$cross_have_poll"])
|
|
if test $have_poll = yes; then
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(HAVE_POLL_F,1, [ Define if poll is NOT emulated via select])
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
fi
|
|
else
|
|
AC_MSG_RESULT(yes)
|
|
fi
|
|
fi
|
|
|
|
#--------------------------------------------------------------------
|
|
# This function needed by StdioStream.m
|
|
#--------------------------------------------------------------------
|
|
AC_CHECK_FUNCS(vsprintf vasprintf snprintf vsnprintf)
|
|
if test $ac_cv_func_vsprintf = yes ; then
|
|
AC_RUN_IFELSE(
|
|
[AC_LANG_SOURCE([[#include "$srcdir/config/config.vsprintf.c"]])],
|
|
[VSPRINTF_RETURNS_LENGTH=1],
|
|
[VSPRINTF_RETURNS_LENGTH=0],
|
|
[VSPRINTF_RETURNS_LENGTH="$cross_VSPRINTF_RETURNS_LENGTH"])
|
|
AC_DEFINE_UNQUOTED(VSPRINTF_RETURNS_LENGTH, $VSPRINTF_RETURNS_LENGTH,
|
|
[Define if vsprintf returns the length printed])
|
|
fi
|
|
if test $ac_cv_func_vasprintf = yes ; then
|
|
AC_RUN_IFELSE(
|
|
[AC_LANG_SOURCE([[#include "$srcdir/config/config.vasprintf.c"]])],
|
|
[VASPRINTF_RETURNS_LENGTH=1],
|
|
[VASPRINTF_RETURNS_LENGTH=0],
|
|
[VASPRINTF_RETURNS_LENGTH="$cross_VASPRINTF_RETURNS_LENGTH"])
|
|
AC_DEFINE_UNQUOTED(VASPRINTF_RETURNS_LENGTH, $VASPRINTF_RETURNS_LENGTH,
|
|
[Define if vasprintf returns the length printed])
|
|
fi
|
|
|
|
#--------------------------------------------------------------------
|
|
# This function needed by NSFileManager.m
|
|
#--------------------------------------------------------------------
|
|
AC_CHECK_FUNCS(getcwd)
|
|
AC_HEADER_DIRENT
|
|
|
|
# Look for file creation and modification date on NetBSD, FreeBSD, Darwin
|
|
AC_CHECK_MEMBERS([struct stat.st_mtim, struct stat.st_birthtime, struct stat.st_birthtimespec, struct stat.st_birthtim, struct stat64.st_birthtimespec],
|
|
,,[#include <sys/stat.h>])
|
|
|
|
#--------------------------------------------------------------------
|
|
# This function needed by gdomap.c
|
|
#--------------------------------------------------------------------
|
|
AC_CHECK_HEADERS(getopt.h)
|
|
|
|
#--------------------------------------------------------------------
|
|
# This function needed by NSPage.m
|
|
#--------------------------------------------------------------------
|
|
AC_CHECK_FUNCS(posix_memalign valloc)
|
|
|
|
#--------------------------------------------------------------------
|
|
# This function needed by Time.m
|
|
#--------------------------------------------------------------------
|
|
AC_CHECK_FUNCS(times)
|
|
|
|
#--------------------------------------------------------------------
|
|
# These functions needed by NSData.m and GSFFIInvocation.m
|
|
#--------------------------------------------------------------------
|
|
AC_CHECK_FUNCS(mkstemp)
|
|
AC_CHECK_FUNCS(shmctl)
|
|
AC_CHECK_FUNCS(mmap)
|
|
AC_CHECK_FUNCS(mprotect)
|
|
AC_CHECK_HEADERS(sys/mman.h)
|
|
|
|
#--------------------------------------------------------------------
|
|
# These functions needed by NSTask.m
|
|
#--------------------------------------------------------------------
|
|
AC_CHECK_FUNCS(killpg setpgrp setpgid setsid grantpt)
|
|
AC_CHECK_FUNCS(closefrom)
|
|
if test "x$ac_cv_func_setpgrp" = xyes; then
|
|
AC_FUNC_SETPGRP
|
|
fi
|
|
|
|
HAVE_PTS_STREAM_MODULES=0
|
|
case "${target}" in
|
|
*-sysv-*)
|
|
HAVE_PTS_STREAM_MODULES=1
|
|
;;
|
|
esac
|
|
AC_DEFINE_UNQUOTED(HAVE_PTS_STREAM_MODULES, $HAVE_PTS_STREAM_MODULES,
|
|
[Define this if you work on sysv])
|
|
AC_SUBST(HAVE_PTS_STREAM_MODULES)
|
|
|
|
AC_CHECK_HEADERS(dnl
|
|
fcntl.h dnl
|
|
inttypes.h dnl
|
|
libc.h dnl
|
|
limits.h dnl
|
|
malloc.h dnl
|
|
memory.h dnl
|
|
signal.h dnl
|
|
stdint.h dnl
|
|
string.h dnl
|
|
sys/fcntl.h dnl
|
|
sys/file.h dnl
|
|
sys/filio.h dnl
|
|
sys/inttypes.h dnl
|
|
sys/ioctl.h dnl
|
|
sys/signal.h dnl
|
|
sys/stropts.h dnl
|
|
sys/wait.h dnl
|
|
unistd.h dnl
|
|
utime.h dnl
|
|
stdlib.h dnl
|
|
stdbool.h dnl
|
|
)
|
|
|
|
if test $ac_cv_header_inttypes_h = yes; then
|
|
INCLUDE_INTTYPES="#include <inttypes.h>"
|
|
elif test $ac_cv_header_sys_inttypes_h = yes; then
|
|
INCLUDE_INTTYPES="#include <sys/inttypes.h>"
|
|
elif test $ac_cv_header_stdint_h = yes; then
|
|
INCLUDE_INTTYPES="#include <stdint.h>"
|
|
else
|
|
INCLUDE_INTTYPES="no"
|
|
fi
|
|
|
|
if test "$INCLUDE_INTTYPES" = "no"; then
|
|
INCLUDE_INTTYPES=""
|
|
DEFINE_INT8_T="#define int8_t gss8"
|
|
DEFINE_UINT8_T="#define uint8_t gsu8"
|
|
DEFINE_INT16_T="#define int16_t gss16"
|
|
DEFINE_UINT16_T="#define uint16_t gsu16"
|
|
DEFINE_INT32_T="#define int32_t gss32"
|
|
DEFINE_UINT32_T="#define uint32_t gsu32"
|
|
DEFINE_INT64_T="#define int64_t gss64"
|
|
DEFINE_UINT64_T="#define uint64_t gsu64"
|
|
DEFINE_INTPTR_T="#define intptr_t gssaddr"
|
|
DEFINE_UINTPTR_T="#define uintptr_t gsuaddr"
|
|
else
|
|
DEFINE_INT8_T=""
|
|
DEFINE_UINT8_T=""
|
|
DEFINE_INT16_T=""
|
|
DEFINE_UINT16_T=""
|
|
DEFINE_INT32_T=""
|
|
DEFINE_UINT32_T=""
|
|
DEFINE_INT64_T=""
|
|
DEFINE_UINT64_T=""
|
|
DEFINE_INTPTR_T=""
|
|
DEFINE_UINTPTR_T=""
|
|
fi
|
|
|
|
AC_SUBST(INCLUDE_INTTYPES)
|
|
AC_SUBST(DEFINE_INT8_T)
|
|
AC_SUBST(DEFINE_UINT8_T)
|
|
AC_SUBST(DEFINE_INT16_T)
|
|
AC_SUBST(DEFINE_UINT16_T)
|
|
AC_SUBST(DEFINE_INT32_T)
|
|
AC_SUBST(DEFINE_UINT32_T)
|
|
AC_SUBST(DEFINE_INT64_T)
|
|
AC_SUBST(DEFINE_UINT64_T)
|
|
AC_SUBST(DEFINE_INTPTR_T)
|
|
AC_SUBST(DEFINE_UINTPTR_T)
|
|
|
|
#--------------------------------------------------------------------
|
|
# These used by GSFileHandle.m and distributed objects
|
|
# On some systems we need -lnsl ... so check for that case.
|
|
#--------------------------------------------------------------------
|
|
AC_CHECK_HEADERS(ws2tcpip.h)
|
|
AC_SEARCH_LIBS([inet_ntop],[nsl Ws2_32])
|
|
AC_CHECK_FUNCS(gethostbyaddr_r inet_aton inet_pton inet_ntop sigaction)
|
|
|
|
USE_ZLIB=0
|
|
AC_CHECK_HEADERS(zlib.h)
|
|
if test $ac_cv_header_zlib_h = yes; then
|
|
AC_CHECK_LIB(z, gzseek, zlib_ok=yes, zlib_ok=no)
|
|
if test "$zlib_ok" = yes; then
|
|
LIBS="$LIBS -lz"
|
|
USE_ZLIB=1
|
|
fi
|
|
fi
|
|
AC_SUBST(USE_ZLIB)
|
|
|
|
HAVE_INET_PTON=no
|
|
if test $ac_cv_func_inet_pton = yes ; then
|
|
HAVE_INET_PTON=yes
|
|
fi
|
|
AC_SUBST(HAVE_INET_PTON)
|
|
|
|
HAVE_INET_NTOP=no
|
|
if test $ac_cv_func_inet_ntop = yes ; then
|
|
HAVE_INET_NTOP=yes
|
|
fi
|
|
AC_SUBST(HAVE_INET_NTOP)
|
|
|
|
#--------------------------------------------------------------------
|
|
# For setting thread stack size
|
|
#--------------------------------------------------------------------
|
|
AC_CHECK_HEADERS(sys/resource.h)
|
|
AC_CHECK_FUNCS(setrlimit)
|
|
|
|
#--------------------------------------------------------------------
|
|
# One of these functions needed by NSDebug.m and NSProcessInfo.m
|
|
#--------------------------------------------------------------------
|
|
AC_CHECK_FUNCS(strerror)
|
|
AC_FUNC_STRERROR_R
|
|
|
|
#--------------------------------------------------------------------
|
|
# Needed by NSDebug.m
|
|
#--------------------------------------------------------------------
|
|
AC_CHECK_FUNCS(sigsetjmp)
|
|
|
|
#--------------------------------------------------------------------
|
|
# This type needed by GSFormat
|
|
#--------------------------------------------------------------------
|
|
AC_CHECK_TYPES([uintmax_t])
|
|
AC_CHECK_HEADERS(wchar.h)
|
|
|
|
#--------------------------------------------------------------------
|
|
# Check if short and int values need to be word aligned
|
|
#--------------------------------------------------------------------
|
|
saved_CFLAGS="$CFLAGS"
|
|
CFLAGS="$CFLAGS -O0"
|
|
AC_MSG_CHECKING(short/int needs to be word aligned)
|
|
AC_RUN_IFELSE(
|
|
[AC_LANG_SOURCE([[#include "$srcdir/config/config.align.c"]])],
|
|
[NEED_WORD_ALIGNMENT=0],
|
|
[NEED_WORD_ALIGNMENT=1],
|
|
[NEED_WORD_ALIGNMENT="$cross_NEED_WORD_ALIGNMENT"])
|
|
CFLAGS="$saved_CFLAGS"
|
|
AC_DEFINE_UNQUOTED(NEED_WORD_ALIGNMENT, $NEED_WORD_ALIGNMENT,
|
|
[Define if your system needs to have short/int word aligned])
|
|
if test $NEED_WORD_ALIGNMENT = 1; then
|
|
AC_MSG_RESULT(yes)
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
fi
|
|
|
|
#--------------------------------------------------------------------
|
|
# This needed by NSString for handling of %@ printf directive.
|
|
#--------------------------------------------------------------------
|
|
AC_CHECK_FUNCS(register_printf_specifier)
|
|
AC_CHECK_FUNC(register_printf_function, register_printf=1,
|
|
register_printf=0)
|
|
if test $register_printf = 1; then
|
|
AC_RUN_IFELSE(
|
|
[AC_LANG_SOURCE([[#include "$srcdir/config/config.printf.c"]])],
|
|
[working_register_printf=1],
|
|
[working_register_printf=0],
|
|
[working_register_printf="$cross_working_register_printf"])
|
|
if test $working_register_printf = 1; then
|
|
AC_DEFINE(HAVE_REGISTER_PRINTF_FUNCTION,1,
|
|
[Define if you have the register_printf_function function])
|
|
AC_RUN_IFELSE(
|
|
[AC_LANG_SOURCE([[#include "$srcdir/config/config.wprintf.c"]])],
|
|
[wide_register_printf=1],
|
|
[wide_register_printf=0],
|
|
[wide_register_printf="$cross_wide_register_printf"])
|
|
if test $wide_register_printf = 1; then
|
|
AC_DEFINE(HAVE_WIDE_PRINTF_FUNCTION,1,
|
|
[Define if register_printf_function supports wide characters])
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
|
|
#--------------------------------------------------------------------
|
|
# This function needed by NSString.
|
|
#--------------------------------------------------------------------
|
|
AC_CHECK_FUNCS(realpath)
|
|
|
|
#--------------------------------------------------------------------
|
|
# Check if the C Library defines extern char *program_invocation_name
|
|
# Used in critical cases by NSProcessInfo.m
|
|
#--------------------------------------------------------------------
|
|
AC_MSG_CHECKING(program_invocation_name in C Library)
|
|
AC_CACHE_VAL(gs_cv_program_invocation_name_worked,
|
|
[AC_RUN_IFELSE(
|
|
[AC_LANG_SOURCE([[
|
|
#include <string.h>
|
|
int
|
|
main (int argc, char *argv[])
|
|
{
|
|
extern char *program_invocation_name;
|
|
return (strcmp (program_invocation_name, argv[0]));
|
|
}
|
|
]])],
|
|
[gs_cv_program_invocation_name_worked=yes],
|
|
[gs_cv_program_invocation_name_worked=no],
|
|
[gs_cv_program_invocation_name_worked="$cross_gs_cv_program_invocation_name_worked"])])
|
|
if test $gs_cv_program_invocation_name_worked = yes; then
|
|
AC_DEFINE(HAVE_PROGRAM_INVOCATION_NAME,1,
|
|
[Define if your Lib C defines program_invocation_name])
|
|
AC_MSG_RESULT(yes)
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
fi
|
|
|
|
#--------------------------------------------------------------------
|
|
# Check for uname header used by NSProcessInfo.m
|
|
#--------------------------------------------------------------------
|
|
AC_CHECK_HEADERS(sys/utsname.h)
|
|
|
|
#--------------------------------------------------------------------
|
|
# Check for sysctlbyname used by NSProcessInfo.m
|
|
#--------------------------------------------------------------------
|
|
AC_CHECK_HEADERS(sys/sysctl.h)
|
|
AC_CHECK_FUNCS(sysctlbyname)
|
|
|
|
#--------------------------------------------------------------------
|
|
# Defines HAVE_PROCFS if the kernel supports the /proc filesystem.
|
|
# Needed by NSProcessInfo.m
|
|
#--------------------------------------------------------------------
|
|
AC_CHECK_HEADERS(procfs.h)
|
|
AC_SYS_PROCFS
|
|
AC_SYS_PROCFS_PSINFO
|
|
AC_SYS_PROCFS_EXE_LINK
|
|
|
|
#--------------------------------------------------------------------
|
|
# Check if /proc/$$/cmdline terminates the last argument with a nul
|
|
#--------------------------------------------------------------------
|
|
AC_MSG_CHECKING(/proc/$$/cmdline terminated by nul)
|
|
AC_RUN_IFELSE(
|
|
[AC_LANG_SOURCE([[#include "$srcdir/config/config.proccmd.c"]])],
|
|
[CMDLINE_TERMINATED=1],
|
|
[CMDLINE_TERMINATED=0],
|
|
[CMDLINE_TERMINATED="$cross_CMDLINE_TERMINATED"])
|
|
AC_DEFINE_UNQUOTED(CMDLINE_TERMINATED, $CMDLINE_TERMINATED,
|
|
[Define if your system terminates the final argument in /proc/$$/cmdline])
|
|
if test $CMDLINE_TERMINATED = 1; then
|
|
AC_MSG_RESULT(yes)
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
fi
|
|
|
|
#--------------------------------------------------------------------
|
|
# If /proc doesn't work, try kvm (on FreeBSD, for instance)
|
|
#--------------------------------------------------------------------
|
|
have_kvm_env=0
|
|
save_LIBS="$LIBS"
|
|
AC_CHECK_LIB(kvm, kvm_getenvv)
|
|
if test "$ac_cv_lib_kvm_kvm_getenvv" = yes; then
|
|
AC_MSG_CHECKING(if we can access kernel memory)
|
|
AC_RUN_IFELSE(
|
|
[AC_LANG_SOURCE[[#include "$srcdir/config/config.kvmopen.c"]])],
|
|
[have_kvm_env=1],
|
|
[have_kvm_env=0],
|
|
[have_kvm_env="$cross_have_kvm_env"])
|
|
if test $have_kvm_env = 1; then
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(HAVE_KVM_ENV, 1,
|
|
[Define if you can access the kernel via kvm_open])
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
# Reset LIBS since we don't need kvm
|
|
LIBS="$save_LIBS"
|
|
fi
|
|
fi
|
|
|
|
#--------------------------------------------------------------------
|
|
# Include redefinition of main () only if needed.
|
|
# On some systems - force redefinition to be used as the /proc stuff
|
|
# doesn't work. Allow NSProcessInfo initialization method also.
|
|
#--------------------------------------------------------------------
|
|
PASS_ARG=no
|
|
case "$target_os" in
|
|
cygwin*) PASS_ARG=yes;;
|
|
esac
|
|
|
|
AC_MSG_CHECKING(use of pass-through arguments)
|
|
AC_ARG_ENABLE(pass-arguments,
|
|
[ --enable-pass-arguments Force user main call to NSProcessInfo initialize],,
|
|
enable_pass_arguments=$PASS_ARG)
|
|
|
|
if test "$enable_pass_arguments" = "yes"; then
|
|
GS_PASS_ARGUMENTS=1
|
|
else
|
|
GS_PASS_ARGUMENTS=0
|
|
fi
|
|
AC_SUBST(GS_PASS_ARGUMENTS)
|
|
AC_MSG_RESULT($enable_pass_arguments)
|
|
|
|
AC_MSG_CHECKING(use of fake-main definition)
|
|
AC_ARG_ENABLE(fake-main,
|
|
[ --enable-fake-main Force redefine of user main function],,
|
|
enable_fake_main=no)
|
|
|
|
if test "$enable_pass_arguments" = "no"; then
|
|
case "$target_os" in
|
|
freebsd2*) enable_fake_main=yes;;
|
|
freebsd*) ;;
|
|
kfreebsd*) enable_fake_main=yes;;
|
|
netbsd*) enable_fake_main=yes;;
|
|
openbsd*) enable_fake_main=yes;;
|
|
*sysv*) enable_fake_main=yes;;
|
|
esac
|
|
fi
|
|
|
|
GS_FAKE_MAIN=0
|
|
if test "$enable_fake_main" = "yes"; then
|
|
GS_FAKE_MAIN=1
|
|
elif test "$enable_pass_arguments" = "no"; then
|
|
if test "$gs_cv_objc_load_method_worked" = yes -a \( "$ac_cv_sys_procfs" = yes -o "$have_kvm_env" = 1 -o "$ac_cv_sys_procfs_psinfo" = yes \); then
|
|
GS_FAKE_MAIN=0
|
|
if test "$have_kvm_env" = "1"; then
|
|
AC_MSG_WARN([Using libkvm which is known to be buggy on some systems consider configuring with --enable-fake-main instead.])
|
|
fi
|
|
else
|
|
case "$target_os" in
|
|
darwin* ) ;;
|
|
* )
|
|
GS_FAKE_MAIN=1
|
|
enable_fake_main=yes
|
|
esac
|
|
fi
|
|
fi
|
|
case "$target_os" in
|
|
mingw*|windows) enable_fake_main=no; GS_FAKE_MAIN=0;;
|
|
esac
|
|
AC_SUBST(GS_FAKE_MAIN)
|
|
AC_MSG_RESULT($enable_fake_main)
|
|
|
|
#--------------------------------------------------------------------
|
|
# Simple way to add a bunch of paths to the flags
|
|
#--------------------------------------------------------------------
|
|
AC_ARG_WITH(include-flags,
|
|
[ --with-include-flags=FLAGS Specify all include flags at once],
|
|
include_flags="$withval", include_flags="no")
|
|
if test ${include_flags} != "no"; then
|
|
CPPFLAGS="$CPPFLAGS ${include_flags}"
|
|
INCLUDE_FLAGS="$INCLUDE_FLAGS ${include_flags}"
|
|
fi
|
|
|
|
AC_ARG_WITH(library-flags,
|
|
[ --with-library-flags=FLAGS Specify all library flags at once],
|
|
library_flags="$withval", library_flags="no")
|
|
if test ${library_flags} != "no"; then
|
|
LDFLAGS="$LDFLAGS ${library_flags}"
|
|
LDIR_FLAGS="$LDIR_FLAGS ${library_flags}"
|
|
fi
|
|
|
|
#--------------------------------------------------------------------
|
|
# Check for FFI interface libraries for invocations
|
|
# We enable ffi by default now, as it's the only well supported
|
|
# library nowadays.
|
|
#--------------------------------------------------------------------
|
|
do_broken_libffi=no
|
|
do_broken_libffcall=no
|
|
do_enable_libffi=yes
|
|
do_enable_libffcall=no
|
|
case "$target_cpu" in
|
|
sparc64*)
|
|
case "$target_os" in
|
|
solaris*)
|
|
do_broken_libffcall=yes;
|
|
do_enable_libffi=yes;
|
|
do_enable_libffcall=no;;
|
|
*) ;;
|
|
esac ;;
|
|
*) ;;
|
|
esac
|
|
|
|
if test "$exceptions" = "yes"; then
|
|
# ffcall will mess up native exceptions, so we must disable it.
|
|
do_broken_libffcall=yes
|
|
do_enable_libffcall=no
|
|
fi
|
|
|
|
AC_ARG_ENABLE(libffi,
|
|
[ --disable-libffi Disable use of libffi library],,
|
|
enable_libffi=$do_enable_libffi)
|
|
|
|
AC_ARG_ENABLE(ffcall,
|
|
[ --enable-ffcall Enable use of the deprecated ffcall library],,
|
|
enable_ffcall=$do_enable_libffcall)
|
|
|
|
if test $enable_ffcall = yes; then
|
|
AC_MSG_WARN([ffcall has been enabled ... this is deprecated ... please install and use a recent libffi if possible])
|
|
fi
|
|
|
|
AC_ARG_ENABLE(invocations,
|
|
[ --disable-invocations Build even if invocation-dependencies are not met],,
|
|
enable_invocations=yes)
|
|
|
|
# DO isn't used on apple-apple-apple
|
|
if test $LIBRARY_COMBO = apple-apple-apple; then
|
|
enable_invocations=no
|
|
fi
|
|
|
|
AC_ARG_WITH(ffi-include,
|
|
[ --with-ffi-include=PATH Include path for ffi headers],
|
|
ffi_incdir="$withval", ffi_incdir="no")
|
|
if test ${ffi_incdir} != "no"; then
|
|
CPPFLAGS="$CPPFLAGS -I${ffi_incdir}"
|
|
INCLUDE_FLAGS="$INCLUDE_FLAGS -I${ffi_incdir}"
|
|
fi
|
|
|
|
AC_ARG_WITH(ffi-library,
|
|
[ --with-ffi-library=PATH Library path for ffi libs],
|
|
ffi_libdir="$withval", ffi_libdir="no")
|
|
if test ${ffi_libdir} != "no"; then
|
|
GS_ADD_LIBRARY_PATH([${ffi_libdir}])
|
|
fi
|
|
|
|
if test "$do_broken_libffi" = "no"; then
|
|
if test -n "$PKG_CONFIG"; then
|
|
if $PKG_CONFIG --exists libffi; then
|
|
pkg_config_libffi=yes
|
|
ffi_CFLAGS=`$PKG_CONFIG --cflags libffi`;
|
|
CPPFLAGS="$CPPFLAGS $ffi_CFLAGS"
|
|
INCLUDE_FLAGS="$INCLUDE_FLAGS $ffi_CFLAGS"
|
|
fi
|
|
fi
|
|
AC_CHECK_HEADER(ffi.h, have_libffi=yes, have_libffi=no)
|
|
else
|
|
have_libffi=no
|
|
fi
|
|
if test "$do_broken_libffcall" = "no"; then
|
|
AC_CHECK_HEADERS(callback.h, have_ffcall=yes, have_ffcall=no)
|
|
else
|
|
have_ffcall=no
|
|
fi
|
|
if test $have_ffcall = no; then
|
|
enable_ffcall=no
|
|
# If we don't have ffcall but do have libffi, use libffi
|
|
if test $have_libffi = yes; then
|
|
enable_libffi=yes
|
|
fi
|
|
fi
|
|
if test $have_libffi = no; then
|
|
enable_libffi=no
|
|
# If we don't have libffi but do have ffcall, use ffcall
|
|
if test $have_ffcall = yes; then
|
|
if test $enable_ffcall = no; then
|
|
AC_MSG_WARN([ffi support seems to be missing on this system ... please install a recent libffi])
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
have_forward_hook=yes
|
|
saved_CPPFLAGS="$CPPFLAGS"
|
|
CPPFLAGS="$CPPFLAGS $OBJCFLAGS -x objective-c"
|
|
AC_MSG_CHECKING(for forwarding callback in runtime)
|
|
AC_COMPILE_IFELSE(
|
|
[AC_LANG_SOURCE([[#include "$srcdir/config/config.forward2.m"]])],
|
|
have_forward_hook=yes, have_forward_hook=no)
|
|
if test $have_forward_hook = yes; then
|
|
AC_DEFINE(HAVE_FORWARD2,1,
|
|
[Define if libobjc has the __objc_msg_forward2 function])
|
|
else
|
|
AC_COMPILE_IFELSE(
|
|
[AC_LANG_SOURCE([[#include "$srcdir/config/config.forward.m"]])],
|
|
have_forward_hook=yes, have_forward_hook=no)
|
|
fi
|
|
AC_MSG_RESULT($have_forward_hook)
|
|
if test $have_forward_hook = no; then
|
|
enable_libffi=no
|
|
enable_ffcall=no
|
|
fi
|
|
CPPFLAGS="$saved_CPPFLAGS"
|
|
|
|
AC_MSG_CHECKING(FFI library usage)
|
|
WITH_FFI=none
|
|
if test $enable_libffi = yes; then
|
|
AC_DEFINE(USE_LIBFFI,1,
|
|
[Define if using the libffi library for invocations])
|
|
WITH_FFI=libffi
|
|
if test "$pkg_config_libffi" = "yes"; then
|
|
ffi_LIBS=`pkg-config --libs libffi`
|
|
else
|
|
ffi_LIBS=-lffi
|
|
fi
|
|
LIBS="$ffi_LIBS $LIBS"
|
|
AC_RUN_IFELSE(
|
|
[AC_LANG_SOURCE([[#include "$srcdir/config/config.ffi.c"]])],
|
|
[ffi_ok="yes"],
|
|
[ffi_ok="no"],
|
|
[ffi_ok="$cross_ffi_ok"])
|
|
if test $ffi_ok = yes; then
|
|
AC_MSG_RESULT(libffi)
|
|
if test $do_broken_libffi = yes; then
|
|
AC_MSG_WARN([ffi may be broken on this system ... try enabling ffcall])
|
|
fi
|
|
AC_CHECK_FUNCS(ffi_prep_closure_loc)
|
|
else
|
|
AC_MSG_ERROR([The ffi library (libffi) does not appear to be working. Perhaps it's missing or you need a more recent version. Version 3.0.9 or later should work, and you can find a link to it n the list of packages for download at http://www.gnustep.org/resources/sources.html])
|
|
fi
|
|
elif test $enable_ffcall = yes; then
|
|
AC_DEFINE(USE_FFCALL,1,
|
|
[Define if using the ffcall library for invocations])
|
|
WITH_FFI=ffcall
|
|
LIBS="-lcallback -lavcall $LIBS"
|
|
AC_LINK_IFELSE(
|
|
[AC_LANG_PROGRAM([[#include <callback.h>]],)],
|
|
[ffi_ok="yes"],
|
|
[ffi_ok="no"])
|
|
if test $ffi_ok = yes; then
|
|
AC_MSG_RESULT(ffcall)
|
|
fi
|
|
AC_MSG_WARN([ffcall is broken on some systems and is deprecated ... try enabling ffi])
|
|
else
|
|
ffi_ok=no
|
|
fi
|
|
|
|
if test $enable_ffcall = yes -a $ffi_ok = yes; then
|
|
AC_MSG_CHECKING(if ffcall trampolines work)
|
|
AC_RUN_IFELSE(
|
|
[AC_LANG_SOURCE([[#include "$srcdir/config/config.trampoline.c"]])],
|
|
have_working_trampoline=yes, have_working_trampoline=no,
|
|
have_working_trampoline=yes)
|
|
AC_MSG_RESULT($have_working_trampoline)
|
|
fi
|
|
|
|
if test $ffi_ok = no; then
|
|
AC_MSG_RESULT(none)
|
|
echo
|
|
if test $have_forward_hook = no; then
|
|
echo "You do not have an up-to-date libobjc library installed"
|
|
elif test "$have_working_trampoline" = no; then
|
|
echo "You have ffcall, but it does not work properly. Most likely because"
|
|
echo "your system's security policy is blocking some parts of ffcall"
|
|
echo "we recommend installing libffi instead."
|
|
else
|
|
echo "You do not have either ffcall or libffi installed/enabled, or configure needs"
|
|
echo "--with-ffi-include and/or --with-ffi-library flags so GNUstep can find them,"
|
|
echo "or you have ffcall but gnustep-make is configured to use native exceptions"
|
|
echo "(native exceptions are not compatible with ffcall)."
|
|
fi
|
|
echo "GNUstep requires libffi (or ffcall) and proper libobjc hooks to do"
|
|
echo "invocations and DO."
|
|
echo "(This does not apply on apple-apple-apple systems where DO is"
|
|
echo "not compatible with other GNUstep systems.)"
|
|
if test $enable_invocations = yes; then
|
|
echo
|
|
echo "You most likely do not want to build base without invocation support."
|
|
echo "Many things (including Distributed Objects and undo/redo), won't work"
|
|
echo "at all without invocations."
|
|
echo "If you really want to build -base without invocation support,"
|
|
echo "add --disable-invocations to the configure arguments."
|
|
echo "For more information, read the GNUstep build guide, ffcall section:"
|
|
echo "http://gnustep.made-it.com/BuildGuide/index.html"
|
|
AC_MSG_ERROR([Incomplete support for ffi functionality.])
|
|
fi
|
|
AC_MSG_WARN([Incomplete support for ffi funtionality.])
|
|
fi
|
|
AC_SUBST(WITH_FFI)
|
|
|
|
|
|
#--------------------------------------------------------------------
|
|
# Check for iconv support (for Unicode conversion).
|
|
#--------------------------------------------------------------------
|
|
# Do this before checking for xml2, as xml2 may require iconv.
|
|
#
|
|
# We need to find an iconv library that matches the installed iconv.h header
|
|
# (if any). It is important to check header/library compatibility. It's
|
|
# fairly common to have iconv support both in libc and from libiconv. In that
|
|
# case, a naive check that iconv() is in libc will succeed, but if we use
|
|
# libiconv's iconv.h, it will redefine iconv() to functions that exist
|
|
# only in libiconv, and we'll get link errors.
|
|
#
|
|
# Some versions of iconv don't support the '//TRANSLIT' option, which is
|
|
# needed for a lossy conversion (where we pick the closest equivalent for
|
|
# any character present in the source string which does not exist in the
|
|
# destination characterset), so we check for support of that first.
|
|
|
|
# First, check if there's a working iconv in libc (ie. if the test program
|
|
# runs without any extra flags).
|
|
AC_ARG_ENABLE(iconv,
|
|
[ --disable-iconv Build even if iconv is not available],,
|
|
enable_iconv=yes)
|
|
|
|
if test $enable_iconv = yes; then
|
|
AC_MSG_CHECKING(iconv support)
|
|
AC_RUN_IFELSE([AC_LANG_SOURCE([#include <iconv.h>
|
|
int main(int argc,char **argv)
|
|
{ return iconv_open("UTF-8//TRANSLIT","ASCII") == -1 ? 1 : 0; }])]
|
|
,
|
|
# libc has a working iconv.
|
|
AC_DEFINE(HAVE_ICONV,1, [Define if you have this function])
|
|
AC_MSG_RESULT([[yes, in libc]])
|
|
found_iconv=yes
|
|
,
|
|
found_iconv=no
|
|
,
|
|
found_iconv="$cross_found_iconv_libc";
|
|
if test "$found_iconv" = "yes"; then
|
|
AC_DEFINE(HAVE_ICONV,1, [Define if you have this function])
|
|
AC_MSG_RESULT([[yes, in libc (via cross.config)]])
|
|
fi
|
|
)
|
|
|
|
if test $found_iconv = no ; then
|
|
# libc doesn't have a working iconv with translit.
|
|
# Try adding -liconv and any user supplied directory.
|
|
AC_ARG_WITH(libiconv-library,
|
|
[ --with-libiconv-library=PATH Library path for libiconv libraries],
|
|
libiconv_libdir="$withval", libiconv_libdir="no")
|
|
|
|
if test "$libiconv_libdir" != "no"; then
|
|
GS_ADD_LIBRARY_PATH([${libiconv_libdir}])
|
|
fi
|
|
|
|
AC_ARG_WITH(libiconv-include,
|
|
[ --with-libiconv-include=PATH Include path for libiconv header],
|
|
libiconv_incdir="$withval", libiconv_incdir="no")
|
|
if test ${libiconv_incdir} != "no"; then
|
|
CPPFLAGS="$CPPFLAGS -I${libiconv_incdir}"
|
|
INCLUDE_FLAGS="$INCLUDE_FLAGS -I${libiconv_incdir}"
|
|
fi
|
|
|
|
old_LIBS="$LIBS"
|
|
LIBS="-liconv $LIBS"
|
|
AC_RUN_IFELSE([AC_LANG_SOURCE([#include <iconv.h>
|
|
int main(int argc,char **argv)
|
|
{ return iconv_open("UTF-8//TRANSLIT","ASCII") == -1 ? 1 : 0; }])]
|
|
,
|
|
# -liconv works.
|
|
AC_DEFINE(HAVE_ICONV,1, [Define if you have this function])
|
|
AC_MSG_RESULT([[yes, -liconv]])
|
|
found_iconv=yes
|
|
,
|
|
found_iconv=no
|
|
LIBS="$old_LIBS"
|
|
,
|
|
found_iconv="$cross_found_iconv_liconv";
|
|
if test "$found_iconv" = "yes"; then
|
|
AC_DEFINE(HAVE_ICONV,1, [Define if you have this function])
|
|
AC_MSG_RESULT([[yes, -liconv (via cross.config)]])
|
|
else
|
|
LIBS="$old_LIBS"
|
|
fi
|
|
)
|
|
fi
|
|
|
|
if test $found_iconv = no ; then
|
|
# -liconv with translit didn't work. Try giconv.h and -lgiconv.
|
|
# BSDs install this lib as libgiconv.
|
|
old_LIBS="$LIBS"
|
|
LIBS="-lgiconv $LIBS"
|
|
AC_RUN_IFELSE([AC_LANG_SOURCE([#include <giconv.h>
|
|
int main(int argc,char **argv)
|
|
{ return iconv_open("UTF-8//TRANSLIT","ASCII") == -1 ? 1 : 0; }])]
|
|
,
|
|
AC_DEFINE(HAVE_ICONV,1, [Define if you have this function])
|
|
AC_DEFINE(HAVE_GICONV,1, [Define if you have this function])
|
|
AC_MSG_RESULT([[yes, -lgiconv]])
|
|
found_iconv=yes
|
|
,
|
|
found_iconv=no
|
|
LIBS="$old_LIBS"
|
|
,
|
|
found_iconv="$cross_found_iconv_lgiconv";
|
|
if test "$found_iconv" = "yes"; then
|
|
AC_DEFINE(HAVE_ICONV,1, [Define if you have this function])
|
|
AC_DEFINE(HAVE_GICONV,1, [Define if you have this function])
|
|
AC_MSG_RESULT([[yes, -lgiconv (via cross.config)]])
|
|
else
|
|
LIBS="$old_LIBS"
|
|
fi
|
|
)
|
|
fi
|
|
|
|
AC_ARG_ENABLE(stricticonv,
|
|
[ --enable-stricticonv Build even if iconv is strict],,
|
|
enable_stricticonv=no)
|
|
if test $enable_stricticonv = yes; then
|
|
AC_MSG_CHECKING(non-lossy iconv support)
|
|
AC_RUN_IFELSE([AC_LANG_SOURCE([#include <iconv.h>
|
|
int main(int argc,char **argv)
|
|
{ return iconv_open("UTF-8","ASCII") == -1 ? 1 : 0; }])]
|
|
,
|
|
# libc has a working iconv.
|
|
AC_DEFINE(HAVE_ICONV,1, [Define if you have this function])
|
|
AC_MSG_RESULT([[yes, in libc]])
|
|
found_iconv=yes
|
|
,
|
|
found_iconv=no
|
|
)
|
|
|
|
if test $found_iconv = no ; then
|
|
# libc doesn't have a working iconv. Try adding -liconv and any user
|
|
# supplied directory.
|
|
AC_ARG_WITH(libiconv-library,
|
|
[ --with-libiconv-library=PATH Library path for libiconv libraries],
|
|
libiconv_libdir="$withval", libiconv_libdir="no")
|
|
|
|
if test "$libiconv_libdir" != "no"; then
|
|
GS_ADD_LIBRARY_PATH([${libiconv_libdir}])
|
|
fi
|
|
|
|
old_LIBS="$LIBS"
|
|
LIBS="-liconv $LIBS"
|
|
AC_RUN_IFELSE([AC_LANG_SOURCE([#include <iconv.h>
|
|
int main(int argc,char **argv)
|
|
{ return iconv_open("UTF-8","ASCII") == -1 ? 1 : 0; }])]
|
|
,
|
|
# -liconv works.
|
|
AC_DEFINE(HAVE_ICONV,1, [Define if you have this function])
|
|
AC_MSG_RESULT([[yes, -liconv]])
|
|
found_iconv=yes
|
|
,
|
|
found_iconv=no
|
|
LIBS="$old_LIBS"
|
|
)
|
|
fi
|
|
|
|
if test $found_iconv = no ; then
|
|
# -liconv didn't work. Try giconv.h and -lgiconv.
|
|
# BSDs install this lib as libgiconv.
|
|
old_LIBS="$LIBS"
|
|
LIBS="-lgiconv $LIBS"
|
|
AC_RUN_IFELSE([AC_LANG_SOURCE([#include <giconv.h>
|
|
int main(int argc,char **argv)
|
|
{ return iconv_open("UTF-8","ASCII") == -1 ? 1 : 0; }])]
|
|
,
|
|
AC_DEFINE(HAVE_ICONV,1, [Define if you have this function])
|
|
AC_DEFINE(HAVE_GICONV,1, [Define if you have this function])
|
|
AC_MSG_RESULT([[yes, -lgiconv]])
|
|
found_iconv=yes
|
|
,
|
|
found_iconv=no
|
|
LIBS="$old_LIBS"
|
|
)
|
|
fi
|
|
fi
|
|
|
|
if test $found_iconv = no ; then
|
|
AC_MSG_RESULT([[no]])
|
|
echo
|
|
echo "You do not appear to have usable iconv header/library."
|
|
echo "Building without them will disable much characterset support."
|
|
echo "If you really want to build gnustep-base without character conversion"
|
|
echo " support, please add --disable-iconv to the configure arguments."
|
|
AC_MSG_ERROR([Missing support for character conversion functionality.])
|
|
fi
|
|
fi
|
|
|
|
#--------------------------------------------------------------------
|
|
# Check recent libxml2 for GSXML and NSXMLNode
|
|
# See DEPENDENCIES POLICY at the start of this file.
|
|
#--------------------------------------------------------------------
|
|
AC_ARG_ENABLE(xml,
|
|
[ --disable-xml Build even if XML-dependencies are not met],,
|
|
enable_xml=yes)
|
|
|
|
HAVE_LIBXML=0
|
|
|
|
if test $enable_xml = yes; then
|
|
PKG_CHECK_MODULES([XML], [libxml-2.0 >= 2.3.0], [enable_libxml=yes], [
|
|
AM_PATH_XML(2.3.0, enable_libxml=yes, enable_libxml=no)
|
|
])
|
|
|
|
if test $enable_libxml = yes; then
|
|
CPPFLAGS="$CPPFLAGS $XML_CFLAGS"
|
|
INCLUDE_FLAGS="$INCLUDE_FLAGS $XML_CFLAGS"
|
|
LIBS="$XML_LIBS $LIBS"
|
|
HAVE_LIBXML=1
|
|
AC_DEFINE(HAVE_LIBXML,1,[Define if libxml available])
|
|
AC_CHECK_HEADERS(libxml/SAX2.h)
|
|
|
|
#--------------------------------------------------------------------
|
|
# Check for (optional) libxslt
|
|
#--------------------------------------------------------------------
|
|
AC_ARG_ENABLE(xslt,
|
|
[ --disable-xslt Build even if XSLT-dependency is not met],,
|
|
enable_xslt=yes)
|
|
|
|
if test $enable_xslt = yes; then
|
|
PKG_CHECK_MODULES([XSLT], [libxslt >= 1.0], [xslt_ok=yes], [xslt_ok=no])
|
|
if test "$xslt_ok" = "yes"; then
|
|
AC_CHECK_HEADERS(libxslt/xslt.h, xslt_ok=yes, xslt_ok=no)
|
|
fi
|
|
if test "$xslt_ok" = "yes"; then
|
|
CPPFLAGS="$CPPFLAGS $XSLT_CFLAGS"
|
|
INCLUDE_FLAGS="$INCLUDE_FLAGS $XSLT_CFLAGS"
|
|
LIBS="$XSLT_LIBS $LIBS"
|
|
HAVE_LIBXSLT=1
|
|
AC_DEFINE(HAVE_LIBXSLT,1,[Define if libxslt available])
|
|
else
|
|
echo
|
|
echo "You do not appear to have usable libxslt headers/library."
|
|
echo "Building without them will disable the XSLT extensions."
|
|
echo "If you really want to build gnustep-base without XSLT support,"
|
|
echo "add --disable-xslt to the configure arguments to avoid warning."
|
|
AC_MSG_WARN([Missing support for XSLT functionality.])
|
|
fi
|
|
else
|
|
HAVE_LIBXSLT=0
|
|
AC_MSG_WARN([Disabled support for XSLT funtionality.])
|
|
fi
|
|
AC_SUBST(HAVE_LIBXSLT)
|
|
else
|
|
echo
|
|
echo "You do not appear to have usable libxml2 headers/library."
|
|
echo "Building without them will disable the GSXML and NSXMLNode."
|
|
echo "If you really want to build gnustep-base without XML DOM support"
|
|
echo " (though NSXMLParser is unaffected), please"
|
|
echo "add --disable-xml to the configure arguments."
|
|
AC_MSG_ERROR([Missing support for XML DOM functionality.])
|
|
fi
|
|
else
|
|
AC_MSG_WARN([XML functionality disabled.])
|
|
fi
|
|
AC_SUBST(HAVE_LIBXML)
|
|
|
|
#--------------------------------------------------------------------
|
|
# Check recent libgnutls for SSL streams.
|
|
# See DEPENDENCIES POLICY at the start of this file.
|
|
#--------------------------------------------------------------------
|
|
AC_ARG_ENABLE(tls,
|
|
[ --disable-tls Disable use of GNUTLS],,
|
|
enable_tls=yes)
|
|
|
|
if test $enable_tls = yes; then
|
|
HAVE_GNUTLS=0
|
|
# Save CFLAGS and LIBS as AM_PATH_TLS clobbers these variables regardless
|
|
# of the success of the macro.
|
|
saved_LIBS="$LIBS"
|
|
saved_CFLAGS="$CFLAGS"
|
|
|
|
if test -n "$PKG_CONFIG"; then
|
|
if pkg-config --exists gnutls; then
|
|
AC_MSG_CHECKING(gnutls support)
|
|
HAVE_GNUTLS=1
|
|
TLS_CFLAGS=`$PKG_CONFIG --cflags gnutls`
|
|
TLS_LIBS=`$PKG_CONFIG --libs gnutls`
|
|
fi
|
|
fi
|
|
|
|
if test $HAVE_GNUTLS = 0; then
|
|
# AM_PATH_TLS(2.0.1, enable_libgnutls=yes, enable_libgnutls=no)
|
|
AM_PATH_TLS(1.4.0, enable_libgnutls=yes, enable_libgnutls=no)
|
|
if test $enable_libgnutls = yes; then
|
|
HAVE_GNUTLS=1
|
|
else
|
|
HAVE_GNUTLS=0
|
|
fi
|
|
fi
|
|
if test $HAVE_GNUTLS = 1; then
|
|
if ! pkg-config --atleast-version=2.12 gnutls; then
|
|
AC_CHECK_LIB(gcrypt, gcry_control, have_gcrypt=yes, have_gcrypt=no)
|
|
if test "$have_gcrypt" = "no"; then
|
|
HAVE_GNUTLS=0
|
|
else
|
|
TLS_LIBS="$TLS_LIBS -lgcrypt"
|
|
fi
|
|
fi
|
|
fi
|
|
if test $HAVE_GNUTLS = 0; then
|
|
# Restore the CFLAGS and LIBS because AM_PATH_TLS messes them
|
|
LIBS="$saved_LIBS"
|
|
CFLAGS="$saved_CFLAGS"
|
|
AC_MSG_RESULT(no)
|
|
echo
|
|
echo "You do not appear to have usable libgnutls headers/library."
|
|
echo "Building without them will disable SSL/TLS/HTTPS in NSStream,"
|
|
echo "NSFileHandle, NSURLHandle and NSURLConnection."
|
|
echo "If you really want to build gnustep-base without TLS support,"
|
|
echo "add --disable-tls to the configure arguments."
|
|
AC_MSG_ERROR([Missing support for TLS functionality.])
|
|
else
|
|
AC_MSG_RESULT(yes)
|
|
CPPFLAGS="$CPPFLAGS $TLS_CFLAGS"
|
|
INCLUDE_FLAGS="$INCLUDE_FLAGS $TLS_CFLAGS"
|
|
LIBS="$TLS_LIBS $LIBS"
|
|
AC_CHECK_FUNCS(gnutls_transport_set_errno)
|
|
if test "$ac_cv_func_gnutls_transport_set_errno" = "no"; then
|
|
AC_MSG_WARN([Missing support for thread-safe error handling in GNUTLS. Please check that you have the most recent version installed (2.0 or later chould be fine).])
|
|
fi
|
|
AC_CHECK_FUNCS(gnutls_x509_privkey_import2)
|
|
fi
|
|
else
|
|
AC_MSG_WARN([Disabled support for TLS funtionality.])
|
|
HAVE_GNUTLS=0
|
|
fi
|
|
if test $HAVE_GNUTLS = 1; then
|
|
AC_DEFINE_UNQUOTED(HAVE_GNUTLS,$HAVE_GNUTLS,[Define if libgnutls available])
|
|
fi
|
|
AC_SUBST(HAVE_GNUTLS)
|
|
|
|
#--------------------------------------------------------------------
|
|
# Check for NSNetServices
|
|
# See DEPENDENCIES POLICY at the start of this file.
|
|
#--------------------------------------------------------------------
|
|
HAVE_MDNS=0
|
|
HAVE_AVAHI=0
|
|
AC_ARG_ENABLE(zeroconf,
|
|
[ --disable-zeroconf Disable NSNetServices support],,
|
|
enable_zeroconf=yes)
|
|
AC_ARG_WITH(zeroconf-api,
|
|
[ --with-zeroconf-api=API force use of a specific zeroconf API (mdns or avahi)],
|
|
zeroconf_api="$withval", zeroconf_api="any")
|
|
if test $enable_zeroconf = yes; then
|
|
if test "$zeroconf_api" = "any" || test "$zeroconf_api" = "mdns"; then
|
|
AC_CHECK_HEADERS(dns_sd.h, have_mdns=yes, have_mdns=no)
|
|
if test "$have_mdns" = "yes"; then
|
|
AC_CHECK_LIB(dns_sd, DNSServiceBrowse, have_mdns=yes, have_mdns=no)
|
|
if test "$have_mdns" = "yes"; then
|
|
MDNS_LIBS="-ldns_sd"
|
|
HAVE_MDNS=1
|
|
fi
|
|
fi
|
|
fi
|
|
if test "$zeroconf_api" = "any" || test "$zeroconf_api" = "avahi"; then
|
|
AC_CHECK_HEADERS(avahi-client/client.h, have_avahi=yes, have_avahi=no)
|
|
if test "$have_avahi" = "yes"; then
|
|
AC_CHECK_LIB(avahi-client, avahi_client_new, have_avahi=yes, have_avahi=no)
|
|
if test "$have_avahi" = "yes"; then
|
|
AVAHI_LIBS="-lavahi-common -lavahi-client"
|
|
HAVE_AVAHI=1
|
|
fi
|
|
fi
|
|
fi
|
|
# If we have both APIs, prefer Avahi, because the mDNS API
|
|
# is most certainly the compatability one
|
|
if test "$have_avahi" = "yes" && test "$have_mdns" = "yes"; then
|
|
LIBS="$AVAHI_LIBS $LIBS"
|
|
HAVE_MDNS=0
|
|
else
|
|
# One of those will be empty.
|
|
LIBS="$AVAHI_LIBS $MDNS_LIBS $LIBS"
|
|
fi
|
|
fi
|
|
AC_SUBST(HAVE_MDNS)
|
|
AC_SUBST(HAVE_AVAHI)
|
|
|
|
#--------------------------------------------------------------------
|
|
# Check for International Components for Unicode
|
|
# See DEPENDENCIES POLICY at the start of this file.
|
|
#--------------------------------------------------------------------
|
|
HAVE_ICU=0
|
|
AC_ARG_ENABLE(icu,
|
|
[ --disable-icu Disable International Components for Unicode],,
|
|
enable_icu=yes)
|
|
|
|
AS_IF([test "x$enable_icu" = "xyes"], [
|
|
case "$target_os" in
|
|
mingw*|windows)
|
|
# check for ICU bundled with Windows 10
|
|
old_LIBS="$LIBS"
|
|
LIBS="-licu $LIBS"
|
|
AC_CHECK_HEADERS([icu.h],
|
|
AC_RUN_IFELSE([AC_LANG_SOURCE([
|
|
#include <icu.h>
|
|
int main () {
|
|
return udat_countAvailable() > 0 ? 0 : 1;
|
|
}])], HAVE_ICU=1))
|
|
LIBS="$old_LIBS"
|
|
if test $HAVE_ICU = 1; then
|
|
ICU_LIBS=-licu
|
|
AC_MSG_NOTICE([Using system-provided ICU DLL (requires Windows 10 version 1903 or later)])
|
|
fi
|
|
;;
|
|
esac
|
|
if test $HAVE_ICU = 0; then
|
|
PKG_CHECK_MODULES([ICU], [icu-i18n > 49.0], [
|
|
AC_CHECK_HEADERS([unicode/uloc.h unicode/ulocdata.h unicode/ucol.h unicode/ucurr.h unicode/uregex.h unicode/ucal.h unicode/unorm2.h unicode/unum.h unicode/udat.h unicode/udatpg.h unicode/ustring.h unicode/usearch.h unicode/ucnv.h unicode/utext.h unicode/ubrk.h unicode/utypes.h],
|
|
HAVE_ICU=1)], [HAVE_ICU=0])
|
|
fi
|
|
if test $HAVE_ICU = 0; then
|
|
AC_MSG_ERROR([No useable ICU installation found])
|
|
fi
|
|
LIBS="$LIBS $ICU_LIBS"
|
|
])
|
|
AC_SUBST(HAVE_ICU)
|
|
|
|
#--------------------------------------------------------------------
|
|
# Check for libdispatch
|
|
# See DEPENDENCIES POLICY at the start of this file.
|
|
#--------------------------------------------------------------------
|
|
|
|
HAVE_LIBDISPATCH=0
|
|
AC_ARG_ENABLE(libdispatch,
|
|
[ --disable-libdispatch Disable dispatching blocks via libdispatch],
|
|
enable_libdispatch=$enableval,
|
|
enable_libdispatch=yes)
|
|
|
|
if test $enable_libdispatch = yes; then
|
|
AC_ARG_WITH(dispatch-include,
|
|
[ --with-dispatch-include=PATH Include path for dispatch header],
|
|
dispatch_incdir="$withval", dispatch_incdir="no")
|
|
if test ${dispatch_incdir} != "no"; then
|
|
CPPFLAGS="$CPPFLAGS -I${dispatch_incdir}"
|
|
INCLUDE_FLAGS="$INCLUDE_FLAGS -I${dispatch_incdir}"
|
|
fi
|
|
|
|
AC_ARG_WITH(dispatch-library,
|
|
[ --with-dispatch-library=PATH Library path for dispatch lib],
|
|
dispatch_libdir="$withval", dispatch_libdir="no")
|
|
if test ${dispatch_libdir} != "no"; then
|
|
GS_ADD_LIBRARY_PATH([${dispatch_libdir}])
|
|
fi
|
|
|
|
AC_CHECK_HEADERS(dispatch/dispatch.h, have_dispatch=yes, have_dispatch=no)
|
|
if test "$have_dispatch" = "yes"; then
|
|
# check for private header which includes runloop integration functions in
|
|
# the Swift corelibs libdispatch release
|
|
AC_CHECK_HEADERS(dispatch/private.h)
|
|
else
|
|
AC_CHECK_HEADERS(dispatch.h, have_dispatch=yes, have_dispatch=no)
|
|
fi
|
|
if test "$have_dispatch" = "yes"; then
|
|
AC_CHECK_LIB(dispatch, dispatch_queue_create, have_dispatch=yes, have_dispatch=no)
|
|
if test "$have_dispatch" = "yes"; then
|
|
saveLIBS="$LIBS"
|
|
LIBS="-lobjc -ldispatch";
|
|
# This check is needed because libdispatch might be linked against a
|
|
# version of libBlocksRuntime that defines symbols conflicting with libobjc
|
|
AC_MSG_CHECKING(whether we can link libdispatch and libobjc at the same time)
|
|
AC_LINK_IFELSE(
|
|
[AC_LANG_PROGRAM(,)],
|
|
[have_dispatch=yes],
|
|
[have_dispatch=no])
|
|
if test "$have_dispatch" = "yes"; then
|
|
LIBS="$saveLIBS -ldispatch";
|
|
AC_MSG_RESULT(yes);
|
|
HAVE_LIBDISPATCH=1;
|
|
else
|
|
LIBS="$saveLIBS";
|
|
AC_MSG_RESULT(no);
|
|
fi
|
|
fi
|
|
else
|
|
HAVE_LIBDISPATCH=0;
|
|
# just ignore libdispatch if it's not there
|
|
fi
|
|
fi
|
|
AC_SUBST(HAVE_LIBDISPATCH)
|
|
|
|
HAVE_LIBDISPATCH_RUNLOOP=0
|
|
if test $HAVE_LIBDISPATCH = 1; then
|
|
# We check whether we have a variant of libdispatch that allows runloop
|
|
# integration
|
|
AC_CHECK_FUNCS(dispatch_main_queue_drain_np dispatch_get_main_queue_handle_np)
|
|
if test "$ac_cv_func_dispatch_main_queue_drain_np" = "yes" && test "$ac_cv_func_dispatch_get_main_queue_handle_np" = "yes"; then
|
|
HAVE_LIBDISPATCH_RUNLOOP=1
|
|
fi
|
|
# Check for "_4CF" variants of runloop integration functions provided by the
|
|
# Swift corelibs libdispatch release
|
|
AC_CHECK_FUNCS(_dispatch_main_queue_callback_4CF _dispatch_get_main_queue_handle_4CF)
|
|
if test "$ac_cv_func__dispatch_main_queue_callback_4CF" = "yes" && test "$ac_cv_func__dispatch_get_main_queue_handle_4CF" = "yes"; then
|
|
HAVE_LIBDISPATCH_RUNLOOP=1
|
|
fi
|
|
# Check for availability of functions in more recent libdispatch versions.
|
|
AC_CHECK_FUNCS(dispatch_cancel)
|
|
fi
|
|
AC_SUBST(HAVE_LIBDISPATCH_RUNLOOP)
|
|
|
|
|
|
#--------------------------------------------------------------------
|
|
# Check for whether the new KVO implementation is enabled (only with
|
|
# the NG runtime)
|
|
#--------------------------------------------------------------------
|
|
HAVE_NEWKVO=0
|
|
AC_ARG_ENABLE(newkvo,
|
|
[ --disable-newkvo Disable new KVO implementation],,[
|
|
if test "$OBJC_RUNTIME_LIB" = "ng"; then
|
|
enable_newkvo=yes
|
|
else
|
|
enable_newkvo=no
|
|
fi])
|
|
if test "x$enable_newkvo" = "xyes"
|
|
then
|
|
if test "$OBJC_RUNTIME_LIB" = "ng"; then
|
|
HAVE_NEWKVO=1
|
|
else
|
|
echo "You are not using the new runtime ... newkvo not available"
|
|
fi
|
|
fi
|
|
AC_SUBST(HAVE_NEWKVO)
|
|
|
|
#--------------------------------------------------------------------
|
|
# Check for libcurl
|
|
# See DEPENDENCIES POLICY at the start of this file.
|
|
#--------------------------------------------------------------------
|
|
CURL_CONFIG="curl-config"
|
|
AC_ARG_WITH(curl, AS_HELP_STRING([--with-curl=<DIR>],
|
|
[use curl installed in directory <DIR>]))
|
|
if test "$with_curl" != ""; then
|
|
CURL_CONFIG="$with_curl/bin/curl-config"
|
|
fi
|
|
|
|
HAVE_LIBCURL=0
|
|
SKIP_CURL_CONFIG=0
|
|
curl_all=no
|
|
AC_MSG_CHECKING([for libcurl])
|
|
|
|
case "$target_os" in
|
|
windows) SKIP_CURL_CONFIG=1;;
|
|
esac
|
|
|
|
# When compiling libs-base in an MSYS2 environment on Windows MSVC, compilation may fail:
|
|
# Curl is preinstalled on MSYS2 and bundles the curl-config script. The MSYS2 curl library
|
|
# and a different (MSVC) curl library might interfere and produce an incorrect configuration.
|
|
#
|
|
# Skip the curl-config check on Windows.
|
|
if eval $CURL_CONFIG --version 2>/dev/null >/dev/null && test "$SKIP_CURL_CONFIG" == "0"; then
|
|
curl_ver=`$CURL_CONFIG --version | sed -e "s/libcurl //g"`
|
|
curl_maj=`echo $curl_ver | sed -e "s/^\(.*\)\.\(.*\)\.\(.*\)$/\1/"`
|
|
curl_min=`echo $curl_ver | sed -e "s/^\(.*\)\.\(.*\)\.\(.*\)$/\2/"`
|
|
if test $curl_maj -lt 7 -o \( $curl_maj -eq 7 -a $curl_min -lt 66 \); then
|
|
AC_MSG_RESULT([FAILED (version too old to use])
|
|
else
|
|
AC_MSG_RESULT(yes ... version $curl_ver)
|
|
AC_CHECK_HEADERS(curl/curl.h, curl_ok=yes, curl_ok=no)
|
|
if test "$curl_ok" = yes; then
|
|
HAVE_LIBCURL=1
|
|
CURLCFLAGS=`$CURL_CONFIG --cflags`
|
|
CURLLIBS=`$CURL_CONFIG --libs`
|
|
CFLAGS="$CFLAGS $CURLCFLAGS"
|
|
LIBS="$LIBS $CURLLIBS"
|
|
curl_all=yes
|
|
fi
|
|
fi
|
|
else
|
|
if test -n "$PKG_CONFIG"; then
|
|
if pkg-config --exists libcurl; then
|
|
AC_MSG_RESULT(yes ... via pkg-config)
|
|
if $PKG_CONFIG --atleast-version 2.66.0 libcurl; then
|
|
AC_CHECK_HEADERS(curl/curl.h, curl_ok=yes, curl_ok=no)
|
|
if test "$curl_ok" = yes; then
|
|
HAVE_LIBCURL=1
|
|
CURLCFLAGS=`$PKG_CONFIG --cflags libcurl`
|
|
CURLLIBS=`$PKG_CONFIG --libs libcurl`
|
|
CFLAGS="$CFLAGS $CURLCFLAGS"
|
|
LIBS="$LIBS $CURLLIBS"
|
|
curl_all=yes
|
|
fi
|
|
else
|
|
AC_MSG_RESULT([FAILED (version too old to use])
|
|
curl_all=no
|
|
fi
|
|
else
|
|
AC_MSG_RESULT([FAILED (libcurl not found via pkg-config)])
|
|
curl_all=no
|
|
fi
|
|
else
|
|
AC_MSG_RESULT([FAILED (curl-config and pkg-config not found)])
|
|
fi
|
|
fi
|
|
|
|
if test "$OBJC_RUNTIME_LIB" = "ng" -a "$HAVE_LIBCURL" = 0; then
|
|
AC_MSG_ERROR([libcurl is a hard-dependency when building with the Objective-C 2.0 toolchain])
|
|
fi
|
|
|
|
AC_SUBST(HAVE_LIBCURL)
|
|
|
|
#--------------------------------------------------------------------
|
|
# Check dependencies of NSURLSession API
|
|
#--------------------------------------------------------------------
|
|
nsurlsessiondefault=no
|
|
if test "$OBJC_RUNTIME_LIB" = "ng" -a $HAVE_BLOCKS = 1 -a $HAVE_LIBDISPATCH = 1 -a $HAVE_LIBCURL = 1; then
|
|
nsurlsessiondefault=yes
|
|
fi
|
|
|
|
GS_HAVE_NSURLSESSION=0
|
|
AC_ARG_ENABLE(nsurlsession,
|
|
[ --disable-nsurlsession Disable support for NSURLSession],,
|
|
enable_nsurlsession=$nsurlsessiondefault)
|
|
if test $enable_nsurlsession = yes; then
|
|
if test "$OBJC_RUNTIME_LIB" != "ng"; then
|
|
AC_MSG_ERROR([Missing ng runtime (needed for NSURLSession). To build without NSURLSession support, please run configure again with the --disable-nsurlsession option.])
|
|
fi
|
|
if test $HAVE_BLOCKS = 0; then
|
|
AC_MSG_ERROR([Missing blocks support (needed for NSURLSession). To build without NSURLSession support, please run configure again with the --disable-nsurlsession option.])
|
|
fi
|
|
if test $HAVE_LIBDISPATCH = 0; then
|
|
AC_MSG_ERROR([Missing libdispatch (needed for NSURLSession). To build without NSURLSession support, please run configure again with the --disable-nsurlsession option.])
|
|
fi
|
|
# Check for dispatch_queue_create_with_target needed for NSURLSession
|
|
AC_CHECK_FUNCS(dispatch_queue_create_with_target)
|
|
if test $HAVE_LIBCURL = 0; then
|
|
AC_MSG_ERROR([Missing libcurl (needed for NSURLSession). To build without NSURLSession support, please run configure again with the --disable-nsurlsession option.])
|
|
fi
|
|
GS_HAVE_NSURLSESSION=1
|
|
fi
|
|
AC_SUBST(GS_HAVE_NSURLSESSION)
|
|
|
|
#--------------------------------------------------------------------
|
|
# Check GMP for NSDecimal
|
|
#--------------------------------------------------------------------
|
|
AC_ARG_WITH(gmp-include,
|
|
[ --with-gmp-include=PATH include path for gmp headers],
|
|
gmp_incdir="$withval", gmp_incdir="no")
|
|
|
|
AC_ARG_WITH(gmp-library,
|
|
[ --with-gmp-library=PATH library path for gmp libraries],
|
|
gmp_libdir="$withval", gmp_libdir="no")
|
|
|
|
libs_temp=$LIBS
|
|
|
|
if test "$gmp_incdir" != "no"; then
|
|
CPPFLAGS="$CPPFLAGS -I$gmp_incdir"
|
|
INCLUDE_FLAGS="$INCLUDE_FLAGS -I$gmp_incdir"
|
|
fi
|
|
if test "$gmp_libdir" != "no"; then
|
|
GS_ADD_LIBRARY_PATH([${gmp_libdir}])
|
|
fi
|
|
|
|
USE_GMP=0
|
|
AC_CHECK_HEADERS(gmp.h)
|
|
if test $ac_cv_header_gmp_h = yes; then
|
|
AC_CHECK_LIB(gmp, mpf_abs, gmp_ok=yes, gmp_ok=no)
|
|
if test "$gmp_ok" = no; then
|
|
AC_CHECK_LIB(gmp, __gmpf_abs, gmp_ok=yes, gmp_ok=no)
|
|
fi
|
|
if test "$gmp_ok" = yes; then
|
|
LIBS="-lgmp $LIBS"
|
|
USE_GMP=1
|
|
fi
|
|
fi
|
|
|
|
AC_SUBST(USE_GMP)
|
|
|
|
#--------------------------------------------------------------------
|
|
# Check dor 'dot', needed for graphs in autogsdoc output.
|
|
#--------------------------------------------------------------------
|
|
AC_ARG_VAR([DOT], [The name or full path of the graphviz dot command.])
|
|
|
|
AC_PATH_PROG([DOT], [dot], [])
|
|
AC_SUBST(HAVE_DOT, [$ac_cv_path_DOT])
|
|
|
|
#--------------------------------------------------------------------
|
|
# Check whether nl_langinfo(CODESET) is supported, needed by Unicode.m.
|
|
#--------------------------------------------------------------------
|
|
AM_LANGINFO_CODESET
|
|
|
|
|
|
AC_SUBST(INCLUDE_FLAGS)
|
|
AC_SUBST(LDIR_FLAGS)
|
|
|
|
#--------------------------------------------------------------------
|
|
# Check for -Wdeclaration-after-statement
|
|
#--------------------------------------------------------------------
|
|
AC_MSG_CHECKING(whether the compiler supports -Wdeclaration-after-statement)
|
|
|
|
saved_CFLAGS="$CFLAGS"
|
|
CFLAGS="$CFLAGS -Wdeclaration-after-statement"
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],HAS_W_DECL_AFTER_STATEMENT=yes,HAS_W_DECL_AFTER_STATEMENT=no)
|
|
CFLAGS="$saved_CFLAGS"
|
|
|
|
AC_MSG_RESULT($HAS_W_DECL_AFTER_STATEMENT)
|
|
|
|
if test x"$HAS_W_DECL_AFTER_STATEMENT" = x"yes"; then
|
|
WARN_FLAGS="-Wall -Wdeclaration-after-statement"
|
|
else
|
|
WARN_FLAGS=-Wall
|
|
fi
|
|
|
|
AC_SUBST(WARN_FLAGS)
|
|
|
|
#--------------------------------------------------------------------
|
|
# Check if we should use an alternative gdomap port
|
|
#--------------------------------------------------------------------
|
|
AC_ARG_WITH(gdomap-port,
|
|
[ --with-gdomap-port=PORT alternative port for gdomap],
|
|
gdomap_port="$withval", gdomap_port="no")
|
|
|
|
if test "$gdomap_port" = "no"; then
|
|
GNUSTEP_GDOMAP_PORT_OVERRIDE="$gdomap_port"
|
|
else
|
|
GNUSTEP_GDOMAP_PORT_OVERRIDE="$gdomap_port"
|
|
fi
|
|
AC_SUBST(GNUSTEP_GDOMAP_PORT_OVERRIDE)
|
|
|
|
#--------------------------------------------------------------------
|
|
# Check if we should install gdomap as setuid
|
|
#--------------------------------------------------------------------
|
|
AC_MSG_CHECKING([if we should install gdomap as setuid])
|
|
AC_ARG_ENABLE(setuid-gdomap,[
|
|
--enable-setuid-gdomap Enable installing gdomap as a setuid
|
|
executable. By default, it is installed
|
|
as a normal program intended to be started
|
|
by root at system boot time, but it can
|
|
also be started up automatically
|
|
by any user at any time. Use this
|
|
option if you are happy having the program
|
|
started automatically on demand.
|
|
],
|
|
ac_cv_setuid_gdomap=$enableval,
|
|
ac_cv_setuid_gdomap="no")
|
|
|
|
if test "$ac_cv_setuid_gdomap" = "yes"; then
|
|
AC_MSG_RESULT(yes);
|
|
GNUSTEP_INSTALL_GDOMAP_AS_SETUID="yes"
|
|
else
|
|
AC_MSG_RESULT(no);
|
|
GNUSTEP_INSTALL_GDOMAP_AS_SETUID="no"
|
|
fi
|
|
|
|
AC_SUBST(GNUSTEP_INSTALL_GDOMAP_AS_SETUID)
|
|
|
|
#--------------------------------------------------------------------
|
|
# Record the version
|
|
#--------------------------------------------------------------------
|
|
AC_MSG_CHECKING(for the version of gnustep-base we are compiling)
|
|
if test -f "Version"; then
|
|
. ./Version
|
|
fi
|
|
AC_MSG_RESULT($VERSION)
|
|
AC_SUBST(VERSION)
|
|
AC_SUBST(MAJOR_VERSION)
|
|
AC_SUBST(MINOR_VERSION)
|
|
AC_SUBST(SUBMINOR_VERSION)
|
|
AC_SUBST(GCC_VERSION)
|
|
|
|
#--------------------------------------------------------------------
|
|
# Write the Makefiles
|
|
#--------------------------------------------------------------------
|
|
AC_CONFIG_FILES([config.mak base.make Source/gnustep-base.pc Headers/GNUstepBase/GSConfig.h])
|
|
AC_OUTPUT
|