Index: libcfa/src/enum.hfa
===================================================================
--- libcfa/src/enum.hfa	(revision 0097d0871e5a15e1055128d4bf70284661a75a8d)
+++ libcfa/src/enum.hfa	(revision cd1d721883249cecf37cb986c18ac63008f73fc8)
@@ -4,41 +4,41 @@
 
 forall( E ) trait Bounded {
-    E lowerBound();
-    E upperBound();
+	E lowerBound();
+	E upperBound();
 };
 
 forall( E | Bounded( E ) ) trait Serial {
-    unsigned fromInstance( E e );
-    E fromInt_unsafe( unsigned i );
-    E succ_unsafe( E e );
-    E pred_unsafe( E e );
+	unsigned fromInstance( E e );
+	E fromInt_unsafe( unsigned i );
+	E succ_unsafe( E e );
+	E pred_unsafe( E e );
 };
 
 forall( E | Serial( E ) ) {
-    E fromInt( unsigned i );
-    E succ( E e );
-    E pred( E e );
-    int Countof( E e );
+	E fromInt( unsigned i );
+	E succ( E e );
+	E pred( E e );
+	int Countof( E e );
 }
 
 // forall( E | Bounded(E) ) trait SafeSerial {
-//     // unsigned fromInstance( E e );
-//     E fromInt_unsafe( unsigned i );
-//     // E succ_unsafe( E e );
-//     //E pred_unsafe( E e );
+//	 // unsigned fromInstance( E e );
+//	 E fromInt_unsafe( unsigned i );
+//	 // E succ_unsafe( E e );
+//	 //E pred_unsafe( E e );
 
-//     unsigned fromInstance( E e );
-//     E fromInt( unsigned i );
-//     E succ( E e );
-//     E pred( E e );
+//	 unsigned fromInstance( E e );
+//	 E fromInt( unsigned i );
+//	 E succ( E e );
+//	 E pred( E e );
 // };
 
 forall( E ) trait CfaEnum {
-    const char * label( E e );
-    unsigned int posn( E e );
+	const char * label( E e );
+	unsigned int posn( E e );
 };
 
 forall( E, V | CfaEnum( E ) ) trait TypedEnum {
-    V value( E e );
+	V value( E e );
 };
 
@@ -55,31 +55,31 @@
 static inline
 forall( E | Serial(E) | CfaEnum(E) ) {
-    int ?==?( E l, E r ) { return posn( l ) == posn( r ); }	// relational operators
-    int ?!=?( E l, E r ) { return posn( l ) != posn( r ); }
-    int ?<?( E l, E r ) { return posn( l ) < posn( r ); }
-    int ?<=?( E l, E r ) { return posn( l ) <= posn( r ); }
-    int ?>?( E l, E r ) { return posn( l ) > posn( r ); }
-    int ?>=?( E l, E r ) { return posn( l ) >= posn( r ); }
+	int ?==?( E l, E r ) { return posn( l ) == posn( r ); }	// relational operators
+	int ?!=?( E l, E r ) { return posn( l ) != posn( r ); }
+	int ?<?( E l, E r ) { return posn( l ) < posn( r ); }
+	int ?<=?( E l, E r ) { return posn( l ) <= posn( r ); }
+	int ?>?( E l, E r ) { return posn( l ) > posn( r ); }
+	int ?>=?( E l, E r ) { return posn( l ) >= posn( r ); }
 
-    E ++?( E & l ) { 									// increment operators
-        l = succ( l );
-        return l;
-    }
-    
-    E ?++( E & l ) {
-        E ret = l;
-        l = succ( l );
-        return ret;
-    }
+	E ++?( E & l ) { 									// increment operators
+		l = succ( l );
+		return l;
+	}
+	
+	E ?++( E & l ) {
+		E ret = l;
+		l = succ( l );
+		return ret;
+	}
 
-    E --?( E & l ) {
-        l = pred( l );
-        return l;
-    }
+	E --?( E & l ) {
+		l = pred( l );
+		return l;
+	}
 
-    E ?--( E & l ) {
-        E ret = l;
-        l = pred( l );
-        return ret;
-    }
+	E ?--( E & l ) {
+		E ret = l;
+		l = pred( l );
+		return ret;
+	}
 }