Line data    Source code

       1              : /* File: universal_simple_random.inl; Copyright and License: see below */
       2              : 
       3              : #include "u8/u8_log.h"
       4              : #include <time.h>
       5              : #include <stdlib.h>
       6              : #include <errno.h>
       7              : #include <stdbool.h>
       8              : 
       9              : extern bool universal_simple_random_initialized;
      10              : 
      11         2779 : static inline void universal_simple_random_init ( universal_simple_random_t *this_ )
      12              : {
      13         2779 :     if ( ! universal_simple_random_initialized )
      14              :     {
      15            1 :         clock_t now = clock();  /* integer represents clocks, to be divided by CLOCKS_PER_SEC */
      16              : #ifdef _WIN32
      17              :         srand( now );
      18              : #else  /* POSIX.1-2001 */
      19            1 :         srandom( now );
      20              : #endif
      21            1 :         universal_simple_random_initialized = true;
      22              :     }
      23              : 
      24         2779 :     (*this_).dummy = 0;  /* prevent warnings on uninitialized usage */
      25         2779 : }
      26              : 
      27         2779 : static inline void universal_simple_random_destroy ( universal_simple_random_t *this_ )
      28              : {
      29         2779 : }
      30              : 
      31        11116 : static inline uint16_t universal_simple_random_get_uint16 ( universal_simple_random_t *this_ )
      32              : {
      33              :     uint16_t result;
      34              : 
      35              : #ifdef _WIN32
      36              :     if ( RAND_MAX >= (uint16_t)(-1) )
      37              :     {
      38              :         result = rand();
      39              :     }
      40              :     else
      41              :     {
      42              :         result = (((uint_fast16_t)rand()) << 8) ^ rand();
      43              :     }
      44              : #else  /* POSIX.1-2001 */
      45              :     if ( RAND_MAX >= (uint16_t)(-1) )
      46              :     {
      47        11116 :         result = random();
      48              :     }
      49              :     else
      50              :     {
      51              :         result = (((uint_fast16_t)random()) << 8) ^ random();
      52              :     }
      53              : #endif
      54              : 
      55              :     /* Note: random() is possibly not available on win32?, preprocessor-if could distinguish __linux__ and _WIN32 */
      56        11116 :     return result;
      57              : }
      58              : 
      59         5558 : static inline uint32_t universal_simple_random_get_uint32 ( universal_simple_random_t *this_ )
      60              : {
      61              :     uint32_t result;
      62              : 
      63              : #ifdef _WIN32
      64              :     if ( RAND_MAX >= (uint32_t)(-1) )
      65              :     {
      66              :         result = rand();
      67              :     }
      68              :     else if ( RAND_MAX >= (uint16_t)(-1) )
      69              :     {
      70              :         result = (((uint_fast32_t)rand()) << 16) ^ rand();
      71              :     }
      72              :     else
      73              :     {
      74              :         result = (((uint_fast32_t)rand()) << 24) ^ (((uint_fast32_t)rand()) << 16)
      75              :                  ^ (((uint_fast32_t)rand()) << 8) ^ rand();
      76              :     }
      77              : #else  /* POSIX.1-2001 */
      78              :     if ( RAND_MAX >= (uint32_t)(-1) )
      79              :     {
      80              :         result = random();
      81              :     }
      82              :     else if ( RAND_MAX >= (uint16_t)(-1) )
      83              :     {
      84         5558 :         result = (((uint_fast32_t)random()) << 16) ^ random();
      85              :     }
      86              :     else
      87              :     {
      88              :         result = (((uint_fast32_t)random()) << 24) ^ (((uint_fast32_t)random()) << 16)
      89              :                  ^ (((uint_fast32_t)random()) << 8) ^ random();
      90              :     }
      91              : #endif
      92              : 
      93              :     /* Note: random() is possibly not available on win32?, preprocessor-if could distinguish __linux__ and _WIN32 */
      94         5558 :     return result;
      95              : }
      96              : 
      97              : 
      98              : /*
      99              : Copyright 2021-2025 Andreas Warnke
     100              : 
     101              : Licensed under the Apache License, Version 2.0 (the "License");
     102              : you may not use this file except in compliance with the License.
     103              : You may obtain a copy of the License at
     104              : 
     105              :     http://www.apache.org/licenses/LICENSE-2.0
     106              : 
     107              : Unless required by applicable law or agreed to in writing, software
     108              : distributed under the License is distributed on an "AS IS" BASIS,
     109              : WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     110              : See the License for the specific language governing permissions and
     111              : limitations under the License.
     112              : */