From: Joakim Verona Date: Fri, 27 Jul 2012 00:22:03 +0000 (+0200) Subject: upstream X-Git-Tag: emacs-25.0.90~3290 X-Git-Url: http://git.eshelyaron.com/gitweb/?a=commitdiff_plain;h=5fb63197843dcae66f2fe0ddd6f4a9d560e9db2f;p=emacs.git upstream --- 5fb63197843dcae66f2fe0ddd6f4a9d560e9db2f diff --cc configure.ac index 00000000000,fba98513825..2b47decb177 mode 000000,100644..100644 --- a/configure.ac +++ b/configure.ac @@@ -1,0 -1,4460 +1,4527 @@@ + dnl Autoconf script for GNU Emacs + dnl To rebuild the `configure' script from this, execute the command + dnl autoconf + dnl in the directory containing this script. + dnl If you changed any AC_DEFINES, also run autoheader. + dnl + dnl Copyright (C) 1994-1996, 1999-2012 Free Software Foundation, Inc. + dnl + dnl This file is part of GNU Emacs. + dnl + dnl GNU Emacs is free software: you can redistribute it and/or modify + dnl it under the terms of the GNU General Public License as published by + dnl the Free Software Foundation, either version 3 of the License, or + dnl (at your option) any later version. + dnl + dnl GNU Emacs is distributed in the hope that it will be useful, + dnl but WITHOUT ANY WARRANTY; without even the implied warranty of + dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + dnl GNU General Public License for more details. + dnl + dnl You should have received a copy of the GNU General Public License + dnl along with GNU Emacs. If not, see . + + AC_PREREQ(2.65) + AC_INIT(emacs, 24.1.50) + AC_CONFIG_HEADER(src/config.h:src/config.in) + AC_CONFIG_SRCDIR(src/lisp.h) + AC_CONFIG_AUX_DIR(build-aux) + AM_INIT_AUTOMAKE + + dnl Support for --program-prefix, --program-suffix and + dnl --program-transform-name options + AC_ARG_PROGRAM + + dnl It is important that variables on the RHS not be expanded here, + dnl hence the single quotes. This is per the GNU coding standards, see + dnl (autoconf) Installation Directory Variables + dnl See also epaths.h below. + lispdir='${datadir}/emacs/${version}/lisp' + leimdir='${datadir}/emacs/${version}/leim' + standardlisppath='${lispdir}:${leimdir}' + locallisppath='${datadir}/emacs/${version}/site-lisp:'\ + '${datadir}/emacs/site-lisp' + lisppath='${locallisppath}:${standardlisppath}' + etcdir='${datadir}/emacs/${version}/etc' + archlibdir='${libexecdir}/emacs/${version}/${configuration}' + docdir='${datadir}/emacs/${version}/etc' + gamedir='${localstatedir}/games/emacs' + + dnl OPTION_DEFAULT_OFF(NAME, HELP-STRING) + dnl Create a new --with option that defaults to being disabled. + dnl NAME is the base name of the option. The shell variable with_NAME + dnl will be set to either the user's value (if the option is + dnl specified; 'yes' for a plain --with-NAME) or to 'no' (if the + dnl option is not specified). Note that the shell variable name is + dnl constructed as autoconf does, by replacing non-alphanumeric + dnl characters with "_". + dnl HELP-STRING is the help text for the option. + AC_DEFUN([OPTION_DEFAULT_OFF], [dnl + AC_ARG_WITH([$1],[AS_HELP_STRING([--with-$1],[$2])],[],[dnl + m4_bpatsubst([with_$1], [[^0-9a-z]], [_])=no])dnl + ])dnl + + dnl OPTION_DEFAULT_ON(NAME, HELP-STRING) + dnl Create a new --with option that defaults to being enabled. NAME + dnl is the base name of the option. The shell variable with_NAME + dnl will be set either to 'no' (for a plain --without-NAME) or to + dnl 'yes' (if the option is not specified). Note that the shell + dnl variable name is constructed as autoconf does, by replacing + dnl non-alphanumeric characters with "_". + dnl HELP-STRING is the help text for the option. + AC_DEFUN([OPTION_DEFAULT_ON], [dnl + AC_ARG_WITH([$1],[AS_HELP_STRING([--without-$1],[$2])],[],[dnl + m4_bpatsubst([with_$1], [[^0-9a-z]], [_])=yes])dnl + ])dnl + + OPTION_DEFAULT_ON([pop],[don't support POP mail retrieval with movemail]) + if test "$with_pop" = yes; then + AC_DEFINE(MAIL_USE_POP) + fi + AH_TEMPLATE(MAIL_USE_POP, [Define to support POP mail retrieval.])dnl + + OPTION_DEFAULT_OFF([kerberos],[support Kerberos-authenticated POP]) + if test "$with_kerberos" != no; then + AC_DEFINE(KERBEROS) + fi + AH_TEMPLATE(KERBEROS, + [Define to support Kerberos-authenticated POP mail retrieval.])dnl + + OPTION_DEFAULT_OFF([kerberos5],[support Kerberos version 5 authenticated POP]) + if test "${with_kerberos5}" != no; then + if test "${with_kerberos}" = no; then + with_kerberos=yes + AC_DEFINE(KERBEROS) + fi + AC_DEFINE(KERBEROS5, 1, [Define to use Kerberos 5 instead of Kerberos 4.]) + fi + + OPTION_DEFAULT_OFF([hesiod],[support Hesiod to get the POP server host]) + dnl FIXME hesiod support may not be present, so it seems like an error + dnl to define, or at least use, this unconditionally. + if test "$with_hesiod" != no; then + AC_DEFINE(HESIOD, 1, [Define to support using a Hesiod database to find the POP server.]) + fi + + OPTION_DEFAULT_OFF([mmdf],[support MMDF mailboxes]) + if test "$with_mmdf" != no; then + AC_DEFINE(MAIL_USE_MMDF, 1, [Define to support MMDF mailboxes in movemail.]) + fi + + OPTION_DEFAULT_OFF([mail-unlink],[unlink, rather than empty, mail spool after reading]) + if test "$with_mail_unlink" != no; then + AC_DEFINE(MAIL_UNLINK_SPOOL, 1, [Define to unlink, rather than empty, mail spool after reading.]) + fi + + AC_ARG_WITH([mailhost],[AS_HELP_STRING([--with-mailhost=HOSTNAME], + [string giving default POP mail host])], + AC_DEFINE_UNQUOTED(MAILHOST, ["$withval"], [String giving fallback POP mail host.])) + + OPTION_DEFAULT_ON([sound],[don't compile with sound support]) + + OPTION_DEFAULT_ON([sync-input],[process async input synchronously]) + if test "$with_sync_input" = yes; then + AC_DEFINE(SYNC_INPUT, 1, [Process async input synchronously.]) + fi + + dnl FIXME currently it is not the last. + dnl This should be the last --with option, because --with-x is + dnl added later on when we find the path of X, and it's best to + dnl keep them together visually. + AC_ARG_WITH([x-toolkit],[AS_HELP_STRING([--with-x-toolkit=KIT], + [use an X toolkit (KIT one of: yes or gtk, gtk3, lucid or athena, motif, no)])], + [ case "${withval}" in + y | ye | yes ) val=gtk ;; + n | no ) val=no ;; + l | lu | luc | luci | lucid ) val=lucid ;; + a | at | ath | athe | athen | athena ) val=athena ;; + m | mo | mot | moti | motif ) val=motif ;; + g | gt | gtk ) val=gtk ;; + gtk3 ) val=gtk3 ;; + * ) + AC_MSG_ERROR([`--with-x-toolkit=$withval' is invalid; + this option's value should be `yes', `no', `lucid', `athena', `motif', `gtk' or + `gtk3'. `yes' and `gtk' are synonyms. `athena' and `lucid' are synonyms.]) + ;; + esac + with_x_toolkit=$val + ]) + + OPTION_DEFAULT_OFF([wide-int], [prefer wide Emacs integers (typically 62-bit)]) + if test "$with_wide_int" = yes; then + AC_DEFINE([WIDE_EMACS_INT], 1, [Use long long for EMACS_INT if available.]) + fi + + dnl _ON results in a '--without' option in the --help output, so + dnl the help text should refer to "don't compile", etc. + OPTION_DEFAULT_ON([xpm],[don't compile with XPM image support]) + OPTION_DEFAULT_ON([jpeg],[don't compile with JPEG image support]) + OPTION_DEFAULT_ON([tiff],[don't compile with TIFF image support]) + OPTION_DEFAULT_ON([gif],[don't compile with GIF image support]) + OPTION_DEFAULT_ON([png],[don't compile with PNG image support]) + OPTION_DEFAULT_ON([rsvg],[don't compile with SVG image support]) + OPTION_DEFAULT_ON([xml2],[don't compile with XML parsing support]) + OPTION_DEFAULT_ON([imagemagick],[don't compile with ImageMagick image support]) + + OPTION_DEFAULT_ON([xft],[don't use XFT for anti aliased fonts]) + OPTION_DEFAULT_ON([libotf],[don't use libotf for OpenType font support]) + OPTION_DEFAULT_ON([m17n-flt],[don't use m17n-flt for text shaping]) + + OPTION_DEFAULT_ON([toolkit-scroll-bars],[don't use Motif or Xaw3d scroll bars]) + OPTION_DEFAULT_ON([xaw3d],[don't use Xaw3d]) + OPTION_DEFAULT_ON([xim],[don't use X11 XIM]) + OPTION_DEFAULT_OFF([ns],[use NeXTstep (Cocoa or GNUstep) windowing system]) + + OPTION_DEFAULT_ON([gpm],[don't use -lgpm for mouse support on a GNU/Linux console]) + OPTION_DEFAULT_ON([dbus],[don't compile with D-Bus support]) + OPTION_DEFAULT_ON([gconf],[don't compile with GConf support]) + OPTION_DEFAULT_ON([gsettings],[don't compile with GSettings support]) + OPTION_DEFAULT_ON([selinux],[don't compile with SELinux support]) + OPTION_DEFAULT_ON([gnutls],[don't use -lgnutls for SSL/TLS support]) + ++OPTION_DEFAULT_OFF([xwidgets],[enable use of some gtk widgets it Emacs buffers]) ++ + ## For the times when you want to build Emacs but don't have + ## a suitable makeinfo, and can live without the manuals. + dnl http://lists.gnu.org/archive/html/emacs-devel/2008-04/msg01844.html + OPTION_DEFAULT_ON([makeinfo],[don't require makeinfo for building manuals]) + + ## Makefile.in needs the cache file name. + AC_SUBST(cache_file) + + ## This is an option because I do not know if all info/man support + ## compressed files, nor how to test if they do so. + OPTION_DEFAULT_ON([compress-info],[don't compress the installed Info pages]) + if test $with_compress_info = yes; then + GZIP_INFO=yes + else + GZIP_INFO= + fi + AC_SUBST(GZIP_INFO) + + AC_ARG_WITH([pkg-config-prog],dnl + [AS_HELP_STRING([--with-pkg-config-prog=PATH], + [path to pkg-config for finding GTK and librsvg])]) + if test "X${with_pkg_config_prog}" != X; then + if test "${with_pkg_config_prog}" != yes; then + PKG_CONFIG="${with_pkg_config_prog}" + fi + fi + + CRT_DIR= + AC_ARG_WITH([crt-dir],dnl + [AS_HELP_STRING([--with-crt-dir=DIR],[directory containing crtn.o etc. + The default is /usr/lib, or /usr/lib64 on some platforms.])]) + CRT_DIR="${with_crt_dir}" + + AC_ARG_WITH(gameuser,dnl + [AS_HELP_STRING([--with-gameuser=USER],[user for shared game score files])]) + test "X${with_gameuser}" != X && test "${with_gameuser}" != yes \ + && gameuser="${with_gameuser}" + test "X$gameuser" = X && gameuser=games + + AC_ARG_WITH([gnustep-conf],dnl + [AS_HELP_STRING([--with-gnustep-conf=PATH],[path to GNUstep.conf; default $GNUSTEP_CONFIG_FILE, or /etc/GNUstep/GNUstep.conf])]) + test "X${with_gnustep_conf}" != X && test "${with_gnustep_conf}" != yes && \ + GNUSTEP_CONFIG_FILE="${with_gnustep_conf}" + test "X$GNUSTEP_CONFIG_FILE" = "X" && \ + GNUSTEP_CONFIG_FILE=/etc/GNUstep/GNUstep.conf + + AC_ARG_ENABLE(ns-self-contained, + [AS_HELP_STRING([--disable-ns-self-contained], + [disable self contained build under NeXTstep])], + EN_NS_SELF_CONTAINED=$enableval, + EN_NS_SELF_CONTAINED=yes) + + AC_ARG_ENABLE(locallisppath, + [AS_HELP_STRING([--enable-locallisppath=PATH], + [directories Emacs should search for lisp files specific + to this site])], + if test "${enableval}" = "no"; then + locallisppath= + elif test "${enableval}" != "yes"; then + locallisppath=${enableval} + fi) + + AC_ARG_ENABLE(checking, + [AS_HELP_STRING([--enable-checking@<:@=LIST@:>@], + [enable expensive run-time checks. With LIST, + enable only specific categories of checks. + Categories are: all,yes,no. + Flags are: stringbytes, stringoverrun, stringfreelist, + xmallocoverrun, conslist, glyphs])], + [ac_checking_flags="${enableval}"],[]) + IFS="${IFS= }"; ac_save_IFS="$IFS"; IFS="$IFS," + for check in $ac_checking_flags + do + case $check in + # these set all the flags to specific states + yes) ac_enable_checking=1 ;; + no) ac_enable_checking= ; + ac_gc_check_stringbytes= ; + ac_gc_check_string_overrun= ; + ac_gc_check_string_free_list= ; + ac_xmalloc_overrun= ; + ac_gc_check_cons_list= ; + ac_glyphs_debug= ;; + all) ac_enable_checking=1 ; + ac_gc_check_stringbytes=1 ; + ac_gc_check_string_overrun=1 ; + ac_gc_check_string_free_list=1 ; + ac_xmalloc_overrun=1 ; + ac_gc_check_cons_list=1 ; + ac_glyphs_debug=1 ;; + # these enable particular checks + stringbytes) ac_gc_check_stringbytes=1 ;; + stringoverrun) ac_gc_check_string_overrun=1 ;; + stringfreelist) ac_gc_check_string_free_list=1 ;; + xmallocoverrun) ac_xmalloc_overrun=1 ;; + conslist) ac_gc_check_cons_list=1 ;; + glyphs) ac_glyphs_debug=1 ;; + *) AC_MSG_ERROR(unknown check category $check) ;; + esac + done + IFS="$ac_save_IFS" + + if test x$ac_enable_checking != x ; then + AC_DEFINE(ENABLE_CHECKING, 1, + [Define to 1 if expensive run-time data type and consistency checks are enabled.]) + fi + if test x$ac_gc_check_stringbytes != x ; then + AC_DEFINE(GC_CHECK_STRING_BYTES, 1, + [Define this temporarily to hunt a bug. If defined, the size of + strings is redundantly recorded in sdata structures so that it can + be compared to the sizes recorded in Lisp strings.]) + fi + if test x$ac_gc_check_string_overrun != x ; then + AC_DEFINE(GC_CHECK_STRING_OVERRUN, 1, + [Define this to check for short string overrun.]) + fi + if test x$ac_gc_check_string_free_list != x ; then + AC_DEFINE(GC_CHECK_STRING_FREE_LIST, 1, + [Define this to check the string free list.]) + fi + if test x$ac_xmalloc_overrun != x ; then + AC_DEFINE(XMALLOC_OVERRUN_CHECK, 1, + [Define this to check for malloc buffer overrun.]) + fi + if test x$ac_gc_check_cons_list != x ; then + AC_DEFINE(GC_CHECK_CONS_LIST, 1, + [Define this to check for errors in cons list.]) + fi + if test x$ac_glyphs_debug != x ; then + AC_DEFINE(GLYPH_DEBUG, 1, + [Define this to enable glyphs debugging code.]) + fi + + AC_ARG_ENABLE(check-lisp-object-type, + [AS_HELP_STRING([--enable-check-lisp-object-type], + [enable compile time checks for the Lisp_Object data type. + This is useful for development for catching certain types of bugs.])], + if test "${enableval}" != "no"; then + AC_DEFINE(CHECK_LISP_OBJECT_TYPE, 1, + [Define this to enable compile time checks for the Lisp_Object data type.]) + fi) + + + AC_ARG_ENABLE(profiling, + [AS_HELP_STRING([--enable-profiling], + [build emacs with profiling support. + This might not work on all platforms])], + [ac_enable_profiling="${enableval}"],[]) + if test x$ac_enable_profiling != x ; then + PROFILING_CFLAGS="-DPROFILING=1 -pg" + else + PROFILING_CFLAGS= + fi + AC_SUBST(PROFILING_CFLAGS) + + AC_ARG_ENABLE(autodepend, + [AS_HELP_STRING([--enable-autodepend], + [automatically generate dependencies to .h-files. + Requires GNU Make and Gcc. Enabled if GNU Make and Gcc is + found])], + [ac_enable_autodepend="${enableval}"],[ac_enable_autodepend=yes]) + + #### Make srcdir absolute, if it isn't already. It's important to + #### avoid running the path through pwd unnecessarily, since pwd can + #### give you automounter prefixes, which can go away. We do all this + #### so Emacs can find its files when run uninstalled. + ## Make sure CDPATH doesn't affect cd (in case PWD is relative). + unset CDPATH + case "${srcdir}" in + /* ) ;; + . ) + ## We may be able to use the $PWD environment variable to make this + ## absolute. But sometimes PWD is inaccurate. + ## Note: we used to use ${PWD} at the end instead of `pwd`, + ## but that tested only for a well-formed and valid PWD, + ## it did not object when PWD was well-formed and valid but just wrong. + if test ".${PWD}" != "." && test ".`(cd ${PWD} ; sh -c pwd)`" = ".`pwd`" ; + then + srcdir="$PWD" + else + srcdir="`(cd ${srcdir}; pwd)`" + fi + ;; + * ) srcdir="`(cd ${srcdir}; pwd)`" ;; + esac + + #### Given the configuration name, set opsysfile to the + #### name of s/*.h file we should use. + + ### Canonicalize the configuration name. + + AC_CANONICAL_HOST + canonical=$host + configuration=${host_alias-${build_alias-$host}} + + dnl This used to use changequote, but, apart from `changequote is evil' + dnl per the autoconf manual, we can speed up autoconf somewhat by quoting + dnl the great gob of text. Thus it's not processed for possible expansion. + dnl Just make sure the brackets remain balanced. + dnl + dnl Since Emacs can't find matching pairs of quotes, boundaries are + dnl indicated by comments. + dnl quotation begins + [ + + ### If you add support for a new configuration, add code to this + ### switch statement to recognize your configuration name and select + ### the appropriate operating system file. + + ### You would hope that you could choose an s/*.h + ### file based on the operating system portion. However, it turns out + ### that each s/*.h file is pretty manufacturer-specific. + ### So we basically have to have a special case for each + ### configuration name. + ### + ### As far as handling version numbers on operating systems is + ### concerned, make sure things will fail in a fixable way. If + ### /etc/MACHINES doesn't say anything about version numbers, be + ### prepared to handle anything reasonably. If version numbers + ### matter, be sure /etc/MACHINES says something about it. + + opsys='' unported=no + case "${canonical}" in + + ## GNU/Linux and similar ports + *-*-linux* ) + opsys=gnu-linux + ;; + + ## FreeBSD ports + *-*-freebsd* ) + opsys=freebsd + ;; + + ## FreeBSD kernel + glibc based userland + *-*-kfreebsd*gnu* ) + opsys=gnu-kfreebsd + ;; + + ## NetBSD ports + *-*-netbsd* ) + opsys=netbsd + ;; + + ## OpenBSD ports + *-*-openbsd* ) + opsys=openbsd + ;; + + ## Apple Darwin / Mac OS X + *-apple-darwin* ) + case "${canonical}" in + i[3456]86-* ) ;; + powerpc-* ) ;; + x86_64-* ) ;; + * ) unported=yes ;; + esac + opsys=darwin + ## Use fink packages if available. + ## FIXME find a better way to do this: http://debbugs.gnu.org/11507 + ## if test -d /sw/include && test -d /sw/lib; then + ## GCC_TEST_OPTIONS="-I/sw/include -L/sw/lib" + ## NON_GCC_TEST_OPTIONS=${GCC_TEST_OPTIONS} + ## fi + ;; + + ## HP 9000 series 700 and 800, running HP/UX + hppa*-hp-hpux10.2* ) + opsys=hpux10-20 + ;; + hppa*-hp-hpux1[1-9]* ) + opsys=hpux11 + CFLAGS="-D_INCLUDE__STDC_A1_SOURCE $CFLAGS" + ;; + + ## IBM machines + rs6000-ibm-aix4.[23]* ) + opsys=aix4-2 + ;; + powerpc-ibm-aix4.[23]* ) + opsys=aix4-2 + ;; + rs6000-ibm-aix[56]* ) + opsys=aix4-2 + ;; + powerpc-ibm-aix[56]* ) + opsys=aix4-2 + ;; + + ## Silicon Graphics machines + ## Iris 4D + mips-sgi-irix6.5 ) + opsys=irix6-5 + # Without defining _LANGUAGE_C, things get masked out in the headers + # so that, for instance, grepping for `free' in stdlib.h fails and + # AC_HEADER_STD_C fails. (MIPSPro 7.2.1.2m compilers, Irix 6.5.3m). + NON_GCC_TEST_OPTIONS="-D_LANGUAGE_C" + ;; + + ## Suns + *-sun-solaris* \ + | i[3456]86-*-solaris2* | i[3456]86-*-sunos5* \ + | x86_64-*-solaris2* | x86_64-*-sunos5*) + case "${canonical}" in + i[3456]86-*-* ) ;; + amd64-*-*|x86_64-*-*) ;; + sparc* ) ;; + * ) unported=yes ;; + esac + case "${canonical}" in + *-sunos5.6* | *-solaris2.6* ) + opsys=sol2-6 + RANLIB="ar -ts" + ;; + *-sunos5.[7-9]* | *-solaris2.[7-9]* ) + opsys=sol2-6 + emacs_check_sunpro_c=yes + ;; + *-sunos5* | *-solaris* ) + opsys=sol2-10 + emacs_check_sunpro_c=yes + ;; + esac + ## Watch out for a compiler that we know will not work. + case "${canonical}" in + *-solaris* | *-sunos5* ) + if [ "x$CC" = x/usr/ucb/cc ]; then + ## /usr/ucb/cc doesn't work; + ## we should find some other compiler that does work. + unset CC + fi + ;; + *) ;; + esac + ;; + + ## Intel 386 machines where we don't care about the manufacturer. + i[3456]86-*-* ) + case "${canonical}" in + *-cygwin ) opsys=cygwin ;; + *-darwin* ) opsys=darwin ;; + *-sysv4.2uw* ) opsys=unixware ;; + *-sysv5uw* ) opsys=unixware ;; + *-sysv5OpenUNIX* ) opsys=unixware ;; + ## Otherwise, we'll fall through to the generic opsys code at the bottom. + esac + ;; + + * ) + unported=yes + ;; + esac + + ### If the code above didn't choose an operating system, just choose + ### an operating system based on the configuration name. You really + ### only want to use this when you have no idea what the right + ### operating system is; if you know what operating systems a machine + ### runs, it's cleaner to make it explicit in the case statement + ### above. + if test x"${opsys}" = x; then + case "${canonical}" in + *-gnu* ) opsys=gnu ;; + * ) + unported=yes + ;; + esac + fi + + ] + dnl quotation ends + + if test $unported = yes; then + AC_MSG_ERROR([Emacs hasn't been ported to `${canonical}' systems. + Check `etc/MACHINES' for recognized configuration names.]) + fi + + opsysfile="s/${opsys}.h" + + + #### Choose a compiler. + + dnl Sets GCC=yes if using gcc. + AC_PROG_CC + AM_PROG_CC_C_O + + if test x$GCC = xyes; then + test "x$GCC_TEST_OPTIONS" != x && CC="$CC $GCC_TEST_OPTIONS" + else + test "x$NON_GCC_TEST_OPTIONS" != x && CC="$CC $NON_GCC_TEST_OPTIONS" + fi + + # Initialize gnulib right after choosing the compiler. + gl_EARLY + + AC_ARG_ENABLE([gcc-warnings], + [AS_HELP_STRING([--enable-gcc-warnings], + [turn on lots of GCC warnings. This is intended for + developers, and may generate false alarms when used + with older or non-GNU development tools.])], + [case $enableval in + yes|no) ;; + *) AC_MSG_ERROR([bad value $enableval for gcc-warnings option]) ;; + esac + gl_gcc_warnings=$enableval], + [gl_gcc_warnings=no] + ) + + AC_ARG_ENABLE(link-time-optimization, + [AS_HELP_STRING([--enable-link-time-optimization], + [build emacs with link-time optimization. + This is supported only for GCC since 4.5.0.])], + if test "${enableval}" != "no"; then + AC_MSG_CHECKING([whether link-time optimization is supported]) + ac_lto_supported=no + if test x$GCC = xyes; then + CPUS=`getconf _NPROCESSORS_ONLN 2>/dev/null` + if test x$CPUS != x; then + LTO="-flto=$CPUS" + else + LTO="-flto" + fi + old_CFLAGS=$CFLAGS + CFLAGS="$CFLAGS $LTO" + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])], + [ac_lto_supported=yes], [ac_lto_supported=no]) + CFLAGS="$old_CFLAGS" + fi + AC_MSG_RESULT([$ac_lto_supported]) + if test "$ac_lto_supported" = "yes"; then + CFLAGS="$CFLAGS $LTO" + fi + fi) + + # gl_GCC_VERSION_IFELSE([major], [minor], [run-if-found], [run-if-not-found]) + # ------------------------------------------------ + # If $CPP is gcc-MAJOR.MINOR or newer, then run RUN-IF-FOUND. + # Otherwise, run RUN-IF-NOT-FOUND. + AC_DEFUN([gl_GCC_VERSION_IFELSE], + [AC_PREPROC_IFELSE( + [AC_LANG_PROGRAM( + [[ + #if ($1) < __GNUC__ || (($1) == __GNUC__ && ($2) <= __GNUC_MINOR__) + /* ok */ + #else + # error "your version of gcc is older than $1.$2" + #endif + ]]), + ], [$3], [$4]) + ] + ) + + # When compiling with GCC, prefer -isystem to -I when including system + # include files, to avoid generating useless diagnostics for the files. + if test "$gl_gcc_warnings" != yes; then + isystem='-I' + else + isystem='-isystem ' + + # This, $nw, is the list of warnings we disable. + nw= + + case $with_x_toolkit in + lucid | athena | motif) + # Old toolkits mishandle 'const'. + nw="$nw -Wwrite-strings" + ;; + *) + gl_WARN_ADD([-Werror], [WERROR_CFLAGS]) + ;; + esac + AC_SUBST([WERROR_CFLAGS]) + + nw="$nw -Waggregate-return" # anachronistic + nw="$nw -Wlong-long" # C90 is anachronistic + nw="$nw -Wc++-compat" # We don't care about C++ compilers + nw="$nw -Wundef" # Warns on '#if GNULIB_FOO' etc in gnulib + nw="$nw -Wtraditional" # Warns on #elif which we use often + nw="$nw -Wcast-qual" # Too many warnings for now + nw="$nw -Wconversion" # Too many warnings for now + nw="$nw -Wsystem-headers" # Don't let system headers trigger warnings + nw="$nw -Wsign-conversion" # Too many warnings for now + nw="$nw -Woverlength-strings" # Not a problem these days + nw="$nw -Wtraditional-conversion" # Too many warnings for now + nw="$nw -Wunreachable-code" # so buggy that it's now silently ignored + nw="$nw -Wpadded" # Our structs are not padded + nw="$nw -Wredundant-decls" # we regularly (re)declare functions + nw="$nw -Wlogical-op" # any use of fwrite provokes this + nw="$nw -Wformat-nonliteral" # we do this a lot + nw="$nw -Wvla" # warnings in gettext.h + nw="$nw -Wnested-externs" # use of XARGMATCH/verify_function__ + nw="$nw -Wswitch-enum" # Too many warnings for now + nw="$nw -Wswitch-default" # Too many warnings for now + nw="$nw -Wfloat-equal" # warns about high-quality code + nw="$nw -Winline" # OK to ignore 'inline' + nw="$nw -Wsync-nand" # irrelevant here, and provokes ObjC warning + nw="$nw -Wunsafe-loop-optimizations" # OK to suppress unsafe optimizations + + # Emacs doesn't care about shadowing; see + # . + nw="$nw -Wshadow" + + # The following lines should be removable at some point. + nw="$nw -Wstack-protector" + nw="$nw -Wstrict-overflow" + nw="$nw -Wsuggest-attribute=pure" + + gl_MANYWARN_ALL_GCC([ws]) + gl_MANYWARN_COMPLEMENT([ws], [$ws], [$nw]) + for w in $ws; do + gl_WARN_ADD([$w]) + done + gl_WARN_ADD([-Wno-missing-field-initializers]) # We need this one + gl_WARN_ADD([-Wno-sign-compare]) # Too many warnings for now + gl_WARN_ADD([-Wno-type-limits]) # Too many warnings for now + gl_WARN_ADD([-Wno-switch]) # Too many warnings for now + gl_WARN_ADD([-Wno-unused-parameter]) # Too many warnings for now + gl_WARN_ADD([-Wno-format-nonliteral]) + + # In spite of excluding -Wlogical-op above, it is enabled, as of + # gcc 4.5.0 20090517. + gl_WARN_ADD([-Wno-logical-op]) + + gl_WARN_ADD([-fdiagnostics-show-option]) + gl_WARN_ADD([-funit-at-a-time]) + + AC_DEFINE([lint], [1], [Define to 1 if the compiler is checking for lint.]) + AC_DEFINE([_FORTIFY_SOURCE], [2], + [enable compile-time and run-time bounds-checking, and some warnings]) + AC_DEFINE([GNULIB_PORTCHECK], [1], [enable some gnulib portability checks]) + + # We use a slightly smaller set of warning options for lib/. + # Remove the following and save the result in GNULIB_WARN_CFLAGS. + nw= + nw="$nw -Wunused-macros" + + gl_MANYWARN_COMPLEMENT([GNULIB_WARN_CFLAGS], [$WARN_CFLAGS], [$nw]) + AC_SUBST([GNULIB_WARN_CFLAGS]) + fi + + + + dnl Some other nice autoconf tests. + dnl These are commented out, since gl_EARLY and/or Autoconf already does them. + dnl AC_PROG_INSTALL + dnl AC_PROG_MKDIR_P + dnl if test "x$RANLIB" = x; then + dnl AC_PROG_RANLIB + dnl fi + + AC_PATH_PROG(INSTALL_INFO, install-info, :, + $PATH$PATH_SEPARATOR/usr/sbin$PATH_SEPARATOR/sbin) + dnl Don't use GZIP, which is used by gzip for additional parameters. + AC_PATH_PROG(GZIP_PROG, gzip) + + if test $opsys = gnu-linux; then + AC_PATH_PROG(PAXCTL, paxctl,, + [$PATH$PATH_SEPARATOR/sbin$PATH_SEPARATOR/usr/sbin]) + fi + + ## Need makeinfo >= 4.7 (?) to build the manuals. + AC_PATH_PROG(MAKEINFO, makeinfo, no) + dnl By this stage, configure has already checked for egrep and set EGREP, + dnl or exited with an error if no egrep was found. + if test "$MAKEINFO" != "no" && \ + test x"`$MAKEINFO --version 2> /dev/null | $EGREP 'texinfo[[^0-9]]*([[1-4]][[0-9]]+|[[5-9]]|4\.[[7-9]]|4\.[[1-6]][[0-9]]+)'`" = x; then + MAKEINFO=no + fi + + ## Makeinfo is unusual. For a released Emacs, the manuals are + ## pre-built, and not deleted by the normal clean rules. makeinfo is + ## therefore in the category of "special tools" not normally required, which + ## configure does not have to check for (eg autoconf itself). + ## In a Bazaar checkout on the other hand, the manuals are not included. + ## So makeinfo is a requirement to build from Bazaar, and configure + ## should test for it as it does for any other build requirement. + ## We use the presence of $srcdir/info/emacs to distinguish a release, + ## with pre-built manuals, from a Bazaar checkout. + HAVE_MAKEINFO=yes + + if test "$MAKEINFO" = "no"; then + MAKEINFO=makeinfo + if test "x${with_makeinfo}" = "xno"; then + HAVE_MAKEINFO=no + elif test ! -e $srcdir/info/emacs; then + AC_MSG_ERROR( [You do not seem to have makeinfo >= 4.7, and your + source tree does not seem to have pre-built manuals in the `info' directory. + Either install a suitable version of makeinfo, or re-run configure + with the `--without-makeinfo' option to build without the manuals.] ) + fi + fi + AC_SUBST(HAVE_MAKEINFO) + + dnl Just so that there is only a single place we need to edit. + INFO_EXT=.info + INFO_OPTS=--no-split + AC_SUBST(INFO_EXT) + AC_SUBST(INFO_OPTS) + + dnl Add our options to ac_link now, after it is set up. + + if test x$GCC = xyes; then + test "x$GCC_LINK_TEST_OPTIONS" != x && \ + ac_link="$ac_link $GCC_LINK_TEST_OPTIONS" + else + test "x$NON_GCC_LINK_TEST_OPTIONS" != x && \ + ac_link="$ac_link $NON_GCC_LINK_TEST_OPTIONS" + fi + + dnl We need -znocombreloc if we're using a relatively recent GNU ld. + dnl If we can link with the flag, it shouldn't do any harm anyhow. + dnl (Don't use `-z nocombreloc' as -z takes no arg on Irix.) + dnl Treat GCC specially since it just gives a non-fatal `unrecognized option' + dnl if not built to support GNU ld. + + late_LDFLAGS=$LDFLAGS + if test x$GCC = xyes; then + LDFLAGS="$LDFLAGS -Wl,-znocombreloc" + else + LDFLAGS="$LDFLAGS -znocombreloc" + fi + + AC_MSG_CHECKING([for -znocombreloc]) + AC_LINK_IFELSE([AC_LANG_PROGRAM([], [])], + [AC_MSG_RESULT(yes)], + LDFLAGS=$late_LDFLAGS + [AC_MSG_RESULT(no)]) + + + dnl The function dump-emacs will not be defined and temacs will do + dnl (load "loadup") automatically unless told otherwise. + test "x$CANNOT_DUMP" = "x" && CANNOT_DUMP=no + case "$opsys" in + your-opsys-here) CANNOT_DUMP=yes ;; + esac + + test "$CANNOT_DUMP" = "yes" && \ + AC_DEFINE(CANNOT_DUMP, 1, [Define if Emacs cannot be dumped on your system.]) + + AC_SUBST(CANNOT_DUMP) + + + UNEXEC_OBJ=unexelf.o + case "$opsys" in + # MSDOS uses unexcoff.o + # MSWindows uses unexw32.o + aix4-2) + UNEXEC_OBJ=unexaix.o + ;; + cygwin) + UNEXEC_OBJ=unexcw.o + ;; + darwin) + UNEXEC_OBJ=unexmacosx.o + ;; + hpux10-20 | hpux11) + UNEXEC_OBJ=unexhp9k800.o + ;; + sol2-10) + # Use the Solaris dldump() function, called from unexsol.c, to dump + # emacs, instead of the generic ELF dump code found in unexelf.c. + # The resulting binary has a complete symbol table, and is better + # for debugging and other observability tools (debuggers, pstack, etc). + # + # If you encounter a problem using dldump(), please consider sending + # a message to the OpenSolaris tools-linking mailing list: + # http://mail.opensolaris.org/mailman/listinfo/tools-linking + # + # It is likely that dldump() works with older Solaris too, but this has + # not been tested, so for now this change is for Solaris 10 or newer. + UNEXEC_OBJ=unexsol.o + ;; + esac + + LD_SWITCH_SYSTEM= + case "$opsys" in + freebsd) + ## Let `ld' find image libs and similar things in /usr/local/lib. + ## The system compiler, GCC, has apparently been modified to not + ## look there, contrary to what a stock GCC would do. + ### It's not our place to do this. See bug#10313#17. + ### LD_SWITCH_SYSTEM=-L/usr/local/lib + : + ;; + + gnu-linux) + ## cpp test was "ifdef __mips__", but presumably this is equivalent... + case $host_cpu in mips*) LD_SWITCH_SYSTEM="-G 0";; esac + ;; + + netbsd) + ### It's not our place to do this. See bug#10313#17. + ### LD_SWITCH_SYSTEM="-Wl,-rpath,/usr/pkg/lib -L/usr/pkg/lib -Wl,-rpath,/usr/local/lib -L/usr/local/lib" + : + ;; + + openbsd) + ## Han Boetes says this is necessary, + ## otherwise Emacs dumps core on elf systems. + LD_SWITCH_SYSTEM="-Z" + ;; + esac + AC_SUBST(LD_SWITCH_SYSTEM) + + ac_link="$ac_link $LD_SWITCH_SYSTEM" + + ## This setting of LD_SWITCH_SYSTEM references LD_SWITCH_X_SITE_RPATH, + ## which has not been defined yet. When this was handled with cpp, + ## it was expanded to null when configure sourced the s/*.h file. + ## Thus LD_SWITCH_SYSTEM had different values in configure and the Makefiles. + ## FIXME it would be cleaner to put this in LD_SWITCH_SYSTEM_TEMACS + ## (or somesuch), but because it is supposed to go at the _front_ + ## of LD_SWITCH_SYSTEM, we cannot do that in exactly the same way. + ## Compare with the gnu-linux case below, which added to the end + ## of LD_SWITCH_SYSTEM, and so can instead go at the front of + ## LD_SWITCH_SYSTEM_TEMACS. + case "$opsys" in + netbsd|openbsd) + LD_SWITCH_SYSTEM="\$(LD_SWITCH_X_SITE_RPATH) $LD_SWITCH_SYSTEM" ;; + esac + + + C_SWITCH_MACHINE= + case $canonical in + alpha*) + AC_CHECK_DECL([__ELF__]) + if test "$ac_cv_have_decl___ELF__" = "yes"; then + ## With ELF, make sure that all common symbols get allocated to in the + ## data section. Otherwise, the dump of temacs may miss variables in + ## the shared library that have been initialized. For example, with + ## GNU libc, __malloc_initialized would normally be resolved to the + ## shared library's .bss section, which is fatal. + if test "x$GCC" = "xyes"; then + C_SWITCH_MACHINE="-fno-common" + else + AC_MSG_ERROR([What gives? Fix me if DEC Unix supports ELF now.]) + fi + else + UNEXEC_OBJ=unexalpha.o + fi + ;; + esac + AC_SUBST(C_SWITCH_MACHINE) + + AC_SUBST(UNEXEC_OBJ) + + C_SWITCH_SYSTEM= + ## Some programs in src produce warnings saying certain subprograms + ## are too complex and need a MAXMEM value greater than 2000 for + ## additional optimization. --nils@exp-math.uni-essen.de + test "$opsys" = "aix4.2" && test "x$GCC" != "xyes" && \ + C_SWITCH_SYSTEM="-ma -qmaxmem=4000" + ## gnu-linux might need -D_BSD_SOURCE on old libc5 systems. + ## It is redundant in glibc2, since we define _GNU_SOURCE. + AC_SUBST(C_SWITCH_SYSTEM) + + + LIBS_SYSTEM= + case "$opsys" in + ## IBM's X11R5 uses -lIM and -liconv in AIX 3.2.2. + aix4-2) LIBS_SYSTEM="-lrts -lIM -liconv" ;; + + freebsd) LIBS_SYSTEM="-lutil" ;; + + hpux*) LIBS_SYSTEM="-l:libdld.sl" ;; + + sol2*) LIBS_SYSTEM="-lsocket -lnsl" ;; + + ## Motif needs -lgen. + unixware) LIBS_SYSTEM="-lsocket -lnsl -lelf -lgen" ;; + esac + AC_SUBST(LIBS_SYSTEM) + + + ### Make sure subsequent tests use flags consistent with the build flags. + + if test x"${OVERRIDE_CPPFLAGS}" != x; then + CPPFLAGS="${OVERRIDE_CPPFLAGS}" + else + CPPFLAGS="$C_SWITCH_SYSTEM $C_SWITCH_MACHINE $CPPFLAGS" + fi + + # Suppress obsolescent Autoconf test for size_t; Emacs assumes C89 or better. + AC_DEFUN([AC_TYPE_SIZE_T]) + # Likewise for obsolescent test for uid_t, gid_t; Emacs assumes them. + AC_DEFUN([AC_TYPE_UID_T]) + + + LIB_MATH=-lm + LIB_STANDARD= + START_FILES= + dnl Current possibilities handled by sed (aix4-2 -> aix, + dnl gnu-linux -> gnu/linux, etc.): + dnl gnu, gnu/linux, gnu/kfreebsd, aix, cygwin, darwin, hpux, irix. + dnl And special cases: berkeley-unix, usg-unix-v, ms-dos, windows-nt. + SYSTEM_TYPE=`echo $opsys | sed -e 's/[[0-9]].*//' -e 's|-|/|'` + + dnl NB do not use CRT_DIR unquoted here, since it might not be set yet. + case $opsys in + cygwin ) + LIB_MATH= + START_FILES='pre-crt0.o' + ;; + darwin ) + ## Adding -lm confuses the dynamic linker, so omit it. + LIB_MATH= + START_FILES='pre-crt0.o' + ;; + freebsd ) + LIB_STANDARD='-lgcc -lc -lgcc $(CRT_DIR)/crtend.o $(CRT_DIR)/crtn.o' + START_FILES='pre-crt0.o $(CRT_DIR)/crt1.o $(CRT_DIR)/crti.o $(CRT_DIR)/crtbegin.o' + SYSTEM_TYPE=berkeley-unix + ;; + gnu-linux | gnu-kfreebsd ) + LIB_STANDARD='-lgcc -lc -lgcc $(CRT_DIR)/crtn.o' + START_FILES='pre-crt0.o $(CRT_DIR)/crt1.o $(CRT_DIR)/crti.o' + ;; + hpux10-20 | hpux11 ) + LIB_STANDARD=-lc + START_FILES='pre-crt0.o $(CRT_DIR)/crt0.o' + ;; + dnl NB this may be adjusted below. + netbsd | openbsd ) + LIB_STANDARD='-lgcc -lc -lgcc $(CRT_DIR)/crtend.o' + START_FILES='pre-crt0.o $(CRT_DIR)/crt0.o $(CRT_DIR)/crtbegin.o' + SYSTEM_TYPE=berkeley-unix + ;; + + sol2* | unixware ) + SYSTEM_TYPE=usg-unix-v + ;; + + esac + + AC_SUBST(LIB_MATH) + AC_SUBST(START_FILES) + AC_DEFINE_UNQUOTED(SYSTEM_TYPE, "$SYSTEM_TYPE", + [The type of system you are compiling for; sets `system-type'.]) + + dnl Not all platforms use crtn.o files. Check if the current one does. + crt_files= + + for file in x $LIB_STANDARD $START_FILES; do + case "$file" in + *CRT_DIR*) crt_files="$crt_files `echo $file | sed -e 's|.*/||'`" ;; + esac + done + + if test "x$crt_files" != x; then + + ## If user specified a crt-dir, use that unconditionally. + crt_gcc=no + + if test "X$CRT_DIR" = "X"; then + + CRT_DIR=/usr/lib # default + + case "$canonical" in + x86_64-*-linux-gnu* | s390x-*-linux-gnu*) + ## On x86-64 and s390x GNU/Linux distributions, the standard library + ## can be in a variety of places. We only try /usr/lib64 and /usr/lib. + ## For anything else (eg /usr/lib32), it is up the user to specify + ## the location (bug#5655). + ## Test for crtn.o, not just the directory, because sometimes the + ## directory exists but does not have the relevant files (bug#1287). + ## FIXME better to test for binary compatibility somehow. + test -e /usr/lib64/crtn.o && CRT_DIR=/usr/lib64 + ;; + + powerpc64-*-linux-gnu* | sparc64-*-linux-gnu*) CRT_DIR=/usr/lib64 ;; + esac + + case "$opsys" in + hpux10-20) CRT_DIR=/lib ;; + esac + + test "x${GCC}" = xyes && crt_gcc=yes + + fi # CRT_DIR = "" + + crt_missing= + + for file in $crt_files; do + + ## If we're using gcc, try to determine it automatically by asking + ## gcc. [If this doesn't work, CRT_DIR will remain at the + ## system-dependent default from above.] + if test $crt_gcc = yes && test ! -e $CRT_DIR/$file; then + + crt_file=`$CC --print-file-name=$file 2>/dev/null` + case "$crt_file" in + */*) + CRT_DIR=`AS_DIRNAME(["$crt_file"])` + ;; + esac + fi + + dnl We expect all the files to be in a single directory, so after the + dnl first there is no point asking gcc. + crt_gcc=no + + test -e $CRT_DIR/$file || crt_missing="$crt_missing $file" + done # $crt_files + + test "x$crt_missing" = x || \ + AC_MSG_ERROR([Required file(s) not found:$crt_missing + Try using the --with-crt-dir option.]) + + fi # crt_files != "" + + AC_SUBST(CRT_DIR) + + case $opsys in + netbsd | openbsd ) + if test -f $CRT_DIR/crti.o; then + + test -f $CRT_DIR/crtn.o || \ + AC_MSG_ERROR([Required file not found: crtn.o]) + + LIB_STANDARD='-lgcc -lc -lgcc $(CRT_DIR)/crtend.o $(CRT_DIR)/crtn.o' + START_FILES='pre-crt0.o $(CRT_DIR)/crt0.o $(CRT_DIR)/crti.o $(CRT_DIR)/crtbegin.o' + fi + ;; + esac + + + pre_PKG_CONFIG_CFLAGS=$CFLAGS + pre_PKG_CONFIG_LIBS=$LIBS + + AC_PATH_PROG(PKG_CONFIG, pkg-config, no) + + dnl This function definition taken from Gnome 2.0 + dnl PKG_CHECK_MODULES(GSTUFF, gtk+-2.0 >= 1.3 glib = 1.3.4, action-if, action-not) + dnl defines GSTUFF_LIBS, GSTUFF_CFLAGS, see pkg-config man page + dnl also defines GSTUFF_PKG_ERRORS on error + AC_DEFUN([PKG_CHECK_MODULES], [ + succeeded=no + + if test "$PKG_CONFIG" = "no" ; then + ifelse([$4], , [AC_MSG_ERROR([ + *** The pkg-config script could not be found. Make sure it is in your path, or give the full path to pkg-config with the PKG_CONFIG environment variable or --with-pkg-config-prog. Or see http://www.freedesktop.org/software/pkgconfig to get pkg-config.])], [$4]) + else + PKG_CONFIG_MIN_VERSION=0.9.0 + if $PKG_CONFIG --atleast-pkgconfig-version $PKG_CONFIG_MIN_VERSION; then + AC_MSG_CHECKING(for $2) + + if $PKG_CONFIG --exists "$2" 2>&AS_MESSAGE_LOG_FD && + $1_CFLAGS=`$PKG_CONFIG --cflags "$2" 2>&AS_MESSAGE_LOG_FD` && + $1_LIBS=`$PKG_CONFIG --libs "$2" 2>&AS_MESSAGE_LOG_FD`; then + edit_cflags=" + s,///*,/,g + s/^/ / + s/ -I/ $isystem/g + s/^ // + " + $1_CFLAGS=`AS_ECHO(["$$1_CFLAGS"]) | sed -e "$edit_cflags"` + $1_LIBS=`AS_ECHO(["$$1_LIBS"]) | sed -e 's,///*,/,g'` + AC_MSG_RESULT([yes CFLAGS='$$1_CFLAGS' LIBS='$$1_LIBS']) + succeeded=yes + else + AC_MSG_RESULT(no) + $1_CFLAGS="" + $1_LIBS="" + ## If we have a custom action on failure, don't print errors, but + ## do set a variable so people can do so. + $1_PKG_ERRORS=`$PKG_CONFIG --errors-to-stdout --print-errors "$2"` + ifelse([$4], ,echo $$1_PKG_ERRORS,) + fi + + AC_SUBST($1_CFLAGS) + AC_SUBST($1_LIBS) + else + echo "*** Your version of pkg-config is too old. You need version $PKG_CONFIG_MIN_VERSION or newer." + echo "*** See http://www.freedesktop.org/software/pkgconfig" + fi + fi + + if test $succeeded = yes; then + ifelse([$3], , :, [$3]) + else + ifelse([$4], , [AC_MSG_ERROR([Library requirements ($2) not met; consider adjusting the PKG_CONFIG_PATH environment variable if your libraries are in a nonstandard prefix so pkg-config can find them.])], [$4]) + fi + ]) + + + if test "${with_sound}" != "no"; then + # Sound support for GNU/Linux and the free BSDs. + AC_CHECK_HEADERS(machine/soundcard.h sys/soundcard.h soundcard.h, + have_sound_header=yes) + # Emulation library used on NetBSD. + AC_CHECK_LIB(ossaudio, _oss_ioctl, LIBSOUND=-lossaudio, LIBSOUND=) + AC_SUBST(LIBSOUND) + + ALSA_REQUIRED=1.0.0 + ALSA_MODULES="alsa >= $ALSA_REQUIRED" + PKG_CHECK_MODULES(ALSA, $ALSA_MODULES, HAVE_ALSA=yes, HAVE_ALSA=no) + if test $HAVE_ALSA = yes; then + SAVE_CFLAGS="$CFLAGS" + SAVE_LIBS="$LIBS" + CFLAGS="$ALSA_CFLAGS $CFLAGS" + LIBS="$ALSA_LIBS $LIBS" + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include ]], [[snd_lib_error_set_handler (0);]])], + emacs_alsa_normal=yes, + emacs_alsa_normal=no) + if test "$emacs_alsa_normal" != yes; then + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include ]], + [[snd_lib_error_set_handler (0);]])], + emacs_alsa_subdir=yes, + emacs_alsa_subdir=no) + if test "$emacs_alsa_subdir" != yes; then + AC_MSG_ERROR([pkg-config found alsa, but it does not compile. See config.log for error messages.]) + fi + ALSA_CFLAGS="$ALSA_CFLAGS -DALSA_SUBDIR_INCLUDE" + fi + + CFLAGS="$SAVE_CFLAGS" + LIBS="$SAVE_LIBS" + LIBSOUND="$LIBSOUND $ALSA_LIBS" + CFLAGS_SOUND="$CFLAGS_SOUND $ALSA_CFLAGS" + AC_DEFINE(HAVE_ALSA, 1, [Define to 1 if ALSA is available.]) + fi + + dnl Define HAVE_SOUND if we have sound support. We know it works and + dnl compiles only on the specified platforms. For others, it + dnl probably doesn't make sense to try. + if test x$have_sound_header = xyes || test $HAVE_ALSA = yes; then + case "$opsys" in + dnl defined __FreeBSD__ || defined __NetBSD__ || defined __linux__ + gnu-linux|freebsd|netbsd) + AC_DEFINE(HAVE_SOUND, 1, [Define to 1 if you have sound support.]) + ;; + esac + fi + + AC_SUBST(CFLAGS_SOUND) + fi + + dnl checks for header files + AC_CHECK_HEADERS_ONCE( + linux/version.h sys/systeminfo.h + stdio_ext.h fcntl.h coff.h pty.h + sys/vlimit.h sys/resource.h + sys/utsname.h pwd.h utmp.h dirent.h util.h) + + AC_MSG_CHECKING(if personality LINUX32 can be set) + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include ]], [[personality (PER_LINUX32)]])], + emacs_cv_personality_linux32=yes, + emacs_cv_personality_linux32=no) + AC_MSG_RESULT($emacs_cv_personality_linux32) + + if test $emacs_cv_personality_linux32 = yes; then + AC_DEFINE(HAVE_PERSONALITY_LINUX32, 1, + [Define to 1 if personality LINUX32 can be set.]) + fi + + dnl On Solaris 8 there's a compilation warning for term.h because + dnl it doesn't define `bool'. + AC_CHECK_HEADERS(term.h, , , -) + AC_HEADER_TIME + AC_CHECK_DECLS([sys_siglist]) + if test $ac_cv_have_decl_sys_siglist != yes; then + # For Tru64, at least: + AC_CHECK_DECLS([__sys_siglist]) + if test $ac_cv_have_decl___sys_siglist = yes; then + AC_DEFINE(sys_siglist, __sys_siglist, + [Define to any substitute for sys_siglist.]) + fi + fi + AC_HEADER_SYS_WAIT + + dnl Check for speed_t typedef. + AC_CACHE_CHECK(for speed_t, emacs_cv_speed_t, + [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include ]], [[speed_t x = 1;]])], + emacs_cv_speed_t=yes, emacs_cv_speed_t=no)]) + if test $emacs_cv_speed_t = yes; then + AC_DEFINE(HAVE_SPEED_T, 1, + [Define to 1 if `speed_t' is declared by .]) + fi + + AC_CACHE_CHECK(for struct exception, emacs_cv_struct_exception, + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include ]], + [[static struct exception x; x.arg1 = x.arg2 = x.retval; x.name = ""; x.type = 1;]])], + emacs_cv_struct_exception=yes, emacs_cv_struct_exception=no)) + HAVE_EXCEPTION=$emacs_cv_struct_exception + dnl Define on Darwin so emacs symbols will not conflict with those + dnl in the System framework. Otherwise -prebind will not work. + if test $emacs_cv_struct_exception != yes || test $opsys = darwin; then + AC_DEFINE(NO_MATHERR, 1, [Define to 1 if you don't have struct exception in math.h.]) + fi + + AC_CHECK_HEADERS_ONCE(sys/socket.h) + AC_CHECK_HEADERS(net/if.h, , , [AC_INCLUDES_DEFAULT + #if HAVE_SYS_SOCKET_H + #include + #endif]) + AC_CHECK_HEADERS(ifaddrs.h, , , [AC_INCLUDES_DEFAULT + #if HAVE_SYS_SOCKET_H + #include + #endif]) + AC_CHECK_HEADERS(net/if_dl.h, , , [AC_INCLUDES_DEFAULT + #if HAVE_SYS_SOCKET_H + #include + #endif]) + + dnl checks for structure members + AC_CHECK_MEMBERS([struct ifreq.ifr_flags, struct ifreq.ifr_hwaddr, + struct ifreq.ifr_netmask, struct ifreq.ifr_broadaddr, + struct ifreq.ifr_addr, + struct ifreq.ifr_addr.sa_len], , , + [AC_INCLUDES_DEFAULT + #if HAVE_SYS_SOCKET_H + #include + #endif + #if HAVE_NET_IF_H + #include + #endif]) + + dnl Check for endianness. + dnl AC_C_BIGENDIAN is done by gnulib. + + AC_CACHE_CHECK([for __attribute__ ((__aligned__ (expr)))], + [emacs_cv_attribute_aligned], + [AC_COMPILE_IFELSE( + [AC_LANG_PROGRAM( + [[char __attribute__ ((__aligned__ (1 << 3))) c;]], + [[]])], + [emacs_cv_attribute_aligned=yes], + [emacs_cv_attribute_aligned=no])]) + if test $emacs_cv_attribute_aligned = yes; then + AC_DEFINE([HAVE_ATTRIBUTE_ALIGNED], 1, + [Define to 1 if GCC-style __attribute__ ((__aligned__ (expr))) works.]) + fi + + dnl check for Make feature + dnl AC_PROG_MAKE_SET is done by Automake. + + DEPFLAGS= + MKDEPDIR=":" + deps_frag=deps.mk + dnl check for GNU Make if we have GCC and autodepend is on. + if test "$GCC" = yes && test "$ac_enable_autodepend" = yes; then + AC_MSG_CHECKING([whether we are using GNU Make]) + HAVE_GNU_MAKE=no + testval=`${MAKE-make} --version 2>/dev/null | grep 'GNU Make'` + if test "x$testval" != x; then + HAVE_GNU_MAKE=yes + else + ac_enable_autodepend=no + fi + AC_MSG_RESULT([$HAVE_GNU_MAKE]) + if test $HAVE_GNU_MAKE = yes; then + AC_MSG_CHECKING([whether gcc understands -MMD -MF]) + SAVE_CFLAGS="$CFLAGS" + CFLAGS="$CFLAGS -MMD -MF deps.d -MP" + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])], , ac_enable_autodepend=no) + CFLAGS="$SAVE_CFLAGS" + test -f deps.d || ac_enable_autodepend=no + rm -rf deps.d + AC_MSG_RESULT([$ac_enable_autodepend]) + fi + if test $ac_enable_autodepend = yes; then + DEPFLAGS='-MMD -MF ${DEPDIR}/$*.d -MP' + ## MKDIR_P is documented (see AC_PROG_MKDIR_P) to be parallel-safe. + MKDEPDIR='${MKDIR_P} ${DEPDIR}' + deps_frag=autodeps.mk + fi + fi + deps_frag=$srcdir/src/$deps_frag + AC_SUBST(MKDEPDIR) + AC_SUBST(DEPFLAGS) + AC_SUBST_FILE(deps_frag) + + + lisp_frag=$srcdir/src/lisp.mk + AC_SUBST_FILE(lisp_frag) + + + dnl checks for operating system services + AC_SYS_LONG_FILE_NAMES + + #### Choose a window system. + + AC_PATH_X + if test "$no_x" = yes; then + window_system=none + else + window_system=x11 + fi + + LD_SWITCH_X_SITE_RPATH= + if test "${x_libraries}" != NONE; then + if test -n "${x_libraries}"; then + LD_SWITCH_X_SITE=-L`echo ${x_libraries} | sed -e "s/:/ -L/g"` + LD_SWITCH_X_SITE_RPATH=-Wl,-rpath,`echo ${x_libraries} | sed -e "s/:/ -Wl,-rpath,/g"` + fi + x_default_search_path="" + x_search_path=${x_libraries} + if test -z "${x_search_path}"; then + x_search_path=/usr/lib + fi + for x_library in `echo ${x_search_path}: | \ + sed -e "s/:/ /g" -e p -e "s:/lib[[^ /]]* :/share :g"`; do + x_search_path="\ + ${x_library}/X11/%L/%T/%N%C%S:\ + ${x_library}/X11/%l/%T/%N%C%S:\ + ${x_library}/X11/%T/%N%C%S:\ + ${x_library}/X11/%L/%T/%N%S:\ + ${x_library}/X11/%l/%T/%N%S:\ + ${x_library}/X11/%T/%N%S" + if test x"${x_default_search_path}" = x; then + x_default_search_path=${x_search_path} + else + x_default_search_path="${x_search_path}:${x_default_search_path}" + fi + done + fi + AC_SUBST(LD_SWITCH_X_SITE_RPATH) + + if test "${x_includes}" != NONE && test -n "${x_includes}"; then + C_SWITCH_X_SITE="$isystem"`echo ${x_includes} | sed -e "s/:/ $isystem/g"` + fi + + if test x"${x_includes}" = x; then + bitmapdir=/usr/include/X11/bitmaps + else + # accumulate include directories that have X11 bitmap subdirectories + bmd_acc="dummyval" + for bmd in `echo ${x_includes} | sed -e "s/:/ /g"`; do + if test -d "${bmd}/X11/bitmaps"; then + bmd_acc="${bmd_acc}:${bmd}/X11/bitmaps" + fi + if test -d "${bmd}/bitmaps"; then + bmd_acc="${bmd_acc}:${bmd}/bitmaps" + fi + done + if test ${bmd_acc} != "dummyval"; then + bitmapdir=`echo ${bmd_acc} | sed -e "s/^dummyval://"` + fi + fi + + HAVE_NS=no + NS_IMPL_COCOA=no + NS_IMPL_GNUSTEP=no + tmp_CPPFLAGS="$CPPFLAGS" + tmp_CFLAGS="$CFLAGS" + CPPFLAGS="$CPPFLAGS -x objective-c" + CFLAGS="$CFLAGS -x objective-c" + TEMACS_LDFLAGS2="\${LDFLAGS}" + GNU_OBJC_CFLAGS= + if test "${with_ns}" != no; then + if test "${opsys}" = darwin; then + NS_IMPL_COCOA=yes + ns_appdir=`pwd`/nextstep/Emacs.app + ns_appbindir=${ns_appdir}/Contents/MacOS + ns_appresdir=${ns_appdir}/Contents/Resources + ns_appsrc=${srcdir}/nextstep/Cocoa/Emacs.base + elif test -f $GNUSTEP_CONFIG_FILE; then + NS_IMPL_GNUSTEP=yes + ns_appdir=`pwd`/nextstep/Emacs.app + ns_appbindir=${ns_appdir} + ns_appresdir=${ns_appdir}/Resources + ns_appsrc=${srcdir}/nextstep/GNUstep/Emacs.base + dnl FIXME sourcing this several times in subshells seems inefficient. + GNUSTEP_SYSTEM_HEADERS="$(. $GNUSTEP_CONFIG_FILE; echo $GNUSTEP_SYSTEM_HEADERS)" + GNUSTEP_SYSTEM_LIBRARIES="$(. $GNUSTEP_CONFIG_FILE; echo $GNUSTEP_SYSTEM_LIBRARIES)" + dnl I seemed to need these as well with GNUstep-startup 0.25. + GNUSTEP_LOCAL_HEADERS="$(. $GNUSTEP_CONFIG_FILE; echo $GNUSTEP_LOCAL_HEADERS)" + GNUSTEP_LOCAL_LIBRARIES="$(. $GNUSTEP_CONFIG_FILE; echo $GNUSTEP_LOCAL_LIBRARIES)" + test "x${GNUSTEP_LOCAL_HEADERS}" != "x" && \ + GNUSTEP_LOCAL_HEADERS="-I${GNUSTEP_LOCAL_HEADERS}" + test "x${GNUSTEP_LOCAL_LIBRARIES}" != "x" && \ + GNUSTEP_LOCAL_LIBRARIES="-L${GNUSTEP_LOCAL_LIBRARIES}" + CPPFLAGS="$CPPFLAGS -I${GNUSTEP_SYSTEM_HEADERS} ${GNUSTEP_LOCAL_HEADERS}" + CFLAGS="$CFLAGS -I${GNUSTEP_SYSTEM_HEADERS} ${GNUSTEP_LOCAL_HEADERS}" + LDFLAGS="$LDFLAGS -L${GNUSTEP_SYSTEM_LIBRARIES} ${GNUSTEP_LOCAL_LIBRARIES}" + LIB_STANDARD= + START_FILES= + TEMACS_LDFLAGS2= + dnl GNUstep defines BASE_NATIVE_OBJC_EXCEPTIONS to 0 or 1. + dnl If they had chosen to either define it or not, we could have + dnl just used AC_CHECK_DECL here. + AC_CACHE_CHECK(if GNUstep defines BASE_NATIVE_OBJC_EXCEPTIONS, + emacs_cv_objc_exceptions, + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include ]], + [[#if defined BASE_NATIVE_OBJC_EXCEPTIONS && BASE_NATIVE_OBJC_EXCEPTIONS > 0 + 1; + #else + fail; + #endif]])], emacs_cv_objc_exceptions=yes, emacs_cv_objc_exceptions=no ) ) + if test $emacs_cv_objc_exceptions = yes; then + dnl _NATIVE_OBJC_EXCEPTIONS is used by the GNUstep headers. + AC_DEFINE(_NATIVE_OBJC_EXCEPTIONS, 1, + [Define if GNUstep uses ObjC exceptions.]) + GNU_OBJC_CFLAGS="-fobjc-exceptions" + fi + fi + + dnl This is only used while we test the NS headers, it gets reset below. + CFLAGS="$CFLAGS $GNU_OBJC_CFLAGS" + + AC_CHECK_HEADER([AppKit/AppKit.h], [HAVE_NS=yes], + [AC_MSG_ERROR([`--with-ns' was specified, but the include + files are missing or cannot be compiled.])]) + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include ], + [NSInteger i;])], + ns_have_nsinteger=yes, + ns_have_nsinteger=no) + if test $ns_have_nsinteger = yes; then + AC_DEFINE(NS_HAVE_NSINTEGER, 1, [Define to 1 if `NSInteger' is defined.]) + fi + fi + AC_SUBST(TEMACS_LDFLAGS2) + + INSTALL_ARCH_INDEP_EXTRA=install-etc + ns_self_contained=no + ns_frag=/dev/null + NS_OBJ= + NS_OBJC_OBJ= + if test "${HAVE_NS}" = yes; then + if test "$with_toolkit_scroll_bars" = "no"; then + AC_MSG_ERROR([Non-toolkit scroll bars are not implemented for Nextstep.]) + fi + + window_system=nextstep + with_xft=no + # set up packaging dirs + if test "${EN_NS_SELF_CONTAINED}" = yes; then + ns_self_contained=yes + prefix=${ns_appresdir} + exec_prefix=${ns_appbindir} + dnl This one isn't really used, only archlibdir is. + libexecdir="\${ns_appbindir}/libexec" + archlibdir="\${ns_appbindir}/libexec" + docdir="\${ns_appresdir}/etc" + etcdir="\${ns_appresdir}/etc" + dnl FIXME maybe set datarootdir instead. + dnl That would also get applications, icons, man. + infodir="\${ns_appresdir}/info" + mandir="\${ns_appresdir}/man" + lispdir="\${ns_appresdir}/lisp" + leimdir="\${ns_appresdir}/leim" + INSTALL_ARCH_INDEP_EXTRA= + fi + ns_frag=$srcdir/src/ns.mk + NS_OBJ="fontset.o fringe.o image.o" + NS_OBJC_OBJ="nsterm.o nsfns.o nsmenu.o nsselect.o nsimage.o nsfont.o" + fi + CFLAGS="$tmp_CFLAGS" + CPPFLAGS="$tmp_CPPFLAGS" + AC_SUBST(INSTALL_ARCH_INDEP_EXTRA) + AC_SUBST(ns_self_contained) + AC_SUBST(NS_OBJ) + AC_SUBST(NS_OBJC_OBJ) + AC_SUBST(LIB_STANDARD) + AC_SUBST_FILE(ns_frag) + + case "${window_system}" in + x11 ) + HAVE_X_WINDOWS=yes + HAVE_X11=yes + case "${with_x_toolkit}" in + athena | lucid ) USE_X_TOOLKIT=LUCID ;; + motif ) USE_X_TOOLKIT=MOTIF ;; + gtk ) with_gtk=yes + dnl Don't set this for GTK. A lot of tests below assumes Xt when + dnl USE_X_TOOLKIT is set. + USE_X_TOOLKIT=none ;; + gtk3 ) with_gtk3=yes + USE_X_TOOLKIT=none ;; + no ) USE_X_TOOLKIT=none ;; + dnl If user did not say whether to use a toolkit, make this decision later: + dnl use the toolkit if we have gtk, or X11R5 or newer. + * ) USE_X_TOOLKIT=maybe ;; + esac + ;; + nextstep | none ) + HAVE_X_WINDOWS=no + HAVE_X11=no + USE_X_TOOLKIT=none + ;; + esac + + if test "$window_system" = none && test "X$with_x" != "Xno"; then + AC_CHECK_PROG(HAVE_XSERVER, X, true, false) + if test "$HAVE_XSERVER" = true || + test -n "$DISPLAY" || + test "`echo /usr/lib/libX11.*`" != "/usr/lib/libX11.*"; then + AC_MSG_ERROR([You seem to be running X, but no X development libraries + were found. You should install the relevant development files for X + and for the toolkit you want, such as Gtk+, Lesstif or Motif. Also make + sure you have development files for image handling, i.e. + tiff, gif, jpeg, png and xpm. + If you are sure you want Emacs compiled without X window support, pass + --without-x + to configure.]) + fi + fi + + ### If we're using X11, we should use the X menu package. + HAVE_MENUS=no + case ${HAVE_X11} in + yes ) HAVE_MENUS=yes ;; + esac + + # Does the opsystem file prohibit the use of the GNU malloc? + # Assume not, until told otherwise. + GNU_MALLOC=yes + + AC_CACHE_CHECK( + [whether malloc is Doug Lea style], + [emacs_cv_var_doug_lea_malloc], + [AC_LINK_IFELSE( + [AC_LANG_PROGRAM( + [[#include + static void hook (void) {}]], + [[malloc_set_state (malloc_get_state ()); + __after_morecore_hook = hook; + __malloc_initialize_hook = hook;]])], + [emacs_cv_var_doug_lea_malloc=yes], + [emacs_cv_var_doug_lea_malloc=no])]) + doug_lea_malloc=$emacs_cv_var_doug_lea_malloc + + + dnl See comments in aix4-2.h about maybe using system malloc there. + system_malloc=no + case "$opsys" in + ## darwin ld insists on the use of malloc routines in the System framework. + darwin|sol2-10) system_malloc=yes ;; + esac + + if test "${system_malloc}" = "yes"; then + AC_DEFINE(SYSTEM_MALLOC, 1, [Define to use system malloc.]) + GNU_MALLOC=no + GNU_MALLOC_reason=" + (The GNU allocators don't work with this system configuration.)" + GMALLOC_OBJ= + VMLIMIT_OBJ= + else + test "$doug_lea_malloc" != "yes" && GMALLOC_OBJ=gmalloc.o + VMLIMIT_OBJ=vm-limit.o + fi + AC_SUBST(GMALLOC_OBJ) + AC_SUBST(VMLIMIT_OBJ) + + if test "$doug_lea_malloc" = "yes" ; then + if test "$GNU_MALLOC" = yes ; then + GNU_MALLOC_reason=" + (Using Doug Lea's new malloc from the GNU C Library.)" + fi + AC_DEFINE(DOUG_LEA_MALLOC, 1, + [Define to 1 if you are using the GNU C Library.]) + + ## Use mmap directly for allocating larger buffers. + ## FIXME this comes from src/s/{gnu,gnu-linux}.h: + ## #ifdef DOUG_LEA_MALLOC; #undef REL_ALLOC; #endif + ## Does the AC_FUNC_MMAP test below make this check unnecessary? + case "$opsys" in + gnu*) REL_ALLOC=no ;; + esac + fi + + if test x"${REL_ALLOC}" = x; then + REL_ALLOC=${GNU_MALLOC} + fi + + use_mmap_for_buffers=no + case "$opsys" in + cygwin|freebsd|irix6-5) use_mmap_for_buffers=yes ;; + esac + + AC_FUNC_MMAP + if test $use_mmap_for_buffers = yes; then + AC_DEFINE(USE_MMAP_FOR_BUFFERS, 1, [Define to use mmap to allocate buffer text.]) + REL_ALLOC=no + fi + + LIBS="$LIBS_SYSTEM $LIBS" + + dnl If found, this defines HAVE_LIBDNET, which m/pmax.h checks, + dnl and also adds -ldnet to LIBS, which Autoconf uses for checks. + AC_CHECK_LIB(dnet, dnet_ntoa) + dnl This causes -lresolv to get used in subsequent tests, + dnl which causes failures on some systems such as HPUX 9. + dnl AC_CHECK_LIB(resolv, gethostbyname) + + dnl FIXME replace main with a function we actually want from this library. + AC_CHECK_LIB(Xbsd, main, LD_SWITCH_X_SITE="$LD_SWITCH_X_SITE -lXbsd") + + dnl Check if pthreads is available. + LIB_PTHREAD= + AC_CHECK_HEADERS_ONCE(pthread.h) + if test "$ac_cv_header_pthread_h"; then + dnl gmalloc.c uses pthread_atfork, which is not available on older-style + dnl hosts such as MirBSD 10, so test for pthread_atfork instead of merely + dnl testing for pthread_self if Emacs uses gmalloc.c. + if test "$GMALLOC_OBJ" = gmalloc.o; then + emacs_pthread_function=pthread_atfork + else + emacs_pthread_function=pthread_self + fi + AC_CHECK_LIB(pthread, $emacs_pthread_function, HAVE_PTHREAD=yes) + fi + if test "$HAVE_PTHREAD" = yes; then + case "${canonical}" in + *-hpux*) ;; + *) LIB_PTHREAD="-lpthread" + LIBS="$LIB_PTHREAD $LIBS" ;; + esac + AC_DEFINE(HAVE_PTHREAD, 1, [Define to 1 if you have pthread (-lpthread).]) + fi + AC_SUBST([LIB_PTHREAD]) + + AC_CHECK_LIB(pthreads, cma_open) + + ## Note: when using cpp in s/aix4.2.h, this definition depended on + ## HAVE_LIBPTHREADS. That was not defined earlier in configure when + ## the system file was sourced. Hence the value of LIBS_SYSTEM + ## added to LIBS in configure would never contain the pthreads part, + ## but the value used in Makefiles might. FIXME? + ## + ## -lpthreads seems to be necessary for Xlib in X11R6, and should + ## be harmless on older versions of X where it happens to exist. + test "$opsys" = "aix4-2" && \ + test $ac_cv_lib_pthreads_cma_open = yes && \ + LIBS_SYSTEM="$LIBS_SYSTEM -lpthreads" + + dnl Check for need for bigtoc support on IBM AIX + + case ${host_os} in + aix*) + AC_CACHE_CHECK([for -bbigtoc option], [gdb_cv_bigtoc], [ + case $GCC in + yes) gdb_cv_bigtoc=-Wl,-bbigtoc ;; + *) gdb_cv_bigtoc=-bbigtoc ;; + esac + + LDFLAGS=$LDFLAGS\ $gdb_cv_bigtoc + AC_LINK_IFELSE([AC_LANG_PROGRAM([[]], [[int i;]])], [], [gdb_cv_bigtoc=]) + ]) + ;; + esac + + # Change CFLAGS and CPPFLAGS temporarily so that C_SWITCH_X_SITE gets + # used for the tests that follow. We set them back to REAL_CFLAGS and + # REAL_CPPFLAGS later on. + + REAL_CFLAGS="$CFLAGS" + REAL_CPPFLAGS="$CPPFLAGS" + + if test "${HAVE_X11}" = "yes"; then + DEFS="$C_SWITCH_X_SITE $DEFS" + LDFLAGS="$LDFLAGS $LD_SWITCH_X_SITE" + LIBS="-lX11 $LIBS" + CFLAGS="$C_SWITCH_X_SITE $CFLAGS" + CPPFLAGS="$C_SWITCH_X_SITE $CPPFLAGS" + + # On Solaris, arrange for LD_RUN_PATH to point to the X libraries for tests. + # This is handled by LD_SWITCH_X_SITE_RPATH during the real build, + # but it's more convenient here to set LD_RUN_PATH since this + # also works on hosts that don't understand LD_SWITCH_X_SITE_RPATH. + if test "${x_libraries}" != NONE && test -n "${x_libraries}"; then + LD_RUN_PATH=$x_libraries${LD_RUN_PATH+:}$LD_RUN_PATH + export LD_RUN_PATH + fi + + if test "${opsys}" = "gnu-linux"; then + AC_MSG_CHECKING(whether X on GNU/Linux needs -b to link) + AC_LINK_IFELSE([AC_LANG_PROGRAM([[]], + [[XOpenDisplay ("foo");]])], + [xgnu_linux_first_failure=no], + [xgnu_linux_first_failure=yes]) + if test "${xgnu_linux_first_failure}" = "yes"; then + OLD_LD_SWITCH_X_SITE="$LD_SWITCH_X_SITE" + OLD_C_SWITCH_X_SITE="$C_SWITCH_X_SITE" + OLD_CPPFLAGS="$CPPFLAGS" + OLD_LIBS="$LIBS" + LD_SWITCH_X_SITE="$LD_SWITCH_X_SITE -b i486-linuxaout" + C_SWITCH_X_SITE="$C_SWITCH_X_SITE -b i486-linuxaout" + CPPFLAGS="$CPPFLAGS -b i486-linuxaout" + LIBS="$LIBS -b i486-linuxaout" + AC_LINK_IFELSE([AC_LANG_PROGRAM([[]], + [[XOpenDisplay ("foo");]])], + [xgnu_linux_second_failure=no], + [xgnu_linux_second_failure=yes]) + if test "${xgnu_linux_second_failure}" = "yes"; then + # If we get the same failure with -b, there is no use adding -b. + # So take it out. This plays safe. + LD_SWITCH_X_SITE="$OLD_LD_SWITCH_X_SITE" + C_SWITCH_X_SITE="$OLD_C_SWITCH_X_SITE" + CPPFLAGS="$OLD_CPPFLAGS" + LIBS="$OLD_LIBS" + AC_MSG_RESULT(no) + else + AC_MSG_RESULT(yes) + fi + else + AC_MSG_RESULT(no) + fi + fi + + # Reportedly, some broken Solaris systems have XKBlib.h but are missing + # header files included from there. + AC_MSG_CHECKING(for Xkb) + AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include + #include ]], + [[XkbDescPtr kb = XkbGetKeyboard (0, XkbAllComponentsMask, XkbUseCoreKbd);]])], + emacs_xkb=yes, emacs_xkb=no) + AC_MSG_RESULT($emacs_xkb) + if test $emacs_xkb = yes; then + AC_DEFINE(HAVE_XKBGETKEYBOARD, 1, [Define to 1 if you have the XkbGetKeyboard function.]) + fi + + AC_CHECK_FUNCS(XrmSetDatabase XScreenResourceString \ + XScreenNumberOfScreen) + fi + + if test "${window_system}" = "x11"; then + AC_MSG_CHECKING(X11 version 6) + AC_CACHE_VAL(emacs_cv_x11_version_6, + [AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include ]], + [[#if XlibSpecificationRelease < 6 + fail; + #endif + ]])], emacs_cv_x11_version_6=yes, emacs_cv_x11_version_6=no)]) + if test $emacs_cv_x11_version_6 = yes; then + AC_MSG_RESULT(6 or newer) + AC_DEFINE(HAVE_X11R6, 1, + [Define to 1 if you have the X11R6 or newer version of Xlib.]) + AC_DEFINE(HAVE_X_I18N, 1, [Define if you have usable i18n support.]) + ## inoue@ainet.or.jp says Solaris has a bug related to X11R6-style + ## XIM support. + case "$opsys" in + sol2-*) : ;; + *) AC_DEFINE(HAVE_X11R6_XIM, 1, + [Define if you have usable X11R6-style XIM support.]) + ;; + esac + else + AC_MSG_RESULT(before 6) + fi + fi + + + ### Use -lrsvg-2 if available, unless `--with-rsvg=no' is specified. + HAVE_RSVG=no + if test "${HAVE_X11}" = "yes" || test "${HAVE_NS}" = "yes"; then + if test "${with_rsvg}" != "no"; then + RSVG_REQUIRED=2.11.0 + RSVG_MODULE="librsvg-2.0 >= $RSVG_REQUIRED" + + PKG_CHECK_MODULES(RSVG, $RSVG_MODULE, HAVE_RSVG=yes, :) + AC_SUBST(RSVG_CFLAGS) + AC_SUBST(RSVG_LIBS) + + if test $HAVE_RSVG = yes; then + AC_DEFINE(HAVE_RSVG, 1, [Define to 1 if using librsvg.]) + CFLAGS="$CFLAGS $RSVG_CFLAGS" + LIBS="$RSVG_LIBS $LIBS" + fi + fi + fi + + HAVE_IMAGEMAGICK=no + if test "${HAVE_X11}" = "yes"; then + if test "${with_imagemagick}" != "no"; then + ## 6.2.8 is the earliest version known to work, but earlier versions + ## might work - let us know if you find one. + ## 6.0.7 does not work. See bug#7955. + IMAGEMAGICK_MODULE="Wand >= 6.2.8" + PKG_CHECK_MODULES(IMAGEMAGICK, $IMAGEMAGICK_MODULE, HAVE_IMAGEMAGICK=yes, :) + AC_SUBST(IMAGEMAGICK_CFLAGS) + AC_SUBST(IMAGEMAGICK_LIBS) + + if test $HAVE_IMAGEMAGICK = yes; then + AC_DEFINE(HAVE_IMAGEMAGICK, 1, [Define to 1 if using imagemagick.]) + CFLAGS="$CFLAGS $IMAGEMAGICK_CFLAGS" + LIBS="$IMAGEMAGICK_LIBS $LIBS" + AC_CHECK_FUNCS(MagickExportImagePixels MagickMergeImageLayers) + fi + fi + fi + + + HAVE_GTK=no + GTK_OBJ= + if test "${with_gtk3}" = "yes"; then + GLIB_REQUIRED=2.28 + GTK_REQUIRED=3.0 + GTK_MODULES="gtk+-3.0 >= $GTK_REQUIRED glib-2.0 >= $GLIB_REQUIRED" + + dnl Checks for libraries. + PKG_CHECK_MODULES(GTK, $GTK_MODULES, pkg_check_gtk=yes, pkg_check_gtk=no) + if test "$pkg_check_gtk" = "no" && test "$USE_X_TOOLKIT" != "maybe"; then + AC_MSG_ERROR($GTK_PKG_ERRORS) + fi + AC_DEFINE(HAVE_GTK3, 1, [Define to 1 if using GTK 3 or later.]) + GTK_OBJ=emacsgtkfixed.o + fi + + if test "$pkg_check_gtk" != "yes"; then + HAVE_GTK=no + if test "${with_gtk}" = "yes" || test "$USE_X_TOOLKIT" = "maybe"; then + GLIB_REQUIRED=2.10 + GTK_REQUIRED=2.10 + GTK_MODULES="gtk+-2.0 >= $GTK_REQUIRED glib-2.0 >= $GLIB_REQUIRED" + + dnl Checks for libraries. + PKG_CHECK_MODULES(GTK, $GTK_MODULES, pkg_check_gtk=yes, pkg_check_gtk=no) + if test "$pkg_check_gtk" = "no" && test "$USE_X_TOOLKIT" != "maybe"; then + AC_MSG_ERROR($GTK_PKG_ERRORS) + fi + fi + fi + + if test x"$pkg_check_gtk" = xyes; then + + AC_SUBST(GTK_CFLAGS) + AC_SUBST(GTK_LIBS) + C_SWITCH_X_SITE="$C_SWITCH_X_SITE $GTK_CFLAGS" + CFLAGS="$CFLAGS $GTK_CFLAGS" + LIBS="$GTK_LIBS $LIBS" + dnl Try to compile a simple GTK program. + GTK_COMPILES=no + AC_CHECK_FUNCS(gtk_main, GTK_COMPILES=yes) + if test "${GTK_COMPILES}" != "yes"; then + if test "$USE_X_TOOLKIT" != "maybe"; then + AC_MSG_ERROR([Gtk+ wanted, but it does not compile, see config.log. Maybe some x11-devel files missing?]); + fi + else + HAVE_GTK=yes + AC_DEFINE(USE_GTK, 1, [Define to 1 if using GTK.]) + GTK_OBJ="gtkutil.o $GTK_OBJ" + USE_X_TOOLKIT=none + if $PKG_CONFIG --atleast-version=2.10 gtk+-2.0; then + : + else + AC_MSG_WARN([[Your version of Gtk+ will have problems with + closing open displays. This is no problem if you just use + one display, but if you use more than one and close one of them + Emacs may crash.]]) + sleep 3 + fi + fi + + fi + AC_SUBST(GTK_OBJ) + + + if test "${HAVE_GTK}" = "yes"; then + + dnl GTK scrollbars resemble toolkit scrollbars a lot, so to avoid + dnl a lot if #ifdef:s, say we have toolkit scrollbars. + if test "$with_toolkit_scroll_bars" != no; then + with_toolkit_scroll_bars=yes + fi + + dnl Check if we have the old file selection dialog declared and + dnl in the link library. In 2.x it may be in the library, + dnl but not declared if deprecated featured has been selected out. + dnl AC_CHECK_DECL checks for a macro, so check for GTK_TYPE_FILE_SELECTION. + HAVE_GTK_FILE_SELECTION=no + AC_CHECK_DECL(GTK_TYPE_FILE_SELECTION, HAVE_GTK_FILE_SELECTION=yes, + HAVE_GTK_FILE_SELECTION=no, [AC_INCLUDES_DEFAULT + #include ]) + if test "$HAVE_GTK_FILE_SELECTION" = yes; then + AC_CHECK_FUNCS(gtk_file_selection_new) + fi + + + dnl Check for functions introduced in 2.14 and later. + AC_CHECK_FUNCS(gtk_widget_get_window gtk_widget_set_has_window \ + gtk_dialog_get_action_area gtk_widget_get_sensitive \ + gtk_widget_get_mapped gtk_adjustment_get_page_size \ + gtk_orientable_set_orientation \ + gtk_window_set_has_resize_grip) + fi + ++ ++HAVE_XWIDGETS=no ++HAVE_WEBKIT=no ++HAVE_GOOCANVAS=no ++HAVE_CLUTTER=no ++HAVE_GIR=no ++ ++if test "${with_xwidgets}" != "no"; then ++ echo "xwidgets enabled, checking webkit, and others" ++ HAVE_XWIDGETS=yes ++ AC_DEFINE(HAVE_XWIDGETS, 1, [Define to 1 if you have xwidgets support.]) ++#xwidgets ++#TODO ++# - enable only if gtk/gtk3 enabled ++# - webkit, goocanvas, clutter ++# - only webkit_osr is good so remove plain webkit laterish ++ ++#webkit version for gtk3. ++ WEBKIT_REQUIRED=1.4.0 ++ WEBKIT_MODULES="webkitgtk-3.0 >= $WEBKIT_REQUIRED" ++ ++ if test "${with_gtk3}" = "yes"; then ++ PKG_CHECK_MODULES(WEBKIT, $WEBKIT_MODULES, HAVE_WEBKIT=yes, HAVE_WEBKIT=no) ++ if test $HAVE_WEBKIT = yes; then ++ AC_DEFINE(HAVE_WEBKIT_OSR, 1, [Define to 1 if you have webkit_osr support.]) ++ fi ++ fi ++ ++ if test "${with_xwdemo}" = "yes"; then ++#clutter and goocanvas are just proof of concept so disable for now ++ CLUTTER_REQUIRED=1.0.0 ++ CLUTTER_MODULES="clutter-gtk-1.0 >= $CLUTTER_REQUIRED" ++ ++ PKG_CHECK_MODULES(CLUTTER, $CLUTTER_MODULES, HAVE_CLUTTER=yes, HAVE_CLUTTER=no) ++ if test $HAVE_CLUTTER = yes; then ++ AC_DEFINE(HAVE_CLUTTER, 1, [Define to 1 if you have clutter support.]) ++ fi ++ ++ ++ GOOCANVAS_REQUIRED=1.4.0 ++ GOOCANVAS_MODULES="goocanvasgtk-3.0 >= $GOOCANVAS_REQUIRED" ++ ++ PKG_CHECK_MODULES(GOOCANVAS, $GOOCANVAS_MODULES, HAVE_GOOCANVAS=yes, HAVE_GOOCANVAS=no) ++ if test $HAVE_GOOCANVAS = yes; then ++ AC_DEFINE(HAVE_GOOCANVAS, 1, [Define to 1 if you have goocanvas support.]) ++ fi ++ fi ++ ++ GIR_REQUIRED=1.32.1 ++ GIR_MODULES="gobject-introspection-1.0 >= $GIR_REQUIRED" ++ PKG_CHECK_MODULES(GIR, $GIR_MODULES, HAVE_GIR=yes, HAVE_GIR=no) ++ if test $HAVE_GIR = yes; then ++ AC_DEFINE(HAVE_GIR, 1, [Define to 1 if you have GIR support.]) ++ fi ++ ++ ++fi ++ ++ + dnl D-Bus has been tested under GNU/Linux only. Must be adapted for + dnl other platforms. + HAVE_DBUS=no + DBUS_OBJ= + if test "${with_dbus}" = "yes"; then + PKG_CHECK_MODULES(DBUS, dbus-1 >= 1.0, HAVE_DBUS=yes, HAVE_DBUS=no) + if test "$HAVE_DBUS" = yes; then + LIBS="$LIBS $DBUS_LIBS" + AC_DEFINE(HAVE_DBUS, 1, [Define to 1 if using D-Bus.]) + dnl dbus_watch_get_unix_fd has been introduced in D-Bus 1.1.1. + dnl dbus_type_is_valid and dbus_validate_* have been introduced in + dnl D-Bus 1.5.12. + AC_CHECK_FUNCS(dbus_watch_get_unix_fd \ + dbus_type_is_valid \ + dbus_validate_bus_name \ + dbus_validate_path \ + dbus_validate_interface \ + dbus_validate_member) + DBUS_OBJ=dbusbind.o + fi + fi + AC_SUBST(DBUS_OBJ) + + dnl GSettings has been tested under GNU/Linux only. + HAVE_GSETTINGS=no + if test "${HAVE_X11}" = "yes" && test "${with_gsettings}" = "yes"; then + PKG_CHECK_MODULES(GSETTINGS, gio-2.0 >= 2.26, HAVE_GSETTINGS=yes, HAVE_GSETTINGS=no) + if test "$HAVE_GSETTINGS" = "yes"; then + AC_DEFINE(HAVE_GSETTINGS, 1, [Define to 1 if using GSettings.]) + SETTINGS_CFLAGS="$GSETTINGS_CFLAGS" + SETTINGS_LIBS="$GSETTINGS_LIBS" + fi + fi + + dnl GConf has been tested under GNU/Linux only. + dnl The version is really arbitrary, it is about the same age as Gtk+ 2.6. + HAVE_GCONF=no + if test "${HAVE_X11}" = "yes" && test "${with_gconf}" = "yes"; then + PKG_CHECK_MODULES(GCONF, gconf-2.0 >= 2.13, HAVE_GCONF=yes, HAVE_GCONF=no) + if test "$HAVE_GCONF" = yes; then + AC_DEFINE(HAVE_GCONF, 1, [Define to 1 if using GConf.]) + dnl Newer GConf doesn't link with g_objects, so this is not defined. + SETTINGS_CFLAGS="$SETTINGS_CFLAGS $GCONF_CFLAGS" + SETTINGS_LIBS="$SETTINGS_LIBS $GCONF_LIBS" + fi + fi + + if test "$HAVE_GSETTINGS" = "yes" || test "$HAVE_GCONF" = "yes"; then + SAVE_CFLAGS="$CFLAGS" + SAVE_LIBS="$LIBS" + CFLAGS="$SETTINGS_CFLAGS $CFLAGS" + LIBS="$SETTINGS_LIBS $LIBS" + AC_CHECK_FUNCS([g_type_init]) + CFLAGS="$SAVE_CFLAGS" + LIBS="$SAVE_LIBS" + fi + AC_SUBST(SETTINGS_CFLAGS) + AC_SUBST(SETTINGS_LIBS) + + + dnl SELinux is available for GNU/Linux only. + HAVE_LIBSELINUX=no + LIBSELINUX_LIBS= + if test "${with_selinux}" = "yes"; then + AC_CHECK_LIB([selinux], [lgetfilecon], HAVE_LIBSELINUX=yes, HAVE_LIBSELINUX=no) + if test "$HAVE_LIBSELINUX" = yes; then + AC_DEFINE(HAVE_LIBSELINUX, 1, [Define to 1 if using SELinux.]) + LIBSELINUX_LIBS=-lselinux + fi + fi + AC_SUBST(LIBSELINUX_LIBS) + + HAVE_GNUTLS=no + HAVE_GNUTLS_CALLBACK_CERTIFICATE_VERIFY=no + if test "${with_gnutls}" = "yes" ; then + PKG_CHECK_MODULES([LIBGNUTLS], [gnutls >= 2.6.6], HAVE_GNUTLS=yes, HAVE_GNUTLS=no) + if test "${HAVE_GNUTLS}" = "yes"; then + AC_DEFINE(HAVE_GNUTLS, 1, [Define if using GnuTLS.]) + fi + + CFLAGS="$CFLAGS $LIBGNUTLS_CFLAGS" + LIBS="$LIBGNUTLS_LIBS $LIBS" + AC_CHECK_FUNCS(gnutls_certificate_set_verify_function, HAVE_GNUTLS_CALLBACK_CERTIFICATE_VERIFY=yes) + + if test "${HAVE_GNUTLS_CALLBACK_CERTIFICATE_VERIFY}" = "yes"; then + AC_DEFINE(HAVE_GNUTLS_CALLBACK_CERTIFICATE_VERIFY, 1, [Define if using GnuTLS certificate verification callbacks.]) + fi + fi + + AC_SUBST(LIBGNUTLS_LIBS) + AC_SUBST(LIBGNUTLS_CFLAGS) + + dnl Do not put whitespace before the #include statements below. + dnl Older compilers (eg sunos4 cc) choke on it. + HAVE_XAW3D=no + LUCID_LIBW= + if test x"${USE_X_TOOLKIT}" = xmaybe || test x"${USE_X_TOOLKIT}" = xLUCID; then + if test "$with_xaw3d" != no; then + AC_MSG_CHECKING(for xaw3d) + AC_CACHE_VAL(emacs_cv_xaw3d, + [AC_LINK_IFELSE([AC_LANG_PROGRAM([[ + #include + #include ]], + [[]])], + [AC_CHECK_LIB(Xaw3d, XawScrollbarSetThumb, + emacs_cv_xaw3d=yes, emacs_cv_xaw3d=no)], + emacs_cv_xaw3d=no)]) + else + emacs_cv_xaw3d=no + fi + if test $emacs_cv_xaw3d = yes; then + AC_MSG_RESULT([yes; using Lucid toolkit]) + USE_X_TOOLKIT=LUCID + HAVE_XAW3D=yes + LUCID_LIBW=-lXaw3d + AC_DEFINE(HAVE_XAW3D, 1, + [Define to 1 if you have the Xaw3d library (-lXaw3d).]) + else + AC_MSG_RESULT(no) + AC_MSG_CHECKING(for libXaw) + AC_CACHE_VAL(emacs_cv_xaw, + [AC_LINK_IFELSE([AC_LANG_PROGRAM([[ + #include + #include ]], + [[]])], + emacs_cv_xaw=yes, + emacs_cv_xaw=no)]) + if test $emacs_cv_xaw = yes; then + AC_MSG_RESULT([yes; using Lucid toolkit]) + USE_X_TOOLKIT=LUCID + LUCID_LIBW=-lXaw + elif test x"${USE_X_TOOLKIT}" = xLUCID; then + AC_MSG_ERROR([Lucid toolkit requires X11/Xaw include files]) + else + AC_MSG_ERROR([No X toolkit could be found. + If you are sure you want Emacs compiled without an X toolkit, pass + --with-x-toolkit=no + to configure. Otherwise, install the development libraries for the toolkit + that you want to use (e.g. Gtk+) and re-run configure.]) + fi + fi + fi + + X_TOOLKIT_TYPE=$USE_X_TOOLKIT + + LIBXTR6= + if test "${USE_X_TOOLKIT}" != "none"; then + AC_MSG_CHECKING(X11 toolkit version) + AC_CACHE_VAL(emacs_cv_x11_toolkit_version_6, + [AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include ]], + [[#if XtSpecificationRelease < 6 + fail; + #endif + ]])], emacs_cv_x11_toolkit_version_6=yes, emacs_cv_x11_toolkit_version_6=no)]) + HAVE_X11XTR6=$emacs_cv_x11_toolkit_version_6 + if test $emacs_cv_x11_toolkit_version_6 = yes; then + AC_MSG_RESULT(6 or newer) + AC_DEFINE(HAVE_X11XTR6, 1, + [Define to 1 if you have the X11R6 or newer version of Xt.]) + LIBXTR6="-lSM -lICE" + case "$opsys" in + ## Use libw.a along with X11R6 Xt. + unixware) LIBXTR6="$LIBXTR6 -lw" ;; + esac + else + AC_MSG_RESULT(before 6) + fi + + dnl If using toolkit, check whether libXmu.a exists. + dnl tranle@intellicorp.com says libXmu.a can need XtMalloc in libXt.a to link. + OLDLIBS="$LIBS" + if test x$HAVE_X11XTR6 = xyes; then + LIBS="-lXt -lSM -lICE $LIBS" + else + LIBS="-lXt $LIBS" + fi + AC_CHECK_LIB(Xmu, XmuConvertStandardSelection) + test $ac_cv_lib_Xmu_XmuConvertStandardSelection = no && LIBS="$OLDLIBS" + dnl ac_cv_lib_Xmu_XmuConvertStandardSelection is also referenced below. + fi + AC_SUBST(LIBXTR6) + + dnl FIXME the logic here seems weird, but this is what cpp was doing. + dnl Why not just test for libxmu in the normal way? + LIBXMU=-lXmu + case $opsys in + ## These systems don't supply Xmu. + hpux* | aix4-2 ) + test "X$ac_cv_lib_Xmu_XmuConvertStandardSelection" != "Xyes" && LIBXMU= + ;; + esac + AC_SUBST(LIBXMU) + + # On Irix 6.5, at least, we need XShapeQueryExtension from -lXext for Xaw3D. + if test "${HAVE_X11}" = "yes"; then + if test "${USE_X_TOOLKIT}" != "none"; then + AC_CHECK_LIB(Xext, XShapeQueryExtension) + fi + fi + + LIBXP= + if test "${USE_X_TOOLKIT}" = "MOTIF"; then + AC_CACHE_CHECK(for Motif version 2.1, emacs_cv_motif_version_2_1, + [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include ]], + [[#if XmVERSION > 2 || (XmVERSION == 2 && XmREVISION >= 1) + int x = 5; + #else + Motif version prior to 2.1. + #endif]])], + emacs_cv_motif_version_2_1=yes, emacs_cv_motif_version_2_1=no)]) + if test $emacs_cv_motif_version_2_1 = yes; then + AC_CHECK_LIB(Xp, XpCreateContext, LIBXP=-lXp) + else + AC_CACHE_CHECK(for LessTif where some systems put it, emacs_cv_lesstif, + # We put this in CFLAGS temporarily to precede other -I options + # that might be in CFLAGS temporarily. + # We put this in CPPFLAGS where it precedes the other -I options. + OLD_CPPFLAGS=$CPPFLAGS + OLD_CFLAGS=$CFLAGS + CPPFLAGS="-I/usr/X11R6/LessTif/Motif1.2/include $CPPFLAGS" + CFLAGS="-I/usr/X11R6/LessTif/Motif1.2/include $CFLAGS" + [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include ]], + [[int x = 5;]])], + emacs_cv_lesstif=yes, emacs_cv_lesstif=no)]) + if test $emacs_cv_lesstif = yes; then + # Make sure this -I option remains in CPPFLAGS after it is set + # back to REAL_CPPFLAGS. + # There is no need to change REAL_CFLAGS, because REAL_CFLAGS does not + # have those other -I options anyway. Ultimately, having this + # directory ultimately in CPPFLAGS will be enough. + REAL_CPPFLAGS="-I/usr/X11R6/LessTif/Motif1.2/include $REAL_CPPFLAGS" + LDFLAGS="-L/usr/X11R6/LessTif/Motif1.2/lib $LDFLAGS" + else + CFLAGS=$OLD_CFLAGS + CPPFLAGS=$OLD_CPPFLAGS + fi + fi + AC_CHECK_HEADER([Xm/BulletinB.h], [], + [AC_MSG_ERROR([Motif toolkit requested but requirements not found.])]) + fi + + dnl Use toolkit scroll bars if configured for GTK or X toolkit and either + dnl using Motif or Xaw3d is available, and unless + dnl --with-toolkit-scroll-bars=no was specified. + + AH_TEMPLATE(USE_TOOLKIT_SCROLL_BARS, + [Define to 1 if we should use toolkit scroll bars.])dnl + USE_TOOLKIT_SCROLL_BARS=no + if test "${with_toolkit_scroll_bars}" != "no"; then + if test "${USE_X_TOOLKIT}" != "none"; then + if test "${USE_X_TOOLKIT}" = "MOTIF"; then + AC_DEFINE(USE_TOOLKIT_SCROLL_BARS) + HAVE_XAW3D=no + USE_TOOLKIT_SCROLL_BARS=yes + elif test "${HAVE_XAW3D}" = "yes" || test "${USE_X_TOOLKIT}" = "LUCID"; then + AC_DEFINE(USE_TOOLKIT_SCROLL_BARS) + USE_TOOLKIT_SCROLL_BARS=yes + fi + elif test "${HAVE_GTK}" = "yes"; then + AC_DEFINE(USE_TOOLKIT_SCROLL_BARS) + USE_TOOLKIT_SCROLL_BARS=yes + elif test "${HAVE_NS}" = "yes"; then + AC_DEFINE(USE_TOOLKIT_SCROLL_BARS) + USE_TOOLKIT_SCROLL_BARS=yes + fi + fi + + dnl See if XIM is available. + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ + #include + #include ]], + [[XIMProc callback;]])], + [HAVE_XIM=yes + AC_DEFINE(HAVE_XIM, 1, [Define to 1 if XIM is available])], + HAVE_XIM=no) + + dnl `--with-xim' now controls only the initial value of use_xim at run time. + + if test "${with_xim}" != "no"; then + AC_DEFINE(USE_XIM, 1, + [Define to 1 if we should use XIM, if it is available.]) + fi + + + if test "${HAVE_XIM}" != "no"; then + late_CFLAGS=$CFLAGS + if test "$GCC" = yes; then + CFLAGS="$CFLAGS --pedantic-errors" + fi + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ + #include + #include ]], + [[Display *display; + XrmDatabase db; + char *res_name; + char *res_class; + XIMProc callback; + XPointer *client_data; + #ifndef __GNUC__ + /* If we're not using GCC, it's probably not XFree86, and this is + probably right, but we can't use something like --pedantic-errors. */ + extern Bool XRegisterIMInstantiateCallback(Display*, XrmDatabase, char*, + char*, XIMProc, XPointer*); + #endif + (void)XRegisterIMInstantiateCallback(display, db, res_name, res_class, callback, + client_data);]])], + [emacs_cv_arg6_star=yes]) + AH_TEMPLATE(XRegisterIMInstantiateCallback_arg6, + [Define to the type of the 6th arg of XRegisterIMInstantiateCallback, + either XPointer or XPointer*.])dnl + if test "$emacs_cv_arg6_star" = yes; then + AC_DEFINE(XRegisterIMInstantiateCallback_arg6, [XPointer*]) + else + AC_DEFINE(XRegisterIMInstantiateCallback_arg6, [XPointer]) + fi + CFLAGS=$late_CFLAGS + fi + + ### Start of font-backend (under any platform) section. + # (nothing here yet -- this is a placeholder) + ### End of font-backend (under any platform) section. + + ### Start of font-backend (under X11) section. + if test "${HAVE_X11}" = "yes"; then + PKG_CHECK_MODULES(FONTCONFIG, fontconfig >= 2.2.0, HAVE_FC=yes, HAVE_FC=no) + + ## Use -lXft if available, unless `--with-xft=no'. + HAVE_XFT=maybe + if test "${HAVE_FC}" = "no" || test "x${with_x}" = "xno"; then + with_xft="no"; + fi + if test "x${with_xft}" != "xno"; then + + PKG_CHECK_MODULES(XFT, xft >= 0.13.0, , HAVE_XFT=no) + ## Because xftfont.c uses XRenderQueryExtension, we also + ## need to link to -lXrender. + HAVE_XRENDER=no + AC_CHECK_LIB(Xrender, XRenderQueryExtension, HAVE_XRENDER=yes) + if test "$HAVE_XFT" != no && test "$HAVE_XRENDER" != no; then + OLD_CPPFLAGS="$CPPFLAGS" + OLD_CFLAGS="$CFLAGS" + OLD_LIBS="$LIBS" + CPPFLAGS="$CPPFLAGS $XFT_CFLAGS" + CFLAGS="$CFLAGS $XFT_CFLAGS" + XFT_LIBS="-lXrender $XFT_LIBS" + LIBS="$XFT_LIBS $LIBS" + AC_CHECK_HEADER(X11/Xft/Xft.h, + AC_CHECK_LIB(Xft, XftFontOpen, HAVE_XFT=yes, , $XFT_LIBS)) + + if test "${HAVE_XFT}" = "yes"; then + AC_DEFINE(HAVE_XFT, 1, [Define to 1 if you have the Xft library.]) + AC_SUBST(XFT_LIBS) + C_SWITCH_X_SITE="$C_SWITCH_X_SITE $XFT_CFLAGS" + else + CPPFLAGS="$OLD_CPPFLAGS" + CFLAGS="$OLD_CFLAGS" + LIBS="$OLD_LIBS" + fi # "${HAVE_XFT}" = "yes" + fi # "$HAVE_XFT" != no + fi # "x${with_xft}" != "xno" + + ## We used to allow building with FreeType and without Xft. + ## However, the ftx font backend driver is not in good shape. + if test "$HAVE_XFT" != "yes"; then + dnl For the "Does Emacs use" message at the end. + HAVE_XFT=no + HAVE_FREETYPE=no + else + dnl Strict linkers fail with + dnl ftfont.o: undefined reference to symbol 'FT_New_Face' + dnl if -lfreetype is not specified. + dnl The following is needed to set FREETYPE_LIBS. + PKG_CHECK_MODULES(FREETYPE, freetype2, HAVE_FREETYPE=yes, + HAVE_FREETYPE=no) + + test "$HAVE_FREETYPE" = "no" && AC_MSG_ERROR(libxft requires libfreetype) + fi + + HAVE_LIBOTF=no + if test "${HAVE_FREETYPE}" = "yes"; then + AC_DEFINE(HAVE_FREETYPE, 1, + [Define to 1 if using the freetype and fontconfig libraries.]) + if test "${with_libotf}" != "no"; then + PKG_CHECK_MODULES(LIBOTF, libotf, HAVE_LIBOTF=yes, + HAVE_LIBOTF=no) + if test "$HAVE_LIBOTF" = "yes"; then + AC_DEFINE(HAVE_LIBOTF, 1, [Define to 1 if using libotf.]) + AC_CHECK_LIB(otf, OTF_get_variation_glyphs, + HAVE_OTF_GET_VARIATION_GLYPHS=yes, + HAVE_OTF_GET_VARIATION_GLYPHS=no) + if test "${HAVE_OTF_GET_VARIATION_GLYPHS}" = "yes"; then + AC_DEFINE(HAVE_OTF_GET_VARIATION_GLYPHS, 1, + [Define to 1 if libotf has OTF_get_variation_glyphs.]) + fi + fi + fi + dnl FIXME should there be an error if HAVE_FREETYPE != yes? + dnl Does the new font backend require it, or can it work without it? + fi + + HAVE_M17N_FLT=no + if test "${HAVE_LIBOTF}" = yes; then + if test "${with_m17n_flt}" != "no"; then + PKG_CHECK_MODULES(M17N_FLT, m17n-flt, HAVE_M17N_FLT=yes, HAVE_M17N_FLT=no) + if test "$HAVE_M17N_FLT" = "yes"; then + AC_DEFINE(HAVE_M17N_FLT, 1, [Define to 1 if using libm17n-flt.]) + fi + fi + fi + else + HAVE_XFT=no + HAVE_FREETYPE=no + HAVE_LIBOTF=no + HAVE_M17N_FLT=no + fi + + ### End of font-backend (under X11) section. + + AC_SUBST(FREETYPE_CFLAGS) + AC_SUBST(FREETYPE_LIBS) + AC_SUBST(FONTCONFIG_CFLAGS) + AC_SUBST(FONTCONFIG_LIBS) + AC_SUBST(LIBOTF_CFLAGS) + AC_SUBST(LIBOTF_LIBS) + AC_SUBST(M17N_FLT_CFLAGS) + AC_SUBST(M17N_FLT_LIBS) + + ### Use -lXpm if available, unless `--with-xpm=no'. + HAVE_XPM=no + LIBXPM= + if test "${HAVE_X11}" = "yes"; then + if test "${with_xpm}" != "no"; then + AC_CHECK_HEADER(X11/xpm.h, + [AC_CHECK_LIB(Xpm, XpmReadFileToPixmap, HAVE_XPM=yes, , -lX11)]) + if test "${HAVE_XPM}" = "yes"; then + AC_MSG_CHECKING(for XpmReturnAllocPixels preprocessor define) + AC_EGREP_CPP(no_return_alloc_pixels, + [#include "X11/xpm.h" + #ifndef XpmReturnAllocPixels + no_return_alloc_pixels + #endif + ], HAVE_XPM=no, HAVE_XPM=yes) + + if test "${HAVE_XPM}" = "yes"; then + AC_MSG_RESULT(yes) + else + AC_MSG_RESULT(no) + fi + fi + fi + + if test "${HAVE_XPM}" = "yes"; then + AC_DEFINE(HAVE_XPM, 1, [Define to 1 if you have the Xpm library (-lXpm).]) + LIBXPM=-lXpm + fi + fi + AC_SUBST(LIBXPM) + + ### Use -ljpeg if available, unless `--with-jpeg=no'. + HAVE_JPEG=no + LIBJPEG= + if test "${HAVE_X11}" = "yes"; then + if test "${with_jpeg}" != "no"; then + dnl Checking for jpeglib.h can lose because of a redefinition of + dnl HAVE_STDLIB_H. + AC_CHECK_HEADER(jerror.h, + [AC_CHECK_LIB(jpeg, jpeg_destroy_compress, HAVE_JPEG=yes)]) + fi + + AH_TEMPLATE(HAVE_JPEG, [Define to 1 if you have the jpeg library (-ljpeg).])dnl + if test "${HAVE_JPEG}" = "yes"; then + AC_DEFINE(HAVE_JPEG) + AC_EGREP_CPP([version= *(6[2-9]|[7-9][0-9])], + [#include + version=JPEG_LIB_VERSION + ], + [AC_DEFINE(HAVE_JPEG)], + [AC_MSG_WARN([libjpeg found, but not version 6b or later]) + HAVE_JPEG=no]) + fi + if test "${HAVE_JPEG}" = "yes"; then + LIBJPEG=-ljpeg + fi + fi + AC_SUBST(LIBJPEG) + + ### Use -lpng if available, unless `--with-png=no'. + HAVE_PNG=no + LIBPNG= + if test "${HAVE_X11}" = "yes"; then + if test "${with_png}" != "no"; then + # Debian unstable as of July 2003 has multiple libpngs, and puts png.h + # in /usr/include/libpng. + AC_CHECK_HEADERS(png.h libpng/png.h, break) + if test "$ac_cv_header_png_h" = yes || test "$ac_cv_header_libpng_png_h" = yes ; then + AC_CHECK_LIB(png, png_get_channels, HAVE_PNG=yes, , -lz -lm) + fi + fi + + if test "${HAVE_PNG}" = "yes"; then + AC_DEFINE(HAVE_PNG, 1, [Define to 1 if you have the png library (-lpng).]) + LIBPNG="-lpng -lz -lm" + + AC_CHECK_DECL(png_longjmp, + [], + [AC_DEFINE(PNG_DEPSTRUCT, [], + [Define to empty to suppress deprecation warnings when building + with --enable-gcc-warnings and with libpng versions before 1.5, + which lack png_longjmp.])], + [[#ifdef HAVE_LIBPNG_PNG_H + # include + #else + # include + #endif + ]]) + fi + fi + AC_SUBST(LIBPNG) + + ### Use -ltiff if available, unless `--with-tiff=no'. + HAVE_TIFF=no + LIBTIFF= + if test "${HAVE_X11}" = "yes"; then + if test "${with_tiff}" != "no"; then + AC_CHECK_HEADER(tiffio.h, + [tifflibs="-lz -lm" + # At least one tiff package requires the jpeg library. + if test "${HAVE_JPEG}" = yes; then tifflibs="-ljpeg $tifflibs"; fi + AC_CHECK_LIB(tiff, TIFFGetVersion, HAVE_TIFF=yes, , $tifflibs)]) + fi + + if test "${HAVE_TIFF}" = "yes"; then + AC_DEFINE(HAVE_TIFF, 1, [Define to 1 if you have the tiff library (-ltiff).]) + dnl FIXME -lz -lm, as per libpng? + LIBTIFF=-ltiff + fi + fi + AC_SUBST(LIBTIFF) + + ### Use -lgif or -lungif if available, unless `--with-gif=no'. + HAVE_GIF=no + LIBGIF= + if test "${HAVE_X11}" = "yes" && test "${with_gif}" != "no"; then + AC_CHECK_HEADER(gif_lib.h, + # EGifPutExtensionLast only exists from version libungif-4.1.0b1. + # Earlier versions can crash Emacs. + [AC_CHECK_LIB(gif, EGifPutExtensionLast, HAVE_GIF=yes, HAVE_GIF=maybe)]) + + if test "$HAVE_GIF" = yes; then + LIBGIF=-lgif + elif test "$HAVE_GIF" = maybe; then + # If gif_lib.h but no libgif, try libungif. + AC_CHECK_LIB(ungif, EGifPutExtensionLast, HAVE_GIF=yes, HAVE_GIF=no) + test "$HAVE_GIF" = yes && LIBGIF=-lungif + fi + + if test "${HAVE_GIF}" = "yes"; then + AC_DEFINE(HAVE_GIF, 1, [Define to 1 if you have a gif (or ungif) library.]) + fi + fi + AC_SUBST(LIBGIF) + + dnl Check for required libraries. + if test "${HAVE_X11}" = "yes"; then + MISSING="" + WITH_NO="" + test "${with_xpm}" != "no" && test "${HAVE_XPM}" != "yes" && + MISSING="libXpm" && WITH_NO="--with-xpm=no" + test "${with_jpeg}" != "no" && test "${HAVE_JPEG}" != "yes" && + MISSING="$MISSING libjpeg" && WITH_NO="$WITH_NO --with-jpeg=no" + test "${with_png}" != "no" && test "${HAVE_PNG}" != "yes" && + MISSING="$MISSING libpng" && WITH_NO="$WITH_NO --with-png=no" + test "${with_gif}" != "no" && test "${HAVE_GIF}" != "yes" && + MISSING="$MISSING libgif/libungif" && WITH_NO="$WITH_NO --with-gif=no" + test "${with_tiff}" != "no" && test "${HAVE_TIFF}" != "yes" && + MISSING="$MISSING libtiff" && WITH_NO="$WITH_NO --with-tiff=no" + + if test "X${MISSING}" != X; then + AC_MSG_ERROR([The following required libraries were not found: + $MISSING + Maybe some development libraries/packages are missing? + If you don't want to link with them give + $WITH_NO + as options to configure]) + fi + fi + + ### Use -lgpm if available, unless `--with-gpm=no'. + HAVE_GPM=no + LIBGPM= + if test "${with_gpm}" != "no"; then + AC_CHECK_HEADER(gpm.h, + [AC_CHECK_LIB(gpm, Gpm_Open, HAVE_GPM=yes)]) + + if test "${HAVE_GPM}" = "yes"; then + AC_DEFINE(HAVE_GPM, 1, [Define to 1 if you have the gpm library (-lgpm).]) + LIBGPM=-lgpm + fi + fi + AC_SUBST(LIBGPM) + + dnl Check for malloc/malloc.h on darwin + AC_CHECK_HEADERS_ONCE(malloc/malloc.h) + + GNUSTEP_CFLAGS= + ### Use NeXTstep API to implement GUI. + if test "${HAVE_NS}" = "yes"; then + AC_DEFINE(HAVE_NS, 1, [Define to 1 if you are using the NeXTstep API, either GNUstep or Cocoa on Mac OS X.]) + if test "${NS_IMPL_COCOA}" = "yes"; then + AC_DEFINE(NS_IMPL_COCOA, 1, [Define to 1 if you are using NS windowing under MacOS X.]) + fi + if test "${NS_IMPL_GNUSTEP}" = "yes"; then + AC_DEFINE(NS_IMPL_GNUSTEP, 1, [Define to 1 if you are using NS windowing under GNUstep.]) + # See also .m.o rule in Makefile.in */ + # FIXME: are all these flags really needed? Document here why. */ + GNUSTEP_CFLAGS="-D_REENTRANT -fPIC -fno-strict-aliasing -I${GNUSTEP_SYSTEM_HEADERS} ${GNUSTEP_LOCAL_HEADERS}" + ## Extra CFLAGS applied to src/*.m files. + GNU_OBJC_CFLAGS="$GNU_OBJC_CFLAGS -fgnu-runtime -Wno-import -fconstant-string-class=NSConstantString -DGNUSTEP_BASE_LIBRARY=1 -DGNU_GUI_LIBRARY=1 -DGNU_RUNTIME=1 -DGSWARN -DGSDIAGNOSE" + fi + # We also have mouse menus. + HAVE_MENUS=yes + OTHER_FILES=ns-app + fi + + + ### Use session management (-lSM -lICE) if available + HAVE_X_SM=no + LIBXSM= + if test "${HAVE_X11}" = "yes"; then + AC_CHECK_HEADER(X11/SM/SMlib.h, + [AC_CHECK_LIB(SM, SmcOpenConnection, HAVE_X_SM=yes, , -lICE)]) + + if test "${HAVE_X_SM}" = "yes"; then + AC_DEFINE(HAVE_X_SM, 1, [Define to 1 if you have the SM library (-lSM).]) + LIBXSM="-lSM -lICE" + case "$LIBS" in + *-lSM*) ;; + *) LIBS="$LIBXSM $LIBS" ;; + esac + fi + fi + AC_SUBST(LIBXSM) + + ### Use libxml (-lxml2) if available + HAVE_LIBXML2=no + if test "${with_xml2}" != "no"; then + ### I'm not sure what the version number should be, so I just guessed. + PKG_CHECK_MODULES(LIBXML2, libxml-2.0 > 2.6.17, HAVE_LIBXML2=yes, HAVE_LIBXML2=no) + if test "${HAVE_LIBXML2}" = "yes"; then + LIBS="$LIBXML2_LIBS $LIBS" + AC_CHECK_LIB(xml2, htmlReadMemory, HAVE_LIBXML2=yes, HAVE_LIBXML2=no) + if test "${HAVE_LIBXML2}" = "yes"; then + AC_DEFINE(HAVE_LIBXML2, 1, [Define to 1 if you have the libxml library (-lxml2).]) + else + LIBXML2_LIBS="" + LIBXML2_CFLAGS="" + fi + fi + fi + AC_SUBST(LIBXML2_LIBS) + AC_SUBST(LIBXML2_CFLAGS) + + # If netdb.h doesn't declare h_errno, we must declare it by hand. + AC_CACHE_CHECK(whether netdb declares h_errno, + emacs_cv_netdb_declares_h_errno, + [AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include ]], + [[return h_errno;]])], + emacs_cv_netdb_declares_h_errno=yes, emacs_cv_netdb_declares_h_errno=no)]) + if test $emacs_cv_netdb_declares_h_errno = yes; then + AC_DEFINE(HAVE_H_ERRNO, 1, [Define to 1 if netdb.h declares h_errno.]) + fi + + # fmod, logb, and frexp are found in -lm on most systems. + # On HPUX 9.01, -lm does not contain logb, so check for sqrt. + AC_CHECK_LIB(m, sqrt) + + # Check for mail-locking functions in a "mail" library. Probably this should + # have the same check as for liblockfile below. + AC_CHECK_LIB(mail, maillock, have_mail=yes, have_mail=no) + if test $have_mail = yes; then + LIBS_MAIL=-lmail + LIBS="$LIBS_MAIL $LIBS" + AC_DEFINE(HAVE_LIBMAIL, 1, [Define to 1 if you have the `mail' library (-lmail).]) + else + LIBS_MAIL= + fi + dnl Debian, at least: + AC_CHECK_LIB(lockfile, maillock, have_lockfile=yes, have_lockfile=no) + if test $have_lockfile = yes; then + LIBS_MAIL=-llockfile + LIBS="$LIBS_MAIL $LIBS" + AC_DEFINE(HAVE_LIBLOCKFILE, 1, [Define to 1 if you have the `lockfile' library (-llockfile).]) + else + # If we have the shared liblockfile, assume we must use it for mail + # locking (e.g. Debian). If we couldn't link against liblockfile + # (no liblockfile.a installed), ensure that we don't need to. + dnl This works for files generally, not just executables. + dnl Should we look elsewhere for it? Maybe examine /etc/ld.so.conf? + AC_CHECK_PROG(liblockfile, liblockfile.so, yes, no, + /usr/lib:/lib:/usr/local/lib:$LD_LIBRARY_PATH) + if test $ac_cv_prog_liblockfile = yes; then + AC_MSG_ERROR([Shared liblockfile found but can't link against it. + This probably means that movemail could lose mail. + There may be a `development' package to install containing liblockfile.]) + fi + fi + AC_CHECK_HEADERS_ONCE(maillock.h) + AC_SUBST(LIBS_MAIL) + + ## Define MAIL_USE_FLOCK (or LOCKF) if the mailer uses flock (or lockf) to + ## interlock access to the mail spool. The alternative is a lock file named + ## /usr/spool/mail/$USER.lock. + mail_lock=no + case "$opsys" in + aix4-2) mail_lock="lockf" ;; + + gnu|freebsd|netbsd|openbsd|darwin|irix6-5) mail_lock="flock" ;; + + ## On GNU/Linux systems, both methods are used by various mail programs. + ## I assume most people are using newer mailers that have heard of flock. + ## Change this if you need to. + ## Debian contains a patch which says: ``On Debian/GNU/Linux systems, + ## configure gets the right answers, and that means *NOT* using flock. + ## Using flock is guaranteed to be the wrong thing. See Debian Policy + ## for details.'' and then uses `#ifdef DEBIAN'. Unfortunately the + ## Debian maintainer hasn't provided a clean fix for Emacs. + ## movemail.c will use `maillock' when MAILDIR, HAVE_LIBMAIL and + ## HAVE_MAILLOCK_H are defined, so the following appears to be the + ## correct logic. -- fx + ## We must check for HAVE_LIBLOCKFILE too, as movemail does. + ## liblockfile is a Free Software replacement for libmail, used on + ## Debian systems and elsewhere. -rfr. + gnu-*) + mail_lock="flock" + if test $have_mail = yes || test $have_lockfile = yes; then + test $ac_cv_header_maillock_h = yes && mail_lock=no + fi + ;; + esac + + BLESSMAIL_TARGET= + case "$mail_lock" in + flock) AC_DEFINE(MAIL_USE_FLOCK, 1, [Define if the mailer uses flock to interlock the mail spool.]) ;; + + lockf) AC_DEFINE(MAIL_USE_LOCKF, 1, [Define if the mailer uses lockf to interlock the mail spool.]) ;; + + *) BLESSMAIL_TARGET="need-blessmail" ;; + esac + AC_SUBST(BLESSMAIL_TARGET) + + + AC_CHECK_FUNCS(gethostname \ + closedir getrusage get_current_dir_name \ + lrand48 logb frexp fmod cbrt setsid \ + fpathconf select euidaccess getpagesize setlocale \ + utimes getrlimit setrlimit setpgid getcwd shutdown getaddrinfo \ + __fpending strsignal setitimer \ + sendto recvfrom getsockname getpeername getifaddrs freeifaddrs \ + gai_strerror mkstemp getline getdelim fsync sync \ + difftime posix_memalign \ + getpwent endpwent getgrent endgrent \ + touchlock \ + cfmakeraw cfsetspeed copysign __executable_start) + + dnl FIXME Fragile: something else may test for getwd as a dependency. + dnl Change to defining BROKEN_xxx ? + dnl getwd appears to be buggy on SVR4.2, so we don't use it. + if test $opsys != unixware; then + AC_CHECK_FUNCS(getwd) + fi + + dnl FIXME Fragile: see above. + ## Eric Backus says, HP-UX 9.x on HP 700 machines + ## has a broken `rint' in some library versions including math library + ## version number A.09.05. + ## You can fix the math library by installing patch number PHSS_4630. + ## But we can fix it more reliably for Emacs by just not using rint. + ## We also skip HAVE_RANDOM - see comments in src/s/hpux10-20.h. + case $opsys in + hpux*) : ;; + *) AC_CHECK_FUNCS(random rint) ;; + esac + + dnl Cannot use AC_CHECK_FUNCS + AC_CACHE_CHECK([for __builtin_unwind_init], + emacs_cv_func___builtin_unwind_init, + [AC_LINK_IFELSE([AC_LANG_PROGRAM([], [__builtin_unwind_init ();])], + emacs_cv_func___builtin_unwind_init=yes, + emacs_cv_func___builtin_unwind_init=no)]) + if test $emacs_cv_func___builtin_unwind_init = yes; then + AC_DEFINE(HAVE___BUILTIN_UNWIND_INIT, 1, + [Define to 1 if you have the `__builtin_unwind_init' function.]) + fi + + AC_CHECK_HEADERS_ONCE(sys/un.h) + + AC_FUNC_FSEEKO + + AC_FUNC_GETPGRP + + # UNIX98 PTYs. + AC_CHECK_FUNCS(grantpt) + + # PTY-related GNU extensions. + AC_CHECK_FUNCS(getpt) + + # Check this now, so that we will NOT find the above functions in ncurses. + # That is because we have not set up to link ncurses in lib-src. + # It's better to believe a function is not available + # than to expect to find it in ncurses. + # Also we need tputs and friends to be able to build at all. + AC_MSG_CHECKING([for library containing tputs]) + # Run a test program that contains a call to tputs, a call that is + # never executed. This tests whether a pre-'main' dynamic linker + # works with the library. It's too much trouble to actually call + # tputs in the test program, due to portability hassles. When + # cross-compiling, assume the test program will run if it links. + AC_DEFUN([tputs_link_source], [ + AC_LANG_SOURCE( + [[extern void tputs (const char *, int, int (*)(int)); + int main (int argc, char **argv) + { + if (argc == 10000) + tputs (argv[0], 0, 0); + return 0; + }]]) + ]) + # Maybe curses should be tried earlier? + # See http://debbugs.gnu.org/cgi/bugreport.cgi?bug=9736#35 + for tputs_library in '' tinfo ncurses terminfo termcap curses; do + OLIBS=$LIBS + if test -z "$tputs_library"; then + LIBS_TERMCAP= + msg='none required' + else + LIBS_TERMCAP=-l$tputs_library + msg=$LIBS_TERMCAP + LIBS="$LIBS_TERMCAP $LIBS" + fi + AC_RUN_IFELSE([tputs_link_source], [], [msg=no], + [AC_LINK_IFELSE([tputs_link_source], [], [msg=no])]) + LIBS=$OLIBS + if test "X$msg" != Xno; then + break + fi + done + AC_MSG_RESULT([$msg]) + if test "X$msg" = Xno; then + AC_MSG_ERROR([The required function `tputs' was not found in any library. + The following libraries were tried (in order): + libtinfo, libncurses, libterminfo, libtermcap, libcurses + Please try installing whichever of these libraries is most appropriate + for your system, together with its header files. + For example, a libncurses-dev(el) or similar package.]) + fi + + ## Use termcap instead of terminfo? + ## Only true for: freebsd < 40000, ms-w32, msdos, netbsd < 599002500. + TERMINFO=yes + ## FIXME? In the cases below where we unconditionally set + ## LIBS_TERMCAP="-lncurses", this overrides LIBS_TERMCAP = -ltinfo, + ## if that was found above to have tputs. + ## Should we use the gnu* logic everywhere? + case "$opsys" in + ## darwin: Prevents crashes when running Emacs in Terminal.app under 10.2. + ## The ncurses library has been moved out of the System framework in + ## Mac OS X 10.2. So if configure detects it, set the command-line + ## option to use it. + darwin) LIBS_TERMCAP="-lncurses" ;; + + gnu*) test -z "$LIBS_TERMCAP" && LIBS_TERMCAP="-lncurses" ;; + + freebsd) + AC_MSG_CHECKING([whether FreeBSD is new enough to use terminfo]) + AC_CACHE_VAL(emacs_cv_freebsd_terminfo, + [AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include ]], + [[#if __FreeBSD_version < 400000 + fail; + #endif + ]])], emacs_cv_freebsd_terminfo=yes, emacs_cv_freebsd_terminfo=no)]) + + AC_MSG_RESULT($emacs_cv_freebsd_terminfo) + + if test $emacs_cv_freebsd_terminfo = yes; then + LIBS_TERMCAP="-lncurses" + else + TERMINFO=no + LIBS_TERMCAP="-ltermcap" + fi + ;; + + netbsd) + if test "x$LIBS_TERMCAP" != "x-lterminfo"; then + TERMINFO=no + LIBS_TERMCAP="-ltermcap" + fi + ;; + + openbsd) LIBS_TERMCAP="-lncurses" ;; + + ## hpux: Make sure we get select from libc rather than from libcurses + ## because libcurses on HPUX 10.10 has a broken version of select. + ## We used to use -lc -lcurses, but this may be cleaner. + ## FIXME? But TERMINFO = yes on hpux (it used to be explicitly + # set that way, now it uses the default). Isn't this a contradiction? + hpux*) LIBS_TERMCAP="-ltermcap" ;; + + esac + + TERMCAP_OBJ=tparam.o + if test $TERMINFO = yes; then + AC_DEFINE(TERMINFO, 1, [Define to 1 if you use terminfo instead of termcap.]) + TERMCAP_OBJ=terminfo.o + fi + AC_SUBST(LIBS_TERMCAP) + AC_SUBST(TERMCAP_OBJ) + + + # Do we have res_init, for detecting changes in /etc/resolv.conf? + # On Darwin, res_init appears not to be useful: see bug#562 and + # http://lists.gnu.org/archive/html/emacs-devel/2007-11/msg01467.html + resolv=no + + if test $opsys != darwin; then + + AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include + #include + #include ]], + [[return res_init();]])], + have_res_init=yes, have_res_init=no) + if test "$have_res_init" = no; then + OLIBS="$LIBS" + LIBS="$LIBS -lresolv" + AC_MSG_CHECKING(for res_init with -lresolv) + AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include + #include + #include ]], + [[return res_init();]])], + have_res_init=yes, have_res_init=no) + AC_MSG_RESULT($have_res_init) + if test "$have_res_init" = yes ; then + resolv=yes + fi + LIBS="$OLIBS" + fi + + if test "$have_res_init" = yes; then + AC_DEFINE(HAVE_RES_INIT, 1, [Define to 1 if res_init is available.]) + fi + fi dnl !darwin + + # Do we need the Hesiod library to provide the support routines? + dnl FIXME? Should we be skipping this on Darwin too? + LIBHESIOD= + if test "$with_hesiod" != no ; then + # Don't set $LIBS here -- see comments above. FIXME which comments? + AC_CHECK_FUNC(res_send, , [AC_CHECK_FUNC(__res_send, , + [AC_CHECK_LIB(resolv, res_send, resolv=yes, + [AC_CHECK_LIB(resolv, __res_send, resolv=yes)])])]) + if test "$resolv" = yes ; then + RESOLVLIB=-lresolv + else + RESOLVLIB= + fi + AC_CHECK_FUNC(hes_getmailhost, , [AC_CHECK_LIB(hesiod, hes_getmailhost, + hesiod=yes, :, $RESOLVLIB)]) + + if test x"$hesiod" = xyes; then + AC_DEFINE(HAVE_LIBHESIOD, 1, + [Define to 1 if you have the hesiod library (-lhesiod).]) + LIBHESIOD=-lhesiod + fi + fi + AC_SUBST(LIBHESIOD) + + # Do we need libresolv (due to res_init or Hesiod)? + if test "$resolv" = yes && test $opsys != darwin; then + AC_DEFINE(HAVE_LIBRESOLV, 1, + [Define to 1 if you have the resolv library (-lresolv).]) + LIBRESOLV=-lresolv + else + LIBRESOLV= + fi + AC_SUBST(LIBRESOLV) + + # These tell us which Kerberos-related libraries to use. + COM_ERRLIB= + CRYPTOLIB= + KRB5LIB= + DESLIB= + KRB4LIB= + + if test "${with_kerberos}" != no; then + AC_CHECK_LIB(com_err, com_err, have_com_err=yes, have_com_err=no) + if test $have_com_err = yes; then + COM_ERRLIB=-lcom_err + LIBS="$COM_ERRLIB $LIBS" + AC_DEFINE(HAVE_LIBCOM_ERR, 1, [Define to 1 if you have the `com_err' library (-lcom_err).]) + fi + AC_CHECK_LIB(crypto, mit_des_cbc_encrypt, have_crypto=yes, have_crypto=no) + if test $have_crypto = yes; then + CRYPTOLIB=-lcrypto + LIBS="$CRYPTOLIB $LIBS" + AC_DEFINE(HAVE_LIBCRYPTO, 1, [Define to 1 if you have the `crypto' library (-lcrypto).]) + fi + AC_CHECK_LIB(k5crypto, mit_des_cbc_encrypt, have_k5crypto=yes, have_k5crypto=no) + if test $have_k5crypto = yes; then + CRYPTOLIB=-lk5crypto + LIBS="$CRYPTOLIB $LIBS" + AC_DEFINE(HAVE_LIBK5CRYPTO, 1, [Define to 1 if you have the `k5crypto' library (-lk5crypto).]) + fi + AC_CHECK_LIB(krb5, krb5_init_context, have_krb5=yes, have_krb5=no) + if test $have_krb5=yes; then + KRB5LIB=-lkrb5 + LIBS="$KRB5LIB $LIBS" + AC_DEFINE(HAVE_LIBKRB5, 1, [Define to 1 if you have the `krb5' library (-lkrb5).]) + fi + dnl FIXME Simplify. Does not match 22 logic, thanks to default_off? + if test "${with_kerberos5}" = no; then + AC_CHECK_LIB(des425, des_cbc_encrypt, have_des425=yes, have_des425=no ) + if test $have_des425 = yes; then + DESLIB=-ldes425 + LIBS="$DESLIB $LIBS" + AC_DEFINE(HAVE_LIBDES425, 1, [Define to 1 if you have the `des425' library (-ldes425).]) + else + AC_CHECK_LIB(des, des_cbc_encrypt, have_des=yes, have_des=no) + if test $have_des = yes; then + DESLIB=-ldes + LIBS="$DESLIB $LIBS" + AC_DEFINE(HAVE_LIBDES, 1, [Define to 1 if you have the `des' library (-ldes).]) + fi + fi + AC_CHECK_LIB(krb4, krb_get_cred, have_krb4=yes, have_krb4=no) + if test $have_krb4 = yes; then + KRB4LIB=-lkrb4 + LIBS="$KRB4LIB $LIBS" + AC_DEFINE(HAVE_LIBKRB4, 1, [Define to 1 if you have the `krb4' library (-lkrb4).]) + else + AC_CHECK_LIB(krb, krb_get_cred, have_krb=yes, have_krb=no) + if test $have_krb = yes; then + KRB4LIB=-lkrb + LIBS="$KRB4LIB $LIBS" + AC_DEFINE(HAVE_LIBKRB, 1, [Define to 1 if you have the `krb' library (-lkrb).]) + fi + fi + fi + + if test "${with_kerberos5}" != no; then + AC_CHECK_HEADERS(krb5.h, + [AC_CHECK_MEMBERS([krb5_error.text, krb5_error.e_text],,, + [#include ])]) + else + AC_CHECK_HEADERS(des.h,, + [AC_CHECK_HEADERS(kerberosIV/des.h,, + [AC_CHECK_HEADERS(kerberos/des.h)])]) + AC_CHECK_HEADERS(krb.h,, + [AC_CHECK_HEADERS(kerberosIV/krb.h,, + [AC_CHECK_HEADERS(kerberos/krb.h)])]) + fi + AC_CHECK_HEADERS(com_err.h) + fi + + AC_SUBST(COM_ERRLIB) + AC_SUBST(CRYPTOLIB) + AC_SUBST(KRB5LIB) + AC_SUBST(DESLIB) + AC_SUBST(KRB4LIB) + + AC_CHECK_FUNCS_ONCE(tzset) + AC_MSG_CHECKING(whether localtime caches TZ) + AC_CACHE_VAL(emacs_cv_localtime_cache, + [if test x$ac_cv_func_tzset = xyes; then + AC_RUN_IFELSE([AC_LANG_SOURCE([[#include + char TZ_GMT0[] = "TZ=GMT0"; + char TZ_PST8[] = "TZ=PST8"; + main() + { + time_t now = time ((time_t *) 0); + int hour_GMT0, hour_unset; + if (putenv (TZ_GMT0) != 0) + exit (1); + hour_GMT0 = localtime (&now)->tm_hour; + unsetenv("TZ"); + hour_unset = localtime (&now)->tm_hour; + if (putenv (TZ_PST8) != 0) + exit (1); + if (localtime (&now)->tm_hour == hour_GMT0) + exit (1); + unsetenv("TZ"); + if (localtime (&now)->tm_hour != hour_unset) + exit (1); + exit (0); + }]])], emacs_cv_localtime_cache=no, emacs_cv_localtime_cache=yes, + [# If we have tzset, assume the worst when cross-compiling. + emacs_cv_localtime_cache=yes]) + else + # If we lack tzset, report that localtime does not cache TZ, + # since we can't invalidate the cache if we don't have tzset. + emacs_cv_localtime_cache=no + fi])dnl + AC_MSG_RESULT($emacs_cv_localtime_cache) + if test $emacs_cv_localtime_cache = yes; then + AC_DEFINE(LOCALTIME_CACHE, 1, + [Define to 1 if localtime caches TZ.]) + fi + + ok_so_far=yes + AC_CHECK_FUNC(socket, , ok_so_far=no) + if test $ok_so_far = yes; then + AC_CHECK_HEADER(netinet/in.h, , ok_so_far=no) + fi + if test $ok_so_far = yes; then + AC_CHECK_HEADER(arpa/inet.h, , ok_so_far=no) + fi + if test $ok_so_far = yes; then + dnl Fixme: Not used. Should this be HAVE_SOCKETS? + AC_DEFINE(HAVE_INET_SOCKETS, 1, + [Define to 1 if you have inet sockets.]) + fi + + if test -f /usr/lpp/X11/bin/smt.exp; then + AC_DEFINE(HAVE_AIX_SMT_EXP, 1, + [Define to 1 if the file /usr/lpp/X11/bin/smt.exp exists.]) + fi + + AC_MSG_CHECKING(whether system supports dynamic ptys) + if test -d /dev/pts && ls -d /dev/ptmx > /dev/null 2>&1 ; then + AC_MSG_RESULT(yes) + AC_DEFINE(HAVE_DEV_PTMX, 1, [Define to 1 if dynamic ptys are supported.]) + else + AC_MSG_RESULT(no) + fi + + AC_FUNC_FORK + + AC_CHECK_FUNCS(snprintf) + + dnl Adapted from Haible's version. + AC_CACHE_CHECK([for nl_langinfo and CODESET], emacs_cv_langinfo_codeset, + [AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include ]], + [[char* cs = nl_langinfo(CODESET);]])], + emacs_cv_langinfo_codeset=yes, + emacs_cv_langinfo_codeset=no) + ]) + if test $emacs_cv_langinfo_codeset = yes; then + AC_DEFINE(HAVE_LANGINFO_CODESET, 1, + [Define if you have and nl_langinfo(CODESET).]) + fi + + AC_TYPE_MBSTATE_T + + AC_CACHE_CHECK([for C restricted array declarations], emacs_cv_c_restrict_arr, + [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[void fred (int x[__restrict]);]], [[]])], + emacs_cv_c_restrict_arr=yes, emacs_cv_c_restrict_arr=no)]) + if test "$emacs_cv_c_restrict_arr" = yes; then + AC_DEFINE(__restrict_arr, __restrict, + [Define to compiler's equivalent of C99 restrict keyword in array + declarations. Define as empty for no equivalent.]) + fi + + dnl Fixme: AC_SYS_POSIX_TERMIOS should probably be used, but it's not clear + dnl how the tty code is related to POSIX and/or other versions of termios. + dnl The following looks like a useful start. + dnl + dnl AC_SYS_POSIX_TERMIOS + dnl if test $ac_cv_sys_posix_termios = yes; then + dnl AC_DEFINE(HAVE_TERMIOS, 1, [Define to 1 if you have POSIX-style functions + dnl and macros for terminal control.]) + dnl AC_DEFINE(HAVE_TCATTR, 1, [Define to 1 if you have tcgetattr and tcsetattr.]) + dnl fi + + dnl Every platform that uses configure (ie every non-MS platform) + dnl supports this. There is a create-lockfiles option you can + dnl customize if you do not want the lock files to be written. + dnl So it is not clear that this #define still needs to exist. + AC_DEFINE(CLASH_DETECTION, 1, [Define if you want lock files to be written, + so that Emacs can tell instantly when you try to modify a file that + someone else has modified in his/her Emacs.]) + + dnl Everybody supports this, except MS. + dnl Seems like the kind of thing we should be testing for, though. + ## Note: PTYs are broken on darwin <6. Use at your own risk. + AC_DEFINE(HAVE_PTYS, 1, [Define if the system supports pty devices.]) + + dnl Everybody supports this, except MS-DOS. + dnl Seems like the kind of thing we should be testing for, though. + dnl Compare with HAVE_INET_SOCKETS (which is unused...) above. + AC_DEFINE(HAVE_SOCKETS, 1, [Define if the system supports + 4.2-compatible sockets.]) + + + AH_TEMPLATE(NO_EDITRES, [Define if XEditRes should not be used.]) + + case $opsys in + aix4-2) + dnl Unfortunately without libXmu we cannot support EditRes. + if test x$ac_cv_lib_Xmu_XmuConvertStandardSelection != xyes; then + AC_DEFINE(NO_EDITRES, 1) + fi + ;; + + hpux*) + dnl Assar Westerlund says this is necessary for + dnl HP-UX 10.20, and that it works for HP-UX 0 as well. + AC_DEFINE(NO_EDITRES, 1) + ;; + esac + + + case $opsys in + darwin | gnu | hpux* | *bsd ) + AC_DEFINE(NO_TERMIO, 1, [Define if termio.h should not be included.]) + ;; + + irix6-5 | sol2* | unixware ) + dnl Some SVr4s don't define NSIG in sys/signal.h for ANSI environments; + dnl instead, there's a system variable _sys_nsig. Unfortunately, we + dnl need the constant to dimension an array. So wire in the appropriate + dnl value here. + AC_DEFINE(NSIG_MINIMUM, 32, [Minimum value of NSIG.]) + ;; + esac + + + case $opsys in + dnl SIGIO exists, but the feature doesn't work in the way Emacs needs. + dnl See eg . + hpux* | irix6-5 | openbsd | sol2* | unixware ) + AC_DEFINE(BROKEN_SIGIO, 1, [Define if SIGIO should not be used.]) + ;; + + aix4-2) + dnl BUILD 9008 - FIONREAD problem still exists in X-Windows. + AC_DEFINE(BROKEN_FIONREAD, 1, [Define if FIONREAD should not be used.]) + dnl As we define BROKEN_FIONREAD, SIGIO will be undefined in systty.h. + dnl But, on AIX, SIGAIO, SIGPTY, and SIGPOLL are defined as SIGIO, + dnl which causes compilation error at init_signals in sysdep.c. + dnl So, we define these macros so that syssignal.h detects them + dnl and undefine SIGAIO, SIGPTY and SIGPOLL. + AC_DEFINE(BROKEN_SIGAIO, 1, [Define if SIGAIO should not be used.]) + AC_DEFINE(BROKEN_SIGPOLL,1, [Define if SIGPOLL should not be used.]) + AC_DEFINE(BROKEN_SIGPTY, 1, [Define if SIGPTY should not be used.]) + + dnl On AIX Emacs uses the gmalloc.c malloc implementation. But given + dnl the way this system works, libc functions that return malloced + dnl memory use the libc malloc implementation. Calling xfree or + dnl xrealloc on the results of such functions results in a crash. + dnl + dnl One solution for this could be to define SYSTEM_MALLOC in configure, + dnl but that does not currently work on this system. + dnl + dnl It is possible to completely override the malloc implementation on + dnl AIX, but that involves putting the malloc functions in a shared + dnl library and setting the MALLOCTYPE environment variable to point to + dnl that shared library. + dnl + dnl Emacs currently calls xrealloc on the results of get_current_dir name, + dnl to avoid a crash just use the Emacs implementation for that function. + dnl + dnl FIXME We could change the AC_CHECK_FUNCS call near the start + dnl of this file, so that we do not check for get_current_dir_name + dnl on AIX. But that might be fragile if something else ends + dnl up testing for get_current_dir_name as a dependency. + AC_DEFINE(BROKEN_GET_CURRENT_DIR_NAME, 1, [Define if + get_current_dir_name should not be used.]) + ;; + + freebsd) + dnl Circumvent a bug in FreeBSD. In the following sequence of + dnl writes/reads on a PTY, read(2) returns bogus data: + dnl + dnl write(2) 1022 bytes + dnl write(2) 954 bytes, get EAGAIN + dnl read(2) 1024 bytes in process_read_output + dnl read(2) 11 bytes in process_read_output + dnl + dnl That is, read(2) returns more bytes than have ever been written + dnl successfully. The 1033 bytes read are the 1022 bytes written + dnl successfully after processing (for example with CRs added if the + dnl terminal is set up that way which it is here). The same bytes will + dnl be seen again in a later read(2), without the CRs. + AC_DEFINE(BROKEN_PTY_READ_AFTER_EAGAIN, 1, [Define on FreeBSD to + work around an issue when reading from a PTY.]) + ;; + + dnl Define the following so emacs symbols will not conflict with those + dnl in the System framework. Otherwise -prebind will not work. + darwin) + AC_DEFINE(NO_ABORT, 1, [Do not define abort in emacs.c.]) + ;; + esac + + case $opsys in + gnu-* | sol2-10 ) + dnl FIXME Can't we test if this exists (eg /proc/$$)? + AC_DEFINE(HAVE_PROCFS, 1, [Define if you have the /proc filesystem.]) + ;; + esac + + case $opsys in + darwin | freebsd | netbsd | openbsd ) + AC_DEFINE(DONT_REOPEN_PTY, 1, [Define if process.c does not need to + close a pty to make it a controlling terminal (it is already a + controlling terminal of the subprocess, because we did ioctl TIOCSCTTY).]) + ;; + esac + + dnl FIXME Surely we can test for this rather than hard-code it. + case $opsys in + netbsd | openbsd) sound_device="/dev/audio" ;; + *) sound_device="/dev/dsp" ;; + esac + + dnl Used in sound.c + AC_DEFINE_UNQUOTED(DEFAULT_SOUND_DEVICE, "$sound_device", + [Name of the default sound device.]) + + + dnl Emacs can read input using SIGIO and buffering characters itself, + dnl or using CBREAK mode and making C-g cause SIGINT. + dnl The choice is controlled by the variable interrupt_input. + dnl + dnl Define INTERRUPT_INPUT to make interrupt_input = 1 the default (use SIGIO) + dnl + dnl Emacs uses the presence or absence of the SIGIO and BROKEN_SIGIO macros + dnl to indicate whether or not signal-driven I/O is possible. It uses + dnl INTERRUPT_INPUT to decide whether to use it by default. + dnl + dnl SIGIO can be used only on systems that implement it (4.2 and 4.3). + dnl CBREAK mode has two disadvantages + dnl 1) At least in 4.2, it is impossible to handle the Meta key properly. + dnl I hear that in system V this problem does not exist. + dnl 2) Control-G causes output to be discarded. + dnl I do not know whether this can be fixed in system V. + dnl + dnl Another method of doing input is planned but not implemented. + dnl It would have Emacs fork off a separate process + dnl to read the input and send it to the true Emacs process + dnl through a pipe. + case $opsys in + darwin | gnu-linux | gnu-kfreebsd ) + AC_DEFINE(INTERRUPT_INPUT, 1, [Define to read input using SIGIO.]) + ;; + esac + + + dnl If the system's imake configuration file defines `NeedWidePrototypes' + dnl as `NO', we must define NARROWPROTO manually. Such a define is + dnl generated in the Makefile generated by `xmkmf'. If we don't define + dnl NARROWPROTO, we will see the wrong function prototypes for X functions + dnl taking float or double parameters. + case $opsys in + cygwin|gnu|gnu-linux|gnu-kfreebsd|irix6-5|freebsd|netbsd|openbsd) + AC_DEFINE(NARROWPROTO, 1, [Define if system's imake configuration + file defines `NeedWidePrototypes' as `NO'.]) + ;; + esac + + + dnl Used in process.c, this must be a loop, even if it only runs once. + dnl (Except on SGI; see below. Take that, clarity and consistency!) + AH_TEMPLATE(PTY_ITERATION, [How to iterate over PTYs.]) + dnl Only used if !PTY_ITERATION. Iterate from FIRST_PTY_LETTER to z, + dnl trying suffixes 0-16. + AH_TEMPLATE(FIRST_PTY_LETTER, [Letter to use in finding device name of + first PTY, if PTYs are supported.]) + AH_TEMPLATE(PTY_OPEN, [How to open a PTY, if non-standard.]) + AH_TEMPLATE(PTY_NAME_SPRINTF, [How to get the device name of the control + end of a PTY, if non-standard.]) + AH_TEMPLATE(PTY_TTY_NAME_SPRINTF, [How to get device name of the tty + end of a PTY, if non-standard.]) + + case $opsys in + aix4-2 ) + AC_DEFINE(PTY_ITERATION, [int c; for (c = 0; !c ; c++)] ) + dnl You allocate a pty by opening /dev/ptc to get the master side. + dnl To get the name of the slave side, you just ttyname() the master side. + AC_DEFINE(PTY_NAME_SPRINTF, [strcpy (pty_name, "/dev/ptc");] ) + AC_DEFINE(PTY_TTY_NAME_SPRINTF, [strcpy (pty_name, ttyname (fd));] ) + ;; + + cygwin ) + AC_DEFINE(PTY_ITERATION, [int i; for (i = 0; i < 1; i++)] ) + dnl multi-line AC_DEFINEs are hard. :( + AC_DEFINE(PTY_OPEN, [ do { int dummy; SIGMASKTYPE mask; mask = sigblock (sigmask (SIGCHLD)); if (-1 == openpty (&fd, &dummy, pty_name, 0, 0)) fd = -1; sigsetmask (mask); if (fd >= 0) emacs_close (dummy); } while (0)] ) + AC_DEFINE(PTY_NAME_SPRINTF, [] ) + AC_DEFINE(PTY_TTY_NAME_SPRINTF, [] ) + ;; + + darwin ) + AC_DEFINE(PTY_ITERATION, [int i; for (i = 0; i < 1; i++)] ) + dnl Not used, because PTY_ITERATION is defined. + AC_DEFINE(FIRST_PTY_LETTER, ['p']) + dnl Note that openpty may fork via grantpt on Mac OS X 10.4/Darwin 8. + dnl But we don't have to block SIGCHLD because it is blocked in the + dnl implementation of grantpt. + AC_DEFINE(PTY_OPEN, [ do { int slave; if (openpty (&fd, &slave, pty_name, NULL, NULL) == -1) fd = -1; else emacs_close (slave); } while (0)] ) + AC_DEFINE(PTY_NAME_SPRINTF, [] ) + AC_DEFINE(PTY_TTY_NAME_SPRINTF, [] ) + ;; + + gnu | freebsd | netbsd | openbsd ) + AC_DEFINE(FIRST_PTY_LETTER, ['p']) + ;; + + gnu-linux | gnu-kfreebsd ) + dnl if HAVE_GRANTPT + if test "x$ac_cv_func_grantpt" = xyes; then + AC_DEFINE(UNIX98_PTYS, 1, [Define if the system has Unix98 PTYs.]) + AC_DEFINE(PTY_ITERATION, [int i; for (i = 0; i < 1; i++)] ) + dnl Note that grantpt and unlockpt may fork. We must block SIGCHLD + dnl to prevent sigchld_handler from intercepting the child's death. + AC_DEFINE(PTY_TTY_NAME_SPRINTF, [{ char *ptyname; sigblock (sigmask (SIGCHLD)); if (grantpt (fd) == -1 || unlockpt (fd) == -1 || !(ptyname = ptsname(fd))) { sigunblock (sigmask (SIGCHLD)); close (fd); return -1; } snprintf (pty_name, sizeof pty_name, "%s", ptyname); sigunblock (sigmask (SIGCHLD)); }] ) + dnl if HAVE_GETPT + if test "x$ac_cv_func_getpt" = xyes; then + AC_DEFINE(PTY_OPEN, [fd = getpt ()]) + AC_DEFINE(PTY_NAME_SPRINTF, [] ) + else + AC_DEFINE(PTY_NAME_SPRINTF, [strcpy (pty_name, "/dev/ptmx");] ) + fi + else + AC_DEFINE(FIRST_PTY_LETTER, ['p']) + fi + ;; + + hpux*) + AC_DEFINE(FIRST_PTY_LETTER, ['p']) + AC_DEFINE(PTY_NAME_SPRINTF, [sprintf (pty_name, "/dev/ptym/pty%c%x", c, i);] ) + AC_DEFINE(PTY_TTY_NAME_SPRINTF, [sprintf (pty_name, "/dev/pty/tty%c%x", c, i);] ) + ;; + + irix6-5 ) + dnl It looks like this cannot be right, because it is not a loop. + dnl However, process.c actually does this: + dnl # ifndef __sgi + dnl continue; + dnl # else + dnl return -1; + dnl # endif + dnl which presumably makes it OK, since irix == sgi (?). + dnl FIXME it seems like this special treatment is unnecessary? + dnl Why can't irix use a single-trip loop like eg cygwin? + AC_DEFINE(PTY_ITERATION, []) + dnl Not used, because PTY_ITERATION is defined. + AC_DEFINE(FIRST_PTY_LETTER, ['q']) + AC_DEFINE(PTY_OPEN, [ { struct sigaction ocstat, cstat; struct stat stb; char * name; sigemptyset(&cstat.sa_mask); cstat.sa_handler = SIG_DFL; cstat.sa_flags = 0; sigaction(SIGCLD, &cstat, &ocstat); name = _getpty (&fd, O_RDWR | O_NDELAY, 0600, 0); sigaction(SIGCLD, &ocstat, (struct sigaction *)0); if (name == 0) return -1; if (fd < 0) return -1; if (fstat (fd, &stb) < 0) return -1; strcpy (pty_name, name); }] ) + dnl No need to get the pty name at all. + AC_DEFINE(PTY_NAME_SPRINTF, [] ) + dnl No need to use sprintf to get the tty name--we get that from _getpty. + AC_DEFINE(PTY_TTY_NAME_SPRINTF, [] ) + ;; + + sol2* ) + dnl Uses sigblock/sigunblock rather than sighold/sigrelse, + dnl which appear to be BSD4.1 specific. It may also be appropriate + dnl for SVR4.x (x<2) but I'm not sure. fnf@cygnus.com + dnl On SysVr4, grantpt(3) forks a subprocess, so keep sigchld_handler() + dnl from intercepting that death. If any child but grantpt's should die + dnl within, it should be caught after sigrelse(2). + AC_DEFINE(PTY_TTY_NAME_SPRINTF, [{ char *ptsname (int), *ptyname; sigblock (sigmask (SIGCLD)); if (grantpt (fd) == -1) { emacs_close (fd); return -1; } sigunblock (sigmask (SIGCLD)); if (unlockpt (fd) == -1) { emacs_close (fd); return -1; } if (!(ptyname = ptsname (fd))) { emacs_close (fd); return -1; } snprintf (pty_name, sizeof pty_name, "%s", ptyname); }] ) + ;; + + unixware ) + dnl Comments are as per sol2*. + AC_DEFINE(PTY_TTY_NAME_SPRINTF, [{ char *ptsname (int), *ptyname; sigblock(sigmask(SIGCLD)); if (grantpt(fd) == -1) fatal("could not grant slave pty"); sigunblock(sigmask(SIGCLD)); if (unlockpt(fd) == -1) fatal("could not unlock slave pty"); if (!(ptyname = ptsname(fd))) fatal ("could not enable slave pty"); snprintf (pty_name, sizeof pty_name, "%s", ptyname); }] ) + ;; + esac + + + case $opsys in + sol2* | unixware ) + dnl This change means that we don't loop through allocate_pty too + dnl many times in the (rare) event of a failure. + AC_DEFINE(FIRST_PTY_LETTER, ['z']) + AC_DEFINE(PTY_NAME_SPRINTF, [strcpy (pty_name, "/dev/ptmx");] ) + dnl Push various streams modules onto a PTY channel. Used in process.c. + AC_DEFINE(SETUP_SLAVE_PTY, [if (ioctl (xforkin, I_PUSH, "ptem") == -1) fatal ("ioctl I_PUSH ptem"); if (ioctl (xforkin, I_PUSH, "ldterm") == -1) fatal ("ioctl I_PUSH ldterm"); if (ioctl (xforkin, I_PUSH, "ttcompat") == -1) fatal ("ioctl I_PUSH ttcompat");], [How to set up a slave PTY, if needed.]) + ;; + esac + + + AH_TEMPLATE(SIGNALS_VIA_CHARACTERS, [Make process_send_signal work by + "typing" a signal character on the pty.]) + + case $opsys in + dnl Perry Smith says this is correct for AIX. + dnl thomas@mathematik.uni-bremen.de says this is needed for IRIX. + aix4-2 | cygwin | gnu | irix6-5 | freebsd | netbsd | openbsd ) + AC_DEFINE(SIGNALS_VIA_CHARACTERS, 1) + ;; + + dnl 21 Jun 06: Eric Hanchrow says this works. + dnl FIXME Does gnu-kfreebsd have linux/version.h? It seems unlikely... + gnu-linux | gnu-kfreebsd ) + + AC_MSG_CHECKING([for signals via characters]) + AC_PREPROC_IFELSE([AC_LANG_PROGRAM([[ + #include + #if LINUX_VERSION_CODE < 0x20400 + # error "Linux version too old" + #endif + ]], [[]])], emacs_signals_via_chars=yes, emacs_signals_via_chars=no) + + AC_MSG_RESULT([$emacs_signals_via_chars]) + test $emacs_signals_via_chars = yes && AC_DEFINE(SIGNALS_VIA_CHARACTERS, 1) + ;; + esac + + + dnl Used in dispnew.c + AH_TEMPLATE(PENDING_OUTPUT_COUNT, [Number of chars of output in the + buffer of a stdio stream.]) + + dnl FIXME just PENDING_OUTPUT_COUNT should suffice. + AH_TEMPLATE(GNU_LIBRARY_PENDING_OUTPUT_COUNT, [Value of + PENDING_OUTPUT_COUNT if using the GNU C library.]) + + case $opsys in + cygwin | darwin | freebsd | netbsd | openbsd ) + AC_DEFINE(PENDING_OUTPUT_COUNT(FILE), [((FILE)->_p - (FILE)->_bf._base)]) + ;; + + unixware) + AC_DEFINE(PENDING_OUTPUT_COUNT(FILE), [((FILE)->__ptr - (FILE)->__base)]) + ;; + + gnu | gnu-linux | gnu-kfreebsd ) + AC_MSG_CHECKING([for style of pending output formalism]) + dnl In autoconf 2.67 and later, we could use a single test + dnl since the preprocessed output is accessible in "conftest.i". + AC_PREPROC_IFELSE([AC_LANG_PROGRAM([[ + #include + #if !defined (_IO_STDIO_H) && !defined (_STDIO_USES_IOSTREAM) + # error "stdio definitions not found" + #endif + ]], [[]])], emacs_pending_output=new, emacs_pending_output=unknown) + + if test $emacs_pending_output = unknown; then + case $opsys in + gnu-linux | gnu-kfreebsd) + AC_PREPROC_IFELSE([AC_LANG_PROGRAM([[ + #include + #ifndef __UCLIBC__ + # error "not using uclibc" + #endif + ]], [[]])], emacs_pending_output=uclibc, emacs_pending_output=old) + ;; + esac + fi + + AC_MSG_RESULT([$emacs_pending_output]) + + case $emacs_pending_output in + new) + dnl New C libio names. + AC_DEFINE(GNU_LIBRARY_PENDING_OUTPUT_COUNT(FILE), + [((FILE)->_IO_write_ptr - (FILE)->_IO_write_base)]) + ;; + uclibc) + dnl Using the uClibc library. + AC_DEFINE(GNU_LIBRARY_PENDING_OUTPUT_COUNT(FILE), + [((FILE)->__bufpos - (FILE)->__bufstart)]) + ;; + old) + dnl Old C++ iostream names. + AC_DEFINE(GNU_LIBRARY_PENDING_OUTPUT_COUNT(FILE), + [((FILE)->_pptr - (FILE)->_pbase)]) + ;; + esac + ;; + esac + + + dnl Used in vm-limit.c + AH_TEMPLATE(DATA_START, [Address of the start of the data segment.]) + dnl Used in lisp.h, emacs.c, mem-limits.h + dnl NEWS.18 describes this as "a number which contains + dnl the high bits to be inclusive or'ed with pointers that are unpacked." + AH_TEMPLATE(DATA_SEG_BITS, [Extra bits to be or'd in with any pointers + stored in a Lisp_Object.]) + dnl if Emacs uses fewer than 32 bits for the value field of a LISP_OBJECT. + + case $opsys in + gnu) + dnl libc defines data_start. + AC_DEFINE(DATA_START, [({ extern int data_start; (char *) &data_start; })]) + ;; + + hpux*) + dnl The data segment on this machine always starts at address 0x40000000. + AC_DEFINE(DATA_START, [0x40000000]) + AC_DEFINE(DATA_SEG_BITS, [0x40000000]) + ;; + irix6-5) + AC_DEFINE(DATA_START, [0x10000000]) + AC_DEFINE(DATA_SEG_BITS, [0x10000000]) + ;; + esac + + + AH_TEMPLATE(ULIMIT_BREAK_VALUE, [Undocumented.]) + AH_TEMPLATE(TAB3, [Undocumented.]) + + case $opsys in + darwin) AC_DEFINE(TAB3, OXTABS) ;; + + gnu | freebsd | netbsd | openbsd ) + AC_DEFINE(TABDLY, OXTABS, [Undocumented.] ) + AC_DEFINE(TAB3, OXTABS) + ;; + + gnu-linux | gnu-kfreebsd ) + dnl libc-linux/sysdeps/linux/i386/ulimit.c says that due to shared + dnl library, we cannot get the maximum address for brk. + AC_PREPROC_IFELSE([AC_LANG_PROGRAM([[ + #ifndef __i386__ + # error "not i386" + #endif + ]], [[]])], AC_DEFINE(ULIMIT_BREAK_VALUE, [(32*1024*1024)]), []) + + AC_PREPROC_IFELSE([AC_LANG_PROGRAM([[ + #ifndef __ia64__ + # error "not ia64" + #endif + ]], [[]])], AC_DEFINE(GC_MARK_SECONDARY_STACK(), + [do { extern void *__libc_ia64_register_backing_store_base; __builtin_ia64_flushrs (); mark_memory (__libc_ia64_register_backing_store_base, __builtin_ia64_bsp ());} while (0)], + [Mark a secondary stack, like the register stack on the ia64.]), []) + ;; + + hpux*) + AC_DEFINE(RUN_TIME_REMAP, 1, [Define if emacs.c needs to call + run_time_remap; for HPUX.]) + ;; + + irix6-5) + dnl Ulimit(UL_GMEMLIM) is busted... + AC_DEFINE(ULIMIT_BREAK_VALUE, [0x14000000]) + ;; + esac + + + dnl These won't be used automatically yet. We also need to know, at least, + dnl that the stack is continuous. + AH_TEMPLATE(GC_SETJMP_WORKS, [Define if setjmp is known to save all + registers relevant for conservative garbage collection in the jmp_buf.]) + + AH_TEMPLATE(GC_MARK_STACK, [Define to GC_USE_GCPROS_AS_BEFORE if + conservative garbage collection is not known to work.]) + + + case $opsys in + aix4-2 | hpux* | unixware) + dnl Conservative garbage collection has not been tested, so for now + dnl play it safe and stick with the old-fashioned way of marking. + AC_DEFINE(GC_MARK_STACK, [GC_USE_GCPROS_AS_BEFORE]) + ;; + + dnl Not all the architectures are tested, but there are Debian packages + dnl for SCM and/or Guile on them, so the technique must work. See also + dnl comments in alloc.c concerning setjmp and gcc. + dnl Fixme: it's probably safe to just use the GCC conditional below. + gnu-linux | gnu-kfreebsd ) + AC_PREPROC_IFELSE([AC_LANG_PROGRAM([[ + #if defined __i386__ || defined __sparc__ || defined __mc68000__ \ + || defined __alpha__ || defined __mips__ || defined __s390__ \ + || defined __arm__ || defined __powerpc__ || defined __amd64__ \ + || defined __ia64__ || defined __sh__ + /* ok */ + #else + # error "setjmp not known to work on this arch" + #endif + ]], [[]])], AC_DEFINE(GC_SETJMP_WORKS, 1), + AC_DEFINE(GC_MARK_STACK, [GC_USE_GCPROS_AS_BEFORE]) ) + ;; + esac + + + if test x$GCC = xyes; then + dnl GC_SETJMP_WORKS is nearly always appropriate for GCC. + AC_DEFINE(GC_SETJMP_WORKS, 1) + else + case $opsys in + dnl irix: Tested on Irix 6.5. SCM worked on earlier versions. + freebsd | netbsd | openbsd | irix6-5 | sol2* ) + AC_DEFINE(GC_SETJMP_WORKS, 1) + ;; + esac + fi dnl GCC? + + + dnl Used in xfaces.c. + case $opsys in + hpux* | sol2* ) + AC_DEFINE(XOS_NEEDS_TIME_H, 1, [Compensate for a bug in Xos.h on + some systems, where it requires time.h.]) + ;; + esac + + + dnl Define symbols to identify the version of Unix this is. + dnl Define all the symbols that apply correctly. + AH_TEMPLATE(BSD4_2, [Define if the system is compatible with BSD 4.2.]) + AH_TEMPLATE(BSD_SYSTEM, [Define if the system is compatible with BSD 4.2.]) + AH_TEMPLATE(USG, [Define if the system is compatible with System III.]) + AH_TEMPLATE(USG5, [Define if the system is compatible with System V.]) + + case $opsys in + aix4-2) + AC_DEFINE(USG, []) + AC_DEFINE(USG5, []) + dnl This symbol should be defined on AIX Version 3 ??????? + AC_PREPROC_IFELSE([AC_LANG_PROGRAM([[ + #ifndef _AIX + # error "_AIX not defined" + #endif + ]], [[]])], [], AC_DEFINE(_AIX, [], [Define if the system is AIX.])) + ;; + + cygwin) + opsysfile= + AC_DEFINE(CYGWIN, 1, [Define if the system is Cygwin.]) + ;; + + darwin) + dnl BSD4_3 and BSD4_4 are already defined in sys/param.h. + AC_DEFINE(BSD4_2, []) + AC_DEFINE(BSD_SYSTEM, []) + dnl More specific than the above two. We cannot use __APPLE__ as this + dnl may not be defined on non-OSX Darwin, and we cannot define DARWIN + dnl here because Panther and lower CoreFoundation.h uses DARWIN to + dnl distinguish OS X from pure Darwin. + AC_DEFINE(DARWIN_OS, [], [Define if the system is Darwin.]) + ;; + + freebsd) + AC_DEFINE(BSD4_2, []) + dnl Hack to avoid calling AC_PREPROC_IFELSE multiple times. + dnl Would not be needed with autoconf >= 2.67, where the + dnl preprocessed output is accessible in "conftest.i". + AC_DEFINE(BSD_SYSTEM_AHB, 1, [Define if AH_BOTTOM should change BSD_SYSTEM.]) + ;; + + gnu | netbsd | openbsd ) + AC_DEFINE(BSD4_2, []) + AC_PREPROC_IFELSE([AC_LANG_PROGRAM([[ + #ifndef BSD_SYSTEM + # error "BSD_SYSTEM not defined" + #endif + ]], [[]])], [], AC_DEFINE(BSD_SYSTEM, 43) ) + ;; + + gnu-linux | gnu-kfreebsd ) + AC_DEFINE(USG, []) + AC_DEFINE(GNU_LINUX, [], [Define if ths system is compatible with GNU/Linux.]) + ;; + + hpux*) + AC_DEFINE(USG, []) + AC_DEFINE(USG5, []) + AC_DEFINE(HPUX, [], [Define if the system is HPUX.]) + ;; + + irix6-5) + AC_DEFINE(USG, []) + AC_DEFINE(USG5, []) + AC_DEFINE(IRIX6_5, [], [Define if the system is IRIX.]) + ;; + + sol2*) + AC_DEFINE(USG, []) + AC_DEFINE(USG5, []) + AC_DEFINE(SOLARIS2, [], [Define if the system is Solaris.]) + ;; + + unixware) + AC_DEFINE(USG, []) + AC_DEFINE(USG5, []) + ;; + esac + + + case $opsys in + dnl Emacs supplies its own malloc, but glib (part of Gtk+) calls + dnl memalign and on Cygwin, that becomes the Cygwin-supplied memalign. + dnl As malloc is not the Cygwin malloc, the Cygwin memalign always + dnl returns ENOSYS. A workaround is to set G_SLICE=always-malloc. */ + cygwin) + AC_DEFINE(G_SLICE_ALWAYS_MALLOC, 1, [Define to set the + G_SLICE environment variable to "always-malloc" at startup, if + using GTK.]) + ;; + + gnu) opsysfile= ;; + + gnu-kfreebsd) opsysfile="s/gnu-linux.h" ;; + + hpux11) + dnl See comments in sysdep.c:sys_signal. + dnl SA_RESTART resets the timeout of `select' on hpux11. + dnl Defining BROKEN_SA_RESTART is not the same as undef'ing SA_RESTART. + AC_DEFINE(BROKEN_SA_RESTART, 1, [Define if SA_RESTART should only + be used in batch mode.]) + dnl It works to open the pty's tty in the parent (Emacs), then + dnl close and reopen it in the child. + AC_DEFINE(USG_SUBTTY_WORKS, 1, [Define for USG systems where it + works to open a pty's tty in the parent process, then close and + reopen it in the child.]) + + opsysfile="s/hpux10-20.h" + ;; + + irix6-5) + AC_DEFINE(PREFER_VSUSP, 1, [Define if process_send_signal should + use VSUSP instead of VSWTCH.]) + AC_DEFINE(SETPGRP_RELEASES_CTTY, 1, [Define if process.c:child_setup + should not call setpgrp.]) + ;; + + openbsd) opsysfile="s/netbsd.h" ;; + + sol2-10) + AC_DEFINE(_STRUCTURED_PROC, 1, [Needed for system_process_attributes + on Solaris.]) + opsysfile="s/sol2-6.h" + ;; + esac + + # Set up the CFLAGS for real compilation, so we can substitute it. + CFLAGS="$REAL_CFLAGS" + CPPFLAGS="$REAL_CPPFLAGS" + + ## Hack to detect a buggy GCC version. + if test "x$GCC" = xyes \ + && test x"`$CC --version 2> /dev/null | grep 'gcc.* 4.5.0'`" != x \ + && test x"`echo $CFLAGS | grep '\-O@<:@23@:>@'`" != x \ + && test x"`echo $CFLAGS | grep '\-fno-optimize-sibling-calls'`" = x; then + AC_MSG_ERROR([GCC 4.5.0 has problems compiling Emacs; see etc/PROBLEMS'.]) + fi + + version=$PACKAGE_VERSION + + ### Specify what sort of things we'll be editing into Makefile and config.h. + ### Use configuration here uncanonicalized to avoid exceeding size limits. + AC_SUBST(version) + AC_SUBST(configuration) + ## Unused? + AC_SUBST(canonical) + AC_SUBST(srcdir) + AC_SUBST(prefix) + AC_SUBST(exec_prefix) + AC_SUBST(bindir) + AC_SUBST(datadir) + AC_SUBST(sharedstatedir) + AC_SUBST(libexecdir) + AC_SUBST(mandir) + AC_SUBST(infodir) + AC_SUBST(lispdir) + AC_SUBST(leimdir) + AC_SUBST(standardlisppath) + AC_SUBST(locallisppath) + AC_SUBST(lisppath) + AC_SUBST(x_default_search_path) + AC_SUBST(etcdir) + AC_SUBST(archlibdir) + AC_SUBST(docdir) + AC_SUBST(bitmapdir) + AC_SUBST(gamedir) + AC_SUBST(gameuser) + ## FIXME? Nothing uses @LD_SWITCH_X_SITE@. + ## src/Makefile.in did add LD_SWITCH_X_SITE (as a cpp define) to the + ## end of LIBX_BASE, but nothing ever set it. + AC_SUBST(LD_SWITCH_X_SITE) + AC_SUBST(C_SWITCH_X_SITE) + AC_SUBST(GNUSTEP_CFLAGS) + AC_SUBST(CFLAGS) + ## Used in lwlib/Makefile.in. + AC_SUBST(X_TOOLKIT_TYPE) + if test -n "${opsysfile}"; then + S_FILE="\$(srcdir)/${opsysfile}" + else + S_FILE= + fi + AC_SUBST(S_FILE) + AC_SUBST(ns_appdir) + AC_SUBST(ns_appbindir) + AC_SUBST(ns_appresdir) + AC_SUBST(ns_appsrc) + AC_SUBST(GNU_OBJC_CFLAGS) + AC_SUBST(OTHER_FILES) + + AC_DEFINE_UNQUOTED(EMACS_CONFIGURATION, "${canonical}", + [Define to the canonical Emacs configuration name.]) + AC_DEFINE_UNQUOTED(EMACS_CONFIG_OPTIONS, "${ac_configure_args}", + [Define to the options passed to configure.]) + if test -n "$opsysfile"; then + AC_DEFINE_UNQUOTED(config_opsysfile, "${opsysfile}", + [Define to the used os dependent file.]) + fi + + XMENU_OBJ= + XOBJ= + FONT_OBJ= + if test "${HAVE_X_WINDOWS}" = "yes" ; then + AC_DEFINE(HAVE_X_WINDOWS, 1, + [Define to 1 if you want to use the X window system.]) + XMENU_OBJ=xmenu.o + XOBJ="xterm.o xfns.o xselect.o xrdb.o fontset.o xsmfns.o fringe.o image.o xsettings.o xgselect.o" + FONT_OBJ=xfont.o + if test "$HAVE_XFT" = "yes"; then + FONT_OBJ="$FONT_OBJ ftfont.o xftfont.o ftxfont.o" + elif test "$HAVE_FREETYPE" = "yes"; then + FONT_OBJ="$FONT_OBJ ftfont.o ftxfont.o" + fi + AC_SUBST(FONT_OBJ) + fi + AC_SUBST(XMENU_OBJ) + AC_SUBST(XOBJ) + AC_SUBST(FONT_OBJ) + + WIDGET_OBJ= + MOTIF_LIBW= + if test "${USE_X_TOOLKIT}" != "none" ; then + WIDGET_OBJ=widget.o + AC_DEFINE(USE_X_TOOLKIT, 1, [Define to 1 if using an X toolkit.]) + if test "${USE_X_TOOLKIT}" = "LUCID"; then + AC_DEFINE(USE_LUCID, 1, [Define to 1 if using the Lucid X toolkit.]) + elif test "${USE_X_TOOLKIT}" = "MOTIF"; then + AC_DEFINE(USE_MOTIF, 1, [Define to 1 if using the Motif X toolkit.]) + MOTIF_LIBW=-lXm + case "$opsys" in + gnu-linux) + ## Paul Abrahams says this is needed. + MOTIF_LIBW="$MOTIF_LIBW -lXpm" + ;; + + unixware) + ## Richard Anthony Ryan + ## says -lXimp is needed in UNIX_SV ... 4.2 1.1.2. + MOTIF_LIBW="MOTIF_LIBW -lXimp" + ;; + + aix4-2) + ## olson@mcs.anl.gov says -li18n is needed by -lXm. + MOTIF_LIBW="$MOTIF_LIBW -li18n" + ;; + esac + MOTIF_LIBW="$MOTIF_LIBW $LIBXP" + fi + fi + AC_SUBST(WIDGET_OBJ) + + TOOLKIT_LIBW= + case "$USE_X_TOOLKIT" in + MOTIF) TOOLKIT_LIBW="$MOTIF_LIBW" ;; + LUCID) TOOLKIT_LIBW="$LUCID_LIBW" ;; - none) test "x$HAVE_GTK" = "xyes" && TOOLKIT_LIBW="$GTK_LIBS" ;; ++ none) test "x$HAVE_GTK" = "xyes" && TOOLKIT_LIBW="$GTK_LIBS -lXcomposite" ;; + esac + AC_SUBST(TOOLKIT_LIBW) + + if test "$USE_X_TOOLKIT" = "none"; then + LIBXT_OTHER="\$(LIBXSM)" + OLDXMENU_TARGET="really-oldXMenu" + else + LIBXT_OTHER="\$(LIBXMU) -lXt \$(LIBXTR6) -lXext" + OLDXMENU_TARGET="really-lwlib" + fi + AC_SUBST(LIBXT_OTHER) + + ## The X Menu stuff is present in the X10 distribution, but missing + ## from X11. If we have X10, just use the installed library; + ## otherwise, use our own copy. + if test "${HAVE_X11}" = "yes" ; then + AC_DEFINE(HAVE_X11, 1, + [Define to 1 if you want to use version 11 of X windows. + Otherwise, Emacs expects to use version 10.]) + + if test "$USE_X_TOOLKIT" = "none"; then + OLDXMENU="\${oldXMenudir}/libXMenu11.a" + else + OLDXMENU="\${lwlibdir}/liblw.a" + fi + LIBXMENU="\$(OLDXMENU)" + LIBX_OTHER="\$(LIBXT) \$(LIBX_EXTRA)" + OLDXMENU_DEPS="\${OLDXMENU} ../src/\${OLDXMENU}" + else + ## For a syntactically valid Makefile; not actually used for anything. + ## See comments in src/Makefile.in. + OLDXMENU=nothing + ## FIXME This case (!HAVE_X11 && HAVE_X_WINDOWS) is no longer possible(?). + if test "${HAVE_X_WINDOWS}" = "yes"; then + LIBXMENU="-lXMenu" + else + LIBXMENU= + fi + LIBX_OTHER= + OLDXMENU_DEPS= + fi + + if test "$HAVE_GTK" = "yes" || test "$HAVE_MENUS" != "yes"; then + OLDXMENU_TARGET= + OLDXMENU=nothing + LIBXMENU= + OLDXMENU_DEPS= + fi + + AC_SUBST(OLDXMENU_TARGET) + AC_SUBST(OLDXMENU) + AC_SUBST(LIBXMENU) + AC_SUBST(LIBX_OTHER) + AC_SUBST(OLDXMENU_DEPS) + + if test "${HAVE_MENUS}" = "yes" ; then + AC_DEFINE(HAVE_MENUS, 1, + [Define to 1 if you have mouse menus. + (This is automatic if you use X, but the option to specify it remains.) + It is also defined with other window systems that support xmenu.c.]) + fi + + if test "${GNU_MALLOC}" = "yes" ; then + AC_DEFINE(GNU_MALLOC, 1, + [Define to 1 if you want to use the GNU memory allocator.]) + fi + + RALLOC_OBJ= + if test "${REL_ALLOC}" = "yes" ; then + AC_DEFINE(REL_ALLOC, 1, + [Define REL_ALLOC if you want to use the relocating allocator for + buffer space.]) + + test "$system_malloc" != "yes" && RALLOC_OBJ=ralloc.o + fi + AC_SUBST(RALLOC_OBJ) + + if test "$opsys" = "cygwin"; then + CYGWIN_OBJ="sheap.o" + ## Cygwin differs because of its unexec(). + PRE_ALLOC_OBJ= + POST_ALLOC_OBJ=lastfile.o + else + CYGWIN_OBJ= + PRE_ALLOC_OBJ=lastfile.o + POST_ALLOC_OBJ= + fi + AC_SUBST(CYGWIN_OBJ) + AC_SUBST(PRE_ALLOC_OBJ) + AC_SUBST(POST_ALLOC_OBJ) + + # Configure gnulib. Although this does not affect CFLAGS or LIBS permanently. + # it temporarily reverts them to their pre-pkg-config values, + # because gnulib needs to work with both src (which uses the + # pkg-config stuff) and lib-src (which does not). For example, gnulib + # may need to determine whether LIB_CLOCK_GETTIME should contain -lrt, + # and it therefore needs to run in an environment where LIBS does not + # already contain -lrt merely because 'pkg-config --libs' printed '-lrt' + # for some package unrelated to lib-src. + SAVE_CFLAGS=$CFLAGS + SAVE_LIBS=$LIBS + CFLAGS=$pre_PKG_CONFIG_CFLAGS + LIBS="$LIB_PTHREAD $pre_PKG_CONFIG_LIBS" + gl_ASSERT_NO_GNULIB_POSIXCHECK + gl_ASSERT_NO_GNULIB_TESTS + gl_INIT + CFLAGS=$SAVE_CFLAGS + LIBS=$SAVE_LIBS + + case "$opsys" in + aix4-2) LD_SWITCH_SYSTEM_TEMACS="-Wl,-bnodelcsect" ;; + + darwin) + ## The -headerpad option tells ld (see man page) to leave room at the + ## end of the header for adding load commands. Needed for dumping. + ## 0x690 is the total size of 30 segment load commands (at 56 + ## each); under Cocoa 31 commands are required. + if test "$HAVE_NS" = "yes"; then + libs_nsgui="-framework AppKit" + headerpad_extra=6C8 + else + libs_nsgui= + headerpad_extra=690 + fi + LD_SWITCH_SYSTEM_TEMACS="-fno-pie -prebind $libs_nsgui -Xlinker -headerpad -Xlinker $headerpad_extra" + + ## This is here because src/Makefile.in did some extra fiddling around + ## with LD_SWITCH_SYSTEM. The cpp logic was: + ## #ifndef LD_SWITCH_SYSTEM + ## #if !defined (__GNUC__) && ((defined (BSD_SYSTEM) && !defined (COFF))) + ## Since all the *bsds define LD_SWITCH_SYSTEM, this simplifies to: + ## not using gcc, darwin. + ## Because this was done in src/Makefile.in, the resulting part of + ## LD_SWITCH_SYSTEM was not used in configure (ie, in ac_link). + ## It therefore seems cleaner to put this in LD_SWITCH_SYSTEM_TEMACS, + ## rather than LD_SWITCH_SYSTEM. + test "x$LD_SWITCH_SYSTEM" = "x" && test "x$GCC" != "xyes" && \ + LD_SWITCH_SYSTEM_TEMACS="-X $LD_SWITCH_SYSTEM_TEMACS" + ;; + + ## LD_SWITCH_X_SITE_RPATH is a -rpath option saying where to + ## find X at run-time. + ## When handled by cpp, this was in LD_SWITCH_SYSTEM. However, at the + ## point where configure sourced the s/*.h file, LD_SWITCH_X_SITE_RPATH + ## had not yet been defined and was expanded to null. Hence LD_SWITCH_SYSTEM + ## had different values in configure (in ac_link) and src/Makefile.in. + ## It seems clearer therefore to put this piece in LD_SWITCH_SYSTEM_TEMACS. + gnu*) LD_SWITCH_SYSTEM_TEMACS="\$(LD_SWITCH_X_SITE_RPATH)" ;; + + *) LD_SWITCH_SYSTEM_TEMACS= ;; + esac + + if test "$NS_IMPL_GNUSTEP" = "yes"; then + LD_SWITCH_SYSTEM_TEMACS="${LD_SWITCH_SYSTEM_TEMACS} -L${GNUSTEP_SYSTEM_LIBRARIES} ${GNUSTEP_LOCAL_LIBRARIES} -lgnustep-gui -lgnustep-base -lobjc -lpthread" + fi + + AC_SUBST(LD_SWITCH_SYSTEM_TEMACS) + + + LD_FIRSTFLAG= + ORDINARY_LINK= + case "$opsys" in + ## gnu: GNU needs its own crt0. + aix4-2|cygwin|darwin|gnu|hpux*|irix6-5|sol2*|unixware) ORDINARY_LINK=yes ;; + + ## On post 1.3 releases of NetBSD, gcc -nostdlib also clears the + ## library search parth, i.e. it won't search /usr/lib for libc and + ## friends. Using -nostartfiles instead avoids this problem, and + ## will also work on earlier NetBSD releases. + netbsd|openbsd) LD_FIRSTFLAG="-nostartfiles" ;; + + ## powerpc*: NAKAJI Hiroyuki says + ## MkLinux/LinuxPPC needs this. + ## s390x-* only supports opsys = gnu-linux so it can be added here. + gnu-*) + case "$canonical" in + powerpc*|s390x-*) LD_FIRSTFLAG="-nostdlib" ;; + esac + ;; + esac + + + if test "x$ORDINARY_LINK" = "xyes"; then + + LD_FIRSTFLAG="" + AC_DEFINE(ORDINARY_LINK, 1, [Define if the C compiler is the linker.]) + + ## The system files defining neither ORDINARY_LINK nor LD_FIRSTFLAG are: + ## freebsd, gnu-* not on powerpc*|s390x*. + elif test "x$GCC" = "xyes" && test "x$LD_FIRSTFLAG" = "x"; then + + ## Versions of GCC >= 2.0 put their library, libgcc.a, in obscure + ## places that are difficult to figure out at make time. Fortunately, + ## these same versions allow you to pass arbitrary flags on to the + ## linker, so there is no reason not to use it as a linker. + ## + ## Well, it is not quite perfect. The "-nostdlib" keeps GCC from + ## searching for libraries in its internal directories, so we have to + ## ask GCC explicitly where to find libgcc.a (LIB_GCC below). + LD_FIRSTFLAG="-nostdlib" + fi + + ## FIXME? What setting of EDIT_LDFLAGS should this have? + test "$NS_IMPL_GNUSTEP" = "yes" && LD_FIRSTFLAG="-rdynamic" + + AC_SUBST(LD_FIRSTFLAG) + + + ## FIXME? The logic here is not precisely the same as that above. + ## There is no check here for a pre-defined LD_FIRSTFLAG. + ## Should we only be setting LIB_GCC if LD ~ -nostdlib? + LIB_GCC= + if test "x$GCC" = "xyes" && test "x$ORDINARY_LINK" != "xyes"; then + + case "$opsys" in + freebsd|netbsd|openbsd) LIB_GCC= ;; + + gnu-*) + ## armin76@gentoo.org reported that the lgcc_s flag is necessary to + ## build on ARM EABI under GNU/Linux. (Bug#5518) + case $host_cpu in + arm*) + LIB_GCC="-lgcc_s" + ;; + *) + ## FIXME? s/gnu-linux.h used to define LIB_GCC as below, then + ## immediately undefine it again and redefine it to empty. + ## Was the C_SWITCH_X_SITE part really necessary? + ## LIB_GCC=`$CC $C_SWITCH_X_SITE -print-libgcc-file-name` + LIB_GCC= + ;; + esac + ;; + + ## Ask GCC where to find libgcc.a. + *) LIB_GCC=`$CC -print-libgcc-file-name 2> /dev/null` ;; + esac + fi dnl if $GCC + AC_SUBST(LIB_GCC) + + + ## If we're using X11/GNUstep, define some consequences. + if test "$HAVE_X_WINDOWS" = "yes" || test "$HAVE_NS" = "yes"; then + AC_DEFINE(HAVE_WINDOW_SYSTEM, 1, [Define if you have a window system.]) + AC_DEFINE(HAVE_MOUSE, 1, [Define if you have mouse support.]) + fi + + + AH_TOP([/* GNU Emacs site configuration template file. + + Copyright (C) 1988, 1993-1994, 1999-2002, 2004-2012 + Free Software Foundation, Inc. + + This file is part of GNU Emacs. + + GNU Emacs 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 3 of the License, or + (at your option) any later version. + + GNU Emacs 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 GNU Emacs. If not, see . */ + + + /* No code in Emacs #includes config.h twice, but some bits of code + intended to work with other packages as well (like gmalloc.c) + think they can include it as many times as they like. */ + #ifndef EMACS_CONFIG_H + #define EMACS_CONFIG_H + ])dnl + + AH_BOTTOM([ + /* On AIX 3 this must be included before any other include file. */ + #include + #if ! HAVE_ALLOCA + # error "alloca not available on this machine" + #endif + + /* This silences a few compilation warnings on FreeBSD. */ + #ifdef BSD_SYSTEM_AHB + #undef BSD_SYSTEM_AHB + #undef BSD_SYSTEM + #if __FreeBSD__ == 1 + #define BSD_SYSTEM 199103 + #elif __FreeBSD__ == 2 + #define BSD_SYSTEM 199306 + #elif __FreeBSD__ >= 3 + #define BSD_SYSTEM 199506 + #endif + #endif + + /* Define AMPERSAND_FULL_NAME if you use the convention + that & in the full name stands for the login id. */ + /* Turned on June 1996 supposing nobody will mind it. */ + #define AMPERSAND_FULL_NAME + + /* `subprocesses' should be defined if you want to + have code for asynchronous subprocesses + (as used in M-x compile and M-x shell). + Only MSDOS does not support this (it overrides + this in its config_opsysfile below). */ + + #define subprocesses + + /* Include the os dependent file. */ + #ifdef config_opsysfile + # include config_opsysfile + #endif + + /* Mac OS X / GNUstep need a bit more pure memory. Of the existing knobs, + SYSTEM_PURESIZE_EXTRA seems like the least likely to cause problems. */ + #ifdef HAVE_NS + #if defined NS_IMPL_GNUSTEP + # define SYSTEM_PURESIZE_EXTRA 30000 + #elif defined DARWIN_OS + # define SYSTEM_PURESIZE_EXTRA 200000 + #endif + #endif + + #ifdef emacs /* Don't do this for lib-src. */ + /* Tell regex.c to use a type compatible with Emacs. */ + #define RE_TRANSLATE_TYPE Lisp_Object + #define RE_TRANSLATE(TBL, C) CHAR_TABLE_TRANSLATE (TBL, C) + #ifdef make_number + /* If make_number is a macro, use it. */ + #define RE_TRANSLATE_P(TBL) (!EQ (TBL, make_number (0))) + #else + /* If make_number is a function, avoid it. */ + #define RE_TRANSLATE_P(TBL) (!(INTEGERP (TBL) && XINT (TBL) == 0)) + #endif + #endif + + #include + #include + + #if __GNUC__ >= 3 /* On GCC 3.0 we might get a warning. */ + #define NO_INLINE __attribute__((noinline)) + #else + #define NO_INLINE + #endif + + #if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 1)) + #define EXTERNALLY_VISIBLE __attribute__((externally_visible)) + #else + #define EXTERNALLY_VISIBLE + #endif + + #if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 7) + # define ATTRIBUTE_FORMAT(spec) __attribute__ ((__format__ spec)) + #else + # define ATTRIBUTE_FORMAT(spec) /* empty */ + #endif + + #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4) + # define ATTRIBUTE_FORMAT_PRINTF(formatstring_parameter, first_argument) \ + ATTRIBUTE_FORMAT ((__gnu_printf__, formatstring_parameter, first_argument)) + #else + # define ATTRIBUTE_FORMAT_PRINTF(formatstring_parameter, first_argument) \ + ATTRIBUTE_FORMAT ((__printf__, formatstring_parameter, first_argument)) + #endif + + #define ATTRIBUTE_CONST _GL_ATTRIBUTE_CONST + + /* Some versions of GNU/Linux define noinline in their headers. */ + #ifdef noinline + #undef noinline + #endif + + #endif /* EMACS_CONFIG_H */ + + /* + Local Variables: + mode: c + End: + */ + ])dnl + + #### Report on what we decided to do. + #### Report GTK as a toolkit, even if it doesn't use Xt. + #### It makes printing result more understandable as using GTK sets + #### toolkit_scroll_bars to yes by default. + if test "${HAVE_GTK}" = "yes"; then + if test "${with_gtk3}" = "yes"; then + USE_X_TOOLKIT=GTK3 + else + USE_X_TOOLKIT=GTK + fi + fi + + echo " + Configured for \`${canonical}'. + + Where should the build process find the source code? ${srcdir} + What operating system file should Emacs use? ${opsysfile-none} + What compiler should emacs be built with? ${CC} ${CFLAGS} + Should Emacs use the GNU version of malloc? ${GNU_MALLOC}${GNU_MALLOC_reason} + Should Emacs use a relocating allocator for buffers? ${REL_ALLOC} + Should Emacs use mmap(2) for buffer allocation? $use_mmap_for_buffers + What window system should Emacs use? ${window_system} + What toolkit should Emacs use? ${USE_X_TOOLKIT}" + + if test -n "${x_includes}"; then + echo " Where do we find X Windows header files? ${x_includes}" + else + echo " Where do we find X Windows header files? Standard dirs" + fi + if test -n "${x_libraries}"; then + echo " Where do we find X Windows libraries? ${x_libraries}" + else + echo " Where do we find X Windows libraries? Standard dirs" + fi + + echo " Does Emacs use -lXaw3d? ${HAVE_XAW3D}" + echo " Does Emacs use -lXpm? ${HAVE_XPM}" + echo " Does Emacs use -ljpeg? ${HAVE_JPEG}" + echo " Does Emacs use -ltiff? ${HAVE_TIFF}" + echo " Does Emacs use a gif library? ${HAVE_GIF} $LIBGIF" + echo " Does Emacs use -lpng? ${HAVE_PNG}" + echo " Does Emacs use -lrsvg-2? ${HAVE_RSVG}" + echo " Does Emacs use imagemagick? ${HAVE_IMAGEMAGICK}" + + echo " Does Emacs use -lgpm? ${HAVE_GPM}" + echo " Does Emacs use -ldbus? ${HAVE_DBUS}" + echo " Does Emacs use -lgconf? ${HAVE_GCONF}" + echo " Does Emacs use GSettings? ${HAVE_GSETTINGS}" + echo " Does Emacs use -lselinux? ${HAVE_LIBSELINUX}" + echo " Does Emacs use -lgnutls? ${HAVE_GNUTLS}" + echo " Does Emacs use -lxml2? ${HAVE_LIBXML2}" + + echo " Does Emacs use -lfreetype? ${HAVE_FREETYPE}" + echo " Does Emacs use -lm17n-flt? ${HAVE_M17N_FLT}" + echo " Does Emacs use -lotf? ${HAVE_LIBOTF}" + echo " Does Emacs use -lxft? ${HAVE_XFT}" + + echo " Does Emacs use toolkit scroll bars? ${USE_TOOLKIT_SCROLL_BARS}" ++ ++echo " Does Emacs support Xwidgets? ${HAVE_XWIDGETS}" ++echo " Does xwidgets support webkit(requires gtk3)? ${HAVE_WEBKIT}" ++echo " Does xwidgets support gobject introspection? ${HAVE_GIR}" ++echo " Does xwidgets support clutter(demo code)? ${HAVE_CLUTTER}" ++echo " Does xwidgets support goocanvas(demo code)? ${HAVE_GOOCANVAS}" + echo + + if test -n "${EMACSDATA}"; then + echo " Environment variable EMACSDATA set to: $EMACSDATA" + fi + if test -n "${EMACSDOC}"; then + echo " Environment variable EMACSDOC set to: $EMACSDOC" + fi + + echo + + if test "$HAVE_NS" = "yes"; then + echo + echo "You must run \"${MAKE-make} install\" in order to test the built application. + The installed application will go to nextstep/Emacs.app and can be + run or moved from there." + if test "$EN_NS_SELF_CONTAINED" = "yes"; then + echo "The application will be fully self-contained." + else + echo "The lisp resources for the application will be installed under ${prefix}. + You may need to run \"${MAKE-make} install\" with sudo. The application will fail + to run if these resources are not installed." + fi + echo + fi + + if test "${opsys}" = "cygwin"; then + case `uname -r` in + 1.5.*) AC_MSG_WARN([[building Emacs on Cygwin 1.5 is not supported.]]) + echo + ;; + esac + fi + + # Remove any trailing slashes in these variables. + [test "${prefix}" != NONE && + prefix=`echo "${prefix}" | sed 's,\([^/]\)/*$,\1,'` + test "${exec_prefix}" != NONE && + exec_prefix=`echo "${exec_prefix}" | sed 's,\([^/]\)/*$,\1,'`] + + dnl Obviously there is duplication here wrt $SUBDIR_MAKEFILES. + dnl You _can_ use that variable in AC_CONFIG_FILES, so long as any directory + dnl using automake (ie lib/) is explicitly listed and not "hidden" in a variable + dnl (else you get "no `Makefile.am' found for any configure output"). + dnl This will work, but you get a config.status that is not quite right + dnl (see http://lists.gnu.org/archive/html/bug-autoconf/2008-08/msg00028.html). + dnl That doesn't have any obvious consequences for Emacs, but on the whole + dnl it seems better to just live with the duplication. + SUBDIR_MAKEFILES="lib/Makefile lib-src/Makefile oldXMenu/Makefile doc/emacs/Makefile doc/misc/Makefile doc/lispintro/Makefile doc/lispref/Makefile src/Makefile lwlib/Makefile lisp/Makefile leim/Makefile" + + AC_CONFIG_FILES([Makefile lib/Makefile lib-src/Makefile oldXMenu/Makefile \ + doc/emacs/Makefile doc/misc/Makefile doc/lispintro/Makefile \ + doc/lispref/Makefile src/Makefile lwlib/Makefile lisp/Makefile \ + leim/Makefile]) + + dnl test/ is not present in release tarfiles. + opt_makefile=test/automated/Makefile + + if test -f $srcdir/${opt_makefile}.in; then + SUBDIR_MAKEFILES="$SUBDIR_MAKEFILES $opt_makefile" + dnl Again, it's best not to use a variable. Though you can add + dnl ", [], [opt_makefile='$opt_makefile']" and it should work. + AC_CONFIG_FILES([test/automated/Makefile]) + fi + + + dnl admin/ may or may not be present. + opt_makefile=admin/unidata/Makefile + + if test -f $srcdir/${opt_makefile}.in; then + SUBDIR_MAKEFILES="$SUBDIR_MAKEFILES $opt_makefile" + AC_CONFIG_FILES([admin/unidata/Makefile]) + fi + + + SUBDIR_MAKEFILES_IN=`echo " ${SUBDIR_MAKEFILES}" | sed -e 's| | $(srcdir)/|g' -e 's|Makefile|Makefile.in|g'` + + AC_SUBST(SUBDIR_MAKEFILES_IN) + + dnl Make the necessary directories, if they don't exist. + AC_CONFIG_COMMANDS([mkdirs], [ + for dir in etc lisp ; do + test -d ${dir} || mkdir ${dir} + done + ]) + + dnl You might wonder (I did) why epaths.h is generated by running make, + dnl rather than just letting configure generate it from epaths.in. + dnl One reason is that the various paths are not fully expanded (see above); + dnl eg gamedir=${prefix}/var/games/emacs. + dnl Secondly, the GNU Coding standards require that one should be able + dnl to run `make prefix=/some/where/else' and override the values set + dnl by configure. This also explains the `move-if-change' test and + dnl the use of force in the `epaths-force' rule in Makefile.in. + AC_CONFIG_COMMANDS([epaths], [ + echo creating src/epaths.h + ${MAKE-make} epaths-force + ], [GCC="$GCC" CPPFLAGS="$CPPFLAGS"]) + + AC_CONFIG_COMMANDS([gdbinit], [ + if test ! -f src/.gdbinit && test -f $srcdir/src/.gdbinit; then + echo creating src/.gdbinit + echo source $srcdir/src/.gdbinit > src/.gdbinit + fi + ]) + + AC_OUTPUT diff --cc lisp/emacs-lisp/cl-loaddefs.el index 7b1f8465dc5,2d00aa62c20..e984d22f5d7 --- a/lisp/emacs-lisp/cl-loaddefs.el +++ b/lisp/emacs-lisp/cl-loaddefs.el @@@ -257,17 -252,15 +252,15 @@@ Remove from SYMBOL's plist the propert ;;;### (autoloads (cl--compiler-macro-cXXr cl--compiler-macro-list* ;;;;;; cl--compiler-macro-adjoin cl-defsubst cl-compiler-macroexpand ;;;;;; cl-define-compiler-macro cl-assert cl-check-type cl-typep - ;;;;;; cl-deftype cl-struct-setf-expander cl-defstruct cl-define-modify-macro - ;;;;;; cl-callf2 cl-callf cl-letf* cl-letf cl-rotatef cl-shiftf - ;;;;;; cl-remf cl-do-pop cl-psetf cl-setf cl-get-setf-method cl-defsetf - ;;;;;; cl-define-setf-expander cl-declare cl-the cl-locally cl-multiple-value-setq - ;;;;;; cl-multiple-value-bind cl-symbol-macrolet cl-macrolet cl-labels - ;;;;;; cl-flet cl-progv cl-psetq cl-do-all-symbols cl-do-symbols - ;;;;;; cl-dotimes cl-dolist cl-do* cl-do cl-loop cl-return-from - ;;;;;; cl-return cl-block cl-etypecase cl-typecase cl-ecase cl-case - ;;;;;; cl-load-time-value cl-eval-when cl-destructuring-bind cl-function - ;;;;;; cl-defmacro cl-defun cl-gentemp cl-gensym) "cl-macs" "cl-macs.el" - ;;;;;; "178bb5377dbd371f1038a7bf5f4d7f29") + ;;;;;; cl-deftype cl-defstruct cl-callf2 cl-callf cl-letf* cl-letf + ;;;;;; cl-rotatef cl-shiftf cl-remf cl-psetf cl-declare cl-the cl-locally + ;;;;;; cl-multiple-value-setq cl-multiple-value-bind cl-symbol-macrolet + ;;;;;; cl-macrolet cl-labels cl-flet* cl-flet cl-progv cl-psetq + ;;;;;; cl-do-all-symbols cl-do-symbols cl-dotimes cl-dolist cl-do* + ;;;;;; cl-do cl-loop cl-return-from cl-return cl-block cl-etypecase + ;;;;;; cl-typecase cl-ecase cl-case cl-load-time-value cl-eval-when + ;;;;;; cl-destructuring-bind cl-function cl-defmacro cl-defun cl-gentemp -;;;;;; cl-gensym) "cl-macs" "cl-macs.el" "db390970b6e9bd057169b197d5189781") ++;;;;;; cl-gensym) "cl-macs" "cl-macs.el" "570bedbd0b42cfe5ead36f6983e54829") ;;; Generated autoloads from cl-macs.el (autoload 'cl-gensym "cl-macs" "\ diff --cc src/lisp.h index 991dec431cc,f845ea6bd12..e371e0a8049 --- a/src/lisp.h +++ b/src/lisp.h @@@ -341,33 -368,28 +368,33 @@@ PUBLISH_TO_GDB (CHECK_LISP_OBJECT_TYPE) It is not crucial, but there are plenty of bits here, so why not do it? */ enum pvec_type { - PVEC_NORMAL_VECTOR = 0, - PVEC_PROCESS = 0x200, - PVEC_FRAME = 0x400, - PVEC_COMPILED = 0x800, - PVEC_WINDOW = 0x1000, - PVEC_WINDOW_CONFIGURATION = 0x2000, - PVEC_SUBR = 0x4000, - PVEC_CHAR_TABLE = 0x8000, - PVEC_BOOL_VECTOR = 0x10000, - PVEC_BUFFER = 0x20000, - PVEC_HASH_TABLE = 0x40000, - PVEC_TERMINAL = 0x80000, - PVEC_SUB_CHAR_TABLE = 0x100000, - PVEC_FONT = 0x200000, - PVEC_OTHER = 0x400000, + PVEC_NORMAL_VECTOR = 0, /* Unused! */ + PVEC_FREE, + PVEC_PROCESS, + PVEC_FRAME, + PVEC_WINDOW, + PVEC_BOOL_VECTOR, + PVEC_BUFFER, + PVEC_HASH_TABLE, + PVEC_TERMINAL, + PVEC_WINDOW_CONFIGURATION, + PVEC_SUBR, + PVEC_OTHER, +#ifdef HAVE_XWIDGETS - PVEC_XWIDGET = 0x800000, - PVEC_XWIDGET_VIEW = 0x1000000, ++ PVEC_XWIDGET, ++ PVEC_XWIDGET_VIEW, +#endif - PVEC_TYPE_MASK = 0x3fffe00 + - #if 0 /* This is used to make the value of PSEUDOVECTOR_FLAG available to - GDB. It doesn't work on OS Alpha. Moved to a variable in - emacs.c. */ - PVEC_FLAG = PSEUDOVECTOR_FLAG - #endif + /* These last 4 are special because we OR them in fns.c:internal_equal, + so they have to use a disjoint bit pattern: + if (!(size & (PVEC_COMPILED | PVEC_CHAR_TABLE + | PVEC_SUB_CHAR_TABLE | PVEC_FONT))) */ + PVEC_COMPILED = 0x10, + PVEC_CHAR_TABLE = 0x20, + PVEC_SUB_CHAR_TABLE = 0x30, + PVEC_FONT = 0x40 }; + PUBLISH_TO_GDB ((enum pvec_type) 0); /* This also publishes PVEC_*. */ /* For convenience, we also store the number of elements in these bits. Note that this size is not necessarily the memory-footprint size, but diff --cc src/print.c index c282c64aa89,fc435efe7c5..5b8e80dcf51 --- a/src/print.c +++ b/src/print.c @@@ -1759,18 -1769,12 +1771,19 @@@ print_object (Lisp_Object obj, registe strout (XSUBR (obj)->symbol_name, -1, -1, printcharfun); PRINTCHAR ('>'); } +#ifdef HAVE_XWIDGETS + else if (XXWIDGETP (obj)) + { + strout ("#'); + } +#endif else if (WINDOWP (obj)) { + int len; strout ("#sequence_number)); - strout (buf, -1, -1, printcharfun); + len = sprintf (buf, "%d", XWINDOW (obj)->sequence_number); + strout (buf, len, len, printcharfun); if (!NILP (XWINDOW (obj)->buffer)) { strout (" on ", -1, -1, printcharfun); diff --cc src/xdisp.c index c06d822de2f,1d3de61c5a3..6a9d2d3ac4c --- a/src/xdisp.c +++ b/src/xdisp.c @@@ -22782,20 -22827,7 +22939,20 @@@ fill_image_glyph_string (struct glyph_s s->ybase += s->first_glyph->voffset; } - +#ifdef HAVE_XWIDGETS +static void +fill_xwidget_glyph_string (struct glyph_string *s) +{ - xassert (s->first_glyph->type == XWIDGET_GLYPH); ++ eassert (s->first_glyph->type == XWIDGET_GLYPH); + printf("fill_xwidget_glyph_string: width:%d \n",s->first_glyph->pixel_width); + s->face = FACE_FROM_ID (s->f, s->first_glyph->face_id); + s->font = s->face->font; + s->width = s->first_glyph->pixel_width; + s->ybase += s->first_glyph->voffset; + s->xwidget = s->first_glyph->u.xwidget; + //assert_valid_xwidget_id ( s->xwidget, "fill_xwidget_glyph_string"); +} +#endif /* Fill glyph string S from a sequence of stretch glyphs. START is the index of the first glyph to consider, @@@ -23926,89 -23923,6 +24082,89 @@@ produce_image_glyph (struct it *it } } +#ifdef HAVE_XWIDGETS +static void +produce_xwidget_glyph (struct it *it) +{ + struct xwidget* xw; + struct face *face; + int glyph_ascent, crop; + printf("produce_xwidget_glyph:\n"); - xassert (it->what == IT_XWIDGET); ++ eassert (it->what == IT_XWIDGET); + + face = FACE_FROM_ID (it->f, it->face_id); - xassert (face); ++ eassert (face); + /* Make sure X resources of the face is loaded. */ + PREPARE_FACE_FOR_DISPLAY (it->f, face); + + xw = it->xwidget; + it->ascent = it->phys_ascent = glyph_ascent = xw->height/2; + it->descent = xw->height/2; + it->phys_descent = it->descent; + it->pixel_width = xw->width; + /* It's quite possible for images to have an ascent greater than + their height, so don't get confused in that case. */ + if (it->descent < 0) + it->descent = 0; + + it->nglyphs = 1; + + if (face->box != FACE_NO_BOX) + { + if (face->box_line_width > 0) + { + it->ascent += face->box_line_width; + it->descent += face->box_line_width; + } + + if (it->start_of_box_run_p) + it->pixel_width += eabs (face->box_line_width); + it->pixel_width += eabs (face->box_line_width); + } + + take_vertical_position_into_account (it); + + /* Automatically crop wide image glyphs at right edge so we can + draw the cursor on same display row. */ + if ((crop = it->pixel_width - (it->last_visible_x - it->current_x), crop > 0) + && (it->hpos == 0 || it->pixel_width > it->last_visible_x / 4)) + { + it->pixel_width -= crop; + } + + if (it->glyph_row) + { + struct glyph *glyph; + enum glyph_row_area area = it->area; + + glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area]; + if (glyph < it->glyph_row->glyphs[area + 1]) + { + glyph->charpos = CHARPOS (it->position); + glyph->object = it->object; + glyph->pixel_width = it->pixel_width; + glyph->ascent = glyph_ascent; + glyph->descent = it->descent; + glyph->voffset = it->voffset; + glyph->type = XWIDGET_GLYPH; + + glyph->multibyte_p = it->multibyte_p; + glyph->left_box_line_p = it->start_of_box_run_p; + glyph->right_box_line_p = it->end_of_box_run_p; + glyph->overlaps_vertically_p = 0; + glyph->padding_p = 0; + glyph->glyph_not_available_p = 0; + glyph->face_id = it->face_id; + glyph->u.xwidget = it->xwidget; + //assert_valid_xwidget_id(glyph->u.xwidget_id,"produce_xwidget_glyph"); + glyph->font_type = FONT_TYPE_UNKNOWN; + ++it->glyph_row->used[area]; + } + else + IT_EXPAND_MATRIX_WIDTH (it, area); + } +} +#endif /* Append a stretch glyph to IT->glyph_row. OBJECT is the source of the glyph, WIDTH and HEIGHT are the width and height of the diff --cc src/xwidget.c index caa0f0e1a31,00000000000..d7cda79ea90 mode 100644,000000..100644 --- a/src/xwidget.c +++ b/src/xwidget.c @@@ -1,1675 -1,0 +1,1675 @@@ +#include +#ifdef HAVE_XWIDGETS + +#include + +#include +#include +#ifdef HAVE_X_WINDOWS + +#include "lisp.h" +#include "blockinput.h" +#include "syssignal.h" + +#include "xterm.h" +#include + +#ifndef makedev +#include +#endif /* makedev */ + +#ifdef BSD_SYSTEM +#include +#endif /* ! defined (BSD_SYSTEM) */ + +#include "systime.h" + +#ifndef INCLUDED_FCNTL +#include +#endif +#include +#include +#include +#include + +#include "charset.h" +#include "character.h" +#include "coding.h" +#include "ccl.h" +#include "frame.h" +#include "dispextern.h" +#include "fontset.h" +#include "termhooks.h" +#include "termopts.h" +#include "termchar.h" +#include "emacs-icon.h" +#include "disptab.h" +#include "buffer.h" +#include "window.h" +#include "keyboard.h" +#include "intervals.h" +#include "process.h" +#include "atimer.h" +#include "keymap.h" + + +#ifdef USE_X_TOOLKIT +#include +#endif +#include +#include +#include +#ifdef HAVE_SYS_TIME_H +#include +#endif +#ifdef HAVE_UNISTD_H +#include +#endif + +#include "gtkutil.h" +#include "font.h" +#endif + +#include +#include + +#ifdef HAVE_GTK3 +//for gtk3; sockets and plugs +#include +#include "emacsgtkfixed.h" +#endif + + + +#ifdef HAVE_GOOCANVAS +#include +#endif + +#ifdef HAVE_CLUTTER +#include +#include +#include +#endif + +#include + +#ifdef HAVE_WEBKIT_OSR +#include +#include +#include +#include +#include +#include +#endif + +//for GIR +#include + +#include "xwidget.h" + +//TODO should of course not be a hardcoded array but I can't be bothered atm +//just a fixed array of xwidgets for now +//would need to be hashtables or something + +#define MAX_XWIDGETS 100 +struct xwidget_view xwidget_views[MAX_XWIDGETS]; + +//TODO embryo of lisp allocators for xwidgets +//TODO xwidget* should be Lisp_xwidget* +struct xwidget* +allocate_xwidget (void) +{ + return ALLOCATE_PSEUDOVECTOR (struct xwidget, height, PVEC_XWIDGET); +} + +//TODO xwidget_view* should be Lisp_xwidget_view* +struct xwidget_view* +allocate_xwidget_view (void) +{ + return ALLOCATE_PSEUDOVECTOR (struct xwidget_view, redisplayed, PVEC_XWIDGET_VIEW); +} +#define XSETXWIDGET(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_XWIDGET)) +#define XSETXWIDGET_VIEW(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_XWIDGET_VIEW)) + +Lisp_Object Qxwidget; +Lisp_Object Qcxwidget; +Lisp_Object Qtitle; +Lisp_Object Qxwidget_set_keyboard_grab; +Lisp_Object Qxwidget_embed_steal_window; +Lisp_Object Qxwidget_info; +Lisp_Object Qxwidget_resize; +Lisp_Object Qxwidget_send_keyboard_event; +Lisp_Object Qcxwgir_class; +Lisp_Object Qbutton, Qtoggle, Qslider, Qsocket, Qsocket_osr, Qcairo, Qxwgir, + Qwebkit_osr, QCplist; + + +extern Lisp_Object QCtype; +extern Lisp_Object QCwidth, QCheight; + +struct xwidget_view* xwidget_view_lookup(struct xwidget* xw, struct window *w); +Lisp_Object xwidget_spec_value ( Lisp_Object spec, Lisp_Object key, int *found); +gboolean webkit_osr_damage_event_callback (GtkWidget *widget, GdkEventExpose *event, gpointer data) ; +gboolean webkit_osr_key_event_callback (GtkWidget *widget, GdkEventKey *event, gpointer data) ; +void webkit_osr_document_load_finished_callback (WebKitWebView *webkitwebview, + WebKitWebFrame *arg1, + gpointer user_data); +gboolean webkit_osr_download_callback (WebKitWebView *webkitwebview, + WebKitDownload *arg1, + gpointer data); + +gboolean webkit_osr_mime_type_policy_typedecision_requested_callback(WebKitWebView *webView, + WebKitWebFrame *frame, + WebKitNetworkRequest *request, + gchar *mimetype, + WebKitWebPolicyDecision *policy_decision, + gpointer user_data); + +gboolean webkit_osr_new_window_policy_decision_requested_callback(WebKitWebView *webView, + WebKitWebFrame *frame, + WebKitNetworkRequest *request, + WebKitWebNavigationAction *navigation_action, + WebKitWebPolicyDecision *policy_decision, + gpointer user_data); + + +gboolean webkit_osr_navigation_policy_decision_requested_callback(WebKitWebView *webView, + WebKitWebFrame *frame, + WebKitNetworkRequest *request, + WebKitWebNavigationAction *navigation_action, + WebKitWebPolicyDecision *policy_decision, + gpointer user_data); + + +DEFUN ("make-xwidget", Fmake_xwidget, Smake_xwidget, 7, 7, 0, + doc: /* xw */ + ) + (Lisp_Object beg, Lisp_Object end, + Lisp_Object type, + Lisp_Object title, + Lisp_Object width, Lisp_Object height, + Lisp_Object data) +{ + //should work a bit like "make-button"(make-button BEG END &rest PROPERTIES) + // arg "type" and fwd should be keyword args eventually + //(make-xwidget 3 3 'button "oei" 31 31 nil) + //(xwidget-info (car xwidget-alist)) + struct xwidget* xw = allocate_xwidget(); + Lisp_Object val; + struct gcpro gcpro1; + GCPRO1(xw); + XSETSYMBOL(xw->type, type); + XSETSTRING(xw->title, title); + //TODO buffer should be an optional argument not just assumed to be the current buffer + XSETBUFFER(xw->buffer, Fcurrent_buffer()); // conservatively gcpro xw since we call lisp + xw->height = XFASTINT(height); + xw->width = XFASTINT(width); + XSETPSEUDOVECTOR (val, xw, PVEC_XWIDGET); //?? dunno why i need this + Vxwidget_alist = Fcons ( val, Vxwidget_alist); + xw->widgetwindow_osr = NULL; + xw->widget_osr = NULL; + xw->plist = Qnil; + + +#ifdef HAVE_WEBKIT_OSR + /* DIY mvc. widget is rendered offscreen, + later bitmap copied to the views. + */ + if (EQ(xw->type, Qwebkit_osr)){ + printf("init webkit osr\n"); + BLOCK_INPUT; + xw->widgetwindow_osr = GTK_CONTAINER (gtk_offscreen_window_new ()); + gtk_window_resize( GTK_WINDOW(xw->widgetwindow_osr), xw->width, xw->height); + xw->widget_osr = webkit_web_view_new(); + + gtk_widget_set_size_request (GTK_WIDGET (xw->widget_osr), xw->width, xw->height); + gtk_container_add (xw->widgetwindow_osr, xw->widget_osr); + + gtk_widget_show_all (GTK_WIDGET (xw->widgetwindow_osr)); + + /* store some xwidget data in the gtk widgets for convenient retrieval in the event handlers. */ + g_object_set_data (G_OBJECT (xw->widget_osr), XG_XWIDGET, (gpointer) (xw)); + g_object_set_data (G_OBJECT (xw->widgetwindow_osr), XG_XWIDGET, (gpointer) (xw)); + /* signals */ + g_signal_connect (G_OBJECT ( xw->widgetwindow_osr), "damage-event", G_CALLBACK (webkit_osr_damage_event_callback), NULL); + + //TODO these were just a test hack + /* g_signal_connect (G_OBJECT ( xw->widget_osr), "key-press-event", G_CALLBACK (webkit_osr_key_event_callback), NULL); */ + /* g_signal_connect (G_OBJECT ( xw->widget_osr), "key-release-event", G_CALLBACK (webkit_osr_key_event_callback), NULL); */ + + g_signal_connect (G_OBJECT ( xw->widget_osr), + "document-load-finished", + G_CALLBACK (webkit_osr_document_load_finished_callback), + xw); + + g_signal_connect (G_OBJECT ( xw->widget_osr), + "download-requested", + G_CALLBACK (webkit_osr_download_callback), + xw); + + g_signal_connect (G_OBJECT ( xw->widget_osr), + "mime-type-policy-decision-requested", + G_CALLBACK (webkit_osr_mime_type_policy_typedecision_requested_callback), + xw); + + g_signal_connect (G_OBJECT ( xw->widget_osr), + "new-window-policy-decision-requested", + G_CALLBACK (webkit_osr_new_window_policy_decision_requested_callback), + xw); + + g_signal_connect (G_OBJECT ( xw->widget_osr), + "navigation-policy-decision-requested", + G_CALLBACK (webkit_osr_navigation_policy_decision_requested_callback), + xw); + + + webkit_web_view_load_uri(WEBKIT_WEB_VIEW(xw->widget_osr), "http://www.fsf.org"); + UNBLOCK_INPUT; + + } +#endif + + if (EQ(xw->type, Qsocket_osr)){ + printf("init socket osr\n"); + BLOCK_INPUT; + xw->widgetwindow_osr = GTK_CONTAINER (gtk_offscreen_window_new ()); + gtk_window_resize( GTK_WINDOW(xw->widgetwindow_osr), xw->width, xw->height); + + //////////////////// + //xw->widget_osr = webkit_web_view_new(); + xw->widget_osr = gtk_socket_new(); + //g_signal_connect_after(xv->widget, "plug-added", G_CALLBACK(xwidget_plug_added), "plug added"); + //g_signal_connect_after(xv->widget, "plug-removed", G_CALLBACK(xwidget_plug_removed), "plug removed"); + /////////////////// + + gtk_widget_set_size_request (GTK_WIDGET (xw->widget_osr), xw->width, xw->height); + gtk_container_add (xw->widgetwindow_osr, xw->widget_osr); + + gtk_widget_show_all (GTK_WIDGET (xw->widgetwindow_osr)); + + /* store some xwidget data in the gtk widgets for convenient retrieval in the event handlers. */ + g_object_set_data (G_OBJECT (xw->widget_osr), XG_XWIDGET, (gpointer) (xw)); + g_object_set_data (G_OBJECT (xw->widgetwindow_osr), XG_XWIDGET, (gpointer) (xw)); + g_signal_connect (G_OBJECT ( xw->widgetwindow_osr), "damage-event", G_CALLBACK (webkit_osr_damage_event_callback), NULL); + + //webkit_web_view_load_uri(WEBKIT_WEB_VIEW(xw->widget_osr), "http://www.fsf.org"); + UNBLOCK_INPUT; + + } + + UNGCPRO; + return val; +} + +int +xwidget_hidden(struct xwidget_view *xv) +{ + return xv->hidden; +} + + +static void +buttonclick_handler (GtkWidget * widget, gpointer data) +{ + struct xwidget *xw = (struct xwidget *) data; + struct input_event event; + Lisp_Object frame; + FRAME_PTR f = NULL;//(FRAME_PTR) g_object_get_data (G_OBJECT (xw->widget), XG_FRAME_DATA); //TODO + printf ("button clicked xw:%d '%s'\n", xw, xw->title); + + EVENT_INIT (event); + event.kind = XWIDGET_EVENT; + + XSETFRAME (frame, f); + + event.frame_or_window = Qnil; //frame; //how to get the frame here? + + + event.arg = Qnil; + event.arg = Fcons ((Lisp_Object)xw, event.arg); //TODO send the actual xwidget object now instead + event.arg = Fcons (intern ("buttonclick"), event.arg); + + kbd_buffer_store_event (&event); + + +} + + +static void +send_xembed_ready_event (struct xwidget* xw, int xembedid) +{ + struct input_event event; + EVENT_INIT (event); + event.kind = XWIDGET_EVENT; + event.frame_or_window = Qnil; //frame; //how to get the frame here? //TODO i store it in the xwidget now + + event.arg = Qnil; + event.arg = Fcons (make_number (xembedid), event.arg); + event.arg = Fcons ((Lisp_Object)xw, event.arg); //TODO + event.arg = Fcons (intern ("xembed-ready"), event.arg); + + + kbd_buffer_store_event (&event); + +} + +void +xwidget_show_view (struct xwidget_view *xv) +{ + xv->hidden = 0; + gtk_widget_show(GTK_WIDGET(xv->widgetwindow)); + gtk_fixed_move (GTK_FIXED (xv->emacswindow), GTK_WIDGET (xv->widgetwindow), xv->x + xv->clip_left, xv->y + xv->clip_top); //TODO refactor +} + + +/* hide an xvidget view */ +void +xwidget_hide_view (struct xwidget_view *xv) +{ + xv->hidden = 1; + //gtk_widget_hide(GTK_WIDGET(xw->widgetwindow)); + gtk_fixed_move (GTK_FIXED (xv->emacswindow), GTK_WIDGET (xv->widgetwindow), + 10000, 10000); +} + + +void +xwidget_plug_added(GtkSocket *socket, + gpointer user_data) +{ + //hmm this doesnt seem to get called for foreign windows + printf("xwidget_plug_added\n"); +} + +gboolean +xwidget_plug_removed(GtkSocket *socket, + gpointer user_data) +{ + printf("xwidget_plug_removed\n"); + return TRUE; /* dont run the default handler because that kills the socket and we want to reuse it*/ +} + + +void +xwidget_slider_changed (GtkRange *range, + gpointer user_data) +{ + //slider value changed. change value of siblings + //correspondingly. but remember that changing value will again + //trigger signal + + //TODO MVC view storage wont be an array futureish so the loop needs to change eventually + //TODO MVC it would be nice if this code could be reusable but, alas, C is not a functional language + //issues are: + // - the type of the controllers value (double, boolean etc) + // - the getter and setter (but they can be func pointers) + // a behemoth macro is always an option. + double v=gtk_range_get_value(range); + struct xwidget_view* xvp = g_object_get_data (G_OBJECT (range), XG_XWIDGET_VIEW); + struct xwidget_view* xv; + + printf("slider changed val:%f\n", v); + + + //block sibling views signal handlers + for (int i = 0; i < MAX_XWIDGETS; i++) + { + xv = &xwidget_views[i]; + if(xv->initialized && xvp->model == xv->model){ + g_signal_handler_block( xv->widget,xv->handler_id); + } + } + //set values of sibling views and unblock + for (int i = 0; i < MAX_XWIDGETS; i++) + { + xv = &xwidget_views[i]; + if(xv->initialized && xvp->model == xv->model){ + gtk_range_set_value(GTK_RANGE(xv->widget), v); + g_signal_handler_unblock( xv->widget,xv->handler_id); + } + } + +} + + +/* when the off-screen webkit master view changes this signal is called. + it copies the bitmap from the off-screen webkit instance */ +gboolean +webkit_osr_damage_event_callback (GtkWidget *widget, GdkEventExpose *event, gpointer data) +{ + //TODO this is wrong! should just oueu a redraw of onscreen widget + struct xwidget* xw = (struct xwidget*) g_object_get_data (G_OBJECT (widget), XG_XWIDGET); + struct xwidget_view* xv; + //webkit_osr_redraw_child(xw, widget); + printf ("damage\n"); + for (int i = 0; i < MAX_XWIDGETS; i++)//todo mvc refactor + { + xv = &xwidget_views[i]; + if(xv->initialized && xv->model == xw){ + gtk_widget_queue_draw (xv->widget); //redraw all views, the master has changed + } + } + + return FALSE; +} + + + +gboolean +webkit_osr_key_event_callback (GtkWidget *widget, GdkEventKey *event, gpointer data) +{ + printf("terminating a webkit osr keypress\n"); + //TRUE terminate the event here. no paren handlers will be called. but webkit then doesng get the event and it still crashes + //FALSE paren handlers will be called. webkit then gets the event and it still crashes + return TRUE; +} + + +void +store_xwidget_event_string(struct xwidget* xw, char* eventname,char* eventstr) +{ + //refactor attempt + struct input_event event; + Lisp_Object xwl; + XSETXWIDGET(xwl,xw); + EVENT_INIT (event); + event.kind = XWIDGET_EVENT; + event.frame_or_window = Qnil; //frame; //how to get the frame here? //TODO i store it in the xwidget now + + event.arg = Qnil; + event.arg = Fcons (build_string(eventstr), event.arg); //string so dont intern + event.arg = Fcons (xwl, event.arg); //TODO + event.arg = Fcons (intern (eventname), event.arg);//interning should be ok + kbd_buffer_store_event (&event); + +} + +//TODO deprecated, use load-status +void +webkit_osr_document_load_finished_callback (WebKitWebView *webkitwebview, + WebKitWebFrame *arg1, + gpointer data) +{ + //TODO this event sending code should be refactored + // struct xwidget *xw = (struct xwidget *) data; + struct xwidget* xw = (struct xwidget*) g_object_get_data (G_OBJECT (webkitwebview), XG_XWIDGET); + printf("webkit finished loading\n"); + + store_xwidget_event_string(xw, + "document-load-finished", ""); +} + +gboolean +webkit_osr_download_callback (WebKitWebView *webkitwebview, + WebKitDownload *arg1, + gpointer data) +{ + //TODO this event sending code should be refactored + struct input_event event; + // struct xwidget *xw = (struct xwidget *) data; + struct xwidget* xw = (struct xwidget*) g_object_get_data (G_OBJECT (webkitwebview), XG_XWIDGET); + printf("download requested %s\n", webkit_download_get_uri (arg1)); + + + printf("webkit finished loading\n"); + + store_xwidget_event_string(xw, "download-requested", webkit_download_get_uri (arg1)); + + return FALSE; +} + +gboolean +webkit_osr_mime_type_policy_typedecision_requested_callback(WebKitWebView *webView, + WebKitWebFrame *frame, + WebKitNetworkRequest *request, + gchar *mimetype, + WebKitWebPolicyDecision *policy_decision, + gpointer user_data) +{ + printf("mime policy requested\n"); + // this function makes webkit send a download signal for all unknown mime types + // TODO defer the decision to lisp, so that its possible to make Emacs handle text mime for instance + if(!webkit_web_view_can_show_mime_type(webView, mimetype)){ + webkit_web_policy_decision_download (policy_decision); + return TRUE; + }else{ + return FALSE; + } +} + + +gboolean +webkit_osr_new_window_policy_decision_requested_callback(WebKitWebView *webView, + WebKitWebFrame *frame, + WebKitNetworkRequest *request, + WebKitWebNavigationAction *navigation_action, + WebKitWebPolicyDecision *policy_decision, + gpointer user_data) +{ + struct xwidget* xw = (struct xwidget*) g_object_get_data (G_OBJECT (webView), XG_XWIDGET); + printf("webkit_osr_new_window_policy_decision_requested_callback %s\n", + webkit_web_navigation_action_get_original_uri (navigation_action)); + + store_xwidget_event_string(xw, "new-window-policy-decision-requested", webkit_web_navigation_action_get_original_uri (navigation_action) + ); + return FALSE; +} + +gboolean +webkit_osr_navigation_policy_decision_requested_callback(WebKitWebView *webView, + WebKitWebFrame *frame, + WebKitNetworkRequest *request, + WebKitWebNavigationAction *navigation_action, + WebKitWebPolicyDecision *policy_decision, + gpointer user_data) +{ + struct xwidget* xw = (struct xwidget*) g_object_get_data (G_OBJECT (webView), XG_XWIDGET); + printf("webkit_osr_navigation_policy_decision_requested_callback %s\n", + webkit_web_navigation_action_get_original_uri (navigation_action)); + store_xwidget_event_string(xw, "navigation-policy-decision-requested", webkit_web_navigation_action_get_original_uri (navigation_action) + ); + return FALSE; +} + +//for gtk3 webkit_osr +gboolean +xwidget_osr_draw_callback (GtkWidget *widget, cairo_t *cr, gpointer data) +{ + struct xwidget* xw = (struct xwidget*) g_object_get_data (G_OBJECT (widget), XG_XWIDGET); + struct xwidget_view* xv = (struct xwidget_view*) g_object_get_data (G_OBJECT (widget), XG_XWIDGET_VIEW); + + // printf("xwidget_osr_draw_callback gtk3 xw.id:%d xw.type:%d window:%d vis:%d\n", + // xw,xw->type, gtk_widget_get_window (widget), gtk_widget_get_visible (xw->widget_osr)); + + cairo_rectangle(cr, 0,0, xv->clip_right, xv->clip_bottom);//xw->width, xw->height); + cairo_clip(cr); + + gtk_widget_draw (xw->widget_osr, cr); + + + return FALSE; +} + + +gboolean +xwidget_osr_button_callback (GtkWidget *widget, + GdkEvent *event, + gpointer user_data) +{ + struct xwidget* xw = (struct xwidget*) g_object_get_data (G_OBJECT (widget), XG_XWIDGET); + GdkEvent* eventcopy = gdk_event_copy(event); + + ((GdkEventButton*)eventcopy)->window = gtk_widget_get_window(xw->widget_osr); + gtk_main_do_event(eventcopy); //TODO this will leak events. they should be deallocated later + return TRUE; //dont propagate this event furter +} + + +GIRepository *girepository ; +DEFUN( "xwgir-require-namespace",Fxwgir_require_namespace, Sxwgir_require_namespace, 2,2,0, + doc: /*require a namespace. must be done for all namespaces we want to use, before using other xwgir functions.*/) + (Lisp_Object lnamespace, Lisp_Object lnamespace_version) +{ + char* namespace = SDATA(lnamespace); + char* namespace_version = SDATA(lnamespace_version); + GError *error = NULL; + + girepository = g_irepository_get_default(); + g_irepository_require(girepository, namespace, namespace_version, 0, &error); + if (error) { + g_error("ERROR: %s\n", error->message); + return Qnil; + } + return Qt; +} + +GtkWidget* xwgir_create(char* class, char* namespace){ + //TODO this is more or less the same as xwgir-call-method, so should be refactored + //create a gtk widget, given its name + //find the constructor + //call it + //also figure out how to pass args + + GError *error = NULL; + GIArgument return_value; + + GIObjectInfo* obj_info = g_irepository_find_by_name(girepository, namespace, class); + GIFunctionInfo* f_info = g_object_info_find_method (obj_info, "new"); + g_function_info_invoke(f_info, + NULL, 0, + NULL, 0, + &return_value, + NULL); + return return_value.v_pointer; + +} + +int +xwgir_convert_lisp_to_gir_arg(GIArgument* giarg, + GIArgInfo* arginfo, + Lisp_Object lisparg ) +{ + + GITypeTag tag; + gboolean is_pointer; + gboolean is_enum; + tag = g_type_info_get_tag (g_arg_info_get_type (arginfo)); + + switch (tag) + { + case GI_TYPE_TAG_BOOLEAN: + giarg->v_boolean = XFASTINT(lisparg); + break; + case GI_TYPE_TAG_INT8: + giarg->v_int8 = XFASTINT(lisparg); + break; + case GI_TYPE_TAG_UINT8: + giarg->v_uint8 = XFASTINT(lisparg); + break; + case GI_TYPE_TAG_INT16: + giarg->v_int16 = XFASTINT(lisparg); + break; + case GI_TYPE_TAG_UINT16: + giarg->v_uint16 = XFASTINT(lisparg); + break; + case GI_TYPE_TAG_INT32: + giarg->v_int32 = XFASTINT(lisparg); + break; + case GI_TYPE_TAG_UINT32: + giarg->v_uint32 = XFASTINT(lisparg); + break; + + case GI_TYPE_TAG_INT64: + giarg->v_int64 = XFASTINT(lisparg); + break; + case GI_TYPE_TAG_UINT64: + giarg->v_uint64 = XFASTINT(lisparg); + break; + + + case GI_TYPE_TAG_FLOAT: + giarg->v_float = XFLOAT_DATA(lisparg); + break; + + case GI_TYPE_TAG_DOUBLE: + giarg->v_double = XFLOAT_DATA(lisparg); + break; + + case GI_TYPE_TAG_UTF8: + case GI_TYPE_TAG_FILENAME: + //giarg->v_string = SDATA(lisparg); + giarg->v_pointer = SDATA(lisparg); + break; + + case GI_TYPE_TAG_ARRAY: + case GI_TYPE_TAG_GLIST: + case GI_TYPE_TAG_GSLIST: + case GI_TYPE_TAG_GHASH: + case GI_TYPE_TAG_ERROR: + case GI_TYPE_TAG_INTERFACE: + case GI_TYPE_TAG_VOID: + case GI_TYPE_TAG_UNICHAR: + case GI_TYPE_TAG_GTYPE: + //?? i dont know how to handle these yet TODO + printf("failed in my lisp to gir arg conversion duties. sob!\n"); + return -1; + break; + } + return 0; +} + +DEFUN ("xwgir-call-method", Fxwgir_call_method, Sxwgir_call_method, 3, 3, 0, + doc: /* call xwidget object method.*/) + (Lisp_Object xwidget, Lisp_Object method, Lisp_Object arguments) +{ + GError *error = NULL; + GIArgument return_value; + GIArgument in_args[20]; + + + struct xwidget* xw; + if(!XXWIDGETP(xwidget)) {printf("ERROR not an xwidget\n"); return Qnil;}; + if(Qnil == xwidget) {printf("ERROR xwidget nil\n"); return Qnil;}; + xw = XXWIDGET(xwidget); + if(NULL == xw) printf("ERROR xw is 0\n"); + char* namespace = SDATA(Fcar(Fget(xw->type, Qcxwgir_class))); + //we need the concrete widget, which happens in 2 ways depending on OSR or not TODO + GtkWidget* widget = NULL; + if(NULL == xw->widget_osr) { + widget = xwidget_view_lookup (xw, XWINDOW(FRAME_SELECTED_WINDOW (SELECTED_FRAME ()))) -> widget; + } else { + widget = xw->widget_osr; + } + + //char* class = SDATA(SYMBOL_NAME(xw->type)); //this works but is unflexible + //figure out the class from the widget instead + /* printf("type class: %s %s\n", G_OBJECT_TYPE_NAME(widget), G_OBJECT_CLASS_NAME(G_OBJECT_GET_CLASS(widget))); */ + /* char* class = G_OBJECT_TYPE_NAME(widget); //gives "GtkButton"(I want "Button") */ + /* class += strlen(namespace); //TODO check for corresponding api method. but this seems to work. */ + + char* class = SDATA(Fcar(Fcdr(Fget(xw->type, Qcxwgir_class)))); + + GIObjectInfo* obj_info = g_irepository_find_by_name(girepository, namespace, class); + GIFunctionInfo* f_info = g_object_info_find_method (obj_info, SDATA(method)); + + //loop over args, convert from lisp to primitive type, given arg introspection data + //TODO g_callable_info_get_n_args(f_info) should match + int argscount = XFASTINT(Flength(arguments)); + if(argscount != g_callable_info_get_n_args(f_info)){ + printf("xwgir call method arg count doesn match! \n"); + return Qnil; + } + int i; + for (i = 1; i < argscount + 1; ++i) + { + xwgir_convert_lisp_to_gir_arg(&in_args[i], g_callable_info_get_arg(f_info, i - 1), Fnth(i - 1, arguments)); + } + + in_args[0].v_pointer = widget; + if(g_function_info_invoke(f_info, + in_args, argscount + 1, + NULL, 0, + &return_value, + &error)) { + //g_error("ERROR: %s\n", error->message); + printf("invokation error\n"); + return Qnil; + } + return Qt; +} + + + + +int xwidget_view_index=0; + +/* initializes and does initial placement of an xwidget view on screen */ +struct xwidget_view* +xwidget_init_view (struct xwidget *xww, + struct glyph_string *s, + int x, int y) +{ + //TODO temp code replace with lisp list + struct xwidget_view *xv; + GdkColor color; + + do{ + if(xwidget_view_index < MAX_XWIDGETS) + xwidget_view_index++; + else + xwidget_view_index=0; + + xv = &xwidget_views[xwidget_view_index]; + }while( xv->initialized == 1); //TODO yeah this can infloop if there are MAX_WIDGETS on-screen + + xv->initialized = 1; + xv->w = s->w; + xv->model = xww; + + //widget creation + if(EQ(xww->type, Qbutton)) + { + xv->widget = gtk_button_new_with_label (XSTRING(xww->title)->data); + g_signal_connect (G_OBJECT (xv->widget), "clicked", + G_CALLBACK (buttonclick_handler), xww); //the model rather than the view + } else if (EQ(xww->type, Qtoggle)) { + xv->widget = gtk_toggle_button_new_with_label (XSTRING(xww->title)->data); + //xv->widget = gtk_entry_new ();//temp hack to experiment with key propagation TODO entry widget is useful for testing + } else if (EQ(xww->type, Qsocket)) { + xv->widget = gtk_socket_new (); + g_signal_connect_after(xv->widget, "plug-added", G_CALLBACK(xwidget_plug_added), "plug added"); + g_signal_connect_after(xv->widget, "plug-removed", G_CALLBACK(xwidget_plug_removed), "plug removed"); + //TODO these doesnt help + gtk_widget_add_events(xv->widget, GDK_KEY_PRESS); + gtk_widget_add_events(xv->widget, GDK_KEY_RELEASE); + } else if (EQ(xww->type, Qslider)) { + xv->widget = + //gtk_hscale_new (GTK_ADJUSTMENT(gtk_adjustment_new (0.0, 0.0, 100.0, 1.0, 10.0, 10.0))); + gtk_hscale_new_with_range ( 0.0, 100.0, 10.0); + gtk_scale_set_draw_value (GTK_SCALE (xv->widget), FALSE); //i think its emacs role to show text and stuff, so disable the widgets own text + xv->handler_id = g_signal_connect_after(xv->widget, "value-changed", G_CALLBACK(xwidget_slider_changed), "slider changed"); + } else if (EQ(xww->type, Qcairo)) { + //Cairo view + //uhm cairo is differentish in gtk 3. + //gdk_cairo_create (gtk_widget_get_window (FRAME_GTK_WIDGET (s->f))); +#ifdef HAVE_GOOCANVAS + xv->widget = goo_canvas_new(); + GooCanvasItem *root, *rect_item, *text_item; + goo_canvas_set_bounds (GOO_CANVAS (xv->widget), 0, 0, 1000, 1000); + root = goo_canvas_get_root_item (GOO_CANVAS (xv->widget)); + rect_item = goo_canvas_rect_new (root, 100, 100, 400, 400, + "line-width", 10.0, + "radius-x", 20.0, + "radius-y", 10.0, + "stroke-color", "yellow", + "fill-color", "red", + NULL); + + text_item = goo_canvas_text_new (root, "Hello World", 300, 300, -1, + GTK_ANCHOR_CENTER, + "font", "Sans 24", + NULL); + goo_canvas_item_rotate (text_item, 45, 300, 300); + +#endif +#ifdef HAVE_CLUTTER + xv->widget = gtk_clutter_embed_new ();; + ClutterActor *stage = NULL; + stage = gtk_clutter_embed_get_stage (GTK_CLUTTER_EMBED ( xv->widget)); + ClutterColor stage_color = { 0xaa, 0xaa, 0xaa, 0xff }; /* Black */ + clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_color); + + ClutterActor * texture = clutter_cairo_texture_new (1000, 1000); + clutter_container_add_actor(stage, texture); + clutter_actor_set_position(texture, 0,0); + clutter_actor_show(texture); + + cairo_t *cr; + cr = clutter_cairo_texture_create (CLUTTER_CAIRO_TEXTURE (texture)); + + /* draw on the context */ + RsvgHandle *h = rsvg_handle_new_from_file ("/tmp/tst.svg", + NULL); + + rsvg_handle_render_cairo(h, cr); + cairo_destroy (cr); + + /* Show the stage: */ + clutter_actor_show (stage); +#endif + } else if (EQ(xww->type, Qwebkit_osr)||EQ(xww->type, Qsocket_osr)) { +#ifdef HAVE_WEBKIT_OSR + xv->widget = gtk_drawing_area_new(); + gtk_widget_set_app_paintable ( xv->widget, TRUE); //because expose event handling + gtk_widget_add_events(xv->widget, + GDK_BUTTON_PRESS_MASK + | GDK_BUTTON_RELEASE_MASK + | GDK_POINTER_MOTION_MASK); + g_signal_connect (G_OBJECT ( xv->widget), "draw", + G_CALLBACK (xwidget_osr_draw_callback), NULL); + g_signal_connect (G_OBJECT ( xv->widget), "button-press-event", + G_CALLBACK (xwidget_osr_button_callback), NULL); + g_signal_connect (G_OBJECT ( xv->widget), "button-release-event", + G_CALLBACK (xwidget_osr_button_callback), NULL); + g_signal_connect (G_OBJECT ( xv->widget), "motion-notify-event", + G_CALLBACK (xwidget_osr_button_callback), NULL); + /* g_signal_connect (G_OBJECT ( xv->widget), "key-press-event", */ + /* G_CALLBACK (xwidget_osr_button_callback), NULL); */ + /* g_signal_connect (G_OBJECT ( xv->widget), "key-release-event", */ + /* G_CALLBACK (xwidget_osr_button_callback), NULL); */ + +#endif + + + } else { + //here we have run out of hard coded symbols, we will now attempt to create + //a widget dynamically + //TODO + // - support OSR + // - support constructor args + // - support signals + // - check that the argument widget type actually exists + printf("xwgir symbol %s %s %s:\n",SDATA(SYMBOL_NAME(xww->type)), SDATA(Fcar(Fcdr(Fget(xww->type, Qcxwgir_class)))), SDATA(Fcar(Fget(xww->type, Qcxwgir_class)))); + //xv->widget = xwgir_create ("Button"); + Fcar(Fget(xww->type, Qcxwgir_class)); + xv->widget = xwgir_create( SDATA(Fcar(Fcdr(Fget(xww->type, Qcxwgir_class)))), + SDATA(Fcar(Fget(xww->type, Qcxwgir_class)))); + + } + + //else return NULL; + + //widget realization + //make container widget 1st, and put the actual widget inside the container + //later, drawing should crop container window if necessary to handle case where xwidget + //is partially obscured by other emacs windows + //other containers than gtk_fixed where explored, but gtk_fixed had the most predictable behaviour so far. + xv->emacswindow = GTK_CONTAINER (FRAME_GTK_WIDGET (s->f)); + xv->widgetwindow = GTK_CONTAINER (gtk_fixed_new ()); + gtk_widget_set_has_window(GTK_WIDGET ( xv->widgetwindow), TRUE); + gtk_container_add (xv->widgetwindow, xv->widget); + + //store some xwidget data in the gtk widgets + g_object_set_data (G_OBJECT (xv->widget), XG_FRAME_DATA, (gpointer) (s->f)); //the emacs frame + g_object_set_data (G_OBJECT (xv->widget), XG_XWIDGET, (gpointer) (xww)); //the xwidget + g_object_set_data (G_OBJECT (xv->widget), XG_XWIDGET_VIEW, (gpointer) (xv)); //the xwidget + g_object_set_data (G_OBJECT (xv->widgetwindow), XG_XWIDGET, (gpointer) (xww)); //the xwidget window + g_object_set_data (G_OBJECT (xv->widgetwindow), XG_XWIDGET_VIEW, (gpointer) (xv)); //the xwidget window + + + gtk_widget_set_size_request (GTK_WIDGET (xv->widget), xww->width, xww->height); + gtk_widget_set_size_request (GTK_WIDGET (xv->widgetwindow), xww->width, xww->height); + gtk_fixed_put (GTK_FIXED (FRAME_GTK_WIDGET (s->f)), GTK_WIDGET (xv->widgetwindow), x, y); + xv->x = x; xv->y = y; + gtk_widget_show_all (GTK_WIDGET (xv->widgetwindow)); + + //widgettype specific initialization only possible after realization + if (EQ(xww->type, Qsocket)) { + printf ("xwid:%d socket id:%x %d\n", + xww, + gtk_socket_get_id (GTK_SOCKET (xv->widget)), + gtk_socket_get_id (GTK_SOCKET (xv->widget))); + send_xembed_ready_event (xww, + gtk_socket_get_id (GTK_SOCKET (xv->widget))); + //gtk_widget_realize(xw->widget); + } + return xv; +} + + +void +x_draw_xwidget_glyph_string (struct glyph_string *s) +{ + /* + this method is called by the redisplay engine and places the xwidget on screen. + moving and clipping is done here. also view init. + + */ + int box_line_hwidth = eabs (s->face->box_line_width); + int box_line_vwidth = max (s->face->box_line_width, 0); + int height = s->height; + struct xwidget *xww = s->xwidget; + struct xwidget_view *xv = xwidget_view_lookup(xww, (s->w)); + int clip_right; int clip_bottom; int clip_top; int clip_left; + + int x = s->x; + int y = s->y + (s->height / 2) - (xww->height / 2); + int moved=0; + + if (xv == NULL || xv->initialized == 0){ + /* Views must be initialized once(only once). + We do it here in the display loop because there is no other time to know things like + window placement etc. + */ + printf ("xv init for xw %d\n", xww); + xv = xwidget_init_view (xww, s, x, y); + } + + //calculate clipping, which is used for all manner of onscreen xwidget views + //each widget border can get clipped by other emacs objects so there are four clipping variables + clip_right = min (xww->width, WINDOW_RIGHT_EDGE_X (s->w) - x - WINDOW_RIGHT_SCROLL_BAR_AREA_WIDTH(s->w) - WINDOW_RIGHT_FRINGE_WIDTH(s->w)); + clip_left = max (0, WINDOW_LEFT_EDGE_X (s->w) - x + WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH(s->w) + WINDOW_LEFT_FRINGE_WIDTH(s->w)); + + clip_bottom = min (xww->height, WINDOW_BOTTOM_EDGE_Y (s->w) - WINDOW_MODE_LINE_HEIGHT (s->w) - y); + clip_top = max(0, WINDOW_TOP_EDGE_Y(s->w) -y ); + + //we are conserned with movement of the onscreen area. the area might sit still when the widget actually moves + //this happens when an emacs window border moves across a widget window + //so, if any corner of the outer widget clippng window moves, that counts as movement here, even + //if it looks like no movement happens because the widget sits still inside the clipping area. + //the widget can also move inside the clipping area, which happens later + moved = (xv->x + xv->clip_left != x+clip_left) + || ((xv->y + xv->clip_top)!= (y+clip_top)); + if(moved) printf ("lxwidget moved: id:%d (%d,%d)->(%d,%d) y+clip_top:%d\n", xww, xv->x, xv->y, x, y, y + clip_top); + else + printf ("lxwidget DIDNT move: id:%d (%d,%d)->(%d,%d) y+clip_top:%d\n", xww, xv->x, xv->y, x, y, y + clip_top); + xv->x = x; + xv->y = y; + if (moved) //has it moved? + { + if (1)//!xwidget_hidden(xv)) //hidden equals not being seen during redisplay + { + //TODO should be possible to use xwidget_show_view here + gtk_fixed_move (GTK_FIXED (FRAME_GTK_WIDGET (s->f)), + GTK_WIDGET (xv->widgetwindow), + x + clip_left, y + clip_top); + } + } + //clip the widget window if some parts happen to be outside drawable area + //an emacs window is not a gtk window, a gtk window covers the entire frame + //cliping might have changed even if we havent actualy moved, we try figure out when we need to reclip for real + if((xv->clip_right != clip_right) + || (xv->clip_bottom != clip_bottom) + || (xv->clip_top != clip_top) + || (xv->clip_left != clip_left)){ + gtk_widget_set_size_request (GTK_WIDGET (xv->widgetwindow), clip_right + clip_left, clip_bottom + clip_top); + gtk_fixed_move(GTK_FIXED(xv->widgetwindow), xv->widget, -clip_left, -clip_top); + printf("reclip %d %d -> %d %d clip_top:%d clip_left:%d\n",xv->clip_right, xv->clip_bottom, clip_right, clip_bottom, clip_top , clip_left); + + + xv->clip_right = clip_right; xv->clip_bottom = clip_bottom; xv->clip_top = clip_top;xv->clip_left = clip_left; + } + //if emacs wants to repaint the area where the widget lives, queue a redraw + //TODO it seems its possible to get out of sync with emacs redraws so emacs bg sometimes shows up instead of xwidget + //its just a visual glitch though + if (!xwidget_hidden(xv)){ + gtk_widget_queue_draw (GTK_WIDGET(xv->widgetwindow)); + gtk_widget_queue_draw (xv->widget); + } +} + + +#ifdef HAVE_WEBKIT_OSR + +//FUGLY macro that checks WEBKIT_IS_WEB_VIEW(xw->widget_osr) first +#define WEBKIT_FN_INIT() \ + struct xwidget* xw; \ +if(!XXWIDGETP(xwidget)) {printf("ERROR not an xwidget\n"); return Qnil;}; \ +if(Qnil == xwidget) {printf("ERROR xwidget nil\n"); return Qnil;}; \ + xw = XXWIDGET(xwidget); \ + if(NULL == xw) printf("ERROR xw is 0\n"); \ + if((NULL == xw->widget_osr) || !WEBKIT_IS_WEB_VIEW(xw->widget_osr)){ \ + printf("ERROR xw->widget_osr does not hold a webkit instance\n");\ + return Qnil;\ + }; + + +DEFUN ("xwidget-webkit-goto-uri", Fxwidget_webkit_goto_uri, Sxwidget_webkit_goto_uri, + 2, 2, 0, + doc: /* webkit goto uri.*/) + (Lisp_Object xwidget, Lisp_Object uri) +{ + WEBKIT_FN_INIT(); + webkit_web_view_load_uri ( WEBKIT_WEB_VIEW(xw->widget_osr), SDATA(uri)); + return Qnil; +} + + +DEFUN ("xwidget-webkit-execute-script", Fxwidget_webkit_execute_script, Sxwidget_webkit_execute_script, + 2, 2, 0, + doc: /* webkit exec js.*/) + (Lisp_Object xwidget, Lisp_Object script) +{ + WEBKIT_FN_INIT(); + webkit_web_view_execute_script( WEBKIT_WEB_VIEW(xw->widget_osr), SDATA(script)); + return Qnil; +} + +DEFUN ("xwidget-webkit-get-title", Fxwidget_webkit_get_title, Sxwidget_webkit_get_title, + 1, 1, 0, + doc: /* webkit get title. can be used to work around exec method lacks return val*/) + (Lisp_Object xwidget) +{ + //TODO support multibyte strings + WEBKIT_FN_INIT(); + const gchar* str=webkit_web_view_get_title( WEBKIT_WEB_VIEW(xw->widget_osr)); + //return make_string_from_bytes(str, wcslen((const wchar_t *)str), strlen(str)); + if(str == 0){ + //TODO maybe return Qnil instead. I suppose webkit returns nullpointer when doc is not properly loaded or something + printf("xwidget-webkit-get-title null webkit title\n"); + return build_string(""); + } + return build_string(str); +} + +//TODO missnamed +DEFUN("xwidget-disable-plugin-for-mime", Fxwidget_disable_plugin_for_mime , Sxwidget_disable_plugin_for_mime, + 1,1,0, doc: /* */) + (Lisp_Object mime) +{ + WebKitWebPlugin *wp = webkit_web_plugin_database_get_plugin_for_mimetype + (webkit_get_web_plugin_database(), SDATA(mime)); + if(wp == NULL) return Qnil; + if(webkit_web_plugin_get_enabled (wp)){ + webkit_web_plugin_set_enabled (wp, FALSE); + return Qt; + } + return Qnil; +} + + +//attempting a workaround for a webkit offscreen bug +//TODO verify its still needed +void +gtk_window_get_position (GtkWindow *window, + gint *root_x, + gint *root_y) +{ + printf("my getsize\n"); + *root_x = 0; + *root_y = 0; +} + +void +xwidget_webkit_dom_dump(WebKitDOMNode* parent) +{ + WebKitDOMNodeList* list; + int i; + int length; + WebKitDOMNode* attribute; + WebKitDOMNamedNodeMap* attrs; + WebKitDOMNode* child; + printf("node:%d type:%d name:%s content:%s\n", + parent, + webkit_dom_node_get_node_type(parent),//1 element 3 text 8 comment 2 attribute + webkit_dom_node_get_local_name(parent), + webkit_dom_node_get_text_content(parent)); + + if(webkit_dom_node_has_attributes(parent)){ + attrs = webkit_dom_node_get_attributes(parent); + + length = webkit_dom_named_node_map_get_length(attrs); + for (int i = 0; i < length; i++) { + attribute = webkit_dom_named_node_map_item(attrs,i); + printf(" attr node:%d type:%d name:%s content:%s\n", + attribute, + webkit_dom_node_get_node_type(attribute),//1 element 3 text 8 comment + webkit_dom_node_get_local_name(attribute), + webkit_dom_node_get_text_content(attribute)); + } + } + list = webkit_dom_node_get_child_nodes(parent); + length = webkit_dom_node_list_get_length(list); + + for (int i = 0; i < length; i++) { + child = webkit_dom_node_list_item(list, i); + //if(webkit_dom_node_has_child_nodes(child)) + xwidget_webkit_dom_dump(child); + } +} + + +DEFUN ("xwidget-webkit-dom-dump", Fxwidget_webkit_dom_dump, Sxwidget_webkit_dom_dump, + 1, 1, 0, + doc: /* webkit dom dump*/) + (Lisp_Object xwidget) +{ + WEBKIT_FN_INIT(); + xwidget_webkit_dom_dump(WEBKIT_DOM_NODE(webkit_web_view_get_dom_document( WEBKIT_WEB_VIEW(xw->widget_osr)))); + return Qnil; +} + + + +#endif + + + + + +DEFUN ("xwidget-resize", Fxwidget_resize, Sxwidget_resize, 3, 3, 0, doc: + /* resize xwidgets*/) + (Lisp_Object xwidget, Lisp_Object new_width, Lisp_Object new_height) +{ + struct xwidget* xw = XXWIDGET(xwidget); + struct xwidget_view *xv; + int w, h; + + CHECK_NUMBER (new_width); + CHECK_NUMBER (new_height); + w = XFASTINT (new_width); + h = XFASTINT (new_height); + + + printf("resize xwidget %d (%d,%d)->(%d,%d)\n",xw, xw->width,xw->height,w,h); + xw->width=w; + xw->height=h; + //if theres a osr resize it 1st + if(xw->widget_osr){ + printf("resize xwidget_osr\n"); + //gtk_container_set_resize_mode ( GTK_WINDOW(xw->widgetwindow_osr), GTK_RESIZE_QUEUE); + //gtk_container_set_resize_mode ( GTK_WINDOW(xw->widget_osr), GTK_RESIZE_QUEUE); + + + //gtk_layout_set_size (GTK_LAYOUT (xw->widgetwindow_osr), xw->width, xw->height); + gtk_widget_set_size_request (GTK_WIDGET (xw->widget_osr), xw->width, xw->height); //minimum size + //gtk_window_resize( GTK_WINDOW(xw->widget_osr), xw->width, xw->height); + gtk_window_resize( GTK_WINDOW(xw->widgetwindow_osr), xw->width, xw->height); + gtk_container_resize_children ( GTK_WINDOW(xw->widgetwindow_osr)); + + } + + for (int i = 0; i < MAX_XWIDGETS; i++) //TODO MVC refactor lazy linear search + { + xv = &xwidget_views[i]; + if(xv->initialized && xv->model == xw){ + gtk_layout_set_size (GTK_LAYOUT (xv->widgetwindow), xw->width, xw->height); + gtk_widget_set_size_request (GTK_WIDGET (xv->widget), xw->width, xw->height); + } + } + + return Qnil; +} + +DEFUN ("xwidget-size-request", Fxwidget_size_request, Sxwidget_size_request, 1, 1, 0, doc: + /* desired size (TODO crashes if arg not osr widget)*/) + (Lisp_Object xwidget) +{ + GtkRequisition requisition; + Lisp_Object rv; + gtk_widget_size_request(XXWIDGET(xwidget)->widget_osr, &requisition); + rv = Qnil; + rv = Fcons (make_number(requisition.height), rv); + rv = Fcons (make_number(requisition.width), rv); + return rv; + +} + +DEFUN ("xwidgetp", Fxwidgetp, Sxwidgetp, 1, 1, 0, + doc: /* Return t if OBJECT is a xwidget. */) + (Lisp_Object object) +{ + return XWIDGETP (object) ? Qt : Qnil; +} + +DEFUN("xwidget-info", Fxwidget_info , Sxwidget_info, 1,1,0, doc: /* get xwidget props */) + (Lisp_Object xwidget) +{ + Lisp_Object info; + struct xwidget* xw = XXWIDGET(xwidget); + + info = Fmake_vector (make_number (4), Qnil); + XSETSYMBOL (XVECTOR (info)->contents[0], xw->type); + XSETSTRING (XVECTOR (info)->contents[1], xw->title); + XSETINT (XVECTOR (info)->contents[2], xw->width); + XSETINT (XVECTOR (info)->contents[3], xw->height); + + + return info; +} + + +DEFUN("xwidget-view-info", Fxwidget_view_info , Sxwidget_view_info, 2,2,0, doc: /* get xwidget view props */) + (Lisp_Object xwidget, Lisp_Object window) +{ + struct xwidget* xw = XXWIDGET(xwidget); + struct xwidget_view* xv = xwidget_view_lookup(xw, XWINDOW(window)); + + Lisp_Object info; + + info = Fmake_vector (make_number (6), Qnil); + XVECTOR (info)->contents[0] = make_number(xv->x); + XVECTOR (info)->contents[1] = make_number(xv->y); + XVECTOR (info)->contents[2] = make_number(xv->clip_right); + XVECTOR (info)->contents[3] = make_number(xv->clip_bottom); + XVECTOR (info)->contents[4] = make_number(xv->clip_top); + XVECTOR (info)->contents[5] = make_number(xv->clip_left); + + return info; +} + +DEFUN ("xwidget-send-keyboard-event", Fxwidget_send_keyboard_event, Sxwidget_send_keyboard_event, 2, 2, 0, doc:/* synthesize a kbd event for a xwidget. */ + ) + (Lisp_Object xwidget, Lisp_Object keydescriptor) +{ + //TODO this code crashes for offscreen widgets and ive tried many different strategies + //int keyval = 0x058; //X + int keyval = XFASTINT(keydescriptor); //X + char *keystring = ""; + GdkKeymapKey* keys; + gint n_keys; + GdkDeviceManager* manager; + struct xwidget *xw; + GtkWidget* widget; + GdkEventKey* ev; + Lisp_Object window; + //popup_activated_flag = 1; //TODO just a hack + gdk_keymap_get_entries_for_keyval(gdk_keymap_get_default(), keyval, &keys, &n_keys); + + xw = XXWIDGET(xwidget); + + ev = (GdkEventKey*)gdk_event_new(GDK_KEY_PRESS); + + + //todo what about windowless widgets? + + window = FRAME_SELECTED_WINDOW (SELECTED_FRAME ()); + + + //TODO maybe we also need to special case sockets by picking up the plug rather than the socket + if(xw->widget_osr) + widget = xw->widget_osr; + else + widget = xwidget_view_lookup(xw, XWINDOW(window))->widget; + + ev->window = gtk_widget_get_window(widget); + gtk_widget_grab_focus(widget); + ev->send_event = FALSE; + + ev->hardware_keycode = keys[0].keycode; + ev->group = keys[0].group; + + ev->keyval = keyval; + ev->time = GDK_CURRENT_TIME; + + //ev->device = gdk_device_get_core_pointer(); + manager = gdk_display_get_device_manager(gdk_window_get_display(ev->window)); + gdk_event_set_device ((GdkEvent*)ev, gdk_device_manager_get_client_pointer(manager)); + gdk_event_put((GdkEvent*)ev); + //g_signal_emit_by_name(ev->window,"key-press-event", ev); + + ev->type = GDK_KEY_RELEASE; + gdk_event_put((GdkEvent*)ev); + //g_signal_emit_by_name(ev->window,"key-release-event", ev); + //gtk_main_do_event(ev); + + //TODO + //if I delete the event the receiving component eventually crashes. + //it ough TDTRT since event_put is supposed to copy the event + //so probably this leaks events now + //gdk_event_free((GdkEvent*)ev); + + return Qnil; +} + + + +DEFUN("xwidget-delete-zombies", Fxwidget_delete_zombies , Sxwidget_delete_zombies, 0,0,0, doc: /* */) + (void) +{ + /* + - remove all views with window gone + + TODO + - remove all xwidgets with buffer gone + - remove all views with xw gone + + */ + struct xwidget_view* xv = NULL; + Lisp_Object w; + for (int i = 0; i < MAX_XWIDGETS; i++){ + xv = &xwidget_views[i]; + XSETWINDOW(w, xv->w); + if(xv->initialized && (! (WINDOW_LIVE_P(w)))){ + + gtk_widget_destroy(GTK_WIDGET(xv->widgetwindow)); + xv->initialized = 0; + } + } +} + + +DEFUN ("xwidget-plist", Fxwidget_plist, Sxwidget_plist, + 1, 1, 0, + doc: /* Return the plist of XWIDGET. */) + (register Lisp_Object xwidget) +{ + //CHECK_XWIDGET (xwidget); //todo + return XXWIDGET (xwidget)->plist; +} + +DEFUN ("xwidget-buffer", Fxwidget_buffer, Sxwidget_buffer, + 1, 1, 0, + doc: /* Return the buffer of XWIDGET. */) + (register Lisp_Object xwidget) +{ + //CHECK_XWIDGET (xwidget); //todo + return XXWIDGET (xwidget)->buffer; +} + +DEFUN ("set-xwidget-plist", Fset_xwidget_plist, Sset_xwidget_plist, + 2, 2, 0, + doc: /* Replace the plist of XWIDGET with PLIST. Returns PLIST. */) + (register Lisp_Object xwidget, Lisp_Object plist) +{ + //CHECK_XWIDGET (xwidget); //todo + CHECK_LIST (plist); + + XXWIDGET (xwidget)->plist = plist; + return plist; +} + + + +void +syms_of_xwidget (void) +{ + int i; + + defsubr (&Smake_xwidget); + defsubr (&Sxwidgetp); + defsubr (&Sxwidget_info); + defsubr (&Sxwidget_view_info); + defsubr (&Sxwidget_resize); + +#ifdef HAVE_WEBKIT_OSR + defsubr (&Sxwidget_webkit_goto_uri); + defsubr (&Sxwidget_webkit_execute_script); + defsubr (&Sxwidget_webkit_get_title); + DEFSYM (Qwebkit_osr ,"webkit-osr"); +#endif + + defsubr (&Sxwgir_call_method ); + defsubr (&Sxwgir_require_namespace); + defsubr (&Sxwidget_size_request ); + defsubr (&Sxwidget_delete_zombies); + defsubr (&Sxwidget_disable_plugin_for_mime); + + defsubr (&Sxwidget_send_keyboard_event); + defsubr (&Sxwidget_webkit_dom_dump); + defsubr (&Sxwidget_plist); + defsubr (&Sxwidget_buffer); + defsubr (&Sset_xwidget_plist); + + DEFSYM (Qxwidget ,"xwidget"); + + DEFSYM (Qcxwidget ,":xwidget"); + DEFSYM (Qcxwgir_class ,":xwgir-class"); + DEFSYM (Qtitle ,":title"); + + DEFSYM (Qbutton, "Button"); //changed to match the gtk class because xwgir(experimental and not really needed) + DEFSYM (Qtoggle, "ToggleButton"); + DEFSYM (Qslider, "slider"); + DEFSYM (Qsocket, "socket"); + DEFSYM (Qsocket_osr, "socket-osr"); + DEFSYM (Qcairo, "cairo"); + + DEFSYM (QCplist, ":plist"); + + DEFVAR_LISP ("xwidget-alist", Vxwidget_alist, doc: /*xwidgets list*/); + Vxwidget_alist = Qnil; + DEFVAR_LISP ("xwidget-view-alist", Vxwidget_view_alist, doc: /*xwidget views list*/); + Vxwidget_alist = Qnil; + + Fprovide (intern ("xwidget-internal"), Qnil); + + // for (i = 0; i < MAX_XWIDGETS; i++) + //xwidgets[i].initialized = 0; +} + + +/* Value is non-zero if OBJECT is a valid Lisp xwidget specification. A + valid xwidget specification is a list whose car is the symbol + `xwidget', and whose rest is a property list. The property list must + contain a value for key `:type'. That value must be the name of a + supported xwidget type. The rest of the property list depends on the + xwidget type. */ + +int +valid_xwidget_p (Lisp_Object object) +{ + int valid_p = 0; + + if (XWIDGETP (object)) + { + /* Lisp_Object tem; */ + + /* for (tem = XCDR (object); CONSP (tem); tem = XCDR (tem)) */ + /* if (EQ (XCAR (tem), QCtype)) */ + /* { */ + /* tem = XCDR (tem); */ + /* if (CONSP (tem) && SYMBOLP (XCAR (tem))) */ + /* { */ + /* struct xwidget_type *type; */ + /* type = lookup_xwidget_type (XCAR (tem)); */ + /* if (type) */ + /* valid_p = type->valid_p (object); */ + /* } */ + + /* break; */ + /* } */ + //never mind type support for now + valid_p = 1; + } + + return valid_p; +} + + + +/* find a value associated with key in spec */ +Lisp_Object +xwidget_spec_value ( Lisp_Object spec, Lisp_Object key, + int *found) +{ + Lisp_Object tail; + - xassert (valid_xwidget_p (spec)); ++ eassert (valid_xwidget_p (spec)); + + for (tail = XCDR (spec); + CONSP (tail) && CONSP (XCDR (tail)); tail = XCDR (XCDR (tail))) + { + if (EQ (XCAR (tail), key)) + { + if (found) + *found = 1; + return XCAR (XCDR (tail)); + } + } + + if (found) + *found = 0; + return Qnil; +} + + +void +xwidget_view_delete_all_in_window (struct window *w) +{ + struct xwidget_view* xv = NULL; + for (int i = 0; i < MAX_XWIDGETS; i++){ + xv = &xwidget_views[i]; + if(xv->initialized && xv->w == w){ + gtk_widget_destroy(GTK_WIDGET(xv->widgetwindow)); + xv->initialized = 0; + } + } +} + + + +struct xwidget_view* +xwidget_view_lookup (struct xwidget* xw, struct window *w) +{ + struct xwidget_view* xv = NULL; + for (int i = 0; i < MAX_XWIDGETS; i++){ + xv = &xwidget_views[i]; + if (xv->initialized && (xv->model == xw) && (xv->w == w)) + return xv; + } + return NULL; /* we didnt find a matching view */ +} + +struct xwidget* +lookup_xwidget (Lisp_Object spec) +{ + /* When a xwidget lisp spec is found initialize the C struct that is used in the C code. + This is done by redisplay so values change if the spec changes. + So, take special care of one-shot events + + TODO remove xwidget init from display spec. simply store an xwidget reference only and set + size etc when creating the xwidget, which should happen before insertion into buffer + */ + int found = 0, found1 = 0, found2 = 0; + Lisp_Object value; + struct xwidget *xw; + + value = xwidget_spec_value (spec, Qcxwidget, &found1); + xw = XXWIDGET(value); + + /* value = xwidget_spec_value (spec, QCtype, &found); */ + /* xw->type = SYMBOLP (value) ? value : Qbutton; //default to button */ + /* value = xwidget_spec_value (spec, Qtitle, &found2); */ + /* xw->title = STRINGP (value) ? (char *) SDATA (value) : "?"; //funky cast FIXME TODO */ + + /* value = xwidget_spec_value (spec, QCheight, NULL); */ + /* xw->height = INTEGERP (value) ? XFASTINT (value) : 50; */ + /* value = xwidget_spec_value (spec, QCwidth, NULL); */ + /* xw->width = INTEGERP (value) ? XFASTINT (value) : 50; */ + + /* value = xwidget_spec_value (spec, QCplist, NULL); */ + /* xw->plist = value; */ + /* coordinates are not known here */ + printf ("lookup_xwidget xwidget_id:%d type:%d found:%d %d %d title:'%s' (%d,%d)\n", xw, + xw->type, found, found1, found2, xw->title, xw->height, xw->width); + + //assert_valid_xwidget_id (id, "lookup_xwidget"); + return xw; +} + +/*set up detection of touched xwidget*/ +void +xwidget_start_redisplay (void) +{ + int i; + for (i = 0; i < MAX_XWIDGETS; i++) + xwidget_views[i].redisplayed = 0; + +} + +/* the xwidget was touched during redisplay, so it isnt a candidate for hiding*/ +void +xwidget_touch (struct xwidget_view *xv) +{ + xv->redisplayed = 1; +} + +int +xwidget_touched (struct xwidget_view *xv) +{ + return xv->redisplayed; +} + +/* redisplay has ended, now we should hide untouched xwidgets +*/ +void +xwidget_end_redisplay (struct window *w, struct glyph_matrix *matrix) +{ + + int i; + struct xwidget *xw; + int area; + + + xwidget_start_redisplay (); + //iterate desired glyph matrix of window here, hide gtk widgets + //not in the desired matrix. + + //this only takes care of xwidgets in active windows. + //if a window goes away from screen xwidget views wust be deleted + + // dump_glyph_matrix(matrix, 2); + for (i = 0; i < matrix->nrows; ++i) + { + // dump_glyph_row (MATRIX_ROW (matrix, i), i, glyphs); + struct glyph_row *row; + row = MATRIX_ROW (matrix, i); + if (row->enabled_p != 0) + { + for (area = LEFT_MARGIN_AREA; area < LAST_AREA; ++area) + { + struct glyph *glyph = row->glyphs[area]; + struct glyph *glyph_end = glyph + row->used[area]; + for (; glyph < glyph_end; ++glyph) + { + if (glyph->type == XWIDGET_GLYPH) + { + /* + the only call to xwidget_end_redisplay is in dispnew + xwidget_end_redisplay(w->current_matrix); + */ + xwidget_touch (xwidget_view_lookup(glyph->u.xwidget, + w)); + } + } + } + } + } + + for (i = 0; i < MAX_XWIDGETS; i++) + { + struct xwidget_view* xv = &xwidget_views[i]; + + //"touched" is only meaningful for the current window, so disregard other views + if (xv->initialized && ( xv->w == w)) + { + if (xwidget_touched(xv)) + xwidget_show_view (xv); + else + xwidget_hide_view (xv); + } + } +} + + +#endif