src/float/input/cl_F_readparsed.cc

   1 // read_float().
   2
   3 // General includes.
   4 #include "cl_sysdep.h"
   5
   6 // Specification.
   7 #include "cln/float_io.h"
   8
   9
  10 // Implementation.
  11
  12 #include "cln/integer.h"
  13 #include "cl_I.h"
  14 #include "cln/rational.h"
  15 #include "cl_RA.h"
  16 #include "cln/float.h"
  17 #include "cln/sfloat.h"
  18 #include "cln/ffloat.h"
  19 #include "cln/dfloat.h"
  20 #include "cln/lfloat.h"
  21 #include "cl_F.h"
  22 #include "cl_SF.h"
  23 #include "cl_FF.h"
  24 #include "cl_DF.h"
  25 #include "cl_LF.h"
  26
  27 namespace cln {
  28
  29 const cl_F read_float (unsigned int base, float_format_t prec, cl_signean sign, const char * string, uintC index1, uintC index4, uintC index2, uintC index3)
  30 {
  31         var cl_I exponent;
  32         {
  33                 var uintC exp_len = index2-index4; // Anzahl Stellen des Exponenten
  34                 if (exp_len > 0) {
  35                         var const char * ptr = &string[index4]; // zeigt auf den Exponentmarker
  36                         ptr++; exp_len--; // Exponentmarker überlesen
  37                         var cl_signean exp_sign = 0; // Exponenten-Vorzeichen
  38                         switch (*ptr) {
  39                                 case '-': exp_sign = ~exp_sign; // Vorzeichen := negativ
  40                                 case '+': ptr++; exp_len--; // Exponenten-Vorzeichen überlesen
  41                                 default: ;
  42                         }
  43                         exponent = digits_to_I(ptr,exp_len,(uintD)base); // Exponent in Integer umwandeln
  44                         if (!(exp_sign==0))
  45                                 exponent = -exponent; // incl. Vorzeichen
  46                 } else {
  47                         // kein Exponent da
  48                         exponent = 0;
  49                 }
  50         }
  51         // exponent = Exponent als Integer.
  52         var cl_RA base_power = expt(base,exponent-(index4-index3)); // zu multiplizierende Zehnerpotenz
  53         var cl_I mantisse = // Mantisse als Integer
  54           digits_to_I(&string[index1],index4-index1,(uintD)base);
  55         // Mantisse (Integer) und Zehnerpotenz (rational >0) unelegant zusammenmultiplizieren:
  56         var cl_RA ratvalue;
  57         if (integerp(base_power)) {
  58                 DeclareType(cl_I,base_power);
  59                 ratvalue = mantisse * base_power;
  60         } else {
  61                 // falls mantisse/=0, in exponent=1/10^i den Zähler durch mantisse
  62                 // ersetzen (liefert ungekürzten Bruch, Vorsicht!)
  63                 DeclareType(cl_RT,base_power);
  64                 if (zerop(mantisse))
  65                         ratvalue = 0;
  66                 else {
  67                         ASSERT(TheRatio(base_power)->refcount == 1);
  68                         TheRatio(base_power)->numerator = mantisse;
  69                         ratvalue = base_power;
  70                 }
  71         }
  72         // ratvalue = Mantisse * Zehnerpotenz, als ungekürzte rationale Zahl!
  73         floatformatcase(prec
  74         ,       // in Short-Float umwandeln
  75                 {
  76                         var cl_SF x = cl_RA_to_SF(ratvalue);
  77                         if (sign==0) { return x; } else { return -x; }
  78                 }
  79         ,       // in Single-Float umwandeln
  80                 {
  81                         var cl_FF x = cl_RA_to_FF(ratvalue);
  82                         if (sign==0) { return x; } else { return -x; }
  83                 }
  84         ,       // in Double-Float umwandeln
  85                 {
  86                         var cl_DF x = cl_RA_to_DF(ratvalue);
  87                         if (sign==0) { return x; } else { return -x; }
  88                 }
  89         ,       // in Long-Float umwandeln
  90                 {
  91                         var cl_LF x = cl_RA_to_LF(ratvalue,len);
  92                         if (sign==0) { return x; } else { return -x; }
  93                 }
  94         );
  95 }
  96
  97 }  // namespace cln