Code cleanup: remove messy spaces before line continuation (\) in macros

src/util/action_stack.hpp

@@ -123,7 +123,7 @@ class ActionStack {
 /// Tests if variable has the type Type.
 /** Uses dynamic cast, so Type must have a virtual function.
  */
-#define TYPE_CASE_(variable, Type)                  \
+#define TYPE_CASE_(variable, Type) \
     if (dynamic_cast<const Type*>(&variable))
 
 /// Tests if variable has the type Type. 
@@ -131,12 +131,12 @@ class ActionStack {
  *  
  *  Uses dynamic cast, so Type must have a virtual function.
  */
-#define TYPE_CASE(variable, Type)                  \
-    pair<const Type*,bool> Type##variable            \
-      (dynamic_cast<const Type*>(&variable), true);      \
-    if (Type##variable.first)                  \
-      for (const Type& variable = *Type##variable.first ;    \
-         Type##variable.second ;              \
+#define TYPE_CASE(variable, Type) \
+    pair<const Type*,bool> Type##variable \
+      (dynamic_cast<const Type*>(&variable), true); \
+    if (Type##variable.first) \
+      for (const Type& variable = *Type##variable.first ; \
+         Type##variable.second ; \
          Type##variable.second = false)
 
 

src/util/dynamic_arg.hpp

@@ -37,24 +37,24 @@
    *  To change the value use WITH_DYNAMIC_ARG(name, newValue)
    *  To be used in a header file. Use IMPLEMENT_DYN_ARG in a source file
    */
-  #define DECLARE_DYNAMIC_ARG(Type, name)          \
-    extern THREAD_LOCAL Type name##_private;      \
-    inline Type name() { return name##_private; }    \
-    class name##_changer {                \
-      public:                      \
-      inline name##_changer(Type const& newValue)    \
-        : oldValue(name##_private) {        \
-        name##_private = newValue;          \
-      }                        \
-      inline ~name##_changer() {            \
-        name##_private = oldValue;          \
-      }                        \
-    private:                      \
-      Type oldValue;                  \
+  #define DECLARE_DYNAMIC_ARG(Type, name) \
+    extern THREAD_LOCAL Type name##_private; \
+    inline Type name() { return name##_private; } \
+    class name##_changer { \
+      public: \
+      inline name##_changer(Type const& newValue) \
+        : oldValue(name##_private) { \
+        name##_private = newValue; \
+      } \
+      inline ~name##_changer() { \
+        name##_private = oldValue; \
+      } \
+    private: \
+      Type oldValue; \
     }
   
   /// Implementation of a dynamic argument
-  #define IMPLEMENT_DYNAMIC_ARG(Type, name, initial)    \
+  #define IMPLEMENT_DYNAMIC_ARG(Type, name, initial) \
     THREAD_LOCAL Type name##_private = initial;
 
   /// Locally change the value of a dynamic argument
@@ -68,7 +68,7 @@
   *   // here name() == old value
   *  @endcode
   */
-  #define WITH_DYNAMIC_ARG(name, value)          \
+  #define WITH_DYNAMIC_ARG(name, value) \
     name##_changer name##_dummmy(value)
 
 #else
@@ -107,13 +107,13 @@
     }
   };
   
-  #define DECLARE_DYNAMIC_ARG(Type, name)        \
+  #define DECLARE_DYNAMIC_ARG(Type, name) \
     extern ThreadLocalObject<Type> name;
 
-  #define IMPLEMENT_DYNAMIC_ARG(Type, name, initial)  \
+  #define IMPLEMENT_DYNAMIC_ARG(Type, name, initial) \
     ThreadLocalObject<Type> name (initial);
 
-  #define WITH_DYNAMIC_ARG(name, value)        \
+  #define WITH_DYNAMIC_ARG(name, value) \
     name.store(value);
 
 #endif

src/util/for_each.hpp

@@ -45,33 +45,33 @@
 /// Iterate over a collection, using an iterator it of type Type
 /** Usage: FOR_EACH_IT_T(Type,it,collect) { body-of-loop }
  */
-#define FOR_EACH_IT_T(Type,Iterator,Collection)                         \
-        for(Type Iterator = (Collection).begin() ;                      \
-            Iterator != (Collection).end() ;                            \
-            ++Iterator)
+#define FOR_EACH_IT_T(Type,Iterator,Collection) \
+  for(Type Iterator = (Collection).begin() ; \
+      Iterator != (Collection).end() ; \
+      ++Iterator)
 
 /// Iterate over a collection whos type must be declared with DECLARE_TYPEOF
 /** Usage: FOR_EACH_IT(it,collect) { body-of-loop }
  */
-#define FOR_EACH_IT(Iterator,Collection)                                \
-        FOR_EACH_IT_T(TYPEOF_IT(Collection), Iterator, Collection)
+#define FOR_EACH_IT(Iterator,Collection) \
+  FOR_EACH_IT_T(TYPEOF_IT(Collection), Iterator, Collection)
 
 /// Iterate over a collection whos type must be declared with DECLARE_TYPEOF
 /** Uses a const_iterator
  *  Usage: FOR_EACH_IT(it,collect) { body-of-loop }
  */
-#define FOR_EACH_CONST_IT(Iterator,Collection)                          \
-        FOR_EACH_IT_T(TYPEOF_CIT(Collection), Iterator, Collection)
+#define FOR_EACH_CONST_IT(Iterator,Collection) \
+  FOR_EACH_IT_T(TYPEOF_CIT(Collection), Iterator, Collection)
 
 /// Iterate over a collection in whos type must be declared with DECLARE_TYPEOF
 /** Iterates using a reverse_iterator
  *  Usage: FOR_EACH_REVERSE_IT(it,collect) { body-of-loop }
  */
-#define FOR_EACH_REVERSE_IT(Iterator,Collection)                        \
-        for(TYPEOF_RIT(Collection)                                      \
-            Iterator = (Collection).rbegin() ;                          \
-            Iterator != (Collection).rend() ;                           \
-            ++Iterator)
+#define FOR_EACH_REVERSE_IT(Iterator,Collection) \
+  for(TYPEOF_RIT(Collection) \
+      Iterator = (Collection).rbegin() ; \
+      Iterator != (Collection).rend() ; \
+      ++Iterator)
 
 // ----------------------------------------------------------------------------- : Looping macros
 
@@ -82,13 +82,13 @@
  *  To do this we use a nested for loop that is only executed once, and which is optimized away.
  *  To terminate this loop we need an extra bool, which we set to false after the first iteration.
  */
-#define FOR_EACH_T(TypeIt,TypeElem,Elem,Collection, begin, end)             \
-        for(std::pair<TypeIt,bool> Elem##_IT((Collection).begin(), true) ;  \
-            Elem##_IT.second && Elem##_IT.first != (Collection).end() ;     \
-            ++Elem##_IT.first, Elem##_IT.second = !Elem##_IT.second)        \
-            for(TypeElem Elem = *Elem##_IT.first ;                          \
-                Elem##_IT.second ;                                          \
-                Elem##_IT.second = false)
+#define FOR_EACH_T(TypeIt,TypeElem,Elem,Collection, begin, end) \
+  for(std::pair<TypeIt,bool> Elem##_IT((Collection).begin(), true) ; \
+      Elem##_IT.second && Elem##_IT.first != (Collection).end() ; \
+      ++Elem##_IT.first, Elem##_IT.second = !Elem##_IT.second) \
+      for(TypeElem Elem = *Elem##_IT.first ; \
+          Elem##_IT.second ; \
+          Elem##_IT.second = false)
 
 /// Iterate over a collection whos type must be declared with DECLARE_TYPEOF
 /** Usage: FOR_EACH(e,collect) { body-of-loop }
@@ -102,8 +102,6 @@
 /** Uses a const iterator
  *  Usage: FOR_EACH_CONST(e,collect) { body-of-loop }
  */
-//#define FOR_EACH_CONST(Elem,Collection)                                 \
-//        FOR_EACH_T(TYPEOF_CIT(Collection), TYPEOF_CREF(Collection), Elem, Collection, begin, end)
 #define FOR_EACH_CONST(Elem,Collection) \
   for (auto const& Elem : Collection)
 
@@ -111,15 +109,15 @@
 /** Iterates using a reverse_iterator
  *  Usage: FOR_EACH_REVERSE(e,collect) { body-of-loop }
  */
-#define FOR_EACH_REVERSE(Elem,Collection)                               \
-        FOR_EACH_T(TYPEOF_RIT(Collection), TYPEOF_REF(Collection), Elem, Collection, rbegin, rend)
+#define FOR_EACH_REVERSE(Elem,Collection) \
+  FOR_EACH_T(TYPEOF_RIT(Collection), TYPEOF_REF(Collection), Elem, Collection, rbegin, rend)
 
 /// Iterate over a collection whos type must be declared with DECLARE_TYPEOF
 /** Iterates using a const_reverse_iterator
  *  Usage: FOR_EACH_CONST_REVERSE(e,collect) { body-of-loop }
  */
-#define FOR_EACH_CONST_REVERSE(Elem,Collection)                         \
-        FOR_EACH_T(TYPEOF_CRIT(Collection), TYPEOF_CREF(Collection), Elem, Collection, rbegin, rend)
+#define FOR_EACH_CONST_REVERSE(Elem,Collection) \
+  FOR_EACH_T(TYPEOF_CRIT(Collection), TYPEOF_CREF(Collection), Elem, Collection, rbegin, rend)
 
 /// Iterate over two collection in parallel
 /** Usage: FOR_EACH_2_T(TypeIt1,TypeElem1,e1,collect1,TypeIt2,TypeElem2,e2,collect2) { body-of-loop }
@@ -127,33 +125,33 @@
  *  Note: This has got to be one of the craziest pieces of code I have ever written :)
  *  It is just an extension of the idea of FOR_EACH_T.
  */
-#define FOR_EACH_2_T(TypeIt1,TypeElem1,Elem1,Coll1,TypeIt2,TypeElem2,Elem2,Coll2)   \
-        for(std::pair<std::pair<TypeIt1,TypeIt2>, bool>                             \
-            Elem1##_IT(make_pair((Coll1).begin(), (Coll2).begin()), true) ;         \
-            Elem1##_IT.first.first  != (Coll1).end() &&                             \
-            Elem1##_IT.first.second != (Coll2).end() ;                              \
-            ++Elem1##_IT.first.first, ++Elem1##_IT.first.second,                    \
-            Elem1##_IT.second = true)                                               \
-            for(TypeElem1 Elem1 = *Elem1##_IT.first.first ;                         \
-                Elem1##_IT.second ;                                                 \
-                Elem1##_IT.second = false)                                          \
-                for(TypeElem2 Elem2 = *Elem1##_IT.first.second ;                    \
-                    Elem1##_IT.second ;                                             \
-                    Elem1##_IT.second = false)
+#define FOR_EACH_2_T(TypeIt1,TypeElem1,Elem1,Coll1,TypeIt2,TypeElem2,Elem2,Coll2) \
+  for(std::pair<std::pair<TypeIt1,TypeIt2>, bool> \
+      Elem1##_IT(make_pair((Coll1).begin(), (Coll2).begin()), true) ; \
+      Elem1##_IT.first.first  != (Coll1).end() && \
+      Elem1##_IT.first.second != (Coll2).end() ; \
+      ++Elem1##_IT.first.first, ++Elem1##_IT.first.second, \
+      Elem1##_IT.second = true) \
+      for(TypeElem1 Elem1 = *Elem1##_IT.first.first ; \
+          Elem1##_IT.second ; \
+          Elem1##_IT.second = false) \
+          for(TypeElem2 Elem2 = *Elem1##_IT.first.second ; \
+              Elem1##_IT.second ; \
+              Elem1##_IT.second = false)
 
 /// Iterate over two collections in parallel, their type must be declared with DECLARE_TYPEOF.
 /** Usage: FOR_EACH_2(e1,collect1, e2,collect2) { body-of-loop }
  */
-#define FOR_EACH_2(Elem1,Collection1, Elem2,Collection2)                                    \
-        FOR_EACH_2_T(TYPEOF_IT(Collection1), TYPEOF_REF(Collection1), Elem1, Collection1,   \
-                     TYPEOF_IT(Collection2), TYPEOF_REF(Collection2), Elem2, Collection2)
+#define FOR_EACH_2(Elem1,Collection1, Elem2,Collection2) \
+  FOR_EACH_2_T(TYPEOF_IT(Collection1), TYPEOF_REF(Collection1), Elem1, Collection1, \
+               TYPEOF_IT(Collection2), TYPEOF_REF(Collection2), Elem2, Collection2)
 
 /// Iterate over two constants collections in parallel, their type must be declared with DECLARE_TYPEOF.
 /** Usage: FOR_EACH_2_CONST(e1,collect1, e2,collect2) { body-of-loop }
  */
-#define FOR_EACH_2_CONST(Elem1,Collection1, Elem2,Collection2)                              \
-        FOR_EACH_2_T(TYPEOF_CIT(Collection1), TYPEOF_CREF(Collection1), Elem1, Collection1, \
-                     TYPEOF_CIT(Collection2), TYPEOF_CREF(Collection2), Elem2, Collection2)
+#define FOR_EACH_2_CONST(Elem1,Collection1, Elem2,Collection2) \
+  FOR_EACH_2_T(TYPEOF_CIT(Collection1), TYPEOF_CREF(Collection1), Elem1, Collection1, \
+               TYPEOF_CIT(Collection2), TYPEOF_CREF(Collection2), Elem2, Collection2)
 
 
 // ----------------------------------------------------------------------------- : EOF

src/util/io/get_member.hpp

@@ -121,25 +121,25 @@ class GetMember : private GetDefaultMember {
 #define REFLECT_OBJECT_GET_DEFAULT_MEMBER_NOT(Cls)  REFLECT_WRITE_NO(Cls,GetDefaultMember)
 #define REFLECT_OBJECT_GET_MEMBER_NOT(Cls)      REFLECT_WRITE_NO(Cls,GetMember)
 
-#define REFLECT_WRITE_YES(Cls, Tag)                    \
-  template<> void Tag::handle<Cls>(const Cls& object) {        \
-    const_cast<Cls&>(object).reflect(*this);            \
-  }                                  \
-  void Cls::reflect(Tag& tag) {                    \
-    reflect_impl(tag);                        \
+#define REFLECT_WRITE_YES(Cls, Tag) \
+  template<> void Tag::handle<Cls>(const Cls& object) { \
+    const_cast<Cls&>(object).reflect(*this); \
+  } \
+  void Cls::reflect(Tag& tag) { \
+    reflect_impl(tag); \
   }
 
-#define REFLECT_WRITE_NO(Cls, Tag)                    \
-  template<> void Tag::handle<Cls>(const Cls& object) {}        \
+#define REFLECT_WRITE_NO(Cls, Tag) \
+  template<> void Tag::handle<Cls>(const Cls& object) {} \
   void Cls::reflect(Tag& tag) {}
 
 // ----------------------------------------------------------------------------- : Reflection for enumerations
 
 /// Implement enum reflection as used by GetMember
-#define REFLECT_ENUM_GET_MEMBER(Enum)                  \
-  template<> void GetDefaultMember::handle<Enum>(const Enum& enum_) {  \
-    EnumGetMember egm(*this);                    \
-    reflect_ ## Enum(const_cast<Enum&>(enum_), egm);        \
+#define REFLECT_ENUM_GET_MEMBER(Enum) \
+  template<> void GetDefaultMember::handle<Enum>(const Enum& enum_) { \
+    EnumGetMember egm(*this); \
+    reflect_ ## Enum(const_cast<Enum&>(enum_), egm); \
   }
 
 /// 'Tag' to be used when reflecting enumerations for GetMember

src/util/io/reader.hpp

@@ -244,27 +244,27 @@ void Reader::handle(IndexMap<K,V>& m) {
 // ----------------------------------------------------------------------------- : Reflection
 
 /// Implement reflection as used by Reader
-#define REFLECT_OBJECT_READER(Cls)                \
-  template<> void Reader::handle<Cls>(Cls& object) {      \
-    object.reflect(*this);                  \
-  }                              \
-  void Cls::reflect(Reader& reader) {              \
-    reflect_impl(reader);                  \
+#define REFLECT_OBJECT_READER(Cls) \
+  template<> void Reader::handle<Cls>(Cls& object) { \
+    object.reflect(*this); \
+  } \
+  void Cls::reflect(Reader& reader) { \
+    reflect_impl(reader); \
   }
 
 // ----------------------------------------------------------------------------- : Reflection for enumerations
 
 /// Implement enum reflection as used by Reader
-#define REFLECT_ENUM_READER(Enum)                \
-  template<> void Reader::handle<Enum>(Enum& enum_) {      \
-    EnumReader reader(getValue());              \
-    reflect_ ## Enum(enum_, reader);            \
-    reader.warnIfNotDone(this);                \
-  }                              \
-  void parse_enum(const String& value, Enum& out) {      \
-    EnumReader reader(value);                \
-    reflect_ ## Enum(out, reader);              \
-    reader.errorIfNotDone();                \
+#define REFLECT_ENUM_READER(Enum) \
+  template<> void Reader::handle<Enum>(Enum& enum_) { \
+    EnumReader reader(getValue()); \
+    reflect_ ## Enum(enum_, reader); \
+    reader.warnIfNotDone(this); \
+  } \
+  void parse_enum(const String& value, Enum& out) { \
+    EnumReader reader(value); \
+    reflect_ ## Enum(out, reader); \
+    reader.errorIfNotDone(); \
   }
 
 /// 'Tag' to be used when reflecting enumerations for Reader

src/util/io/writer.hpp

@@ -129,21 +129,21 @@ void Writer::handle(const IndexMap<K,V>& m) {
 // ----------------------------------------------------------------------------- : Reflection
 
 /// Implement reflection as used by Writer
-#define REFLECT_OBJECT_WRITER(Cls)                \
-  template<> void Writer::handle<Cls>(const Cls& object) {  \
-    const_cast<Cls&>(object).reflect(*this);        \
-  }                              \
-  void Cls::reflect(Writer& writer) {              \
-    reflect_impl(writer);                  \
+#define REFLECT_OBJECT_WRITER(Cls) \
+  template<> void Writer::handle<Cls>(const Cls& object) { \
+    const_cast<Cls&>(object).reflect(*this); \
+  } \
+  void Cls::reflect(Writer& writer) { \
+    reflect_impl(writer); \
   }
 
 // ----------------------------------------------------------------------------- : Reflection for enumerations
 
 /// Implement enum reflection as used by Writer
-#define REFLECT_ENUM_WRITER(Enum)                \
-  template<> void Writer::handle<Enum>(const Enum& enum_) {  \
-    EnumWriter writer(*this);                \
-    reflect_ ## Enum(const_cast<Enum&>(enum_), writer);    \
+#define REFLECT_ENUM_WRITER(Enum) \
+  template<> void Writer::handle<Enum>(const Enum& enum_) { \
+    EnumWriter writer(*this); \
+    reflect_ ## Enum(const_cast<Enum&>(enum_), writer); \
   }
 
 /// 'Tag' to be used when reflecting enumerations for Writer