src/integer/conv/cl_I_from_UQ.cc

   1 // UQ_to_I() helper.
   2
   3 // General includes.
   4 #include "cl_sysdep.h"
   5
   6 // Specification.
   7 #include "cl_I.h"
   8
   9
  10 // Implementation.
  11
  12 #include "cl_number.h"
  13
  14 #ifdef intQsize
  15
  16 #include "cl_DS.h"
  17
  18 cl_private_thing cl_I_constructor_from_UQ (uint64 wert)
  19 {
  20         if ((wert & (sint64)minus_bit(cl_value_len-1)) == 0)
  21            // Bits, die nicht in den Fixnum-Wert >= 0 reinpassen.
  22                 return (cl_private_thing)(cl_combine(cl_FN_tag,(uint32)wert));
  23         // Bignum erzeugen:
  24         // (dessen Länge  bn_minlength <= n <= ceiling((32+1)/intDsize)  erfüllt)
  25         #define UQ_maxlength  ceiling(64+1,intDsize)
  26         #define IF_LENGTH(i)  \
  27           if ((bn_minlength <= i) && (i <= UQ_maxlength))       \
  28             if (!(i+1 <= UQ_maxlength)                          \
  29                 || ((uint64)wert < ((uint64)1 << (i*intDsize-1 < 64 ? i*intDsize-1 : 0))) \
  30                )
  31         IF_LENGTH(1)
  32                 { var cl_heap_bignum* ptr = allocate_bignum(1);
  33                   arrayLSref(ptr->data,1,0) = (uintD)wert;
  34                   return (cl_private_thing)(ptr);
  35                 }
  36         IF_LENGTH(2)
  37                 { var cl_heap_bignum* ptr = allocate_bignum(2);
  38                   arrayLSref(ptr->data,2,0) = (uintD)wert;
  39                   #if (intDsize>=64)
  40                   arrayLSref(ptr->data,2,1) = 0;
  41                   #else
  42                   arrayLSref(ptr->data,2,1) = (uintD)(wert>>intDsize);
  43                   #endif
  44                   return (cl_private_thing)(ptr);
  45                 }
  46         #if (intDsize <= 32)
  47         IF_LENGTH(3)
  48                 { var cl_heap_bignum* ptr = allocate_bignum(3);
  49                   arrayLSref(ptr->data,3,0) = (uintD)wert; wert >>= intDsize;
  50                   arrayLSref(ptr->data,3,1) = (uintD)wert;
  51                   #if (2*intDsize>=64)
  52                   arrayLSref(ptr->data,3,2) = 0;
  53                   #else
  54                   arrayLSref(ptr->data,3,2) = (uintD)(wert>>intDsize);
  55                   #endif
  56                   return (cl_private_thing)(ptr);
  57                 }
  58         #if (intDsize <= 16)
  59         IF_LENGTH(4)
  60                 { var cl_heap_bignum* ptr = allocate_bignum(4);
  61                   arrayLSref(ptr->data,4,0) = (uintD)wert; wert >>= intDsize;
  62                   arrayLSref(ptr->data,4,1) = (uintD)wert; wert >>= intDsize;
  63                   arrayLSref(ptr->data,4,2) = (uintD)wert;
  64                   #if (3*intDsize>=64)
  65                   arrayLSref(ptr->data,4,3) = 0;
  66                   #else
  67                   arrayLSref(ptr->data,4,3) = (uintD)(wert>>intDsize);
  68                   #endif
  69                   return (cl_private_thing)(ptr);
  70                 }
  71         IF_LENGTH(5)
  72                 { var cl_heap_bignum* ptr = allocate_bignum(5);
  73                   arrayLSref(ptr->data,5,0) = (uintD)wert; wert >>= intDsize;
  74                   arrayLSref(ptr->data,5,1) = (uintD)wert; wert >>= intDsize;
  75                   arrayLSref(ptr->data,5,2) = (uintD)wert; wert >>= intDsize;
  76                   arrayLSref(ptr->data,5,3) = (uintD)wert;
  77                   #if (4*intDsize>=64)
  78                   arrayLSref(ptr->data,5,4) = 0;
  79                   #else
  80                   arrayLSref(ptr->data,5,4) = (uintD)(wert>>intDsize);
  81                   #endif
  82                   return (cl_private_thing)(ptr);
  83                 }
  84         #if (intDsize <= 8)
  85         IF_LENGTH(6)
  86                 { var cl_heap_bignum* ptr = allocate_bignum(6);
  87                   arrayLSref(ptr->data,6,0) = (uintD)wert; wert >>= intDsize;
  88                   arrayLSref(ptr->data,6,1) = (uintD)wert; wert >>= intDsize;
  89                   arrayLSref(ptr->data,6,2) = (uintD)wert; wert >>= intDsize;
  90                   arrayLSref(ptr->data,6,3) = (uintD)wert; wert >>= intDsize;
  91                   arrayLSref(ptr->data,6,4) = (uintD)wert;
  92                   #if (5*intDsize>=64)
  93                   arrayLSref(ptr->data,6,5) = 0;
  94                   #else
  95                   arrayLSref(ptr->data,6,5) = (uintD)(wert>>intDsize);
  96                   #endif
  97                   return (cl_private_thing)(ptr);
  98                 }
  99         IF_LENGTH(7)
 100                 { var cl_heap_bignum* ptr = allocate_bignum(7);
 101                   arrayLSref(ptr->data,7,0) = (uintD)wert; wert >>= intDsize;
 102                   arrayLSref(ptr->data,7,1) = (uintD)wert; wert >>= intDsize;
 103                   arrayLSref(ptr->data,7,2) = (uintD)wert; wert >>= intDsize;
 104                   arrayLSref(ptr->data,7,3) = (uintD)wert; wert >>= intDsize;
 105                   arrayLSref(ptr->data,7,4) = (uintD)wert; wert >>= intDsize;
 106                   arrayLSref(ptr->data,7,5) = (uintD)wert;
 107                   #if (6*intDsize>=64)
 108                   arrayLSref(ptr->data,7,6) = 0;
 109                   #else
 110                   arrayLSref(ptr->data,7,6) = (uintD)(wert>>intDsize);
 111                   #endif
 112                   return (cl_private_thing)(ptr);
 113                 }
 114         IF_LENGTH(8)
 115                 { var cl_heap_bignum* ptr = allocate_bignum(8);
 116                   arrayLSref(ptr->data,8,0) = (uintD)wert; wert >>= intDsize;
 117                   arrayLSref(ptr->data,8,1) = (uintD)wert; wert >>= intDsize;
 118                   arrayLSref(ptr->data,8,2) = (uintD)wert; wert >>= intDsize;
 119                   arrayLSref(ptr->data,8,3) = (uintD)wert; wert >>= intDsize;
 120                   arrayLSref(ptr->data,8,4) = (uintD)wert; wert >>= intDsize;
 121                   arrayLSref(ptr->data,8,5) = (uintD)wert; wert >>= intDsize;
 122                   arrayLSref(ptr->data,8,6) = (uintD)wert;
 123                   #if (7*intDsize>=64)
 124                   arrayLSref(ptr->data,8,7) = 0;
 125                   #else
 126                   arrayLSref(ptr->data,8,7) = (uintD)(wert>>intDsize);
 127                   #endif
 128                   return (cl_private_thing)(ptr);
 129                 }
 130         IF_LENGTH(9)
 131                 { var cl_heap_bignum* ptr = allocate_bignum(9);
 132                   arrayLSref(ptr->data,9,0) = (uintD)wert; wert >>= intDsize;
 133                   arrayLSref(ptr->data,9,1) = (uintD)wert; wert >>= intDsize;
 134                   arrayLSref(ptr->data,9,2) = (uintD)wert; wert >>= intDsize;
 135                   arrayLSref(ptr->data,9,3) = (uintD)wert; wert >>= intDsize;
 136                   arrayLSref(ptr->data,9,4) = (uintD)wert; wert >>= intDsize;
 137                   arrayLSref(ptr->data,9,5) = (uintD)wert; wert >>= intDsize;
 138                   arrayLSref(ptr->data,9,6) = (uintD)wert; wert >>= intDsize;
 139                   arrayLSref(ptr->data,9,7) = (uintD)wert;
 140                   #if (8*intDsize>=64)
 141                   arrayLSref(ptr->data,9,8) = 0;
 142                   #else
 143                   arrayLSref(ptr->data,9,8) = (uintD)(wert>>intDsize);
 144                   #endif
 145                   return (cl_private_thing)(ptr);
 146                 }
 147         #endif
 148         #endif
 149         #endif
 150         #undef IF_LENGTH
 151         #undef UQ_maxlength
 152 }
 153
 154 #endif