compile again without HAVE_LUA (sorry)

Common/Bindings.h

-#ifndef _LUNA_SIGNATURE_H_
-#define _LUNA_SIGNATURE_H_
+#ifndef _BINDINGS_H_
+#define _BINDINGS_H_
+
+#ifndef HAVE_LUA //no bindings
+
+class methodBinding{};
+class constructorBinding{};
+template <class objectType, class returnType=void, class arg0Type=void, class arg1Type=void, class arg2Type=void, class arg3Type=void>
+class methodBindingTemplate:public methodBinding {
+  typedef returnType (objectType::*callback)(arg0Type,arg1Type,arg2Type,arg3Type);
+  public:
+  methodBindingTemplate(const std::string luaname,callback f){}
+};
+template <class objectType, class returnType, class arg0Type, class arg1Type, class arg2Type>
+class methodBindingTemplate<objectType,returnType,arg0Type,arg1Type,arg2Type,void>:public methodBinding {
+  typedef returnType (objectType::*callback)(arg0Type,arg1Type,arg2Type);
+  public:
+  methodBindingTemplate(const std::string luaname,callback f){}
+};
+template <class objectType, class returnType, class arg0Type, class arg1Type>
+class methodBindingTemplate<objectType,returnType,arg0Type,arg1Type,void,void>:public methodBinding {
+  typedef returnType (objectType::*callback)(arg0Type,arg1Type);
+  public:
+  methodBindingTemplate(const std::string luaname,callback f){}
+};
+template <class objectType, class returnType, class arg0Type>
+class methodBindingTemplate<objectType,returnType,arg0Type,void,void,void>:public methodBinding {
+  typedef returnType (objectType::*callback)(arg0Type);
+  public:
+  methodBindingTemplate(const std::string luaname,callback f){}
+};
+template <class objectType, class returnType>
+class methodBindingTemplate<objectType,returnType,void,void,void,void>:public methodBinding {
+  typedef returnType (objectType::*callback)();
+  public:
+  methodBindingTemplate(const std::string luaname,callback f){}
+};
+template <class objectType, class arg0Type, class arg1Type, class arg2Type>
+class methodBindingTemplate<objectType,void,arg0Type,arg1Type,arg2Type,void>:public methodBinding {
+  typedef void (objectType::*callback)(arg0Type,arg1Type,arg2Type);
+  public:
+  methodBindingTemplate(const std::string luaname,callback f){}
+};
+template <class objectType, class arg0Type, class arg1Type>
+class methodBindingTemplate<objectType,void,arg0Type,arg1Type,void,void>:public methodBinding {
+  typedef void (objectType::*callback)(arg0Type,arg1Type);
+  public:
+  methodBindingTemplate(const std::string luaname,callback f){}
+};
+template <class objectType, class arg0Type>
+class methodBindingTemplate<objectType,void,arg0Type,void,void,void>:public methodBinding {
+  typedef void (objectType::*callback)(arg0Type);
+  public:
+  methodBindingTemplate(const std::string luaname,callback f){}
+};
+template <class objectType>
+class methodBindingTemplate<objectType,void,void,void,void,void>:public methodBinding {
+  typedef void (objectType::*callback)();
+  public:
+  methodBindingTemplate(const std::string luaname,callback f){}
+};
+template<class objectType, class arg0Type=void, class arg1Type=void, class arg2Type=void, class arg3Type=void>
+class constructorBindingTemplate:public constructorBinding {};
+
+#else // HAVE_LUA
 
 extern "C" {
 #include "lua.h"
@@ -8,9 +71,6 @@ extern "C" {
 #include <vector>
 
 
-class binding {
-};
-
 class methodBinding {
   public:
   std::string _luaname;
@@ -25,6 +85,9 @@ class constructorBinding {
   virtual int call (lua_State *L)=0;
 };
 
+
+// this class is largely copied from luna
+// todo : add  reference to luna and check luna  licence
 template <typename T> class classBinding {
   typedef struct { T *pT; bool owned;} userdataType;
 public:
@@ -455,3 +518,4 @@ class constructorBindingTemplate<objectType,void,void,void,void>:public construc
   }
 };
 #endif
+#endif

Solver/dgConservationLaw.h

@@ -9,10 +9,8 @@
 #include "fullMatrix.h"
 class dataCacheDouble;
 class dataCacheMap;
-#ifdef HAVE_LUA
 class constructorBinding;
 class methodBinding;
-#endif
 
 class dgConservationLaw;
 
@@ -20,12 +18,10 @@ class dgBoundaryCondition {
  public:
   virtual ~dgBoundaryCondition () {}
   virtual dataCacheDouble *newBoundaryTerm(dataCacheMap &cacheMapLeft) const = 0;
-#if defined(HAVE_LUA)
   static const char className[];
   static const char parentClassName[];
   static methodBinding *methods[];
   static constructorBinding *constructorMethod;
-#endif
 };
 
 class dgConservationLaw {
@@ -62,12 +58,10 @@ class dgConservationLaw {
   dgBoundaryCondition *newOutsideValueBoundary(std::string outsideValueFunctionName);
   dgBoundaryCondition *new0FluxBoundary();
 
-  #ifdef HAVE_LUA
   static const char className[];
   static const char parentClassName[];
   static methodBinding *methods[];
   static constructorBinding *constructorMethod;
-  #endif
 };
 
 dgConservationLaw *dgNewPerfectGasLaw2d();

Solver/function.h

@@ -7,6 +7,8 @@
 #include <fullMatrix.h>
 class dataCacheMap;
 class MElement;
+class methodBinding;
+class constructorBinding;
 
 // those classes manage complex function dependencies and keep their values in cache so that they are not recomputed when it is not necessary. To do this, we use three classes : function, dataCache and dataCacheMap. The workflow is :
 //