util.h

Go to the documentation of this file.

 
#ifndef EDAX_UTIL_H
#define EDAX_UTIL_H
 
#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
 
struct Board;
struct Move;
struct Line;
 
// for winsock & winsock2 collision
#ifdef _WIN32
#include <winsock2.h>
#endif
 
/*
 * Time management
 */
extern long long (*time_clock)(void);
long long real_clock(void);
long long cpu_clock(void);
void time_print(long long, bool, FILE*);
long long time_read(FILE*);
void time_stamp(FILE*);
void relax(int);
 
/*
 * Special printing function
 */
char* format_scientific(double, const char*, char*);
void print_scientific(double, const char*, FILE*);
 
/*
 * Strings
 */
char* string_duplicate(const char*);
long long string_to_time(const char*);
char* string_read_line(FILE*);
char* string_copy_line(FILE*);
void string_to_lowercase(char*);
void string_to_uppercase(char*);
int string_to_coordinate(const char*);
char* string_to_word(char*);
bool string_to_boolean(const char*);
int string_to_int(const char*, const int);
double string_to_real(const char*, const double);
/*
 * Parsing
 */
char* parse_word(const char*, char*, unsigned int);
char* parse_field(const char*, char*, unsigned int, char);
char* parse_line(const char*, char*, unsigned int);
char* parse_board(const char*, struct Board*, int*);
char* parse_move(const char*, const struct Board*, struct Move*);
char* parse_game(const char*, const struct Board*, struct Line*);
char* parse_boolean(const char*, bool*);
char* parse_int(const char*, int*);
char* parse_real(const char*, double*);
char* parse_command(const char*, char*, char*, const unsigned int);
char* parse_find(const char*, const int);
char* parse_skip_spaces(const char*);
char* parse_skip_word(const char*);
 
/*
 * File.
 */
FILE* file_open(const char*, const char*);
void path_get_dir(const char*, char*);
char* file_add_ext(const char*, const char*, char*); 
bool is_stdin_keyboard(void);
 
/*
 * random
 */
typedef struct Random {
        unsigned long long x;
} Random;
 
unsigned long long random_get(Random*);
void random_seed(Random*, const unsigned long long);
 
/*
 * Usefull macros
 */
#define MAX(a, b) ((a) > (b) ? (a) : (b))
 
#define MIN(a, b) ((a) < (b) ? (a) : (b))
 
#define BOUND(var, min, max, name) do {\
        if (var < min && min <= max) {\
                if (name) fprintf(stderr, "\nWARNING: %s = %lld is out of range. Set to %lld\n", name, (long long)var, (long long)min);\
                var = min;\
        } else if (var > max) {\
                if (name) fprintf(stderr, "\nWARNING: %s = %lld is out of range. Set to %lld\n", name, (long long)var, (long long)max);\
                var = max;\
        }\
} while (0)
 
 
/*
 *Threads
 */
#if defined(__unix__) || (defined(_WIN32) && defined(USE_PTHREAD)) || defined(__APPLE__)
 
#include <pthread.h>
 
typedef pthread_t Thread;
 
typedef pthread_mutex_t Lock;
 
typedef pthread_cond_t Condition;
 
#define thread_detach(thread) pthread_detach(thread)
 
#if DEBUG && defined(__unix__) && !defined(__APPLE__)
#define lock(c) if (pthread_mutex_lock(&(c)->lock)) { \
        error("lock"); \
} else (void) 0
 
#define unlock(c) if (pthread_mutex_unlock(&(c)->lock)) { \
        error("unlock"); \
} else (void) 0
 
#define lock_init(c) do {\
        pthread_mutexattr_t attr;\
        pthread_mutexattr_init(&attr);\
        pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK_NP);\
        pthread_mutex_init(&(c)->lock, &attr);\
} while (0)
 
#define lock_free(c) if (pthread_mutex_destroy(&(c)->lock)) { \
        error("lock_free"); \
} else (void) 0
 
