gecoder-with-gecode 0.7.1 → 0.8.0

data/ext/gecode-2.1.1/doxygen/reflection.hh

@@ -0,0 +1,417 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2008
+ *
+ *  Last modified:
+ *     $Date: 2008-01-31 10:36:59 +0100 (Thu, 31 Jan 2008) $ by $Author: tack $
+ *     $Revision: 6001 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining
+ *  a copy of this software and associated documentation files (the
+ *  "Software"), to deal in the Software without restriction, including
+ *  without limitation the rights to use, copy, modify, merge, publish,
+ *  distribute, sublicense, and/or sell copies of the Software, and to
+ *  permit persons to whom the Software is furnished to do so, subject to
+ *  the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be
+ *  included in all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+/**
+  \page PageReflection The Reflection API
+
+Reflection in %Gecode provides information about all the actors (propagators and branchings) and the variables in a Space. %Gecode also enables the reverse direction: creating a variable or actor in a space, given a specification. Some use cases for reflection are
+  - \b %Serialization, which creates an external, platform-independent 
+    representation of a space that can be used to recreate a copy of the 
+    original space. This facilitates the development of distributed search 
+    engines, makes it possible to store instances of constraint problems, and 
+    can be used to transfer a problem instance from one solver to another.
+
+  - \b Visualization of variable domains or the propagators in a space can 
+    help with debugging scripts or propagators. %Gecode's Gist uses reflection 
+    for visualization.
+
+  - \b Interfacing to other programming languages becomes easy, because only 
+    the generic unreflection functions have to be made available. The Qt-based 
+    JavaScript interpreter in examples/javascript.cc builds on reflection.
+
+  - \b Heuristics can be based on properties of the constraint graph, which is 
+    effectively exposed by the reflection API.
+
+This tutorial is split in two parts:
+  - \ref SecReflUsage
+  - \ref SecReflAddSupport
+
+\section SecReflUsage Using the reflection API
+
+The starting point for reflection in %Gecode is a Space. The basic work cycle is to iterate over all the actors in a space using an ActorSpecIter, collecting the variables that the actors reference in a VarMap. The iterator returns an ActorSpec for each actor, and the VarMap contains a VarSpec for each variable. All the specifications in the VarMap can be accessed using a VarMapIter.
+
+\code
+Gecode::Space* space = ...
+Gecode::Reflection::VarMap vm;
+Gecode::Reflection::VarMapIter vmi(vm);
+for (Gecode::Reflection::ActorSpecIter si(space, vm); si(); ++si) {
+  Gecode::Reflection::ActorSpec aSpec = si.actor();
+  doSomethingForAnActor(aSpec);
+  for (; vmi(); ++vmi) {
+    Gecode::Reflection::VarSpec vSpec = vmi.spec();
+    doSomethingForAVariable(vSpec);
+  }
+}
+\endcode
+
+Note that new variables are added to \c vm when the specification for an actor is accessed (using \c si.actor()). The VarMapIter therefore always iterates all those variables that were added to \c vm for the current actor.
+
+We will now go into the details of ActorSpec and VarSpec, and after that discuss the VarMap and the unreflection mechanism.
+
+\subsection SecReflUsageSpecs Accessing the specifications
+
+Specifications for actors and variables are similar. For each actor or variable, a specification contains a Symbol (a string) representing its type (accessed as \c ActorSpec::ati resp. \c VarSpec::vti), and a term representing its state (e.g. the current variable domain for variables, or the arguments of a propagator). Terms are represented as objects of the class Reflection::Arg and can be summarized by the following grammar:
+
+\verbatim
+term ::= INT | VAR | STRING
+       | [term,...,term] | [INT,...,INT]  | (term,term)
+       | sharedObject(term) | sharedReference(INT)
+\endverbatim
+
+The upper-case constructors stand for actual values; signed integers for \c INT, character pointers for \c STRING, and <em>integers for \c VAR </em>: variables are represented as indices into the VarMap.
+
+The second line shows term constructors for arrays and pairs. There is special support for integer arrays. The constructors for shared objects in the third line have a similar purpose as the \c VAR constructor: a term, e.g. an array, that is shared between several actors, is introduced using a \c sharedObject constructor, and later referenced by a \c sharedReference. The shared references are counted in the order in which the shared objects are encountered.
+
+The concrete representation of a variable's or actor's state depends on its concrete implementation. The following list will give you an idea of possible encodings:
+  - Domains of integer variables are encoded as arrays of integers, where two consecutive integers represent a range in the domain. For example, the domain \f$\{0,1,2,4,5,8\}\f$ would be represented as \c [0,2,4,5,8,8].
+  - The arguments of the distinct constraint with offsets are encoded as an array of pairs of integers and variables, like \c [(0,q0),(-1,q1),(-2,q2),(-3,q3)] for the Queens model.
+  - The DFA of an extensional constraint that uses a LayeredGraph is encoded into an array of integers, where each transition is represented by three integers, one for the input state, one for the symbol, and one for the output state. As DFAs can be shared between several propagators, they are wrapped in a \c sharedObject or \c sharedReference.
+
+\subsection SecReflUsageVarMap The VarMap
+
+Several propagators can share the same variable, and reflection makes this sharing explicit. The VarMap contains one entry per variable that is referenced by an actor, and it is filled by iterating over the actors. The specification of an actor only contains an integer reference into the VarMap that was used when the specification was created.
+
+Reflection of variables is similar to copying, as only those variables will be put into a VarMap that are reachable from the actors. As with copying, variables can be added manually. Furthermore, a VarMap can store a \em name for each variable. The Space class has a virtual function Gecode::Space::getVars, which is used to fill a VarMap with the variables that the user is interested in.
+
+The Queens example shows how to use \c getVars:
+
+\code
+class Queens : public Example {
+public:
+  virtual void
+  getVars(Gecode::Reflection::VarMap& vm, bool registerOnly) {
+    vm.putArray(this,q,"q", registerOnly);
+  }  
+};
+\endcode
+
+The parameter \c registerOnly is needed for unreflection.
+
+\subsection SecReflUsageUnref Unreflection
+
+With unreflection, %Gecode can create variables and actors in a space from a VarSpec or ActorSpec. The unreflection mechanism can be used for deserialization, or to implement an interface to %Gecode.
+
+Assuming that the actor and variable specifications were stored in vectors, the basic setup for unreflection looks like this:
+
+\code
+void unreflect(Space* home, std::vector<ActorSpec>& as, std::vector<VarSpec>& vs) {
+  Gecode::Reflection::VarMap vm;
+  Gecode::Reflection::Unreflector ur(home, vm);
+  for (std::vector<VarSpec>::iterator it=vs.begin(); it != vs.end(); ++it) {
+    ur.var(*it);   // Create variables from specifications
+  }
+  for (std::vector<ActorSpec>::iterator it=as.begin(); it != as.end(); ++it) {
+    ur.post(*it);  // Post actors from specifications
+  }
+}
+\endcode
+
+After unreflection, the VarMap contains the created variables. If the variable specifications had names for the variables, the new variables can be accessed via their names, otherwise, they can only be accessed by their index into the VarMap. The indices are consecutive integers, starting at 0, and assigned in the order in which the variables were created.
+
+The VarMap can be filled \em before you use unreflection. That way, existing variables can be mapped to the new variables via names, and the actors created by unreflection are posted on the existing variables. This is the purpose of the \c registerOnly argument of Gecode::Space::getVars. If it is \c true, only the names of the variables will be registered, but no index will be assigned for the variable in the VarMap:
+
+\code
+...
+Gecode::Reflection::VarMap vm;
+home->getVars(vm, true);   // Register variables
+Gecode::Reflection::Unreflector ur(home, vm);
+for (std::vector<VarSpec>::iterator it=vs.begin(); it != vs.end(); ++it) {
+...
+\endcode
+
+\subsection SecReflUsageGenericVars Generic variables
+
+%Gecode provides a generic variable class, Gecode::Reflection::Var. Generic variables can be obtained from any variable class that supports reflection. They provide a dynamically type-safe way of handling inhomogeneous collections of variables, for instance a \c VarArray that contains both integer and set variables.
+
+All variables can be constructed from a generic variable. At construction, a dynamic check is performed that guarantees that the generic variable is actually an instance of the variable type that is constructed. The variables in a VarMap can be accessed as generic variables:
+\code
+...
+Gecode::Space* home = ...
+Gecode::Reflection::VarMap vm;
+space->getVars(vm);
+Gecode::Reflection::Var v = vm.var(0); // Get variable at index 0
+Gecode::IntVar i(v);                   // Construct IntVar (with dynamic type check)
+\endcode
+
+\subsection SecReflUsageBranchingSpec Branching specifications
+
+A Gecode::Reflection::BranchingSpec provides a human-readable description of a Gecode::BranchingDesc. This is e.g. used by Gist, so that the user can see what actions the branchings took at each branch in the search tree.
+
+A BranchingSpec contains one ArrayArg per alternative, and each ArrayArg may only contain strings and variable references. The string concatenation of these arguments yields a human-readable description of the alternative:
+
+\code
+void printAlternatives(Gecode::Space* home) {
+  if (home->status() != SS_BRANCH) {
+    std::cout << "no alternatives left" << std::endl;
+    return;
+  }
+  const Gecode::BranchingDesc* d = space->description();
+  Gecode::Reflection::VarMap vm;
+  space->getVars(vm, false);
+  Gecode::Reflection::BranchingSpec bs = space->branchingSpec(vm,d);
+  delete d;
+  std::cout << "Alternatives:" << std::endl;
+  for (unsigned int i=0; i<bs.alternatives(); i++) {
+    std::cout << i << ": ";
+    Gecode::Reflection::ArrayArg& aa = *bs[i]->toArray();
+    for (int j=0; j<aa.size(); j++) {
+      if (aa[j]->isString()) {
+        std::cout << aa[j]->toString();
+      } else if (aa[j]->isVar()) {
+        int v = aa[j]->toVar();
+        if (vm.hasName(v))
+          std::cout << vm.name(v).toString();
+        else
+          std::cout << "_v" << v;
+      }
+    }
+    std::cout << std::endl;
+  }
+}
+\endcode
+
+\subsection SecReflUsageMemory Memory management
+
+All the reflection classes provide memory management. This means that you must not free the argument objects, they are automatically deallocated when the ActorSpec, VarSpec, or BranchingSpec is deallocated. Copying specifications is cheap, as all classes use reference counting.
+
+\subsection SecReflUsageInterfacing Interfacing to Gecode through reflection
+
+The (un-)reflection API makes interfacing to %Gecode very easy. We provide a full JavaScript interface (through TrollTech's Qt library), and it only requires 150 lines of code.
+
+An interface can benefit from reflection in three ways:
+
+  - The generic Gecode::Reflection::Var class leaves the C++ part of the 
+    interface independent of the actual variable types that are supported. 
+    Every variable type supported by %Gecode is automatically supported by the 
+    interface.
+
+  - Instead of a post function for every propagator and branching and variable 
+    creation functions for all the variable types, only the 
+    Gecode::Reflection::Unreflector has to be exported.
+
+  - All propagators and branchings that are supported by %Gecode are 
+    immediately available through the interface. When propagators are added to
+    %Gecode, no new interfacing code has to be written. If the propagators are 
+    added as additional libraries, the interface does not even have to be 
+    recompiled.
+
+Please refer to \ref PageReflectionRegistry for more information on the propagators that are available through unreflection.
+
+\section SecReflAddSupport Adding reflection support to actors and variables
+
+When the ActorSpecIter iterates over the actors of a space, each actor has to deliver its specification through the virtual function Actor::spec. When this function is called, the actor creates an ActorSpec with its <em>actor type identifier</em> (ati) and fills it with a representation of its arguments, encoded into objects of type Reflection::Arg. The specification for the views is delegated to the views or view arrays that the actor uses.
+
+We now go through the steps that are needed for reflection of actors and variables.
+
+\subsection SecReflAddSupportProp Propagators
+
+Propagators implement the virtual function Gecode::Reflection::Actor::spec. It creates an ActorSpec with a proper actor type identifier and arguments. The following example provides reflection for a propagator with an IntView \c x, a ViewArray of IntViews \c y, and an integer constant \c c:
+
+\code
+class MyPropagator : public Gecode::Propagator {
+protected:
+  IntView            x;
+  ViewArray<IntView> y;
+  int                c;
+public:
+  // Return specification for reflection
+  virtual Gecode::Reflection::ActorSpec
+  spec(const Space* home, Gecode::Reflection::VarMap& m) const {
+    Gecode::Support::Symbol ati("MyPropagator");
+    Gecode::Reflection::ActorSpec spec(ati);
+    spec << x.spec(home, m);
+    spec << y.spec(home, m);
+    spec << c;
+    return spec;
+  }
+};
+\endcode
+
+For a generic propagator, the types of its views must be part of the actor type identifier. All views have a static function \c type to enable this, and the reflection library contains name mangling functions:
+
+\code
+template <class View0, class View1>
+class MyGenericPropagator : public Gecode::Propagator {
+protected:
+  View0            x;
+  ViewArray<View1> y;
+  int              c;
+public:
+  // Return specification for reflection
+  virtual Gecode::Reflection::ActorSpec
+  spec(const Space* home, Gecode::Reflection::VarMap& m) const {
+    Gecode::Support::Symbol ati =
+      Gecode::Reflection::mangle<View0,View1>("MyGenericPropagator");
+    Gecode::Reflection::ActorSpec spec(ati);
+    spec << x.spec(home, m);
+    spec << y.spec(home, m);
+    spec << c;
+    return spec;
+  }
+};
+\endcode
+
+For unreflection, the actor must be \em registered. %Gecode contains a global Gecode::Reflection::registry, mapping actor type identifiers to post functions.
+
+In order to register a propagator, the propagator class has to provide two static functions, \c ati and \c post. Then the Gecode::Reflection::ActorRegistrar class can be used, or more conveniently, the \c GECODE_REGISTER macros. Here is a complete example:
+
+\code
+template <class View0, class View1>
+class MyGenericPropagator : public Gecode::Propagator {
+protected:
+  View0            x;
+  ViewArray<View1> y;
+  int              c;
+public:
+  // Constructor
+  MyGenericPropagator(Space*,View0,ViewArray<View1>&,int);
+  // Actor type identifier
+  static Gecode::Symbol ati(void) const {
+    return Gecode::Reflection::mangle<View0,View1>("MyGenericPropagator");
+  }
+  // Return specification for reflection
+  virtual Gecode::Reflection::ActorSpec
+  spec(const Space* home, Gecode::Reflection::VarMap& m) const {
+    Gecode::Reflection::ActorSpec spec(ati());
+    spec << x.spec(home, m);
+    spec << y.spec(home, m);
+    spec << c;
+    return spec;
+  }
+  // Posting the propagator from a specification
+  static void
+  post(Space* home, Reflection::VarMap& vars, const Reflection::ActorSpec& spec) {
+    spec.checkArity(3);
+    View0 x(home, vars, spec[0]);
+    ViewArray<View1> y(home, vars, spec[1]);
+    int c = spec[2]->toInt();
+    (void) new (home) MyGenericPropagator<View0,View1>(home,x,y,c);
+  }
+};
+\endcode
+
+Using the static function \c ati for both registration and reflection (in \c spec) makes sure that the type identifiers are the same.
+
+The function \c checkArity makes sure that \c spec contains exactly 3 arguments and throws an exception otherwise. The accessor functions (like Gecode::Reflection::Arg::toInt) also check that the argument type matches. The reflection constructors for views and view arrays use these accesor functions, so an incorrect view type will be detected.
+
+Now we can register the propagator. Note that we have to register each \em instance separately:
+
+\code
+namespace {
+  GECODE_REGISTER2(MyGenericPropagator<IntView,IntView>);
+  GECODE_REGISTER2(MyGenericPropagator<IntView,OffsetView>);
+}
+\endcode
+
+\subsection SecReflAddSupportBranching Branchings
+
+Actor reflection for branchings is, in principle, the same as for propagators. However, if you subclass Gecode::ViewValBranching, all you have to provide are \c type functions in your view and value selection classes. See
+Gecode::Int::Branch::ByNone<View>::type and Gecode::Int::Branch::ValMin<View>::type for examples.
+
+Branchings provide a second type of reflection. Given a Gecode::BranchingDesc, they can deliver a Gecode::Reflection::BranchingSpec. For this to work, you have to implement the virtual function Gecode::Branching::branchingSpec.
+
+Please see the Gecode::ViewValBranching and the corresponding value selectors (Gecode::Int::Branch::ValMin<View>::branchingSpec) for examples.
+
+\subsection SecReflAddSupportVar Variables and Views
+
+Reflection for variables and views is similar to reflection for actors. Each view class provides two functions:
+\code
+class MyView {
+public:
+  Reflection::Arg* spec(const Space* home, Reflection::VarMap& m) const;
+  static Support::Symbol type(void);
+};
+\endcode
+
+Views delegate the reflection of the underlying variable to the variable implementation and just add their own arguments. For a concrete example, see Gecode::Int::IntVarImp::spec and Gecode::Int::OffsetView::spec.
+
+The \c spec function of a view returns a <em>reference to a variable</em>. As a side effect, the actual VarSpec is entered into the VarMap.
+
+Views and variables also have constructors for unreflection. Again, the Views delegate unreflection of the underlying variable. See Gecode::IntVar::IntVar(const Gecode::Reflection::Var&) and Gecode::Int::IntView::IntView(Space*, const Reflection::VarMap&, Reflection::Arg*).
+
+For unreflection, the registry contains functions for creating, constraining, updating, and printing variable implementations. If a variable implementation implements the two functions \c create and \c constrain, it can be registered using a Gecode::Reflection::VarImpRegistrar. The generic variables (Gecode::Reflection::Var) use the registry to perform updates. For an example of how to implement the necessary functionality, see Gecode::Int::IntVarImp.
+
+*/
+
+/**
+  \page PageReflectionRegistry The Reflection Registry
+
+The registry maps an actor type identifier (ati) to a function that posts the corresponding constraint. The type of these post functions is defined in the registry as
+\code
+class Registry {
+public:
+    /// The type of constraint posting functions
+    typedef void (*poster) (Gecode::Space*,
+                            Gecode::Reflection::VarMap&,
+                            const Gecode::Reflection::ActorSpec&);
+};
+\endcode
+
+There are two kinds of post functions in the registry:
+  - One function per actor instance. These functions correspond directly to individual propagators and branchings. For instance, the registry contains a function for the ati \c Int::Distinct::Dom<Int::OffsetView>. Each propagator registers one post function per instance. The registry is populated with these post functions as soon as the library in which the propagator is defined is loaded.
+  
+  - One function per constraint post function (the functions found in gecode/int.hh or gecode/set.hh, for example). The functions are useful for interfacing to Gecode, as they provide a higher-level interface to the propagators. For example, the registry contains a post function for the ati \c Gecode::rel. Depending on the arguments given in the ActorSpec, this function can post any of the \c rel constraints found in gecode/int.hh and gecode/set.hh. All high-level post functions are registered when the serialization library is loaded, which can be triggered by callling Gecode::Serialization::initRegistry.
+
+\section SecRegistryArgMapping Mapping arguments to ActorSpecs
+
+The high-level post functions are generated automatically from the post functions in gecode/int.hh and gecode/set.hh. The argument types are mapped automatically to Gecode::Reflection::Arg terms.
+
+<TABLE>
+<TR>
+  <TH>C++ argument type</TH>
+  <TH>Reflection::Arg type</TH>
+  <TH>Comment</TH>
+</TR>
+<TR><TD>\c int</TD><TD>\c INT</TD></TR>
+<TR><TD><TT>unsigned int</TT></TD><TD>\c INT</TD></TR>
+<TR><TD>\c bool</TD><TD>\c INT</TD></TR>
+<TR><TD>\c IntVar</TD><TD>\c VAR</TD></TR>
+<TR><TD>\c BoolVar</TD><TD>\c VAR</TD></TR>
+<TR><TD>\c SetVar</TD><TD>\c VAR</TD></TR>
+<TR><TD>\c IntVarArgs</TD><TD><TT>[VAR,...,VAR]</TT></TD></TR>
+<TR><TD>\c BoolVarArgs</TD><TD><TT> [VAR,...,VAR]</TT></TD></TR>
+<TR><TD>\c SetVarArgs</TD><TD><TT>[VAR,...,VAR]</TT></TD></TR>
+<TR><TD>\c IntArgs</TD><TD><TT>[INT,...,INT]</TT></TD></TR>
+<TR><TD>\c IntSet</TD><TD><TT>[INT,...,INT]</TT></TD>
+<TD>Two consecutive integers are interpreted as a range</TD></TR>
+<TR><TD>\c IntSetArgs</TD><TD><TT>[[INT,...,INT],...,[INT,...,INT]]</TT></TD>
+<TD>Same representation as for IntSet</TD></TR>
+<TR><TD>Any enumeration</TD><TD><TT>STRING</TT></TD>
+<TD>The string representation of the enum value, e.g. \c "IRT_EQ"</TD>
+</TR>
+</TABLE>
+
+*/

