src/integer/conv/cl_I_from_UL.cc

   1 // UL_to_I() helper.
   2
   3 // General includes.
   4 #include "base/cl_sysdep.h"
   5
   6 // Specification.
   7 #include "integer/cl_I.h"
   8
   9
  10 // Implementation.
  11
  12 #include "cln/number.h"
  13
  14 #if (cl_value_len <= 32) || (long_bitsize==32)
  15
  16 #include "base/digitseq/cl_DS.h"
  17
  18 namespace cln {
  19
  20 cl_private_thing cl_I_constructor_from_UL (uint32 wert)
  21 {
  22 #if (cl_value_len <= 32)
  23         if ((wert & minus_bit(cl_value_len-1)) == 0)
  24            // Bits, die nicht in den Fixnum-Wert >= 0 reinpassen.
  25                 return (cl_private_thing)(cl_combine(cl_FN_tag,wert));
  26         // Bignum erzeugen:
  27         // (dessen Länge  bn_minlength <= n <= ceiling((32+1)/intDsize)  erfüllt)
  28         #define UL_maxlength  ceiling(32+1,intDsize)
  29         #define IF_LENGTH(i)  \
  30           if ((bn_minlength <= i) && (i <= UL_maxlength)        \
  31             && (!(i+1 <= UL_maxlength)                          \
  32                 || ((uint32)wert < (uint32)bitc(i*intDsize-1))  \
  33              ) )
  34         IF_LENGTH(1)
  35                 { var cl_heap_bignum* ptr = allocate_bignum(1);
  36                   arrayLSref(ptr->data,1,0) = wert;
  37                   return (cl_private_thing)(ptr);
  38                 }
  39         #if (intDsize <= 32)
  40         IF_LENGTH(2)
  41                 { var cl_heap_bignum* ptr = allocate_bignum(2);
  42                   arrayLSref(ptr->data,2,0) = (uintD)wert;
  43                   #if (intDsize>=32)
  44                   arrayLSref(ptr->data,2,1) = 0;
  45                   #else
  46                   arrayLSref(ptr->data,2,1) = (uintD)(wert>>intDsize);
  47                   #endif
  48                   return (cl_private_thing)(ptr);
  49                 }
  50         #if (intDsize <= 16)
  51         IF_LENGTH(3)
  52                 { var cl_heap_bignum* ptr = allocate_bignum(3);
  53                   arrayLSref(ptr->data,3,0) = (uintD)wert; wert >>= intDsize;
  54                   arrayLSref(ptr->data,3,1) = (uintD)wert;
  55                   #if (2*intDsize>=32)
  56                   arrayLSref(ptr->data,3,2) = 0;
  57                   #else
  58                   arrayLSref(ptr->data,3,2) = (uintD)(wert>>intDsize);
  59                   #endif
  60                   return (cl_private_thing)(ptr);
  61                 }
  62         #if (intDsize <= 8)
  63         IF_LENGTH(4)
  64                 { var cl_heap_bignum* ptr = allocate_bignum(4);
  65                   arrayLSref(ptr->data,4,0) = (uintD)wert; wert >>= intDsize;
  66                   arrayLSref(ptr->data,4,1) = (uintD)wert; wert >>= intDsize;
  67                   arrayLSref(ptr->data,4,2) = (uintD)wert;
  68                   #if (3*intDsize>=32)
  69                   arrayLSref(ptr->data,4,3) = 0;
  70                   #else
  71                   arrayLSref(ptr->data,4,3) = (uintD)(wert>>intDsize);
  72                   #endif
  73                   return (cl_private_thing)(ptr);
  74                 }
  75         IF_LENGTH(5)
  76                 { var cl_heap_bignum* ptr = allocate_bignum(5);
  77                   arrayLSref(ptr->data,5,0) = (uintD)wert; wert >>= intDsize;
  78                   arrayLSref(ptr->data,5,1) = (uintD)wert; wert >>= intDsize;
  79                   arrayLSref(ptr->data,5,2) = (uintD)wert; wert >>= intDsize;
  80                   arrayLSref(ptr->data,5,3) = (uintD)wert;
  81                   #if (4*intDsize>=32)
  82                   arrayLSref(ptr->data,5,4) = 0;
  83                   #else
  84                   arrayLSref(ptr->data,5,4) = (uintD)(wert>>intDsize);
  85                   #endif
  86                   return (cl_private_thing)(ptr);
  87                 }
  88         #endif
  89         #endif
  90         #endif
  91         #undef IF_LENGTH
  92         #undef UL_maxlength
  93 #else // cl_value_len > 32
  94         // All bits fit in a fixnum value >= 0.
  95         return (cl_private_thing)(cl_combine(cl_FN_tag,wert));
  96 #endif
  97 }
  98
  99 }  // namespace cln
 100
 101 #endif