sinclude(config/open-axiom.m4) sinclude(config/aclocal.m4) AC_INIT([OpenAxiom], [1.4.0-2010-02-07], [open-axiom-bugs@lists.sf.net]) AC_CONFIG_AUX_DIR(config) AC_CONFIG_MACRO_DIR(config) AC_CONFIG_HEADERS([config/openaxiom-c-macros.h]) # AM_INIT_AUTOMAKE([foreign]) AC_PREREQ([2.62]) AC_CONFIG_SRCDIR(src/Makefile.pamphlet) AC_CANONICAL_SYSTEM open_axiom_installdir=$libdir/open-axiom/$target/$PACKAGE_VERSION AC_SUBST(open_axiom_installdir) if test $build != $target; then AC_MSG_WARN([Cross build is not supported.]) AC_MSG_WARN([Please notify open-axiom-devel@open-axiom.org if you succeed.]) fi ## Where tools for the build platform are sequestered axiom_build_sharedir=$axiom_builddir/share AC_PROG_CC AC_PROG_CXX ## What is the extension of object and executable files on this platform? AC_OBJEXT AC_DEFINE_UNQUOTED([OPENAXIOM_EXEEXT], ["$ac_cv_exeext"], [Extension of executable file.]) ## Byte order of the host. AC_C_BIGENDIAN oa_use_libtool_for_shared_lib=yes oa_shrobj_flags= oa_shrlib_flags= # Tell Libtool to assume `dlopen' so that it does not have to # emulate it. LT_INIT([pic-only dlopen win32-dll shared]) AC_SUBST([LIBTOOL_DEPS]) # Give me extension of libraries eval shared_ext=\"$shrext_cmds\" AC_SUBST(shared_ext) AC_SUBST(libext) ## Don't use Libtool for building actual DLLs on MinGW and Cygwin ## Libool has been improved to the point of being useless ## for building in-place shared libraries. oa_use_libtool_for_shared_lib=no case $host in *mingw*|*cygwin*) # oa_use_libtool_for_shared_lib=no oa_shrobj_flags='-prefer-pic' oa_shrlib_flags="-shared --export-all-symbols" ;; *darwin*) oa_shrobj_flags='-dynamic' oa_shrlib_flags='-dynamiclib -undefined suppress -flat_namespace' ;; *) oa_shrobj_flags='-prefer-pic' oa_shrlib_flags='-shared' ;; esac AC_SUBST(oa_use_libtool_for_shared_lib) AC_SUBST(oa_shrobj_flags) AC_SUBST(oa_shrlib_flags) axiom_src_subdirs="lib hyper lisp boot interp share algebra input etc doc" AC_SUBST(axiom_src_subdirs) ## On Windows system, we prefer the default installation ## location to be 'C:/Program Files/OpenAxiom', following Windows ## convention. We cannot use AC_PREFIX_DEFAULT directly as it seems ## to operate unconditionally. Therefore, we resort to this dirty ## trick stepping over Autoconf's internals. case $host in *mingw*) ac_default_prefix="C:/Program Files/OpenAxiom" AC_PATH_PROGS([oa_editor],[notepad.exe]) ;; *) AC_PATH_PROGS([oa_editor],[vi]) ;; esac AC_SUBST(oa_editor) ## Accumulate list of utils needed for the build platform ## It is vital that noweb is present in the build environement. axiom_all_prerequisites= case $build in *linux*) # GNU/Linux systems come equipped with GNU Make, called `make' AC_CHECK_PROGS([MAKE], [make], [AC_MSG_ERROR([Make utility missing.])]) ;; *) # Other systems tend to spell it `gmake' and such AC_CHECK_PROGS([MAKE], [gmake make], [AC_MSG_ERROR([Make utility missing.])]) if ! $MAKE --version | grep 'GNU' 2>/dev/null; then AC_MSG_ERROR([OpenAxiom build system needs GNU Make.]) fi ;; esac AC_PROG_INSTALL # AC_PROG_LN_S AC_CHECK_PROG([TOUCH], [touch], [touch], [AC_MSG_ERROR(['touch' program is missing.])]) AC_CHECK_PROGS([MKTEMP], [mktemp]) AC_PROG_AWK AC_PATH_PROGS([HOST_AWK],[awk nawk gawk mawk]) AC_CHECK_PROG([AR], [ar], [ar], [AC_MSG_ERROR([program 'ar' is missing])]) AC_PATH_PROG([PDFLATEX], [pdflatex]) if test -z "$PDFLATEX"; then AC_PATH_PROG([LATEX], [latex], [AC_MSG_NOTICE([Documentation is disabled.])]) fi AC_CHECK_PROGS([MAKEINDEX], [makeindex]) ## --------------------------------------- ## Make sure noweb executable is available ## --------------------------------------- AC_CHECK_PROGS([NOTANGLE], [notangle]) AC_CHECK_PROGS([NOWEAVE], [noweave]) ## In case noweb is missing we need to build our own. if test -z $NOTANGLE -o -z $NOWEAVE ; then ## Yes, but do we have the source files to build from? if test ! -d ${srcdir}/noweb; then AC_MSG_NOTICE([OpenAxiom requires noweb utilties]) AC_MSG_ERROR([Please get the tarball of dependencies and reconfigure]) fi NOTANGLE='$(axiom_build_bindir)/notangle' NOWEAVE='$(axiom_build_bindir)/noweave' axiom_all_prerequisites="$axiom_all_prerequisites all-noweb" fi ## ------------------------ ## -- Which Lisp to use? -- ## ------------------------ ## ## We will default to GCL later, if no lisp implementation is specified. axiom_lisp= axiom_lisp_flavor=unknown # Most Lisp systems don't use conventional methods for building programs. oa_standard_linking=no AC_ARG_WITH([lisp], [ --with-lisp=L use L as Lisp platform], [axiom_lisp=$withval]) ## If --enable-gcl is specified, we need to check for coonsistency axiom_include_gcl= if test -z $axiom_lisp; then AC_ARG_ENABLE([gcl], [ --enable-gcl build GCL from OpenAxiom source], [case $enableval in yes|no) axiom_include_gcl=$enableval ;; *) AC_MSG_ERROR([erroneous value for --enable-gcl]) ;; esac]) fi ## We need to build our own GCL if none is avalaible. if test -z $axiom_lisp; then AC_CHECK_PROGS([AXIOM_LISP], [sbcl gcl ecl clisp]) ## A lisp may not be available AND the GCL source may also ## be missing. Instruct user to either build one or get ## the dependencies from our website. if test -z $AXIOM_LISP && test ! -d ${srcdir}/gcl; then AC_MSG_ERROR([OpenAxiom requires a Lisp system. Either separately build one (GCL-2.6.7, GCL-2.6.8, SBCL, CLisp), or get the dependency tarball from OpenAxiom download website.]) fi axiom_lisp=$AXIOM_LISP else ## Honor use of Lisp image specified on command line AXIOM_LISP=$axiom_lisp AC_SUBST(AXIOM_LISP) : fi ## Some Lisp systems are just too buggy to use. case $AXIOM_LISP in *gcl*) AC_MSG_CHECKING([$AXIOM_LISP version]) v=`$AXIOM_LISP -batch -eval "(format t \"~S\" (lisp-implementation-version))"` AC_MSG_RESULT([$v]) case $v in *2.6.7*|*2.6.8*) ;; # OK *) AC_MSG_WARN([$v is not supported by this version of OpenAxiom. $AXIOM_LISP will be ignored.]) AXIOM_LISP= ;; esac ;; # SBCL-1.0.29 has a nasty regression that prevents OpenAxiom build *sbcl*) AC_MSG_CHECKING([$AXIOM_LISP version]) v=`$AXIOM_LISP --version` AC_MSG_RESULT([$v]) case $v in *1.0.29) AC_MSG_ERROR([This version of SBCL has a bug that breaks OpenAxiom build. Consider SBCL-1.0.30 or higher.]) ;; esac ;; esac ## Coherence check for GCL inclusion. case $axiom_include_gcl,$axiom_lisp in ,|no,|yes*) ## It doesn't make sense not to include GCL when no Lisp image ## is available. Give up. if test $axiom_include_gcl,$AXIOM_LISP = no,; then AC_MSG_ERROR([--disable-gcl specified but no GCL image found]) fi ## No Lisp image was specified and none was available from ## the build environment; build GCL from OpenAxiom source. ## User may explicilty specify --enable-gcl, but may be missing ## the dependency tarball. if test ! -d ${srcdir}/gcl; then AC_MSG_ERROR([The OpenAxiom dependency tarball is missing; please get it from our website.]) fi AXIOM_LISP='$(axiom_build_bindir)/gcl' axiom_all_prerequisites="$axiom_all_prerequisites all-gcl" axiom_include_gcl=yes axiom_lisp_flavor=gcl axiom_fasl_type=o ;; yes,*) AC_MSG_ERROR([--with-lisp=$axiom_lisp conflicts with --enable-gcl]) ;; *) ## As of this writting, the Lisp systems ECL, GCL, SBCL, and CLisp all ## exist at the end of standard input. AC_MSG_CHECKING([which flavor of Lisp]) what=`echo '(lisp-implementation-type)' | $axiom_lisp` case $what in *GCL*) axiom_lisp_flavor=gcl ;; *"ECL"*) axiom_lisp_flavor=ecl oa_standard_linking=yes ;; *"SBCL"*) axiom_lisp_flavor=sbcl ;; *"CLISP"*) ## Not all variants of CLisp have FFI support. FFI is used ## internally used by OpenAxiom in essential way. if ! $axiom_lisp -q -x '*features*' | grep ':FFI' > /dev/null then AC_MSG_ERROR([$axiom_lisp does not support Foreign Function Interface. Please upgrade to a better version of CLisp or install SBCL.]) fi axiom_lisp_flavor=clisp ;; *"Armed Bear Common Lisp"*) axiom_lisp_flavor=abcl ;; *"Clozure Common Lisp"*) axiom_lisp_flavor=clozure ;; esac AC_MSG_RESULT([$axiom_lisp_flavor]) esac AC_SUBST(axiom_include_gcl) AC_SUBST(axiom_lisp_flavor) AC_SUBST(oa_standard_linking) AC_DEFINE_UNQUOTED([OPENAXIOM_BASE_RTS], [openaxiom_${axiom_lisp_flavor}_runtime], [The kind of base runtime system for this build.]) ## The following is a horrible hack to arrange for GCL to successfully ## rebuild symbol tables with "rsym" on Windows platform. It should ## go away as soon as GCL upstream is fixed. case $axiom_lisp_flavor,$target in gcl,*mingw*) axiom_gcl_rsym_hack='d=`echo "(format nil \"~a\" si::*system-directory*)" | $(AXIOM_LISP) | grep "/gcl.*/" | sed -e "s,\",,g"`; cp $$d/rsym$(EXEEXT) .' ;; *) ## Breath. axiom_gcl_rsym_hack=':' ;; esac AC_SUBST(axiom_gcl_rsym_hack) ## If we are using GCL as the base runtime system, then we do really need # a C compiler from GNU. Well, at least for the moment. case $axiom_lisp_flavor,$GCC in gcl,yes) axiom_cflags="-O2 -Wall -D_GNU_SOURCE" ;; gcl,*) AC_MSG_ERROR([We need a GNU C compiler]) ;; esac AC_SUBST(axiom_cflags) ## Can we use dynamically linked libraries? ## Tentatively answer `yes' -- this is modern time. oa_use_dynamic_lib=yes ## How are we supposed to tell the Lisp system to eval an expression ## in batch mode? What is the extension of a compiled Lisp file? case $axiom_lisp_flavor in gcl) axiom_quiet_flags='-batch' axiom_eval_flags='-eval' oa_use_dynamic_lib=no ;; ecl) axiom_quiet_flags= axiom_eval_flags='-norc -eval' oa_use_dynamic_lib=no ;; sbcl) axiom_quiet_flags='--noinform --noprint' axiom_eval_flags='--eval' ;; clisp) axiom_quiet_flags='--quiet' axiom_eval_flags='-norc -x' ;; clozure) axiom_quiet_flags='--quiet --no-init' axiom_eval_flags='--eval' ;; *) AC_MSG_ERROR([We do not know how to build OpenAxiom this $axiom_lisp]) ;; esac AC_SUBST(axiom_quiet_flags) AC_SUBST(axiom_eval_flags) AC_SUBST(oa_use_dynamic_lib) if test -z $axiom_fasl_type; then AC_MSG_CHECKING([compiled Lisp file extension]) ## We set the IFS to as we don't want automatic ## replacement of by . axiom_save_IFS=$IFS IFS=' ' axiom_fasl_type=`$axiom_lisp $axiom_quiet_flags $axiom_eval_flags '(progn (format t "axiom_fasl_type=~a" (pathname-type (compile-file-pathname "foo.lisp"))) (quit))'` ## Now pull out the fasl type. ECL has the habit of spitting noise ## about internal loading. Therefore, we must look only for a line that ## begins with axiom_fasl_type. axiom_fasl_type=`echo $axiom_fasl_type | grep '^axiom_fasl_type'` IFS=$axiom_save_IFS axiom_fasl_type=`echo $axiom_fasl_type | sed -e 's/axiom_fasl_type=//'` if test -z $axiom_fasl_type; then AC_MSG_ERROR([Could not determine extension for compiled Lisp files]) fi AC_MSG_RESULT([$axiom_fasl_type]) fi AC_SUBST(axiom_fasl_type) ## Does it make sense to pretend that we support multithreading? oa_enable_threads=no AC_ARG_ENABLE([threads], [ --enable-threads turn on threads support], [case $enableval in yes|no) oa_enable_threads=$enableval ;; *) AC_MSG_ERROR([erroneous value for --enable-threads]) ;; esac]) # GNU compiler wants to have a hint about multithreading. case $GCC,$oa_enable_threads in yes,yes) axiom_cflags="$axiom_cflags -pthread" esac AC_SUBST(oa_enable_threads) AC_SUBST(axiom_all_prerequisites) axiom_optimize_options=speed ## Shall we proclaim safety? axiom_enable_checking=no # don't turn on checking by default. AC_ARG_ENABLE([checking], [ --enable-checking turn runtime checking on], [case $enableval in yes|no) axiom_enable_checking=$enableval ;; *) AC_MSG_ERROR([erroneous value for --enable-checking]) ;; esac]) if test x"$axiom_enable_checking" = xyes; then case $axiom_lisp_flavor in gcl) # GCL-2.6.x does not understand debug. axiom_optimize_options="$axiom_optimize_options safety" ;; *) axiom_optimize_options="$axiom_optimize_options safety debug" ;; esac AC_MSG_NOTICE([runtime checking may increase compilation time]) fi AC_SUBST(axiom_enable_checking) AC_SUBST(axiom_optimize_options) ## Parse args for profiling-enabled build. oa_enable_profiling=no AC_ARG_ENABLE([profiling], [ --enable-profiling turn profiling on], [case $enableval in yes|no) oa_enable_profiling=$enableval ;; *) AC_MSG_ERROR([erroneous value for --enable-profiling]) ;; esac]) AC_SUBST(oa_enable_profiling) # FIXME: Move this out of here. axiom_c_runtime= AC_SUBST(axiom_c_runtime) AC_CHECK_HEADERS([stdint.h inttypes.h]) AC_TYPE_UINT8_T AC_CHECK_HEADERS([signal.h], [], [AC_MSG_ERROR([OpenAxiom needs signal support.])]) AC_CHECK_DECLS([sigaction], [], [], [#include ]) AC_CHECK_HEADERS([sys/stat.h], [], [AC_MSG_ERROR([OpenAxiom needs ])]) case $host in *mingw*) ;; *) AC_CHECK_HEADERS([dirent.h], [], [AC_MSG_ERROR([OpenAxiom needs ])]) ;; esac AC_CHECK_HEADERS([unistd.h], [], [AC_MSG_ERROR([OpenAxiom needs ])]) AC_CHECK_DECLS([getuid, geteuid, getgid, getegid], [], [], [#include ]) AC_CHECK_DECLS([kill], [], [], [#include ]) case $host in *mingw*) AC_CHECK_HEADERS([winsock2.h], [axiom_host_has_socket=yes], []) axiom_c_runtime_extra="-lwsock32" ;; *) AC_CHECK_HEADERS([sys/socket.h], [axiom_host_has_socket=yes], []) ;; esac if test x$axiom_host_has_socket != xyes; then \ AC_MSG_ERROR([OpenAxiom needs suport for sockets.]) fi ## solaris-based systems tend to hide the socket library. case $host in *solaris*) AC_SEARCH_LIBS([accept], [socket], [], [AC_MSG_ERROR([socket library not found])]) AC_SEARCH_LIBS([gethostbyname], [nsl]) ;; *) ;; esac AC_SUBST(axiom_c_runtime_extra) AC_EGREP_CPP([has_af_local], [#if HAVE_SYS_SOCKET_H # include #else # include #endif #ifdef AF_LOCAL has_af_local #endif ], [AC_DEFINE([HAVE_AF_LOCAL], [1], [Host has AF_LOCAL])]) AC_EGREP_CPP([has_af_unix], [#if HAVE_SYS_SOCKET_H # include #else # include #endif #ifdef AF_UNIX has_af_unix #endif ], [AC_DEFINE([HAVE_AF_UNIX], [1], [Host has AF_UNIX])]) AC_CHECK_HEADERS([sys/wait.h]) if test x"$ac_cv_header_sys_wait_h" = xyes; then \ AC_CHECK_DECLS([wait], [], [], [#include ]) fi AC_CHECK_DECLS([fork], [], [], [#include ]) ## Does this system have openpty or shall we emulate? AC_CHECK_HEADERS([sys/ioctl.h pty.h util.h libutil.h termios.h]) AC_CHECK_DECLS([openpty],[],[], [#if HAVE_PTY_H # include #endif #if HAVE_UTIL_H # include #endif #if HAVE_SYS_IOCTL_H # include #endif #if HAVE_TERMIOS_H # include #endif #if HAVE_LIBUTIL_H # include # include #endif ]) if test x"$ac_cv_have_decl_openpty" = xyes; then \ AC_SEARCH_LIBS([openpty],[util]) fi axiom_use_sman=1 if test x"$ac_cv_have_decl_fork" = xyes \ -a x"$ac_cv_have_decl_wait" = xyes; then \ axiom_c_runtime="$axiom_c_runtime terminal_io" axiom_src_all="$axiom_src_all all-sman all-clef" axiom_src_subdirs="$axiom_src_subdirs clef sman" AXIOM_MAKEFILE([src/clef/Makefile]) AXIOM_MAKEFILE([src/sman/Makefile]) else axiom_use_sman=0 AC_MSG_NOTICE([Superman component is disabled.]) fi AC_DEFINE_UNQUOTED([OPENAXIOM_USE_SMAN], [$axiom_use_sman], [Whether to use the session manager as driver.]) axiom_src_all="all-input $axiom_src_all" AC_PATH_XTRA ## Output directives for the C compiler AC_SUBST(X_CLFAGS) ## Output directives for the linker AC_SUBST(X_LIBS) ## Output any extra libraries required by X11 AC_SUBST(X_EXTRA_LIBS) ## Finally, output the list of libraries that need to appear before -lX11 ## Some part of OpenAxiom depends on Xpm. That library has kind uncertain ## future. At some point in the past, it was deprecated, to be ## replaced by xpm-nox; then came back again. So, its support may ## vary from system to system. For the moment, we assume that if X11 ## is found then, Xpm is already present. Though, clearly that is a ## very optimistic assumption. Long term, OpenAxiom should get rid of ## dependence on Xpm. A nearly fool-proof test would be probably ## inspired by AC_PATH_XTRA. I don't have time to get to that ## complication right now. Will fix later. X_PRE_LIBS="-lXpm $X_PRE_LIBS" AC_SUBST(X_PRE_LIBS) ## If the system supports X11, then build graphics # Check for Qt utilities. AC_CHECK_PROGS([OA_QT_MOC], [moc]) AC_CHECK_PROGS([OA_QT_QMAKE], [qmake]) if test -n "$OA_QT_MOC"; then AC_MSG_CHECKING([Qt version]) oa_qt_version=`"$OA_QT_MOC" -v 2>&1 | sed -e 's/^.*(\(.*\))$/\1/'` AC_MSG_RESULT([$oa_qt_version]) case $oa_qt_version in *[1-3]\.[0-9]+\.[0-9]+) AC_MSG_WARN([This version of Qt is too old for OpenAxiom.]) ;; esac fi axiom_use_x=no if test -z $no_x; then axiom_use_x=yes axiom_c_runtime="$axiom_c_runtime graphics" axiom_src_all="$axiom_src_all all-graph" axiom_src_subdirs="$axiom_src_subdirs graph" AXIOM_MAKEFILE([src/graph/Makefile]) AXIOM_MAKEFILE([src/graph/Gdraws/Makefile]) AXIOM_MAKEFILE([src/graph/view2D/Makefile]) AXIOM_MAKEFILE([src/graph/view3D/Makefile]) AXIOM_MAKEFILE([src/graph/viewAlone/Makefile]) AXIOM_MAKEFILE([src/graph/viewman/Makefile]) else AC_MSG_NOTICE([The Garphics component is disabled.]) fi AC_SUBST(axiom_src_all) AC_SUBST(axiom_use_x) openaxiom_host_has_regex= AC_CHECK_HEADER([regex.h], [openaxiom_host_has_regex=yes], [openaxiom_host_has_regex=no]) AC_SUBST(openaxiom_host_has_regex) axiom_host_has_libbfd= ## Check for these only if we are going to build GCL from source. case $axiom_all_prerequisites in *all-gcl*) AC_CHECK_HEADER([bfd.h]) AC_HAVE_LIBRARY([bfd], [axiom_host_has_libbfd=yes]) axiom_gcl_bfd_option= if test x"$ac_cv_header_bfd_h" = xyes \ && test x"$axiom_host_has_libbfd" = xyes; then axiom_gcl_bfd_option="--disable-dynsysbfd" else axiom_gcl_bfd_option="--disable-statsysbfd --enable-locbfd" fi ;; *) # Nothing to worry about ;; esac # axiom_gcl_mm_option="--enable-maxpage=256*1024" axiom_gcl_x_option="--disable-tkconfig --disable-x --disable-xgcl" axiom_gcl_emacs="--enable-emacs=correct" case $GCC in yes) CCF="-O2 -Wall -D_GNU_SOURCE" ;; esac case $target in *bsd*|*dragonfly*) CCF="-O2 -Wall" ;; windows) SRCDIRS=bootdir interpdir sharedir algebradir etcdir docdir inputdir ;; *solaris*) AC_DEFINE([SUNplatform], [], [SunOS flavour]) ;; powerpc*darwin*) CCF="-O2 -Wall -D_GNU_SOURCE \ -I/usr/include -I/usr/include/sys" axiom_gcl_bfd_option="--disable-statsysbfd \ --enable-machine=powerpc-macosx" axiom_gcl_mm_option="--enable-vssize=65536*2" ;; esac GCLOPTS="$axiom_gcl_emacs $axiom_gcl_bfd_option $axiom_gcl_mm_option $axiom_gcl_x_option" AC_SUBST(CCF) AC_SUBST(GCLOPTS) case $axiom_lisp_flavor in gcl) void_type='void' char_type='char' int_type='int' float_type='float' double_type='double' string_type='string' ;; sbcl) void_type='void' char_type='char' int_type='int' float_type='float' double_type='double' string_type='c-string' ;; clisp) void_type='nil' char_type='character' int_type='int' float_type='single-float' double_type='double-float' string_type='c-string' ;; ecl) void_type=':void' char_type=':char' int_type=':int' float_type=':float' double_type=':double' string_type=':cstring' ;; clozure) void_type=':void' # FIXME: this is not really what we want, but good enough for now. char_type=':unsigned-byte' int_type=':signed-fullword' float_type=':single-float' double_type=':double-float' # Clozure CL wants you to deal with your own mess string_type=':address' ;; *) AC_MSG_ERROR([We do not know how to translate native types for this Lisp]) ;; esac AC_SUBST(void_type) AC_SUBST(char_type) AC_SUBST(int_type) AC_SUBST(float_type) AC_SUBST(double_type) AC_SUBST(string_type) AXIOM_MAKEFILE([Makefile]) AXIOM_MAKEFILE([src/Makefile]) AXIOM_MAKEFILE([src/lib/Makefile]) AXIOM_MAKEFILE([src/hyper/Makefile]) AXIOM_MAKEFILE([src/driver/Makefile]) AXIOM_MAKEFILE([src/lisp/Makefile]) AXIOM_MAKEFILE([src/boot/Makefile]) AXIOM_MAKEFILE([src/interp/Makefile]) AXIOM_MAKEFILE([src/share/Makefile]) AXIOM_MAKEFILE([src/algebra/Makefile]) AXIOM_MAKEFILE([src/input/Makefile]) AXIOM_MAKEFILE([src/etc/Makefile]) AXIOM_MAKEFILE([src/doc/Makefile]) AC_CONFIG_FILES([src/hyper/presea], [chmod +x src/hyper/presea]) ## We now generate the "document" script and support files at configure time. ## We put them in the build directory because they are intended to be ## build support utils only. AC_CONFIG_FILES(build/scripts/document:$srcdir/src/scripts/document.in, \ [chmod +x build/scripts/document]) AC_OUTPUT ## Generate rules to extrad SPAD type definitions from pamphlets. echo -n "extracting list of SPAD type definitions..." egrep '<<(category|domain|package) .*>>=' \ $srcdir/src/algebra/*.spad.pamphlet \ | sort | uniq | \ while IFS=':' read spad_file chunk_desc; do chunk_desc=`echo $chunk_desc | sed -e 's,<<,,' -e 's,>>=,,'` set $chunk_desc; spad_abbrev=$2 cat >> src/algebra/tmp-extract-spad.mk <