configure.in

   1 dnl $MirOS: src/gnu/usr.bin/cvs/configure.in,v 1.23 2016/10/22 22:01:42 tg Exp $
   2 dnl
   3 dnl configure.in for cvs
   4
   5 AC_COPYRIGHT(
   6 [Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
   7               1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
   8               Free Software Foundation, Inc.
   9
  10 This program is free software; you can redistribute it and/or modify
  11 it under the terms of the GNU General Public License as published by
  12 the Free Software Foundation; either version 2, or (at your option)
  13 any later version.
  14
  15 This program is distributed in the hope that it will be useful,
  16 but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 GNU General Public License for more details.])
  19
  20 AC_INIT([Concurrent Versions System (CVS)],[1.12.13-MirOS-0AB7.4],
  21         [miros-discuss@mirbsd.org],[cvs])
  22 AC_CONFIG_SRCDIR(src/cvs.h)
  23 AM_INIT_AUTOMAKE([gnu 1.9.2 dist-bzip2 no-define])
  24 AC_PREREQ(2.59)
  25
  26 AC_PREFIX_PROGRAM(cvs)
  27 AM_CONFIG_HEADER(config.h)
  28 AM_MAINTAINER_MODE
  29
  30 dnl This needs to be called to enable certain system extensions before calling
  31 dnl a C compiler.
  32 gl_EARLY
  33
  34 AC_PROG_CC
  35
  36 AC_PROG_RANLIB
  37 AC_PROG_LN_S
  38 AC_SYS_LARGEFILE
  39 AC_EXEEXT
  40
  41 AC_PATH_PROG(PERL, perl, no)
  42 AC_PATH_PROG(CSH, csh, no)
  43 # for contrib/rcs2log.sh & src/cvsbug.in.
  44 AC_PATH_PROG(MKTEMP, mktemp, mktemp)
  45 if test x"$MKTEMP" = xmktemp; then
  46         MKTEMP_SH_FUNCTION=$srcdir/mktemp.sh
  47 else
  48         MKTEMP_SH_FUNCTION=/dev/null
  49 fi
  50 AC_SUBST_FILE(MKTEMP_SH_FUNCTION)
  51 # for src/cvsbug.in
  52 AC_PATH_PROG(SENDMAIL, sendmail, no, [$PATH:/usr/sbin:/usr/lib])
  53 # For diff/util.c
  54 AC_PATH_PROG(PR, pr, no)
  55 if test x"$PR" != xno; then
  56         AC_DEFINE_UNQUOTED([PR_PROGRAM], ["$PR"], [Path to the pr utility])
  57 fi
  58
  59 dnl FIXME This is truly gross.
  60 missing_dir=`cd $ac_aux_dir && pwd`
  61 dnl FIXME I pulled this default list from sanity.sh.  Perhaps these lists
  62 dnl can be stored in one location?
  63 dnl
  64 dnl Yeah, put the value in a variable add it to the substitution list
  65 dnl then have configure create sanity.sh from sanity.sh.in...
  66 glocs="$PATH:/usr/local/bin:/usr/contrib/bin:/usr/gnu/bin:/local/bin:/local/gnu/bin:/gnu/bin"
  67 AC_PATH_PROGS(ROFF, nroff gnroff groff roff, $missing_dir/missing roff, $glocs)
  68 AC_PATH_PROG(PS2PDF, ps2pdf, $missing_dir/missing ps2pdf)
  69 AC_PATH_PROG(TEXI2DVI, texi2dvi, $missing_dir/missing texi2dvi)
  70
  71 AC_SYS_INTERPRETER
  72 if test X"$ac_cv_sys_interpreter" != X"yes" ; then
  73   # silly trick to avoid problems in AC macros...
  74   ac_msg='perl scripts using #! may not be invoked properly'
  75   AC_MSG_WARN($ac_msg)
  76 fi
  77
  78 # BSD's logo is a devil for a reason, hey?
  79 AC_CACHE_CHECK(for BSD VPATH bug in make, ccvs_cv_bsd_make_vpath_bug,
  80 [if test ! -d ac_test_dir ; then
  81         AC_TRY_COMMAND([mkdir ac_test_dir])
  82 fi
  83 cat >conftestmake <<EOF
  84 VPATH = ac_test_dir
  85 ac_test_target: ac_test_dep
  86         echo BSD VPATH bug present >&2
  87 ac_test_dep: ac_test_dep_dep
  88 EOF
  89 touch ac_test_dir/ac_test_dep_dep
  90 touch ac_test_dir/ac_test_dep
  91 touch ac_test_target
  92 # Don't know why, but the following test doesn't work under FreeBSD 4.2
  93 # without this sleep command
  94 sleep 1
  95 if AC_TRY_COMMAND([make -f conftestmake 2>&1 >/dev/null |grep ^BSD\ VPATH\ bug\ present\$ >/dev/null]) ; then
  96         ccvs_cv_bsd_make_vpath_bug=yes
  97 else
  98         ccvs_cv_bsd_make_vpath_bug=no
  99 fi
 100 AC_TRY_COMMAND([rm -rf ac_test_dir ac_test_target conftestmake])])
 101 # We also don't need to worry about the bug when $srcdir = $builddir
 102 AM_CONDITIONAL(MAKE_TARGETS_IN_VPATH, \
 103                 test $ccvs_cv_bsd_make_vpath_bug = no \
 104                 || test $srcdir = .)
 105
 106 AC_HEADER_DIRENT
 107 AC_HEADER_STDC
 108 AC_HEADER_SYS_WAIT
 109 AC_CHECK_HEADERS(\
 110         direct.h \
 111         fcntl.h \
 112         getopt.h \
 113         inttypes.h \
 114         io.h \
 115         memory.h \
 116         ndbm.h \
 117         stdint.h \
 118         syslog.h \
 119         sys/bsdtypes.h \
 120         sys/file.h \
 121         sys/inttypes.h \
 122         sys/param.h \
 123         sys/resource.h \
 124         sys/select.h \
 125         unistd.h \
 126         utime.h \
 127         wctype.h \
 128         zlib.h \
 129 )
 130 gl_AC_HEADER_STDINT_H
 131 AC_HEADER_STAT
 132 AC_HEADER_STDBOOL
 133
 134 AC_C_CONST
 135 AC_TYPE_UID_T
 136 AC_TYPE_MODE_T
 137 AC_TYPE_PID_T
 138 AC_TYPE_SIGNAL
 139
 140 AC_CHECK_MEMBERS([struct stat.st_blksize])
 141 AC_CHECK_MEMBERS([struct stat.st_rdev])
 142
 143 AC_FUNC_FSEEKO
 144 AC_FUNC_ALLOCA
 145 AC_CHECK_FUNCS([fseeko])
 146 if test $ac_cv_func_fseeko = no; then
 147     AC_LIBOBJ(fseeko)
 148     AC_LIBOBJ(ftello)
 149 fi
 150
 151 # Replace functions with versions in lib/ when they can't be found.
 152 AC_REPLACE_FUNCS(\
 153         waitpid \
 154 )
 155
 156 #
 157 # Special hack for a SunOS 5.7 (aka Solaris 7) select() problem.
 158 #
 159 ccvs_FUNC_SELECT
 160
 161 #
 162 # Begin GNULIB stuff.
 163 #
 164
 165 # Look for functions from GNULIB and replace with versions in lib/ when
 166 # necessary.
 167 dnl This calls most of the GNULIB macros we need via the
 168 dnl autogenerated m4/gnulib.m4.
 169 gl_INIT
 170 # The error module still poses merge problems.
 171 AC_FUNC_STRERROR_R
 172 dnl The following macros can be called by other GNULIB macros but are also
 173 dnl used by the UNIQUE_*_TYPE stuff below.  I don't want to rely on the GNULIB
 174 dnl macros which call these to continue to do so, so use AC_REQUIRE, which can
 175 dnl only be called from within another macro, to only call them only once.
 176 AC_DEFUN([CCVS_CALL_GNULIB_MACROS_ONCE],
 177 [AC_REQUIRE([gt_TYPE_LONGDOUBLE])
 178 AC_REQUIRE([gt_TYPE_WCHAR_T])
 179 AC_REQUIRE([gt_TYPE_WINT_T])
 180 AC_REQUIRE([gl_AC_TYPE_INTMAX_T])
 181 AC_REQUIRE([gl_FUNC_MMAP_ANON])
 182 AC_REQUIRE([gl_AC_TYPE_LONG_LONG])])
 183 CCVS_CALL_GNULIB_MACROS_ONCE()
 184
 185 #
 186 # End GNULIB stuff.
 187 #
 188
 189
 190
 191 # Check for function existance.
 192 AC_CHECK_FUNCS(\
 193         alloca \
 194         btowc \
 195         fchdir \
 196         fchmod \
 197         fsync \
 198         ftime \
 199         geteuid \
 200         getgroups \
 201         getopt_long_only \
 202         getpagesize \
 203         getpass \
 204         gettimeofday \
 205         initgroups \
 206         login \
 207         logout \
 208         mbsrtowcs \
 209         regcomp \
 210         regerror \
 211         regexec \
 212         regfree \
 213         sigaction \
 214         sigblock \
 215         sigprocmask \
 216         sigsetmask \
 217         sigvec \
 218         timezone \
 219         tzset \
 220         vprintf \
 221         wait3 \
 222         wmemchr \
 223         wmemcpy \
 224         wmempcpy \
 225 )
 226 HAVE_PUTENV=$ac_cv_func_putenv
 227 AC_SUBST(HAVE_PUTENV)
 228 AC_C_BIGENDIAN
 229
 230 dnl
 231 dnl Find the sizes of various types and set a variable for some if they
 232 dnl are "unique", meaning it does not share a size with a lower precedence
 233 dnl type.
 234 dnl
 235 dnl also, I snagged this cross_compiling line from openldap's autoconf,
 236 dnl because I can't figure out how to stop autoconf from giving cross compiler
 237 dnl related warnings each time the AC_CHECK_SIZEOF function is run
 238 dnl
 239 if test $cross_compiling = yes ; then
 240         AC_DEFINE(CROSS_COMPILING, 1, [define if cross compiling])
 241 else
 242         AC_CHECK_SIZEOF(char)
 243         AC_CACHE_CHECK(for uniquely sized char,
 244                 ccvs_cv_unique_int_type_char,
 245                 [if set |grep ^ccvs_cv_unique_int_type_ \
 246                         |grep "($ac_cv_sizeof_char)" >/dev/null ; then
 247                         ccvs_cv_unique_int_type_char=no
 248                 else
 249                         ccvs_cv_unique_int_type_char=yes\($ac_cv_sizeof_char\)
 250                 fi])
 251         if test $ccvs_cv_unique_int_type_char != no ; then
 252                 AC_DEFINE( UNIQUE_INT_TYPE_CHAR, 1,
 253                            [Define if char is the first integer type
 254                             detected with its size.])
 255         fi
 256         AC_CHECK_SIZEOF(short)
 257         AC_CACHE_CHECK(for uniquely sized short,
 258                 ccvs_cv_unique_int_type_short,
 259                 [if set |grep ^ccvs_cv_unique_int_type_ \
 260                         |grep "($ac_cv_sizeof_short)" >/dev/null ; then
 261                         ccvs_cv_unique_int_type_short=no
 262                 else
 263                         ccvs_cv_unique_int_type_short=yes\($ac_cv_sizeof_short\)
 264                 fi])
 265         if test $ccvs_cv_unique_int_type_short != no ; then
 266                 AC_DEFINE( UNIQUE_INT_TYPE_SHORT, 1,
 267                            [Define if short is the first integer type
 268                             detected with its size.])
 269         fi
 270         AC_CHECK_SIZEOF(int)
 271         AC_CACHE_CHECK(for uniquely sized int,
 272                 ccvs_cv_unique_int_type_int,
 273                 [if set |grep ^ccvs_cv_unique_int_type_ \
 274                         |grep "($ac_cv_sizeof_int)" >/dev/null ; then
 275                         ccvs_cv_unique_int_type_int=no
 276                 else
 277                         ccvs_cv_unique_int_type_int=yes\($ac_cv_sizeof_int\)
 278                 fi])
 279         if test $ccvs_cv_unique_int_type_int != no ; then
 280                 AC_DEFINE( UNIQUE_INT_TYPE_INT, 1,
 281                            [Define if int is the first integer type
 282                             detected with its size.])
 283         fi
 284         AC_CHECK_SIZEOF(long)
 285         AC_CACHE_CHECK(for uniquely sized long,
 286                 ccvs_cv_unique_int_type_long,
 287                 [if set |grep ^ccvs_cv_unique_int_type_ \
 288                         |grep "($ac_cv_sizeof_long)" >/dev/null ; then
 289                         ccvs_cv_unique_int_type_long=no
 290                 else
 291                         ccvs_cv_unique_int_type_long=yes\($ac_cv_sizeof_long\)
 292                 fi])
 293         if test $ccvs_cv_unique_int_type_long != no ; then
 294                 AC_DEFINE(UNIQUE_INT_TYPE_LONG, 1,
 295                           [Define if long int is the first integer type
 296                            detected with its size.])
 297         fi
 298         if test $ac_cv_type_long_long != no; then
 299                 AC_CHECK_SIZEOF(long long)
 300                 AC_CACHE_CHECK(for uniquely sized long long,
 301                         ccvs_cv_unique_int_type_long_long,
 302                         [if set |grep ^ccvs_cv_unique_int_type_ \
 303                                 |grep "($ac_cv_sizeof_long_long)" >/dev/null ; then
 304                                 ccvs_cv_unique_int_type_long_long=no
 305                         else
 306                                 ccvs_cv_unique_int_type_long_long=yes\($ac_cv_sizeof_long_long\)
 307                         fi])
 308                 if test $ccvs_cv_unique_int_type_long_long != no ; then
 309                         AC_DEFINE(UNIQUE_INT_TYPE_LONG_LONG, 1,
 310                                   [Define if long long is the first integer type
 311                                    detected with its size.])
 312                 fi
 313         fi
 314         AC_CHECK_SIZEOF(size_t)
 315         AC_CACHE_CHECK(for uniquely sized size_t,
 316                 ccvs_cv_unique_int_type_size_t,
 317                 [if set |grep ^ccvs_cv_unique_int_type_ \
 318                         |grep "($ac_cv_sizeof_size_t)" >/dev/null ; then
 319                         ccvs_cv_unique_int_type_size_t=no
 320                 else
 321                         ccvs_cv_unique_int_type_size_t=yes\($ac_cv_sizeof_size_t\)
 322                 fi])
 323         if test $ccvs_cv_unique_int_type_size_t != no ; then
 324                 AC_DEFINE(UNIQUE_INT_TYPE_SIZE_T, 1,
 325                           [Define if size_t is the first integer type
 326                            detected with its size.])
 327         fi
 328         AC_CHECK_SIZEOF(ptrdiff_t)
 329         AC_CACHE_CHECK(for uniquely sized ptrdiff_t,
 330                 ccvs_cv_unique_int_type_ptrdiff_t,
 331                 [if set |grep ^ccvs_cv_unique_int_type_ \
 332                         |grep "($ac_cv_sizeof_ptrdiff_t)" >/dev/null ; then
 333                         ccvs_cv_unique_int_type_ptrdiff_t=no
 334                 else
 335                         ccvs_cv_unique_int_type_ptrdiff_t=yes\($ac_cv_sizeof_ptrdiff_t\)
 336                 fi])
 337         if test $ccvs_cv_unique_int_type_ptrdiff_t != no ; then
 338                 AC_DEFINE(UNIQUE_INT_TYPE_PTRDIFF_T, 1,
 339                           [Define if ptrdiff_t is the first integer type
 340                            detected with its size.])
 341         fi
 342         if test $gt_cv_c_wint_t != no; then
 343                 AC_CHECK_SIZEOF(wint_t, [], [[#include <stdio.h>
 344 #include <wchar.h>
 345 ]])
 346                 AC_CACHE_CHECK(for uniquely sized wint_t,
 347                         ccvs_cv_unique_int_type_wint_t,
 348                         [if set |grep ^ccvs_cv_unique_int_type_ \
 349                                 |grep "($ac_cv_sizeof_wint_t)" >/dev/null ; then
 350                                 ccvs_cv_unique_int_type_wint_t=no
 351                         else
 352                                 ccvs_cv_unique_int_type_wint_t=yes\($ac_cv_sizeof_wint_t\)
 353                         fi])
 354                 if test $ccvs_cv_unique_int_type_wint_t != no ; then
 355                         AC_DEFINE( UNIQUE_INT_TYPE_WINT_T, 1,
 356                                    [Define if wint_t is the first integer type
 357                                     detected with its size.])
 358                 fi
 359         fi
 360         if test $gt_cv_c_intmax_t != no; then
 361                 AC_CHECK_SIZEOF(intmax_t, [], [[#include <stdio.h>
 362 #ifdef HAVE_INTTYPES_H
 363 #include <inttypes.h>
 364 #else
 365 #ifdef HAVE_STDINT_H
 366 #include <stdint.h>
 367 #endif
 368 #endif
 369 ]])
 370                 AC_CACHE_CHECK(for uniquely sized intmax_t,
 371                         ccvs_cv_unique_int_type_intmax_t,
 372                         [if set |grep ^ccvs_cv_unique_int_type_ \
 373                                 |grep "($ac_cv_sizeof_intmax_t)" >/dev/null ; then
 374                                 ccvs_cv_unique_int_type_intmax_t=no
 375                         else
 376                                 ccvs_cv_unique_int_type_intmax_t=yes\($ac_cv_sizeof_intmax_t\)
 377                         fi])
 378                 if test $ccvs_cv_unique_int_type_intmax_t != no ; then
 379                         AC_DEFINE( UNIQUE_INT_TYPE_INTMAX_T, 1,
 380                                    [Define if intmax_t is the first integer type
 381                                     detected with its size.])
 382                 fi
 383         fi
 384
 385         dnl
 386         dnl and the same for floats...
 387         dnl
 388         AC_CHECK_SIZEOF(float)
 389         AC_CACHE_CHECK(for uniquely sized float,
 390                 ccvs_cv_unique_float_type_float,
 391                 [if set |grep ^ccvs_cv_unique_float_type_ \
 392                         |grep "($ac_cv_sizeof_float)" >/dev/null ; then
 393                         ccvs_cv_unique_float_type_float=no
 394                 else
 395                         ccvs_cv_unique_float_type_float=yes\($ac_cv_sizeof_float\)
 396                 fi])
 397         if test $ccvs_cv_unique_float_type_float != no ; then
 398                 AC_DEFINE( UNIQUE_FLOAT_TYPE_FLOAT, 1,
 399                            [Define if float is the first floating point type
 400                             detected with its size.])
 401         fi
 402         AC_CHECK_SIZEOF(double)
 403         AC_CACHE_CHECK(for uniquely sized double,
 404                 ccvs_cv_unique_float_type_double,
 405                 [if set |grep ^ccvs_cv_unique_float_type_ \
 406                         |grep "($ac_cv_sizeof_double)" >/dev/null ; then
 407                         ccvs_cv_unique_float_type_double=no
 408                 else
 409                         ccvs_cv_unique_float_type_double=yes\($ac_cv_sizeof_double\)
 410                 fi])
 411         if test $ccvs_cv_unique_float_type_double != no ; then
 412                 AC_DEFINE( UNIQUE_FLOAT_TYPE_DOUBLE, 1,
 413                            [Define if double is the first floating point type
 414                             detected with its size.])
 415         fi
 416         if test $gt_cv_c_long_double != no; then
 417                 AC_CHECK_SIZEOF(long double)
 418                 AC_CACHE_CHECK(for uniquely sized long double,
 419                         ccvs_cv_unique_float_type_long_double,
 420                         [if set |grep ^ccvs_cv_unique_float_type_ \
 421                                 |grep "($ac_cv_sizeof_long_double)" >/dev/null ; then
 422                                 ccvs_cv_unique_float_type_long_double=no
 423                         else
 424                                 ccvs_cv_unique_float_type_long_double=yes\($ac_cv_sizeof_long_double\)
 425                         fi])
 426                 if test $ccvs_cv_unique_float_type_long_double != no ; then
 427                         AC_DEFINE(UNIQUE_FLOAT_TYPE_LONG_DOUBLE, 1,
 428                                   [Define if long double is the first floating point
 429                                    type detected with its size.])
 430                 fi
 431         fi
 432 fi
 433
 434 dnl
 435 dnl The CVS coding standard (as specified in HACKING) is that if it exists
 436 dnl in SunOS4 and ANSI, we use it.  CVS itself, of course, therefore doesn't
 437 dnl need HAVE_* defines for such functions, but diff wants them.
 438 dnl
 439 AC_DEFINE(HAVE_STRCHR, 1,
 440 [Define if you have strchr (always for CVS).])
 441 AC_DEFINE(HAVE_MEMCHR, 1,
 442 [Define if you have memchr (always for CVS).])
 443
 444 dnl
 445 dnl Force lib/regex.c to use malloc instead of messing around with alloca
 446 dnl and define the old re_comp routines that we use.
 447 dnl
 448 AC_DEFINE(REGEX_MALLOC, 1,
 449 [Define to force lib/regex.c to use malloc instead of alloca.])
 450 AC_DEFINE(_REGEX_RE_COMP, 1,
 451 [Define to force lib/regex.c to define re_comp et al.])
 452 dnl
 453 dnl AC_FUNC_FORK([]) is rather baroque.  It seems to be rather more picky
 454 dnl than, say, the Single Unix Specification (version 2), which simplifies
 455 dnl a lot of cases by saying that the child process can't set any variables
 456 dnl (thus avoiding problems with register allocation) or call any functions
 457 dnl (thus avoiding problems with whether file descriptors are shared).
 458 dnl It would be nice if we could just write to the Single Unix Specification.
 459 dnl I think the only way to do redirection this way is by doing it in the
 460 dnl parent, and then undoing it afterwards (analogous to windows-NT/run.c).
 461 dnl That would appear to have a race condition if the user hits ^C (or
 462 dnl some other signal) at the wrong time, as main_cleanup will try to use
 463 dnl stdout/stderr.  So maybe we are stuck with AC_FUNC_FORK([]).
 464 dnl
 465 AC_FUNC_FORK([])
 466 AC_FUNC_CLOSEDIR_VOID
 467
 468 dnl
 469 dnl Check for shadow password support.
 470 dnl
 471 dnl We used to try to determine whether shadow passwords were actually in
 472 dnl use or not, but the code has been changed to work right reguardless,
 473 dnl so we can go back to a simple check.
 474 AC_SEARCH_LIBS(getspnam, sec gen, AC_DEFINE(HAVE_GETSPNAM, 1,
 475 [Define if you have the getspnam function.]))
 476
 477 AC_FUNC_UTIME_NULL
 478 AC_SYS_LONG_FILE_NAMES
 479
 480 dnl for debugging code
 481 CVS_FUNC_PRINTF_PTR
 482
 483 # Try to find connect and gethostbyname.
 484 AC_CHECK_LIB(nsl, main)
 485 AC_SEARCH_LIBS(connect, xnet socket inet,
 486   AC_DEFINE(HAVE_CONNECT, 1,
 487 [Define if you have the connect function.]))
 488 dnl no need to search nsl for gethostbyname here since we should have
 489 dnl just added libnsl above if we found it.
 490 AC_SEARCH_LIBS(gethostbyname, netinet)
 491
 492 AC_SUBST(cvs_client_objects)
 493
 494
 495 dnl
 496 dnl begin --with-*
 497 dnl
 498
 499 dnl
 500 dnl begin --with-rsh
 501 dnl
 502 dnl Many sites no longer desire the use of "rsh" as the default
 503 dnl remote shell program. They typically favor "ssh" as the default
 504
 505 # What remote shell transport should our client cvs default to using?
 506 AC_ARG_WITH(
 507   [rsh],
 508   AC_HELP_STRING(
 509     [--with-rsh],
 510     [The default remote shell CVS will use for :ext: transport
 511      (default ssh)]), ,
 512   [with_rsh="ssh rsh"])
 513
 514 if test no = "$with_rsh"; then
 515   AC_MSG_WARN([Failed to find usable remote shell. Using 'rsh'.])
 516   with_rsh=rsh
 517 elif test yes = "$with_rsh"; then
 518   # Make --with-rsh mean the same thing as --with-rsh=rsh
 519   with_rsh=rsh
 520 fi
 521
 522 if echo $with_rsh |grep ^/ >/dev/null; then
 523   # If $with_rsh is an absolute path, issue a warning if the executable
 524   # doesn't exist or isn't usable, but then trust the user and use it
 525   # regardless
 526   with_default_rsh=$with_rsh
 527   AC_MSG_CHECKING([for a remote shell])
 528   if ! test -f $with_rsh \
 529       || ! test -x $with_rsh; then
 530     # warn the user that they may encounter problems
 531     AC_MSG_WARN([$with_rsh is not a path to an executable file])
 532   fi
 533 else
 534   # Search for a remote shell
 535   AC_CHECK_PROGS([with_default_rsh], [$with_rsh], "rsh")
 536 fi
 537
 538 AC_DEFINE_UNQUOTED(
 539   [RSH_DFLT], ["$with_default_rsh"],
 540   [The default remote shell to use, if one does not specify the
 541    CVS_RSH environment variable.])
 542 RSH_DFLT=$with_default_rsh
 543 AC_SUBST(RSH_DFLT)
 544 dnl done with finding a default CVS_RSH value
 545 dnl
 546 dnl end --with-rsh
 547 dnl
 548
 549 dnl
 550 dnl begin --with-editor
 551 dnl
 552 dnl Set the default editor to use for log messages
 553 dnl
 554
 555 AC_ARG_VAR(
 556   [EDITOR],
 557   [The text editor CVS will use by default for log messages.])
 558
 559 # Let the confiscator request a specific editor
 560 AC_ARG_WITH(
 561   [editor],
 562   AC_HELP_STRING(
 563     [--with-editor],
 564     [The default text editor CVS should use for log messages
 565      (default autoselects)]), ,
 566   [with_editor=yes])
 567
 568 # If --with-editor was supplied with an argument, let it override $EDITOR from
 569 # the user's environment.  We need to unset EDITOR here because AC_CHECK_PROGS
 570 # will let the value of EDITOR ride when it is set rather than searching.  We
 571 # ignore the --without-editor case since it will be caught below.
 572 if test -n "$EDITOR" && test yes != $with_editor; then
 573   AS_UNSET([EDITOR])
 574 fi
 575
 576 # Set the default when --with-editor wasn't supplied or when it was supplied
 577 # without an argument.
 578 if test yes = $with_editor; then
 579   with_editor="vim vi emacs nano pico edit"
 580 fi
 581
 582 if echo $with_editor |grep ^/ >/dev/null; then
 583   # If $with_editor is an absolute path, issue a warning if the executable
 584   # doesn't exist or isn't usable, but then trust the user and use it
 585   # regardless
 586   EDITOR=$with_editor
 587   AC_MSG_CHECKING([for an editor])
 588   AC_MSG_RESULT([$EDITOR])
 589   if ! test -f $with_editor \
 590       || ! test -x $with_editor; then
 591     # warn the user that they may encounter problems
 592     AC_MSG_WARN([\`$with_editor' is not a path to an executable file])
 593   fi
 594 elif test no != "${with_editor}"; then
 595   # Search for an editor
 596   AC_CHECK_PROGS([EDITOR], [$with_editor], [no])
 597     if test no = "${EDITOR}"; then
 598       AC_MSG_ERROR([
 599     Failed to find a text file editor.  CVS cannot be compiled
 600     without a default log message editor.  Searched for
 601     \`$with_editor'.  Try \`configure --with-editor'.])
 602     fi
 603 else
 604   AC_MSG_ERROR([
 605     CVS cannot be compiled without a default log message editor.
 606     Try \`configure --with-editor'.])
 607 fi
 608
 609 dnl FIXME - Using --without-editor will probably break a compile at
 610 dnl the moment, but maybe it is reasonable for someone to want to
 611 dnl compile a CVS executable that refuses to run if no $EDITOR,
 612 dnl $CVS_EDITOR, or -e option is specified?  Making a preliminary
 613 dnl design decision in this direction, subject to discussion.
 614 dnl
 615 dnl Still don't know if the above would be useful, but we shouldn't
 616 dnl be able to get here any longer without $EDITOR defined due to the
 617 dnl error checking above.
 618 AC_DEFINE_UNQUOTED(
 619   [EDITOR_DFLT], ["$EDITOR"],
 620   [The default editor to use, if one does not specify the "-e" option
 621    to cvs, or does not have an EDITOR environment variable.  If this
 622    is not set to an absolute path to an executable, use the shell to
 623    find where the editor actually is.  This allows sites with
 624    /usr/bin/vi or /usr/ucb/vi to work equally well (assuming that their
 625    PATH is reasonable).])
 626
 627 dnl
 628 dnl done finding an editor
 629 dnl
 630 dnl end --with-editor
 631 dnl
 632
 633
 634
 635 dnl
 636 dnl --with-hardcoded-pam-service-name
 637 dnl
 638 AC_ARG_WITH(
 639   [hardcoded-pam-service-name],
 640   AC_HELP_STRING(
 641     [--with-hardcoded-pam-service-name],
 642     [Use this to hard code a service name for PAM CVS authentication.  The
 643      special name, `program_name', will cause CVS to use whatever name it
 644      was invoked as as the service name.  (defaults to `cvs')]),,
 645     [with_hardcoded_pam_service_name=cvs])
 646
 647 if test "x$with_hardcoded_pam_service_name" = xno ||
 648    test "x$with_hardcoded_pam_service_name" = xprogram_name; then
 649   AC_DEFINE([PAM_SERVICE_NAME], [program_name],
 650     [Define to set a service name for PAM.  This must be defined.  Define to
 651      `program_name', without the quotes, to use whatever name CVS was invoked
 652       as.  Otherwise, define to a double-quoted literal string, such as
 653       `"cvs"'.])
 654 else
 655   if test x"$with_hardcoded_pam_service_name" = xyes; then
 656     with_hardcoded_pam_service_name=cvs
 657   fi
 658   AC_DEFINE_UNQUOTED([PAM_SERVICE_NAME], ["$with_hardcoded_pam_service_name"])
 659 fi
 660
 661
 662
 663 dnl
 664 dnl Find a temporary directory
 665 dnl
 666 AC_ARG_WITH(
 667   [tmpdir],
 668   AC_HELP_STRING(
 669     [--with-tmpdir],
 670     [The temporary directory CVS should use as a default
 671      (default autoselects)]))
 672
 673 AC_MSG_CHECKING([for temporary directory])
 674 if test -z "$with_tmpdir" || test yes = "$with_tmpdir"; then
 675   for with_tmpdir in /tmp /var/tmp no; do
 676     if test -d "$with_tmpdir" && test -x "$with_tmpdir" \
 677         && test -w "$with_tmpdir" && test -r "$with_tmpdir"; then
 678       break
 679     fi
 680   done
 681   if test no = "$with_tmpdir"; then
 682     AC_MSG_WARN([Failed to find usable temporary directory.  Using '/tmp'.])
 683     with_tmpdir=/tmp
 684   fi
 685   AC_MSG_RESULT([$with_tmpdir])
 686 elif ! echo "$with_tmpdir" |grep '^[[\\/]]'; then
 687   AC_MSG_RESULT([$with_tmpdir])
 688   AC_MSG_ERROR([--with-tmpdir requires an absolute path.])
 689 elif ! test -d "$with_tmpdir" || ! test -x "$with_tmpdir" \
 690         || ! test -w "$with_tmpdir" || ! test -r "$with_tmpdir"; then
 691   AC_MSG_RESULT([$with_tmpdir])
 692   AC_MSG_WARN(
 693     [User supplied temporary directory ('$with_tmpdir') does not
 694      exist or lacks sufficient permissions for read/write.])
 695 fi
 696
 697 AC_DEFINE_UNQUOTED(
 698   [TMPDIR_DFLT], ["$with_tmpdir"],
 699   [Directory used for storing temporary files, if not overridden by
 700    environment variables or the -T global option.  There should be little
 701    need to change this (-T is a better mechanism if you need to use a
 702    different directory for temporary files).])
 703
 704 dnl
 705 dnl done finding tmpdir
 706 dnl
 707
 708
 709 dnl
 710 dnl Get default umask
 711 dnl
 712
 713 AC_ARG_WITH(
 714   [umask],
 715   AC_HELP_STRING(
 716     [--with-umask],
 717     [Set the umask CVS will use by default in the repository (default 002)]))
 718
 719 if test -z "$with_umask" || test yes = "$with_umask"; then
 720   with_umask=002
 721 elif test no = "$with_umask"; then
 722   with_umask=000
 723 fi
 724
 725 AC_DEFINE_UNQUOTED(
 726   [UMASK_DFLT], [$with_umask],
 727   [The default umask to use when creating or otherwise setting file or
 728    directory permissions in the repository.  Must be a value in the
 729    range of 0 through 0777.  For example, a value of 002 allows group
 730    rwx access and world rx access; a value of 007 allows group rwx
 731    access but no world access.  This value is overridden by the value
 732    of the CVSUMASK environment variable, which is interpreted as an
 733    octal number.])
 734
 735 dnl
 736 dnl Done setting default umask
 737 dnl
 738
 739 dnl
 740 dnl Set CVS Administrator Group
 741 dnl
 742 AC_ARG_WITH(
 743   [cvs-admin-group],
 744   AC_HELP_STRING(
 745     [--with-cvs-admin-group=GROUP],
 746     [The CVS admin command is restricted to the members of this group.
 747      If this group does not exist, all users are allowed to run CVS admin.
 748      To disable the CVS admin command for all users, create an empty group
 749      by specifying the --with-cvs-admin-group= option.  To disable access
 750      control for CVS admin, run configure with the --without-cvs-admin-group
 751      option. (default 'cvsadmin')]), ,
 752   [with_cvs_admin_group=cvsadmin])
 753
 754 if test yes = "$with_cvs_admin_group"; then
 755   with_cvs_admin_group=cvsadmin
 756 fi
 757 if test no != "$with_cvs_admin_group"; then
 758   dnl FIXME We should warn if the group doesn't exist
 759   AC_DEFINE_UNQUOTED(
 760     [CVS_ADMIN_GROUP], ["$with_cvs_admin_group"],
 761     [The CVS admin command is restricted to the members of the group
 762      CVS_ADMIN_GROUP.  If this group does not exist, all users are
 763      allowed to run CVS admin.  To disable the CVS admin command for
 764      all users, create an empty CVS_ADMIN_GROUP by running configure
 765      with the --with-cvs-admin-group= option.  To disable access control
 766      for CVS admin, run configure with the --without-cvs-admin-group
 767      option in order to comment out the define below.])
 768 fi
 769
 770 dnl
 771 dnl Done setting CVS Administrator Group
 772 dnl
 773
 774 dnl
 775 dnl Set the NDBM library to use.
 776 dnl
 777 dnl XXX - FIXME - FIXME - FIXME - XXX
 778 dnl
 779 dnl This is very bad.  It should really autodetect an appropriate NDBM library
 780 dnl and, if it doesn't find one, decide to use MY_NDBM.  I'm am defining
 781 dnl this here since this is no worse than it worked when it was in options.h
 782 dnl and I am cleaning out options.h so that the Windows version of CVS will
 783 dnl compile properly for the next release.
 784 dnl
 785 dnl That's why this option is in the --with-* section rather than the
 786 dnl --enable-* section.
 787 dnl
 788 dnl XXX - FIXME - FIXME - FIXME - XXX
 789 dnl
 790 AC_ARG_ENABLE(
 791   [cvs-ndbm],
 792   AC_HELP_STRING(
 793     [--enable-cvs-ndbm],
 794     [Use the NDBM library distributed with CVS rather than attempting to use
 795      a system NDBM library.  Disabling this may not work.  (default)]), ,
 796   [enable_cvs_ndbm=yes])
 797 if test no != "$enable_cvs_ndbm"; then
 798   AC_DEFINE(
 799     [MY_NDBM], [1],
 800     [By default, CVS stores its modules and other such items in flat
 801      text files (MY_NDBM enables this).  Turning off MY_NDBM causes CVS
 802      to look for a system-supplied ndbm database library and use it
 803      instead.  That may speed things up, but the default setting
 804      generally works fine too.])
 805 fi
 806
 807 dnl
 808 dnl Done selecting NDBM library.
 809 dnl
 810
 811
 812
 813 dnl
 814 dnl end --with-*
 815 dnl
 816
 817
 818 dnl
 819 dnl begin --enables
 820 dnl
 821
 822
 823 dnl
 824 dnl begin --enable-client
 825 dnl
 826
 827 # Check for options requesting client and server feature. If none are
 828 # given and we have connect(), we want the full client & server arrangement.
 829 AC_ARG_ENABLE(
 830   [client],
 831   AC_HELP_STRING(
 832     [--enable-client],
 833     [Include code for running as a remote client (default)]), ,
 834   [enable_client=$ac_cv_search_connect])
 835 if test no != "$enable_client"; then
 836   AC_DEFINE(
 837     [CLIENT_SUPPORT], [1],
 838     [Define if you want CVS to be able to be a remote repository client.])
 839 fi
 840
 841 dnl
 842 dnl end --enable-client
 843 dnl
 844
 845
 846 dnl
 847 dnl begin --enable-password-authenticated-client
 848 dnl
 849 AC_ARG_ENABLE(
 850   [password-authenticated-client],
 851   AC_HELP_STRING(
 852     [--enable-password-authenticated-client],
 853     [Enable pserver as a remote access method in the CVS client
 854      (default)]), ,
 855   [enable_password_authenticated_client=$enable_client])
 856
 857 if test xno != "x$enable_password_authenticated_client"; then
 858   if test xno != "x$enable_client"; then
 859     AC_DEFINE(
 860       [AUTH_CLIENT_SUPPORT], [1],
 861       [Enable AUTH_CLIENT_SUPPORT to enable pserver as a remote access
 862        method in the CVS client (default)])
 863   else
 864     AC_MSG_WARN(
 865       [--enable-password-authenticated-client is meaningless with
 866        the CVS client disabled (--disable-client)])
 867   fi
 868 fi
 869
 870 dnl
 871 dnl begin --enable-password-authenticated-client
 872 dnl
 873
 874
 875 dnl
 876 dnl begin --enable-server
 877 dnl
 878
 879 dnl
 880 dnl Give the confiscator control over whether the server code is compiled
 881 dnl
 882 AC_ARG_ENABLE(
 883   [server],
 884   AC_HELP_STRING(
 885     [--enable-server],
 886     [Include code for running as a server (default)]), ,
 887   [enable_server=$ac_cv_search_connect])
 888
 889 if test no != "$enable_server"; then
 890   AC_DEFINE(
 891     [SERVER_SUPPORT], [1],
 892     [Define if you want CVS to be able to serve repositories to remote
 893      clients.])
 894
 895   dnl
 896   dnl The auth server needs to be able to check passwords against passwd
 897   dnl file entries, so we only #define AUTH_SERVER_SUPPORT if we can
 898   dnl find the crypt function.
 899   dnl
 900   AC_SEARCH_LIBS(
 901     [crypt], [crypt],
 902     [AC_DEFINE(
 903        [HAVE_CRYPT], [1],
 904        [Define if you have the crypt function.])
 905      AC_DEFINE(
 906        [AUTH_SERVER_SUPPORT], [1],
 907        [Define if you want to use the password authenticated server.])dnl
 908   ])dnl AC_SEARCH_LIBS
 909
 910   dnl
 911   dnl Allow the configurer to enable server flowcontrol.  Read the help
 912   dnl strings below for a full explanation.
 913   dnl
 914   AC_ARG_ENABLE(
 915     [server-flow-control],
 916     AC_HELP_STRING(
 917       [--enable-server-flow-control],
 918       [If you are working with a large remote repository and a 'cvs
 919        checkout' is swamping your network and memory, define these to
 920        enable flow control.  You may optionally pass a low water mark
 921        in bytes and a high water mark in bytes, separated by commas.
 922        (default is enabled 1M,2M)]),
 923     [if test yes = $enable_server_flow_control; then
 924        enable_server_flow_control=1M,2M
 925      fi],
 926     [enable_server_flow_control=1M,2M])
 927   if test no != $enable_server_flow_control; then
 928     ccvs_lwm=`expr "$enable_server_flow_control" : '\(.*\),'`
 929     ccvs_hwm=`expr "$enable_server_flow_control" : '.*,\(.*\)'`
 930     ccvs_lwm_E=`expr "$ccvs_lwm" : '[[0-9]][[0-9]]*\(.*\)'`
 931     ccvs_lwm=`expr "$ccvs_lwm" : '\([[0-9]][[0-9]]*\)'`
 932     test "" != "$ccvs_lwm" || ccvs_lwm_E="?"
 933     case $ccvs_lwm_E in
 934         G) ccvs_lwm="$ccvs_lwm * 1024 * 1024 * 1024";;
 935         M) ccvs_lwm="$ccvs_lwm * 1024 * 1024";;
 936         k) ccvs_lwm="$ccvs_lwm * 1024";;
 937         b | '') ;;
 938         *) AC_MSG_ERROR([Can't parse argument to --enable-server-flow-control
 939                         ('$enable_server_flow_control') as <lwm>,<hwm>])
 940       esac
 941     ccvs_hwm_E=`expr "$ccvs_hwm" : '[[0-9]][[0-9]]*\(.*\)'`
 942     ccvs_hwm=`expr "$ccvs_hwm" : '\([[0-9]][[0-9]]*\).*'`
 943     test "" != "$ccvs_hwm" || ccvs_hwm_E="?"
 944     case $ccvs_hwm_E in
 945         G) ccvs_hwm="$ccvs_hwm * 1024 * 1024 * 1024";;
 946         M) ccvs_hwm="$ccvs_hwm * 1024 * 1024";;
 947         k) ccvs_hwm="$ccvs_hwm * 1024";;
 948         b | '') ccvs_hwm="$ccvs_hwm";;
 949         *) AC_MSG_ERROR([Can't parse argument to --enable-server-flow-control
 950                         ('$enable_server_flow_control') as <lwm>,<hwm>])
 951       esac
 952
 953     AC_DEFINE(
 954       [SERVER_FLOWCONTROL], [1],
 955       [If you are working with a large remote repository and a 'cvs
 956        checkout' is swamping your network and memory, define these to
 957        enable flow control.  You will end up with even less probability of
 958        a consistent checkout (see Concurrency in cvs.texinfo), but CVS
 959        doesn't try to guarantee that anyway.  The master server process
 960        will monitor how far it is getting behind, if it reaches the high
 961        water mark, it will signal the child process to stop generating
 962        data when convenient (ie: no locks are held, currently at the
 963        beginning of a new directory).  Once the buffer has drained
 964        sufficiently to reach the low water mark, it will be signalled to
 965        start again.])
 966     AC_DEFINE_UNQUOTED(
 967       [SERVER_LO_WATER], [($ccvs_lwm)],
 968       [The low water mark in bytes for server flow control.  Required if
 969        SERVER_FLOWCONTROL is defined, and useless otherwise.])
 970     AC_DEFINE_UNQUOTED(
 971       [SERVER_HI_WATER], [($ccvs_hwm)],
 972       [The high water mark in bytes for server flow control.  Required if
 973        SERVER_FLOWCONTROL is defined, and useless otherwise.])
 974   fi # enable_server_flow_control
 975 fi # enable_server
 976
 977 dnl
 978 dnl end --enable-server
 979 dnl
 980
 981
 982 dnl
 983 dnl begin --enable-proxy
 984 dnl
 985
 986 dnl
 987 dnl Give the confiscator control over whether the proxy server code is compiled
 988 dnl
 989 AC_ARG_ENABLE(
 990   [proxy],
 991   AC_HELP_STRING(
 992     [--enable-proxy],
 993     [Include code for running as a transparent proxy server.  Disabling this
 994      may produce a slight performance gain on some systems, at the expense of
 995      write proxy support. (default)]), ,
 996   [if test xno != "x$enable_client" && test xno != "x$enable_server"; then
 997      enable_proxy=yes
 998    else
 999      enable_proxy=no
1000    fi])
1001
1002 if test no != "$enable_proxy"; then
1003   if test xno = "x$enable_client" || test xno = "x$enable_server"; then
1004     AC_MSG_WARN(
1005       [--enable-proxy is meaningless when either the CVS client or the
1006        CVS server is disabled (--disable-client and --disable-server).])
1007   else
1008     AC_DEFINE(
1009       [PROXY_SUPPORT], [1],
1010       [Define if you want CVS to be able to serve as a transparent proxy for
1011        write operations.  Disabling this may produce a slight performance gain
1012        on some systems, at the expense of write proxy support.])
1013   fi
1014 fi
1015 dnl
1016 dnl end --enable-proxy
1017 dnl
1018
1019
1020 dnl
1021 dnl begin --enable-pam
1022 dnl
1023
1024 dnl
1025 dnl Check if PAM authentication is enabled
1026 dnl
1027 AC_ARG_ENABLE(
1028   [pam],
1029   AC_HELP_STRING(
1030     [--enable-pam],
1031     [Use to enable system authentication with PAM instead of using the
1032     simple getpwnam interface.  This allows authentication (in theory)
1033     with any PAM module, e.g. on systems with shadow passwords or via LDAP]), ,
1034   [enable_pam=no]
1035   )
1036
1037 if test yes = $enable_pam; then
1038   ac_pam_header_available=
1039
1040   AC_CHECK_HEADER([security/pam_appl.h], [
1041     AC_DEFINE([HAVE_SECURITY_PAM_APPL_H], 1, [Define to 1 if security/pam_appl.h is available])
1042     ac_pam_header_available=1])
1043
1044   if test -z "$ac_pam_header_available"; then
1045   AC_CHECK_HEADER([pam/pam_appl.h], [
1046     AC_DEFINE([HAVE_PAM_PAM_APPL_H], 1, [Define to 1 if pam/pam_appl.h is available])
1047     ac_pam_header_available=1])
1048   fi
1049
1050   if test -z "$ac_pam_header_available"; then
1051     AC_MSG_ERROR([Could not find PAM headers])
1052   else
1053     AC_DEFINE(HAVE_PAM, 1,
1054     [Define to enable system authentication with PAM instead of using the
1055     simple getpwnam interface.  This allows authentication (in theory)
1056     with any PAM module, e.g. on systems with shadow passwords or via LDAP])
1057     AC_CHECK_LIB(pam, pam_start, [LIBS="${LIBS} -lpam"],
1058       AC_MSG_ERROR([Could not find PAM libraries but the headers exist.
1059       Give the --disable-pam option to compile without PAM support (or fix
1060       your broken configuration)])
1061     )
1062   fi
1063 fi
1064
1065 dnl
1066 dnl end --enable-pam
1067 dnl
1068
1069
1070 dnl
1071 dnl begin --enable-case-sensitivity
1072 dnl
1073
1074 AC_ARG_ENABLE(
1075   [case-sensitivity],
1076   AC_HELP_STRING(
1077     [--enable-case-sensitivity],
1078     [Force CVS to expect a case sensitive file system.  Enabling this on a case
1079      insensitive system should have little effect on the server or client
1080      operation, though client users may ocassionally be suprised that the CVS
1081      server appears to be case sensitive.  Disabling this for a case sensitive
1082      server disables server support for case insensitive clients, which can
1083      confuse all users of case insensitive clients contacting the server.
1084      Disabling this for a case sensitive client will cause the client to ask
1085      servers to behave case insensitively, which could cause confusion for
1086      users, but also probably no real harm.  (default autoselects based on the
1087      case sensitivity of the file system containing the current working
1088      directory)]),
1089     [case "$enable_case_sensitivity" in
1090        yes | no | auto) ;;
1091        *)
1092           AC_MSG_ERROR([Unrecognized argument to --enable-case-sensitivity: \`$enable_case_sensitivity'.  Acceptable values are \`yes', \`no', and \`auto'.])
1093           ;;
1094      esac],
1095   [enable_case_sensitivity=auto])
1096
1097 acx_forced=' (forced)'
1098 AC_MSG_CHECKING([for a case sensitive file system])
1099 if test $enable_case_sensitivity = auto; then
1100   dnl
1101   dnl Check for a case insensitive filesystem, like Mac OS X and Windows have.
1102   dnl
1103   AC_CACHE_VAL([acx_cv_case_sensitive],
1104   [ rm -f ac_TEST_filenames_CASE_sensitive
1105     echo foo >ac_test_filenames_case_sensitive
1106     if test -f ac_TEST_filenames_CASE_sensitive; then
1107       acx_cv_case_sensitive=no
1108     else
1109       acx_cv_case_sensitive=yes
1110     fi
1111     rm ac_test_filenames_case_sensitive
1112   ])
1113   enable_case_sensitivity=$acx_cv_case_sensitive
1114   acx_forced=
1115 fi
1116 AC_MSG_RESULT([$enable_case_sensitivity$acx_forced])
1117 if test $enable_case_sensitivity = no; then
1118   AC_DEFINE([FILENAMES_CASE_INSENSITIVE], [1],
1119             [Define if this executable will be running on case insensitive
1120              file systems.  In the client case, this means that it will request
1121              that the server pretend to be case insensitive if it isn't
1122              already.])
1123   dnl Compile fncase.c (containing fncase() & fncmp()) to handle file name
1124   dnl comparisons on case insensitive filesystems.
1125   AC_LIBOBJ(fncase)
1126 fi
1127
1128 dnl
1129 dnl end --enable-case-sensitivity
1130 dnl
1131
1132
1133 dnl
1134 dnl begin --enable-encryption
1135 dnl
1136
1137 dnl
1138 dnl Use --enable-encryption to turn on encryption support, but ignore this
1139 dnl option unless either client or server is enabled.
1140 dnl
1141 AC_ARG_ENABLE(
1142   [encryption],
1143   AC_HELP_STRING(
1144     [--enable-encryption],
1145     [Enable encryption support (disabled by default)]), ,
1146   [enable_encryption=no])
1147 if test "x$enable_encryption" = xyes; then
1148   if test xno = "x$with_client" && test xno = "x$with_server"; then
1149     AC_MSG_WARN(
1150       [--enable-encryption is meaningless when neither the CVS client
1151        nor the CVS server is enabled (--disable-client and --disable-server).])
1152   else
1153     AC_DEFINE(
1154       [ENCRYPTION], [1],
1155       [Define to enable encryption support.])
1156   fi
1157 fi
1158
1159 dnl
1160 dnl end --enable-encryption
1161 dnl
1162
1163
1164 dnl
1165 dnl begin --enable-force-editor
1166 dnl
1167
1168 AC_ARG_ENABLE(
1169   [force-editor],
1170   AC_HELP_STRING(
1171     [--enable-force-editor],
1172     [When committing or importing files, you must enter a log message.
1173      Normally, you can do this either via the -m flag on the command
1174      line, the -F flag on the command line, or an editor will be started
1175      for you.  If you like to use logging templates (the rcsinfo file
1176      within the $CVSROOT/CVSROOT directory), you might want to force
1177      people to use the editor even if they specify a message with -m or
1178      -F.  --enable-force-editor will cause the -m or -F message to be
1179      appended to the temp file when the editor is started. (disabled
1180      by default)]), ,
1181   [enable_force_editor=no])
1182
1183 if test yes = "$enable_force_editor"; then
1184   AC_DEFINE(
1185     [FORCE_USE_EDITOR], [1],
1186     [When committing or importing files, you must enter a log message.
1187     Normally, you can do this either via the -m flag on the command
1188     line, the -F flag on the command line, or an editor will be started
1189     for you.  If you like to use logging templates (the rcsinfo file
1190     within the $CVSROOT/CVSROOT directory), you might want to force
1191     people to use the editor even if they specify a message with -m or
1192     -F.  Enabling FORCE_USE_EDITOR will cause the -m or -F message to be
1193     appended to the temp file when the editor is started.])
1194 fi
1195
1196 dnl
1197 dnl end --enable-force-editor
1198 dnl
1199
1200
1201 dnl
1202 dnl begin --enable-lock-compatibility
1203 dnl
1204
1205 # Check for options requesting client and server feature. If none are
1206 # given and we have connect(), we want the full client & server arrangement.
1207 AC_ARG_ENABLE(
1208   [lock-compatibility],
1209   AC_HELP_STRING(
1210     [--enable-lock-compatibility],
1211     [Include locking code which prevents versions of CVS earlier than 1.12.4
1212      directly accessing the same repositiory as this executable from ignoring
1213      this executable's promotable read locks.  If only CVS versions 1.12.4 and
1214      later will be accessing your repository directly (as a server or locally),
1215      you can safely disable this option in return for fewer disk accesses and a
1216      small speed increase.  Disabling this option when versions of CVS earlier
1217      than 1,12,4 _will_ be accessing your repository, however, is *VERY* *VERY*
1218      *VERY* dangerous and could result in data loss.  (enabled by default)]),,
1219   [enable_lock_compatibility=yes])
1220
1221 if test x$enable_lock_compatibility = xyes; then
1222   AC_DEFINE([LOCK_COMPATIBILITY], [1],
1223     [Define to include locking code which prevents versions of CVS earlier than
1224      1.12.4 directly accessing the same repositiory as this executable from
1225      ignoring this executable's promotable read locks.  If only CVS versions
1226      1.12.4 and later will be accessing your repository directly (as a server
1227      or locally), you can safely disable this option in return for fewer disk
1228      accesses and a small speed increase.  Disabling this option when versions
1229      of CVS earlier than 1,12,4 _will_ be accessing your repository, however,
1230      is *VERY* *VERY* *VERY* dangerous and could result in data loss.
1231
1232      As such, by default, CVS is compiled with this code enabled.  If you are
1233      sure you would like this code disabled, you can disable it by passing the
1234      "--disable-lock-compatibility" option to configure or by commenting out
1235      the lines below.])
1236 fi
1237
1238 dnl
1239 dnl end --enable-lock-compatibility
1240 dnl
1241
1242
1243 dnl
1244 dnl begin --enable-rootcommit
1245 dnl
1246
1247 dnl
1248 dnl I don't like this here, but I don't really like options.h, either.
1249 dnl Besides, this is causing some problems currently when compiling under
1250 dnl Windows and moving it here should avoid the issue (the wrong options.h
1251 dnl is being used).
1252 dnl
1253 dnl I don't like making this a runtime option either.  I think I just don't
1254 dnl like making it easy to get to, but putting it here goes along with the
1255 dnl Autoconf ideal.
1256 dnl
1257 AC_ARG_ENABLE(
1258   [rootcommit],
1259   AC_HELP_STRING(
1260     [--enable-rootcommit],
1261     [Allow the root user to commit files (disabled by default)]), ,
1262   [enable_rootcommit=no])
1263 if test "$enable_rootcommit" = no; then
1264   AC_DEFINE(
1265     [CVS_BADROOT], [1],
1266     [When committing a permanent change, CVS and RCS make a log entry of
1267      who committed the change.  If you are committing the change logged
1268      in as "root" (not under "su" or other root-priv giving program),
1269      CVS/RCS cannot determine who is actually making the change.
1270
1271      As such, by default, CVS prohibits changes committed by users
1272      logged in as "root".  You can disable checking by passing the
1273      "--enable-rootcommit" option to configure or by commenting out the
1274      lines below.])
1275 fi
1276
1277 dnl
1278 dnl end --enable-rootcommit
1279 dnl
1280
1281 dnl
1282 dnl begin --enable-old-info-support
1283 dnl
1284 AC_ARG_ENABLE(
1285   [old-info-support],
1286   AC_HELP_STRING(
1287     [--enable-old-info-format-support],
1288     [Enable support for the pre 1.12.1 *info scripting hook format strings.
1289      Disable this option for a smaller executable once your scripting
1290      hooks have been updated to use the new *info format strings (default).]), ,
1291   [enable_old_info_format_support=yes])
1292 if test "$enable_old_info_format_support" = yes; then
1293   AC_DEFINE(
1294     [SUPPORT_OLD_INFO_FMT_STRINGS], [1],
1295     [Enable support for the pre 1.12.1 *info scripting hook format strings.
1296      Disable this option for a smaller executable once your scripting
1297      hooks have been updated to use the new *info format strings by passing
1298      "--disable-old-info-format-support" option to configure or by commenting
1299      out the line below.])
1300 fi
1301
1302 dnl
1303 dnl end --enable-old-info-support
1304 dnl
1305
1306
1307 dnl
1308 dnl begin --enable-config-override
1309 dnl
1310
1311 AC_ARG_ENABLE(
1312   [config-override],
1313   AC_HELP_STRING(
1314     [--enable-config-override],
1315     [Set to a comma-separated list of paths to directories (designated by
1316      trailing `/') and files, specifies the path prefixes (for directories) and
1317      paths to files the CVS server commands will allow configuration to be read
1318      from.  Specify `--enable-config-override=no' to disable config file
1319      overrides completely and `--enable-config-override=/' or simply
1320      `--enable-config-override' to allow all paths.  (Defaults to
1321      `SYSCONFDIR/cvs.conf,SYSCONFDIR/cvs/')]),,
1322   [# $sysconfdir may still contain variable references.  By default, this will
1323    # be to $prefix, and $prefix won't be set to its default value until later.
1324    # Compromise without setting $prefix for the rest of the file.
1325    cvs_save_prefix=$prefix
1326    if test "X$prefix" = XNONE; then
1327      prefix=$ac_prefix_default
1328    fi
1329    eval enable_config_override=`echo $sysconfdir/cvs.conf,$sysconfdir/cvs/`
1330    prefix=$cvs_save_prefix])
1331
1332 if test x"$enable_config_override" = xyes; then
1333   enable_config_override=/
1334 fi
1335
1336 if test x"$enable_config_override" = xno; then :; else
1337   save_IFS=$IFS
1338   IFS=,
1339   arrayinit=""
1340   for path in $enable_config_override; do
1341     IFS=$save_IFS
1342     case "$path" in
1343       [[\\/$]]* | ?:[[\\/]]* )
1344         arrayinit="$arrayinit\"$path\", "
1345         ;;
1346       *)  AC_MSG_ERROR(
1347           [expected comma separated list of absolute directory
1348            names for --enable-config-override, or \`no', not:
1349            \`$enable_config_override'
1350            (\`$path' invalid.)]);;
1351     esac
1352   done
1353   arrayinit="${arrayinit}NULL"
1354
1355   AC_DEFINE_UNQUOTED(ALLOW_CONFIG_OVERRIDE, [$arrayinit],
1356     [Define this to a NULL terminated list of allowed path prefixes (for
1357      directories) and paths to files the CVS server will allow configuration to
1358      be read from when specified from the command line.])
1359 fi
1360
1361 dnl
1362 dnl end --enable-config-override
1363 dnl
1364
1365
1366
1367 dnl
1368 dnl end --enables
1369 dnl
1370
1371
1372
1373 dnl For the moment we will assume that all systems which have
1374 dnl the unixyness to run configure are unixy enough to do the
1375 dnl PreservePermissions stuff.  I have this sinking feeling that
1376 dnl things won't be that simple, before long.
1377 dnl AC_DEFINE(PRESERVE_PERMISSIONS_SUPPORT, 1,
1378 dnl [Define if this system supports chown(), link(), and friends.])
1379
1380 dnl On cygwin32, we configure like a Unix system, but we need some support
1381 dnl libraries.  We do this at the end so that the new libraries are added at
1382 dnl the end of LIBS.
1383 dnl
1384 dnl FIXME: We should be trying to meet the autoconf ideal of checking for
1385 dnl the properties of the system rather than the name of the os here.  In other
1386 dnl words, we should check the case sensitivty of the system and then for
1387 dnl the support functions we are using and which library we find them in.
1388 AC_CACHE_CHECK(for cygwin32, ccvs_cv_sys_cygwin32,
1389 [AC_TRY_COMPILE([], [return __CYGWIN32__;],
1390 ccvs_cv_sys_cygwin32=yes, ccvs_cv_sys_cygwin32=no)])
1391 if test $ccvs_cv_sys_cygwin32 = yes; then
1392   LIBS="$LIBS -ladvapi32"
1393
1394   dnl On Windows you can only change file times if you can write to
1395   dnl the file.  cygwin32 should really handle this for us, but as of
1396   dnl January 1998 it doesn't.
1397   AC_DEFINE(UTIME_EXPECTS_WRITABLE, 1,
1398 [Define if utime requires write access to the file (true on Windows,
1399 but not Unix).])
1400
1401   dnl On Windows we must use setmode to change between binary and text
1402   dnl mode.  This probably doesn't really require two macro definitions
1403   AC_DEFINE(USE_SETMODE_STDOUT, 1,
1404 [Define if setmode is required when writing binary data to stdout.])
1405   AC_DEFINE(HAVE_SETMODE, 1,
1406 [Define if the diff library should use setmode for binary files.])
1407 fi
1408
1409 dnl associate the setting of the execute bit with the individual scripts
1410 AC_CONFIG_FILES(contrib/validate_repo, [chmod +x contrib/validate_repo])
1411 AC_CONFIG_FILES(contrib/clmerge, [chmod +x contrib/clmerge])
1412 AC_CONFIG_FILES(contrib/cln_hist, [chmod +x contrib/cln_hist])
1413 dnl AC_CONFIG_FILES(contrib/commit_prep, [chmod +x contrib/commit_prep])
1414 dnl AC_CONFIG_FILES(contrib/cvs_acls, [chmod +x contrib/cvs_acls])
1415 dnl AC_CONFIG_FILES(contrib/log, [chmod +x contrib/log])
1416 dnl AC_CONFIG_FILES(contrib/log_accum, [chmod +x contrib/log_accum])
1417 dnl AC_CONFIG_FILES(contrib/mfpipe, [chmod +x contrib/mfpipe])
1418 AC_CONFIG_FILES(contrib/pvcs2rcs, [chmod +x contrib/pvcs2rcs])
1419 AC_CONFIG_FILES(contrib/rcs2log:contrib/rcs2log.sh, [chmod +x contrib/rcs2log])
1420 dnl AC_CONFIG_FILES(contrib/rcslock, [chmod +x contrib/rcslock])
1421 AC_CONFIG_FILES(contrib/sccs2rcs, [chmod +x contrib/sccs2rcs])
1422 AC_CONFIG_FILES(doc/mkman:doc/mkman.pl, [chmod +x doc/mkman])
1423
1424 dnl the bulk files
1425 AC_CONFIG_FILES([Makefile \
1426           contrib/Makefile \
1427           diff/Makefile \
1428           doc/Makefile \
1429           lib/Makefile \
1430           man/Makefile \
1431           src/Makefile])
1432
1433 dnl and we're done
1434 AC_OUTPUT
1435
1436
1437
1438 # Report the state of this version of CVS if this is from dev.
1439 m4_bmatch(m4_defn([AC_PACKAGE_VERSION]),  [[0-9]*\.[0-9]*\.[0-9]*\.[0-9]],
1440 [    cat <<EOF
1441
1442 You are about to use an unreleased version of CVS.  Be sure to
1443 read the relevant mailing lists, most importantly <info-cvs@nongnu.org>.
1444
1445 Below you will find information on the status of this version of CVS.
1446
1447
1448 EOF
1449     sed -n '/^\* Status/,$p' $srcdir/BUGS
1450 ])