Source:NetHack 5.0.0/src/isaac64.c

From NetHackWiki
Jump to navigation Jump to search

Below is the full text to isaac64.c from the source code of NetHack 5.0.0. To link to a particular line, write [[Source:NetHack 5.0.0/src/isaac64.c#line12]], for example.

The NetHack General Public License applies to screenshots, source code and other content from NetHack.

This content was modified from the original NetHack source code distribution (by splitting up NetHack content between wiki pages, and possibly further editing). See the page history for a list of who changed it, and on what dates.

1. /*Written by Timothy B. Terriberry (tterribe@xiph.org) 1999-2009
2.   CC0 (Public domain) - see http://creativecommons.org/publicdomain/zero/1.0/
3.   for details.
4.   Based on the public domain ISAAC implementation by Robert J. Jenkins Jr.*/
5. 
6. /*
7.  * Changes for NetHack:
8.  *      include config.h;
9.  *      skip rest of file if USE_ISAAC64 isn't defined there;
10.  *      re-do 'inline' handling.
11.  */
12. #include "config.h"
13. 
14. #ifdef USE_ISAAC64
15. #include <string.h>
16. #include "isaac64.h"
17. 
18. #define ISAAC64_MASK ((uint64_t)0xFFFFFFFFFFFFFFFFULL)
19. 
20. #if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L)
21. #if !defined(HAS_INLINE)
22. #define HAS_INLINE
23. #endif
24. #else
25. # if (defined(__GNUC__) && __GNUC__ >= 2 && !defined(inline))
26. # define inline __inline__
27. # endif
28. #endif
29. #if !defined(HAS_INLINE) && !defined(inline)
30. #define inline /*empty*/
31. #endif
32. 
33. static inline uint32_t lower_bits(uint64_t);
34. static inline uint32_t upper_bits(uint64_t);
35. staticfn void isaac64_update(isaac64_ctx *);
36. staticfn void isaac64_mix(uint64_t[8]);
37. 
38. /* Extract ISAAC64_SZ_LOG bits (starting at bit 3). */
39. static inline uint32_t lower_bits(uint64_t x)
40. {
41.     return (x & ((ISAAC64_SZ-1) << 3)) >>3;
42. }
43. 
44. /* Extract next ISAAC64_SZ_LOG bits (starting at bit ISAAC64_SZ_LOG+2). */
45. static inline uint32_t upper_bits(uint64_t y)
46. {
47.     return (y >> (ISAAC64_SZ_LOG+3)) & (ISAAC64_SZ-1);
48. }
49. 
50. staticfn void isaac64_update(isaac64_ctx *_ctx){
51.   uint64_t *m;
52.   uint64_t *r;
53.   uint64_t  a;
54.   uint64_t  b;
55.   uint64_t  x;
56.   uint64_t  y;
57.   int       i;
58.   m=_ctx->m;
59.   r=_ctx->r;
60.   a=_ctx->a;
61.   b=_ctx->b+(++_ctx->c);
62.   for(i=0;i<ISAAC64_SZ/2;i++){
63.     x=m[i];
64.     a=~(a^a<<21)+m[i+ISAAC64_SZ/2];
65.     m[i]=y=m[lower_bits(x)]+a+b;
66.     r[i]=b=m[upper_bits(y)]+x;
67.     x=m[++i];
68.     a=(a^a>>5)+m[i+ISAAC64_SZ/2];
69.     m[i]=y=m[lower_bits(x)]+a+b;
70.     r[i]=b=m[upper_bits(y)]+x;
71.     x=m[++i];
72.     a=(a^a<<12)+m[i+ISAAC64_SZ/2];
73.     m[i]=y=m[lower_bits(x)]+a+b;
74.     r[i]=b=m[upper_bits(y)]+x;
75.     x=m[++i];
76.     a=(a^a>>33)+m[i+ISAAC64_SZ/2];
77.     m[i]=y=m[lower_bits(x)]+a+b;
78.     r[i]=b=m[upper_bits(y)]+x;
79.   }
80.   for(i=ISAAC64_SZ/2;i<ISAAC64_SZ;i++){
81.     x=m[i];
82.     a=~(a^a<<21)+m[i-ISAAC64_SZ/2];
83.     m[i]=y=m[lower_bits(x)]+a+b;
84.     r[i]=b=m[upper_bits(y)]+x;
85.     x=m[++i];
86.     a=(a^a>>5)+m[i-ISAAC64_SZ/2];
87.     m[i]=y=m[lower_bits(x)]+a+b;
88.     r[i]=b=m[upper_bits(y)]+x;
89.     x=m[++i];
90.     a=(a^a<<12)+m[i-ISAAC64_SZ/2];
91.     m[i]=y=m[lower_bits(x)]+a+b;
92.     r[i]=b=m[upper_bits(y)]+x;
93.     x=m[++i];
94.     a=(a^a>>33)+m[i-ISAAC64_SZ/2];
95.     m[i]=y=m[lower_bits(x)]+a+b;
96.     r[i]=b=m[upper_bits(y)]+x;
97.   }
98.   _ctx->b=b;
99.   _ctx->a=a;
100.   _ctx->n=ISAAC64_SZ;
101. }
102. 
103. staticfn void isaac64_mix(uint64_t _x[8]){
104.   static const unsigned char SHIFT[8]={9,9,23,15,14,20,17,14};
105.   int i;
106.   for(i=0;i<8;i++){
107.     _x[i]-=_x[(i+4)&7];
108.     _x[(i+5)&7]^=_x[(i+7)&7]>>SHIFT[i];
109.     _x[(i+7)&7]+=_x[i];
110.     i++;
111.     _x[i]-=_x[(i+4)&7];
112.     _x[(i+5)&7]^=_x[(i+7)&7]<<SHIFT[i];
113.     _x[(i+7)&7]+=_x[i];
114.   }
115. }
116. 
117. 
118. void isaac64_init(isaac64_ctx *_ctx,const unsigned char *_seed,int _nseed){
119.   _ctx->a=_ctx->b=_ctx->c=0;
120.   memset(_ctx->r,0,sizeof(_ctx->r));
121.   isaac64_reseed(_ctx,_seed,_nseed);
122. }
123. 
124. void isaac64_reseed(isaac64_ctx *_ctx,const unsigned char *_seed,int _nseed){
125.   uint64_t *m;
126.   uint64_t *r;
127.   uint64_t  x[8];
128.   int       i;
129.   int       j;
130.   m=_ctx->m;
131.   r=_ctx->r;
132.   if(_nseed>ISAAC64_SEED_SZ_MAX)_nseed=ISAAC64_SEED_SZ_MAX;
133.   for(i=0;i<_nseed>>3;i++){
134.     r[i]^=(uint64_t)_seed[i<<3|7]<<56|(uint64_t)_seed[i<<3|6]<<48|
135.      (uint64_t)_seed[i<<3|5]<<40|(uint64_t)_seed[i<<3|4]<<32|
136.      (uint64_t)_seed[i<<3|3]<<24|(uint64_t)_seed[i<<3|2]<<16|
137.      (uint64_t)_seed[i<<3|1]<<8|_seed[i<<3];
138.   }
139.   _nseed-=i<<3;
140.   if(_nseed>0){
141.     uint64_t ri;
142.     ri=_seed[i<<3];
143.     for(j=1;j<_nseed;j++)ri|=(uint64_t)_seed[i<<3|j]<<(j<<3);
144.     r[i++]^=ri;
145.   }
146.   x[0]=x[1]=x[2]=x[3]=x[4]=x[5]=x[6]=x[7]=(uint64_t)0x9E3779B97F4A7C13ULL;
147.   for(i=0;i<4;i++)isaac64_mix(x);
148.   for(i=0;i<ISAAC64_SZ;i+=8){
149.     for(j=0;j<8;j++)x[j]+=r[i+j];
150.     isaac64_mix(x);
151.     memcpy(m+i,x,sizeof(x));
152.   }
153.   for(i=0;i<ISAAC64_SZ;i+=8){
154.     for(j=0;j<8;j++)x[j]+=m[i+j];
155.     isaac64_mix(x);
156.     memcpy(m+i,x,sizeof(x));
157.   }
158.   isaac64_update(_ctx);
159. }
160. 
161. uint64_t isaac64_next_uint64(isaac64_ctx *_ctx){
162.   if(!_ctx->n)isaac64_update(_ctx);
163.   return _ctx->r[--_ctx->n];
164. }
165. 
166. uint64_t isaac64_next_uint(isaac64_ctx *_ctx,uint64_t _n){
167.   uint64_t r;
168.   uint64_t v;
169.   uint64_t d;
170.   do{
171.     r=isaac64_next_uint64(_ctx);
172.     v=r%_n;
173.     d=r-v;
174.   }
175.   while(((d+_n-1)&ISAAC64_MASK)<d);
176.   return v;
177. }
178. #endif /* USE_ISAAC64 */
179. 
180. /*isaac64.c*/