soft-fp: fix horizontal whitespace.

1 files changed, 130 insertions, 130 deletions

diff --git a/soft-fp/extended.h b/soft-fp/extended.h
index e030b6b..1189f7c 100644
--- a/soft-fp/extended.h
+++ b/soft-fp/extended.h
@@ -48,22 +48,22 @@
 #define _FP_EXPMAX_E		32767
 
 #define _FP_QNANBIT_E		\
-	((_FP_W_TYPE)1 << (_FP_FRACBITS_E-2) % _FP_W_TYPE_SIZE)
+	((_FP_W_TYPE) 1 << (_FP_FRACBITS_E-2) % _FP_W_TYPE_SIZE)
 #define _FP_QNANBIT_SH_E		\
-	((_FP_W_TYPE)1 << (_FP_FRACBITS_E-2+_FP_WORKBITS) % _FP_W_TYPE_SIZE)
+	((_FP_W_TYPE) 1 << (_FP_FRACBITS_E-2+_FP_WORKBITS) % _FP_W_TYPE_SIZE)
 #define _FP_IMPLBIT_E		\
-	((_FP_W_TYPE)1 << (_FP_FRACBITS_E-1) % _FP_W_TYPE_SIZE)
+	((_FP_W_TYPE) 1 << (_FP_FRACBITS_E-1) % _FP_W_TYPE_SIZE)
 #define _FP_IMPLBIT_SH_E		\
-	((_FP_W_TYPE)1 << (_FP_FRACBITS_E-1+_FP_WORKBITS) % _FP_W_TYPE_SIZE)
+	((_FP_W_TYPE) 1 << (_FP_FRACBITS_E-1+_FP_WORKBITS) % _FP_W_TYPE_SIZE)
 #define _FP_OVERFLOW_E		\
-	((_FP_W_TYPE)1 << (_FP_WFRACBITS_E % _FP_W_TYPE_SIZE))
+	((_FP_W_TYPE) 1 << (_FP_WFRACBITS_E % _FP_W_TYPE_SIZE))
 
 #define _FP_WFRACBITS_DW_E	(2 * _FP_WFRACBITS_E)
 #define _FP_WFRACXBITS_DW_E	(_FP_FRACTBITS_DW_E - _FP_WFRACBITS_DW_E)
 #define _FP_HIGHBIT_DW_E	\
-  ((_FP_W_TYPE)1 << (_FP_WFRACBITS_DW_E - 1) % _FP_W_TYPE_SIZE)
+  ((_FP_W_TYPE) 1 << (_FP_WFRACBITS_DW_E - 1) % _FP_W_TYPE_SIZE)
 
-typedef float XFtype __attribute__((mode(XF)));
+typedef float XFtype __attribute__ ((mode (XF)));
 
 #if _FP_W_TYPE_SIZE < 64
 
@@ -85,11 +85,11 @@ union _FP_UNION_E
     unsigned exp : _FP_EXPBITS_E;
     unsigned sign : 1;
 # endif /* not bigendian */
-  } bits __attribute__((packed));
+  } bits __attribute__ ((packed));
 };
 
 
-# define FP_DECL_E(X)		_FP_DECL(4,X)
+# define FP_DECL_E(X)		_FP_DECL (4, X)
 
 # define FP_UNPACK_RAW_E(X, val)		\
   do						\
@@ -109,7 +109,7 @@ union _FP_UNION_E
 # define FP_UNPACK_RAW_EP(X, val)				\
   do								\
     {								\
-      union _FP_UNION_E *_flo = (union _FP_UNION_E *)(val);	\
+      union _FP_UNION_E *_flo = (union _FP_UNION_E *) (val);	\
 								\
       X##_f[2] = 0;						\
       X##_f[3] = 0;						\
@@ -138,97 +138,97 @@ union _FP_UNION_E
     }						\
   while (0)
 