#else //NDEBUG
 
#define lock(c) pthread_mutex_lock(&(c)->lock)
 
#define unlock(c) pthread_mutex_unlock(&(c)->lock)
 
#define lock_init(c) pthread_mutex_init(&(c)->lock, NULL)
 
#define lock_free(c) pthread_mutex_destroy(&(c)->lock)
 
#endif
 
#ifdef __APPLE__ // Mac OS spinlock
 
#include <libkern/OSAtomic.h>
 
typedef OSSpinLock SpinLock;
 
#define spin_lock(c) OSSpinLockLock(&(c)->spin)
 
#define spin_unlock(c) OSSpinLockUnlock(&(c)->spin)
 
#define spin_init(c)  do {(c)->spin = OS_SPINLOCK_INIT;} while (0)
 
#define spin_free(c)   // FIXME ?? should this stay empty ?
 
 
#elif defined(__USE_XOPEN2K) // Posix spinlock
 
typedef pthread_spinlock_t SpinLock;
 
#define spin_lock(c) pthread_spin_lock(&(c)->spin)
 
#define spin_unlock(c) pthread_spin_unlock(&(c)->spin)
 
#define spin_init(c) pthread_spin_init(&(c)->spin, PTHREAD_PROCESS_PRIVATE)
 
#define spin_free(c) pthread_spin_destroy(&(c)->spin)
 
#else // No spin lock available, use mutex instead
 
typedef pthread_mutex_t SpinLock;
 
#define spin_lock(c) pthread_mutex_lock(&(c)->spin)
 
#define spin_unlock(c) pthread_mutex_unlock(&(c)->spin)
 
#define spin_init(c) pthread_mutex_init(&(c)->spin, NULL)
 
#define spin_free(c) pthread_mutex_destroy(&(c)->spin)
 
#endif
 
#define condition_init(c) pthread_cond_init(&(c)->cond, NULL)
 
#define condition_wait(c) pthread_cond_wait(&(c)->cond, &(c)->lock)
 
#define condition_signal(c) pthread_cond_signal(&(c)->cond)
 
#define condition_broadcast(c) pthread_cond_broadcast(&(c)->cond)
 
#define condition_free(c) pthread_cond_destroy(&(c)->cond)
 
#elif defined(_WIN32)
 
#include <windows.h>
 
typedef HANDLE Thread;
 
typedef CRITICAL_SECTION Lock;
 
typedef CRITICAL_SECTION SpinLock;
 
#if defined(_WIN64)
 
#ifndef _MSC_VER
 
//typedef DWORD CONDITION_VARIABLE;
void InitializeConditionVariable(CONDITION_VARIABLE*);
void WakeConditionVariable(CONDITION_VARIABLE*);
void WakeAllConditionVariable(CONDITION_VARIABLE*);
BOOL SleepConditionVariableCS(CONDITION_VARIABLE*, CRITICAL_SECTION*, DWORD);
 
#endif
 
typedef CONDITION_VARIABLE Condition;
 
#define condition_init(c) InitializeConditionVariable(&(c)->cond)
 
#define condition_wait(c) SleepConditionVariableCS(&(c)->cond, &(c)->lock, INFINITE)
 
#define condition_signal(c) WakeConditionVariable(&(c)->cond)
 
#define condition_broadcast(c) WakeAllConditionVariable(&(c)->cond)
 
#define condition_free(c)
 
#endif
 
#define thread_detach(thread) CloseHandle(thread)
 
#define lock(c) EnterCriticalSection(&(c)->lock)
 
#define unlock(c) LeaveCriticalSection(&(c)->lock)
 
#define lock_init(c) InitializeCriticalSection(&(c)->lock)
 
#define lock_free(c) DeleteCriticalSection(&(c)->lock)
 
#define spin_lock(c) EnterCriticalSection(&(c)->spin)
 
#define spin_unlock(c) LeaveCriticalSection(&(c)->spin)
 
