dnl This is the input file which autoconf uses to construct adnl "configure" script for the tecla library. It is a bourne shelldnl script which autoconf pre-processes with the m4 preprocessor todnl expand autoconf-defined m4 macros such as AC_INIT().  Thednl following line just initializes autoconf. Autoconf interprets thednl single argument as the name of an arbitrary file, which it uses todnl ensure that it is being run correctly from the directory whichdnl contains the libtecla source code.AC_INIT(getline.c)dnl Here we set the major version number of the tecla library.dnl Incrementing this number implies that a change has been made todnl the library's public interface, which makes it binary incompatiblednl with programs that were linked with previous shared versions ofdnl the tecla library.  Incompatible changes of this type should bednl avoided at all costs, so it is hoped that the major version numberdnl won't ever have to change. The major version number must be adnl small integer number, preferably a single numeric digit.AC_SUBST(MAJOR_VER)MAJOR_VER="1"dnl Set the minor version number of the tecla library. This numberdnl should be incremented by one whenever additional functionality,dnl such as new functions or modules, are added to the library. Thednl idea is that a program that was linked with a shared library ofdnl the same major version number, but a lower minor version number,dnl will continue to function when the run-time loader links itdnl against the updated version.  The minor version number must be adnl small integer number, which should be reset to 0 whenever thednl major version number is incremented.AC_SUBST(MINOR_VER)MINOR_VER="4"dnl Set the micro version number of the tecla library. This isdnl incremented whenever modifications to the library are made whichdnl make no changes to the public interface, but which fix bugs and/ordnl improve the behind-the-scenes implementation.  The micro versiondnl number should be reset to 0 whenever the minor version number isdnl incremented.  The micro version number must be a small integerdnl number.AC_SUBST(MICRO_VER)MICRO_VER="0"dnl The AC_PROG_CC line looks for a C compiler, and if gcc is chosen,dnl sets the $GCC shell variable to "yes". Make sure that CFLAGS isdnl set to something first, to prevent AC_PROG_CC from substituting -gdnl for the optimization level.CFLAGS="$CFLAGS"AC_PROG_CCdnl Apparently not all implementations of the 'make' command definednl the MAKE variable. The following directive creates a variablednl called SET_MAKE which when expanded in a makefile is either emptydnl if the local 'make' command was found to define the MAKE variable,dnl or contains an assignment which will give the MAKE variable thednl value 'make'.AC_PROG_MAKE_SETdnl The following directive causes autoconf to see if symbolic linksdnl are supported on the current filesystem. If so, it sets thednl variable LN_S to "ln -s". Otherwise it sets LN_S to just "ln".dnl This allows us to create symbolic links where possible, but fallsdnl back to creating hard links where symbolic links aren't available.AC_PROG_LN_Sdnl The following macro searches for the best implementation of awkdnl on the host system, and records it in the AWK shell variable.AC_PROG_AWKdnl The following directive tells autoconf to figure out the targetdnl system type and assign a canonical name for this to the $targetdnl shell variable. This is used below in the target-specific casednl statement.AC_CANONICAL_SYSTEMdnl In early versions of Solaris, some libraries are in /usr/ccs/lib,dnl where gcc doesn't look. The tests below for the curses librarydnl would thus fail without this directory being added to the searchdnl path. We thus add it here before the tests. Note that in thednl following, since [ and ] are m4 quotes, and m4 will remove thednl outermost quotes when it processes this file, we have to doublednl them up here to get [0-6] to appear in the output configurednl script.case $target in*-sun-solaris2.[[0-6]]|*-sun-solaris2.[[0-6]].*)  LIBS="$LIBS -L/usr/ccs/lib"  ;;esacdnl The following lines look for terminfo functions in the normaldnl curses library. If not found, they are searched for in the GNUdnl ncurses library. If the terminfo functions still aren't found,dnl then termcap functions are searched for in the curses library.  Ifdnl either set of functions is found, the corresponding variablednl USE_TERMINFO or USE_TERMCAP is arranged to be defined in CFLAGS,dnl via the exported DEFINES shell variable, and the library in whichdnl they were found is appended to the LIBS shell variable.AC_CHECK_LIB(curses, tigetstr, [  AC_DEFINE(USE_TERMINFO)  LIBS="$LIBS -lcurses"], [AC_CHECK_LIB(ncurses, tigetstr, [  AC_DEFINE(USE_TERMINFO)  LIBS="$LIBS -lncurses"], [AC_CHECK_LIB(curses, tgetstr, [  AC_DEFINE(USE_TERMCAP)  LIBS="$LIBS -lcurses"  AC_CHECK_HEADER(termcap.h, AC_DEFINE(HAVE_TERMCAP_H))])])])dnl The following variable lists the targets that will be created ifdnl the user runs make without any arguments. Initially we assumednl that we can create both the normal and the reentrant versionsdnl of the library.AC_SUBST(TARGETS)TARGETS="normal reentrant"dnl Check for reentrant functions by attempting to compile and link adnl temporary program which calls them, being sure to include thednl appropriate headers and define _POSIX_C_SOURCE, just in case anydnl of the functions are defined as macros. In the following,dnl AC_CACHE_CHECK outputs the message "checking for reentrantdnl functions". If this check has been done before, it assigns thednl cached yes/no value to tecla_cv_reentrant.  Otherwise it usesdnl AC_TRY_LINK() to attempt to compile and link the specified dummydnl program, and sets tecla_cv_reentrant to yes or no, depending ondnl whether this succeeds. Finally it caches the value ofdnl tecla_cv_reentrant in the file config.cache, and writes "yes" ordnl "no" to the terminal.AC_CACHE_CHECK(for reentrant functions, tecla_cv_reentrant, [  KEPT_CFLAGS="$CFLAGS"  CFLAGS="$CFLAGS -D_POSIX_C_SOURCE=199506L"  AC_TRY_LINK([#include <unistd.h>#include <sys/types.h>#include <sys/stat.h>#include <dirent.h>#include <pwd.h>  ], [    (void) readdir_r(NULL, NULL, NULL);    (void) getpwuid_r(geteuid(), NULL, NULL, 0, NULL);    (void) getpwnam_r(NULL, NULL, NULL, 0, NULL);  ], tecla_cv_reentrant=yes, tecla_cv_reentrant=no)  CFLAGS="$KEPT_CFLAGS"])dnl If the necessary reentrant functions weren't found to bednl available, default to only compiling the non-reentrant version ofdnl the library.if test $tecla_cv_reentrant = no; then  TARGETS="normal"fidnl Check for the select system call with the normal arguments,dnl by attempting to compile and link a temporary program whichdnl calls it, being sure to include the appropriate headers.dnl In the following, AC_CACHE_CHECK outputs the messagednl "checking for select system call". If this check has been donednl before, it assigns the cached yes/no value to tecla_cv_select.dnl Otherwise it uses AC_TRY_LINK() to attempt to compile and linkdnl the specified dummy program, and sets tecla_cv_select to yesdnl or no, depending on whether this succeeds. Finally it cachesdnl the value of tecla_cv_select in the file config.cache, anddnl writes "yes" or "no" to the terminal.AC_CACHE_CHECK(for select system call, tecla_cv_select, [  AC_TRY_LINK([#ifdef HAVE_SELECT_H#include <select.h>#endif#include <sys/time.h>#include <sys/types.h>#include <unistd.h>  ], [    fd_set fds;    int nready;    FD_ZERO(&fds);    FD_SET(1, &fds);    nready = select(2, &fds, &fds, &fds, NULL);  ], tecla_cv_select=yes, tecla_cv_select=no)])dnl If the select function was available, arrange for HAVE_SELECT todnl be defined by CFLAGS.if test $tecla_cv_select = yes; then  AC_DEFINE(HAVE_SELECT)fidnl Check if this system supports the system V pseudo terminal interface.AC_CACHE_CHECK(for SysV pseudo-terminals, tecla_cv_sysv_pty, [  AC_TRY_LINK([#include <stdlib.h>#include <unistd.h>#include <stropts.h>  ], [    char *name = ptsname(0);    int i1 = grantpt(0);    int i2 = unlockpt(0);    int i3 = ioctl(0, I_PUSH, "ptem");    return 0;  ], tecla_cv_sysv_pty=yes, tecla_cv_sysv_pty=no)])dnl If the system-V pseudo-terminal interface is available, arrangednl for HAVE_SYSV_PTY to be defined by CFLAGS.if test $tecla_cv_sysv_pty = yes; then  AC_DEFINE(HAVE_SYSV_PTY)fidnl The following variable contains the extension to append todnl "libtecla" and "libtecla_r" when creating shared libraries on thednl target platform.  This is system dependent and is ignored ifdnl LINK_SHARED remains an empty string. On most platforms thatdnl support shared libaries, this will be .so.$MAJOR_VER, wherednl MAJOR_VER is the major version number described above, which ondnl some systems, tells the run-time loader if the program beingdnl loaded is binary compatible with a given version of the librarydnl (see the discussion of MAJOR_VER near the top of this file).dnl The following empty default can be overriden on a system by systemdnl basis later in this file.AC_SUBST(SHARED_EXT)SHARED_EXT=""dnl When a shared library is installed with the extension $SHARED_EXT,dnl you can optionally produce other copies of this library withdnl different extensions. This is done using symbolic or hard links,dnl depending on what is available on the current filesystem, and thednl extensions to use for these links are listed in the followingdnl variable, separated by spaces. The following empty default can bednl overriden on a system by system basis later in this file.AC_SUBST(SHARED_ALT)SHARED_ALT=""dnl The following variable lists extra compilation flags needed todnl create object files that can be included in shared libraries.dnl Normally one would include a flag to tell the C compiler todnl compile position-independent code. This option commonly includesdnl the acronym 'pic'.AC_SUBST(SHARED_CFLAGS)SHARED_CFLAGS=""dnl On systems that support shared libraries, the following variablednl provides the command needed to make a shared library. In thisdnl variable, $$@ will be replaced with the name of the shareddnl library, $$(LIB_OBJECTS) will be replaced with a space separateddnl list of the object files that are to be included in the library,dnl and libtecla$$(SUFFIX) will be the name of the library beingdnl built, minus the system-specific extension (eg. libtecla ordnl libtecla_r).  If LINK_SHARED is left as an empty string, shareddnl library creation will not attempted. If your system supportsdnl shared library creation, you should override the default value ofdnl this variable in the target-specific case statement later in thisdnl file.AC_SUBST(LINK_SHARED)LINK_SHARED=""dnl The following bourne shell case statement is where systemdnl dependencies can be added.  In particular, if your system supportsdnl shared library creation, the following switch is the place todnl configure it. To do so you will first need to find out what targetdnl type was just assigned by the AC_CANONICAL_SYSTEM macro executeddnl previously.  The target type of your current system can bednl determined by cd'ing to the top level directory of the tecladnl distribution, and typing the command "sh config.guess". This willdnl report what autoconf thinks the system type is. Note that thisdnl will be very specific, so if you know that the configurationdnl parameters that you are about to provide apply to differentdnl versions of the current system type, you can express this in thednl case statement by using a wild-card in place of the versiondnl number, or by using an | alternation to list one or more versiondnl names. Beware that autoconf uses [] as quote characters, so if youdnl want to use a regexp character range like [a-z], you should writednl this as [[a-z]].case $target in*solaris*)  AC_DEFINE(__EXTENSIONS__)  SHARED_EXT=".so.${MAJOR_VER}"  SHARED_ALT=".so"  LINK_SHARED='ld -G -M $$(srcdir)/libtecla.map -o $$@ -h $$(@F) -z defs -i $$(LIB_OBJECTS) $$(LIBS) -lc'  SHARED_CFLAGS="-Kpic"  case $CC in  */cc|cc) SHARED_CFLAGS="$SHARED_CFLAGS -xstrconst" ;;  gcc) CFLAGS="-I/usr/include $CFLAGS" ;;  esac  case $target in  *sparc*) SHARED_CFLAGS="$SHARED_CFLAGS -xregs=no%appl"  esac  ;;*linux*)  SHARED_EXT=".so.${MAJOR_VER}.${MINOR_VER}.${MICRO_VER}"  SHARED_ALT=".so .so.${MAJOR_VER}"dnl See if the installed version of Gnu ld accepts version scripts.  AC_CACHE_CHECK([for --version-script in GNU ld], tecla_cv_gnu_ld_script, [    if (echo 'void dummy(void) {return;}' > dummy.c; $CC -c -fpic dummy.c; \         ld -o dummy.so dummy.o -shared --version-script=$srcdir/libtecla.map) 1>&2 2>/dev/null; then      tecla_cv_gnu_ld_script=yes    else      tecla_cv_gnu_ld_script=no    fi    rm -f dummy.c dummy.o dummy.so  ])  if test $tecla_cv_gnu_ld_script = yes; then    VERSION_OPT='--version-script=$$(srcdir)/libtecla.map'  else    VERSION_OPT=''  fi  LINK_SHARED='ld -o $$@ -soname libtecla$$(SUFFIX).so.'${MAJOR_VER}' -shared '$VERSION_OPT' $$(LIB_OBJECTS) $$(LIBS) -lc'  SHARED_CFLAGS="-fpic"  ;;*hpux*)  SHARED_EXT=".${MAJOR_VER}"  SHARED_ALT=".sl"  LINK_SHARED='ld -b +h $$(@F) +k +vshlibunsats -o $$@ -c libtecla.map.opt $$(LIB_OBJECTS) $$(LIBS) -lc'  SHARED_CFLAGS="+z"  ;;*dec-osf*)  AC_DEFINE(_OSF_SOURCE)  ;;esacdnl The following statement checks to see if the GNU C compiler hasdnl been chosen instead of the normal compiler of the host operatingdnl system. If it has, and shared library creation has beendnl configured, it replaces the shared-library-specific C compilationdnl flags with those supported by gcc. Also append the gcc run-timednl library to the shared library link line.if test "$GCC"_ = "yes"_ && test "$LINK_SHARED"_ != "_" ; then  SHARED_CFLAGS="-fpic"  case $target_os in  sparc*solaris*) SHARED_CFLAGS="$SHARED_CFLAGS -mno-app-regs"  esac  LINK_SHARED="$LINK_SHARED `gcc -print-libgcc-file-name`"fidnl The following variable will list which types of libraries,dnl "static", and possibly "shared", are to be created and installed.AC_SUBST(TARGET_LIBS)dnl If shared library creation has been configured, add shareddnl libraries to the list of libraries to be built.if test "$LINK_SHARED"_ != "_"; then  TARGET_LIBS="static shared"else  TARGET_LIBS="static"  LINK_SHARED="@:"fidnl The following directive must always be the last line of anydnl autoconf script. It causes autoconf to create the configurednl script, which for each argument of AC_OUTPUT, will look for adnl filename formed by appending ".in" to the argument, preprocessdnl that file, replacing @VAR@ directives with the corresponding valuednl of the specified shell variable VAR, as set above in this file,dnl and write the resulting output to the filename given in thednl argument. Note that only shell variables that were exported abovednl with the AC_SUBST() directive will be substituted in @VAR@dnl directives (some macros like AC_PROG_CC also call AC_SUBST for youdnl for the variables that they output).AC_OUTPUT(Makefile)