-# define FP_PACK_RAW_EP(val, X)					\
-  do								\
-    {								\
-      if (!FP_INHIBIT_RESULTS)					\
-	{							\
-	  union _FP_UNION_E *_flo = (union _FP_UNION_E *)(val);	\
-								\
-	  if (X##_e)						\
-	    X##_f[1] |= _FP_IMPLBIT_E;				\
-	  else							\
-	    X##_f[1] &= ~(_FP_IMPLBIT_E);			\
-	  _flo->bits.frac0 = X##_f[0];				\
-	  _flo->bits.frac1 = X##_f[1];				\
-	  _flo->bits.exp   = X##_e;				\
-	  _flo->bits.sign  = X##_s;				\
-	}							\
-    }								\
+# define FP_PACK_RAW_EP(val, X)						\
+  do									\
+    {									\
+      if (!FP_INHIBIT_RESULTS)						\
+	{								\
+	  union _FP_UNION_E *_flo = (union _FP_UNION_E *) (val);	\
+									\
+	  if (X##_e)							\
+	    X##_f[1] |= _FP_IMPLBIT_E;					\
+	  else								\
+	    X##_f[1] &= ~(_FP_IMPLBIT_E);				\
+	  _flo->bits.frac0 = X##_f[0];					\
+	  _flo->bits.frac1 = X##_f[1];					\
+	  _flo->bits.exp   = X##_e;					\
+	  _flo->bits.sign  = X##_s;					\
+	}								\
+    }									\
   while (0)
 
-# define FP_UNPACK_E(X,val)			\
+# define FP_UNPACK_E(X, val)			\
   do						\
     {						\
-      FP_UNPACK_RAW_E(X,val);			\
-      _FP_UNPACK_CANONICAL(E,4,X);		\
+      FP_UNPACK_RAW_E (X, val);			\
+      _FP_UNPACK_CANONICAL (E, 4, X);		\
     }						\
   while (0)
 
-# define FP_UNPACK_EP(X,val)			\
+# define FP_UNPACK_EP(X, val)			\
   do						\
     {						\
-      FP_UNPACK_RAW_EP(X,val);			\
-      _FP_UNPACK_CANONICAL(E,4,X);		\
+      FP_UNPACK_RAW_EP (X, val);		\
+      _FP_UNPACK_CANONICAL (E, 4, X);		\
     }						\
   while (0)
 
-# define FP_UNPACK_SEMIRAW_E(X,val)		\
+# define FP_UNPACK_SEMIRAW_E(X, val)		\
   do						\
     {						\
-      FP_UNPACK_RAW_E(X,val);			\
-      _FP_UNPACK_SEMIRAW(E,4,X);		\
+      FP_UNPACK_RAW_E (X, val);			\
+      _FP_UNPACK_SEMIRAW (E, 4, X);		\
     }						\
   while (0)
 
-# define FP_UNPACK_SEMIRAW_EP(X,val)		\
+# define FP_UNPACK_SEMIRAW_EP(X, val)		\
   do						\
     {						\
-      FP_UNPACK_RAW_EP(X,val);			\
-      _FP_UNPACK_SEMIRAW(E,4,X);		\
+      FP_UNPACK_RAW_EP (X, val);		\
+      _FP_UNPACK_SEMIRAW (E, 4, X);		\
     }						\
   while (0)
 
-# define FP_PACK_E(val,X)			\
+# define FP_PACK_E(val, X)			\
   do						\
     {						\
-      _FP_PACK_CANONICAL(E,4,X);		\
-      FP_PACK_RAW_E(val,X);			\
+      _FP_PACK_CANONICAL (E, 4, X);		\
+      FP_PACK_RAW_E (val, X);			\
     }						\
   while (0)
 
-# define FP_PACK_EP(val,X)			\
+# define FP_PACK_EP(val, X)			\
   do						\
     {						\
-      _FP_PACK_CANONICAL(E,4,X);		\
-      FP_PACK_RAW_EP(val,X);			\
+      _FP_PACK_CANONICAL (E, 4, X);		\
+      FP_PACK_RAW_EP (val, X);			\
     }						\
   while (0)
 
-# define FP_PACK_SEMIRAW_E(val,X)		\
+# define FP_PACK_SEMIRAW_E(val, X)		\
   do						\
     {						\
-      _FP_PACK_SEMIRAW(E,4,X);			\
-      FP_PACK_RAW_E(val,X);			\
+      _FP_PACK_SEMIRAW (E, 4, X);		\
+      FP_PACK_RAW_E (val, X);			\
     }						\
   while (0)
 
-# define FP_PACK_SEMIRAW_EP(val,X)		\
+# define FP_PACK_SEMIRAW_EP(val, X)		\
   do						\
     {						\
-      _FP_PACK_SEMIRAW(E,4,X);			\
-      FP_PACK_RAW_EP(val,X);			\
+      _FP_PACK_SEMIRAW (E, 4, X);		\
+      FP_PACK_RAW_EP (val, X);			\
     }						\
   while (0)
 
-# define FP_ISSIGNAN_E(X)	_FP_ISSIGNAN(E,4,X)
-# define FP_NEG_E(R,X)		_FP_NEG(E,4,R,X)
-# define FP_ADD_E(R,X,Y)	_FP_ADD(E,4,R,X,Y)
-# define FP_SUB_E(R,X,Y)	_FP_SUB(E,4,R,X,Y)
-# define FP_MUL_E(R,X,Y)	_FP_MUL(E,4,R,X,Y)
-# define FP_DIV_E(R,X,Y)	_FP_DIV(E,4,R,X,Y)
-# define FP_SQRT_E(R,X)		_FP_SQRT(E,4,R,X)
-# define FP_FMA_E(R,X,Y,Z)	_FP_FMA(E,4,8,R,X,Y,Z)
+# define FP_ISSIGNAN_E(X)	_FP_ISSIGNAN (E, 4, X)
+# define FP_NEG_E(R, X)		_FP_NEG (E, 4, R, X)
+# define FP_ADD_E(R, X, Y)	_FP_ADD (E, 4, R, X, Y)
+# define FP_SUB_E(R, X, Y)	_FP_SUB (E, 4, R, X, Y)
+# define FP_MUL_E(R, X, Y)	_FP_MUL (E, 4, R, X, Y)
+# define FP_DIV_E(R, X, Y)	_FP_DIV (E, 4, R, X, Y)
+# define FP_SQRT_E(R, X)	_FP_SQRT (E, 4, R, X)
+# define FP_FMA_E(R, X, Y, Z)	_FP_FMA (E, 4, 8, R, X, Y, Z)
 
 /*
  * Square root algorithms:
@@ -244,8 +244,8 @@ union _FP_UNION_E
 # define _FP_SQRT_MEAT_E(R, S, T, X, q)			\
   do							\
     {							\
-      q = (_FP_W_TYPE)1 << (_FP_W_TYPE_SIZE - 1);	\
-      _FP_FRAC_SRL_4(X, (_FP_WORKBITS));		\
+      q = (_FP_W_TYPE) 1 << (_FP_W_TYPE_SIZE - 1);	\
+      _FP_FRAC_SRL_4 (X, (_FP_WORKBITS));		\
       while (q)						\
 	{						\
 	  T##_f[1] = S##_f[1] + q;			\
@@ -255,10 +255,10 @@ union _FP_UNION_E
 	      X##_f[1] -= T##_f[1];			\
 	      R##_f[1] += q;				\
 	    }						\
-	  _FP_FRAC_SLL_2(X, 1);				\
+	  _FP_FRAC_SLL_2 (X, 1);			\
 	  q >>= 1;					\
 	}						\
-      q = (_FP_W_TYPE)1 << (_FP_W_TYPE_SIZE - 1);	\
+      q = (_FP_W_TYPE) 1 << (_FP_W_TYPE_SIZE - 1);	\
       while (q)						\
 	{						\
 	  T##_f[0] = S##_f[0] + q;			\
@@ -269,13 +269,13 @@ union _FP_UNION_E
 	    {						\
 	      S##_f[0] = T##_f[0] + q;			\
 	      S##_f[1] += (T##_f[0] > S##_f[0]);	\
-	      _FP_FRAC_DEC_2(X, T);			\
+	      _FP_FRAC_DEC_2 (X, T);			\
 	      R##_f[0] += q;				\
 	    }						\
-	  _FP_FRAC_SLL_2(X, 1);				\
+	  _FP_FRAC_SLL_2 (X, 1);			\
 	  q >>= 1;					\
 	}						\
-      _FP_FRAC_SLL_4(R, (_FP_WORKBITS));		\
+      _FP_FRAC_SLL_4 (R, (_FP_WORKBITS));		\
       if (X##_f[0] | X##_f[1])				\
 	{						\
 	  if (S##_f[1] < X##_f[1]			\
@@ -287,12 +287,12 @@ union _FP_UNION_E
     }							\
   while (0)
 
-# define FP_CMP_E(r,X,Y,un)	_FP_CMP(E,4,r,X,Y,un)
-# define FP_CMP_EQ_E(r,X,Y)	_FP_CMP_EQ(E,4,r,X,Y)
-# define FP_CMP_UNORD_E(r,X,Y)	_FP_CMP_UNORD(E,4,r,X,Y)
+# define FP_CMP_E(r, X, Y, un)		_FP_CMP (E, 4, r, X, Y, un)
+# define FP_CMP_EQ_E(r, X, Y)		_FP_CMP_EQ (E, 4, r, X, Y)
+# define FP_CMP_UNORD_E(r, X, Y)	_FP_CMP_UNORD (E, 4, r, X, Y)
 
-# define FP_TO_INT_E(r,X,rsz,rsg)	_FP_TO_INT(E,4,r,X,rsz,rsg)
-# define FP_FROM_INT_E(X,r,rs,rt)	_FP_FROM_INT(E,4,X,r,rs,rt)
+# define FP_TO_INT_E(r, X, rsz, rsg)	_FP_TO_INT (E, 4, r, X, rsz, rsg)
+# define FP_FROM_INT_E(X, r, rs, rt)	_FP_FROM_INT (E, 4, X, r, rs, rt)
 
 # define _FP_FRAC_HIGH_E(X)	(X##_f[2])
 # define _FP_FRAC_HIGH_RAW_E(X)	(X##_f[1])
@@ -318,7 +318,7 @@ union _FP_UNION_E
   } bits;
 };
 
-# define FP_DECL_E(X)		_FP_DECL(2,X)
+# define FP_DECL_E(X)		_FP_DECL (2, X)
 
 # define FP_UNPACK_RAW_E(X, val)		\
   do						\
@@ -336,7 +336,7 @@ union _FP_UNION_E
 # define FP_UNPACK_RAW_EP(X, val)				\
   do								\
     {								\
-      union _FP_UNION_E *_flo = (union _FP_UNION_E *)(val);	\
+      union _FP_UNION_E *_flo = (union _FP_UNION_E *) (val);	\
 								\
       X##_f0 = _flo->bits.frac;					\
       X##_f1 = 0;						\
@@ -362,97 +362,97 @@ union _FP_UNION_E
     }						\
   while (0)
 
-# define FP_PACK_RAW_EP(fs, val, X)				\
-  do								\
-    {								\
-      if (!FP_INHIBIT_RESULTS)					\
-	{							\
-	  union _FP_UNION_E *_flo = (union _FP_UNION_E *)(val);	\
-								\
-	  if (X##_e)						\
-	    X##_f0 |= _FP_IMPLBIT_E;				\
-	  else							\
-	    X##_f0 &= ~(_FP_IMPLBIT_E);				\
-	  _flo->bits.frac = X##_f0;				\
-	  _flo->bits.exp  = X##_e;				\
-	  _flo->bits.sign = X##_s;				\
-	}							\
-    }								\
+# define FP_PACK_RAW_EP(fs, val, X)					\
+  do									\
+    {									\
+      if (!FP_INHIBIT_RESULTS)						\
+	{								\
+	  union _FP_UNION_E *_flo = (union _FP_UNION_E *) (val);	\
+									\
+	  if (X##_e)							\
+	    X##_f0 |= _FP_IMPLBIT_E;					\
+	  else								\
+	    X##_f0 &= ~(_FP_IMPLBIT_E);					\
+	  _flo->bits.frac = X##_f0;					\
+	  _flo->bits.exp  = X##_e;					\
+	  _flo->bits.sign = X##_s;					\
+	}								\
+    }									\
   while (0)
 
 
-# define FP_UNPACK_E(X,val)			\
+# define FP_UNPACK_E(X, val)			\
   do						\
     {						\
-      FP_UNPACK_RAW_E(X,val);			\
-      _FP_UNPACK_CANONICAL(E,2,X);		\
+      FP_UNPACK_RAW_E (X, val);			\
+      _FP_UNPACK_CANONICAL (E, 2, X);		\
     }						\
   while (0)
 
-# define FP_UNPACK_EP(X,val)			\
+# define FP_UNPACK_EP(X, val)			\
   do						\
     {						\
-      FP_UNPACK_RAW_EP(X,val);			\
-      _FP_UNPACK_CANONICAL(E,2,X);		\
+      FP_UNPACK_RAW_EP (X, val);		\
+      _FP_UNPACK_CANONICAL (E, 2, X);		\
     }						\
   while (0)
 
-# define FP_UNPACK_SEMIRAW_E(X,val)		\
+# define FP_UNPACK_SEMIRAW_E(X, val)		\
   do						\
     {						\
-      FP_UNPACK_RAW_E(X,val);			\
-      _FP_UNPACK_SEMIRAW(E,2,X);		\
+      FP_UNPACK_RAW_E (X, val);			\
+      _FP_UNPACK_SEMIRAW (E, 2, X);		\
     }						\
   while (0)
 
-# define FP_UNPACK_SEMIRAW_EP(X,val)		\
+# define FP_UNPACK_SEMIRAW_EP(X, val)		\
   do						\
     {						\
-      FP_UNPACK_RAW_EP(X,val);			\
-      _FP_UNPACK_SEMIRAW(E,2,X);		\
+      FP_UNPACK_RAW_EP (X, val);		\
+      _FP_UNPACK_SEMIRAW (E, 2, X);		\
     }						\
   while (0)
 
-# define FP_PACK_E(val,X)			\
+# define FP_PACK_E(val, X)			\
   do						\
     {						\
-      _FP_PACK_CANONICAL(E,2,X);		\
-      FP_PACK_RAW_E(val,X);			\
+      _FP_PACK_CANONICAL (E, 2, X);		\
+      FP_PACK_RAW_E (val, X);			\
     }						\
   while (0)
 
-# define FP_PACK_EP(val,X)			\
+# define FP_PACK_EP(val, X)			\
   do						\
     {						\
-      _FP_PACK_CANONICAL(E,2,X);		\
-      FP_PACK_RAW_EP(val,X);			\
+      _FP_PACK_CANONICAL (E, 2, X);		\
+      FP_PACK_RAW_EP (val, X);			\
     }						\
   while (0)
 
-# define FP_PACK_SEMIRAW_E(val,X)		\
+# define FP_PACK_SEMIRAW_E(val, X)		\
   do						\
     {						\
-      _FP_PACK_SEMIRAW(E,2,X);			\
-      FP_PACK_RAW_E(val,X);			\
+      _FP_PACK_SEMIRAW (E, 2, X);		\
+      FP_PACK_RAW_E (val, X);			\
     }						\
   while (0)
 
-# define FP_PACK_SEMIRAW_EP(val,X)		\
+# define FP_PACK_SEMIRAW_EP(val, X)		\
   do						\
     {						\
-      _FP_PACK_SEMIRAW(E,2,X);			\
-      FP_PACK_RAW_EP(val,X);			\
+      _FP_PACK_SEMIRAW (E, 2, X);		\
+      FP_PACK_RAW_EP (val, X);			\
     }						\
   while (0)
 
-# define FP_ISSIGNAN_E(X)	_FP_ISSIGNAN(E,2,X)
-# define FP_NEG_E(R,X)		_FP_NEG(E,2,R,X)
-# define FP_ADD_E(R,X,Y)	_FP_ADD(E,2,R,X,Y)
-# define FP_SUB_E(R,X,Y)	_FP_SUB(E,2,R,X,Y)
-# define FP_MUL_E(R,X,Y)	_FP_MUL(E,2,R,X,Y)
-# define FP_DIV_E(R,X,Y)	_FP_DIV(E,2,R,X,Y)
-# define FP_SQRT_E(R,X)		_FP_SQRT(E,2,R,X)
-# define FP_FMA_E(R,X,Y,Z)	_FP_FMA(E,2,4,R,X,Y,Z)
+# define FP_ISSIGNAN_E(X)	_FP_ISSIGNAN (E, 2, X)
+# define FP_NEG_E(R, X)		_FP_NEG (E, 2, R, X)
+# define FP_ADD_E(R, X, Y)	_FP_ADD (E, 2, R, X, Y)
+# define FP_SUB_E(R, X, Y)	_FP_SUB (E, 2, R, X, Y)
+# define FP_MUL_E(R, X, Y)	_FP_MUL (E, 2, R, X, Y)
+# define FP_DIV_E(R, X, Y)	_FP_DIV (E, 2, R, X, Y)
+# define FP_SQRT_E(R, X)	_FP_SQRT (E, 2, R, X)
+# define FP_FMA_E(R, X, Y, Z)	_FP_FMA (E, 2, 4, R, X, Y, Z)
 
 /*
  * Square root algorithms:
@@ -465,8 +465,8 @@ union _FP_UNION_E
 # define _FP_SQRT_MEAT_E(R, S, T, X, q)			\
   do							\
     {							\
-      q = (_FP_W_TYPE)1 << (_FP_W_TYPE_SIZE - 1);	\
-      _FP_FRAC_SRL_2(X, (_FP_WORKBITS));		\
+      q = (_FP_W_TYPE) 1 << (_FP_W_TYPE_SIZE - 1);	\
+      _FP_FRAC_SRL_2 (X, (_FP_WORKBITS));		\
       while (q)						\
 	{						\
 	  T##_f0 = S##_f0 + q;				\
@@ -476,10 +476,10 @@ union _FP_UNION_E
 	      X##_f0 -= T##_f0;				\
 	      R##_f0 += q;				\
 	    }						\
-	  _FP_FRAC_SLL_1(X, 1);				\
+	  _FP_FRAC_SLL_1 (X, 1);			\
 	  q >>= 1;					\
 	}						\
-      _FP_FRAC_SLL_2(R, (_FP_WORKBITS));		\
+      _FP_FRAC_SLL_2 (R, (_FP_WORKBITS));		\
       if (X##_f0)					\
 	{						\
 	  if (S##_f0 < X##_f0)				\
@@ -489,12 +489,12 @@ union _FP_UNION_E
     }							\
   while (0)
 
-# define FP_CMP_E(r,X,Y,un)	_FP_CMP(E,2,r,X,Y,un)
-# define FP_CMP_EQ_E(r,X,Y)	_FP_CMP_EQ(E,2,r,X,Y)
-# define FP_CMP_UNORD_E(r,X,Y)	_FP_CMP_UNORD(E,2,r,X,Y)
+# define FP_CMP_E(r, X, Y, un)		_FP_CMP (E, 2, r, X, Y, un)
+# define FP_CMP_EQ_E(r, X, Y)		_FP_CMP_EQ (E, 2, r, X, Y)
+# define FP_CMP_UNORD_E(r, X, Y)	_FP_CMP_UNORD (E, 2, r, X, Y)
 
-# define FP_TO_INT_E(r,X,rsz,rsg)	_FP_TO_INT(E,2,r,X,rsz,rsg)
-# define FP_FROM_INT_E(X,r,rs,rt)	_FP_FROM_INT(E,2,X,r,rs,rt)
+# define FP_TO_INT_E(r, X, rsz, rsg)	_FP_TO_INT (E, 2, r, X, rsz, rsg)
+# define FP_FROM_INT_E(X, r, rs, rt)	_FP_FROM_INT (E, 2, X, r, rs, rt)
 
 # define _FP_FRAC_HIGH_E(X)	(X##_f1)
 # define _FP_FRAC_HIGH_RAW_E(X)	(X##_f0)