#define spin_init(c) InitializeCriticalSection(&(c)->spin)
 
#define spin_free(c) DeleteCriticalSection(&(c)->spin)
 
 
#endif
 
void thread_create2(Thread*, void* (*f)(void*), void*); // modified for iOS by lavox. 2018/1/16
void thread_join(Thread);
void thread_set_cpu(Thread, int);
Thread thread_self(void);
 
static inline void atomic_add(volatile unsigned long long *value, long long i)
{
#if defined(USE_GAS_X64)
  __asm__ __volatile__("lock xaddq %1, %0":"=m"(*value) :"r"(i), "m" (*value));
#elif defined(USE_MSVC_X64)
        _InterlockedAdd64(value, i);
#else
        *value += i;
#endif
}
 
void cpu(void);
int get_cpu_number(void);
 
/*
 * Error management
 */
 
#define fatal_error(...) \
        do { \
                fprintf(stderr, "\nFATAL ERROR: %s : %s : %d : ", __FILE__, __func__, __LINE__); \
                if (errno) fprintf(stderr, "\terror #%d : %s", errno, strerror(errno)); \
                fputc('\n', stderr); \
                fprintf(stderr, __VA_ARGS__); \
                abort(); \
        } while (0)
 
#define error(...) \
        do { \
                fprintf(stderr, "\nERROR: %s : %s : %d :", __FILE__, __func__, __LINE__); \
                if (errno) fprintf(stderr, " error #%d : %s", errno, strerror(errno)); \
                fputc('\n', stderr); \
                fprintf(stderr, __VA_ARGS__); \
                errno = 0; \
        } while (0)
 
#define warn(...) \
        do { \
                fprintf(stderr, "\nWARNING: "); \
                fprintf(stderr, __VA_ARGS__); \
        } while (0)
 
#define info(...) if (options.info) { \
        fprintf(stderr, __VA_ARGS__); \
} else (void) 0
 
#define cassio_debug(...) if (options.debug_cassio) { \
        printf("DEBUG: "); \
        printf(__VA_ARGS__); \
        log_print(engine_log, "DEBUG: "); \
        log_print(engine_log, __VA_ARGS__);\
} else (void) 0
 
 
#ifndef NDEBUG
#define trace(...) do {\
        fprintf(stderr, "trace %s : %s : %d : ", __FILE__, __func__, __LINE__); \
        fprintf(stderr, __VA_ARGS__); \
} while (0)
 
#define debug(...) \
        do { \
                fprintf(stderr, "\nDEBUG : "); \
                fprintf(stderr, __VA_ARGS__); \
        } while (0)
 
#else
#define trace(...)
#define debug(...)
#endif
 
typedef struct Log {
        FILE *f;
        Lock lock;
} Log;
 
#define log_open(l, file) if ((l)->f == NULL && file != NULL) { \
        lock_init(l); \
        (l)->f = fopen(file, "w"); \
} else (void) 0
 
#define log_close(l) if ((l)->f) { \
        lock_free(l); \
        fclose((l)->f); \
        (l)->f = NULL; \
} else (void) 0
 
#define log_print(l, ...) if ((l)->f) { \
        fprintf((l)->f, __VA_ARGS__); \
        fflush((l)->f); \
} else (void) 0
 
#define log_is_open(l) ((l)->f != NULL)
 
#define log_receive(l, title, ...)  if ((l)->f) { \
        fprintf((l)->f, "%s", title); \
        time_stamp((l)->f); \
        fprintf((l)->f, " <== "); \
        fprintf((l)->f, __VA_ARGS__); \
        fflush((l)->f); \
} else (void) 0
 
#define log_send(l, title, ...)  if ((l)->f) { \
        fprintf((l)->f, "%s", title); \
        time_stamp((l)->f); \
        fprintf((l)->f, " ==> "); \
        fprintf((l)->f, __VA_ARGS__); \
        fflush((l)->f); \
} else (void) 0
 
#endif // EDAX_UTIL_H