Merge pull request #115 from bashtage/manylinux-wheel

bashtage · web-flow · commit c410b4675add · 2017-09-29T17:38:43.000+01:00
BLD: Add manylinux1 build
diff --git a/ci/docker-run.sh b/ci/docker-run.sh
@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+# Usage:
+#
+#   ci/docker-run.sh
+#
+# Must be started from repo root
+
+rm -rf wheelhouse
+mkdir wheelhouse
+
+export DOCKER_IMAGE=quay.io/pypa/manylinux1_x86_64
+sudo docker pull $DOCKER_IMAGE
+sudo docker run --rm -v `pwd`:/io $DOCKER_IMAGE /io/ci/docker-wheel-build.sh
diff --git a/ci/docker-wheel-build.sh b/ci/docker-wheel-build.sh
@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+
+set -e -x
+
+export SUPPORTED_PYTHONS=(cp27-cp27m cp35-cp35m cp36-cp36m)
+
+for PYVER in ${SUPPORTED_PYTHONS[@]}; do
+    echo ${PYVER}
+    PYBIN=/opt/python/${PYVER}/bin
+    "${PYBIN}/pip" install -r /io/ci/requirements_dev.txt
+    "${PYBIN}/pip" wheel /io/ --no-deps -w wheelhouse/
+done
+
+for whl in wheelhouse/*.whl; do
+    auditwheel repair $whl -w /io/wheelhouse/
+done
+
+cd $HOME
+for PYVER in ${SUPPORTED_PYTHONS[@]}; do
+    echo ${PYVER}
+    PYBIN=/opt/python/${PYVER}/bin
+    ${PYBIN}/pip install randomstate --no-index -f /io/wheelhouse
+    ${PYBIN}/pytest --pyargs randomstate
+done
diff --git a/ci/requirements_dev.txt b/ci/requirements_dev.txt
@@ -0,0 +1,4 @@
+numpy>=1.13
+cython>=0.26
+pytest
+nose
diff --git a/randomstate/src/mlfg-1279-861/mlfg-1279-861.h b/randomstate/src/mlfg-1279-861/mlfg-1279-861.h
@@ -30,7 +30,7 @@ void mlfg_init_state(mlfg_state *state, uint64_t seeds[K]);
 *  when making a 64 bit unsigned int, take the two upper
 *  32 bit segments.
 */
-inline uint64_t mlfg_next(mlfg_state* state)
+static inline uint64_t mlfg_next(mlfg_state* state)
 {
     state->pos++;
     state->lag_pos++;
diff --git a/randomstate/src/mrg32k3a/mrg32k3a.h b/randomstate/src/mrg32k3a/mrg32k3a.h
@@ -19,7 +19,7 @@ typedef struct s_mrg32k3a_state
     int loc;
 } mrg32k3a_state;
 
