tack-1.07/0000755000175100001440000000000011315504666011111 5ustar tomuserstack-1.07/aclocal.m40000644000175100001440000016714111315503376012760 0ustar tomusersdnl*************************************************************************** dnl Copyright (c) 2007,2009 Free Software Foundation, Inc. * dnl * dnl Permission is hereby granted, free of charge, to any person obtaining a * dnl copy of this software and associated documentation files (the * dnl "Software"), to deal in the Software without restriction, including * dnl without limitation the rights to use, copy, modify, merge, publish, * dnl distribute, distribute with modifications, sublicense, and/or sell * dnl copies of the Software, and to permit persons to whom the Software is * dnl furnished to do so, subject to the following conditions: * dnl * dnl The above copyright notice and this permission notice shall be included * dnl in all copies or substantial portions of the Software. * dnl * dnl THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * dnl OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * dnl MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * dnl IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, * dnl DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR * dnl OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR * dnl THE USE OR OTHER DEALINGS IN THE SOFTWARE. * dnl * dnl Except as contained in this notice, the name(s) of the above copyright * dnl holders shall not be used in advertising or otherwise to promote the * dnl sale, use or other dealings in this Software without prior written * dnl authorization. * dnl*************************************************************************** dnl dnl $Id: aclocal.m4,v 1.6 2009/12/26 21:58:22 tom Exp $ dnl dnl Author: Thomas E. Dickey dnl dnl Macros used in TACK test program auto-configuration script. dnl dnl These macros are maintained separately from NCURSES. The copyright on dnl this file applies to the aggregation of macros and does not affect use of dnl these macros in other applications. dnl dnl See http://invisible-island.net/autoconf/ for additional information. dnl dnl --------------------------------------------------------------------------- dnl --------------------------------------------------------------------------- dnl CF_ADD_CFLAGS version: 8 updated: 2009/01/06 19:33:30 dnl ------------- dnl Copy non-preprocessor flags to $CFLAGS, preprocessor flags to $CPPFLAGS dnl The second parameter if given makes this macro verbose. dnl dnl Put any preprocessor definitions that use quoted strings in $EXTRA_CPPFLAGS, dnl to simplify use of $CPPFLAGS in compiler checks, etc., that are easily dnl confused by the quotes (which require backslashes to keep them usable). AC_DEFUN([CF_ADD_CFLAGS], [ cf_fix_cppflags=no cf_new_cflags= cf_new_cppflags= cf_new_extra_cppflags= for cf_add_cflags in $1 do case $cf_fix_cppflags in no) case $cf_add_cflags in #(vi -undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C) #(vi case $cf_add_cflags in -D*) cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^-D[[^=]]*='\''\"[[^"]]*//'` test "${cf_add_cflags}" != "${cf_tst_cflags}" \ && test -z "${cf_tst_cflags}" \ && cf_fix_cppflags=yes if test $cf_fix_cppflags = yes ; then cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags" continue elif test "${cf_tst_cflags}" = "\"'" ; then cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags" continue fi ;; esac case "$CPPFLAGS" in *$cf_add_cflags) #(vi ;; *) #(vi cf_new_cppflags="$cf_new_cppflags $cf_add_cflags" ;; esac ;; *) cf_new_cflags="$cf_new_cflags $cf_add_cflags" ;; esac ;; yes) cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags" cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^[[^"]]*"'\''//'` test "${cf_add_cflags}" != "${cf_tst_cflags}" \ && test -z "${cf_tst_cflags}" \ && cf_fix_cppflags=no ;; esac done if test -n "$cf_new_cflags" ; then ifelse($2,,,[CF_VERBOSE(add to \$CFLAGS $cf_new_cflags)]) CFLAGS="$CFLAGS $cf_new_cflags" fi if test -n "$cf_new_cppflags" ; then ifelse($2,,,[CF_VERBOSE(add to \$CPPFLAGS $cf_new_cppflags)]) CPPFLAGS="$CPPFLAGS $cf_new_cppflags" fi if test -n "$cf_new_extra_cppflags" ; then ifelse($2,,,[CF_VERBOSE(add to \$EXTRA_CPPFLAGS $cf_new_extra_cppflags)]) EXTRA_CPPFLAGS="$cf_new_extra_cppflags $EXTRA_CPPFLAGS" fi AC_SUBST(EXTRA_CPPFLAGS) ])dnl dnl --------------------------------------------------------------------------- dnl CF_ADD_INCDIR version: 12 updated: 2009/01/18 10:00:47 dnl ------------- dnl Add an include-directory to $CPPFLAGS. Don't add /usr/include, since it's dnl redundant. We don't normally need to add -I/usr/local/include for gcc, dnl but old versions (and some misinstalled ones) need that. To make things dnl worse, gcc 3.x may give error messages if -I/usr/local/include is added to dnl the include-path). AC_DEFUN([CF_ADD_INCDIR], [ if test -n "$1" ; then for cf_add_incdir in $1 do while test $cf_add_incdir != /usr/include do if test -d $cf_add_incdir then cf_have_incdir=no if test -n "$CFLAGS$CPPFLAGS" ; then # a loop is needed to ensure we can add subdirs of existing dirs for cf_test_incdir in $CFLAGS $CPPFLAGS ; do if test ".$cf_test_incdir" = ".-I$cf_add_incdir" ; then cf_have_incdir=yes; break fi done fi if test "$cf_have_incdir" = no ; then if test "$cf_add_incdir" = /usr/local/include ; then if test "$GCC" = yes then cf_save_CPPFLAGS=$CPPFLAGS CPPFLAGS="$CPPFLAGS -I$cf_add_incdir" AC_TRY_COMPILE([#include ], [printf("Hello")], [], [cf_have_incdir=yes]) CPPFLAGS=$cf_save_CPPFLAGS fi fi fi if test "$cf_have_incdir" = no ; then CF_VERBOSE(adding $cf_add_incdir to include-path) ifelse($2,,CPPFLAGS,$2)="$ifelse($2,,CPPFLAGS,$2) -I$cf_add_incdir" cf_top_incdir=`echo $cf_add_incdir | sed -e 's%/include/.*$%/include%'` test "$cf_top_incdir" = "$cf_add_incdir" && break cf_add_incdir="$cf_top_incdir" else break fi fi done done fi ])dnl dnl --------------------------------------------------------------------------- dnl CF_ADD_LIBDIR version: 8 updated: 2009/01/18 10:01:08 dnl ------------- dnl Adds to the library-path dnl dnl Some machines have trouble with multiple -L options. dnl dnl $1 is the (list of) directory(s) to add dnl $2 is the optional name of the variable to update (default LDFLAGS) dnl AC_DEFUN([CF_ADD_LIBDIR], [ if test -n "$1" ; then for cf_add_libdir in $1 do if test $cf_add_libdir = /usr/lib ; then : elif test -d $cf_add_libdir then cf_have_libdir=no if test -n "$LDFLAGS$LIBS" ; then # a loop is needed to ensure we can add subdirs of existing dirs for cf_test_libdir in $LDFLAGS $LIBS ; do if test ".$cf_test_libdir" = ".-L$cf_add_libdir" ; then cf_have_libdir=yes; break fi done fi if test "$cf_have_libdir" = no ; then CF_VERBOSE(adding $cf_add_libdir to library-path) ifelse($2,,LDFLAGS,$2)="-L$cf_add_libdir $ifelse($2,,LDFLAGS,$2)" fi fi done fi ])dnl dnl --------------------------------------------------------------------------- dnl CF_ADD_SUBDIR_PATH version: 2 updated: 2007/07/29 10:12:59 dnl ------------------ dnl Append to a search-list for a nonstandard header/lib-file dnl $1 = the variable to return as result dnl $2 = the package name dnl $3 = the subdirectory, e.g., bin, include or lib dnl $4 = the directory under which we will test for subdirectories dnl $5 = a directory that we do not want $4 to match AC_DEFUN([CF_ADD_SUBDIR_PATH], [ test "$4" != "$5" && \ test -d "$4" && \ ifelse([$5],NONE,,[(test $5 = NONE || test -d $5) &&]) { test -n "$verbose" && echo " ... testing for $3-directories under $4" test -d $4/$3 && $1="[$]$1 $4/$3" test -d $4/$3/$2 && $1="[$]$1 $4/$3/$2" test -d $4/$3/$2/$3 && $1="[$]$1 $4/$3/$2/$3" test -d $4/$2/$3 && $1="[$]$1 $4/$2/$3" test -d $4/$2/$3/$2 && $1="[$]$1 $4/$2/$3/$2" } ])dnl dnl --------------------------------------------------------------------------- dnl CF_ANSI_CC_CHECK version: 9 updated: 2001/12/30 17:53:34 dnl ---------------- dnl This is adapted from the macros 'fp_PROG_CC_STDC' and 'fp_C_PROTOTYPES' dnl in the sharutils 4.2 distribution. AC_DEFUN([CF_ANSI_CC_CHECK], [ AC_CACHE_CHECK(for ${CC-cc} option to accept ANSI C, cf_cv_ansi_cc,[ cf_cv_ansi_cc=no cf_save_CFLAGS="$CFLAGS" cf_save_CPPFLAGS="$CPPFLAGS" # Don't try gcc -ansi; that turns off useful extensions and # breaks some systems' header files. # AIX -qlanglvl=ansi # Ultrix and OSF/1 -std1 # HP-UX -Aa -D_HPUX_SOURCE # SVR4 -Xc # UnixWare 1.2 (cannot use -Xc, since ANSI/POSIX clashes) for cf_arg in "-DCC_HAS_PROTOS" \ "" \ -qlanglvl=ansi \ -std1 \ -Ae \ "-Aa -D_HPUX_SOURCE" \ -Xc do CF_ADD_CFLAGS($cf_arg) AC_TRY_COMPILE( [ #ifndef CC_HAS_PROTOS #if !defined(__STDC__) || (__STDC__ != 1) choke me #endif #endif ],[ int test (int i, double x); struct s1 {int (*f) (int a);}; struct s2 {int (*f) (double a);};], [cf_cv_ansi_cc="$cf_arg"; break]) done CFLAGS="$cf_save_CFLAGS" CPPFLAGS="$cf_save_CPPFLAGS" ]) if test "$cf_cv_ansi_cc" != "no"; then if test ".$cf_cv_ansi_cc" != ".-DCC_HAS_PROTOS"; then CF_ADD_CFLAGS($cf_cv_ansi_cc) else AC_DEFINE(CC_HAS_PROTOS) fi fi ])dnl dnl --------------------------------------------------------------------------- dnl CF_ANSI_CC_REQD version: 4 updated: 2008/03/23 14:48:54 dnl --------------- dnl For programs that must use an ANSI compiler, obtain compiler options that dnl will make it recognize prototypes. We'll do preprocessor checks in other dnl macros, since tools such as unproto can fake prototypes, but only part of dnl the preprocessor. AC_DEFUN([CF_ANSI_CC_REQD], [AC_REQUIRE([CF_ANSI_CC_CHECK]) if test "$cf_cv_ansi_cc" = "no"; then AC_MSG_ERROR( [Your compiler does not appear to recognize prototypes. You have the following choices: a. adjust your compiler options b. get an up-to-date compiler c. use a wrapper such as unproto]) fi ])dnl dnl --------------------------------------------------------------------------- dnl CF_ARG_ENABLE version: 3 updated: 1999/03/30 17:24:31 dnl ------------- dnl Allow user to enable a normally-off option. AC_DEFUN([CF_ARG_ENABLE], [CF_ARG_OPTION($1,[$2],[$3],[$4],no)])dnl dnl --------------------------------------------------------------------------- dnl CF_ARG_OPTION version: 3 updated: 1997/10/18 14:42:41 dnl ------------- dnl Restricted form of AC_ARG_ENABLE that ensures user doesn't give bogus dnl values. dnl dnl Parameters: dnl $1 = option name dnl $2 = help-string dnl $3 = action to perform if option is not default dnl $4 = action if perform if option is default dnl $5 = default option value (either 'yes' or 'no') AC_DEFUN([CF_ARG_OPTION], [AC_ARG_ENABLE($1,[$2],[test "$enableval" != ifelse($5,no,yes,no) && enableval=ifelse($5,no,no,yes) if test "$enableval" != "$5" ; then ifelse($3,,[ :]dnl ,[ $3]) ifelse($4,,,[ else $4]) fi],[enableval=$5 ifelse($4,,,[ $4 ])dnl ])])dnl dnl --------------------------------------------------------------------------- dnl CF_CHECK_CACHE version: 11 updated: 2008/03/23 14:45:59 dnl -------------- dnl Check if we're accidentally using a cache from a different machine. dnl Derive the system name, as a check for reusing the autoconf cache. dnl dnl If we've packaged config.guess and config.sub, run that (since it does a dnl better job than uname). Normally we'll use AC_CANONICAL_HOST, but allow dnl an extra parameter that we may override, e.g., for AC_CANONICAL_SYSTEM dnl which is useful in cross-compiles. dnl dnl Note: we would use $ac_config_sub, but that is one of the places where dnl autoconf 2.5x broke compatibility with autoconf 2.13 AC_DEFUN([CF_CHECK_CACHE], [ if test -f $srcdir/config.guess || test -f $ac_aux_dir/config.guess ; then ifelse([$1],,[AC_CANONICAL_HOST],[$1]) system_name="$host_os" else system_name="`(uname -s -r) 2>/dev/null`" if test -z "$system_name" ; then system_name="`(hostname) 2>/dev/null`" fi fi test -n "$system_name" && AC_DEFINE_UNQUOTED(SYSTEM_NAME,"$system_name") AC_CACHE_VAL(cf_cv_system_name,[cf_cv_system_name="$system_name"]) test -z "$system_name" && system_name="$cf_cv_system_name" test -n "$cf_cv_system_name" && AC_MSG_RESULT(Configuring for $cf_cv_system_name) if test ".$system_name" != ".$cf_cv_system_name" ; then AC_MSG_RESULT(Cached system name ($system_name) does not agree with actual ($cf_cv_system_name)) AC_MSG_ERROR("Please remove config.cache and try again.") fi ])dnl dnl --------------------------------------------------------------------------- dnl CF_CHECK_CFLAGS version: 2 updated: 2001/12/30 19:09:58 dnl --------------- dnl Conditionally add to $CFLAGS and $CPPFLAGS values which are derived from dnl a build-configuration such as imake. These have the pitfall that they dnl often contain compiler-specific options which we cannot use, mixed with dnl preprocessor options that we usually can. AC_DEFUN([CF_CHECK_CFLAGS], [ CF_VERBOSE(checking additions to CFLAGS) cf_check_cflags="$CFLAGS" cf_check_cppflags="$CPPFLAGS" CF_ADD_CFLAGS($1,yes) if test "$cf_check_cflags" != "$CFLAGS" ; then AC_TRY_LINK([#include ],[printf("Hello world");],, [CF_VERBOSE(test-compile failed. Undoing change to \$CFLAGS) if test "$cf_check_cppflags" != "$CPPFLAGS" ; then CF_VERBOSE(but keeping change to \$CPPFLAGS) fi CFLAGS="$cf_check_flags"]) fi ])dnl dnl --------------------------------------------------------------------------- dnl CF_CURSES_CONFIG version: 2 updated: 2006/10/29 11:06:27 dnl ---------------- dnl Tie together the configure-script macros for curses. It may be ncurses, dnl but unless asked, we do not make a special search for ncurses. However, dnl still check for the ncurses version number, for use in other macros. AC_DEFUN([CF_CURSES_CONFIG], [ CF_CURSES_CPPFLAGS CF_NCURSES_VERSION CF_CURSES_LIBS ])dnl dnl --------------------------------------------------------------------------- dnl CF_CURSES_CPPFLAGS version: 10 updated: 2009/01/06 19:34:11 dnl ------------------ dnl Look for the curses headers. AC_DEFUN([CF_CURSES_CPPFLAGS],[ AC_CACHE_CHECK(for extra include directories,cf_cv_curses_incdir,[ cf_cv_curses_incdir=no case $host_os in #(vi hpux10.*) #(vi test -d /usr/include/curses_colr && \ cf_cv_curses_incdir="-I/usr/include/curses_colr" ;; sunos3*|sunos4*) test -d /usr/5lib && \ test -d /usr/5include && \ cf_cv_curses_incdir="-I/usr/5include" ;; esac ]) test "$cf_cv_curses_incdir" != no && CPPFLAGS="$CPPFLAGS $cf_cv_curses_incdir" CF_CURSES_HEADER CF_TERM_HEADER ])dnl dnl --------------------------------------------------------------------------- dnl CF_CURSES_HEADER version: 1 updated: 2005/12/31 13:28:25 dnl ---------------- dnl Find a "curses" header file, e.g,. "curses.h", or one of the more common dnl variations of ncurses' installs. dnl dnl See also CF_NCURSES_HEADER, which sets the same cache variable. AC_DEFUN([CF_CURSES_HEADER],[ AC_CACHE_CHECK(if we have identified curses headers,cf_cv_ncurses_header,[ cf_cv_ncurses_header=none for cf_header in \ curses.h \ ncurses.h \ ncurses/curses.h \ ncurses/ncurses.h do AC_TRY_COMPILE([#include <${cf_header}>], [initscr(); tgoto("?", 0,0)], [cf_cv_ncurses_header=$cf_header; break],[]) done ]) if test "$cf_cv_ncurses_header" = none ; then AC_MSG_ERROR(No curses header-files found) fi # cheat, to get the right #define's for HAVE_NCURSES_H, etc. AC_CHECK_HEADERS($cf_cv_ncurses_header) ])dnl dnl --------------------------------------------------------------------------- dnl CF_CURSES_LIBS version: 29 updated: 2009/01/06 19:34:57 dnl -------------- dnl Look for the curses libraries. Older curses implementations may require dnl termcap/termlib to be linked as well. Call CF_CURSES_CPPFLAGS first. AC_DEFUN([CF_CURSES_LIBS],[ AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl AC_MSG_CHECKING(if we have identified curses libraries) AC_TRY_LINK([#include <${cf_cv_ncurses_header-curses.h}>], [initscr(); tgoto("?", 0,0)], cf_result=yes, cf_result=no) AC_MSG_RESULT($cf_result) if test "$cf_result" = no ; then case $host_os in #(vi freebsd*) #(vi AC_CHECK_LIB(mytinfo,tgoto,[LIBS="-lmytinfo $LIBS"]) ;; hpux10.*) #(vi AC_CHECK_LIB(cur_colr,initscr,[ LIBS="-lcur_colr $LIBS" ac_cv_func_initscr=yes ],[ AC_CHECK_LIB(Hcurses,initscr,[ # HP's header uses __HP_CURSES, but user claims _HP_CURSES. LIBS="-lHcurses $LIBS" CPPFLAGS="$CPPFLAGS -D__HP_CURSES -D_HP_CURSES" ac_cv_func_initscr=yes ])]) ;; linux*) # Suse Linux does not follow /usr/lib convention CF_ADD_LIBDIR(/lib) ;; sunos3*|sunos4*) if test -d /usr/5lib ; then CF_ADD_LIBDIR(/usr/5lib) LIBS="$LIBS -lcurses -ltermcap" fi ac_cv_func_initscr=yes ;; esac if test ".$ac_cv_func_initscr" != .yes ; then cf_save_LIBS="$LIBS" cf_term_lib="" cf_curs_lib="" if test ".${cf_cv_ncurses_version-no}" != .no then cf_check_list="ncurses curses cursesX" else cf_check_list="cursesX curses ncurses" fi # Check for library containing tgoto. Do this before curses library # because it may be needed to link the test-case for initscr. AC_CHECK_FUNC(tgoto,[cf_term_lib=predefined],[ for cf_term_lib in $cf_check_list termcap termlib unknown do AC_CHECK_LIB($cf_term_lib,tgoto,[break]) done ]) # Check for library containing initscr test "$cf_term_lib" != predefined && test "$cf_term_lib" != unknown && LIBS="-l$cf_term_lib $cf_save_LIBS" for cf_curs_lib in $cf_check_list xcurses jcurses pdcurses unknown do AC_CHECK_LIB($cf_curs_lib,initscr,[break]) done test $cf_curs_lib = unknown && AC_MSG_ERROR(no curses library found) LIBS="-l$cf_curs_lib $cf_save_LIBS" if test "$cf_term_lib" = unknown ; then AC_MSG_CHECKING(if we can link with $cf_curs_lib library) AC_TRY_LINK([#include <${cf_cv_ncurses_header-curses.h}>], [initscr()], [cf_result=yes], [cf_result=no]) AC_MSG_RESULT($cf_result) test $cf_result = no && AC_MSG_ERROR(Cannot link curses library) elif test "$cf_curs_lib" = "$cf_term_lib" ; then : elif test "$cf_term_lib" != predefined ; then AC_MSG_CHECKING(if we need both $cf_curs_lib and $cf_term_lib libraries) AC_TRY_LINK([#include <${cf_cv_ncurses_header-curses.h}>], [initscr(); tgoto((char *)0, 0, 0);], [cf_result=no], [ LIBS="-l$cf_curs_lib -l$cf_term_lib $cf_save_LIBS" AC_TRY_LINK([#include <${cf_cv_ncurses_header-curses.h}>], [initscr()], [cf_result=yes], [cf_result=error]) ]) AC_MSG_RESULT($cf_result) fi fi fi ])dnl dnl --------------------------------------------------------------------------- dnl CF_DIRNAME version: 4 updated: 2002/12/21 19:25:52 dnl ---------- dnl "dirname" is not portable, so we fake it with a shell script. AC_DEFUN([CF_DIRNAME],[$1=`echo $2 | sed -e 's%/[[^/]]*$%%'`])dnl dnl --------------------------------------------------------------------------- dnl CF_DISABLE_LEAKS version: 4 updated: 2006/12/16 15:10:42 dnl ---------------- dnl Combine no-leak checks with the libraries or tools that are used for the dnl checks. AC_DEFUN([CF_DISABLE_LEAKS],[ AC_REQUIRE([CF_WITH_DMALLOC]) AC_REQUIRE([CF_WITH_DBMALLOC]) AC_REQUIRE([CF_WITH_VALGRIND]) AC_MSG_CHECKING(if you want to perform memory-leak testing) AC_ARG_ENABLE(leaks, [ --disable-leaks test: free permanent memory, analyze leaks], [with_no_leaks=yes], : ${with_no_leaks:=no}) AC_MSG_RESULT($with_no_leaks) if test "$with_no_leaks" = yes ; then AC_DEFINE(NO_LEAKS) fi ])dnl dnl --------------------------------------------------------------------------- dnl CF_ENABLE_WARNINGS version: 4 updated: 2009/07/26 17:53:03 dnl ------------------ dnl Configure-option to enable gcc warnings AC_DEFUN([CF_ENABLE_WARNINGS],[ if ( test "$GCC" = yes || test "$GXX" = yes ) then AC_MSG_CHECKING(if you want to turn on gcc warnings) CF_ARG_ENABLE(warnings, [ --enable-warnings test: turn on gcc compiler warnings], [with_warnings=yes], [with_warnings=no]) AC_MSG_RESULT($with_warnings) if test "$with_warnings" = "yes" then CF_GCC_ATTRIBUTES CF_GCC_WARNINGS fi fi ])dnl dnl --------------------------------------------------------------------------- dnl CF_FIND_LIBRARY version: 9 updated: 2008/03/23 14:48:54 dnl --------------- dnl Look for a non-standard library, given parameters for AC_TRY_LINK. We dnl prefer a standard location, and use -L options only if we do not find the dnl library in the standard library location(s). dnl $1 = library name dnl $2 = library class, usually the same as library name dnl $3 = includes dnl $4 = code fragment to compile/link dnl $5 = corresponding function-name dnl $6 = flag, nonnull if failure should not cause an error-exit dnl dnl Sets the variable "$cf_libdir" as a side-effect, so we can see if we had dnl to use a -L option. AC_DEFUN([CF_FIND_LIBRARY], [ eval 'cf_cv_have_lib_'$1'=no' cf_libdir="" AC_CHECK_FUNC($5, eval 'cf_cv_have_lib_'$1'=yes',[ cf_save_LIBS="$LIBS" AC_MSG_CHECKING(for $5 in -l$1) LIBS="-l$1 $LIBS" AC_TRY_LINK([$3],[$4], [AC_MSG_RESULT(yes) eval 'cf_cv_have_lib_'$1'=yes' ], [AC_MSG_RESULT(no) CF_LIBRARY_PATH(cf_search,$2) for cf_libdir in $cf_search do AC_MSG_CHECKING(for -l$1 in $cf_libdir) LIBS="-L$cf_libdir -l$1 $cf_save_LIBS" AC_TRY_LINK([$3],[$4], [AC_MSG_RESULT(yes) eval 'cf_cv_have_lib_'$1'=yes' break], [AC_MSG_RESULT(no) LIBS="$cf_save_LIBS"]) done ]) ]) eval 'cf_found_library=[$]cf_cv_have_lib_'$1 ifelse($6,,[ if test $cf_found_library = no ; then AC_MSG_ERROR(Cannot link $1 library) fi ]) ])dnl dnl --------------------------------------------------------------------------- dnl CF_GCC_ATTRIBUTES version: 13 updated: 2009/08/11 20:19:56 dnl ----------------- dnl Test for availability of useful gcc __attribute__ directives to quiet dnl compiler warnings. Though useful, not all are supported -- and contrary dnl to documentation, unrecognized directives cause older compilers to barf. AC_DEFUN([CF_GCC_ATTRIBUTES], [ if test "$GCC" = yes then cat > conftest.i < conftest.$ac_ext <&AC_FD_CC case $cf_attribute in #(vi printf) #(vi cf_printf_attribute=yes cat >conftest.h <conftest.h <conftest.h <>confdefs.h case $cf_attribute in #(vi printf) #(vi if test "$cf_printf_attribute" = no ; then cat >>confdefs.h <>confdefs.h <>confdefs.h <>confdefs.h <>confdefs.h fi rm -rf conftest* fi ])dnl dnl --------------------------------------------------------------------------- dnl CF_GCC_VERSION version: 4 updated: 2005/08/27 09:53:42 dnl -------------- dnl Find version of gcc AC_DEFUN([CF_GCC_VERSION],[ AC_REQUIRE([AC_PROG_CC]) GCC_VERSION=none if test "$GCC" = yes ; then AC_MSG_CHECKING(version of $CC) GCC_VERSION="`${CC} --version| sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[[^0-9.]]*//' -e 's/[[^0-9.]].*//'`" test -z "$GCC_VERSION" && GCC_VERSION=unknown AC_MSG_RESULT($GCC_VERSION) fi ])dnl dnl --------------------------------------------------------------------------- dnl CF_GCC_WARNINGS version: 24 updated: 2009/02/01 15:21:00 dnl --------------- dnl Check if the compiler supports useful warning options. There's a few that dnl we don't use, simply because they're too noisy: dnl dnl -Wconversion (useful in older versions of gcc, but not in gcc 2.7.x) dnl -Wredundant-decls (system headers make this too noisy) dnl -Wtraditional (combines too many unrelated messages, only a few useful) dnl -Wwrite-strings (too noisy, but should review occasionally). This dnl is enabled for ncurses using "--enable-const". dnl -pedantic dnl dnl Parameter: dnl $1 is an optional list of gcc warning flags that a particular dnl application might want to use, e.g., "no-unused" for dnl -Wno-unused dnl Special: dnl If $with_ext_const is "yes", add a check for -Wwrite-strings dnl AC_DEFUN([CF_GCC_WARNINGS], [ AC_REQUIRE([CF_GCC_VERSION]) CF_INTEL_COMPILER(GCC,INTEL_COMPILER,CFLAGS) cat > conftest.$ac_ext <],[ #ifndef _XOPEN_SOURCE make an error #endif], [cf_cv_gnu_source=no], [cf_save="$CPPFLAGS" CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE" AC_TRY_COMPILE([#include ],[ #ifdef _XOPEN_SOURCE make an error #endif], [cf_cv_gnu_source=no], [cf_cv_gnu_source=yes]) CPPFLAGS="$cf_save" ]) ]) test "$cf_cv_gnu_source" = yes && CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE" ])dnl dnl --------------------------------------------------------------------------- dnl CF_HEADER_PATH version: 9 updated: 2008/12/07 19:38:31 dnl -------------- dnl Construct a search-list of directories for a nonstandard header-file dnl dnl Parameters dnl $1 = the variable to return as result dnl $2 = the package name AC_DEFUN([CF_HEADER_PATH], [ cf_header_path_list="" if test -n "${CFLAGS}${CPPFLAGS}" ; then for cf_header_path in $CPPFLAGS $CFLAGS do case $cf_header_path in #(vi -I*) cf_header_path=`echo ".$cf_header_path" |sed -e 's/^...//' -e 's,/include$,,'` CF_ADD_SUBDIR_PATH($1,$2,include,$cf_header_path,NONE) cf_header_path_list="$cf_header_path_list [$]$1" ;; esac done fi CF_SUBDIR_PATH($1,$2,include) test "$includedir" != NONE && \ test "$includedir" != "/usr/include" && \ test -d "$includedir" && { test -d $includedir && $1="[$]$1 $includedir" test -d $includedir/$2 && $1="[$]$1 $includedir/$2" } test "$oldincludedir" != NONE && \ test "$oldincludedir" != "/usr/include" && \ test -d "$oldincludedir" && { test -d $oldincludedir && $1="[$]$1 $oldincludedir" test -d $oldincludedir/$2 && $1="[$]$1 $oldincludedir/$2" } $1="$cf_header_path_list [$]$1" ])dnl dnl --------------------------------------------------------------------------- dnl CF_INHERIT_SCRIPT version: 2 updated: 2003/03/01 23:50:42 dnl ----------------- dnl If we do not have a given script, look for it in the parent directory. AC_DEFUN([CF_INHERIT_SCRIPT], [ test -f $1 || ( test -f ../$1 && cp ../$1 ./ ) ])dnl dnl --------------------------------------------------------------------------- dnl CF_INTEL_COMPILER version: 3 updated: 2005/08/06 18:37:29 dnl ----------------- dnl Check if the given compiler is really the Intel compiler for Linux. It dnl tries to imitate gcc, but does not return an error when it finds a mismatch dnl between prototypes, e.g., as exercised by CF_MISSING_CHECK. dnl dnl This macro should be run "soon" after AC_PROG_CC or AC_PROG_CPLUSPLUS, to dnl ensure that it is not mistaken for gcc/g++. It is normally invoked from dnl the wrappers for gcc and g++ warnings. dnl dnl $1 = GCC (default) or GXX dnl $2 = INTEL_COMPILER (default) or INTEL_CPLUSPLUS dnl $3 = CFLAGS (default) or CXXFLAGS AC_DEFUN([CF_INTEL_COMPILER],[ ifelse($2,,INTEL_COMPILER,[$2])=no if test "$ifelse($1,,[$1],GCC)" = yes ; then case $host_os in linux*|gnu*) AC_MSG_CHECKING(if this is really Intel ifelse($1,GXX,C++,C) compiler) cf_save_CFLAGS="$ifelse($3,,CFLAGS,[$3])" ifelse($3,,CFLAGS,[$3])="$ifelse($3,,CFLAGS,[$3]) -no-gcc" AC_TRY_COMPILE([],[ #ifdef __INTEL_COMPILER #else make an error #endif ],[ifelse($2,,INTEL_COMPILER,[$2])=yes cf_save_CFLAGS="$cf_save_CFLAGS -we147 -no-gcc" ],[]) ifelse($3,,CFLAGS,[$3])="$cf_save_CFLAGS" AC_MSG_RESULT($ifelse($2,,INTEL_COMPILER,[$2])) ;; esac fi ])dnl dnl --------------------------------------------------------------------------- dnl CF_LIBRARY_PATH version: 8 updated: 2008/12/07 19:38:31 dnl --------------- dnl Construct a search-list of directories for a nonstandard library-file dnl dnl Parameters dnl $1 = the variable to return as result dnl $2 = the package name AC_DEFUN([CF_LIBRARY_PATH], [ cf_library_path_list="" if test -n "${LDFLAGS}${LIBS}" ; then for cf_library_path in $LDFLAGS $LIBS do case $cf_library_path in #(vi -L*) cf_library_path=`echo ".$cf_library_path" |sed -e 's/^...//' -e 's,/lib$,,'` CF_ADD_SUBDIR_PATH($1,$2,lib,$cf_library_path,NONE) cf_library_path_list="$cf_library_path_list [$]$1" ;; esac done fi CF_SUBDIR_PATH($1,$2,lib) $1="$cf_library_path_list [$]$1" ])dnl dnl --------------------------------------------------------------------------- dnl CF_MAKE_TAGS version: 2 updated: 2000/10/04 09:18:40 dnl ------------ dnl Generate tags/TAGS targets for makefiles. Do not generate TAGS if we have dnl a monocase filesystem. AC_DEFUN([CF_MAKE_TAGS],[ AC_REQUIRE([CF_MIXEDCASE_FILENAMES]) AC_CHECK_PROG(MAKE_LOWER_TAGS, ctags, yes, no) if test "$cf_cv_mixedcase" = yes ; then AC_CHECK_PROG(MAKE_UPPER_TAGS, etags, yes, no) else MAKE_UPPER_TAGS=no fi if test "$MAKE_UPPER_TAGS" = yes ; then MAKE_UPPER_TAGS= else MAKE_UPPER_TAGS="#" fi AC_SUBST(MAKE_UPPER_TAGS) if test "$MAKE_LOWER_TAGS" = yes ; then MAKE_LOWER_TAGS= else MAKE_LOWER_TAGS="#" fi AC_SUBST(MAKE_LOWER_TAGS) ])dnl dnl --------------------------------------------------------------------------- dnl CF_MIXEDCASE_FILENAMES version: 3 updated: 2003/09/20 17:07:55 dnl ---------------------- dnl Check if the file-system supports mixed-case filenames. If we're able to dnl create a lowercase name and see it as uppercase, it doesn't support that. AC_DEFUN([CF_MIXEDCASE_FILENAMES], [ AC_CACHE_CHECK(if filesystem supports mixed-case filenames,cf_cv_mixedcase,[ if test "$cross_compiling" = yes ; then case $target_alias in #(vi *-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-mingw32*|*-uwin*) #(vi cf_cv_mixedcase=no ;; *) cf_cv_mixedcase=yes ;; esac else rm -f conftest CONFTEST echo test >conftest if test -f CONFTEST ; then cf_cv_mixedcase=no else cf_cv_mixedcase=yes fi rm -f conftest CONFTEST fi ]) test "$cf_cv_mixedcase" = yes && AC_DEFINE(MIXEDCASE_FILENAMES) ])dnl dnl --------------------------------------------------------------------------- dnl CF_MSG_LOG version: 4 updated: 2007/07/29 09:55:12 dnl ---------- dnl Write a debug message to config.log, along with the line number in the dnl configure script. AC_DEFUN([CF_MSG_LOG],[ echo "${as_me-configure}:__oline__: testing $* ..." 1>&AC_FD_CC ])dnl dnl --------------------------------------------------------------------------- dnl CF_NCURSES_CC_CHECK version: 4 updated: 2007/07/29 10:39:05 dnl ------------------- dnl Check if we can compile with ncurses' header file dnl $1 is the cache variable to set dnl $2 is the header-file to include dnl $3 is the root name (ncurses or ncursesw) AC_DEFUN([CF_NCURSES_CC_CHECK],[ AC_TRY_COMPILE([ ]ifelse($3,ncursesw,[ #define _XOPEN_SOURCE_EXTENDED #undef HAVE_LIBUTF8_H /* in case we used CF_UTF8_LIB */ #define HAVE_LIBUTF8_H /* to force ncurses' header file to use cchar_t */ ])[ #include <$2>],[ #ifdef NCURSES_VERSION ]ifelse($3,ncursesw,[ #ifndef WACS_BSSB make an error #endif ])[ printf("%s\n", NCURSES_VERSION); #else #ifdef __NCURSES_H printf("old\n"); #else make an error #endif #endif ] ,[$1=$2] ,[$1=no]) ])dnl dnl --------------------------------------------------------------------------- dnl CF_NCURSES_CONFIG version: 5 updated: 2009/01/11 15:31:22 dnl ----------------- dnl Tie together the configure-script macros for ncurses. dnl Prefer the "-config" script from ncurses 5.6, to simplify analysis. dnl Allow that to be overridden using the $NCURSES_CONFIG environment variable. dnl dnl $1 is the root library name (default: "ncurses") AC_DEFUN([CF_NCURSES_CONFIG], [ cf_ncuconfig_root=ifelse($1,,ncurses,$1) echo "Looking for ${cf_ncuconfig_root}-config" AC_PATH_PROGS(NCURSES_CONFIG,${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}5-config,none) if test "$NCURSES_CONFIG" != none ; then cf_cv_ncurses_header=curses.h CPPFLAGS="$CPPFLAGS `$NCURSES_CONFIG --cflags`" LIBS="`$NCURSES_CONFIG --libs` $LIBS" dnl like CF_NCURSES_CPPFLAGS AC_DEFINE(NCURSES) dnl like CF_NCURSES_LIBS CF_UPPER(cf_nculib_ROOT,HAVE_LIB$cf_ncuconfig_root) AC_DEFINE_UNQUOTED($cf_nculib_ROOT) dnl like CF_NCURSES_VERSION cf_cv_ncurses_version=`$NCURSES_CONFIG --version` else CF_NCURSES_CPPFLAGS(ifelse($1,,ncurses,$1)) CF_NCURSES_LIBS(ifelse($1,,ncurses,$1)) fi ])dnl dnl --------------------------------------------------------------------------- dnl CF_NCURSES_CPPFLAGS version: 19 updated: 2007/07/29 13:35:20 dnl ------------------- dnl Look for the SVr4 curses clone 'ncurses' in the standard places, adjusting dnl the CPPFLAGS variable so we can include its header. dnl dnl The header files may be installed as either curses.h, or ncurses.h (would dnl be obsolete, except that some packagers prefer this name to distinguish it dnl from a "native" curses implementation). If not installed for overwrite, dnl the curses.h file would be in an ncurses subdirectory (e.g., dnl /usr/include/ncurses), but someone may have installed overwriting the dnl vendor's curses. Only very old versions (pre-1.9.2d, the first autoconf'd dnl version) of ncurses don't define either __NCURSES_H or NCURSES_VERSION in dnl the header. dnl dnl If the installer has set $CFLAGS or $CPPFLAGS so that the ncurses header dnl is already in the include-path, don't even bother with this, since we cannot dnl easily determine which file it is. In this case, it has to be . dnl dnl The optional parameter gives the root name of the library, in case it is dnl not installed as the default curses library. That is how the dnl wide-character version of ncurses is installed. AC_DEFUN([CF_NCURSES_CPPFLAGS], [AC_REQUIRE([CF_WITH_CURSES_DIR]) AC_PROVIDE([CF_CURSES_CPPFLAGS])dnl cf_ncuhdr_root=ifelse($1,,ncurses,$1) test -n "$cf_cv_curses_dir" && \ test "$cf_cv_curses_dir" != "no" && { \ CF_ADD_INCDIR($cf_cv_curses_dir/include $cf_cv_curses_dir/include/$cf_ncuhdr_root) } AC_CACHE_CHECK(for $cf_ncuhdr_root header in include-path, cf_cv_ncurses_h,[ cf_header_list="$cf_ncuhdr_root/curses.h $cf_ncuhdr_root/ncurses.h" ( test "$cf_ncuhdr_root" = ncurses || test "$cf_ncuhdr_root" = ncursesw ) && cf_header_list="$cf_header_list curses.h ncurses.h" for cf_header in $cf_header_list do CF_NCURSES_CC_CHECK(cf_cv_ncurses_h,$cf_header,$1) test "$cf_cv_ncurses_h" != no && break done ]) CF_NCURSES_HEADER CF_TERM_HEADER # some applications need this, but should check for NCURSES_VERSION AC_DEFINE(NCURSES) CF_NCURSES_VERSION ])dnl dnl --------------------------------------------------------------------------- dnl CF_NCURSES_HEADER version: 2 updated: 2008/03/23 14:48:54 dnl ----------------- dnl Find a "curses" header file, e.g,. "curses.h", or one of the more common dnl variations of ncurses' installs. dnl dnl See also CF_CURSES_HEADER, which sets the same cache variable. AC_DEFUN([CF_NCURSES_HEADER],[ if test "$cf_cv_ncurses_h" != no ; then cf_cv_ncurses_header=$cf_cv_ncurses_h else AC_CACHE_CHECK(for $cf_ncuhdr_root include-path, cf_cv_ncurses_h2,[ test -n "$verbose" && echo CF_HEADER_PATH(cf_search,$cf_ncuhdr_root) test -n "$verbose" && echo search path $cf_search cf_save2_CPPFLAGS="$CPPFLAGS" for cf_incdir in $cf_search do CF_ADD_INCDIR($cf_incdir) for cf_header in \ ncurses.h \ curses.h do CF_NCURSES_CC_CHECK(cf_cv_ncurses_h2,$cf_header,$1) if test "$cf_cv_ncurses_h2" != no ; then cf_cv_ncurses_h2=$cf_incdir/$cf_header test -n "$verbose" && echo $ac_n " ... found $ac_c" 1>&AC_FD_MSG break fi test -n "$verbose" && echo " ... tested $cf_incdir/$cf_header" 1>&AC_FD_MSG done CPPFLAGS="$cf_save2_CPPFLAGS" test "$cf_cv_ncurses_h2" != no && break done test "$cf_cv_ncurses_h2" = no && AC_MSG_ERROR(not found) ]) CF_DIRNAME(cf_1st_incdir,$cf_cv_ncurses_h2) cf_cv_ncurses_header=`basename $cf_cv_ncurses_h2` if test `basename $cf_1st_incdir` = $cf_ncuhdr_root ; then cf_cv_ncurses_header=$cf_ncuhdr_root/$cf_cv_ncurses_header fi CF_ADD_INCDIR($cf_1st_incdir) fi # Set definitions to allow ifdef'ing for ncurses.h case $cf_cv_ncurses_header in # (vi *ncurses.h) AC_DEFINE(HAVE_NCURSES_H) ;; esac case $cf_cv_ncurses_header in # (vi ncurses/curses.h|ncurses/ncurses.h) AC_DEFINE(HAVE_NCURSES_NCURSES_H) ;; ncursesw/curses.h|ncursesw/ncurses.h) AC_DEFINE(HAVE_NCURSESW_NCURSES_H) ;; esac ])dnl dnl --------------------------------------------------------------------------- dnl CF_NCURSES_LIBS version: 13 updated: 2007/07/29 10:29:20 dnl --------------- dnl Look for the ncurses library. This is a little complicated on Linux, dnl because it may be linked with the gpm (general purpose mouse) library. dnl Some distributions have gpm linked with (bsd) curses, which makes it dnl unusable with ncurses. However, we don't want to link with gpm unless dnl ncurses has a dependency, since gpm is normally set up as a shared library, dnl and the linker will record a dependency. dnl dnl The optional parameter gives the root name of the library, in case it is dnl not installed as the default curses library. That is how the dnl wide-character version of ncurses is installed. AC_DEFUN([CF_NCURSES_LIBS], [AC_REQUIRE([CF_NCURSES_CPPFLAGS]) cf_nculib_root=ifelse($1,,ncurses,$1) # This works, except for the special case where we find gpm, but # ncurses is in a nonstandard location via $LIBS, and we really want # to link gpm. cf_ncurses_LIBS="" cf_ncurses_SAVE="$LIBS" AC_CHECK_LIB(gpm,Gpm_Open, [AC_CHECK_LIB(gpm,initscr, [LIBS="$cf_ncurses_SAVE"], [cf_ncurses_LIBS="-lgpm"])]) case $host_os in #(vi freebsd*) # This is only necessary if you are linking against an obsolete # version of ncurses (but it should do no harm, since it's static). if test "$cf_nculib_root" = ncurses ; then AC_CHECK_LIB(mytinfo,tgoto,[cf_ncurses_LIBS="-lmytinfo $cf_ncurses_LIBS"]) fi ;; esac LIBS="$cf_ncurses_LIBS $LIBS" if ( test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no" ) then CF_ADD_LIBDIR($cf_cv_curses_dir/lib) LIBS="-l$cf_nculib_root $LIBS" else CF_FIND_LIBRARY($cf_nculib_root,$cf_nculib_root, [#include <${cf_cv_ncurses_header-curses.h}>], [initscr()], initscr) fi if test -n "$cf_ncurses_LIBS" ; then AC_MSG_CHECKING(if we can link $cf_nculib_root without $cf_ncurses_LIBS) cf_ncurses_SAVE="$LIBS" for p in $cf_ncurses_LIBS ; do q=`echo $LIBS | sed -e "s%$p %%" -e "s%$p$%%"` if test "$q" != "$LIBS" ; then LIBS="$q" fi done AC_TRY_LINK([#include <${cf_cv_ncurses_header-curses.h}>], [initscr(); mousemask(0,0); tgoto((char *)0, 0, 0);], [AC_MSG_RESULT(yes)], [AC_MSG_RESULT(no) LIBS="$cf_ncurses_SAVE"]) fi CF_UPPER(cf_nculib_ROOT,HAVE_LIB$cf_nculib_root) AC_DEFINE_UNQUOTED($cf_nculib_ROOT) ])dnl dnl --------------------------------------------------------------------------- dnl CF_NCURSES_VERSION version: 12 updated: 2007/04/28 09:15:55 dnl ------------------ dnl Check for the version of ncurses, to aid in reporting bugs, etc. dnl Call CF_CURSES_CPPFLAGS first, or CF_NCURSES_CPPFLAGS. We don't use dnl AC_REQUIRE since that does not work with the shell's if/then/else/fi. AC_DEFUN([CF_NCURSES_VERSION], [ AC_REQUIRE([CF_CURSES_CPPFLAGS])dnl AC_CACHE_CHECK(for ncurses version, cf_cv_ncurses_version,[ cf_cv_ncurses_version=no cf_tempfile=out$$ rm -f $cf_tempfile AC_TRY_RUN([ #include <${cf_cv_ncurses_header-curses.h}> #include int main() { FILE *fp = fopen("$cf_tempfile", "w"); #ifdef NCURSES_VERSION # ifdef NCURSES_VERSION_PATCH fprintf(fp, "%s.%d\n", NCURSES_VERSION, NCURSES_VERSION_PATCH); # else fprintf(fp, "%s\n", NCURSES_VERSION); # endif #else # ifdef __NCURSES_H fprintf(fp, "old\n"); # else make an error # endif #endif ${cf_cv_main_return-return}(0); }],[ cf_cv_ncurses_version=`cat $cf_tempfile`],,[ # This will not work if the preprocessor splits the line after the # Autoconf token. The 'unproto' program does that. cat > conftest.$ac_ext < #undef Autoconf #ifdef NCURSES_VERSION Autoconf NCURSES_VERSION #else #ifdef __NCURSES_H Autoconf "old" #endif ; #endif EOF cf_try="$ac_cpp conftest.$ac_ext 2>&AC_FD_CC | grep '^Autoconf ' >conftest.out" AC_TRY_EVAL(cf_try) if test -f conftest.out ; then cf_out=`cat conftest.out | sed -e 's%^Autoconf %%' -e 's%^[[^"]]*"%%' -e 's%".*%%'` test -n "$cf_out" && cf_cv_ncurses_version="$cf_out" rm -f conftest.out fi ]) rm -f $cf_tempfile ]) test "$cf_cv_ncurses_version" = no || AC_DEFINE(NCURSES) ])dnl dnl --------------------------------------------------------------------------- dnl CF_NO_LEAKS_OPTION version: 4 updated: 2006/12/16 14:24:05 dnl ------------------ dnl see CF_WITH_NO_LEAKS AC_DEFUN([CF_NO_LEAKS_OPTION],[ AC_MSG_CHECKING(if you want to use $1 for testing) AC_ARG_WITH($1, [$2], [AC_DEFINE($3)ifelse([$4],,[ $4 ]) : ${with_cflags:=-g} : ${with_no_leaks:=yes} with_$1=yes], [with_$1=]) AC_MSG_RESULT(${with_$1:-no}) case .$with_cflags in #(vi .*-g*) case .$CFLAGS in #(vi .*-g*) #(vi ;; *) CF_ADD_CFLAGS([-g]) ;; esac ;; esac ])dnl dnl --------------------------------------------------------------------------- dnl CF_PATH_SYNTAX version: 12 updated: 2008/03/23 14:45:59 dnl -------------- dnl Check the argument to see that it looks like a pathname. Rewrite it if it dnl begins with one of the prefix/exec_prefix variables, and then again if the dnl result begins with 'NONE'. This is necessary to work around autoconf's dnl delayed evaluation of those symbols. AC_DEFUN([CF_PATH_SYNTAX],[ if test "x$prefix" != xNONE; then cf_path_syntax="$prefix" else cf_path_syntax="$ac_default_prefix" fi case ".[$]$1" in #(vi .\[$]\(*\)*|.\'*\'*) #(vi ;; ..|./*|.\\*) #(vi ;; .[[a-zA-Z]]:[[\\/]]*) #(vi OS/2 EMX ;; .\[$]{*prefix}*) #(vi eval $1="[$]$1" case ".[$]$1" in #(vi .NONE/*) $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%` ;; esac ;; #(vi .no|.NONE/*) $1=`echo [$]$1 | sed -e s%NONE%$cf_path_syntax%` ;; *) ifelse($2,,[AC_MSG_ERROR([expected a pathname, not \"[$]$1\"])],$2) ;; esac ])dnl dnl --------------------------------------------------------------------------- dnl CF_POSIX_C_SOURCE version: 6 updated: 2005/07/14 20:25:10 dnl ----------------- dnl Define _POSIX_C_SOURCE to the given level, and _POSIX_SOURCE if needed. dnl dnl POSIX.1-1990 _POSIX_SOURCE dnl POSIX.1-1990 and _POSIX_SOURCE and dnl POSIX.2-1992 C-Language _POSIX_C_SOURCE=2 dnl Bindings Option dnl POSIX.1b-1993 _POSIX_C_SOURCE=199309L dnl POSIX.1c-1996 _POSIX_C_SOURCE=199506L dnl X/Open 2000 _POSIX_C_SOURCE=200112L dnl dnl Parameters: dnl $1 is the nominal value for _POSIX_C_SOURCE AC_DEFUN([CF_POSIX_C_SOURCE], [ cf_POSIX_C_SOURCE=ifelse($1,,199506L,$1) cf_save_CFLAGS="$CFLAGS" cf_save_CPPFLAGS="$CPPFLAGS" CF_REMOVE_DEFINE(cf_trim_CFLAGS,$cf_save_CFLAGS,_POSIX_C_SOURCE) CF_REMOVE_DEFINE(cf_trim_CPPFLAGS,$cf_save_CPPFLAGS,_POSIX_C_SOURCE) AC_CACHE_CHECK(if we should define _POSIX_C_SOURCE,cf_cv_posix_c_source,[ CF_MSG_LOG(if the symbol is already defined go no further) AC_TRY_COMPILE([#include ],[ #ifndef _POSIX_C_SOURCE make an error #endif], [cf_cv_posix_c_source=no], [cf_want_posix_source=no case .$cf_POSIX_C_SOURCE in #(vi .[[12]]??*) #(vi cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE" ;; .2) #(vi cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE" cf_want_posix_source=yes ;; .*) cf_want_posix_source=yes ;; esac if test "$cf_want_posix_source" = yes ; then AC_TRY_COMPILE([#include ],[ #ifdef _POSIX_SOURCE make an error #endif],[], cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE") fi CF_MSG_LOG(ifdef from value $cf_POSIX_C_SOURCE) CFLAGS="$cf_trim_CFLAGS" CPPFLAGS="$cf_trim_CPPFLAGS $cf_cv_posix_c_source" CF_MSG_LOG(if the second compile does not leave our definition intact error) AC_TRY_COMPILE([#include ],[ #ifndef _POSIX_C_SOURCE make an error #endif],, [cf_cv_posix_c_source=no]) CFLAGS="$cf_save_CFLAGS" CPPFLAGS="$cf_save_CPPFLAGS" ]) ]) if test "$cf_cv_posix_c_source" != no ; then CFLAGS="$cf_trim_CFLAGS" CPPFLAGS="$cf_trim_CPPFLAGS" if test "$cf_cv_cc_u_d_options" = yes ; then cf_temp_posix_c_source=`echo "$cf_cv_posix_c_source" | \ sed -e 's/-D/-U/g' -e 's/=[[^ ]]*//g'` CPPFLAGS="$CPPFLAGS $cf_temp_posix_c_source" fi CPPFLAGS="$CPPFLAGS $cf_cv_posix_c_source" fi ])dnl dnl --------------------------------------------------------------------------- dnl CF_PRG_RULES version: 1 updated: 2006/06/03 11:45:08 dnl ------------ dnl Append definitions and rules for the given programs to the subdirectory dnl Makefiles, and the recursion rule for the top-level Makefile. dnl dnl parameters dnl $1 = script to run dnl $2 = list of subdirectories dnl dnl variables dnl $AWK AC_DEFUN([CF_PRG_RULES], [ for cf_dir in $2 do if test ! -d $srcdir/$cf_dir; then continue elif test -f $srcdir/$cf_dir/programs; then $AWK -f $1 $srcdir/$cf_dir/programs >>$cf_dir/Makefile fi done ])dnl dnl --------------------------------------------------------------------------- dnl CF_PROG_CC_U_D version: 1 updated: 2005/07/14 16:59:30 dnl -------------- dnl Check if C (preprocessor) -U and -D options are processed in the order dnl given rather than by type of option. Some compilers insist on apply all dnl of the -U options after all of the -D options. Others allow mixing them, dnl and may predefine symbols that conflict with those we define. AC_DEFUN([CF_PROG_CC_U_D], [ AC_CACHE_CHECK(if $CC -U and -D options work together,cf_cv_cc_u_d_options,[ cf_save_CPPFLAGS="$CPPFLAGS" CPPFLAGS="-UU_D_OPTIONS -DU_D_OPTIONS -DD_U_OPTIONS -UD_U_OPTIONS" AC_TRY_COMPILE([],[ #ifndef U_D_OPTIONS make an undefined-error #endif #ifdef D_U_OPTIONS make a defined-error #endif ],[ cf_cv_cc_u_d_options=yes],[ cf_cv_cc_u_d_options=no]) CPPFLAGS="$cf_save_CPPFLAGS" ]) ])dnl dnl --------------------------------------------------------------------------- dnl CF_PROG_INSTALL version: 5 updated: 2002/12/21 22:46:07 dnl --------------- dnl Force $INSTALL to be an absolute-path. Otherwise, edit_man.sh and the dnl misc/tabset install won't work properly. Usually this happens only when dnl using the fallback mkinstalldirs script AC_DEFUN([CF_PROG_INSTALL], [AC_PROG_INSTALL case $INSTALL in /*) ;; *) CF_DIRNAME(cf_dir,$INSTALL) test -z "$cf_dir" && cf_dir=. INSTALL=`cd $cf_dir && pwd`/`echo $INSTALL | sed -e 's%^.*/%%'` ;; esac ])dnl dnl --------------------------------------------------------------------------- dnl CF_REMOVE_DEFINE version: 2 updated: 2005/07/09 16:12:18 dnl ---------------- dnl Remove all -U and -D options that refer to the given symbol from a list dnl of C compiler options. This works around the problem that not all dnl compilers process -U and -D options from left-to-right, so a -U option dnl cannot be used to cancel the effect of a preceding -D option. dnl dnl $1 = target (which could be the same as the source variable) dnl $2 = source (including '$') dnl $3 = symbol to remove define([CF_REMOVE_DEFINE], [ # remove $3 symbol from $2 $1=`echo "$2" | \ sed -e 's/-[[UD]]$3\(=[[^ ]]*\)\?[[ ]]/ /g' \ -e 's/-[[UD]]$3\(=[[^ ]]*\)\?[$]//g'` ])dnl dnl --------------------------------------------------------------------------- dnl CF_SIG_ATOMIC_T version: 2 updated: 2005/09/18 17:27:12 dnl --------------- dnl signal handler, but there are some gcc depedencies in that recommendation. dnl Try anyway. AC_DEFUN([CF_SIG_ATOMIC_T], [ AC_MSG_CHECKING(for signal global datatype) AC_CACHE_VAL(cf_cv_sig_atomic_t,[ for cf_type in \ "volatile sig_atomic_t" \ "sig_atomic_t" \ "int" do AC_TRY_COMPILE([ #include #include #include extern $cf_type x; $cf_type x; static void handler(int sig) { x = 5; }], [signal(SIGINT, handler); x = 1], [cf_cv_sig_atomic_t=$cf_type], [cf_cv_sig_atomic_t=no]) test "$cf_cv_sig_atomic_t" != no && break done ]) AC_MSG_RESULT($cf_cv_sig_atomic_t) test "$cf_cv_sig_atomic_t" != no && AC_DEFINE_UNQUOTED(SIG_ATOMIC_T, $cf_cv_sig_atomic_t) ])dnl dnl --------------------------------------------------------------------------- dnl CF_SUBDIR_PATH version: 5 updated: 2007/07/29 09:55:12 dnl -------------- dnl Construct a search-list for a nonstandard header/lib-file dnl $1 = the variable to return as result dnl $2 = the package name dnl $3 = the subdirectory, e.g., bin, include or lib AC_DEFUN([CF_SUBDIR_PATH], [$1="" CF_ADD_SUBDIR_PATH($1,$2,$3,/usr,$prefix) CF_ADD_SUBDIR_PATH($1,$2,$3,$prefix,NONE) CF_ADD_SUBDIR_PATH($1,$2,$3,/usr/local,$prefix) CF_ADD_SUBDIR_PATH($1,$2,$3,/opt,$prefix) CF_ADD_SUBDIR_PATH($1,$2,$3,[$]HOME,$prefix) ])dnl dnl --------------------------------------------------------------------------- dnl CF_SYS_TIME_SELECT version: 4 updated: 2000/10/04 09:18:40 dnl ------------------ dnl Check if we can include with ; this breaks on dnl older SCO configurations. AC_DEFUN([CF_SYS_TIME_SELECT], [ AC_MSG_CHECKING(if sys/time.h works with sys/select.h) AC_CACHE_VAL(cf_cv_sys_time_select,[ AC_TRY_COMPILE([ #include #ifdef HAVE_SYS_TIME_H #include #endif #ifdef HAVE_SYS_SELECT_H #include #endif ],[],[cf_cv_sys_time_select=yes], [cf_cv_sys_time_select=no]) ]) AC_MSG_RESULT($cf_cv_sys_time_select) test "$cf_cv_sys_time_select" = yes && AC_DEFINE(HAVE_SYS_TIME_SELECT) ])dnl dnl --------------------------------------------------------------------------- dnl CF_TERM_HEADER version: 1 updated: 2005/12/31 13:26:39 dnl -------------- dnl Look for term.h, which is part of X/Open curses. It defines the interface dnl to terminfo database. Usually it is in the same include-path as curses.h, dnl but some packagers change this, breaking various applications. AC_DEFUN([CF_TERM_HEADER],[ AC_CACHE_CHECK(for terminfo header, cf_cv_term_header,[ case ${cf_cv_ncurses_header} in #(vi */ncurses.h|*/ncursesw.h) #(vi cf_term_header=`echo "$cf_cv_ncurses_header" | sed -e 's%ncurses[[^.]]*\.h$%term.h%'` ;; *) cf_term_header=term.h ;; esac for cf_test in $cf_term_header "ncurses/term.h" "ncursesw/term.h" do AC_TRY_COMPILE([#include #include <${cf_cv_ncurses_header-curses.h}> #include <$cf_test> ],[int x = auto_left_margin],[ cf_cv_term_header="$cf_test"],[ cf_cv_term_header=unknown ]) test "$cf_cv_term_header" != unknown && break done ]) # Set definitions to allow ifdef'ing to accommodate subdirectories case $cf_cv_term_header in # (vi *term.h) AC_DEFINE(HAVE_TERM_H) ;; esac case $cf_cv_term_header in # (vi ncurses/term.h) #(vi AC_DEFINE(HAVE_NCURSES_TERM_H) ;; ncursesw/term.h) AC_DEFINE(HAVE_NCURSESW_TERM_H) ;; esac ])dnl dnl --------------------------------------------------------------------------- dnl CF_UPPER version: 5 updated: 2001/01/29 23:40:59 dnl -------- dnl Make an uppercase version of a variable dnl $1=uppercase($2) AC_DEFUN([CF_UPPER], [ $1=`echo "$2" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%` ])dnl dnl --------------------------------------------------------------------------- dnl CF_VERBOSE version: 3 updated: 2007/07/29 09:55:12 dnl ---------- dnl Use AC_VERBOSE w/o the warnings AC_DEFUN([CF_VERBOSE], [test -n "$verbose" && echo " $1" 1>&AC_FD_MSG CF_MSG_LOG([$1]) ])dnl dnl --------------------------------------------------------------------------- dnl CF_WITH_CURSES_DIR version: 2 updated: 2002/11/10 14:46:59 dnl ------------------ dnl Wrapper for AC_ARG_WITH to specify directory under which to look for curses dnl libraries. AC_DEFUN([CF_WITH_CURSES_DIR],[ AC_ARG_WITH(curses-dir, [ --with-curses-dir=DIR directory in which (n)curses is installed], [CF_PATH_SYNTAX(withval) cf_cv_curses_dir=$withval], [cf_cv_curses_dir=no]) ])dnl dnl --------------------------------------------------------------------------- dnl CF_WITH_DBMALLOC version: 6 updated: 2006/12/16 14:24:05 dnl ---------------- dnl Configure-option for dbmalloc. The optional parameter is used to override dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests. AC_DEFUN([CF_WITH_DBMALLOC],[ CF_NO_LEAKS_OPTION(dbmalloc, [ --with-dbmalloc test: use Conor Cahill's dbmalloc library], [USE_DBMALLOC]) if test "$with_dbmalloc" = yes ; then AC_CHECK_HEADER(dbmalloc.h, [AC_CHECK_LIB(dbmalloc,[debug_malloc]ifelse($1,,[],[,$1]))]) fi ])dnl dnl --------------------------------------------------------------------------- dnl CF_WITH_DMALLOC version: 6 updated: 2006/12/16 14:24:05 dnl --------------- dnl Configure-option for dmalloc. The optional parameter is used to override dnl the updating of $LIBS, e.g., to avoid conflict with subsequent tests. AC_DEFUN([CF_WITH_DMALLOC],[ CF_NO_LEAKS_OPTION(dmalloc, [ --with-dmalloc test: use Gray Watson's dmalloc library], [USE_DMALLOC]) if test "$with_dmalloc" = yes ; then AC_CHECK_HEADER(dmalloc.h, [AC_CHECK_LIB(dmalloc,[dmalloc_debug]ifelse($1,,[],[,$1]))]) fi ])dnl dnl --------------------------------------------------------------------------- dnl CF_WITH_VALGRIND version: 1 updated: 2006/12/14 18:00:21 dnl ---------------- AC_DEFUN([CF_WITH_VALGRIND],[ CF_NO_LEAKS_OPTION(valgrind, [ --with-valgrind test: use valgrind], [USE_VALGRIND]) ])dnl dnl --------------------------------------------------------------------------- dnl CF_XOPEN_SOURCE version: 29 updated: 2009/07/16 21:07:04 dnl --------------- dnl Try to get _XOPEN_SOURCE defined properly that we can use POSIX functions, dnl or adapt to the vendor's definitions to get equivalent functionality, dnl without losing the common non-POSIX features. dnl dnl Parameters: dnl $1 is the nominal value for _XOPEN_SOURCE dnl $2 is the nominal value for _POSIX_C_SOURCE AC_DEFUN([CF_XOPEN_SOURCE],[ AC_REQUIRE([CF_PROG_CC_U_D]) cf_XOPEN_SOURCE=ifelse($1,,500,$1) cf_POSIX_C_SOURCE=ifelse($2,,199506L,$2) case $host_os in #(vi aix[[456]]*) #(vi CPPFLAGS="$CPPFLAGS -D_ALL_SOURCE" ;; freebsd*|dragonfly*) #(vi # 5.x headers associate # _XOPEN_SOURCE=600 with _POSIX_C_SOURCE=200112L # _XOPEN_SOURCE=500 with _POSIX_C_SOURCE=199506L cf_POSIX_C_SOURCE=200112L cf_XOPEN_SOURCE=600 CPPFLAGS="$CPPFLAGS -D_BSD_TYPES -D__BSD_VISIBLE -D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE" ;; hpux11*) #(vi CPPFLAGS="$CPPFLAGS -D_HPUX_SOURCE -D_XOPEN_SOURCE=500" ;; hpux*) #(vi CPPFLAGS="$CPPFLAGS -D_HPUX_SOURCE" ;; irix[[56]].*) #(vi CPPFLAGS="$CPPFLAGS -D_SGI_SOURCE" ;; linux*|gnu*|mint*|k*bsd*-gnu) #(vi CF_GNU_SOURCE ;; mirbsd*) #(vi # setting _XOPEN_SOURCE or _POSIX_SOURCE breaks ;; netbsd*) #(vi # setting _XOPEN_SOURCE breaks IPv6 for lynx on NetBSD 1.6, breaks xterm, is not needed for ncursesw ;; openbsd*) #(vi # setting _XOPEN_SOURCE breaks xterm on OpenBSD 2.8, is not needed for ncursesw ;; osf[[45]]*) #(vi CPPFLAGS="$CPPFLAGS -D_OSF_SOURCE" ;; nto-qnx*) #(vi CPPFLAGS="$CPPFLAGS -D_QNX_SOURCE" ;; sco*) #(vi # setting _XOPEN_SOURCE breaks Lynx on SCO Unix / OpenServer ;; solaris*) #(vi CPPFLAGS="$CPPFLAGS -D__EXTENSIONS__" ;; *) AC_CACHE_CHECK(if we should define _XOPEN_SOURCE,cf_cv_xopen_source,[ AC_TRY_COMPILE([#include ],[ #ifndef _XOPEN_SOURCE make an error #endif], [cf_cv_xopen_source=no], [cf_save="$CPPFLAGS" CPPFLAGS="$CPPFLAGS -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE" AC_TRY_COMPILE([#include ],[ #ifdef _XOPEN_SOURCE make an error #endif], [cf_cv_xopen_source=no], [cf_cv_xopen_source=$cf_XOPEN_SOURCE]) CPPFLAGS="$cf_save" ]) ]) if test "$cf_cv_xopen_source" != no ; then CF_REMOVE_DEFINE(CFLAGS,$CFLAGS,_XOPEN_SOURCE) CF_REMOVE_DEFINE(CPPFLAGS,$CPPFLAGS,_XOPEN_SOURCE) test "$cf_cv_cc_u_d_options" = yes && \ CPPFLAGS="$CPPFLAGS -U_XOPEN_SOURCE" CPPFLAGS="$CPPFLAGS -D_XOPEN_SOURCE=$cf_cv_xopen_source" fi CF_POSIX_C_SOURCE($cf_POSIX_C_SOURCE) ;; esac ]) tack-1.07/ansi.c0000644000175100001440000004652211315477317012222 0ustar tomusers/* ** Copyright (C) 1991, 1997 Free Software Foundation, Inc. ** ** This file is part of TACK. ** ** TACK is free software; you can redistribute it and/or modify ** it under the terms of the GNU General Public License as published by ** the Free Software Foundation; either version 2, or (at your option) ** any later version. ** ** TACK 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 TACK; see the file COPYING. If not, write to ** the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, ** Boston, MA 02110-1301, USA */ #include MODULE_ID("$Id: ansi.c,v 1.12 2009/12/26 21:23:27 tom Exp $") /* * Standalone tests for ANSI terminals. Three entry points: * test_ansi_graphics(), test_ansi_reports() and test_ansi_sgr(). */ /***************************************************************************** * * Test ANSI status reports * *****************************************************************************/ /* ASCII control characters */ #define A_DC1 0x11 /* Control Q */ #define A_DC3 0x13 /* Control S */ #define A_ESC 0x1b #define A_DCS 0x90 #define A_CSI 0x9b #define A_ST 0x9c #define MAX_MODES 256 static char default_bank[] = "\033(B\017"; static int private_use, ape, terminal_class; static short ansi_value[256]; static unsigned char ansi_buf[512], pack_buf[512]; struct ansi_reports { int lvl, final; const char *text; const char *request; }; static struct ansi_reports report_list[] = { {0, 'c', "(DA) Primary device attributes", "\033[0c"}, {1, 0, "(DSR) Terminal status", "\033[5n"}, {1, 'R', "(DSR) Cursor position", "\033[6n"}, {62, 0, "(DA) Secondary device attributes", "\033[>0c"}, {62, 0, "(DSR) Printer status", "\033[?15n"}, {62, 0, "(DSR) Function key definition", "\033[?25n"}, {62, 0, "(DSR) Keyboard language", "\033[?26n"}, {63, 0, "(DECRQSS) Data destination", "\033P$q$}\033\\"}, {63, 0, "(DECRQSS) Status line type", "\033P$q$~\033\\"}, {63, 0, "(DECRQSS) Erase attribute", "\033P$q\"q\033\\"}, {63, 0, "(DECRQSS) Personality", "\033P$q\"p\033\\"}, {63, 0, "(DECRQSS) Top and bottom margins", "\033P$qr\033\\"}, {63, 0, "(DECRQSS) Character attributes", "\033P$qm\033\\"}, {63, 0, "(DECRQSS) Illegal request", "\033P$q@\033\\"}, {63, 0, "(DECRQUPSS) User pref supplemental set", "\033[&u"}, {63, 0, "(DECRQPSR) Cursor information", "\033[1$w"}, {63, 0, "(DECRQPSR) Tab stop information", "\033[2$w"}, {64, 0, "(DA) Tertiary device attributes", "\033[=0c"}, {64, 0, "(DSR) Extended cursor position", "\033[?6n"}, {64, 0, "(DSR) Macro space", "\033[?62n"}, {64, 0, "(DSR) Memory checksum", "\033[?63n"}, {64, 0, "(DSR) Data integrity", "\033[?75n"}, {64, 0, "(DSR) Multiple session status", "\033[?85n"}, {64, 0, "(DECRQSS) Attribute change extent", "\033P$q*x\033\\"}, {64, 0, "(DECRQSS) Columns per page", "\033P$q$|\033\\"}, {64, 0, "(DECRQSS) Lines per page", "\033P$qt\033\\"}, {64, 0, "(DECRQSS) Lines per screen", "\033P$q*|\033\\"}, {64, 0, "(DECRQSS) Left and right margins", "\033P$qs\033\\"}, {64, 0, "(DECRQSS) Local functions", "\033P$q+q\033\\"}, {64, 0, "(DECRQSS) Local function key control", "\033P$q=}\033\\"}, {64, 0, "(DECRQSS) Select modifier key reporting", "\033P$q+r\033\\"}, {64, 0, "(DECRQDE) Window report", "\033[\"v"}, {0, 0, 0, 0} }; struct request_control { const char *text; const char *expect; const char *request; const char *set_mode; const char *reset_mode; }; /* Request control function selection or setting */ static const struct request_control rqss[] = { {"Data sent to screen", "0", "$}", "\033[0$}", 0}, {"Data sent to disabled status line", "0", "$}", 0, 0}, {"\033[0$~\033[1$}", "\033[0$}", 0, 0, 0}, {"Data sent to enabled status line", "1", "$}", 0, 0}, {"\033[2$~\033[1$}", "\033[0$}", 0, 0, 0}, {"Disable status line", "0", "$~", "\033[0$~", 0}, {"Top status line", "1", "$~", "\033[1$~", 0}, {"Bottom status line", "2", "$~", "\033[2$~", 0}, {"Erasable character", "0", "\"q", "\033[0\"q", 0}, {"Nonerasable character", "1", "\"q", "\033[1\"q", "\033[0\"q"}, {"Top and bottom margins", "3;10", "r", "\0337\033[3;10r", 0}, {"\033[r\0338", 0, 0, 0, 0}, {"Top and bottom margins", "default", "r", "\0337\033[r", "\0338"}, {"Character attributes, dim, bold", "1", "m", "\033[2;1m", "\033[m"}, {"Character attributes, bold, dim", "2", "m", "\033[1;2m", "\033[m"}, {"Character attributes, under, rev", "4;7", "m", "\033[4;7m", "\033[m"}, {"Character attributes, color", "35;42", "m", "\033[35;42m", "\033[m"}, {"All character attributes", "", "m", "\033[1;2;3;4;5;6;7;8;9m", 0}, {"\033[m", 0, 0, 0, 0}, {0, 0, 0, 0, 0} }; /* ** read_ansi() ** ** read an ANSI status report from terminal */ static void read_ansi(void) { int ch, i, j, last_escape; fflush(stdout); read_key((char *)ansi_buf, sizeof(ansi_buf)); /* Throw away control characters inside CSI sequences. Convert two character 7-bit sequences into 8-bit sequences. */ for (i = j = last_escape = 0; (ch = ansi_buf[i]) != 0; i++) { if (ch == A_ESC) { if (last_escape == A_ESC) { pack_buf[j++] = A_ESC; } last_escape = A_ESC; } else if (last_escape == A_ESC && ch >= '@' && ch <= '_') { last_escape = ch + 0x40; pack_buf[j++] = (unsigned char) last_escape; } else if (last_escape != A_CSI || (ch > 0x20 && ch != 0x80)) { if (last_escape == A_ESC) { pack_buf[j++] = A_ESC; } if (ch > 0x80 && ch < 0xa0) { last_escape = ch; } pack_buf[j++] = (unsigned char) ch; } } if (last_escape == A_ESC) { pack_buf[j++] = A_ESC; } pack_buf[j] = '\0'; return; } /* ** valid_mode(expected) ** ** read a terminal mode status report and parse the result ** Return TRUE if we got the expected terminating character. */ static int valid_mode(int expected) { unsigned char *s; int ch, terminator; read_ansi(); ape = 0; ch = UChar(pack_buf[0]); ansi_value[0] = 0; if (ch != A_CSI && ch != A_DCS) return FALSE; s = pack_buf + 1; private_use = 0; if ((*s >= '<') & (*s <= '?')) { private_use = *s++; } terminator = 0; for (; (ch = *s); s++) { if (ch >= '0' && ch <= '9') ansi_value[ape] = (short) (ansi_value[ape] * 10 + ch - '0'); else if (ch == ';' || ch == ':') ansi_value[++ape] = 0; else if (ch >= '<' && ch <= '?') private_use = ch; else if (ch >= ' ') terminator = (terminator << 8) | ch; else break; } return terminator == expected; } /* ** read_reports() ** ** read all the reports in the ANSI report structure */ static int read_reports(void) { int i, j, k, tc, vcr, lc; char *s; const char *t; lc = 5; terminal_class = tc = 0; for (i = 0; report_list[i].text; i++, lc++) { if (terminal_class < report_list[i].lvl && tc < report_list[i].lvl) { put_crlf(); menu_prompt(); ptext("/status [q] > "); j = wait_here(); if (j != 'n' && j != 'N') return 0; tc = report_list[i].lvl; lc = 1; } else if (lc + 2 >= lines) { put_crlf(); ptext("Hit any key to continue "); (void) wait_here(); lc = 1; } sprintf(temp, "%s (%s) ", report_list[i].text, expand_command(report_list[i].request)); ptext(temp); for (j = (int) strlen(temp); j < 49; j++) putchp(' '); tc_putp(report_list[i].request); vcr = 0; if (report_list[i].final == 0) { read_ansi(); } else if (valid_mode(report_list[i].final)) switch (report_list[i].final) { case 'c': terminal_class = ansi_value[0]; break; case 'R': vcr = TRUE; break; } j = UChar(pack_buf[0]); if (j != A_CSI && j != A_DCS) { put_crlf(); t = "*** The above request gives illegal response ***"; ptext(t); for (j = (int) strlen(t); j < 49; j++) putchp(' '); } s = expand((const char *)ansi_buf); if (char_count + expand_chars >= columns) { put_str("\r\n "); lc++; } putln(s); if (vcr) { /* find out how big the screen is */ tc_putp(report_list[i].request); if (!valid_mode('R')) continue; j = ansi_value[0]; k = ansi_value[1]; tc_putp("\033[255B\033[255C\033[6n"); if (!valid_mode('R')) continue; sprintf(temp, "\033[%d;%dH", j, k); tc_putp(temp); ptext("(DSR) Screen size (CSI 6 n)"); for (j = char_count; j < 50; j++) putchp(' '); sprintf(temp, "%d x %d", ansi_value[1], ansi_value[0]); ptextln(temp); } } menu_prompt(); ptext("/status r->repeat test, to continue > "); return wait_here(); } /* ** request_cfss() ** ** Request Control function selection or settings */ static int request_cfss(void) { int i, j, k, l, ch; char *s; put_clear(); ptextln("Request Expected Received"); put_crlf(); for (i = 0; rqss[i].text; i++) { ptext(rqss[i].text); if (rqss[i].expect == 0) continue; j = (int) (strlen(rqss[i].text) + strlen(rqss[i].expect)); putchp(' '); for (j++; j < 40; j++) putchp(' '); ptext(rqss[i].expect); putchp(' '); tc_putp(rqss[i].set_mode); sprintf(temp, "\033P$q%s\033\\", rqss[i].request); tc_putp(temp); read_ansi(); tc_putp(rqss[i].reset_mode); putchp(' '); for (j = 0; ansi_buf[j]; j++) { if (ansi_buf[j] == 'r') { for (k = j++; (ch = UChar(ansi_buf[k])) != 0; k++) if (ch == A_ESC) { break; } else if (ch == A_ST) { break; } ansi_buf[k] = '\0'; s = expand((const char *)&ansi_buf[j]); if (char_count + expand_chars >= columns) put_str("\r\n "); put_str(s); } } put_crlf(); } /* calculate the valid attributes */ ptext("Valid attributes: 0"); j = 0; for (i = 1; i < 20; i++) { sprintf(temp, "\033[0;%dm\033P$qm\033\\", i); tc_putp(temp); (void) valid_mode('m'); if (ape > 0) { j = i; sprintf(temp, "\033[0m; %d", i); tc_putp(temp); } } put_crlf(); /* calculate how many parameters can be sent */ ptext("Max number of parameters: "); sprintf(temp, "%dm\033P$qm\033\\", j); l = -1; if (j > 0) for (l = 1; l < 33; l++) { tc_putp("\033[0"); for (ch = 1; ch <= l; ch++) put_this(';'); tc_putp(temp); (void) valid_mode('m'); if (ape == 0) break; } tc_putp("\033[m"); if (l >= 0) { sprintf(temp, "%d", l); ptext(temp); } else ptext("unknown"); put_crlf(); return wait_here(); } /* ** mode_display(puc, mode, initial, set, reset) ** ** print the mode display entry */ static void mode_display(const char *p, int n, int c, char s, char r) { int k; sprintf(temp, "%s%d (%c, %c, %c)", p, n, c, s, r); k = (int) strlen(temp); if (char_count + k >= columns) put_crlf(); for (; k < 14; k++) putchp(' '); put_str(temp); } /* ** terminal_state() ** ** test DECRQM status reports */ static void terminal_state(void) { static const char *puc[] = {"", "<", "=", ">", "?", 0}; int i, j, k, l, modes_found; char *s; char buf[256], tms[256]; int mode_puc[MAX_MODES], mode_number[MAX_MODES]; char set_value[MAX_MODES], reset_value[MAX_MODES]; char current_value[MAX_MODES]; ptext("Testing terminal mode status. (CSI 0 $ p)"); tc_putp("\033[0$p"); modes_found = 0; tms[0] = '\0'; if (valid_mode(('$' << 8) | 'y')) { for (i = 0; puc[i]; i++) { put_crlf(); if (i) { sprintf(temp, "Private use: %c", puc[i][0]); } else { strcpy(temp, "Standard modes:"); } k = (int) strlen(temp); ptext(temp); for (j = 0; j < (int) sizeof(buf); buf[j++] = ' ') ; for (j = l = 0; j < 255 && j - l < 50; j++) { sprintf(temp, "\033[%s%d$p", puc[i], j); tc_putp(temp); if (!valid_mode(('$' << 8) | 'y')) { /* not valid, save terminating value */ s = expand((const char *)ansi_buf); sprintf(tms, "%s%s%d %s ", tms, puc[i], j, s); break; } if (private_use != puc[i][0]) break; if (ansi_value[0] != j) break; if (ansi_value[1]) { l = j; if (k > 70) { buf[k] = '\0'; put_crlf(); ptextln(buf); for (k = 0; k < (int) sizeof(buf);) { buf[k++] = ' '; } k = 0; } sprintf(temp, " %d", j); ptext(temp); k += (int) strlen(temp); buf[k - 1] = (char) (ansi_value[1] + '0'); if (modes_found >= MAX_MODES) continue; current_value[modes_found] = (char) (ansi_value[1] + '0'); /* some modes never return */ if ((i == 0 && j == 13) /* control execution */ || (puc[i][0] == '?' && j == 2)) /* VT52 */ set_value[modes_found] = reset_value[modes_found] = '-'; else set_value[modes_found] = reset_value[modes_found] = ' '; mode_puc[modes_found] = i; mode_number[modes_found++] = j; } } buf[k] = '\0'; if (buf[k - 1] != ' ') { put_crlf(); ptext(buf); } } if ((i = modes_found) != 0) { put_crlf(); put_crlf(); if (tms[0]) { ptextln(tms); } ptext("Hit 'Y' to test mode set/reset states: "); i = wait_here(); } if (i == 'y' || i == 'Y') while (1) { #ifdef STATUSFIX FILE *fp; #ifdef TEDANSI fp = fopen("ted.ansi", "w"); #else fp = fopen("/dev/console", "w"); #endif #endif for (i = j = 0; j < modes_found; j = ++i >> 1) { if (set_value[j] == '-') continue; k = (current_value[j] ^ i) & 1; sprintf(temp, "\033[%s%d%c\033[%s%d$p", puc[mode_puc[j]], mode_number[j], k ? 'l' : 'h', puc[mode_puc[j]], mode_number[j]); #ifdef STATUSFIX if (fp) { fprintf(fp, "%s\n", expand(temp)); fflush(fp); } #endif tc_putp(temp); if (!valid_mode(('$' << 8) | 'y')) continue; if (k) { reset_value[j] = (char) (ansi_value[1] + '0'); } else { set_value[j] = (char) (ansi_value[1] + '0'); } } put_str("\033[30l"); /* added for GORT bug (WY-185) */ #ifdef STATUSFIX if (fp) fclose(fp); #endif tty_set(); /* print the results */ put_clear(); putln("mode (initial, set, reset)"); for (j = 0; j < modes_found; j++) { mode_display(puc[mode_puc[j]], mode_number[j], current_value[j], set_value[j], reset_value[j]); } ptext("\n\nHit 'R' to repeat test. 'S' to sort results: "); i = wait_here(); if (i == 's' || i == 'S') { /* print the same stuff, sorted by current_value */ put_crlf(); for (i = '1'; i <= '4'; i++) { for (j = 0; j < modes_found; j++) { if (current_value[j] == i) mode_display(puc[mode_puc[j]], mode_number[j], current_value[j], set_value[j], reset_value[j]); } } ptext("\n\nHit 'R' to repeat test: "); i = wait_here(); } if (i != 'r' && i != 'R') break; tty_raw(1, char_mask); } } else { tty_set(); } } /* ** ansi_report_help() ** ** Display the informational data for the ANSI report test. */ static void ansi_report_help(void) { ptext("Begin ANSI status report testing. "); ptext(" Parity bit set will be displayed in reverse video. "); ptext(" If the terminal hangs, hit any alphabetic key. "); ptextln(" Use n to continue testing. Use q to quit."); put_crlf(); } /* ** test_ansi_reports() ** ** Test the ANSI status report functions */ void tools_status( struct test_list *t GCC_UNUSED, int *state GCC_UNUSED, int *ch) { int i; put_clear(); ansi_report_help(); tty_raw(1, char_mask); do { i = read_reports(); if (i != 'r' && i != 'R') { *ch = i; break; } } while (i); /* VT320, VT420, etc. */ if (terminal_class >= 63) { do { i = request_cfss(); } while (i == 'r' || i == 'R'); *ch = i; terminal_state(); } else { tty_set(); } } /* ** display_sgr() ** ** Test a range of ANSI sgr attributes ** puc -> Private Use Character */ static void display_sgr(int puc) { int k; temp[0] = (char) puc; temp[1] = '\0'; for (k = 0; k < 80; k++) { if (char_count + 8 > 80) put_crlf(); else if (char_count + 8 > columns) put_crlf(); else if (k > 0) printf(" "); printf("\033[%s%dmMode %2d\033[0m", temp, k, k); char_count += 8; if (puc == '\0') { if (k == 19) printf("\033[10m"); if (k == 39) printf("\033[37m"); if (k == 49) printf("\033[40m"); } } put_crlf(); if (puc == '<') printf("\033[<1m"); else if (puc) printf("\033[%s0m", temp); set_attr(0); } /* ** print_sgr20(on, off) ** ** print the sgr line for sgr20() */ static void print_sgr20(int on, int off) { if (char_count > columns - 13) { put_crlf(); } else if (char_count) { put_str(" "); } char_count += 11; printf("%d/%d \033[%dmon\033[%dm off\033[0m", on, off, on, off); } /* ** sgr20(void) ** ** display the enter/exit attributes 1-9 and 20-29 */ static void sgr20(void) { int k; put_crlf(); ptextln("Test enter/exit attributes 1-9 and 21-29."); for (k = 1; k < 10; k++) { print_sgr20(k, k + 20); } print_sgr20(1, 22); /* bold */ print_sgr20(2, 22); /* dim */ print_sgr20(8, 22); /* blank */ printf("\033[0m"); set_attr(0); } /* ** tools_sgr(testlist, state, ch) ** ** Run the ANSI graphics rendition mode tool ** Return the last character typed. */ void tools_sgr( struct test_list *t GCC_UNUSED, int *state GCC_UNUSED, int *ch) { int k; put_clear(); for (k = 0;;) { display_sgr(k); put_crlf(); menu_prompt(); ptext("/sgr Enter =>] > "); k = wait_here(); if ((k == 'r') || (k == 'R')) { k = 0; } else if ((k < '<') || (k > '?')) { break; } } sgr20(); put_newlines(2); *ch = REQUEST_PROMPT; } /***************************************************************************** * * Test ANSI graphics * *****************************************************************************/ /* ** select_bank(bank) ** ** select a graphics character set for ANSI terminals */ static void select_bank(char *bank) { tc_putp(bank); switch (bank[1] & 3) { case 0: putchp('O' & 0x1f); /* control O */ break; case 1: putchp('N' & 0x1f); /* control N */ tc_putp("\033~"); break; case 2: tc_putp("\033n\033}"); break; case 3: tc_putp("\033o\033|"); break; } } /* ** show_characters(bank, bias) ** ** print the ANSI graphics characters */ static void show_characters(char *bank, int bias) { int i; sprintf(temp, "G%d GL ", bank[1] & 3); ptext(temp); select_bank(bank); for (i = ' '; i < 0x80; i++) { if (char_count >= columns || (i != ' ' && (i & 31) == 0)) put_str("\n "); putchp(i + bias); } select_bank(default_bank); put_str(" DEL <"); select_bank(bank); putchp(0x7f + bias); select_bank(default_bank); putchp('>'); put_crlf(); put_crlf(); } /* ANSI graphics test 94 96 character sets G0 ( , G1 ) - G2 * . G3 + / Standard Definitions A UK B US ASCII Dec extended definitions 0 Special graphics */ /* ** tools_charset(testlist, state, ch) ** ** Run the ANSI alt-charset mode tool */ void tools_charset( struct test_list *t GCC_UNUSED, int *state GCC_UNUSED, int *chp GCC_UNUSED) { int j, ch; char bank[32]; put_clear(); ptext("Enter the bank ()*+,-./ followed by the character set"); ptext(" 0123456789:;<=>? for private use, and"); ptextln(" @A...Z[\\]^_`a...z{|}~ for standard sets."); strcpy(bank, "\033)0"); for (; bank[0];) { put_crlf(); show_characters(bank, 0); /* G0 will not print in GR */ if (bank[1] & 3) { show_characters(bank, 0x80); } ptext("bank+set> "); for (j = 1; (ch = getchp(char_mask)); j++) { if (ch == EOF) break; putchp(ch); if (j == 1 && ch > '/') j++; bank[j] = (char) ch; if (ch < ' ' || ch > '/') break; if (j + 2 >= (int) sizeof(bank)) break; } if (j == 1) break; if (bank[j] < '0' || bank[j] > '~') break; bank[j + 1] = '\0'; } put_crlf(); } tack-1.07/CHANGES0000644000175100001440000002010311315504067012073 0ustar tomusers2009-12-26 Thomas Dickey * configure: regen to get new macros, as well as to use autoconf-252 (patched) * aclocal.m4: resync with my-autoconf (many changes) * Makefile.in: drop mkdirs.sh, just use mkdir -p * control.c, tack.c, sysdep.c, sync.c: strict gcc warnings * init.c: check if baudrate() returns ERR, use 1 if so. * fun.c, edit.c, pad.c, scan.c, charset.c: strict gcc warnings * tack.h: bump to 1.07 * HISTORY: reason for release * ansi.c, output.c, menu.c: strict gcc warnings * edit.c: fix an incorrect malloc-size in show_report(), which could cause core-dump when displaying long list of function-keys, e.g., for xterm-new 2009-11-19 Thomas Dickey * config.guess, config.sub: update to 2009-11-20 2007-08-12 Thomas Dickey * edit.c: as of 2007/8/12, ncurses no longer exports the data _nc_info_hash_table. Instead, use the function _nc_get_hash_table(), which is in ncurses 5.0 2007-08-11 Thomas Dickey * HISTORY: tweak to build with latest ncurses (does not rely on new api's) 2007-04-29 Thomas Dickey * HISTORY, tack.h: mark 1.05 * configure: regen'd * configure.in: update LIB_LINK symbol to match CF_WITH_LIBTOOL change * tack.h: use SIG_ATOMIC_T * sysdep.c: move include of to tack.h so SIG_ATOMIC_T definition works. * tack.c: use EXIT_FAILURE/EXIT_SUCCESS * sysdep.c: use EXIT_FAILURE/EXIT_SUCCESS use SIG_ATOMIC_T * output.c: add braces for readability * tack.h: trim whitespace * scan.c, init.c: use EXIT_FAILURE/EXIT_SUCCESS * configure.in, aclocal.m4: add CF_SIG_ATOMIC_T * control.c: use SIG_ATOMIC_T * Makefile.in: update $(LINK) to work with ncurses after importing CF_WITH_LIBTOOL change that moved $(CC) into $(LIBTOOL_LINK) symbol. 2007-04-08 Thomas Dickey * configure: regen'd * Makefile.in: define $(INCDIR) - needed for building in ncurses tree * tack.h: expand the ExitProgram() macro into a function which can call the ncurses- and tack-specific leak-auditing functions. * configure.in: check for _nc_free_tic() function, since that's what tack needs. * edit.c: add tack_edit_leaks(), to help audit memory leaks * tack.c: add ExitProgram() function, to free all application memory on exit to simplify leak-checking. * fun.c: add tack_fun_leaks(), to help audit memory leaks * init.c: free the TERMTYPE used just for error-checking (memory leak) * tack.h: define ExitProgram() macro to hide details of memory audit on exit(). * tack.c, init.c, sysdep.c: use ExitProgram() macro * configure.in: add "--disable-leaks" and related testing options. * aclocal.m4: add macros used for "--disable-leaks" and related testing options * configure.in: use CF_NCURSES_CONFIG to find ncurses5-config, etc., fixing rpath issues. add check for ticlib, if needed. remove check for pdcurses (this will never work with anything except for ncurses), and add checks for select() and gettimeofday(). * aclocal.m4: modify CF_XOPEN_SOURCE to add FreeBSD/GNU (kFreeBSD) pattern * Makefile.in: rename mkinstalldirs to mkdirs.sh * HISTORY: 1.04 2007-04-07 Thomas Dickey * ansi.c, output.c: fixes from Coverity report 2007-03-25 Thomas Dickey * mkdirs.sh: RCS_BASE 2007-01-28 Thomas Dickey * HISTORY: tack's out of ncurses now. * Makefile.in: make install rule work * tack.h: bump to 1.03 * Makefile.in: first cut of installing manpage * Makefile.in: tweaks to work after chopping out of ncurses tree 2007-01-27 Thomas Dickey * HISTORY: update to 1.03 * README: FROM_KEYS 2007-01-13 Thomas Dickey * Makefile.in: FROM_KEYS * configure: RCS_BASE * configure.in, aclocal.m4: FROM_KEYS 2006-12-23 Thomas Dickey * modules: FROM_KEYS 2006-12-22 Thomas Dickey * config.guess: RCS_BASE 2006-12-08 Thomas Dickey * config.sub: RCS_BASE 2006-11-25 Thomas Dickey * output.c: FROM_KEYS * modes.c: from ncurses * init.c, fun.c: FROM_KEYS * crum.c: from ncurses * color.c, charset.c, tack.h: FROM_KEYS 2006-06-24 Thomas Dickey * control.c, edit.c: FROM_KEYS 2006-05-06 Thomas Dickey * sync.c: FROM_KEYS 2006-04-22 Thomas Dickey * tack.1: FROM_KEYS 2005-09-17 Thomas Dickey * ansi.c, pad.c, sysdep.c: FROM_KEYS * menu.c, scan.c, tack.c: from ncurses * COPYING: fix address 2003-11-29 Thomas Dickey * install-sh: resync with my-autoconf 2002-06-29 Thomas Dickey * mkinstalldirs: RCS_BASE 2001-06-22 Thomas Dickey * install-sh: RCS_BASE 1999-02-07 Thomas Dickey * HISTORY: nit * init.c: tweak to make this build after renaming as per Alexander 1998-09-26 Thomas Dickey * edit.c: add param to _nc_tic_expand() 1998-03-28 Thomas Dickey * Makefile.in: updates to sync with ncurses 4.2 1998-02-11 Thomas Dickey * ncurses_tst.hin: FROM_KEYS 1998-01-09 Daniel.Weaver * tack.c, Makefile.in, tack.h, control.c, color.c, charset.c, ansi.c, sysdep.c, sync.c, scan.c, pad.c, output.c, modes.c, menu.c, init.c, fun.c, edit.c, crum.c, HISTORY, COPYING: tack-1.00 1998-01-03 Thomas Dickey * tack.h: moved ncurses' externs to tic.h * edit.c: split-out _nc_tic_expand(), as per DW's request. * sysdep.c: nits (we don't _need_ time.h?) * tack.h: SCO's compiler doesn't like array-of-const 1998-01-02 Thomas Dickey * control.c: work with no 'gettimeofday()' workaround for SCO 3.x compiler which gets confused by array of const. * output.c, edit.c, fun.c: SCO's compiler doesn't like array-of-const * ansi.c: SCO's compiler: parameter promotion warnings. 1997-12-28 Thomas Dickey * tack.h: first cut of fixes for AIX/SCO/CLIX * sysdep.c, control.c: first cut of fixes for AIX/CLIX/SCO 1997-12-27 Thomas Dickey * ansi.c, charset.c, control.c, crum.c, edit.c, fun.c, init.c, menu.c, modes.c, output.c, scan.c, sync.c, sysdep.c, tack.c: integration with ncurses: restructured includes, fix gcc warnings * pad.c: integration with ncurses: restructures includes, fix gcc warnings * color.c: typo * tack.h: integration with ncurses: reordered headers, provide fallback definitions for the stuff we get from ncurses_cfg.h, make some stuff const. * Makefile.in: use HAVE_SELECT from configure-script * color.c: integration with ncurses: move most headers into tack.h, fix gcc warnings * Makefile.in: we'll have a config.h (actually ncurses_cfg.h) * modules: set base-subset 1997-12-24 Daniel.Weaver * HISTORY: ncurses-4.1-971220 1997-12-22 Daniel.Weaver * ansi.c, tack.1: ncurses-4.1-971220 1997-12-02 Daniel.Weaver * tack.c, init.c: ncurses-4.1-971220 1997-11-30 Daniel.Weaver * edit.c: ncurses-4.1-971220 1997-11-29 Daniel.Weaver * charset.c, pad.c: ncurses-4.1-971220 1997-11-07 Daniel.Weaver * sync.c, fun.c, crum.c, modes.c, control.c, sysdep.c, output.c, tack.h: ncurses-4.1-971220 1997-11-04 Daniel.Weaver * Makefile.in, menu.c: ncurses-4.1-971220 1997-11-03 Daniel.Weaver * scan.c, color.c, modules: ncurses-4.1-971220 1997-10-29 Daniel.Weaver * control.c, fun.c: ncurses-4.1-971101 1997-10-26 Daniel.Weaver * makefile, edit.c, tack.h, sync.c: ncurses-4.1-971101 1997-10-25 Daniel.Weaver * pad.c, tack.1: ncurses-4.1-971101 1997-10-19 Daniel.Weaver * tack.c, sysdep.c, scan.c, output.c, modes.c, menu.c, init.c, crum.c, color.c, charset.c, ansi.c, HISTORY: ncurses-4.1-971101 1997-10-11 dickey * RCS: PERMIT FILE 1997-10-06 Daniel.Weaver * makefile, tac.h, tack.c: ncurses-4.1-971011 1997-10-04 Daniel.Weaver * control.c, fun.c, sync.c, init.c, pad.c, modes.c, sysdep.c: ncurses-4.1-971011 1997-10-03 Daniel.Weaver * charset.c, output.c, edit.c, crum.c: ncurses-4.1-971011 1997-10-02 Daniel.Weaver * menu.c: ncurses-4.1-971011 1997-09-29 Daniel.Weaver * color.c, ansi.c: ncurses-4.1-971011 1997-09-28 Daniel.Weaver * tic.h: ncurses-4.1-971011 1997-09-22 Daniel.Weaver * scan.c: ncurses-4.1-971011 tack-1.07/charset.c0000644000175100001440000004075211315477615012721 0ustar tomusers/* ** Copyright (C) 1991, 1997-2000 Free Software Foundation, Inc. ** ** This file is part of TACK. ** ** TACK is free software; you can redistribute it and/or modify ** it under the terms of the GNU General Public License as published by ** the Free Software Foundation; either version 2, or (at your option) ** any later version. ** ** TACK 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 TACK; see the file COPYING. If not, write to ** the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, ** Boston, MA 02110-1301, USA */ #include MODULE_ID("$Id: charset.c,v 1.12 2009/12/26 21:26:37 tom Exp $") /* Menu definitions for alternate character set and SGR tests. */ static void charset_bel(struct test_list *t, int *state, int *ch); static void charset_flash(struct test_list *t, int *state, int *ch); static void charset_civis(struct test_list *t, int *state, int *ch); static void charset_cvvis(struct test_list *t, int *state, int *ch); static void charset_cnorm(struct test_list *t, int *state, int *ch); static void charset_hs(struct test_list *t, int *state, int *ch); static void charset_status(struct test_list *t, int *state, int *ch); static void charset_dsl(struct test_list *t, int *state, int *ch); static void charset_enacs(struct test_list *t, int *state, int *ch); static void charset_smacs(struct test_list *t, int *state, int *ch); static void charset_attributes(struct test_list *t, int *state, int *ch); static void charset_sgr(struct test_list *t, int *state, int *ch); struct test_list acs_test_list[] = { {0, 0, 0, 0, "e) edit terminfo", 0, &edit_menu}, {MENU_NEXT, 3, "bel", 0, 0, charset_bel, 0}, {MENU_NEXT, 3, "flash", 0, 0, charset_flash, 0}, {MENU_NEXT, 3, "civis", 0, 0, charset_civis, 0}, {MENU_NEXT, 3, "cvvis", 0, 0, charset_cvvis, 0}, {MENU_NEXT, 3, "cnorm", 0, 0, charset_cnorm, 0}, {MENU_NEXT, 3, "hs", 0, 0, charset_hs, 0}, {MENU_NEXT, 3, "tsl) (fsl) (wsl", "hs", 0, charset_status, 0}, {MENU_NEXT, 3, "dsl", "hs", 0, charset_dsl, 0}, {MENU_NEXT, 0, "acsc) (enacs) (smacs) (rmacs", 0, 0, charset_enacs, 0}, {MENU_NEXT, 0, "smacs) (rmacs", 0, 0, charset_smacs, 0}, {MENU_NEXT, 11, 0, 0, 0, charset_attributes, 0}, {MENU_NEXT, 11, "sgr) (sgr0", "ma", 0, charset_sgr, 0}, {MENU_LAST, 0, 0, 0, 0, 0, 0} }; const struct mode_list alt_modes[] = { {"normal", "(sgr0)", "(sgr0)", 1}, {"standout", "(smso)", "(rmso)", 2}, {"underline", "(smul)", "(rmul)", 4}, {"reverse", "(rev)", "(sgr0)", 8}, {"blink", "(blink)", "(sgr0)", 16}, {"dim", "(dim)", "(sgr0)", 32}, {"bold", "(bold)", "(sgr0)", 64}, {"invis", "(invis)", "(sgr0)", 128}, {"protect", "(prot)", "(sgr0)", 256}, {"altcharset", "(smacs)", "(rmacs)", 512} }; /* On many terminals the underline attribute is the last scan line. This is OK unless the following line is reverse video. Then the underline attribute does not show up. The following map will reorder the display so that the underline attribute will show up. */ const int mode_map[10] = {0, 1, 3, 4, 5, 6, 7, 8, 9, 2}; struct graphics_pair { unsigned char c; const char *name; }; static struct graphics_pair glyph[] = { {'+', "arrow pointing right"}, {',', "arrow pointing left"}, {'.', "arrow pointing down"}, {'0', "solid square block"}, {'i', "lantern symbol"}, {'-', "arrow pointing up"}, {'`', "diamond"}, {'a', "checker board (stipple)"}, {'f', "degree symbol"}, {'g', "plus/minus"}, {'h', "board of squares"}, {'j', "lower right corner"}, {'k', "upper right corner"}, {'l', "upper left corner"}, {'m', "lower left corner"}, {'n', "plus"}, {'o', "scan line 1"}, {'p', "scan line 3"}, {'q', "horizontal line"}, {'r', "scan line 7"}, {'s', "scan line 9"}, {'t', "left tee (|-)"}, {'u', "right tee (-|)"}, {'v', "bottom tee(_|_)"}, {'w', "top tee (T)"}, {'x', "vertical line"}, {'y', "less/equal"}, {'z', "greater/equal"}, {'{', "Pi"}, {'|', "not equal"}, {'}', "UK pound sign"}, {'~', "bullet"}, {'\0', "\0"} }; /* ** charset_hs(test_list, status, ch) ** ** (hs) test Has status line */ static void charset_hs( struct test_list *t, int *state, int *ch) { if (has_status_line != 1) { ptext("(hs) Has-status line is not defined. "); generic_done_message(t, state, ch); } } /* ** charset_status(test_list, status, ch) ** ** (tsl) (fsl) (wsl) test Status line */ static void charset_status( struct test_list *t, int *state, int *ch) { int i, max; char *s; static char m[] = "*** status line *** 123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789."; if (has_status_line != 1) { return; } put_clear(); max = width_status_line == -1 ? columns : width_status_line; sprintf(temp, "Terminal has status line of %d characters", max); ptextln(temp); put_str("This line s"); s = TPARM_1(to_status_line, 0); tc_putp(s); for (i = 0; i < max; i++) putchp(m[i]); tc_putp(from_status_line); putln("hould not be broken."); ptextln("If the previous line is not a complete sentence then (tsl) to-status-line, (fsl) from-status-line, or (wsl) width-of-status-line is incorrect." ); generic_done_message(t, state, ch); } /* ** charset_dsl(test_list, status, ch) ** ** (dsl) test Disable status line */ static void charset_dsl( struct test_list *t, int *state, int *ch) { if (has_status_line != 1) { return; } if (dis_status_line) { ptextln("Disable status line (dsl)"); tc_putp(dis_status_line); ptext("If you can still see the status line then (dsl) disable-status-line has failed. "); } else { ptext("(dsl) Disable-status-line is not defined. "); } generic_done_message(t, state, ch); } void eat_cookie(void) { /* put a blank if this is not a magic cookie terminal */ if (magic_cookie_glitch < 1) putchp(' '); } void put_mode(char *s) { /* send the attribute string (with or without % execution) */ tc_putp(TPARM_0(s)); /* allow % execution */ } void set_attr(int a) { /* set the attribute from the bits in a */ int i, b[32]; if (magic_cookie_glitch > 0) { char_count += magic_cookie_glitch; } if (a == 0 && exit_attribute_mode) { put_mode(exit_attribute_mode); return; } for (i = 0; i < 31; i++) { b[i] = (a >> i) & 1; } tc_putp(TPARM_9(set_attributes, b[1], b[2], b[3], b[4], b[5], b[6], b[7], b[8], b[9])); } /* ** charset_sgr(test_list, status, ch) ** ** (sgr) test Set Graphics Rendition */ static void charset_sgr( struct test_list *t, int *state, int *ch) { int i, j; if (!set_attributes) { ptext("(sgr) Set-graphics-rendition is not defined. "); generic_done_message(t, state, ch); return; } if (!exit_attribute_mode) { ptextln("(sgr0) Set-graphics-rendition-zero is not defined."); /* go ahead and test anyway */ } ptext("Test video attributes (sgr)"); for (i = 0; i < (int) (sizeof(alt_modes) / sizeof(struct mode_list)); i++) { put_crlf(); sprintf(temp, "%d %-20s", i, alt_modes[i].name); put_str(temp); set_attr(alt_modes[i].number); sprintf(temp, "%s", alt_modes[i].name); put_str(temp); set_attr(0); } putln("\n\nDouble mode test"); for (i = 0; i <= 9; i++) { sprintf(temp, " %2d ", mode_map[i]); put_str(temp); } for (i = 0; i <= 9; i++) { put_crlf(); sprintf(temp, "%d", mode_map[i]); put_str(temp); for (j = 0; j <= 9; j++) { eat_cookie(); set_attr((1 << mode_map[i]) | (1 << mode_map[j])); put_str("Aa"); set_attr(0); if (j < 9) eat_cookie(); } } put_crlf(); #ifdef max_attributes if (max_attributes >= 0) { sprintf(temp, "(ma) Maximum attributes %d ", max_attributes); ptext(temp); } #endif generic_done_message(t, state, ch); } /* ** test_one_attr(mode-number, begin-string, end-string) ** ** Display one attribute line. */ static void test_one_attr( int n, char *begin_mode, char *end_mode) { int i; sprintf(temp, "%-10s %s ", alt_modes[n].name, alt_modes[n].begin_mode); ptext(temp); for (; char_count < 19;) { putchp(' '); } if (begin_mode) { putchp('.'); put_mode(begin_mode); put_str(alt_modes[n].name); for (i = (int) strlen(alt_modes[n].name); i < 13; i++) { putchp(' '); } if (end_mode) { put_mode(end_mode); sprintf(temp, ". %s", alt_modes[n].end_mode); } else { set_attr(0); strcpy(temp, ". (sgr)"); } ptextln(temp); } else { for (i = 0; i < magic_cookie_glitch; i++) putchp('*'); put_str("*** missing ***"); for (i = 0; i < magic_cookie_glitch; i++) putchp('*'); put_crlf(); } } /* ** charset_attributes(test_list, status, ch) ** ** Test SGR */ static void charset_attributes( struct test_list *t, int *state, int *ch) { putln("Test video attributes"); test_one_attr(1, enter_standout_mode, exit_standout_mode); test_one_attr(2, enter_underline_mode, exit_underline_mode); test_one_attr(9, enter_alt_charset_mode, exit_alt_charset_mode); if (!exit_attribute_mode && !set_attributes) { ptextln("(sgr0) exit attribute mode is not defined."); generic_done_message(t, state, ch); return; } test_one_attr(3, enter_reverse_mode, exit_attribute_mode); test_one_attr(4, enter_blink_mode, exit_attribute_mode); test_one_attr(5, enter_dim_mode, exit_attribute_mode); test_one_attr(6, enter_bold_mode, exit_attribute_mode); test_one_attr(7, enter_secure_mode, exit_attribute_mode); test_one_attr(8, enter_protected_mode, exit_attribute_mode); generic_done_message(t, state, ch); } #define GLYPHS 256 /* ** charset_smacs(test_list, status, ch) ** ** display all possible acs characters ** (smacs) (rmacs) */ static void charset_smacs( struct test_list *t, int *state, int *ch) { int i, c; if (enter_alt_charset_mode) { put_clear(); ptextln("The following characters are available. (smacs) (rmacs)"); for (i = ' '; i <= '`'; i += 32) { put_crlf(); put_mode(exit_alt_charset_mode); for (c = 0; c < 32; c++) { putchp(c + i); } put_crlf(); put_mode(enter_alt_charset_mode); for (c = 0; c < 32; c++) { putchp(c + i); } put_mode(exit_alt_charset_mode); put_crlf(); } put_mode(exit_alt_charset_mode); put_crlf(); generic_done_message(t, state, ch); } } static void test_acs( int attr) { /* alternate character set */ int i, j; char valid_glyph[GLYPHS]; char acs_table[GLYPHS]; static unsigned char vt100[] = "`afgjklmnopqrstuvwxyz{|}~"; line_count = 0; for (i = 0; i < GLYPHS; i++) { valid_glyph[i] = FALSE; acs_table[i] = (char) i; } if (acs_chars) { sprintf(temp, "Alternate character set map: %s", expand(acs_chars)); putln(temp); for (i = 0; acs_chars[i]; i += 2) { if (acs_chars[i + 1] == 0) { break; } for (j = 0;; j++) { if (glyph[j].c == (unsigned char) acs_chars[i]) { acs_table[glyph[j].c] = acs_chars[i + 1]; valid_glyph[glyph[j].c] = TRUE; break; } if (glyph[j].name[0] == '\0') { if (isgraph(UChar(acs_chars[i]))) { sprintf(temp, " %c", acs_chars[i]); } else { sprintf(temp, " 0x%02x", UChar(acs_chars[i])); } strcpy(&temp[5], " *** has no mapping ***"); putln(temp); break; } } } } else { ptextln("acs_chars not defined (acsc)"); /* enable the VT-100 graphics characters (default) */ for (i = 0; vt100[i]; i++) { valid_glyph[vt100[i]] = TRUE; } } if (attr) { set_attr(attr); } _nc_init_acs(); /* puts 'ena_acs' and incidentally links acs_map[] */ for (i = 0; glyph[i].name[0]; i++) { if (valid_glyph[glyph[i].c]) { put_mode(enter_alt_charset_mode); put_this(acs_table[glyph[i].c]); char_count++; put_mode(exit_alt_charset_mode); if (magic_cookie_glitch >= 1) { sprintf(temp, " %-30.30s", glyph[i].name); put_str(temp); if (char_count + 33 >= columns) put_crlf(); } else { sprintf(temp, " %-24.24s", glyph[i].name); put_str(temp); if (char_count + 26 >= columns) put_crlf(); } if (line_count >= lines) { (void) wait_here(); put_clear(); } } } if (char_count > 1) { put_crlf(); } #ifdef ACS_ULCORNER maybe_wait(5); put_mode(enter_alt_charset_mode); put_that(ACS_ULCORNER); put_that(ACS_TTEE); put_that(ACS_URCORNER); put_that(ACS_ULCORNER); put_that(ACS_HLINE); put_that(ACS_URCORNER); char_count += 6; put_mode(exit_alt_charset_mode); put_crlf(); put_mode(enter_alt_charset_mode); put_that(ACS_LTEE); put_that(ACS_PLUS); put_that(ACS_RTEE); put_that(ACS_VLINE); if (magic_cookie_glitch >= 1) put_this(' '); else { put_mode(exit_alt_charset_mode); put_this(' '); put_mode(enter_alt_charset_mode); } put_that(ACS_VLINE); char_count += 6; put_mode(exit_alt_charset_mode); put_str(" Here are 2 boxes"); put_crlf(); put_mode(enter_alt_charset_mode); put_that(ACS_LLCORNER); put_that(ACS_BTEE); put_that(ACS_LRCORNER); put_that(ACS_LLCORNER); put_that(ACS_HLINE); put_that(ACS_LRCORNER); char_count += 6; put_mode(exit_alt_charset_mode); put_crlf(); #endif } /* ** charset_bel(test_list, status, ch) ** ** (bel) test Bell */ static void charset_bel( struct test_list *t, int *state, int *ch) { if (bell) { ptextln("Testing bell (bel)"); tc_putp(bell); ptext("If you did not hear the Bell then (bel) has failed. "); } else { ptext("(bel) Bell is not defined. "); } generic_done_message(t, state, ch); } /* ** charset_flash(test_list, status, ch) ** ** (flash) test Visual bell */ static void charset_flash( struct test_list *t, int *state, int *ch) { if (flash_screen) { ptextln("Testing visual bell (flash)"); tc_putp(flash_screen); ptext("If you did not see the screen flash then (flash) has failed. "); } else { ptext("(flash) Flash is not defined. "); } generic_done_message(t, state, ch); } /* ** charset_civis(test_list, status, ch) ** ** (civis) test Cursor invisible */ static void charset_civis( struct test_list *t, int *state, int *ch) { if (cursor_normal) { if (cursor_invisible) { ptext("(civis) Turn off the cursor. "); tc_putp(cursor_invisible); ptext("If you can still see the cursor then (civis) has failed. "); } else { ptext("(civis) Cursor-invisible is not defined. "); } generic_done_message(t, state, ch); tc_putp(cursor_normal); } } /* ** charset_cvvis(test_list, status, ch) ** ** (cvvis) test Cursor very visible */ static void charset_cvvis( struct test_list *t, int *state, int *ch) { if (cursor_normal) { if (cursor_visible) { ptext("(cvvis) Make cursor very visible. "); tc_putp(cursor_visible); ptext("If the cursor is not very visible then (cvvis) has failed. "); } else { ptext("(cvvis) Cursor-very-visible is not defined. "); } generic_done_message(t, state, ch); tc_putp(cursor_normal); } } /* ** charset_cnorm(test_list, status, ch) ** ** (cnorm) test Cursor normal */ static void charset_cnorm( struct test_list *t, int *state, int *ch) { if (cursor_normal) { ptext("(cnorm) Normal cursor. "); tc_putp(cursor_normal); ptext("If the cursor is not normal then (cnorm) has failed. "); } else { ptext("(cnorm) Cursor-normal is not defined. "); } generic_done_message(t, state, ch); } /* ** charset_enacs(test_list, status, ch) ** ** test Alternate character set mode and alternate characters ** (acsc) (enacs) (smacs) (rmacs) */ static void charset_enacs( struct test_list *t, int *state, int *ch) { int c, i; if (enter_alt_charset_mode || acs_chars) { c = 0; while (1) { put_clear(); /* for terminals that use separate fonts for attributes (such as X windows) the line drawing characters must be checked for each font. */ if (c >= '0' && c <= '9') { test_acs(alt_modes[c - '0'].number); set_attr(0); } else { test_acs(0); } while (1) { ptextln("[r] to repeat, [012345789] to test with attributes on, [?] for a list of attributes, anything else to go to next test. "); generic_done_message(t, state, ch); if (*ch != '?') { break; } for (i = 0; i <= 9; i++) { sprintf(temp, " %d %s %s", i, alt_modes[i].begin_mode, alt_modes[i].name); ptextln(temp); } } if (*ch >= '0' && *ch <= '9') { c = *ch; } else if (*ch != 'r') { break; } } } else { ptext("(smacs) Enter-alt-char-set-mode and (acsc) Alternate-char-set are not defined. "); generic_done_message(t, state, ch); } } /* ** charset_can_test() ** ** Initialize the can_test data base */ void charset_can_test(void) { int i; for (i = 0; i < 9; i++) { can_test(alt_modes[i].begin_mode, FLAG_CAN_TEST); can_test(alt_modes[i].end_mode, FLAG_CAN_TEST); } } tack-1.07/color.c0000644000175100001440000004324010532156141012365 0ustar tomusers/* ** Copyright (C) 1991, 1997 Free Software Foundation, Inc. ** ** This file is part of TACK. ** ** TACK is free software; you can redistribute it and/or modify ** it under the terms of the GNU General Public License as published by ** the Free Software Foundation; either version 2, or (at your option) ** any later version. ** ** TACK 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 TACK; see the file COPYING. If not, write to ** the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, ** Boston, MA 02110-1301, USA */ #include MODULE_ID("$Id: color.c,v 1.7 2006/11/26 00:14:25 tom Exp $") /* * Color terminal tests. Has only one entry point: test_color(). */ static void color_check(struct test_list *, int *, int *); static void color_setf(struct test_list *, int *, int *); static void color_matrix(struct test_list *, int *, int *); static void color_ncv(struct test_list *, int *, int *); static void color_ccc(struct test_list *, int *, int *); static void color_bce(struct test_list *, int *, int *); struct test_list color_test_list[] = { {0, 0, 0, 0, "e) edit terminfo", 0, &edit_menu}, {MENU_NEXT, 2, "colors) (pairs", 0, 0, color_check, 0}, {MENU_NEXT, 12, "setf) (setb) (scp", 0, 0, color_setf, 0}, {MENU_NEXT, 24, "op", 0, 0, color_matrix, 0}, {MENU_NEXT, 16, "ncv", 0, 0, color_ncv, 0}, {MENU_NEXT, 0, "bce", 0, 0, color_bce, 0}, {MENU_NEXT | MENU_CLEAR, 0, "ccc) (initc) (initp", "hls op oc", 0, color_ccc, 0}, {MENU_LAST, 0, 0, 0, 0, 0, 0} }; #ifndef COLOR_BLACK #define COLOR_BLACK 0 #define COLOR_BLUE 1 #define COLOR_GREEN 2 #define COLOR_CYAN 3 #define COLOR_RED 4 #define COLOR_MAGENTA 5 #define COLOR_YELLOW 6 #define COLOR_WHITE 7 #endif struct color_table { const char *name; int index; int r, g, b; int h, l, s; }; static struct color_table def_colors[8] = { {"black ", COLOR_BLACK, 0, 0, 0, 0, 0, 0}, {"blue ", COLOR_BLUE, 0, 0, 1000, 330, 50, 100}, {"green ", COLOR_GREEN, 0, 1000, 0, 240, 50, 100}, {"cyan ", COLOR_CYAN, 0, 1000, 1000, 300, 50, 100}, {"red ", COLOR_RED, 1000, 0, 0, 120, 50, 100}, {"magenta", COLOR_MAGENTA, 1000, 0, 1000, 60, 50, 100}, {"yellow ", COLOR_YELLOW, 1000, 1000, 0, 180, 50, 100}, {"white ", COLOR_WHITE, 1000, 1000, 1000, 0, 100, 0} }; #define MAX_PAIR 256 static int fg_color[MAX_PAIR] = {COLOR_BLACK, COLOR_BLUE, COLOR_GREEN, COLOR_CYAN, COLOR_RED, COLOR_MAGENTA, COLOR_YELLOW, COLOR_WHITE}; static int bg_color[MAX_PAIR] = {COLOR_BLACK, COLOR_BLACK, COLOR_BLACK, COLOR_BLACK, COLOR_BLACK, COLOR_BLACK, COLOR_BLACK, COLOR_BLACK}; static int pairs_used = 8; static int a_bright_color, bright_value; static int cookie_monster, color_step, colors_per_line; static int R, G, B; static void reset_colors(void) { tc_putp(orig_colors); tc_putp(TPARM_0(orig_pair)); } static int color_trans(int c) { /* translate or load the color */ int i; for (i = 0; i < pairs_used; i++) { if (fg_color[i] == c) { return i; } } if (!can_change) { return 0; } if (pairs_used > max_colors || pairs_used >= MAX_PAIR) { pairs_used = 0; ptextln("Ran out of colors"); } fg_color[pairs_used] = c; bg_color[pairs_used] = c; if (hue_lightness_saturation) { tc_putp(TPARM_4(initialize_color, pairs_used, def_colors[c].h, def_colors[c].l, def_colors[c].s)); } else { tc_putp(TPARM_4(initialize_color, pairs_used, def_colors[c].r, def_colors[c].g, def_colors[c].b)); } return pairs_used++; } static void new_color( int fg, int bg, int hungry) { /* change the color to fg and bg. */ int i; if (hungry) { eat_cookie(); } if (set_a_foreground) { /* set ANSI color (setaf) (setab) */ tc_putp(TPARM_1(set_a_foreground, fg)); tc_putp(TPARM_1(set_a_background, bg)); } else if (set_foreground) { /* make sure black is zero */ (void) color_trans(COLOR_BLACK); tc_putp(TPARM_1(set_foreground, color_trans(fg))); tc_putp(TPARM_1(set_background, color_trans(bg))); } else { /* set color pair */ for (i = 0; i < pairs_used; i++) { if (fg_color[i] == fg && bg_color[i] == bg) { tc_putp(TPARM_1(set_color_pair, i)); if (hungry) { eat_cookie(); } return; } } if (!can_change) { /* try to set just the foreground */ for (i = pairs_used - 1; i; i--) { if (fg_color[i] == fg) break; } tc_putp(TPARM_1(set_color_pair, i)); if (hungry) { eat_cookie(); } return; } if (pairs_used > max_pairs || pairs_used >= MAX_PAIR) { pairs_used = 0; ptextln("Ran out of color pairs"); } fg_color[pairs_used] = fg; bg_color[pairs_used] = bg; if (hue_lightness_saturation) { tc_putp(TPARM_7(initialize_pair, pairs_used, def_colors[fg].h, def_colors[fg].l, def_colors[fg].s, def_colors[bg].h, def_colors[bg].l, def_colors[bg].s)); } else { tc_putp(TPARM_7(initialize_pair, pairs_used, def_colors[fg].r, def_colors[fg].g, def_colors[fg].b, def_colors[bg].r, def_colors[bg].g, def_colors[bg].b)); } tc_putp(TPARM_1(set_color_pair, pairs_used)); pairs_used++; } if (hungry) { eat_cookie(); } } static void set_color_step(void) { /* set the color_step for the (ccc) display */ int i; for (i = 2; i < 1000; i++) { if ((i * i * i) >= max_colors) { break; } } color_step = 1000 / (i - 1); } static void rgb_2_hls(int r, int g, int b, int *h, int *l, int *s) { /* convert RGB to HLS system */ int min, max, t; if ((min = g < r ? g : r) > b) { min = b; } if ((max = g > r ? g : r) < b) { max = b; } /* calculate lightness */ *l = (min + max) / 20; if (min == max) { /* black, white and all shades of gray */ *h = 0; *s = 0; return; } /* calculate saturation */ if (*l < 50) { *s = ((max - min) * 100) / (max + min); } else { *s = ((max - min) * 100) / (2000 - max - min); } /* calculate hue */ if (r == max) { t = 120 + ((g - b) * 60) / (max - min); } else if (g == max) { t = 240 + ((b - r) * 60) / (max - min); } else { t = 360 + ((r - g) * 60) / (max - min); } *h = t % 360; } static void send_color(int p, int r, int g, int b) { /* send the initialize_color (initc) command */ int h, l, s; if (hue_lightness_saturation) { rgb_2_hls(r, g, b, &h, &l, &s); tc_putp(TPARM_4(initialize_color, p, h, l, s)); } else { tc_putp(TPARM_4(initialize_color, p, r, g, b)); } } static void send_pair(int p, int fr, int fg, int fb, int br, int bg, int bb) { /* send the initialize_pair (initp) command */ int fh, fl, fs, bh, bl, bs; if (hue_lightness_saturation) { rgb_2_hls(fr, fg, fb, &fh, &fl, &fs); rgb_2_hls(br, bg, bb, &bh, &bl, &bs); tc_putp(TPARM_7(initialize_pair, p, fh, fl, fs, bh, bl, bs)); } else { tc_putp(TPARM_7(initialize_pair, p, fr, fg, fb, bb, bg, bb)); } } static int load_palette(int n) { /* load the color palette */ int rgb; for (;;) { if (pairs_used >= n) { return FALSE; } if (set_a_foreground || set_foreground) { if (pairs_used >= max_colors) { return FALSE; } send_color(pairs_used, R, G, B); rgb = R + G + B; if (rgb > bright_value) { bright_value = rgb; a_bright_color = pairs_used; } } else { if (pairs_used >= max_pairs) { return FALSE; } if (pairs_used == 0) { send_pair(pairs_used, 1000, 1000, 1000, R, G, B); } else { send_pair(pairs_used, R, G, B, R, G, B); } } pairs_used++; if ((B += color_step) > 1000) { B = 0; if ((G += color_step) > 1000) { G = 0; if ((R += color_step) > 1000) { return TRUE; } } } } } static int rainbow(int n) { /* print the programmable color display */ int i, c, d, palette_full, initial_pair; static const struct { const char *name; char ch; } splat[] = { {"Bg normal", ' '}, {"Fg normal", ' '}, {0, 0} }; if ((set_a_foreground || set_foreground) ? pairs_used >= max_colors : pairs_used >= max_pairs) { ptext("New palette: "); (void) wait_here(); initial_pair = pairs_used = 1; bright_value = 0; } else if (line_count + 3 >= lines) { ptext("Go: "); (void) wait_here(); put_clear(); initial_pair = pairs_used = 1; bright_value = 0; n++; } else { initial_pair = pairs_used; n += initial_pair; } palette_full = load_palette(n); for (d = 0; splat[d].name; d++) { c = splat[d].ch; if (d == 1) { put_mode(enter_reverse_mode); } for (i = initial_pair; i < n; i++) { if (i >= pairs_used) { break; } if (set_a_foreground) { if (i >= max_colors) { break; } tc_putp(TPARM_1(set_a_foreground, i)); tc_putp(TPARM_1(set_a_background, i)); } else if (set_foreground) { if (i >= max_colors) { break; } tc_putp(TPARM_1(set_foreground, i)); tc_putp(TPARM_1(set_background, i)); } else { if (i >= max_pairs) { break; } tc_putp(TPARM_1(set_color_pair, i)); } putchp(c); } if (d == 1) { put_mode(exit_attribute_mode); } if (set_a_foreground) { tc_putp(TPARM_1(set_a_foreground, a_bright_color)); tc_putp(TPARM_1(set_a_background, 0)); } else if (set_foreground) { tc_putp(TPARM_1(set_foreground, a_bright_color)); tc_putp(TPARM_1(set_background, 0)); } else { tc_putp(TPARM_1(set_color_pair, 0)); } put_str(" "); put_str(splat[d].name); put_crlf(); } return palette_full; } static void ncv_display(int m) { /* print the no_color_video (ncv) test line */ putchp('0' + m); putchp(' '); eat_cookie(); set_attr(1 << m); sprintf(temp, "%-11s", alt_modes[m].name); put_str(temp); new_color(COLOR_BLUE, COLOR_BLACK, TRUE); put_str("blue"); new_color(COLOR_BLACK, COLOR_GREEN, TRUE); put_str("green"); new_color(COLOR_WHITE, COLOR_BLACK, TRUE); put_str(alt_modes[m].name); eat_cookie(); set_attr(0); reset_colors(); put_crlf(); } static void dump_colors(void) { /* display the colors in some esthetic pattern */ static int xmap[8] = {0, 3, 4, 7, 1, 2, 5, 6}; int i, j, k, xi, xj, width, p, cs; int found_one; cs = color_step <= 125 ? 125 : color_step; width = (1000 / cs) + 1; for (xi = 0; xi < 16; xi++) { i = (xi & 8) ? xi ^ 15 : xi; R = i * cs; if (R <= 1000) { found_one = FALSE; for (xj = 0; xj < 32; xj++) { j = ((xj & 8) ? xj ^ 15 : xj) & 7; k = xmap[((xi >> 1) & 4) + (xj >> 3)]; G = j * cs; B = k * cs; if (G <= 1000 && B <= 1000) { p = (k * width + j) * width + i; if (set_a_background) { if (p >= max_colors) { continue; } send_color(p, R, G, B); tc_putp(TPARM_1(set_a_background, p)); } else if (set_background) { if (p >= max_colors) { continue; } send_color(p, R, G, B); tc_putp(TPARM_1(set_background, p)); } else { if (p >= max_pairs) { continue; } send_pair(p, R, G, B, R, G, B); tc_putp(TPARM_1(set_color_pair, p)); } found_one = TRUE; putchp(' '); putchp(' '); } } if (found_one) { put_crlf(); } } } } /* ** color_check(test_list, status, ch) ** ** test (colors) and (pairs) */ static void color_check( struct test_list *t, int *state, int *ch) { if (max_colors <= 0 && max_pairs <= 0) { ptext("This is not a color terminal; (colors) and (pairs) are missing. "); *state |= MENU_STOP; } else { sprintf(temp, "This terminal can display %d colors and %d color pairs. (colors) (pairs)", max_colors, max_pairs); ptextln(temp); } generic_done_message(t, state, ch); } /* ** color_setf(test_list, status, ch) ** ** test (setf) (setb) and (scp) */ static void color_setf( struct test_list *t, int *state, int *ch) { int i, j; if (max_colors <= 0 && max_pairs <= 0) { ptext("This is not a color terminal; (colors) and (pairs) are missing. "); generic_done_message(t, state, ch); *state |= MENU_STOP; return; } if ((set_a_foreground == NULL || set_a_background == NULL) && (set_foreground == NULL || set_background == NULL) && set_color_pair == NULL) { ptextln("Both set foreground (setaf/setf) and set color pair (scp) are not present."); if (!set_a_background || !set_background) { ptextln("(setab/setb) set background not present"); } ptext("These must be defined for color testing. "); generic_done_message(t, state, ch); *state |= MENU_STOP; return; } /* initialize the color palette */ pairs_used = max_colors >= 8 ? 8 : max_colors; reset_colors(); new_color(COLOR_WHITE, COLOR_BLACK, FALSE); ptextln("(setf) (setb) (scp) The following colors are predefined:"); ptextln("\n Foreground Background"); put_crlf(); j = max_colors > 8 ? 8 : max_colors; /* * the black on white test is the same as the white on black test. */ for (i = 1; i < j; i++) { putchp('0' + def_colors[i].index); putchp(' '); sprintf(temp, " %s ", def_colors[i].name); new_color(def_colors[i].index, COLOR_BLACK, TRUE); put_str(temp); new_color(COLOR_BLACK, COLOR_BLACK, TRUE); put_str(" "); new_color(COLOR_BLACK, def_colors[i].index, TRUE); put_str(temp); new_color(COLOR_WHITE, COLOR_BLACK, FALSE); put_crlf(); } reset_colors(); put_crlf(); generic_done_message(t, state, ch); } /* ** color_matrix(test_list, status, ch) ** ** test (pairs) (op) */ static void color_matrix( struct test_list *t, int *state, int *ch) { int i, j, matrix_size, matrix_area, brightness; matrix_size = max_colors > 8 ? 8 : max_colors; sprintf(temp, "(pairs) There are %d color pairs.", max_pairs); ptextln(temp); for ( ; matrix_size; matrix_size--) { if (matrix_size * matrix_size <= max_pairs) { break; } } matrix_area = matrix_size * matrix_size; for (brightness = 0; brightness < 2; brightness++) { put_crlf(); sprintf(temp, "%dx%d matrix of foreground/background colors, bright *o%s*", matrix_size, matrix_size, brightness ? "n" : "ff"); put_str(temp); put_str("\n "); for (i = 0; i < matrix_size; i++) { (void) sprintf(temp, "%-8s", def_colors[i].name); put_str(temp); } for (j = 0; j < matrix_area; j++) { if (j % matrix_size == 0) { reset_colors(); put_crlf(); if (brightness) { tc_putp(exit_attribute_mode); } (void) sprintf(temp, "%-8s", def_colors[j / matrix_size].name); put_str(temp); if (brightness) { put_mode(enter_bold_mode); } } new_color(def_colors[j % matrix_size].index, def_colors[j / matrix_size].index, FALSE); put_str(" Hello "); } reset_colors(); if (brightness) { tc_putp(exit_attribute_mode); } put_crlf(); } generic_done_message(t, state, ch); } /* ** color_ncv(test_list, status, ch) ** ** test (ncv) */ static void color_ncv( struct test_list *t, int *state, int *ch) { int i; if (no_color_video == -1) { /* I have no idea what this means */ return; } sprintf(temp, "According to no_color_video (ncv) which is %d, the following attributes should work correctly with color.", no_color_video); ptextln(temp); put_crlf(); set_attr(0); ncv_display(0); for (i = 1; i <= 9; i++) { if (((no_color_video >> (mode_map[i] - 1)) & 1) == 0) { ncv_display(mode_map[i]); } } if (no_color_video & 0x3ff) { ptextln("\nThe following attributes should not work correctly with color. (ncv)\n"); for (i = 1; i <= 9; i++) { if ((no_color_video >> (mode_map[i] - 1)) & 1) { ncv_display(mode_map[i]); } } } reset_colors(); put_crlf(); generic_done_message(t, state, ch); } /* ** color_bce(test_list, status, ch) ** ** test (bce) background color erase */ static void color_bce( struct test_list *t, int *state, int *ch) { new_color(COLOR_CYAN, COLOR_BLUE, FALSE); put_clear(); put_newlines(2); reset_colors(); ptextln("If the two lines above are blue then back_color_erase (bce) should be true."); sprintf(temp, "(bce) is %s in the data base.", back_color_erase ? "true" : "false"); ptextln(temp); generic_done_message(t, state, ch); } /* ** color_ccc(test_list, status, ch) ** ** test (ccc) color palette test (oc) (op) (initc) (initp) */ static void color_ccc( struct test_list *t, int *state, int *ch) { int i, j; if (!can_change) { ptextln("Terminal can not change colors (ccc)"); generic_done_message(t, state, ch); return; } reset_colors(); pairs_used = 0; new_color(COLOR_WHITE, COLOR_BLACK, FALSE); sprintf(temp, "Reloading colors (init%c) using %s method", set_foreground ? 'c' : 'p', hue_lightness_saturation ? "HLS" : "RGB"); ptextln(temp); put_crlf(); j = max_colors > 7 ? 7 : max_colors; /* redisplay the above test with reinitialized colors */ /* If these colors don't look right to you... */ for (i = 0; i < j; i++) { sprintf(temp, " %s ", def_colors[i ^ 7].name); new_color(i ^ 7, COLOR_BLACK, TRUE); put_str(temp); new_color(COLOR_BLACK, COLOR_BLACK, TRUE); put_str(" "); new_color(COLOR_BLACK, i ^ 7, TRUE); put_str(temp); new_color(COLOR_WHITE, COLOR_BLACK, FALSE); put_crlf(); } generic_done_message(t, state, ch); if (*ch != 0 && *ch != 'n') { reset_colors(); return; } pairs_used = 0; cookie_monster = 0; if (magic_cookie_glitch > 0) { cookie_monster = ((set_a_foreground || set_foreground) ? magic_cookie_glitch : 0) + ((set_a_background || set_background) ? magic_cookie_glitch : 0) + (set_color_pair ? magic_cookie_glitch : 0); } set_color_step(); colors_per_line = max_colors > max_pairs ? max_pairs : max_colors; j = (columns - 14) / (cookie_monster + 1); if (colors_per_line > j) { colors_per_line = (j / i) * i; } sprintf(temp, "RGB color step %d, cookies %d", color_step, cookie_monster); ptextln(temp); R = G = B = 0; pairs_used = 0; for (;;) { if (rainbow(colors_per_line)) { break; } } generic_done_message(t, state, ch); if (*ch != 0 && *ch != 'n') { reset_colors(); return; } dump_colors(); reset_colors(); generic_done_message(t, state, ch); } tack-1.07/config.guess0000755000175100001440000012761511301407346013435 0ustar tomusers#! /bin/sh # Attempt to guess a canonical system name. # Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, # 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 # Free Software Foundation, Inc. timestamp='2009-11-20' # This file is free software; you can redistribute it and/or modify it # under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, but # WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA # 02110-1301, USA. # # As a special exception to the GNU General Public License, if you # distribute this file as part of a program that contains a # configuration script generated by Autoconf, you may include it under # the same distribution terms that you use for the rest of that program. # Originally written by Per Bothner. Please send patches (context # diff format) to and include a ChangeLog # entry. # # This script attempts to guess a canonical system name similar to # config.sub. If it succeeds, it prints the system name on stdout, and # exits with 0. Otherwise, it exits with 1. # # You can get the latest version of this script from: # http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess;hb=HEAD me=`echo "$0" | sed -e 's,.*/,,'` usage="\ Usage: $0 [OPTION] Output the configuration name of the system \`$me' is run on. Operation modes: -h, --help print this help, then exit -t, --time-stamp print date of last modification, then exit -v, --version print version number, then exit Report bugs and patches to ." version="\ GNU config.guess ($timestamp) Originally written by Per Bothner. Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc. This is free software; see the source for copying conditions. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE." help=" Try \`$me --help' for more information." # Parse command line while test $# -gt 0 ; do case $1 in --time-stamp | --time* | -t ) echo "$timestamp" ; exit ;; --version | -v ) echo "$version" ; exit ;; --help | --h* | -h ) echo "$usage"; exit ;; -- ) # Stop option processing shift; break ;; - ) # Use stdin as input. break ;; -* ) echo "$me: invalid option $1$help" >&2 exit 1 ;; * ) break ;; esac done if test $# != 0; then echo "$me: too many arguments$help" >&2 exit 1 fi trap 'exit 1' 1 2 15 # CC_FOR_BUILD -- compiler used by this script. Note that the use of a # compiler to aid in system detection is discouraged as it requires # temporary files to be created and, as you can see below, it is a # headache to deal with in a portable fashion. # Historically, `CC_FOR_BUILD' used to be named `HOST_CC'. We still # use `HOST_CC' if defined, but it is deprecated. # Portable tmp directory creation inspired by the Autoconf team. set_cc_for_build=' trap "exitcode=\$?; (rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null) && exit \$exitcode" 0 ; trap "rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null; exit 1" 1 2 13 15 ; : ${TMPDIR=/tmp} ; { tmp=`(umask 077 && mktemp -d "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } || { test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir $tmp) ; } || { tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir $tmp) && echo "Warning: creating insecure temp directory" >&2 ; } || { echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; } ; dummy=$tmp/dummy ; tmpfiles="$dummy.c $dummy.o $dummy.rel $dummy" ; case $CC_FOR_BUILD,$HOST_CC,$CC in ,,) echo "int x;" > $dummy.c ; for c in cc gcc c89 c99 ; do if ($c -c -o $dummy.o $dummy.c) >/dev/null 2>&1 ; then CC_FOR_BUILD="$c"; break ; fi ; done ; if test x"$CC_FOR_BUILD" = x ; then CC_FOR_BUILD=no_compiler_found ; fi ;; ,,*) CC_FOR_BUILD=$CC ;; ,*,*) CC_FOR_BUILD=$HOST_CC ;; esac ; set_cc_for_build= ;' # This is needed to find uname on a Pyramid OSx when run in the BSD universe. # (ghazi@noc.rutgers.edu 1994-08-24) if (test -f /.attbin/uname) >/dev/null 2>&1 ; then PATH=$PATH:/.attbin ; export PATH fi UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown UNAME_SYSTEM=`(uname -s) 2>/dev/null` || UNAME_SYSTEM=unknown UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown # Note: order is significant - the case branches are not exclusive. case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in *:NetBSD:*:*) # NetBSD (nbsd) targets should (where applicable) match one or # more of the tupples: *-*-netbsdelf*, *-*-netbsdaout*, # *-*-netbsdecoff* and *-*-netbsd*. For targets that recently # switched to ELF, *-*-netbsd* would select the old # object file format. This provides both forward # compatibility and a consistent mechanism for selecting the # object file format. # # Note: NetBSD doesn't particularly care about the vendor # portion of the name. We always set it to "unknown". sysctl="sysctl -n hw.machine_arch" UNAME_MACHINE_ARCH=`(/sbin/$sysctl 2>/dev/null || \ /usr/sbin/$sysctl 2>/dev/null || echo unknown)` case "${UNAME_MACHINE_ARCH}" in armeb) machine=armeb-unknown ;; arm*) machine=arm-unknown ;; sh3el) machine=shl-unknown ;; sh3eb) machine=sh-unknown ;; sh5el) machine=sh5le-unknown ;; *) machine=${UNAME_MACHINE_ARCH}-unknown ;; esac # The Operating System including object format, if it has switched # to ELF recently, or will in the future. case "${UNAME_MACHINE_ARCH}" in arm*|i386|m68k|ns32k|sh3*|sparc|vax) eval $set_cc_for_build if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \ | grep -q __ELF__ then # Once all utilities can be ECOFF (netbsdecoff) or a.out (netbsdaout). # Return netbsd for either. FIX? os=netbsd else os=netbsdelf fi ;; *) os=netbsd ;; esac # The OS release # Debian GNU/NetBSD machines have a different userland, and # thus, need a distinct triplet. However, they do not need # kernel version information, so it can be replaced with a # suitable tag, in the style of linux-gnu. case "${UNAME_VERSION}" in Debian*) release='-gnu' ;; *) release=`echo ${UNAME_RELEASE}|sed -e 's/[-_].*/\./'` ;; esac # Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM: # contains redundant information, the shorter form: # CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used. echo "${machine}-${os}${release}" exit ;; *:OpenBSD:*:*) UNAME_MACHINE_ARCH=`arch | sed 's/OpenBSD.//'` echo ${UNAME_MACHINE_ARCH}-unknown-openbsd${UNAME_RELEASE} exit ;; *:ekkoBSD:*:*) echo ${UNAME_MACHINE}-unknown-ekkobsd${UNAME_RELEASE} exit ;; *:SolidBSD:*:*) echo ${UNAME_MACHINE}-unknown-solidbsd${UNAME_RELEASE} exit ;; macppc:MirBSD:*:*) echo powerpc-unknown-mirbsd${UNAME_RELEASE} exit ;; *:MirBSD:*:*) echo ${UNAME_MACHINE}-unknown-mirbsd${UNAME_RELEASE} exit ;; alpha:OSF1:*:*) case $UNAME_RELEASE in *4.0) UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'` ;; *5.*) UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $4}'` ;; esac # According to Compaq, /usr/sbin/psrinfo has been available on # OSF/1 and Tru64 systems produced since 1995. I hope that # covers most systems running today. This code pipes the CPU # types through head -n 1, so we only detect the type of CPU 0. ALPHA_CPU_TYPE=`/usr/sbin/psrinfo -v | sed -n -e 's/^ The alpha \(.*\) processor.*$/\1/p' | head -n 1` case "$ALPHA_CPU_TYPE" in "EV4 (21064)") UNAME_MACHINE="alpha" ;; "EV4.5 (21064)") UNAME_MACHINE="alpha" ;; "LCA4 (21066/21068)") UNAME_MACHINE="alpha" ;; "EV5 (21164)") UNAME_MACHINE="alphaev5" ;; "EV5.6 (21164A)") UNAME_MACHINE="alphaev56" ;; "EV5.6 (21164PC)") UNAME_MACHINE="alphapca56" ;; "EV5.7 (21164PC)") UNAME_MACHINE="alphapca57" ;; "EV6 (21264)") UNAME_MACHINE="alphaev6" ;; "EV6.7 (21264A)") UNAME_MACHINE="alphaev67" ;; "EV6.8CB (21264C)") UNAME_MACHINE="alphaev68" ;; "EV6.8AL (21264B)") UNAME_MACHINE="alphaev68" ;; "EV6.8CX (21264D)") UNAME_MACHINE="alphaev68" ;; "EV6.9A (21264/EV69A)") UNAME_MACHINE="alphaev69" ;; "EV7 (21364)") UNAME_MACHINE="alphaev7" ;; "EV7.9 (21364A)") UNAME_MACHINE="alphaev79" ;; esac # A Pn.n version is a patched version. # A Vn.n version is a released version. # A Tn.n version is a released field test version. # A Xn.n version is an unreleased experimental baselevel. # 1.2 uses "1.2" for uname -r. echo ${UNAME_MACHINE}-dec-osf`echo ${UNAME_RELEASE} | sed -e 's/^[PVTX]//' | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` exit ;; Alpha\ *:Windows_NT*:*) # How do we know it's Interix rather than the generic POSIX subsystem? # Should we change UNAME_MACHINE based on the output of uname instead # of the specific Alpha model? echo alpha-pc-interix exit ;; 21064:Windows_NT:50:3) echo alpha-dec-winnt3.5 exit ;; Amiga*:UNIX_System_V:4.0:*) echo m68k-unknown-sysv4 exit ;; *:[Aa]miga[Oo][Ss]:*:*) echo ${UNAME_MACHINE}-unknown-amigaos exit ;; *:[Mm]orph[Oo][Ss]:*:*) echo ${UNAME_MACHINE}-unknown-morphos exit ;; *:OS/390:*:*) echo i370-ibm-openedition exit ;; *:z/VM:*:*) echo s390-ibm-zvmoe exit ;; *:OS400:*:*) echo powerpc-ibm-os400 exit ;; arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*) echo arm-acorn-riscix${UNAME_RELEASE} exit ;; arm:riscos:*:*|arm:RISCOS:*:*) echo arm-unknown-riscos exit ;; SR2?01:HI-UX/MPP:*:* | SR8000:HI-UX/MPP:*:*) echo hppa1.1-hitachi-hiuxmpp exit ;; Pyramid*:OSx*:*:* | MIS*:OSx*:*:* | MIS*:SMP_DC-OSx*:*:*) # akee@wpdis03.wpafb.af.mil (Earle F. Ake) contributed MIS and NILE. if test "`(/bin/universe) 2>/dev/null`" = att ; then echo pyramid-pyramid-sysv3 else echo pyramid-pyramid-bsd fi exit ;; NILE*:*:*:dcosx) echo pyramid-pyramid-svr4 exit ;; DRS?6000:unix:4.0:6*) echo sparc-icl-nx6 exit ;; DRS?6000:UNIX_SV:4.2*:7* | DRS?6000:isis:4.2*:7*) case `/usr/bin/uname -p` in sparc) echo sparc-icl-nx7; exit ;; esac ;; s390x:SunOS:*:*) echo ${UNAME_MACHINE}-ibm-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` exit ;; sun4H:SunOS:5.*:*) echo sparc-hal-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` exit ;; sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*) echo sparc-sun-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` exit ;; i86pc:AuroraUX:5.*:* | i86xen:AuroraUX:5.*:*) echo i386-pc-auroraux${UNAME_RELEASE} exit ;; i86pc:SunOS:5.*:* | i86xen:SunOS:5.*:*) eval $set_cc_for_build SUN_ARCH="i386" # If there is a compiler, see if it is configured for 64-bit objects. # Note that the Sun cc does not turn __LP64__ into 1 like gcc does. # This test works for both compilers. if [ "$CC_FOR_BUILD" != 'no_compiler_found' ]; then if (echo '#ifdef __amd64'; echo IS_64BIT_ARCH; echo '#endif') | \ (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | \ grep IS_64BIT_ARCH >/dev/null then SUN_ARCH="x86_64" fi fi echo ${SUN_ARCH}-pc-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` exit ;; sun4*:SunOS:6*:*) # According to config.sub, this is the proper way to canonicalize # SunOS6. Hard to guess exactly what SunOS6 will be like, but # it's likely to be more like Solaris than SunOS4. echo sparc-sun-solaris3`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` exit ;; sun4*:SunOS:*:*) case "`/usr/bin/arch -k`" in Series*|S4*) UNAME_RELEASE=`uname -v` ;; esac # Japanese Language versions have a version number like `4.1.3-JL'. echo sparc-sun-sunos`echo ${UNAME_RELEASE}|sed -e 's/-/_/'` exit ;; sun3*:SunOS:*:*) echo m68k-sun-sunos${UNAME_RELEASE} exit ;; sun*:*:4.2BSD:*) UNAME_RELEASE=`(sed 1q /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null` test "x${UNAME_RELEASE}" = "x" && UNAME_RELEASE=3 case "`/bin/arch`" in sun3) echo m68k-sun-sunos${UNAME_RELEASE} ;; sun4) echo sparc-sun-sunos${UNAME_RELEASE} ;; esac exit ;; aushp:SunOS:*:*) echo sparc-auspex-sunos${UNAME_RELEASE} exit ;; # The situation for MiNT is a little confusing. The machine name # can be virtually everything (everything which is not # "atarist" or "atariste" at least should have a processor # > m68000). The system name ranges from "MiNT" over "FreeMiNT" # to the lowercase version "mint" (or "freemint"). Finally # the system name "TOS" denotes a system which is actually not # MiNT. But MiNT is downward compatible to TOS, so this should # be no problem. atarist[e]:*MiNT:*:* | atarist[e]:*mint:*:* | atarist[e]:*TOS:*:*) echo m68k-atari-mint${UNAME_RELEASE} exit ;; atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*) echo m68k-atari-mint${UNAME_RELEASE} exit ;; *falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*) echo m68k-atari-mint${UNAME_RELEASE} exit ;; milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*) echo m68k-milan-mint${UNAME_RELEASE} exit ;; hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*) echo m68k-hades-mint${UNAME_RELEASE} exit ;; *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*) echo m68k-unknown-mint${UNAME_RELEASE} exit ;; m68k:machten:*:*) echo m68k-apple-machten${UNAME_RELEASE} exit ;; powerpc:machten:*:*) echo powerpc-apple-machten${UNAME_RELEASE} exit ;; RISC*:Mach:*:*) echo mips-dec-mach_bsd4.3 exit ;; RISC*:ULTRIX:*:*) echo mips-dec-ultrix${UNAME_RELEASE} exit ;; VAX*:ULTRIX*:*:*) echo vax-dec-ultrix${UNAME_RELEASE} exit ;; 2020:CLIX:*:* | 2430:CLIX:*:*) echo clipper-intergraph-clix${UNAME_RELEASE} exit ;; mips:*:*:UMIPS | mips:*:*:RISCos) eval $set_cc_for_build sed 's/^ //' << EOF >$dummy.c #ifdef __cplusplus #include /* for printf() prototype */ int main (int argc, char *argv[]) { #else int main (argc, argv) int argc; char *argv[]; { #endif #if defined (host_mips) && defined (MIPSEB) #if defined (SYSTYPE_SYSV) printf ("mips-mips-riscos%ssysv\n", argv[1]); exit (0); #endif #if defined (SYSTYPE_SVR4) printf ("mips-mips-riscos%ssvr4\n", argv[1]); exit (0); #endif #if defined (SYSTYPE_BSD43) || defined(SYSTYPE_BSD) printf ("mips-mips-riscos%sbsd\n", argv[1]); exit (0); #endif #endif exit (-1); } EOF $CC_FOR_BUILD -o $dummy $dummy.c && dummyarg=`echo "${UNAME_RELEASE}" | sed -n 's/\([0-9]*\).*/\1/p'` && SYSTEM_NAME=`$dummy $dummyarg` && { echo "$SYSTEM_NAME"; exit; } echo mips-mips-riscos${UNAME_RELEASE} exit ;; Motorola:PowerMAX_OS:*:*) echo powerpc-motorola-powermax exit ;; Motorola:*:4.3:PL8-*) echo powerpc-harris-powermax exit ;; Night_Hawk:*:*:PowerMAX_OS | Synergy:PowerMAX_OS:*:*) echo powerpc-harris-powermax exit ;; Night_Hawk:Power_UNIX:*:*) echo powerpc-harris-powerunix exit ;; m88k:CX/UX:7*:*) echo m88k-harris-cxux7 exit ;; m88k:*:4*:R4*) echo m88k-motorola-sysv4 exit ;; m88k:*:3*:R3*) echo m88k-motorola-sysv3 exit ;; AViiON:dgux:*:*) # DG/UX returns AViiON for all architectures UNAME_PROCESSOR=`/usr/bin/uname -p` if [ $UNAME_PROCESSOR = mc88100 ] || [ $UNAME_PROCESSOR = mc88110 ] then if [ ${TARGET_BINARY_INTERFACE}x = m88kdguxelfx ] || \ [ ${TARGET_BINARY_INTERFACE}x = x ] then echo m88k-dg-dgux${UNAME_RELEASE} else echo m88k-dg-dguxbcs${UNAME_RELEASE} fi else echo i586-dg-dgux${UNAME_RELEASE} fi exit ;; M88*:DolphinOS:*:*) # DolphinOS (SVR3) echo m88k-dolphin-sysv3 exit ;; M88*:*:R3*:*) # Delta 88k system running SVR3 echo m88k-motorola-sysv3 exit ;; XD88*:*:*:*) # Tektronix XD88 system running UTekV (SVR3) echo m88k-tektronix-sysv3 exit ;; Tek43[0-9][0-9]:UTek:*:*) # Tektronix 4300 system running UTek (BSD) echo m68k-tektronix-bsd exit ;; *:IRIX*:*:*) echo mips-sgi-irix`echo ${UNAME_RELEASE}|sed -e 's/-/_/g'` exit ;; ????????:AIX?:[12].1:2) # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX. echo romp-ibm-aix # uname -m gives an 8 hex-code CPU id exit ;; # Note that: echo "'`uname -s`'" gives 'AIX ' i*86:AIX:*:*) echo i386-ibm-aix exit ;; ia64:AIX:*:*) if [ -x /usr/bin/oslevel ] ; then IBM_REV=`/usr/bin/oslevel` else IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE} fi echo ${UNAME_MACHINE}-ibm-aix${IBM_REV} exit ;; *:AIX:2:3) if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then eval $set_cc_for_build sed 's/^ //' << EOF >$dummy.c #include main() { if (!__power_pc()) exit(1); puts("powerpc-ibm-aix3.2.5"); exit(0); } EOF if $CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy` then echo "$SYSTEM_NAME" else echo rs6000-ibm-aix3.2.5 fi elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then echo rs6000-ibm-aix3.2.4 else echo rs6000-ibm-aix3.2 fi exit ;; *:AIX:*:[456]) IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }'` if /usr/sbin/lsattr -El ${IBM_CPU_ID} | grep ' POWER' >/dev/null 2>&1; then IBM_ARCH=rs6000 else IBM_ARCH=powerpc fi if [ -x /usr/bin/oslevel ] ; then IBM_REV=`/usr/bin/oslevel` else IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE} fi echo ${IBM_ARCH}-ibm-aix${IBM_REV} exit ;; *:AIX:*:*) echo rs6000-ibm-aix exit ;; ibmrt:4.4BSD:*|romp-ibm:BSD:*) echo romp-ibm-bsd4.4 exit ;; ibmrt:*BSD:*|romp-ibm:BSD:*) # covers RT/PC BSD and echo romp-ibm-bsd${UNAME_RELEASE} # 4.3 with uname added to exit ;; # report: romp-ibm BSD 4.3 *:BOSX:*:*) echo rs6000-bull-bosx exit ;; DPX/2?00:B.O.S.:*:*) echo m68k-bull-sysv3 exit ;; 9000/[34]??:4.3bsd:1.*:*) echo m68k-hp-bsd exit ;; hp300:4.4BSD:*:* | 9000/[34]??:4.3bsd:2.*:*) echo m68k-hp-bsd4.4 exit ;; 9000/[34678]??:HP-UX:*:*) HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'` case "${UNAME_MACHINE}" in 9000/31? ) HP_ARCH=m68000 ;; 9000/[34]?? ) HP_ARCH=m68k ;; 9000/[678][0-9][0-9]) if [ -x /usr/bin/getconf ]; then sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null` sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null` case "${sc_cpu_version}" in 523) HP_ARCH="hppa1.0" ;; # CPU_PA_RISC1_0 528) HP_ARCH="hppa1.1" ;; # CPU_PA_RISC1_1 532) # CPU_PA_RISC2_0 case "${sc_kernel_bits}" in 32) HP_ARCH="hppa2.0n" ;; 64) HP_ARCH="hppa2.0w" ;; '') HP_ARCH="hppa2.0" ;; # HP-UX 10.20 esac ;; esac fi if [ "${HP_ARCH}" = "" ]; then eval $set_cc_for_build sed 's/^ //' << EOF >$dummy.c #define _HPUX_SOURCE #include #include int main () { #if defined(_SC_KERNEL_BITS) long bits = sysconf(_SC_KERNEL_BITS); #endif long cpu = sysconf (_SC_CPU_VERSION); switch (cpu) { case CPU_PA_RISC1_0: puts ("hppa1.0"); break; case CPU_PA_RISC1_1: puts ("hppa1.1"); break; case CPU_PA_RISC2_0: #if defined(_SC_KERNEL_BITS) switch (bits) { case 64: puts ("hppa2.0w"); break; case 32: puts ("hppa2.0n"); break; default: puts ("hppa2.0"); break; } break; #else /* !defined(_SC_KERNEL_BITS) */ puts ("hppa2.0"); break; #endif default: puts ("hppa1.0"); break; } exit (0); } EOF (CCOPTS= $CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null) && HP_ARCH=`$dummy` test -z "$HP_ARCH" && HP_ARCH=hppa fi ;; esac if [ ${HP_ARCH} = "hppa2.0w" ] then eval $set_cc_for_build # hppa2.0w-hp-hpux* has a 64-bit kernel and a compiler generating # 32-bit code. hppa64-hp-hpux* has the same kernel and a compiler # generating 64-bit code. GNU and HP use different nomenclature: # # $ CC_FOR_BUILD=cc ./config.guess # => hppa2.0w-hp-hpux11.23 # $ CC_FOR_BUILD="cc +DA2.0w" ./config.guess # => hppa64-hp-hpux11.23 if echo __LP64__ | (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | grep -q __LP64__ then HP_ARCH="hppa2.0w" else HP_ARCH="hppa64" fi fi echo ${HP_ARCH}-hp-hpux${HPUX_REV} exit ;; ia64:HP-UX:*:*) HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'` echo ia64-hp-hpux${HPUX_REV} exit ;; 3050*:HI-UX:*:*) eval $set_cc_for_build sed 's/^ //' << EOF >$dummy.c #include int main () { long cpu = sysconf (_SC_CPU_VERSION); /* The order matters, because CPU_IS_HP_MC68K erroneously returns true for CPU_PA_RISC1_0. CPU_IS_PA_RISC returns correct results, however. */ if (CPU_IS_PA_RISC (cpu)) { switch (cpu) { case CPU_PA_RISC1_0: puts ("hppa1.0-hitachi-hiuxwe2"); break; case CPU_PA_RISC1_1: puts ("hppa1.1-hitachi-hiuxwe2"); break; case CPU_PA_RISC2_0: puts ("hppa2.0-hitachi-hiuxwe2"); break; default: puts ("hppa-hitachi-hiuxwe2"); break; } } else if (CPU_IS_HP_MC68K (cpu)) puts ("m68k-hitachi-hiuxwe2"); else puts ("unknown-hitachi-hiuxwe2"); exit (0); } EOF $CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy` && { echo "$SYSTEM_NAME"; exit; } echo unknown-hitachi-hiuxwe2 exit ;; 9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:* ) echo hppa1.1-hp-bsd exit ;; 9000/8??:4.3bsd:*:*) echo hppa1.0-hp-bsd exit ;; *9??*:MPE/iX:*:* | *3000*:MPE/iX:*:*) echo hppa1.0-hp-mpeix exit ;; hp7??:OSF1:*:* | hp8?[79]:OSF1:*:* ) echo hppa1.1-hp-osf exit ;; hp8??:OSF1:*:*) echo hppa1.0-hp-osf exit ;; i*86:OSF1:*:*) if [ -x /usr/sbin/sysversion ] ; then echo ${UNAME_MACHINE}-unknown-osf1mk else echo ${UNAME_MACHINE}-unknown-osf1 fi exit ;; parisc*:Lites*:*:*) echo hppa1.1-hp-lites exit ;; C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*) echo c1-convex-bsd exit ;; C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*) if getsysinfo -f scalar_acc then echo c32-convex-bsd else echo c2-convex-bsd fi exit ;; C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*) echo c34-convex-bsd exit ;; C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*) echo c38-convex-bsd exit ;; C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*) echo c4-convex-bsd exit ;; CRAY*Y-MP:*:*:*) echo ymp-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' exit ;; CRAY*[A-Z]90:*:*:*) echo ${UNAME_MACHINE}-cray-unicos${UNAME_RELEASE} \ | sed -e 's/CRAY.*\([A-Z]90\)/\1/' \ -e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/ \ -e 's/\.[^.]*$/.X/' exit ;; CRAY*TS:*:*:*) echo t90-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' exit ;; CRAY*T3E:*:*:*) echo alphaev5-cray-unicosmk${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' exit ;; CRAY*SV1:*:*:*) echo sv1-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' exit ;; *:UNICOS/mp:*:*) echo craynv-cray-unicosmp${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' exit ;; F30[01]:UNIX_System_V:*:* | F700:UNIX_System_V:*:*) FUJITSU_PROC=`uname -m | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'` FUJITSU_REL=`echo ${UNAME_RELEASE} | sed -e 's/ /_/'` echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}" exit ;; 5000:UNIX_System_V:4.*:*) FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'` FUJITSU_REL=`echo ${UNAME_RELEASE} | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/ /_/'` echo "sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}" exit ;; i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*) echo ${UNAME_MACHINE}-pc-bsdi${UNAME_RELEASE} exit ;; sparc*:BSD/OS:*:*) echo sparc-unknown-bsdi${UNAME_RELEASE} exit ;; *:BSD/OS:*:*) echo ${UNAME_MACHINE}-unknown-bsdi${UNAME_RELEASE} exit ;; *:FreeBSD:*:*) case ${UNAME_MACHINE} in pc98) echo i386-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;; amd64) echo x86_64-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;; *) echo ${UNAME_MACHINE}-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;; esac exit ;; i*:CYGWIN*:*) echo ${UNAME_MACHINE}-pc-cygwin exit ;; *:MINGW*:*) echo ${UNAME_MACHINE}-pc-mingw32 exit ;; i*:windows32*:*) # uname -m includes "-pc" on this system. echo ${UNAME_MACHINE}-mingw32 exit ;; i*:PW*:*) echo ${UNAME_MACHINE}-pc-pw32 exit ;; *:Interix*:*) case ${UNAME_MACHINE} in x86) echo i586-pc-interix${UNAME_RELEASE} exit ;; authenticamd | genuineintel | EM64T) echo x86_64-unknown-interix${UNAME_RELEASE} exit ;; IA64) echo ia64-unknown-interix${UNAME_RELEASE} exit ;; esac ;; [345]86:Windows_95:* | [345]86:Windows_98:* | [345]86:Windows_NT:*) echo i${UNAME_MACHINE}-pc-mks exit ;; 8664:Windows_NT:*) echo x86_64-pc-mks exit ;; i*:Windows_NT*:* | Pentium*:Windows_NT*:*) # How do we know it's Interix rather than the generic POSIX subsystem? # It also conflicts with pre-2.0 versions of AT&T UWIN. Should we # UNAME_MACHINE based on the output of uname instead of i386? echo i586-pc-interix exit ;; i*:UWIN*:*) echo ${UNAME_MACHINE}-pc-uwin exit ;; amd64:CYGWIN*:*:* | x86_64:CYGWIN*:*:*) echo x86_64-unknown-cygwin exit ;; p*:CYGWIN*:*) echo powerpcle-unknown-cygwin exit ;; prep*:SunOS:5.*:*) echo powerpcle-unknown-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` exit ;; *:GNU:*:*) # the GNU system echo `echo ${UNAME_MACHINE}|sed -e 's,[-/].*$,,'`-unknown-gnu`echo ${UNAME_RELEASE}|sed -e 's,/.*$,,'` exit ;; *:GNU/*:*:*) # other systems with GNU libc and userland echo ${UNAME_MACHINE}-unknown-`echo ${UNAME_SYSTEM} | sed 's,^[^/]*/,,' | tr '[A-Z]' '[a-z]'``echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`-gnu exit ;; i*86:Minix:*:*) echo ${UNAME_MACHINE}-pc-minix exit ;; alpha:Linux:*:*) case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' < /proc/cpuinfo` in EV5) UNAME_MACHINE=alphaev5 ;; EV56) UNAME_MACHINE=alphaev56 ;; PCA56) UNAME_MACHINE=alphapca56 ;; PCA57) UNAME_MACHINE=alphapca56 ;; EV6) UNAME_MACHINE=alphaev6 ;; EV67) UNAME_MACHINE=alphaev67 ;; EV68*) UNAME_MACHINE=alphaev68 ;; esac objdump --private-headers /bin/sh | grep -q ld.so.1 if test "$?" = 0 ; then LIBC="libc1" ; else LIBC="" ; fi echo ${UNAME_MACHINE}-unknown-linux-gnu${LIBC} exit ;; arm*:Linux:*:*) eval $set_cc_for_build if echo __ARM_EABI__ | $CC_FOR_BUILD -E - 2>/dev/null \ | grep -q __ARM_EABI__ then echo ${UNAME_MACHINE}-unknown-linux-gnu else echo ${UNAME_MACHINE}-unknown-linux-gnueabi fi exit ;; avr32*:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; cris:Linux:*:*) echo cris-axis-linux-gnu exit ;; crisv32:Linux:*:*) echo crisv32-axis-linux-gnu exit ;; frv:Linux:*:*) echo frv-unknown-linux-gnu exit ;; i*86:Linux:*:*) LIBC=gnu eval $set_cc_for_build sed 's/^ //' << EOF >$dummy.c #ifdef __dietlibc__ LIBC=dietlibc #endif EOF eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep '^LIBC'` echo "${UNAME_MACHINE}-pc-linux-${LIBC}" exit ;; ia64:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; m32r*:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; m68*:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; mips:Linux:*:* | mips64:Linux:*:*) eval $set_cc_for_build sed 's/^ //' << EOF >$dummy.c #undef CPU #undef ${UNAME_MACHINE} #undef ${UNAME_MACHINE}el #if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL) CPU=${UNAME_MACHINE}el #else #if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB) CPU=${UNAME_MACHINE} #else CPU= #endif #endif EOF eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep '^CPU'` test x"${CPU}" != x && { echo "${CPU}-unknown-linux-gnu"; exit; } ;; or32:Linux:*:*) echo or32-unknown-linux-gnu exit ;; padre:Linux:*:*) echo sparc-unknown-linux-gnu exit ;; parisc64:Linux:*:* | hppa64:Linux:*:*) echo hppa64-unknown-linux-gnu exit ;; parisc:Linux:*:* | hppa:Linux:*:*) # Look for CPU level case `grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2` in PA7*) echo hppa1.1-unknown-linux-gnu ;; PA8*) echo hppa2.0-unknown-linux-gnu ;; *) echo hppa-unknown-linux-gnu ;; esac exit ;; ppc64:Linux:*:*) echo powerpc64-unknown-linux-gnu exit ;; ppc:Linux:*:*) echo powerpc-unknown-linux-gnu exit ;; s390:Linux:*:* | s390x:Linux:*:*) echo ${UNAME_MACHINE}-ibm-linux exit ;; sh64*:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; sh*:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; sparc:Linux:*:* | sparc64:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; vax:Linux:*:*) echo ${UNAME_MACHINE}-dec-linux-gnu exit ;; x86_64:Linux:*:*) echo x86_64-unknown-linux-gnu exit ;; xtensa*:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; i*86:DYNIX/ptx:4*:*) # ptx 4.0 does uname -s correctly, with DYNIX/ptx in there. # earlier versions are messed up and put the nodename in both # sysname and nodename. echo i386-sequent-sysv4 exit ;; i*86:UNIX_SV:4.2MP:2.*) # Unixware is an offshoot of SVR4, but it has its own version # number series starting with 2... # I am not positive that other SVR4 systems won't match this, # I just have to hope. -- rms. # Use sysv4.2uw... so that sysv4* matches it. echo ${UNAME_MACHINE}-pc-sysv4.2uw${UNAME_VERSION} exit ;; i*86:OS/2:*:*) # If we were able to find `uname', then EMX Unix compatibility # is probably installed. echo ${UNAME_MACHINE}-pc-os2-emx exit ;; i*86:XTS-300:*:STOP) echo ${UNAME_MACHINE}-unknown-stop exit ;; i*86:atheos:*:*) echo ${UNAME_MACHINE}-unknown-atheos exit ;; i*86:syllable:*:*) echo ${UNAME_MACHINE}-pc-syllable exit ;; i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.[02]*:*) echo i386-unknown-lynxos${UNAME_RELEASE} exit ;; i*86:*DOS:*:*) echo ${UNAME_MACHINE}-pc-msdosdjgpp exit ;; i*86:*:4.*:* | i*86:SYSTEM_V:4.*:*) UNAME_REL=`echo ${UNAME_RELEASE} | sed 's/\/MP$//'` if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then echo ${UNAME_MACHINE}-univel-sysv${UNAME_REL} else echo ${UNAME_MACHINE}-pc-sysv${UNAME_REL} fi exit ;; i*86:*:5:[678]*) # UnixWare 7.x, OpenUNIX and OpenServer 6. case `/bin/uname -X | grep "^Machine"` in *486*) UNAME_MACHINE=i486 ;; *Pentium) UNAME_MACHINE=i586 ;; *Pent*|*Celeron) UNAME_MACHINE=i686 ;; esac echo ${UNAME_MACHINE}-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}${UNAME_VERSION} exit ;; i*86:*:3.2:*) if test -f /usr/options/cb.name; then UNAME_REL=`sed -n 's/.*Version //p' /dev/null >/dev/null ; then UNAME_REL=`(/bin/uname -X|grep Release|sed -e 's/.*= //')` (/bin/uname -X|grep i80486 >/dev/null) && UNAME_MACHINE=i486 (/bin/uname -X|grep '^Machine.*Pentium' >/dev/null) \ && UNAME_MACHINE=i586 (/bin/uname -X|grep '^Machine.*Pent *II' >/dev/null) \ && UNAME_MACHINE=i686 (/bin/uname -X|grep '^Machine.*Pentium Pro' >/dev/null) \ && UNAME_MACHINE=i686 echo ${UNAME_MACHINE}-pc-sco$UNAME_REL else echo ${UNAME_MACHINE}-pc-sysv32 fi exit ;; pc:*:*:*) # Left here for compatibility: # uname -m prints for DJGPP always 'pc', but it prints nothing about # the processor, so we play safe by assuming i586. # Note: whatever this is, it MUST be the same as what config.sub # prints for the "djgpp" host, or else GDB configury will decide that # this is a cross-build. echo i586-pc-msdosdjgpp exit ;; Intel:Mach:3*:*) echo i386-pc-mach3 exit ;; paragon:*:*:*) echo i860-intel-osf1 exit ;; i860:*:4.*:*) # i860-SVR4 if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then echo i860-stardent-sysv${UNAME_RELEASE} # Stardent Vistra i860-SVR4 else # Add other i860-SVR4 vendors below as they are discovered. echo i860-unknown-sysv${UNAME_RELEASE} # Unknown i860-SVR4 fi exit ;; mini*:CTIX:SYS*5:*) # "miniframe" echo m68010-convergent-sysv exit ;; mc68k:UNIX:SYSTEM5:3.51m) echo m68k-convergent-sysv exit ;; M680?0:D-NIX:5.3:*) echo m68k-diab-dnix exit ;; M68*:*:R3V[5678]*:*) test -r /sysV68 && { echo 'm68k-motorola-sysv'; exit; } ;; 3[345]??:*:4.0:3.0 | 3[34]??A:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 3[34]??/*:*:4.0:3.0 | 4400:*:4.0:3.0 | 4850:*:4.0:3.0 | SKA40:*:4.0:3.0 | SDS2:*:4.0:3.0 | SHG2:*:4.0:3.0 | S7501*:*:4.0:3.0) OS_REL='' test -r /etc/.relid \ && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid` /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ && { echo i486-ncr-sysv4.3${OS_REL}; exit; } /bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \ && { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;; 3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*) /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ && { echo i486-ncr-sysv4; exit; } ;; NCR*:*:4.2:* | MPRAS*:*:4.2:*) OS_REL='.3' test -r /etc/.relid \ && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid` /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ && { echo i486-ncr-sysv4.3${OS_REL}; exit; } /bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \ && { echo i586-ncr-sysv4.3${OS_REL}; exit; } /bin/uname -p 2>/dev/null | /bin/grep pteron >/dev/null \ && { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;; m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*) echo m68k-unknown-lynxos${UNAME_RELEASE} exit ;; mc68030:UNIX_System_V:4.*:*) echo m68k-atari-sysv4 exit ;; TSUNAMI:LynxOS:2.*:*) echo sparc-unknown-lynxos${UNAME_RELEASE} exit ;; rs6000:LynxOS:2.*:*) echo rs6000-unknown-lynxos${UNAME_RELEASE} exit ;; PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.[02]*:*) echo powerpc-unknown-lynxos${UNAME_RELEASE} exit ;; SM[BE]S:UNIX_SV:*:*) echo mips-dde-sysv${UNAME_RELEASE} exit ;; RM*:ReliantUNIX-*:*:*) echo mips-sni-sysv4 exit ;; RM*:SINIX-*:*:*) echo mips-sni-sysv4 exit ;; *:SINIX-*:*:*) if uname -p 2>/dev/null >/dev/null ; then UNAME_MACHINE=`(uname -p) 2>/dev/null` echo ${UNAME_MACHINE}-sni-sysv4 else echo ns32k-sni-sysv fi exit ;; PENTIUM:*:4.0*:*) # Unisys `ClearPath HMP IX 4000' SVR4/MP effort # says echo i586-unisys-sysv4 exit ;; *:UNIX_System_V:4*:FTX*) # From Gerald Hewes . # How about differentiating between stratus architectures? -djm echo hppa1.1-stratus-sysv4 exit ;; *:*:*:FTX*) # From seanf@swdc.stratus.com. echo i860-stratus-sysv4 exit ;; i*86:VOS:*:*) # From Paul.Green@stratus.com. echo ${UNAME_MACHINE}-stratus-vos exit ;; *:VOS:*:*) # From Paul.Green@stratus.com. echo hppa1.1-stratus-vos exit ;; mc68*:A/UX:*:*) echo m68k-apple-aux${UNAME_RELEASE} exit ;; news*:NEWS-OS:6*:*) echo mips-sony-newsos6 exit ;; R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*) if [ -d /usr/nec ]; then echo mips-nec-sysv${UNAME_RELEASE} else echo mips-unknown-sysv${UNAME_RELEASE} fi exit ;; BeBox:BeOS:*:*) # BeOS running on hardware made by Be, PPC only. echo powerpc-be-beos exit ;; BeMac:BeOS:*:*) # BeOS running on Mac or Mac clone, PPC only. echo powerpc-apple-beos exit ;; BePC:BeOS:*:*) # BeOS running on Intel PC compatible. echo i586-pc-beos exit ;; BePC:Haiku:*:*) # Haiku running on Intel PC compatible. echo i586-pc-haiku exit ;; SX-4:SUPER-UX:*:*) echo sx4-nec-superux${UNAME_RELEASE} exit ;; SX-5:SUPER-UX:*:*) echo sx5-nec-superux${UNAME_RELEASE} exit ;; SX-6:SUPER-UX:*:*) echo sx6-nec-superux${UNAME_RELEASE} exit ;; SX-7:SUPER-UX:*:*) echo sx7-nec-superux${UNAME_RELEASE} exit ;; SX-8:SUPER-UX:*:*) echo sx8-nec-superux${UNAME_RELEASE} exit ;; SX-8R:SUPER-UX:*:*) echo sx8r-nec-superux${UNAME_RELEASE} exit ;; Power*:Rhapsody:*:*) echo powerpc-apple-rhapsody${UNAME_RELEASE} exit ;; *:Rhapsody:*:*) echo ${UNAME_MACHINE}-apple-rhapsody${UNAME_RELEASE} exit ;; *:Darwin:*:*) UNAME_PROCESSOR=`uname -p` || UNAME_PROCESSOR=unknown case $UNAME_PROCESSOR in i386) eval $set_cc_for_build if [ "$CC_FOR_BUILD" != 'no_compiler_found' ]; then if (echo '#ifdef __LP64__'; echo IS_64BIT_ARCH; echo '#endif') | \ (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | \ grep IS_64BIT_ARCH >/dev/null then UNAME_PROCESSOR="x86_64" fi fi ;; unknown) UNAME_PROCESSOR=powerpc ;; esac echo ${UNAME_PROCESSOR}-apple-darwin${UNAME_RELEASE} exit ;; *:procnto*:*:* | *:QNX:[0123456789]*:*) UNAME_PROCESSOR=`uname -p` if test "$UNAME_PROCESSOR" = "x86"; then UNAME_PROCESSOR=i386 UNAME_MACHINE=pc fi echo ${UNAME_PROCESSOR}-${UNAME_MACHINE}-nto-qnx${UNAME_RELEASE} exit ;; *:QNX:*:4*) echo i386-pc-qnx exit ;; NSE-?:NONSTOP_KERNEL:*:*) echo nse-tandem-nsk${UNAME_RELEASE} exit ;; NSR-?:NONSTOP_KERNEL:*:*) echo nsr-tandem-nsk${UNAME_RELEASE} exit ;; *:NonStop-UX:*:*) echo mips-compaq-nonstopux exit ;; BS2000:POSIX*:*:*) echo bs2000-siemens-sysv exit ;; DS/*:UNIX_System_V:*:*) echo ${UNAME_MACHINE}-${UNAME_SYSTEM}-${UNAME_RELEASE} exit ;; *:Plan9:*:*) # "uname -m" is not consistent, so use $cputype instead. 386 # is converted to i386 for consistency with other x86 # operating systems. if test "$cputype" = "386"; then UNAME_MACHINE=i386 else UNAME_MACHINE="$cputype" fi echo ${UNAME_MACHINE}-unknown-plan9 exit ;; *:TOPS-10:*:*) echo pdp10-unknown-tops10 exit ;; *:TENEX:*:*) echo pdp10-unknown-tenex exit ;; KS10:TOPS-20:*:* | KL10:TOPS-20:*:* | TYPE4:TOPS-20:*:*) echo pdp10-dec-tops20 exit ;; XKL-1:TOPS-20:*:* | TYPE5:TOPS-20:*:*) echo pdp10-xkl-tops20 exit ;; *:TOPS-20:*:*) echo pdp10-unknown-tops20 exit ;; *:ITS:*:*) echo pdp10-unknown-its exit ;; SEI:*:*:SEIUX) echo mips-sei-seiux${UNAME_RELEASE} exit ;; *:DragonFly:*:*) echo ${UNAME_MACHINE}-unknown-dragonfly`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` exit ;; *:*VMS:*:*) UNAME_MACHINE=`(uname -p) 2>/dev/null` case "${UNAME_MACHINE}" in A*) echo alpha-dec-vms ; exit ;; I*) echo ia64-dec-vms ; exit ;; V*) echo vax-dec-vms ; exit ;; esac ;; *:XENIX:*:SysV) echo i386-pc-xenix exit ;; i*86:skyos:*:*) echo ${UNAME_MACHINE}-pc-skyos`echo ${UNAME_RELEASE}` | sed -e 's/ .*$//' exit ;; i*86:rdos:*:*) echo ${UNAME_MACHINE}-pc-rdos exit ;; i*86:AROS:*:*) echo ${UNAME_MACHINE}-pc-aros exit ;; esac #echo '(No uname command or uname output not recognized.)' 1>&2 #echo "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" 1>&2 eval $set_cc_for_build cat >$dummy.c < # include #endif main () { #if defined (sony) #if defined (MIPSEB) /* BFD wants "bsd" instead of "newsos". Perhaps BFD should be changed, I don't know.... */ printf ("mips-sony-bsd\n"); exit (0); #else #include printf ("m68k-sony-newsos%s\n", #ifdef NEWSOS4 "4" #else "" #endif ); exit (0); #endif #endif #if defined (__arm) && defined (__acorn) && defined (__unix) printf ("arm-acorn-riscix\n"); exit (0); #endif #if defined (hp300) && !defined (hpux) printf ("m68k-hp-bsd\n"); exit (0); #endif #if defined (NeXT) #if !defined (__ARCHITECTURE__) #define __ARCHITECTURE__ "m68k" #endif int version; version=`(hostinfo | sed -n 's/.*NeXT Mach \([0-9]*\).*/\1/p') 2>/dev/null`; if (version < 4) printf ("%s-next-nextstep%d\n", __ARCHITECTURE__, version); else printf ("%s-next-openstep%d\n", __ARCHITECTURE__, version); exit (0); #endif #if defined (MULTIMAX) || defined (n16) #if defined (UMAXV) printf ("ns32k-encore-sysv\n"); exit (0); #else #if defined (CMU) printf ("ns32k-encore-mach\n"); exit (0); #else printf ("ns32k-encore-bsd\n"); exit (0); #endif #endif #endif #if defined (__386BSD__) printf ("i386-pc-bsd\n"); exit (0); #endif #if defined (sequent) #if defined (i386) printf ("i386-sequent-dynix\n"); exit (0); #endif #if defined (ns32000) printf ("ns32k-sequent-dynix\n"); exit (0); #endif #endif #if defined (_SEQUENT_) struct utsname un; uname(&un); if (strncmp(un.version, "V2", 2) == 0) { printf ("i386-sequent-ptx2\n"); exit (0); } if (strncmp(un.version, "V1", 2) == 0) { /* XXX is V1 correct? */ printf ("i386-sequent-ptx1\n"); exit (0); } printf ("i386-sequent-ptx\n"); exit (0); #endif #if defined (vax) # if !defined (ultrix) # include # if defined (BSD) # if BSD == 43 printf ("vax-dec-bsd4.3\n"); exit (0); # else # if BSD == 199006 printf ("vax-dec-bsd4.3reno\n"); exit (0); # else printf ("vax-dec-bsd\n"); exit (0); # endif # endif # else printf ("vax-dec-bsd\n"); exit (0); # endif # else printf ("vax-dec-ultrix\n"); exit (0); # endif #endif #if defined (alliant) && defined (i860) printf ("i860-alliant-bsd\n"); exit (0); #endif exit (1); } EOF $CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null && SYSTEM_NAME=`$dummy` && { echo "$SYSTEM_NAME"; exit; } # Apollos put the system type in the environment. test -d /usr/apollo && { echo ${ISP}-apollo-${SYSTYPE}; exit; } # Convex versions that predate uname can use getsysinfo(1) if [ -x /usr/convex/getsysinfo ] then case `getsysinfo -f cpu_type` in c1*) echo c1-convex-bsd exit ;; c2*) if getsysinfo -f scalar_acc then echo c32-convex-bsd else echo c2-convex-bsd fi exit ;; c34*) echo c34-convex-bsd exit ;; c38*) echo c38-convex-bsd exit ;; c4*) echo c4-convex-bsd exit ;; esac fi cat >&2 < in order to provide the needed information to handle your system. config.guess timestamp = $timestamp uname -m = `(uname -m) 2>/dev/null || echo unknown` uname -r = `(uname -r) 2>/dev/null || echo unknown` uname -s = `(uname -s) 2>/dev/null || echo unknown` uname -v = `(uname -v) 2>/dev/null || echo unknown` /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null` /bin/uname -X = `(/bin/uname -X) 2>/dev/null` hostinfo = `(hostinfo) 2>/dev/null` /bin/universe = `(/bin/universe) 2>/dev/null` /usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null` /bin/arch = `(/bin/arch) 2>/dev/null` /usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null` /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null` UNAME_MACHINE = ${UNAME_MACHINE} UNAME_RELEASE = ${UNAME_RELEASE} UNAME_SYSTEM = ${UNAME_SYSTEM} UNAME_VERSION = ${UNAME_VERSION} EOF exit 1 # Local variables: # eval: (add-hook 'write-file-hooks 'time-stamp) # time-stamp-start: "timestamp='" # time-stamp-format: "%:y-%02m-%02d" # time-stamp-end: "'" # End: tack-1.07/config.sub0000755000175100001440000010316711301407346013074 0ustar tomusers#! /bin/sh # Configuration validation subroutine script. # Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, # 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 # Free Software Foundation, Inc. timestamp='2009-11-20' # This file is (in principle) common to ALL GNU software. # The presence of a machine in this file suggests that SOME GNU software # can handle that machine. It does not imply ALL GNU software can. # # This file is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA # 02110-1301, USA. # # As a special exception to the GNU General Public License, if you # distribute this file as part of a program that contains a # configuration script generated by Autoconf, you may include it under # the same distribution terms that you use for the rest of that program. # Please send patches to . Submit a context # diff and a properly formatted GNU ChangeLog entry. # # Configuration subroutine to validate and canonicalize a configuration type. # Supply the specified configuration type as an argument. # If it is invalid, we print an error message on stderr and exit with code 1. # Otherwise, we print the canonical config type on stdout and succeed. # You can get the latest version of this script from: # http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub;hb=HEAD # This file is supposed to be the same for all GNU packages # and recognize all the CPU types, system types and aliases # that are meaningful with *any* GNU software. # Each package is responsible for reporting which valid configurations # it does not support. The user should be able to distinguish # a failure to support a valid configuration from a meaningless # configuration. # The goal of this file is to map all the various variations of a given # machine specification into a single specification in the form: # CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM # or in some cases, the newer four-part form: # CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM # It is wrong to echo any other type of specification. me=`echo "$0" | sed -e 's,.*/,,'` usage="\ Usage: $0 [OPTION] CPU-MFR-OPSYS $0 [OPTION] ALIAS Canonicalize a configuration name. Operation modes: -h, --help print this help, then exit -t, --time-stamp print date of last modification, then exit -v, --version print version number, then exit Report bugs and patches to ." version="\ GNU config.sub ($timestamp) Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc. This is free software; see the source for copying conditions. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE." help=" Try \`$me --help' for more information." # Parse command line while test $# -gt 0 ; do case $1 in --time-stamp | --time* | -t ) echo "$timestamp" ; exit ;; --version | -v ) echo "$version" ; exit ;; --help | --h* | -h ) echo "$usage"; exit ;; -- ) # Stop option processing shift; break ;; - ) # Use stdin as input. break ;; -* ) echo "$me: invalid option $1$help" exit 1 ;; *local*) # First pass through any local machine types. echo $1 exit ;; * ) break ;; esac done case $# in 0) echo "$me: missing argument$help" >&2 exit 1;; 1) ;; *) echo "$me: too many arguments$help" >&2 exit 1;; esac # Separate what the user gave into CPU-COMPANY and OS or KERNEL-OS (if any). # Here we must recognize all the valid KERNEL-OS combinations. maybe_os=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\2/'` case $maybe_os in nto-qnx* | linux-gnu* | linux-dietlibc | linux-newlib* | linux-uclibc* | \ uclinux-uclibc* | uclinux-gnu* | kfreebsd*-gnu* | knetbsd*-gnu* | netbsd*-gnu* | \ kopensolaris*-gnu* | \ storm-chaos* | os2-emx* | rtmk-nova*) os=-$maybe_os basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'` ;; *) basic_machine=`echo $1 | sed 's/-[^-]*$//'` if [ $basic_machine != $1 ] then os=`echo $1 | sed 's/.*-/-/'` else os=; fi ;; esac ### Let's recognize common machines as not being operating systems so ### that things like config.sub decstation-3100 work. We also ### recognize some manufacturers as not being operating systems, so we ### can provide default operating systems below. case $os in -sun*os*) # Prevent following clause from handling this invalid input. ;; -dec* | -mips* | -sequent* | -encore* | -pc532* | -sgi* | -sony* | \ -att* | -7300* | -3300* | -delta* | -motorola* | -sun[234]* | \ -unicom* | -ibm* | -next | -hp | -isi* | -apollo | -altos* | \ -convergent* | -ncr* | -news | -32* | -3600* | -3100* | -hitachi* |\ -c[123]* | -convex* | -sun | -crds | -omron* | -dg | -ultra | -tti* | \ -harris | -dolphin | -highlevel | -gould | -cbm | -ns | -masscomp | \ -apple | -axis | -knuth | -cray | -microblaze) os= basic_machine=$1 ;; -bluegene*) os=-cnk ;; -sim | -cisco | -oki | -wec | -winbond) os= basic_machine=$1 ;; -scout) ;; -wrs) os=-vxworks basic_machine=$1 ;; -chorusos*) os=-chorusos basic_machine=$1 ;; -chorusrdb) os=-chorusrdb basic_machine=$1 ;; -hiux*) os=-hiuxwe2 ;; -sco6) os=-sco5v6 basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -sco5) os=-sco3.2v5 basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -sco4) os=-sco3.2v4 basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -sco3.2.[4-9]*) os=`echo $os | sed -e 's/sco3.2./sco3.2v/'` basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -sco3.2v[4-9]*) # Don't forget version if it is 3.2v4 or newer. basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -sco5v6*) # Don't forget version if it is 3.2v4 or newer. basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -sco*) os=-sco3.2v2 basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -udk*) basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -isc) os=-isc2.2 basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -clix*) basic_machine=clipper-intergraph ;; -isc*) basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -lynx*) os=-lynxos ;; -ptx*) basic_machine=`echo $1 | sed -e 's/86-.*/86-sequent/'` ;; -windowsnt*) os=`echo $os | sed -e 's/windowsnt/winnt/'` ;; -psos*) os=-psos ;; -mint | -mint[0-9]*) basic_machine=m68k-atari os=-mint ;; esac # Decode aliases for certain CPU-COMPANY combinations. case $basic_machine in # Recognize the basic CPU types without company name. # Some are omitted here because they have special meanings below. 1750a | 580 \ | a29k \ | alpha | alphaev[4-8] | alphaev56 | alphaev6[78] | alphapca5[67] \ | alpha64 | alpha64ev[4-8] | alpha64ev56 | alpha64ev6[78] | alpha64pca5[67] \ | am33_2.0 \ | arc | arm | arm[bl]e | arme[lb] | armv[2345] | armv[345][lb] | avr | avr32 \ | bfin \ | c4x | clipper \ | d10v | d30v | dlx | dsp16xx \ | fido | fr30 | frv \ | h8300 | h8500 | hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \ | i370 | i860 | i960 | ia64 \ | ip2k | iq2000 \ | lm32 \ | m32c | m32r | m32rle | m68000 | m68k | m88k \ | maxq | mb | microblaze | mcore | mep | metag \ | mips | mipsbe | mipseb | mipsel | mipsle \ | mips16 \ | mips64 | mips64el \ | mips64octeon | mips64octeonel \ | mips64orion | mips64orionel \ | mips64r5900 | mips64r5900el \ | mips64vr | mips64vrel \ | mips64vr4100 | mips64vr4100el \ | mips64vr4300 | mips64vr4300el \ | mips64vr5000 | mips64vr5000el \ | mips64vr5900 | mips64vr5900el \ | mipsisa32 | mipsisa32el \ | mipsisa32r2 | mipsisa32r2el \ | mipsisa64 | mipsisa64el \ | mipsisa64r2 | mipsisa64r2el \ | mipsisa64sb1 | mipsisa64sb1el \ | mipsisa64sr71k | mipsisa64sr71kel \ | mipstx39 | mipstx39el \ | mn10200 | mn10300 \ | moxie \ | mt \ | msp430 \ | nios | nios2 \ | ns16k | ns32k \ | or32 \ | pdp10 | pdp11 | pj | pjl \ | powerpc | powerpc64 | powerpc64le | powerpcle | ppcbe \ | pyramid \ | rx \ | score \ | sh | sh[1234] | sh[24]a | sh[24]aeb | sh[23]e | sh[34]eb | sheb | shbe | shle | sh[1234]le | sh3ele \ | sh64 | sh64le \ | sparc | sparc64 | sparc64b | sparc64v | sparc86x | sparclet | sparclite \ | sparcv8 | sparcv9 | sparcv9b | sparcv9v \ | spu | strongarm \ | tahoe | thumb | tic4x | tic80 | tron \ | ubicom32 \ | v850 | v850e \ | we32k \ | x86 | xc16x | xscale | xscalee[bl] | xstormy16 | xtensa \ | z8k | z80) basic_machine=$basic_machine-unknown ;; m6811 | m68hc11 | m6812 | m68hc12 | picochip) # Motorola 68HC11/12. basic_machine=$basic_machine-unknown os=-none ;; m88110 | m680[12346]0 | m683?2 | m68360 | m5200 | v70 | w65 | z8k) ;; ms1) basic_machine=mt-unknown ;; # We use `pc' rather than `unknown' # because (1) that's what they normally are, and # (2) the word "unknown" tends to confuse beginning users. i*86 | x86_64) basic_machine=$basic_machine-pc ;; # Object if more than one company name word. *-*-*) echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2 exit 1 ;; # Recognize the basic CPU types with company name. 580-* \ | a29k-* \ | alpha-* | alphaev[4-8]-* | alphaev56-* | alphaev6[78]-* \ | alpha64-* | alpha64ev[4-8]-* | alpha64ev56-* | alpha64ev6[78]-* \ | alphapca5[67]-* | alpha64pca5[67]-* | arc-* \ | arm-* | armbe-* | armle-* | armeb-* | armv*-* \ | avr-* | avr32-* \ | bfin-* | bs2000-* \ | c[123]* | c30-* | [cjt]90-* | c4x-* | c54x-* | c55x-* | c6x-* \ | clipper-* | craynv-* | cydra-* \ | d10v-* | d30v-* | dlx-* \ | elxsi-* \ | f30[01]-* | f700-* | fido-* | fr30-* | frv-* | fx80-* \ | h8300-* | h8500-* \ | hppa-* | hppa1.[01]-* | hppa2.0-* | hppa2.0[nw]-* | hppa64-* \ | i*86-* | i860-* | i960-* | ia64-* \ | ip2k-* | iq2000-* \ | lm32-* \ | m32c-* | m32r-* | m32rle-* \ | m68000-* | m680[012346]0-* | m68360-* | m683?2-* | m68k-* \ | m88110-* | m88k-* | maxq-* | mcore-* | metag-* | microblaze-* \ | mips-* | mipsbe-* | mipseb-* | mipsel-* | mipsle-* \ | mips16-* \ | mips64-* | mips64el-* \ | mips64octeon-* | mips64octeonel-* \ | mips64orion-* | mips64orionel-* \ | mips64r5900-* | mips64r5900el-* \ | mips64vr-* | mips64vrel-* \ | mips64vr4100-* | mips64vr4100el-* \ | mips64vr4300-* | mips64vr4300el-* \ | mips64vr5000-* | mips64vr5000el-* \ | mips64vr5900-* | mips64vr5900el-* \ | mipsisa32-* | mipsisa32el-* \ | mipsisa32r2-* | mipsisa32r2el-* \ | mipsisa64-* | mipsisa64el-* \ | mipsisa64r2-* | mipsisa64r2el-* \ | mipsisa64sb1-* | mipsisa64sb1el-* \ | mipsisa64sr71k-* | mipsisa64sr71kel-* \ | mipstx39-* | mipstx39el-* \ | mmix-* \ | mt-* \ | msp430-* \ | nios-* | nios2-* \ | none-* | np1-* | ns16k-* | ns32k-* \ | orion-* \ | pdp10-* | pdp11-* | pj-* | pjl-* | pn-* | power-* \ | powerpc-* | powerpc64-* | powerpc64le-* | powerpcle-* | ppcbe-* \ | pyramid-* \ | romp-* | rs6000-* | rx-* \ | sh-* | sh[1234]-* | sh[24]a-* | sh[24]aeb-* | sh[23]e-* | sh[34]eb-* | sheb-* | shbe-* \ | shle-* | sh[1234]le-* | sh3ele-* | sh64-* | sh64le-* \ | sparc-* | sparc64-* | sparc64b-* | sparc64v-* | sparc86x-* | sparclet-* \ | sparclite-* \ | sparcv8-* | sparcv9-* | sparcv9b-* | sparcv9v-* | strongarm-* | sv1-* | sx?-* \ | tahoe-* | thumb-* \ | tic30-* | tic4x-* | tic54x-* | tic55x-* | tic6x-* | tic80-* | tile-* \ | tron-* \ | ubicom32-* \ | v850-* | v850e-* | vax-* \ | we32k-* \ | x86-* | x86_64-* | xc16x-* | xps100-* | xscale-* | xscalee[bl]-* \ | xstormy16-* | xtensa*-* \ | ymp-* \ | z8k-* | z80-*) ;; # Recognize the basic CPU types without company name, with glob match. xtensa*) basic_machine=$basic_machine-unknown ;; # Recognize the various machine names and aliases which stand # for a CPU type and a company and sometimes even an OS. 386bsd) basic_machine=i386-unknown os=-bsd ;; 3b1 | 7300 | 7300-att | att-7300 | pc7300 | safari | unixpc) basic_machine=m68000-att ;; 3b*) basic_machine=we32k-att ;; a29khif) basic_machine=a29k-amd os=-udi ;; abacus) basic_machine=abacus-unknown ;; adobe68k) basic_machine=m68010-adobe os=-scout ;; alliant | fx80) basic_machine=fx80-alliant ;; altos | altos3068) basic_machine=m68k-altos ;; am29k) basic_machine=a29k-none os=-bsd ;; amd64) basic_machine=x86_64-pc ;; amd64-*) basic_machine=x86_64-`echo $basic_machine | sed 's/^[^-]*-//'` ;; amdahl) basic_machine=580-amdahl os=-sysv ;; amiga | amiga-*) basic_machine=m68k-unknown ;; amigaos | amigados) basic_machine=m68k-unknown os=-amigaos ;; amigaunix | amix) basic_machine=m68k-unknown os=-sysv4 ;; apollo68) basic_machine=m68k-apollo os=-sysv ;; apollo68bsd) basic_machine=m68k-apollo os=-bsd ;; aros) basic_machine=i386-pc os=-aros ;; aux) basic_machine=m68k-apple os=-aux ;; balance) basic_machine=ns32k-sequent os=-dynix ;; blackfin) basic_machine=bfin-unknown os=-linux ;; blackfin-*) basic_machine=bfin-`echo $basic_machine | sed 's/^[^-]*-//'` os=-linux ;; bluegene*) basic_machine=powerpc-ibm os=-cnk ;; c90) basic_machine=c90-cray os=-unicos ;; cegcc) basic_machine=arm-unknown os=-cegcc ;; convex-c1) basic_machine=c1-convex os=-bsd ;; convex-c2) basic_machine=c2-convex os=-bsd ;; convex-c32) basic_machine=c32-convex os=-bsd ;; convex-c34) basic_machine=c34-convex os=-bsd ;; convex-c38) basic_machine=c38-convex os=-bsd ;; cray | j90) basic_machine=j90-cray os=-unicos ;; craynv) basic_machine=craynv-cray os=-unicosmp ;; cr16) basic_machine=cr16-unknown os=-elf ;; crds | unos) basic_machine=m68k-crds ;; crisv32 | crisv32-* | etraxfs*) basic_machine=crisv32-axis ;; cris | cris-* | etrax*) basic_machine=cris-axis ;; crx) basic_machine=crx-unknown os=-elf ;; da30 | da30-*) basic_machine=m68k-da30 ;; decstation | decstation-3100 | pmax | pmax-* | pmin | dec3100 | decstatn) basic_machine=mips-dec ;; decsystem10* | dec10*) basic_machine=pdp10-dec os=-tops10 ;; decsystem20* | dec20*) basic_machine=pdp10-dec os=-tops20 ;; delta | 3300 | motorola-3300 | motorola-delta \ | 3300-motorola | delta-motorola) basic_machine=m68k-motorola ;; delta88) basic_machine=m88k-motorola os=-sysv3 ;; dicos) basic_machine=i686-pc os=-dicos ;; djgpp) basic_machine=i586-pc os=-msdosdjgpp ;; dpx20 | dpx20-*) basic_machine=rs6000-bull os=-bosx ;; dpx2* | dpx2*-bull) basic_machine=m68k-bull os=-sysv3 ;; ebmon29k) basic_machine=a29k-amd os=-ebmon ;; elxsi) basic_machine=elxsi-elxsi os=-bsd ;; encore | umax | mmax) basic_machine=ns32k-encore ;; es1800 | OSE68k | ose68k | ose | OSE) basic_machine=m68k-ericsson os=-ose ;; fx2800) basic_machine=i860-alliant ;; genix) basic_machine=ns32k-ns ;; gmicro) basic_machine=tron-gmicro os=-sysv ;; go32) basic_machine=i386-pc os=-go32 ;; h3050r* | hiux*) basic_machine=hppa1.1-hitachi os=-hiuxwe2 ;; h8300hms) basic_machine=h8300-hitachi os=-hms ;; h8300xray) basic_machine=h8300-hitachi os=-xray ;; h8500hms) basic_machine=h8500-hitachi os=-hms ;; harris) basic_machine=m88k-harris os=-sysv3 ;; hp300-*) basic_machine=m68k-hp ;; hp300bsd) basic_machine=m68k-hp os=-bsd ;; hp300hpux) basic_machine=m68k-hp os=-hpux ;; hp3k9[0-9][0-9] | hp9[0-9][0-9]) basic_machine=hppa1.0-hp ;; hp9k2[0-9][0-9] | hp9k31[0-9]) basic_machine=m68000-hp ;; hp9k3[2-9][0-9]) basic_machine=m68k-hp ;; hp9k6[0-9][0-9] | hp6[0-9][0-9]) basic_machine=hppa1.0-hp ;; hp9k7[0-79][0-9] | hp7[0-79][0-9]) basic_machine=hppa1.1-hp ;; hp9k78[0-9] | hp78[0-9]) # FIXME: really hppa2.0-hp basic_machine=hppa1.1-hp ;; hp9k8[67]1 | hp8[67]1 | hp9k80[24] | hp80[24] | hp9k8[78]9 | hp8[78]9 | hp9k893 | hp893) # FIXME: really hppa2.0-hp basic_machine=hppa1.1-hp ;; hp9k8[0-9][13679] | hp8[0-9][13679]) basic_machine=hppa1.1-hp ;; hp9k8[0-9][0-9] | hp8[0-9][0-9]) basic_machine=hppa1.0-hp ;; hppa-next) os=-nextstep3 ;; hppaosf) basic_machine=hppa1.1-hp os=-osf ;; hppro) basic_machine=hppa1.1-hp os=-proelf ;; i370-ibm* | ibm*) basic_machine=i370-ibm ;; # I'm not sure what "Sysv32" means. Should this be sysv3.2? i*86v32) basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` os=-sysv32 ;; i*86v4*) basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` os=-sysv4 ;; i*86v) basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` os=-sysv ;; i*86sol2) basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` os=-solaris2 ;; i386mach) basic_machine=i386-mach os=-mach ;; i386-vsta | vsta) basic_machine=i386-unknown os=-vsta ;; iris | iris4d) basic_machine=mips-sgi case $os in -irix*) ;; *) os=-irix4 ;; esac ;; isi68 | isi) basic_machine=m68k-isi os=-sysv ;; m68knommu) basic_machine=m68k-unknown os=-linux ;; m68knommu-*) basic_machine=m68k-`echo $basic_machine | sed 's/^[^-]*-//'` os=-linux ;; m88k-omron*) basic_machine=m88k-omron ;; magnum | m3230) basic_machine=mips-mips os=-sysv ;; merlin) basic_machine=ns32k-utek os=-sysv ;; microblaze) basic_machine=microblaze-xilinx ;; mingw32) basic_machine=i386-pc os=-mingw32 ;; mingw32ce) basic_machine=arm-unknown os=-mingw32ce ;; miniframe) basic_machine=m68000-convergent ;; *mint | -mint[0-9]* | *MiNT | *MiNT[0-9]*) basic_machine=m68k-atari os=-mint ;; mips3*-*) basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'` ;; mips3*) basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`-unknown ;; monitor) basic_machine=m68k-rom68k os=-coff ;; morphos) basic_machine=powerpc-unknown os=-morphos ;; msdos) basic_machine=i386-pc os=-msdos ;; ms1-*) basic_machine=`echo $basic_machine | sed -e 's/ms1-/mt-/'` ;; mvs) basic_machine=i370-ibm os=-mvs ;; ncr3000) basic_machine=i486-ncr os=-sysv4 ;; netbsd386) basic_machine=i386-unknown os=-netbsd ;; netwinder) basic_machine=armv4l-rebel os=-linux ;; news | news700 | news800 | news900) basic_machine=m68k-sony os=-newsos ;; news1000) basic_machine=m68030-sony os=-newsos ;; news-3600 | risc-news) basic_machine=mips-sony os=-newsos ;; necv70) basic_machine=v70-nec os=-sysv ;; next | m*-next ) basic_machine=m68k-next case $os in -nextstep* ) ;; -ns2*) os=-nextstep2 ;; *) os=-nextstep3 ;; esac ;; nh3000) basic_machine=m68k-harris os=-cxux ;; nh[45]000) basic_machine=m88k-harris os=-cxux ;; nindy960) basic_machine=i960-intel os=-nindy ;; mon960) basic_machine=i960-intel os=-mon960 ;; nonstopux) basic_machine=mips-compaq os=-nonstopux ;; np1) basic_machine=np1-gould ;; nsr-tandem) basic_machine=nsr-tandem ;; op50n-* | op60c-*) basic_machine=hppa1.1-oki os=-proelf ;; openrisc | openrisc-*) basic_machine=or32-unknown ;; os400) basic_machine=powerpc-ibm os=-os400 ;; OSE68000 | ose68000) basic_machine=m68000-ericsson os=-ose ;; os68k) basic_machine=m68k-none os=-os68k ;; pa-hitachi) basic_machine=hppa1.1-hitachi os=-hiuxwe2 ;; paragon) basic_machine=i860-intel os=-osf ;; parisc) basic_machine=hppa-unknown os=-linux ;; parisc-*) basic_machine=hppa-`echo $basic_machine | sed 's/^[^-]*-//'` os=-linux ;; pbd) basic_machine=sparc-tti ;; pbb) basic_machine=m68k-tti ;; pc532 | pc532-*) basic_machine=ns32k-pc532 ;; pc98) basic_machine=i386-pc ;; pc98-*) basic_machine=i386-`echo $basic_machine | sed 's/^[^-]*-//'` ;; pentium | p5 | k5 | k6 | nexgen | viac3) basic_machine=i586-pc ;; pentiumpro | p6 | 6x86 | athlon | athlon_*) basic_machine=i686-pc ;; pentiumii | pentium2 | pentiumiii | pentium3) basic_machine=i686-pc ;; pentium4) basic_machine=i786-pc ;; pentium-* | p5-* | k5-* | k6-* | nexgen-* | viac3-*) basic_machine=i586-`echo $basic_machine | sed 's/^[^-]*-//'` ;; pentiumpro-* | p6-* | 6x86-* | athlon-*) basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'` ;; pentiumii-* | pentium2-* | pentiumiii-* | pentium3-*) basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'` ;; pentium4-*) basic_machine=i786-`echo $basic_machine | sed 's/^[^-]*-//'` ;; pn) basic_machine=pn-gould ;; power) basic_machine=power-ibm ;; ppc) basic_machine=powerpc-unknown ;; ppc-*) basic_machine=powerpc-`echo $basic_machine | sed 's/^[^-]*-//'` ;; ppcle | powerpclittle | ppc-le | powerpc-little) basic_machine=powerpcle-unknown ;; ppcle-* | powerpclittle-*) basic_machine=powerpcle-`echo $basic_machine | sed 's/^[^-]*-//'` ;; ppc64) basic_machine=powerpc64-unknown ;; ppc64-*) basic_machine=powerpc64-`echo $basic_machine | sed 's/^[^-]*-//'` ;; ppc64le | powerpc64little | ppc64-le | powerpc64-little) basic_machine=powerpc64le-unknown ;; ppc64le-* | powerpc64little-*) basic_machine=powerpc64le-`echo $basic_machine | sed 's/^[^-]*-//'` ;; ps2) basic_machine=i386-ibm ;; pw32) basic_machine=i586-unknown os=-pw32 ;; rdos) basic_machine=i386-pc os=-rdos ;; rom68k) basic_machine=m68k-rom68k os=-coff ;; rm[46]00) basic_machine=mips-siemens ;; rtpc | rtpc-*) basic_machine=romp-ibm ;; s390 | s390-*) basic_machine=s390-ibm ;; s390x | s390x-*) basic_machine=s390x-ibm ;; sa29200) basic_machine=a29k-amd os=-udi ;; sb1) basic_machine=mipsisa64sb1-unknown ;; sb1el) basic_machine=mipsisa64sb1el-unknown ;; sde) basic_machine=mipsisa32-sde os=-elf ;; sei) basic_machine=mips-sei os=-seiux ;; sequent) basic_machine=i386-sequent ;; sh) basic_machine=sh-hitachi os=-hms ;; sh5el) basic_machine=sh5le-unknown ;; sh64) basic_machine=sh64-unknown ;; sparclite-wrs | simso-wrs) basic_machine=sparclite-wrs os=-vxworks ;; sps7) basic_machine=m68k-bull os=-sysv2 ;; spur) basic_machine=spur-unknown ;; st2000) basic_machine=m68k-tandem ;; stratus) basic_machine=i860-stratus os=-sysv4 ;; sun2) basic_machine=m68000-sun ;; sun2os3) basic_machine=m68000-sun os=-sunos3 ;; sun2os4) basic_machine=m68000-sun os=-sunos4 ;; sun3os3) basic_machine=m68k-sun os=-sunos3 ;; sun3os4) basic_machine=m68k-sun os=-sunos4 ;; sun4os3) basic_machine=sparc-sun os=-sunos3 ;; sun4os4) basic_machine=sparc-sun os=-sunos4 ;; sun4sol2) basic_machine=sparc-sun os=-solaris2 ;; sun3 | sun3-*) basic_machine=m68k-sun ;; sun4) basic_machine=sparc-sun ;; sun386 | sun386i | roadrunner) basic_machine=i386-sun ;; sv1) basic_machine=sv1-cray os=-unicos ;; symmetry) basic_machine=i386-sequent os=-dynix ;; t3e) basic_machine=alphaev5-cray os=-unicos ;; t90) basic_machine=t90-cray os=-unicos ;; tic54x | c54x*) basic_machine=tic54x-unknown os=-coff ;; tic55x | c55x*) basic_machine=tic55x-unknown os=-coff ;; tic6x | c6x*) basic_machine=tic6x-unknown os=-coff ;; tile*) basic_machine=tile-unknown os=-linux-gnu ;; tx39) basic_machine=mipstx39-unknown ;; tx39el) basic_machine=mipstx39el-unknown ;; toad1) basic_machine=pdp10-xkl os=-tops20 ;; tower | tower-32) basic_machine=m68k-ncr ;; tpf) basic_machine=s390x-ibm os=-tpf ;; udi29k) basic_machine=a29k-amd os=-udi ;; ultra3) basic_machine=a29k-nyu os=-sym1 ;; v810 | necv810) basic_machine=v810-nec os=-none ;; vaxv) basic_machine=vax-dec os=-sysv ;; vms) basic_machine=vax-dec os=-vms ;; vpp*|vx|vx-*) basic_machine=f301-fujitsu ;; vxworks960) basic_machine=i960-wrs os=-vxworks ;; vxworks68) basic_machine=m68k-wrs os=-vxworks ;; vxworks29k) basic_machine=a29k-wrs os=-vxworks ;; w65*) basic_machine=w65-wdc os=-none ;; w89k-*) basic_machine=hppa1.1-winbond os=-proelf ;; xbox) basic_machine=i686-pc os=-mingw32 ;; xps | xps100) basic_machine=xps100-honeywell ;; ymp) basic_machine=ymp-cray os=-unicos ;; z8k-*-coff) basic_machine=z8k-unknown os=-sim ;; z80-*-coff) basic_machine=z80-unknown os=-sim ;; none) basic_machine=none-none os=-none ;; # Here we handle the default manufacturer of certain CPU types. It is in # some cases the only manufacturer, in others, it is the most popular. w89k) basic_machine=hppa1.1-winbond ;; op50n) basic_machine=hppa1.1-oki ;; op60c) basic_machine=hppa1.1-oki ;; romp) basic_machine=romp-ibm ;; mmix) basic_machine=mmix-knuth ;; rs6000) basic_machine=rs6000-ibm ;; vax) basic_machine=vax-dec ;; pdp10) # there are many clones, so DEC is not a safe bet basic_machine=pdp10-unknown ;; pdp11) basic_machine=pdp11-dec ;; we32k) basic_machine=we32k-att ;; sh[1234] | sh[24]a | sh[24]aeb | sh[34]eb | sh[1234]le | sh[23]ele) basic_machine=sh-unknown ;; sparc | sparcv8 | sparcv9 | sparcv9b | sparcv9v) basic_machine=sparc-sun ;; cydra) basic_machine=cydra-cydrome ;; orion) basic_machine=orion-highlevel ;; orion105) basic_machine=clipper-highlevel ;; mac | mpw | mac-mpw) basic_machine=m68k-apple ;; pmac | pmac-mpw) basic_machine=powerpc-apple ;; *-unknown) # Make sure to match an already-canonicalized machine name. ;; *) echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2 exit 1 ;; esac # Here we canonicalize certain aliases for manufacturers. case $basic_machine in *-digital*) basic_machine=`echo $basic_machine | sed 's/digital.*/dec/'` ;; *-commodore*) basic_machine=`echo $basic_machine | sed 's/commodore.*/cbm/'` ;; *) ;; esac # Decode manufacturer-specific aliases for certain operating systems. if [ x"$os" != x"" ] then case $os in # First match some system type aliases # that might get confused with valid system types. # -solaris* is a basic system type, with this one exception. -auroraux) os=-auroraux ;; -solaris1 | -solaris1.*) os=`echo $os | sed -e 's|solaris1|sunos4|'` ;; -solaris) os=-solaris2 ;; -svr4*) os=-sysv4 ;; -unixware*) os=-sysv4.2uw ;; -gnu/linux*) os=`echo $os | sed -e 's|gnu/linux|linux-gnu|'` ;; # First accept the basic system types. # The portable systems comes first. # Each alternative MUST END IN A *, to match a version number. # -sysv* is not here because it comes later, after sysvr4. -gnu* | -bsd* | -mach* | -minix* | -genix* | -ultrix* | -irix* \ | -*vms* | -sco* | -esix* | -isc* | -aix* | -cnk* | -sunos | -sunos[34]*\ | -hpux* | -unos* | -osf* | -luna* | -dgux* | -auroraux* | -solaris* \ | -sym* | -kopensolaris* \ | -amigaos* | -amigados* | -msdos* | -newsos* | -unicos* | -aof* \ | -aos* | -aros* \ | -nindy* | -vxsim* | -vxworks* | -ebmon* | -hms* | -mvs* \ | -clix* | -riscos* | -uniplus* | -iris* | -rtu* | -xenix* \ | -hiux* | -386bsd* | -knetbsd* | -mirbsd* | -netbsd* \ | -openbsd* | -solidbsd* \ | -ekkobsd* | -kfreebsd* | -freebsd* | -riscix* | -lynxos* \ | -bosx* | -nextstep* | -cxux* | -aout* | -elf* | -oabi* \ | -ptx* | -coff* | -ecoff* | -winnt* | -domain* | -vsta* \ | -udi* | -eabi* | -lites* | -ieee* | -go32* | -aux* \ | -chorusos* | -chorusrdb* | -cegcc* \ | -cygwin* | -pe* | -psos* | -moss* | -proelf* | -rtems* \ | -mingw32* | -linux-gnu* | -linux-newlib* | -linux-uclibc* \ | -uxpv* | -beos* | -mpeix* | -udk* \ | -interix* | -uwin* | -mks* | -rhapsody* | -darwin* | -opened* \ | -openstep* | -oskit* | -conix* | -pw32* | -nonstopux* \ | -storm-chaos* | -tops10* | -tenex* | -tops20* | -its* \ | -os2* | -vos* | -palmos* | -uclinux* | -nucleus* \ | -morphos* | -superux* | -rtmk* | -rtmk-nova* | -windiss* \ | -powermax* | -dnix* | -nx6 | -nx7 | -sei* | -dragonfly* \ | -skyos* | -haiku* | -rdos* | -toppers* | -drops* | -es*) # Remember, each alternative MUST END IN *, to match a version number. ;; -qnx*) case $basic_machine in x86-* | i*86-*) ;; *) os=-nto$os ;; esac ;; -nto-qnx*) ;; -nto*) os=`echo $os | sed -e 's|nto|nto-qnx|'` ;; -sim | -es1800* | -hms* | -xray | -os68k* | -none* | -v88r* \ | -windows* | -osx | -abug | -netware* | -os9* | -beos* | -haiku* \ | -macos* | -mpw* | -magic* | -mmixware* | -mon960* | -lnews*) ;; -mac*) os=`echo $os | sed -e 's|mac|macos|'` ;; -linux-dietlibc) os=-linux-dietlibc ;; -linux*) os=`echo $os | sed -e 's|linux|linux-gnu|'` ;; -sunos5*) os=`echo $os | sed -e 's|sunos5|solaris2|'` ;; -sunos6*) os=`echo $os | sed -e 's|sunos6|solaris3|'` ;; -opened*) os=-openedition ;; -os400*) os=-os400 ;; -wince*) os=-wince ;; -osfrose*) os=-osfrose ;; -osf*) os=-osf ;; -utek*) os=-bsd ;; -dynix*) os=-bsd ;; -acis*) os=-aos ;; -atheos*) os=-atheos ;; -syllable*) os=-syllable ;; -386bsd) os=-bsd ;; -ctix* | -uts*) os=-sysv ;; -nova*) os=-rtmk-nova ;; -ns2 ) os=-nextstep2 ;; -nsk*) os=-nsk ;; # Preserve the version number of sinix5. -sinix5.*) os=`echo $os | sed -e 's|sinix|sysv|'` ;; -sinix*) os=-sysv4 ;; -tpf*) os=-tpf ;; -triton*) os=-sysv3 ;; -oss*) os=-sysv3 ;; -svr4) os=-sysv4 ;; -svr3) os=-sysv3 ;; -sysvr4) os=-sysv4 ;; # This must come after -sysvr4. -sysv*) ;; -ose*) os=-ose ;; -es1800*) os=-ose ;; -xenix) os=-xenix ;; -*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*) os=-mint ;; -aros*) os=-aros ;; -kaos*) os=-kaos ;; -zvmoe) os=-zvmoe ;; -dicos*) os=-dicos ;; -none) ;; *) # Get rid of the `-' at the beginning of $os. os=`echo $os | sed 's/[^-]*-//'` echo Invalid configuration \`$1\': system \`$os\' not recognized 1>&2 exit 1 ;; esac else # Here we handle the default operating systems that come with various machines. # The value should be what the vendor currently ships out the door with their # machine or put another way, the most popular os provided with the machine. # Note that if you're going to try to match "-MANUFACTURER" here (say, # "-sun"), then you have to tell the case statement up towards the top # that MANUFACTURER isn't an operating system. Otherwise, code above # will signal an error saying that MANUFACTURER isn't an operating # system, and we'll never get to this point. case $basic_machine in score-*) os=-elf ;; spu-*) os=-elf ;; *-acorn) os=-riscix1.2 ;; arm*-rebel) os=-linux ;; arm*-semi) os=-aout ;; c4x-* | tic4x-*) os=-coff ;; # This must come before the *-dec entry. pdp10-*) os=-tops20 ;; pdp11-*) os=-none ;; *-dec | vax-*) os=-ultrix4.2 ;; m68*-apollo) os=-domain ;; i386-sun) os=-sunos4.0.2 ;; m68000-sun) os=-sunos3 # This also exists in the configure program, but was not the # default. # os=-sunos4 ;; m68*-cisco) os=-aout ;; mep-*) os=-elf ;; mips*-cisco) os=-elf ;; mips*-*) os=-elf ;; or32-*) os=-coff ;; *-tti) # must be before sparc entry or we get the wrong os. os=-sysv3 ;; sparc-* | *-sun) os=-sunos4.1.1 ;; *-be) os=-beos ;; *-haiku) os=-haiku ;; *-ibm) os=-aix ;; *-knuth) os=-mmixware ;; *-wec) os=-proelf ;; *-winbond) os=-proelf ;; *-oki) os=-proelf ;; *-hp) os=-hpux ;; *-hitachi) os=-hiux ;; i860-* | *-att | *-ncr | *-altos | *-motorola | *-convergent) os=-sysv ;; *-cbm) os=-amigaos ;; *-dg) os=-dgux ;; *-dolphin) os=-sysv3 ;; m68k-ccur) os=-rtu ;; m88k-omron*) os=-luna ;; *-next ) os=-nextstep ;; *-sequent) os=-ptx ;; *-crds) os=-unos ;; *-ns) os=-genix ;; i370-*) os=-mvs ;; *-next) os=-nextstep3 ;; *-gould) os=-sysv ;; *-highlevel) os=-bsd ;; *-encore) os=-bsd ;; *-sgi) os=-irix ;; *-siemens) os=-sysv4 ;; *-masscomp) os=-rtu ;; f30[01]-fujitsu | f700-fujitsu) os=-uxpv ;; *-rom68k) os=-coff ;; *-*bug) os=-coff ;; *-apple) os=-macos ;; *-atari*) os=-mint ;; *) os=-none ;; esac fi # Here we handle the case where we know the os, and the CPU type, but not the # manufacturer. We pick the logical manufacturer. vendor=unknown case $basic_machine in *-unknown) case $os in -riscix*) vendor=acorn ;; -sunos*) vendor=sun ;; -cnk*|-aix*) vendor=ibm ;; -beos*) vendor=be ;; -hpux*) vendor=hp ;; -mpeix*) vendor=hp ;; -hiux*) vendor=hitachi ;; -unos*) vendor=crds ;; -dgux*) vendor=dg ;; -luna*) vendor=omron ;; -genix*) vendor=ns ;; -mvs* | -opened*) vendor=ibm ;; -os400*) vendor=ibm ;; -ptx*) vendor=sequent ;; -tpf*) vendor=ibm ;; -vxsim* | -vxworks* | -windiss*) vendor=wrs ;; -aux*) vendor=apple ;; -hms*) vendor=hitachi ;; -mpw* | -macos*) vendor=apple ;; -*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*) vendor=atari ;; -vos*) vendor=stratus ;; esac basic_machine=`echo $basic_machine | sed "s/unknown/$vendor/"` ;; esac echo $basic_machine$os exit # Local variables: # eval: (add-hook 'write-file-hooks 'time-stamp) # time-stamp-start: "timestamp='" # time-stamp-format: "%:y-%02m-%02d" # time-stamp-end: "'" # End: tack-1.07/configure0000755000175100001440000075207211315503402013020 0ustar tomusers#! /bin/sh # Guess values for system-dependent variables and create Makefiles. # Generated by Autoconf 2.52.20081225. # # Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001 # Free Software Foundation, Inc. # This configure script is free software; the Free Software Foundation # gives unlimited permission to copy, distribute and modify it. # Avoid depending upon Character Ranges. as_cr_letters='abcdefghijklmnopqrstuvwxyz' as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' as_cr_Letters=$as_cr_letters$as_cr_LETTERS as_cr_digits='0123456789' as_cr_alnum=$as_cr_Letters$as_cr_digits # Sed expression to map a string onto a valid variable name. as_tr_sh="sed y%*+%pp%;s%[^_$as_cr_alnum]%_%g" # Sed expression to map a string onto a valid CPP name. as_tr_cpp="sed y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g" # Be Bourne compatible if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then emulate sh NULLCMD=: elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then set -o posix fi # Name of the executable. as_me=`echo "$0" |sed 's,.*[\\/],,'` if expr a : '\(a\)' >/dev/null 2>&1; then as_expr=expr else as_expr=false fi rm -f conf$$ conf$$.exe conf$$.file echo >conf$$.file if ln -s conf$$.file conf$$ 2>/dev/null; then # We could just check for DJGPP; but this test a) works b) is more generic # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04). if test -f conf$$.exe; then # Don't use ln at all; we don't have any links as_ln_s='cp -p' else as_ln_s='ln -s' fi elif ln conf$$.file conf$$ 2>/dev/null; then as_ln_s=ln else as_ln_s='cp -p' fi rm -f conf$$ conf$$.exe conf$$.file as_executable_p="test -f" # Support unset when possible. if (FOO=FOO; unset FOO) >/dev/null 2>&1; then as_unset=unset else as_unset=false fi # NLS nuisances. $as_unset LANG || test "${LANG+set}" != set || { LANG=C; export LANG; } $as_unset LC_ALL || test "${LC_ALL+set}" != set || { LC_ALL=C; export LC_ALL; } $as_unset LC_TIME || test "${LC_TIME+set}" != set || { LC_TIME=C; export LC_TIME; } $as_unset LC_CTYPE || test "${LC_CTYPE+set}" != set || { LC_CTYPE=C; export LC_CTYPE; } $as_unset LANGUAGE || test "${LANGUAGE+set}" != set || { LANGUAGE=C; export LANGUAGE; } $as_unset LC_COLLATE || test "${LC_COLLATE+set}" != set || { LC_COLLATE=C; export LC_COLLATE; } $as_unset LC_NUMERIC || test "${LC_NUMERIC+set}" != set || { LC_NUMERIC=C; export LC_NUMERIC; } $as_unset LC_MESSAGES || test "${LC_MESSAGES+set}" != set || { LC_MESSAGES=C; export LC_MESSAGES; } # IFS # We need space, tab and new line, in precisely that order. as_nl=' ' IFS=" $as_nl" # CDPATH. $as_unset CDPATH || test "${CDPATH+set}" != set || { CDPATH=:; export CDPATH; } # Name of the host. # hostname on some systems (SVR3.2, Linux) returns a bogus exit status, # so uname gets run too. ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q` exec 6>&1 # # Initializations. # ac_default_prefix=/usr/local cross_compiling=no subdirs= MFLAGS= MAKEFLAGS= SHELL=${CONFIG_SHELL-/bin/sh} # Maximum number of lines to put in a shell here document. # This variable seems obsolete. It should probably be removed, and # only ac_max_sed_lines should be used. : ${ac_max_here_lines=38} ac_unique_file="tack.c" # Initialize some variables set by options. ac_init_help= ac_init_version=false # The variables have the same names as the options, with # dashes changed to underlines. cache_file=/dev/null exec_prefix=NONE no_create= no_recursion= prefix=NONE program_prefix=NONE program_suffix=NONE program_transform_name=s,x,x, silent= site= srcdir= verbose= x_includes=NONE x_libraries=NONE # Installation directory options. # These are left unexpanded so users can "make install exec_prefix=/foo" # and all the variables that are supposed to be based on exec_prefix # by default will actually change. # Use braces instead of parens because sh, perl, etc. also accept them. bindir='${exec_prefix}/bin' sbindir='${exec_prefix}/sbin' libexecdir='${exec_prefix}/libexec' datadir='${prefix}/share' sysconfdir='${prefix}/etc' sharedstatedir='${prefix}/com' localstatedir='${prefix}/var' libdir='${exec_prefix}/lib' includedir='${prefix}/include' oldincludedir='/usr/include' infodir='${prefix}/info' mandir='${prefix}/man' # Identity of this package. PACKAGE_NAME= PACKAGE_TARNAME= PACKAGE_VERSION= PACKAGE_STRING= PACKAGE_BUGREPORT= ac_prev= for ac_option do # If the previous option needs an argument, assign it. if test -n "$ac_prev"; then eval "$ac_prev=\$ac_option" ac_prev= continue fi ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'` # Accept the important Cygnus configure options, so we can diagnose typos. case $ac_option in -bindir | --bindir | --bindi | --bind | --bin | --bi) ac_prev=bindir ;; -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*) bindir=$ac_optarg ;; -build | --build | --buil | --bui | --bu) ac_prev=build_alias ;; -build=* | --build=* | --buil=* | --bui=* | --bu=*) build_alias=$ac_optarg ;; -cache-file | --cache-file | --cache-fil | --cache-fi \ | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c) ac_prev=cache_file ;; -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \ | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*) cache_file=$ac_optarg ;; --config-cache | -C) cache_file=config.cache ;; -datadir | --datadir | --datadi | --datad | --data | --dat | --da) ac_prev=datadir ;; -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \ | --da=*) datadir=$ac_optarg ;; -disable-* | --disable-*) ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'` # Reject names that are not valid shell variable names. expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null && { echo "$as_me: error: invalid feature name: $ac_feature" >&2 { (exit 1); exit 1; }; } ac_feature=`echo $ac_feature | sed 's/-/_/g'` eval "enable_$ac_feature=no" ;; -enable-* | --enable-*) ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'` # Reject names that are not valid shell variable names. expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null && { echo "$as_me: error: invalid feature name: $ac_feature" >&2 { (exit 1); exit 1; }; } ac_feature=`echo $ac_feature | sed 's/-/_/g'` case $ac_option in *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;; *) ac_optarg=yes ;; esac eval "enable_$ac_feature='$ac_optarg'" ;; -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \ | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \ | --exec | --exe | --ex) ac_prev=exec_prefix ;; -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \ | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \ | --exec=* | --exe=* | --ex=*) exec_prefix=$ac_optarg ;; -gas | --gas | --ga | --g) # Obsolete; use --with-gas. with_gas=yes ;; -help | --help | --hel | --he | -h) ac_init_help=long ;; -help=r* | --help=r* | --hel=r* | --he=r* | -hr*) ac_init_help=recursive ;; -help=s* | --help=s* | --hel=s* | --he=s* | -hs*) ac_init_help=short ;; -host | --host | --hos | --ho) ac_prev=host_alias ;; -host=* | --host=* | --hos=* | --ho=*) host_alias=$ac_optarg ;; -includedir | --includedir | --includedi | --included | --include \ | --includ | --inclu | --incl | --inc) ac_prev=includedir ;; -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \ | --includ=* | --inclu=* | --incl=* | --inc=*) includedir=$ac_optarg ;; -infodir | --infodir | --infodi | --infod | --info | --inf) ac_prev=infodir ;; -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*) infodir=$ac_optarg ;; -libdir | --libdir | --libdi | --libd) ac_prev=libdir ;; -libdir=* | --libdir=* | --libdi=* | --libd=*) libdir=$ac_optarg ;; -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \ | --libexe | --libex | --libe) ac_prev=libexecdir ;; -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \ | --libexe=* | --libex=* | --libe=*) libexecdir=$ac_optarg ;; -localstatedir | --localstatedir | --localstatedi | --localstated \ | --localstate | --localstat | --localsta | --localst \ | --locals | --local | --loca | --loc | --lo) ac_prev=localstatedir ;; -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \ | --localstate=* | --localstat=* | --localsta=* | --localst=* \ | --locals=* | --local=* | --loca=* | --loc=* | --lo=*) localstatedir=$ac_optarg ;; -mandir | --mandir | --mandi | --mand | --man | --ma | --m) ac_prev=mandir ;; -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*) mandir=$ac_optarg ;; -nfp | --nfp | --nf) # Obsolete; use --without-fp. with_fp=no ;; -no-create | --no-create | --no-creat | --no-crea | --no-cre \ | --no-cr | --no-c) no_create=yes ;; -no-recursion | --no-recursion | --no-recursio | --no-recursi \ | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) no_recursion=yes ;; -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \ | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \ | --oldin | --oldi | --old | --ol | --o) ac_prev=oldincludedir ;; -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \ | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \ | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*) oldincludedir=$ac_optarg ;; -prefix | --prefix | --prefi | --pref | --pre | --pr | --p) ac_prev=prefix ;; -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*) prefix=$ac_optarg ;; -program-prefix | --program-prefix | --program-prefi | --program-pref \ | --program-pre | --program-pr | --program-p) ac_prev=program_prefix ;; -program-prefix=* | --program-prefix=* | --program-prefi=* \ | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*) program_prefix=$ac_optarg ;; -program-suffix | --program-suffix | --program-suffi | --program-suff \ | --program-suf | --program-su | --program-s) ac_prev=program_suffix ;; -program-suffix=* | --program-suffix=* | --program-suffi=* \ | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*) program_suffix=$ac_optarg ;; -program-transform-name | --program-transform-name \ | --program-transform-nam | --program-transform-na \ | --program-transform-n | --program-transform- \ | --program-transform | --program-transfor \ | --program-transfo | --program-transf \ | --program-trans | --program-tran \ | --progr-tra | --program-tr | --program-t) ac_prev=program_transform_name ;; -program-transform-name=* | --program-transform-name=* \ | --program-transform-nam=* | --program-transform-na=* \ | --program-transform-n=* | --program-transform-=* \ | --program-transform=* | --program-transfor=* \ | --program-transfo=* | --program-transf=* \ | --program-trans=* | --program-tran=* \ | --progr-tra=* | --program-tr=* | --program-t=*) program_transform_name=$ac_optarg ;; -q | -quiet | --quiet | --quie | --qui | --qu | --q \ | -silent | --silent | --silen | --sile | --sil) silent=yes ;; -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb) ac_prev=sbindir ;; -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \ | --sbi=* | --sb=*) sbindir=$ac_optarg ;; -sharedstatedir | --sharedstatedir | --sharedstatedi \ | --sharedstated | --sharedstate | --sharedstat | --sharedsta \ | --sharedst | --shareds | --shared | --share | --shar \ | --sha | --sh) ac_prev=sharedstatedir ;; -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \ | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \ | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \ | --sha=* | --sh=*) sharedstatedir=$ac_optarg ;; -site | --site | --sit) ac_prev=site ;; -site=* | --site=* | --sit=*) site=$ac_optarg ;; -srcdir | --srcdir | --srcdi | --srcd | --src | --sr) ac_prev=srcdir ;; -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*) srcdir=$ac_optarg ;; -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \ | --syscon | --sysco | --sysc | --sys | --sy) ac_prev=sysconfdir ;; -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \ | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*) sysconfdir=$ac_optarg ;; -target | --target | --targe | --targ | --tar | --ta | --t) ac_prev=target_alias ;; -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*) target_alias=$ac_optarg ;; -v | -verbose | --verbose | --verbos | --verbo | --verb) verbose=yes ;; -version | --version | --versio | --versi | --vers | -V) ac_init_version=: ;; -with-* | --with-*) ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'` # Reject names that are not valid shell variable names. expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null && { echo "$as_me: error: invalid package name: $ac_package" >&2 { (exit 1); exit 1; }; } ac_package=`echo $ac_package| sed 's/-/_/g'` case $ac_option in *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;; *) ac_optarg=yes ;; esac eval "with_$ac_package='$ac_optarg'" ;; -without-* | --without-*) ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'` # Reject names that are not valid shell variable names. expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null && { echo "$as_me: error: invalid package name: $ac_package" >&2 { (exit 1); exit 1; }; } ac_package=`echo $ac_package | sed 's/-/_/g'` eval "with_$ac_package=no" ;; --x) # Obsolete; use --with-x. with_x=yes ;; -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \ | --x-incl | --x-inc | --x-in | --x-i) ac_prev=x_includes ;; -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \ | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*) x_includes=$ac_optarg ;; -x-libraries | --x-libraries | --x-librarie | --x-librari \ | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l) ac_prev=x_libraries ;; -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \ | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*) x_libraries=$ac_optarg ;; -*) { echo "$as_me: error: unrecognized option: $ac_option Try \`$0 --help' for more information." >&2 { (exit 1); exit 1; }; } ;; *=*) ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='` # Reject names that are not valid shell variable names. expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null && { echo "$as_me: error: invalid variable name: $ac_envvar" >&2 { (exit 1); exit 1; }; } ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` eval "$ac_envvar='$ac_optarg'" export $ac_envvar ;; *) # FIXME: should be removed in autoconf 3.0. echo "$as_me: WARNING: you should use --build, --host, --target" >&2 expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null && echo "$as_me: WARNING: invalid host type: $ac_option" >&2 : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option} ;; esac done if test -n "$ac_prev"; then ac_option=--`echo $ac_prev | sed 's/_/-/g'` { echo "$as_me: error: missing argument to $ac_option" >&2 { (exit 1); exit 1; }; } fi # Be sure to have absolute paths. for ac_var in exec_prefix prefix do eval ac_val=$`echo $ac_var` case $ac_val in [\\/$]* | ?:[\\/]* | NONE | '' ) ;; *) { echo "$as_me: error: expected an absolute path for --$ac_var: $ac_val" >&2 { (exit 1); exit 1; }; };; esac done # Be sure to have absolute paths. for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \ localstatedir libdir includedir oldincludedir infodir mandir do eval ac_val=$`echo $ac_var` case $ac_val in [\\/$]* | ?:[\\/]* ) ;; *) { echo "$as_me: error: expected an absolute path for --$ac_var: $ac_val" >&2 { (exit 1); exit 1; }; };; esac done # There might be people who depend on the old broken behavior: `$host' # used to hold the argument of --host etc. build=$build_alias host=$host_alias target=$target_alias # FIXME: should be removed in autoconf 3.0. if test "x$host_alias" != x; then if test "x$build_alias" = x; then cross_compiling=maybe echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host. If a cross compiler is detected then cross compile mode will be used." >&2 elif test "x$build_alias" != "x$host_alias"; then cross_compiling=yes fi fi ac_tool_prefix= test -n "$host_alias" && ac_tool_prefix=$host_alias- test "$silent" = yes && exec 6>/dev/null # Find the source files, if location was not specified. if test -z "$srcdir"; then ac_srcdir_defaulted=yes # Try the directory containing this script, then its parent. ac_prog=$0 ac_confdir=`echo "$ac_prog" | sed 's%[\\/][^\\/][^\\/]*$%%'` test "x$ac_confdir" = "x$ac_prog" && ac_confdir=. srcdir=$ac_confdir if test ! -r $srcdir/$ac_unique_file; then srcdir=.. fi else ac_srcdir_defaulted=no fi if test ! -r $srcdir/$ac_unique_file; then if test "$ac_srcdir_defaulted" = yes; then { echo "$as_me: error: cannot find sources in $ac_confdir or .." >&2 { (exit 1); exit 1; }; } else { echo "$as_me: error: cannot find sources in $srcdir" >&2 { (exit 1); exit 1; }; } fi fi srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'` ac_env_build_alias_set=${build_alias+set} ac_env_build_alias_value=$build_alias ac_cv_env_build_alias_set=${build_alias+set} ac_cv_env_build_alias_value=$build_alias ac_env_host_alias_set=${host_alias+set} ac_env_host_alias_value=$host_alias ac_cv_env_host_alias_set=${host_alias+set} ac_cv_env_host_alias_value=$host_alias ac_env_target_alias_set=${target_alias+set} ac_env_target_alias_value=$target_alias ac_cv_env_target_alias_set=${target_alias+set} ac_cv_env_target_alias_value=$target_alias ac_env_CC_set=${CC+set} ac_env_CC_value=$CC ac_cv_env_CC_set=${CC+set} ac_cv_env_CC_value=$CC ac_env_CFLAGS_set=${CFLAGS+set} ac_env_CFLAGS_value=$CFLAGS ac_cv_env_CFLAGS_set=${CFLAGS+set} ac_cv_env_CFLAGS_value=$CFLAGS ac_env_LDFLAGS_set=${LDFLAGS+set} ac_env_LDFLAGS_value=$LDFLAGS ac_cv_env_LDFLAGS_set=${LDFLAGS+set} ac_cv_env_LDFLAGS_value=$LDFLAGS ac_env_CPPFLAGS_set=${CPPFLAGS+set} ac_env_CPPFLAGS_value=$CPPFLAGS ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set} ac_cv_env_CPPFLAGS_value=$CPPFLAGS ac_env_CPP_set=${CPP+set} ac_env_CPP_value=$CPP ac_cv_env_CPP_set=${CPP+set} ac_cv_env_CPP_value=$CPP # # Report the --help message. # if test "$ac_init_help" = "long"; then # Omit some internal or obsolete options to make the list less imposing. # This message is too long to be a string in the A/UX 3.1 sh. cat < if you have libraries in a nonstandard directory CPPFLAGS C/C++ preprocessor flags, e.g. -I if you have headers in a nonstandard directory CPP C preprocessor Use these variables to override the choices made by `configure' or to help it to find libraries and programs with nonstandard names/locations. EOF fi if test "$ac_init_help" = "recursive"; then # If there are subdirs, report their specific --help. ac_popdir=`pwd` for ac_subdir in : $ac_subdirs_all; do test "x$ac_subdir" = x: && continue cd $ac_subdir # A "../" for each directory in /$ac_subdir. ac_dots=`echo $ac_subdir | sed 's,^\./,,;s,[^/]$,&/,;s,[^/]*/,../,g'` case $srcdir in .) # No --srcdir option. We are building in place. ac_sub_srcdir=$srcdir ;; [\\/]* | ?:[\\/]* ) # Absolute path. ac_sub_srcdir=$srcdir/$ac_subdir ;; *) # Relative path. ac_sub_srcdir=$ac_dots$srcdir/$ac_subdir ;; esac # Check for guested configure; otherwise get Cygnus style configure. if test -f $ac_sub_srcdir/configure.gnu; then echo $SHELL $ac_sub_srcdir/configure.gnu --help=recursive elif test -f $ac_sub_srcdir/configure; then echo $SHELL $ac_sub_srcdir/configure --help=recursive elif test -f $ac_sub_srcdir/configure.ac || test -f $ac_sub_srcdir/configure.in; then echo $ac_configure --help else echo "$as_me: WARNING: no configuration information is in $ac_subdir" >&2 fi cd $ac_popdir done fi test -n "$ac_init_help" && exit 0 if $ac_init_version; then cat <<\EOF Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001 Free Software Foundation, Inc. This configure script is free software; the Free Software Foundation gives unlimited permission to copy, distribute and modify it. EOF exit 0 fi exec 5>config.log cat >&5 </dev/null | sed 1q` uname -m = `(uname -m) 2>/dev/null || echo unknown` uname -r = `(uname -r) 2>/dev/null || echo unknown` uname -s = `(uname -s) 2>/dev/null || echo unknown` uname -v = `(uname -v) 2>/dev/null || echo unknown` /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown` /bin/uname -X = `(/bin/uname -X) 2>/dev/null || echo unknown` /bin/arch = `(/bin/arch) 2>/dev/null || echo unknown` /usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null || echo unknown` /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown` hostinfo = `(hostinfo) 2>/dev/null || echo unknown` /bin/machine = `(/bin/machine) 2>/dev/null || echo unknown` /usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null || echo unknown` /bin/universe = `(/bin/universe) 2>/dev/null || echo unknown` PATH = $PATH _ASUNAME } >&5 cat >&5 <\?\"\']*) ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'" ac_sep=" " ;; *) ac_configure_args="$ac_configure_args$ac_sep$ac_arg" ac_sep=" " ;; esac # Get rid of the leading space. done # When interrupted or exit'd, cleanup temporary files, and complete # config.log. We remove comments because anyway the quotes in there # would cause problems or look ugly. trap 'exit_status=$? # Save into config.log some information that might help in debugging. echo >&5 echo "## ----------------- ##" >&5 echo "## Cache variables. ##" >&5 echo "## ----------------- ##" >&5 echo >&5 # The following way of writing the cache mishandles newlines in values, { (set) 2>&1 | case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in *ac_space=\ *) sed -n \ "s/'"'"'/'"'"'\\\\'"'"''"'"'/g; s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p" ;; *) sed -n \ "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p" ;; esac; } >&5 sed "/^$/d" confdefs.h >conftest.log if test -s conftest.log; then echo >&5 echo "## ------------ ##" >&5 echo "## confdefs.h. ##" >&5 echo "## ------------ ##" >&5 echo >&5 cat conftest.log >&5 fi (echo; echo) >&5 test "$ac_signal" != 0 && echo "$as_me: caught signal $ac_signal" >&5 echo "$as_me: exit $exit_status" >&5 rm -rf conftest* confdefs* core core.* *.core conf$$* $ac_clean_files && exit $exit_status ' 0 for ac_signal in 1 2 13 15; do trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal done ac_signal=0 # confdefs.h avoids OS command line length limits that DEFS can exceed. rm -rf conftest* confdefs.h # AIX cpp loses on an empty file, so make sure it contains at least a newline. echo >confdefs.h # Let the site file select an alternate cache file if it wants to. # Prefer explicitly selected file to automatically selected ones. if test -z "$CONFIG_SITE"; then if test "x$prefix" != xNONE; then CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site" else CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site" fi fi for ac_site_file in $CONFIG_SITE; do if test -r "$ac_site_file"; then { echo "$as_me:840: loading site script $ac_site_file" >&5 echo "$as_me: loading site script $ac_site_file" >&6;} cat "$ac_site_file" >&5 . "$ac_site_file" fi done if test -r "$cache_file"; then # Some versions of bash will fail to source /dev/null (special # files actually), so we avoid doing that. if test -f "$cache_file"; then { echo "$as_me:851: loading cache $cache_file" >&5 echo "$as_me: loading cache $cache_file" >&6;} case $cache_file in [\\/]* | ?:[\\/]* ) . $cache_file;; *) . ./$cache_file;; esac fi else { echo "$as_me:859: creating cache $cache_file" >&5 echo "$as_me: creating cache $cache_file" >&6;} >$cache_file fi # Check that the precious variables saved in the cache have kept the same # value. ac_cache_corrupted=false for ac_var in `(set) 2>&1 | sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do eval ac_old_set=\$ac_cv_env_${ac_var}_set eval ac_new_set=\$ac_env_${ac_var}_set eval ac_old_val="\$ac_cv_env_${ac_var}_value" eval ac_new_val="\$ac_env_${ac_var}_value" case $ac_old_set,$ac_new_set in set,) { echo "$as_me:875: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5 echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;} ac_cache_corrupted=: ;; ,set) { echo "$as_me:879: error: \`$ac_var' was not set in the previous run" >&5 echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;} ac_cache_corrupted=: ;; ,);; *) if test "x$ac_old_val" != "x$ac_new_val"; then { echo "$as_me:885: error: \`$ac_var' has changed since the previous run:" >&5 echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;} { echo "$as_me:887: former value: $ac_old_val" >&5 echo "$as_me: former value: $ac_old_val" >&2;} { echo "$as_me:889: current value: $ac_new_val" >&5 echo "$as_me: current value: $ac_new_val" >&2;} ac_cache_corrupted=: fi;; esac # Pass precious variables to config.status. It doesn't matter if # we pass some twice (in addition to the command line arguments). if test "$ac_new_set" = set; then case $ac_new_val in *" "*|*" "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*) ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ac_configure_args="$ac_configure_args '$ac_arg'" ;; *) ac_configure_args="$ac_configure_args $ac_var=$ac_new_val" ;; esac fi done if $ac_cache_corrupted; then { echo "$as_me:908: error: changes in the environment can compromise the build" >&5 echo "$as_me: error: changes in the environment can compromise the build" >&2;} { { echo "$as_me:910: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5 echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;} { (exit 1); exit 1; }; } fi ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu ac_main_return=return case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in *c*,-n*) ECHO_N= ECHO_C=' ' ECHO_T=' ' ;; *c*,* ) ECHO_N=-n ECHO_C= ECHO_T= ;; *) ECHO_N= ECHO_C='\c' ECHO_T= ;; esac echo "#! $SHELL" >conftest.sh echo "exit 0" >>conftest.sh chmod +x conftest.sh if { (echo "$as_me:931: PATH=\".;.\"; conftest.sh") >&5 (PATH=".;."; conftest.sh) 2>&5 ac_status=$? echo "$as_me:934: \$? = $ac_status" >&5 (exit $ac_status); }; then ac_path_separator=';' else ac_path_separator=: fi PATH_SEPARATOR="$ac_path_separator" rm -f conftest.sh ac_config_headers="$ac_config_headers ncurses_cfg.h:ncurses_tst.hin" test -f config.guess || ( test -f ../config.guess && cp ../config.guess ./ ) test -f config.sub || ( test -f ../config.sub && cp ../config.sub ./ ) ac_aux_dir= for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do if test -f $ac_dir/install-sh; then ac_aux_dir=$ac_dir ac_install_sh="$ac_aux_dir/install-sh -c" break elif test -f $ac_dir/install.sh; then ac_aux_dir=$ac_dir ac_install_sh="$ac_aux_dir/install.sh -c" break elif test -f $ac_dir/shtool; then ac_aux_dir=$ac_dir ac_install_sh="$ac_aux_dir/shtool install -c" break fi done if test -z "$ac_aux_dir"; then { { echo "$as_me:966: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5 echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;} { (exit 1); exit 1; }; } fi ac_config_guess="$SHELL $ac_aux_dir/config.guess" ac_config_sub="$SHELL $ac_aux_dir/config.sub" ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure. # Make sure we can run config.sub. $ac_config_sub sun4 >/dev/null 2>&1 || { { echo "$as_me:976: error: cannot run $ac_config_sub" >&5 echo "$as_me: error: cannot run $ac_config_sub" >&2;} { (exit 1); exit 1; }; } echo "$as_me:980: checking build system type" >&5 echo $ECHO_N "checking build system type... $ECHO_C" >&6 if test "${ac_cv_build+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else ac_cv_build_alias=$build_alias test -z "$ac_cv_build_alias" && ac_cv_build_alias=`$ac_config_guess` test -z "$ac_cv_build_alias" && { { echo "$as_me:989: error: cannot guess build type; you must specify one" >&5 echo "$as_me: error: cannot guess build type; you must specify one" >&2;} { (exit 1); exit 1; }; } ac_cv_build=`$ac_config_sub $ac_cv_build_alias` || { { echo "$as_me:993: error: $ac_config_sub $ac_cv_build_alias failed." >&5 echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed." >&2;} { (exit 1); exit 1; }; } fi echo "$as_me:998: result: $ac_cv_build" >&5 echo "${ECHO_T}$ac_cv_build" >&6 build=$ac_cv_build build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'` build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'` build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'` if test -f $srcdir/config.guess || test -f $ac_aux_dir/config.guess ; then echo "$as_me:1006: checking host system type" >&5 echo $ECHO_N "checking host system type... $ECHO_C" >&6 if test "${ac_cv_host+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else ac_cv_host_alias=$host_alias test -z "$ac_cv_host_alias" && ac_cv_host_alias=$ac_cv_build_alias ac_cv_host=`$ac_config_sub $ac_cv_host_alias` || { { echo "$as_me:1015: error: $ac_config_sub $ac_cv_host_alias failed" >&5 echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;} { (exit 1); exit 1; }; } fi echo "$as_me:1020: result: $ac_cv_host" >&5 echo "${ECHO_T}$ac_cv_host" >&6 host=$ac_cv_host host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'` host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'` host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'` system_name="$host_os" else system_name="`(uname -s -r) 2>/dev/null`" if test -z "$system_name" ; then system_name="`(hostname) 2>/dev/null`" fi fi test -n "$system_name" && cat >>confdefs.h <&6 else cf_cv_system_name="$system_name" fi test -z "$system_name" && system_name="$cf_cv_system_name" test -n "$cf_cv_system_name" && echo "$as_me:1045: result: Configuring for $cf_cv_system_name" >&5 echo "${ECHO_T}Configuring for $cf_cv_system_name" >&6 if test ".$system_name" != ".$cf_cv_system_name" ; then echo "$as_me:1049: result: Cached system name ($system_name) does not agree with actual ($cf_cv_system_name)" >&5 echo "${ECHO_T}Cached system name ($system_name) does not agree with actual ($cf_cv_system_name)" >&6 { { echo "$as_me:1051: error: \"Please remove config.cache and try again.\"" >&5 echo "$as_me: error: \"Please remove config.cache and try again.\"" >&2;} { (exit 1); exit 1; }; } fi echo "$as_me:1056: checking whether ${MAKE-make} sets \${MAKE}" >&5 echo $ECHO_N "checking whether ${MAKE-make} sets \${MAKE}... $ECHO_C" >&6 set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,./+-,__p_,'` if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then echo $ECHO_N "(cached) $ECHO_C" >&6 else cat >conftest.make <<\EOF all: @echo 'ac_maketemp="${MAKE}"' EOF # GNU make sometimes prints "make[1]: Entering...", which would confuse us. eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=` if test -n "$ac_maketemp"; then eval ac_cv_prog_make_${ac_make}_set=yes else eval ac_cv_prog_make_${ac_make}_set=no fi rm -f conftest.make fi if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then echo "$as_me:1076: result: yes" >&5 echo "${ECHO_T}yes" >&6 SET_MAKE= else echo "$as_me:1080: result: no" >&5 echo "${ECHO_T}no" >&6 SET_MAKE="MAKE=${MAKE-make}" fi ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu ac_main_return=return if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args. set dummy ${ac_tool_prefix}gcc; ac_word=$2 echo "$as_me:1094: checking for $ac_word" >&5 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 if test "${ac_cv_prog_CC+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else ac_save_IFS=$IFS; IFS=$ac_path_separator ac_dummy="$PATH" for ac_dir in $ac_dummy; do IFS=$ac_save_IFS test -z "$ac_dir" && ac_dir=. $as_executable_p "$ac_dir/$ac_word" || continue ac_cv_prog_CC="${ac_tool_prefix}gcc" echo "$as_me:1109: found $ac_dir/$ac_word" >&5 break done fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then echo "$as_me:1117: result: $CC" >&5 echo "${ECHO_T}$CC" >&6 else echo "$as_me:1120: result: no" >&5 echo "${ECHO_T}no" >&6 fi fi if test -z "$ac_cv_prog_CC"; then ac_ct_CC=$CC # Extract the first word of "gcc", so it can be a program name with args. set dummy gcc; ac_word=$2 echo "$as_me:1129: checking for $ac_word" >&5 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else if test -n "$ac_ct_CC"; then ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. else ac_save_IFS=$IFS; IFS=$ac_path_separator ac_dummy="$PATH" for ac_dir in $ac_dummy; do IFS=$ac_save_IFS test -z "$ac_dir" && ac_dir=. $as_executable_p "$ac_dir/$ac_word" || continue ac_cv_prog_ac_ct_CC="gcc" echo "$as_me:1144: found $ac_dir/$ac_word" >&5 break done fi fi ac_ct_CC=$ac_cv_prog_ac_ct_CC if test -n "$ac_ct_CC"; then echo "$as_me:1152: result: $ac_ct_CC" >&5 echo "${ECHO_T}$ac_ct_CC" >&6 else echo "$as_me:1155: result: no" >&5 echo "${ECHO_T}no" >&6 fi CC=$ac_ct_CC else CC="$ac_cv_prog_CC" fi if test -z "$CC"; then if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args. set dummy ${ac_tool_prefix}cc; ac_word=$2 echo "$as_me:1168: checking for $ac_word" >&5 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 if test "${ac_cv_prog_CC+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else ac_save_IFS=$IFS; IFS=$ac_path_separator ac_dummy="$PATH" for ac_dir in $ac_dummy; do IFS=$ac_save_IFS test -z "$ac_dir" && ac_dir=. $as_executable_p "$ac_dir/$ac_word" || continue ac_cv_prog_CC="${ac_tool_prefix}cc" echo "$as_me:1183: found $ac_dir/$ac_word" >&5 break done fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then echo "$as_me:1191: result: $CC" >&5 echo "${ECHO_T}$CC" >&6 else echo "$as_me:1194: result: no" >&5 echo "${ECHO_T}no" >&6 fi fi if test -z "$ac_cv_prog_CC"; then ac_ct_CC=$CC # Extract the first word of "cc", so it can be a program name with args. set dummy cc; ac_word=$2 echo "$as_me:1203: checking for $ac_word" >&5 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else if test -n "$ac_ct_CC"; then ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. else ac_save_IFS=$IFS; IFS=$ac_path_separator ac_dummy="$PATH" for ac_dir in $ac_dummy; do IFS=$ac_save_IFS test -z "$ac_dir" && ac_dir=. $as_executable_p "$ac_dir/$ac_word" || continue ac_cv_prog_ac_ct_CC="cc" echo "$as_me:1218: found $ac_dir/$ac_word" >&5 break done fi fi ac_ct_CC=$ac_cv_prog_ac_ct_CC if test -n "$ac_ct_CC"; then echo "$as_me:1226: result: $ac_ct_CC" >&5 echo "${ECHO_T}$ac_ct_CC" >&6 else echo "$as_me:1229: result: no" >&5 echo "${ECHO_T}no" >&6 fi CC=$ac_ct_CC else CC="$ac_cv_prog_CC" fi fi if test -z "$CC"; then # Extract the first word of "cc", so it can be a program name with args. set dummy cc; ac_word=$2 echo "$as_me:1242: checking for $ac_word" >&5 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 if test "${ac_cv_prog_CC+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else ac_prog_rejected=no ac_save_IFS=$IFS; IFS=$ac_path_separator ac_dummy="$PATH" for ac_dir in $ac_dummy; do IFS=$ac_save_IFS test -z "$ac_dir" && ac_dir=. $as_executable_p "$ac_dir/$ac_word" || continue if test "$ac_dir/$ac_word" = "/usr/ucb/cc"; then ac_prog_rejected=yes continue fi ac_cv_prog_CC="cc" echo "$as_me:1262: found $ac_dir/$ac_word" >&5 break done if test $ac_prog_rejected = yes; then # We found a bogon in the path, so make sure we never use it. set dummy $ac_cv_prog_CC shift if test $# != 0; then # We chose a different compiler from the bogus one. # However, it has the same basename, so the bogon will be chosen # first if we set CC to just the basename; use the full file name. shift set dummy "$ac_dir/$ac_word" ${1+"$@"} shift ac_cv_prog_CC="$@" fi fi fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then echo "$as_me:1284: result: $CC" >&5 echo "${ECHO_T}$CC" >&6 else echo "$as_me:1287: result: no" >&5 echo "${ECHO_T}no" >&6 fi fi if test -z "$CC"; then if test -n "$ac_tool_prefix"; then for ac_prog in cl do # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. set dummy $ac_tool_prefix$ac_prog; ac_word=$2 echo "$as_me:1298: checking for $ac_word" >&5 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 if test "${ac_cv_prog_CC+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else ac_save_IFS=$IFS; IFS=$ac_path_separator ac_dummy="$PATH" for ac_dir in $ac_dummy; do IFS=$ac_save_IFS test -z "$ac_dir" && ac_dir=. $as_executable_p "$ac_dir/$ac_word" || continue ac_cv_prog_CC="$ac_tool_prefix$ac_prog" echo "$as_me:1313: found $ac_dir/$ac_word" >&5 break done fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then echo "$as_me:1321: result: $CC" >&5 echo "${ECHO_T}$CC" >&6 else echo "$as_me:1324: result: no" >&5 echo "${ECHO_T}no" >&6 fi test -n "$CC" && break done fi if test -z "$CC"; then ac_ct_CC=$CC for ac_prog in cl do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 echo "$as_me:1337: checking for $ac_word" >&5 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else if test -n "$ac_ct_CC"; then ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. else ac_save_IFS=$IFS; IFS=$ac_path_separator ac_dummy="$PATH" for ac_dir in $ac_dummy; do IFS=$ac_save_IFS test -z "$ac_dir" && ac_dir=. $as_executable_p "$ac_dir/$ac_word" || continue ac_cv_prog_ac_ct_CC="$ac_prog" echo "$as_me:1352: found $ac_dir/$ac_word" >&5 break done fi fi ac_ct_CC=$ac_cv_prog_ac_ct_CC if test -n "$ac_ct_CC"; then echo "$as_me:1360: result: $ac_ct_CC" >&5 echo "${ECHO_T}$ac_ct_CC" >&6 else echo "$as_me:1363: result: no" >&5 echo "${ECHO_T}no" >&6 fi test -n "$ac_ct_CC" && break done CC=$ac_ct_CC fi fi test -z "$CC" && { { echo "$as_me:1375: error: no acceptable cc found in \$PATH" >&5 echo "$as_me: error: no acceptable cc found in \$PATH" >&2;} { (exit 1); exit 1; }; } # Provide some information about the compiler. echo "$as_me:1380:" \ "checking for C compiler version" >&5 ac_compiler=`set X $ac_compile; echo $2` { (eval echo "$as_me:1383: \"$ac_compiler --version &5\"") >&5 (eval $ac_compiler --version &5) 2>&5 ac_status=$? echo "$as_me:1386: \$? = $ac_status" >&5 (exit $ac_status); } { (eval echo "$as_me:1388: \"$ac_compiler -v &5\"") >&5 (eval $ac_compiler -v &5) 2>&5 ac_status=$? echo "$as_me:1391: \$? = $ac_status" >&5 (exit $ac_status); } { (eval echo "$as_me:1393: \"$ac_compiler -V &5\"") >&5 (eval $ac_compiler -V &5) 2>&5 ac_status=$? echo "$as_me:1396: \$? = $ac_status" >&5 (exit $ac_status); } cat >conftest.$ac_ext <<_ACEOF #line 1400 "configure" #include "confdefs.h" int main () { ; return 0; } _ACEOF ac_clean_files_save=$ac_clean_files ac_clean_files="$ac_clean_files a.out a.exe" # Try to create an executable without -o first, disregard a.out. # It will help us diagnose broken compilers, and finding out an intuition # of exeext. echo "$as_me:1416: checking for C compiler default output" >&5 echo $ECHO_N "checking for C compiler default output... $ECHO_C" >&6 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'` if { (eval echo "$as_me:1419: \"$ac_link_default\"") >&5 (eval $ac_link_default) 2>&5 ac_status=$? echo "$as_me:1422: \$? = $ac_status" >&5 (exit $ac_status); }; then # Find the output, starting from the most likely. This scheme is # not robust to junk in `.', hence go to wildcards (a.*) only as a last # resort. for ac_file in `ls a.exe conftest.exe 2>/dev/null; ls a.out conftest 2>/dev/null; ls a.* conftest.* 2>/dev/null`; do case $ac_file in *.$ac_ext | *.xcoff | *.tds | *.d | *.dbg | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.o | *.obj ) ;; a.out ) # We found the default executable, but exeext='' is most # certainly right. break;; *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'` # FIXME: I believe we export ac_cv_exeext for Libtool --akim. export ac_cv_exeext break;; * ) break;; esac done else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 { { echo "$as_me:1445: error: C compiler cannot create executables" >&5 echo "$as_me: error: C compiler cannot create executables" >&2;} { (exit 77); exit 77; }; } fi ac_exeext=$ac_cv_exeext echo "$as_me:1451: result: $ac_file" >&5 echo "${ECHO_T}$ac_file" >&6 # Check the compiler produces executables we can run. If not, either # the compiler is broken, or we cross compile. echo "$as_me:1456: checking whether the C compiler works" >&5 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0 # If not cross compiling, check that we can run a simple program. if test "$cross_compiling" != yes; then if { ac_try='./$ac_file' { (eval echo "$as_me:1462: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:1465: \$? = $ac_status" >&5 (exit $ac_status); }; }; then cross_compiling=no else if test "$cross_compiling" = maybe; then cross_compiling=yes else { { echo "$as_me:1472: error: cannot run C compiled programs. If you meant to cross compile, use \`--host'." >&5 echo "$as_me: error: cannot run C compiled programs. If you meant to cross compile, use \`--host'." >&2;} { (exit 1); exit 1; }; } fi fi fi echo "$as_me:1480: result: yes" >&5 echo "${ECHO_T}yes" >&6 rm -f a.out a.exe conftest$ac_cv_exeext ac_clean_files=$ac_clean_files_save # Check the compiler produces executables we can run. If not, either # the compiler is broken, or we cross compile. echo "$as_me:1487: checking whether we are cross compiling" >&5 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6 echo "$as_me:1489: result: $cross_compiling" >&5 echo "${ECHO_T}$cross_compiling" >&6 echo "$as_me:1492: checking for executable suffix" >&5 echo $ECHO_N "checking for executable suffix... $ECHO_C" >&6 if { (eval echo "$as_me:1494: \"$ac_link\"") >&5 (eval $ac_link) 2>&5 ac_status=$? echo "$as_me:1497: \$? = $ac_status" >&5 (exit $ac_status); }; then # If both `conftest.exe' and `conftest' are `present' (well, observable) # catch `conftest.exe'. For instance with Cygwin, `ls conftest' will # work properly (i.e., refer to `conftest.exe'), while it won't with # `rm'. for ac_file in `(ls conftest.exe; ls conftest; ls conftest.*) 2>/dev/null`; do case $ac_file in *.$ac_ext | *.xcoff | *.tds | *.d | *.dbg | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.o | *.obj ) ;; *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'` export ac_cv_exeext break;; * ) break;; esac done else { { echo "$as_me:1513: error: cannot compute EXEEXT: cannot compile and link" >&5 echo "$as_me: error: cannot compute EXEEXT: cannot compile and link" >&2;} { (exit 1); exit 1; }; } fi rm -f conftest$ac_cv_exeext echo "$as_me:1519: result: $ac_cv_exeext" >&5 echo "${ECHO_T}$ac_cv_exeext" >&6 rm -f conftest.$ac_ext EXEEXT=$ac_cv_exeext ac_exeext=$EXEEXT echo "$as_me:1525: checking for object suffix" >&5 echo $ECHO_N "checking for object suffix... $ECHO_C" >&6 if test "${ac_cv_objext+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else cat >conftest.$ac_ext <<_ACEOF #line 1531 "configure" #include "confdefs.h" int main () { ; return 0; } _ACEOF rm -f conftest.o conftest.obj if { (eval echo "$as_me:1543: \"$ac_compile\"") >&5 (eval $ac_compile) 2>&5 ac_status=$? echo "$as_me:1546: \$? = $ac_status" >&5 (exit $ac_status); }; then for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do case $ac_file in *.$ac_ext | *.xcoff | *.tds | *.d | *.dbg | *.pdb | *.xSYM | *.map | *.inf ) ;; *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'` break;; esac done else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 { { echo "$as_me:1558: error: cannot compute OBJEXT: cannot compile" >&5 echo "$as_me: error: cannot compute OBJEXT: cannot compile" >&2;} { (exit 1); exit 1; }; } fi rm -f conftest.$ac_cv_objext conftest.$ac_ext fi echo "$as_me:1565: result: $ac_cv_objext" >&5 echo "${ECHO_T}$ac_cv_objext" >&6 OBJEXT=$ac_cv_objext ac_objext=$OBJEXT echo "$as_me:1569: checking whether we are using the GNU C compiler" >&5 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6 if test "${ac_cv_c_compiler_gnu+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else cat >conftest.$ac_ext <<_ACEOF #line 1575 "configure" #include "confdefs.h" int main () { #ifndef __GNUC__ choke me #endif ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (eval echo "$as_me:1590: \"$ac_compile\"") >&5 (eval $ac_compile) 2>&5 ac_status=$? echo "$as_me:1593: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest.$ac_objext' { (eval echo "$as_me:1596: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:1599: \$? = $ac_status" >&5 (exit $ac_status); }; }; then ac_compiler_gnu=yes else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 ac_compiler_gnu=no fi rm -f conftest.$ac_objext conftest.$ac_ext ac_cv_c_compiler_gnu=$ac_compiler_gnu fi echo "$as_me:1611: result: $ac_cv_c_compiler_gnu" >&5 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6 GCC=`test $ac_compiler_gnu = yes && echo yes` ac_test_CFLAGS=${CFLAGS+set} ac_save_CFLAGS=$CFLAGS CFLAGS="-g" echo "$as_me:1617: checking whether $CC accepts -g" >&5 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6 if test "${ac_cv_prog_cc_g+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else cat >conftest.$ac_ext <<_ACEOF #line 1623 "configure" #include "confdefs.h" int main () { ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (eval echo "$as_me:1635: \"$ac_compile\"") >&5 (eval $ac_compile) 2>&5 ac_status=$? echo "$as_me:1638: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest.$ac_objext' { (eval echo "$as_me:1641: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:1644: \$? = $ac_status" >&5 (exit $ac_status); }; }; then ac_cv_prog_cc_g=yes else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 ac_cv_prog_cc_g=no fi rm -f conftest.$ac_objext conftest.$ac_ext fi echo "$as_me:1654: result: $ac_cv_prog_cc_g" >&5 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6 if test "$ac_test_CFLAGS" = set; then CFLAGS=$ac_save_CFLAGS elif test $ac_cv_prog_cc_g = yes; then if test "$GCC" = yes; then CFLAGS="-g -O2" else CFLAGS="-g" fi else if test "$GCC" = yes; then CFLAGS="-O2" else CFLAGS= fi fi # Some people use a C++ compiler to compile C. Since we use `exit', # in C++ we need to declare it. In case someone uses the same compiler # for both compiling C and C++ we need to have the C++ compiler decide # the declaration of exit, since it's the most demanding environment. cat >conftest.$ac_ext <<_ACEOF #ifndef __cplusplus choke me #endif _ACEOF rm -f conftest.$ac_objext if { (eval echo "$as_me:1681: \"$ac_compile\"") >&5 (eval $ac_compile) 2>&5 ac_status=$? echo "$as_me:1684: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest.$ac_objext' { (eval echo "$as_me:1687: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:1690: \$? = $ac_status" >&5 (exit $ac_status); }; }; then for ac_declaration in \ ''\ '#include ' \ 'extern "C" void std::exit (int) throw (); using std::exit;' \ 'extern "C" void std::exit (int); using std::exit;' \ 'extern "C" void exit (int) throw ();' \ 'extern "C" void exit (int);' \ 'void exit (int);' do cat >conftest.$ac_ext <<_ACEOF #line 1702 "configure" #include "confdefs.h" #include $ac_declaration int main () { exit (42); ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (eval echo "$as_me:1715: \"$ac_compile\"") >&5 (eval $ac_compile) 2>&5 ac_status=$? echo "$as_me:1718: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest.$ac_objext' { (eval echo "$as_me:1721: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:1724: \$? = $ac_status" >&5 (exit $ac_status); }; }; then : else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 continue fi rm -f conftest.$ac_objext conftest.$ac_ext cat >conftest.$ac_ext <<_ACEOF #line 1734 "configure" #include "confdefs.h" $ac_declaration int main () { exit (42); ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (eval echo "$as_me:1746: \"$ac_compile\"") >&5 (eval $ac_compile) 2>&5 ac_status=$? echo "$as_me:1749: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest.$ac_objext' { (eval echo "$as_me:1752: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:1755: \$? = $ac_status" >&5 (exit $ac_status); }; }; then break else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 fi rm -f conftest.$ac_objext conftest.$ac_ext done rm -f conftest* if test -n "$ac_declaration"; then echo '#ifdef __cplusplus' >>confdefs.h echo $ac_declaration >>confdefs.h echo '#endif' >>confdefs.h fi else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 fi rm -f conftest.$ac_objext conftest.$ac_ext ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu ac_main_return=return ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu ac_main_return=return echo "$as_me:1789: checking how to run the C preprocessor" >&5 echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6 # On Suns, sometimes $CPP names a directory. if test -n "$CPP" && test -d "$CPP"; then CPP= fi if test -z "$CPP"; then if test "${ac_cv_prog_CPP+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else # Double quotes because CPP needs to be expanded for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp" do ac_preproc_ok=false for ac_c_preproc_warn_flag in '' yes do # Use a header file that comes with gcc, so configuring glibc # with a fresh cross-compiler works. # On the NeXT, cc -E runs the code through the compiler's parser, # not just through cpp. "Syntax error" is here to catch this case. cat >conftest.$ac_ext <<_ACEOF #line 1810 "configure" #include "confdefs.h" #include Syntax error _ACEOF if { (eval echo "$as_me:1815: \"$ac_cpp conftest.$ac_ext\"") >&5 (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1 ac_status=$? egrep -v '^ *\+' conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo "$as_me:1821: \$? = $ac_status" >&5 (exit $ac_status); } >/dev/null; then if test -s conftest.err; then ac_cpp_err=$ac_c_preproc_warn_flag else ac_cpp_err= fi else ac_cpp_err=yes fi if test -z "$ac_cpp_err"; then : else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 # Broken: fails on valid input. continue fi rm -f conftest.err conftest.$ac_ext # OK, works on sane cases. Now check whether non-existent headers # can be detected and how. cat >conftest.$ac_ext <<_ACEOF #line 1844 "configure" #include "confdefs.h" #include _ACEOF if { (eval echo "$as_me:1848: \"$ac_cpp conftest.$ac_ext\"") >&5 (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1 ac_status=$? egrep -v '^ *\+' conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo "$as_me:1854: \$? = $ac_status" >&5 (exit $ac_status); } >/dev/null; then if test -s conftest.err; then ac_cpp_err=$ac_c_preproc_warn_flag else ac_cpp_err= fi else ac_cpp_err=yes fi if test -z "$ac_cpp_err"; then # Broken: success on invalid input. continue else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 # Passes both tests. ac_preproc_ok=: break fi rm -f conftest.err conftest.$ac_ext done # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. rm -f conftest.err conftest.$ac_ext if $ac_preproc_ok; then break fi done ac_cv_prog_CPP=$CPP fi CPP=$ac_cv_prog_CPP else ac_cv_prog_CPP=$CPP fi echo "$as_me:1891: result: $CPP" >&5 echo "${ECHO_T}$CPP" >&6 ac_preproc_ok=false for ac_c_preproc_warn_flag in '' yes do # Use a header file that comes with gcc, so configuring glibc # with a fresh cross-compiler works. # On the NeXT, cc -E runs the code through the compiler's parser, # not just through cpp. "Syntax error" is here to catch this case. cat >conftest.$ac_ext <<_ACEOF #line 1901 "configure" #include "confdefs.h" #include Syntax error _ACEOF if { (eval echo "$as_me:1906: \"$ac_cpp conftest.$ac_ext\"") >&5 (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1 ac_status=$? egrep -v '^ *\+' conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo "$as_me:1912: \$? = $ac_status" >&5 (exit $ac_status); } >/dev/null; then if test -s conftest.err; then ac_cpp_err=$ac_c_preproc_warn_flag else ac_cpp_err= fi else ac_cpp_err=yes fi if test -z "$ac_cpp_err"; then : else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 # Broken: fails on valid input. continue fi rm -f conftest.err conftest.$ac_ext # OK, works on sane cases. Now check whether non-existent headers # can be detected and how. cat >conftest.$ac_ext <<_ACEOF #line 1935 "configure" #include "confdefs.h" #include _ACEOF if { (eval echo "$as_me:1939: \"$ac_cpp conftest.$ac_ext\"") >&5 (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1 ac_status=$? egrep -v '^ *\+' conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo "$as_me:1945: \$? = $ac_status" >&5 (exit $ac_status); } >/dev/null; then if test -s conftest.err; then ac_cpp_err=$ac_c_preproc_warn_flag else ac_cpp_err= fi else ac_cpp_err=yes fi if test -z "$ac_cpp_err"; then # Broken: success on invalid input. continue else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 # Passes both tests. ac_preproc_ok=: break fi rm -f conftest.err conftest.$ac_ext done # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. rm -f conftest.err conftest.$ac_ext if $ac_preproc_ok; then : else { { echo "$as_me:1973: error: C preprocessor \"$CPP\" fails sanity check" >&5 echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check" >&2;} { (exit 1); exit 1; }; } fi ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu ac_main_return=return for ac_prog in mawk gawk nawk awk do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 echo "$as_me:1989: checking for $ac_word" >&5 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 if test "${ac_cv_prog_AWK+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else if test -n "$AWK"; then ac_cv_prog_AWK="$AWK" # Let the user override the test. else ac_save_IFS=$IFS; IFS=$ac_path_separator ac_dummy="$PATH" for ac_dir in $ac_dummy; do IFS=$ac_save_IFS test -z "$ac_dir" && ac_dir=. $as_executable_p "$ac_dir/$ac_word" || continue ac_cv_prog_AWK="$ac_prog" echo "$as_me:2004: found $ac_dir/$ac_word" >&5 break done fi fi AWK=$ac_cv_prog_AWK if test -n "$AWK"; then echo "$as_me:2012: result: $AWK" >&5 echo "${ECHO_T}$AWK" >&6 else echo "$as_me:2015: result: no" >&5 echo "${ECHO_T}no" >&6 fi test -n "$AWK" && break done # Find a good install program. We prefer a C program (faster), # so one script is as good as another. But avoid the broken or # incompatible versions: # SysV /etc/install, /usr/sbin/install # SunOS /usr/etc/install # IRIX /sbin/install # AIX /bin/install # AmigaOS /C/install, which installs bootblocks on floppy discs # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag # AFS /usr/afsws/bin/install, which mishandles nonexistent args # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff" # ./install, which can be erroneously created by make from ./install.sh. echo "$as_me:2034: checking for a BSD compatible install" >&5 echo $ECHO_N "checking for a BSD compatible install... $ECHO_C" >&6 if test -z "$INSTALL"; then if test "${ac_cv_path_install+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else ac_save_IFS=$IFS; IFS=$ac_path_separator for ac_dir in $PATH; do IFS=$ac_save_IFS # Account for people who put trailing slashes in PATH elements. case $ac_dir/ in / | ./ | .// | /cC/* \ | /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* \ | /usr/ucb/* ) ;; *) # OSF1 and SCO ODT 3.0 have their own names for install. # Don't use installbsd from OSF since it installs stuff as root # by default. for ac_prog in ginstall scoinst install; do if $as_executable_p "$ac_dir/$ac_prog"; then if test $ac_prog = install && grep dspmsg "$ac_dir/$ac_prog" >/dev/null 2>&1; then # AIX install. It has an incompatible calling convention. : elif test $ac_prog = install && grep pwplus "$ac_dir/$ac_prog" >/dev/null 2>&1; then # program-specific install script used by HP pwplus--don't use. : else ac_cv_path_install="$ac_dir/$ac_prog -c" break 2 fi fi done ;; esac done fi if test "${ac_cv_path_install+set}" = set; then INSTALL=$ac_cv_path_install else # As a last resort, use the slow shell script. We don't cache a # path for INSTALL within a source directory, because that will # break other packages using the cache if that directory is # removed, or if the path is relative. INSTALL=$ac_install_sh fi fi echo "$as_me:2083: result: $INSTALL" >&5 echo "${ECHO_T}$INSTALL" >&6 # Use test -z because SunOS4 sh mishandles braces in ${var-val}. # It thinks the first close brace ends the variable substitution. test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}' test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}' test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644' case $INSTALL in /*) ;; *) cf_dir=`echo $INSTALL | sed -e 's%/[^/]*$%%'` test -z "$cf_dir" && cf_dir=. INSTALL=`cd $cf_dir && pwd`/`echo $INSTALL | sed -e 's%^.*/%%'` ;; esac echo "$as_me:2104: checking whether ln -s works" >&5 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6 LN_S=$as_ln_s if test "$LN_S" = "ln -s"; then echo "$as_me:2108: result: yes" >&5 echo "${ECHO_T}yes" >&6 else echo "$as_me:2111: result: no, using $LN_S" >&5 echo "${ECHO_T}no, using $LN_S" >&6 fi echo "$as_me:2115: checking if filesystem supports mixed-case filenames" >&5 echo $ECHO_N "checking if filesystem supports mixed-case filenames... $ECHO_C" >&6 if test "${cf_cv_mixedcase+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else if test "$cross_compiling" = yes ; then case $target_alias in #(vi *-os2-emx*|*-msdosdjgpp*|*-cygwin*|*-mingw32*|*-uwin*) #(vi cf_cv_mixedcase=no ;; *) cf_cv_mixedcase=yes ;; esac else rm -f conftest CONFTEST echo test >conftest if test -f CONFTEST ; then cf_cv_mixedcase=no else cf_cv_mixedcase=yes fi rm -f conftest CONFTEST fi fi echo "$as_me:2142: result: $cf_cv_mixedcase" >&5 echo "${ECHO_T}$cf_cv_mixedcase" >&6 test "$cf_cv_mixedcase" = yes && cat >>confdefs.h <<\EOF #define MIXEDCASE_FILENAMES 1 EOF # Extract the first word of "ctags", so it can be a program name with args. set dummy ctags; ac_word=$2 echo "$as_me:2150: checking for $ac_word" >&5 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 if test "${ac_cv_prog_MAKE_LOWER_TAGS+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else if test -n "$MAKE_LOWER_TAGS"; then ac_cv_prog_MAKE_LOWER_TAGS="$MAKE_LOWER_TAGS" # Let the user override the test. else ac_save_IFS=$IFS; IFS=$ac_path_separator ac_dummy="$PATH" for ac_dir in $ac_dummy; do IFS=$ac_save_IFS test -z "$ac_dir" && ac_dir=. $as_executable_p "$ac_dir/$ac_word" || continue ac_cv_prog_MAKE_LOWER_TAGS="yes" echo "$as_me:2165: found $ac_dir/$ac_word" >&5 break done test -z "$ac_cv_prog_MAKE_LOWER_TAGS" && ac_cv_prog_MAKE_LOWER_TAGS="no" fi fi MAKE_LOWER_TAGS=$ac_cv_prog_MAKE_LOWER_TAGS if test -n "$MAKE_LOWER_TAGS"; then echo "$as_me:2174: result: $MAKE_LOWER_TAGS" >&5 echo "${ECHO_T}$MAKE_LOWER_TAGS" >&6 else echo "$as_me:2177: result: no" >&5 echo "${ECHO_T}no" >&6 fi if test "$cf_cv_mixedcase" = yes ; then # Extract the first word of "etags", so it can be a program name with args. set dummy etags; ac_word=$2 echo "$as_me:2184: checking for $ac_word" >&5 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 if test "${ac_cv_prog_MAKE_UPPER_TAGS+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else if test -n "$MAKE_UPPER_TAGS"; then ac_cv_prog_MAKE_UPPER_TAGS="$MAKE_UPPER_TAGS" # Let the user override the test. else ac_save_IFS=$IFS; IFS=$ac_path_separator ac_dummy="$PATH" for ac_dir in $ac_dummy; do IFS=$ac_save_IFS test -z "$ac_dir" && ac_dir=. $as_executable_p "$ac_dir/$ac_word" || continue ac_cv_prog_MAKE_UPPER_TAGS="yes" echo "$as_me:2199: found $ac_dir/$ac_word" >&5 break done test -z "$ac_cv_prog_MAKE_UPPER_TAGS" && ac_cv_prog_MAKE_UPPER_TAGS="no" fi fi MAKE_UPPER_TAGS=$ac_cv_prog_MAKE_UPPER_TAGS if test -n "$MAKE_UPPER_TAGS"; then echo "$as_me:2208: result: $MAKE_UPPER_TAGS" >&5 echo "${ECHO_T}$MAKE_UPPER_TAGS" >&6 else echo "$as_me:2211: result: no" >&5 echo "${ECHO_T}no" >&6 fi else MAKE_UPPER_TAGS=no fi if test "$MAKE_UPPER_TAGS" = yes ; then MAKE_UPPER_TAGS= else MAKE_UPPER_TAGS="#" fi if test "$MAKE_LOWER_TAGS" = yes ; then MAKE_LOWER_TAGS= else MAKE_LOWER_TAGS="#" fi CC_G_OPT="-g" CC_SHARED_OPTS=unknown CPPFLAGS="$CPPFLAGS" DESTDIR="" DFT_DEP_SUFFIX="" DFT_OBJ_SUBDIR=`pwd|sed -e's:.*/::'` DFT_UPR_MODEL="NORMAL" ECHO_LINK='@ echo linking $@ ... ;' EXTRA_LDFLAGS="" LD="ld" LDFLAGS_SHARED="" LD_MODEL="" LD_SHARED_OPTS="" LIBTOOL="" LIB_CLEAN="" LIB_COMPILE="" LIB_INSTALL="" LIB_LINK='$(CC)' LIB_SUFFIX="" LIB_UNINSTALL="" LINK_PROGS="" LINT=lint LINT_OPTS="" LOCAL_LDFLAGS="" MATH_LIB="-lm" TICS_ARGS="" TINFO_ARGS='$(LIBS_CURSES)' cf_cv_abi_version="" cf_cv_rel_version="" NCURSES_TREE="#" cf_cv_screen=curses cf_cv_libtype= echo "$as_me:2266: checking for ${CC-cc} option to accept ANSI C" >&5 echo $ECHO_N "checking for ${CC-cc} option to accept ANSI C... $ECHO_C" >&6 if test "${cf_cv_ansi_cc+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else cf_cv_ansi_cc=no cf_save_CFLAGS="$CFLAGS" cf_save_CPPFLAGS="$CPPFLAGS" # Don't try gcc -ansi; that turns off useful extensions and # breaks some systems' header files. # AIX -qlanglvl=ansi # Ultrix and OSF/1 -std1 # HP-UX -Aa -D_HPUX_SOURCE # SVR4 -Xc # UnixWare 1.2 (cannot use -Xc, since ANSI/POSIX clashes) for cf_arg in "-DCC_HAS_PROTOS" \ "" \ -qlanglvl=ansi \ -std1 \ -Ae \ "-Aa -D_HPUX_SOURCE" \ -Xc do cf_fix_cppflags=no cf_new_cflags= cf_new_cppflags= cf_new_extra_cppflags= for cf_add_cflags in $cf_arg do case $cf_fix_cppflags in no) case $cf_add_cflags in #(vi -undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C) #(vi case $cf_add_cflags in -D*) cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^-D[^=]*='\''\"[^"]*//'` test "${cf_add_cflags}" != "${cf_tst_cflags}" \ && test -z "${cf_tst_cflags}" \ && cf_fix_cppflags=yes if test $cf_fix_cppflags = yes ; then cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags" continue elif test "${cf_tst_cflags}" = "\"'" ; then cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags" continue fi ;; esac case "$CPPFLAGS" in *$cf_add_cflags) #(vi ;; *) #(vi cf_new_cppflags="$cf_new_cppflags $cf_add_cflags" ;; esac ;; *) cf_new_cflags="$cf_new_cflags $cf_add_cflags" ;; esac ;; yes) cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags" cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^[^"]*"'\''//'` test "${cf_add_cflags}" != "${cf_tst_cflags}" \ && test -z "${cf_tst_cflags}" \ && cf_fix_cppflags=no ;; esac done if test -n "$cf_new_cflags" ; then CFLAGS="$CFLAGS $cf_new_cflags" fi if test -n "$cf_new_cppflags" ; then CPPFLAGS="$CPPFLAGS $cf_new_cppflags" fi if test -n "$cf_new_extra_cppflags" ; then EXTRA_CPPFLAGS="$cf_new_extra_cppflags $EXTRA_CPPFLAGS" fi cat >conftest.$ac_ext <<_ACEOF #line 2360 "configure" #include "confdefs.h" #ifndef CC_HAS_PROTOS #if !defined(__STDC__) || (__STDC__ != 1) choke me #endif #endif int main () { int test (int i, double x); struct s1 {int (*f) (int a);}; struct s2 {int (*f) (double a);}; ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (eval echo "$as_me:2381: \"$ac_compile\"") >&5 (eval $ac_compile) 2>&5 ac_status=$? echo "$as_me:2384: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest.$ac_objext' { (eval echo "$as_me:2387: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:2390: \$? = $ac_status" >&5 (exit $ac_status); }; }; then cf_cv_ansi_cc="$cf_arg"; break else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 fi rm -f conftest.$ac_objext conftest.$ac_ext done CFLAGS="$cf_save_CFLAGS" CPPFLAGS="$cf_save_CPPFLAGS" fi echo "$as_me:2403: result: $cf_cv_ansi_cc" >&5 echo "${ECHO_T}$cf_cv_ansi_cc" >&6 if test "$cf_cv_ansi_cc" != "no"; then if test ".$cf_cv_ansi_cc" != ".-DCC_HAS_PROTOS"; then cf_fix_cppflags=no cf_new_cflags= cf_new_cppflags= cf_new_extra_cppflags= for cf_add_cflags in $cf_cv_ansi_cc do case $cf_fix_cppflags in no) case $cf_add_cflags in #(vi -undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C) #(vi case $cf_add_cflags in -D*) cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^-D[^=]*='\''\"[^"]*//'` test "${cf_add_cflags}" != "${cf_tst_cflags}" \ && test -z "${cf_tst_cflags}" \ && cf_fix_cppflags=yes if test $cf_fix_cppflags = yes ; then cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags" continue elif test "${cf_tst_cflags}" = "\"'" ; then cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags" continue fi ;; esac case "$CPPFLAGS" in *$cf_add_cflags) #(vi ;; *) #(vi cf_new_cppflags="$cf_new_cppflags $cf_add_cflags" ;; esac ;; *) cf_new_cflags="$cf_new_cflags $cf_add_cflags" ;; esac ;; yes) cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags" cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^[^"]*"'\''//'` test "${cf_add_cflags}" != "${cf_tst_cflags}" \ && test -z "${cf_tst_cflags}" \ && cf_fix_cppflags=no ;; esac done if test -n "$cf_new_cflags" ; then CFLAGS="$CFLAGS $cf_new_cflags" fi if test -n "$cf_new_cppflags" ; then CPPFLAGS="$CPPFLAGS $cf_new_cppflags" fi if test -n "$cf_new_extra_cppflags" ; then EXTRA_CPPFLAGS="$cf_new_extra_cppflags $EXTRA_CPPFLAGS" fi else cat >>confdefs.h <<\EOF #define CC_HAS_PROTOS 1 EOF fi fi if test "$cf_cv_ansi_cc" = "no"; then { { echo "$as_me:2486: error: Your compiler does not appear to recognize prototypes. You have the following choices: a. adjust your compiler options b. get an up-to-date compiler c. use a wrapper such as unproto" >&5 echo "$as_me: error: Your compiler does not appear to recognize prototypes. You have the following choices: a. adjust your compiler options b. get an up-to-date compiler c. use a wrapper such as unproto" >&2;} { (exit 1); exit 1; }; } fi GCC_VERSION=none if test "$GCC" = yes ; then echo "$as_me:2501: checking version of $CC" >&5 echo $ECHO_N "checking version of $CC... $ECHO_C" >&6 GCC_VERSION="`${CC} --version| sed -e '2,$d' -e 's/^.*(GCC) //' -e 's/^[^0-9.]*//' -e 's/[^0-9.].*//'`" test -z "$GCC_VERSION" && GCC_VERSION=unknown echo "$as_me:2505: result: $GCC_VERSION" >&5 echo "${ECHO_T}$GCC_VERSION" >&6 fi if ( test "$GCC" = yes || test "$GXX" = yes ) then echo "$as_me:2511: checking if you want to turn on gcc warnings" >&5 echo $ECHO_N "checking if you want to turn on gcc warnings... $ECHO_C" >&6 # Check whether --enable-warnings or --disable-warnings was given. if test "${enable_warnings+set}" = set; then enableval="$enable_warnings" test "$enableval" != yes && enableval=no if test "$enableval" != "no" ; then with_warnings=yes else with_warnings=no fi else enableval=no with_warnings=no fi; echo "$as_me:2528: result: $with_warnings" >&5 echo "${ECHO_T}$with_warnings" >&6 if test "$with_warnings" = "yes" then if test "$GCC" = yes then cat > conftest.i <&5 echo "$as_me: checking for $CC __attribute__ directives..." >&6;} cat > conftest.$ac_ext <&5 case $cf_attribute in #(vi printf) #(vi cf_printf_attribute=yes cat >conftest.h <conftest.h <conftest.h <&5 (eval $ac_compile) 2>&5 ac_status=$? echo "$as_me:2606: \$? = $ac_status" >&5 (exit $ac_status); }; then test -n "$verbose" && echo "$as_me:2608: result: ... $cf_attribute" >&5 echo "${ECHO_T}... $cf_attribute" >&6 cat conftest.h >>confdefs.h case $cf_attribute in #(vi printf) #(vi if test "$cf_printf_attribute" = no ; then cat >>confdefs.h <>confdefs.h <>confdefs.h <>confdefs.h <>confdefs.h fi rm -rf conftest* fi INTEL_COMPILER=no if test "$GCC" = yes ; then case $host_os in linux*|gnu*) echo "$as_me:2648: checking if this is really Intel C compiler" >&5 echo $ECHO_N "checking if this is really Intel C compiler... $ECHO_C" >&6 cf_save_CFLAGS="$CFLAGS" CFLAGS="$CFLAGS -no-gcc" cat >conftest.$ac_ext <<_ACEOF #line 2653 "configure" #include "confdefs.h" int main () { #ifdef __INTEL_COMPILER #else make an error #endif ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (eval echo "$as_me:2670: \"$ac_compile\"") >&5 (eval $ac_compile) 2>&5 ac_status=$? echo "$as_me:2673: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest.$ac_objext' { (eval echo "$as_me:2676: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:2679: \$? = $ac_status" >&5 (exit $ac_status); }; }; then INTEL_COMPILER=yes cf_save_CFLAGS="$cf_save_CFLAGS -we147 -no-gcc" else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 fi rm -f conftest.$ac_objext conftest.$ac_ext CFLAGS="$cf_save_CFLAGS" echo "$as_me:2690: result: $INTEL_COMPILER" >&5 echo "${ECHO_T}$INTEL_COMPILER" >&6 ;; esac fi cat > conftest.$ac_ext <&5 echo "$as_me: checking for $CC warning options..." >&6;} cf_save_CFLAGS="$CFLAGS" EXTRA_CFLAGS="-Wall" for cf_opt in \ wd1419 \ wd1683 \ wd1684 \ wd193 \ wd593 \ wd279 \ wd810 \ wd869 \ wd981 do CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt" if { (eval echo "$as_me:2730: \"$ac_compile\"") >&5 (eval $ac_compile) 2>&5 ac_status=$? echo "$as_me:2733: \$? = $ac_status" >&5 (exit $ac_status); }; then test -n "$verbose" && echo "$as_me:2735: result: ... -$cf_opt" >&5 echo "${ECHO_T}... -$cf_opt" >&6 EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt" fi done CFLAGS="$cf_save_CFLAGS" elif test "$GCC" = yes then { echo "$as_me:2744: checking for $CC warning options..." >&5 echo "$as_me: checking for $CC warning options..." >&6;} cf_save_CFLAGS="$CFLAGS" EXTRA_CFLAGS="-W -Wall" cf_warn_CONST="" test "$with_ext_const" = yes && cf_warn_CONST="Wwrite-strings" for cf_opt in \ Wbad-function-cast \ Wcast-align \ Wcast-qual \ Winline \ Wmissing-declarations \ Wmissing-prototypes \ Wnested-externs \ Wpointer-arith \ Wshadow \ Wstrict-prototypes \ Wundef $cf_warn_CONST do CFLAGS="$cf_save_CFLAGS $EXTRA_CFLAGS -$cf_opt" if { (eval echo "$as_me:2764: \"$ac_compile\"") >&5 (eval $ac_compile) 2>&5 ac_status=$? echo "$as_me:2767: \$? = $ac_status" >&5 (exit $ac_status); }; then test -n "$verbose" && echo "$as_me:2769: result: ... -$cf_opt" >&5 echo "${ECHO_T}... -$cf_opt" >&6 case $cf_opt in #(vi Wcast-qual) #(vi CPPFLAGS="$CPPFLAGS -DXTSTRINGDEFINES" ;; Winline) #(vi case $GCC_VERSION in [34].*) test -n "$verbose" && echo " feature is broken in gcc $GCC_VERSION" 1>&6 echo "${as_me-configure}:2780: testing feature is broken in gcc $GCC_VERSION ..." 1>&5 continue;; esac ;; esac EXTRA_CFLAGS="$EXTRA_CFLAGS -$cf_opt" fi done CFLAGS="$cf_save_CFLAGS" fi rm -f conftest* fi fi if test "$GCC" = yes then cat > conftest.i <&5 echo "$as_me: checking for $CC __attribute__ directives..." >&6;} cat > conftest.$ac_ext <&5 case $cf_attribute in #(vi printf) #(vi cf_printf_attribute=yes cat >conftest.h <conftest.h <conftest.h <&5 (eval $ac_compile) 2>&5 ac_status=$? echo "$as_me:2869: \$? = $ac_status" >&5 (exit $ac_status); }; then test -n "$verbose" && echo "$as_me:2871: result: ... $cf_attribute" >&5 echo "${ECHO_T}... $cf_attribute" >&6 cat conftest.h >>confdefs.h case $cf_attribute in #(vi printf) #(vi if test "$cf_printf_attribute" = no ; then cat >>confdefs.h <>confdefs.h <>confdefs.h <>confdefs.h <>confdefs.h fi rm -rf conftest* fi echo "$as_me:2906: checking if $CC -U and -D options work together" >&5 echo $ECHO_N "checking if $CC -U and -D options work together... $ECHO_C" >&6 if test "${cf_cv_cc_u_d_options+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else cf_save_CPPFLAGS="$CPPFLAGS" CPPFLAGS="-UU_D_OPTIONS -DU_D_OPTIONS -DD_U_OPTIONS -UD_U_OPTIONS" cat >conftest.$ac_ext <<_ACEOF #line 2915 "configure" #include "confdefs.h" int main () { #ifndef U_D_OPTIONS make an undefined-error #endif #ifdef D_U_OPTIONS make a defined-error #endif ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (eval echo "$as_me:2934: \"$ac_compile\"") >&5 (eval $ac_compile) 2>&5 ac_status=$? echo "$as_me:2937: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest.$ac_objext' { (eval echo "$as_me:2940: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:2943: \$? = $ac_status" >&5 (exit $ac_status); }; }; then cf_cv_cc_u_d_options=yes else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 cf_cv_cc_u_d_options=no fi rm -f conftest.$ac_objext conftest.$ac_ext CPPFLAGS="$cf_save_CPPFLAGS" fi echo "$as_me:2957: result: $cf_cv_cc_u_d_options" >&5 echo "${ECHO_T}$cf_cv_cc_u_d_options" >&6 cf_XOPEN_SOURCE=500 cf_POSIX_C_SOURCE=199506L case $host_os in #(vi aix[456]*) #(vi CPPFLAGS="$CPPFLAGS -D_ALL_SOURCE" ;; freebsd*|dragonfly*) #(vi # 5.x headers associate # _XOPEN_SOURCE=600 with _POSIX_C_SOURCE=200112L # _XOPEN_SOURCE=500 with _POSIX_C_SOURCE=199506L cf_POSIX_C_SOURCE=200112L cf_XOPEN_SOURCE=600 CPPFLAGS="$CPPFLAGS -D_BSD_TYPES -D__BSD_VISIBLE -D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE" ;; hpux11*) #(vi CPPFLAGS="$CPPFLAGS -D_HPUX_SOURCE -D_XOPEN_SOURCE=500" ;; hpux*) #(vi CPPFLAGS="$CPPFLAGS -D_HPUX_SOURCE" ;; irix[56].*) #(vi CPPFLAGS="$CPPFLAGS -D_SGI_SOURCE" ;; linux*|gnu*|mint*|k*bsd*-gnu) #(vi echo "$as_me:2986: checking if we must define _GNU_SOURCE" >&5 echo $ECHO_N "checking if we must define _GNU_SOURCE... $ECHO_C" >&6 if test "${cf_cv_gnu_source+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else cat >conftest.$ac_ext <<_ACEOF #line 2993 "configure" #include "confdefs.h" #include int main () { #ifndef _XOPEN_SOURCE make an error #endif ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (eval echo "$as_me:3008: \"$ac_compile\"") >&5 (eval $ac_compile) 2>&5 ac_status=$? echo "$as_me:3011: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest.$ac_objext' { (eval echo "$as_me:3014: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:3017: \$? = $ac_status" >&5 (exit $ac_status); }; }; then cf_cv_gnu_source=no else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 cf_save="$CPPFLAGS" CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE" cat >conftest.$ac_ext <<_ACEOF #line 3026 "configure" #include "confdefs.h" #include int main () { #ifdef _XOPEN_SOURCE make an error #endif ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (eval echo "$as_me:3041: \"$ac_compile\"") >&5 (eval $ac_compile) 2>&5 ac_status=$? echo "$as_me:3044: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest.$ac_objext' { (eval echo "$as_me:3047: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:3050: \$? = $ac_status" >&5 (exit $ac_status); }; }; then cf_cv_gnu_source=no else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 cf_cv_gnu_source=yes fi rm -f conftest.$ac_objext conftest.$ac_ext CPPFLAGS="$cf_save" fi rm -f conftest.$ac_objext conftest.$ac_ext fi echo "$as_me:3065: result: $cf_cv_gnu_source" >&5 echo "${ECHO_T}$cf_cv_gnu_source" >&6 test "$cf_cv_gnu_source" = yes && CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE" ;; mirbsd*) #(vi # setting _XOPEN_SOURCE or _POSIX_SOURCE breaks ;; netbsd*) #(vi # setting _XOPEN_SOURCE breaks IPv6 for lynx on NetBSD 1.6, breaks xterm, is not needed for ncursesw ;; openbsd*) #(vi # setting _XOPEN_SOURCE breaks xterm on OpenBSD 2.8, is not needed for ncursesw ;; osf[45]*) #(vi CPPFLAGS="$CPPFLAGS -D_OSF_SOURCE" ;; nto-qnx*) #(vi CPPFLAGS="$CPPFLAGS -D_QNX_SOURCE" ;; sco*) #(vi # setting _XOPEN_SOURCE breaks Lynx on SCO Unix / OpenServer ;; solaris*) #(vi CPPFLAGS="$CPPFLAGS -D__EXTENSIONS__" ;; *) echo "$as_me:3092: checking if we should define _XOPEN_SOURCE" >&5 echo $ECHO_N "checking if we should define _XOPEN_SOURCE... $ECHO_C" >&6 if test "${cf_cv_xopen_source+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else cat >conftest.$ac_ext <<_ACEOF #line 3099 "configure" #include "confdefs.h" #include int main () { #ifndef _XOPEN_SOURCE make an error #endif ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (eval echo "$as_me:3114: \"$ac_compile\"") >&5 (eval $ac_compile) 2>&5 ac_status=$? echo "$as_me:3117: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest.$ac_objext' { (eval echo "$as_me:3120: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:3123: \$? = $ac_status" >&5 (exit $ac_status); }; }; then cf_cv_xopen_source=no else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 cf_save="$CPPFLAGS" CPPFLAGS="$CPPFLAGS -D_XOPEN_SOURCE=$cf_XOPEN_SOURCE" cat >conftest.$ac_ext <<_ACEOF #line 3132 "configure" #include "confdefs.h" #include int main () { #ifdef _XOPEN_SOURCE make an error #endif ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (eval echo "$as_me:3147: \"$ac_compile\"") >&5 (eval $ac_compile) 2>&5 ac_status=$? echo "$as_me:3150: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest.$ac_objext' { (eval echo "$as_me:3153: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:3156: \$? = $ac_status" >&5 (exit $ac_status); }; }; then cf_cv_xopen_source=no else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 cf_cv_xopen_source=$cf_XOPEN_SOURCE fi rm -f conftest.$ac_objext conftest.$ac_ext CPPFLAGS="$cf_save" fi rm -f conftest.$ac_objext conftest.$ac_ext fi echo "$as_me:3171: result: $cf_cv_xopen_source" >&5 echo "${ECHO_T}$cf_cv_xopen_source" >&6 if test "$cf_cv_xopen_source" != no ; then # remove _XOPEN_SOURCE symbol from $CFLAGS CFLAGS=`echo "$CFLAGS" | \ sed -e 's/-[UD]_XOPEN_SOURCE\(=[^ ]*\)\?[ ]/ /g' \ -e 's/-[UD]_XOPEN_SOURCE\(=[^ ]*\)\?$//g'` # remove _XOPEN_SOURCE symbol from $CPPFLAGS CPPFLAGS=`echo "$CPPFLAGS" | \ sed -e 's/-[UD]_XOPEN_SOURCE\(=[^ ]*\)\?[ ]/ /g' \ -e 's/-[UD]_XOPEN_SOURCE\(=[^ ]*\)\?$//g'` test "$cf_cv_cc_u_d_options" = yes && \ CPPFLAGS="$CPPFLAGS -U_XOPEN_SOURCE" CPPFLAGS="$CPPFLAGS -D_XOPEN_SOURCE=$cf_cv_xopen_source" fi cf_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE cf_save_CFLAGS="$CFLAGS" cf_save_CPPFLAGS="$CPPFLAGS" # remove _POSIX_C_SOURCE symbol from $cf_save_CFLAGS cf_trim_CFLAGS=`echo "$cf_save_CFLAGS" | \ sed -e 's/-[UD]_POSIX_C_SOURCE\(=[^ ]*\)\?[ ]/ /g' \ -e 's/-[UD]_POSIX_C_SOURCE\(=[^ ]*\)\?$//g'` # remove _POSIX_C_SOURCE symbol from $cf_save_CPPFLAGS cf_trim_CPPFLAGS=`echo "$cf_save_CPPFLAGS" | \ sed -e 's/-[UD]_POSIX_C_SOURCE\(=[^ ]*\)\?[ ]/ /g' \ -e 's/-[UD]_POSIX_C_SOURCE\(=[^ ]*\)\?$//g'` echo "$as_me:3205: checking if we should define _POSIX_C_SOURCE" >&5 echo $ECHO_N "checking if we should define _POSIX_C_SOURCE... $ECHO_C" >&6 if test "${cf_cv_posix_c_source+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else echo "${as_me-configure}:3211: testing if the symbol is already defined go no further ..." 1>&5 cat >conftest.$ac_ext <<_ACEOF #line 3214 "configure" #include "confdefs.h" #include int main () { #ifndef _POSIX_C_SOURCE make an error #endif ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (eval echo "$as_me:3229: \"$ac_compile\"") >&5 (eval $ac_compile) 2>&5 ac_status=$? echo "$as_me:3232: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest.$ac_objext' { (eval echo "$as_me:3235: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:3238: \$? = $ac_status" >&5 (exit $ac_status); }; }; then cf_cv_posix_c_source=no else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 cf_want_posix_source=no case .$cf_POSIX_C_SOURCE in #(vi .[12]??*) #(vi cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE" ;; .2) #(vi cf_cv_posix_c_source="-D_POSIX_C_SOURCE=$cf_POSIX_C_SOURCE" cf_want_posix_source=yes ;; .*) cf_want_posix_source=yes ;; esac if test "$cf_want_posix_source" = yes ; then cat >conftest.$ac_ext <<_ACEOF #line 3259 "configure" #include "confdefs.h" #include int main () { #ifdef _POSIX_SOURCE make an error #endif ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (eval echo "$as_me:3274: \"$ac_compile\"") >&5 (eval $ac_compile) 2>&5 ac_status=$? echo "$as_me:3277: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest.$ac_objext' { (eval echo "$as_me:3280: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:3283: \$? = $ac_status" >&5 (exit $ac_status); }; }; then : else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 cf_cv_posix_c_source="$cf_cv_posix_c_source -D_POSIX_SOURCE" fi rm -f conftest.$ac_objext conftest.$ac_ext fi echo "${as_me-configure}:3294: testing ifdef from value $cf_POSIX_C_SOURCE ..." 1>&5 CFLAGS="$cf_trim_CFLAGS" CPPFLAGS="$cf_trim_CPPFLAGS $cf_cv_posix_c_source" echo "${as_me-configure}:3299: testing if the second compile does not leave our definition intact error ..." 1>&5 cat >conftest.$ac_ext <<_ACEOF #line 3302 "configure" #include "confdefs.h" #include int main () { #ifndef _POSIX_C_SOURCE make an error #endif ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (eval echo "$as_me:3317: \"$ac_compile\"") >&5 (eval $ac_compile) 2>&5 ac_status=$? echo "$as_me:3320: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest.$ac_objext' { (eval echo "$as_me:3323: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:3326: \$? = $ac_status" >&5 (exit $ac_status); }; }; then : else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 cf_cv_posix_c_source=no fi rm -f conftest.$ac_objext conftest.$ac_ext CFLAGS="$cf_save_CFLAGS" CPPFLAGS="$cf_save_CPPFLAGS" fi rm -f conftest.$ac_objext conftest.$ac_ext fi echo "$as_me:3342: result: $cf_cv_posix_c_source" >&5 echo "${ECHO_T}$cf_cv_posix_c_source" >&6 if test "$cf_cv_posix_c_source" != no ; then CFLAGS="$cf_trim_CFLAGS" CPPFLAGS="$cf_trim_CPPFLAGS" if test "$cf_cv_cc_u_d_options" = yes ; then cf_temp_posix_c_source=`echo "$cf_cv_posix_c_source" | \ sed -e 's/-D/-U/g' -e 's/=[^ ]*//g'` CPPFLAGS="$CPPFLAGS $cf_temp_posix_c_source" fi CPPFLAGS="$CPPFLAGS $cf_cv_posix_c_source" fi ;; esac # Check whether --with-ncursesw or --without-ncursesw was given. if test "${with_ncursesw+set}" = set; then withval="$with_ncursesw" cf_cv_screen=ncursesw else # Check whether --with-ncurses or --without-ncurses was given. if test "${with_ncurses+set}" = set; then withval="$with_ncurses" cf_cv_screen=ncurses fi; fi; case $cf_cv_screen in ncurses) # Check whether --with-curses-dir or --without-curses-dir was given. if test "${with_curses_dir+set}" = set; then withval="$with_curses_dir" if test "x$prefix" != xNONE; then cf_path_syntax="$prefix" else cf_path_syntax="$ac_default_prefix" fi case ".$withval" in #(vi .\$\(*\)*|.\'*\'*) #(vi ;; ..|./*|.\\*) #(vi ;; .[a-zA-Z]:[\\/]*) #(vi OS/2 EMX ;; .\${*prefix}*) #(vi eval withval="$withval" case ".$withval" in #(vi .NONE/*) withval=`echo $withval | sed -e s%NONE%$cf_path_syntax%` ;; esac ;; #(vi .no|.NONE/*) withval=`echo $withval | sed -e s%NONE%$cf_path_syntax%` ;; *) { { echo "$as_me:3404: error: expected a pathname, not \"$withval\"" >&5 echo "$as_me: error: expected a pathname, not \"$withval\"" >&2;} { (exit 1); exit 1; }; } ;; esac cf_cv_curses_dir=$withval else cf_cv_curses_dir=no fi; cf_ncuconfig_root=ncurses echo "Looking for ${cf_ncuconfig_root}-config" for ac_prog in ${cf_ncuconfig_root}6-config ${cf_ncuconfig_root}5-config do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 echo "$as_me:3422: checking for $ac_word" >&5 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 if test "${ac_cv_path_NCURSES_CONFIG+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else case $NCURSES_CONFIG in [\\/]* | ?:[\\/]*) ac_cv_path_NCURSES_CONFIG="$NCURSES_CONFIG" # Let the user override the test with a path. ;; *) ac_save_IFS=$IFS; IFS=$ac_path_separator ac_dummy="$PATH" for ac_dir in $ac_dummy; do IFS=$ac_save_IFS test -z "$ac_dir" && ac_dir=. if $as_executable_p "$ac_dir/$ac_word"; then ac_cv_path_NCURSES_CONFIG="$ac_dir/$ac_word" echo "$as_me:3439: found $ac_dir/$ac_word" >&5 break fi done ;; esac fi NCURSES_CONFIG=$ac_cv_path_NCURSES_CONFIG if test -n "$NCURSES_CONFIG"; then echo "$as_me:3450: result: $NCURSES_CONFIG" >&5 echo "${ECHO_T}$NCURSES_CONFIG" >&6 else echo "$as_me:3453: result: no" >&5 echo "${ECHO_T}no" >&6 fi test -n "$NCURSES_CONFIG" && break done test -n "$NCURSES_CONFIG" || NCURSES_CONFIG="none" if test "$NCURSES_CONFIG" != none ; then cf_cv_ncurses_header=curses.h CPPFLAGS="$CPPFLAGS `$NCURSES_CONFIG --cflags`" LIBS="`$NCURSES_CONFIG --libs` $LIBS" cat >>confdefs.h <<\EOF #define NCURSES 1 EOF cf_nculib_ROOT=`echo "HAVE_LIB$cf_ncuconfig_root" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%` cat >>confdefs.h <conftest.$ac_ext <<_ACEOF #line 3511 "configure" #include "confdefs.h" #include int main () { printf("Hello") ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (eval echo "$as_me:3523: \"$ac_compile\"") >&5 (eval $ac_compile) 2>&5 ac_status=$? echo "$as_me:3526: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest.$ac_objext' { (eval echo "$as_me:3529: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:3532: \$? = $ac_status" >&5 (exit $ac_status); }; }; then : else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 cf_have_incdir=yes fi rm -f conftest.$ac_objext conftest.$ac_ext CPPFLAGS=$cf_save_CPPFLAGS fi fi fi if test "$cf_have_incdir" = no ; then test -n "$verbose" && echo " adding $cf_add_incdir to include-path" 1>&6 echo "${as_me-configure}:3549: testing adding $cf_add_incdir to include-path ..." 1>&5 CPPFLAGS="$CPPFLAGS -I$cf_add_incdir" cf_top_incdir=`echo $cf_add_incdir | sed -e 's%/include/.*$%/include%'` test "$cf_top_incdir" = "$cf_add_incdir" && break cf_add_incdir="$cf_top_incdir" else break fi fi done done fi } echo "$as_me:3566: checking for $cf_ncuhdr_root header in include-path" >&5 echo $ECHO_N "checking for $cf_ncuhdr_root header in include-path... $ECHO_C" >&6 if test "${cf_cv_ncurses_h+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else cf_header_list="$cf_ncuhdr_root/curses.h $cf_ncuhdr_root/ncurses.h" ( test "$cf_ncuhdr_root" = ncurses || test "$cf_ncuhdr_root" = ncursesw ) && cf_header_list="$cf_header_list curses.h ncurses.h" for cf_header in $cf_header_list do cat >conftest.$ac_ext <<_ACEOF #line 3578 "configure" #include "confdefs.h" #include <$cf_header> int main () { #ifdef NCURSES_VERSION printf("%s\n", NCURSES_VERSION); #else #ifdef __NCURSES_H printf("old\n"); #else make an error #endif #endif ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (eval echo "$as_me:3602: \"$ac_compile\"") >&5 (eval $ac_compile) 2>&5 ac_status=$? echo "$as_me:3605: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest.$ac_objext' { (eval echo "$as_me:3608: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:3611: \$? = $ac_status" >&5 (exit $ac_status); }; }; then cf_cv_ncurses_h=$cf_header else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 cf_cv_ncurses_h=no fi rm -f conftest.$ac_objext conftest.$ac_ext test "$cf_cv_ncurses_h" != no && break done fi echo "$as_me:3626: result: $cf_cv_ncurses_h" >&5 echo "${ECHO_T}$cf_cv_ncurses_h" >&6 if test "$cf_cv_ncurses_h" != no ; then cf_cv_ncurses_header=$cf_cv_ncurses_h else echo "$as_me:3633: checking for $cf_ncuhdr_root include-path" >&5 echo $ECHO_N "checking for $cf_ncuhdr_root include-path... $ECHO_C" >&6 if test "${cf_cv_ncurses_h2+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else test -n "$verbose" && echo cf_header_path_list="" if test -n "${CFLAGS}${CPPFLAGS}" ; then for cf_header_path in $CPPFLAGS $CFLAGS do case $cf_header_path in #(vi -I*) cf_header_path=`echo ".$cf_header_path" |sed -e 's/^...//' -e 's,/include$,,'` test "$cf_header_path" != "NONE" && \ test -d "$cf_header_path" && \ { test -n "$verbose" && echo " ... testing for include-directories under $cf_header_path" test -d $cf_header_path/include && cf_search="$cf_search $cf_header_path/include" test -d $cf_header_path/include/$cf_ncuhdr_root && cf_search="$cf_search $cf_header_path/include/$cf_ncuhdr_root" test -d $cf_header_path/include/$cf_ncuhdr_root/include && cf_search="$cf_search $cf_header_path/include/$cf_ncuhdr_root/include" test -d $cf_header_path/$cf_ncuhdr_root/include && cf_search="$cf_search $cf_header_path/$cf_ncuhdr_root/include" test -d $cf_header_path/$cf_ncuhdr_root/include/$cf_ncuhdr_root && cf_search="$cf_search $cf_header_path/$cf_ncuhdr_root/include/$cf_ncuhdr_root" } cf_header_path_list="$cf_header_path_list $cf_search" ;; esac done fi cf_search="" test "/usr" != "$prefix" && \ test -d "/usr" && \ (test $prefix = NONE || test -d $prefix) && { test -n "$verbose" && echo " ... testing for include-directories under /usr" test -d /usr/include && cf_search="$cf_search /usr/include" test -d /usr/include/$cf_ncuhdr_root && cf_search="$cf_search /usr/include/$cf_ncuhdr_root" test -d /usr/include/$cf_ncuhdr_root/include && cf_search="$cf_search /usr/include/$cf_ncuhdr_root/include" test -d /usr/$cf_ncuhdr_root/include && cf_search="$cf_search /usr/$cf_ncuhdr_root/include" test -d /usr/$cf_ncuhdr_root/include/$cf_ncuhdr_root && cf_search="$cf_search /usr/$cf_ncuhdr_root/include/$cf_ncuhdr_root" } test "$prefix" != "NONE" && \ test -d "$prefix" && \ { test -n "$verbose" && echo " ... testing for include-directories under $prefix" test -d $prefix/include && cf_search="$cf_search $prefix/include" test -d $prefix/include/$cf_ncuhdr_root && cf_search="$cf_search $prefix/include/$cf_ncuhdr_root" test -d $prefix/include/$cf_ncuhdr_root/include && cf_search="$cf_search $prefix/include/$cf_ncuhdr_root/include" test -d $prefix/$cf_ncuhdr_root/include && cf_search="$cf_search $prefix/$cf_ncuhdr_root/include" test -d $prefix/$cf_ncuhdr_root/include/$cf_ncuhdr_root && cf_search="$cf_search $prefix/$cf_ncuhdr_root/include/$cf_ncuhdr_root" } test "/usr/local" != "$prefix" && \ test -d "/usr/local" && \ (test $prefix = NONE || test -d $prefix) && { test -n "$verbose" && echo " ... testing for include-directories under /usr/local" test -d /usr/local/include && cf_search="$cf_search /usr/local/include" test -d /usr/local/include/$cf_ncuhdr_root && cf_search="$cf_search /usr/local/include/$cf_ncuhdr_root" test -d /usr/local/include/$cf_ncuhdr_root/include && cf_search="$cf_search /usr/local/include/$cf_ncuhdr_root/include" test -d /usr/local/$cf_ncuhdr_root/include && cf_search="$cf_search /usr/local/$cf_ncuhdr_root/include" test -d /usr/local/$cf_ncuhdr_root/include/$cf_ncuhdr_root && cf_search="$cf_search /usr/local/$cf_ncuhdr_root/include/$cf_ncuhdr_root" } test "/opt" != "$prefix" && \ test -d "/opt" && \ (test $prefix = NONE || test -d $prefix) && { test -n "$verbose" && echo " ... testing for include-directories under /opt" test -d /opt/include && cf_search="$cf_search /opt/include" test -d /opt/include/$cf_ncuhdr_root && cf_search="$cf_search /opt/include/$cf_ncuhdr_root" test -d /opt/include/$cf_ncuhdr_root/include && cf_search="$cf_search /opt/include/$cf_ncuhdr_root/include" test -d /opt/$cf_ncuhdr_root/include && cf_search="$cf_search /opt/$cf_ncuhdr_root/include" test -d /opt/$cf_ncuhdr_root/include/$cf_ncuhdr_root && cf_search="$cf_search /opt/$cf_ncuhdr_root/include/$cf_ncuhdr_root" } test "$HOME" != "$prefix" && \ test -d "$HOME" && \ (test $prefix = NONE || test -d $prefix) && { test -n "$verbose" && echo " ... testing for include-directories under $HOME" test -d $HOME/include && cf_search="$cf_search $HOME/include" test -d $HOME/include/$cf_ncuhdr_root && cf_search="$cf_search $HOME/include/$cf_ncuhdr_root" test -d $HOME/include/$cf_ncuhdr_root/include && cf_search="$cf_search $HOME/include/$cf_ncuhdr_root/include" test -d $HOME/$cf_ncuhdr_root/include && cf_search="$cf_search $HOME/$cf_ncuhdr_root/include" test -d $HOME/$cf_ncuhdr_root/include/$cf_ncuhdr_root && cf_search="$cf_search $HOME/$cf_ncuhdr_root/include/$cf_ncuhdr_root" } test "$includedir" != NONE && \ test "$includedir" != "/usr/include" && \ test -d "$includedir" && { test -d $includedir && cf_search="$cf_search $includedir" test -d $includedir/$cf_ncuhdr_root && cf_search="$cf_search $includedir/$cf_ncuhdr_root" } test "$oldincludedir" != NONE && \ test "$oldincludedir" != "/usr/include" && \ test -d "$oldincludedir" && { test -d $oldincludedir && cf_search="$cf_search $oldincludedir" test -d $oldincludedir/$cf_ncuhdr_root && cf_search="$cf_search $oldincludedir/$cf_ncuhdr_root" } cf_search="$cf_header_path_list $cf_search" test -n "$verbose" && echo search path $cf_search cf_save2_CPPFLAGS="$CPPFLAGS" for cf_incdir in $cf_search do if test -n "$cf_incdir" ; then for cf_add_incdir in $cf_incdir do while test $cf_add_incdir != /usr/include do if test -d $cf_add_incdir then cf_have_incdir=no if test -n "$CFLAGS$CPPFLAGS" ; then # a loop is needed to ensure we can add subdirs of existing dirs for cf_test_incdir in $CFLAGS $CPPFLAGS ; do if test ".$cf_test_incdir" = ".-I$cf_add_incdir" ; then cf_have_incdir=yes; break fi done fi if test "$cf_have_incdir" = no ; then if test "$cf_add_incdir" = /usr/local/include ; then if test "$GCC" = yes then cf_save_CPPFLAGS=$CPPFLAGS CPPFLAGS="$CPPFLAGS -I$cf_add_incdir" cat >conftest.$ac_ext <<_ACEOF #line 3768 "configure" #include "confdefs.h" #include int main () { printf("Hello") ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (eval echo "$as_me:3780: \"$ac_compile\"") >&5 (eval $ac_compile) 2>&5 ac_status=$? echo "$as_me:3783: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest.$ac_objext' { (eval echo "$as_me:3786: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:3789: \$? = $ac_status" >&5 (exit $ac_status); }; }; then : else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 cf_have_incdir=yes fi rm -f conftest.$ac_objext conftest.$ac_ext CPPFLAGS=$cf_save_CPPFLAGS fi fi fi if test "$cf_have_incdir" = no ; then test -n "$verbose" && echo " adding $cf_add_incdir to include-path" 1>&6 echo "${as_me-configure}:3806: testing adding $cf_add_incdir to include-path ..." 1>&5 CPPFLAGS="$CPPFLAGS -I$cf_add_incdir" cf_top_incdir=`echo $cf_add_incdir | sed -e 's%/include/.*$%/include%'` test "$cf_top_incdir" = "$cf_add_incdir" && break cf_add_incdir="$cf_top_incdir" else break fi fi done done fi for cf_header in \ ncurses.h \ curses.h do cat >conftest.$ac_ext <<_ACEOF #line 3827 "configure" #include "confdefs.h" #include <$cf_header> int main () { #ifdef NCURSES_VERSION printf("%s\n", NCURSES_VERSION); #else #ifdef __NCURSES_H printf("old\n"); #else make an error #endif #endif ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (eval echo "$as_me:3851: \"$ac_compile\"") >&5 (eval $ac_compile) 2>&5 ac_status=$? echo "$as_me:3854: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest.$ac_objext' { (eval echo "$as_me:3857: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:3860: \$? = $ac_status" >&5 (exit $ac_status); }; }; then cf_cv_ncurses_h2=$cf_header else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 cf_cv_ncurses_h2=no fi rm -f conftest.$ac_objext conftest.$ac_ext if test "$cf_cv_ncurses_h2" != no ; then cf_cv_ncurses_h2=$cf_incdir/$cf_header test -n "$verbose" && echo $ac_n " ... found $ac_c" 1>&6 break fi test -n "$verbose" && echo " ... tested $cf_incdir/$cf_header" 1>&6 done CPPFLAGS="$cf_save2_CPPFLAGS" test "$cf_cv_ncurses_h2" != no && break done test "$cf_cv_ncurses_h2" = no && { { echo "$as_me:3881: error: not found" >&5 echo "$as_me: error: not found" >&2;} { (exit 1); exit 1; }; } fi echo "$as_me:3886: result: $cf_cv_ncurses_h2" >&5 echo "${ECHO_T}$cf_cv_ncurses_h2" >&6 cf_1st_incdir=`echo $cf_cv_ncurses_h2 | sed -e 's%/[^/]*$%%'` cf_cv_ncurses_header=`basename $cf_cv_ncurses_h2` if test `basename $cf_1st_incdir` = $cf_ncuhdr_root ; then cf_cv_ncurses_header=$cf_ncuhdr_root/$cf_cv_ncurses_header fi if test -n "$cf_1st_incdir" ; then for cf_add_incdir in $cf_1st_incdir do while test $cf_add_incdir != /usr/include do if test -d $cf_add_incdir then cf_have_incdir=no if test -n "$CFLAGS$CPPFLAGS" ; then # a loop is needed to ensure we can add subdirs of existing dirs for cf_test_incdir in $CFLAGS $CPPFLAGS ; do if test ".$cf_test_incdir" = ".-I$cf_add_incdir" ; then cf_have_incdir=yes; break fi done fi if test "$cf_have_incdir" = no ; then if test "$cf_add_incdir" = /usr/local/include ; then if test "$GCC" = yes then cf_save_CPPFLAGS=$CPPFLAGS CPPFLAGS="$CPPFLAGS -I$cf_add_incdir" cat >conftest.$ac_ext <<_ACEOF #line 3919 "configure" #include "confdefs.h" #include int main () { printf("Hello") ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (eval echo "$as_me:3931: \"$ac_compile\"") >&5 (eval $ac_compile) 2>&5 ac_status=$? echo "$as_me:3934: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest.$ac_objext' { (eval echo "$as_me:3937: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:3940: \$? = $ac_status" >&5 (exit $ac_status); }; }; then : else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 cf_have_incdir=yes fi rm -f conftest.$ac_objext conftest.$ac_ext CPPFLAGS=$cf_save_CPPFLAGS fi fi fi if test "$cf_have_incdir" = no ; then test -n "$verbose" && echo " adding $cf_add_incdir to include-path" 1>&6 echo "${as_me-configure}:3957: testing adding $cf_add_incdir to include-path ..." 1>&5 CPPFLAGS="$CPPFLAGS -I$cf_add_incdir" cf_top_incdir=`echo $cf_add_incdir | sed -e 's%/include/.*$%/include%'` test "$cf_top_incdir" = "$cf_add_incdir" && break cf_add_incdir="$cf_top_incdir" else break fi fi done done fi fi # Set definitions to allow ifdef'ing for ncurses.h case $cf_cv_ncurses_header in # (vi *ncurses.h) cat >>confdefs.h <<\EOF #define HAVE_NCURSES_H 1 EOF ;; esac case $cf_cv_ncurses_header in # (vi ncurses/curses.h|ncurses/ncurses.h) cat >>confdefs.h <<\EOF #define HAVE_NCURSES_NCURSES_H 1 EOF ;; ncursesw/curses.h|ncursesw/ncurses.h) cat >>confdefs.h <<\EOF #define HAVE_NCURSESW_NCURSES_H 1 EOF ;; esac echo "$as_me:4000: checking for terminfo header" >&5 echo $ECHO_N "checking for terminfo header... $ECHO_C" >&6 if test "${cf_cv_term_header+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else case ${cf_cv_ncurses_header} in #(vi */ncurses.h|*/ncursesw.h) #(vi cf_term_header=`echo "$cf_cv_ncurses_header" | sed -e 's%ncurses[^.]*\.h$%term.h%'` ;; *) cf_term_header=term.h ;; esac for cf_test in $cf_term_header "ncurses/term.h" "ncursesw/term.h" do cat >conftest.$ac_ext <<_ACEOF #line 4018 "configure" #include "confdefs.h" #include #include <${cf_cv_ncurses_header-curses.h}> #include <$cf_test> int main () { int x = auto_left_margin ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (eval echo "$as_me:4033: \"$ac_compile\"") >&5 (eval $ac_compile) 2>&5 ac_status=$? echo "$as_me:4036: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest.$ac_objext' { (eval echo "$as_me:4039: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:4042: \$? = $ac_status" >&5 (exit $ac_status); }; }; then cf_cv_term_header="$cf_test" else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 cf_cv_term_header=unknown fi rm -f conftest.$ac_objext conftest.$ac_ext test "$cf_cv_term_header" != unknown && break done fi echo "$as_me:4058: result: $cf_cv_term_header" >&5 echo "${ECHO_T}$cf_cv_term_header" >&6 # Set definitions to allow ifdef'ing to accommodate subdirectories case $cf_cv_term_header in # (vi *term.h) cat >>confdefs.h <<\EOF #define HAVE_TERM_H 1 EOF ;; esac case $cf_cv_term_header in # (vi ncurses/term.h) #(vi cat >>confdefs.h <<\EOF #define HAVE_NCURSES_TERM_H 1 EOF ;; ncursesw/term.h) cat >>confdefs.h <<\EOF #define HAVE_NCURSESW_TERM_H 1 EOF ;; esac # some applications need this, but should check for NCURSES_VERSION cat >>confdefs.h <<\EOF #define NCURSES 1 EOF echo "$as_me:4092: checking for ncurses version" >&5 echo $ECHO_N "checking for ncurses version... $ECHO_C" >&6 if test "${cf_cv_ncurses_version+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else cf_cv_ncurses_version=no cf_tempfile=out$$ rm -f $cf_tempfile if test "$cross_compiling" = yes; then # This will not work if the preprocessor splits the line after the # Autoconf token. The 'unproto' program does that. cat > conftest.$ac_ext < #undef Autoconf #ifdef NCURSES_VERSION Autoconf NCURSES_VERSION #else #ifdef __NCURSES_H Autoconf "old" #endif ; #endif EOF cf_try="$ac_cpp conftest.$ac_ext 2>&5 | grep '^Autoconf ' >conftest.out" { (eval echo "$as_me:4118: \"$cf_try\"") >&5 (eval $cf_try) 2>&5 ac_status=$? echo "$as_me:4121: \$? = $ac_status" >&5 (exit $ac_status); } if test -f conftest.out ; then cf_out=`cat conftest.out | sed -e 's%^Autoconf %%' -e 's%^[^"]*"%%' -e 's%".*%%'` test -n "$cf_out" && cf_cv_ncurses_version="$cf_out" rm -f conftest.out fi else cat >conftest.$ac_ext <<_ACEOF #line 4131 "configure" #include "confdefs.h" #include <${cf_cv_ncurses_header-curses.h}> #include int main() { FILE *fp = fopen("$cf_tempfile", "w"); #ifdef NCURSES_VERSION # ifdef NCURSES_VERSION_PATCH fprintf(fp, "%s.%d\n", NCURSES_VERSION, NCURSES_VERSION_PATCH); # else fprintf(fp, "%s\n", NCURSES_VERSION); # endif #else # ifdef __NCURSES_H fprintf(fp, "old\n"); # else make an error # endif #endif ${cf_cv_main_return-return}(0); } _ACEOF rm -f conftest$ac_exeext if { (eval echo "$as_me:4156: \"$ac_link\"") >&5 (eval $ac_link) 2>&5 ac_status=$? echo "$as_me:4159: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='./conftest$ac_exeext' { (eval echo "$as_me:4161: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:4164: \$? = $ac_status" >&5 (exit $ac_status); }; }; then cf_cv_ncurses_version=`cat $cf_tempfile` else echo "$as_me: program exited with status $ac_status" >&5 echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 fi rm -f core core.* *.core conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext fi rm -f $cf_tempfile fi echo "$as_me:4178: result: $cf_cv_ncurses_version" >&5 echo "${ECHO_T}$cf_cv_ncurses_version" >&6 test "$cf_cv_ncurses_version" = no || cat >>confdefs.h <<\EOF #define NCURSES 1 EOF cf_nculib_root=ncurses # This works, except for the special case where we find gpm, but # ncurses is in a nonstandard location via $LIBS, and we really want # to link gpm. cf_ncurses_LIBS="" cf_ncurses_SAVE="$LIBS" echo "$as_me:4190: checking for Gpm_Open in -lgpm" >&5 echo $ECHO_N "checking for Gpm_Open in -lgpm... $ECHO_C" >&6 if test "${ac_cv_lib_gpm_Gpm_Open+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else ac_check_lib_save_LIBS=$LIBS LIBS="-lgpm $LIBS" cat >conftest.$ac_ext <<_ACEOF #line 4198 "configure" #include "confdefs.h" /* Override any gcc2 internal prototype to avoid an error. */ #ifdef __cplusplus extern "C" #endif /* We use char because int might match the return type of a gcc2 builtin and then its argument prototype would still apply. */ char Gpm_Open (); int main () { Gpm_Open (); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (eval echo "$as_me:4217: \"$ac_link\"") >&5 (eval $ac_link) 2>&5 ac_status=$? echo "$as_me:4220: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest$ac_exeext' { (eval echo "$as_me:4223: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:4226: \$? = $ac_status" >&5 (exit $ac_status); }; }; then ac_cv_lib_gpm_Gpm_Open=yes else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 ac_cv_lib_gpm_Gpm_Open=no fi rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi echo "$as_me:4237: result: $ac_cv_lib_gpm_Gpm_Open" >&5 echo "${ECHO_T}$ac_cv_lib_gpm_Gpm_Open" >&6 if test $ac_cv_lib_gpm_Gpm_Open = yes; then echo "$as_me:4240: checking for initscr in -lgpm" >&5 echo $ECHO_N "checking for initscr in -lgpm... $ECHO_C" >&6 if test "${ac_cv_lib_gpm_initscr+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else ac_check_lib_save_LIBS=$LIBS LIBS="-lgpm $LIBS" cat >conftest.$ac_ext <<_ACEOF #line 4248 "configure" #include "confdefs.h" /* Override any gcc2 internal prototype to avoid an error. */ #ifdef __cplusplus extern "C" #endif /* We use char because int might match the return type of a gcc2 builtin and then its argument prototype would still apply. */ char initscr (); int main () { initscr (); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (eval echo "$as_me:4267: \"$ac_link\"") >&5 (eval $ac_link) 2>&5 ac_status=$? echo "$as_me:4270: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest$ac_exeext' { (eval echo "$as_me:4273: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:4276: \$? = $ac_status" >&5 (exit $ac_status); }; }; then ac_cv_lib_gpm_initscr=yes else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 ac_cv_lib_gpm_initscr=no fi rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi echo "$as_me:4287: result: $ac_cv_lib_gpm_initscr" >&5 echo "${ECHO_T}$ac_cv_lib_gpm_initscr" >&6 if test $ac_cv_lib_gpm_initscr = yes; then LIBS="$cf_ncurses_SAVE" else cf_ncurses_LIBS="-lgpm" fi fi case $host_os in #(vi freebsd*) # This is only necessary if you are linking against an obsolete # version of ncurses (but it should do no harm, since it's static). if test "$cf_nculib_root" = ncurses ; then echo "$as_me:4302: checking for tgoto in -lmytinfo" >&5 echo $ECHO_N "checking for tgoto in -lmytinfo... $ECHO_C" >&6 if test "${ac_cv_lib_mytinfo_tgoto+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else ac_check_lib_save_LIBS=$LIBS LIBS="-lmytinfo $LIBS" cat >conftest.$ac_ext <<_ACEOF #line 4310 "configure" #include "confdefs.h" /* Override any gcc2 internal prototype to avoid an error. */ #ifdef __cplusplus extern "C" #endif /* We use char because int might match the return type of a gcc2 builtin and then its argument prototype would still apply. */ char tgoto (); int main () { tgoto (); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (eval echo "$as_me:4329: \"$ac_link\"") >&5 (eval $ac_link) 2>&5 ac_status=$? echo "$as_me:4332: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest$ac_exeext' { (eval echo "$as_me:4335: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:4338: \$? = $ac_status" >&5 (exit $ac_status); }; }; then ac_cv_lib_mytinfo_tgoto=yes else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 ac_cv_lib_mytinfo_tgoto=no fi rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi echo "$as_me:4349: result: $ac_cv_lib_mytinfo_tgoto" >&5 echo "${ECHO_T}$ac_cv_lib_mytinfo_tgoto" >&6 if test $ac_cv_lib_mytinfo_tgoto = yes; then cf_ncurses_LIBS="-lmytinfo $cf_ncurses_LIBS" fi fi ;; esac LIBS="$cf_ncurses_LIBS $LIBS" if ( test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no" ) then if test -n "$cf_cv_curses_dir/lib" ; then for cf_add_libdir in $cf_cv_curses_dir/lib do if test $cf_add_libdir = /usr/lib ; then : elif test -d $cf_add_libdir then cf_have_libdir=no if test -n "$LDFLAGS$LIBS" ; then # a loop is needed to ensure we can add subdirs of existing dirs for cf_test_libdir in $LDFLAGS $LIBS ; do if test ".$cf_test_libdir" = ".-L$cf_add_libdir" ; then cf_have_libdir=yes; break fi done fi if test "$cf_have_libdir" = no ; then test -n "$verbose" && echo " adding $cf_add_libdir to library-path" 1>&6 echo "${as_me-configure}:4383: testing adding $cf_add_libdir to library-path ..." 1>&5 LDFLAGS="-L$cf_add_libdir $LDFLAGS" fi fi done fi LIBS="-l$cf_nculib_root $LIBS" else eval 'cf_cv_have_lib_'$cf_nculib_root'=no' cf_libdir="" echo "$as_me:4396: checking for initscr" >&5 echo $ECHO_N "checking for initscr... $ECHO_C" >&6 if test "${ac_cv_func_initscr+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else cat >conftest.$ac_ext <<_ACEOF #line 4402 "configure" #include "confdefs.h" /* System header to define __stub macros and hopefully few prototypes, which can conflict with char initscr (); below. */ #include /* Override any gcc2 internal prototype to avoid an error. */ #ifdef __cplusplus extern "C" #endif /* We use char because int might match the return type of a gcc2 builtin and then its argument prototype would still apply. */ char initscr (); char (*f) (); int main () { /* The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. */ #if defined (__stub_initscr) || defined (__stub___initscr) choke me #else f = initscr; #endif ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (eval echo "$as_me:4433: \"$ac_link\"") >&5 (eval $ac_link) 2>&5 ac_status=$? echo "$as_me:4436: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest$ac_exeext' { (eval echo "$as_me:4439: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:4442: \$? = $ac_status" >&5 (exit $ac_status); }; }; then ac_cv_func_initscr=yes else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 ac_cv_func_initscr=no fi rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext fi echo "$as_me:4452: result: $ac_cv_func_initscr" >&5 echo "${ECHO_T}$ac_cv_func_initscr" >&6 if test $ac_cv_func_initscr = yes; then eval 'cf_cv_have_lib_'$cf_nculib_root'=yes' else cf_save_LIBS="$LIBS" echo "$as_me:4459: checking for initscr in -l$cf_nculib_root" >&5 echo $ECHO_N "checking for initscr in -l$cf_nculib_root... $ECHO_C" >&6 LIBS="-l$cf_nculib_root $LIBS" cat >conftest.$ac_ext <<_ACEOF #line 4463 "configure" #include "confdefs.h" #include <${cf_cv_ncurses_header-curses.h}> int main () { initscr() ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (eval echo "$as_me:4475: \"$ac_link\"") >&5 (eval $ac_link) 2>&5 ac_status=$? echo "$as_me:4478: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest$ac_exeext' { (eval echo "$as_me:4481: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:4484: \$? = $ac_status" >&5 (exit $ac_status); }; }; then echo "$as_me:4486: result: yes" >&5 echo "${ECHO_T}yes" >&6 eval 'cf_cv_have_lib_'$cf_nculib_root'=yes' else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 echo "$as_me:4493: result: no" >&5 echo "${ECHO_T}no" >&6 cf_library_path_list="" if test -n "${LDFLAGS}${LIBS}" ; then for cf_library_path in $LDFLAGS $LIBS do case $cf_library_path in #(vi -L*) cf_library_path=`echo ".$cf_library_path" |sed -e 's/^...//' -e 's,/lib$,,'` test "$cf_library_path" != "NONE" && \ test -d "$cf_library_path" && \ { test -n "$verbose" && echo " ... testing for lib-directories under $cf_library_path" test -d $cf_library_path/lib && cf_search="$cf_search $cf_library_path/lib" test -d $cf_library_path/lib/$cf_nculib_root && cf_search="$cf_search $cf_library_path/lib/$cf_nculib_root" test -d $cf_library_path/lib/$cf_nculib_root/lib && cf_search="$cf_search $cf_library_path/lib/$cf_nculib_root/lib" test -d $cf_library_path/$cf_nculib_root/lib && cf_search="$cf_search $cf_library_path/$cf_nculib_root/lib" test -d $cf_library_path/$cf_nculib_root/lib/$cf_nculib_root && cf_search="$cf_search $cf_library_path/$cf_nculib_root/lib/$cf_nculib_root" } cf_library_path_list="$cf_library_path_list $cf_search" ;; esac done fi cf_search="" test "/usr" != "$prefix" && \ test -d "/usr" && \ (test $prefix = NONE || test -d $prefix) && { test -n "$verbose" && echo " ... testing for lib-directories under /usr" test -d /usr/lib && cf_search="$cf_search /usr/lib" test -d /usr/lib/$cf_nculib_root && cf_search="$cf_search /usr/lib/$cf_nculib_root" test -d /usr/lib/$cf_nculib_root/lib && cf_search="$cf_search /usr/lib/$cf_nculib_root/lib" test -d /usr/$cf_nculib_root/lib && cf_search="$cf_search /usr/$cf_nculib_root/lib" test -d /usr/$cf_nculib_root/lib/$cf_nculib_root && cf_search="$cf_search /usr/$cf_nculib_root/lib/$cf_nculib_root" } test "$prefix" != "NONE" && \ test -d "$prefix" && \ { test -n "$verbose" && echo " ... testing for lib-directories under $prefix" test -d $prefix/lib && cf_search="$cf_search $prefix/lib" test -d $prefix/lib/$cf_nculib_root && cf_search="$cf_search $prefix/lib/$cf_nculib_root" test -d $prefix/lib/$cf_nculib_root/lib && cf_search="$cf_search $prefix/lib/$cf_nculib_root/lib" test -d $prefix/$cf_nculib_root/lib && cf_search="$cf_search $prefix/$cf_nculib_root/lib" test -d $prefix/$cf_nculib_root/lib/$cf_nculib_root && cf_search="$cf_search $prefix/$cf_nculib_root/lib/$cf_nculib_root" } test "/usr/local" != "$prefix" && \ test -d "/usr/local" && \ (test $prefix = NONE || test -d $prefix) && { test -n "$verbose" && echo " ... testing for lib-directories under /usr/local" test -d /usr/local/lib && cf_search="$cf_search /usr/local/lib" test -d /usr/local/lib/$cf_nculib_root && cf_search="$cf_search /usr/local/lib/$cf_nculib_root" test -d /usr/local/lib/$cf_nculib_root/lib && cf_search="$cf_search /usr/local/lib/$cf_nculib_root/lib" test -d /usr/local/$cf_nculib_root/lib && cf_search="$cf_search /usr/local/$cf_nculib_root/lib" test -d /usr/local/$cf_nculib_root/lib/$cf_nculib_root && cf_search="$cf_search /usr/local/$cf_nculib_root/lib/$cf_nculib_root" } test "/opt" != "$prefix" && \ test -d "/opt" && \ (test $prefix = NONE || test -d $prefix) && { test -n "$verbose" && echo " ... testing for lib-directories under /opt" test -d /opt/lib && cf_search="$cf_search /opt/lib" test -d /opt/lib/$cf_nculib_root && cf_search="$cf_search /opt/lib/$cf_nculib_root" test -d /opt/lib/$cf_nculib_root/lib && cf_search="$cf_search /opt/lib/$cf_nculib_root/lib" test -d /opt/$cf_nculib_root/lib && cf_search="$cf_search /opt/$cf_nculib_root/lib" test -d /opt/$cf_nculib_root/lib/$cf_nculib_root && cf_search="$cf_search /opt/$cf_nculib_root/lib/$cf_nculib_root" } test "$HOME" != "$prefix" && \ test -d "$HOME" && \ (test $prefix = NONE || test -d $prefix) && { test -n "$verbose" && echo " ... testing for lib-directories under $HOME" test -d $HOME/lib && cf_search="$cf_search $HOME/lib" test -d $HOME/lib/$cf_nculib_root && cf_search="$cf_search $HOME/lib/$cf_nculib_root" test -d $HOME/lib/$cf_nculib_root/lib && cf_search="$cf_search $HOME/lib/$cf_nculib_root/lib" test -d $HOME/$cf_nculib_root/lib && cf_search="$cf_search $HOME/$cf_nculib_root/lib" test -d $HOME/$cf_nculib_root/lib/$cf_nculib_root && cf_search="$cf_search $HOME/$cf_nculib_root/lib/$cf_nculib_root" } cf_search="$cf_library_path_list $cf_search" for cf_libdir in $cf_search do echo "$as_me:4582: checking for -l$cf_nculib_root in $cf_libdir" >&5 echo $ECHO_N "checking for -l$cf_nculib_root in $cf_libdir... $ECHO_C" >&6 LIBS="-L$cf_libdir -l$cf_nculib_root $cf_save_LIBS" cat >conftest.$ac_ext <<_ACEOF #line 4586 "configure" #include "confdefs.h" #include <${cf_cv_ncurses_header-curses.h}> int main () { initscr() ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (eval echo "$as_me:4598: \"$ac_link\"") >&5 (eval $ac_link) 2>&5 ac_status=$? echo "$as_me:4601: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest$ac_exeext' { (eval echo "$as_me:4604: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:4607: \$? = $ac_status" >&5 (exit $ac_status); }; }; then echo "$as_me:4609: result: yes" >&5 echo "${ECHO_T}yes" >&6 eval 'cf_cv_have_lib_'$cf_nculib_root'=yes' break else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 echo "$as_me:4616: result: no" >&5 echo "${ECHO_T}no" >&6 LIBS="$cf_save_LIBS" fi rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext done fi rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext fi eval 'cf_found_library=$cf_cv_have_lib_'$cf_nculib_root if test $cf_found_library = no ; then { { echo "$as_me:4631: error: Cannot link $cf_nculib_root library" >&5 echo "$as_me: error: Cannot link $cf_nculib_root library" >&2;} { (exit 1); exit 1; }; } fi fi if test -n "$cf_ncurses_LIBS" ; then echo "$as_me:4639: checking if we can link $cf_nculib_root without $cf_ncurses_LIBS" >&5 echo $ECHO_N "checking if we can link $cf_nculib_root without $cf_ncurses_LIBS... $ECHO_C" >&6 cf_ncurses_SAVE="$LIBS" for p in $cf_ncurses_LIBS ; do q=`echo $LIBS | sed -e "s%$p %%" -e "s%$p$%%"` if test "$q" != "$LIBS" ; then LIBS="$q" fi done cat >conftest.$ac_ext <<_ACEOF #line 4649 "configure" #include "confdefs.h" #include <${cf_cv_ncurses_header-curses.h}> int main () { initscr(); mousemask(0,0); tgoto((char *)0, 0, 0); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (eval echo "$as_me:4661: \"$ac_link\"") >&5 (eval $ac_link) 2>&5 ac_status=$? echo "$as_me:4664: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest$ac_exeext' { (eval echo "$as_me:4667: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:4670: \$? = $ac_status" >&5 (exit $ac_status); }; }; then echo "$as_me:4672: result: yes" >&5 echo "${ECHO_T}yes" >&6 else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 echo "$as_me:4677: result: no" >&5 echo "${ECHO_T}no" >&6 LIBS="$cf_ncurses_SAVE" fi rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext fi cf_nculib_ROOT=`echo "HAVE_LIB$cf_nculib_root" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%` cat >>confdefs.h <&5 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 if test "${ac_cv_path_NCURSES_CONFIG+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else case $NCURSES_CONFIG in [\\/]* | ?:[\\/]*) ac_cv_path_NCURSES_CONFIG="$NCURSES_CONFIG" # Let the user override the test with a path. ;; *) ac_save_IFS=$IFS; IFS=$ac_path_separator ac_dummy="$PATH" for ac_dir in $ac_dummy; do IFS=$ac_save_IFS test -z "$ac_dir" && ac_dir=. if $as_executable_p "$ac_dir/$ac_word"; then ac_cv_path_NCURSES_CONFIG="$ac_dir/$ac_word" echo "$as_me:4720: found $ac_dir/$ac_word" >&5 break fi done ;; esac fi NCURSES_CONFIG=$ac_cv_path_NCURSES_CONFIG if test -n "$NCURSES_CONFIG"; then echo "$as_me:4731: result: $NCURSES_CONFIG" >&5 echo "${ECHO_T}$NCURSES_CONFIG" >&6 else echo "$as_me:4734: result: no" >&5 echo "${ECHO_T}no" >&6 fi test -n "$NCURSES_CONFIG" && break done test -n "$NCURSES_CONFIG" || NCURSES_CONFIG="none" if test "$NCURSES_CONFIG" != none ; then cf_cv_ncurses_header=curses.h CPPFLAGS="$CPPFLAGS `$NCURSES_CONFIG --cflags`" LIBS="`$NCURSES_CONFIG --libs` $LIBS" cat >>confdefs.h <<\EOF #define NCURSES 1 EOF cf_nculib_ROOT=`echo "HAVE_LIB$cf_ncuconfig_root" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%` cat >>confdefs.h <conftest.$ac_ext <<_ACEOF #line 4792 "configure" #include "confdefs.h" #include int main () { printf("Hello") ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (eval echo "$as_me:4804: \"$ac_compile\"") >&5 (eval $ac_compile) 2>&5 ac_status=$? echo "$as_me:4807: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest.$ac_objext' { (eval echo "$as_me:4810: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:4813: \$? = $ac_status" >&5 (exit $ac_status); }; }; then : else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 cf_have_incdir=yes fi rm -f conftest.$ac_objext conftest.$ac_ext CPPFLAGS=$cf_save_CPPFLAGS fi fi fi if test "$cf_have_incdir" = no ; then test -n "$verbose" && echo " adding $cf_add_incdir to include-path" 1>&6 echo "${as_me-configure}:4830: testing adding $cf_add_incdir to include-path ..." 1>&5 CPPFLAGS="$CPPFLAGS -I$cf_add_incdir" cf_top_incdir=`echo $cf_add_incdir | sed -e 's%/include/.*$%/include%'` test "$cf_top_incdir" = "$cf_add_incdir" && break cf_add_incdir="$cf_top_incdir" else break fi fi done done fi } echo "$as_me:4847: checking for $cf_ncuhdr_root header in include-path" >&5 echo $ECHO_N "checking for $cf_ncuhdr_root header in include-path... $ECHO_C" >&6 if test "${cf_cv_ncurses_h+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else cf_header_list="$cf_ncuhdr_root/curses.h $cf_ncuhdr_root/ncurses.h" ( test "$cf_ncuhdr_root" = ncurses || test "$cf_ncuhdr_root" = ncursesw ) && cf_header_list="$cf_header_list curses.h ncurses.h" for cf_header in $cf_header_list do cat >conftest.$ac_ext <<_ACEOF #line 4859 "configure" #include "confdefs.h" #define _XOPEN_SOURCE_EXTENDED #undef HAVE_LIBUTF8_H /* in case we used CF_UTF8_LIB */ #define HAVE_LIBUTF8_H /* to force ncurses' header file to use cchar_t */ #include <$cf_header> int main () { #ifdef NCURSES_VERSION #ifndef WACS_BSSB make an error #endif printf("%s\n", NCURSES_VERSION); #else #ifdef __NCURSES_H printf("old\n"); #else make an error #endif #endif ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (eval echo "$as_me:4891: \"$ac_compile\"") >&5 (eval $ac_compile) 2>&5 ac_status=$? echo "$as_me:4894: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest.$ac_objext' { (eval echo "$as_me:4897: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:4900: \$? = $ac_status" >&5 (exit $ac_status); }; }; then cf_cv_ncurses_h=$cf_header else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 cf_cv_ncurses_h=no fi rm -f conftest.$ac_objext conftest.$ac_ext test "$cf_cv_ncurses_h" != no && break done fi echo "$as_me:4915: result: $cf_cv_ncurses_h" >&5 echo "${ECHO_T}$cf_cv_ncurses_h" >&6 if test "$cf_cv_ncurses_h" != no ; then cf_cv_ncurses_header=$cf_cv_ncurses_h else echo "$as_me:4922: checking for $cf_ncuhdr_root include-path" >&5 echo $ECHO_N "checking for $cf_ncuhdr_root include-path... $ECHO_C" >&6 if test "${cf_cv_ncurses_h2+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else test -n "$verbose" && echo cf_header_path_list="" if test -n "${CFLAGS}${CPPFLAGS}" ; then for cf_header_path in $CPPFLAGS $CFLAGS do case $cf_header_path in #(vi -I*) cf_header_path=`echo ".$cf_header_path" |sed -e 's/^...//' -e 's,/include$,,'` test "$cf_header_path" != "NONE" && \ test -d "$cf_header_path" && \ { test -n "$verbose" && echo " ... testing for include-directories under $cf_header_path" test -d $cf_header_path/include && cf_search="$cf_search $cf_header_path/include" test -d $cf_header_path/include/$cf_ncuhdr_root && cf_search="$cf_search $cf_header_path/include/$cf_ncuhdr_root" test -d $cf_header_path/include/$cf_ncuhdr_root/include && cf_search="$cf_search $cf_header_path/include/$cf_ncuhdr_root/include" test -d $cf_header_path/$cf_ncuhdr_root/include && cf_search="$cf_search $cf_header_path/$cf_ncuhdr_root/include" test -d $cf_header_path/$cf_ncuhdr_root/include/$cf_ncuhdr_root && cf_search="$cf_search $cf_header_path/$cf_ncuhdr_root/include/$cf_ncuhdr_root" } cf_header_path_list="$cf_header_path_list $cf_search" ;; esac done fi cf_search="" test "/usr" != "$prefix" && \ test -d "/usr" && \ (test $prefix = NONE || test -d $prefix) && { test -n "$verbose" && echo " ... testing for include-directories under /usr" test -d /usr/include && cf_search="$cf_search /usr/include" test -d /usr/include/$cf_ncuhdr_root && cf_search="$cf_search /usr/include/$cf_ncuhdr_root" test -d /usr/include/$cf_ncuhdr_root/include && cf_search="$cf_search /usr/include/$cf_ncuhdr_root/include" test -d /usr/$cf_ncuhdr_root/include && cf_search="$cf_search /usr/$cf_ncuhdr_root/include" test -d /usr/$cf_ncuhdr_root/include/$cf_ncuhdr_root && cf_search="$cf_search /usr/$cf_ncuhdr_root/include/$cf_ncuhdr_root" } test "$prefix" != "NONE" && \ test -d "$prefix" && \ { test -n "$verbose" && echo " ... testing for include-directories under $prefix" test -d $prefix/include && cf_search="$cf_search $prefix/include" test -d $prefix/include/$cf_ncuhdr_root && cf_search="$cf_search $prefix/include/$cf_ncuhdr_root" test -d $prefix/include/$cf_ncuhdr_root/include && cf_search="$cf_search $prefix/include/$cf_ncuhdr_root/include" test -d $prefix/$cf_ncuhdr_root/include && cf_search="$cf_search $prefix/$cf_ncuhdr_root/include" test -d $prefix/$cf_ncuhdr_root/include/$cf_ncuhdr_root && cf_search="$cf_search $prefix/$cf_ncuhdr_root/include/$cf_ncuhdr_root" } test "/usr/local" != "$prefix" && \ test -d "/usr/local" && \ (test $prefix = NONE || test -d $prefix) && { test -n "$verbose" && echo " ... testing for include-directories under /usr/local" test -d /usr/local/include && cf_search="$cf_search /usr/local/include" test -d /usr/local/include/$cf_ncuhdr_root && cf_search="$cf_search /usr/local/include/$cf_ncuhdr_root" test -d /usr/local/include/$cf_ncuhdr_root/include && cf_search="$cf_search /usr/local/include/$cf_ncuhdr_root/include" test -d /usr/local/$cf_ncuhdr_root/include && cf_search="$cf_search /usr/local/$cf_ncuhdr_root/include" test -d /usr/local/$cf_ncuhdr_root/include/$cf_ncuhdr_root && cf_search="$cf_search /usr/local/$cf_ncuhdr_root/include/$cf_ncuhdr_root" } test "/opt" != "$prefix" && \ test -d "/opt" && \ (test $prefix = NONE || test -d $prefix) && { test -n "$verbose" && echo " ... testing for include-directories under /opt" test -d /opt/include && cf_search="$cf_search /opt/include" test -d /opt/include/$cf_ncuhdr_root && cf_search="$cf_search /opt/include/$cf_ncuhdr_root" test -d /opt/include/$cf_ncuhdr_root/include && cf_search="$cf_search /opt/include/$cf_ncuhdr_root/include" test -d /opt/$cf_ncuhdr_root/include && cf_search="$cf_search /opt/$cf_ncuhdr_root/include" test -d /opt/$cf_ncuhdr_root/include/$cf_ncuhdr_root && cf_search="$cf_search /opt/$cf_ncuhdr_root/include/$cf_ncuhdr_root" } test "$HOME" != "$prefix" && \ test -d "$HOME" && \ (test $prefix = NONE || test -d $prefix) && { test -n "$verbose" && echo " ... testing for include-directories under $HOME" test -d $HOME/include && cf_search="$cf_search $HOME/include" test -d $HOME/include/$cf_ncuhdr_root && cf_search="$cf_search $HOME/include/$cf_ncuhdr_root" test -d $HOME/include/$cf_ncuhdr_root/include && cf_search="$cf_search $HOME/include/$cf_ncuhdr_root/include" test -d $HOME/$cf_ncuhdr_root/include && cf_search="$cf_search $HOME/$cf_ncuhdr_root/include" test -d $HOME/$cf_ncuhdr_root/include/$cf_ncuhdr_root && cf_search="$cf_search $HOME/$cf_ncuhdr_root/include/$cf_ncuhdr_root" } test "$includedir" != NONE && \ test "$includedir" != "/usr/include" && \ test -d "$includedir" && { test -d $includedir && cf_search="$cf_search $includedir" test -d $includedir/$cf_ncuhdr_root && cf_search="$cf_search $includedir/$cf_ncuhdr_root" } test "$oldincludedir" != NONE && \ test "$oldincludedir" != "/usr/include" && \ test -d "$oldincludedir" && { test -d $oldincludedir && cf_search="$cf_search $oldincludedir" test -d $oldincludedir/$cf_ncuhdr_root && cf_search="$cf_search $oldincludedir/$cf_ncuhdr_root" } cf_search="$cf_header_path_list $cf_search" test -n "$verbose" && echo search path $cf_search cf_save2_CPPFLAGS="$CPPFLAGS" for cf_incdir in $cf_search do if test -n "$cf_incdir" ; then for cf_add_incdir in $cf_incdir do while test $cf_add_incdir != /usr/include do if test -d $cf_add_incdir then cf_have_incdir=no if test -n "$CFLAGS$CPPFLAGS" ; then # a loop is needed to ensure we can add subdirs of existing dirs for cf_test_incdir in $CFLAGS $CPPFLAGS ; do if test ".$cf_test_incdir" = ".-I$cf_add_incdir" ; then cf_have_incdir=yes; break fi done fi if test "$cf_have_incdir" = no ; then if test "$cf_add_incdir" = /usr/local/include ; then if test "$GCC" = yes then cf_save_CPPFLAGS=$CPPFLAGS CPPFLAGS="$CPPFLAGS -I$cf_add_incdir" cat >conftest.$ac_ext <<_ACEOF #line 5057 "configure" #include "confdefs.h" #include int main () { printf("Hello") ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (eval echo "$as_me:5069: \"$ac_compile\"") >&5 (eval $ac_compile) 2>&5 ac_status=$? echo "$as_me:5072: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest.$ac_objext' { (eval echo "$as_me:5075: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:5078: \$? = $ac_status" >&5 (exit $ac_status); }; }; then : else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 cf_have_incdir=yes fi rm -f conftest.$ac_objext conftest.$ac_ext CPPFLAGS=$cf_save_CPPFLAGS fi fi fi if test "$cf_have_incdir" = no ; then test -n "$verbose" && echo " adding $cf_add_incdir to include-path" 1>&6 echo "${as_me-configure}:5095: testing adding $cf_add_incdir to include-path ..." 1>&5 CPPFLAGS="$CPPFLAGS -I$cf_add_incdir" cf_top_incdir=`echo $cf_add_incdir | sed -e 's%/include/.*$%/include%'` test "$cf_top_incdir" = "$cf_add_incdir" && break cf_add_incdir="$cf_top_incdir" else break fi fi done done fi for cf_header in \ ncurses.h \ curses.h do cat >conftest.$ac_ext <<_ACEOF #line 5116 "configure" #include "confdefs.h" #include <$cf_header> int main () { #ifdef NCURSES_VERSION printf("%s\n", NCURSES_VERSION); #else #ifdef __NCURSES_H printf("old\n"); #else make an error #endif #endif ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (eval echo "$as_me:5140: \"$ac_compile\"") >&5 (eval $ac_compile) 2>&5 ac_status=$? echo "$as_me:5143: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest.$ac_objext' { (eval echo "$as_me:5146: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:5149: \$? = $ac_status" >&5 (exit $ac_status); }; }; then cf_cv_ncurses_h2=$cf_header else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 cf_cv_ncurses_h2=no fi rm -f conftest.$ac_objext conftest.$ac_ext if test "$cf_cv_ncurses_h2" != no ; then cf_cv_ncurses_h2=$cf_incdir/$cf_header test -n "$verbose" && echo $ac_n " ... found $ac_c" 1>&6 break fi test -n "$verbose" && echo " ... tested $cf_incdir/$cf_header" 1>&6 done CPPFLAGS="$cf_save2_CPPFLAGS" test "$cf_cv_ncurses_h2" != no && break done test "$cf_cv_ncurses_h2" = no && { { echo "$as_me:5170: error: not found" >&5 echo "$as_me: error: not found" >&2;} { (exit 1); exit 1; }; } fi echo "$as_me:5175: result: $cf_cv_ncurses_h2" >&5 echo "${ECHO_T}$cf_cv_ncurses_h2" >&6 cf_1st_incdir=`echo $cf_cv_ncurses_h2 | sed -e 's%/[^/]*$%%'` cf_cv_ncurses_header=`basename $cf_cv_ncurses_h2` if test `basename $cf_1st_incdir` = $cf_ncuhdr_root ; then cf_cv_ncurses_header=$cf_ncuhdr_root/$cf_cv_ncurses_header fi if test -n "$cf_1st_incdir" ; then for cf_add_incdir in $cf_1st_incdir do while test $cf_add_incdir != /usr/include do if test -d $cf_add_incdir then cf_have_incdir=no if test -n "$CFLAGS$CPPFLAGS" ; then # a loop is needed to ensure we can add subdirs of existing dirs for cf_test_incdir in $CFLAGS $CPPFLAGS ; do if test ".$cf_test_incdir" = ".-I$cf_add_incdir" ; then cf_have_incdir=yes; break fi done fi if test "$cf_have_incdir" = no ; then if test "$cf_add_incdir" = /usr/local/include ; then if test "$GCC" = yes then cf_save_CPPFLAGS=$CPPFLAGS CPPFLAGS="$CPPFLAGS -I$cf_add_incdir" cat >conftest.$ac_ext <<_ACEOF #line 5208 "configure" #include "confdefs.h" #include int main () { printf("Hello") ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (eval echo "$as_me:5220: \"$ac_compile\"") >&5 (eval $ac_compile) 2>&5 ac_status=$? echo "$as_me:5223: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest.$ac_objext' { (eval echo "$as_me:5226: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:5229: \$? = $ac_status" >&5 (exit $ac_status); }; }; then : else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 cf_have_incdir=yes fi rm -f conftest.$ac_objext conftest.$ac_ext CPPFLAGS=$cf_save_CPPFLAGS fi fi fi if test "$cf_have_incdir" = no ; then test -n "$verbose" && echo " adding $cf_add_incdir to include-path" 1>&6 echo "${as_me-configure}:5246: testing adding $cf_add_incdir to include-path ..." 1>&5 CPPFLAGS="$CPPFLAGS -I$cf_add_incdir" cf_top_incdir=`echo $cf_add_incdir | sed -e 's%/include/.*$%/include%'` test "$cf_top_incdir" = "$cf_add_incdir" && break cf_add_incdir="$cf_top_incdir" else break fi fi done done fi fi # Set definitions to allow ifdef'ing for ncurses.h case $cf_cv_ncurses_header in # (vi *ncurses.h) cat >>confdefs.h <<\EOF #define HAVE_NCURSES_H 1 EOF ;; esac case $cf_cv_ncurses_header in # (vi ncurses/curses.h|ncurses/ncurses.h) cat >>confdefs.h <<\EOF #define HAVE_NCURSES_NCURSES_H 1 EOF ;; ncursesw/curses.h|ncursesw/ncurses.h) cat >>confdefs.h <<\EOF #define HAVE_NCURSESW_NCURSES_H 1 EOF ;; esac echo "$as_me:5289: checking for terminfo header" >&5 echo $ECHO_N "checking for terminfo header... $ECHO_C" >&6 if test "${cf_cv_term_header+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else case ${cf_cv_ncurses_header} in #(vi */ncurses.h|*/ncursesw.h) #(vi cf_term_header=`echo "$cf_cv_ncurses_header" | sed -e 's%ncurses[^.]*\.h$%term.h%'` ;; *) cf_term_header=term.h ;; esac for cf_test in $cf_term_header "ncurses/term.h" "ncursesw/term.h" do cat >conftest.$ac_ext <<_ACEOF #line 5307 "configure" #include "confdefs.h" #include #include <${cf_cv_ncurses_header-curses.h}> #include <$cf_test> int main () { int x = auto_left_margin ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (eval echo "$as_me:5322: \"$ac_compile\"") >&5 (eval $ac_compile) 2>&5 ac_status=$? echo "$as_me:5325: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest.$ac_objext' { (eval echo "$as_me:5328: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:5331: \$? = $ac_status" >&5 (exit $ac_status); }; }; then cf_cv_term_header="$cf_test" else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 cf_cv_term_header=unknown fi rm -f conftest.$ac_objext conftest.$ac_ext test "$cf_cv_term_header" != unknown && break done fi echo "$as_me:5347: result: $cf_cv_term_header" >&5 echo "${ECHO_T}$cf_cv_term_header" >&6 # Set definitions to allow ifdef'ing to accommodate subdirectories case $cf_cv_term_header in # (vi *term.h) cat >>confdefs.h <<\EOF #define HAVE_TERM_H 1 EOF ;; esac case $cf_cv_term_header in # (vi ncurses/term.h) #(vi cat >>confdefs.h <<\EOF #define HAVE_NCURSES_TERM_H 1 EOF ;; ncursesw/term.h) cat >>confdefs.h <<\EOF #define HAVE_NCURSESW_TERM_H 1 EOF ;; esac # some applications need this, but should check for NCURSES_VERSION cat >>confdefs.h <<\EOF #define NCURSES 1 EOF echo "$as_me:5381: checking for ncurses version" >&5 echo $ECHO_N "checking for ncurses version... $ECHO_C" >&6 if test "${cf_cv_ncurses_version+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else cf_cv_ncurses_version=no cf_tempfile=out$$ rm -f $cf_tempfile if test "$cross_compiling" = yes; then # This will not work if the preprocessor splits the line after the # Autoconf token. The 'unproto' program does that. cat > conftest.$ac_ext < #undef Autoconf #ifdef NCURSES_VERSION Autoconf NCURSES_VERSION #else #ifdef __NCURSES_H Autoconf "old" #endif ; #endif EOF cf_try="$ac_cpp conftest.$ac_ext 2>&5 | grep '^Autoconf ' >conftest.out" { (eval echo "$as_me:5407: \"$cf_try\"") >&5 (eval $cf_try) 2>&5 ac_status=$? echo "$as_me:5410: \$? = $ac_status" >&5 (exit $ac_status); } if test -f conftest.out ; then cf_out=`cat conftest.out | sed -e 's%^Autoconf %%' -e 's%^[^"]*"%%' -e 's%".*%%'` test -n "$cf_out" && cf_cv_ncurses_version="$cf_out" rm -f conftest.out fi else cat >conftest.$ac_ext <<_ACEOF #line 5420 "configure" #include "confdefs.h" #include <${cf_cv_ncurses_header-curses.h}> #include int main() { FILE *fp = fopen("$cf_tempfile", "w"); #ifdef NCURSES_VERSION # ifdef NCURSES_VERSION_PATCH fprintf(fp, "%s.%d\n", NCURSES_VERSION, NCURSES_VERSION_PATCH); # else fprintf(fp, "%s\n", NCURSES_VERSION); # endif #else # ifdef __NCURSES_H fprintf(fp, "old\n"); # else make an error # endif #endif ${cf_cv_main_return-return}(0); } _ACEOF rm -f conftest$ac_exeext if { (eval echo "$as_me:5445: \"$ac_link\"") >&5 (eval $ac_link) 2>&5 ac_status=$? echo "$as_me:5448: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='./conftest$ac_exeext' { (eval echo "$as_me:5450: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:5453: \$? = $ac_status" >&5 (exit $ac_status); }; }; then cf_cv_ncurses_version=`cat $cf_tempfile` else echo "$as_me: program exited with status $ac_status" >&5 echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 fi rm -f core core.* *.core conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext fi rm -f $cf_tempfile fi echo "$as_me:5467: result: $cf_cv_ncurses_version" >&5 echo "${ECHO_T}$cf_cv_ncurses_version" >&6 test "$cf_cv_ncurses_version" = no || cat >>confdefs.h <<\EOF #define NCURSES 1 EOF cf_nculib_root=ncursesw # This works, except for the special case where we find gpm, but # ncurses is in a nonstandard location via $LIBS, and we really want # to link gpm. cf_ncurses_LIBS="" cf_ncurses_SAVE="$LIBS" echo "$as_me:5479: checking for Gpm_Open in -lgpm" >&5 echo $ECHO_N "checking for Gpm_Open in -lgpm... $ECHO_C" >&6 if test "${ac_cv_lib_gpm_Gpm_Open+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else ac_check_lib_save_LIBS=$LIBS LIBS="-lgpm $LIBS" cat >conftest.$ac_ext <<_ACEOF #line 5487 "configure" #include "confdefs.h" /* Override any gcc2 internal prototype to avoid an error. */ #ifdef __cplusplus extern "C" #endif /* We use char because int might match the return type of a gcc2 builtin and then its argument prototype would still apply. */ char Gpm_Open (); int main () { Gpm_Open (); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (eval echo "$as_me:5506: \"$ac_link\"") >&5 (eval $ac_link) 2>&5 ac_status=$? echo "$as_me:5509: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest$ac_exeext' { (eval echo "$as_me:5512: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:5515: \$? = $ac_status" >&5 (exit $ac_status); }; }; then ac_cv_lib_gpm_Gpm_Open=yes else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 ac_cv_lib_gpm_Gpm_Open=no fi rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi echo "$as_me:5526: result: $ac_cv_lib_gpm_Gpm_Open" >&5 echo "${ECHO_T}$ac_cv_lib_gpm_Gpm_Open" >&6 if test $ac_cv_lib_gpm_Gpm_Open = yes; then echo "$as_me:5529: checking for initscr in -lgpm" >&5 echo $ECHO_N "checking for initscr in -lgpm... $ECHO_C" >&6 if test "${ac_cv_lib_gpm_initscr+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else ac_check_lib_save_LIBS=$LIBS LIBS="-lgpm $LIBS" cat >conftest.$ac_ext <<_ACEOF #line 5537 "configure" #include "confdefs.h" /* Override any gcc2 internal prototype to avoid an error. */ #ifdef __cplusplus extern "C" #endif /* We use char because int might match the return type of a gcc2 builtin and then its argument prototype would still apply. */ char initscr (); int main () { initscr (); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (eval echo "$as_me:5556: \"$ac_link\"") >&5 (eval $ac_link) 2>&5 ac_status=$? echo "$as_me:5559: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest$ac_exeext' { (eval echo "$as_me:5562: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:5565: \$? = $ac_status" >&5 (exit $ac_status); }; }; then ac_cv_lib_gpm_initscr=yes else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 ac_cv_lib_gpm_initscr=no fi rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi echo "$as_me:5576: result: $ac_cv_lib_gpm_initscr" >&5 echo "${ECHO_T}$ac_cv_lib_gpm_initscr" >&6 if test $ac_cv_lib_gpm_initscr = yes; then LIBS="$cf_ncurses_SAVE" else cf_ncurses_LIBS="-lgpm" fi fi case $host_os in #(vi freebsd*) # This is only necessary if you are linking against an obsolete # version of ncurses (but it should do no harm, since it's static). if test "$cf_nculib_root" = ncurses ; then echo "$as_me:5591: checking for tgoto in -lmytinfo" >&5 echo $ECHO_N "checking for tgoto in -lmytinfo... $ECHO_C" >&6 if test "${ac_cv_lib_mytinfo_tgoto+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else ac_check_lib_save_LIBS=$LIBS LIBS="-lmytinfo $LIBS" cat >conftest.$ac_ext <<_ACEOF #line 5599 "configure" #include "confdefs.h" /* Override any gcc2 internal prototype to avoid an error. */ #ifdef __cplusplus extern "C" #endif /* We use char because int might match the return type of a gcc2 builtin and then its argument prototype would still apply. */ char tgoto (); int main () { tgoto (); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (eval echo "$as_me:5618: \"$ac_link\"") >&5 (eval $ac_link) 2>&5 ac_status=$? echo "$as_me:5621: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest$ac_exeext' { (eval echo "$as_me:5624: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:5627: \$? = $ac_status" >&5 (exit $ac_status); }; }; then ac_cv_lib_mytinfo_tgoto=yes else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 ac_cv_lib_mytinfo_tgoto=no fi rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi echo "$as_me:5638: result: $ac_cv_lib_mytinfo_tgoto" >&5 echo "${ECHO_T}$ac_cv_lib_mytinfo_tgoto" >&6 if test $ac_cv_lib_mytinfo_tgoto = yes; then cf_ncurses_LIBS="-lmytinfo $cf_ncurses_LIBS" fi fi ;; esac LIBS="$cf_ncurses_LIBS $LIBS" if ( test -n "$cf_cv_curses_dir" && test "$cf_cv_curses_dir" != "no" ) then if test -n "$cf_cv_curses_dir/lib" ; then for cf_add_libdir in $cf_cv_curses_dir/lib do if test $cf_add_libdir = /usr/lib ; then : elif test -d $cf_add_libdir then cf_have_libdir=no if test -n "$LDFLAGS$LIBS" ; then # a loop is needed to ensure we can add subdirs of existing dirs for cf_test_libdir in $LDFLAGS $LIBS ; do if test ".$cf_test_libdir" = ".-L$cf_add_libdir" ; then cf_have_libdir=yes; break fi done fi if test "$cf_have_libdir" = no ; then test -n "$verbose" && echo " adding $cf_add_libdir to library-path" 1>&6 echo "${as_me-configure}:5672: testing adding $cf_add_libdir to library-path ..." 1>&5 LDFLAGS="-L$cf_add_libdir $LDFLAGS" fi fi done fi LIBS="-l$cf_nculib_root $LIBS" else eval 'cf_cv_have_lib_'$cf_nculib_root'=no' cf_libdir="" echo "$as_me:5685: checking for initscr" >&5 echo $ECHO_N "checking for initscr... $ECHO_C" >&6 if test "${ac_cv_func_initscr+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else cat >conftest.$ac_ext <<_ACEOF #line 5691 "configure" #include "confdefs.h" /* System header to define __stub macros and hopefully few prototypes, which can conflict with char initscr (); below. */ #include /* Override any gcc2 internal prototype to avoid an error. */ #ifdef __cplusplus extern "C" #endif /* We use char because int might match the return type of a gcc2 builtin and then its argument prototype would still apply. */ char initscr (); char (*f) (); int main () { /* The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. */ #if defined (__stub_initscr) || defined (__stub___initscr) choke me #else f = initscr; #endif ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (eval echo "$as_me:5722: \"$ac_link\"") >&5 (eval $ac_link) 2>&5 ac_status=$? echo "$as_me:5725: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest$ac_exeext' { (eval echo "$as_me:5728: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:5731: \$? = $ac_status" >&5 (exit $ac_status); }; }; then ac_cv_func_initscr=yes else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 ac_cv_func_initscr=no fi rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext fi echo "$as_me:5741: result: $ac_cv_func_initscr" >&5 echo "${ECHO_T}$ac_cv_func_initscr" >&6 if test $ac_cv_func_initscr = yes; then eval 'cf_cv_have_lib_'$cf_nculib_root'=yes' else cf_save_LIBS="$LIBS" echo "$as_me:5748: checking for initscr in -l$cf_nculib_root" >&5 echo $ECHO_N "checking for initscr in -l$cf_nculib_root... $ECHO_C" >&6 LIBS="-l$cf_nculib_root $LIBS" cat >conftest.$ac_ext <<_ACEOF #line 5752 "configure" #include "confdefs.h" #include <${cf_cv_ncurses_header-curses.h}> int main () { initscr() ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (eval echo "$as_me:5764: \"$ac_link\"") >&5 (eval $ac_link) 2>&5 ac_status=$? echo "$as_me:5767: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest$ac_exeext' { (eval echo "$as_me:5770: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:5773: \$? = $ac_status" >&5 (exit $ac_status); }; }; then echo "$as_me:5775: result: yes" >&5 echo "${ECHO_T}yes" >&6 eval 'cf_cv_have_lib_'$cf_nculib_root'=yes' else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 echo "$as_me:5782: result: no" >&5 echo "${ECHO_T}no" >&6 cf_library_path_list="" if test -n "${LDFLAGS}${LIBS}" ; then for cf_library_path in $LDFLAGS $LIBS do case $cf_library_path in #(vi -L*) cf_library_path=`echo ".$cf_library_path" |sed -e 's/^...//' -e 's,/lib$,,'` test "$cf_library_path" != "NONE" && \ test -d "$cf_library_path" && \ { test -n "$verbose" && echo " ... testing for lib-directories under $cf_library_path" test -d $cf_library_path/lib && cf_search="$cf_search $cf_library_path/lib" test -d $cf_library_path/lib/$cf_nculib_root && cf_search="$cf_search $cf_library_path/lib/$cf_nculib_root" test -d $cf_library_path/lib/$cf_nculib_root/lib && cf_search="$cf_search $cf_library_path/lib/$cf_nculib_root/lib" test -d $cf_library_path/$cf_nculib_root/lib && cf_search="$cf_search $cf_library_path/$cf_nculib_root/lib" test -d $cf_library_path/$cf_nculib_root/lib/$cf_nculib_root && cf_search="$cf_search $cf_library_path/$cf_nculib_root/lib/$cf_nculib_root" } cf_library_path_list="$cf_library_path_list $cf_search" ;; esac done fi cf_search="" test "/usr" != "$prefix" && \ test -d "/usr" && \ (test $prefix = NONE || test -d $prefix) && { test -n "$verbose" && echo " ... testing for lib-directories under /usr" test -d /usr/lib && cf_search="$cf_search /usr/lib" test -d /usr/lib/$cf_nculib_root && cf_search="$cf_search /usr/lib/$cf_nculib_root" test -d /usr/lib/$cf_nculib_root/lib && cf_search="$cf_search /usr/lib/$cf_nculib_root/lib" test -d /usr/$cf_nculib_root/lib && cf_search="$cf_search /usr/$cf_nculib_root/lib" test -d /usr/$cf_nculib_root/lib/$cf_nculib_root && cf_search="$cf_search /usr/$cf_nculib_root/lib/$cf_nculib_root" } test "$prefix" != "NONE" && \ test -d "$prefix" && \ { test -n "$verbose" && echo " ... testing for lib-directories under $prefix" test -d $prefix/lib && cf_search="$cf_search $prefix/lib" test -d $prefix/lib/$cf_nculib_root && cf_search="$cf_search $prefix/lib/$cf_nculib_root" test -d $prefix/lib/$cf_nculib_root/lib && cf_search="$cf_search $prefix/lib/$cf_nculib_root/lib" test -d $prefix/$cf_nculib_root/lib && cf_search="$cf_search $prefix/$cf_nculib_root/lib" test -d $prefix/$cf_nculib_root/lib/$cf_nculib_root && cf_search="$cf_search $prefix/$cf_nculib_root/lib/$cf_nculib_root" } test "/usr/local" != "$prefix" && \ test -d "/usr/local" && \ (test $prefix = NONE || test -d $prefix) && { test -n "$verbose" && echo " ... testing for lib-directories under /usr/local" test -d /usr/local/lib && cf_search="$cf_search /usr/local/lib" test -d /usr/local/lib/$cf_nculib_root && cf_search="$cf_search /usr/local/lib/$cf_nculib_root" test -d /usr/local/lib/$cf_nculib_root/lib && cf_search="$cf_search /usr/local/lib/$cf_nculib_root/lib" test -d /usr/local/$cf_nculib_root/lib && cf_search="$cf_search /usr/local/$cf_nculib_root/lib" test -d /usr/local/$cf_nculib_root/lib/$cf_nculib_root && cf_search="$cf_search /usr/local/$cf_nculib_root/lib/$cf_nculib_root" } test "/opt" != "$prefix" && \ test -d "/opt" && \ (test $prefix = NONE || test -d $prefix) && { test -n "$verbose" && echo " ... testing for lib-directories under /opt" test -d /opt/lib && cf_search="$cf_search /opt/lib" test -d /opt/lib/$cf_nculib_root && cf_search="$cf_search /opt/lib/$cf_nculib_root" test -d /opt/lib/$cf_nculib_root/lib && cf_search="$cf_search /opt/lib/$cf_nculib_root/lib" test -d /opt/$cf_nculib_root/lib && cf_search="$cf_search /opt/$cf_nculib_root/lib" test -d /opt/$cf_nculib_root/lib/$cf_nculib_root && cf_search="$cf_search /opt/$cf_nculib_root/lib/$cf_nculib_root" } test "$HOME" != "$prefix" && \ test -d "$HOME" && \ (test $prefix = NONE || test -d $prefix) && { test -n "$verbose" && echo " ... testing for lib-directories under $HOME" test -d $HOME/lib && cf_search="$cf_search $HOME/lib" test -d $HOME/lib/$cf_nculib_root && cf_search="$cf_search $HOME/lib/$cf_nculib_root" test -d $HOME/lib/$cf_nculib_root/lib && cf_search="$cf_search $HOME/lib/$cf_nculib_root/lib" test -d $HOME/$cf_nculib_root/lib && cf_search="$cf_search $HOME/$cf_nculib_root/lib" test -d $HOME/$cf_nculib_root/lib/$cf_nculib_root && cf_search="$cf_search $HOME/$cf_nculib_root/lib/$cf_nculib_root" } cf_search="$cf_library_path_list $cf_search" for cf_libdir in $cf_search do echo "$as_me:5871: checking for -l$cf_nculib_root in $cf_libdir" >&5 echo $ECHO_N "checking for -l$cf_nculib_root in $cf_libdir... $ECHO_C" >&6 LIBS="-L$cf_libdir -l$cf_nculib_root $cf_save_LIBS" cat >conftest.$ac_ext <<_ACEOF #line 5875 "configure" #include "confdefs.h" #include <${cf_cv_ncurses_header-curses.h}> int main () { initscr() ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (eval echo "$as_me:5887: \"$ac_link\"") >&5 (eval $ac_link) 2>&5 ac_status=$? echo "$as_me:5890: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest$ac_exeext' { (eval echo "$as_me:5893: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:5896: \$? = $ac_status" >&5 (exit $ac_status); }; }; then echo "$as_me:5898: result: yes" >&5 echo "${ECHO_T}yes" >&6 eval 'cf_cv_have_lib_'$cf_nculib_root'=yes' break else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 echo "$as_me:5905: result: no" >&5 echo "${ECHO_T}no" >&6 LIBS="$cf_save_LIBS" fi rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext done fi rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext fi eval 'cf_found_library=$cf_cv_have_lib_'$cf_nculib_root if test $cf_found_library = no ; then { { echo "$as_me:5920: error: Cannot link $cf_nculib_root library" >&5 echo "$as_me: error: Cannot link $cf_nculib_root library" >&2;} { (exit 1); exit 1; }; } fi fi if test -n "$cf_ncurses_LIBS" ; then echo "$as_me:5928: checking if we can link $cf_nculib_root without $cf_ncurses_LIBS" >&5 echo $ECHO_N "checking if we can link $cf_nculib_root without $cf_ncurses_LIBS... $ECHO_C" >&6 cf_ncurses_SAVE="$LIBS" for p in $cf_ncurses_LIBS ; do q=`echo $LIBS | sed -e "s%$p %%" -e "s%$p$%%"` if test "$q" != "$LIBS" ; then LIBS="$q" fi done cat >conftest.$ac_ext <<_ACEOF #line 5938 "configure" #include "confdefs.h" #include <${cf_cv_ncurses_header-curses.h}> int main () { initscr(); mousemask(0,0); tgoto((char *)0, 0, 0); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (eval echo "$as_me:5950: \"$ac_link\"") >&5 (eval $ac_link) 2>&5 ac_status=$? echo "$as_me:5953: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest$ac_exeext' { (eval echo "$as_me:5956: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:5959: \$? = $ac_status" >&5 (exit $ac_status); }; }; then echo "$as_me:5961: result: yes" >&5 echo "${ECHO_T}yes" >&6 else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 echo "$as_me:5966: result: no" >&5 echo "${ECHO_T}no" >&6 LIBS="$cf_ncurses_SAVE" fi rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext fi cf_nculib_ROOT=`echo "HAVE_LIB$cf_nculib_root" | sed y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%` cat >>confdefs.h <&5 echo $ECHO_N "checking for extra include directories... $ECHO_C" >&6 if test "${cf_cv_curses_incdir+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else cf_cv_curses_incdir=no case $host_os in #(vi hpux10.*) #(vi test -d /usr/include/curses_colr && \ cf_cv_curses_incdir="-I/usr/include/curses_colr" ;; sunos3*|sunos4*) test -d /usr/5lib && \ test -d /usr/5include && \ cf_cv_curses_incdir="-I/usr/5include" ;; esac fi echo "$as_me:6004: result: $cf_cv_curses_incdir" >&5 echo "${ECHO_T}$cf_cv_curses_incdir" >&6 test "$cf_cv_curses_incdir" != no && CPPFLAGS="$CPPFLAGS $cf_cv_curses_incdir" echo "$as_me:6008: checking if we have identified curses headers" >&5 echo $ECHO_N "checking if we have identified curses headers... $ECHO_C" >&6 if test "${cf_cv_ncurses_header+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else cf_cv_ncurses_header=none for cf_header in \ curses.h \ ncurses.h \ ncurses/curses.h \ ncurses/ncurses.h do cat >conftest.$ac_ext <<_ACEOF #line 6022 "configure" #include "confdefs.h" #include <${cf_header}> int main () { initscr(); tgoto("?", 0,0) ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (eval echo "$as_me:6034: \"$ac_compile\"") >&5 (eval $ac_compile) 2>&5 ac_status=$? echo "$as_me:6037: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest.$ac_objext' { (eval echo "$as_me:6040: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:6043: \$? = $ac_status" >&5 (exit $ac_status); }; }; then cf_cv_ncurses_header=$cf_header; break else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 fi rm -f conftest.$ac_objext conftest.$ac_ext done fi echo "$as_me:6054: result: $cf_cv_ncurses_header" >&5 echo "${ECHO_T}$cf_cv_ncurses_header" >&6 if test "$cf_cv_ncurses_header" = none ; then { { echo "$as_me:6058: error: No curses header-files found" >&5 echo "$as_me: error: No curses header-files found" >&2;} { (exit 1); exit 1; }; } fi # cheat, to get the right #define's for HAVE_NCURSES_H, etc. for ac_header in $cf_cv_ncurses_header do as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh` echo "$as_me:6068: checking for $ac_header" >&5 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6 if eval "test \"\${$as_ac_Header+set}\" = set"; then echo $ECHO_N "(cached) $ECHO_C" >&6 else cat >conftest.$ac_ext <<_ACEOF #line 6074 "configure" #include "confdefs.h" #include <$ac_header> _ACEOF if { (eval echo "$as_me:6078: \"$ac_cpp conftest.$ac_ext\"") >&5 (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1 ac_status=$? egrep -v '^ *\+' conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo "$as_me:6084: \$? = $ac_status" >&5 (exit $ac_status); } >/dev/null; then if test -s conftest.err; then ac_cpp_err=$ac_c_preproc_warn_flag else ac_cpp_err= fi else ac_cpp_err=yes fi if test -z "$ac_cpp_err"; then eval "$as_ac_Header=yes" else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 eval "$as_ac_Header=no" fi rm -f conftest.err conftest.$ac_ext fi echo "$as_me:6103: result: `eval echo '${'$as_ac_Header'}'`" >&5 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6 if test `eval echo '${'$as_ac_Header'}'` = yes; then cat >>confdefs.h <&5 echo $ECHO_N "checking for terminfo header... $ECHO_C" >&6 if test "${cf_cv_term_header+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else case ${cf_cv_ncurses_header} in #(vi */ncurses.h|*/ncursesw.h) #(vi cf_term_header=`echo "$cf_cv_ncurses_header" | sed -e 's%ncurses[^.]*\.h$%term.h%'` ;; *) cf_term_header=term.h ;; esac for cf_test in $cf_term_header "ncurses/term.h" "ncursesw/term.h" do cat >conftest.$ac_ext <<_ACEOF #line 6131 "configure" #include "confdefs.h" #include #include <${cf_cv_ncurses_header-curses.h}> #include <$cf_test> int main () { int x = auto_left_margin ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (eval echo "$as_me:6146: \"$ac_compile\"") >&5 (eval $ac_compile) 2>&5 ac_status=$? echo "$as_me:6149: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest.$ac_objext' { (eval echo "$as_me:6152: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:6155: \$? = $ac_status" >&5 (exit $ac_status); }; }; then cf_cv_term_header="$cf_test" else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 cf_cv_term_header=unknown fi rm -f conftest.$ac_objext conftest.$ac_ext test "$cf_cv_term_header" != unknown && break done fi echo "$as_me:6171: result: $cf_cv_term_header" >&5 echo "${ECHO_T}$cf_cv_term_header" >&6 # Set definitions to allow ifdef'ing to accommodate subdirectories case $cf_cv_term_header in # (vi *term.h) cat >>confdefs.h <<\EOF #define HAVE_TERM_H 1 EOF ;; esac case $cf_cv_term_header in # (vi ncurses/term.h) #(vi cat >>confdefs.h <<\EOF #define HAVE_NCURSES_TERM_H 1 EOF ;; ncursesw/term.h) cat >>confdefs.h <<\EOF #define HAVE_NCURSESW_TERM_H 1 EOF ;; esac echo "$as_me:6200: checking for ncurses version" >&5 echo $ECHO_N "checking for ncurses version... $ECHO_C" >&6 if test "${cf_cv_ncurses_version+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else cf_cv_ncurses_version=no cf_tempfile=out$$ rm -f $cf_tempfile if test "$cross_compiling" = yes; then # This will not work if the preprocessor splits the line after the # Autoconf token. The 'unproto' program does that. cat > conftest.$ac_ext < #undef Autoconf #ifdef NCURSES_VERSION Autoconf NCURSES_VERSION #else #ifdef __NCURSES_H Autoconf "old" #endif ; #endif EOF cf_try="$ac_cpp conftest.$ac_ext 2>&5 | grep '^Autoconf ' >conftest.out" { (eval echo "$as_me:6226: \"$cf_try\"") >&5 (eval $cf_try) 2>&5 ac_status=$? echo "$as_me:6229: \$? = $ac_status" >&5 (exit $ac_status); } if test -f conftest.out ; then cf_out=`cat conftest.out | sed -e 's%^Autoconf %%' -e 's%^[^"]*"%%' -e 's%".*%%'` test -n "$cf_out" && cf_cv_ncurses_version="$cf_out" rm -f conftest.out fi else cat >conftest.$ac_ext <<_ACEOF #line 6239 "configure" #include "confdefs.h" #include <${cf_cv_ncurses_header-curses.h}> #include int main() { FILE *fp = fopen("$cf_tempfile", "w"); #ifdef NCURSES_VERSION # ifdef NCURSES_VERSION_PATCH fprintf(fp, "%s.%d\n", NCURSES_VERSION, NCURSES_VERSION_PATCH); # else fprintf(fp, "%s\n", NCURSES_VERSION); # endif #else # ifdef __NCURSES_H fprintf(fp, "old\n"); # else make an error # endif #endif ${cf_cv_main_return-return}(0); } _ACEOF rm -f conftest$ac_exeext if { (eval echo "$as_me:6264: \"$ac_link\"") >&5 (eval $ac_link) 2>&5 ac_status=$? echo "$as_me:6267: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='./conftest$ac_exeext' { (eval echo "$as_me:6269: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:6272: \$? = $ac_status" >&5 (exit $ac_status); }; }; then cf_cv_ncurses_version=`cat $cf_tempfile` else echo "$as_me: program exited with status $ac_status" >&5 echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 fi rm -f core core.* *.core conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext fi rm -f $cf_tempfile fi echo "$as_me:6286: result: $cf_cv_ncurses_version" >&5 echo "${ECHO_T}$cf_cv_ncurses_version" >&6 test "$cf_cv_ncurses_version" = no || cat >>confdefs.h <<\EOF #define NCURSES 1 EOF echo "$as_me:6292: checking if we have identified curses libraries" >&5 echo $ECHO_N "checking if we have identified curses libraries... $ECHO_C" >&6 cat >conftest.$ac_ext <<_ACEOF #line 6295 "configure" #include "confdefs.h" #include <${cf_cv_ncurses_header-curses.h}> int main () { initscr(); tgoto("?", 0,0) ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (eval echo "$as_me:6307: \"$ac_link\"") >&5 (eval $ac_link) 2>&5 ac_status=$? echo "$as_me:6310: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest$ac_exeext' { (eval echo "$as_me:6313: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:6316: \$? = $ac_status" >&5 (exit $ac_status); }; }; then cf_result=yes else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 cf_result=no fi rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext echo "$as_me:6325: result: $cf_result" >&5 echo "${ECHO_T}$cf_result" >&6 if test "$cf_result" = no ; then case $host_os in #(vi freebsd*) #(vi echo "$as_me:6331: checking for tgoto in -lmytinfo" >&5 echo $ECHO_N "checking for tgoto in -lmytinfo... $ECHO_C" >&6 if test "${ac_cv_lib_mytinfo_tgoto+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else ac_check_lib_save_LIBS=$LIBS LIBS="-lmytinfo $LIBS" cat >conftest.$ac_ext <<_ACEOF #line 6339 "configure" #include "confdefs.h" /* Override any gcc2 internal prototype to avoid an error. */ #ifdef __cplusplus extern "C" #endif /* We use char because int might match the return type of a gcc2 builtin and then its argument prototype would still apply. */ char tgoto (); int main () { tgoto (); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (eval echo "$as_me:6358: \"$ac_link\"") >&5 (eval $ac_link) 2>&5 ac_status=$? echo "$as_me:6361: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest$ac_exeext' { (eval echo "$as_me:6364: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:6367: \$? = $ac_status" >&5 (exit $ac_status); }; }; then ac_cv_lib_mytinfo_tgoto=yes else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 ac_cv_lib_mytinfo_tgoto=no fi rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi echo "$as_me:6378: result: $ac_cv_lib_mytinfo_tgoto" >&5 echo "${ECHO_T}$ac_cv_lib_mytinfo_tgoto" >&6 if test $ac_cv_lib_mytinfo_tgoto = yes; then LIBS="-lmytinfo $LIBS" fi ;; hpux10.*) #(vi echo "$as_me:6386: checking for initscr in -lcur_colr" >&5 echo $ECHO_N "checking for initscr in -lcur_colr... $ECHO_C" >&6 if test "${ac_cv_lib_cur_colr_initscr+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else ac_check_lib_save_LIBS=$LIBS LIBS="-lcur_colr $LIBS" cat >conftest.$ac_ext <<_ACEOF #line 6394 "configure" #include "confdefs.h" /* Override any gcc2 internal prototype to avoid an error. */ #ifdef __cplusplus extern "C" #endif /* We use char because int might match the return type of a gcc2 builtin and then its argument prototype would still apply. */ char initscr (); int main () { initscr (); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (eval echo "$as_me:6413: \"$ac_link\"") >&5 (eval $ac_link) 2>&5 ac_status=$? echo "$as_me:6416: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest$ac_exeext' { (eval echo "$as_me:6419: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:6422: \$? = $ac_status" >&5 (exit $ac_status); }; }; then ac_cv_lib_cur_colr_initscr=yes else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 ac_cv_lib_cur_colr_initscr=no fi rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi echo "$as_me:6433: result: $ac_cv_lib_cur_colr_initscr" >&5 echo "${ECHO_T}$ac_cv_lib_cur_colr_initscr" >&6 if test $ac_cv_lib_cur_colr_initscr = yes; then LIBS="-lcur_colr $LIBS" ac_cv_func_initscr=yes else echo "$as_me:6442: checking for initscr in -lHcurses" >&5 echo $ECHO_N "checking for initscr in -lHcurses... $ECHO_C" >&6 if test "${ac_cv_lib_Hcurses_initscr+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else ac_check_lib_save_LIBS=$LIBS LIBS="-lHcurses $LIBS" cat >conftest.$ac_ext <<_ACEOF #line 6450 "configure" #include "confdefs.h" /* Override any gcc2 internal prototype to avoid an error. */ #ifdef __cplusplus extern "C" #endif /* We use char because int might match the return type of a gcc2 builtin and then its argument prototype would still apply. */ char initscr (); int main () { initscr (); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (eval echo "$as_me:6469: \"$ac_link\"") >&5 (eval $ac_link) 2>&5 ac_status=$? echo "$as_me:6472: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest$ac_exeext' { (eval echo "$as_me:6475: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:6478: \$? = $ac_status" >&5 (exit $ac_status); }; }; then ac_cv_lib_Hcurses_initscr=yes else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 ac_cv_lib_Hcurses_initscr=no fi rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi echo "$as_me:6489: result: $ac_cv_lib_Hcurses_initscr" >&5 echo "${ECHO_T}$ac_cv_lib_Hcurses_initscr" >&6 if test $ac_cv_lib_Hcurses_initscr = yes; then # HP's header uses __HP_CURSES, but user claims _HP_CURSES. LIBS="-lHcurses $LIBS" CPPFLAGS="$CPPFLAGS -D__HP_CURSES -D_HP_CURSES" ac_cv_func_initscr=yes fi fi ;; linux*) # Suse Linux does not follow /usr/lib convention if test -n "/lib" ; then for cf_add_libdir in /lib do if test $cf_add_libdir = /usr/lib ; then : elif test -d $cf_add_libdir then cf_have_libdir=no if test -n "$LDFLAGS$LIBS" ; then # a loop is needed to ensure we can add subdirs of existing dirs for cf_test_libdir in $LDFLAGS $LIBS ; do if test ".$cf_test_libdir" = ".-L$cf_add_libdir" ; then cf_have_libdir=yes; break fi done fi if test "$cf_have_libdir" = no ; then test -n "$verbose" && echo " adding $cf_add_libdir to library-path" 1>&6 echo "${as_me-configure}:6524: testing adding $cf_add_libdir to library-path ..." 1>&5 LDFLAGS="-L$cf_add_libdir $LDFLAGS" fi fi done fi ;; sunos3*|sunos4*) if test -d /usr/5lib ; then if test -n "/usr/5lib" ; then for cf_add_libdir in /usr/5lib do if test $cf_add_libdir = /usr/lib ; then : elif test -d $cf_add_libdir then cf_have_libdir=no if test -n "$LDFLAGS$LIBS" ; then # a loop is needed to ensure we can add subdirs of existing dirs for cf_test_libdir in $LDFLAGS $LIBS ; do if test ".$cf_test_libdir" = ".-L$cf_add_libdir" ; then cf_have_libdir=yes; break fi done fi if test "$cf_have_libdir" = no ; then test -n "$verbose" && echo " adding $cf_add_libdir to library-path" 1>&6 echo "${as_me-configure}:6555: testing adding $cf_add_libdir to library-path ..." 1>&5 LDFLAGS="-L$cf_add_libdir $LDFLAGS" fi fi done fi LIBS="$LIBS -lcurses -ltermcap" fi ac_cv_func_initscr=yes ;; esac if test ".$ac_cv_func_initscr" != .yes ; then cf_save_LIBS="$LIBS" cf_term_lib="" cf_curs_lib="" if test ".${cf_cv_ncurses_version-no}" != .no then cf_check_list="ncurses curses cursesX" else cf_check_list="cursesX curses ncurses" fi # Check for library containing tgoto. Do this before curses library # because it may be needed to link the test-case for initscr. echo "$as_me:6583: checking for tgoto" >&5 echo $ECHO_N "checking for tgoto... $ECHO_C" >&6 if test "${ac_cv_func_tgoto+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else cat >conftest.$ac_ext <<_ACEOF #line 6589 "configure" #include "confdefs.h" /* System header to define __stub macros and hopefully few prototypes, which can conflict with char tgoto (); below. */ #include /* Override any gcc2 internal prototype to avoid an error. */ #ifdef __cplusplus extern "C" #endif /* We use char because int might match the return type of a gcc2 builtin and then its argument prototype would still apply. */ char tgoto (); char (*f) (); int main () { /* The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. */ #if defined (__stub_tgoto) || defined (__stub___tgoto) choke me #else f = tgoto; #endif ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (eval echo "$as_me:6620: \"$ac_link\"") >&5 (eval $ac_link) 2>&5 ac_status=$? echo "$as_me:6623: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest$ac_exeext' { (eval echo "$as_me:6626: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:6629: \$? = $ac_status" >&5 (exit $ac_status); }; }; then ac_cv_func_tgoto=yes else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 ac_cv_func_tgoto=no fi rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext fi echo "$as_me:6639: result: $ac_cv_func_tgoto" >&5 echo "${ECHO_T}$ac_cv_func_tgoto" >&6 if test $ac_cv_func_tgoto = yes; then cf_term_lib=predefined else for cf_term_lib in $cf_check_list termcap termlib unknown do as_ac_Lib=`echo "ac_cv_lib_$cf_term_lib''_tgoto" | $as_tr_sh` echo "$as_me:6648: checking for tgoto in -l$cf_term_lib" >&5 echo $ECHO_N "checking for tgoto in -l$cf_term_lib... $ECHO_C" >&6 if eval "test \"\${$as_ac_Lib+set}\" = set"; then echo $ECHO_N "(cached) $ECHO_C" >&6 else ac_check_lib_save_LIBS=$LIBS LIBS="-l$cf_term_lib $LIBS" cat >conftest.$ac_ext <<_ACEOF #line 6656 "configure" #include "confdefs.h" /* Override any gcc2 internal prototype to avoid an error. */ #ifdef __cplusplus extern "C" #endif /* We use char because int might match the return type of a gcc2 builtin and then its argument prototype would still apply. */ char tgoto (); int main () { tgoto (); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (eval echo "$as_me:6675: \"$ac_link\"") >&5 (eval $ac_link) 2>&5 ac_status=$? echo "$as_me:6678: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest$ac_exeext' { (eval echo "$as_me:6681: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:6684: \$? = $ac_status" >&5 (exit $ac_status); }; }; then eval "$as_ac_Lib=yes" else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 eval "$as_ac_Lib=no" fi rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi echo "$as_me:6695: result: `eval echo '${'$as_ac_Lib'}'`" >&5 echo "${ECHO_T}`eval echo '${'$as_ac_Lib'}'`" >&6 if test `eval echo '${'$as_ac_Lib'}'` = yes; then break fi done fi # Check for library containing initscr test "$cf_term_lib" != predefined && test "$cf_term_lib" != unknown && LIBS="-l$cf_term_lib $cf_save_LIBS" for cf_curs_lib in $cf_check_list xcurses jcurses pdcurses unknown do as_ac_Lib=`echo "ac_cv_lib_$cf_curs_lib''_initscr" | $as_tr_sh` echo "$as_me:6710: checking for initscr in -l$cf_curs_lib" >&5 echo $ECHO_N "checking for initscr in -l$cf_curs_lib... $ECHO_C" >&6 if eval "test \"\${$as_ac_Lib+set}\" = set"; then echo $ECHO_N "(cached) $ECHO_C" >&6 else ac_check_lib_save_LIBS=$LIBS LIBS="-l$cf_curs_lib $LIBS" cat >conftest.$ac_ext <<_ACEOF #line 6718 "configure" #include "confdefs.h" /* Override any gcc2 internal prototype to avoid an error. */ #ifdef __cplusplus extern "C" #endif /* We use char because int might match the return type of a gcc2 builtin and then its argument prototype would still apply. */ char initscr (); int main () { initscr (); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (eval echo "$as_me:6737: \"$ac_link\"") >&5 (eval $ac_link) 2>&5 ac_status=$? echo "$as_me:6740: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest$ac_exeext' { (eval echo "$as_me:6743: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:6746: \$? = $ac_status" >&5 (exit $ac_status); }; }; then eval "$as_ac_Lib=yes" else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 eval "$as_ac_Lib=no" fi rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi echo "$as_me:6757: result: `eval echo '${'$as_ac_Lib'}'`" >&5 echo "${ECHO_T}`eval echo '${'$as_ac_Lib'}'`" >&6 if test `eval echo '${'$as_ac_Lib'}'` = yes; then break fi done test $cf_curs_lib = unknown && { { echo "$as_me:6764: error: no curses library found" >&5 echo "$as_me: error: no curses library found" >&2;} { (exit 1); exit 1; }; } LIBS="-l$cf_curs_lib $cf_save_LIBS" if test "$cf_term_lib" = unknown ; then echo "$as_me:6770: checking if we can link with $cf_curs_lib library" >&5 echo $ECHO_N "checking if we can link with $cf_curs_lib library... $ECHO_C" >&6 cat >conftest.$ac_ext <<_ACEOF #line 6773 "configure" #include "confdefs.h" #include <${cf_cv_ncurses_header-curses.h}> int main () { initscr() ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (eval echo "$as_me:6785: \"$ac_link\"") >&5 (eval $ac_link) 2>&5 ac_status=$? echo "$as_me:6788: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest$ac_exeext' { (eval echo "$as_me:6791: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:6794: \$? = $ac_status" >&5 (exit $ac_status); }; }; then cf_result=yes else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 cf_result=no fi rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext echo "$as_me:6803: result: $cf_result" >&5 echo "${ECHO_T}$cf_result" >&6 test $cf_result = no && { { echo "$as_me:6805: error: Cannot link curses library" >&5 echo "$as_me: error: Cannot link curses library" >&2;} { (exit 1); exit 1; }; } elif test "$cf_curs_lib" = "$cf_term_lib" ; then : elif test "$cf_term_lib" != predefined ; then echo "$as_me:6811: checking if we need both $cf_curs_lib and $cf_term_lib libraries" >&5 echo $ECHO_N "checking if we need both $cf_curs_lib and $cf_term_lib libraries... $ECHO_C" >&6 cat >conftest.$ac_ext <<_ACEOF #line 6814 "configure" #include "confdefs.h" #include <${cf_cv_ncurses_header-curses.h}> int main () { initscr(); tgoto((char *)0, 0, 0); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (eval echo "$as_me:6826: \"$ac_link\"") >&5 (eval $ac_link) 2>&5 ac_status=$? echo "$as_me:6829: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest$ac_exeext' { (eval echo "$as_me:6832: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:6835: \$? = $ac_status" >&5 (exit $ac_status); }; }; then cf_result=no else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 LIBS="-l$cf_curs_lib -l$cf_term_lib $cf_save_LIBS" cat >conftest.$ac_ext <<_ACEOF #line 6844 "configure" #include "confdefs.h" #include <${cf_cv_ncurses_header-curses.h}> int main () { initscr() ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (eval echo "$as_me:6856: \"$ac_link\"") >&5 (eval $ac_link) 2>&5 ac_status=$? echo "$as_me:6859: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest$ac_exeext' { (eval echo "$as_me:6862: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:6865: \$? = $ac_status" >&5 (exit $ac_status); }; }; then cf_result=yes else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 cf_result=error fi rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext fi rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext echo "$as_me:6877: result: $cf_result" >&5 echo "${ECHO_T}$cf_result" >&6 fi fi fi ;; esac case $cf_cv_screen in ncurses*) echo "$as_me:6888: checking for _nc_tic_expand" >&5 echo $ECHO_N "checking for _nc_tic_expand... $ECHO_C" >&6 if test "${ac_cv_func__nc_tic_expand+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else cat >conftest.$ac_ext <<_ACEOF #line 6894 "configure" #include "confdefs.h" /* System header to define __stub macros and hopefully few prototypes, which can conflict with char _nc_tic_expand (); below. */ #include /* Override any gcc2 internal prototype to avoid an error. */ #ifdef __cplusplus extern "C" #endif /* We use char because int might match the return type of a gcc2 builtin and then its argument prototype would still apply. */ char _nc_tic_expand (); char (*f) (); int main () { /* The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. */ #if defined (__stub__nc_tic_expand) || defined (__stub____nc_tic_expand) choke me #else f = _nc_tic_expand; #endif ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (eval echo "$as_me:6925: \"$ac_link\"") >&5 (eval $ac_link) 2>&5 ac_status=$? echo "$as_me:6928: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest$ac_exeext' { (eval echo "$as_me:6931: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:6934: \$? = $ac_status" >&5 (exit $ac_status); }; }; then ac_cv_func__nc_tic_expand=yes else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 ac_cv_func__nc_tic_expand=no fi rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext fi echo "$as_me:6944: result: $ac_cv_func__nc_tic_expand" >&5 echo "${ECHO_T}$ac_cv_func__nc_tic_expand" >&6 if test $ac_cv_func__nc_tic_expand = yes; then : else echo "$as_me:6950: checking for _nc_tic_expand in -ltic" >&5 echo $ECHO_N "checking for _nc_tic_expand in -ltic... $ECHO_C" >&6 if test "${ac_cv_lib_tic__nc_tic_expand+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else ac_check_lib_save_LIBS=$LIBS LIBS="-ltic $LIBS" cat >conftest.$ac_ext <<_ACEOF #line 6958 "configure" #include "confdefs.h" /* Override any gcc2 internal prototype to avoid an error. */ #ifdef __cplusplus extern "C" #endif /* We use char because int might match the return type of a gcc2 builtin and then its argument prototype would still apply. */ char _nc_tic_expand (); int main () { _nc_tic_expand (); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (eval echo "$as_me:6977: \"$ac_link\"") >&5 (eval $ac_link) 2>&5 ac_status=$? echo "$as_me:6980: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest$ac_exeext' { (eval echo "$as_me:6983: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:6986: \$? = $ac_status" >&5 (exit $ac_status); }; }; then ac_cv_lib_tic__nc_tic_expand=yes else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 ac_cv_lib_tic__nc_tic_expand=no fi rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi echo "$as_me:6997: result: $ac_cv_lib_tic__nc_tic_expand" >&5 echo "${ECHO_T}$ac_cv_lib_tic__nc_tic_expand" >&6 if test $ac_cv_lib_tic__nc_tic_expand = yes; then LIBS="-ltic $LIBS" fi fi ;; esac echo "$as_me:7008: checking if you want to use dmalloc for testing" >&5 echo $ECHO_N "checking if you want to use dmalloc for testing... $ECHO_C" >&6 # Check whether --with-dmalloc or --without-dmalloc was given. if test "${with_dmalloc+set}" = set; then withval="$with_dmalloc" cat >>confdefs.h <<\EOF #define USE_DMALLOC 1 EOF : ${with_cflags:=-g} : ${with_no_leaks:=yes} with_dmalloc=yes else with_dmalloc= fi; echo "$as_me:7024: result: ${with_dmalloc:-no}" >&5 echo "${ECHO_T}${with_dmalloc:-no}" >&6 case .$with_cflags in #(vi .*-g*) case .$CFLAGS in #(vi .*-g*) #(vi ;; *) cf_fix_cppflags=no cf_new_cflags= cf_new_cppflags= cf_new_extra_cppflags= for cf_add_cflags in -g do case $cf_fix_cppflags in no) case $cf_add_cflags in #(vi -undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C) #(vi case $cf_add_cflags in -D*) cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^-D[^=]*='\''\"[^"]*//'` test "${cf_add_cflags}" != "${cf_tst_cflags}" \ && test -z "${cf_tst_cflags}" \ && cf_fix_cppflags=yes if test $cf_fix_cppflags = yes ; then cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags" continue elif test "${cf_tst_cflags}" = "\"'" ; then cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags" continue fi ;; esac case "$CPPFLAGS" in *$cf_add_cflags) #(vi ;; *) #(vi cf_new_cppflags="$cf_new_cppflags $cf_add_cflags" ;; esac ;; *) cf_new_cflags="$cf_new_cflags $cf_add_cflags" ;; esac ;; yes) cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags" cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^[^"]*"'\''//'` test "${cf_add_cflags}" != "${cf_tst_cflags}" \ && test -z "${cf_tst_cflags}" \ && cf_fix_cppflags=no ;; esac done if test -n "$cf_new_cflags" ; then CFLAGS="$CFLAGS $cf_new_cflags" fi if test -n "$cf_new_cppflags" ; then CPPFLAGS="$CPPFLAGS $cf_new_cppflags" fi if test -n "$cf_new_extra_cppflags" ; then EXTRA_CPPFLAGS="$cf_new_extra_cppflags $EXTRA_CPPFLAGS" fi ;; esac ;; esac if test "$with_dmalloc" = yes ; then echo "$as_me:7108: checking for dmalloc.h" >&5 echo $ECHO_N "checking for dmalloc.h... $ECHO_C" >&6 if test "${ac_cv_header_dmalloc_h+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else cat >conftest.$ac_ext <<_ACEOF #line 7114 "configure" #include "confdefs.h" #include _ACEOF if { (eval echo "$as_me:7118: \"$ac_cpp conftest.$ac_ext\"") >&5 (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1 ac_status=$? egrep -v '^ *\+' conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo "$as_me:7124: \$? = $ac_status" >&5 (exit $ac_status); } >/dev/null; then if test -s conftest.err; then ac_cpp_err=$ac_c_preproc_warn_flag else ac_cpp_err= fi else ac_cpp_err=yes fi if test -z "$ac_cpp_err"; then ac_cv_header_dmalloc_h=yes else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 ac_cv_header_dmalloc_h=no fi rm -f conftest.err conftest.$ac_ext fi echo "$as_me:7143: result: $ac_cv_header_dmalloc_h" >&5 echo "${ECHO_T}$ac_cv_header_dmalloc_h" >&6 if test $ac_cv_header_dmalloc_h = yes; then echo "$as_me:7147: checking for dmalloc_debug in -ldmalloc" >&5 echo $ECHO_N "checking for dmalloc_debug in -ldmalloc... $ECHO_C" >&6 if test "${ac_cv_lib_dmalloc_dmalloc_debug+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else ac_check_lib_save_LIBS=$LIBS LIBS="-ldmalloc $LIBS" cat >conftest.$ac_ext <<_ACEOF #line 7155 "configure" #include "confdefs.h" /* Override any gcc2 internal prototype to avoid an error. */ #ifdef __cplusplus extern "C" #endif /* We use char because int might match the return type of a gcc2 builtin and then its argument prototype would still apply. */ char dmalloc_debug (); int main () { dmalloc_debug (); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (eval echo "$as_me:7174: \"$ac_link\"") >&5 (eval $ac_link) 2>&5 ac_status=$? echo "$as_me:7177: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest$ac_exeext' { (eval echo "$as_me:7180: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:7183: \$? = $ac_status" >&5 (exit $ac_status); }; }; then ac_cv_lib_dmalloc_dmalloc_debug=yes else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 ac_cv_lib_dmalloc_dmalloc_debug=no fi rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi echo "$as_me:7194: result: $ac_cv_lib_dmalloc_dmalloc_debug" >&5 echo "${ECHO_T}$ac_cv_lib_dmalloc_dmalloc_debug" >&6 if test $ac_cv_lib_dmalloc_dmalloc_debug = yes; then cat >>confdefs.h <&5 echo $ECHO_N "checking if you want to use dbmalloc for testing... $ECHO_C" >&6 # Check whether --with-dbmalloc or --without-dbmalloc was given. if test "${with_dbmalloc+set}" = set; then withval="$with_dbmalloc" cat >>confdefs.h <<\EOF #define USE_DBMALLOC 1 EOF : ${with_cflags:=-g} : ${with_no_leaks:=yes} with_dbmalloc=yes else with_dbmalloc= fi; echo "$as_me:7225: result: ${with_dbmalloc:-no}" >&5 echo "${ECHO_T}${with_dbmalloc:-no}" >&6 case .$with_cflags in #(vi .*-g*) case .$CFLAGS in #(vi .*-g*) #(vi ;; *) cf_fix_cppflags=no cf_new_cflags= cf_new_cppflags= cf_new_extra_cppflags= for cf_add_cflags in -g do case $cf_fix_cppflags in no) case $cf_add_cflags in #(vi -undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C) #(vi case $cf_add_cflags in -D*) cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^-D[^=]*='\''\"[^"]*//'` test "${cf_add_cflags}" != "${cf_tst_cflags}" \ && test -z "${cf_tst_cflags}" \ && cf_fix_cppflags=yes if test $cf_fix_cppflags = yes ; then cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags" continue elif test "${cf_tst_cflags}" = "\"'" ; then cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags" continue fi ;; esac case "$CPPFLAGS" in *$cf_add_cflags) #(vi ;; *) #(vi cf_new_cppflags="$cf_new_cppflags $cf_add_cflags" ;; esac ;; *) cf_new_cflags="$cf_new_cflags $cf_add_cflags" ;; esac ;; yes) cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags" cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^[^"]*"'\''//'` test "${cf_add_cflags}" != "${cf_tst_cflags}" \ && test -z "${cf_tst_cflags}" \ && cf_fix_cppflags=no ;; esac done if test -n "$cf_new_cflags" ; then CFLAGS="$CFLAGS $cf_new_cflags" fi if test -n "$cf_new_cppflags" ; then CPPFLAGS="$CPPFLAGS $cf_new_cppflags" fi if test -n "$cf_new_extra_cppflags" ; then EXTRA_CPPFLAGS="$cf_new_extra_cppflags $EXTRA_CPPFLAGS" fi ;; esac ;; esac if test "$with_dbmalloc" = yes ; then echo "$as_me:7309: checking for dbmalloc.h" >&5 echo $ECHO_N "checking for dbmalloc.h... $ECHO_C" >&6 if test "${ac_cv_header_dbmalloc_h+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else cat >conftest.$ac_ext <<_ACEOF #line 7315 "configure" #include "confdefs.h" #include _ACEOF if { (eval echo "$as_me:7319: \"$ac_cpp conftest.$ac_ext\"") >&5 (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1 ac_status=$? egrep -v '^ *\+' conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo "$as_me:7325: \$? = $ac_status" >&5 (exit $ac_status); } >/dev/null; then if test -s conftest.err; then ac_cpp_err=$ac_c_preproc_warn_flag else ac_cpp_err= fi else ac_cpp_err=yes fi if test -z "$ac_cpp_err"; then ac_cv_header_dbmalloc_h=yes else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 ac_cv_header_dbmalloc_h=no fi rm -f conftest.err conftest.$ac_ext fi echo "$as_me:7344: result: $ac_cv_header_dbmalloc_h" >&5 echo "${ECHO_T}$ac_cv_header_dbmalloc_h" >&6 if test $ac_cv_header_dbmalloc_h = yes; then echo "$as_me:7348: checking for debug_malloc in -ldbmalloc" >&5 echo $ECHO_N "checking for debug_malloc in -ldbmalloc... $ECHO_C" >&6 if test "${ac_cv_lib_dbmalloc_debug_malloc+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else ac_check_lib_save_LIBS=$LIBS LIBS="-ldbmalloc $LIBS" cat >conftest.$ac_ext <<_ACEOF #line 7356 "configure" #include "confdefs.h" /* Override any gcc2 internal prototype to avoid an error. */ #ifdef __cplusplus extern "C" #endif /* We use char because int might match the return type of a gcc2 builtin and then its argument prototype would still apply. */ char debug_malloc (); int main () { debug_malloc (); ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (eval echo "$as_me:7375: \"$ac_link\"") >&5 (eval $ac_link) 2>&5 ac_status=$? echo "$as_me:7378: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest$ac_exeext' { (eval echo "$as_me:7381: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:7384: \$? = $ac_status" >&5 (exit $ac_status); }; }; then ac_cv_lib_dbmalloc_debug_malloc=yes else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 ac_cv_lib_dbmalloc_debug_malloc=no fi rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi echo "$as_me:7395: result: $ac_cv_lib_dbmalloc_debug_malloc" >&5 echo "${ECHO_T}$ac_cv_lib_dbmalloc_debug_malloc" >&6 if test $ac_cv_lib_dbmalloc_debug_malloc = yes; then cat >>confdefs.h <&5 echo $ECHO_N "checking if you want to use valgrind for testing... $ECHO_C" >&6 # Check whether --with-valgrind or --without-valgrind was given. if test "${with_valgrind+set}" = set; then withval="$with_valgrind" cat >>confdefs.h <<\EOF #define USE_VALGRIND 1 EOF : ${with_cflags:=-g} : ${with_no_leaks:=yes} with_valgrind=yes else with_valgrind= fi; echo "$as_me:7426: result: ${with_valgrind:-no}" >&5 echo "${ECHO_T}${with_valgrind:-no}" >&6 case .$with_cflags in #(vi .*-g*) case .$CFLAGS in #(vi .*-g*) #(vi ;; *) cf_fix_cppflags=no cf_new_cflags= cf_new_cppflags= cf_new_extra_cppflags= for cf_add_cflags in -g do case $cf_fix_cppflags in no) case $cf_add_cflags in #(vi -undef|-nostdinc*|-I*|-D*|-U*|-E|-P|-C) #(vi case $cf_add_cflags in -D*) cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^-D[^=]*='\''\"[^"]*//'` test "${cf_add_cflags}" != "${cf_tst_cflags}" \ && test -z "${cf_tst_cflags}" \ && cf_fix_cppflags=yes if test $cf_fix_cppflags = yes ; then cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags" continue elif test "${cf_tst_cflags}" = "\"'" ; then cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags" continue fi ;; esac case "$CPPFLAGS" in *$cf_add_cflags) #(vi ;; *) #(vi cf_new_cppflags="$cf_new_cppflags $cf_add_cflags" ;; esac ;; *) cf_new_cflags="$cf_new_cflags $cf_add_cflags" ;; esac ;; yes) cf_new_extra_cppflags="$cf_new_extra_cppflags $cf_add_cflags" cf_tst_cflags=`echo ${cf_add_cflags} |sed -e 's/^[^"]*"'\''//'` test "${cf_add_cflags}" != "${cf_tst_cflags}" \ && test -z "${cf_tst_cflags}" \ && cf_fix_cppflags=no ;; esac done if test -n "$cf_new_cflags" ; then CFLAGS="$CFLAGS $cf_new_cflags" fi if test -n "$cf_new_cppflags" ; then CPPFLAGS="$CPPFLAGS $cf_new_cppflags" fi if test -n "$cf_new_extra_cppflags" ; then EXTRA_CPPFLAGS="$cf_new_extra_cppflags $EXTRA_CPPFLAGS" fi ;; esac ;; esac echo "$as_me:7509: checking if you want to perform memory-leak testing" >&5 echo $ECHO_N "checking if you want to perform memory-leak testing... $ECHO_C" >&6 # Check whether --enable-leaks or --disable-leaks was given. if test "${enable_leaks+set}" = set; then enableval="$enable_leaks" with_no_leaks=yes else : ${with_no_leaks:=no} fi; echo "$as_me:7519: result: $with_no_leaks" >&5 echo "${ECHO_T}$with_no_leaks" >&6 if test "$with_no_leaks" = yes ; then cat >>confdefs.h <<\EOF #define NO_LEAKS 1 EOF fi # look for curses-related headers for ac_header in \ nc_alloc.h \ nc_tparm.h \ nomacros.h \ term_entry.h \ do as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh` echo "$as_me:7539: checking for $ac_header" >&5 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6 if eval "test \"\${$as_ac_Header+set}\" = set"; then echo $ECHO_N "(cached) $ECHO_C" >&6 else cat >conftest.$ac_ext <<_ACEOF #line 7545 "configure" #include "confdefs.h" #include <$ac_header> _ACEOF if { (eval echo "$as_me:7549: \"$ac_cpp conftest.$ac_ext\"") >&5 (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1 ac_status=$? egrep -v '^ *\+' conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo "$as_me:7555: \$? = $ac_status" >&5 (exit $ac_status); } >/dev/null; then if test -s conftest.err; then ac_cpp_err=$ac_c_preproc_warn_flag else ac_cpp_err= fi else ac_cpp_err=yes fi if test -z "$ac_cpp_err"; then eval "$as_ac_Header=yes" else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 eval "$as_ac_Header=no" fi rm -f conftest.err conftest.$ac_ext fi echo "$as_me:7574: result: `eval echo '${'$as_ac_Header'}'`" >&5 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6 if test `eval echo '${'$as_ac_Header'}'` = yes; then cat >>confdefs.h <&5 echo $ECHO_N "checking return type of signal handlers... $ECHO_C" >&6 if test "${ac_cv_type_signal+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else cat >conftest.$ac_ext <<_ACEOF #line 7590 "configure" #include "confdefs.h" #include #include #ifdef signal # undef signal #endif #ifdef __cplusplus extern "C" void (*signal (int, void (*)(int)))(int); #else void (*signal ()) (); #endif int main () { int i; ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (eval echo "$as_me:7612: \"$ac_compile\"") >&5 (eval $ac_compile) 2>&5 ac_status=$? echo "$as_me:7615: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest.$ac_objext' { (eval echo "$as_me:7618: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:7621: \$? = $ac_status" >&5 (exit $ac_status); }; }; then ac_cv_type_signal=void else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 ac_cv_type_signal=int fi rm -f conftest.$ac_objext conftest.$ac_ext fi echo "$as_me:7631: result: $ac_cv_type_signal" >&5 echo "${ECHO_T}$ac_cv_type_signal" >&6 cat >>confdefs.h <&5 echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6 if test "${ac_cv_header_stdc+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else cat >conftest.$ac_ext <<_ACEOF #line 7644 "configure" #include "confdefs.h" #include #include #include #include _ACEOF if { (eval echo "$as_me:7652: \"$ac_cpp conftest.$ac_ext\"") >&5 (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1 ac_status=$? egrep -v '^ *\+' conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo "$as_me:7658: \$? = $ac_status" >&5 (exit $ac_status); } >/dev/null; then if test -s conftest.err; then ac_cpp_err=$ac_c_preproc_warn_flag else ac_cpp_err= fi else ac_cpp_err=yes fi if test -z "$ac_cpp_err"; then ac_cv_header_stdc=yes else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 ac_cv_header_stdc=no fi rm -f conftest.err conftest.$ac_ext if test $ac_cv_header_stdc = yes; then # SunOS 4.x string.h does not declare mem*, contrary to ANSI. cat >conftest.$ac_ext <<_ACEOF #line 7680 "configure" #include "confdefs.h" #include _ACEOF if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | egrep "memchr" >/dev/null 2>&1; then : else ac_cv_header_stdc=no fi rm -f conftest* fi if test $ac_cv_header_stdc = yes; then # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI. cat >conftest.$ac_ext <<_ACEOF #line 7698 "configure" #include "confdefs.h" #include _ACEOF if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | egrep "free" >/dev/null 2>&1; then : else ac_cv_header_stdc=no fi rm -f conftest* fi if test $ac_cv_header_stdc = yes; then # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi. if test "$cross_compiling" = yes; then : else cat >conftest.$ac_ext <<_ACEOF #line 7719 "configure" #include "confdefs.h" #include #if ((' ' & 0x0FF) == 0x020) # define ISLOWER(c) ('a' <= (c) && (c) <= 'z') # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c)) #else # define ISLOWER(c) (('a' <= (c) && (c) <= 'i') \ || ('j' <= (c) && (c) <= 'r') \ || ('s' <= (c) && (c) <= 'z')) # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c)) #endif #define XOR(e, f) (((e) && !(f)) || (!(e) && (f))) int main () { int i; for (i = 0; i < 256; i++) if (XOR (islower (i), ISLOWER (i)) || toupper (i) != TOUPPER (i)) $ac_main_return(2); $ac_main_return (0); } _ACEOF rm -f conftest$ac_exeext if { (eval echo "$as_me:7745: \"$ac_link\"") >&5 (eval $ac_link) 2>&5 ac_status=$? echo "$as_me:7748: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='./conftest$ac_exeext' { (eval echo "$as_me:7750: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:7753: \$? = $ac_status" >&5 (exit $ac_status); }; }; then : else echo "$as_me: program exited with status $ac_status" >&5 echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 ac_cv_header_stdc=no fi rm -f core core.* *.core conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext fi fi fi echo "$as_me:7766: result: $ac_cv_header_stdc" >&5 echo "${ECHO_T}$ac_cv_header_stdc" >&6 if test $ac_cv_header_stdc = yes; then cat >>confdefs.h <<\EOF #define STDC_HEADERS 1 EOF fi echo "$as_me:7776: checking whether time.h and sys/time.h may both be included" >&5 echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6 if test "${ac_cv_header_time+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else cat >conftest.$ac_ext <<_ACEOF #line 7782 "configure" #include "confdefs.h" #include #include #include int main () { if ((struct tm *) 0) return 0; ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (eval echo "$as_me:7798: \"$ac_compile\"") >&5 (eval $ac_compile) 2>&5 ac_status=$? echo "$as_me:7801: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest.$ac_objext' { (eval echo "$as_me:7804: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:7807: \$? = $ac_status" >&5 (exit $ac_status); }; }; then ac_cv_header_time=yes else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 ac_cv_header_time=no fi rm -f conftest.$ac_objext conftest.$ac_ext fi echo "$as_me:7817: result: $ac_cv_header_time" >&5 echo "${ECHO_T}$ac_cv_header_time" >&6 if test $ac_cv_header_time = yes; then cat >>confdefs.h <<\EOF #define TIME_WITH_SYS_TIME 1 EOF fi for ac_header in \ getopt.h \ locale.h \ stdarg.h \ sys/ioctl.h \ sys/select.h \ sys/time.h \ termios.h \ unistd.h \ do as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh` echo "$as_me:7839: checking for $ac_header" >&5 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6 if eval "test \"\${$as_ac_Header+set}\" = set"; then echo $ECHO_N "(cached) $ECHO_C" >&6 else cat >conftest.$ac_ext <<_ACEOF #line 7845 "configure" #include "confdefs.h" #include <$ac_header> _ACEOF if { (eval echo "$as_me:7849: \"$ac_cpp conftest.$ac_ext\"") >&5 (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1 ac_status=$? egrep -v '^ *\+' conftest.er1 >conftest.err rm -f conftest.er1 cat conftest.err >&5 echo "$as_me:7855: \$? = $ac_status" >&5 (exit $ac_status); } >/dev/null; then if test -s conftest.err; then ac_cpp_err=$ac_c_preproc_warn_flag else ac_cpp_err= fi else ac_cpp_err=yes fi if test -z "$ac_cpp_err"; then eval "$as_ac_Header=yes" else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 eval "$as_ac_Header=no" fi rm -f conftest.err conftest.$ac_ext fi echo "$as_me:7874: result: `eval echo '${'$as_ac_Header'}'`" >&5 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6 if test `eval echo '${'$as_ac_Header'}'` = yes; then cat >>confdefs.h <&5 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6 if eval "test \"\${$as_ac_var+set}\" = set"; then echo $ECHO_N "(cached) $ECHO_C" >&6 else cat >conftest.$ac_ext <<_ACEOF #line 7898 "configure" #include "confdefs.h" /* System header to define __stub macros and hopefully few prototypes, which can conflict with char $ac_func (); below. */ #include /* Override any gcc2 internal prototype to avoid an error. */ #ifdef __cplusplus extern "C" #endif /* We use char because int might match the return type of a gcc2 builtin and then its argument prototype would still apply. */ char $ac_func (); char (*f) (); int main () { /* The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. */ #if defined (__stub_$ac_func) || defined (__stub___$ac_func) choke me #else f = $ac_func; #endif ; return 0; } _ACEOF rm -f conftest.$ac_objext conftest$ac_exeext if { (eval echo "$as_me:7929: \"$ac_link\"") >&5 (eval $ac_link) 2>&5 ac_status=$? echo "$as_me:7932: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest$ac_exeext' { (eval echo "$as_me:7935: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:7938: \$? = $ac_status" >&5 (exit $ac_status); }; }; then eval "$as_ac_var=yes" else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 eval "$as_ac_var=no" fi rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext fi echo "$as_me:7948: result: `eval echo '${'$as_ac_var'}'`" >&5 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6 if test `eval echo '${'$as_ac_var'}'` = yes; then cat >>confdefs.h <&5 echo $ECHO_N "checking if sys/time.h works with sys/select.h... $ECHO_C" >&6 if test "${cf_cv_sys_time_select+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else cat >conftest.$ac_ext <<_ACEOF #line 7965 "configure" #include "confdefs.h" #include #ifdef HAVE_SYS_TIME_H #include #endif #ifdef HAVE_SYS_SELECT_H #include #endif int main () { ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (eval echo "$as_me:7985: \"$ac_compile\"") >&5 (eval $ac_compile) 2>&5 ac_status=$? echo "$as_me:7988: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest.$ac_objext' { (eval echo "$as_me:7991: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:7994: \$? = $ac_status" >&5 (exit $ac_status); }; }; then cf_cv_sys_time_select=yes else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 cf_cv_sys_time_select=no fi rm -f conftest.$ac_objext conftest.$ac_ext fi echo "$as_me:8006: result: $cf_cv_sys_time_select" >&5 echo "${ECHO_T}$cf_cv_sys_time_select" >&6 test "$cf_cv_sys_time_select" = yes && cat >>confdefs.h <<\EOF #define HAVE_SYS_TIME_SELECT 1 EOF echo "$as_me:8012: checking for signal global datatype" >&5 echo $ECHO_N "checking for signal global datatype... $ECHO_C" >&6 if test "${cf_cv_sig_atomic_t+set}" = set; then echo $ECHO_N "(cached) $ECHO_C" >&6 else for cf_type in \ "volatile sig_atomic_t" \ "sig_atomic_t" \ "int" do cat >conftest.$ac_ext <<_ACEOF #line 8024 "configure" #include "confdefs.h" #include #include #include extern $cf_type x; $cf_type x; static void handler(int sig) { x = 5; } int main () { signal(SIGINT, handler); x = 1 ; return 0; } _ACEOF rm -f conftest.$ac_objext if { (eval echo "$as_me:8047: \"$ac_compile\"") >&5 (eval $ac_compile) 2>&5 ac_status=$? echo "$as_me:8050: \$? = $ac_status" >&5 (exit $ac_status); } && { ac_try='test -s conftest.$ac_objext' { (eval echo "$as_me:8053: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? echo "$as_me:8056: \$? = $ac_status" >&5 (exit $ac_status); }; }; then cf_cv_sig_atomic_t=$cf_type else echo "$as_me: failed program was:" >&5 cat conftest.$ac_ext >&5 cf_cv_sig_atomic_t=no fi rm -f conftest.$ac_objext conftest.$ac_ext test "$cf_cv_sig_atomic_t" != no && break done fi echo "$as_me:8070: result: $cf_cv_sig_atomic_t" >&5 echo "${ECHO_T}$cf_cv_sig_atomic_t" >&6 test "$cf_cv_sig_atomic_t" != no && cat >>confdefs.h <confcache <<\_ACEOF # This file is a shell script that caches the results of configure # tests run on this system so they can be shared between configure # scripts and configure runs, see configure's option --config-cache. # It is not useful on other systems. If it contains results you don't # want to keep, you may remove or edit it. # # config.status only pays attention to the cache file if you give it # the --recheck option to rerun configure. # # `ac_cv_env_foo' variables (set or unset) will be overriden when # loading this file, other *unset* `ac_cv_foo' will be assigned the # following values. _ACEOF # The following way of writing the cache mishandles newlines in values, # but we know of no workaround that is simple, portable, and efficient. # So, don't put newlines in cache variables' values. # Ultrix sh set writes to stderr and can't be redirected directly, # and sets the high bit in the cache file unless we assign to the vars. { (set) 2>&1 | case `(ac_space=' '; set | grep ac_space) 2>&1` in *ac_space=\ *) # `set' does not quote correctly, so add quotes (double-quote # substitution turns \\\\ into \\, and sed turns \\ into \). sed -n \ "s/'/'\\\\''/g; s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p" ;; *) # `set' quotes correctly as required by POSIX, so do not add quotes. sed -n \ "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p" ;; esac; } | sed ' t clear : clear s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/ t end /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/ : end' >>confcache if cmp -s $cache_file confcache; then :; else if test -w $cache_file; then test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file" cat confcache >$cache_file else echo "not updating unwritable cache $cache_file" fi fi rm -f confcache test "x$prefix" = xNONE && prefix=$ac_default_prefix # Let make expand exec_prefix. test "x$exec_prefix" = xNONE && exec_prefix='${prefix}' # VPATH may cause trouble with some makes, so we remove $(srcdir), # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and # trailing colons and then remove the whole line if VPATH becomes empty # (actually we leave an empty line to preserve line numbers). if test "x$srcdir" = x.; then ac_vpsub='/^[ ]*VPATH[ ]*=/{ s/:*\$(srcdir):*/:/; s/:*\${srcdir}:*/:/; s/:*@srcdir@:*/:/; s/^\([^=]*=[ ]*\):*/\1/; s/:*$//; s/^[^=]*=[ ]*$//; }' fi DEFS=-DHAVE_CONFIG_H : ${CONFIG_STATUS=./config.status} ac_clean_files_save=$ac_clean_files ac_clean_files="$ac_clean_files $CONFIG_STATUS" { echo "$as_me:8160: creating $CONFIG_STATUS" >&5 echo "$as_me: creating $CONFIG_STATUS" >&6;} cat >$CONFIG_STATUS <<_ACEOF #! $SHELL # Generated automatically by configure. # Run this file to recreate the current configuration. # Compiler output produced by configure, useful for debugging # configure, is in config.log if it exists. debug=false SHELL=\${CONFIG_SHELL-$SHELL} ac_cs_invocation="\$0 \$@" _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF # Be Bourne compatible if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then emulate sh NULLCMD=: elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then set -o posix fi # Name of the executable. as_me=`echo "$0" |sed 's,.*[\\/],,'` if expr a : '\(a\)' >/dev/null 2>&1; then as_expr=expr else as_expr=false fi rm -f conf$$ conf$$.exe conf$$.file echo >conf$$.file if ln -s conf$$.file conf$$ 2>/dev/null; then # We could just check for DJGPP; but this test a) works b) is more generic # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04). if test -f conf$$.exe; then # Don't use ln at all; we don't have any links as_ln_s='cp -p' else as_ln_s='ln -s' fi elif ln conf$$.file conf$$ 2>/dev/null; then as_ln_s=ln else as_ln_s='cp -p' fi rm -f conf$$ conf$$.exe conf$$.file as_executable_p="test -f" # Support unset when possible. if (FOO=FOO; unset FOO) >/dev/null 2>&1; then as_unset=unset else as_unset=false fi # NLS nuisances. $as_unset LANG || test "${LANG+set}" != set || { LANG=C; export LANG; } $as_unset LC_ALL || test "${LC_ALL+set}" != set || { LC_ALL=C; export LC_ALL; } $as_unset LC_TIME || test "${LC_TIME+set}" != set || { LC_TIME=C; export LC_TIME; } $as_unset LC_CTYPE || test "${LC_CTYPE+set}" != set || { LC_CTYPE=C; export LC_CTYPE; } $as_unset LANGUAGE || test "${LANGUAGE+set}" != set || { LANGUAGE=C; export LANGUAGE; } $as_unset LC_COLLATE || test "${LC_COLLATE+set}" != set || { LC_COLLATE=C; export LC_COLLATE; } $as_unset LC_NUMERIC || test "${LC_NUMERIC+set}" != set || { LC_NUMERIC=C; export LC_NUMERIC; } $as_unset LC_MESSAGES || test "${LC_MESSAGES+set}" != set || { LC_MESSAGES=C; export LC_MESSAGES; } # IFS # We need space, tab and new line, in precisely that order. as_nl=' ' IFS=" $as_nl" # CDPATH. $as_unset CDPATH || test "${CDPATH+set}" != set || { CDPATH=:; export CDPATH; } exec 6>&1 _ACEOF # Files that config.status was made for. if test -n "$ac_config_files"; then echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS fi if test -n "$ac_config_headers"; then echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS fi if test -n "$ac_config_links"; then echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS fi if test -n "$ac_config_commands"; then echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS fi cat >>$CONFIG_STATUS <<\EOF ac_cs_usage="\ \`$as_me' instantiates files from templates according to the current configuration. Usage: $0 [OPTIONS] [FILE]... -h, --help print this help, then exit -V, --version print version number, then exit -d, --debug don't remove temporary files --recheck update $as_me by reconfiguring in the same conditions --file=FILE[:TEMPLATE] instantiate the configuration file FILE --header=FILE[:TEMPLATE] instantiate the configuration header FILE Configuration files: $config_files Configuration headers: $config_headers Configuration commands: $config_commands Report bugs to ." EOF cat >>$CONFIG_STATUS <>$CONFIG_STATUS <<\EOF # If no file are specified by the user, then we need to provide default # value. By we need to know if files were specified by the user. ac_need_defaults=: while test $# != 0 do case $1 in --*=*) ac_option=`expr "x$1" : 'x\([^=]*\)='` ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'` shift set dummy "$ac_option" "$ac_optarg" ${1+"$@"} shift ;; -*);; *) # This is not an option, so the user has probably given explicit # arguments. ac_need_defaults=false;; esac case $1 in # Handling of the options. EOF cat >>$CONFIG_STATUS <>$CONFIG_STATUS <<\EOF --version | --vers* | -V ) echo "$ac_cs_version"; exit 0 ;; --he | --h) # Conflict between --help and --header { { echo "$as_me:8336: error: ambiguous option: $1 Try \`$0 --help' for more information." >&5 echo "$as_me: error: ambiguous option: $1 Try \`$0 --help' for more information." >&2;} { (exit 1); exit 1; }; };; --help | --hel | -h ) echo "$ac_cs_usage"; exit 0 ;; --debug | --d* | -d ) debug=: ;; --file | --fil | --fi | --f ) shift CONFIG_FILES="$CONFIG_FILES $1" ac_need_defaults=false;; --header | --heade | --head | --hea ) shift CONFIG_HEADERS="$CONFIG_HEADERS $1" ac_need_defaults=false;; # This is an error. -*) { { echo "$as_me:8355: error: unrecognized option: $1 Try \`$0 --help' for more information." >&5 echo "$as_me: error: unrecognized option: $1 Try \`$0 --help' for more information." >&2;} { (exit 1); exit 1; }; } ;; *) ac_config_targets="$ac_config_targets $1" ;; esac shift done exec 5>>config.log cat >&5 << _ACEOF ## ----------------------- ## ## Running config.status. ## ## ----------------------- ## This file was extended by $as_me 2.52.20081225, executed with CONFIG_FILES = $CONFIG_FILES CONFIG_HEADERS = $CONFIG_HEADERS CONFIG_LINKS = $CONFIG_LINKS CONFIG_COMMANDS = $CONFIG_COMMANDS > $ac_cs_invocation on `(hostname || uname -n) 2>/dev/null | sed 1q` _ACEOF EOF cat >>$CONFIG_STATUS <>$CONFIG_STATUS <<\EOF for ac_config_target in $ac_config_targets do case "$ac_config_target" in # Handling of arguments. "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;; "default" ) CONFIG_COMMANDS="$CONFIG_COMMANDS default" ;; "ncurses_cfg.h" ) CONFIG_HEADERS="$CONFIG_HEADERS ncurses_cfg.h:ncurses_tst.hin" ;; *) { { echo "$as_me:8402: error: invalid argument: $ac_config_target" >&5 echo "$as_me: error: invalid argument: $ac_config_target" >&2;} { (exit 1); exit 1; }; };; esac done # If the user did not use the arguments to specify the items to instantiate, # then the envvar interface is used. Set only those that are not. # We use the long form for the default assignment because of an extremely # bizarre bug on SunOS 4.1.3. if $ac_need_defaults; then test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers test "${CONFIG_COMMANDS+set}" = set || CONFIG_COMMANDS=$config_commands fi # Create a temporary directory, and hook for its removal unless debugging. $debug || { trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0 trap '{ (exit 1); exit 1; }' 1 2 13 15 } # Create a (secure) tmp directory for tmp files. : ${TMPDIR=/tmp} { tmp=`(umask 077 && mktemp -d -q "$TMPDIR/csXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" } || { tmp=$TMPDIR/cs$$-$RANDOM (umask 077 && mkdir $tmp) } || { echo "$me: cannot create a temporary directory in $TMPDIR" >&2 { (exit 1); exit 1; } } EOF cat >>$CONFIG_STATUS <\$tmp/subs.sed <<\\CEOF s,@SHELL@,$SHELL,;t t s,@exec_prefix@,$exec_prefix,;t t s,@prefix@,$prefix,;t t s,@program_transform_name@,$program_transform_name,;t t s,@bindir@,$bindir,;t t s,@sbindir@,$sbindir,;t t s,@libexecdir@,$libexecdir,;t t s,@datadir@,$datadir,;t t s,@sysconfdir@,$sysconfdir,;t t s,@sharedstatedir@,$sharedstatedir,;t t s,@localstatedir@,$localstatedir,;t t s,@libdir@,$libdir,;t t s,@includedir@,$includedir,;t t s,@oldincludedir@,$oldincludedir,;t t s,@infodir@,$infodir,;t t s,@mandir@,$mandir,;t t s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t s,@build_alias@,$build_alias,;t t s,@host_alias@,$host_alias,;t t s,@target_alias@,$target_alias,;t t s,@ECHO_C@,$ECHO_C,;t t s,@ECHO_N@,$ECHO_N,;t t s,@ECHO_T@,$ECHO_T,;t t s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t s,@DEFS@,$DEFS,;t t s,@LIBS@,$LIBS,;t t s,@build@,$build,;t t s,@build_cpu@,$build_cpu,;t t s,@build_vendor@,$build_vendor,;t t s,@build_os@,$build_os,;t t s,@host@,$host,;t t s,@host_cpu@,$host_cpu,;t t s,@host_vendor@,$host_vendor,;t t s,@host_os@,$host_os,;t t s,@SET_MAKE@,$SET_MAKE,;t t s,@CC@,$CC,;t t s,@CFLAGS@,$CFLAGS,;t t s,@LDFLAGS@,$LDFLAGS,;t t s,@CPPFLAGS@,$CPPFLAGS,;t t s,@ac_ct_CC@,$ac_ct_CC,;t t s,@EXEEXT@,$EXEEXT,;t t s,@OBJEXT@,$OBJEXT,;t t s,@CPP@,$CPP,;t t s,@AWK@,$AWK,;t t s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t s,@INSTALL_DATA@,$INSTALL_DATA,;t t s,@LN_S@,$LN_S,;t t s,@MAKE_LOWER_TAGS@,$MAKE_LOWER_TAGS,;t t s,@MAKE_UPPER_TAGS@,$MAKE_UPPER_TAGS,;t t s,@CC_G_OPT@,$CC_G_OPT,;t t s,@CC_SHARED_OPTS@,$CC_SHARED_OPTS,;t t s,@DESTDIR@,$DESTDIR,;t t s,@DFT_DEP_SUFFIX@,$DFT_DEP_SUFFIX,;t t s,@DFT_OBJ_SUBDIR@,$DFT_OBJ_SUBDIR,;t t s,@DFT_UPR_MODEL@,$DFT_UPR_MODEL,;t t s,@ECHO_LINK@,$ECHO_LINK,;t t s,@EXTRA_LDFLAGS@,$EXTRA_LDFLAGS,;t t s,@LD@,$LD,;t t s,@LDFLAGS_SHARED@,$LDFLAGS_SHARED,;t t s,@LD_MODEL@,$LD_MODEL,;t t s,@LD_SHARED_OPTS@,$LD_SHARED_OPTS,;t t s,@LIBTOOL@,$LIBTOOL,;t t s,@LIB_CLEAN@,$LIB_CLEAN,;t t s,@LIB_COMPILE@,$LIB_COMPILE,;t t s,@LIB_INSTALL@,$LIB_INSTALL,;t t s,@LIB_LINK@,$LIB_LINK,;t t s,@LIB_SUFFIX@,$LIB_SUFFIX,;t t s,@LIB_UNINSTALL@,$LIB_UNINSTALL,;t t s,@LINK_PROGS@,$LINK_PROGS,;t t s,@LINT@,$LINT,;t t s,@LINT_OPTS@,$LINT_OPTS,;t t s,@LOCAL_LDFLAGS@,$LOCAL_LDFLAGS,;t t s,@MATH_LIB@,$MATH_LIB,;t t s,@TICS_ARGS@,$TICS_ARGS,;t t s,@TINFO_ARGS@,$TINFO_ARGS,;t t s,@cf_cv_abi_version@,$cf_cv_abi_version,;t t s,@cf_cv_rel_version@,$cf_cv_rel_version,;t t s,@NCURSES_TREE@,$NCURSES_TREE,;t t s,@EXTRA_CPPFLAGS@,$EXTRA_CPPFLAGS,;t t s,@EXTRA_CFLAGS@,$EXTRA_CFLAGS,;t t s,@NCURSES_CONFIG@,$NCURSES_CONFIG,;t t CEOF EOF cat >>$CONFIG_STATUS <<\EOF # Split the substitutions into bite-sized pieces for seds with # small command number limits, like on Digital OSF/1 and HP-UX. ac_max_sed_lines=48 ac_sed_frag=1 # Number of current file. ac_beg=1 # First line for current file. ac_end=$ac_max_sed_lines # Line after last line for current file. ac_more_lines=: ac_sed_cmds= while $ac_more_lines; do if test $ac_beg -gt 1; then sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag else sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag fi if test ! -s $tmp/subs.frag; then ac_more_lines=false else # The purpose of the label and of the branching condition is to # speed up the sed processing (if there are no `@' at all, there # is no need to browse any of the substitutions). # These are the two extra sed commands mentioned above. (echo ':t /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed if test -z "$ac_sed_cmds"; then ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed" else ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed" fi ac_sed_frag=`expr $ac_sed_frag + 1` ac_beg=$ac_end ac_end=`expr $ac_end + $ac_max_sed_lines` fi done if test -z "$ac_sed_cmds"; then ac_sed_cmds=cat fi fi # test -n "$CONFIG_FILES" EOF cat >>$CONFIG_STATUS <<\EOF for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in". case $ac_file in - | *:- | *:-:* ) # input from stdin cat >$tmp/stdin ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'` ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;; *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'` ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;; * ) ac_file_in=$ac_file.in ;; esac # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories. ac_dir=`$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$ac_file" : 'X\(//\)[^/]' \| \ X"$ac_file" : 'X\(//\)$' \| \ X"$ac_file" : 'X\(/\)' \| \ . : '\(.\)' 2>/dev/null || echo X"$ac_file" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; } /^X\(\/\/\)[^/].*/{ s//\1/; q; } /^X\(\/\/\)$/{ s//\1/; q; } /^X\(\/\).*/{ s//\1/; q; } s/.*/./; q'` if test "$ac_dir" != "$ac_file" && test "$ac_dir" != .; then { case "$ac_dir" in [\\/]* | ?:[\\/]* ) as_incr_dir=;; *) as_incr_dir=.;; esac as_dummy="$ac_dir" for as_mkdir_dir in `IFS='/\\'; set X $as_dummy; shift; echo "$@"`; do case $as_mkdir_dir in # Skip DOS drivespec ?:) as_incr_dir=$as_mkdir_dir ;; *) as_incr_dir=$as_incr_dir/$as_mkdir_dir test -d "$as_incr_dir" || mkdir "$as_incr_dir" ;; esac done; } ac_dir_suffix="/`echo $ac_dir|sed 's,^\./,,'`" # A "../" for each directory in $ac_dir_suffix. ac_dots=`echo "$ac_dir_suffix" | sed 's,/[^/]*,../,g'` else ac_dir_suffix= ac_dots= fi case $srcdir in .) ac_srcdir=. if test -z "$ac_dots"; then ac_top_srcdir=. else ac_top_srcdir=`echo $ac_dots | sed 's,/$,,'` fi ;; [\\/]* | ?:[\\/]* ) ac_srcdir=$srcdir$ac_dir_suffix; ac_top_srcdir=$srcdir ;; *) # Relative path. ac_srcdir=$ac_dots$srcdir$ac_dir_suffix ac_top_srcdir=$ac_dots$srcdir ;; esac case $INSTALL in [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;; *) ac_INSTALL=$ac_dots$INSTALL ;; esac if test x"$ac_file" != x-; then { echo "$as_me:8654: creating $ac_file" >&5 echo "$as_me: creating $ac_file" >&6;} rm -f "$ac_file" fi # Let's still pretend it is `configure' which instantiates (i.e., don't # use $as_me), people would be surprised to read: # /* config.h. Generated automatically by config.status. */ configure_input="Generated automatically from `echo $ac_file_in | sed 's,.*/,,'` by configure." # First look for the input files in the build tree, otherwise in the # src tree. ac_file_inputs=`IFS=: for f in $ac_file_in; do case $f in -) echo $tmp/stdin ;; [\\/$]*) # Absolute (can't be DOS-style, as IFS=:) test -f "$f" || { { echo "$as_me:8672: error: cannot find input file: $f" >&5 echo "$as_me: error: cannot find input file: $f" >&2;} { (exit 1); exit 1; }; } echo $f;; *) # Relative if test -f "$f"; then # Build tree echo $f elif test -f "$srcdir/$f"; then # Source tree echo $srcdir/$f else # /dev/null tree { { echo "$as_me:8685: error: cannot find input file: $f" >&5 echo "$as_me: error: cannot find input file: $f" >&2;} { (exit 1); exit 1; }; } fi;; esac done` || { (exit 1); exit 1; } EOF cat >>$CONFIG_STATUS <>$CONFIG_STATUS <<\EOF :t /@[a-zA-Z_][a-zA-Z_0-9]*@/!b s,@configure_input@,$configure_input,;t t s,@srcdir@,$ac_srcdir,;t t s,@top_srcdir@,$ac_top_srcdir,;t t s,@INSTALL@,$ac_INSTALL,;t t " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out rm -f $tmp/stdin if test x"$ac_file" != x-; then mv $tmp/out $ac_file else cat $tmp/out rm -f $tmp/out fi done EOF cat >>$CONFIG_STATUS <<\EOF # # CONFIG_HEADER section. # # These sed commands are passed to sed as "A NAME B NAME C VALUE D", where # NAME is the cpp macro being defined and VALUE is the value it is being given. # # ac_d sets the value in "#define NAME VALUE" lines. ac_dA='s,^\([ ]*\)#\([ ]*define[ ][ ]*\)' ac_dB='[ ].*$,\1#\2' ac_dC=' ' ac_dD=',;t' # ac_i turns "#undef NAME" with trailing blanks into "#define NAME VALUE". ac_iA='s,^\([ ]*\)#\([ ]*\)undef\([ ][ ]*\)' ac_iB='\([ ]\),\1#\2define\3' ac_iC=' ' ac_iD='\4,;t' # ac_u turns "#undef NAME" without trailing blanks into "#define NAME VALUE". ac_uA='s,^\([ ]*\)#\([ ]*\)undef\([ ][ ]*\)' ac_uB='$,\1#\2define\3' ac_uC=' ' ac_uD=',;t' for ac_file in : $CONFIG_HEADERS; do test "x$ac_file" = x: && continue # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in". case $ac_file in - | *:- | *:-:* ) # input from stdin cat >$tmp/stdin ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'` ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;; *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'` ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;; * ) ac_file_in=$ac_file.in ;; esac test x"$ac_file" != x- && { echo "$as_me:8751: creating $ac_file" >&5 echo "$as_me: creating $ac_file" >&6;} # First look for the input files in the build tree, otherwise in the # src tree. ac_file_inputs=`IFS=: for f in $ac_file_in; do case $f in -) echo $tmp/stdin ;; [\\/$]*) # Absolute (can't be DOS-style, as IFS=:) test -f "$f" || { { echo "$as_me:8762: error: cannot find input file: $f" >&5 echo "$as_me: error: cannot find input file: $f" >&2;} { (exit 1); exit 1; }; } echo $f;; *) # Relative if test -f "$f"; then # Build tree echo $f elif test -f "$srcdir/$f"; then # Source tree echo $srcdir/$f else # /dev/null tree { { echo "$as_me:8775: error: cannot find input file: $f" >&5 echo "$as_me: error: cannot find input file: $f" >&2;} { (exit 1); exit 1; }; } fi;; esac done` || { (exit 1); exit 1; } # Remove the trailing spaces. sed 's/[ ]*$//' $ac_file_inputs >$tmp/in EOF # Transform confdefs.h into a list of #define's. We won't use it as a sed # script, but as data to insert where we see @DEFS@. We expect AC_SAVE_DEFS to # be either 'cat' or 'sort'. cat confdefs.h | uniq >conftest.vals # Break up conftest.vals because some shells have a limit on # the size of here documents, and old seds have small limits too. rm -f conftest.tail echo ' rm -f conftest.frag' >> $CONFIG_STATUS while grep . conftest.vals >/dev/null do # Write chunks of a limited-size here document to conftest.frag. echo ' cat >> conftest.frag <> $CONFIG_STATUS sed ${ac_max_here_lines}q conftest.vals | sed -e 's/#ifdef.*/#if 0/' >> $CONFIG_STATUS echo 'CEOF' >> $CONFIG_STATUS sed 1,${ac_max_here_lines}d conftest.vals > conftest.tail rm -f conftest.vals mv conftest.tail conftest.vals done rm -f conftest.vals # Run sed to substitute the contents of conftest.frag into $tmp/in at the # marker @DEFS@. echo ' cat >> conftest.edit < $tmp/out rm -f $tmp/in mv $tmp/out $tmp/in rm -f conftest.edit conftest.frag ' >> $CONFIG_STATUS cat >>$CONFIG_STATUS <<\EOF # Let's still pretend it is `configure' which instantiates (i.e., don't # use $as_me), people would be surprised to read: # /* config.h. Generated automatically by config.status. */ if test x"$ac_file" = x-; then echo "/* Generated automatically by configure. */" >$tmp/config.h else echo "/* $ac_file. Generated automatically by configure. */" >$tmp/config.h fi cat $tmp/in >>$tmp/config.h rm -f $tmp/in if test x"$ac_file" != x-; then if cmp -s $ac_file $tmp/config.h 2>/dev/null; then { echo "$as_me:8833: $ac_file is unchanged" >&5 echo "$as_me: $ac_file is unchanged" >&6;} else ac_dir=`$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$ac_file" : 'X\(//\)[^/]' \| \ X"$ac_file" : 'X\(//\)$' \| \ X"$ac_file" : 'X\(/\)' \| \ . : '\(.\)' 2>/dev/null || echo X"$ac_file" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; } /^X\(\/\/\)[^/].*/{ s//\1/; q; } /^X\(\/\/\)$/{ s//\1/; q; } /^X\(\/\).*/{ s//\1/; q; } s/.*/./; q'` if test "$ac_dir" != "$ac_file" && test "$ac_dir" != .; then { case "$ac_dir" in [\\/]* | ?:[\\/]* ) as_incr_dir=;; *) as_incr_dir=.;; esac as_dummy="$ac_dir" for as_mkdir_dir in `IFS='/\\'; set X $as_dummy; shift; echo "$@"`; do case $as_mkdir_dir in # Skip DOS drivespec ?:) as_incr_dir=$as_mkdir_dir ;; *) as_incr_dir=$as_incr_dir/$as_mkdir_dir test -d "$as_incr_dir" || mkdir "$as_incr_dir" ;; esac done; } fi rm -f $ac_file mv $tmp/config.h $ac_file fi else cat $tmp/config.h rm -f $tmp/config.h fi done EOF cat >>$CONFIG_STATUS <<\EOF # # CONFIG_COMMANDS section. # for ac_file in : $CONFIG_COMMANDS; do test "x$ac_file" = x: && continue ac_dest=`echo "$ac_file" | sed 's,:.*,,'` ac_source=`echo "$ac_file" | sed 's,[^:]*:,,'` case $ac_dest in default ) for cf_dir in . do if test ! -d $srcdir/$cf_dir; then continue elif test -f $srcdir/$cf_dir/programs; then $AWK -f $srcdir/mk-test.awk ECHO_LINK="$ECHO_LINK" $srcdir/$cf_dir/programs >>$cf_dir/Makefile fi done cat >>Makefile <>Makefile <>$CONFIG_STATUS <<\EOF { (exit 0); exit 0; } EOF chmod +x $CONFIG_STATUS ac_clean_files=$ac_clean_files_save # configure is writing to config.log, and then calls config.status. # config.status does its own redirection, appending to config.log. # Unfortunately, on DOS this fails, as config.log is still kept open # by configure, so config.status won't be able to write to it; its # output is simply discarded. So we exec the FD to /dev/null, # effectively closing config.log, so it can be properly (re)opened and # appended to by config.status. When coming back to configure, we # need to make the FD available again. if test "$no_create" != yes; then ac_cs_success=: exec 5>/dev/null $SHELL $CONFIG_STATUS || ac_cs_success=false exec 5>>config.log # Use ||, not &&, to avoid exiting from the if with $? = 1, which # would make configure fail if this is the last instruction. $ac_cs_success || { (exit 1); exit 1; } fi tack-1.07/configure.in0000644000175100001440000001364210615227216013423 0ustar tomusersdnl*************************************************************************** dnl Copyright (c) 2007 Free Software Foundation, Inc. * dnl * dnl Permission is hereby granted, free of charge, to any person obtaining a * dnl copy of this software and associated documentation files (the * dnl "Software"), to deal in the Software without restriction, including * dnl without limitation the rights to use, copy, modify, merge, publish, * dnl distribute, distribute with modifications, sublicense, and/or sell * dnl copies of the Software, and to permit persons to whom the Software is * dnl furnished to do so, subject to the following conditions: * dnl * dnl The above copyright notice and this permission notice shall be included * dnl in all copies or substantial portions of the Software. * dnl * dnl THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * dnl OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * dnl MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * dnl IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, * dnl DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR * dnl OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR * dnl THE USE OR OTHER DEALINGS IN THE SOFTWARE. * dnl * dnl Except as contained in this notice, the name(s) of the above copyright * dnl holders shall not be used in advertising or otherwise to promote the * dnl sale, use or other dealings in this Software without prior written * dnl authorization. * dnl*************************************************************************** dnl dnl Author: Thomas E. Dickey 2007 dnl dnl $Id: configure.in,v 1.7 2007/04/29 23:47:26 tom Exp $ dnl This is a simple configuration-script for tack which makes it simpler to dnl build outside the ncurses tree (provided that ncurses was configured using dnl the --with-ticlib option). dnl dnl See http://invisible-island.net/autoconf/ for additional information. dnl --------------------------------------------------------------------------- AC_PREREQ(2.13.20020210) AC_INIT(tack.c) AC_CONFIG_HEADER(ncurses_cfg.h:ncurses_tst.hin) CF_INHERIT_SCRIPT(config.guess) CF_INHERIT_SCRIPT(config.sub) CF_CHECK_CACHE AC_PROG_MAKE_SET AC_PROG_CC AC_PROG_CPP AC_PROG_AWK CF_PROG_INSTALL AC_PROG_LN_S CF_MAKE_TAGS dnl Things that we don't need (or must override) if we're not building ncurses CC_G_OPT="-g" AC_SUBST(CC_G_OPT) CC_SHARED_OPTS=unknown AC_SUBST(CC_SHARED_OPTS) CPPFLAGS="$CPPFLAGS" AC_SUBST(CPPFLAGS) DESTDIR="" AC_SUBST(DESTDIR) DFT_DEP_SUFFIX="" AC_SUBST(DFT_DEP_SUFFIX) DFT_OBJ_SUBDIR=`pwd|sed -e's:.*/::'` AC_SUBST(DFT_OBJ_SUBDIR) DFT_UPR_MODEL="NORMAL" AC_SUBST(DFT_UPR_MODEL) ECHO_LINK='@ echo linking $@ ... ;' AC_SUBST(ECHO_LINK) EXTRA_LDFLAGS="" AC_SUBST(EXTRA_LDFLAGS) LD="ld" AC_SUBST(LD) LDFLAGS_SHARED="" AC_SUBST(LDFLAGS_SHARED) LD_MODEL="" AC_SUBST(LD_MODEL) LD_SHARED_OPTS="" AC_SUBST(LD_SHARED_OPTS) LIBTOOL="" AC_SUBST(LIBTOOL) LIB_CLEAN="" AC_SUBST(LIB_CLEAN) LIB_COMPILE="" AC_SUBST(LIB_COMPILE) LIB_INSTALL="" AC_SUBST(LIB_INSTALL) LIB_LINK='$(CC)' AC_SUBST(LIB_LINK) LIB_SUFFIX="" AC_SUBST(LIB_SUFFIX) LIB_UNINSTALL="" AC_SUBST(LIB_UNINSTALL) LINK_PROGS="" AC_SUBST(LINK_PROGS) LINT=lint AC_SUBST(LINT) LINT_OPTS="" AC_SUBST(LINT_OPTS) LOCAL_LDFLAGS="" AC_SUBST(LOCAL_LDFLAGS) MATH_LIB="-lm" AC_SUBST(MATH_LIB) TICS_ARGS="" AC_SUBST(TICS_ARGS) TINFO_ARGS='$(LIBS_CURSES)' AC_SUBST(TINFO_ARGS) cf_cv_abi_version="" AC_SUBST(cf_cv_abi_version) cf_cv_rel_version="" AC_SUBST(cf_cv_rel_version) NCURSES_TREE="#" AC_SUBST(NCURSES_TREE) cf_cv_screen=curses cf_cv_libtype= AC_EXEEXT AC_OBJEXT CF_ANSI_CC_REQD CF_ENABLE_WARNINGS CF_GCC_ATTRIBUTES CF_XOPEN_SOURCE dnl --------------------------------------------------------------------------- dnl NcursesW, installed in conventional location AC_ARG_WITH(ncursesw, [ --with-ncursesw use wide ncurses-libraries (installed)], [cf_cv_screen=ncursesw],[ dnl Ncurses, installed in conventional location AC_ARG_WITH(ncurses, [ --with-ncurses use ncurses-libraries (installed)], [cf_cv_screen=ncurses])]) case $cf_cv_screen in ncurses) CF_NCURSES_CONFIG ;; ncursesw) cf_cv_libtype=w CF_NCURSES_CONFIG(ncursesw) ;; *) CF_CURSES_CONFIG ;; esac case $cf_cv_screen in ncurses*) AC_CHECK_FUNC(_nc_tic_expand,,[ AC_CHECK_LIB(tic,_nc_tic_expand,[LIBS="-ltic $LIBS"])]) ;; esac CF_DISABLE_LEAKS # look for curses-related headers AC_CHECK_HEADERS( \ nc_alloc.h \ nc_tparm.h \ nomacros.h \ term_entry.h \ ) AC_TYPE_SIGNAL AC_STDC_HEADERS AC_HEADER_TIME AC_CHECK_HEADERS( \ getopt.h \ locale.h \ stdarg.h \ sys/ioctl.h \ sys/select.h \ sys/time.h \ termios.h \ unistd.h \ ) AC_CHECK_FUNCS( \ _nc_free_tic \ gettimeofday \ select \ strstr \ ) CF_SYS_TIME_SELECT CF_SIG_ATOMIC_T TICS_ARGS="$LIBS" LIBS= dnl --------------------------------------------------------------------------- AC_OUTPUT(Makefile,[ CF_PRG_RULES([$srcdir/mk-test.awk ECHO_LINK="$ECHO_LINK"], .) cat >>Makefile <>Makefile < #if HAVE_SYS_TIME_H #include #endif MODULE_ID("$Id: control.c,v 1.11 2009/12/26 21:48:54 tom Exp $") /* terminfo test program control subroutines */ #if HAVE_GETTIMEOFDAY #define MY_TIMER struct timeval #else #define MY_TIMER time_t #endif /* globals */ int test_complete; /* counts number of tests completed */ char txt_longer_test_time[80]; /* +) use longer time */ char txt_shorter_test_time[80]; /* -) use shorter time */ static int pad_test_duration = 1; /* number of seconds for a pad test */ int auto_pad_mode; /* run the time tests */ SIG_ATOMIC_T no_alarm_event; /* TRUE if the alarm has not gone off yet */ unsigned long usec_run_time; /* length of last test in microseconds */ static MY_TIMER stop_watch[MAX_TIMERS]; /* Hold the start timers */ char txt_longer_augment[80]; /* >) use bigger augment */ char txt_shorter_augment[80]; /* <) use smaller augment */ /* caps under test data base */ int tt_delay_max; /* max number of milliseconds we can delay */ int tt_delay_used; /* number of milliseconds consumed in delay */ const char *tt_cap[TT_MAX]; /* value of string */ int tt_affected[TT_MAX]; /* lines or columns effected (repetition factor) */ int tt_count[TT_MAX]; /* Number of times sent */ int tt_delay[TT_MAX]; /* Number of milliseconds delay */ int ttp; /* number of entries used */ /* Saved value of the above data base */ const char *tx_cap[TT_MAX]; /* value of string */ int tx_affected[TT_MAX]; /* lines or columns effected (repetition factor) */ int tx_count[TT_MAX]; /* Number of times sent */ int tx_index[TT_MAX]; /* String index */ int tx_delay[TT_MAX]; /* Number of milliseconds delay */ int txp; /* number of entries used */ int tx_characters; /* printing characters sent by test */ unsigned long tx_cps; /* characters per second */ static struct test_list *tx_source; /* The test that generated this data */ #define RESULT_BLOCK 1024 static int blocks; /* number of result blocks available */ static struct test_results *results; /* pointer to next available */ static struct test_results **pads; /* save pad results here */ static void alloc_arrays(void) { if (pads == 0) { pads = (struct test_results **)calloc(MAX_STRINGS, sizeof(struct test_results *)); } } /* ** event_start(number) ** ** Begin the stopwatch at the current time-of-day. */ void event_start(int n) { #if HAVE_GETTIMEOFDAY (void) gettimeofday(&stop_watch[n], (struct timezone *)0); #else stop_watch[n] = time((time_t *)0); #endif } /* ** event_time(number) ** ** Return the number of milliseconds since this stop watch began. */ long event_time(int n) { #if HAVE_GETTIMEOFDAY MY_TIMER current_time; (void) gettimeofday(¤t_time, (struct timezone *)0); return ((current_time.tv_sec - stop_watch[n].tv_sec) * 1000000) + current_time.tv_usec - stop_watch[n].tv_usec; #else return (time((time_t *)0) - stop_watch[n]) * 1000; #endif } /***************************************************************************** * * Execution control for string capability tests * *****************************************************************************/ /* ** get_next_block() ** ** Get a results block for pad test data. */ static struct test_results * get_next_block(void) { if (blocks <= 0) { results = (struct test_results *) malloc(sizeof(struct test_results) * RESULT_BLOCK); if (!results) { ptextln("Malloc failed"); return (struct test_results *) 0; } blocks = RESULT_BLOCK; } blocks--; return results++; } /* ** set_augment_txt() ** ** Initialize the augment menu selections */ void set_augment_txt(void) { sprintf(txt_longer_augment, ">) Change lines/characters effected to %d", augment << 1); sprintf(txt_shorter_augment, "<) Change lines/characters effected to %d", augment >> 1); } void control_init(void) { sprintf(txt_longer_test_time, "+) Change test time to %d seconds", pad_test_duration + 1); sprintf(txt_shorter_test_time, "-) Change test time to %d seconds", pad_test_duration - 1); set_augment_txt(); } /* ** msec_cost(cap, affected-count) ** ** Return the number of milliseconds delay needed by the cap. */ int msec_cost( const char *const cap, int affcnt) { int dec, value, total, star, ch; const char *cp; if (!cap) { return 0; } total = 0; for (cp = cap; *cp; cp++) { if (*cp == '$' && cp[1] == '<') { star = 1; value = dec = 0; for (cp += 2; (ch = *cp); cp++) { if (ch >= '0' && ch <= '9') { value = value * 10 + (ch - '0'); dec *= 10; } else if (ch == '.') { dec = 1; } else if (ch == '*') { star = affcnt; } else if (ch == '>') { break; } } if (dec > 1) { total += (value * star) / dec; } else { total += (value * star); } } } return total; } /* ** liberated(cap) ** ** Return the cap without padding */ char * liberated(char *cap) { static char cb[1024]; char *ts, *ls; cb[0] = '\0'; ls = NULL; if (cap) { for (ts = cb; (*ts = *cap); ++cap) { if (*cap == '$' && cap[1] == '<') { ls = ts; } ++ts; if (*cap == '>') { if (ls) { ts = ls; ls = NULL; } } } } return cb; } /* ** page_loop() ** ** send CR/LF or go home and bump letter */ void page_loop(void) { if (line_count + 2 >= lines) { NEXT_LETTER; go_home(); } else { put_crlf(); } } /* ** skip_pad_test(test-list-entry, state, ch, text) ** ** Print the start test line. Handle start up commands. ** Return TRUE if a return is requested. */ int skip_pad_test( struct test_list *test, int *state, int *ch, const char *text) { char rep_text[16]; while(1) { if (text) { ptext(text); } if ((test->flags & MENU_LC_MASK)) { sprintf(rep_text, " *%d", augment); ptext(rep_text); } ptext(" [n] > "); *ch = wait_here(); if (*ch == 's') { /* Skip is converted to next */ *ch = 'n'; return TRUE; } if (*ch == 'q') { /* Quit is converted to help */ *ch = '?'; return TRUE; } if (*ch == '\r' || *ch == '\n' || *ch == 'n' || *ch == 'r') { /* this is the only response that allows the test to run */ *ch = 0; } if (subtest_menu(pad_test_list, state, ch)) { continue; } return (*ch != 0); } } /* ** pad_done_message(test_list) ** ** Print the Done message and request input. */ void pad_done_message( struct test_list *test, int *state, int *ch) { int default_action = 0; char done_message[128]; char rep_text[16]; while (1) { if ((test->flags & MENU_LC_MASK)) { sprintf(rep_text, "*%d", augment); } else { rep_text[0] = '\0'; } if (test->caps_done) { sprintf(done_message, "(%s)%s Done ", test->caps_done, rep_text); ptext(done_message); } else { if (rep_text[0]) { ptext(rep_text); ptext(" "); } ptext("Done "); } if (debug_level & 2) { dump_test_stats(test, state, ch); } else { *ch = wait_here(); } if (*ch == '\r' || *ch == '\n') { *ch = default_action; return; } if (*ch == 's' || *ch == 'n') { *ch = 0; return; } if (strchr(pad_repeat_test, *ch)) { /* default action is now repeat */ default_action = 'r'; } if (subtest_menu(pad_test_list, state, ch)) { continue; } return; } } /* ** sliding_scale(dividend, factor, divisor) ** ** Return (dividend * factor) / divisor */ int sliding_scale( int dividend, int factor, unsigned long divisor) { double d = dividend; if (divisor) { d = (d * (double) factor) / (double) divisor; return (int) (d + 0.5); } return 0; } /* ** pad_test_startup() ** ** Do the stuff needed to begin a test. */ void pad_test_startup( int do_clear) { if (do_clear) { put_clear(); } repeats = augment; raw_characters_sent = 0; test_complete = ttp = char_count = tt_delay_used = 0; letter = letters[letter_number = 0]; if (pad_test_duration <= 0) { pad_test_duration = 1; } tt_delay_max = pad_test_duration * 1000; set_alarm_clock(pad_test_duration); event_start(TIME_TEST); } /* ** still_testing() ** ** This function is called to see if the test loop should be terminated. */ int still_testing(void) { fflush(stdout); test_complete++; return EXIT_CONDITION; } /* ** pad_test_shutdown() ** ** Do the stuff needed to end a test. */ void pad_test_shutdown( struct test_list *t, int crlf) { int i; int counts; /* total counts */ int ss; /* Save string index */ int cpo; /* characters per operation */ long delta; /* difference in characters */ int bogus; /* Time is inaccurate */ struct test_results *r; /* Results of current test */ int ss_index[TT_MAX]; /* String index */ alloc_arrays(); if (tty_can_sync == SYNC_TESTED) { bogus = tty_sync_error(); } else { bogus = 1; } usec_run_time = (unsigned long) event_time(TIME_TEST); tx_source = t; tx_characters = raw_characters_sent; tx_cps = (unsigned long) sliding_scale(tx_characters, 1000000, usec_run_time); /* save the data base */ for (txp = ss = counts = 0; txp < ttp; txp++) { tx_cap[txp] = tt_cap[txp]; tx_count[txp] = tt_count[txp]; tx_delay[txp] = tt_delay[txp]; tx_affected[txp] = tt_affected[txp]; tx_index[txp] = get_string_cap_byvalue(tt_cap[txp]); if (tx_index[txp] >= 0) { if (cap_match(t->caps_done, strnames[tx_index[txp]])) { ss_index[ss++] = txp; counts += tx_count[txp]; } } } if (crlf) { put_crlf(); } if (counts == 0 || tty_cps == 0 || bogus) { /* nothing to do */ return; } /* calculate the suggested pad times */ delta = (long) (usec_run_time - (unsigned long) sliding_scale(tx_characters, 1000000, tty_cps)); if (delta < 0) { /* probably should bump tx_characters */ delta = 0; } cpo = delta / counts; for (i = 0; i < ss; i++) { if (!(r = get_next_block())) { return; } r->next = pads[tx_index[ss_index[i]]]; pads[tx_index[ss_index[i]]] = r; r->test = t; r->reps = tx_affected[ss_index[i]]; r->delay = cpo; } } /* ** show_cap_results(index) ** ** Display the previous results */ static void show_cap_results( int x) { struct test_results *r; /* a result */ int delay; alloc_arrays(); if ((r = pads[x])) { sprintf(temp, "(%s)", strnames[x]); ptext(temp); while (r) { sprintf(temp, "$<%d>", r->delay / 1000); put_columns(temp, (int) strlen(temp), 10); r = r->next; } r = pads[x]; while (r) { if (r->reps > 1) { delay = r->delay / (r->reps * 100); sprintf(temp, "$<%d.%d*>", delay / 10, delay % 10); put_columns(temp, (int) strlen(temp), 10); } r = r->next; } put_crlf(); } } /* ** dump_test_stats(test_list, status, ch) ** ** Dump the statistics about the last test */ void dump_test_stats( struct test_list *t, int *state, int *ch) { int i, j; char tbuf[32]; int x[32]; put_crlf(); if (tx_source && tx_source->caps_done) { cap_index(tx_source->caps_done, x); if (x[0] >= 0) { sprintf(temp, "Caps summary for (%s)", tx_source->caps_done); ptextln(temp); for (i = 0; x[i] >= 0; i++) { show_cap_results(x[i]); } put_crlf(); } } sprintf(tbuf, "%011lu", usec_run_time); sprintf(temp, "Test time: %lu.%s, characters per second %lu, characters %d", usec_run_time / 1000000UL, &tbuf[5], tx_cps, tx_characters); ptextln(temp); for (i = 0; i < txp; i++) { if ((j = get_string_cap_byvalue(tx_cap[i])) >= 0) { sprintf(tbuf, "(%s)", strnames[j]); } else { strcpy(tbuf, "(?)"); } sprintf(temp, "%8d %3d $<%3d> %8s %s", tx_count[i], tx_affected[i], tx_delay[i], tbuf, expand(tx_cap[i])); putln(temp); } generic_done_message(t, state, ch); } /* ** longer_test_time(test_list, status, ch) ** ** Extend the number of seconds for each test. */ void longer_test_time( struct test_list *t GCC_UNUSED, int *state GCC_UNUSED, int *ch) { pad_test_duration += 1; sprintf(txt_longer_test_time, "+) Change test time to %d seconds", pad_test_duration + 1); sprintf(txt_shorter_test_time, "-) Change test time to %d seconds", pad_test_duration - 1); sprintf(temp, "Tests will run for %d seconds", pad_test_duration); ptext(temp); *ch = REQUEST_PROMPT; } /* ** shorter_test_time(test_list, status, ch) ** ** Shorten the number of seconds for each test. */ void shorter_test_time( struct test_list *t GCC_UNUSED, int *state GCC_UNUSED, int *ch) { if (pad_test_duration > 1) { pad_test_duration -= 1; sprintf(txt_longer_test_time, "+) Change test time to %d seconds", pad_test_duration + 1); sprintf(txt_shorter_test_time, "-) Change test time to %d seconds", pad_test_duration - 1); } sprintf(temp, "Tests will run for %d second%s", pad_test_duration, pad_test_duration > 1 ? "s" : ""); ptext(temp); *ch = REQUEST_PROMPT; } /* ** longer_augment(test_list, status, ch) ** ** Lengthen the number of lines/characters effected */ void longer_augment( struct test_list *t, int *state GCC_UNUSED, int *ch) { augment <<= 1; set_augment_txt(); if (augment_test) { t = augment_test; } sprintf(temp, "The pad tests will effect %d %s.", augment, ((t->flags & MENU_LC_MASK) == MENU_lines) ? "lines" : "characters"); ptextln(temp); *ch = REQUEST_PROMPT; } /* ** shorter_augment(test_list, status, ch) ** ** Shorten the number of lines/characters effected */ void shorter_augment( struct test_list *t, int *state GCC_UNUSED, int *ch) { if (augment > 1) { /* don't let the augment go to zero */ augment >>= 1; } set_augment_txt(); if (augment_test) { t = augment_test; } sprintf(temp, "The pad tests will effect %d %s.", augment, ((t->flags & MENU_LC_MASK) == MENU_lines) ? "lines" : "characters"); ptextln(temp); *ch = REQUEST_PROMPT; } tack-1.07/COPYING0000644000175100001440000004313510313071260012134 0ustar tomusers GNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Library General Public License instead.) You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) year name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. , 1 April 1989 Ty Coon, President of Vice This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Library General Public License instead of this License. tack-1.07/crum.c0000644000175100001440000002150110532156206012213 0ustar tomusers/* ** Copyright (C) 1991, 1997 Free Software Foundation, Inc. ** ** This file is part of TACK. ** ** TACK is free software; you can redistribute it and/or modify ** it under the terms of the GNU General Public License as published by ** the Free Software Foundation; either version 2, or (at your option) ** any later version. ** ** TACK 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 TACK; see the file COPYING. If not, write to ** the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, ** Boston, MA 02110-1301, USA */ #include MODULE_ID("$Id: crum.c,v 1.6 2006/11/26 00:15:02 tom Exp $") /* * Test cursor movement. */ static void crum_clear(struct test_list *t, int *state, int *ch); static void crum_home(struct test_list *t, int *state, int *ch); static void crum_ll(struct test_list *t, int *state, int *ch); static void crum_move(struct test_list *t, int *state, int *ch); static void crum_os(struct test_list *t, int *state, int *ch); static char crum_text[5][80]; struct test_list crum_test_list[] = { {0, 0, 0, 0, "e) edit terminfo", 0, &edit_menu}, {MENU_NEXT, 0, "clear", 0, 0, crum_clear, 0}, {MENU_NEXT, 0, "home", 0, 0, crum_home, 0}, {MENU_NEXT, 0, "ll", 0, 0, crum_ll, 0}, {MENU_NEXT, 0, crum_text[0], "home cuu1", 0, crum_move, 0}, {MENU_NEXT + 1, 0, crum_text[1], "cub1 cud1 cuf1 cuu1", 0, crum_move, 0}, {MENU_NEXT + 2, 0, crum_text[2], "cub cud cuf cuu", 0, crum_move, 0}, {MENU_NEXT + 3, 0, crum_text[3], "vpa hpa", 0, crum_move, 0}, {MENU_NEXT + 4, 0, crum_text[4], "cup", 0, crum_move, 0}, {MENU_NEXT, 0, "cup", "os", 0, crum_os, 0}, {MENU_LAST, 0, 0, 0, 0, 0, 0} }; /* ** move_to(from-row, from-column, to-row, to-column, selection) ** ** move the cursor from (rf, cf) to (rt, ct) using sel */ static void move_to( int rf, int cf, int rt, int ct, int sel) { char *s; if (sel & 16) { /* use (cup) */ s = TPARM_2(cursor_address, rt, ct); tputs(s, lines, tc_putch); return; } if (sel & 8) { /* use (hpa) (vpa) */ if (column_address) { s = TPARM_1(column_address, ct); tputs(s, 1, tc_putch); cf = ct; } if (row_address) { s = TPARM_1(row_address, rt); tputs(s, 1, tc_putch); rf = rt; } } if (sel & 4) { /* parameterized relative cursor movement */ if (parm_right_cursor) if (cf < ct) { s = TPARM_1(parm_right_cursor, ct - cf); tputs(s, ct - cf, tc_putch); cf = ct; } if (parm_left_cursor) if (cf > ct) { s = TPARM_1(parm_left_cursor, cf - ct); tputs(s, cf - ct, tc_putch); cf = ct; } if (parm_down_cursor) if (rf < rt) { s = TPARM_1(parm_down_cursor, rt - rf); tputs(s, rt - rf, tc_putch); rf = rt; } if (parm_up_cursor) if (rf > rt) { s = TPARM_1(parm_up_cursor, rf - rt); tputs(s, rf - rt, tc_putch); rf = rt; } } if (sel & 2) { if (cursor_left) while (cf > ct) { tc_putp(cursor_left); cf--; } /* do vertical motion next. Just in case cursor_down has a side effect of changing the column. This could happen if the tty handler translates NL to CRNL. */ if (cursor_down) while (rf < rt) { tc_putp(cursor_down); rf++; } if (cursor_up) while (rf > rt) { tc_putp(cursor_up); rf--; } if (cursor_right) while (cf < ct) { tc_putp(cursor_right); cf++; } } /* last chance */ if (rf > rt) { if (can_go_home) { /* a bit drastic but ... */ go_home(); cf = 0; rf = 0; } else if (cursor_up) { while (rf > rt) { tc_putp(cursor_up); rf--; } } } if (ct == 0 && rt > rf) { put_crlf(); cf = 0; rf++; } if (ct == 0 && cf != 0) { put_cr(); cf = 0; } while (rf < rt) { put_lf(); rf++; } while (cf > ct) { put_str("\b"); cf--; } if (cursor_right) { while (cf < ct) { tc_putp(cursor_right); cf++; } } else { /* go ahead and trash my display */ while (cf < ct) { putchp(' '); cf++; } } } /* ** display_it(selection, text) ** ** print the display using sel */ static void display_it( int sel, char *txt) { int i, done_line; put_clear(); go_home(); put_newlines(2); ptextln(" The top line should be alternating <'s and >'s"); ptextln(" The left side should be alternating A's and V's"); ptext(" Testing "); ptext(txt); put_cr(); /* horizontal */ move_to(done_line = line_count, 0, 0, 2, sel); for (i = 4; i < columns - 2; i += 2) { putchp('>'); move_to(0, i - 1, 0, i, sel); } putchp('>'); i -= 2; move_to(0, i + 1, 0, i - 1, sel); for (; i > 2; i -= 2) { putchp('<'); move_to(0, i, 0, i - 3, sel); } putchp('<'); /* vertical */ move_to(0, 2, 0, 0, sel); for (i = 2; i < lines - 1; i += 2) { putchp('V'); move_to(i - 2, 1, i, 0, sel); } putchp('V'); i -= 2; move_to(i, 1, i + 1, 0, sel); for (; i > 0; i -= 2) { putchp('A'); move_to(i + 1, 1, i - 1, 0, sel); } putchp('A'); move_to(i + 1, 1, 0, 0, sel); /* go home first */ move_to(0, 0, done_line + 1, 3, sel); put_str(txt); put_str(" Done. "); } /* ** crum_clear(test_list, status, ch) ** ** (clear) test Clear screen */ static void crum_clear( struct test_list *t, int *state, int *ch) { int i; if (clear_screen) { for (i = lines; i > 1; i--) { putln("garbage"); } put_clear(); ptextln("This line should start in the home position."); ptext("The rest of the screen should be clear. "); } else { ptextln("(clear) Clear screen is not defined. "); } generic_done_message(t, state, ch); } /* ** crum_home(test_list, status, ch) ** ** (home) test Home cursor */ static void crum_home( struct test_list *t, int *state, int *ch) { if (cursor_home) { put_clear(); put_newlines(lines / 2); go_home(); put_crlf(); ptext("The bottom line should have text."); go_home(); put_newlines(lines - 1); ptext("This line is on the bottom."); go_home(); ptextln("This line starts in the home position."); put_crlf(); } else { ptextln("(home) Home cursor is not defined. "); } generic_done_message(t, state, ch); } /* ** crum_ll(test_list, status, ch) ** ** (ll) test Last line */ static void crum_ll( struct test_list *t, int *state, int *ch) { /* (ll) may be simulated with (cup). Don't complain if (cup) is present. */ if (cursor_to_ll) { put_clear(); put_str("This line could be anywhere."); tc_putp(cursor_to_ll); ptext("This line should be on the bottom"); go_home(); put_crlf(); } else if (cursor_address) { return; } else { ptextln("(ll) Move to last line is not defined. "); } generic_done_message(t, state, ch); } /* ** crum_move(test_list, status, ch) ** ** (*) test all cursor move commands */ static void crum_move( struct test_list *t, int *state, int *ch) { char buf[80]; int n; switch (n = (t->flags & 15)) { case 0: sprintf(buf, " (cr) (nel) (cub1)%s", cursor_home ? " (home)" : (cursor_up ? " (cuu1)" : "")); break; case 1: sprintf(buf, "%s%s%s%s", cursor_left ? " (cub1)" : "", cursor_down ? " (cud1)" : "", cursor_right ? " (cuf1)" : "", cursor_up ? " (cuu1)" : ""); if (buf[0] == '\0') { ptext(" (cub1) (cud1) (cuf1) (cuu1) not defined."); } break; case 2: sprintf(buf, "%s%s%s%s", parm_left_cursor ? " (cub)" : "", parm_down_cursor ? " (cud)" : "", parm_right_cursor ? " (cuf)" : "", parm_up_cursor ? " (cuu)" : ""); if (buf[0] == '\0') { ptext(" (cub) (cud) (cuf) (cuu) not defined."); } break; case 3: sprintf(buf, "%s%s", row_address ? " (vpa)" : "", column_address ? " (hpa)" : ""); if (buf[0] == '\0') { ptext(" (vpa) (hpa) not defined."); } break; case 4: if (!cursor_address) { ptext(" (cup) not defined. "); generic_done_message(t, state, ch); return; } strcpy(buf, " (cup)"); break; } if (buf[0] == '\0') { put_str(" Done. "); } else { can_test(buf, FLAG_TESTED); strcpy(crum_text[n], &buf[2]); crum_text[n][strlen(buf) - 3] = '\0'; display_it(1 << n, buf); } *ch = wait_here(); if (*ch != 'r') { put_clear(); } } /* ** crum_os(test_list, status, ch) ** ** (cup) test Cursor position on overstrike terminals */ static void crum_os( struct test_list *t, int *state, int *ch) { int i; if (cursor_address && over_strike) { put_clear(); for (i = 0; i < columns - 2; i++) { tc_putch('|'); } for (i = 1; i < lines - 2; i++) { put_crlf(); tc_putch('_'); } for (i = 0; i < columns - 2; i++) { tputs(TPARM_2(cursor_address, 0, i), lines, tc_putch); tc_putch('+'); } for (i = 0; i < lines - 2; i++) { tputs(TPARM_2(cursor_address, i, 0), lines, tc_putch); tc_putch(']'); tc_putch('_'); } go_home(); put_newlines(3); ptext(" All the characters should look the same. "); generic_done_message(t, state, ch); put_clear(); } } tack-1.07/edit.c0000644000175100001440000005371411315500431012176 0ustar tomusers/* ** Copyright (C) 1997 Free Software Foundation, Inc. ** ** This file is part of TACK. ** ** TACK is free software; you can redistribute it and/or modify ** it under the terms of the GNU General Public License as published by ** the Free Software Foundation; either version 2, or (at your option) ** any later version. ** ** TACK 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 TACK; see the file COPYING. If not, write to ** the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, ** Boston, MA 02110-1301, USA */ #include #include #include MODULE_ID("$Id: edit.c,v 1.15 2009/12/26 21:33:13 tom Exp $") /* * Terminfo edit features */ static void show_info(struct test_list *, int *, int *); static void show_value(struct test_list *, int *, int *); static void show_untested(struct test_list *, int *, int *); static void show_changed(struct test_list *, int *, int *); #define SHOW_VALUE 1 #define SHOW_EDIT 2 #define SHOW_DELETE 3 struct test_list edit_test_list[] = { {MENU_CLEAR, 0, 0, 0, "i) display current terminfo", show_info, 0}, {0, 0, 0, 0, "w) write the current terminfo to a file", save_info, 0}, {SHOW_VALUE, 3, 0, 0, "v) show value of a selected cap", show_value, 0}, {SHOW_EDIT, 4, 0, 0, "e) edit value of a selected cap", show_value, 0}, {SHOW_DELETE, 3, 0, 0, "d) delete string", show_value, 0}, {0, 3, 0, 0, "m) show caps that have been modified", show_changed, 0}, {MENU_CLEAR + FLAG_CAN_TEST, 0, 0, 0, "c) show caps that can be tested", show_report, 0}, {MENU_CLEAR + FLAG_TESTED, 0, 0, 0, "t) show caps that have been tested", show_report, 0}, {MENU_CLEAR + FLAG_FUNCTION_KEY, 0, 0, 0, "f) show a list of function keys", show_report, 0}, {MENU_CLEAR, 0, 0, 0, "u) show caps defined that can not be tested", show_untested, 0}, {MENU_LAST, 0, 0, 0, 0, 0, 0} }; static char change_pad_text[MAX_CHANGES][80]; static struct test_list change_pad_list[MAX_CHANGES] = { {MENU_LAST, 0, 0, 0, 0, 0, 0} }; static void build_change_menu(struct test_menu *); static void change_one_entry(struct test_list *, int *, int *); struct test_menu change_pad_menu = { 0, 'q', 0, "Select cap name", "change", 0, build_change_menu, change_pad_list, 0, 0, 0 }; static TERMTYPE original_term; /* terminal type description */ static char flag_boolean[BOOLCOUNT]; /* flags for booleans */ static char flag_numerics[NUMCOUNT]; /* flags for numerics */ static char *flag_strings; /* flags for strings */ static int *label_strings; static int xon_index; /* Subscript for (xon) */ static int xon_shadow; static int start_display; /* the display has just started */ static int display_lines; /* number of lines displayed */ static void alloc_arrays(void) { if (flag_strings == 0) { label_strings = (int *)calloc(MAX_STRINGS, sizeof(int)); flag_strings = (char *)calloc(MAX_STRINGS, sizeof(char)); } } /* ** send_info_string(str) ** ** Return the terminfo string prefixed by the correct separator */ static void send_info_string( const char *str, int *ch) { int len; if (display_lines == -1) { return; } len = (int) strlen(str); if (len + char_count + 3 >= columns) { if (start_display == 0) { put_str(","); } put_crlf(); if (++display_lines > lines) { ptext("-- more -- "); *ch = wait_here(); if (*ch == 'q') { display_lines = -1; return; } display_lines = 0; } if (len >= columns) { /* if the terminal does not (am) then this loses */ if (columns) { display_lines += (((int) strlen(str) + 3) / columns) + 1; } put_str(" "); put_str(str); start_display = 0; return; } ptext(" "); } else if (start_display == 0) { ptext(", "); } else { ptext(" "); } ptext(str); start_display = 0; } /* ** show_info(test_list, status, ch) ** ** Display the current terminfo */ static void show_info( struct test_list *t GCC_UNUSED, int *state GCC_UNUSED, int *ch) { int i; char buf[1024]; display_lines = 1; start_display = 1; for (i = 0; i < BOOLCOUNT; i++) { if ((i == xon_index) ? xon_shadow : CUR Booleans[i]) { send_info_string(boolnames[i], ch); } } for (i = 0; i < NUMCOUNT; i++) { if (CUR Numbers[i] >= 0) { sprintf(buf, "%s#%d", numnames[i], CUR Numbers[i]); send_info_string(buf, ch); } } for (i = 0; i < MAX_STRINGS; i++) { if (CUR Strings[i]) { sprintf(buf, "%s=%s", STR_NAME(i), print_expand(CUR Strings[i])); send_info_string(buf, ch); } } put_newlines(2); *ch = REQUEST_PROMPT; } /* ** save_info_string(str, fp) ** ** Write the terminfo string prefixed by the correct separator */ static void save_info_string( const char *str, FILE *fp) { int len; len = (int) strlen(str); if (len + display_lines >= 77) { if (display_lines > 0) { (void) fprintf(fp, "\n\t"); } display_lines = 8; } else if (display_lines > 0) { (void) fprintf(fp, " "); display_lines++; } else { (void) fprintf(fp, "\t"); display_lines = 8; } (void) fprintf(fp, "%s,", str); display_lines += len + 1; } /* ** save_info(test_list, status, ch) ** ** Write the current terminfo to a file */ void save_info( struct test_list *t, int *state, int *ch) { int i; FILE *fp; time_t now; char buf[1024]; if ((fp = fopen(tty_basename, "w")) == (FILE *) NULL) { (void) sprintf(temp, "can't open: %s", tty_basename); ptextln(temp); generic_done_message(t, state, ch); return; } time(&now); /* Note: ctime() returns a newline at the end of the string */ (void) fprintf(fp, "# Terminfo created by TACK for TERM=%s on %s", tty_basename, ctime(&now)); (void) fprintf(fp, "%s|%s,\n", tty_basename, longname()); display_lines = 0; for (i = 0; i < BOOLCOUNT; i++) { if (i == xon_index ? xon_shadow : CUR Booleans[i]) { save_info_string(boolnames[i], fp); } } for (i = 0; i < NUMCOUNT; i++) { if (CUR Numbers[i] >= 0) { sprintf(buf, "%s#%d", numnames[i], CUR Numbers[i]); save_info_string(buf, fp); } } for (i = 0; i < MAX_STRINGS; i++) { if (CUR Strings[i]) { sprintf(buf, "%s=%s", STR_NAME(i), _nc_tic_expand(CUR Strings[i], TRUE, TRUE)); save_info_string(buf, fp); } } (void) fprintf(fp, "\n"); (void) fclose(fp); sprintf(temp, "Terminfo saved as file: %s", tty_basename); ptextln(temp); } /* ** show_value(test_list, status, ch) ** ** Display the value of a selected cap */ static void show_value( struct test_list *t, int *state GCC_UNUSED, int *ch) { struct name_table_entry const *nt; char *s; int n, op, b; char buf[1024]; char tmp[1024]; ptext("enter name: "); read_string(buf, 80); if (buf[0] == '\0' || buf[1] == '\0') { *ch = buf[0]; return; } if (line_count + 2 >= lines) { put_clear(); } op = t->flags & 255; if ((nt = _nc_find_entry(buf, _nc_get_hash_table(FALSE)))) { switch (nt->nte_type) { case BOOLEAN: if (op == SHOW_DELETE) { if (nt->nte_index == xon_index) { xon_shadow = 0; } else { CUR Booleans[nt->nte_index] = 0; } return; } b = nt->nte_index == xon_index ? xon_shadow : CUR Booleans[nt->nte_index]; sprintf(temp, "boolean %s %s", buf, b ? "True" : "False"); break; case STRING: if (op == SHOW_DELETE) { CUR Strings[nt->nte_index] = (char *) 0; return; } if (CUR Strings[nt->nte_index]) { sprintf(temp, "string %s %s", buf, expand(CUR Strings[nt->nte_index])); } else { sprintf(temp, "undefined string %s", buf); } break; case NUMBER: if (op == SHOW_DELETE) { CUR Numbers[nt->nte_index] = -1; return; } sprintf(temp, "numeric %s %d", buf, CUR Numbers[nt->nte_index]); break; default: sprintf(temp, "unknown"); break; } ptextln(temp); } else { sprintf(temp, "Cap not found: %s", buf); ptextln(temp); return; } if (op != SHOW_EDIT) { return; } if (nt->nte_type == BOOLEAN) { ptextln("Value flipped"); if (nt->nte_index == xon_index) { xon_shadow = !xon_shadow; } else { CUR Booleans[nt->nte_index] = (char) !CUR Booleans[nt->nte_index]; } return; } ptextln("Enter new value"); read_string(buf, sizeof(buf)); switch (nt->nte_type) { case STRING: _nc_reset_input((FILE *) 0, buf); _nc_trans_string(tmp, tmp + sizeof(tmp)); s = (char *)malloc(strlen(tmp) + 1); strcpy(s, tmp); CUR Strings[nt->nte_index] = s; sprintf(temp, "new string value %s", nt->nte_name); ptextln(temp); ptextln(expand(CUR Strings[nt->nte_index])); break; case NUMBER: if (sscanf(buf, "%d", &n) == 1) { CUR Numbers[nt->nte_index] = (short) n; sprintf(temp, "new numeric value %s %d", nt->nte_name, n); ptextln(temp); } else { sprintf(temp, "Illegal number: %s", buf); ptextln(temp); } break; default: break; } } /* ** get_string_cap_byname(name, long_name) ** ** Given a cap name, find the value ** Errors are quietly ignored. */ char * get_string_cap_byname( const char *name, const char **long_name) { struct name_table_entry const *nt; if ((nt = _nc_find_entry(name, _nc_get_hash_table(FALSE)))) { if (nt->nte_type == STRING) { *long_name = strfnames[nt->nte_index]; return (CUR Strings[nt->nte_index]); } } *long_name = "??"; return (char *) 0; } /* ** get_string_cap_byvalue(value) ** ** Given a capability string, find its position in the data base. ** Return the index or -1 if not found. */ int get_string_cap_byvalue( const char *value) { int i; if (value) { for (i = 0; i < MAX_STRINGS; i++) { if (CUR Strings[i] == value) { return i; } } /* search for translated strings */ for (i = 0; i < TM_last; i++) { if (TM_string[i].value == value) { return TM_string[i].index; } } } return -1; } /* ** show_changed(test_list, status, ch) ** ** Display a list of caps that have been changed. */ static void show_changed( struct test_list *t GCC_UNUSED, int *state GCC_UNUSED, int *ch) { int i, header = 1, v; const char *a; const char *b; static char title[] = " old value cap new value"; char abuf[1024]; for (i = 0; i < BOOLCOUNT; i++) { v = (i == xon_index) ? xon_shadow : CUR Booleans[i]; if (original_term.Booleans[i] != v) { if (header) { ptextln(title); header = 0; } sprintf(temp, "%30d %6s %d", original_term.Booleans[i], boolnames[i], v); ptextln(temp); } } for (i = 0; i < NUMCOUNT; i++) { if (original_term.Numbers[i] != CUR Numbers[i]) { if (header) { ptextln(title); header = 0; } sprintf(temp, "%30d %6s %d", original_term.Numbers[i], numnames[i], CUR Numbers[i]); ptextln(temp); } } for (i = 0; i < MAX_STRINGS; i++) { a = original_term.Strings[i] ? original_term.Strings[i] : ""; b = CUR Strings[i] ? CUR Strings[i] : ""; if (strcmp(a, b)) { if (header) { ptextln(title); header = 0; } strcpy(abuf, _nc_tic_expand(a, TRUE, TRUE)); sprintf(temp, "%30s %6s %s", abuf, STR_NAME(i), _nc_tic_expand(b, TRUE, TRUE)); putln(temp); } } if (header) { ptextln("No changes"); } put_crlf(); *ch = REQUEST_PROMPT; } /* ** user_modified() ** ** Return TRUE if the user has modified the terminfo */ int user_modified(void) { const char *a, *b; int i, v; for (i = 0; i < BOOLCOUNT; i++) { v = (i == xon_index) ? xon_shadow : CUR Booleans[i]; if (original_term.Booleans[i] != v) { return TRUE; } } for (i = 0; i < NUMCOUNT; i++) { if (original_term.Numbers[i] != CUR Numbers[i]) { return TRUE; } } for (i = 0; i < MAX_STRINGS; i++) { a = original_term.Strings[i] ? original_term.Strings[i] : ""; b = CUR Strings[i] ? CUR Strings[i] : ""; if (strcmp(a, b)) { return TRUE; } } return FALSE; } /***************************************************************************** * * Maintain the list of capabilities that can be tested * *****************************************************************************/ /* ** mark_cap(name, flag) ** ** Mark the cap data base with the flag provided. */ static void mark_cap( char *name, int flag) { struct name_table_entry const *nt; alloc_arrays(); if ((nt = _nc_find_entry(name, _nc_get_hash_table(FALSE)))) { switch (nt->nte_type) { case BOOLEAN: flag_boolean[nt->nte_index] = (char) (flag_boolean[nt->nte_index] | flag); break; case STRING: flag_strings[nt->nte_index] = (char) (flag_strings[nt->nte_index] | flag); break; case NUMBER: flag_numerics[nt->nte_index] = (char) (flag_numerics[nt->nte_index] | flag); break; default: sprintf(temp, "unknown cap type (%s)", name); ptextln(temp); break; } } else { sprintf(temp, "Cap not found: %s", name); ptextln(temp); (void) wait_here(); } } /* ** can_test(name-list, flags) ** ** Scan the name list and get the names. ** Enter each name into the can-test data base. ** ( and ) may be used as separators. */ void can_test( const char *s, int flags) { int ch, j; char name[32]; if (s) { for (j = 0; (ch = name[j] = *s); s++) { if (ch == ' ' || ch == ')' || ch == '(') { if (j) { name[j] = '\0'; mark_cap(name, flags); } j = 0; } else { j++; } } if (j) { mark_cap(name, flags); } } } /* ** cap_index(name-list, index-list) ** ** Scan the name list and return a list of indexes. ** ( and ) may be used as separators. ** This list is terminated with -1. */ void cap_index( const char *s, int *inx) { struct name_table_entry const *nt; int ch, j; char name[32]; if (s) { for (j = 0; ; s++) { ch = name[j] = *s; if (ch == ' ' || ch == ')' || ch == '(' || ch == 0) { if (j) { name[j] = '\0'; if ((nt = _nc_find_entry(name, _nc_get_hash_table(FALSE))) && (nt->nte_type == STRING)) { *inx++ = nt->nte_index; } } if (ch == 0) { break; } j = 0; } else { j++; } } } *inx = -1; } /* ** cap_match(name-list, cap) ** ** Scan the name list and see if the cap is in the list. ** Return TRUE if we find an exact match. ** ( and ) may be used as separators. */ int cap_match( const char *names, const char *cap) { char *s; int c, l, t; if (names) { l = (int) strlen(cap); while ((s = strstr(names, cap))) { c = (names == s) ? 0 : *(s - 1); t = s[l]; if ((c == 0 || c == ' ' || c == '(') && (t == 0 || t == ' ' || t == ')')) { return TRUE; } if (t == 0) { break; } names = s + l; } } return FALSE; } /* ** show_report(test_list, status, ch) ** ** Display a list of caps that can be tested */ void show_report( struct test_list *t, int *state GCC_UNUSED, int *ch) { int i, j, nc, flag; const char *s; size_t count = (size_t) (BOOLCOUNT + NUMCOUNT + MAX_STRINGS); const char **nx = (const char **) calloc(sizeof(const char *), count); alloc_arrays(); flag = t->flags & 255; nc = 0; for (i = 0; i < BOOLCOUNT; i++) { if (flag_boolean[i] & flag) { nx[nc++] = boolnames[i]; } } for (i = 0; i < NUMCOUNT; i++) { if (flag_numerics[i] & flag) { nx[nc++] = numnames[i]; } } for (i = 0; i < MAX_STRINGS; i++) { if (flag_strings[i] & flag) { nx[nc++] = STR_NAME(i); } } /* sort */ for (i = 0; i < nc - 1; i++) { for (j = i + 1; j < nc; j++) { if (strcmp(nx[i], nx[j]) > 0) { s = nx[i]; nx[i] = nx[j]; nx[j] = s; } } } if (flag & FLAG_FUNCTION_KEY) { ptextln("The following function keys can be tested:"); } else if (flag & FLAG_CAN_TEST) { ptextln("The following capabilities can be tested:"); } else if (flag & FLAG_TESTED) { ptextln("The following capabilities have been tested:"); } put_crlf(); for (i = 0; i < nc; i++) { sprintf(temp, "%s ", nx[i]); ptext(temp); } put_newlines(1); *ch = REQUEST_PROMPT; free (nx); } /* ** show_untested(test_list, status, ch) ** ** Display a list of caps that are defined but cannot be tested. ** Don't bother to sort this list. */ static void show_untested( struct test_list *t GCC_UNUSED, int *state GCC_UNUSED, int *ch) { int i; alloc_arrays(); ptextln("Caps that are defined but cannot be tested:"); for (i = 0; i < BOOLCOUNT; i++) { if (flag_boolean[i] == 0 && CUR Booleans[i]) { sprintf(temp, "%s ", boolnames[i]); ptext(temp); } } for (i = 0; i < NUMCOUNT; i++) { if (flag_numerics[i] == 0 && CUR Numbers[i] >= 0) { sprintf(temp, "%s ", numnames[i]); ptext(temp); } } for (i = 0; i < MAX_STRINGS; i++) { if (flag_strings[i] == 0 && CUR Strings[i]) { sprintf(temp, "%s ", STR_NAME(i)); ptext(temp); } } put_newlines(1); *ch = REQUEST_PROMPT; } /* ** edit_init() ** ** Initialize the function key data base */ void edit_init(void) { int i, j, lc; char *lab; struct name_table_entry const *nt; alloc_arrays(); _nc_copy_termtype(&original_term, &cur_term->type); for (i = 0; i < BOOLCOUNT; i++) { original_term.Booleans[i] = CUR Booleans[i]; } for (i = 0; i < NUMCOUNT; i++) { original_term.Numbers[i] = CUR Numbers[i]; } /* scan for labels */ for (i = lc = 0; i < MAX_STRINGS; i++) { original_term.Strings[i] = CUR Strings[i]; if (strncmp(STR_NAME(i), "lf", 2) == 0) { flag_strings[i] |= FLAG_LABEL; if (CUR Strings[i]) { label_strings[lc++] = i; } } } /* scan for function keys */ for (i = 0; i < MAX_STRINGS; i++) { const char *this_name = STR_NAME(i); if ((this_name[0] == 'k') && strcmp(this_name, "kmous")) { flag_strings[i] |= FLAG_FUNCTION_KEY; lab = (char *) 0; for (j = 0; j < lc; j++) { if (!strcmp(this_name, STR_NAME(label_strings[j]))) { lab = CUR Strings[label_strings[j]]; break; } } enter_key(this_name, CUR Strings[i], lab); } } /* Lookup the translated strings */ for (i = 0; i < TM_last; i++) { if ((nt = _nc_find_entry(TM_string[i].name, _nc_get_hash_table(FALSE))) && (nt->nte_type == STRING)) { TM_string[i].index = nt->nte_index; } else { sprintf(temp, "TM_string lookup failed for: %s", TM_string[i].name); ptextln(temp); } } if ((nt = _nc_find_entry("xon", _nc_get_hash_table(FALSE))) != 0) { xon_index = nt->nte_index; } xon_shadow = xon_xoff; FreeIfNeeded(label_strings); } /* ** change_one_entry(test_list, status, ch) ** ** Change the padding on the selected cap */ static void change_one_entry( struct test_list *test, int *state, int *chp) { struct name_table_entry const *nt; int i, j, x, star, slash, v, dot, ch; const char *s; char *t, *p; const char *current_string; char buf[1024]; char pad[1024]; i = test->flags & 255; if (i == 255) { /* read the cap name from the user */ ptext("enter name: "); read_string(pad, 32); if (pad[0] == '\0' || pad[1] == '\0') { *chp = pad[0]; return; } if ((nt = _nc_find_entry(pad, _nc_get_hash_table(FALSE))) && (nt->nte_type == STRING)) { x = nt->nte_index; current_string = CUR Strings[x]; } else { sprintf(temp, "%s is not a string capability", pad); ptext(temp); generic_done_message(test, state, chp); return; } } else { x = tx_index[i]; current_string = tx_cap[i]; strcpy(pad, STR_NAME(x)); } if (!current_string) { ptextln("That string is not currently defined. Please enter a new value, including the padding delay:"); read_string(buf, sizeof(buf)); _nc_reset_input((FILE *) 0, buf); _nc_trans_string(pad, pad + sizeof(pad)); t = (char *)malloc(strlen(pad) + 1); strcpy(t, pad); CUR Strings[x] = t; sprintf(temp, "new string value %s", STR_NAME(x)); ptextln(temp); ptextln(expand(t)); return; } sprintf(buf, "Current value: (%s) %s", pad, _nc_tic_expand(current_string, TRUE, TRUE)); putln(buf); ptextln("Enter new pad. 0 for no pad. CR for no change."); read_string(buf, 32); if (buf[0] == '\0' || (buf[1] == '\0' && isalpha(UChar(buf[0])))) { *chp = buf[0]; return; } star = slash = FALSE; for (j = v = dot = 0; (ch = buf[j]); j++) { if (ch >= '0' && ch <= '9') { v = ch - '0' + v * 10; if (dot) { dot++; } } else if (ch == '*') { star = TRUE; } else if (ch == '/') { slash = TRUE; } else if (ch == '.') { dot = 1; } else { sprintf(temp, "Illegal character: %c", ch); ptextln(temp); ptext("General format: 99.9*/ "); generic_done_message(test, state, chp); return; } } while (dot > 2) { v /= 10; dot--; } if (dot == 2) { sprintf(pad, "%d.%d%s%s", v / 10, v % 10, star ? "*" : "", slash ? "/" : ""); } else { sprintf(pad, "%d%s%s", v, star ? "*" : "", slash ? "/" : ""); } s = current_string; t = buf; for (v = 0; (ch = *t = *s++); t++) { if (v == '$' && ch == '<') { while ((ch = *s++) && (ch != '>')); for (p = pad; (*++t = *p++); ); *t++ = '>'; while ((*t++ = *s++)); pad[0] = '\0'; break; } v = ch; } if (pad[0]) { sprintf(t, "$<%s>", pad); } if ((t = (char *)malloc(strlen(buf) + 1))) { strcpy(t, buf); CUR Strings[x] = t; if (i != 255) { tx_cap[i] = t; } } generic_done_message(test, state, chp); } /* ** build_change_menu(menu_list) ** ** Build the change pad menu list */ static void build_change_menu( struct test_menu *m) { int i, j, k; char *s; for (i = j = 0; i < txp; i++) { if ((k = tx_index[i]) >= 0) { s = _nc_tic_expand(tx_cap[i], TRUE, TRUE); s[40] = '\0'; sprintf(change_pad_text[j], "%c) (%s) %s", 'a' + j, STR_NAME(k), s); change_pad_list[j].flags = i; change_pad_list[j].lines_needed = 4; change_pad_list[j].menu_entry = change_pad_text[j]; change_pad_list[j].test_procedure = change_one_entry; j++; } } strcpy(change_pad_text[j], "z) enter name"); change_pad_list[j].flags = 255; change_pad_list[j].lines_needed = 4; change_pad_list[j].menu_entry = change_pad_text[j]; change_pad_list[j].test_procedure = change_one_entry; j++; change_pad_list[j].flags = MENU_LAST; if (m->menu_title) { put_crlf(); ptextln(m->menu_title); } } #if NO_LEAKS void tack_edit_leaks(void) { /* * 2007/4/8 - * _nc_copy_termtype() does not copy str_table and ext_str_table. * The call to del_curterm() frees those - so we have to cancel * these pointers to prevent a double-free. */ original_term.str_table = 0; #if NCURSES_XNAMES original_term.ext_str_table = 0; #endif _nc_free_termtype(&original_term); FreeIfNeeded(label_strings); FreeIfNeeded(flag_strings); } #endif tack-1.07/fun.c0000644000175100001440000005032711315500742012043 0ustar tomusers/* ** Copyright (C) 1991, 1997 Free Software Foundation, Inc. ** ** This file is part of TACK. ** ** TACK is free software; you can redistribute it and/or modify ** it under the terms of the GNU General Public License as published by ** the Free Software Foundation; either version 2, or (at your option) ** any later version. ** ** TACK 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 TACK; see the file COPYING. If not, write to ** the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, ** Boston, MA 02110-1301, USA */ #include MODULE_ID("$Id: fun.c,v 1.11 2009/12/26 21:36:34 tom Exp $") /* * Test the function keys on the terminal. The code for echo tests * lives here too. */ static void funkey_keys(struct test_list *, int *, int *); static void funkey_meta(struct test_list *, int *, int *); static void funkey_label(struct test_list *, int *, int *); static void funkey_prog(struct test_list *, int *, int *); static void funkey_local(struct test_list *, int *, int *); struct test_list funkey_test_list[] = { {0, 0, 0, 0, "e) edit terminfo", 0, &edit_menu}, {MENU_CLEAR + FLAG_FUNCTION_KEY, 0, 0, 0, "f) show a list of function keys", show_report, 0}, {MENU_NEXT | MENU_CLEAR, 0, "smkx) (rmkx", 0, "k) test function keys", funkey_keys, 0}, {MENU_NEXT, 10, "km", "smm rmm", 0, funkey_meta, 0}, {MENU_NEXT, 8, "nlab) (smln) (pln) (rmln", "lw lh", 0, funkey_label, 0}, {MENU_NEXT, 2, "pfx", 0, 0, funkey_prog, 0}, {MENU_NEXT, 2, "pfloc", 0, 0, funkey_local, 0}, {MENU_LAST, 0, 0, 0, 0, 0, 0} }; static void printer_on(struct test_list *, int *, int *); static void printer_mc0(struct test_list *, int *, int *); struct test_list printer_test_list[] = { {0, 0, 0, 0, "e) edit terminfo", 0, &edit_menu}, {MENU_NEXT | MENU_CLEAR, 0, "mc4) (mc5) (mc5i", 0, 0, printer_on, 0}, {MENU_NEXT | MENU_CLEAR, 0, "mc0", 0, 0, printer_mc0, 0}, {MENU_LAST, 0, 0, 0, 0, 0, 0} }; /* local definitions */ static const char **fk_name; static char **fkval; static char **fk_label; /* function key labels (if any) */ static int *fk_tested; static size_t num_strings = 0; static unsigned fkmax = 1; /* length of longest key */ static int got_labels = 0; /* true if we have some labels */ static int key_count = 0; static int end_state; /* unknown function keys */ #define MAX_FK_UNK 50 static char *fk_unknown[MAX_FK_UNK]; static int fk_length[MAX_FK_UNK]; static int funk; /* * Initialize arrays that depend on the actual number of strings. */ static void alloc_strings(void) { if (num_strings != MAX_STRINGS) { num_strings = MAX_STRINGS; fk_name = (const char **)calloc(num_strings, sizeof(const char *)); fkval = (char **)calloc(num_strings, sizeof(char *)); fk_label = (char **)calloc(num_strings, sizeof(char *)); fk_tested = (int *)calloc(num_strings, sizeof(int)); } } /* ** keys_tested(first-time, show-help, hex-output) ** ** Display a list of the keys not tested. */ static void keys_tested( int first_time, int show_help, int hex_output) { int i, l; char outbuf[256]; alloc_strings(); put_clear(); tty_set(); flush_input(); if (got_labels) { putln("Function key labels:"); for (i = 0; i < key_count; ++i) { if (fk_label[i]) { sprintf(outbuf, "%s %s", fk_name[i] ? fk_name[i] : "??", fk_label[i]); put_columns(outbuf, (int) strlen(outbuf), 16); } } put_newlines(2); } if (funk) { putln("The following keys are not defined:"); for (i = 0; i < funk; ++i) { put_columns(fk_unknown[i], fk_length[i], 16); } put_mode(exit_attribute_mode); put_newlines(2); } if (first_time) { putln("The following keys are defined:"); } else { putln("The following keys have not been tested:"); } if (scan_mode) { for (i = 0; scan_down[i]; i++) { if (!scan_tested[i]) { if (hex_output) { strcpy(outbuf, hex_expand_to(scan_down[i], 3)); } else { strcpy(outbuf, expand(scan_down[i])); } l = expand_chars; if (hex_output) { strcat(outbuf, hex_expand_to(scan_up[i], 3)); } else { strcat(outbuf, expand(scan_up[i])); } expand_chars += l; l = (int) strlen(scan_name[i]); if (((char_count + 16) & ~15) + ((expand_chars + 7) & ~7) + l >= columns) { put_crlf(); } else if (char_count + 24 > columns) { put_crlf(); } else if (char_count) { putchp(' '); } put_columns(outbuf, expand_chars, 16); put_columns(scan_name[i], l, 8); } } } else { for (i = 0; i < key_count; i++) { if (!fk_tested[i]) { if (hex_output) { strcpy(outbuf, hex_expand_to(fkval[i], 3)); } else { strcpy(outbuf, expand(fkval[i])); } l = (int) strlen(fk_name[i]); if (((char_count + 16) & ~15) + ((expand_chars + 7) & ~7) + l >= columns) { put_crlf(); } else if (char_count + 24 > columns) { put_crlf(); } else if (char_count) { putchp(' '); } put_columns(outbuf, expand_chars, 16); put_columns(fk_name[i], l, 8); } } } put_newlines(2); if (show_help) { ptextln("Hit any function key. Type 'end' to quit. Type ? to update the display."); put_crlf(); } } /* ** enter_key(name, value, label) ** ** Enter a function key into the data base */ void enter_key( const char *name, char *value, char *lab) { unsigned j; alloc_strings(); if (value) { j = strlen(value); fkmax = fkmax > j ? fkmax : j; /* do not permit duplicates */ for (j = 0; (int) j < key_count; j++) { if (!strcmp(fk_name[j], name)) { return; } } fkval[key_count] = value; fk_tested[key_count] = 0; fk_label[key_count] = lab; fk_name[key_count++] = name; if (lab) { got_labels = TRUE; } } } static void fresh_line(void) { /* clear the line for a new function key line */ if (over_strike) { put_crlf(); } else { put_cr(); if (clr_eol) { tc_putp(clr_eol); } else { put_str(" \r"); } } } static int end_funky(int ch) { /* return true if this is the end */ switch (ch) { case 'e': case 'E': end_state = 'e'; break; case 'n': case 'N': if (end_state == 'e') { end_state = 'n'; } else { end_state = 0; } break; case 'd': case 'D': if (end_state == 'n') { end_state = 'd'; } else { end_state = 0; } break; case 'l': case 'L': if (end_state == 'l') { end_state = '?'; } else { end_state = 'l'; } break; default: end_state = 0; break; } return end_state == 'd'; } static int found_match(char *s, int hx, int cc) { /* return true if this string is a match */ int j, f; char outbuf[256]; alloc_strings(); if (!*s) { return 0; } if (scan_mode) { for (j = f = 0; scan_down[j]; j++) { if (scan_length[j] == 0) { continue; } if (!strncmp(s, scan_down[j], scan_length[j])) { if (!f) { /* first match */ put_cr(); if (hx) { put_str(hex_expand_to(s, 10)); } else { put_str(expand_to(s, 10)); } f = 1; } (void) end_funky(scan_name[j][0]); put_str(" "); put_str(scan_name[j]); scan_tested[j] = 1; s += scan_length[j]; if (strncmp(s, scan_up[j], scan_length[j])) { put_str(" scan down"); } else { s += scan_length[j]; } if (!*s) { break; } j = -1; } if (!strncmp(s, scan_up[j], scan_length[j])) { if (!f) { /* first match */ put_cr(); if (hx) { put_str(hex_expand_to(s, 10)); } else { put_str(expand_to(s, 10)); } f = 1; } put_str(" "); put_str(scan_name[j]); put_str(" scan up"); s += scan_length[j]; if (!*s) { break; } j = -1; } } } else { for (j = f = 0; j < key_count; j++) { if (!strcmp(s, fkval[j])) { if (!f) { /* first match */ put_cr(); if (hx) { put_str(hex_expand_to(s, 10)); } else { put_str(expand_to(s, 10)); } f = 1; } sprintf(outbuf, " (%s)", fk_name[j]); put_str(outbuf); if (fk_label[j]) { sprintf(outbuf, " <%s>", fk_label[j]); put_str(outbuf); } fk_tested[j] = 1; } } } if (end_state == '?') { keys_tested(0, 1, hx); tty_raw(cc, char_mask); end_state = 0; } return f; } static int found_exit(char *keybuf, int hx, int cc) { /* return true if the user wants to exit */ int j, k; char *s; if (scan_mode) { if (*keybuf == '\0') { return TRUE; } } else { /* break is a special case */ if (*keybuf == '\0') { fresh_line(); tty_set(); ptext("Hit X to exit: "); if (wait_here() == 'X') { return TRUE; } keys_tested(0, 1, hx); tty_raw(cc, char_mask); return FALSE; } /* is this the end? */ for (k = 0; (j = (keybuf[k] & STRIP_PARITY)); k++) { if (end_funky(j)) { return TRUE; } } j = TRUE; /* does he need an updated list? */ for (k = 0; keybuf[k]; k++) { j &= (keybuf[k] & STRIP_PARITY) == '?'; } if (j || end_state == '?') { keys_tested(0, 1, hx); tty_raw(cc, char_mask); end_state = 0; return FALSE; } } put_cr(); if (hx) { s = hex_expand_to(keybuf, 10); } else { s = expand_to(keybuf, 10); } sprintf(temp, "%s Unknown", s); put_str(temp); for (j = 0; j < MAX_FK_UNK; j++) { if (j == funk) { fk_length[funk] = expand_chars; if ((fk_unknown[funk] = (char *)malloc(strlen(s) + 1))) { strcpy(fk_unknown[funk++], s); } break; } if (fk_length[j] == expand_chars) { if (!strcmp(fk_unknown[j], s)) { break; } } } return FALSE; } /* ** funkey_keys(test_list, status, ch) ** ** Test function keys */ static void funkey_keys( struct test_list *t, int *state, int *ch) { char keybuf[256]; if (keypad_xmit) { tc_putp(keypad_xmit); } keys_tested(1, 1, hex_out); /* also clears screen */ keybuf[0] = '\0'; end_state = 0; if (scan_mode) { fkmax = scan_max; } tty_raw(0, char_mask); while (end_state != 'd') { read_key(keybuf, sizeof(keybuf)); fresh_line(); if (found_match(keybuf, hex_out, 0)) { continue; } if (found_exit(keybuf, hex_out, 0)) { break; } } if (keypad_local) { tc_putp(keypad_local); } keys_tested(0, 0, hex_out); ptext("Function key test "); generic_done_message(t, state, ch); } int tty_meta_prep(void) { /* print a warning before the meta key test */ if (not_a_tty) { return 0; } if (initial_stty_query(TTY_8_BIT)) { return 0; } ptext("The meta key test must be run with the"); ptext(" terminal set for 8 data bits. Two stop bits"); ptext(" may also be needed for correct display. I will"); ptext(" transmit 8 bit data but if the terminal is set for"); ptextln(" 7 bit data, garbage may appear on the screen."); return 1; } /* ** funkey_meta(test_list, status, ch) ** ** Test meta key (km) (smm) (rmm) */ static void funkey_meta( struct test_list *t, int *state, int *ch) { int i, j, k, len; char outbuf[256]; if (has_meta_key) { put_crlf(); if (char_mask != ALLOW_PARITY) { if (tty_meta_prep()) { ptext("\nHit any key to continue > "); (void) wait_here(); put_crlf(); } } ptext("Begin meta key test. (km) (smm) (rmm) Hit any key"); ptext(" with the meta key. The character will be"); ptext(" displayed in hex. If the meta key is working"); ptext(" then the most significant bit will be set. Type"); ptextln(" 'end' to exit."); tty_raw(1, ALLOW_PARITY); tc_putp(meta_on); for (i = j = k = len = 0; i != 'e' || j != 'n' || k != 'd';) { i = j; j = k; k = getchp(ALLOW_PARITY); if (k == EOF) { break; } if ((len += 3) >= columns) { put_crlf(); len = 3; } sprintf(outbuf, "%02X ", k); put_str(outbuf); k &= STRIP_PARITY; } tc_putp(meta_off); put_crlf(); tty_set(); put_crlf(); } else { ptext("(km) Has-meta-key is not set. "); } generic_done_message(t, state, ch); } /* ** funkey_label(test_list, status, ch) ** ** Test labels (nlab) (smln) (pln) (rmln) (lw) (lh) */ static void funkey_label( struct test_list *t, int *state, int *ch) { int i; char outbuf[256]; if (num_labels == -1) { ptextln("Your terminal has no labels. (nlab)"); } else { sprintf(temp, "Your terminal has %d labels (nlab) that are %d characters wide (lw) and %d lines high (lh)", num_labels, label_width, label_height); ptext(temp); ptextln(" Testing (smln) (pln) (rmln)"); if (label_on) { tc_putp(label_on); } if (label_width <= 0) { label_width = sizeof(outbuf) - 1; } for (i = 1; i <= num_labels; i++) { sprintf(outbuf, "L%d..............................", i); outbuf[label_width] = '\0'; tc_putp(TPARM_2(plab_norm, i, outbuf)); } if (label_off) { ptext("Hit any key to remove the labels: "); (void) wait_here(); tc_putp(label_off); } } generic_done_message(t, state, ch); } /* ** funkey_prog(test_list, status, ch) ** ** Test program function keys (pfx) */ static void funkey_prog( struct test_list *t, int *state, int *ch) { int i, fk; char mm[256]; fk = 1; /* use function key 1 for now */ if (pkey_xmit) { /* test program function key */ sprintf(temp, "(pfx) Set function key %d to transmit abc\\n", fk); ptextln(temp); tc_putp(TPARM_2(pkey_xmit, fk, "abc\n")); sprintf(temp, "Hit function key %d\n", fk); ptextln(temp); for (i = 0; i < 4; ++i) mm[i] = (char) getchp(STRIP_PARITY); mm[i] = '\0'; put_crlf(); if (mm[0] != 'a' || mm[1] != 'b' || mm[2] != 'c') { sprintf(temp, "Error string received was: %s", expand(mm)); ptextln(temp); } else { putln("Thank you\n"); } flush_input(); if (key_f1) { tc_putp(TPARM_2(pkey_xmit, fk, key_f1)); } } else { ptextln("Function key transmit (pfx), not present."); } generic_done_message(t, state, ch); } /* ** funkey_local(test_list, status, ch) ** ** Test program local function keys (pfloc) */ static void funkey_local( struct test_list *t, int *state, int *ch) { int fk; fk = 1; if (pkey_local) { /* test local function key */ sprintf(temp, "(pfloc) Set function key %d to execute a clear and print \"Done!\"", fk); ptextln(temp); sprintf(temp, "%sDone!", liberated(clear_screen)); tc_putp(TPARM_2(pkey_local, fk, temp)); sprintf(temp, "Hit function key %d. Then hit return.", fk); ptextln(temp); (void) wait_here(); flush_input(); if (key_f1 && pkey_xmit) { tc_putp(TPARM_2(pkey_xmit, fk, key_f1)); } } else { ptextln("Function key execute local (pfloc), not present."); } generic_done_message(t, state, ch); } /* ** printer_on(test_list, status, ch) ** ** Test printer on/off (mc4) (mc5) (mc5i) */ static void printer_on( struct test_list *t, int *state, int *ch) { if (!prtr_on || !prtr_off) { ptextln("Printer on/off missing. (mc5) (mc4)"); } else if (prtr_silent) { ptextln("Your printer is silent. (mc5i) is set."); tc_putp(prtr_on); ptextln("This line should be on the printer but not your screen. (mc5)"); tc_putp(prtr_off); ptextln("This line should be only on the screen. (mc4)"); } else { ptextln("Your printer is not silent. (mc5i) is reset."); tc_putp(prtr_on); ptextln("This line should be on the printer and the screen. (mc5)"); tc_putp(prtr_off); ptextln("This line should only be on the screen. (mc4)"); } generic_done_message(t, state, ch); } /* ** printer_mc0(test_list, status, ch) ** ** Test screen print (mc0) */ static void printer_mc0( struct test_list *t, int *state, int *ch) { if (print_screen) { ptext("I am going to send the contents of the screen to"); ptext(" the printer, then wait for a keystroke from you."); ptext(" All of the text that appears on the screen"); ptextln(" should be printed. (mc0)"); tc_putp(print_screen); } else { ptext("(mc0) Print-screen is not present. "); } generic_done_message(t, state, ch); } static void line_pattern(void) { /* put up a pattern that will help count the number of lines */ int i, j; put_clear(); if (over_strike) { for (i = 0; i < 100; i++) { if (i) { put_crlf(); } for (j = i / 10; j; j--) { put_this(' '); } put_this('0' + ((i + 1) % 10)); } } else /* I assume it will scroll */ { for (i = 100; i; i--) { sprintf(temp, "\r\n%d", i); put_str(temp); } } } static void column_pattern(void) { /* put up a pattern that will help count the number of columns */ int i, j; put_clear(); for (i = 0; i < 20; i++) { for (j = 1; j < 10; j++) { put_this('0' + j); } put_this('.'); } } /* ** report_help() ** ** Print the help text for the echo tests */ static void report_help(int crx) { ptextln("The following commands may also be entered:"); ptextln(" clear clear screen."); ptextln(" columns print a test pattern to help count screen width."); ptextln(" lines print a test pattern to help count screen length."); ptextln(" end exit."); ptextln(" echo redisplay last report."); if (crx) { ptextln(" hex redisplay last report in hex."); } else { ptextln(" hex toggle hex display mode."); } ptextln(" help display this list."); ptextln(" high toggle forced high bit (0x80)."); ptextln(" scan toggle scan mode."); ptextln(" one echo one character after or as is. (report mode)"); ptextln(" two echo two characters after or as is."); ptextln(" all echo all characters after or as is. (echo mode)"); } /* ** tools_report(testlist, state, ch) ** ** Run the echo tool and report tool */ void tools_report( struct test_list *t, int *state GCC_UNUSED, int *pch GCC_UNUSED) { int i, j, ch, crp, crx, high_bit, save_scan_mode, hex_display; char buf[1024]; char txt[8]; hex_display = hex_out; put_clear(); if ((crx = (t->flags & 255)) == 1) { ptext("Characters after a CR or LF will be echoed as"); ptextln(" is. All other characters will be expanded."); report_help(crx); } else { /* echo test */ ptextln("Begin echo test."); report_help(crx); } memset(txt, 0, sizeof(txt)); save_scan_mode = scan_mode; tty_raw(1, char_mask); for (i = crp = high_bit = 0;;) { ch = getchp(char_mask); if (ch == EOF) { break; } if (i >= (int) sizeof(buf) - 1) { i = 0; } buf[i++] = (char) ch; buf[i] = '\0'; for (j = 0; j < (int) sizeof(txt) - 1; j++) { txt[j] = txt[j + 1]; } txt[sizeof(txt) - 1] = (char) (ch & STRIP_PARITY); if (crx == 0) { /* echo test */ if (hex_display) { ptext(hex_expand_to(&buf[i - 1], 3)); } else { tc_putch(ch | high_bit); } } else /* status report test */ if (ch == '\n' || ch == '\r') { put_crlf(); crp = 0; } else if (crp++ < crx) { tc_putch(ch | high_bit); } else { put_str(expand(&buf[i - 1])); } if (!strncmp(&txt[sizeof(txt) - 7], "columns", 7)) { column_pattern(); buf[i = 0] = '\0'; crp = 0; } if (!strncmp(&txt[sizeof(txt) - 5], "lines", 5)) { line_pattern(); buf[i = 0] = '\0'; crp = 0; } if (!strncmp(&txt[sizeof(txt) - 5], "clear", 5)) { put_clear(); buf[i = 0] = '\0'; crp = 0; } if (!strncmp(&txt[sizeof(txt) - 4], "high", 4)) { high_bit ^= 0x80; if (high_bit) { ptextln("\nParity bit set"); } else { ptextln("\nParity bit reset"); } } if (!strncmp(&txt[sizeof(txt) - 4], "help", 4)) { put_crlf(); report_help(crx); } if (!strncmp(&txt[sizeof(txt) - 4], "echo", 4)) { /* display the last status report */ /* clear bypass condition on Tek terminals */ put_crlf(); if (i >= 4) { buf[i -= 4] = '\0'; } put_str(expand(buf)); } if (save_scan_mode && !strncmp(&txt[sizeof(txt) - 4], "scan", 4)) { /* toggle scan mode */ scan_mode = !scan_mode; } if (!strncmp(&txt[sizeof(txt) - 3], "end", 3)) break; if (!strncmp(&txt[sizeof(txt) - 3], "hex", 3)) { if (crx) { /* display the last status report in hex */ /* clear bypass condition on Tek terminals */ put_crlf(); if (i >= 3) { buf[i -= 3] = '\0'; } put_str(hex_expand_to(buf, 3)); } else { hex_display = !hex_display; } } if (!strncmp(&txt[sizeof(txt) - 3], "two", 3)) crx = 2; if (!strncmp(&txt[sizeof(txt) - 3], "one", 3)) crx = 1; if (!strncmp(&txt[sizeof(txt) - 3], "all", 3)) crx = 0; } scan_mode = save_scan_mode; put_crlf(); tty_set(); if (crx) { ptextln("End of status report test."); } else { ptextln("End of echo test."); } } #if NO_LEAKS void tack_fun_leaks(void) { FreeIfNeeded(fk_name); FreeIfNeeded(fkval); FreeIfNeeded(fk_label); FreeIfNeeded(fk_tested); } #endif tack-1.07/HISTORY0000644000175100001440000000465411315477451012207 0ustar tomusers Current history: 2009/12/26 1.07 Fix an allocation-size. 2007/08/11 1.06 Updates to build with ncurses 5.6 patch 20070811 2007/04/29 1.05 Updates to build with ncurses 5.6 patch 20070428 2007/04/08 1.04 Fixes from Coverity scan for ncurses 5.6 2007/01/28 1.03 Separate releases of tack from ncurses tree. 2006/11/25 Fixes for ncurses tparm() prototype. 2006/06/24 1.02 Modify to support ncurses extended string capabilities. 2003/10/18 1.01 Fix some logic in pad.c, improve bce test. 2003/09/20 Modified to allow running from compiled-in terminfo. 2001/10/20 Make menu titles agree with descriptions. 2000/03/04 Fix a few spelling errors 1999/09/04 Minor fix to build/link on BeOS 1999/05/16 Minor fix to build/link on CLIX 1999/05/09 Update to build/link on NeXT 1999/04/17 Update to work with ncurses 5.0 beta1 (TERMTYPE struct) 1999/02/07 Build with ncurses 4.2 981219 (renamed function) 1998/01/09 1.00 First release under GPL 1997/12/24 0.02 First version that requires ncurses 1997/10/29 0.01 Second beta release to the ncurses mailing list. 1997/10/06 0.00 First beta release to the ncurses mailing list. Ancient history: TACK -- the terminfo action checker The purpose of this program is to verify the correctness of terminfos and to calculate the pads needed for each capability. This program is not designed to test curses and therefore uses as little of curses as possible. This program was originally called TED. In 1991 it was released to USENET in comp.sources. TED was originally written to test both terminfos and termcaps. The original intent was to create a terminfo editor. This code fell quite short of its goal. Tests were controlled by command line switches and editing was done with pen and paper. In 1995 Eric S. Raymond got interested in the program and added a first cut at making the program menu driven. He also converted the code from K&R C to an ANSI/POSIX-conforming C. He re-christened the program TAC (Terminfo Action Checker). Eric also wrote a man page for TAC. In 1997 I decided to dust off the code and make it easier to use by the novice. I totally rewrote the menu system and added the editing features I originally planned for TED. I also did a total rewrite of the code that does the timings. In the process of rewriting the code I changed it to be more tightly coupled with ncurses. By this time someone had taken the name TAC so I re-christened the program TACK. Daniel Weaver tack-1.07/init.c0000644000175100001440000001646011315501070012211 0ustar tomusers/* ** Copyright (C) 1991, 1997 Free Software Foundation, Inc. ** ** This file is part of TACK. ** ** TACK is free software; you can redistribute it and/or modify ** it under the terms of the GNU General Public License as published by ** the Free Software Foundation; either version 2, or (at your option) ** any later version. ** ** TACK 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 TACK; see the file COPYING. If not, write to ** the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, ** Boston, MA 02110-1301, USA */ /* initialization and wrapup code */ #include #include MODULE_ID("$Id: init.c,v 1.11 2009/12/26 21:38:00 tom Exp $") #if NCURSES_VERSION_MAJOR >= 5 || NCURSES_VERSION_PATCH >= 981219 #define _nc_get_curterm(p) _nc_get_tty_mode(p) #endif FILE *debug_fp; char temp[1024]; char tty_basename[MAX_ALIAS * 2]; void put_name(const char *cap, const char *name) { /* send the cap name followed by the cap */ if (cap) { ptext(name); tc_putp(cap); } } static void report_cap(const char *tag, const char *s) { /* expand the cap or print *** missing *** */ int i; ptext(tag); for (i = char_count; i < 13; i++) { putchp(' '); } put_str(" = "); if (s) { putln(expand(s)); } else { putln("*** missing ***"); } } void reset_init(void) { /* send the reset and init strings */ int i; ptext("Terminal reset"); i = char_count; put_name(reset_1string, " (rs1)"); put_name(reset_2string, " (rs2)"); /* run the reset file */ if (reset_file && reset_file[0]) { FILE *fp; int ch; can_test("rf", FLAG_TESTED); if ((fp = fopen(reset_file, "r"))) { /* send the reset file */ sprintf(temp, " (rf) %s", reset_file); ptextln(temp); while (1) { ch = getc(fp); if (ch == EOF) break; put_this(ch); } fclose(fp); } else { sprintf(temp, "\nCannot open reset file (rf) %s", reset_file); ptextln(temp); } } put_name(reset_3string, " (rs3)"); if (i != char_count) { put_crlf(); } ptext(" init"); put_name(init_1string, " (is1)"); put_name(init_2string, " (is2)"); if (set_tab && clear_all_tabs && init_tabs != 8) { put_crlf(); tc_putp(clear_all_tabs); for (char_count = 0; char_count < columns; char_count++) { put_this(' '); if ((char_count & 7) == 7) { tc_putp(set_tab); } } put_cr(); } /* run the initialization file */ if (init_file && init_file[0]) { FILE *fp; int ch; can_test("if", FLAG_TESTED); if ((fp = fopen(init_file, "r"))) { /* send the init file */ sprintf(temp, " (if) %s", init_file); ptextln(temp); while (1) { ch = getc(fp); if (ch == EOF) break; put_this(ch); } fclose(fp); } else { sprintf(temp, "\nCannot open init file (if) %s", init_file); ptextln(temp); } } if (init_prog) { can_test("iprog", FLAG_TESTED); (void) system(init_prog); } put_name(init_3string, " (is3)"); fflush(stdout); } /* ** display_basic() ** ** display the basic terminal definitions */ void display_basic(void) { put_str("Name: "); putln(ttytype); report_cap("\\r ^M (cr)", carriage_return); report_cap("\\n ^J (ind)", scroll_forward); report_cap("\\b ^H (cub1)", cursor_left); report_cap("\\t ^I (ht)", tab); /* report_cap("\\f ^L (ff)", form_feed); */ if (newline) { /* OK if missing */ report_cap(" (nel)", newline); } report_cap(" (clear)", clear_screen); if (!cursor_home && cursor_address) { report_cap("(cup) (home)", TPARM_2(cursor_address, 0, 0)); } else { report_cap(" (home)", cursor_home); } #ifdef user9 report_cap("ENQ (u9)", user9); #endif #ifdef user8 report_cap("ACK (u8)", user8); #endif sprintf(temp, "\nTerminal size: %d x %d. Baud rate: %u. Frame size: %d.%d", columns, lines, tty_baud_rate, tty_frame_size >> 1, (tty_frame_size & 1) * 5); putln(temp); } /* ** curses_setup(exec_name) ** ** Startup ncurses */ void curses_setup( char *exec_name) { int status; TERMTYPE term; char tty_filename[2048]; tty_init(); /* * See if the terminal is in the terminfo data base. This call has two * useful benefits, 1) it returns the filename of the terminfo entry, * and 2) it searches only terminfo's. This allows us to abort before * ncurses starts scanning the termcap file. */ if ((status = _nc_read_entry(tty_basename, tty_filename, &term)) == 0) { const TERMTYPE *fallback = _nc_fallback(tty_basename); if (fallback) { term = *fallback; sprintf(tty_filename, "(fallback)%s", tty_basename); status = 1; } else { fprintf(stderr, "Terminal not found: TERM=%s\n", tty_basename); show_usage(exec_name); ExitProgram(EXIT_FAILURE); } } if (status == -1) { fprintf(stderr, "Terminfo database is inaccessible\n"); ExitProgram(EXIT_FAILURE); } #if NO_LEAKS _nc_free_termtype(&term); #endif /** * This call will load the terminfo data base and set the cur-term * variable. Only terminals that actually exist will get here so its * OK to ignore errors. This is a good thing since ncurses does not * permit (os) or (gn) to be set. */ setupterm(tty_basename, 1, &status); /** * Get the current terminal definitions. This must be done before * getting the baudrate. */ _nc_get_curterm(&cur_term->Nttyb); if (baudrate() > 0) tty_baud_rate = (unsigned) baudrate(); else tty_baud_rate = 1; tty_cps = (tty_baud_rate << 1) / tty_frame_size; /* set up the defaults */ replace_mode = TRUE; scan_mode = 0; char_count = 0; select_delay_type = debug_level = 0; char_mask = (meta_on && meta_on[0] == '\0') ? ALLOW_PARITY : STRIP_PARITY; /* Don't change the XON/XOFF modes yet. */ select_xon_xoff = initial_stty_query(TTY_XON_XOFF) ? 1 : needs_xon_xoff; fflush(stdout); /* flush any output */ tty_set(); go_home(); /* set can_go_home */ put_clear(); /* set can_clear_screen */ if (send_reset_init) { reset_init(); } /* * I assume that the reset and init strings may not have the correct * pads. (Because that part of the test comes much later.) Because * of this, I allow the terminal some time to catch up. */ fflush(stdout); /* waste some time */ sleep(1); /* waste more time */ charset_can_test(); can_test("lines cols cr nxon rf if iprog rmp smcup rmcup", FLAG_CAN_TEST); edit_init(); /* initialize the edit data base */ if (send_reset_init && enter_ca_mode) { tc_putp(enter_ca_mode); put_clear(); /* just in case we switched pages */ } put_crlf(); ptext("Using terminfo from: "); ptextln(tty_filename); put_crlf(); if (tty_can_sync == SYNC_NEEDED) { verify_time(); } display_basic(); } /* ** bye_kids(exit-condition) ** ** Shutdown the terminal, clear the signals, and exit */ void bye_kids(int n) { /* reset the tty and exit */ ignoresig(); if (send_reset_init) { if (exit_ca_mode) { tc_putp(exit_ca_mode); } if (initial_stty_query(TTY_XON_XOFF)) { if (enter_xon_mode) { tc_putp(enter_xon_mode); } } else if (exit_xon_mode) { tc_putp(exit_xon_mode); } } if (debug_fp) { fclose(debug_fp); } if (log_fp) { fclose(log_fp); } tty_reset(); fclose(stdin); fclose(stdout); fclose(stderr); if (not_a_tty) sleep(1); ExitProgram(n); } tack-1.07/install-sh0000755000175100001440000001572307762207755013137 0ustar tomusers#! /bin/sh # # install - install a program, script, or datafile # # This originates from X11R5 (mit/util/scripts/install.sh), which was # later released in X11R6 (xc/config/util/install.sh) with the # following copyright and license. # # Copyright (C) 1994 X Consortium # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to # deal in the Software without restriction, including without limitation the # rights to use, copy, modify, merge, publish, distribute, sublicense, and/or # sell copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in # all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN # AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNEC- # TION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. # # Except as contained in this notice, the name of the X Consortium shall not # be used in advertising or otherwise to promote the sale, use or other deal- # ings in this Software without prior written authorization from the X Consor- # tium. # # # FSF changes to this file are in the public domain. # # Calling this script install-sh is preferred over install.sh, to prevent # `make' implicit rules from creating a file called install from it # when there is no Makefile. # # This script is compatible with the BSD install script, but was written # from scratch. It can only install one file at a time, a restriction # shared with many OS's install programs. # set DOITPROG to echo to test this script # Don't use :- since 4.3BSD and earlier shells don't like it. doit="${DOITPROG-}" # put in absolute paths if you don't have them in your path; or use env. vars. mvprog="${MVPROG-mv}" cpprog="${CPPROG-cp}" chmodprog="${CHMODPROG-chmod}" chownprog="${CHOWNPROG-chown}" chgrpprog="${CHGRPPROG-chgrp}" stripprog="${STRIPPROG-strip}" rmprog="${RMPROG-rm}" mkdirprog="${MKDIRPROG-mkdir}" transformbasename="" transform_arg="" instcmd="$mvprog" chmodcmd="$chmodprog 0755" chowncmd="" chgrpcmd="" stripcmd="" rmcmd="$rmprog -f" mvcmd="$mvprog" src="" dst="" dir_arg="" while [ x"$1" != x ]; do case $1 in -c) instcmd=$cpprog shift continue;; -d) dir_arg=true shift continue;; -m) chmodcmd="$chmodprog $2" shift shift continue;; -o) chowncmd="$chownprog $2" shift shift continue;; -g) chgrpcmd="$chgrpprog $2" shift shift continue;; -s) stripcmd=$stripprog shift continue;; -t=*) transformarg=`echo $1 | sed 's/-t=//'` shift continue;; -b=*) transformbasename=`echo $1 | sed 's/-b=//'` shift continue;; *) if [ x"$src" = x ] then src=$1 else # this colon is to work around a 386BSD /bin/sh bug : dst=$1 fi shift continue;; esac done if [ x"$src" = x ] then echo "$0: no input file specified" >&2 exit 1 else : fi if [ x"$dir_arg" != x ]; then dst=$src src="" if [ -d "$dst" ]; then instcmd=: chmodcmd="" else instcmd=$mkdirprog fi else # Waiting for this to be detected by the "$instcmd $src $dsttmp" command # might cause directories to be created, which would be especially bad # if $src (and thus $dsttmp) contains '*'. if [ -f "$src" ] || [ -d "$src" ] then : else echo "$0: $src does not exist" >&2 exit 1 fi if [ x"$dst" = x ] then echo "$0: no destination specified" >&2 exit 1 else : fi # If destination is a directory, append the input filename; if your system # does not like double slashes in filenames, you may need to add some logic if [ -d "$dst" ] then dst=$dst/`basename "$src"` else : fi fi ## this sed command emulates the dirname command dstdir=`echo "$dst" | sed -e 's,[^/]*$,,;s,/$,,;s,^$,.,'` # Make sure that the destination directory exists. # this part is taken from Noah Friedman's mkinstalldirs script # Skip lots of stat calls in the usual case. if [ ! -d "$dstdir" ]; then defaultIFS=' ' IFS="${IFS-$defaultIFS}" oIFS=$IFS # Some sh's can't handle IFS=/ for some reason. IFS='%' set - `echo "$dstdir" | sed -e 's@/@%@g' -e 's@^%@/@'` IFS=$oIFS pathcomp='' while [ $# -ne 0 ] ; do pathcomp=$pathcomp$1 shift if [ ! -d "$pathcomp" ] ; then $mkdirprog "$pathcomp" else : fi pathcomp=$pathcomp/ done fi if [ x"$dir_arg" != x ] then $doit $instcmd "$dst" && if [ x"$chowncmd" != x ]; then $doit $chowncmd "$dst"; else : ; fi && if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd "$dst"; else : ; fi && if [ x"$stripcmd" != x ]; then $doit $stripcmd "$dst"; else : ; fi && if [ x"$chmodcmd" != x ]; then $doit $chmodcmd "$dst"; else : ; fi else # If we're going to rename the final executable, determine the name now. if [ x"$transformarg" = x ] then dstfile=`basename "$dst"` else dstfile=`basename "$dst" $transformbasename | sed $transformarg`$transformbasename fi # don't allow the sed command to completely eliminate the filename if [ x"$dstfile" = x ] then dstfile=`basename "$dst"` else : fi # Make a couple of temp file names in the proper directory. dsttmp=$dstdir/#inst.$$# rmtmp=$dstdir/#rm.$$# # Trap to clean up temp files at exit. trap 'status=$?; rm -f "$dsttmp" "$rmtmp" && exit $status' 0 trap '(exit $?); exit' 1 2 13 15 # Move or copy the file name to the temp name $doit $instcmd "$src" "$dsttmp" && # and set any options; do chmod last to preserve setuid bits # If any of these fail, we abort the whole thing. If we want to # ignore errors from any of these, just make sure not to ignore # errors from the above "$doit $instcmd $src $dsttmp" command. if [ x"$chowncmd" != x ]; then $doit $chowncmd "$dsttmp"; else :;fi && if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd "$dsttmp"; else :;fi && if [ x"$stripcmd" != x ]; then $doit $stripcmd "$dsttmp"; else :;fi && if [ x"$chmodcmd" != x ]; then $doit $chmodcmd "$dsttmp"; else :;fi && # Now remove or move aside any old file at destination location. We try this # two ways since rm can't unlink itself on some systems and the destination # file might be busy for other reasons. In this case, the final cleanup # might fail but the new file should still install successfully. { if [ -f "$dstdir/$dstfile" ] then $doit $rmcmd -f "$dstdir/$dstfile" 2>/dev/null || $doit $mvcmd -f "$dstdir/$dstfile" "$rmtmp" 2>/dev/null || { echo "$0: cannot unlink or rename $dstdir/$dstfile" >&2 (exit 1); exit } else : fi } && # Now rename the file to the real destination. $doit $mvcmd "$dsttmp" "$dstdir/$dstfile" fi && # The final little trick to "correctly" pass the exit status to the exit trap. { (exit 0); exit } tack-1.07/Makefile.in0000644000175100001440000001473411315503000013144 0ustar tomusers# $Id: Makefile.in,v 1.48 2009/12/26 21:54:08 tom Exp $ ############################################################################## # Copyright (c) 1998-2007,2009 Free Software Foundation, Inc. # # # # Permission is hereby granted, free of charge, to any person obtaining a # # copy of this software and associated documentation files (the "Software"), # # to deal in the Software without restriction, including without limitation # # the rights to use, copy, modify, merge, publish, distribute, distribute # # with modifications, sublicense, and/or sell copies of the Software, and to # # permit persons to whom the Software is furnished to do so, subject to the # # following conditions: # # # # The above copyright notice and this permission notice shall be included in # # all copies or substantial portions of the Software. # # # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL # # THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING # # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # # DEALINGS IN THE SOFTWARE. # # # # Except as contained in this notice, the name(s) of the above copyright # # holders shall not be used in advertising or otherwise to promote the sale, # # use or other dealings in this Software without prior written # # authorization. # ############################################################################## # Makefile for tack # # The variable 'srcdir' refers to the source-distribution, and can be set with # the configure script by "--srcdir=DIR". # # The rules are organized to produce the libraries for the configured models, # and the programs with the configured default model. # turn off _all_ suffix rules; we'll generate our own .SUFFIXES: SHELL = /bin/sh THIS = Makefile CF_MFLAGS = @cf_cv_makeflags@ @SET_MAKE@ x = @EXEEXT@ o = .@OBJEXT@ DESTDIR = @DESTDIR@ top_srcdir = @top_srcdir@ srcdir = @srcdir@ prefix = @prefix@ exec_prefix = @exec_prefix@ bindir = @bindir@ libdir = @libdir@ mandir = @mandir@ includedir = @includedir@ datadir = @datadir@ MODEL = ../@DFT_OBJ_SUBDIR@ INCDIR = $(top_srcdir)/include LIBTOOL = @LIBTOOL@ LIBTOOL_CLEAN = @LIB_CLEAN@ LIBTOOL_COMPILE = @LIB_COMPILE@ LIBTOOL_LINK = @LIB_LINK@ LIBTOOL_INSTALL = @LIB_INSTALL@ LIBTOOL_UNINSTALL = @LIB_UNINSTALL@ INSTALL = @INSTALL@ INSTALL_PROG = @INSTALL_PROGRAM@ INSTALL_DATA = @INSTALL_DATA@ AWK = @AWK@ LN_S = @LN_S@ CC = @CC@ CPP = @CPP@ CFLAGS = @CFLAGS@ CPPFLAGS = -DHAVE_CONFIG_H -I. -I$(srcdir) @CPPFLAGS@ CCFLAGS = $(CPPFLAGS) $(CFLAGS) CFLAGS_LIBTOOL = $(CCFLAGS) CFLAGS_NORMAL = $(CCFLAGS) CFLAGS_DEBUG = $(CCFLAGS) @CC_G_OPT@ -DTRACE CFLAGS_PROFILE = $(CCFLAGS) -pg CFLAGS_SHARED = $(CCFLAGS) @CC_SHARED_OPTS@ CFLAGS_DEFAULT = $(CFLAGS_@DFT_UPR_MODEL@) REL_VERSION = @cf_cv_rel_version@ ABI_VERSION = @cf_cv_abi_version@ LOCAL_LIBDIR = @top_builddir@/lib LD = @LD@ LINK = @LINK_PROGS@ $(LIBTOOL_LINK) LDFLAGS = @EXTRA_LDFLAGS@ \ @TICS_ARGS@ @TINFO_ARGS@ @LDFLAGS@ @LD_MODEL@ @LIBS@ LDFLAGS_LIBTOOL = $(LDFLAGS) $(CFLAGS_LIBTOOL) LDFLAGS_NORMAL = $(LDFLAGS) $(CFLAGS_NORMAL) LDFLAGS_DEBUG = $(LDFLAGS) $(CFLAGS_DEBUG) LDFLAGS_PROFILE = $(LDFLAGS) $(CFLAGS_PROFILE) LDFLAGS_SHARED = $(LDFLAGS) $(CFLAGS_SHARED) @LD_SHARED_OPTS@ LDFLAGS_DEFAULT = $(LDFLAGS_@DFT_UPR_MODEL@) LINT = @LINT@ LINT_OPTS = @LINT_OPTS@ LINT_LIBS = -lncurses@LIB_SUFFIX@ @LIBS@ PROGS = tack$x mymandir = $(mandir)/man1 @NCURSES_TREE@# Default library, for linking applications @NCURSES_TREE@DEPS_CURSES = ../lib/@LIB_PREFIX@ncurses@DFT_DEP_SUFFIX@ ################################################################################ all: $(PROGS) sources: install: install.tack uninstall: uninstall.tack # this line simplifies the configure-script libs \ install.libs \ uninstall.libs: install.tack: $(PROGS) \ $(DESTDIR)$(bindir) \ $(DESTDIR)$(mymandir) $(LIBTOOL_INSTALL) $(INSTALL_PROG) tack$x $(DESTDIR)$(bindir)/tack$x $(INSTALL_DATA) tack.1 $(DESTDIR)$(mymandir)/tack.1 uninstall.tack: -@$(LIBTOOL_UNINSTALL) rm -f $(DESTDIR)$(bindir)/tack$x rm -f $(DESTDIR)$(mymandir)/tack.1 $(DESTDIR)$(bindir) \ $(DESTDIR)$(mymandir) : mkdir -p $@ # # Rules for building tack # DEPS_TACK = \ $(MODEL)/ansi$o \ $(MODEL)/charset$o \ $(MODEL)/color$o \ $(MODEL)/control$o \ $(MODEL)/crum$o \ $(MODEL)/edit$o \ $(MODEL)/fun$o \ $(MODEL)/init$o \ $(MODEL)/menu$o \ $(MODEL)/modes$o \ $(MODEL)/output$o \ $(MODEL)/pad$o \ $(MODEL)/scan$o \ $(MODEL)/sync$o \ $(MODEL)/sysdep$o \ $(MODEL)/tack$o tack$x: $(DEPS_TACK) @NCURSES_TREE@$(DEPS_CURSES) @ECHO_LINK@ $(LINK) $(DEPS_TACK) $(LDFLAGS_DEFAULT) -o $@ # # Utility productions start here # tags: ctags *.[ch] @MAKE_UPPER_TAGS@TAGS: @MAKE_UPPER_TAGS@ etags *.[ch] mostlyclean :: -rm -f core tags TAGS *~ *.bak *.i *.atac trace clean :: mostlyclean -sh -c "if test -n '$x' ; then $(MAKE) clean x=''; fi" -rm -f $(DEPS_TACK) -rm -f $(PROGS) -rm -rf .libs distclean :: clean -rm -f ncurses_cfg.h -rm -f config.cache config.status *.log *.out -rm -f Makefile realclean :: distclean tack.tar: Makefile.in modules *.[ch] tack.1 HISTORY COPYING tar -cvf tack.tar Makefile.in modules *.[ch] tack.1 HISTORY COPYING # These rules are used to allow "make -n" to work on a clean directory-tree @NCURSES_TREE@../include/hashsize.h \ @NCURSES_TREE@../include/parametrized.h \ @NCURSES_TREE@../include/term.h : @NCURSES_TREE@ cd ../include; $(MAKE) $(CF_MFLAGS) @NCURSES_TREE@$(DEPS_CURSES) : @NCURSES_TREE@ cd ../ncurses; $(MAKE) $(CF_MFLAGS) lint: $(LINT) $(LINT_OPTS) $(CPPFLAGS) $(srcdir)/*.c $(LINT_LIBS) ############################################################################### # The remainder of this file is automatically generated during configuration ############################################################################### tack-1.07/menu.c0000644000175100001440000002070511315476645012232 0ustar tomusers/* ** Copyright (C) 1991, 1997 Free Software Foundation, Inc. ** ** This file is part of TACK. ** ** TACK is free software; you can redistribute it and/or modify ** it under the terms of the GNU General Public License as published by ** the Free Software Foundation; either version 2, or (at your option) ** any later version. ** ** TACK 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 TACK; see the file COPYING. If not, write to ** the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, ** Boston, MA 02110-1301, USA */ #include MODULE_ID("$Id: menu.c,v 1.7 2009/12/26 21:18:29 tom Exp $") /* Menu control */ static void test_byname(struct test_menu *, int *, int *); struct test_list *augment_test; char prompt_string[80]; /* menu prompt storage */ /* ** menu_prompt() ** ** Print the menu prompt string. */ void menu_prompt(void) { ptext(&prompt_string[1]); } /* ** menu_test_loop(test-structure, state, control-character) ** ** This function implements the repeat test function. */ static void menu_test_loop( struct test_list *test, int *state, int *ch) { int nch, p; if ((test->flags & MENU_REP_MASK) && (augment_test != test)) { /* set the augment variable (first time only) */ p = (test->flags >> 8) & 15; if ((test->flags & MENU_REP_MASK) == MENU_LM1) { augment = lines - 1; } else if ((test->flags & MENU_ONE_MASK) == MENU_ONE) { augment = 1; } else if ((test->flags & MENU_LC_MASK) == MENU_lines) { augment = lines * p / 10; } else if ((test->flags & MENU_LC_MASK) == MENU_columns) { augment = columns * p / 10; } else { augment = 1; } augment_test = test; set_augment_txt(); } do { if ((test->flags | *state) & MENU_CLEAR) { put_clear(); } else if (line_count + test->lines_needed >= lines) { put_clear(); } nch = 0; if (test->test_procedure) { /* The procedure takes precedence so I can pass the menu entry as an argument. */ can_test(test->caps_done, FLAG_TESTED); can_test(test->caps_tested, FLAG_TESTED); test->test_procedure(test, state, &nch); } else if (test->sub_menu) { /* nested menu's */ menu_display(test->sub_menu, &nch); *state = 0; if (nch == 'q' || nch == 's') { /* Quit and skip are killed here */ nch = '?'; } } else { break; /* cya */ } if (nch == '\r' || nch == '\n' || nch == 'n') { nch = 0; break; } } while (nch == 'r'); *ch = nch; } /* ** menu_display(menu-structure, flags) ** ** This function implements menu control. */ void menu_display( struct test_menu *menu, int *last_ch) { int test_state = 0, run_standard_tests; int hot_topic, ch = 0, nch = 0; struct test_list *mt; struct test_list *repeat_tests = 0; int repeat_state = 0; int prompt_length; prompt_length = (int) strlen(prompt_string); if (menu->ident) { sprintf(&prompt_string[prompt_length], "/%s", menu->ident); } hot_topic = menu->default_action; run_standard_tests = menu->standard_tests ? menu->standard_tests[0] : -1; if (!last_ch) { last_ch = &ch; } while (1) { if (ch == 0) { /* Display the menu */ put_crlf(); if (menu->menu_function) { /* this function may be used to restrict menu entries. If used it must print the title. */ menu->menu_function(menu); } else if (menu->menu_title) { ptextln(menu->menu_title); } for (mt = menu->tests; (mt->flags & MENU_LAST) == 0; mt++) { if (mt->menu_entry) { ptext(" "); ptextln(mt->menu_entry); } } if (menu->standard_tests) { ptext(" "); ptextln(menu->standard_tests); ptextln(" r) repeat test"); ptextln(" s) skip to next test"); } ptextln(" q) quit"); ptextln(" ?) help"); } if (ch == 0 || ch == REQUEST_PROMPT) { put_crlf(); ptext(&prompt_string[1]); if (hot_topic) { ptext(" ["); putchp(hot_topic); ptext("]"); } ptext(" > "); /* read a character */ ch = wait_here(); } if (ch == '\r' || ch == '\n') { ch = hot_topic; } if (ch == 'q') { break; } if (ch == '?') { ch = 0; continue; } nch = ch; ch = 0; /* Run one of the standard tests (by request) */ for (mt = menu->tests; (mt->flags & MENU_LAST) == 0; mt++) { if (mt->menu_entry && (nch == mt->menu_entry[0])) { if (mt->flags & MENU_MENU) { test_byname(menu, &test_state, &nch); } else { menu_test_loop(mt, &test_state, &nch); } ch = nch; if ((mt->flags & MENU_COMPLETE) && ch == 0) { /* top level */ hot_topic = 'q'; ch = '?'; } } } if (menu->standard_tests && nch == 'r') { menu->resume_tests = repeat_tests; test_state = repeat_state; nch = run_standard_tests; } if (nch == run_standard_tests) { if (!(mt = menu->resume_tests)) { mt = menu->tests; } if (mt->flags & MENU_LAST) { mt = menu->tests; } /* Run the standard test suite */ for ( ; (mt->flags & MENU_LAST) == 0; ) { if ((mt->flags & MENU_NEXT) == MENU_NEXT) { repeat_tests = mt; repeat_state = test_state; nch = run_standard_tests; menu_test_loop(mt, &test_state, &nch); if (nch != 0 && nch != 'n') { ch = nch; break; } if (test_state & MENU_STOP) { break; } } mt++; } if (ch == 0) { ch = hot_topic; } menu->resume_tests = mt; menu->resume_state = test_state; menu->resume_char = ch; if (ch == run_standard_tests) { /* pop up a level */ break; } } } *last_ch = ch; prompt_string[prompt_length] = '\0'; } /* ** generic_done_message(test_list) ** ** Print the Done message and request input. */ void generic_done_message( struct test_list *test, int *state, int *ch) { char done_message[128]; if (test->caps_done) { sprintf(done_message, "(%s) Done ", test->caps_done); ptext(done_message); } else { ptext("Done "); } *ch = wait_here(); if (*ch == '\r' || *ch == '\n' || *ch == 'n') { *ch = 0; } if (*ch == 's') { *state |= MENU_STOP; *ch = 0; } } /* ** menu_clear_screen(test, state, ch) ** ** Just clear the screen. */ void menu_clear_screen( struct test_list *test GCC_UNUSED, int *state GCC_UNUSED, int *ch GCC_UNUSED) { put_clear(); } /* ** menu_reset_init(test, state, ch) ** ** Send the reset and init strings. */ void menu_reset_init( struct test_list *test GCC_UNUSED, int *state GCC_UNUSED, int *ch GCC_UNUSED) { reset_init(); put_crlf(); } /* ** subtest_menu(test, state, ch) ** ** Scan the menu looking for something to execute ** Return TRUE if we found anything. */ int subtest_menu( struct test_list *test, int *state, int *ch) { struct test_list *mt; if (*ch) { for (mt = test; (mt->flags & MENU_LAST) == 0; mt++) { if (mt->menu_entry && (*ch == mt->menu_entry[0])) { *ch = 0; menu_test_loop(mt, state, ch); return TRUE; } } } return FALSE; } /* ** menu_can_scan(menu-structure) ** ** Recursively scan the menu tree and find which cap names can be tested. */ void menu_can_scan( const struct test_menu *menu) { struct test_list *mt; for (mt = menu->tests; (mt->flags & MENU_LAST) == 0; mt++) { can_test(mt->caps_done, FLAG_CAN_TEST); can_test(mt->caps_tested, FLAG_CAN_TEST); if (!(mt->test_procedure)) { if (mt->sub_menu) { menu_can_scan(mt->sub_menu); } } } } /* ** menu_search(menu-structure, cap) ** ** Recursively search the menu tree and execute any tests that use cap. */ static void menu_search( struct test_menu *menu, int *state, int *ch, char *cap) { struct test_list *mt; int nch; for (mt = menu->tests; (mt->flags & MENU_LAST) == 0; mt++) { nch = 0; if (cap_match(mt->caps_done, cap) || cap_match(mt->caps_tested, cap)) { menu_test_loop(mt, state, &nch); } if (!(mt->test_procedure)) { if (mt->sub_menu) { menu_search(mt->sub_menu, state, &nch, cap); } } if (*state & MENU_STOP) { break; } if (nch != 0 && nch != 'n') { *ch = nch; break; } } } /* ** test_byname(menu, state, ch) ** ** Get a cap name then run all tests that use that cap. */ static void test_byname( struct test_menu *menu, int *state GCC_UNUSED, int *ch) { int test_state = 0; char cap[32]; if (tty_can_sync == SYNC_NOT_TESTED) { verify_time(); } ptext("enter name: "); read_string(cap, sizeof(cap)); if (cap[0]) { menu_search(menu, &test_state, ch, cap); } *ch = '?'; } tack-1.07/modes.c0000644000175100001440000005105710532156325012367 0ustar tomusers/* ** Copyright (C) 1991, 1997 Free Software Foundation, Inc. ** ** This file is part of TACK. ** ** TACK is free software; you can redistribute it and/or modify ** it under the terms of the GNU General Public License as published by ** the Free Software Foundation; either version 2, or (at your option) ** any later version. ** ** TACK 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 TACK; see the file COPYING. If not, write to ** the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, ** Boston, MA 02110-1301, USA */ #include MODULE_ID("$Id: modes.c,v 1.6 2006/11/26 00:16:21 tom Exp $") /* * Tests boolean flags and terminal modes. */ static void subtest_os(struct test_list *, int *, int *); static void subtest_rmam(struct test_list *, int *, int *); static void subtest_smam(struct test_list *, int *, int *); static void subtest_am(struct test_list *, int *, int *); static void subtest_ul(struct test_list *, int *, int *); static void subtest_uc(struct test_list *, int *, int *); static void subtest_bw(struct test_list *, int *, int *); static void subtest_xenl(struct test_list *, int *, int *); static void subtest_eo(struct test_list *, int *, int *); static void subtest_xmc(struct test_list *, int *, int *); static void subtest_xhp(struct test_list *, int *, int *); static void subtest_mir(struct test_list *, int *, int *); static void subtest_msgr(struct test_list *, int *, int *); static void subtest_tbc(struct test_list *, int *, int *); static void subtest_xt(struct test_list *, int *, int *); static void subtest_hts(struct test_list *, int *, int *); static void subtest_cbt(struct test_list *, int *, int *); static void subtest_in(struct test_list *, int *, int *); static void subtest_dadb(struct test_list *, int *, int *); struct test_list mode_test_list[] = { {0, 0, 0, 0, "e) edit terminfo", 0, &edit_menu}, {MENU_NEXT, 3, "os", 0, 0, subtest_os, 0}, {MENU_NEXT, 1, "rmam", 0, 0, subtest_rmam, 0}, {MENU_NEXT, 1, "smam", 0, 0, subtest_smam, 0}, {MENU_NEXT, 1, "am", 0, 0, subtest_am, 0}, {MENU_NEXT, 3, "ul", 0, 0, subtest_ul, 0}, {MENU_NEXT, 3, "uc", 0, 0, subtest_uc, 0}, {MENU_NEXT, 3, "bw", 0, 0, subtest_bw, 0}, {MENU_NEXT, 4, "xenl", 0, 0, subtest_xenl, 0}, {MENU_NEXT, 3, "eo", 0, 0, subtest_eo, 0}, {MENU_NEXT, 3, "xmc", 0, 0, subtest_xmc, 0}, {MENU_NEXT, 3, "xhp", 0, 0, subtest_xhp, 0}, {MENU_NEXT, 6, "mir", 0, 0, subtest_mir, 0}, {MENU_NEXT, 6, "msgr", 0, 0, subtest_msgr, 0}, {MENU_NEXT | MENU_CLEAR, 0, "tbc", "it", 0, subtest_tbc, 0}, {MENU_NEXT | MENU_CLEAR, 0, "hts", "it", 0, subtest_hts, 0}, {MENU_NEXT, 4, "xt", "it", 0, subtest_xt, 0}, {MENU_NEXT, 1, "cbt", "it", 0, subtest_cbt, 0}, {MENU_NEXT, 6, "in", 0, 0, subtest_in, 0}, {MENU_NEXT, 1, "da) (db", 0, 0, subtest_dadb, 0}, {MENU_LAST, 0, 0, 0, 0, 0, 0} }; /* ** subtest_os(test_list, status, ch) ** ** test over strike mode (os) */ static void subtest_os( struct test_list *t, int *state, int *ch) { ptext("(os) should be true, not false."); put_cr(); ptextln("(os) should be false."); sprintf(temp, "(os) over-strike is %s in the data base. ", over_strike ? "true" : "false"); ptext(temp); generic_done_message(t, state, ch); } /* ** subtest_rmam(test_list, status, ch) ** ** test exit automatic margins mode (rmam) */ static void subtest_rmam( struct test_list *t, int *state, int *ch) { int j; if (!exit_am_mode) { ptext("(rmam) not present. "); } else if (!can_go_home) { ptext("(rmam) not tested, no way to home cursor. "); } else if (over_strike) { put_clear(); go_home(); tc_putp(exit_am_mode); ptext("\n(rmam) will reset (am)"); go_home(); for (j = 0; j < columns; j++) put_this(' '); ptext("(rmam) will not reset (am)"); go_home(); put_newlines(2); } else { put_clear(); go_home(); tc_putp(exit_am_mode); ptext("\n(rmam) will reset (am)"); go_home(); for (j = 0; j < columns; j++) put_this(' '); ptext("(rmam) will not reset (am) "); go_home(); put_str(" "); go_home(); put_newlines(2); } ptext("Exit-automatic-margins "); generic_done_message(t, state, ch); } /* ** subtest_smam(test_list, status, ch) ** ** test enter automatic margins mode (smam) */ static void subtest_smam( struct test_list *t, int *state, int *ch) { int i, j; if (!enter_am_mode) { ptext("(smam) not present. "); } else if (!can_go_home) { ptext("(smam) not tested, no way to home cursor. "); } else if (over_strike) { put_clear(); go_home(); tc_putp(enter_am_mode); ptext("\n(smam) will "); i = char_count; ptext("not set (am)"); go_home(); for (j = -i; j < columns; j++) put_this(' '); put_str("@@@"); put_newlines(2); } else { put_clear(); go_home(); tc_putp(enter_am_mode); ptext("\n(smam) will not set (am)"); go_home(); for (j = 0; j < columns; j++) put_this(' '); ptext("(smam) will set (am) "); go_home(); put_str(" "); put_newlines(2); } ptext("Enter-automatic-margins "); generic_done_message(t, state, ch); } /* ** subtest_am(test_list, status, ch) ** ** test automatic margins (am) */ static void subtest_am( struct test_list *t, int *state, int *ch) { int i, j; if (!can_go_home) { ptextln("(am) not tested, no way to home cursor. "); } else if (over_strike) { put_clear(); go_home(); ptext("\n(am) should "); i = char_count; ptext("not be set"); go_home(); for (j = -i; j < columns; j++) put_this(' '); put_str("@@@"); go_home(); put_newlines(2); sprintf(temp, "(am) is %s in the data base", auto_right_margin ? "true" : "false"); ptextln(temp); } else { put_clear(); go_home(); ptext("\n(am) should not be set"); go_home(); for (j = 0; j < columns; j++) put_this(' '); ptext("(am) should be set "); go_home(); put_str(" \n\n"); sprintf(temp, "(am) is %s in the data base", auto_right_margin ? "true" : "false"); ptextln(temp); } ptext("Automatic-right-margin "); generic_done_message(t, state, ch); } /* Note: uprint() sends underscore back-space character, and ucprint() sends character back-space underscore. */ /* ** uprint(string) ** ** underline string for (ul) test */ static void uprint(const char *s) { if (s) { while (*s) { put_str("_\b"); putchp(*s++); } } } /* ** ucprint(string) ** ** underline string for (uc) test */ static void ucprint(const char *s) { if (s) { while (*s) { putchp(*s++); putchp('\b'); tc_putp(underline_char); } } } /* ** subtest_ul(test_list, status, ch) ** ** test transparent underline (ul) */ static void subtest_ul( struct test_list *t, int *state, int *ch) { if (!over_strike) { /* (ul) is used only if (os) is reset */ put_crlf(); sprintf(temp, "This text should %sbe underlined.", transparent_underline ? "" : "not "); uprint(temp); put_crlf(); ptextln("If the above line is not underlined the (ul) should be false."); sprintf(temp, "(ul) Transparent-underline is %s in the data base", transparent_underline ? "true" : "false"); ptextln(temp); generic_done_message(t, state, ch); } } /* ** subtest_uc(test_list, status, ch) ** ** test underline character (uc) */ static void subtest_uc( struct test_list *t, int *state, int *ch) { if (!over_strike) { if (underline_char) { ucprint("This text should be underlined."); put_crlf(); ptextln("If the above text is not underlined the (uc) has failed."); ptext("Underline-character "); } else { ptext("(uc) underline-character is not defined. "); } generic_done_message(t, state, ch); } } /* ** subtest_bw(test_list, status, ch) ** ** test auto left margin (bw) */ static void subtest_bw( struct test_list *t, int *state, int *ch) { int i, j; if (over_strike) { /* test (bw) */ ptext("\n(bw) should "); i = char_count; ptextln("not be set."); for (j = i; j < columns; j++) put_str("\b"); put_str("@@@"); put_crlf(); sprintf(temp, "(bw) Auto-left-margin is %s in the data base", auto_left_margin ? "true" : "false"); ptextln(temp); } else { /* test (bw) */ ptextln("(bw) should not be set."); for (i = 12; i < columns; i++) put_str("\b"); if (delete_character) { for (i = 0; i < 4; i++) tc_putp(delete_character); } else { put_str(" "); } put_crlf(); sprintf(temp, "(bw) Auto-left-margin is %s in the data base", auto_left_margin ? "true" : "false"); ptextln(temp); } generic_done_message(t, state, ch); } /* ** subtest_tbc(test_list, status, ch) ** ** test clear tabs (tbc) */ static void subtest_tbc( struct test_list *t, int *state, int *ch) { int tabat; /* the tab spacing we end up with */ int i; if (clear_all_tabs && !set_tab) { ptext("(tbc) Clear-all-tabs is defined but (hts) set-tab is not. "); ptext("Once the tabs are cleared there is no way to set them. "); } else if (clear_all_tabs) { tabat = set_tab ? 8 : init_tabs; tc_putp(clear_all_tabs); ptext("Clear tabs (tbc)"); go_home(); put_crlf(); putchp('\t'); putchp('T'); go_home(); put_newlines(2); for (i = 0; i < columns; i++) { if (i == tabat) { putchp('T'); } else { putchp('.'); } } go_home(); ptext("\n\n\nIf the above two lines have T's in the same column then (tbc) has failed. "); } else { ptext("(tbc) Clear-all-tabs is not defined. "); } generic_done_message(t, state, ch); } /* ** subtest_hts(test_list, status, ch) ** ** (ht) and set tabs with (hts) */ static void subtest_hts( struct test_list *t, int *state, int *ch) { int tabat; /* the tab spacing we end up with */ int i; tabat = init_tabs; if (set_tab) { ptext("Tabs set with (hts)"); put_crlf(); for (i = 1; i < columns; i++) { if (i % 8 == 1) { tc_putp(set_tab); } putchp(' '); } tabat = 8; } else { sprintf(temp, "(hts) Set-tabs not defined. (it) Initial-tabs at %d", init_tabs); ptext(temp); } go_home(); put_newlines(2); if (tabat <= 0) { tabat = 8; } for (i = tabat; i < columns; i += tabat) { putchp('\t'); putchp('T'); } go_home(); put_newlines(3); for (i = 1; i < columns; i++) { putchp('.'); } go_home(); put_newlines(3); for (i = tabat; i < columns; i += tabat) { putchp('\t'); putchp('T'); } go_home(); put_newlines(4); putchp('.'); for (i = 2; i < columns; i++) { if (i % tabat == 1) { putchp('T'); } else { putchp('.'); } } go_home(); put_newlines(5); if (set_tab) { ptextln("If the last two lines are not the same then (hts) has failed."); } else if (init_tabs > 0) { ptextln("If the last two lines are not the same then (it) is wrong."); } else { ptextln("If the last two lines are the same then maybe you do have tabs and (it) should be changed."); } generic_done_message(t, state, ch); } /* ** subtest_xt(test_list, status, ch) ** ** (xt) glitch */ static void subtest_xt( struct test_list *t, int *state, int *ch) { int tabat; /* the tab spacing we end up with */ int cc; tabat = set_tab ? 8 : init_tabs; if (!over_strike && (tabat > 0)) { ptext("(xt) should not "); put_cr(); ptext("(xt) should"); cc = char_count; while (cc < 16) { putchp('\t'); cc = ((cc / tabat) + 1) * tabat; } putln("be set."); sprintf(temp, "(xt) Destructive-tab is %s in the data base.", dest_tabs_magic_smso ? "true" : "false"); ptextln(temp); generic_done_message(t, state, ch); } } /* ** subtest_cbt(test_list, status, ch) ** ** (cbt) back tab */ static void subtest_cbt( struct test_list *t, int *state, int *ch) { int i; if (back_tab) { put_clear(); ptext("Back-tab (cbt)"); go_home(); put_crlf(); for (i = 1; i < columns; i++) { putchp(' '); } for (i = 0; i < columns; i += 8) { tc_putp(back_tab); putchp('T'); tc_putp(back_tab); } go_home(); put_newlines(2); for (i = 1; i < columns; i++) { if (i % 8 == 1) { putchp('T'); } else { putchp(' '); } } go_home(); put_newlines(3); ptextln("The preceding two lines should be the same."); } else { ptextln("(cbt) Back-tab not present"); } generic_done_message(t, state, ch); } /* ** subtest_xenl(test_list, status, ch) ** ** (xenl) eat newline glitch */ static void subtest_xenl( struct test_list *t, int *state, int *ch) { int i, j, k; if (over_strike) { /* test (xenl) on overstrike terminals */ if (!can_go_home || !can_clear_screen) { ptextln("(xenl) Newline-glitch not tested, can't home cursor and clear."); generic_done_message(t, state, ch); return; } put_clear(); /* this test must be done in raw mode. Otherwise UNIX will translate CR to CRLF. */ if (stty_query(TTY_OUT_TRANS)) tty_raw(1, char_mask); ptext("\nreset (xenl). Does "); i = char_count; put_str("not ignore CR, does "); k = char_count; put_str("not ignore LF"); go_home(); for (j = 0; j < columns; j++) put_this(' '); put_cr(); for (j = 0; j < i; j++) putchp(' '); put_str("@@@\n@@"); go_home(); for (j = 0; j < columns; j++) put_this(' '); put_lf(); for (j = 0; j < k; j++) putchp(' '); put_str("@@@\r@@"); tty_set(); go_home(); put_newlines(4); sprintf(temp, "(xenl) Newline-glitch is %s in the data base", eat_newline_glitch ? "true" : "false"); ptextln(temp); } else { /* test (xenl) when (os) is reset */ if (!can_go_home) { ptextln("(xenl) Newline-glitch not tested, can't home cursor"); generic_done_message(t, state, ch); return; } /* (xenl) test */ put_clear(); /* this test must be done in raw mode. Otherwise UNIX will translate CR to CRLF. */ if (stty_query(TTY_OUT_TRANS)) tty_raw(1, char_mask); for (j = 0; j < columns; j++) put_this(' '); put_cr(); ptext("(xenl) should be set. Does not ignore CR"); go_home(); put_crlf(); for (j = 0; j < columns; j++) put_this(' '); put_lf(); /* test (cud1) */ ptext("(xenl) should be set. Ignores (cud1)"); go_home(); put_newlines(3); if (scroll_forward && cursor_down && strcmp(scroll_forward, cursor_down)) { for (j = 0; j < columns; j++) put_this(' '); put_ind(); /* test (ind) */ ptext("(xenl) should be set. Ignores (ind)"); go_home(); put_newlines(5); } tty_set(); ptextln("If you don't see text above telling you to set it, (xenl) should be false"); sprintf(temp, "(xenl) Newline-glitch is %s in the data base", eat_newline_glitch ? "true" : "false"); ptextln(temp); } generic_done_message(t, state, ch); } /* ** subtest_eo(test_list, status, ch) ** ** (eo) erase overstrike */ static void subtest_eo( struct test_list *t, int *state, int *ch) { if (transparent_underline || over_strike || underline_char) { ptext("(eo) should "); if (underline_char) { ucprint("not"); } else { uprint("not"); } put_cr(); ptextln("(eo) should be set"); sprintf(temp, "\n(eo) Erase-overstrike is %s in the data base", erase_overstrike ? "true" : "false"); ptextln(temp); generic_done_message(t, state, ch); } } /* ** subtest_xmc(test_list, status, ch) ** ** (xmc) magic cookie glitch */ static void subtest_xmc( struct test_list *t, int *state, int *ch) { int i, j; if (enter_standout_mode) { sprintf(temp, "\n(xmc) Magic-cookie-glitch is %d in the data base", magic_cookie_glitch); ptextln(temp); j = magic_cookie_glitch * 8; for (i = 0; i < j; i++) { put_str(" "); } ptextln(" These two lines should line up."); if (j > 0) { char_count += j; } for (i = 0; i < 4; i++) { put_mode(enter_standout_mode); putchp(' '); put_mode(exit_standout_mode); putchp(' '); } ptextln("These two lines should line up."); ptext("If they don't line up then (xmc) magic-cookie-glitch should be greater than zero. "); generic_done_message(t, state, ch); } } /* ** subtest_xhp(test_list, status, ch) ** ** (xhp) erase does not clear standout mode */ static void subtest_xhp( struct test_list *t, int *state, int *ch) { if (enter_standout_mode) { put_crlf(); put_mode(enter_standout_mode); put_str("Stand out"); put_mode(exit_standout_mode); put_cr(); ptextln("If any part of this line is standout then (xhp) should be set."); sprintf(temp, "(xhp) Erase-standout-glitch is %s in the data base", ceol_standout_glitch ? "true" : "false"); ptextln(temp); generic_done_message(t, state, ch); } } /* ** subtest_mir(test_list, status, ch) ** ** (mir) move in insert mode */ static void subtest_mir( struct test_list *t, int *state, int *ch) { int i; char *s; if (enter_insert_mode && exit_insert_mode && cursor_address) { put_clear(); i = line_count; put_str("\nXXX\nXXX\nXXX\nXXX"); tc_putp(enter_insert_mode); s = TPARM_2(cursor_address, i + 1, 0); tputs(s, lines, tc_putch); putchp('X'); s = TPARM_2(cursor_address, i + 2, 1); tputs(s, lines, tc_putch); putchp('X'); s = TPARM_2(cursor_address, i + 3, 2); tputs(s, lines, tc_putch); putchp('X'); s = TPARM_2(cursor_address, i + 4, 3); tputs(s, lines, tc_putch); putchp('X'); tc_putp(exit_insert_mode); put_newlines(2); ptextln("If you see a 4 by 4 block of X's then (mir) should be true."); sprintf(temp, "(mir) Move-in-insert-mode is %s in the data base", move_insert_mode ? "true" : "false"); ptextln(temp); } else { ptext("(mir) Move-in-insert-mode not tested, "); if (!enter_insert_mode) { ptext("(smir) "); } if (!exit_insert_mode) { ptext("(rmir) "); } if (!cursor_address) { ptext("(cup) "); } ptext("not present. "); } generic_done_message(t, state, ch); } /* ** subtest_msgr(test_list, status, ch) ** ** (msgr) move in sgr mode */ static void subtest_msgr( struct test_list *t, int *state, int *ch) { int i; if (cursor_address && ((enter_standout_mode && exit_standout_mode) || (enter_alt_charset_mode && exit_alt_charset_mode))) { put_crlf(); i = line_count + 1; tputs(TPARM_2(cursor_address, i, 0), lines, tc_putch); put_mode(enter_alt_charset_mode); put_crlf(); /* some versions of the wy-120 can not clear lines or screen when in alt charset mode. If (el) and (ed) are defined then I can test them. If they are not defined then they can not break (msgr) */ tc_putp(clr_eos); tc_putp(clr_eol); put_mode(exit_alt_charset_mode); put_mode(enter_standout_mode); putchp('X'); tputs(TPARM_2(cursor_address, i + 2, 1), lines, tc_putch); putchp('X'); tputs(TPARM_2(cursor_address, i + 3, 2), lines, tc_putch); putchp('X'); tputs(TPARM_2(cursor_address, i + 4, 3), lines, tc_putch); putchp('X'); put_mode(exit_standout_mode); put_crlf(); tc_putp(clr_eos); /* OK if missing */ put_crlf(); ptextln("If you see a diagonal line of standout X's then (msgr) should be true. If any of the blanks are standout then (msgr) should be false."); sprintf(temp, "(msgr) Move-in-SGR-mode is %s in the data base", move_standout_mode ? "true" : "false"); ptextln(temp); } else { ptextln("(smso) (rmso) (smacs) (rmacs) missing; (msgr) Move-in-SGR-mode not tested."); } generic_done_message(t, state, ch); } /* ** subtest_in(test_list, status, ch) ** ** (in) insert null glitch */ static void subtest_in( struct test_list *t, int *state, int *ch) { if (enter_insert_mode && exit_insert_mode) { ptextln("\nTesting (in) with (smir) and (rmir)"); putln("\tIf these two lines line up ..."); put_str("\tIf these two lines line up ..."); put_cr(); tc_putp(enter_insert_mode); putchp(' '); tc_putp(exit_insert_mode); ptext("\nthen (in) should be set. "); sprintf(temp, "(in) Insert-null-glitch is %s in the data base.", insert_null_glitch ? "true" : "false"); ptextln(temp); generic_done_message(t, state, ch); } } /* ** subtest_dadb(test_list, status, ch) ** ** (da) (db) data above, (db) data below */ static void subtest_dadb( struct test_list *t, int *state, int *ch) { if (can_clear_screen && scroll_reverse && scroll_forward) { put_clear(); if (scroll_reverse) ptext("(da) Data-above should be set\r"); home_down(); if (scroll_forward) ptext("(db) Data-below should be set\r"); tc_putp(scroll_forward); go_home(); tc_putp(scroll_reverse); tc_putp(scroll_reverse); home_down(); tc_putp(scroll_forward); go_home(); ptextln("\n\n\n\n\nIf the top line is blank then (da) should be false."); ptextln("If the bottom line is blank then (db) should be false."); sprintf(temp, "\n(da) Data-above is %s, and (db) Data-below is %s, in the data base.", memory_above ? "true" : "false", memory_below ? "true" : "false"); ptextln(temp); line_count = lines; } else { ptextln("(da) Data-above, (db) Data-below not tested, scrolls or (clear) is missing."); } generic_done_message(t, state, ch); } tack-1.07/modules0000644000175100001440000000630710543347630012510 0ustar tomusers# $Id: modules,v 1.6 2006/12/24 00:53:44 tom Exp $ ############################################################################## # Copyright (c) 1998-1999,2006 Free Software Foundation, Inc. # # # # Permission is hereby granted, free of charge, to any person obtaining a # # copy of this software and associated documentation files (the "Software"), # # to deal in the Software without restriction, including without limitation # # the rights to use, copy, modify, merge, publish, distribute, distribute # # with modifications, sublicense, and/or sell copies of the Software, and to # # permit persons to whom the Software is furnished to do so, subject to the # # following conditions: # # # # The above copyright notice and this permission notice shall be included in # # all copies or substantial portions of the Software. # # # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL # # THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING # # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # # DEALINGS IN THE SOFTWARE. # # # # Except as contained in this notice, the name(s) of the above copyright # # holders shall not be used in advertising or otherwise to promote the sale, # # use or other dealings in this Software without prior written # # authorization. # ############################################################################## # # Author: Thomas E. Dickey 1997-on # @ base ansi progs $(srcdir) $(srcdir)/tack.h ../include/term.h charset progs $(srcdir) $(srcdir)/tack.h ../include/term.h color progs $(srcdir) $(srcdir)/tack.h ../include/term.h control progs $(srcdir) $(srcdir)/tack.h ../include/term.h crum progs $(srcdir) $(srcdir)/tack.h ../include/term.h edit progs $(srcdir) $(srcdir)/tack.h ../include/term.h $(INCDIR)/tic.h fun progs $(srcdir) $(srcdir)/tack.h ../include/term.h init progs $(srcdir) $(srcdir)/tack.h ../include/term.h menu progs $(srcdir) $(srcdir)/tack.h ../include/term.h modes progs $(srcdir) $(srcdir)/tack.h ../include/term.h output progs $(srcdir) $(srcdir)/tack.h ../include/term.h pad progs $(srcdir) $(srcdir)/tack.h ../include/term.h scan progs $(srcdir) $(srcdir)/tack.h ../include/term.h sync progs $(srcdir) $(srcdir)/tack.h ../include/term.h sysdep progs $(srcdir) $(srcdir)/tack.h ../include/term.h tack progs $(srcdir) $(srcdir)/tack.h ../include/term.h # vile:makemode tack-1.07/ncurses_tst.hin0000644000175100001440000000560706470313015014165 0ustar tomusers/**************************************************************************** * Copyright (c) 1998 Free Software Foundation, Inc. * * * * Permission is hereby granted, free of charge, to any person obtaining a * * copy of this software and associated documentation files (the * * "Software"), to deal in the Software without restriction, including * * without limitation the rights to use, copy, modify, merge, publish, * * distribute, distribute with modifications, sublicense, and/or sell * * copies of the Software, and to permit persons to whom the Software is * * furnished to do so, subject to the following conditions: * * * * The above copyright notice and this permission notice shall be included * * in all copies or substantial portions of the Software. * * * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, * * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR * * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR * * THE USE OR OTHER DEALINGS IN THE SOFTWARE. * * * * Except as contained in this notice, the name(s) of the above copyright * * holders shall not be used in advertising or otherwise to promote the * * sale, use or other dealings in this Software without prior written * * authorization. * ****************************************************************************/ /**************************************************************************** * Author: Thomas E. Dickey 1998 * ****************************************************************************/ /* * $Id: ncurses_tst.hin,v 1.1 1998/02/11 12:14:05 tom Exp $ * * This is a template-file used to generate the "ncurses_cfg.h" file. * * Rather than list every definition, the configuration script substitutes * the definitions that it finds using 'sed'. You need a patch (971222) * to autoconf 2.12 to do this. */ #ifndef NC_CONFIG_H #define NC_CONFIG_H @DEFS@ /* The C compiler may not treat these properly but C++ has to */ #ifdef __cplusplus #undef const #undef inline #else #if defined(lint) || defined(TRACE) #undef inline #define inline /* nothing */ #endif #endif #endif /* NC_CONFIG_H */ tack-1.07/output.c0000644000175100001440000003535211315476746012634 0ustar tomusers/* ** Copyright (C) 1991, 1997 Free Software Foundation, Inc. ** ** This file is part of TACK. ** ** TACK is free software; you can redistribute it and/or modify ** it under the terms of the GNU General Public License as published by ** the Free Software Foundation; either version 2, or (at your option) ** any later version. ** ** TACK 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 TACK; see the file COPYING. If not, write to ** the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, ** Boston, MA 02110-1301, USA */ /* screen formatting and I/O utility functions */ #include #include MODULE_ID("$Id: output.c,v 1.14 2009/12/26 21:19:34 tom Exp $") /* globals */ long char_sent; /* number of characters sent */ int char_count; /* counts characters */ int line_count; /* counts line feeds */ int expand_chars; /* length of expand() string */ int replace_mode; /* used to output replace mode padding */ int can_go_home; /* TRUE if we can fashion a home command */ int can_clear_screen; /* TRUE if we can somehow clear the screen */ int raw_characters_sent; /* Total output characters */ static int log_count; /* Number of characters on a log line */ /* translate mode default strings */ #define TM_carriage_return TM_string[0].value #define TM_cursor_down TM_string[1].value #define TM_scroll_forward TM_string[2].value #define TM_newline TM_string[3].value #define TM_cursor_left TM_string[4].value #define TM_bell TM_string[5].value #define TM_form_feed TM_string[6].value #define TM_tab TM_string[7].value struct default_string_list TM_string[TM_last] = { {"cr", "\r", 0}, {"cud1", "\n", 0}, {"ind", "\n", 0}, {"nel", "\r\n", 0}, {"cub1", "\b", 0}, {"bel", "\007", 0}, {"ff", "\f", 0}, {"ht", "\t", 0} }; static const char *c0[32] = { "NUL", "SOH", "STX", "ETX", "EOT", "ENQ", "ACK", "BEL", "BS", "HT", "LF", "VT", "FF", "CR", "SO", "SI", "DLE", "DC1", "DC2", "DC3", "DC4", "NAK", "SYN", "ETB", "CAN", "EM", "SUB", "ESC", "FS", "GS", "RS", "US" }; static const char *c1[32] = { "", "", "", "", "IND", "NEL", "SSA", "ESA", "HTS", "HTJ", "VTS", "PLD", "PLU", "RI", "SS2", "SS3", "DCS", "PU1", "PU2", "STS", "CCH", "MW", "SPA", "EPA", "", "", "", "CSI", "ST", "OSC", "PM", "APC" }; int getnext(int mask) { /* get the next character without scan mode conversion */ int ch; unsigned char buf; tc_putp(req_for_input); fflush(stdout); if (nodelay_read) { while (1) { ch = read(fileno(stdin), &buf, 1); if (ch == -1) return EOF; if (ch == 1) return buf; } } ch = getchar(); if (ch == EOF) return EOF; return ch & mask; } int getchp(int mask) { /* read a character with scan mode conversion */ if (scan_mode) { tc_putp(req_for_input); fflush(stdout); return scan_key(); } else return getnext(mask); } /* ** tc_putch(c) ** ** Output one character */ int tc_putch(int c) { char_sent++; raw_characters_sent++; putchar(c); if ((raw_characters_sent & 31) == 31) { fflush(stdout); } if (log_fp) { /* terminal output logging */ c = UChar(c); if (c < 32) { fprintf(log_fp, "<%s>", c0[c]); log_count += 5; } else if (c < 127) { fprintf(log_fp, "%c", c); log_count += 1; } else { fprintf(log_fp, "<%02x>", c); log_count += 4; } if (c == '\n' || log_count >= 80) { fprintf(log_fp, "\n"); log_count = 0; } } return (c); } /* ** tt_tputs(string, reps) ** ** Output a string with tputs() translation. ** Use this function inside timing tests. */ void tt_tputs(const char *string, int reps) { int i; if (string) { for (i = 0; i < TT_MAX; i++) { if (i >= ttp) { tt_cap[i] = string; tt_affected[i] = reps; tt_count[i] = 1; tt_delay[i] = msec_cost(string, reps); ttp++; break; } if (string == tt_cap[i] && reps == tt_affected[i]) { tt_count[i]++; tt_delay_used += tt_delay[i]; break; } } (void) tputs(string, reps, tc_putch); } } /* ** tt_putp(string) ** ** Output a string with tputs() translation. ** Use this function inside timing tests. */ void tt_putp(const char *string) { tt_tputs(string, 1); } /* ** tt_putparm(string, reps, arg1, arg2) ** ** Send tt_tputs(tparm(string, args1, arg2), reps) ** Use this function inside timing tests. */ void tt_putparm( NCURSES_CONST char *string, int reps, int arg1, int arg2) { int i; if (string) { for (i = 0; i < TT_MAX; i++) { if (i >= ttp) { tt_cap[i] = string; tt_affected[i] = reps; tt_count[i] = 1; tt_delay[i] = msec_cost(string, reps); ttp++; break; } if (string == tt_cap[i] && reps == tt_affected[i]) { tt_count[i]++; tt_delay_used += tt_delay[i]; break; } } (void) tputs(TPARM_2((NCURSES_CONST char *)string, arg1, arg2), reps, tc_putch); } } /* ** tc_putp(string) ** ** Output a string with tputs() translation. ** Use this function instead of putp() so we can track ** the actual number of characters sent. */ int tc_putp(const char *string) { return tputs(string, 1, tc_putch); } void put_this(int c) { /* output one character (with padding) */ tc_putch(c); if (char_padding && replace_mode) tt_putp(char_padding); } void put_cr(void) { if (translate_mode && carriage_return) { tt_putp(carriage_return); } else { tt_putp(TM_carriage_return); } char_count = 0; } void put_lf(void) { /* send a linefeed (only works in RAW or CBREAK mode) */ if (translate_mode && cursor_down) { tt_putp(cursor_down); } else { tt_putp(TM_cursor_down); } line_count++; } void put_ind(void) { /* scroll forward (only works in RAW or CBREAK mode) */ if (translate_mode && scroll_forward) { tt_putp(scroll_forward); } else { tt_putp(TM_scroll_forward); } line_count++; } /* ** put_crlf() ** ** Send (nel) or */ void put_crlf(void) { if (translate_mode && newline) { tt_putp(newline); } else { tt_putp(TM_newline); } char_count = 0; line_count++; } /* ** put_new_lines(count) ** ** Send a number of newlines. (nel) */ void put_newlines(int n) { while (n-- > 0) { put_crlf(); } } /* ** putchp(character) ** ** Send one character to the terminal. ** This function does translation of control characters. */ void putchp(int c) { switch (c) { case '\b': if (translate_mode && cursor_left) { tt_putp(cursor_left); } else { tt_putp(TM_cursor_left); } char_count--; break; case 7: if (translate_mode && bell) { tt_putp(bell); } else { tt_putp(TM_bell); } break; case '\f': if (translate_mode && form_feed) { tt_putp(form_feed); } else { tt_putp(TM_form_feed); } char_count = 0; line_count++; break; case '\n': put_crlf(); break; case '\r': put_cr(); break; case '\t': if (translate_mode && tab) { tt_putp(tab); } else { tt_putp(TM_tab); } char_count = ((char_count / 8) + 1) * 8; break; default: put_this(c); char_count++; break; } } void put_str(const char *s) { /* send the string to the terminal */ for (; *s; putchp(*s++)); } void putln(const char *s) { /* output a string followed by a CR LF */ for (; *s; putchp(*s++)); put_crlf(); } void put_columns(const char *s, int len, int w) { /* put out s in column format */ int l; if (char_count + w > columns) { put_crlf(); } l = char_count % w; if (l) { while (l < w) { putchp(' '); l++; } } if (char_count && char_count + len >= columns) { put_crlf(); } l = char_count; put_str(s); char_count = l + len; } /* ** ptext(string) ** ** Output a string but do not assume the terminal will wrap to a ** new line. Break the line at a word boundary then send a CR LF. ** This is more esthetic on 40 column terminals. */ void ptext(const char *s) { const char *t; while (*s) { for (t = s + 1; *t > ' '; t++); if ((char_count != 0) && ((t - s) + char_count >= columns)) { put_crlf(); while (*s == ' ') s++; } while (s < t) { putchp(*s++); } } } void put_dec(char *f, int i) { /* print a line with a decimal number in it */ char tm[128]; sprintf(tm, f, i / 10, i % 10); ptext(tm); } void three_digit(char *tx, int i) { /* convert the decimal number to a string of at least 3 digits */ if (i < 1000) sprintf(tx, "%d.%d", i / 10, i % 10); else sprintf(tx, "%d", i / 10); } void ptextln(const char *s) { /* print the text using ptext() then add a CR LF */ ptext(s); put_crlf(); } static void expand_one(int ch, char **v) { /* expand one character */ char *t = *v; if (ch & 0x80) { /* dump it in octal (yuck) */ *t++ = '\\'; *t++ = (char) ('0' + ((ch >> 6) & 3)); *t++ = (char) ('0' + ((ch >> 3) & 7)); *t++ = (char) ('0' + (ch & 7)); expand_chars += 4; } else if (ch == 127) { /* DEL */ *t++ = '^'; *t++ = '?'; expand_chars += 2; } else if (ch >= ' ') { *t++ = (char) ch; expand_chars++; } else { /* control characters */ *t++ = '^'; *t++ = (char) (ch + '@'); expand_chars += 2; } *v = t; } char * expand(const char *s) { /* convert the string to printable form */ static char buf[4096]; char *t, *v; int ch; if (magic_cookie_glitch <= 0 && exit_attribute_mode) { v = enter_reverse_mode; } else { v = NULL; } expand_chars = 0; t = buf; if (s) { for (; (ch = *s); s++) { if ((ch & 0x80) && v) { /* print it in reverse video mode */ strcpy(t, liberated(TPARM_0(v))); for (; *t; t++); expand_one(ch & 0x7f, &t); strcpy(t, liberated(TPARM_0(exit_attribute_mode))); for (; *t; t++); } else { expand_one(ch, &t); } } } *t = '\0'; return buf; } char * print_expand(char *s) { /* convert the string to 7-bit printable form */ static char buf[4096]; char *t; int ch; expand_chars = 0; t = buf; if (s) { for (; (ch = *s); s++) { expand_one(ch, &t); } } *t = '\0'; return buf; } char * expand_to(char *s, int l) { /* expand s to length l */ char *t; for (s = t = expand(s); *t; t++); for (; expand_chars < l; expand_chars++) { *t++ = ' '; } *t = '\0'; return s; } char * hex_expand_to(char *s, int l) { /* expand s to length l in hex */ static char buf[4096]; char *t; for (t = buf; *s; s++) { sprintf(t, "%02X ", UChar(*s)); t += 3; if (t - buf > (int) sizeof(buf) - 4) { break; } } for (; t - buf < l;) { *t++ = ' '; } *t = '\0'; expand_chars = t - buf; return buf; } char * expand_command(const char *c) { /* expand an ANSI escape sequence */ static char buf[256]; int i, j, ch; char *s; s = buf; for (i = FALSE; (ch = UChar(*c)) != 0; c++) { if (i) { *s++ = ' '; } i = TRUE; if (ch < 32) { j = UChar(c[1]); if (ch == '\033' && j >= '@' && j <= '_') { ch = j - '@'; c++; for (j = 0; (*s = c1[ch][j++]); s++); } else for (j = 0; (*s = c0[ch][j++]); s++); } else { *s++ = (char) ch; j = UChar(c[1]); if (ch >= '0' && ch <= '9' && j >= '0' && j <= '9') { i = FALSE; } } } *s = '\0'; return buf; } /* ** go_home() ** ** Move the cursor to the home position */ void go_home(void) { int i; if (cursor_home) tt_putp(cursor_home); else if (cursor_address) tt_putparm(cursor_address, lines, 0, 0); else if (row_address) { /* use (vpa) */ put_cr(); tt_putparm(row_address, 1, 0, 0); } else if (cursor_up && cursor_to_ll) { tt_putp(cursor_to_ll); for (i = 1; i < lines; i++) { tt_putp(cursor_up); } } else { can_go_home = FALSE; return; } char_count = line_count = 0; can_go_home = TRUE; } void home_down(void) { /* move the cursor to the lower left hand corner */ int i; if (cursor_to_ll) tt_putp(cursor_to_ll); else if (cursor_address) tt_putparm(cursor_address, lines, lines - 1, 0); else if (row_address) { /* use (vpa) */ put_cr(); tt_putparm(row_address, 1, lines - 1, 0); } else if (cursor_down && cursor_home) { tt_putp(cursor_home); for (i = 1; i < lines; i++) tt_putp(cursor_down); } else return; char_count = 0; line_count = lines - 1; } void put_clear(void) { /* clear the screen */ int i; if (clear_screen) tt_tputs(clear_screen, lines); else if (clr_eos && can_go_home) { go_home(); tt_tputs(clr_eos, lines); } else if (scroll_forward && !over_strike && (can_go_home || cursor_up)) { /* clear the screen by scrolling */ put_cr(); if (cursor_to_ll) { tt_putp(cursor_to_ll); } else if (cursor_address) { tt_putparm(cursor_address, lines, lines - 1, 0); } else if (row_address) { tt_putparm(row_address, 1, lines - 1, 0); } else { for (i = 1; i < lines; i++) { tt_putp(scroll_forward); } } for (i = 1; i < lines; i++) { tt_putp(scroll_forward); } if (can_go_home) { go_home(); } else { for (i = 1; i < lines; i++) { tt_putp(cursor_up); } } } else { can_clear_screen = FALSE; return; } char_count = line_count = 0; can_clear_screen = TRUE; } /* ** wait_here() ** ** read one character from the input stream ** If the terminal is not in RAW mode then this function will ** wait for a or . */ int wait_here(void) { char ch, cc[64]; char message[16]; int i, j; for (i = 0; i < (int) sizeof(cc); i++) { cc[i] = ch = (char) getchp(STRIP_PARITY); if (ch == '\r' || ch == '\n') { put_crlf(); char_sent = 0; return cc[i ? i - 1 : 0]; } if (ch >= ' ') { if (stty_query(TTY_CHAR_MODE)) { put_crlf(); char_sent = 0; return ch; } continue; } if (ch == 023) { /* Control S */ /* ignore control S, but tell me about it */ while (ch == 023 || ch == 021) { ch = (char) getchp(STRIP_PARITY); if (ch == EOF) break; if (i + 1 < (int) sizeof(cc)) cc[++i] = ch; } put_str("\nThe terminal sent a ^S -"); for (j = 0; j <= i; j++) { sprintf(message, " %02X", cc[j] & 0xFF); put_str(message); } put_crlf(); i = -1; } else if (ch != 021) { /* Not Control Q */ /* could be abort character */ spin_flush(); if (tty_can_sync == SYNC_TESTED) { (void) tty_sync_error(); } else { put_str("\n? "); } } } return '?'; } /* ** read_string(buffer, length) ** ** Read a string of characters from the input stream. */ void read_string( char *buf, int length) { int ch, i; for (i = 0; i < length - 1; ) { ch = getchp(STRIP_PARITY); if (ch == '\r' || ch == '\n' || ch == EOF) { break; } if (ch == '\b' || ch == 127) { if (i) { putchp('\b'); putchp(' '); putchp('\b'); i--; } } else { buf[i++] = (char) ch; putchp(ch); } } buf[i] = '\0'; put_crlf(); char_sent = 0; } /* ** maybe_wait(lines) ** ** wait if near the end of the screen, then clear screen */ void maybe_wait(int n) { if (line_count + n >= lines) { if (char_sent != 0) { ptext("Go? "); (void) wait_here(); } put_clear(); } else { put_crlf(); } } tack-1.07/pad.c0000644000175100001440000012600311315500167012013 0ustar tomusers/* ** Copyright (C) 1991, 1997 Free Software Foundation, Inc. ** ** This file is part of TACK. ** ** TACK is free software; you can redistribute it and/or modify ** it under the terms of the GNU General Public License as published by ** the Free Software Foundation; either version 2, or (at your option) ** any later version. ** ** TACK 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 TACK; see the file COPYING. If not, write to ** the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, ** Boston, MA 02110-1301, USA */ #include MODULE_ID("$Id: pad.c,v 1.7 2009/12/26 21:30:31 tom Exp $") /* test the pad counts on the terminal */ static void pad_standard(struct test_list *, int *, int *); static void init_xon_xoff(struct test_list *, int *, int *); static void init_cup(struct test_list *, int *, int *); static void pad_rmxon(struct test_list *, int *, int *); static void pad_home1(struct test_list *, int *, int *); static void pad_home2(struct test_list *, int *, int *); static void pad_clear(struct test_list *, int *, int *); static void pad_ech(struct test_list *, int *, int *); static void pad_el1(struct test_list *, int *, int *); static void pad_el(struct test_list *, int *, int *); static void pad_smdc(struct test_list *, int *, int *); static void pad_dch(struct test_list *, int *, int *); static void pad_dch1(struct test_list *, int *, int *); static void pad_smir(struct test_list *, int *, int *); static void pad_ich(struct test_list *, int *, int *); static void pad_ich1(struct test_list *, int *, int *); static void pad_xch1(struct test_list *, int *, int *); static void pad_rep(struct test_list *, int *, int *); static void pad_cup(struct test_list *, int *, int *); static void pad_hd(struct test_list *, int *, int *); static void pad_hu(struct test_list *, int *, int *); static void pad_rin(struct test_list *, int *, int *); static void pad_il(struct test_list *, int *, int *); static void pad_indn(struct test_list *, int *, int *); static void pad_dl(struct test_list *, int *, int *); static void pad_xl(struct test_list *, int *, int *); static void pad_scrc(struct test_list *, int *, int *); static void pad_csrind(struct test_list *, int *, int *); static void pad_sccsrrc(struct test_list *, int *, int *); static void pad_csr_nel(struct test_list *, int *, int *); static void pad_csr_cup(struct test_list *, int *, int *); static void pad_ht(struct test_list *, int *, int *); static void pad_smso(struct test_list *, int *, int *); static void pad_smacs(struct test_list *, int *, int *); static void pad_crash(struct test_list *, int *, int *); /* Any command found in this list, executed from a "Done" prompt will force the default action to repeat rather than next. */ const char *pad_repeat_test = {"ep-+<>"}; struct test_list pad_test_list[] = { {0, 0, 0, 0, "e) edit terminfo", 0, &edit_menu}, {0, 0, 0, 0, "p) change padding", 0, &change_pad_menu}, {0, 0, 0, 0, "@) display statistics about the last test", dump_test_stats, 0}, {0, 0, 0, 0, "c) clear screen", menu_clear_screen, 0}, {0, 0, 0, 0, "i) send reset and init", menu_reset_init, 0}, {0, 0, 0, 0, txt_longer_test_time, longer_test_time, 0}, {0, 0, 0, 0, txt_shorter_test_time, shorter_test_time, 0}, {0, 0, 0, 0, txt_longer_augment, longer_augment, 0}, {0, 0, 0, 0, txt_shorter_augment, shorter_augment, 0}, /*** Phase 1: Test initialization and reset strings. (rs1) (rs2) (rs3) (is1) (is2) (is3) are very difficult to test. They have no defined output. To make matters worse, the cap builder could partition (rs1) (rs2) (rs3) by length, leaving the terminal in some unknown state between (rs1) and (rs2) or between (r2) and (rs3). Some reset strings clear the screen when done. We have no control over this. The only thing we can do for certain is to test the pad times by checking for overruns. ***/ {MENU_NEXT, 3, "rs1", 0, 0, pad_standard, 0}, {MENU_NEXT, 3, "rs2", 0, 0, pad_standard, 0}, {MENU_NEXT, 3, "rs3", 0, 0, pad_standard, 0}, {MENU_NEXT | MENU_INIT, 0, 0, 0, 0, init_xon_xoff, 0}, {MENU_NEXT, 3, "is1", 0, 0, pad_standard, 0}, {MENU_NEXT, 3, "is2", 0, 0, pad_standard, 0}, {MENU_NEXT, 3, "is3", 0, 0, pad_standard, 0}, {MENU_NEXT, 3, "rmxon", "smxon", 0, pad_rmxon, 0}, {MENU_NEXT | MENU_INIT, 0, 0, 0, 0, init_cup, 0}, /* Phase 2: Test home, screen clears and erases. */ {MENU_NEXT, 0, "home", 0, 0, pad_home1, 0}, {MENU_NEXT, 0, "home) (nel", 0, 0, pad_home2, 0}, {MENU_NEXT | 1, 0, "clear", 0, 0, pad_clear, 0}, {MENU_NEXT | MENU_LM1, 0, "ed", 0, 0, pad_clear, 0}, {MENU_NEXT | MENU_80c, 0, "ech", 0, 0, pad_ech, 0}, {MENU_NEXT | MENU_80c, 0, "el1", "cub1 nel", 0, pad_el1, 0}, {MENU_NEXT | MENU_10c, 0, "el", "nel", 0, pad_el, 0}, /* Phase 3: Character deletions and insertions */ {MENU_NEXT, 0, "smdc) (rmdc", 0, 0, pad_smdc, 0}, {MENU_NEXT | MENU_80c, 0, "dch", "smdc rmdc", 0, pad_dch, 0}, {MENU_NEXT | MENU_80c, 0, "dch1", "smdc rmdc", 0, pad_dch1, 0}, {MENU_NEXT, 0, "smir) (rmir", 0, 0, pad_smir, 0}, {MENU_NEXT | MENU_90c, 0, "ich) (ip", "smir rmir", 0, pad_ich, 0}, {MENU_NEXT | MENU_90c, 0, "ich1) (ip", "smir rmir", 0, pad_ich1, 0}, {MENU_NEXT, 4, "ich1) (dch1", "smir rmir", 0, pad_xch1, 0}, {MENU_NEXT | MENU_90c, 0, "rep", 0, 0, pad_rep, 0}, /* Phase 4: Test cursor addressing pads. */ {MENU_NEXT, 0, "cup", 0, 0, pad_cup, 0}, /* Phase 5: Test scrolling and cursor save/restore. */ {MENU_NEXT, 0, "hd", 0, 0, pad_hd, 0}, {MENU_NEXT, 0, "hu", 0, 0, pad_hu, 0}, {MENU_NEXT | MENU_LM1 | 1, 0, "rin", 0, 0, pad_rin, 0}, {MENU_NEXT, 0, "ri", 0, 0, pad_rin, 0}, {MENU_NEXT | MENU_LM1 | 1, 0, "il", 0, 0, pad_il, 0}, {MENU_NEXT, 0, "il1", 0, 0, pad_il, 0}, {MENU_NEXT | MENU_LM1 | 1, 0, "indn", 0, 0, pad_indn, 0}, {MENU_NEXT, 0, "ind", 0, 0, pad_indn, 0}, {MENU_NEXT | MENU_LM1 | 1, 0, "dl", 0, 0, pad_dl, 0}, {MENU_NEXT, 0, "dl1", 0, 0, pad_dl, 0}, {MENU_NEXT, 0, "il1) (dl1", 0, 0, pad_xl, 0}, {MENU_NEXT, 0, "sc) (rc", 0, 0, pad_scrc, 0}, {MENU_NEXT | MENU_50l, 0, "csr) (ind", 0, 0, pad_csrind, 0}, {MENU_NEXT, 0, "sc) (csr) (rc", 0, 0, pad_sccsrrc, 0}, {MENU_NEXT, 0, "csr) (nel", "sc rc", 0, pad_csr_nel, 0}, {MENU_NEXT, 0, "csr) (cup", 0, 0, pad_csr_cup, 0}, /* Phase 6: Test tabs. */ {MENU_NEXT, 0, "ht", 0, 0, pad_ht, 0}, /* Phase 7: Test character-set-switch pads. */ {MENU_NEXT, 0, "smso) (rmso", 0, 0, pad_smso, 0}, {MENU_NEXT, 0, "smacs) (rmacs", 0, 0, pad_smacs, 0}, /* Phase 8: Tests for miscellaneous mode-switch pads. */ {MENU_NEXT, 3, "flash", 0, 0, pad_standard, 0}, {MENU_NEXT, 3, "smkx", 0, 0, pad_standard, 0}, {MENU_NEXT, 3, "rmkx", 0, 0, pad_standard, 0}, {MENU_NEXT, 3, "smm", 0, 0, pad_standard, 0}, {MENU_NEXT, 3, "rmm", 0, 0, pad_standard, 0}, /* Phase 9: Test crash-and-burn properties of unpadded (clear). */ {0, 0, "clear", "xon", "k) run clear test with no padding", pad_crash, 0}, {MENU_LAST, 0, 0, 0, 0, 0, 0} }; /* globals */ static int hzcc; /* horizontal character count */ char letter; /* current character being displayed */ int letter_number; /* points into letters[] */ int augment, repeats; /* number of characters (or lines) effected */ char letters[] = "AbCdefghiJklmNopQrStuVwXyZ"; static char every_line[] = "This text should be on every line."; static char all_lines[] = "Each char on any line should be the same. "; static char above_line[] = "The above lines should be all Xs. "; static char no_visual[] = "This loop test has no visual failure indicator. "; /* ** pad_standard(test_list, status, ch) ** ** Run a single cap pad test. */ static void pad_standard( struct test_list *t, int *state, int *ch) { const char *long_name; char *cap; int l = 2, i; char tbuf[128]; if ((cap = get_string_cap_byname(t->caps_done, &long_name))) { sprintf(tbuf, "(%s) %s, start testing", t->caps_done, long_name); if (skip_pad_test(t, state, ch, tbuf)) { return; } i = 1; pad_test_startup(1); do { if (i >= columns) { page_loop(); l++; i = 1; } tt_putp(cap); putchp(letter); i++; } while(still_testing()); pad_test_shutdown(t, 0); if (l >= lines) { home_down(); } else { put_crlf(); } ptextln(no_visual); } else { CAP_NOT_FOUND; /* Note: get_string_cap_byname() always sets long_name */ sprintf(temp, "(%s) %s, not present. ", t->caps_done, long_name); ptext(temp); } pad_done_message(t, state, ch); } /* ** init_xon_xoff(test_list, status, ch) ** ** Initialize the xon_xoff values */ static void init_xon_xoff( struct test_list *t GCC_UNUSED, int *state GCC_UNUSED, int *ch GCC_UNUSED) { /* the reset strings may dink with the XON/XOFF modes */ if (select_xon_xoff == 0 && exit_xon_mode) { tc_putp(exit_xon_mode); } if (select_xon_xoff == 1 && enter_xon_mode) { tc_putp(enter_xon_mode); } } /* ** pad_rmxon(test_list, status, ch) ** ** Test (rmxon) exit XON/XOFF mode */ static void pad_rmxon( struct test_list *t, int *state, int *ch) { if (select_xon_xoff == 0 && exit_xon_mode) { pad_standard(t, state, ch); } } /* ** init_cup(test_list, status, ch) ** ** Send the initialization strings for XON/XOFF and (smcup) ** Stop pad testing if clear screen is missing. */ static void init_cup( struct test_list *t, int *state, int *ch) { init_xon_xoff(t, state, ch); if (enter_ca_mode) { tc_putp(enter_ca_mode); } if (!can_clear_screen) { ptext("(clear) clear screen not present,"); ptext(" pad processing terminated. "); pad_done_message(t, state, ch); if (*ch == 0 || *ch == 'n' || *ch == 's' || *ch == 'r') { *ch = '?'; } return; } } /* ** pad_home1(test_list, status, ch) ** ** Test (home) when (am) is set. */ static void pad_home1( struct test_list *t, int *state, int *ch) { int j, k; if (can_go_home && auto_right_margin) { /* truly brain damaged terminals will fail this test because they cannot accept data at full rate */ if (skip_pad_test(t, state, ch, "(home) Home start testing")) { return; } pad_test_startup(1); do { go_home(); for (j = 1; j < lines; j++) { for (k = 0; k < columns; k++) { if (k & 0xF) { put_this(letter); } else { put_this('.'); } } SLOW_TERMINAL_EXIT; } NEXT_LETTER; } while(still_testing()); pad_test_shutdown(t, 0); ptext("All the dots should line up. "); pad_done_message(t, state, ch); put_clear(); } } /* ** pad_home2(test_list, status, ch) ** ** Test (home) and (nel). (am) is reset. */ static void pad_home2( struct test_list *t, int *state, int *ch) { int j, k; if (can_go_home) { if (skip_pad_test(t, state, ch, "(home) Home, (nel) newline start testing")) { return; } pad_test_startup(1); do { go_home(); for (j = 1; j < lines; j++) { for (k = 2; k < columns; k++) { if (k & 0xF) { put_this(letter); } else { put_this('.'); } } put_crlf(); /* this does the (nel) */ SLOW_TERMINAL_EXIT; } NEXT_LETTER; } while(still_testing()); pad_test_shutdown(t, 0); ptext("All the dots should line up. "); pad_done_message(t, state, ch); put_clear(); } } /* ** pad_clear(test_list, status, ch) ** ** Test (clear) and (ed) ** run the clear screen tests (also clear-to-end-of-screen) ** ** 0) full page ** 1) sparse page ** 2) short lines ** 3) one full line ** 4) one short line */ static void pad_clear( struct test_list *t, int *state, int *ch) { const char *end_message = 0; const char *txt; int j, k, is_clear; int clear_select; /* select the test number */ is_clear = t->flags & 1; clear_select = auto_right_margin ? 0 : 1; if (is_clear) { txt = "(clear) clear-screen start testing"; } else { if (!clr_eos) { CAP_NOT_FOUND; ptext("(ed) erase-to-end-of-display, not present. "); pad_done_message(t, state, ch); return; } txt = "(ed) erase-to-end-of-display start testing"; } if (skip_pad_test(t, state, ch, txt)) { return; } if (enter_am_mode) { tc_putp(enter_am_mode); clear_select = 0; } for (; clear_select < 5; clear_select++) { if (augment > lines || is_clear || !cursor_address) { augment = lines; } else { if (augment <= 1) { augment = 2; } if (augment < lines) { put_clear(); tt_putparm(cursor_address, 1, lines - augment - 1, 0); ptextln("This line should not be erased (ed)"); } } repeats = augment; switch (clear_select) { case 0: end_message = "Clear full screen. "; break; case 1: end_message = "Clear sparse screen. "; if (cursor_down) { break; } clear_select++; /* FALLTHRU */ case 2: end_message = "Clear one character per line. "; if (newline) { break; } clear_select++; /* FALLTHRU */ case 3: end_message = "Clear one full line. "; break; case 4: end_message = "Clear single short line. "; break; } pad_test_startup(0); do { switch (clear_select) { case 0: /* full screen test */ for (j = 1; j < repeats; j++) { for (k = 0; k < columns; k++) { if (k & 0xF) { put_this(letter); } else { put_this('.'); } } SLOW_TERMINAL_EXIT; } break; case 1: /* sparse screen test */ for (j = columns - repeats; j > 2; j--) { put_this(letter); } for (j = 2; j < repeats; j++) { tt_putp(cursor_down); put_this(letter); } break; case 2: /* short lines */ for (j = 2; j < repeats; j++) { put_this(letter); tt_putp(newline); } put_this(letter); break; case 3: /* one full line */ for (j = columns - 5; j > 1; j--) { put_this(letter); } break; case 4: /* one short line */ put_str("Erase this!"); break; } if (is_clear) { put_clear(); } else { if (augment == lines) { go_home(); } else { tt_putparm(cursor_address, 1, lines - repeats, 0); } tt_tputs(clr_eos, repeats); } NEXT_LETTER; } while(still_testing()); pad_test_shutdown(t, 1); ptext(end_message); pad_done_message(t, state, ch); if (*ch != 0 && *ch != 'n') { return; } } } /* ** pad_ech(test_list, status, ch) ** ** Test (ech) erase characters */ static void pad_ech( struct test_list *t, int *state, int *ch) { int i, j; if (!erase_chars) { CAP_NOT_FOUND; ptext("(ech) Erase-characters, not present. "); pad_done_message(t, state, ch); return; } if (skip_pad_test(t, state, ch, "(ech) Erase-characters start testing")) { return; } if (augment > columns - 2) { augment = columns - 2; } pad_test_startup(1); do { go_home(); for (i = 2; i < lines; i++) { for (j = 0; j <= repeats; j++) { putchp(letter); } put_cr(); tt_putparm(erase_chars, repeats, repeats, 0); put_crlf(); SLOW_TERMINAL_EXIT; } for (i = 1; i <= repeats; i++) { putchp(' '); } putchp(letter); put_crlf(); NEXT_LETTER; } while(still_testing()); pad_test_shutdown(t, 0); ptext(all_lines); pad_done_message(t, state, ch); put_clear(); } /* ** pad_el1(test_list, status, ch) ** ** Test (el1) erase to start of line also (cub1) and (nel) */ static void pad_el1( struct test_list *t, int *state, int *ch) { int i, j; if (!clr_bol) { CAP_NOT_FOUND; ptext("(el1) Erase-to-beginning-of-line, not present. "); pad_done_message(t, state, ch); return; } if (skip_pad_test(t, state, ch, "(el1) Erase-to-beginning-of-line start testing")) { return; } if (augment > columns - 2) { augment = columns - 2; } pad_test_startup(1); do { go_home(); for (i = 2; i < lines; i++) { for (j = 0; j <= repeats; j++) { putchp(letter); } tt_putp(cursor_left); tt_putp(cursor_left); tt_tputs(clr_bol, repeats); put_crlf(); SLOW_TERMINAL_EXIT; } for (i = 1; i <= repeats; i++) { putchp(' '); } putchp(letter); put_crlf(); NEXT_LETTER; } while(still_testing()); pad_test_shutdown(t, 0); ptext(all_lines); pad_done_message(t, state, ch); put_clear(); } /* ** pad_el(test_list, status, ch) ** ** Test (el) clear to end of line also (nel) */ static void pad_el( struct test_list *t, int *state, int *ch) { int i, j; if (!clr_eol) { CAP_NOT_FOUND; ptext("(el) Clear-to-end-of-line, not present. "); pad_done_message(t, state, ch); return; } if (skip_pad_test(t, state, ch, "(el) Clear-to-end-of-line start testing")) { return; } hzcc = columns * 8 / 10; /* horizontal character count */ if (augment > hzcc) { augment = hzcc; } pad_test_startup(1); do { go_home(); for (i = 2; i < lines; i++) { for (j = -1; j < augment; j++) { putchp(letter); } put_cr(); putchp(letter); tt_putp(clr_eol); put_crlf(); SLOW_TERMINAL_EXIT; } putchp(letter); put_crlf(); NEXT_LETTER; } while(still_testing()); pad_test_shutdown(t, 0); ptext(all_lines); pad_done_message(t, state, ch); put_clear(); } /* ** pad_smdc(test_list, status, ch) ** ** Test (smdc) (rmdc) Delete mode */ static void pad_smdc( struct test_list *t, int *state, int *ch) { int i; if (!enter_delete_mode) { CAP_NOT_FOUND; ptext("(smdc) Enter-delete-mode"); if (!exit_delete_mode) { ptext(", (rmdc) Exit-delete-mode"); } ptext(", not present. "); pad_done_message(t, state, ch); return; } if (skip_pad_test(t, state, ch, "(smdc) (rmdc) Enter/Exit-delete-mode start testing")) { return; } pad_test_startup(1); do { page_loop(); for (i = 1; i < columns; i++) { tt_putp(enter_delete_mode); tt_putp(exit_delete_mode); putchp(letter); } } while(still_testing()); pad_test_shutdown(t, 0); home_down(); ptext(no_visual); pad_done_message(t, state, ch); put_clear(); } /* ** pad_dch(test_list, status, ch) ** ** Test (smdc) (rmdc) Delete mode and (dch) */ static void pad_dch( struct test_list *t, int *state, int *ch) { int i, j; if (!parm_dch) { CAP_NOT_FOUND; ptext("(dch) Delete-characters, not present. "); pad_done_message(t, state, ch); return; } if (skip_pad_test(t, state, ch, "(dch) Delete-characters start testing")) { return; } hzcc = columns * 8 / 10; /* horizontal character count */ if (augment > hzcc) { augment = hzcc; } pad_test_startup(1); do { go_home(); for (i = 2; i < lines; i++) { for (j = 0; j <= repeats; j++) { putchp(letter); } put_cr(); tt_putp(enter_delete_mode); tt_putparm(parm_dch, repeats, repeats, 0); tt_putp(exit_delete_mode); put_crlf(); SLOW_TERMINAL_EXIT; } putchp(letter); put_crlf(); NEXT_LETTER; } while(still_testing()); pad_test_shutdown(t, 0); home_down(); ptext(all_lines); pad_done_message(t, state, ch); put_clear(); } /* ** pad_dch1(test_list, status, ch) ** ** Test (smdc) (rmdc) Delete mode and (dch1) */ static void pad_dch1( struct test_list *t, int *state, int *ch) { int i, j; if (!delete_character) { if (parm_dch) { /* if the other one is defined then its OK */ return; } CAP_NOT_FOUND; ptext("(dch1) Delete-character, not present. "); pad_done_message(t, state, ch); return; } if (skip_pad_test(t, state, ch, "(dch1) Delete-character start testing")) { return; } hzcc = columns * 8 / 10; /* horizontal character count */ if (augment > hzcc) { augment = hzcc; } pad_test_startup(1); do { go_home(); for (i = 2; i < lines; i++) { for (j = -1; j < augment; j++) { putchp(letter); } put_cr(); tt_putp(enter_delete_mode); for (j = 0; j < augment; j++) { tt_putp(delete_character); } tt_putp(exit_delete_mode); put_crlf(); SLOW_TERMINAL_EXIT; } putchp(letter); put_crlf(); NEXT_LETTER; } while(still_testing()); pad_test_shutdown(t, 0); ptext(all_lines); pad_done_message(t, state, ch); put_clear(); } /* ** pad_smir(test_list, status, ch) ** ** Test (smir) (rmir) Insert mode */ static void pad_smir( struct test_list *t, int *state, int *ch) { int i; if (!enter_insert_mode) { CAP_NOT_FOUND; ptext("(smir) Enter-insert-mode"); if (!exit_insert_mode) { ptext(", (rmir) Exit-insert-mode"); } ptext(", not present. "); pad_done_message(t, state, ch); return; } if (skip_pad_test(t, state, ch, "(smir) (rmir) Enter/Exit-insert-mode start testing")) { return; } pad_test_startup(1); do { page_loop(); for (i = 1; i < columns; i++) { tt_putp(enter_insert_mode); tt_putp(exit_insert_mode); putchp(letter); } } while(still_testing()); pad_test_shutdown(t, 0); home_down(); ptext(no_visual); pad_done_message(t, state, ch); put_clear(); } /* ** pad_ich(test_list, status, ch) ** ** Test (smir) (rmir) Insert mode and (ich) and (ip) */ static void pad_ich( struct test_list *t, int *state, int *ch) { int i, j; if (!parm_ich) { CAP_NOT_FOUND; ptext("(ich) Insert-characters, not present. "); pad_done_message(t, state, ch); return; } if (skip_pad_test(t, state, ch, "(ich) Insert-characters, (ip) Insert-padding start testing")) { return; } j = columns * 9 / 10; if (augment > j) { augment = j; } pad_test_startup(1); do { go_home(); for (i = 2; i < lines; i++) { putchp(letter); put_cr(); tt_putp(enter_insert_mode); replace_mode = 0; tt_putparm(parm_ich, repeats, repeats, 0); tt_putp(exit_insert_mode); replace_mode = 1; put_crlf(); SLOW_TERMINAL_EXIT; } for (i = 0; i < repeats; i++) { putchp(' '); } putchp(letter); NEXT_LETTER; put_crlf(); } while(still_testing()); pad_test_shutdown(t, 0); ptext(all_lines); pad_done_message(t, state, ch); tc_putp(exit_insert_mode); } /* ** pad_ich1(test_list, status, ch) ** ** Test (smir) (rmir) Insert mode and (ich1) and (ip) */ static void pad_ich1( struct test_list *t, int *state, int *ch) { int i, j; if (!insert_character) { CAP_NOT_FOUND; ptext("(ich1) Insert-character, not present. "); pad_done_message(t, state, ch); return; } if (skip_pad_test(t, state, ch, "(ich1) Insert-character, (ip) Insert-padding start testing")) { return; } if (augment > columns - 2) { augment = columns - 2; } pad_test_startup(1); do { put_clear(); for (i = 2; i < lines; i++) { putchp(letter); put_cr(); tt_putp(enter_insert_mode); replace_mode = 0; if (!insert_padding && !insert_character) { /* only enter/exit is needed */ for (j = 0; j < augment; j++) { putchp('.'); } } else { for (j = 0; j < augment; j++) { tt_putp(insert_character); putchp('.'); tt_putp(insert_padding); } } tt_putp(exit_insert_mode); replace_mode = 1; put_crlf(); SLOW_TERMINAL_EXIT; } for (j = 0; j < augment; j++) { putchp('.'); } putchp(letter); NEXT_LETTER; put_crlf(); } while(still_testing()); pad_test_shutdown(t, 0); ptext(all_lines); pad_done_message(t, state, ch); tc_putp(exit_insert_mode); } /* ** pad_xch1(test_list, status, ch) ** ** Test (ich1) (ip) (dch1) */ static void pad_xch1( struct test_list *t, int *state, int *ch) { static char xch1[] = "This line should not be garbled. It should be left justified."; if (enter_insert_mode || exit_insert_mode || enter_delete_mode || exit_delete_mode || !insert_character || !delete_character) { /* this test is quietly ignored */ return; } if (skip_pad_test(t, state, ch, "(ich1) Insert-character, (dch1) Delete-character start testing")) { return; } put_crlf(); ptext(xch1); put_cr(); pad_test_startup(0); do { tt_putp(insert_character); tt_putp(delete_character); } while(still_testing()); pad_test_shutdown(t, 1); ptextln(xch1); ptext("The preceding two lines should be the same. "); pad_done_message(t, state, ch); } /* ** pad_rep(test_list, status, ch) ** ** Test (rep) repeat character */ static void pad_rep( struct test_list *t, int *state, int *ch) { int i, j; if (!repeat_char) { CAP_NOT_FOUND; ptext("(rep) Repeat-character, not present. "); pad_done_message(t, state, ch); return; } if (skip_pad_test(t, state, ch, "(rep) Repeat-character start testing")) { return; } if (augment > columns - 2) { augment = columns - 2; } if (augment < 2) { augment = 2; } pad_test_startup(1); do { go_home(); for (i = 2; i < lines; i++) { tt_putparm(repeat_char, repeats, letter, repeats); put_crlf(); } for (j = 0; j < repeats; j++) { putchp(letter); } put_crlf(); NEXT_LETTER; } while(still_testing()); pad_test_shutdown(t, 0); ptextln(all_lines); pad_done_message(t, state, ch); } /* ** pad_cup(test_list, status, ch) ** ** Test (cup) Cursor address */ static void pad_cup( struct test_list *t, int *state, int *ch) { int i, j, l, r, c; if (!cursor_address) { CAP_NOT_FOUND; ptext("(cup) Cursor-address not present. "); pad_done_message(t, state, ch); return; } if (skip_pad_test(t, state, ch, "(cup) Cursor-address start testing")) { return; } put_clear(); ptext("Each line should be filled with the same letter. There should"); ptext(" be no gaps, or single letters scattered over the screen. "); if (char_count + 15 > columns) { put_crlf(); } if (((lines - line_count) & 1) == 0) { /* this removes the gap in the middle of the test when the number of lines is odd. */ put_crlf(); } r = line_count; c = char_count; l = (columns - 4) >> 1; pad_test_startup(0); do { for (i = 1; i + i + r < lines; i++) { for (j = 0; j <= l; j++) { tt_putparm(cursor_address, 1, r + i, j); putchp(letter); tt_putparm(cursor_address, 1, r + i, l + l + 1 - j); putchp(letter); tt_putparm(cursor_address, 1, lines - i, j); putchp(letter); tt_putparm(cursor_address, 1, lines - i, l + l + 1 - j); putchp(letter); } SLOW_TERMINAL_EXIT; } NEXT_LETTER; } while(still_testing()); pad_test_shutdown(t, 0); tt_putparm(cursor_address, 1, line_count = r, char_count = c); pad_done_message(t, state, ch); put_clear(); } /* ** pad_hd(test_list, status, ch) ** ** Test (hd) Half down */ static void pad_hd( struct test_list *t, int *state, int *ch) { int i, j, k; if (!down_half_line) { CAP_NOT_FOUND; ptext("(hd) Half-line-down not present. "); pad_done_message(t, state, ch); return; } if (skip_pad_test(t, state, ch, "(hd) Half-line-down start testing")) { return; } pad_test_startup(1); do { for (i = 1; i < columns; i += 2) { for (j = 1; j < i; ++j) { putchp(' '); } tt_putp(down_half_line); for (k = lines + lines; k > 4; k--) { if (j++ >= columns) { break; } tt_putp(down_half_line); putchp(letter); } go_home(); SLOW_TERMINAL_EXIT; } NEXT_LETTER; } while(still_testing()); pad_test_shutdown(t, 0); pad_done_message(t, state, ch); put_clear(); } /* ** pad_hu(test_list, status, ch) ** ** Test (hu) Half line up */ static void pad_hu( struct test_list *t, int *state, int *ch) { int i, j, k; if (!up_half_line) { CAP_NOT_FOUND; ptext("(hu) Half-line-up not present. "); pad_done_message(t, state, ch); return; } if (skip_pad_test(t, state, ch, "(hu) Half-line-up start testing")) { return; } pad_test_startup(1); do { for (i = 1; i < columns; i += 2) { home_down(); for (j = 1; j < i; ++j) { putchp(' '); } tt_putp(up_half_line); for (k = lines + lines; k > 4; k--) { if (j++ >= columns) { break; } tt_putp(up_half_line); putchp(letter); } SLOW_TERMINAL_EXIT; } go_home(); NEXT_LETTER; } while(still_testing()); pad_test_shutdown(t, 0); pad_done_message(t, state, ch); put_clear(); } /* ** pad_rin(test_list, status, ch) ** ** Test (rin) and (ri) Reverse index */ static void pad_rin( struct test_list *t, int *state, int *ch) { int i; const char *start_message; if (t->flags & 1) { /* rin */ if (!parm_rindex) { CAP_NOT_FOUND; ptext("(rin) Scroll-reverse-n-lines not present. "); pad_done_message(t, state, ch); return; } start_message = "(rin) Scroll-reverse-n-lines start testing"; } else { /* ri */ if (!scroll_reverse) { CAP_NOT_FOUND; ptext("(ri) Scroll-reverse not present. "); pad_done_message(t, state, ch); return; } start_message = "(ri) Scroll-reverse start testing"; augment = 1; } if (skip_pad_test(t, state, ch, start_message)) { return; } pad_test_startup(1); do { sprintf(temp, "%d\r", test_complete); put_str(temp); if (scroll_reverse && repeats == 1) { tt_putp(scroll_reverse); } else { tt_putparm(parm_rindex, repeats, repeats, 0); } } while(still_testing()); put_str("This line should be on the bottom.\r"); if (scroll_reverse && augment == 1) { for (i = 1; i < lines; i++) { tt_putp(scroll_reverse); } } else { tt_putparm(parm_rindex, lines - 1, lines - 1, 0); } putln("The screen should have text on the bottom line."); sprintf(temp, "Scroll reverse %d line%s. ", augment, augment == 1 ? "" : "s"); put_str(temp); pad_test_shutdown(t, 0); pad_done_message(t, state, ch); put_clear(); } /* ** pad_il(test_list, status, ch) ** ** Test (il) and (il1) Insert line */ static void pad_il( struct test_list *t, int *state, int *ch) { int i; const char *start_message; if (t->flags & 1) { /* il */ if (!parm_insert_line) { CAP_NOT_FOUND; ptext("(il) Insert-lines not present. "); pad_done_message(t, state, ch); return; } start_message = "(il) Insert-lines start testing"; } else { /* il1 */ if (!insert_line) { CAP_NOT_FOUND; ptext("(il1) Insert-line not present. "); pad_done_message(t, state, ch); return; } start_message = "(il1) Insert-line start testing"; augment = 1; } if (skip_pad_test(t, state, ch, start_message)) { return; } pad_test_startup(1); do { sprintf(temp, "%d\r", test_complete); put_str(temp); if (insert_line && repeats == 1) { tt_putp(insert_line); } else { tt_putparm(parm_insert_line, repeats, repeats, 0); } } while(still_testing()); put_str("This line should be on the bottom.\r"); if (insert_line && augment == 1) { for (i = 1; i < lines; i++) { tt_putp(insert_line); } } else { tt_putparm(parm_insert_line, lines - 1, lines - 1, 0); } putln("The screen should have text on the bottom line."); sprintf(temp, "Insert %d line%s. ", augment, augment == 1 ? "" : "s"); put_str(temp); pad_test_shutdown(t, 0); pad_done_message(t, state, ch); put_clear(); } /* ** pad_indn(test_list, status, ch) ** ** Test (indn) and (ind) Scroll forward */ static void pad_indn( struct test_list *t, int *state, int *ch) { int i; const char *start_message; if (t->flags & 1) { /* indn */ if (!parm_index) { CAP_NOT_FOUND; ptext("(indn) Scroll-forward-n-lines not present. "); pad_done_message(t, state, ch); return; } start_message = "(indn) Scroll-forward-n-lines start testing"; } else { /* ind */ if (!scroll_forward) { CAP_NOT_FOUND; ptext("(ind) Scroll-forward not present. "); pad_done_message(t, state, ch); return; } if (over_strike) { ptext("(ind) Scroll-forward not tested on overstrike terminals. "); pad_done_message(t, state, ch); return; } start_message = "(ind) Scroll-forward start testing"; augment = 1; } if (skip_pad_test(t, state, ch, start_message)) { return; } pad_test_startup(1); /* go to the bottom of the screen */ home_down(); do { sprintf(temp, "%d\r", test_complete); put_str(temp); if (scroll_forward && repeats == 1) { put_ind(); } else { tt_putparm(parm_index, repeats, repeats, 0); } } while(still_testing()); put_str("This line should be on the top.\r"); if (scroll_forward && augment == 1) { for (i = 1; i < lines; i++) { put_ind(); } } else { tt_putparm(parm_index, lines - 1, lines - 1, 0); } go_home(); sprintf(temp, "\nScroll forward %d line%s. ", augment, augment == 1 ? "" : "s"); put_str(temp); pad_test_shutdown(t, 0); pad_done_message(t, state, ch); } /* ** pad_dl(test_list, status, ch) ** ** Test (dl) and (dl1) Delete lines */ static void pad_dl( struct test_list *t, int *state, int *ch) { int i = 0; const char *start_message; if (t->flags & 1) { /* dl */ if (!parm_delete_line) { CAP_NOT_FOUND; ptext("(dl) Delete-lines not present. "); pad_done_message(t, state, ch); return; } start_message = "(dl) Delete-lines start testing"; } else { /* dl1 */ if (!delete_line) { CAP_NOT_FOUND; ptext("(dl1) Delete-line not present. "); pad_done_message(t, state, ch); return; } start_message = "(dl1) Delete-line start testing"; augment = 1; } if (skip_pad_test(t, state, ch, start_message)) { return; } pad_test_startup(1); do { sprintf(temp, "%d\r", test_complete); if (augment < lines - 1) { go_home(); putln(temp); } put_str(temp); if (delete_line && repeats == 1) { tt_putp(delete_line); } else { tt_putparm(parm_delete_line, repeats, repeats, 0); } } while(still_testing()); home_down(); put_str("This line should be on the top."); go_home(); if (delete_line && augment == 1) { for (i = 1; i < lines; i++) { tt_putp(delete_line); } } else { tt_putparm(parm_delete_line, lines - 1, lines - 1, 0); } sprintf(temp, "\nDelete %d line%s. ", augment, augment == 1 ? "" : "s"); put_str(temp); pad_test_shutdown(t, 0); pad_done_message(t, state, ch); } /* ** pad_xl(test_list, status, ch) ** ** Test (il1) Insert and (dl1) Delete lines */ static void pad_xl( struct test_list *t, int *state, int *ch) { if (!insert_line && !delete_line) { /* quietly skip this test */ return; } if (skip_pad_test(t, state, ch, "(il1) Insert-line, (dl1) Delete-line start testing")) { return; } put_clear(); putln("\rThis text is written on the first line."); ptext("This sentence begins on the second line. As this"); ptext(" test runs the bottom part of this paragraph will"); ptext(" jump up and down. Don't worry, that's normal. When"); ptext(" the jumping stops, the entire paragraph should"); ptext(" still be on the screen and in the same place as when"); ptext(" the test started. If this paragraph has scrolled"); ptext(" off the top or bottom of the screen then the test"); ptext(" has failed. Scrolling off the top of the screen"); ptext(" usually means that the delete line capability is"); ptext(" working better than the insert line capability. If"); ptext(" the text scrolls off the bottom then delete line may"); ptext(" be broken. If parts of the text are missing then"); ptext(" you should get professional help."); put_crlf(); go_home(); put_newlines(2); pad_test_startup(0); do { tt_putp(insert_line); put_cr(); tt_putp(delete_line); } while(still_testing()); pad_test_shutdown(t, 0); home_down(); ptext("The top of the screen should have a paragraph of text. "); pad_done_message(t, state, ch); } /* ** pad_scrc(test_list, status, ch) ** ** Test (sc) (rc) Save/restore cursor */ static void pad_scrc( struct test_list *t, int *state, int *ch) { int i; if (!save_cursor || !restore_cursor) { CAP_NOT_FOUND; if (save_cursor) { ptext("(rc) Restore-cursor"); } else if (restore_cursor) { ptext("(sc) Save-cursor"); } else { ptext("(sc) Save-cursor, (rc) Restore-cursor"); } ptext(" not present. "); pad_done_message(t, state, ch); return; } if (skip_pad_test(t, state, ch, "(sc) (rc) Save/Restore-cursor start testing")) { return; } pad_test_startup(1); do { page_loop(); for (i = 1; i < columns; i++) { tt_putp(save_cursor); putchp(letter); tt_putp(restore_cursor); putchp('X'); } } while(still_testing()); pad_test_shutdown(t, 0); home_down(); ptext(above_line); pad_done_message(t, state, ch); } /* ** pad_csrind(test_list, status, ch) ** ** Test (csr) and (ind) Change scroll region and index. */ static void pad_csrind( struct test_list *t, int *state, int *ch) { int i; if (!change_scroll_region) { CAP_NOT_FOUND; ptext("(csr) Change-scroll-region not present. "); pad_done_message(t, state, ch); return; } if (skip_pad_test(t, state, ch, "(csr) Save/Restore-cursor, (ind) index start testing")) { return; } if (augment < 2) { augment = 2; } if (augment > lines - 1) { augment = lines - 1; } put_clear(); ptext("This text is on the top line."); tt_putparm(change_scroll_region, 1, lines - augment, lines - 1); /* go to the bottom of the screen */ home_down(); pad_test_startup(0); do { sprintf(temp, "%d\r", test_complete); put_str(temp); put_ind(); } while(still_testing()); ptextln("(csr) is broken."); for (i = augment; i > 1; i--) { put_ind(); } pad_test_shutdown(t, 0); ptext("All but top and bottom lines should be blank. "); pad_done_message(t, state, ch); tt_putparm(change_scroll_region, 1, 0, lines - 1); put_clear(); } /* ** pad_sccsrrc(test_list, status, ch) ** ** Test (sc) (csr) and (rc) Save/Change/Restore scroll region */ static void pad_sccsrrc( struct test_list *t, int *state, int *ch) { int i; if (!save_cursor || !change_scroll_region || !restore_cursor) { /* quietly ignore this test */ return; } if (skip_pad_test(t, state, ch, "(sc) (csr) (rc) Save/Change/Restore-cursor, start testing")) { return; } pad_test_startup(1); do { page_loop(); for (i = 1; i < columns; i++) { tt_putp(save_cursor); putchp(letter); tt_putparm(change_scroll_region, 1, 0, lines - 1); tt_putp(restore_cursor); putchp('X'); } } while(still_testing()); pad_test_shutdown(t, 0); home_down(); ptext(above_line); pad_done_message(t, state, ch); tt_putparm(change_scroll_region, 1, 0, lines - 1); } /* ** pad_csr_nel(test_list, status, ch) ** ** Test (sc) (csr) (nel) and (rc) Save/Change/Restore scroll region */ static void pad_csr_nel( struct test_list *t, int *state, int *ch) { int i, j; if (!save_cursor || !change_scroll_region || !restore_cursor) { /* quietly ignore this test */ return; } if (skip_pad_test(t, state, ch, "(csr) Change-scroll-region, (nel) newline start testing")) { return; } pad_test_startup(1); do { for (i = 0; i < lines; i++) { for (j = lines - i; j > 0; j--) { put_crlf(); } tt_putp(save_cursor); tt_putparm(change_scroll_region, 1, i, lines - 1); tt_putp(restore_cursor); put_str(every_line); } tt_putp(save_cursor); tt_putparm(change_scroll_region, 1, 0, lines - 1); tt_putp(restore_cursor); } while(still_testing()); pad_test_shutdown(t, 0); put_str(" "); pad_done_message(t, state, ch); tt_putparm(change_scroll_region, 1, 0, lines - 1); } /* ** pad_csr_cup(test_list, status, ch) ** ** Test (csr) (cup) Change scroll region and cursor address */ static void pad_csr_cup( struct test_list *t, int *state, int *ch) { int i, j; if (!change_scroll_region || !cursor_address) { /* quietly ignore this test */ return; } if (skip_pad_test(t, state, ch, "(csr) Change-scroll-region, (cup) cursor-address start testing")) { return; } pad_test_startup(1); do { for (i = 0; i < lines; i++) { for (j = lines - i; j > 0; j--) { put_crlf(); } tt_putparm(change_scroll_region, 1, i, lines - 1); tt_putparm(cursor_address, 1, lines - 1, 0); put_str(every_line); } tt_putparm(change_scroll_region, 1, 0, lines - 1); tt_putparm(cursor_address, 1, lines - 1, (int) strlen(every_line)); } while(still_testing()); pad_test_shutdown(t, 0); put_str(" "); pad_done_message(t, state, ch); tt_putparm(change_scroll_region, 1, 0, lines - 1); } /* ** pad_ht(test_list, status, ch) ** ** Test (ht) Tabs */ static void pad_ht( struct test_list *t, int *state, int *ch) { int i, j; if (!set_tab && init_tabs <= 0) { CAP_NOT_FOUND; ptext("(ht) Tab not tested. (hts) Set-tabs and (it) initial-tabs not present. "); pad_done_message(t, state, ch); return; } if (skip_pad_test(t, state, ch, "(ht) Tab start testing")) { return; } pad_test_startup(1); do { /* it is not always possible to test tabs with caps that do not already have padding. The following test uses a mixed bag of tests in order to avoid this problem. Note: I do not scroll */ if (auto_right_margin && can_go_home) for (i = 1, go_home(); i < lines - 2; i++) { for (j = 8; j < columns; j += 8) { putchp('\t'); } put_str("A "); } if (cursor_down && can_go_home) for (i = 1, go_home(); i < lines - 2; i++) { for (j = 8; j < columns; j += 8) { putchp('\t'); } put_str("D\r"); tt_putp(cursor_down); } if (cursor_address) for (i = 1; i < lines - 2; i++) { tt_putparm(cursor_address, 1, i - 1, 0); for (j = 8; j < columns; j += 8) { putchp('\t'); } put_str("C"); } go_home(); for (i = 1; i < lines - 2; i++) { for (j = 8; j < columns; j += 8) { putchp('\t'); } putln("N"); } } while(still_testing()); pad_test_shutdown(t, 0); ptextln("Letters on the screen other than Ns at the right margin indicate failure."); ptext("A-(am) D-(cud1) C-(cup) N-(nel) "); pad_done_message(t, state, ch); } /* ** pad_smso(test_list, status, ch) ** ** Test (smso) (rmso) Enter/exit mode */ static void pad_smso( struct test_list *t, int *state, int *ch) { int i, j; if (!enter_standout_mode || !exit_standout_mode) { CAP_NOT_FOUND; ptext("(smso) (rmso) Enter/Exit-standout-mode not present. "); pad_done_message(t, state, ch); return; } if (skip_pad_test(t, state, ch, "(smso) (rmso) Enter/Exit-standout-mode start testing")) { return; } /* In terminals that emulate non-hidden attributes with hidden attributes, the amount of time that it takes to fill the screen with an attribute is nontrivial. The following test is designed to catch those delays */ pad_test_startup(1); do { page_loop(); j = magic_cookie_glitch > 0 ? magic_cookie_glitch : 0; for (i = 2 + j + j; i < columns;) { put_mode(enter_standout_mode); i += j + j + 2; putchp('X'); put_mode(exit_standout_mode); putchp('X'); } } while(still_testing()); pad_test_shutdown(t, 0); home_down(); ptext(above_line); pad_done_message(t, state, ch); put_mode(exit_standout_mode); } /* ** pad_smacs(test_list, status, ch) ** ** Test (smacs) (rmacs) Enter/exit altcharset mode */ static void pad_smacs( struct test_list *t, int *state, int *ch) { int i, j; /* test enter even if exit is missing */ if (!enter_alt_charset_mode) { CAP_NOT_FOUND; ptext("(smacs) Enter-altcharset-mode not present. "); pad_done_message(t, state, ch); return; } if (skip_pad_test(t, state, ch, "(smacs) (rmacs) Enter/Exit-altcharset-mode start testing")) { return; } pad_test_startup(1); do { page_loop(); j = magic_cookie_glitch > 0 ? magic_cookie_glitch : 0; for (i = 2 + j + j; i < columns;) { put_mode(enter_alt_charset_mode); i += j + j + 2; putchp(letter); put_mode(exit_alt_charset_mode); putchp(letter); } } while(still_testing()); pad_test_shutdown(t, 0); home_down(); ptext("Every other character is from the alternate character set. "); pad_done_message(t, state, ch); put_mode(exit_alt_charset_mode); } /* ** pad_crash(test_list, status, ch) ** ** Test (clear) without padding */ static void pad_crash( struct test_list *t, int *state, int *ch) { char save_xon_xoff; if (!clear_screen) { ptext("(clear) Clear-screen not present. "); pad_done_message(t, state, ch); return; } ptext("If you would like to see if the terminal will really lock up."); ptextln(" I will send the clear screen sequence without the pads."); if (skip_pad_test(t, state, ch, "(clear) Clear-screen start crash testing")) { return; } save_xon_xoff = xon_xoff; xon_xoff = 1; pad_test_startup(0); do { put_str("Erase this!"); tt_putp(clear_screen); } while(still_testing()); xon_xoff = save_xon_xoff; pad_test_shutdown(t, 1); pad_done_message(t, state, ch); } tack-1.07/README0000644000175100001440000000176510556756313012006 0ustar tomusers-- $Id: README,v 1.3 2007/01/27 23:14:19 tom Exp $ The 'tack' program is a diagnostic that is designed to create and verify the correctness of terminfo's. This program can be used to create new terminal descriptions that are not included in the standard release. Although 'tack' has been distributed with ncurses, it is not an integral part of ncurses. It may be removed from the release without limiting the usefulness of ncurses on those terminals described in the terminfo data base. The best way to remove 'tack' from the build is to delete or rename the 'tack' directory before running the configure script. Starting with ncurses 5.6 patch 20070113, this program can be built outside the ncurses source-tree, provided that ncurses is configured using the "--with-ticlib" option. That makes available the private interfaces used by tack, and eliminates the need to distribute tack as an optional part of ncurses. Unlike the rest of ncurses, the 'tack' program is covered under the GNU Public License. tack-1.07/scan.c0000644000175100001440000001357211315500035012173 0ustar tomusers/* ** Copyright (C) 1991, 1997 Free Software Foundation, Inc. ** ** This file is part of TACK. ** ** TACK is free software; you can redistribute it and/or modify ** it under the terms of the GNU General Public License as published by ** the Free Software Foundation; either version 2, or (at your option) ** any later version. ** ** TACK 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 TACK; see the file COPYING. If not, write to ** the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, ** Boston, MA 02110-1301, USA */ /* scan mode keyboard support */ #include MODULE_ID("$Id: scan.c,v 1.8 2009/12/26 21:29:01 tom Exp $") unsigned scan_max; /* length of longest scan code */ char **scan_up, **scan_down, **scan_name; unsigned *scan_tested, *scan_length; static unsigned *scan_value; static unsigned shift_state; static char *str; static int debug_char_count; #define SHIFT_KEY 0x100 #define CONTROL_KEY 0x200 #define META_KEY 0x400 #define CAPS_LOCK 0x800 static const struct { const char *name; unsigned type; } scan_special[] = { {"", SHIFT_KEY}, {"", SHIFT_KEY}, {"", SHIFT_KEY}, {"", CONTROL_KEY}, {"", CONTROL_KEY}, {"", CONTROL_KEY}, {"", META_KEY}, {"", META_KEY}, {"", META_KEY}, {"", CAPS_LOCK}, {"", '\t'}, {"", ' '}, {"", '\r'}, {"", '\n'}, {"", '\f'}, {"", '\b'}, {0, 0} }; static void scan_blanks(void) { /* scan past the white space */ while (*str == ' ' || *str == '\t') str++; } static char * smash(void) { /* convert a string to hex */ char *s, *t; int ch, i, j; t = s = str; for (i = 0; (ch = *str); str++) { if (ch >= '0' && ch <= '9') j = ch - '0'; else if (ch >= 'a' && ch <= 'f') j = 10 - 'a' + ch; else if (ch >= 'A' && ch <= 'F') j = 10 - 'A' + ch; else if (ch == ' ' || ch == '\t') break; else continue; if (i) { *s = (char) (*s | j); s++; } else *s = (char) (j << 4); i ^= 1; } *s = '\0'; return t; } void scan_init(char *fn) { /* read the scan mode key definitions */ char *s, *sl; FILE *fp; int ch, i, j; unsigned len; char home[512]; if ((str = getenv("HOME"))) strcpy(home, str); else home[0] = '\0'; fp = NULL; if ((str = getenv("KEYBOARD"))) { if (!(fp = fopen(str, "r")) && home[0]) { sprintf(temp, "%s/.scan.%s", home, str); fp = fopen(temp, "r"); } } if (!fp) { sprintf(temp, ".scan.%s", fn); fp = fopen(temp, "r"); } if (!fp && home[0]) { sprintf(temp, "%s/.scan.%s", home, fn); fp = fopen(temp, "r"); } if (!fp) { ptext("Unable to open scanfile: "); ptextln(temp); bye_kids(EXIT_FAILURE); return; } /* scan file format: values are in hex. may be any string of characters */ scan_up = (char **) malloc(sizeof(char *) * MAX_SCAN); scan_down = (char **) malloc(sizeof(char *) * MAX_SCAN); scan_name = (char **) malloc(sizeof(char *) * MAX_SCAN); scan_tested = (unsigned *) malloc(sizeof(unsigned *) * MAX_SCAN); scan_length = (unsigned *) malloc(sizeof(unsigned *) * MAX_SCAN); scan_value = (unsigned *) malloc(sizeof(unsigned *) * MAX_SCAN); scan_up[0] = scan_down[0] = scan_name[0] = (char *) 0; str = (char *) malloc(4096); /* buffer space */ sl = str + 4000; /* an upper limit */ scan_max = 1; for (i = 0;;) { for (s = str; (ch = getc(fp)) != EOF;) { if (ch == '\n' || ch == '\r') break; *s++ = (char) ch; } *s++ = '\0'; if (ch == EOF) break; if (*str == '#' || *str == '\0') continue; scan_down[i] = smash(); scan_blanks(); scan_up[i] = smash(); scan_blanks(); scan_name[i] = str; scan_length[i] = strlen(scan_down[i]); len = strlen(scan_up[i]) + scan_length[i]; if (len > scan_max) scan_max = len; scan_value[i] = UChar(scan_name[i][0]); if (scan_name[i][1]) /* multi-character name */ for (j = 0; scan_special[j].name; j++) { if (!strcmp(scan_name[i], scan_special[j].name)) { scan_value[i] = scan_special[j].type; break; } } i++; if (str > sl) { str = (char *) malloc(4096); sl = str + 4000; } else str = s; } fclose(fp); #ifdef notdef for (i = 0; scan_down[i]; i++) { put_str(hex_expand_to(scan_down[i], 3)); put_str(hex_expand_to(scan_up[i], 3)); put_str(" "); put_str(scan_name[i]); put_crlf(); } (void) wait_here(); #endif } int scan_key(void) { /* read a key and translate scan mode to ASCII */ unsigned i; int j, ch; char buf[64]; for (i = 1;; i++) { ch = getchar(); if (ch == EOF) return EOF; if (debug_fp) { fprintf(debug_fp, "%02X ", ch); debug_char_count += 3; if (debug_char_count > 72) { fprintf(debug_fp, "\n"); debug_char_count = 0; } } buf[i - 1] = (char) ch; buf[i] = '\0'; if (buf[0] & 0x80) { /* scan up */ for (j = 0; scan_up[j]; j++) { if (i == scan_length[j] && !strcmp(buf, scan_up[j])) { i = 0; shift_state &= ~scan_value[j]; break; } } continue; } for (j = 0; scan_down[j]; j++) { if (i == scan_length[j] && !strcmp(buf, scan_down[j])) { i = 0; shift_state |= scan_value[j]; ch = (int) scan_value[j]; if (ch == CAPS_LOCK) shift_state ^= SHIFT_KEY; if (ch >= 256) break; if (shift_state & SHIFT_KEY) { if (ch >= 0x60) ch -= 0x20; else if (ch >= 0x30 && ch <= 0x3f) ch -= 0x10; } if (shift_state & CONTROL_KEY) { if ((ch | 0x20) >= 0x60 && (ch | 0x20) <= 0x7f) ch = (ch | 0x20) - 0x60; } if (shift_state & META_KEY) ch |= 0x80; return ch; } } if (i > scan_max) i = 1; } } tack-1.07/sync.c0000644000175100001440000002347211315501250012223 0ustar tomusers/* ** Copyright (C) 1991, 1997 Free Software Foundation, Inc. ** ** This file is part of TACK. ** ** TACK is free software; you can redistribute it and/or modify ** it under the terms of the GNU General Public License as published by ** the Free Software Foundation; either version 2, or (at your option) ** any later version. ** ** TACK 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 TACK; see the file COPYING. If not, write to ** the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, ** Boston, MA 02110-1301, USA */ #include #include MODULE_ID("$Id: sync.c,v 1.10 2009/12/26 21:39:52 tom Exp $") /* terminal-synchronization and performance tests */ static void sync_home(struct test_list *, int *, int *); static void sync_lines(struct test_list *, int *, int *); static void sync_clear(struct test_list *, int *, int *); static void sync_summary(struct test_list *, int *, int *); static struct test_list sync_test_list[] = { {MENU_NEXT, 0, 0, 0, "b) baud rate test", sync_home, 0}, {MENU_NEXT, 0, 0, 0, "l) scroll performance", sync_lines, 0}, {MENU_NEXT, 0, 0, 0, "c) clear screen performance", sync_clear, 0}, {MENU_NEXT, 0, 0, 0, "p) summary of results", sync_summary, 0}, {0, 0, 0, 0, txt_longer_test_time, longer_test_time, 0}, {0, 0, 0, 0, txt_shorter_test_time, shorter_test_time, 0}, {MENU_LAST, 0, 0, 0, 0, 0, 0} }; struct test_menu sync_menu = { 0, 'n', 0, "Performance tests", "perf", "n) run standard tests", sync_test, sync_test_list, 0, 0, 0 }; int tty_can_sync; /* TRUE if tty_sync_error() returned FALSE */ static int tty_newline_rate; /* The number of newlines per second */ static int tty_clear_rate; /* The number of clear-screens per second */ unsigned long tty_cps; /* The number of characters per second */ #define TTY_ACK_SIZE 64 static int ACK_terminator; /* terminating ACK character */ static int ACK_length; /* length of ACK string */ static const char *tty_ENQ; /* enquire string */ static char tty_ACK[TTY_ACK_SIZE]; /* ACK response, set by tty_sync_error() */ /***************************************************************************** * * Terminal synchronization. * * These functions handle the messy business of enq-ack handshaking * for timing purposes. * *****************************************************************************/ int tty_sync_error(void) { int ch, trouble, ack; trouble = FALSE; for (;;) { tt_putp(tty_ENQ); /* send ENQ */ ch = getnext(STRIP_PARITY); event_start(TIME_SYNC); /* start the timer */ /* The timer doesn't start until we get the first character. After that I expect to get the remaining characters of the acknowledge string in a short period of time. If that is not true then these characters are coming from the user and we need to send the ENQ sequence out again. */ for (ack = 0; ; ) { if (ack < TTY_ACK_SIZE - 2) { tty_ACK[ack] = (char) ch; tty_ACK[ack + 1] = '\0'; } if (ch == ACK_terminator) { return trouble; } if (++ack >= ACK_length) { return trouble; } ch = getnext(STRIP_PARITY); if (event_time(TIME_SYNC) > 400000) { break; } } set_attr(0); /* just in case */ put_crlf(); if (trouble) { /* The terminal won't sync. Life is not good. */ return TRUE; } put_str(" -- sync -- "); trouble = TRUE; } } /* ** flush_input() ** ** Throw away any output. */ void flush_input(void) { if (tty_can_sync == SYNC_TESTED && ACK_terminator >= 0) { (void) tty_sync_error(); } else { spin_flush(); } } /* ** probe_enq_ok() ** ** does the terminal do enq/ack handshaking? */ static void probe_enq_ok(void) { int tc, len, ulen; put_str("Testing ENQ/ACK, standby..."); fflush(stdout); can_test("u8 u9", FLAG_TESTED); #ifdef user9 tty_ENQ = user9 ? user9 : "\005"; #else tty_ENQ = "\005"; #endif tc_putp(tty_ENQ); event_start(TIME_SYNC); /* start the timer */ read_key(tty_ACK, TTY_ACK_SIZE - 1); if (event_time(TIME_SYNC) > 400000 || tty_ACK[0] == '\0') { /* These characters came from the user. Sigh. */ tty_can_sync = SYNC_FAILED; ptext("\nThis program expects the ENQ sequence to be"); ptext(" answered with the ACK character. This will help"); ptext(" the program reestablish synchronization when"); ptextln(" the terminal is overrun with data."); ptext("\nENQ sequence from (u9): "); putln(expand(tty_ENQ)); ptext("ACK received: "); putln(expand(tty_ACK)); #ifdef user8 len = user8 ? (int) strlen(user8) : 0; #else len = 0; #endif sprintf(temp, "Length of ACK %d. Expected length of ACK %d.", (int) strlen(tty_ACK), len); ptextln(temp); #ifdef user8 if (len) { temp[0] = user8[len - 1]; temp[1] = '\0'; ptext("Terminating character found in (u8): "); putln(expand(temp)); } #endif return; } tty_can_sync = SYNC_TESTED; if ((len = (int) strlen(tty_ACK)) == 1) { /* single character acknowledge string */ ACK_terminator = tty_ACK[0]; ACK_length = 4096; return; } tc = tty_ACK[len - 1]; #ifdef user8 if (user8) { ulen = (int) strlen(user8); if (tc == user8[ulen - 1]) { /* ANSI style acknowledge string */ ACK_terminator = tc; ACK_length = 4096; return; } } #endif /* fixed length acknowledge string */ ACK_length = len; ACK_terminator = -2; } /* ** verify_time() ** ** verify that the time tests are ready to run. ** If the baud rate is not set then compute it. */ void verify_time(void) { int status, ch; if (tty_can_sync == SYNC_FAILED) { return; } probe_enq_ok(); put_crlf(); if (tty_can_sync == SYNC_TESTED) { put_crlf(); if (ACK_terminator >= 0) { ptext("ACK terminating character: "); temp[0] = (char) ACK_terminator; temp[1] = '\0'; ptextln(expand(temp)); } else { sprintf(temp, "Fixed length ACK, %d characters", ACK_length); ptextln(temp); } } if (tty_baud_rate == 0) { sync_home(&sync_test_list[0], &status, &ch); } } /***************************************************************************** * * Terminal performance tests * * Find out how fast the terminal can: * 1) accept characters * 2) scroll the screen * 3) clear the screen * *****************************************************************************/ /* ** sync_home(test_list, status, ch) ** ** Baudrate test */ static void sync_home( struct test_list *t, int *state, int *ch) { int j, k; unsigned long rate; if (!cursor_home && !cursor_address && !row_address) { ptext("Terminal can not home cursor. "); generic_done_message(t, state, ch); return; } if (skip_pad_test(t, state, ch, "(home) Start baudrate search")) { return; } pad_test_startup(1); do { go_home(); for (j = 1; j < lines; j++) { for (k = 0; k < columns; k++) { if (k & 0xF) { put_this(letter); } else { put_this('.'); } } SLOW_TERMINAL_EXIT; } NEXT_LETTER; } while(still_testing()); pad_test_shutdown(t, auto_right_margin == 0); /* note: tty_frame_size is the real framesize times two. This takes care of half bits. */ rate = ((tx_cps * (unsigned long) tty_frame_size) >> 1); if (rate > tty_baud_rate) { tty_baud_rate = rate; } if (tx_cps > tty_cps) { tty_cps = tx_cps; } sprintf(temp, "%lu characters per second. Baudrate %d ", tx_cps, j); ptext(temp); generic_done_message(t, state, ch); } /* ** sync_lines(test_list, status, ch) ** ** How many newlines/second? */ static void sync_lines( struct test_list *t, int *state, int *ch) { int j; if (skip_pad_test(t, state, ch, "(nel) Start scroll performance test")) { return; } pad_test_startup(0); repeats = 100; do { sprintf(temp, "%d", test_complete); put_str(temp); put_newlines(repeats); } while(still_testing()); pad_test_shutdown(t, 0); j = sliding_scale(tx_count[0], 1000000, usec_run_time); if (j > tty_newline_rate) { tty_newline_rate = j; } sprintf(temp, "%d linefeeds per second. ", j); ptext(temp); generic_done_message(t, state, ch); } /* ** sync_clear(test_list, status, ch) ** ** How many clear-screens/second? */ static void sync_clear( struct test_list *t, int *state, int *ch) { int j; if (!clear_screen) { ptext("Terminal can not clear-screen. "); generic_done_message(t, state, ch); return; } if (skip_pad_test(t, state, ch, "(clear) Start clear-screen performance test")) { return; } pad_test_startup(0); repeats = 20; do { sprintf(temp, "%d", test_complete); put_str(temp); for (j = 0; j < repeats; j++) { put_clear(); } } while(still_testing()); pad_test_shutdown(t, 0); j = sliding_scale(tx_count[0], 1000000, usec_run_time); if (j > tty_clear_rate) { tty_clear_rate = j; } sprintf(temp, "%d clear-screens per second. ", j); ptext(temp); generic_done_message(t, state, ch); } /* ** sync_summary(test_list, status, ch) ** ** Print out the test results. */ static void sync_summary( struct test_list *t, int *state, int *ch) { char size[32]; put_crlf(); ptextln("Terminal size characters/sec linefeeds/sec clears/sec"); sprintf(size, "%dx%d", columns, lines); sprintf(temp, "%-10s%-11s%11lu %11d %11d", tty_basename, size, tty_cps, tty_newline_rate, tty_clear_rate); ptextln(temp); generic_done_message(t, state, ch); } /* ** sync_test(menu) ** ** Run at the beginning of the pad tests and function key tests */ void sync_test( struct test_menu *menu) { control_init(); if (tty_can_sync == SYNC_NOT_TESTED) { verify_time(); } if (menu->menu_title) { put_crlf(); ptextln(menu->menu_title); } } /* ** sync_handshake(test_list, status, ch) ** ** Test or retest the ENQ/ACK handshake */ void sync_handshake( struct test_list *t GCC_UNUSED, int *state GCC_UNUSED, int *ch GCC_UNUSED) { tty_can_sync = SYNC_NOT_TESTED; verify_time(); } tack-1.07/sysdep.c0000644000175100001440000002345311315501324012557 0ustar tomusers/* ** Copyright (C) 1991, 1997 Free Software Foundation, Inc. ** ** This file is part of TACK. ** ** TACK is free software; you can redistribute it and/or modify ** it under the terms of the GNU General Public License as published by ** the Free Software Foundation; either version 2, or (at your option) ** any later version. ** ** TACK 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 TACK; see the file COPYING. If not, write to ** the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, ** Boston, MA 02110-1301, USA */ /* * Operating system dependent functions. We assume the POSIX API. * Note: on strict-POSIX systems (including BSD/OS) the select_delay_type * global has no effect. */ #include #include #include #if defined(__BEOS__) #undef false #undef true #include #endif #if HAVE_SELECT #if HAVE_SYS_TIME_H && HAVE_SYS_TIME_SELECT #include #endif #if HAVE_SYS_SELECT_H #include #endif #endif MODULE_ID("$Id: sysdep.c,v 1.19 2009/12/26 21:40:36 tom Exp $") #if DECL_ERRNO extern int errno; #endif #ifdef TERMIOS #define PUT_TTY(fd, buf) tcsetattr(fd, TCSAFLUSH, buf) #else #define PUT_TTY(fd, buf) stty(fd, buf) #endif /* globals */ int tty_frame_size; /* asynch frame size times 2 */ unsigned tty_baud_rate; /* baud rate - bits per second */ SIG_ATOMIC_T not_a_tty; /* TRUE if output is not a tty (i.e. pipe) */ int nodelay_read; /* TRUE if NDELAY is set */ #ifdef TERMIOS #define TTY_IS_NOECHO !(new_modes.c_lflag & ECHO) #define TTY_IS_OUT_TRANS (new_modes.c_oflag & OPOST) #define TTY_IS_CHAR_MODE !(new_modes.c_lflag & ICANON) #define TTY_WAS_CS8 ((old_modes.c_cflag & CSIZE) == CS8) #define TTY_WAS_XON_XOFF (old_modes.c_iflag & (IXON|IXOFF)) #else #define TTY_IS_NOECHO !(new_modes.sg_flags & (ECHO)) #define TTY_IS_OUT_TRANS (new_modes.sg_flags & (CRMOD)) #define TTY_IS_CHAR_MODE (new_modes.sg_flags & (RAW|CBREAK)) #define TTY_WAS_CS8 (old_modes.sg_flags & (PASS8)) #define TTY_WAS_XON_XOFF (old_modes.sg_flags & (TANDEM|MDMBUF|DECCTQ)) #endif static TTY old_modes, new_modes; void catchsig(void); /* * These are a sneaky way of conditionalizing bit unsets so strict-POSIX * systems won't see them. */ #ifndef XCASE #define XCASE 0 #endif #ifndef OLCUC #define OLCUC 0 #endif #ifndef IUCLC #define IUCLC 0 #endif #ifndef TABDLY #define TABDLY 0 #endif #ifndef IXANY #define IXANY 0 #endif void tty_raw(int minch GCC_UNUSED, int mask) { /* set tty to raw noecho */ new_modes = old_modes; #ifdef TERMIOS #if HAVE_SELECT new_modes.c_cc[VMIN] = 1; #else new_modes.c_cc[VMIN] = minch; #endif new_modes.c_cc[VTIME] = 2; new_modes.c_lflag &= ~(ISIG | ICANON | XCASE | ECHO | ECHOE | ECHOK | ECHONL); #ifdef LOBLK new_modes.c_lflag &= ~LOBLK; #endif new_modes.c_oflag &= ~(OPOST | OLCUC | TABDLY); if (mask == ALLOW_PARITY) { new_modes.c_cflag &= ~(CSIZE | PARENB | HUPCL); new_modes.c_cflag |= CS8; } new_modes.c_iflag &= ~(IGNBRK | BRKINT | IGNPAR | PARMRK | INPCK | ISTRIP | INLCR | IGNCR | ICRNL | IUCLC | IXON | IXANY | IXOFF); #else new_modes.sg_flags |= RAW; #endif if (not_a_tty) return; PUT_TTY(fileno(stdin), &new_modes); } void tty_set(void) { /* set tty to special modes */ new_modes = old_modes; #ifdef TERMIOS new_modes.c_cc[VMIN] = 1; new_modes.c_cc[VTIME] = 1; new_modes.c_lflag &= ~(ISIG | ICANON | ECHO | ECHOE | ECHOK | ECHONL); #if defined(ONLCR) && defined(OCRNL) && defined(ONLRET) && defined(OFILL) new_modes.c_oflag &= ~(ONLCR | OCRNL | ONLRET | OFILL); #else new_modes.c_oflag &= ~(OPOST); #endif if (char_mask == ALLOW_PARITY) new_modes.c_iflag &= ~ISTRIP; switch (select_xon_xoff) { case 0: new_modes.c_iflag &= ~(IXON | IXOFF); break; case 1: #if defined(sequent) && sequent /* the sequent System V emulation is broken */ new_modes = old_modes; new_modes.c_cc[VEOL] = 6; /* control F (ACK) */ #endif new_modes.c_iflag |= IXON | IXOFF; break; } switch (select_delay_type) { case 0: #ifdef NLDLY new_modes.c_oflag &= ~(NLDLY | CRDLY | TABDLY | BSDLY | VTDLY | FFDLY); #endif /* NLDLY */ break; case 1: #ifdef NLDLY new_modes.c_oflag &= ~(NLDLY | CRDLY | TABDLY | BSDLY | VTDLY | FFDLY); #endif /* NLDLY */ #ifdef NL1 new_modes.c_oflag |= NL1 | CR2; #endif /* NL1 */ break; } if ((new_modes.c_oflag & (unsigned long) ~OPOST) == 0) new_modes.c_oflag &= (unsigned long) ~OPOST; #else new_modes.sg_flags |= RAW; if (not_a_tty) return; #endif PUT_TTY(fileno(stdin), &new_modes); } void tty_reset(void) { /* reset the tty to the original modes */ fflush(stdout); if (not_a_tty) return; PUT_TTY(fileno(stdin), &old_modes); } void tty_init(void) { /* ATT terminal init */ #if defined(F_GETFL) && defined(O_NDELAY) int flags; flags = fcntl(fileno(stdin), F_GETFL, 0); nodelay_read = flags & O_NDELAY; #else nodelay_read = FALSE; #endif not_a_tty = FALSE; if (GET_TTY(fileno(stdin), &old_modes) == -1) { if (errno == ENOTTY) { tty_frame_size = 20; not_a_tty = TRUE; return; } printf("tcgetattr error: %d\n", errno); ExitProgram(EXIT_FAILURE); } /* if TAB3 is set then setterm() wipes out tabs (ht) */ new_modes = old_modes; #ifdef TERMIOS #ifdef TABDLY new_modes.c_oflag &= ~TABDLY; #endif /* TABDLY */ #endif if (PUT_TTY(fileno(stdin), &new_modes) == -1) { printf("tcsetattr error: %d\n", errno); ExitProgram(EXIT_FAILURE); } #ifdef sequent /* the sequent ATT emulation is broken soooo. */ old_modes.c_cflag &= ~(CSIZE | CSTOPB); old_modes.c_cflag |= CS7 | PARENB; #endif catchsig(); #ifdef TERMIOS switch (old_modes.c_cflag & CSIZE) { #if defined(CS5) && (CS5 != 0) case CS5: tty_frame_size = 10; break; #endif #if defined(CS6) && (CS6 != 0) case CS6: tty_frame_size = 12; break; #endif #if defined(CS7) && (CS7 != 0) case CS7: tty_frame_size = 14; break; #endif #if defined(CS8) && (CS8 != 0) case CS8: tty_frame_size = 16; break; #endif } tty_frame_size += 2 + ((old_modes.c_cflag & PARENB) ? 2 : 0) + ((old_modes.c_cflag & CSTOPB) ? 4 : 2); #else tty_frame_size = 6 + (old_modes.sg_flags & PASS8) ? 16 : 14; #endif } /* ** stty_query(question) ** ** Does the current driver settings have this property? */ int stty_query(int q) { switch (q) { case TTY_NOECHO: return TTY_IS_NOECHO; case TTY_OUT_TRANS: return (int) TTY_IS_OUT_TRANS; case TTY_CHAR_MODE: return TTY_IS_CHAR_MODE; } return (-1); } /* ** initial_stty_query(question) ** ** Did the initial driver settings have this property? */ int initial_stty_query(int q) { switch (q) { case TTY_8_BIT: return TTY_WAS_CS8; case TTY_XON_XOFF: return (int) TTY_WAS_XON_XOFF; } return (-1); } #if HAVE_SELECT && defined(FD_ZERO) static int char_ready(void) { int n; fd_set ifds; struct timeval tv; FD_ZERO(&ifds); FD_SET(fileno(stdin), &ifds); tv.tv_sec = 0; tv.tv_usec = 200000; n = select(fileno(stdin)+1, &ifds, NULL, NULL, &tv); return (n != 0); } #else #ifdef FIONREAD int char_ready(void) { int i, j; /* the following loop has to be tuned for each computer */ for (j = 0; j < 1000; j++) { ioctl(fileno(stdin), FIONREAD, &i); if (i) return i; } return i; } #else #if defined(__BEOS__) int char_ready(void) { int n = 0; int howmany = ioctl(0, 'ichr', &n); return (howmany >= 0 && n > 0); } #else #define char_ready() 1 #endif #endif #endif /* ** spin_flush() ** ** Wait for the input stream to stop. ** Throw away all input characters. */ void spin_flush(void) { unsigned char buf[64]; fflush(stdout); event_start(TIME_FLUSH); /* start the timer */ do { if (char_ready()) { (void) read(fileno(stdin), &buf, sizeof(buf)); } } while (event_time(TIME_FLUSH) < 400000); } /* ** read_key(input-buffer, length-of-buffer) ** ** read one function key from the input stream. ** A null character is converted to 0x80. */ void read_key(char *buf, int max) { int got, ask, i, l; char *s; *buf = '\0'; s = buf; fflush(stdout); /* ATT unix may return 0 or 1, Berkeley Unix should be 1 */ while (read(fileno(stdin), s, 1) == 0); ++s; --max; while (max > 0 && (ask = char_ready())) { if (ask > max) { ask = max; } if ((got = read(fileno(stdin), s, (unsigned) ask))) { s += got; } else { break; } max -= got; } *s = '\0'; l = s - buf; for (s = buf, i = 0; i < l; i++) { if ((*s & 0x7f) == 0) { /* convert nulls to 0x80 */ *(unsigned char *)s = 128; } else { /* strip high order bits (if any) */ *s = (char) (*s & char_mask); } } } void ignoresig(void) { /* ignore signals */ signal(SIGINT, SIG_IGN); signal(SIGHUP, SIG_IGN); signal(SIGQUIT, SIG_IGN); signal(SIGTERM, SIG_IGN); signal(SIGALRM, SIG_IGN); } /* * onintr( ) * * is the interrupt handling routine. * onintr turns off interrupts while doing clean-up. * * onintr always exits fatally */ static RETSIGTYPE onintr(int sig GCC_UNUSED) { ignoresig(); tty_reset(); ExitProgram(EXIT_FAILURE); } /* * catchsig( ) * * set up to field interrupts (via function onintr( )) so that if interrupted * we can restore the correct terminal modes * * catchsig simply returns */ void catchsig(void) { if ((signal(SIGINT, SIG_IGN)) == SIG_DFL) signal(SIGINT, onintr); if ((signal(SIGHUP, SIG_IGN)) == SIG_DFL) signal(SIGHUP, onintr); if ((signal(SIGQUIT, SIG_IGN)) == SIG_DFL) signal(SIGQUIT, onintr); if ((signal(SIGTERM, SIG_IGN)) == SIG_DFL) signal(SIGTERM, onintr); } /* ** alarm_event(sig) ** ** Come here for an alarm event */ static void alarm_event( int sig GCC_UNUSED) { no_alarm_event = 0; } /* ** set_alarm_clock(seconds) ** ** Set the alarm clock to fire in */ void set_alarm_clock( int seconds) { signal(SIGALRM, alarm_event); no_alarm_event = 1; (void) alarm((unsigned) seconds); } tack-1.07/tack.10000644000175100001440000004136310422526657012126 0ustar tomusers.\"*************************************************************************** .\" Copyright (c) 1998-2005,2006 Free Software Foundation, Inc. * .\" * .\" Permission is hereby granted, free of charge, to any person obtaining a * .\" copy of this software and associated documentation files (the * .\" "Software"), to deal in the Software without restriction, including * .\" without limitation the rights to use, copy, modify, merge, publish, * .\" distribute, distribute with modifications, sublicense, and/or sell * .\" copies of the Software, and to permit persons to whom the Software is * .\" furnished to do so, subject to the following conditions: * .\" * .\" The above copyright notice and this permission notice shall be included * .\" in all copies or substantial portions of the Software. * .\" * .\" THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * .\" OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * .\" MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * .\" IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, * .\" DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR * .\" OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR * .\" THE USE OR OTHER DEALINGS IN THE SOFTWARE. * .\" * .\" Except as contained in this notice, the name(s) of the above copyright * .\" holders shall not be used in advertising or otherwise to promote the * .\" sale, use or other dealings in this Software without prior written * .\" authorization. * .\"*************************************************************************** .\" .\" $Id: tack.1,v 1.3 2006/04/22 22:26:55 tom Exp $ .TH tack 1M "" .ds n 5 .ds d @TERMINFO@ .SH NAME \fBtack\fR - \fIterminfo\fR action checker .SH SYNOPSIS \fBtack\fR [-itV] [term] .br .SH DESCRIPTION The \fBtack\fR program has three purposes: (1) to help you build a new terminfo entry describing an unknown terminal, (2) to test the correctness of an existing entry, and (3) to develop the correct pad timings needed to ensure that screen updates don't fall behind the incoming data stream. .PP \fBTack\fR presents a series of screen-painting and interactive tests in ways which are intended to make any mismatches between the terminfo entry and reality visually obvious. \fBTack\fR also provides tools that can help in understanding how the terminal operates. .SS OPTIONS .TP .I "\-i" Usually \fBtack\fR will send the reset and init strings to the terminal when the program starts up. The \fI-i\fR option will inhibit the terminal initialization. .TP .I "\-t" Tell \fBtack\fR to override the terminfo settings for basic terminal functions. When this option is set \fBtack\fR will translate (cr) to \\r, (cud1) to \\n, (ind) to \\n, (nel) to \\r\\n, (cub1) to \\b, (bel) to \\007, (ff) to \\f and (ht) to \\t. .TP .I "\-V" Display the version information and exit. .TP .I "term" Terminfo terminal name to be tested. If not present then the $TERM environment variable will be used. .SH OVERVIEW Since \fBtack\fR is designed to test terminfo's it is not possible to rely on the correctness of the terminfo data base. Because of this the menuing system used with \fBtack\fR is vary primitive. When a menu is printed it will scroll the entire screen. To compensate for this verbose menu system \fBtack\fR permits menu selection type ahead. If you already know what action you would like \fBtack\fR to perform then you can enter that value immediately and avoid the menu display. When in doubt the question mark (?) is a good character to type. A carriage return will execute the default action. These default actions are designed to run all the standard tests. .PP When \fBtack\fR first comes up it will display some basic information about the terminal. Take some time to verify this information. If it is wrong many of the subsequent tests will fail. The most important item is the screen size. If the screen size is wrong there is no point in proceeding. (home) and (clear) are also critical to the success of subsequent tests. The values of (cr) (ind) (cub1) and (ht) may effect the tests if they are defined incorrectly. If they are undefined \fBtack\fR will set them to reasonable defaults. The last two entries on the display are the enquire and acknowledge strings. These strings are taken from the user strings (u9) and (u8). .PP By now you must be wondering why the terminfo names are enclosed in parenthesis. This has no profound meaning other than it makes them stand out. The \fBtack\fR program uses this convention any time it displays a terminfo name. Remember \fBtack\fR is designed to rely on as little of the terminfo entry as possible. .SH CREATING NEW ENTRIES \fBTack\fR has a number of tools that are designed to help gather information about the terminal. Although these functions are not dependent on terminal type, you may wish to execute \fBtack\fR with options \fI\-it\fR. This will turn off initialization and default the standard entries. .PP These tools may be reached from the main menu by selecting the 'tools' entry. .PP \fBEcho tool\fR: All data typed from the keyboard will be echoed back to the terminal. Control characters are not translated to the up arrow format but are sent as control characters. This allows you to test an escape sequence and see what it actually does. You may also elect to \fBenable hex output on echo tool\fR this will echo the characters in hexadecimal. Once the test is running you may enter the 'lines' or 'columns' keywords which will display a pattern that will help you determine your screen size. A complete list of keywords will be displayed when the test starts. Type 'help' to redisplay the list of available commands. .PP \fBReply tool\fR: This tool acts much like the echo tool, but control characters that are sent from the terminal more than one character after a carriage return will be expanded to the up arrow format. For example on a standard ANSI terminal you may type: CR ESC [ c and the response will be echoed as something like: ^[ [ ? 6 c .PP \fBANSI sgr display\fR: This test assumes you have an ANSI terminal. It goes through attribute numbers 0 to 79, displaying each in turn and using that SGR number to write the text. This shows you which of the SGR modes are actually implemented by the terminal. Note: some terminals (such as Tektronix color) use the private use characters to augment the functionality of the SGR command. These private use characters may be interjected into the escape sequence by typing the character ( <, =, >, ? ) after the original display has been shown. .PP \fBANSI status reports\fR: This test queries the terminal in standard ANSI/VT-100 fashion. The results of this test may help determine what options are supported by your terminal. .PP \fBANSI character sets\fR: This test displays the character sets available on a ANSI/VT-100 style terminal. Character sets on a real VT-100 terminal are usually defined with smacs=\\E(0 and rmacs=\\E(B. The first character after the escape defines the font bank. The second character defines the character set. This test allows you to view any of the possible combinations. Private use character sets are defined by the digits. Standard character sets are located in the alphabetic range. .SH VERIFYING AN EXISTING ENTRY .PP You can verify the correctness of an entry with the `begin testing' function. This entry is the default action and will be chosen if you hit carriage return (or enter). This will bring up a secondary menu that allows you to select more specific tests. .PP The general philosophy of the program is, for each capability, to send an appropriate test pattern to the terminal then send a description of what the user should expect. Occasionally (as when checking function-key capabilities) the program will ask you to enter input for it to check. .PP If the test fails then you have the option of dynamically changing the terminfo entry and re-running the test. This is done with the 'edit terminfo' menu item. The edit submenu allows you to change the offending terminfo entry and immediately retest the capability. The edit menu lets you do other things with the terminfo, such as; display the entire terminfo entry, display which caps have been tested and display which caps cannot be tested. This menu also allows you to write the newly modified terminfo to disc. If you have made any modifications to the terminfo \fBtack\fR will ask you if you want to save the file to disc before it exits. The filename will be the same as the terminal name. After the program exits you can run the tic(1M) compiler on the new terminfo to install it in the terminfo data base. .PP .SH CORRECTING PAD TIMINGS .SS Theory of Overruns and Padding .PP Some terminals require significant amounts of time (that is, more than one transmitted-character interval) to do screen updates that change large portions of the screen, such as screen clears, line insertions, line deletions, and scrolls (including scrolls triggered by line feeds or a write to the lowest, right-hand-most cell of the screen). .PP If the computer continues to send characters to the terminal while one of these time-consuming operations is going on, the screen may be garbled. Since the length of a character transmission time varies inversely with transmission speed in cps, entries which function at lower speeds may break at higher speeds. .PP Similar problems result if the host machine is simply sending characters at a sustained rate faster than the terminal can buffer and process them. In either case, when the terminal cannot process them and can't tell the host to stop soon enough, it will just drop them. The dropped characters could be text, escape sequences or the escape character itself, causing some really strange-looking displays. This kind of glitch is called an \fIoverrun\fR. .PP In terminfo entries, you can attach a \fBpad time\fR to each string capability that is a number of milliseconds to delay after sending it. This will give the terminal time to catch up and avoid overruns. .PP If you are running a software terminal emulator, or you are on an X pseudo-tty, or your terminal is on an RS-232C line which correctly handles RTS/CTS hardware flow control, then pads are not strictly necessary. However, some display packages (such as ncurses(3X)) use the pad counts to calculate the fastest way to implement certain functions. For example: scrolling the screen may be faster than deleting the top line. .PP One common way to avoid overruns is with XON/XOFF handshaking. But even this handshake may have problems at high baud rates. This is a result of the way XON/XOFF works. The terminal tells the host to stop with an XOFF. When the host gets this character, it stops sending. However, there is a small amount of time between the stop request and the actual stop. During this window, the terminal must continue to accept characters even though it has told the host to stop. If the terminal sends the stop request too late, then its internal buffer will overflow. If it sends the stop character too early, then the terminal is not getting the most efficient use out of its internal buffers. In a real application at high baud rates, a terminal could get a dozen or more characters before the host gets around to suspending transmission. Connecting the terminal over a network will make the problem much worse. .PP (RTS/CTS handshaking does not have this problem because the UARTs are signal-connected and the "stop flow" is done at the lowest level, without software intervention). .PP .SS Timing your terminal .PP In order to get accurate timings from your terminal \fBtack\fR needs to know when the terminal has finished processing all the characters that were sent. This requires a different type of handshaking than the XON/XOFF that is supported by most terminals. \fBTack\fR needs to send a request to the terminal and wait for its reply. Many terminals will respond with an ACK when they receive an ENQ. This is the preferred method since the sequence is short. ANSI/VT-100 style terminals can mimic this handshake with the escape sequence that requests 'primary device attributes'. ESC [ c The terminal will respond with a sequence like: ESC [ ? 1 ; 0 c \fBTack\fR assumes that (u9) is the enquire sequence and that (u8) is the acknowledge string. A VT-100 style terminal could set u9=\\E[c and u8=\\E[?1;0c. Acknowledge strings fall into two categories. 1) Strings with a unique terminating character and, 2) strings of fixed length. The acknowledge string for the VT-100 is of the first type since it always ends with the letter 'c'. Some Tektronics terminals have fixed length acknowledge strings. \fBTack\fR supports both types of strings by scanning for the terminating character until the length of the expected acknowledge string has arrived. (u8) should be set to some typical acknowledge that will be returned when (u9) is sent. .PP \fBTack\fR will test this sequence before running any of the pad tests or the function key tests. \fBTack\fR will ask you the following: Hit lower case g to start testing... After it sends this message it will send the enquire string. It will then read characters from the terminal until it sees the letter g. .PP .SS Testing and Repairing Pad Timings .PP The pad timings in distributed terminfo entries are often incorrect. One major motivation for this program is to make it relatively easy to tune these timings. .PP You can verify and edit the pad timings for a terminal with the `test string capabilities' function (this is also part of the `normal test sequence' function). .PP The key to determining pad times is to find out the effective baud rate of the terminal. The effective baud rate determines the number of characters per second that the terminal can accept without either handshaking or losing data. This rate is frequently less than the nominal cps rate on the RS-232 line. .PP \fBTack\fR uses the effective baud rate to judge the duration of the test and how much a particular escape sequence will perturb the terminal. .PP Each pad test has two associated variables that can be tweaked to help verify the correctness of the pad timings. One is the pad test length. The other is the pad multiplier, which is used if the pad prefix includes `*'. In curses use, it is often the first parameter of the capability (if there is one). For a capability like (dch) or (il) this will be the number of character positions or lines affected, respectively. .PP \fBTack\fR will run the pad tests and display the results to the terminal. On capabilities that have multipliers \fBtack\fR will not tell you if the pad needs the multiplier or not. You must make this decision yourself by rerunning the test with a different multiplier. If the padding changes in proportion to the multiplier than the multiplier is required. If the multiplier has little or no effect on the suggested padding then the multiplier is not needed. Some capabilities will take several runs to get a good feel for the correct values. You may wish to make the test longer to get more accurate results. System load will also effect the results (a heavily loaded system will not stress the terminal as much, possibly leading to pad timings that are too short). .PP .SH NOTE The tests done at the beginning of the program are assumed to be correct later in the code. In particular, \fBtack\fR displays the number of lines and columns indicated in the terminfo entry as part of its initial output. If these values are wrong a large number of tests will fail or give incorrect results. .SH FILES .TP 12 tack.log If logging is enabled then all characters written to the terminal will also be written to the log file. This gives you the ability to see how the tests were performed. This feature is disabled by default. .TP 12 .I "term" If you make changes to the terminfo entry \fBtack\fR will save the new terminfo to a file. The file will have the same name as the terminal name. .SH SEE ALSO \fBterminfo\fR(\*n), \fBncurses\fR(3X), \fBtic\fR(1M), \fBinfocmp\fR(1M). You should also have the documentation supplied by the terminal manufacturer. .SH BUGS If the screen size is incorrect, many of the tests will fail. .SH AUTHOR Concept, design, and original implementation by Daniel Weaver . Portions of the code and documentation are by Eric S. Raymond . .\"# .\"# The following sets edit modes for GNU EMACS .\"# Local Variables: .\"# mode:nroff .\"# fill-column:79 .\"# End: tack-1.07/tack.c0000644000175100001440000003575611315501434012205 0ustar tomusers/* ** Copyright (C) 1991, 1997 Free Software Foundation, Inc. ** ** This file is part of TACK. ** ** TACK is free software; you can redistribute it and/or modify ** it under the terms of the GNU General Public License as published by ** the Free Software Foundation; either version 2, or (at your option) ** any later version. ** ** TACK 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 TACK; see the file COPYING. If not, write to ** the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, ** Boston, MA 02110-1301, USA */ #include MODULE_ID("$Id: tack.c,v 1.10 2009/12/26 21:41:48 tom Exp $") /* This program is designed to test terminfo, not curses. Therefore I have used as little of curses as possible. Pads associated with the following capabilities are used to set delay times in the handler: (cr), (ind), (cub1), (ff), (tab). I use the (nxon) capability to set the tty handler with/without xon/xoff. If (smxon)/(rmxon) is defined I will change the terminal too. (xon) inhibits the sending of delay characters in putp(). If the terminal is defined with no padding then the (xon) boolean is a don't care. In this case I recommend that it be reset. */ /***************************************************************************** * * Option processing * *****************************************************************************/ /* options and modes */ int debug_level; /* debugging level */ int translate_mode; /* translate tab, bs, cr, lf, ff */ int scan_mode; /* use scan codes */ int char_mask; /* either 0xFF else 0x7F, eight bit data mask */ int select_delay_type; /* set handler delays for */ int select_xon_xoff; /* TTY driver XON/XOFF mode select */ int hex_out; /* Display output in hex */ int send_reset_init; /* Send the reset and initialization strings */ FILE *log_fp; /* Terminal logfile */ /***************************************************************************** * * Menu definitions * *****************************************************************************/ static void tools_hex_echo(struct test_list *, int *, int *); static void tools_debug(struct test_list *, int *, int *); static char hex_echo_menu_entry[80]; static struct test_list tools_test_list[] = { {0, 0, 0, 0, "s) ANSI status reports", tools_status, 0}, {0, 0, 0, 0, "g) ANSI SGR modes (bold, underline, reverse)", tools_sgr, 0}, {0, 0, 0, 0, "c) ANSI character sets", tools_charset, 0}, {0, 0, 0, 0, hex_echo_menu_entry, tools_hex_echo, 0}, {0, 0, 0, 0, "e) echo tool", tools_report, 0}, {1, 0, 0, 0, "r) reply tool", tools_report, 0}, {0, 0, 0, 0, "p) performance testing", 0, &sync_menu}, {0, 0, 0, 0, "i) send reset and init", menu_reset_init, 0}, {0, 0, "u8) (u9", 0, "u) test ENQ/ACK handshake", sync_handshake, 0}, {0, 0, 0, 0, "d) change debug level", tools_debug, 0}, {MENU_LAST, 0, 0, 0, 0, 0, 0} }; static struct test_menu tools_menu = { 0, 'q', 0, "Tools Menu", "tools", 0, 0, tools_test_list, 0, 0, 0 }; static void tty_width(struct test_list *, int *, int *); static void tty_delay(struct test_list *, int *, int *); static void tty_xon(struct test_list *, int *, int *); static void tty_trans(struct test_list *, int *, int *); static void tty_show_state(struct test_menu *); static char tty_width_menu[80]; static char tty_delay_menu[80]; static char tty_xon_menu[80]; static char tty_trans_menu[80]; static char enable_xon_xoff[] = {"x) enable xon/xoff"}; static char disable_xon_xoff[] = {"x) disable xon/xoff"}; static struct test_list tty_test_list[] = { {0, 0, 0, 0, tty_width_menu, tty_width, 0}, {0, 0, 0, 0, tty_delay_menu, tty_delay, 0}, {0, 0, 0, 0, tty_xon_menu, tty_xon, 0}, {0, 0, 0, 0, tty_trans_menu, tty_trans, 0}, {MENU_LAST, 0, 0, 0, 0, 0, 0} }; static struct test_menu tty_menu = { 0, 'q', 0, "Terminal and driver configuration", "tty", 0, tty_show_state, tty_test_list, 0, 0, 0 }; struct test_menu edit_menu = { 0, 'q', 0, "Edit terminfo menu", "edit", 0, 0, edit_test_list, 0, 0, 0 }; static struct test_menu mode_menu = { 0, 'n', 0, "Test modes and glitches:", "mode", "n) run standard tests", 0, mode_test_list, 0, 0, 0 }; static struct test_menu acs_menu = { 0, 'n', 0, "Test alternate character set and graphics rendition:", "acs", "n) run standard tests", 0, acs_test_list, 0, 0, 0 }; static struct test_menu color_menu = { 0, 'n', 0, "Test color:", "color", "n) run standard tests", 0, color_test_list, 0, 0, 0 }; static struct test_menu crum_menu = { 0, 'n', 0, "Test cursor movement:", "move", "n) run standard tests", 0, crum_test_list, 0, 0, 0 }; static struct test_menu funkey_menu = { 0, 'n', 0, "Test function keys:", "fkey", "n) run standard tests", sync_test, funkey_test_list, 0, 0, 0 }; static struct test_menu printer_menu = { 0, 'n', 0, "Test printer:", "printer", "n) run standard tests", 0, printer_test_list, 0, 0, 0 }; static void pad_gen(struct test_list *, int *, int *); static struct test_menu pad_menu = { 0, 'n', 0, "Test padding and string capabilities:", "pad", "n) run standard tests", sync_test, pad_test_list, 0, 0, 0 }; static struct test_list normal_test_list[] = { {0, 0, 0, 0, "e) edit terminfo", 0, &edit_menu}, {0, 0, 0, 0, "i) send reset and init", menu_reset_init, 0}, {MENU_NEXT, 0, 0, 0, "x) test modes and glitches", 0, &mode_menu}, {MENU_NEXT, 0, 0, 0, "a) test alternate character set and graphic rendition", 0, &acs_menu}, {MENU_NEXT, 0, 0, 0, "c) test color", 0, &color_menu}, {MENU_NEXT, 0, 0, 0, "m) test cursor movement", 0, &crum_menu}, {MENU_NEXT, 0, 0, 0, "f) test function keys", 0, &funkey_menu}, {MENU_NEXT, 0, 0, 0, "p) test padding and string capabilities", 0, &pad_menu}, {0, 0, 0, 0, "P) test printer", 0, &printer_menu}, {MENU_MENU, 0, 0, 0, "/) test a specific capability", 0, 0}, {0, 0, 0, 0, "t) auto generate pad delays", pad_gen, &pad_menu}, {0, 0, "u8) (u9", 0, 0, sync_handshake, 0}, {MENU_LAST, 0, 0, 0, 0, 0, 0} }; static struct test_menu normal_menu = { 0, 'n', 0, "Main test menu", "test", "n) run standard tests", 0, normal_test_list, 0, 0, 0 }; static void start_tools(struct test_list *, int *, int *); static void start_modes(struct test_list *, int *, int *); static void start_basic(struct test_list *, int *, int *); static void start_log(struct test_list *, int *, int *); static char logging_menu_entry[80] = "l) start logging"; static struct test_list start_test_list[] = { {0, 0, 0, 0, "b) display basic information", start_basic, 0}, {0, 0, 0, 0, "m) change modes", start_modes, 0}, {0, 0, 0, 0, "t) tools", start_tools, 0}, {MENU_COMPLETE, 0, 0, 0, "n) begin testing", 0, &normal_menu}, {0, 0, 0, 0, logging_menu_entry, start_log, 0}, {MENU_LAST, 0, 0, 0, 0, 0, 0} }; static struct test_menu start_menu = { 0, 'n', 0, "Main Menu", "tack", 0, 0, start_test_list, 0, 0, 0 }; static struct test_list write_terminfo_list[] = { {0, 0, 0, 0, "w) write the current terminfo to a file", save_info, 0}, {MENU_LAST, 0, 0, 0, 0, 0, 0} }; /***************************************************************************** * * Menu command interpretation. * *****************************************************************************/ /* ** tools_hex_echo(testlist, state, ch) ** ** Flip the hex echo flag. */ static void tools_hex_echo( struct test_list *t GCC_UNUSED, int *state GCC_UNUSED, int *ch GCC_UNUSED) { if (hex_out) { hex_out = FALSE; strcpy(hex_echo_menu_entry, "h) enable hex output on echo tool"); } else { hex_out = TRUE; strcpy(hex_echo_menu_entry, "h) disable hex output on echo tool"); } } /* ** tools_debug(testlist, state, ch) ** ** Change the debug level. */ static void tools_debug( struct test_list *t GCC_UNUSED, int *state GCC_UNUSED, int *ch) { char buf[32]; ptext("Enter a new value: "); read_string(buf, sizeof(buf)); if (buf[0]) { sscanf(buf, "%d", &debug_level); } sprintf(temp, "Debug level is now %d", debug_level); ptext(temp); *ch = REQUEST_PROMPT; } /* ** start_tools(testlist, state, ch) ** ** Run the generic test tools */ static void start_tools( struct test_list *t GCC_UNUSED, int *state GCC_UNUSED, int *ch GCC_UNUSED) { if (hex_out) { strcpy(hex_echo_menu_entry, "h) disable hex output on echo tool"); } else { strcpy(hex_echo_menu_entry, "h) enable hex output on echo tool"); } menu_display(&tools_menu, 0); } /* ** tty_show_state() ** ** Display the current state on the tty driver settings */ static void tty_show_state( struct test_menu *menu GCC_UNUSED) { put_crlf(); (void) sprintf(temp, "Accepting %d bits, UNIX delays %d, XON/XOFF %sabled, speed %u, translate %s, scan-code mode %s.", (char_mask == ALLOW_PARITY) ? 8 : 7, select_delay_type, select_xon_xoff ? "en" : "dis", tty_baud_rate, translate_mode ? "on" : "off", scan_mode ? "on" : "off"); ptextln(temp); put_crlf(); } /* ** tty_width(testlist, state, ch) ** ** Change the character width */ static void tty_width( struct test_list *t GCC_UNUSED, int *state GCC_UNUSED, int *ch GCC_UNUSED) { if (char_mask == STRIP_PARITY) { char_mask = ALLOW_PARITY; strcpy(tty_width_menu, "7) treat terminal as 7-bit"); } else { char_mask = STRIP_PARITY; strcpy(tty_width_menu, "8) treat terminal as 8-bit"); } } /* ** tty_delay(testlist, state, ch) ** ** Change the delay for in the TTY driver */ static void tty_delay( struct test_list *t GCC_UNUSED, int *state GCC_UNUSED, int *ch GCC_UNUSED) { if (select_delay_type) { select_delay_type = FALSE; strcpy(tty_delay_menu, "d) enable UNIX tty driver delays for "); } else { select_delay_type = TRUE; strcpy(tty_delay_menu, "d) disable UNIX tty driver delays for "); } } /* ** tty_xon(testlist, state, ch) ** ** Change the XON/XOFF flags in the TTY driver */ static void tty_xon( struct test_list *t GCC_UNUSED, int *state GCC_UNUSED, int *ch GCC_UNUSED) { if (select_xon_xoff) { if (needs_xon_xoff) { ptextln("This terminal is marked as needing XON/XOFF protocol with (nxon)"); } if (exit_xon_mode) { tc_putp(exit_xon_mode); } xon_xoff = FALSE; select_xon_xoff = FALSE; strcpy(tty_xon_menu, enable_xon_xoff); } else { if (enter_xon_mode) { tc_putp(enter_xon_mode); } xon_xoff = TRUE; select_xon_xoff = TRUE; strcpy(tty_xon_menu, disable_xon_xoff); } tty_set(); } /* ** tty_trans(testlist, state, ch) ** ** Change the translation mode for special characters */ static void tty_trans( struct test_list *t GCC_UNUSED, int *state GCC_UNUSED, int *ch GCC_UNUSED) { if (translate_mode) { translate_mode = FALSE; strcpy(tty_trans_menu, "t) use terminfo values for \\b\\f\\n\\r\\t"); } else { translate_mode = TRUE; strcpy(tty_trans_menu, "t) override terminfo values for \\b\\f\\n\\r\\t"); } } /* ** pad_gen(testlist, state, ch) ** ** Menu function for automatic pad generation */ static void pad_gen( struct test_list *t, int *state GCC_UNUSED, int *ch) { control_init(); if (tty_can_sync == SYNC_NOT_TESTED) { verify_time(); } auto_pad_mode = TRUE; menu_display(t->sub_menu, ch); auto_pad_mode = FALSE; } /* ** start_modes(testlist, state, ch) ** ** Change the TTY modes */ static void start_modes( struct test_list *t GCC_UNUSED, int *state GCC_UNUSED, int *ch GCC_UNUSED) { if (select_delay_type) { strcpy(tty_delay_menu, "d) disable UNIX tty driver delays for "); } else { strcpy(tty_delay_menu, "d) enable UNIX tty driver delays for "); } if (char_mask == ALLOW_PARITY) { strcpy(tty_width_menu, "7) treat terminal as 7-bit"); } else { strcpy(tty_width_menu, "8) treat terminal as 8-bit"); } if (select_xon_xoff) { strcpy(tty_xon_menu, disable_xon_xoff); } else { strcpy(tty_xon_menu, enable_xon_xoff); } if (translate_mode) { strcpy(tty_trans_menu, "t) override terminfo values for \\b\\f\\n\\r\\t"); } else { strcpy(tty_trans_menu, "t) use terminfo values for \\b\\f\\n\\r\\t"); } menu_display(&tty_menu, 0); tty_set(); } /* ** start_basic(testlist, state, ch) ** ** Display basic terminal information */ static void start_basic( struct test_list *t GCC_UNUSED, int *state GCC_UNUSED, int *ch) { display_basic(); *ch = REQUEST_PROMPT; } /* ** start_log(testlist, state, ch) ** ** Start/stop in logging function */ static void start_log( struct test_list *t GCC_UNUSED, int *state GCC_UNUSED, int *ch GCC_UNUSED) { if (logging_menu_entry[5] == 'a') { ptextln("The log file will capture all characters sent to the terminal."); if ((log_fp = fopen("tack.log", "w"))) { ptextln("Start logging to file: tack.log"); strcpy(logging_menu_entry, "l) stop logging"); } else { ptextln("File open error: tack.log"); } } else { if (log_fp) { fclose(log_fp); log_fp = 0; } ptextln("Terminal output logging stopped."); strcpy(logging_menu_entry, "l) start logging"); } } /* ** show_usage() ** ** Tell the user how its done. */ void show_usage( char *name) { (void) fprintf(stderr, "usage: %s [-itV] [term]\n", name); } /* ** print_version() ** ** Print version and other useful information. */ void print_version(void) { printf("tack version %d.%02d\n", MAJOR_VERSION, MINOR_VERSION); printf("Copyright (C) 1997 Free Software Foundation, Inc.\n"); printf("Tack comes with NO WARRANTY, to the extent permitted by law.\n"); printf("You may redistribute copies of Tack under the terms of the\n"); printf("GNU General Public License. For more information about\n"); printf("these matters, see the file named COPYING.\n"); } /***************************************************************************** * * Main sequence * *****************************************************************************/ int main(int argc, char *argv[]) { int i, j; char *term_variable; /* scan the option flags */ send_reset_init = TRUE; translate_mode = FALSE; term_variable = getenv("TERM"); tty_can_sync = SYNC_NOT_TESTED; for (i = 1; i < argc; i++) { if (argv[i][0] == '-') { for (j = 1; argv[i][j]; j++) { switch (argv[i][j]) { case 'V': print_version(); ExitProgram (EXIT_FAILURE); /* NOTREACHED */ case 'i': send_reset_init = FALSE; break; case 't': translate_mode = FALSE; break; default: show_usage(argv[0]); ExitProgram (EXIT_SUCCESS); /* NOTREACHED */ } } } else { term_variable = argv[i]; } } (void) strcpy(tty_basename, term_variable); curses_setup(argv[0]); menu_can_scan(&normal_menu); /* extract which caps can be tested */ menu_display(&start_menu, 0); if (user_modified()) { sprintf(temp, "Hit y to save changes to file: %s ? ", tty_basename); ptext(temp); if (wait_here() == 'y') { save_info(write_terminfo_list, &i, &j); } } put_str("\nTerminal test complete\n"); bye_kids(EXIT_SUCCESS); ExitProgram(EXIT_SUCCESS); } #if NO_LEAKS void ExitProgram(int code) { del_curterm(cur_term); tack_edit_leaks(); tack_fun_leaks(); _nc_free_tic(code); } #endif tack-1.07/tack.h0000644000175100001440000003416611315477467012226 0ustar tomusers/* ** Copyright (C) 1991, 1997 Free Software Foundation, Inc. ** ** This file is part of TACK. ** ** TACK is free software; you can redistribute it and/or modify ** it under the terms of the GNU General Public License as published by ** the Free Software Foundation; either version 2, or (at your option) ** any later version. ** ** TACK 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 TACK; see the file COPYING. If not, write to ** the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, ** Boston, MA 02110-1301, USA */ /* $Id: tack.h,v 1.23 2009/12/26 21:25:11 tom Exp $ */ #ifndef NCURSES_TACK_H_incl #define NCURSES_TACK_H_incl 1 /* terminfo action checker include file */ #define MAJOR_VERSION 1 #define MINOR_VERSION 7 #ifdef HAVE_CONFIG_H #include #else #define RETSIGTYPE void #define GCC_UNUSED /*nothing*/ #define HAVE_GETTIMEOFDAY 1 #define HAVE_SELECT 1 #define HAVE_SYS_TIME_H 1 #define HAVE_SYS_TIME_SELECT 1 #endif #include #include #include #include #include #include /* include before curses.h to work around glibc bug */ #include #include #include #if USE_RCS_IDS #define MODULE_ID(id) static const char Ident[] = id; #else #define MODULE_ID(id) /*nothing*/ #endif #if !HAVE_STRSTR extern char *_nc_strstr(const char *, const char *); #define strstr(h,n) _nc_strstr(h,n) #endif #if NO_LEAKS && defined(HAVE__NC_FREE_TIC) extern void _nc_free_tic(int); extern void tack_edit_leaks(void); extern void tack_fun_leaks(void); extern void ExitProgram(int); #else #define ExitProgram(code) exit(code) #undef NO_LEAKS #define NO_LEAKS 0 #endif #define FreeIfNeeded(p) if (p) { free(p); p = 0; } #define CUR_TP (&(cur_term->type)) #define MAX_STRINGS NUM_STRINGS(CUR_TP) #define STR_NAME(n) ExtStrname(CUR_TP,n,strnames) #define UChar(c) ((unsigned char)(c)) extern FILE *log_fp; extern FILE *debug_fp; extern int debug_level; extern char temp[]; extern char tty_basename[]; extern char tty_shortname[]; #define SYNC_FAILED 0 #define SYNC_TESTED 1 #define SYNC_NOT_TESTED 2 #define SYNC_NEEDED 3 extern int tty_can_sync; extern int total_pads_sent; /* count pad characters sent */ extern int total_caps_sent; /* count caps sent */ extern int total_printing_characters; /* count printing characters sent */ extern SIG_ATOMIC_T no_alarm_event; /* TRUE if the alarm has not gone off yet */ extern unsigned long usec_run_time; /* length of last test in microseconds */ extern int raw_characters_sent; /* Total output characters */ /* Stopwatch event timers */ #define TIME_TEST 0 #define TIME_SYNC 1 #define TIME_FLUSH 2 #define MAX_TIMERS 3 /* definitions for pad.c */ #define EXIT_CONDITION (no_alarm_event && (tt_delay_used < tt_delay_max)) #define SLOW_TERMINAL_EXIT if (!test_complete && !EXIT_CONDITION) { break; } #define CAP_NOT_FOUND if (auto_pad_mode) return extern char letters[26+1]; #define NEXT_LETTER letter = letters[letter_number =\ letters[letter_number + 1] ? letter_number + 1 : 0] extern int test_complete; /* counts number of tests completed */ extern char letter; extern int letter_number; extern int augment, repeats; extern long char_sent; extern const char *pad_repeat_test; /* commands that force repeat */ extern int replace_mode; extern int char_count, line_count, expand_chars; extern int can_go_home, can_clear_screen; extern int translate_mode, scan_mode; extern int auto_pad_mode; /* TRUE for auto time tests */ extern int char_mask; extern int hex_out; /* Display output in hex */ /* Parity bit macros */ #define STRIP_PARITY 0x7f #define ALLOW_PARITY 0xff /* select_delay_type: 0 -> reset all delays 1 -> force long delays 2 -> do not change the delays */ extern int select_delay_type; /* select_xon_xoff: 0 -> reset xon/xoff 1 -> set xon/xoff 2 -> do not change xon/xoff */ extern int select_xon_xoff; extern int tty_frame_size; extern unsigned tty_baud_rate; extern unsigned long tty_cps; /* The number of characters per second */ extern SIG_ATOMIC_T not_a_tty; extern int nodelay_read; extern int send_reset_init; /* definitions for stty_query() and initial_stty_query() */ #define TTY_CHAR_MODE 0 #define TTY_NOECHO 1 #define TTY_OUT_TRANS 2 #define TTY_8_BIT 3 #define TTY_XON_XOFF 4 /* scan code definitions */ #define MAX_SCAN 256 /* translate mode default strings */ struct default_string_list { const char *name; /* terminfo name */ const char *value; /* value of default string */ int index; /* index into the strfname[] array */ }; #define TM_last 8 extern struct default_string_list TM_string[TM_last]; /* attribute structure definition */ struct mode_list { const char *name; const char *begin_mode; const char *end_mode; int number; }; extern const struct mode_list alt_modes[]; extern const int mode_map[]; /* Test data base */ #define FLAG_CAN_TEST 1 #define FLAG_TESTED 2 #define FLAG_LABEL 4 #define FLAG_FUNCTION_KEY 8 /* caps under test data base */ #define TT_MAX 8 #define MAX_CHANGES (TT_MAX+2) extern int tt_delay_max; /* max number of milliseconds we can delay */ extern int tt_delay_used; /* number of milliseconds consumed in delay */ extern const char *tt_cap[TT_MAX]; /* value of string */ extern int tt_affected[TT_MAX]; /* lines or columns effected (repetition factor) */ extern int tt_count[TT_MAX]; /* Number of times sent */ extern int tt_delay[TT_MAX]; /* Number of milliseconds delay */ extern int ttp; /* number of entries used */ extern const char *tx_cap[TT_MAX]; /* value of string */ extern int tx_affected[TT_MAX]; /* lines or columns effected (repetition factor) */ extern int tx_count[TT_MAX]; /* Number of times sent */ extern int tx_delay[TT_MAX]; /* Number of milliseconds delay */ extern int tx_index[TT_MAX]; /* String index */ extern int txp; /* number of entries used */ extern int tx_characters; /* printing characters sent by test */ extern unsigned long tx_cps; /* characters per second */ /* Menu control for tack. */ struct test_results { struct test_results *next; /* point to next entry */ struct test_list *test; /* Test which got these results */ int reps; /* repeat count */ int delay; /* delay times 10 */ }; struct test_list { int flags; /* Test description flags */ int lines_needed; /* Lines needed for test (0->no action) */ const char *caps_done; /* Caps shown in Done message */ const char *caps_tested; /* Other caps also being tested */ const char *menu_entry; /* Menu entry text (optional) */ /* Function that does testing */ void (*test_procedure)(struct test_list *, int *, int *); struct test_menu *sub_menu; /* Nested sub-menu */ }; struct test_menu { int flags; /* Menu feature flag */ int default_action; /* Default command if entered */ const char *menu_text; /* Describe this test_menu */ const char *menu_title; /* Title for the menu */ const char *ident; /* short menu name */ const char *standard_tests; /* Standard test text */ /* print current settings (optional) */ void (*menu_function)(struct test_menu *); struct test_list *tests; /* Pointer to the menu/function pairs */ struct test_list *resume_tests; /* Standard test resume point */ int resume_state; /* resume state of test group */ int resume_char; /* resume ch of test group */ }; /* menu flags */ #define MENU_100c 0x00001a00 /* Augment 100% of columns */ #define MENU_90c 0x00001900 /* Augment 90% of columns */ #define MENU_80c 0x00001800 /* Augment 80% of columns */ #define MENU_70c 0x00001700 /* Augment 70% of columns */ #define MENU_60c 0x00001600 /* Augment 60% of columns */ #define MENU_50c 0x00001500 /* Augment 50% of columns */ #define MENU_40c 0x00001400 /* Augment 40% of columns */ #define MENU_30c 0x00001300 /* Augment 30% of columns */ #define MENU_20c 0x00001200 /* Augment 20% of columns */ #define MENU_10c 0x00001100 /* Augment 10% of columns */ #define MENU_LM1 0x00002e00 /* Augment lines - 1 */ #define MENU_100l 0x00002a00 /* Augment 100% of lines */ #define MENU_90l 0x00002900 /* Augment 90% of lines */ #define MENU_50l 0x00002500 /* Augment 50% of lines */ #define MENU_lines 0x00002000 /* Augment of lines */ #define MENU_columns 0x00001000 /* Augment of columns */ #define MENU_LC_MASK 0x00003000 /* Augment mask for lines and columns */ #define MENU_1L 0x00002f00 /* Augment == one */ #define MENU_1C 0x00001f00 /* Augment == one */ #define MENU_ONE 0x00000f00 /* Augment == one */ #define MENU_ONE_MASK 0x00000f00 /* Augment == one mask */ #define MENU_REP_MASK 0x00003f00 /* Augment mask */ #define MENU_CLEAR 0x00010000 /* clear screen */ #define MENU_INIT 0x00020000 /* Initialization function */ #define MENU_NEXT 0x00040000 /* Next test in sequence */ #define MENU_LAST 0x00080000 /* End of menu list */ #define MENU_STOP 0x00100000 /* Stop testing next-in-sequence */ #define MENU_COMPLETE 0x00200000 /* Test complete after this */ #define MENU_MENU 0x00400000 /* Pass the menu name not test name */ #define REQUEST_PROMPT 256 /* tack.c */ extern struct test_menu edit_menu; extern void show_usage(char *); extern void print_version(void); /* output.c */ extern char *expand(const char *); extern char *expand_command(const char *); extern char *expand_to(char *, int); extern char *hex_expand_to(char *, int); extern char *print_expand(char *); extern int getchp(int); extern int getnext(int); extern int tc_putch(int); extern int tc_putp(const char *); extern int wait_here(void); extern void go_home(void); extern void home_down(void); extern void maybe_wait(int); extern void ptext(const char *); extern void ptextln(const char *); extern void put_clear(void); extern void put_columns(const char *, int, int); extern void put_cr(void); extern void put_crlf(void); extern void put_dec(char *, int); extern void put_ind(void); extern void put_lf(void); extern void put_newlines(int); extern void put_str(const char *); extern void put_this(int); extern void putchp(int); extern void putln(const char *); extern void read_string(char *, int); extern void three_digit(char *, int); extern void tt_putp(const char *); extern void tt_putparm(NCURSES_CONST char *, int, int, int); extern void tt_tputs(const char *, int); #define put_that(n) put_this((int) (n)) /* control.c */ extern struct test_list color_test_list[]; extern char *liberated(char *); extern char txt_longer_augment[80]; extern char txt_longer_test_time[80]; extern char txt_shorter_augment[80]; extern char txt_shorter_test_time[80]; extern int msec_cost(const char *const, int); extern int skip_pad_test(struct test_list *, int *, int *, const char *); extern int sliding_scale(int, int, unsigned long); extern int still_testing(void); extern long event_time(int); extern void control_init(void); extern void dump_test_stats(struct test_list *, int *, int *); extern void event_start(int); extern void longer_augment(struct test_list *, int *, int *); extern void longer_test_time(struct test_list *, int *, int *); extern void pad_test_shutdown(struct test_list *, int); extern void pad_test_startup(int); extern void page_loop(void); extern void set_augment_txt(void); extern void shorter_augment(struct test_list *, int *, int *); extern void shorter_test_time(struct test_list *, int *, int *); /* charset.c */ extern struct test_list acs_test_list[]; extern void set_attr(int); extern void eat_cookie(void); extern void put_mode(char *); /* crum.c */ extern struct test_list crum_test_list[]; /* ansi.c */ extern void tools_status(struct test_list *, int *, int *); extern void tools_charset(struct test_list *, int *, int *); extern void tools_sgr(struct test_list *, int *, int *); /* edit.c */ extern struct test_menu change_pad_menu; extern struct test_list edit_test_list[]; extern char *get_string_cap_byname(const char *, const char **); extern int cap_match(const char *names, const char *cap); extern int get_string_cap_byvalue(const char *); extern int user_modified(void); extern void can_test(const char *, int); extern void cap_index(const char *, int *); extern void edit_init(void); extern void save_info(struct test_list *, int *, int *); extern void show_report(struct test_list *, int *, int *); /* fun.c */ extern struct test_list funkey_test_list[]; extern struct test_list printer_test_list[]; extern void enter_key(const char *, char *, char *); extern int tty_meta_prep(void); extern void tools_report(struct test_list *, int *, int *); /* init.c */ extern void reset_init(void); extern void display_basic(void); extern void put_name(const char *, const char *); extern void charset_can_test(void); extern void curses_setup(char *); extern void bye_kids(int); /* scan.c */ extern char **scan_up, **scan_down, **scan_name; extern int scan_key(void); extern unsigned scan_max; /* length of longest scan code */ extern unsigned *scan_tested, *scan_length; extern void scan_init(char *fn); /* sysdep.c */ extern int initial_stty_query(int); extern int stty_query(int); extern void ignoresig(void); extern void read_key(char *, int); extern void set_alarm_clock(int); extern void spin_flush(void); extern void tty_init(void); extern void tty_raw(int, int); extern void tty_reset(void); extern void tty_set(void); /* menu.c */ extern char prompt_string[80]; /* menu prompt storage */ extern int subtest_menu(struct test_list *, int *, int *); extern struct test_list *augment_test; extern void generic_done_message(struct test_list *, int *, int *); extern void menu_can_scan(const struct test_menu *); extern void menu_clear_screen(struct test_list *, int *, int *); extern void menu_display(struct test_menu *, int *); extern void menu_prompt(void); extern void menu_reset_init(struct test_list *, int *, int *); extern void pad_done_message(struct test_list *, int *, int *); /* modes.c */ extern struct test_list mode_test_list[]; /* pad.c */ extern struct test_list pad_test_list[]; /* sync.c */ extern struct test_menu sync_menu; extern int tty_sync_error(void); extern void flush_input(void); extern void sync_handshake(struct test_list *, int *, int *); extern void sync_test(struct test_menu *); extern void verify_time(void); #endif /* NCURSES_TACK_H_incl */