1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
  
13
  
14
  
15
  
16
  
17
  
18
  
19
  
20
  
21
  
22
  
23
  
24
  
25
  
26
  
27
  
28
  
29
  
30
  
31
  
32
  
33
  
34
  
35
  
36
  
37
  
38
  
39
  
40
  
41
  
42
  
43
  
44
  
45
  
46
  
47
  
48
  
49
  
50
  
51
  
52
  
53
  
54
  
55
  
56
  
57
  
58
  
59
  
60
  
61
  
62
  
63
  
64
  
65
  
66
  
67
  
68
  
69
  
70
  
71
  
72
  
73
  
74
  
75
  
76
  
77
  
78
  
79
  
80
  
81
  
82
  
83
  
84
  
85
  
86
  
87
  
88
  
89
  
90
  
91
  
92
  
93
  
94
  
95
  
96
  
97
  
98
  
99
  
100
  
101
  
102
  
103
  
104
  
105
  
106
  
107
  
108
  
109
  
/* 
|| This file is part of Pike. For copyright information see COPYRIGHT. 
|| Pike is distributed under GPL, LGPL and MPL. See the file COPYING 
|| for more information. 
*/ 
 
#include "global.h" 
#include "stuff.h" 
#include "bitvector.h" 
#include "pike_cpulib.h" 
#include "pike_memory.h" 
 
/* Used by isidchar in pike_macros.h. */ 
PMOD_EXPORT const char Pike_isidchar_vector[] = 
  "0000000000000000" 
  "0000000000000000" 
  "0000000000000000" 
  "1111111111000000" 
  "0111111111111111" 
  "1111111111100001" 
  "0111111111111111" 
  "1111111111100000" 
  "0000000000000000" 
  "0000000000000000" 
  "0011110101100010" 
  "1011011001101110" 
  "1111111111111111" 
  "1111111011111111" 
  "1111111111111111" 
  "1111111011111111"; 
 
/* Not all of these are primes, but they should be adequate */ 
const INT32 hashprimes[32] = 
{ 
  31,        /* ~ 2^0  = 1 */ 
  31,        /* ~ 2^1  = 2 */ 
  31,        /* ~ 2^2  = 4 */ 
  31,        /* ~ 2^3  = 8 */ 
  31,        /* ~ 2^4  = 16 */ 
  31,        /* ~ 2^5  = 32 */ 
  61,        /* ~ 2^6  = 64 */ 
  127,       /* ~ 2^7  = 128 */ 
  251,       /* ~ 2^8  = 256 */ 
  541,       /* ~ 2^9  = 512 */ 
  1151,      /* ~ 2^10 = 1024 */ 
  2111,      /* ~ 2^11 = 2048 */ 
  4327,      /* ~ 2^12 = 4096 */ 
  8803,      /* ~ 2^13 = 8192 */ 
  17903,     /* ~ 2^14 = 16384 */ 
  32321,     /* ~ 2^15 = 32768 */ 
  65599,     /* ~ 2^16 = 65536 */ 
  133153,    /* ~ 2^17 = 131072 */ 
  270001,    /* ~ 2^18 = 264144 */ 
  547453,    /* ~ 2^19 = 524288 */ 
  1109891,   /* ~ 2^20 = 1048576 */ 
  2000143,   /* ~ 2^21 = 2097152 */ 
  4561877,   /* ~ 2^22 = 4194304 */ 
  9248339,   /* ~ 2^23 = 8388608 */ 
  16777215,  /* ~ 2^24 = 16777216 */ 
  33554431,  /* ~ 2^25 = 33554432 */ 
  67108863,  /* ~ 2^26 = 67108864 */ 
  134217727, /* ~ 2^27 = 134217728 */ 
  268435455, /* ~ 2^28 = 268435456 */ 
  536870911, /* ~ 2^29 = 536870912 */ 
  1073741823,/* ~ 2^30 = 1073741824 */ 
  2147483647,/* ~ 2^31 = 2147483648 */ 
}; 
 
/* Same thing as (int)floor(log((double)x) / log(2.0)), except a bit 
   quicker. Number of log2 per second: 
 
   log(x)/log(2.0)             50,000,000 
   log2(x)                     75,000,000 
   Table lookup             3,000,000,000 
   Intrinsic       30,000,000,000,000,000 
*/ 
 
PMOD_EXPORT int my_log2(UINT64 x) 
{ 
    if( x == 0 ) return 0; 
    if(x & ~((UINT64)0xffffffffUL)) { 
      return 32 + log2_u32((unsigned INT32)(x>>32)); 
    } 
    return log2_u32((unsigned INT32)x); 
} 
 
 
PMOD_EXPORT double my_strtod(char *nptr, char **endptr) 
{ 
  double tmp=strtod(nptr,endptr); 
  if(*endptr>nptr) 
  { 
    if(endptr[0][-1]=='.') 
      endptr[0]--; 
  } 
  return tmp; 
} 
 
/* 
 * This rounds an integer up to the next power of two. For x a power 
 * of two, this will just return the same again. 
 */ 
unsigned INT32 find_next_power(unsigned INT32 x) 
{ 
    if( x == 0 ) return 1; 
    return 1<<(my_log2(x-1)+1); 
}