Coccinelle release 1.0.0-rc12

[bpt/coccinelle.git] / configure.ac

dnl  standard initialization (we only use autoconf not automake)
AC_INIT([coccinelle], [`cat ./version`], [cocci@diku.dk], [], [http://coccinelle.lip6.fr/])
AC_SUBST([COCCI_VERSION], [$(cat ./version)])
AC_SUBST([COCCI_SRCDIR], [$(pwd)])
AC_MSG_NOTICE([configuring coccinelle $COCCI_VERSION in $COCCI_SRCDIR])

AC_CONFIG_SRCDIR([cocci.ml])    dnl  this file must be present in our src directory
AC_COCCI_CONFVERSION

dnl  reminder that this configure depends on macros generated by aclocal
AC_MSG_NOTICE([this configure program uses pkg-config m4 macros])
AC_MSG_NOTICE([this configure program uses ocaml m4 macros (see setup/ocaml.m4)])
AC_MSG_NOTICE([this configure program uses custom m4 macros (see setup/cocci.m4)])
AC_MSG_NOTICE([some fake substitutions for required but unavailable programs may be used (see setup/fake*)])


dnl
dnl  Note: the conditionals in this configure script are tricky.
dnl  The approach taken here is that many tools can be enabled/disabled
dnl  and paths can be given explicitly via commandline parameters or
dnl  environment variables.
dnl


dnl
dnl  Basic tools
dnl

AC_MSG_NOTICE([verifying basic tools])

AC_PROG_INSTALL
AC_PROG_MKDIR_P
AC_PROG_CPP
AC_PATH_PROG([TAR],[tar])
AC_PATH_PROG([PATCH],[patch])

dnl  pkg config is required
AC_COCCI_TOOL([PKG_CONFIG],[pkg-config],[$COCCI_SRCDIR/setup/fake-subst.sh pkg-config])
AS_IF([test "x$PKG_CONFIG" = xno],
[dnl
  AC_MSG_ERROR([A suitable pkg-config could not be found.])
])

dnl  ocaml compile
AC_PROG_OCAML
AC_CHECK_OCAMLVERSION([OCAMLATLEAST310],[3.10])
AC_CHECK_OCAMLVERSION([OCAMLATLEAST311],[3.11])

AS_IF([test "x$OCAMLC" = xno -o "x$OCAMLDEP" = xno -o "x$OCAMLDOC" = xno -o "x$OCAMLMKLIB" = xno],
[dnl
  AC_MSG_ERROR([You must install the OCaml compiler])
])
AS_IF([test "x$OCAMLATLEAST310" = xno],[AC_MSG_NOTICE([a more recent OCaml installation may be required])])

dnl  ocaml tools
AC_PROG_CAMLP4
AC_COCCI_TOOL([OCAMLLEX],[ocamllex],[])
AC_COCCI_TOOL([OCAMLYACC],[ocamlyacc],[])
AC_COCCI_TOOL([OCAMLFIND],[ocamlfind],[$COCCI_SRCDIR/setup/fake-subst.sh ocamlfind])

dnl  enforce ocaml tool requirements
AS_IF([test "x$OCAMLLEX" = xno],
[dnl
  AC_MSG_ERROR([the OCaml Lexer needs to be installed (the ocamllex command). It should be part of your OCaml distribution.])
])

AS_IF([test "x$OCAMLYACC" = xno],
[dnl
  AC_MSG_ERROR([The OCaml parser generated needs to be installed (the ocamlyacc command). It should be part of your OCaml distribution.])
])

AS_IF([test "x$OCAMLFIND" = xno],
[dnl
  AC_MSG_ERROR([A suitable OCaml findlib (the ocamlfind command) could not be found.])
])

dnl  these variables are substituted for in the code: this guarantees a default for them.
AC_COCCI_RUNTIME_CMD([OCAMLFIND],[ocamlfind])
AC_COCCI_RUNTIME_CMD([OCAMLC],[ocamlc])
AC_COCCI_RUNTIME_CMD([OCAMLOPT],[ocamlopt])
AC_COCCI_RUNTIME_CMD([OCAMLDEP],[ocamldep])
AC_COCCI_RUNTIME_CMD([CAMLP4],[camlp4])
AC_COCCI_RUNTIME_CMD([CAMLP4O],[camlp4o])

AC_CACHE_SAVE


dnl
dnl  Basic ocaml modules
dnl

AC_MSG_NOTICE([verifying basic ocaml modules])

dnl  default dir with the bundled ocaml packages
AC_COCCI_SET_EXTERNAL_DIR([$COCCI_SRCDIR/bundles])

dnl  set some defaults
dnl  add a line for each package that is
dnl  configured via AC_CHECK_COCCI_EXTPKG
dnl  or AC_REQ_COCCI_EXTPKG
AC_COCCI_INIT_PKG_EMPTY([sexplib])
AC_COCCI_INIT_PKG_EMPTY([menhirLib])
AC_COCCI_INIT_PKG_EMPTY([extlib])
AC_COCCI_INIT_PKG_EMPTY([dynlink])
AC_COCCI_INIT_PKG_EMPTY([pcre])
AC_COCCI_INIT_PKG_EMPTY([pycaml])
AC_COCCI_INIT_PKG_EMPTY([camlp4])

dnl  required ocaml packages
AC_MSG_NOTICE([the following OCaml packages should be provided by your ocaml installation])
AC_REQ_COCCI_STDPKG([unix])
AC_REQ_COCCI_STDPKG([bigarray])
AC_REQ_COCCI_STDPKG([num])
AC_REQ_COCCI_STDPKG([str])
AC_REQ_COCCI_STDPKG([threads])

dnl  required modules (Some are available locally too)
AC_REQ_COCCI_EXTPKG([dynlink])
AC_REQ_COCCI_EXTPKG([camlp4])
AC_REQ_COCCI_EXTPKG([sexplib])
AC_REQ_COCCI_EXTPKG([menhirLib])
AC_REQ_COCCI_EXTPKG([extlib])


AC_CACHE_SAVE


dnl
dnl  Handling of optional features
dnl

AC_MSG_NOTICE([verifying optional features])


dnl  menhir handling
dnl  variables:
dnl    with_menhir: whether or not menhir must be used
AC_COCCI_TOOL([MENHIR],[menhir],[$COCCI_SRCDIR/setup/fake-menhir.sh menhir])
AS_IF([test "x$SUBSTITUTED_MENHIR" = xyes],
[dnl
  AC_MSG_NOTICE([pregenerated parsers will be required as substitute for Menhir])
])


dnl  ocaml script handling
dnl  variables:
dnl    enable_ocaml: whether to enable ocaml scripts
AC_ARG_ENABLE([ocaml], AS_HELP_STRING([--enable-ocaml], [enable ocaml scripting (default: auto)]))
AS_IF([test "x$OCAML_PKG_dynlink" = xno],
[dnl
  AS_IF([test -z "$enable_ocaml"],
  [dnl
    AC_SUBST([enable_ocaml],[no])
    AC_MSG_NOTICE([ocaml scripting is disabled because the 'dynlink' package is not installed])
  ], [test "x$enable_ocaml" != xno],
  [dnl
    AC_MSG_ERROR([the OCaml package dynlink is required for ocaml scripting])
  ])
])

dnl  too old ocaml version, disable dynlink by default
AS_IF([test "x$OCAMLATLEAST311" = xno],
[dnl
  AC_SUBST([enable_ocaml],[no])
  AC_MSG_NOTICE([ocaml scripting has been disabled because your OCaml version may not support dynamic linking properly])
])

dnl  scripting requirement on ocamlfind
AS_IF([test -n "$SUBSTITUTED_OCAMLFIND"],
[dnl
  AS_IF([test -z "$enable_ocaml"],
  [dnl  this is perhaps a bit too strict
    AC_SUBST([enable_ocaml],[no])
    AC_MSG_NOTICE([ocaml scripting is disabled because it depends on ocamlfind])
  ], [test "x$enable_ocaml" != xno],
  [dnl
    AC_MSG_NOTICE([warning: ocamlfind is not found but may be required if ocaml scripts are used])
  ])
])

dnl  scripting requirement on camlp4
AS_IF([test "x$CAMLP4" = xno],
[dnl
  AS_IF([test -z "$enable_ocaml"],
  [dnl  this is perhaps a bit too strict
    AC_SUBST([enable_ocaml],no)
    AC_MSG_NOTICE([ocaml scripting is disabled because it depends on camlp4])
  ], [test "x$enable_ocaml" != xno],
  [dnl
    AC_MSG_NOTICE([warning: camlp4 is not found but may be required if ocaml scripts are used])
  ])
])

AS_IF([test "x$enable_ocaml" = xno],
[dnl
  AC_COCCI_INIT_PKG_EMPTY([dynlink])    dnl  prevent linking with it
  AC_SUBST(OCAMLCOCCI_MODULE,[No_prepare_ocamlcocci])
  AC_SUBST(OCAMLCOCCI_FILE,[no_prepare_ocamlcocci.ml])
],
[dnl
  AC_SUBST([enable_ocaml],[yes])
  AC_SUBST(OCAMLCOCCI_MODULE,[Yes_prepare_ocamlcocci])
  AC_SUBST(OCAMLCOCCI_FILE,[yes_prepare_ocamlcocci.ml])
])


dnl  python handling
dnl  variables:
dnl    with_python: whether to enable the python feature (and what version)
dnl    OCAML_PKG_pycaml: if "local" use local pycaml package
AC_ARG_VAR([PYTHON], [path to python when the version is determined automatically])
AC_ARG_ENABLE([python], [AS_HELP_STRING([--enable-python], [enable python scripting (yes/no) (default: auto)])])
AS_IF([test "x$enable_python" != xno],
[dnl
  dnl  an explicitly set --with-python disablees by default the global pycaml
  AS_IF([test -n "$enable_python" -a -z "$enable_pycaml"],
  [dnl  if explicit python given: 
    AC_MSG_NOTICE([skipped the selection of a global pycaml module because --enable-python is given explicitly but --enable-pycaml is not.])
    AC_SUBST([enable_pycaml],[no])
  ])

  dnl  sets "$PYVER" if python is available
  AC_COCCI_PYVER

  AS_IF([test -z "$PYVER"],
  [dnl  PYVER undetermined
    AS_IF([test "x$enable_python" = xyes],
    [dnl
      AC_MSG_ERROR([python scripting is enabled explicitly but the version of python could not be determined])
    ])
  ],
  [dnl
    PKG_CHECK_MODULES([PYTHON], [python-$PYVER],[AC_SUBST(HAVE_PYTHON,[yes])],[AC_SUBST(HAVE_PYTHON,[no])])

    AS_IF([test "x$HAVE_PYTHON" != xyes -a "x$enable_python" != xyes],
    [dnl  fallback if the above failed
      AC_MSG_NOTICE([trying the default python version as fallback])
      PKG_CHECK_MODULES([PYTHON], [python],[AC_SUBST(HAVE_PYTHON,[yes])],[AC_SUBST(HAVE_PYTHON,[no])])
    ])
  ])
])

AS_IF([test -z "$enable_python"],
[dnl
  AS_IF([test "x$HAVE_PYTHON" = xyes],
  [dnl
    AC_SUBST([enable_python],[yes])
  ],
  [dnl
    AC_SUBST([enable_python],[no])
  ])
])

AS_IF([test "x$enable_python" != xno],
[dnl
  AS_IF([test "x$HAVE_PYTHON" = xyes],
  [dnl
    AC_MSG_NOTICE([support for python scripts is enabled])
  ],
  [dnl
    AC_MSG_ERROR([the python scripts feature is enabled but the pkg-config python library is not found])
  ])

  AC_REQ_COCCI_EXTPKG([pycaml])
  AC_SUBST([PYCOCCI_MODULE], [Yes_pycocci])
  AC_SUBST([PYCOCCI_FILE],[yes_pycocci.ml])
],
[dnl
  AC_COCCI_INIT_PKG_EMPTY([pycaml])
  AC_SUBST([PYCOCCI_MODULE], [No_pycocci])
  AC_SUBST([PYCOCCI_FILE],[no_pycocci.ml])
])


dnl  pcre handling
dnl  variables:
dnl    enable_pcre: whether to enable the pcre feature
dnl    OCAML_PKG_pcre: if "local" use str package
AC_ARG_ENABLE([pcre-syntax], AS_HELP_STRING([--enable-pcre-syntax], [enable pcre regular expression syntax (default: auto)]))
AS_IF([test "x$enable_pcre_syntax" != "xno"],
[dnl
  PKG_CHECK_MODULES([PCRE], [libpcre],[AC_SUBST([HAVE_PCRE],[yes])],[AC_SUBST([HAVE_PCRE],[no])])
  AS_IF([test -z "$enable_pcre_syntax" -a "x$HAVE_PCRE" != xyes],
  [dnl
    AC_SUBST([enable_pcre_syntax],[no])
  ],
  [dnl
    AC_CHECK_COCCI_EXTPKG([pcre])  dnl  will set $enable_pcre to 'yes', 'no', or 'local'
    enable_pcre_syntax=$enable_pcre
  ])
])

AS_IF([test "x$enable_pcre_syntax" != xno],
[dnl
  AS_IF([test "x$HAVE_PCRE" = xyes],
  [dnl
    AC_MSG_NOTICE([support for pcre syntax is enabled])
  ],
  [dnl
    AC_MSG_ERROR([the pcre feature is enabled but the pkg-config libpcre library is not found])
  ])

  AC_SUBST([REGEXP_MODULE], [Regexp_pcre])
  AC_SUBST([REGEXP_FILE], [regexp_pcre.ml])
],
[dnl
  AC_COCCI_INIT_PKG_EMPTY([pcre])
  AC_SUBST([REGEXP_MODULE], [Regexp_str])
  AC_SUBST([REGEXP_FILE], [regexp_str.ml])
])


AC_CACHE_SAVE


dnl  obtain the value of $prefix
AS_IF([test "$prefix" = "NONE"],[prefix=$ac_default_prefix])


dnl
dnl  backwards compatibility
dnl

dnl  defines some variables needed by the Make infrastructure
AC_SUBST(SHAREDIR,["${prefix}/share/coccinelle"])

AS_IF([test "x$enable_python" != xno],
[dnl
  AC_SUBST(FEATURE_PYTHON,[1])
],
[dnl
  AC_SUBST(FEATURE_PYTHON,[0])
])

AS_IF([test "x$enable_ocaml" != xno],
[dnl
  AC_SUBST(FEATURE_OCAML,[1])
],
[dnl
  AC_SUBST(FEATURE_OCAML,[0])
])

dnl  dynlink stuff depending on the OCaml version and whether it is enabled
AS_IF([test "x$OCAMLATLEAST311" = xyes -a "x$enable_ocaml" = xyes],
[dnl
  AC_SUBST([DYNLINK_IS_NATIVE],[Dynlink.is_native])
],
[dnl
  AC_SUBST([DYNLINK_IS_NATIVE],[false])
])

dnl  in case of the compilation of the manual
AC_COCCI_TOOL([PDFLATEX],[pdflatex],[$COCCI_SRCDIR/setup/fake-pdflatex.sh pdflatex])


dnl
dnl  determine the default make target
dnl  if ocamlopt is availabe, the default is both
dnl  the bytecode version and the optimized version
dnl  of coccinelle.
dnl

AC_ARG_ENABLE([release], [AS_HELP_STRING([--enable-release], [build with a release configuration (yes,no, default: no)])])

AS_IF([test "x$OCAMLOPT" = xno],
[dnl
  AS_IF([test "x$enable_release" = xyes],
  [dnl
    AC_MSG_ERROR([a release build is requested, but ocamlopt is not available])
  ])

  AC_SUBST([enable_release],[no])
])

AS_IF([test "x$OCAMLVERSION" = x3.11.2 -a "x$enable_release" != xyes],
[dnl  the optimized version may not be buildable with ocaml 3.11.2 (know bug), hence disable it by default
  AC_MSG_NOTICE([the optimized version of coccinelle will not be build by default due to OCaml version $OCAMLVERSION and --enable-build-all is not given to override this decision])
  AC_SUBST([enable_release],[no])
])

AS_IF([test -z "$enable_release"],
[dnl
  AC_MSG_NOTICE([choosing the development Makefile configuration because the release configuration is not explicitly requested.])
  AC_SUBST([enable_release], [no])
])

AS_IF([test "x$enable_release" = xyes],
[dnl  include the optimized version by default
  AC_SUBST([MAKETARGET_ALL], [all-release])
], [test "x$enable_release" = xno],
[dnl  otherwise, exclude the optimized version
  AC_SUBST([MAKETARGET_ALL], [all-dev])
],
[dnl  custom target given
  AC_SUBST([MAKETARGET_ALL], ["$enable_release"])
])

dnl  which spatch will be constructed
AS_IF([test "x$enable_release" != xno],[SPATCHNAME=spatch.opt],[SPATCHNAME=spatch])


dnl
dnl  generating configuration
dnl

AC_CONFIG_FILES([Makefile.config])
AC_CONFIG_FILES([version.ml])
AC_CONFIG_FILES([commons/commands.ml])
AC_CONFIG_FILES([globals/config.ml])
AC_CONFIG_FILES([globals/regexp.ml])
AC_CONFIG_FILES([python/pycocci.ml])
AC_CONFIG_FILES([ocaml/prepare_ocamlcocci.ml])
AC_CONFIG_FILES([scripts/spatch.sh])
AC_CONFIG_FILES([docs/spatch.1])

AC_OUTPUT

AC_MSG_NOTICE([configuration completed])

cat << EOF
------------------------------------------------------------------------------
Summary

findlib:          $OCAMLFIND
menhir:           $MENHIR
menhirLib module: $OCAML_PKG_menhirLib

ocaml scripting:  $enable_ocaml
python scripting: $enable_python
pycaml module:    $enable_pycaml

pcre regexes:     $enable_pcre_syntax
pcre module:      $enable_pcre
pcre library:     $HAVE_PCRE

release config:   $enable_release

EOF

cat << EOF
------------------------------------------------------------------------------
Coccinelle can now be compiled and installed.


If you compile coccinelle again after source code changes or
configuration changes, you may need to run first:
  \$ make clean

To compile coccinelle, run:
  \$ make all

To install coccinelle, run:
  \$ make install

Then, to test coccinelle run for example:
  \$ $SPATCHNAME -sp_file demos/simple.cocci demos/simple.c -o /tmp/new_simple.c
EOF

if test "x$enable_python" != "xno"; then
cat << EOF
------------------------------------------------------------------------------
You may need to set some environment variables so that the python
libraries are found. The frontend 'spatch' sets the following variables:

  \$ export LD_LIBRARY_PATH=\$LD_LIBRARY_PATH:$prefix/lib
  \$ export PYTHONPATH=\$PYTHONPATH:$prefix/share/coccinelle/python

EOF
fi

cat << EOF
------------------------------------------------------------------------------
EOF