Replace unused macro with cl_unused.

[cln.git] / src / float / cl_F.h

diff --git a/src/float/cl_F.h b/src/float/cl_F.h
index 9dd7b205c04d24baaf179df40e73e21a1e87731a..a7d63fa38cc885607fe0be9cca4806fffc4e06bc 100644 (file)
--- a/src/float/cl_F.h
+++ b/src/float/cl_F.h
@@ -4,14 +4,11 @@
 #define _CL_F_H
 
 #include "cln/number.h"
-#include "cl_macros.h"
+#include "base/cl_macros.h"
 #include "cln/float.h"
 
 namespace cln {
 
-nonreturning_function(extern, cl_error_floating_point_overflow, (void));
-nonreturning_function(extern, cl_error_floating_point_underflow, (void));
-
 #define underflow_allowed()  (! cl_inhibit_floating_point_underflow)
 
 
@@ -24,7 +21,7 @@ nonreturning_function(extern, cl_error_floating_point_underflow, (void));
 // SF           1           8             16
 // FF           1           8             23
 // DF           1          11             52
-// LF           1          32         intDsize*n >= 53
+// LF           1       32 or 64      intDsize*n >= 53
 
 
 // Konversionen ohne Rundung:
@@ -36,18 +33,18 @@ extern const cl_FF cl_SF_to_FF (const cl_SF& x);
 extern const cl_DF cl_SF_to_DF (const cl_SF& x);
 
 // cl_SF_to_LF(x,len) wandelt ein Short-Float x in ein Long-Float mit len Digits um.
-// > uintC len: gewünschte Anzahl Digits, >=LF_minlen
+// > uintC len: gewünschte Anzahl Digits, >=LF_minlen
 extern const cl_LF cl_SF_to_LF (const cl_SF& x, uintC len);
 
 // cl_FF_to_DF(x) wandelt ein Single-Float x in ein Double-Float um.
 extern const cl_DF cl_FF_to_DF (const cl_FF& x);
 
 // cl_FF_to_LF(x,len) wandelt ein Single-Float x in ein Long-Float mit len Digits um.
-// > uintC len: gewünschte Anzahl Digits, >=LF_minlen
+// > uintC len: gewünschte Anzahl Digits, >=LF_minlen
 extern const cl_LF cl_FF_to_LF (const cl_FF& x, uintC len);
 
 // cl_DF_to_LF(x,len) wandelt ein Double-Float x in ein Long-Float mit len Digits um.
-// > uintC len: gewünschte Anzahl Digits, >=LF_minlen
+// > uintC len: gewünschte Anzahl Digits, >=LF_minlen
 extern const cl_LF cl_DF_to_LF (const cl_DF& x, uintC len);
 
 
@@ -72,22 +69,18 @@ extern const cl_FF cl_LF_to_FF (const cl_LF& x);
 extern const cl_DF cl_LF_to_DF (const cl_LF& x);
 
 
-// Fehlermeldung wegen NaN
-nonreturning_function(extern, cl_error_floating_point_nan, (void));
-
-
 // Runtime typing support.
 extern cl_class cl_class_ffloat;
 extern cl_class cl_class_dfloat;
 extern cl_class cl_class_lfloat;
 
 // Type test.
-inline cl_boolean longfloatp (const cl_F& x)
+inline bool longfloatp (const cl_F& x)
 {
        if (x.pointer_p())
                if (x.pointer_type() == &cl_class_lfloat)
-                       return cl_true;
-       return cl_false;
+                       return true;
+       return false;
 }
 
 // Macro: verteilt je nach Float-Typ eines Floats x auf 4 Statements.
@@ -122,7 +115,7 @@ inline cl_boolean longfloatp (const cl_F& x)
 #endif
 
 // Macro: verteilt je nach Float-Typ eines Floats x auf 4 Statements,
-// die x vom jeweiligen Float-Typ benutzen dürfen.
+// die x vom jeweiligen Float-Typ benutzen dürfen.
 // floatcase(x, SF_statement,FF_statement,DF_statement,LF_statement);
 // x sollte eine Variable sein.
   #define floatcase(x, SF_statement,FF_statement,DF_statement,LF_statement) \
@@ -225,13 +218,13 @@ inline cl_boolean longfloatp (const cl_F& x)
 #define GEN_LF_OP2_AUX0(arg1,arg2,F_OP,r,ergebnis_zuweisung)  \
   var uintC len1 = TheLfloat(arg1)->len;                               \
   var uintC len2 = TheLfloat(arg2)->len;                               \
-  if (len1 == len2) /* gleich -> direkt ausführen */                   \
+  if (len1 == len2) /* gleich -> direkt ausführen */                  \
     { ergebnis_zuweisung CONCAT(NOMAP,r) (LF, F_OP(arg1,arg2)); }      \
-  elif (len1 > len2) /* -> arg2 auf die Länge von arg1 bringen */      \
+  elif (len1 > len2) /* -> arg2 auf die Länge von arg1 bringen */     \
     { ergebnis_zuweisung CONCAT(MAP,r) (LF, LF_shorten_len2,           \
       F_OP(arg1,extend(arg2,len1)) );                                  \
     }                                                                  \
-  else /* (len1 < len2) -> arg1 auf die Länge von arg2 bringen */      \
+  else /* (len1 < len2) -> arg1 auf die Länge von arg2 bringen */     \
     { ergebnis_zuweisung CONCAT(MAP,r) (LF, LF_shorten_len1,           \
       F_OP(extend(arg1,len2),arg2) );                                  \
     }
@@ -270,7 +263,7 @@ extern const cl_F cl_F_shortenrelative (const cl_F& x, const cl_F& y);
 // Macro: dispatches according to a float_format_t value.
 // floatformatcase(value, SF_statement,FF_statement,DF_statement,LF_statement)
 // LF_statement darf auf `len' zugreifen, die zu `value' korrespondierende
-// Mantissenlänge (gemessen in Digits).
+// Mantissenlänge (gemessen in Digits).
   #define floatformatcase(value, SF_statement,FF_statement,DF_statement,LF_statement)  \
     { if ((value) <= float_format_sfloat) { SF_statement }             \
       elif ((value) <= float_format_ffloat) { FF_statement }           \