-inline uint32_t mrg32k3a_random(mrg32k3a_state* state)
+static inline uint32_t mrg32k3a_random(mrg32k3a_state* state)
 {
     int64_t p1 = 0;
     int64_t p2 = 0;
diff --git a/randomstate/src/pcg/pcg32.h b/randomstate/src/pcg/pcg32.h
@@ -25,7 +25,7 @@ typedef struct  {
 #define PCG_STATE_SETSEQ_64_INITIALIZER                                        \
     { 0x853c49e6748fea9bULL, 0xda3e39cb94b95bdbULL }
 
-inline uint32_t pcg_rotr_32(uint32_t value, unsigned int rot)
+static inline uint32_t pcg_rotr_32(uint32_t value, unsigned int rot)
 {
 #if PCG_USE_INLINE_ASM && __clang__ && (__x86_64__  || __i386__)
     asm ("rorl   %%cl, %0" : "=r" (value) : "0" (value), "c" (rot));
@@ -35,32 +35,32 @@ inline uint32_t pcg_rotr_32(uint32_t value, unsigned int rot)
 #endif
 }
 
-inline void pcg_setseq_64_step_r(pcg_state_setseq_64* rng)
+static inline void pcg_setseq_64_step_r(pcg_state_setseq_64* rng)
 {
     rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_64 + rng->inc;
 }
 
-inline uint32_t pcg_output_xsl_rr_64_32(uint64_t state)
+static inline uint32_t pcg_output_xsl_rr_64_32(uint64_t state)
 {
     return pcg_rotr_32(((uint32_t)(state >> 32u)) ^ (uint32_t)state,
                        state >> 59u);
 }
 
-inline uint32_t pcg_output_xsh_rr_64_32(uint64_t state)
+static inline uint32_t pcg_output_xsh_rr_64_32(uint64_t state)
 {
     return pcg_rotr_32(((state >> 18u) ^ state) >> 27u, state >> 59u);
 }
 
 
-inline uint32_t
+static inline uint32_t
 pcg_setseq_64_xsh_rr_32_random_r(pcg_state_setseq_64* rng)
 {
     uint64_t oldstate = rng->state;
     pcg_setseq_64_step_r(rng);
     return pcg_output_xsh_rr_64_32(oldstate);
 }
 
-inline void pcg_setseq_64_srandom_r(pcg_state_setseq_64* rng,
+static inline void pcg_setseq_64_srandom_r(pcg_state_setseq_64* rng,
                                     uint64_t initstate, uint64_t initseq)
 {
     rng->state = 0U;
@@ -70,15 +70,15 @@ inline void pcg_setseq_64_srandom_r(pcg_state_setseq_64* rng,
     pcg_setseq_64_step_r(rng);
 }
 
-inline uint32_t
+static inline uint32_t
 pcg_setseq_64_xsl_rr_32_random_r(pcg_state_setseq_64* rng)
 {
     uint64_t oldstate = rng->state;
     pcg_setseq_64_step_r(rng);
     return pcg_output_xsl_rr_64_32(oldstate);
 }
 
-inline uint32_t
+static inline uint32_t
 pcg_setseq_64_xsl_rr_32_boundedrand_r(pcg_state_setseq_64* rng,
                                       uint32_t bound)
 {
@@ -95,7 +95,7 @@ extern uint64_t pcg_advance_lcg_64(uint64_t state, uint64_t delta,
 
 
 
-inline void pcg_setseq_64_advance_r(pcg_state_setseq_64* rng,
+static inline void pcg_setseq_64_advance_r(pcg_state_setseq_64* rng,
                                     uint64_t delta)
 {
     rng->state = pcg_advance_lcg_64(rng->state, delta,
diff --git a/randomstate/src/pcg64-compat/pcg64.h b/randomstate/src/pcg64-compat/pcg64.h
@@ -34,7 +34,6 @@
 #include <inttypes.h>
 #endif
 
-
 #if __GNUC_GNU_INLINE__  &&  !defined(__cplusplus)
 #error Nonstandard GNU inlining semantics. Compile with -std=c99 or better.
 #endif
@@ -53,7 +52,7 @@ extern "C" {
         uint64_t low;
     } pcg128_t;
 
-    inline pcg128_t PCG_128BIT_CONSTANT(uint64_t high, uint64_t low) {
+    static inline pcg128_t PCG_128BIT_CONSTANT(uint64_t high, uint64_t low) {
         pcg128_t result;
         result.high = high;
         result.low = low;
@@ -80,22 +79,22 @@ extern "C" {
     { PCG_128BIT_CONSTANT(0x979c9a98d8462005ULL, 0x7d3e9cb6cfe0549bULL),       \
       PCG_128BIT_CONSTANT(0x0000000000000001ULL, 0xda3e39cb94b95bdbULL) }
 
-    inline uint64_t pcg_rotr_64(uint64_t value, unsigned int rot)
+    static inline uint64_t pcg_rotr_64(uint64_t value, unsigned int rot)
     {
         return (value >> rot) | (value << ((- rot) & 63));
     }
 
 #ifdef PCG_EMULATED_128BIT_MATH
 
-    inline pcg128_t _pcg128_add(pcg128_t a, pcg128_t b) {
+    static inline pcg128_t _pcg128_add(pcg128_t a, pcg128_t b) {
         pcg128_t result;
 
         result.low = a.low + b.low;
         result.high = a.high + b.high + (result.low < b.low);
         return result;
     }
 
-    inline void _pcg_mult64(uint64_t x, uint64_t y, uint64_t* z1, uint64_t* z0) {
+    static inline void _pcg_mult64(uint64_t x, uint64_t y, uint64_t* z1, uint64_t* z0) {
         uint64_t x0, x1, y0, y1;
         uint64_t w0, w1, w2, t;
         /* Lower 64 bits are straightforward clock-arithmetic. */
@@ -113,7 +112,7 @@ extern "C" {
         *z1 = x1 * y1 + w2 + (w1 >> 32);
     }
 
-    inline pcg128_t _pcg128_mult(pcg128_t a, pcg128_t b) {
+    static inline pcg128_t _pcg128_mult(pcg128_t a, pcg128_t b) {
         uint64_t h1;
         pcg128_t result;
 
@@ -123,18 +122,18 @@ extern "C" {
         return result;
     }
 
-    inline void pcg_setseq_128_step_r(pcg_state_setseq_128* rng)
+    static inline void pcg_setseq_128_step_r(pcg_state_setseq_128* rng)
     {
         rng->state = _pcg128_add(_pcg128_mult(rng->state, PCG_DEFAULT_MULTIPLIER_128), rng->inc);
     }
 
-    inline uint64_t pcg_output_xsl_rr_128_64(pcg128_t state)
+    static inline uint64_t pcg_output_xsl_rr_128_64(pcg128_t state)
     {
         return pcg_rotr_64(state.high ^ state.low,
                            state.high >> 58u);
     }
 
-    inline void pcg_setseq_128_srandom_r(pcg_state_setseq_128* rng,
+    static inline void pcg_setseq_128_srandom_r(pcg_state_setseq_128* rng,
                                          pcg128_t initstate, pcg128_t initseq)
     {
         rng->state = PCG_128BIT_CONSTANT(0ULL, 0ULL);
@@ -148,18 +147,18 @@ extern "C" {
 
 #else /* PCG_EMULATED_128BIT_MATH */
 
-    inline void pcg_setseq_128_step_r(pcg_state_setseq_128* rng)
+    static inline void pcg_setseq_128_step_r(pcg_state_setseq_128* rng)
     {
         rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_128 + rng->inc;
     }
 
-    inline uint64_t pcg_output_xsl_rr_128_64(pcg128_t state)
+    static inline uint64_t pcg_output_xsl_rr_128_64(pcg128_t state)
     {
         return pcg_rotr_64(((uint64_t)(state >> 64u)) ^ (uint64_t)state,
                            state >> 122u);
     }
 
-    inline void pcg_setseq_128_srandom_r(pcg_state_setseq_128* rng,
+    static inline void pcg_setseq_128_srandom_r(pcg_state_setseq_128* rng,
                                          pcg128_t initstate, pcg128_t initseq)
     {
         rng->state = 0U;
@@ -172,14 +171,14 @@ extern "C" {
 #endif /* PCG_EMULATED_128BIT_MATH */
 
 
-    inline uint64_t
+    static inline uint64_t
     pcg_setseq_128_xsl_rr_64_random_r(pcg_state_setseq_128* rng)
     {
         pcg_setseq_128_step_r(rng);
         return pcg_output_xsl_rr_128_64(rng->state);
     }
 
-    inline uint64_t
+    static inline uint64_t
     pcg_setseq_128_xsl_rr_64_boundedrand_r(pcg_state_setseq_128* rng,
                                            uint64_t bound)
     {
@@ -194,7 +193,7 @@ extern "C" {
     extern pcg128_t pcg_advance_lcg_128(pcg128_t state, pcg128_t delta, pcg128_t cur_mult,
                                         pcg128_t cur_plus);
 
-    inline void pcg_setseq_128_advance_r(pcg_state_setseq_128* rng, pcg128_t delta)
+    static inline void pcg_setseq_128_advance_r(pcg_state_setseq_128* rng, pcg128_t delta)
     {
         rng->state = pcg_advance_lcg_128(rng->state, delta,
                                          PCG_DEFAULT_MULTIPLIER_128, rng->inc);
@@ -211,4 +210,4 @@ extern "C" {
 }
 #endif
 
-#endif /* PCG64_H_INCLUDED */
+#endif /* PCG64_H_INCLUDED */
diff --git a/randomstate/src/random-kit/random-kit.h b/randomstate/src/random-kit/random-kit.h
@@ -31,7 +31,7 @@ extern void randomkit_seed(randomkit_state *state, uint32_t seed);
 extern void randomkit_gen(randomkit_state *state);
 
 /* Slightly optimized reference implementation of the Mersenne Twister */
-inline uint32_t randomkit_random(randomkit_state *state)
+static inline uint32_t randomkit_random(randomkit_state *state)
 {
     uint32_t y;
 
diff --git a/randomstate/src/xoroshiro128plus/xoroshiro128plus.c b/randomstate/src/xoroshiro128plus/xoroshiro128plus.c
@@ -3,7 +3,7 @@
 
 extern inline uint64_t xoroshiro128plus_next(xoroshiro128plus_state* state);
 
-inline uint64_t rotl(const uint64_t x, int k);
+extern inline uint64_t rotl(const uint64_t x, int k);
 
 void xoroshiro128plus_jump(xoroshiro128plus_state* state) {
 	static const uint64_t JUMP[] = { 0xbeac0467eba5facb, 0xd86b048b86aa9922 };
diff --git a/randomstate/src/xoroshiro128plus/xoroshiro128plus.h b/randomstate/src/xoroshiro128plus/xoroshiro128plus.h
@@ -20,11 +20,11 @@ void xoroshiro128plus_seed_by_array(xoroshiro128plus_state* state, uint64_t *see
 
 void xoroshiro128plus_init_state(xoroshiro128plus_state* state, uint64_t seed, uint64_t inc);
 
-inline uint64_t rotl(const uint64_t x, int k) {
+static inline uint64_t rotl(const uint64_t x, int k) {
 	return (x << k) | (x >> (64 - k));
 }
 
-inline uint64_t xoroshiro128plus_next(xoroshiro128plus_state* state) {
+static inline uint64_t xoroshiro128plus_next(xoroshiro128plus_state* state) {
 	const uint64_t s0 = state->s[0];
 	uint64_t s1 = state->s[1];
 	const uint64_t result = s0 + s1;
diff --git a/randomstate/src/xorshift1024/xorshift1024.h b/randomstate/src/xorshift1024/xorshift1024.h
@@ -13,7 +13,7 @@ typedef struct s_xorshift1024_state
     int p;
 } xorshift1024_state;
 
-inline uint64_t xorshift1024_next(xorshift1024_state* state) {
+static inline uint64_t xorshift1024_next(xorshift1024_state* state) {
     const uint64_t s0 = state->s[state->p];
     uint64_t s1;
     state->p = (state->p + 1) & 15;
diff --git a/randomstate/src/xorshift128/xorshift128.h b/randomstate/src/xorshift128/xorshift128.h
@@ -21,7 +21,7 @@ void xorshift128_seed_by_array(xorshift128_state* state, uint64_t *seed_array, i
 
 void xorshift128_init_state(xorshift128_state* state, uint64_t seed, uint64_t inc);
 
-inline uint64_t xorshift128_next(xorshift128_state* state) {
+static inline uint64_t xorshift128_next(xorshift128_state* state) {
     uint64_t s1 = state->s[0];
     const uint64_t s0 = state->s[1];
     state->s[0] = s0;
diff --git a/setup.py b/setup.py
@@ -38,7 +38,9 @@
 
 extra_defs = [('_CRT_SECURE_NO_WARNINGS', '1')] if os.name == 'nt' else []
 extra_link_args = ['/LTCG', '/OPT:REF', 'Advapi32.lib', 'Kernel32.lib'] if os.name == 'nt' else []
-base_extra_compile_args = [] if os.name == 'nt' else ['-std=c99']
+# TODO: The unddefine is to handle a problem when building
+# TODO: manylinux1 on CentOS 5/GCC 4.8.2
+base_extra_compile_args = [] if os.name == 'nt' else ['-std=c99', '-U__GNUC_GNU_INLINE__']
 
 if USE_SSE2:
     if os.name == 'nt':

-Original file line number
+Diff line change
@@ @@ -0,0 +1,4 @@ @@
 +numpy>=1.13
 +cython>=0.26
 +pytest
 +nose
Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ void mlfg_init_state(mlfg_state *state, uint64_t seeds[K]);`
`30`	`30`	`* when making a 64 bit unsigned int, take the two upper`
`31`	`31`	`* 32 bit segments.`
`32`	`32`	`*/`
`33`		`-inline uint64_t mlfg_next(mlfg_state* state)`
	`33`	`+static inline uint64_t mlfg_next(mlfg_state* state)`
`34`	`34`	`{`
`35`	`35`	`state->pos++;`
`36`	`36`	`state->lag_pos++;`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ typedef struct s_mrg32k3a_state`
`19`	`19`	`int loc;`
`20`	`20`	`} mrg32k3a_state;`
`21`	`21`
`22`		`-inline uint32_t mrg32k3a_random(mrg32k3a_state* state)`
	`22`	`+static inline uint32_t mrg32k3a_random(mrg32k3a_state* state)`
`23`	`23`	`{`
`24`	`24`	`int64_t p1 = 0;`
`25`	`25`	`int64_t p2 = 0;`
Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@ typedef struct {`
`25`	`25`	`#define PCG_STATE_SETSEQ_64_INITIALIZER \`
`26`	`26`	`{ 0x853c49e6748fea9bULL, 0xda3e39cb94b95bdbULL }`
`27`	`27`
`28`		`-inline uint32_t pcg_rotr_32(uint32_t value, unsigned int rot)`
	`28`	`+static inline uint32_t pcg_rotr_32(uint32_t value, unsigned int rot)`
`29`	`29`	`{`
`30`	`30`	`#if PCG_USE_INLINE_ASM && __clang__ && (__x86_64__ \|\| __i386__)`
`31`	`31`	`asm ("rorl %%cl, %0" : "=r" (value) : "0" (value), "c" (rot));`
`@@ -35,32 +35,32 @@ inline uint32_t pcg_rotr_32(uint32_t value, unsigned int rot)`
`35`	`35`	`#endif`
`36`	`36`	`}`
`37`	`37`
`38`		`-inline void pcg_setseq_64_step_r(pcg_state_setseq_64* rng)`
	`38`	`+static inline void pcg_setseq_64_step_r(pcg_state_setseq_64* rng)`
`39`	`39`	`{`
`40`	`40`	`rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_64 + rng->inc;`
`41`	`41`	`}`
`42`	`42`
`43`		`-inline uint32_t pcg_output_xsl_rr_64_32(uint64_t state)`
	`43`	`+static inline uint32_t pcg_output_xsl_rr_64_32(uint64_t state)`
`44`	`44`	`{`
`45`	`45`	`return pcg_rotr_32(((uint32_t)(state >> 32u)) ^ (uint32_t)state,`
`46`	`46`	`state >> 59u);`
`47`	`47`	`}`
`48`	`48`
`49`		`-inline uint32_t pcg_output_xsh_rr_64_32(uint64_t state)`
	`49`	`+static inline uint32_t pcg_output_xsh_rr_64_32(uint64_t state)`
`50`	`50`	`{`
`51`	`51`	`return pcg_rotr_32(((state >> 18u) ^ state) >> 27u, state >> 59u);`
`52`	`52`	`}`
`53`	`53`
`54`	`54`
`55`		`-inline uint32_t`
	`55`	`+static inline uint32_t`
`56`	`56`	`pcg_setseq_64_xsh_rr_32_random_r(pcg_state_setseq_64* rng)`
`57`	`57`	`{`
`58`	`58`	`uint64_t oldstate = rng->state;`
`59`	`59`	`pcg_setseq_64_step_r(rng);`
`60`	`60`	`return pcg_output_xsh_rr_64_32(oldstate);`
`61`	`61`	`}`
`62`	`62`
`63`		`-inline void pcg_setseq_64_srandom_r(pcg_state_setseq_64* rng,`
	`63`	`+static inline void pcg_setseq_64_srandom_r(pcg_state_setseq_64* rng,`
`64`	`64`	`uint64_t initstate, uint64_t initseq)`
`65`	`65`	`{`
`66`	`66`	`rng->state = 0U;`
`@@ -70,15 +70,15 @@ inline void pcg_setseq_64_srandom_r(pcg_state_setseq_64* rng,`
`70`	`70`	`pcg_setseq_64_step_r(rng);`
`71`	`71`	`}`
`72`	`72`
`73`		`-inline uint32_t`
	`73`	`+static inline uint32_t`
`74`	`74`	`pcg_setseq_64_xsl_rr_32_random_r(pcg_state_setseq_64* rng)`
`75`	`75`	`{`
`76`	`76`	`uint64_t oldstate = rng->state;`
`77`	`77`	`pcg_setseq_64_step_r(rng);`
`78`	`78`	`return pcg_output_xsl_rr_64_32(oldstate);`
`79`	`79`	`}`
`80`	`80`
`81`		`-inline uint32_t`
	`81`	`+static inline uint32_t`
`82`	`82`	`pcg_setseq_64_xsl_rr_32_boundedrand_r(pcg_state_setseq_64* rng,`
`83`	`83`	`uint32_t bound)`
`84`	`84`	`{`
`@@ -95,7 +95,7 @@ extern uint64_t pcg_advance_lcg_64(uint64_t state, uint64_t delta,`
`95`	`95`
`96`	`96`
`97`	`97`
`98`		`-inline void pcg_setseq_64_advance_r(pcg_state_setseq_64* rng,`
	`98`	`+static inline void pcg_setseq_64_advance_r(pcg_state_setseq_64* rng,`
`99`	`99`	`uint64_t delta)`
`100`	`100`	`{`
`101`	`101`	`rng->state = pcg_advance_lcg_64(rng->state, delta,`
Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,6 @@`
`34`	`34`	`#include <inttypes.h>`
`35`	`35`	`#endif`
`36`	`36`
`37`		`-`
`38`	`37`	`#if __GNUC_GNU_INLINE__ && !defined(__cplusplus)`
`39`	`38`	`#error Nonstandard GNU inlining semantics. Compile with -std=c99 or better.`
`40`	`39`	`#endif`
`@@ -53,7 +52,7 @@ extern "C" {`
`53`	`52`	`uint64_t low;`
`54`	`53`	`} pcg128_t;`
`55`	`54`
`56`		`- inline pcg128_t PCG_128BIT_CONSTANT(uint64_t high, uint64_t low) {`
	`55`	`+ static inline pcg128_t PCG_128BIT_CONSTANT(uint64_t high, uint64_t low) {`
`57`	`56`	`pcg128_t result;`
`58`	`57`	`result.high = high;`
`59`	`58`	`result.low = low;`
`@@ -80,22 +79,22 @@ extern "C" {`
`80`	`79`	`{ PCG_128BIT_CONSTANT(0x979c9a98d8462005ULL, 0x7d3e9cb6cfe0549bULL), \`
`81`	`80`	`PCG_128BIT_CONSTANT(0x0000000000000001ULL, 0xda3e39cb94b95bdbULL) }`
`82`	`81`
`83`		`- inline uint64_t pcg_rotr_64(uint64_t value, unsigned int rot)`
	`82`	`+ static inline uint64_t pcg_rotr_64(uint64_t value, unsigned int rot)`
`84`	`83`	`{`
`85`	`84`	`return (value >> rot) \| (value << ((- rot) & 63));`
`86`	`85`	`}`
`87`	`86`
`88`	`87`	`#ifdef PCG_EMULATED_128BIT_MATH`
`89`	`88`
`90`		`- inline pcg128_t _pcg128_add(pcg128_t a, pcg128_t b) {`
	`89`	`+ static inline pcg128_t _pcg128_add(pcg128_t a, pcg128_t b) {`
`91`	`90`	`pcg128_t result;`
`92`	`91`
`93`	`92`	`result.low = a.low + b.low;`
`94`	`93`	`result.high = a.high + b.high + (result.low < b.low);`
`95`	`94`	`return result;`
`96`	`95`	`}`
`97`	`96`
`98`		`- inline void _pcg_mult64(uint64_t x, uint64_t y, uint64_t* z1, uint64_t* z0) {`
	`97`	`+ static inline void _pcg_mult64(uint64_t x, uint64_t y, uint64_t* z1, uint64_t* z0) {`
`99`	`98`	`uint64_t x0, x1, y0, y1;`
`100`	`99`	`uint64_t w0, w1, w2, t;`
`101`	`100`	`/* Lower 64 bits are straightforward clock-arithmetic. */`
`@@ -113,7 +112,7 @@ extern "C" {`
`113`	`112`	`z1 = x1 y1 + w2 + (w1 >> 32);`
`114`	`113`	`}`
`115`	`114`
`116`		`- inline pcg128_t _pcg128_mult(pcg128_t a, pcg128_t b) {`
	`115`	`+ static inline pcg128_t _pcg128_mult(pcg128_t a, pcg128_t b) {`
`117`	`116`	`uint64_t h1;`
`118`	`117`	`pcg128_t result;`
`119`	`118`
`@@ -123,18 +122,18 @@ extern "C" {`
`123`	`122`	`return result;`
`124`	`123`	`}`
`125`	`124`
`126`		`- inline void pcg_setseq_128_step_r(pcg_state_setseq_128* rng)`
	`125`	`+ static inline void pcg_setseq_128_step_r(pcg_state_setseq_128* rng)`
`127`	`126`	`{`
`128`	`127`	`rng->state = _pcg128_add(_pcg128_mult(rng->state, PCG_DEFAULT_MULTIPLIER_128), rng->inc);`
`129`	`128`	`}`
`130`	`129`
`131`		`- inline uint64_t pcg_output_xsl_rr_128_64(pcg128_t state)`
	`130`	`+ static inline uint64_t pcg_output_xsl_rr_128_64(pcg128_t state)`
`132`	`131`	`{`
`133`	`132`	`return pcg_rotr_64(state.high ^ state.low,`
`134`	`133`	`state.high >> 58u);`
`135`	`134`	`}`
`136`	`135`
`137`		`- inline void pcg_setseq_128_srandom_r(pcg_state_setseq_128* rng,`
	`136`	`+ static inline void pcg_setseq_128_srandom_r(pcg_state_setseq_128* rng,`
`138`	`137`	`pcg128_t initstate, pcg128_t initseq)`
`139`	`138`	`{`
`140`	`139`	`rng->state = PCG_128BIT_CONSTANT(0ULL, 0ULL);`
`@@ -148,18 +147,18 @@ extern "C" {`
`148`	`147`
`149`	`148`	`#else /* PCG_EMULATED_128BIT_MATH */`
`150`	`149`
`151`		`- inline void pcg_setseq_128_step_r(pcg_state_setseq_128* rng)`
	`150`	`+ static inline void pcg_setseq_128_step_r(pcg_state_setseq_128* rng)`
`152`	`151`	`{`
`153`	`152`	`rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_128 + rng->inc;`
`154`	`153`	`}`
`155`	`154`
`156`		`- inline uint64_t pcg_output_xsl_rr_128_64(pcg128_t state)`
	`155`	`+ static inline uint64_t pcg_output_xsl_rr_128_64(pcg128_t state)`
`157`	`156`	`{`
`158`	`157`	`return pcg_rotr_64(((uint64_t)(state >> 64u)) ^ (uint64_t)state,`
`159`	`158`	`state >> 122u);`
`160`	`159`	`}`
`161`	`160`
`162`		`- inline void pcg_setseq_128_srandom_r(pcg_state_setseq_128* rng,`
	`161`	`+ static inline void pcg_setseq_128_srandom_r(pcg_state_setseq_128* rng,`
`163`	`162`	`pcg128_t initstate, pcg128_t initseq)`
`164`	`163`	`{`
`165`	`164`	`rng->state = 0U;`
`@@ -172,14 +171,14 @@ extern "C" {`
`172`	`171`	`#endif /* PCG_EMULATED_128BIT_MATH */`
`173`	`172`
`174`	`173`
`175`		`- inline uint64_t`
	`174`	`+ static inline uint64_t`
`176`	`175`	`pcg_setseq_128_xsl_rr_64_random_r(pcg_state_setseq_128* rng)`
`177`	`176`	`{`
`178`	`177`	`pcg_setseq_128_step_r(rng);`
`179`	`178`	`return pcg_output_xsl_rr_128_64(rng->state);`
`180`	`179`	`}`
`181`	`180`
`182`		`- inline uint64_t`
	`181`	`+ static inline uint64_t`
`183`	`182`	`pcg_setseq_128_xsl_rr_64_boundedrand_r(pcg_state_setseq_128* rng,`
`184`	`183`	`uint64_t bound)`
`185`	`184`	`{`
`@@ -194,7 +193,7 @@ extern "C" {`
`194`	`193`	`extern pcg128_t pcg_advance_lcg_128(pcg128_t state, pcg128_t delta, pcg128_t cur_mult,`
`195`	`194`	`pcg128_t cur_plus);`
`196`	`195`
`197`		`- inline void pcg_setseq_128_advance_r(pcg_state_setseq_128* rng, pcg128_t delta)`
	`196`	`+ static inline void pcg_setseq_128_advance_r(pcg_state_setseq_128* rng, pcg128_t delta)`
`198`	`197`	`{`
`199`	`198`	`rng->state = pcg_advance_lcg_128(rng->state, delta,`
`200`	`199`	`PCG_DEFAULT_MULTIPLIER_128, rng->inc);`
`@@ -211,4 +210,4 @@ extern "C" {`
`211`	`210`	`}`
`212`	`211`	`#endif`
`213`	`212`
`214`		`-#endif /* PCG64_H_INCLUDED */`
	`213`	`+#endif /* PCG64_H_INCLUDED */`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ extern void randomkit_seed(randomkit_state *state, uint32_t seed);`
`31`	`31`	`extern void randomkit_gen(randomkit_state *state);`
`32`	`32`
`33`	`33`	`/* Slightly optimized reference implementation of the Mersenne Twister */`
`34`		`-inline uint32_t randomkit_random(randomkit_state *state)`
	`34`	`+static inline uint32_t randomkit_random(randomkit_state *state)`
`35`	`35`	`{`
`36`	`36`	`uint32_t y;`
`37`	`37`