pp

Common/Bindings.cpp

+// Gmsh - Copyright (C) 1997-2010 C. Geuzaine, J.-F. Remacle
+//
+// See the LICENSE.txt file for license information. Please report all
+// bugs and problems to <gmsh@geuz.org>.
+//
+// Contributor(s):
+//   Jonathan Lambrechts
+//
+
 #include <stdarg.h>
-#include "Bindings.h"
 #include <stdio.h>
-void methodBinding::setArgNames(const char *arg1, ...) {
+#include "Bindings.h"
+
+void methodBinding::setArgNames(const char *arg1, ...)
+{
   va_list ap;
   va_start(ap, arg1);
   const char *name=arg1;

Common/Bindings.h

+// Gmsh - Copyright (C) 1997-2010 C. Geuzaine, J.-F. Remacle
+//
+// See the LICENSE.txt file for license information. Please report all
+// bugs and problems to <gmsh@geuz.org>.
+
 #ifndef _BINDINGS_H_
 #define _BINDINGS_H_
+
 #include <string>
 #include <vector>
 #include <typeinfo>
@@ -8,21 +14,16 @@ class methodBinding{
   std::string _description;
   std::vector<std::string> _argNames;
   public:
-  inline const std::vector<std::string> &getArgNames()const{
-    return _argNames;
-  }
+  inline const std::vector<std::string> &getArgNames() const { return _argNames; }
   void setArgNames(const char * arg1, ...);
   void setDescription(std::string description){ _description = description; }
   inline const std::string getDescription() const { return _description; }
 };
 
-
-
 #if defined(HAVE_LUA)
 #include "LuaBindings.h"
 #else // no bindings
 #include "DummyBindings.h"
 #endif
 
-
 #endif

Common/DummyBindings.h

+// Gmsh - Copyright (C) 1997-2010 C. Geuzaine, J.-F. Remacle
+//
+// See the LICENSE.txt file for license information. Please report all
+// bugs and problems to <gmsh@geuz.org>.
+
 #ifndef _DUMMY_BINDINGS_H_
 #define _DUMMY_BINDINGS_H_
 
@@ -8,7 +13,8 @@ class classBinding {
   void setParentClass(){}
   template <typename cb>
   methodBinding *addMethod(std::string n, cb f){ return new methodBinding(); }
-  template <typename tObj, typename t0, typename t1, typename t2, typename t3, typename t4>
+  template <typename tObj, typename t0, typename t1, typename t2, typename t3, 
+            typename t4>
   methodBinding *setConstructor(){ return 0; }
   template <typename tObj, typename t0, typename t1, typename t2, typename t3>
   methodBinding *setConstructor(){ return 0; }

Common/LuaBindings.cpp

+// Gmsh - Copyright (C) 1997-2010 C. Geuzaine, J.-F. Remacle
+//
+// See the LICENSE.txt file for license information. Please report all
+// bugs and problems to <gmsh@geuz.org>.
+//
+// Contributor(s):
+//   Jonathan Lambrechts
+//
+
 #include "GmshConfig.h"
 
 #if defined(HAVE_LUA)
@@ -16,6 +25,7 @@
 #include "Bindings.h"
 #include "drawContext.h"
 #include "GmshMessage.h"
+
 #if defined(HAVE_SOLVER)
 #include "linearSystemCSR.h"
 #endif
@@ -35,28 +45,34 @@ extern "C" {
 class gmshOptions {
   public:
   gmshOptions(){};
-  void colorSet(std::string category, int index, std::string name, int value) {
+  void colorSet(std::string category, int index, std::string name, int value)
+  {
     GmshSetOption(category,name,(unsigned int)(value), index);
   }
-  int colorGet(std::string category, int index, std::string name) {
+  int colorGet(std::string category, int index, std::string name)
+  {
     unsigned int value;
     GmshGetOption(category, name, value, index);
     return value;
   }
-  double numberGet(std::string category, int index, std::string name) {
+  double numberGet(std::string category, int index, std::string name)
+  {
     double value;
     GmshGetOption(category, name, value, index);
     return value;
   }
-  void numberSet(std::string category, int index, std::string name, double value) {
+  void numberSet(std::string category, int index, std::string name, double value)
+  {
     GmshSetOption(category, name, value, index);
   }
-  std::string stringGet(std::string category, int index, std::string name) {
+  std::string stringGet(std::string category, int index, std::string name)
+  {
     std::string value;
     GmshGetOption(category, name, value, index);
     return value;
   }
-  void stringSet(std::string category, int index, std::string name, double value) {
+  void stringSet(std::string category, int index, std::string name, double value)
+  {
     GmshSetOption(category, name, value, index);
   }
   static void registerBindings(binding *b) {
@@ -64,22 +80,28 @@ class gmshOptions {
     cb->setDescription("access the gmsh option database");
     methodBinding *mb;
     mb = cb->addMethod("colorSet", &gmshOptions::colorSet);
-    mb->setDescription("set the value of a color (unsigned int) option. This is equivalent to category[index].name = value");
+    mb->setDescription("set the value of a color (unsigned int) option. This is "
+                       "equivalent to category[index].name = value");
     mb->setArgNames("category", "index", "name", "value", NULL);
     mb = cb->addMethod("colorGet", &gmshOptions::colorGet);
-    mb->setDescription("return the value of a color (unsigned int) option. This is equivalent to category[index].name");
+    mb->setDescription("return the value of a color (unsigned int) option. This "
+                       "is equivalent to category[index].name");
     mb->setArgNames("category", "index", "name", NULL);
     mb = cb->addMethod("numberSet", &gmshOptions::numberSet);
-    mb->setDescription("set the value of a number option. This is equivalent to category[index].name = value");
+    mb->setDescription("set the value of a number option. This is equivalent "
+                       "to category[index].name = value");
     mb->setArgNames("category", "index", "name", "value", NULL);
     mb = cb->addMethod("numberGet", &gmshOptions::numberGet);
-    mb->setDescription("return the value of a number option. This is equivalent to category[index].name");
+    mb->setDescription("return the value of a number option. This is equivalent "
+                       "to category[index].name");
     mb->setArgNames("category", "index", "name", NULL);
     mb = cb->addMethod("srtingSet", &gmshOptions::stringSet);
-    mb->setDescription("set the value of a string option. This is equivalent to category[index].name = \"value\"");
+    mb->setDescription("set the value of a string option. This is equivalent "
+                       "to category[index].name = \"value\"");
     mb->setArgNames("category", "index", "name", "value", NULL);
     mb = cb->addMethod("srtingGet", &gmshOptions::stringGet);
-    mb->setDescription("return the value of a string option. This is equivalent to category[index].name");
+    mb->setDescription("return the value of a string option. This is equivalent "
+                       "to category[index].name");
     mb->setArgNames("category", "index", "name", NULL);
     mb = cb->setConstructor<gmshOptions>();
     mb->setDescription("an instance of gmshOptions is needed to access the database");
@@ -102,7 +124,8 @@ const char *colorBlue = "\033[1;34m";
 const char *colorDefault = "\033[0m";
 const char *colorBold = "\033[1m";
 
-static void printMethod(std::string name, luaMethodBinding *mb, bool isConstructor=false) {
+static void printMethod(std::string name, luaMethodBinding *mb, bool isConstructor=false)
+{
   std::vector<std::string> argTypeNames;
   mb->getArgTypeNames(argTypeNames);
   std::cout << "  ";
@@ -123,34 +146,41 @@ static void printMethod(std::string name, luaMethodBinding *mb, bool isConstruct
   std::cout << colorBold << ")\n" << colorDefault;
   const std::string description = mb->getDescription();
   std::cout << (description.empty() ? "no help available" : description) << "\n";
-
 }
-static void listMethods(classBinding *cb){
+
+static void listMethods(classBinding *cb)
+{
   if(cb->methods.size())
-    std::cout<<colorGreen<<"Methods from "<<cb->getClassName()<<colorDefault<<"\n";
-  for(std::map<std::string,luaMethodBinding *>::iterator it = cb->methods.begin(); it!=cb->methods.end(); it++){
+    std::cout << colorGreen << "Methods from " << cb->getClassName() 
+              << colorDefault<< "\n";
+  for(std::map<std::string, luaMethodBinding *>::iterator it = cb->methods.begin();
+      it != cb->methods.end(); it++){
     printMethod(it->first, it->second);
   }
   if(cb->getParent())
     listMethods(cb->getParent());
 }
 
-static int luaHelp (lua_State *L){
+static int luaHelp (lua_State *L)
+{
   int argc = lua_gettop(L);
   binding *b = binding::instance();
   if (argc == 0){
     std::cout << "this is the gmsh help\n";
-    for(std::map<std::string,classBinding *>::iterator it = b->classes.begin(); it!=b->classes.end(); it++){
+    for(std::map<std::string,classBinding *>::iterator it = b->classes.begin();
+        it != b->classes.end(); it++){
       if(it->second->getParent())
         continue;
       std::cout << colorBlue << "  " << it->first<<colorDefault << " : ";
       const std::string description = it->second->getDescription();
       std::cout << (description.empty() ? "no help available" : description) << "\n";
     }
-  }else{
+  }
+  else{
     const char *className = luaL_checkstring(L, 1);
     if(b->classes.find(className) == b->classes.end()){
-      std::cout<<"Class "<<colorBold<<className<<colorDefault<<" does not exist.\n";
+      std::cout << "Class " << colorBold << className << colorDefault 
+                << " does not exist.\n";
       return 0;
     }
     classBinding *cb = b->classes[className];
@@ -166,8 +196,10 @@ static int luaHelp (lua_State *L){
     listMethods(cb);
     std::cout << "\n";
     if(cb->children.size()){
-      std::cout<<colorGreen<<"Children of "<<cb->getClassName()<<colorDefault<<"\n";
-      for(std::set<classBinding *>::iterator it = cb->children.begin(); it!=cb->children.end(); it++){
+      std::cout << colorGreen << "Children of " << cb->getClassName() 
+                << colorDefault << "\n";
+      for(std::set<classBinding *>::iterator it = cb->children.begin(); 
+          it != cb->children.end(); it++){
         std::cout << "  " << colorBlue << (*it)->getClassName() << colorDefault << " : ";
         const std::string description = (*it)->getDescription();
         std::cout << (description.empty() ? "no help available" : description) << "\n";
@@ -178,19 +210,23 @@ static int luaHelp (lua_State *L){
   return 0;
 }
 
-
-#ifdef HAVE_READLINE
-static int luaSave (lua_State *L){
+#if defined(HAVE_READLINE)
+static int luaSave (lua_State *L)
+{
   const char *filename = luaL_checkstring(L, 1);
   write_history(filename);
   return 0;
 }
-static int luaClear (lua_State *L){
+
+static int luaClear(lua_State *L)
+{
   clear_history();
   return 0;
 }
 #endif
-static int luaRefresh (lua_State *L){
+
+static int luaRefresh (lua_State *L)
+{
   drawContext::global()->draw();
   return 0;
 }
@@ -211,16 +247,19 @@ int binding::readFile(const char *filename)
   return (s == 0);
 }
 
-static int countInArguments(const std::vector<std::string> &types){
+static int countInArguments(const std::vector<std::string> &types)
+{
   int c = 0;
   for(int i = 1; i < types.size(); i++)
     c+=(types[i] != "-1");
   return c;
 }
 
-void binding::checkDocCompleteness(){
+void binding::checkDocCompleteness()
+{
   int nBad = 0;
-  for(std::map<std::string,classBinding *>::iterator cb = classes.begin(); cb!=classes.end();cb++) {
+  for(std::map<std::string, classBinding *>::iterator cb = classes.begin();
+      cb!=classes.end();cb++) {
     if(cb->second->getDescription().empty()){
       Msg::Error("binded class %s has no description.", cb->first.c_str());
       nBad++;
@@ -228,7 +267,8 @@ void binding::checkDocCompleteness(){
     luaMethodBinding *constructor = cb->second->getConstructor();
     if(constructor){
       if(constructor->getDescription().empty()){
-        Msg::Error("binded constructor of class %s has no description.", cb->first.c_str());
+        Msg::Error("binded constructor of class %s has no description.", 
+                   cb->first.c_str());
         nBad++;
       }
       std::vector<std::string> argTypeNames;
@@ -236,14 +276,16 @@ void binding::checkDocCompleteness(){
       int nTypeArg = countInArguments(argTypeNames);
       int nDocArg = constructor->getArgNames().size();
       if(nTypeArg != nDocArg){
-        Msg::Error("binded constructor of class %s takes %i arguments but %i are documented.",
-          cb->first.c_str(), nTypeArg, nDocArg);
+        Msg::Error("binded constructor of class %s takes %i arguments but %i "
+                   "are documented.", cb->first.c_str(), nTypeArg, nDocArg);
         nBad++;
       }
     }
-    for(std::map<std::string,luaMethodBinding*>::iterator mb = cb->second->methods.begin(); mb != cb->second->methods.end(); mb++){
+    for(std::map<std::string,luaMethodBinding*>::iterator mb = cb->second->methods.begin();
+        mb != cb->second->methods.end(); mb++){
       if(mb->second->getDescription().empty()){
-        Msg::Error("binded method %s.%s has no description.", cb->first.c_str(),mb->first.c_str());
+        Msg::Error("binded method %s.%s has no description.", cb->first.c_str(),
+                   mb->first.c_str());
         nBad++;
       }
       std::vector<std::string> argTypeNames;
@@ -258,10 +300,11 @@ void binding::checkDocCompleteness(){
     }
   }
   if(nBad != 0){
-    Msg::Error("Bindings documentation is not complete (%i error(s) ). To enforce documentation completeness, I will exit now. Please complete the documentation and run gmsh again ;-) .\n",nBad);
-    exit(1);
+    Msg::Error("Bindings documentation is not complete (%i error(s)). To enforce "
+               "documentation completeness, I will exit now. Please complete the "
+               "documentation and run Gmsh again ;-)", nBad);
+    Msg::Exit(1);
   }
-    
 }
 
 void binding::interactiveSession()
@@ -271,7 +314,7 @@ void binding::interactiveSession()
   checkDocCompleteness();
 
   Msg::Info("Starting interactive lua session, press Ctrl-D to exit"); 
-#ifdef HAVE_READLINE
+#if defined(HAVE_READLINE)
   using_history();
   while (const char *line=readline("lua> ")){
     char *expansion = NULL;
@@ -288,8 +331,7 @@ void binding::interactiveSession()
   clear_history();
 #else
   std::string line;
-  while(std::cout<<"lua> ",
-        getline(std::cin,line) ){
+  while(std::cout << "lua> ", getline(std::cin, line)){
     reportErrors(L, luaL_dostring(L, line.c_str()));
   }
 #endif
@@ -307,7 +349,7 @@ binding::binding()
   luaopen_base(L);
   luaopen_table(L);
   luaopen_os(L);
-  //luaopen_io(L);
+  luaopen_io(L);
   luaopen_string(L);
   luaopen_math(L);
   luaopen_debug(L);
@@ -315,7 +357,7 @@ binding::binding()
   luaL_openlibs(L);
 
   lua_register(L, "help",luaHelp);
-  #ifdef HAVE_READLINE
+#if defined(HAVE_READLINE)
   lua_register(L, "saveHistory", luaSave);
   lua_register(L, "clearHistory", luaClear);
   lua_register(L, "refreshGraphics", luaRefresh);

Common/LuaBindings.h

+// Gmsh - Copyright (C) 1997-2010 C. Geuzaine, J.-F. Remacle
+//
+// See the LICENSE.txt file for license information. Please report all
+// bugs and problems to <gmsh@geuz.org>.
+//
+// Contributor(s):
+//   Jonathan Lambrechts
+//
+
 #ifndef _LUA_BINDINGS_H_
 #define _LUA_BINDINGS_H_
 
@@ -8,31 +17,30 @@
 #include "GmshMessage.h"
 #include "Bindings.h"
 
-#ifdef HAVE_LUA
+#if defined(HAVE_LUA)
 
 extern "C" {
 #include "lua.h"
 #include "lauxlib.h"
 }
-/*** store a unique static class name for each binded class ***/
+
+// store a unique static class name for each binded class
 template <typename type>
 class className{
   static std::string _name;
  public:
-  static void set(std::string name){
-    if(_name!=""){
-      throw;
-    }
+  static void set(std::string name)
+  {
+    if(_name != "") Msg::Error("Class name already set");
     _name = name;
   }
-  static const std::string &get(){
-    if(_name==""){
-      Msg::Error("Class unknown to Lua");
-      throw;
-    }
+  static const std::string &get()
+  {
+    if(_name == "") Msg::Error("Class unknown to Lua");
     return _name;
   }
 };
+
 template<typename type>
 std::string  className<type>::_name;
 
@@ -40,19 +48,15 @@ template <>
 template <typename t>
 class className<t*>{
  public:
-  static const std::string get(){
-    return className<t>::get();
-  }
+  static const std::string get(){ return className<t>::get(); }
 };
+
 template <typename t>
 class className<const t &>{
  public:
-  static const std::string get(){
-    return className<t>::get();
-  }
+  static const std::string get(){ return className<t>::get(); }
 };
 
-
 class classBinding;
 class binding {
   static binding *_instance;
@@ -71,14 +75,10 @@ class binding {
 template <>
 class className<lua_State>{
  public:
-  static const std::string get(){
-    return "-1";
-  }
+  static const std::string get(){ return "-1"; }
 };
 
-
-
-/*** lua Stack : templates to get/push value from/on the lua stack ***/
+// lua Stack: templates to get/push value from/on the lua stack
 
 template<class type>
 class luaStack {
@@ -88,56 +88,40 @@ template <>
 class luaStack<void>
 {
  public:
-  static std::string getName(){
-    return "void";
-  }
+  static std::string getName(){ return "void"; }
 };
 
 template<>
 class luaStack<lua_State *>{
  public:
-  static lua_State *get(lua_State *L, int ia){
-    return L;
-  }
-  static std::string getName(){
-    return "-1";
-  }
+  static lua_State *get(lua_State *L, int ia){ return L; }
+  static std::string getName(){ return "-1"; }
 };
 
 template<>
 class luaStack<int>{
  public:
-  static int get(lua_State *L, int ia){
-    int a= luaL_checkint(L,ia);
-    return a;
-  }
-  static void push(lua_State *L, int i){
-    lua_pushinteger(L,i);
-  }
-  static std::string getName(){
-    return "int";
-  }
+  static int get(lua_State *L, int ia){ return luaL_checkint(L, ia); }
+  static void push(lua_State *L, int i){ lua_pushinteger(L, i); }
+  static std::string getName(){ return "int"; }
 };
 
 template<>
 class luaStack<unsigned int>{
  public:
-  static int get(lua_State *L, unsigned int ia){
-    unsigned int a= (unsigned int)luaL_checkint(L,ia);
-    return a;
-  }
-  static void push(lua_State *L, unsigned int i){
-    lua_pushinteger(L,i);
-  }
-  static std::string getName(){
-    return "unsigned int";
+  static int get(lua_State *L, unsigned int ia)
+  { 
+    return (unsigned int)luaL_checkint(L, ia);
   }
+  static void push(lua_State *L, unsigned int i){ lua_pushinteger(L, i); }
+  static std::string getName(){ return "unsigned int"; }
 };
 
 template<class type>
 class luaStack<std::vector<type > >{
  public:
-  static std::vector<type>  get(lua_State *L, int ia){
+  static std::vector<type> get(lua_State *L, int ia)
+  {
     std::vector<type> v;
     size_t size = lua_objlen(L, ia);
     v.resize(size);
@@ -148,22 +132,26 @@ class luaStack<std::vector<type > >{
     }
     return v;
   }
-  static void push(lua_State *L, const std::vector<type>& v){
+  static void push(lua_State *L, const std::vector<type>& v)
+  {
     lua_createtable(L, v.size(), 0);
     for(size_t i = 0; i < v.size; i++){
       luaStack<type>::push(L, v[i]);
       lua_rawseti(L, 2, i + 1);
     }
   }
-  static std::string getName(){
+  static std::string getName()
+  {
     std::string name = "vector of ";
     return name + luaStack<type>::getName();
   }
 };
+
 template<class type>
 class luaStack<std::vector<type> &>{
  public:
-  static std::vector<type>  get(lua_State *L, int ia){
+  static std::vector<type> get(lua_State *L, int ia)
+  {
     std::vector<type> v;
     size_t size = lua_objlen(L, ia);
     v.resize(size);
@@ -174,14 +162,16 @@ class luaStack<std::vector<type > &>{
     }
     return v;
   }
-  static void push(lua_State *L, const std::vector<type>& v){
+  static void push(lua_State *L, const std::vector<type>& v)
+  {
     lua_createtable(L, v.size(), 0);
     for(size_t i = 0; i < v.size; i++){
       luaStack<type>::push(L, v[i]);
       lua_rawseti(L, 2, i + 1);
     }
   }
-  static std::string getName(){
+  static std::string getName()
+  {
     std::string name="vector of ";
     return name + luaStack<type>::getName();
   }
@@ -190,66 +180,65 @@ class luaStack<std::vector<type > &>{
 template<>
 class luaStack<double>{
  public:
-  static double get(lua_State *L, int ia){
-    return luaL_checknumber(L,ia);
-  }
-  static void push(lua_State *L, double v){
-    lua_pushnumber(L,v);
-  }
-  static std::string getName(){
-    return "double";
-  }
+  static double get(lua_State *L, int ia){ return luaL_checknumber(L, ia); }
+  static void push(lua_State *L, double v){ lua_pushnumber(L, v); }
+  static std::string getName(){ return "double"; }
 };
 
 template<>
 class luaStack<std::string>{
   public:
-  static std::string get(lua_State *L, int ia){
-    return luaL_checkstring(L,ia);
-  }
-  static void push(lua_State *L, std::string s){
-    lua_pushstring(L,s.c_str());
-  }
-  static std::string getName(){
-    return "string";
-  }
+  static std::string get(lua_State *L, int ia){ return luaL_checkstring(L, ia); }
+  static void push(lua_State *L, std::string s){ lua_pushstring(L, s.c_str()); }
+  static std::string getName(){ return "string"; }
 };
 
 template <typename type>
 class luaStack<type *>{
   typedef struct { type *pT; } userdataType;
   public:
-  static type* get(lua_State *L, int ia){
+  static type* get(lua_State *L, int ia)
+  {
     userdataType *ud = static_cast<userdataType*>(lua_touserdata(L, ia));
     if(!ud) luaL_typerror(L, ia, className<type>::get().c_str());
     return ud->pT;
   }
-  static void push(lua_State *L,type *obj){
-    userdataType *ud = static_cast<userdataType*>(lua_newuserdata(L, sizeof(userdataType)));
+  static void push(lua_State *L, type *obj)
+  {
+    userdataType *ud = static_cast<userdataType*>
+      (lua_newuserdata(L, sizeof(userdataType)));
     ud->pT=obj;
-    luaL_getmetatable(L,className<type>::get().c_str());  // lookup metatable in Lua registry
+    // lookup metatable in Lua registry
+    luaL_getmetatable(L,className<type>::get().c_str());
     lua_setmetatable(L, -2);
   }
-  static std::string getName(){
+  static std::string getName()
+  {
     return className<type>::get();
   }
 };
+
 template <typename type>
 class luaStack<const type *>{
   typedef struct { type *pT; } userdataType;
   public:
-  static type* get(lua_State *L, int ia){
+  static type* get(lua_State *L, int ia)
+  {
     userdataType *ud = static_cast<userdataType*>(lua_touserdata(L, ia));
     if(!ud) luaL_typerror(L, ia, className<type>::get().c_str());
     return ud->pT;
   }
-  static void push(lua_State *L,const type *obj){
-    userdataType *ud = static_cast<userdataType*>(lua_newuserdata(L, sizeof(userdataType)));
+  static void push(lua_State *L, const type *obj)
+  {
+    userdataType *ud = static_cast<userdataType*>
+      (lua_newuserdata(L, sizeof(userdataType)));
     ud->pT=(type*)obj;
-    luaL_getmetatable(L,className<type>::get().c_str());  // lookup metatable in Lua registry
+    // lookup metatable in Lua registry
+    luaL_getmetatable(L,className<type>::get().c_str());
     lua_setmetatable(L, -2);
   }
-  static std::string getName(){
+  static std::string getName()
+  {
     return className<type>::get();
   }
 };
@@ -258,12 +247,14 @@ template <typename type>
 class luaStack<type &>{
   typedef struct { type *pT; } userdataType;
  public:
-  static type& get(lua_State *L, int ia){
+  static type& get(lua_State *L, int ia)
+  {
     userdataType *ud = static_cast<userdataType*>(lua_touserdata(L, ia));
     if(!ud) luaL_typerror(L, ia, className<type>::get().c_str());
     return *ud->pT; 
   }
-  static std::string getName(){
+  static std::string getName()
+  {
     return className<type>::get();
   }
 };
@@ -272,12 +263,14 @@ template <typename type>
 class luaStack<const type &>{
   typedef struct { type *pT; } userdataType;
  public:
-  static type& get(lua_State *L, int ia){
+  static type& get(lua_State *L, int ia)
+  {
     userdataType *ud = static_cast<userdataType*>(lua_touserdata(L, ia));
     if(!ud) luaL_typerror(L, ia, className<type>::get().c_str());
     return *ud->pT; 
   }
-  static std::string getName(){
+  static std::string getName()
+  {
     return className<type>::get();
   }
 };
@@ -285,10 +278,12 @@ class luaStack<const type &>{
 //static
 template <typename cb>
 class argTypeNames;
-template <typename tr, typename t0, typename t1, typename t2, typename t3, typename t4, typename t5>
+template <typename tr, typename t0, typename t1, typename t2, typename t3, 
+          typename t4, typename t5>
 class argTypeNames<tr (*)(t0, t1, t2, t3, t4, t5)>{
  public:
-  static void get(std::vector<std::string> &names){
+  static void get(std::vector<std::string> &names)
+  {
     names.clear();
     names.push_back(luaStack<tr>::getName());
     names.push_back(luaStack<t0>::getName());
@@ -299,10 +294,13 @@ class argTypeNames<tr (*)(t0,t1,t2,t3,t4,t5)>{
     names.push_back(luaStack<t5>::getName());
   }
 };
-template <typename tr, typename t0, typename t1, typename t2, typename t3, typename t4>
+
+template <typename tr, typename t0, typename t1, typename t2, typename t3, 
+          typename t4>
 class argTypeNames<tr (*)(t0, t1, t2, t3, t4)>{
  public:
-  static void get(std::vector<std::string> &names){
+  static void get(std::vector<std::string> &names)
+  {
     names.clear();
     names.push_back(luaStack<tr>::getName());
     names.push_back(luaStack<t0>::getName());
@@ -312,10 +310,12 @@ class argTypeNames<tr (*)(t0,t1,t2,t3,t4)>{
     names.push_back(luaStack<t4>::getName());
   }
 };
+
 template <typename tr, typename t0, typename t1, typename t2, typename t3>
 class argTypeNames<tr (*)(t0, t1, t2, t3)>{
  public:
-  static void get(std::vector<std::string> &names){
+  static void get(std::vector<std::string> &names)
+  {
     names.clear();
     names.push_back(luaStack<tr>::getName());
     names.push_back(luaStack<t0>::getName());
@@ -324,10 +324,12 @@ class argTypeNames<tr (*)(t0,t1,t2,t3)>{
     names.push_back(luaStack<t3>::getName());
   }
 };
+
 template <typename tr, typename t0, typename t1, typename t2>
 class argTypeNames<tr (*)(t0, t1, t2)>{
  public:
-  static void get(std::vector<std::string> &names){
+  static void get(std::vector<std::string> &names)
+  {
     names.clear();
     names.push_back(luaStack<tr>::getName());
     names.push_back(luaStack<t0>::getName());
@@ -335,29 +337,35 @@ class argTypeNames<tr (*)(t0,t1,t2)>{
     names.push_back(luaStack<t2>::getName());
   }
 };
+
 template <typename tr, typename t0, typename t1>
 class argTypeNames<tr (*)(t0, t1)>{
   public:
-  static void get(std::vector<std::string> &names){
+  static void get(std::vector<std::string> &names)
+  {
     names.clear();
     names.push_back(luaStack<tr>::getName());
     names.push_back(luaStack<t0>::getName());
     names.push_back(luaStack<t1>::getName());
   }
 };
+
 template <typename tr, typename t0>
 class argTypeNames<tr (*)(t0)>{
   public:
-  static void get(std::vector<std::string> &names){
+  static void get(std::vector<std::string> &names)
+  {
     names.clear();
     names.push_back(luaStack<tr>::getName());
     names.push_back(luaStack<t0>::getName());
   }
 };
+
 template <typename tr>
 class argTypeNames<tr (*)()>{
   public:
-  static void get(std::vector<std::string> &names){
+  static void get(std::vector<std::string> &names)
+  {
     names.clear();
     names.push_back(luaStack<tr>::getName());
   }
@@ -365,160 +373,195 @@ class argTypeNames<tr (*)()>{
 
 template <typename cb>
 class argTypeNames;
-template <typename tr, typename tObj, typename t0, typename t1, typename t2, typename t3, typename t4, typename t5>
+template <typename tr, typename tObj, typename t0, typename t1, typename t2,
+          typename t3, typename t4, typename t5>
 class argTypeNames<tr (tObj::*)(t0, t1, t2, t3, t4, t5)>{
  public:
-  static void get(std::vector<std::string> &names){
+  static void get(std::vector<std::string> &names)
+  {
     argTypeNames<tr(*)(t0, t1, t2, t3, t4, t5)>::get(names);
   }
 };
-template <typename tr, typename tObj, typename t0, typename t1, typename t2, typename t3, typename t4>
+
+template <typename tr, typename tObj, typename t0, typename t1, typename t2,
+          typename t3, typename t4>
 class argTypeNames<tr (tObj::*)(t0, t1, t2, t3, t4)>{
  public:
-  static void get(std::vector<std::string> &names){
+  static void get(std::vector<std::string> &names)
+  {
     argTypeNames<tr(*)(t0, t1, t2, t3, t4)>::get(names);
   }
 };
-template <typename tr, typename tObj, typename t0, typename t1, typename t2, typename t3>
+
+template <typename tr, typename tObj, typename t0, typename t1, typename t2,
+          typename t3>
 class argTypeNames<tr (tObj::*)(t0, t1, t2, t3)>{
  public:
-  static void get(std::vector<std::string> &names){
+  static void get(std::vector<std::string> &names)
+  {
     argTypeNames<tr(*)(t0, t1, t2, t3)>::get(names);
   }
 };
+
 template <typename tr, typename tObj, typename t0, typename t1, typename t2>
 class argTypeNames<tr (tObj::*)(t0, t1, t2)>{
  public:
-  static void get(std::vector<std::string> &names){
+  static void get(std::vector<std::string> &names)
+  {
     argTypeNames<tr(*)(t0, t1, t2)>::get(names);
   }
 };
+
 template <typename tr, typename tObj, typename t0, typename t1>
 class argTypeNames<tr (tObj::*)(t0, t1)>{
  public:
-  static void get(std::vector<std::string> &names){
+  static void get(std::vector<std::string> &names)
+  {
     argTypeNames<tr(*)(t0, t1)>::get(names);
   }
 };
+
 template <typename tr, typename tObj, typename t0>
 class argTypeNames<tr (tObj::*)(t0)>{
  public:
-  static void get(std::vector<std::string> &names){
+  static void get(std::vector<std::string> &names)
+  {
     argTypeNames<tr(*)(t0)>::get(names);
   }
 };
+
 template <typename tr, typename tObj>
 class argTypeNames<tr (tObj::*)()>{
  public:
-  static void get(std::vector<std::string> &names){
+  static void get(std::vector<std::string> &names)
+  {
     argTypeNames<tr(*)()>::get(names);
   }
 };
 
-
 // const 
 template <typename cb>
 class argTypeNames;
-template <typename tr, typename tObj, typename t0, typename t1, typename t2, typename t3>
+template <typename tr, typename tObj, typename t0, typename t1, typename t2,
+          typename t3>
 class argTypeNames<tr (tObj::*)(t0, t1, t2, t3)const>{
  public:
-  static void get(std::vector<std::string> &names){
+  static void get(std::vector<std::string> &names)
+  {
     argTypeNames<tr (*)(t0, t1, t2, t3)>::get(names);
   }
 };
+
 template <typename tr, typename tObj, typename t0, typename t1, typename t2>
 class argTypeNames<tr (tObj::*)(t0, t1, t2)const>{
  public:
-  static void get(std::vector<std::string> &names){
+  static void get(std::vector<std::string> &names)
+  {
     argTypeNames<tr (*)(t0, t1, t2)>::get(names);
   }
 };
+
 template <typename tr, typename tObj, typename t0, typename t1>
 class argTypeNames<tr (tObj::*)(t0, t1)const>{
   public:
-  static void get(std::vector<std::string> &names){
+  static void get(std::vector<std::string> &names)
+  {
     argTypeNames<tr (*)(t0, t1)>::get(names);
   }
 };
+
 template <typename tr, typename tObj, typename t0>
 class argTypeNames<tr (tObj::*)(t0)const>{
  public:
-  static void get(std::vector<std::string> &names){
+  static void get(std::vector<std::string> &names)
+  {
     argTypeNames<tr (*)(t0)>::get(names);
   }
 };
+
 template <typename tr, typename tObj>
 class argTypeNames<tr (tObj::*)()const>{
  public:
-  static void get(std::vector<std::string> &names){
+  static void get(std::vector<std::string> &names)
+  {
     argTypeNames<tr (*)()>::get(names);
   }
 };
 
-/*** template to call c function from the lua stack ***/
+// template to call c function from the lua stack
 // static, return 
 template < typename tRet, typename t0, typename t1, typename t2, typename t3>
-static int luaCall(lua_State *L,tRet (*_f)(t0,t1,t2,t3)) {
-  if (lua_gettop(L)==5)
-    lua_remove(L,1);
-  luaStack<tRet>::push(L,(*(_f))(luaStack<t0>::get(L,1),luaStack<t1>::get(L,2),luaStack<t2>::get(L,3),luaStack<t3>::get(L,4)));
+static int luaCall(lua_State *L, tRet (*_f)(t0, t1, t2, t3))
+{
+  if (lua_gettop(L) == 5) lua_remove(L, 1);
+  luaStack<tRet>::push(L, (*_f)(luaStack<t0>::get(L, 1), luaStack<t1>::get(L, 2),
+                                luaStack<t2>::get(L, 3), luaStack<t3>::get(L, 4)));
   return 1;
 };
+
 template < typename tRet, typename t0, typename t1, typename t2>
-static int luaCall(lua_State *L,tRet (*_f)(t0,t1,t2)) {
-  if (lua_gettop(L)==4)
-    lua_remove(L,1);
-  luaStack<tRet>::push(L,(*(_f))(luaStack<t0>::get(L,1),luaStack<t1>::get(L,2),luaStack<t2>::get(L,3)));
+static int luaCall(lua_State *L, tRet (*_f)(t0, t1, t2))
+{
+  if (lua_gettop(L) == 4) lua_remove(L,1);
+  luaStack<tRet>::push(L, (*_f)(luaStack<t0>::get(L, 1), luaStack<t1>::get(L, 2),
+                                luaStack<t2>::get(L, 3)));
   return 1;
 };
+
 template < typename tRet, typename t0, typename t1>
-static int luaCall(lua_State *L,tRet (*_f)(t0,t1)) {
-  if (lua_gettop(L)==3)
-    lua_remove(L,1);
-  luaStack<tRet>::push(L,(*(_f))(luaStack<t0>::get(L,1),luaStack<t1>::get(L,2)));
+static int luaCall(lua_State *L, tRet (*_f)(t0, t1))
+{
+  if (lua_gettop(L) == 3) lua_remove(L, 1);
+  luaStack<tRet>::push(L, (*_f)(luaStack<t0>::get(L, 1), luaStack<t1>::get(L, 2)));
   return 1;
 };
+
 template < typename tRet, typename t0>
-static int luaCall(lua_State *L,tRet (*_f)(t0)) {
-  if (lua_gettop(L)==2)
-    lua_remove(L,1);
-  luaStack<tRet>::push(L,(*(_f))(luaStack<t0>::get(L,1)));
+static int luaCall(lua_State *L, tRet (*_f)(t0))
+{
+  if (lua_gettop(L) == 2) lua_remove(L, 1);
+  luaStack<tRet>::push(L, (*_f)(luaStack<t0>::get(L, 1)));
   return 1;
 };
+
 template < typename tRet>
-static int luaCall(lua_State *L,tRet (*_f)()) {
-  if (lua_gettop(L)==1)
-    lua_remove(L,1);
-  luaStack<tRet>::push(L,(*(_f))());
+static int luaCall(lua_State *L, tRet (*_f)())
+{
+  if (lua_gettop(L) == 1) lua_remove(L, 1);
+  luaStack<tRet>::push(L, (*_f)());
   return 1;
 };
 
 //static, no return 
 template < typename t0, typename t1, typename t2, typename t3>
-static int luaCall(lua_State *L, void (*_f)(t0,t1,t2,t3)) {
-  if (lua_gettop(L)==5)
-    lua_remove(L,1);
-  (*(_f))(luaStack<t0>::get(L,1),luaStack<t1>::get(L,2),luaStack<t2>::get(L,3),luaStack<t3>::get(L,4));
+static int luaCall(lua_State *L, void (*_f)(t0, t1, t2, t3))
+{
+  if (lua_gettop(L) == 5) lua_remove(L, 1);
+  (*(_f))(luaStack<t0>::get(L, 1), luaStack<t1>::get(L, 2),
+          luaStack<t2>::get(L, 3), luaStack<t3>::get(L, 4));
   return 1;
 };
+
 template <typename t0, typename t1, typename t2>
-static int luaCall(lua_State *L, void (*_f)(t0,t1,t2)) {
-  if (lua_gettop(L)==4)
-    lua_remove(L,1);
+static int luaCall(lua_State *L, void (*_f)(t0, t1, t2))
+{
+  if (lua_gettop(L) == 4) lua_remove(L, 1);
   (*(_f))(luaStack<t0>::get(L, 1), luaStack<t1>::get(L, 2),luaStack<t2>::get(L, 3));
   return 1;
 };
+
 template <typename t0, typename t1>
-static int luaCall(lua_State *L,void (*_f)(t0,t1)) {
-  if (lua_gettop(L)==3)
-    lua_remove(L,1);
+static int luaCall(lua_State *L,void (*_f)(t0, t1))
+{
+  if (lua_gettop(L) == 3) lua_remove(L,1);
   (*(_f))(luaStack<t0>::get(L,1),luaStack<t1>::get(L,2));
   return 1;
 };
+
 template <typename t0>
-static int luaCall(lua_State *L, void (*_f)(t0)) {
-  if (lua_gettop(L)==2)
-    lua_remove(L,1);
+static int luaCall(lua_State *L, void (*_f)(t0))
+{
+  if (lua_gettop(L) == 2) lua_remove(L, 1);
   (*(_f))(luaStack<t0>::get(L, 1));
   return 1;
 };
@@ -527,34 +570,49 @@ template <>
 #if (__GNUC__< 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 3))
 static 
 #endif
-int luaCall<void>(lua_State *L,void (*_f)()) {
-  if (lua_gettop(L)==1)
-    lua_remove(L,1);
+int luaCall<void>(lua_State *L,void (*_f)())
+{
+  if (lua_gettop(L) == 1) lua_remove(L,1);
   (*(_f))();
   return 1;
 }
 
 //const, return
-template <typename tObj, typename tRet, typename t0, typename t1, typename t2, typename t3>
-static int luaCall(lua_State *L,tRet (tObj::*_f)(t0,t1,t2,t3) const) {
-  luaStack<tRet>::push(L,(luaStack<tObj*>::get(L,1)->*(_f))(luaStack<t0>::get(L,2),luaStack<t1>::get(L,3),luaStack<t2>::get(L,4),luaStack<t3>::get(L,5)));
+template <typename tObj, typename tRet, typename t0, typename t1, typename t2,
+          typename t3>
+static int luaCall(lua_State *L, tRet (tObj::*_f)(t0, t1, t2, t3) const)
+{
+  luaStack<tRet>::push(L, (luaStack<tObj*>::get(L, 1)->*(_f))
+                       (luaStack<t0>::get(L, 2), luaStack<t1>::get(L, 3), 
+                        luaStack<t2>::get(L, 4), luaStack<t3>::get(L, 5)));
   return 1;
 };
+
 template <typename tObj, typename tRet, typename t0, typename t1, typename t2>
-static int luaCall(lua_State *L,tRet (tObj::*_f)(t0,t1,t2) const) {
-  luaStack<tRet>::push(L,(luaStack<tObj*>::get(L,1)->*(_f))(luaStack<t0>::get(L,2),luaStack<t1>::get(L,3),luaStack<t2>::get(L,4)));
+static int luaCall(lua_State *L, tRet (tObj::*_f)(t0, t1, t2) const)
+{
+  luaStack<tRet>::push(L,(luaStack<tObj*>::get(L, 1)->*(_f))
+                       (luaStack<t0>::get(L, 2), luaStack<t1>::get(L, 3),
+                        luaStack<t2>::get(L, 4)));
   return 1;
 };
+
 template <typename tObj, typename tRet, typename t0, typename t1>
-static int luaCall(lua_State *L,tRet (tObj::*_f)(t0,t1) const) {
-  luaStack<tRet>::push(L,(luaStack<tObj*>::get(L,1)->*(_f))(luaStack<t0>::get(L,2),luaStack<t1>::get(L,3)));
+static int luaCall(lua_State *L, tRet (tObj::*_f)(t0, t1) const)
+{
+  luaStack<tRet>::push(L, (luaStack<tObj*>::get(L, 1)->*(_f))
+                       (luaStack<t0>::get(L, 2),luaStack<t1>::get(L, 3)));
   return 1;
 };
+
 template <typename tObj, typename tRet, typename t0>
-static int luaCall(lua_State *L,tRet (tObj::*_f)(t0) const) {
-  luaStack<tRet>::push(L,(luaStack<tObj*>::get(L,1)->*(_f))(luaStack<t0>::get(L,2)));
+static int luaCall(lua_State *L, tRet (tObj::*_f)(t0) const)
+{
+  luaStack<tRet>::push(L, (luaStack<tObj*>::get(L, 1)->*(_f))
+                       (luaStack<t0>::get(L, 2)));
   return 1;
 };
+
 template <typename tObj, typename tRet>
 static int luaCall(lua_State *L, tRet (tObj::*_f)() const) {
   luaStack<tRet>::push(L,(luaStack<tObj*>::get(L,1)->*(_f))());
@@ -562,123 +620,172 @@ static int luaCall(lua_State *L,tRet (tObj::*_f)() const) {
 };
 
 //non const, return
-template <typename tObj, typename tRet, typename t0, typename t1, typename t2, typename t3, typename t4, typename t5>
-static int luaCall(lua_State *L,tRet (tObj::*_f)(t0,t1,t2,t3,t4,t5)) {
-  luaStack<tRet>::push(L,(luaStack<tObj*>::get(L,1)->*(_f))(luaStack<t0>::get(L,2),luaStack<t1>::get(L,3),luaStack<t2>::get(L,4),luaStack<t3>::get(L,5),luaStack<t4>::get(L,6),luaStack<t5>::get(L,7)));
+template <typename tObj, typename tRet, typename t0, typename t1, typename t2,
+          typename t3, typename  t4, typename t5>
+static int luaCall(lua_State *L,tRet (tObj::*_f)(t0, t1, t2, t3, t4, t5))
+{
+  luaStack<tRet>::push(L,(luaStack<tObj*>::get(L, 1)->*(_f))
+                       (luaStack<t0>::get(L, 2), luaStack<t1>::get(L, 3),
+                        luaStack<t2>::get(L, 4), luaStack<t3>::get(L, 5),
+                        luaStack<t4>::get(L, 6), luaStack<t5>::get(L, 7)));
   return 1;
 };
-template <typename tObj, typename tRet, typename t0, typename t1, typename t2, typename t3, typename t4>
-static int luaCall(lua_State *L,tRet (tObj::*_f)(t0,t1,t2,t3,t4)) {
-  luaStack<tRet>::push(L,(luaStack<tObj*>::get(L,1)->*(_f))(luaStack<t0>::get(L,2),luaStack<t1>::get(L,3),luaStack<t2>::get(L,4),luaStack<t3>::get(L,5),luaStack<t4>::get(L,6)));
+
+template <typename tObj, typename tRet, typename t0, typename t1, typename t2, 
+          typename t3, typename t4>
+static int luaCall(lua_State *L, tRet (tObj::*_f)(t0, t1, t2, t3, t4))
+{
+  luaStack<tRet>::push(L, (luaStack<tObj*>::get(L, 1)->*(_f))
+                       (luaStack<t0>::get(L, 2), luaStack<t1>::get(L, 3), 
+                        luaStack<t2>::get(L, 4), luaStack<t3>::get(L, 5),
+                        luaStack<t4>::get(L, 6)));
   return 1;
 };
-template <typename tObj, typename tRet, typename t0, typename t1, typename t2, typename t3>
+
+template <typename tObj, typename tRet, typename t0, typename t1, typename t2, 
+          typename t3>
 static int luaCall(lua_State *L,tRet (tObj::*_f)(t0, t1, t2, t3)) {
-  luaStack<tRet>::push(L,(luaStack<tObj*>::get(L,1)->*(_f))(luaStack<t0>::get(L,2),luaStack<t1>::get(L,3),luaStack<t2>::get(L,4),luaStack<t3>::get(L,5)));
+  luaStack<tRet>::push(L, (luaStack<tObj*>::get(L,1)->*(_f))
+                       (luaStack<t0>::get(L, 2), luaStack<t1>::get(L, 3),
+                        luaStack<t2>::get(L, 4), luaStack<t3>::get(L, 5)));
   return 1;
 };
+
 template <typename tObj, typename tRet, typename t0, typename t1, typename t2>
 static int luaCall(lua_State *L,tRet (tObj::*_f)(t0, t1, t2)) {
-  luaStack<tRet>::push(L,(luaStack<tObj*>::get(L,1)->*(_f))(luaStack<t0>::get(L,2),luaStack<t1>::get(L,3),luaStack<t2>::get(L,4)));
+  luaStack<tRet>::push(L, (luaStack<tObj*>::get(L, 1)->*(_f))
+                       (luaStack<t0>::get(L, 2), luaStack<t1>::get(L, 3),
+                        luaStack<t2>::get(L, 4)));
   return 1;
 };
+
 template <typename tObj, typename tRet, typename t0, typename t1>
-static int luaCall(lua_State *L,tRet (tObj::*_f)(t0,t1)) {
-  luaStack<tRet>::push(L,(luaStack<tObj*>::get(L,1)->*(_f))(luaStack<t0>::get(L,2),luaStack<t1>::get(L,3)));
+static int luaCall(lua_State *L,tRet (tObj::*_f)(t0, t1))
+{
+  luaStack<tRet>::push(L, (luaStack<tObj*>::get(L, 1)->*(_f))
+                       (luaStack<t0>::get(L, 2),luaStack<t1>::get(L, 3)));
   return 1;
 };
+
 template <typename tObj, typename tRet, typename t0>
-static int luaCall(lua_State *L,tRet (tObj::*_f)(t0)) {
+static int luaCall(lua_State *L,tRet (tObj::*_f)(t0))
+{
   luaStack<tRet>::push(L, (luaStack<tObj*>::get(L,1)->*(_f))(luaStack<t0>::get(L, 2)));
   return 1;
 };
+
 template <typename tObj, typename tRet>
-static int luaCall(lua_State *L,tRet (tObj::*_f)()) {
+static int luaCall(lua_State *L,tRet (tObj::*_f)())
+{
   luaStack<tRet>::push(L, (luaStack<tObj*>::get(L,1)->*(_f))());
   return 1;
 };
 
 //const, no return
 template <typename tObj, typename t0, typename t1, typename t2, typename t3>
-static int luaCall(lua_State *L,void (tObj::*_f)(t0,t1,t2,t3) const) {
-  (luaStack<tObj*>::get(L,1)->*(_f))(luaStack<t0>::get(L,2),luaStack<t1>::get(L,3),luaStack<t2>::get(L,4),luaStack<t3>::get(L,5));
+static int luaCall(lua_State *L, void (tObj::*_f)(t0, t1, t2, t3) const)
+{
+  (luaStack<tObj*>::get(L,1)->*(_f))
+    (luaStack<t0>::get(L, 2), luaStack<t1>::get(L, 3), luaStack<t2>::get(L, 4),
+     luaStack<t3>::get(L, 5));
   return 0;
 };
+
 template <typename tObj, typename t0, typename t1, typename t2>
-static int luaCall(lua_State *L,void (tObj::*_f)(t0,t1,t2) const) {
-  (luaStack<tObj*>::get(L,1)->*(_f))(luaStack<t0>::get(L,2),luaStack<t1>::get(L,3),luaStack<t2>::get(L,4));
+static int luaCall(lua_State *L, void (tObj::*_f)(t0, t1, t2) const)
+{
+  (luaStack<tObj*>::get(L, 1)->*(_f))
+    (luaStack<t0>::get(L, 2), luaStack<t1>::get(L, 3), luaStack<t2>::get(L, 4));
   return 0;
 };
+
 template <typename tObj, typename t0, typename t1>
-static int luaCall(lua_State *L,void (tObj::*_f)(t0,t1) const) {
-  (luaStack<tObj*>::get(L,1)->*(_f))(luaStack<t0>::get(L,2),luaStack<t1>::get(L,3));
+static int luaCall(lua_State *L, void (tObj::*_f)(t0, t1) const)
+{
+  (luaStack<tObj*>::get(L, 1)->*(_f))
+    (luaStack<t0>::get(L, 2), luaStack<t1>::get(L, 3));
   return 0;
 };
+
 template <typename tObj, typename t0>
 static int luaCall(lua_State *L, void (tObj::*_f)(t0) const) {
   (luaStack<tObj*>::get(L, 1)->*(_f))(luaStack<t0>::get(L, 2));
   return 0;
 };
+
 template <typename tObj>
-static int luaCall(lua_State *L,void (tObj::*_f)() const) {
+static int luaCall(lua_State *L, void (tObj::*_f)() const)
+{
   (luaStack<tObj*>::get(L, 1)->*(_f))();
   return 0;
 };
 
-
-
 //non const, no return
-template <typename tObj, typename t0, typename t1, typename t2, typename t3, typename t4, typename t5>
-static int luaCall(lua_State *L,void (tObj::*_f)(t0,t1,t2,t3,t4,t5)) {
-  (luaStack<tObj*>::get(L,1)->*(_f))(luaStack<t0>::get(L,2),luaStack<t1>::get(L,3),luaStack<t2>::get(L,4),luaStack<t3>::get(L,5),luaStack<t4>::get(L,6),luaStack<t5>::get(L,7));
+template <typename tObj, typename t0, typename t1, typename t2, typename t3, 
+          typename t4, typename t5>
+static int luaCall(lua_State *L, void (tObj::*_f)(t0, t1, t2, t3, t4, t5))
+{
+  (luaStack<tObj*>::get(L, 1)->*(_f))
+    (luaStack<t0>::get(L, 2), luaStack<t1>::get(L, 3), luaStack<t2>::get(L, 4),
+     luaStack<t3>::get(L, 5), luaStack<t4>::get(L, 6), luaStack<t5>::get(L, 7));
   return 1;
 };
-template <typename tObj, typename t0, typename t1, typename t2, typename t3, typename t4>
-static int luaCall(lua_State *L,void (tObj::*_f)(t0,t1,t2,t3,t4)) {
-  (luaStack<tObj*>::get(L,1)->*(_f))(luaStack<t0>::get(L,2),luaStack<t1>::get(L,3),luaStack<t2>::get(L,4),luaStack<t3>::get(L,5),luaStack<t4>::get(L,6));
+
+template <typename tObj, typename t0, typename t1, typename t2, typename t3, 
+          typename t4>
+static int luaCall(lua_State *L, void (tObj::*_f)(t0, t1, t2, t3, t4))
+{
+  (luaStack<tObj*>::get(L, 1)->*(_f))
+    (luaStack<t0>::get(L, 2), luaStack<t1>::get(L, 3), luaStack<t2>::get(L, 4),
+     luaStack<t3>::get(L, 5), luaStack<t4>::get(L, 6));
   return 1;
 };
+
 template <typename tObj, typename t0, typename t1, typename t2, typename t3>
-static int luaCall(lua_State *L,void (tObj::*_f)(t0,t1,t2,t3)) {
-  (luaStack<tObj*>::get(L,1)->*(_f))(luaStack<t0>::get(L,2),luaStack<t1>::get(L,3),luaStack<t2>::get(L,4),luaStack<t3>::get(L,5));
+static int luaCall(lua_State *L, void (tObj::*_f)(t0, t1, t2, t3)) 
+{
+  (luaStack<tObj*>::get(L, 1)->*(_f))
+    (luaStack<t0>::get(L, 2), luaStack<t1>::get(L, 3), luaStack<t2>::get(L, 4),
+     luaStack<t3>::get(L, 5));
   return 0;
 };
+
 template <typename tObj, typename t0, typename t1, typename t2>
-static int luaCall(lua_State *L,void (tObj::*_f)(t0,t1,t2)) {
-  (luaStack<tObj*>::get(L,1)->*(_f))(luaStack<t0>::get(L,2),luaStack<t1>::get(L,3),luaStack<t2>::get(L,4));
+static int luaCall(lua_State *L, void (tObj::*_f)(t0, t1, t2))
+{
+  (luaStack<tObj*>::get(L, 1)->*(_f))
+    (luaStack<t0>::get(L, 2), luaStack<t1>::get(L, 3), luaStack<t2>::get(L, 4));
   return 0;
 };
+
 template <typename tObj, typename t0, typename t1>
-static int luaCall(lua_State *L,void (tObj::*_f)(t0,t1)) {
-  (luaStack<tObj*>::get(L,1)->*(_f))(luaStack<t0>::get(L,2),luaStack<t1>::get(L,3));
+static int luaCall(lua_State *L, void (tObj::*_f)(t0, t1))
+{
+  (luaStack<tObj*>::get(L, 1)->*(_f))
+    (luaStack<t0>::get(L, 2), luaStack<t1>::get(L, 3));
   return 0;
 };
 template <typename tObj, typename t0>
-static int luaCall(lua_State *L,void (tObj::*_f)(t0)) {
+static int luaCall(lua_State *L, void (tObj::*_f)(t0))
+{
   (luaStack<tObj*>::get(L,1)->*(_f))(luaStack<t0>::get(L, 2));
   return 0;
 };
+
 template <typename tObj>
-static int luaCall(lua_State *L,void (tObj::*_f)()) {
+static int luaCall(lua_State *L,void (tObj::*_f)())
+{
   (luaStack<tObj*>::get(L,1)->*(_f))();
   return 0;
 };
 
-
-/*** arg names ***/
-
-
-/*** actual bindings classes ***/
+// actual bindings classes
 class luaMethodBinding : public methodBinding{
  public:
   std::string _luaname;
   virtual int call (lua_State *L) = 0;
-  luaMethodBinding(const std::string luaname){
-    _luaname=luaname;
-  }
-  luaMethodBinding(){
-    _luaname="";
-  }
+  luaMethodBinding(const std::string luaname){ _luaname = luaname; }
+  luaMethodBinding(){ _luaname = ""; }
   virtual void getArgTypeNames(std::vector<std::string> &names){};
 };
 
@@ -686,26 +793,25 @@ template <typename cb>
 class methodBindingT :public luaMethodBinding {
  public:
   cb _f;
-  methodBindingT(const std::string luaname,cb f):luaMethodBinding(luaname) {
-    _f=f;
-  }
-  int call (lua_State *L) {
-    return luaCall(L,_f);
-  }
-  void getArgTypeNames(std::vector<std::string> &names) {
-    argTypeNames<cb>::get(names);
-  }
+  methodBindingT(const std::string luaname, cb f) : luaMethodBinding(luaname) { _f = f; }
+  int call(lua_State *L){ return luaCall(L, _f); }
+  void getArgTypeNames(std::vector<std::string> &names){ argTypeNames<cb>::get(names); }
 };
 
-template <typename tObj, typename t0=void, typename t1=void , typename t2=void, typename t3=void, typename t4=void>
+template <typename tObj, typename t0=void, typename t1=void, typename t2=void, 
+          typename t3=void, typename t4=void>
 class constructorBindingT: public luaMethodBinding {
  public:
-  int call (lua_State *L) {
+  int call(lua_State *L)
+  {
     lua_remove(L, 1);
-    (luaStack<tObj*>::push(L,new tObj(luaStack<t0>::get(L,1),luaStack<t1>::get(L,2),luaStack<t2>::get(L,3), luaStack<t3>::get(L,4),  luaStack<t4>::get(L, 5))));
+    (luaStack<tObj*>::push(L, new tObj(luaStack<t0>::get(L, 1), luaStack<t1>::get(L, 2),
+                                       luaStack<t2>::get(L, 3), luaStack<t3>::get(L, 4),
+                                       luaStack<t4>::get(L, 5))));
     return 1;
   }
-  void getArgTypeNames(std::vector<std::string> &names) {
+  void getArgTypeNames(std::vector<std::string> &names)
+  {
     argTypeNames<void (tObj::*)(t0, t1, t2, t3, t4)>::get(names);
   }
 };
@@ -713,19 +819,23 @@ class constructorBindingT:public luaMethodBinding {
 template <typename tObj>
 class constructorBindingT<tObj, void, void, void, void> : public luaMethodBinding {
  public:
-  int call (lua_State *L) {
+  int call(lua_State *L)
+  {
     lua_remove(L, 1);
     (luaStack<tObj*>::push(L, new tObj()));
     return 1;
   }
-  void getArgTypeNames(std::vector<std::string> &names) {
+  void getArgTypeNames(std::vector<std::string> &names)
+  {
     argTypeNames<void (tObj::*)()>::get(names);
   }
 };
+
 template <typename tObj, typename t0>
 class constructorBindingT<tObj, t0, void, void, void, void> : public luaMethodBinding {
  public:
-  int call (lua_State *L) {
+  int call(lua_State *L)
+  {
     lua_remove(L,1);
     (luaStack<tObj*>::push(L,new tObj(luaStack<t0>::get(L,1))));
     return 1;
@@ -734,39 +844,50 @@ class constructorBindingT<tObj,t0,void,void,void,void>:public luaMethodBinding {
     argTypeNames<void (tObj::*)(t0)>::get(names);
   }
 };
+
 template <typename tObj, typename t0, typename t1>
 class constructorBindingT<tObj, t0, t1, void, void, void> : public luaMethodBinding {
  public:
-  int call (lua_State *L) {
+  int call(lua_State *L)
+  {
     lua_remove(L, 1);
     (luaStack<tObj*>::push(L, new tObj(luaStack<t0>::get(L, 1), luaStack<t1>::get(L, 2))));
     return 1;
   }
-  void getArgTypeNames(std::vector<std::string> &names) {
+  void getArgTypeNames(std::vector<std::string> &names)
+  {
     argTypeNames<void (tObj::*)(t0, t1)>::get(names);
   }
 };
+
 template <typename tObj, typename t0, typename t1, typename t2>
 class constructorBindingT<tObj, t0, t1, t2, void, void> : public luaMethodBinding {
  public:
-  int call (lua_State *L) {
+  int call(lua_State *L)
+  {
     lua_remove(L, 1);
-    (luaStack<tObj*>::push(L,new tObj(luaStack<t0>::get(L,1),luaStack<t1>::get(L,2),luaStack<t2>::get(L,3))));
+    (luaStack<tObj*>::push(L, new tObj(luaStack<t0>::get(L, 1), luaStack<t1>::get(L, 2),
+                                       luaStack<t2>::get(L, 3))));
     return 1;
   }
-  void getArgTypeNames(std::vector<std::string> &names) {
+  void getArgTypeNames(std::vector<std::string> &names)
+  {
     argTypeNames<void (tObj::*)(t0, t1, t2)>::get(names);
   }
 };
+
 template <typename tObj, typename t0, typename t1, typename t2,  typename t3>
 class constructorBindingT<tObj, t0, t1, t2, t3, void> : public luaMethodBinding {
  public:
-  int call (lua_State *L) {
+  int call(lua_State *L)
+  {
     lua_remove(L, 1);
-    (luaStack<tObj*>::push(L,new tObj(luaStack<t0>::get(L,1),luaStack<t1>::get(L,2),luaStack<t2>::get(L,3), luaStack<t3>::get(L,4))));
+    (luaStack<tObj*>::push(L, new tObj(luaStack<t0>::get(L, 1), luaStack<t1>::get(L, 2),
+                                       luaStack<t2>::get(L, 3), luaStack<t3>::get(L, 4))));
     return 1;
   }
-  void getArgTypeNames(std::vector<std::string> &names) {
+  void getArgTypeNames(std::vector<std::string> &names)
+  {
     argTypeNames<void (tObj::*)(t0, t1, t2, t3)>::get(names);
   }
 };
@@ -775,17 +896,22 @@ class classBinding {
   std::string _className;
   binding *_b;
   luaMethodBinding *_constructor;
-  static int callMethod(lua_State *L) {
+  static int callMethod(lua_State *L)
+  {
     return static_cast<luaMethodBinding*>(lua_touserdata(L, lua_upvalueindex(1)))->call(L); 
   }
-  //I'd like to remove the "luaMethodBinding" and the "methodBindingT" classes and use this callback insteak
-  //but for some reason I don't understand, it does not work
-  static int callMethod2(lua_State *L) {
-    int (*f)(lua_State*,void *)=(int (*)(lua_State*,void*))(lua_touserdata(L,lua_upvalueindex(1)));
+  // I'd like to remove the "luaMethodBinding" and the "methodBindingT"
+  // classes and use this callback insteak but for some reason I don't
+  // understand, it does not work
+  static int callMethod2(lua_State *L)
+  {
+    int (*f)(lua_State*, void *) = (int (*)(lua_State*, void*))
+      (lua_touserdata(L, lua_upvalueindex(1)));
     void *ff=lua_touserdata(L, lua_upvalueindex(2));
     return (*f)(L, ff);
   }
-  static int tostring (lua_State *L) {
+  static int tostring(lua_State *L)
+  {
     typedef struct { void *pt; } userdata;
     char buff[32];
     const char *name = luaL_checkstring(L, lua_upvalueindex(1));
@@ -794,7 +920,8 @@ class classBinding {
     lua_pushfstring(L, "%s (%s)", name, buff);
     return 1;
   }
-  void setConstructorLuaMethod(luaMethodBinding *constructor){
+  void setConstructorLuaMethod(luaMethodBinding *constructor)
+  {
     lua_State *L = _b->L;
     lua_getglobal(L, _className.c_str());
     int methods = lua_gettop(L);
@@ -811,11 +938,10 @@ class classBinding {
   classBinding *_parent;
  public:
   std::set<classBinding *> children;
-  inline luaMethodBinding *getConstructor(){
-    return _constructor;
-  }
+  inline luaMethodBinding *getConstructor(){ return _constructor; }
   // get userdata from Lua stack and return pointer to T object
-  classBinding(binding *b, std::string name){
+  classBinding(binding *b, std::string name)
+  {
     _b = b;
     lua_State *L = _b->L;
     _className = name;
@@ -824,8 +950,10 @@ public:
 
     // there are 3 tables involved :
     // methods : the table of the C++ functions we bind (exept constructor)
-    // metatable : the metatable attached to each intance of the class, falling back to method (metatable.__index=method)
-    // mt : the metatable of method to store the constructor (__new) and possibly falling back to the parent metatable( __index)
+    // metatable : the metatable attached to each intance of the
+    //   class, falling back to method (metatable.__index=method)
+    // mt : the metatable of method to store the constructor (__new)
+    //   and possibly falling back to the parent metatable( __index)
     lua_newtable(L); // methods
     int methods = lua_gettop(L);
     lua_pushvalue(L, methods);
@@ -848,9 +976,11 @@ public:
     lua_pop(L, 2);  // drop metatable and method table
   } 
   template<typename parentType>
-  void setParentClass(){
+  void setParentClass()
+  {
     if(_parent)
-      Msg::Error("Multiple inheritance not implemented in lua bindings for class %s",_className.c_str());
+      Msg::Error("Multiple inheritance not implemented in lua bindings "
+                 "for class %s", _className.c_str());
     std::string parentClassName = className<parentType>::get();
     _parent = _b->classes[parentClassName];
     _parent->children.insert(this);
@@ -858,23 +988,20 @@ public:
     lua_getmetatable(_b->L, -1);
     int mt=lua_gettop(_b->L);
     lua_getglobal(_b->L, parentClassName.c_str());
-    lua_setfield(_b->L,mt,"__index");// mt.__index = global[_parentClassName] // this is the inheritance bit
+    lua_setfield(_b->L, mt, "__index"); 
+    // mt.__index = global[_parentClassName] // this is the inheritance bit
     lua_pop(_b->L, 2);
   }
-
-  void setDescription(std::string description){
-    _description = description;
-  }
-  inline const std::string getDescription()const {return _description;};
-  inline classBinding *getParent()const {return _parent;};
+  void setDescription(std::string description){ _description = description; }
+  inline const std::string getDescription() const { return _description; }
+  inline classBinding *getParent() const { return _parent; }
   std::map<std::string, luaMethodBinding *> methods;
-
   template <typename cb>
-  methodBinding *addMethod(std::string n, cb f){
+  methodBinding *addMethod(std::string n, cb f)
+  {
     luaMethodBinding *mb = new methodBindingT<cb>(n, f);
     methods[n] = mb;
     lua_State *L = _b->L;
-
     lua_getglobal(L, _className.c_str());
     int methods = lua_gettop(L);
     /*int (*lc)(lua_State *,cb)=(int(*)(lua_State*,cb))luaCall;
@@ -887,38 +1014,45 @@ public:
     lua_pop(L, 1);
     return mb; 
   }
-  template <typename tObj, typename t0, typename t1, typename t2, typename t3, typename t4>
-  methodBinding *setConstructor(){
+  template <typename tObj, typename t0, typename t1, typename t2, typename t3, 
+            typename t4>
+  methodBinding *setConstructor()
+  {
     luaMethodBinding *constructorLua = new constructorBindingT<tObj,t0,t1,t2,t3,t4>;
     setConstructorLuaMethod(constructorLua);
     return constructorLua;
   }
   template <typename tObj, typename t0, typename t1, typename t2, typename t3 >
-  methodBinding *setConstructor(){
+  methodBinding *setConstructor()
+  {
     luaMethodBinding *constructorLua = new constructorBindingT<tObj,t0,t1,t2,t3>;
     setConstructorLuaMethod(constructorLua);
     return constructorLua;
   }
   template <typename tObj, typename t0, typename t1, typename t2 >
-  methodBinding *setConstructor(){
+  methodBinding *setConstructor()
+  {
     luaMethodBinding *constructorLua = new constructorBindingT<tObj,t0,t1,t2>;
     setConstructorLuaMethod(constructorLua);
     return constructorLua;
   }
   template <typename tObj, typename t0, typename t1>
-  methodBinding *setConstructor(){
+  methodBinding *setConstructor()
+  {
     luaMethodBinding *constructorLua = new constructorBindingT<tObj,t0,t1>;
     setConstructorLuaMethod(constructorLua);
     return constructorLua;
   }
   template <typename tObj, typename t0>
-  methodBinding *setConstructor(){
+  methodBinding *setConstructor()
+  {
     luaMethodBinding *constructorLua = new constructorBindingT<tObj,t0>;
     setConstructorLuaMethod(constructorLua);
     return constructorLua;
   }
   template<typename tObj>
-  methodBinding *setConstructor(){
+  methodBinding *setConstructor()
+  {
     luaMethodBinding *constructorLua = new constructorBindingT<tObj>;
     setConstructorLuaMethod(constructorLua);
     return constructorLua;
@@ -926,13 +1060,14 @@ public:
   inline const std::string getClassName()const {return _className;}
 };
 
-
 template<typename t>
-classBinding *binding::addClass(std::string name){
+classBinding *binding::addClass(std::string name)
+{
   className<t>::set(name);
   classBinding *cb = new classBinding(this, name);
   classes[name] = cb;
   return cb;
 }
+
 #endif
 #endif

Geo/GFaceCompound.cpp

@@ -2,6 +2,10 @@
 //
 // See the LICENSE.txt file for license information. Please report all
 // bugs and problems to <gmsh@geuz.org>.
+//
+// Contributor(s):
+//   Emilie Marchandise
+//
 
 #include "GmshConfig.h"
 

doc/CREDITS.txt

@@ -11,17 +11,17 @@
 Code contributions to Gmsh have been provided by David Colignon
 (colormaps), Emilie Marchandise (compound geometrical entities),
 Gaetan Bricteux (Gauss integration and levelsets), Jacques Lechelle
-(DIFFPACK mesh format), Jonathan Lambrechts (fields), Jozef Vesely
-(Tetgen), Koen Hillewaert (high order elements), Laurent Stainier
-(eigenvalue solvers, tensor display and MacOS bits), Marc Ume
+(DIFFPACK mesh format), Jonathan Lambrechts (fields, solver), Jozef
+Vesely (Tetgen), Koen Hillewaert (high order elements), Laurent
+Stainier (eigenvalue solvers, tensor display and MacOS bits), Marc Ume
 (original list code), Mark van Doesburg (Open CASCADE face
 connection), Matt Gundry (Plot3d mesh format), Matti Pellikka
 (Homology), Nicolas Tardieu (Netgen), Pascale Noyret (MED mesh
 format), Pierre Badel (root finding and minimization), Ruth Sabariego
 (pyramids), Stephen Guzik (CGNS and partitioners), Bastien Gorissen
-(parallel remote). See comments in the sources for more
-information. If we forgot to list your contributions please send us an
-email!
+(parallel remote), Eric Bechet (solver). See comments in the sources
+for more information. If we forgot to list your contributions please
+send us an email!
 
 The AVL tree code (Common/avl.*) and the YUV image code
 (Graphics/gl2yuv.*) are copyright (C) 1988-1993, 1995 The Regents of
@@ -111,9 +111,9 @@ Thanks to the following folks who have contributed by providing fresh
 ideas on theoretical or programming topics, who have sent patches,
 requests for changes or improvements, or who gave us access to exotic
 machines for testing Gmsh: Juan Abanto, Olivier Adam, Guillaume
-Alleon, Eric Bechet, Laurent Champaney, Pascal Dupuis, Patrick Dular,
-Philippe Geuzaine, Johan Gyselinck, Francois Henrotte, Benoit Meys,
-Nicolas Moes, Osamu Nakamura, Chad Schmutzer, Jean-Luc Fl'ejou, Xavier
+Alleon, Laurent Champaney, Pascal Dupuis, Patrick Dular, Philippe
+Geuzaine, Johan Gyselinck, Francois Henrotte, Benoit Meys, Nicolas
+Moes, Osamu Nakamura, Chad Schmutzer, Jean-Luc Fl'ejou, Xavier
 Dardenne, Christophe Prud'homme, Sebastien Clerc, Jose Miguel Pasini,
 Philippe Lussou, Jacques Kools, Bayram Yenikaya, Peter Hornby, Krishna
 Mohan Gundu, Christopher Stott, Timmy Schumacher, Carl Osterwisch,