data/ext/gecode-2.1.1/gecode.m4

@@ -0,0 +1,956 @@
+dnl
+dnl Main authors:
+dnl   Guido Tack <tack@gecode.org>
+dnl
+dnl Copyright:
+dnl   Guido Tack, 2004, 2005
+dnl
+dnl Last modified:
+dnl   $Date: 2005-10-27 21:01:30 +0200 (Thu, 27 Oct 2005) $
+dnl   by $Author: schulte $
+dnl   $Revision: 2420 $
+dnl
+dnl This file is part of Gecode, the generic constraint
+dnl development environment:
+dnl   http://www.gecode.org
+dnl
+dnl Permission is hereby granted, free of charge, to any person obtaining
+dnl a copy of this software and associated documentation files (the
+dnl "Software"), to deal in the Software without restriction, including
+dnl without limitation the rights to use, copy, modify, merge, publish,
+dnl distribute, sublicense, and/or sell copies of the Software, and to
+dnl permit persons to whom the Software is furnished to do so, subject to
+dnl the following conditions:
+dnl
+dnl The above copyright notice and this permission notice shall be
+dnl included in all copies or substantial portions of the Software.
+dnl
+dnl THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+dnl EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+dnl MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+dnl NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+dnl LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+dnl OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+dnl WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+dnl
+dnl
+
+dnl check whether we have pkgconfig and should generate config files for it
+AC_DEFUN([AC_GECODE_PKGCONFIG],
+	[AC_CHECK_PROG(PKGCONFIG, pkg-config, [found])
+	 AC_MSG_CHECKING(whether to generate pkg-config files)
+	 if test "${PKGCONFIG}x" = "x"; then
+	    AC_MSG_RESULT(no)
+	    AC_SUBST(HAS_PKGCONFIG, "no")
+	 else
+	    AC_MSG_RESULT(yes)
+	    AC_SUBST(HAS_PKGCONFIG, "yes")
+	 fi])
+
+AC_DEFUN([AC_GECODE_GET_OS],
+	[AC_ARG_WITH([host-os],
+           AC_HELP_STRING([--with-host-os],
+	   [Override operating system test. Valid values are Linux, Darwin, and Windows.]))
+	 AC_MSG_CHECKING([for the host operating system])
+         if test "${with_host_os:-no}" = "no"; then
+	   guess_host_os=$(uname -s 2>/dev/null)
+	 else
+	   guess_host_os=${with_host_os}
+   	 fi
+	 dnl Try to find out operating system
+	 case ${guess_host_os} in
+	   GNU/kFreeBSD|*inux*)
+	   host_os=linux
+	   AC_MSG_RESULT([Linux])
+	   ;;
+	   *arwin*)
+	   host_os=darwin
+	   AC_MSG_RESULT([Darwin])
+	   ;;
+	   CYGWIN*|*indows*)
+	   host_os=windows
+	   AC_MSG_RESULT([Windows])
+	   ;;
+	   *)
+	   AC_MSG_ERROR([Host OS not supported.])
+	   ;;
+	 esac])
+
+dnl Macros:
+dnl   AC_GECODE_ADD_TO_CXXFLAGS ([FLAG...])
+dnl   AC_GECODE_ADD_TO_GLDFLAGS ([FLAG...])
+dnl
+dnl Description:
+dnl   Add the flags to the corresponding variables
+dnl
+dnl Author:
+dnl   Marco Kuhlmann <kuhlmann@ps.uni-sb.de>
+dnl
+AC_DEFUN([AC_GECODE_ADD_TO_CXXFLAGS],
+   [CXXFLAGS="${CXXFLAGS}${CXXFLAGS:+ }$1"])
+AC_DEFUN([AC_GECODE_ADD_TO_COMPILERFLAGS],
+   [CFLAGS="${CFLAGS}${CFLAGS:+ }$1"
+    CXXFLAGS="${CXXFLAGS}${CXXFLAGS:+ }$1"])
+AC_DEFUN([AC_GECODE_ADD_TO_CFLAGS],
+   [CFLAGS="${CFLAGS}${CFLAGS:+ }$1"])
+AC_DEFUN([AC_GECODE_ADD_TO_GLDFLAGS],
+   [GLDFLAGS="${GLDFLAGS}${GLDFLAGS:+ }$1"])
+AC_DEFUN([AC_GECODE_ADD_TO_PKG_CXXFLAGS],
+  [ac_gecode_pkg_cxxflags="${ac_gecode_pkg_cxxflags}${ac_gecode_pkg_cxxflags:+ }$1"])
+AC_DEFUN([AC_GECODE_ADD_TO_DLLFLAGS],
+  [DLLFLAGS="${DLLFLAGS}${DLLFLAGS:+ }$1"])
+
+
+dnl Macro:
+dnl   AC_GECODE_CHECK_CXXFLAG (FLAG, [ACTION-IF-TRUE,
+dnl                                [ACTION-IF-FALSE]])
+dnl
+dnl Description:
+dnl   Check whether FLAG is supported by the C++ compiler.  Run
+dnl   the shell commands ACTION-IF-TRUE if it is, ACTION-IF-FALSE
+dnl   otherwise.  If ACTION-IF-TRUE is not given, append FLAG to
+dnl   the contents of $CXXFLAGS.
+dnl
+dnl Authors:
+dnl   Leif Kornstaedt <kornstae@ps.uni-sb.de>
+dnl   Marco Kuhlmann <kuhlmann@ps.uni-sb.de>
+dnl
+AC_DEFUN([AC_GECODE_CHECK_CXXFLAG],
+  [AC_MSG_CHECKING(whether ${CXX} accepts [$1])
+   ac_gecode_save_CXXFLAGS="${CXXFLAGS}"
+   CXXFLAGS="${CXXFLAGS}${CXXFLAGS:+ }$1 -Werror"
+   AC_LANG_PUSH(C++)
+   AC_COMPILE_IFELSE(AC_LANG_PROGRAM(),
+     [AC_MSG_RESULT(yes)
+      CXXFLAGS="${ac_gecode_save_CXXFLAGS}"
+      ifelse([$2], , [CXXFLAGS="${CXXFLAGS}${CXXFLAGS:+ }$1"], [$2])],
+     [AC_MSG_RESULT(no)
+      CXXFLAGS="${ac_gecode_save_CXXFLAGS}"
+      ifelse([$3], , :, [$3])])
+   AC_LANG_POP])dnl
+
+AC_DEFUN([AC_GECODE_CHECK_COMPILERFLAG],
+  [AC_MSG_CHECKING(whether ${CXX} accepts [$1])
+   ac_gecode_save_CXXFLAGS="${CXXFLAGS}"
+   CXXFLAGS="${CXXFLAGS}${CXXFLAGS:+ }$1 -Werror"
+   AC_LANG_PUSH(C++)
+   AC_COMPILE_IFELSE(AC_LANG_PROGRAM(),
+     [AC_MSG_RESULT(yes)
+      CXXFLAGS="${ac_gecode_save_CXXFLAGS}"
+      CXXFLAGS="${CXXFLAGS}${CXXFLAGS:+ }$1"],
+     [AC_MSG_RESULT(no)
+      CXXFLAGS="${ac_gecode_save_CXXFLAGS}"])
+   AC_LANG_POP
+   
+   AC_MSG_CHECKING(whether ${CC} accepts [$1])
+   ac_gecode_save_CFLAGS="${CFLAGS}"
+   CFLAGS="${CFLAGS}${CFLAGS:+ }$1 -Werror"
+   AC_LANG_PUSH(C)
+   AC_COMPILE_IFELSE(AC_LANG_PROGRAM(),
+     [AC_MSG_RESULT(yes)
+      CFLAGS="${ac_gecode_save_CFLAGS}"
+      CFLAGS="${CFLAGS}${CFLAGS:+ }$1"],
+     [AC_MSG_RESULT(no)
+      CFLAGS="${ac_gecode_save_CFLAGS}"])
+   AC_LANG_POP])dnl
+
+dnl Macro:
+dnl   AC_GECODE_CHECK_GLDFLAG (FLAG, [ACTION-IF-TRUE,
+dnl                                  [ACTION-IF-FALSE]])
+dnl
+dnl Description:
+dnl   Check whether FLAG is supported by the linker.  Run the
+dnl   shell commands ACTION-IF-TRUE if it is, ACTION-IF-FALSE
+dnl   otherwise.  If ACTION-IF-TRUE is not given, append FLAG to
+dnl   the contents of $GLDFLAGS.
+dnl
+dnl Authors:
+dnl   Leif Kornstaedt <kornstae@ps.uni-sb.de>
+dnl   Marco Kuhlmann <kuhlmann@ps.uni-sb.de>
+dnl
+AC_DEFUN([AC_GECODE_CHECK_GLDFLAG],
+  [AC_REQUIRE([AC_PROG_CXX])
+   AC_MSG_CHECKING(whether the linker accepts [$1])
+   ac_gecode_save_GLDFLAGS="${GLDFLAGS}"
+   GLDFLAGS="${GLDFLAGS}${GLDFLAGS:+ }$1"
+   AC_LINK_IFELSE(AC_LANG_PROGRAM(),
+     [AC_MSG_RESULT(yes)
+      GLDFLAGS="$ac_gecode_save_GLDFLAGS"
+      ifelse([$2], , [GLDFLAGS="${GLDFLAGS}${GLDFLAGS:+ }$1"], [$2])],
+     [AC_MSG_RESULT(no)
+      GLDFLAGS="$ac_gecode_save_GLDFLAGS"
+      ifelse([$3], , :, [$3])])])dnl
+
+dnl @synopsis _AC_C_IFDEF(MACRO-NAME, ACTION-IF-DEF, ACTION-IF-NOT-DEF)
+dnl
+dnl Check for the definition of macro MACRO-NAME using the current
+dnl language's compiler.
+dnl
+dnl @category Misc
+dnl @author Ludovic Court�s <ludo@chbouib.org>
+dnl @version 2004-09-07
+dnl @license AllPermissive
+AC_DEFUN([_AC_C_IFDEF],
+  [AC_COMPILE_IFELSE([#ifndef $1
+                      # error "Macro $1 is undefined!"
+		      /* For some compilers (eg. SGI's CC), #error is not
+		         enough...  */
+		      please, do fail
+		      #endif],
+		     [$2], [$3])])
+
+dnl @synopsis AC_CXX_COMPILER_VENDOR(VENDOR-NAME)
+dnl
+dnl Set VENDOR-NAME to the lower-case name of the compiler vendor or `unknown'
+dnl if the compiler's vendor is unknown.
+dnl
+dnl @version 20040907
+dnl @author  Ludovic Court�s <ludo@chbouib.org>
+dnl Modified by G. Tack to recognize only those compilers we need.
+AC_DEFUN([AC_CXX_COMPILER_VENDOR],
+  [AC_ARG_WITH([compiler-vendor],
+     AC_HELP_STRING([--with-compiler-vendor],
+       [Override compiler test. Valid values are gnu, intel, and microsoft.]))
+   AC_REQUIRE([AC_PROG_CXX])
+   AC_REQUIRE([AC_PROG_CXXCPP])
+   AC_CACHE_CHECK([the C++ compiler vendor],
+    [ac_cv_cxx_compiler_vendor],
+
+    [if test "${with_compiler_vendor:-no}" = "no"; then
+
+     AC_LANG_PUSH([C++])
+
+     dnl GNU C++
+     _AC_C_IFDEF([__GNUG__],
+       [ac_cv_cxx_compiler_vendor=gnu],
+       [_AC_C_IFDEF([__INTEL_COMPILER],
+                    [ac_cv_cxx_compiler_vendor=intel],
+       [dnl Note:  We are using the C compiler because VC++ doesn't
+        dnl recognize `.cc'(which is used by `configure') as a C++ file
+        dnl extension and requires `/TP' to be passed.
+        AC_LANG_PUSH([C])
+        _AC_C_IFDEF([_MSC_VER],
+                    [ac_cv_cxx_compiler_vendor=microsoft],
+                    [ac_cv_cxx_compiler_vendor=unknown])
+        AC_LANG_POP()])])
+
+     AC_LANG_POP()
+     else
+       ac_cv_cxx_compiler_vendor=${with_compiler_vendor}
+     fi
+     $1="$ac_cv_cxx_compiler_vendor"])])dnl
+
+
+dnl Macro:
+dnl   AC_GECODE_VTI (vartype, help-string, default,
+dnl		     [ACTION-IF-ENABLED])
+dnl
+dnl Description:
+dnl   Introduce --enable-vartype-vars configure switch. The help-string
+dnl   is used for the configure --help output.
+dnl   default is either yes or no and says whether this option should be
+dnl   enabled by default. ACTION-IF-ENABLED can be used to perform additional
+dnl   actions in case this variable type is enabled.
+dnl
+dnl Authors:
+dnl   Guido Tack <tack@gecode.org>
+AC_DEFUN([AC_GECODE_ADD_VTI],
+   [AC_DEFINE(GECODE_HAS_$1_VARS)])
+AC_DEFUN([AC_GECODE_VTI],
+   [
+   AC_ARG_ENABLE([$1-vars],
+     AC_HELP_STRING([--enable-$1-vars],[build $2 @<:@default=$3@:>@]))
+   AC_MSG_CHECKING(whether to build the $1 variables library)
+   if test "${enable_$1_vars:-$3}" = "yes"; then
+     AC_MSG_RESULT(yes)
+     enable_$1_vars="yes";
+     $4
+     AC_GECODE_ADD_VTI(translit($1,`a-z', `A-Z'))
+   else
+     enable_$1_vars="no";
+     AC_MSG_RESULT(no)
+   fi
+   AC_SUBST(enable_$1_vars, ${enable_$1_vars})
+   ])
+
+dnl Macro:
+dnl   AC_GECODE_ENABLE_MODULE (module, default, help-string,
+dnl                            [ACTION-IF-ENABLED])
+dnl
+dnl Description:
+dnl   Produces a configure switch --enable-<module>.
+dnl
+dnl Authors:
+dnl   Guido Tack <tack@gecode.org>
+AC_DEFUN([AC_GECODE_ENABLE_MODULE],
+	 [
+     AC_ARG_ENABLE([$1],
+	   AC_HELP_STRING([--enable-$1],
+	     [$3 @<:@default=$2@:>@]))
+	 AC_MSG_CHECKING(whether to build $1)
+	 if test "${enable_$1:-$2}" = "yes"; then
+	    enable_$1="yes";
+	    AC_MSG_RESULT(yes)
+	    $4
+	 else
+	    enable_$1="no";
+	    AC_MSG_RESULT(no)
+	 fi
+   	 AC_SUBST(enable_$1, ${enable_$1})])	
+
+dnl Description:
+dnl   Makes an enable check for a contrib
+dnl   The third argument can be used for dependency checking 
+dnl
+dnl Authors:
+dnl   Gr�goire Dooms <dooms@info.ucl.ac.be>
+AC_DEFUN([AC_GECODE_ENABLE_CONTRIB],
+[
+   AC_ARG_ENABLE([$1],
+     AC_HELP_STRING([--enable-$1],[build $2 @<:@default=yes@:>@]))
+   AC_MSG_CHECKING(whether to build the $1 contrib library)
+   if test "${enable_$1:-yes}" = "yes"; then
+     AC_MSG_RESULT(yes)
+     enable_$1="yes";
+     $3
+   else
+     enable_$1="no";
+     AC_MSG_RESULT(no)
+   fi
+   AC_SUBST(enable_$1, ${enable_$1})])
+
+
+AC_DEFUN([AC_GECODE_STATICLIBS],
+	 [if test "${host_os}" = "windows" -a \
+                  "${ac_gecode_compiler_vendor}" = "gnu"; then
+            enable_static="yes"
+	    enable_shared="no"
+          fi
+          AC_ARG_ENABLE([static],
+	   AC_HELP_STRING([--enable-static],
+	     [build static libraries @<:@default=no@:>@]))
+	  AC_MSG_CHECKING(whether to build static libraries)
+ 	  if test "${enable_static:-no}" = "yes"; then
+ 	     AC_DEFINE(GECODE_STATIC_LIBS)
+ 	     AC_SUBST(BUILDSTATIC, "yes")
+ 	     AC_MSG_RESULT(yes)
+ 	  else
+ 	     AC_SUBST(BUILDSTATIC, "no")
+ 	     AC_MSG_RESULT(no)
+ 	  fi
+	  AC_ARG_ENABLE([shared],
+	   AC_HELP_STRING([--enable-shared],
+	     [build shared libraries @<:@default=yes@:>@]))
+	  AC_MSG_CHECKING(whether to build shared libraries)
+ 	  if test "${enable_shared:-yes}" = "yes"; then
+ 	     AC_SUBST(BUILDDLL, "yes")
+ 	     AC_MSG_RESULT(yes)
+ 	  else
+ 	     AC_SUBST(BUILDDLL, "no")
+ 	     if test "${enable_static:-no}" = "no"; then
+ 	       AC_MSG_ERROR([One of --enable-static or --enable-shared must be given])
+ 	     fi
+ 	     AC_MSG_RESULT(no)
+ 	  fi
+	  ])
+
+
+AC_DEFUN([AC_GECODE_DEBUG],
+	[AC_ARG_ENABLE([debug],
+	   AC_HELP_STRING([--enable-debug],
+	     [build with assertions @<:@default=no@:>@]))
+	 AC_MSG_CHECKING(whether to build with debug symbols and assertions)
+	 if test "${enable_debug:-no}" = "yes"; then
+	    AC_MSG_RESULT(yes)
+	 else
+	    AC_MSG_RESULT(no)
+       	    AC_GECODE_ADD_TO_COMPILERFLAGS(-DNDEBUG)
+	 fi])
+
+AC_DEFUN([AC_GECODE_LEAK_DEBUG],
+	[AC_ARG_ENABLE([leak-debug],
+	   AC_HELP_STRING([--enable-leak-debug],
+	     [build with support for finding memory leaks @<:@default=no@:>@]))
+	 AC_MSG_CHECKING(whether to build with support for finding memory leaks)
+	 if test "${enable_leak_debug:-no}" = "yes"; then
+	    AC_MSG_RESULT(yes)
+	    AC_CHECK_DECL(mtrace,
+			  [AC_DEFINE(GECODE_HAS_MTRACE)],
+			  [AC_MSG_ERROR(mtrace not available.)],
+			  [[#include <mcheck.h>]])	    
+	 else
+	    AC_MSG_RESULT(no)
+	 fi])
+
+AC_DEFUN([AC_GECODE_AUDIT],
+	[AC_ARG_ENABLE([audit],
+	   AC_HELP_STRING([--enable-audit],
+	     [build with auditing code @<:@default=no@:>@]))
+	 AC_MSG_CHECKING(whether to build with auditing code)
+	 if test "${enable_audit:-no}" = "yes"; then
+	    AC_DEFINE(GECODE_AUDIT)
+	    AC_MSG_RESULT(yes)
+	 else
+	    AC_MSG_RESULT(no)
+	 fi])
+
+
+AC_DEFUN([AC_GECODE_PROFILE],
+	 [AC_ARG_ENABLE([profile],
+	   AC_HELP_STRING([--enable-profile],
+	     [build with profiling information @<:@default=no@:>@]))
+	 AC_MSG_CHECKING(whether to build with profiling information)
+	 if test "${enable_profile:-no}" = "yes"; then
+	    AC_MSG_RESULT(yes)
+	    AC_GECODE_CHECK_CXXFLAG(-pg,
+	       AC_GECODE_ADD_TO_COMPILERFLAGS(-pg),
+	       AC_GECODE_CHECK_COMPILERFLAG(-p))
+	 else
+	    AC_MSG_RESULT(no)
+	 fi])
+
+AC_DEFUN([AC_GECODE_GCOV],
+	 [AC_ARG_ENABLE([gcov],
+	   AC_HELP_STRING([--enable-gcov],
+	     [build with gcov support @<:@default=no@:>@]))
+	 AC_MSG_CHECKING(whether to build with gcov support)
+	 if test "${enable_gcov:-no}" = "yes"; then
+	    AC_MSG_RESULT(yes)
+	    AC_GECODE_CHECK_COMPILERFLAG(-fprofile-arcs)
+	    AC_GECODE_CHECK_COMPILERFLAG(-ftest-coverage)
+	    AC_GECODE_ADD_TO_DLLFLAGS("-fprofile-arcs")
+	    AC_GECODE_ADD_TO_DLLFLAGS("-ftest-coverage")
+	 else
+	    AC_MSG_RESULT(no)
+	 fi])
+
+
+# Test for platform specific behaviour of arithmetic
+
+AC_DEFUN([AC_GECODE_CHECK_ARITH],
+	[AC_LANG_PUSH([C])
+	 AC_CHECK_SIZEOF(int)
+	 AC_MSG_CHECKING([if int has at least 32 bit])
+	 AC_TRY_COMPILE([],
+	   [
+	   #if SIZEOF_INT>=4
+	   #else
+	   blablub
+	   #endif
+	   ],
+	   [AC_MSG_RESULT(yes)],
+	   [AC_MSG_ERROR([Gecode needs at least 32 bit integers.])])
+
+	 AC_MSG_CHECKING([if doubles have a big enough mantissa])
+	 AC_TRY_COMPILE([#include <float.h>],
+	   [
+	   #if DBL_MANT_DIG>=53
+	   #else
+	   blablub
+	   #endif
+	   ],
+	   [AC_MSG_RESULT(yes)],
+	   [AC_MSG_ERROR([Gecode needs a double mantissa of at least 53 bits.])])
+
+	 AC_LANG_POP([C])])
+
+AC_DEFUN([AC_GECODE_GCC_GENERAL_SWITCHES],
+ [AC_DEFINE(forceinline, [inline])
+  AC_GECODE_CHECK_COMPILERFLAG([-fPIC])
+  AC_GECODE_CHECK_COMPILERFLAG([-Wextra])
+  AC_GECODE_CHECK_COMPILERFLAG([-Wall])
+  AC_GECODE_CHECK_COMPILERFLAG([-pipe])
+  AC_GECODE_CHECK_CXXFLAG(-ggdb,
+     AC_GECODE_ADD_TO_COMPILERFLAGS(-ggdb),
+     AC_GECODE_CHECK_COMPILERFLAG(-g))
+
+  AC_SUBST(docdir, "${datadir}/doc/gecode")
+
+  dnl file extensions
+  AC_SUBST(SBJEXT, "s")
+  AC_SUBST(LIBEXT, "${DLLEXT}")
+  AC_SUBST(LIBPREFIX, "libgecode")
+  AC_SUBST(STATICLIBEXT, "a")
+  AC_SUBST(MINUSLDIR, "-L${libdir}")
+  AC_SUBST(LINKLIBDIR, "")
+
+  cygpathprefix=$prefix
+  test "x$cygpathprefix" = xNONE && cygpathprefix=$ac_default_prefix
+  AC_SUBST(cygpathprefix, "${cygpathprefix}")
+
+  AC_SUBST(COMPILEOBJ, "-c -o ")
+  AC_SUBST(COMPILESBJ, "-S -o ")
+  AC_SUBST(CXXIN, " ")
+  AC_SUBST(CCIN, " ")
+  AC_SUBST(EXAMPLES_EXTRA_CXXFLAGS, "")
+
+  dnl Do not install stub .lib files (required for msvc)
+  AC_SUBST(INSTALLLIBS, "no")
+
+  AC_SUBST(LINKPREFIX, "-lgecode")
+  AC_SUBST(LINKSUFFIX, "")
+
+  dnl how to tell the compiler to output an object file
+  AC_SUBST(LINKOUTPUT, "-o ")
+  dnl how to tell the compiler to output an executable
+  AC_SUBST(EXEOUTPUT, "-o ")
+
+  dnl the names of the generated dlls
+  AC_SUBST(SUPPORT, "support")
+  AC_SUBST(KERNEL,  "kernel")
+  AC_SUBST(SEARCH,  "search")
+  AC_SUBST(INT,     "int")
+  AC_SUBST(SET,     "set")
+  AC_SUBST(CPLTSET, "cpltset")
+  AC_SUBST(MM,      "minimodel")
+  AC_SUBST(SER,     "serialization")
+  AC_SUBST(GIST,    "gist")])
+
+
+AC_DEFUN([AC_GECODE_GCC_OPTIMIZED_SWITCHES],
+ [AC_GECODE_CHECK_COMPILERFLAG([-O3])
+  AC_GECODE_CHECK_COMPILERFLAG([-fno-strict-aliasing])])
+
+AC_DEFUN([AC_GECODE_GCC_VISIBILITY],
+  	[AC_ARG_ENABLE([gcc-visibility],
+	   AC_HELP_STRING([--enable-gcc-visibility],
+	     [use gcc visibility attributes @<:@default=yes@:>@]))
+	 AC_MSG_CHECKING(whether to use gcc visibility attributes)
+	 if test "${enable_gcc_visibility:-yes}" = "yes"; then
+	    AC_MSG_RESULT(yes)
+	    AC_GECODE_CHECK_CXXFLAG([-fvisibility=hidden],
+	      [AC_DEFINE(GECODE_GCC_HAS_CLASS_VISIBILITY)
+	       AC_GECODE_ADD_TO_COMPILERFLAGS([-fvisibility=hidden])],
+	       [])
+	 else
+	    AC_MSG_RESULT(no)
+	 fi])
+
+AC_DEFUN([AC_GECODE_GCC_DEBUG_SWITCHES],
+  [AC_GECODE_CHECK_COMPILERFLAG([-fno-inline-functions])
+   AC_GECODE_CHECK_COMPILERFLAG([-fimplement-inlines])])
+
+AC_DEFUN([AC_GECODE_NO_BUILDFLAGS],
+  [AC_SUBST(GECODE_BUILD_SUPPORT_FLAG, "")
+   AC_SUBST(GECODE_BUILD_KERNEL_FLAG, "")
+   AC_SUBST(GECODE_BUILD_SEARCH_FLAG, "")
+   AC_SUBST(GECODE_BUILD_INT_FLAG, "")
+   AC_SUBST(GECODE_BUILD_SET_FLAG, "")
+   AC_SUBST(GECODE_BUILD_CPLTSET_FLAG, "")
+   AC_SUBST(GECODE_BUILD_MINIMODEL_FLAG, "")
+   AC_SUBST(GECODE_BUILD_SERIALIZATION_FLAG, "")
+   AC_SUBST(GECODE_BUILD_GIST_FLAG, "")])
+
+AC_DEFUN([AC_GECODE_BUILDFLAGS],
+  [AC_SUBST(GECODE_BUILD_SUPPORT_FLAG, "-DGECODE_BUILD_SUPPORT")
+   AC_SUBST(GECODE_BUILD_KERNEL_FLAG, "-DGECODE_BUILD_KERNEL")
+   AC_SUBST(GECODE_BUILD_SEARCH_FLAG, "-DGECODE_BUILD_SEARCH")
+   AC_SUBST(GECODE_BUILD_INT_FLAG, "-DGECODE_BUILD_INT")
+   AC_SUBST(GECODE_BUILD_SET_FLAG, "-DGECODE_BUILD_SET")
+   AC_SUBST(GECODE_BUILD_CPLTSET_FLAG, "-DGECODE_BUILD_CPLTSET")
+   AC_SUBST(GECODE_BUILD_MINIMODEL_FLAG, "-DGECODE_BUILD_MINIMODEL")
+   AC_SUBST(GECODE_BUILD_SERIALIZATION_FLAG, "-DGECODE_BUILD_SERIALIZATION")
+   AC_SUBST(GECODE_BUILD_GIST_FLAG, "-DGECODE_BUILD_GIST")])
+
+
+AC_DEFUN([AC_GECODE_UNIX_PATHS],
+ [AC_SUBST(DLLPATH, [-L.])
+  dnl flags for creating dlls
+  case $host_os in
+     darwin*)
+       AC_SUBST(need_soname, "yes")
+       AC_GECODE_ADD_TO_DLLFLAGS([-Wl,-single_module])
+       AC_GECODE_ADD_TO_DLLFLAGS("-dynamiclib")
+       AC_SUBST(DLLEXT, "${ac_gecode_soversion}.0.dylib")
+       AC_SUBST(SOSUFFIX, ".${ac_gecode_soversion}.dylib")
+       AC_SUBST(SOLINKSUFFIX, ".dylib")
+       AC_SUBST(sharedlibdir, "${libdir}")
+       AC_SUBST(WLSONAME, "-compatibility_version ${ac_gecode_soversion}.0 -current_version ${ac_gecode_soversion}.0 -install_name ${libdir}/")
+       AC_GECODE_NO_BUILDFLAGS
+       ;;
+     windows*)
+       AC_SUBST(need_soname, "no")
+       if test "${enable_static:-no}"  = "yes" -a \
+	       "${enable_shared:-yes}" = "yes"; then
+         AC_MSG_ERROR([Only either static or shared libraries can be built.])
+       fi
+       AC_GECODE_ADD_TO_DLLFLAGS("-shared")
+       AC_SUBST(DLLEXT, "dll")
+       AC_SUBST(SOSUFFIX, "")
+       AC_SUBST(SOLINKSUFFIX, "")
+       AC_SUBST(WLSONAME, "")
+       if test "${enable_static:-no}" = "no"; then
+	  AC_SUBST(sharedlibdir, "${bindir}")
+       else
+          AC_SUBST(sharedlibdir, "${libdir}")
+       fi
+       AC_GECODE_BUILDFLAGS
+       ;;
+     *)
+       AC_SUBST(need_soname, "yes")
+       AC_GECODE_ADD_TO_DLLFLAGS("-shared")
+       AC_SUBST(DLLEXT, "so.${ac_gecode_soversion}.0")
+       AC_SUBST(SOSUFFIX, ".so.${ac_gecode_soversion}")
+       AC_SUBST(SOLINKSUFFIX, ".so")
+       AC_SUBST(WLSONAME, ["-Wl,-soname="])
+       AC_SUBST(sharedlibdir, "${libdir}")
+       AC_GECODE_NO_BUILDFLAGS
+       ;;
+  esac])
+
+AC_DEFUN([AC_GECODE_MSVC_SWITCHES],
+ [dnl general compiler flags
+  AC_DEFINE(forceinline,[__forceinline])
+  AC_GECODE_ADD_TO_COMPILERFLAGS([-nologo])
+  AC_GECODE_ADD_TO_CFLAGS([-D_CRT_SECURE_NO_DEPRECATE])
+  AC_GECODE_ADD_TO_CXXFLAGS([-EHsc])
+  AC_DEFINE(GECODE_MEMORY_ALIGNMENT, 4)
+
+  if test "${enable_debug:-no}" = "no"; then
+    dnl compiler flags for an optimized build
+    AC_GECODE_ADD_TO_COMPILERFLAGS([-Ox -fp:fast -GS- -arch:SSE -wd4355])
+    dnl AC_GECODE_ADD_TO_COMPILERFLAGS([-Ox -fp:fast -GS- -wd4355 -w34640 -w34365 -w34800 -w34265])
+
+    dnl flags for creating optimized dlls
+    AC_GECODE_ADD_TO_DLLFLAGS([${CXXFLAGS} -LD -MD])
+    dnl linker flags
+    GLDFLAGS="-link -DEBUG -OPT:REF -OPT:ICF"
+  else
+    dnl compiler flags for a debug build
+    AC_GECODE_ADD_TO_COMPILERFLAGS([-Zi -wd4355])  
+
+    dnl flags for creating debug dlls
+    AC_GECODE_ADD_TO_DLLFLAGS([${CXXFLAGS} -LDd -MDd])
+  fi
+
+  AC_SUBST(sharedlibdir, "${bindir}")
+  AC_SUBST(docdir, "${prefix}")
+  if test "${enable_static:-no}" = "yes"; then
+    AC_MSG_ERROR([Static linking not supported for Windows/cl.])
+  fi
+
+  AC_SUBST(DLLPATH, "")
+
+  dnl file extensions
+  AC_SUBST(SBJEXT, "sbj")
+  AC_SUBST(DLLEXT, "dll")
+  AC_SUBST(SOSUFFIX, "")
+  AC_SUBST(SOLINKSUFFIX, "")
+  AC_SUBST(WLSONAME, "")
+  AC_SUBST(LIBEXT, "lib")
+  AC_SUBST(LIBPREFIX, "Gecode")
+  AC_SUBST(LINKPREFIX, "Gecode")
+  AC_SUBST(LINKSUFFIX, ".lib")
+  AC_SUBST(MINUSLDIR, "")
+  AC_SUBST(LINKLIBDIR, "${libdir}/")
+
+  cygpathprefix=$prefix
+  test "x$cygpathprefix" = xNONE && cygpathprefix=$ac_default_prefix
+  cygpathprefix=`cygpath -m ${cygpathprefix}`
+
+  AC_SUBST(cygpathprefix, "${cygpathprefix}")
+  AC_GECODE_BUILDFLAGS
+
+  dnl compiler options
+  AC_SUBST(COMPILEOBJ, "-c -Fo")
+  AC_SUBST(COMPILESBJ, "-c -Fa")
+  AC_SUBST(CXXIN, "-Tp")
+  AC_SUBST(CCIN, "-Tc")
+  AC_SUBST(EXAMPLES_EXTRA_CXXFLAGS, "")
+
+  dnl Install stub .lib files (required for msvc)
+  AC_SUBST(INSTALLLIBS, "yes")
+
+  dnl how to tell the compiler to output an object file
+  AC_SUBST(LINKOUTPUT, "-Fe")
+  dnl how to tell the compiler to output an executable
+  AC_SUBST(EXEOUTPUT, "-Fe")
+
+  dnl the names of the generated dlls
+  AC_SUBST(SUPPORT, "Support")
+  AC_SUBST(KERNEL,  "Kernel")
+  AC_SUBST(SEARCH,  "Search")
+  AC_SUBST(INT,     "Int")
+  AC_SUBST(SET,     "Set")
+  AC_SUBST(CPLTSET, "CpltSet")
+  AC_SUBST(MM,      "Minimodel")
+  AC_SUBST(SER,     "Serialization")
+  AC_SUBST(GIST,    "Gist")])
+
+dnl Macro:
+dnl   AC_GECODE_DOC_SWITCHES
+dnl
+dnl Description:
+dnl   Produces the configure switches --enable-doc-search,
+dnl   --enable-doc-chm, and --enable-doc-tagfile.
+dnl
+dnl Authors:
+dnl   Guido Tack <tack@gecode.org>
+AC_DEFUN([AC_GECODE_DOC_SWITCHES],
+  [dnl check if we can use dot for generating graphs in the documentation
+   AC_ARG_ENABLE([doc-dot],
+     AC_HELP_STRING([--enable-doc-dot],
+	[enable graphs in documentation @<:@default=yes@:>@]))
+   AC_CHECK_PROG(DOT, dot, dot)
+   AC_MSG_CHECKING(whether to enable graphs in the documentation)
+   if test "${enable_doc_dot:-yes}" = "yes"; then
+     if test x$DOT = x; then
+        if test x"${enable_doc_dot}" = x; then
+	  AC_MSG_RESULT(no)
+     	  AC_SUBST(GECODE_DOXYGEN_DOT, NO)
+	else
+          AC_MSG_ERROR(you need the dot tool from graphviz to generate graphs in the documentation)
+	fi
+     else
+        AC_MSG_RESULT(yes)
+	AC_SUBST(GECODE_DOXYGEN_DOT, YES)
+     fi
+   else
+     AC_MSG_RESULT(no)
+     AC_SUBST(GECODE_DOXYGEN_DOT, NO)
+   fi
+
+   AC_ARG_ENABLE([doc-search],
+     AC_HELP_STRING([--enable-doc-search],
+	[enable documentation search engine @<:@default=no@:>@]))
+   AC_MSG_CHECKING(whether to enable the documentation search engine)
+   if test "${enable_doc_search:-no}" = "yes"; then
+     AC_MSG_RESULT(yes)
+     AC_SUBST(ENABLEDOCSEARCH, "yes")
+   else
+     AC_MSG_RESULT(no)
+     AC_SUBST(ENABLEDOCSEARCH, "no")
+   fi
+   AC_ARG_ENABLE([doc-tagfile],
+     AC_HELP_STRING([--enable-doc-tagfile],
+	[generate doxygen tagfile @<:@default=no@:>@]))
+   AC_MSG_CHECKING(whether to generate a doxygen tagfile)
+   if test "${enable_doc_tagfile:-no}" = "yes"; then
+     AC_MSG_RESULT(yes)
+     AC_SUBST(GECODE_DOXYGEN_TAGFILE, "doc/gecode-doc.tag")
+   else
+     AC_MSG_RESULT(no)
+     AC_SUBST(GECODE_DOXYGEN_TAGFILE, [])
+   fi
+   AC_ARG_ENABLE([doc-chm],
+     AC_HELP_STRING([--enable-doc-chm],
+	[build compressed html documentation @<:@default=yes on Windows@:>@]))
+   AC_MSG_CHECKING(whether to build compressed html documentation)
+   case $host_os in
+	windows*)
+   		if test "${enable_doc_chm:-yes}" = "yes"; then
+		  AC_MSG_RESULT(yes)
+     		  AC_SUBST(ENABLEDOCCHM, "yes")
+                  AC_SUBST(ENABLEDOCSEARCH, "no")
+   		else
+     		  AC_MSG_RESULT(no)
+     		  AC_SUBST(ENABLEDOCCHM, "no")
+   		fi
+	;;
+	*)
+   		if test "${enable_doc_chm:-no}" = "yes"; then
+		  AC_MSG_ERROR([building chms is only supported on Windows.])
+   		else
+     		  AC_MSG_RESULT(no)
+     		  AC_SUBST(ENABLEDOCCHM, "no")
+   		fi
+	;;
+   esac])
+
+dnl Macro:
+dnl   AC_GECODE_UNIVERSAL
+dnl
+dnl Description:
+dnl   Produces the configure switches --enable-universal and --with-sdk
+dnl   for compiling universal binaries on Mac OS X.
+dnl
+dnl Authors:
+dnl   Guido Tack <tack@gecode.org>
+AC_DEFUN([AC_GECODE_UNIVERSAL],
+  [dnl build universal binaries on Mac OS X
+  AC_ARG_WITH([sdk],
+    AC_HELP_STRING([--with-sdk],
+	[SDK to use on Mac OS X]))
+  if test "${host_os}" = "darwin"; then
+    if test "${with_sdk:-no}" != "no"; then
+      AC_GECODE_CHECK_COMPILERFLAG([-isysroot ${with_sdk}])
+      AC_GECODE_ADD_TO_DLLFLAGS([-Wl,-syslibroot,${with_sdk}])
+    fi
+  fi
+  AC_ARG_WITH([macosx-version-min],
+    AC_HELP_STRING([--with-macosx-version-min],
+	[minimum version of Mac OS X to support]))
+  if test "${host_os}" = "darwin"; then
+    if test "${with_macosx_version_min:-no}" != "no"; then
+      AC_GECODE_CHECK_COMPILERFLAG(
+        [-mmacosx-version-min=${with_macosx_version_min}])
+      AC_GECODE_ADD_TO_DLLFLAGS(
+        [-mmacosx-version-min=${with_macosx_version_min}])
+    fi
+  fi
+  AC_ARG_WITH([architectures],
+    AC_HELP_STRING([--with-archiectures],
+	[architectures to compile for on Mac OS X]))
+  AC_MSG_CHECKING(Whether to build for different architectures)
+  if test "${host_os}" = "darwin"; then
+    if test "${with_architectures:-no}" != "no"; then
+      archflags="";
+      for a in `echo ${with_architectures} | sed -e "s/,/ /g"`; do
+	archflags="${archflags} -arch $a";
+      done
+      AC_GECODE_CHECK_COMPILERFLAG([${archflags}])
+      AC_GECODE_ADD_TO_DLLFLAGS([${archflags}])
+      AC_MSG_RESULT(yes)
+    else
+      AC_MSG_RESULT(no)
+    fi
+  else
+    AC_MSG_RESULT(no)
+  fi
+])
+
+dnl Macro:
+dnl   AC_GECODE_FRAMEWORK
+dnl
+dnl Description:
+dnl   Produces the configure switch --enable-framework
+dnl   for creating a Mac OS X framework instead of individual libraries.
+dnl
+dnl Authors:
+dnl   Guido Tack <tack@gecode.org>
+AC_DEFUN([AC_GECODE_FRAMEWORK],
+  [dnl build framework bundle on Mac OS X
+  AC_ARG_ENABLE([framework],
+    AC_HELP_STRING([--enable-framework],
+	[build framework bundle on Mac OS X @<:@default=no@:>@]))
+  if test "${host_os}" = "darwin"; then
+    AC_MSG_CHECKING(whether to build framework bundle on Mac OS X)
+    if test "${enable_framework:-no}" = "yes"; then
+      AC_MSG_RESULT(yes)
+      AC_SUBST(BUILD_MACOS_FRAMEWORK, "yes")
+      AC_DEFINE(GECODE_STATIC_LIBS)
+      AC_SUBST(BUILDSTATIC, "yes")
+    else
+      AC_MSG_RESULT(no)
+      AC_SUBST(BUILD_MACOS_FRAMEWORK, "no")
+    fi
+  fi
+])
+
+dnl Macro:
+dnl   AC_GECODE_BOOST_SERIALIZATION
+dnl
+dnl Description:
+dnl   Produces the configure switch --with-boost
+dnl   for supplying the path to the boost serialization library.
+dnl   If present, support for boost serialization will be built
+dnl   into Gecode.
+dnl
+dnl Authors:
+dnl   Guido Tack <tack@gecode.org>
+AC_DEFUN([AC_GECODE_BOOST_SERIALIZATION],
+  [dnl build with support for the boost serialization library
+  AC_ARG_WITH([boost-include],
+    AC_HELP_STRING([--with-boost-include],
+	[path to the boost header files (used for serialization)]))
+  if test "${with_boost_include:-no}" != "no"; then
+      AC_SUBST(BOOST_CPPFLAGS,[-I${with_boost_include}])
+      AC_SUBST(BOOST_LINK,["-L${with_boost_include}/../../lib -lboost_serialization"])
+      AC_DEFINE(GECODE_HAS_BOOST_SERIALIZATION)
+  fi
+])
+
+dnl Macro:
+dnl   AC_GECODE_QT
+dnl
+dnl Description:
+dnl   Produces the configure switch --enable-qt
+dnl   for compiling parts of Gecode that need the Qt library.
+dnl
+dnl Authors:
+dnl   Guido Tack <tack@gecode.org>
+AC_DEFUN([AC_GECODE_QT],
+  [
+  AC_ARG_ENABLE([qt],
+    AC_HELP_STRING([--enable-qt],
+      [build with Qt support @<:@default=no@:>@]))
+  AC_MSG_CHECKING(whether to build with Qt support)
+  if test "${enable_qt:-no}" = "yes"; then
+    AC_MSG_RESULT(yes)
+    AC_DEFINE(GECODE_HAS_QT)
+
+    AC_CHECK_PROG(QMAKE, qmake, [found])
+    if test "${QMAKE}x" = "x"; then
+      AC_MSG_ERROR([The qmake tool was not found.])
+    else
+      ac_gecode_qt_version=`qmake -query QT_VERSION`
+      ac_gecode_qt_major=`echo ${ac_gecode_qt_version} | grep -o '^[[0-9]]*'`
+      ac_gecode_qt_minor=`echo ${ac_gecode_qt_version} | sed -e 's/^[[0-9]]*\\.//g' -e 's/\\.[[0-9]]*$//g'`
+      ac_gecode_qt_ok="yes"
+      if test ${ac_gecode_qt_major} -lt 4; then ac_gecode_qt_ok="no";
+      else if test ${ac_gecode_qt_major} -eq 4 \
+                -a ${ac_gecode_qt_minor} -lt 2; then ac_gecode_qt_ok="no";
+           fi
+      fi
+      if test "${ac_gecode_qt_ok}" != "yes"; then
+        AC_MSG_ERROR([Your version of Qt is too old. Minimum required: 4.2. Your version: ${ac_gecode_qt_version}.])
+      fi
+    fi
+
+    dnl use qmake to find the Qt installation
+    ac_gecode_qt_tmpdir=`mktemp -d gistqt.XXXXXX` || exit 1
+    cd ${ac_gecode_qt_tmpdir}
+    echo "QT += script" > a.pro
+    qmake
+    if test -d a.xcodeproj; then
+      ac_gecode_qt_makefile=a.xcodeproj/qt_preprocess.mak
+    elif test -f Makefile.Debug; then
+        if test "${enable_debug:-no}" = "no"; then
+          ac_gecode_qt_makefile=Makefile.Release
+        else
+          ac_gecode_qt_makefile=Makefile.Debug
+        fi
+    else
+      ac_gecode_qt_makefile=Makefile
+    fi
+    ac_gecode_qt_defines=`grep ${ac_gecode_qt_makefile} -e 'DEFINES.*=' | sed -e 's/.*=//' -e 's|\\\\|/|g' -e 's|-I\\("*\\)\\.\\./\\.\\.|-I\\1..|g'`
+    ac_gecode_qt_inc=`grep ${ac_gecode_qt_makefile} -e 'INCPATH.*=' | sed -e 's/.*=//' -e 's|\\\\|/|g' -e 's|-I\\("*\\)\\.\\./\\.\\.|-I\\1..|g'`
+    ac_gecode_qt_libs=`grep ${ac_gecode_qt_makefile} -e 'LIBS.*=' | sed -e 's/.*=//' -e 's|\\\\|/|g' -e 's|-I\\("*\\)\\.\\./\\.\\.|-I\\1..|g'`
+    if test -d a.xcodeproj; then
+      ac_gecode_qt_libs="-framework QtScript -framework QtGui -framework QtCore"
+    fi
+    cd ..
+    rm -r ${ac_gecode_qt_tmpdir}
+    AC_SUBST(QTINCLUDES, ${ac_gecode_qt_inc})
+    AC_SUBST(QTDEFINES, ${ac_gecode_qt_defines})
+    AC_SUBST(QTLIBS, ${ac_gecode_qt_libs})
+  else
+    AC_MSG_RESULT(no)
+  fi
+  AC_SUBST(enable_qt, ${enable_qt})
+])
+
+dnl Macro:
+dnl   AC_GECODE_GIST
+dnl
+dnl Description:
+dnl   Produces the configure switch --enable-gist
+dnl   for compiling the Gecode Interactive Search Tool.
+dnl
+dnl Authors:
+dnl   Guido Tack <tack@gecode.org>
+AC_DEFUN([AC_GECODE_GIST],
+  [
+  AC_ARG_ENABLE([gist],
+    AC_HELP_STRING([--enable-gist],
+      [build Gecode Interactive Search Tool @<:@default=no@:>@]))
+  AC_MSG_CHECKING(whether to build Gist)
+  if test "${enable_gist:-no}" = "yes"; then
+    enable_qt="yes";
+    AC_MSG_RESULT(yes)
+    AC_DEFINE(GECODE_HAS_GIST)
+  else
+    AC_MSG_RESULT(no)
+  fi
+  AC_SUBST(enable_gist, ${enable_gist})
+])