config/lyxinclude.m4

   1 dnl Some useful functions for LyXs configure.in                 -*- sh -*-
   2 dnl Author: Jean-Marc Lasgouttes (Jean-Marc.Lasgouttes@inria.fr)
   3 dnl         Lars Gullik Bjønnes (larsbj@lyx.org)
   4 dnl         Allan Rae (rae@lyx.org)
   5
   6
   7 dnl Usage LYX_CHECK_VERSION   Displays version of LyX being built and
   8 dnl sets variables "lyx_devel_version" and "lyx_prerelease"
   9 AC_DEFUN([LYX_CHECK_VERSION],[
  10 echo "configuring LyX version" AC_PACKAGE_VERSION
  11 lyx_devel_version=no
  12 lyx_prerelease=no
  13 case AC_PACKAGE_VERSION in
  14   *svn*) lyx_devel_version=yes
  15          AC_DEFINE(DEVEL_VERSION, 1, [Define if you are building a development version of LyX])
  16          LYX_DATE="not released yet"
  17          echo "WARNING: This is a development version. Expect bugs.";;
  18   *pre*|*alpha*|*beta*) lyx_prerelease=yes
  19         echo "WARNING: This is a prerelease. Be careful and backup your documents.";;
  20 esac
  21 AC_SUBST(lyx_devel_version)])
  22
  23
  24 dnl Define the option to set a LyX version on installed executables and directories
  25 dnl
  26 dnl
  27 AC_DEFUN([LYX_VERSION_SUFFIX],[
  28 AC_MSG_CHECKING([for version suffix])
  29 dnl We need the literal double quotes in the rpm spec file
  30 RPM_VERSION_SUFFIX='""'
  31 AC_ARG_WITH(version-suffix,
  32   [  --with-version-suffix[=<version>]  install lyx files as lyx<version>],
  33   [if test "x$withval" = "xyes";
  34    then
  35      withval="-"AC_PACKAGE_VERSION
  36      ac_configure_args=`echo $ac_configure_args | sed "s,--with-version-suffix,--with-version-suffix=$withval,"`
  37    fi
  38    version_suffix=$withval
  39    RPM_VERSION_SUFFIX="--with-version-suffix=$withval"])
  40 AC_SUBST(RPM_VERSION_SUFFIX)
  41 AC_MSG_RESULT([$withval])
  42 ])
  43
  44
  45 dnl Usage: LYX_ERROR(message)  Displays the warning "message" and sets the
  46 dnl flag lyx_error to yes.
  47 AC_DEFUN([LYX_ERROR],[
  48 lyx_error_txt="$lyx_error_txt
  49 ** $1
  50 "
  51 lyx_error=yes])
  52
  53
  54 dnl Usage: LYX_WARNING(message)  Displays the warning "message" and sets the
  55 dnl flag lyx_warning to yes.
  56 AC_DEFUN([LYX_WARNING],[
  57 lyx_warning_txt="$lyx_warning_txt
  58 == $1
  59 "
  60 lyx_warning=yes])
  61
  62
  63 dnl Usage: LYX_LIB_ERROR(file,library)  Displays an error message indication
  64 dnl  that 'file' cannot be found because 'lib' may be uncorrectly installed.
  65 AC_DEFUN([LYX_LIB_ERROR],[
  66 LYX_ERROR([Cannot find $1. Please check that the $2 library
  67    is correctly installed on your system.])])
  68
  69
  70 dnl Usage: LYX_CHECK_ERRORS  Displays a warning message if a LYX_ERROR
  71 dnl   has occured previously.
  72 AC_DEFUN([LYX_CHECK_ERRORS],[
  73 if test x$lyx_warning = xyes; then
  74 cat <<EOF
  75 === The following minor problems have been detected by configure.
  76 === Please check the messages below before running 'make'.
  77 === (see the section 'Problems' in the INSTALL file)
  78 $lyx_warning_txt
  79 EOF
  80 fi
  81 if test x$lyx_error = xyes; then
  82 cat <<EOF
  83 **** The following problems have been detected by configure.
  84 **** Please check the messages below before running 'make'.
  85 **** (see the section 'Problems' in the INSTALL file)
  86 $lyx_error_txt
  87 $lyx_warning_txt
  88 EOF
  89 exit 1
  90 else
  91
  92 cat <<EOF
  93 Configuration of LyX was successful.
  94 Type 'make' to compile the program,
  95 and then 'make install' to install it.
  96 EOF
  97 fi])
  98
  99
 100 dnl LYX_SEARCH_PROG(VARIABLE-NAME,PROGRAMS-LIST,ACTION-IF-FOUND)
 101 dnl
 102 define(LYX_SEARCH_PROG,[dnl
 103 for ac_prog in $2 ; do
 104 # Extract the first word of "$ac_prog", so it can be a program name with args.
 105   set dummy $ac_prog ; ac_word=$[2]
 106   if test -z "[$]$1"; then
 107     IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS=":"
 108     for ac_dir in $PATH; do
 109       test -z "$ac_dir" && ac_dir=.
 110       if test -f [$ac_dir/$ac_word]; then
 111         $1="$ac_prog"
 112         break
 113       fi
 114     done
 115     IFS="$ac_save_ifs"
 116   fi
 117
 118   if test -n "[$]$1"; then
 119     ac_result=yes
 120   else
 121     ac_result=no
 122   fi
 123   ifelse($3,,,[$3])
 124   test -n "[$]$1" && break
 125 done
 126 ])dnl
 127
 128
 129 AC_DEFUN([LYX_PROG_CXX_WORKS],
 130 [rm -f conftest.C
 131 cat >conftest.C <<EOF
 132 class foo {
 133    // we require the mutable keyword
 134    mutable int bar;
 135  };
 136  // we require namespace support
 137  namespace baz {
 138    int bar;
 139  }
 140  int main() {
 141    return(0);
 142  }
 143 EOF
 144 $CXX -c $CXXFLAGS $CPPFLAGS conftest.C >&5 || CXX=
 145 rm -f conftest.C conftest.o conftest.obj || true
 146 ])
 147
 148
 149 AC_DEFUN([LYX_PROG_CXX],
 150 [AC_MSG_CHECKING([for a good enough C++ compiler])
 151 LYX_SEARCH_PROG(CXX, $CXX $CCC g++ gcc c++ CC cxx xlC cc++, [LYX_PROG_CXX_WORKS])
 152
 153 if test -z "$CXX" ; then
 154   AC_MSG_ERROR([Unable to find a good enough C++ compiler])
 155 fi
 156 AC_MSG_RESULT($CXX)
 157
 158 AC_PROG_CXX
 159
 160 ### We might want to get or shut warnings.
 161 AC_ARG_ENABLE(warnings,
 162   AC_HELP_STRING([--enable-warnings],[tell the compiler to display more warnings]),,
 163   [ if test $lyx_devel_version = yes -o $lyx_prerelease = yes && test $ac_cv_prog_gxx = yes ; then
 164         enable_warnings=yes;
 165     else
 166         enable_warnings=no;
 167     fi;])
 168 if test x$enable_warnings = xyes ; then
 169   lyx_flags="warnings $lyx_flags"
 170   AC_DEFINE(WITH_WARNINGS, 1,
 171   [Define this if you want to see the warning directives put here and
 172    there by the developpers to get attention])
 173 fi
 174
 175 ### We might want to disable debug
 176 AC_ARG_ENABLE(debug,
 177   AC_HELP_STRING([--enable-debug],[enable debug information]),,
 178   [ if test $lyx_devel_version = yes -o $lyx_prerelease = yes ; then
 179         enable_debug=yes;
 180     else
 181         enable_debug=no;
 182     fi;])
 183
 184 AC_ARG_ENABLE(stdlib-debug,
 185   AC_HELP_STRING([--enable-stdlib-debug],[enable debug mode in the standard library]),,
 186   [ if test $lyx_devel_version = yes ; then
 187       enable_stdlib_debug=yes;
 188     else
 189       enable_stdlib_debug=no;
 190     fi;])
 191
 192 AC_ARG_ENABLE(concept-checks,
 193   AC_HELP_STRING([--enable-concept-checks],[enable concept checks]),,
 194   [ if test $lyx_devel_version = yes -o $lyx_prerelease = yes ; then
 195         enable_concept_checks=yes;
 196     else
 197         enable_concept_checks=no;
 198     fi;])
 199
 200 AC_ARG_ENABLE(profiling,
 201   AC_HELP_STRING([--enable-profiling],[enable profiling]),,
 202   enable_profiling=no;)
 203
 204 ### set up optimization
 205 AC_ARG_ENABLE(optimization,
 206     AC_HELP_STRING([--enable-optimization[=value]],[enable compiler optimisation]),,
 207     enable_optimization=yes;)
 208 case $enable_optimization in
 209     yes)
 210         if test $lyx_devel_version = yes ; then
 211             lyx_opt=-O
 212         else
 213             lyx_opt=-O2
 214         fi;;
 215     no) lyx_opt=;;
 216     *) lyx_opt=${enable_optimization};;
 217 esac
 218
 219 AC_ARG_ENABLE(pch,
 220   AC_HELP_STRING([--enable-pch],[enable precompiled headers]),,
 221         enable_pch=yes;)
 222 lyx_pch_comp=no
 223
 224 # set the compiler options correctly.
 225 if test x$GXX = xyes; then
 226   dnl Useful for global version info
 227   gxx_version=`${CXX} -dumpversion`
 228   CXX_VERSION="($gxx_version)"
 229
 230   if test "$ac_test_CXXFLAGS" = set; then
 231     CXXFLAGS="$ac_save_CXXFLAGS"
 232   else
 233       CFLAGS="$lyx_opt"
 234       CXXFLAGS="$lyx_opt"
 235     if test x$enable_debug = xyes ; then
 236         CFLAGS="-g $CFLAGS"
 237         CXXFLAGS="-g $CXXFLAGS"
 238     fi
 239     if test x$enable_profiling = xyes ; then
 240         CFLAGS="-pg $CFLAGS"
 241         CXXFLAGS="-pg $CXXFLAGS"
 242         LDFLAGS="-pg $LDFLAGS"
 243     fi
 244   fi
 245   if test "$ac_env_CPPFLAGS_set" != set; then
 246     if test x$enable_warnings = xyes ; then
 247         case $gxx_version in
 248             3.1*|3.2*|3.3*)
 249                 CPPFLAGS="-W -Wall $CPPFLAGS"
 250                 ;;
 251             *)
 252                 CPPFLAGS="-Wextra -Wall $CPPFLAGS "
 253                 ;;
 254         esac
 255     fi
 256   fi
 257   case $gxx_version in
 258       3.1*)    AM_CXXFLAGS="-finline-limit=500 ";;
 259       3.2*|3.3*)    AM_CXXFLAGS="";;
 260       3.4*|4.*)
 261           AM_CXXFLAGS=""
 262           test $enable_pch = yes && lyx_pch_comp=yes
 263           ;;
 264       *)       AM_CXXFLAGS="";;
 265   esac
 266   if test x$enable_stdlib_debug = xyes ; then
 267     case $gxx_version in
 268       3.4*|4.*)
 269         lyx_flags="stdlib-debug $lyx_flags"
 270         AC_DEFINE(_GLIBCXX_DEBUG, 1, [libstdc++ debug mode])
 271         AC_DEFINE(_GLIBCXX_DEBUG_PEDANTIC, 1, [libstdc++ pedantic debug mode])
 272         ;;
 273     esac
 274   fi
 275   if test x$enable_concept_checks = xyes ; then
 276     case $gxx_version in
 277       3.3*)
 278         lyx_flags="concept-checks $lyx_flags"
 279         AC_DEFINE(_GLIBCPP_CONCEPT_CHECKS, 1, [libstdc++ concept checking])
 280         ;;
 281       3.4*|4.*)
 282         lyx_flags="concept-checks $lyx_flags"
 283         AC_DEFINE(_GLIBCXX_CONCEPT_CHECKS, 1, [libstdc++ concept checking])
 284         ;;
 285     esac
 286   fi
 287 fi
 288 test "$lyx_pch_comp" = yes && lyx_flags="pch $lyx_flags"
 289 AM_CONDITIONAL(LYX_BUILD_PCH, test "$lyx_pch_comp" = yes)
 290 ])dnl
 291
 292
 293 dnl NOT USED CURRENTLY*************************************
 294 dnl Usage: LYX_CXX_RTTI : checks whether the C++ compiler
 295 dnl   supports RTTI
 296 AC_DEFUN([LYX_CXX_RTTI],[
 297 ### Check whether the compiler supports runtime type information
 298 AC_CACHE_CHECK(whether the C++ compiler supports RTTI,lyx_cv_rtti,
 299  [AC_TRY_RUN([
 300 class rtti {
 301 public:
 302    virtual int tag() { return 0; }
 303 };
 304 class derived1 : public rtti {
 305 public:
 306     int tag() { return 1; }
 307 };
 308 class derived2 : public rtti {
 309 public:
 310     int tag() { return 2; }
 311 };
 312 int main() {
 313     derived1 * foo1 = new derived1();
 314     derived2 * foo2 = new derived2();
 315     rtti * bar = foo1;
 316     derived1 * bar1 = dynamic_cast<derived1 *>(bar);
 317     if (bar1 == 0)
 318         exit(1);
 319     bar = foo2;
 320     bar1 = dynamic_cast<derived1 *>(bar);
 321     if (bar1 != 0)
 322         exit(1);
 323     return 0;
 324 }
 325 ],lyx_cv_rtti=yes,lyx_cv_rtti=no,lyx_cv_rtti=no)
 326 ])
 327 if test x$lyx_cv_rtti = xyes ; then
 328   AC_DEFINE(HAVE_RTTI, 1,
 329    [Define to 1 if your compiler supports runtime type information])
 330 fi])
 331
 332
 333 dnl Usage: LYX_CXX_EXPLICIT : checks whether the C++ compiler
 334 dnl   understands the "explicit" directive.
 335 AC_DEFUN([LYX_CXX_EXPLICIT],[
 336 ### Check whether the compiler understands the keyword `explicit'
 337 AC_CACHE_CHECK(whether the C++ compiler understands explicit,lyx_cv_explicit,
 338  [AC_TRY_COMPILE([
 339 class Expl {
 340 public:
 341         explicit Expl() {}
 342 };],,lyx_cv_explicit=yes,lyx_cv_explicit=no)
 343 ])
 344 if test $lyx_cv_explicit = no ; then
 345   AC_DEFINE(explicit,[ ],
 346    [Define to nothing if your compiler does not understand the
 347    'explicit' directive])
 348 fi])
 349
 350
 351 dnl NOT USED CURRENTLY*************************************
 352 dnl Usage: LYX_CXX_STL_STACK : checks whether the C++ compiler
 353 dnl   has a working stl stack template
 354 AC_DEFUN([LYX_CXX_STL_STACK],[
 355 AC_CACHE_CHECK(for broken STL stack template,lyx_cv_broken_stack,
 356  [AC_TRY_COMPILE([
 357 #include <stack>
 358 using std::stack;
 359 ],[
 360     stack<int> stakk;
 361     stakk.push(0);
 362 ],lyx_cv_broken_stack=no,lyx_cv_broken_stack=yes)
 363 ])
 364 if test $lyx_cv_broken_stack = yes ; then
 365   AC_DEFINE(BROKEN_STL_STACK, 1,
 366    [Define if you have the STL from libg++ 2.7.x, where stack<> is not defined
 367    correctly])
 368 fi])
 369
 370
 371 dnl Usage: LYX_STD_COUNT : checks wherer the C++ library have a conforming
 372 dnl    count template, if not the old HP version is assumed.
 373 AC_DEFUN([LYX_STD_COUNT],[
 374 AC_CACHE_CHECK(for conforming std::count,lyx_cv_std_count,
 375  [AC_TRY_COMPILE([
 376 #include <algorithm>
 377 using std::count;
 378 int countChar(char * b, char * e, char const c)
 379 {
 380         return count(b, e, c);
 381 }
 382 ],[
 383     char a[] = "hello";
 384     int i = countChar(a, a + 5, 'l');
 385 ],lyx_cv_std_count=yes,lyx_cv_std_count=no)
 386 ])
 387 if test $lyx_cv_std_count = yes ; then
 388     AC_DEFINE(HAVE_STD_COUNT, 1,
 389     [Define if you have a conforming std::count template, otherwise HP version of count template is assumed.])
 390 fi])
 391
 392
 393 dnl Usage: LYX_CXX_STL_MODERN_STREAMS : checks whether the C++ compiler
 394 dnl   supports modern STL streams
 395 AC_DEFUN([LYX_CXX_STL_MODERN_STREAMS],[
 396 AC_CACHE_CHECK(for modern STL streams,lyx_cv_modern_streams,
 397  [AC_TRY_COMPILE([
 398 #include <iostream>
 399 ],[
 400  std::streambuf * test = std::cerr.rdbuf();
 401  test->pubsync();
 402 ],lyx_cv_modern_streams=yes,lyx_cv_modern_streams=no)
 403 ])
 404 if test $lyx_cv_modern_streams = yes ; then
 405   AC_DEFINE(MODERN_STL_STREAMS, 1,
 406    [Define if you have modern standard-compliant STL streams])
 407 fi])
 408
 409
 410 dnl Usage: LYX_USE_INCLUDED_BOOST : select if the included boost should
 411 dnl        be used.
 412 AC_DEFUN([LYX_USE_INCLUDED_BOOST],[
 413         AC_ARG_WITH(included-boost,
 414             [  --with-included-boost  use the boost lib supplied with LyX],
 415             [lyx_cv_with_included_boost=$withval
 416                 AC_MSG_RESULT([$with_included_boost])],
 417             [lyx_cv_with_included_boost=yes])
 418         AM_CONDITIONAL(USE_INCLUDED_BOOST, test x$lyx_cv_with_included_boost = xyes)
 419 ])
 420
 421
 422 dnl NOT USED CURRENTLY*************************************
 423 dnl LYX_CXX_PARTIAL
 424 AC_DEFUN([LYX_CXX_PARTIAL], [
 425     AC_REQUIRE([AC_PROG_CXX])
 426     AC_CACHE_CHECK([if C++ compiler supports partial specialization],
 427         [lyx_cv_cxx_partial_specialization],
 428         [AC_TRY_COMPILE(
 429             [
 430             template<class T, class K>
 431             class k {
 432             public:
 433             };
 434             template<class T> class k<void,T> { };
 435             ],[
 436             k<float, float> b;
 437             k<void,void> a;
 438             ],[
 439             lyx_cv_cxx_partial_specialization=yes
 440             ],[
 441             lyx_cv_cxx_partial_specialization=no
 442             ])
 443         ])
 444     if test x$lyx_cv_cxx_partial_specialization = xyes ; then
 445         AC_DEFINE(HAVE_PARTIAL_SPECIALIZATION, 1,
 446         [Defined if your compiler supports partial specialization.])
 447     fi
 448 ])
 449
 450
 451 dnl Usage: LYX_CXX_GLOBAL_CSTD: checks whether C library functions
 452 dnl   are already in the global namespace
 453 AC_DEFUN([LYX_CXX_GLOBAL_CSTD],[
 454     AC_CACHE_CHECK(whether C library functions are already in the global namespace,
 455     lyx_cv_cxx_global_cstd,
 456     [AC_TRY_COMPILE([
 457     #include <cctype>
 458     using std::tolower;
 459     ],[
 460     return 0;
 461     ],[lyx_cv_cxx_global_cstd=no],[lyx_cv_cxx_global_cstd=yes])])
 462     if test x$lyx_cv_cxx_global_cstd = xyes; then
 463         AC_DEFINE(CXX_GLOBAL_CSTD,1,
 464         [Define if your C++ compiler puts C library functions in the global namespace])
 465     fi
 466 ])
 467
 468
 469 dnl Usage: LYX_WITH_DIR(dir-name,desc,dir-var-name,default-value,
 470 dnl                       [default-yes-value])
 471 dnl  Adds a --with-'dir-name' option (described by 'desc') and puts the
 472 dnl  resulting directory name in 'dir-var-name'.
 473 AC_DEFUN([LYX_WITH_DIR],[
 474   AC_ARG_WITH($1,[  --with-$1        specify $2])
 475   AC_MSG_CHECKING([for $2])
 476   if test -z "$with_$3"; then
 477      AC_CACHE_VAL(lyx_cv_$3, lyx_cv_$3=$4)
 478   else
 479     test "x$with_$3" = xyes && with_$3=$5
 480     lyx_cv_$3="$with_$3"
 481   fi
 482   AC_MSG_RESULT($lyx_cv_$3)])
 483
 484
 485 dnl Usage: LYX_LOOP_DIR(value,action)
 486 dnl Executes action for values of variable `dir' in `values'. `values' can
 487 dnl use ":" as a separator.
 488 AC_DEFUN([LYX_LOOP_DIR],[
 489 IFS="${IFS=     }"; ac_save_ifs="$IFS"; IFS="${IFS}:"
 490 for dir in `eval "echo $1"`; do
 491   if test ! "$dir" = NONE; then
 492     test ! -d "$dir" && AC_MSG_ERROR([\"$dir\" is not a directory])
 493     $2
 494   fi
 495 done
 496 IFS=$ac_save_ifs
 497 ])
 498
 499
 500 dnl Usage: LYX_ADD_LIB_DIR(var-name,dir) Adds a -L directive to variable
 501 dnl var-name.
 502 AC_DEFUN([LYX_ADD_LIB_DIR],[
 503 $1="${$1} -L$2"
 504 if test "`(uname) 2>/dev/null`" = SunOS &&
 505     uname -r | grep '^5' >/dev/null; then
 506   if test $ac_cv_prog_gxx = yes ; then
 507     $1="${$1} -Wl[,]-R$2"
 508   else
 509     $1="${$1} -R$2"
 510   fi
 511 fi])
 512
 513
 514 dnl Usage: LYX_ADD_INC_DIR(var-name,dir) Adds a -I directive to variable
 515 dnl var-name.
 516 AC_DEFUN([LYX_ADD_INC_DIR],[$1="${$1} -I$2 "])
 517
 518 ### Check for a headers existence and location iff it exists
 519 ## This is supposed to be a generalised version of LYX_STL_STRING_FWD
 520 ## It almost works.  I've tried a few variations but they give errors
 521 ## of one sort or other: bad substitution or file not found etc.  The
 522 ## actual header _is_ found though and the cache variable is set however
 523 ## the reported setting (on screen) is equal to $ac_safe for some unknown
 524 ## reason.
 525 ## Additionally, autoheader can't figure out what to use as the name in
 526 ## the config.h.in file so we need to write our own entries there -- one for
 527 ## each header in the form PATH_HEADER_NAME_H
 528 ##
 529 AC_DEFUN([LYX_PATH_HEADER],
 530 [ AC_CHECK_HEADER($1,[
 531   ac_tr_safe=PATH_`echo $ac_safe | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
 532 ### the only remaining problem is getting the second parameter to this
 533 ### AC_CACHE_CACHE to print correctly. Currently it just results in value
 534 ### of $ac_safe being printed.
 535   AC_CACHE_CHECK([path to $1],[lyx_cv_path2_$ac_safe],
 536   [ cat > conftest.$ac_ext <<EOF
 537 #line __oline__ "configure"
 538 #include "confdefs.h"
 539
 540 #include <$1>
 541 EOF
 542 lyx_path_header_path=`(eval "$ac_cpp conftest.$ac_ext") 2>&5 | \
 543   grep $1  2>/dev/null | \
 544   sed -e 's/.*\(".*$1"\).*/\1/' -e "1q"`
 545 eval "lyx_cv_path2_${ac_safe}=\$lyx_path_header_path"
 546 rm -f conftest*])
 547   AC_DEFINE_UNQUOTED($ac_tr_safe, $lyx_path_header_path, [dummy])])
 548 ])
 549 ### end of LYX_PATH_HEADER
 550
 551 ### Check which frontends we want to use.
 552 ###
 553 AC_DEFUN([LYX_USE_FRONTENDS],
 554 [AC_MSG_CHECKING([what frontend should be used for the GUI])
 555 AC_ARG_WITH(frontend,
 556   [  --with-frontend=THIS    Use THIS frontend as main GUI:
 557                             Possible values: qt4],
 558   [FRONTENDS="$withval"],[FRONTENDS="qt4"])
 559 if test "x$FRONTENDS" = x ; then
 560   AC_MSG_RESULT(none)
 561   AC_ERROR("Please select a frontend using --with-frontend")
 562 fi
 563 AC_MSG_RESULT($FRONTENDS)
 564 AC_SUBST(FRONTENDS)
 565 AC_SUBST(FRONTENDS_SUBDIRS)
 566 AC_SUBST(FRONTENDS_PROGS)
 567 ])
 568
 569
 570 ## Check what kind of packaging should be used at install time.
 571 ## The default is autodetected.
 572 AC_DEFUN([LYX_USE_PACKAGING],
 573 [AC_MSG_CHECKING([what packaging should be used])
 574 AC_ARG_WITH(packaging,
 575   [  --with-packaging=THIS   Use THIS packaging for installation:
 576                             Possible values: posix, windows, macosx],
 577   [lyx_use_packaging="$withval"], [
 578   case $host in
 579     *-apple-darwin*) lyx_use_packaging=macosx ;;
 580      *-pc-mingw32*) lyx_use_packaging=windows;;
 581                   *) lyx_use_packaging=posix;;
 582   esac])
 583 AC_MSG_RESULT($lyx_use_packaging)
 584 case $lyx_use_packaging in
 585    macosx) AC_DEFINE(USE_MACOSX_PACKAGING, 1, [Define to 1 if LyX should use a MacOS X application bundle file layout])
 586            PACKAGE=LyX${version_suffix}
 587            default_prefix="/Applications/${PACKAGE}.app"
 588            bindir='${prefix}/Contents/MacOS'
 589            libdir='${prefix}/Contents/Resources'
 590            datadir='${prefix}/Contents/Resources'
 591            pkgdatadir='${datadir}'
 592            mandir='${datadir}/man' ;;
 593   windows) AC_DEFINE(USE_WINDOWS_PACKAGING, 1, [Define to 1 if LyX should use a Windows-style file layout])
 594            PACKAGE=LyX${version_suffix}
 595            default_prefix="C:/Program Files/${PACKAGE}"
 596            bindir='${prefix}/bin'
 597            libdir='${prefix}/Resources'
 598            datadir='${prefix}/Resources'
 599            pkgdatadir='${datadir}'
 600            mandir='${prefix}/Resources/man' ;;
 601     posix) AC_DEFINE(USE_POSIX_PACKAGING, 1, [Define to 1 if LyX should use a POSIX-style file layout])
 602            PACKAGE=lyx${version_suffix}
 603            program_suffix=$version_suffix
 604            pkgdatadir='${datadir}/${PACKAGE}'
 605            default_prefix=$ac_default_prefix ;;
 606     *) LYX_ERROR([Unknown packaging type $lyx_use_packaging]) ;;
 607 esac
 608 AC_SUBST(pkgdatadir)
 609 AC_SUBST(program_suffix)
 610 ])
 611
 612
 613 ## ------------------------------------------------------------------------
 614 ## Find a file (or one of more files in a list of dirs)
 615 ## ------------------------------------------------------------------------
 616 ##
 617 AC_DEFUN([AC_FIND_FILE],
 618 [
 619 $3=NO
 620 for i in $2;
 621 do
 622   for j in $1;
 623   do
 624     if test -r "$i/$j"; then
 625       $3=$i
 626       break 2
 627     fi
 628   done
 629 done
 630 ])
 631
 632 dnl just a wrapper to clean up configure.in
 633 AC_DEFUN([LYX_PROG_LIBTOOL],
 634 [
 635 AC_REQUIRE([AC_ENABLE_SHARED])
 636 AC_REQUIRE([AC_ENABLE_STATIC])
 637 dnl libtool is only for C, so I must force him
 638 dnl to find the correct flags for C++
 639 ac_save_cc=$CC
 640 ac_save_cflags="$CFLAGS"
 641 CC=$CXX
 642 CFLAGS="$CXXFLAGS"
 643 AC_PROG_LIBTOOL dnl for libraries
 644 CC=$ac_save_cc
 645 CFLAGS="$ac_save_cflags"
 646 ])
 647
 648
 649 ## ------------------------------------------------------------------------
 650 ## Check whether mkdir() is mkdir or _mkdir, and whether it takes
 651 ## one or two arguments.
 652 ##
 653 ## http://ac-archive.sourceforge.net/C_Support/ac_func_mkdir.html
 654 ## ------------------------------------------------------------------------
 655 ##
 656 AC_DEFUN([AC_FUNC_MKDIR],
 657 [AC_CHECK_FUNCS([mkdir _mkdir])
 658 AC_CACHE_CHECK([whether mkdir takes one argument],
 659                [ac_cv_mkdir_takes_one_arg],
 660 [AC_TRY_COMPILE([
 661 #include <sys/stat.h>
 662 #if HAVE_UNISTD_H
 663 #  include <unistd.h>
 664 #endif
 665 ], [mkdir (".");],
 666 [ac_cv_mkdir_takes_one_arg=yes], [ac_cv_mkdir_takes_one_arg=no])])
 667 if test x"$ac_cv_mkdir_takes_one_arg" = xyes; then
 668   AC_DEFINE([MKDIR_TAKES_ONE_ARG], 1,
 669             [Define if mkdir takes only one argument.])
 670 fi
 671 ])
 672
 673
 674 dnl Set VAR to the canonically resolved absolute equivalent of PATHNAME,
 675 dnl (which may be a relative path, and need not refer to any existing
 676 dnl entity).
 677
 678 dnl On Win32-MSYS build hosts, the returned path is resolved to its true
 679 dnl native Win32 path name, (but with slashes, not backslashes).
 680
 681 dnl On any other system, it is simply the result which would be obtained
 682 dnl if PATHNAME represented an existing directory, and the pwd command was
 683 dnl executed in that directory.
 684 AC_DEFUN([MSYS_AC_CANONICAL_PATH],
 685 [ac_dir="$2"
 686  ( exec 2>/dev/null; cd / && pwd -W ) | grep ':' >/dev/null &&
 687     ac_pwd_w="pwd -W" || ac_pwd_w=pwd
 688  until ac_val=`exec 2>/dev/null; cd "$ac_dir" && $ac_pwd_w`
 689  do
 690    ac_dir=`AS_DIRNAME(["$ac_dir"])`
 691  done
 692  ac_dir=`echo "$ac_dir" | sed 's?^[[./]]*??'`
 693  ac_val=`echo "$ac_val" | sed 's?/*$[]??'`
 694  $1=`echo "$2" | sed "s?^[[./]]*$ac_dir/*?$ac_val/?"'
 695    s?/*$[]??'`
 696 ])
 697
 698 dnl this is used by the macro blow to general a proper config.h.in entry
 699 m4_define([LYX_AH_CHECK_DECL],
 700 [AH_TEMPLATE(AS_TR_CPP(HAVE_DECL_$1),
 701   [Define if you have the prototype for function `$1'])])
 702
 703 dnl Check things are declared in headers to avoid errors or warnings.
 704 dnl Called like LYX_CHECK_DECL(function, header1 header2...)
 705 dnl Defines HAVE_DECL_{FUNCTION}
 706 AC_DEFUN([LYX_CHECK_DECL],
 707 [LYX_AH_CHECK_DECL($1)
 708 for ac_header in $2
 709 do
 710   AC_MSG_CHECKING([if $1 is declared by header $ac_header])
 711   AC_EGREP_HEADER($1, $ac_header,
 712       [AC_MSG_RESULT(yes)
 713        AC_DEFINE_UNQUOTED(AS_TR_CPP(HAVE_DECL_$1))
 714        break],
 715       [AC_MSG_RESULT(no)])
 716 done])