zdoom/zdoom-macos-deps
0
0
Fork 0
mirror of https://github.com/ZDoom/zdoom-macos-deps.git synced 2024-11-24 21:01:59 +00:00
Code Issues Projects Releases Packages Wiki Activity

quasi-glib: use spaces instead of tabs in library source code

Browse source
This commit is contained in:
alexey.lysiuk 2023-02-23 15:17:23 +02:00
parent 40ce7088f4
commit 93b3e7f9b1
1 changed files with 195 additions and 195 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

390
patch/quasi-glib/quasi-glib.cpp
View file

@ -14,29 +14,29 @@ extern "C"
void* g_malloc(size_t size)
{
return malloc(size);
return malloc(size);
}
void g_free(void* ptr)
{
free(ptr);
free(ptr);
}
struct GError
{
uint32_t domain;
int code;
char* message;
uint32_t domain;
int code;
char* message;
};
void g_clear_error(GError** err)
{
if (nullptr != err && nullptr != *err)
{
free(*err);
*err = nullptr;
}
if (nullptr != err && nullptr != *err)
{
free(*err);
*err = nullptr;
}
}
@ -47,305 +47,305 @@ void g_return_if_fail_warning(const char* domain, const char* function, const ch
enum GFileTest
{
G_FILE_TEST_IS_REGULAR = 1 << 0,
G_FILE_TEST_IS_SYMLINK = 1 << 1,
G_FILE_TEST_IS_DIR = 1 << 2,
G_FILE_TEST_IS_EXECUTABLE = 1 << 3,
G_FILE_TEST_EXISTS = 1 << 4
G_FILE_TEST_IS_REGULAR = 1 << 0,
G_FILE_TEST_IS_SYMLINK = 1 << 1,
G_FILE_TEST_IS_DIR = 1 << 2,
G_FILE_TEST_IS_EXECUTABLE = 1 << 3,
G_FILE_TEST_EXISTS = 1 << 4
};
int g_file_test(const char* filename, int test)
{
if (filename == nullptr)
{
return 0;
}
if (filename == nullptr)
{
return 0;
}
if ((test & G_FILE_TEST_EXISTS) && (access(filename, F_OK) == 0))
{
return 1;
}
if ((test & G_FILE_TEST_EXISTS) && (access(filename, F_OK) == 0))
{
return 1;
}
if ((test & G_FILE_TEST_IS_EXECUTABLE) && (access(filename, X_OK) == 0))
{
if (getuid() != 0)
{
return 1;
}
}
else
{
test &= ~G_FILE_TEST_IS_EXECUTABLE;
}
if ((test & G_FILE_TEST_IS_EXECUTABLE) && (access(filename, X_OK) == 0))
{
if (getuid() != 0)
{
return 1;
}
}
else
{
test &= ~G_FILE_TEST_IS_EXECUTABLE;
}
if (test & G_FILE_TEST_IS_SYMLINK)
{
struct stat s;
if (test & G_FILE_TEST_IS_SYMLINK)
{
struct stat s;
if ((lstat(filename, &s) == 0) && S_ISLNK(s.st_mode))
{
return 1;
}
}
if ((lstat(filename, &s) == 0) && S_ISLNK(s.st_mode))
{
return 1;
}
}
if (test & (G_FILE_TEST_IS_REGULAR | G_FILE_TEST_IS_DIR | G_FILE_TEST_IS_EXECUTABLE))
{
struct stat s;
if (test & (G_FILE_TEST_IS_REGULAR | G_FILE_TEST_IS_DIR | G_FILE_TEST_IS_EXECUTABLE))
{
struct stat s;
if (stat(filename, &s) == 0)
{
if ((test & G_FILE_TEST_IS_REGULAR) && S_ISREG(s.st_mode))
{
return 1;
}
if (stat(filename, &s) == 0)
{
if ((test & G_FILE_TEST_IS_REGULAR) && S_ISREG(s.st_mode))
{
return 1;
}
if ((test & G_FILE_TEST_IS_DIR) && S_ISDIR(s.st_mode))
{
return 1;
}
if ((test & G_FILE_TEST_IS_DIR) && S_ISDIR(s.st_mode))
{
return 1;
}
if ((test & G_FILE_TEST_IS_EXECUTABLE) && ((s.st_mode & S_IXOTH) || (s.st_mode & S_IXUSR) || (s.st_mode & S_IXGRP)))
{
return 1;
}
}
}
if ((test & G_FILE_TEST_IS_EXECUTABLE) && ((s.st_mode & S_IXOTH) || (s.st_mode & S_IXUSR) || (s.st_mode & S_IXGRP)))
{
return 1;
}
}
}
return 0;
return 0;
}
int64_t g_get_monotonic_time()
{
static mach_timebase_info_data_t timebase_info;
static mach_timebase_info_data_t timebase_info;
if (timebase_info.denom == 0)
{
mach_timebase_info(&timebase_info);
if (timebase_info.denom == 0)
{
mach_timebase_info(&timebase_info);
if (timebase_info.numer % 1000 == 0)
{
timebase_info.numer /= 1000;
}
else
{
timebase_info.denom *= 1000;
}
if (timebase_info.numer % 1000 == 0)
{
timebase_info.numer /= 1000;
}
else
{
timebase_info.denom *= 1000;
}
if (timebase_info.denom % timebase_info.numer == 0)
{
timebase_info.denom /= timebase_info.numer;
timebase_info.numer = 1;
}
}
if (timebase_info.denom % timebase_info.numer == 0)
{
timebase_info.denom /= timebase_info.numer;
timebase_info.numer = 1;
}
}
return mach_absolute_time() / timebase_info.denom;
return mach_absolute_time() / timebase_info.denom;
}
void g_usleep(unsigned long microseconds)
{
usleep(microseconds);
usleep(microseconds);
}
struct GMutex
{
pthread_mutex_t* p;
pthread_mutex_t* p;
};
static pthread_mutex_t* g_mutex_impl_new()
{
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutex_t* mutex = new pthread_mutex_t;
pthread_mutex_init(mutex, &attr);
pthread_mutex_t* mutex = new pthread_mutex_t;
pthread_mutex_init(mutex, &attr);
pthread_mutexattr_destroy(&attr);
pthread_mutexattr_destroy(&attr);
return mutex;
return mutex;
}
static void g_mutex_impl_free(pthread_mutex_t* mutex)
{
pthread_mutex_destroy(mutex);
delete mutex;
pthread_mutex_destroy(mutex);
delete mutex;
}
static pthread_mutex_t* g_mutex_get_impl(GMutex* mutex)
{
pthread_mutex_t* impl = mutex->p;
__sync_synchronize();
pthread_mutex_t* impl = mutex->p;
__sync_synchronize();
if (nullptr == impl)
if (nullptr == impl)
{
impl = g_mutex_impl_new();
impl = g_mutex_impl_new();
if (__sync_val_compare_and_swap(&mutex->p, nullptr, impl) != nullptr)
{
g_mutex_impl_free(impl);
impl = mutex->p;
}
}
if (__sync_val_compare_and_swap(&mutex->p, nullptr, impl) != nullptr)
{
g_mutex_impl_free(impl);
impl = mutex->p;
}
}
return impl;
return impl;
}
void g_mutex_init(GMutex* mutex)
{
mutex->p = g_mutex_impl_new();
mutex->p = g_mutex_impl_new();
}
void g_mutex_clear(GMutex* mutex)
{
g_mutex_impl_free(mutex->p);
g_mutex_impl_free(mutex->p);
}
void g_mutex_lock(GMutex* mutex)
{
pthread_mutex_lock(g_mutex_get_impl(mutex));
pthread_mutex_lock(g_mutex_get_impl(mutex));
}
void g_mutex_unlock(GMutex* mutex)
{
pthread_mutex_unlock(g_mutex_get_impl(mutex));
pthread_mutex_unlock(g_mutex_get_impl(mutex));
}
struct GRecMutex
{
pthread_mutex_t* p;
unsigned int i[2];
pthread_mutex_t* p;
unsigned int i[2];
};
static pthread_mutex_t* g_rec_mutex_impl_new()
{
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
pthread_mutex_t* mutex = new pthread_mutex_t;
pthread_mutex_init(mutex, &attr);
pthread_mutex_t* mutex = new pthread_mutex_t;
pthread_mutex_init(mutex, &attr);
pthread_mutexattr_destroy(&attr);
pthread_mutexattr_destroy(&attr);
return mutex;
return mutex;
}
static void g_rec_mutex_impl_free(pthread_mutex_t* mutex)
{
pthread_mutex_destroy(mutex);
delete mutex;
pthread_mutex_destroy(mutex);
delete mutex;
}
static pthread_mutex_t* g_rec_mutex_get_impl(GRecMutex* mutex)
{
pthread_mutex_t* impl = mutex->p;
__sync_synchronize();
pthread_mutex_t* impl = mutex->p;
__sync_synchronize();
if (nullptr == impl)
if (nullptr == impl)
{
impl = g_rec_mutex_impl_new();
impl = g_rec_mutex_impl_new();
if (__sync_val_compare_and_swap(&mutex->p, nullptr, impl) != nullptr)
{
g_rec_mutex_impl_free(impl);
impl = mutex->p;
}
if (__sync_val_compare_and_swap(&mutex->p, nullptr, impl) != nullptr)
{
g_rec_mutex_impl_free(impl);
impl = mutex->p;
}
}
return impl;
return impl;
}
void g_rec_mutex_init(GRecMutex* mutex)
{
mutex->p = g_rec_mutex_impl_new();
mutex->p = g_rec_mutex_impl_new();
}
void g_rec_mutex_clear(GRecMutex* mutex)
{
g_rec_mutex_impl_free(mutex->p);
g_rec_mutex_impl_free(mutex->p);
}
void g_rec_mutex_lock(GRecMutex* mutex)
{
pthread_mutex_lock(g_rec_mutex_get_impl(mutex));
pthread_mutex_lock(g_rec_mutex_get_impl(mutex));
}
void g_rec_mutex_unlock(GRecMutex* mutex)
{
pthread_mutex_unlock(g_rec_mutex_get_impl(mutex));
pthread_mutex_unlock(g_rec_mutex_get_impl(mutex));
}
struct GCond
{
pthread_cond_t* p;
unsigned int i[2];
pthread_cond_t* p;
unsigned int i[2];
};
static pthread_cond_t* g_cond_impl_new()
{
pthread_condattr_t attr;
pthread_condattr_init(&attr);
pthread_condattr_t attr;
pthread_condattr_init(&attr);
pthread_cond_t* cond = new pthread_cond_t;
pthread_cond_init(cond, &attr);
pthread_cond_t* cond = new pthread_cond_t;
pthread_cond_init(cond, &attr);
pthread_condattr_destroy(&attr);
return cond;
return cond;
}
static void g_cond_impl_free(pthread_cond_t* cond)
{
pthread_cond_destroy(cond);
delete cond;
pthread_cond_destroy(cond);
delete cond;
}
static pthread_cond_t* g_cond_get_impl(GCond* cond)
{
pthread_cond_t* impl = cond->p;
__sync_synchronize();
pthread_cond_t* impl = cond->p;
__sync_synchronize();
if (nullptr == impl)
{
impl = g_cond_impl_new();
if (nullptr == impl)
{
impl = g_cond_impl_new();
if (__sync_val_compare_and_swap(&cond->p, nullptr, impl) != nullptr)
{
g_cond_impl_free(impl);
impl = cond->p;
}
}
if (__sync_val_compare_and_swap(&cond->p, nullptr, impl) != nullptr)
{
g_cond_impl_free(impl);
impl = cond->p;
}
}
return impl;
return impl;
}
void g_cond_init(GCond* cond)
{
cond->p = g_cond_impl_new();
cond->p = g_cond_impl_new();
}
void g_cond_clear(GCond* cond)
{
g_cond_impl_free(cond->p);
g_cond_impl_free(cond->p);
}
void g_cond_wait(GCond* cond, GMutex* mutex)
{
pthread_cond_wait(g_cond_get_impl(cond), g_mutex_get_impl(mutex));
pthread_cond_wait(g_cond_get_impl(cond), g_mutex_get_impl(mutex));
}
void g_cond_signal(GCond* cond)
{
pthread_cond_signal(g_cond_get_impl(cond));
pthread_cond_signal(g_cond_get_impl(cond));
}
void g_cond_broadcast(GCond* cond)
{
pthread_cond_broadcast(g_cond_get_impl(cond));
pthread_cond_broadcast(g_cond_get_impl(cond));
}
@ -353,37 +353,37 @@ using GDestroyNotify = void (*)(void* data);
struct GPrivate
{
pthread_key_t* p;
GDestroyNotify notify;
void* future[2];
pthread_key_t* p;
GDestroyNotify notify;
void* future[2];
};
static pthread_key_t* g_private_impl_new(GDestroyNotify notify)
{
pthread_key_t* key = new pthread_key_t;
pthread_key_create(key, notify);
return key;
pthread_key_t* key = new pthread_key_t;
pthread_key_create(key, notify);
return key;
}
static void g_private_impl_free(pthread_key_t* key)
{
pthread_key_delete(*key);
delete key;
pthread_key_delete(*key);
delete key;
}
static inline pthread_key_t* g_private_get_impl(GPrivate* key)
{
pthread_key_t* impl = key->p;
__sync_synchronize();
pthread_key_t* impl = key->p;
__sync_synchronize();
if (nullptr == impl)
if (nullptr == impl)
{
impl = g_private_impl_new(key->notify);
impl = g_private_impl_new(key->notify);
if (__sync_val_compare_and_swap(&key->p, nullptr, impl) != nullptr)
if (__sync_val_compare_and_swap(&key->p, nullptr, impl) != nullptr)
{
g_private_impl_free(impl);
impl = key->p;
g_private_impl_free(impl);
impl = key->p;
}
}
@ -392,56 +392,56 @@ static inline pthread_key_t* g_private_get_impl(GPrivate* key)
void* g_private_get(GPrivate* key)
{
return pthread_getspecific(*g_private_get_impl(key));
return pthread_getspecific(*g_private_get_impl(key));
}
void g_private_set(GPrivate* key, void* value)
{
pthread_setspecific(*g_private_get_impl(key), value);
pthread_setspecific(*g_private_get_impl(key), value);
}
struct GThread
{
pthread_t thread;
int ref_count;
pthread_t thread;
int ref_count;
};
using GThreadFunc = void* (*)(void* data);
GThread* g_thread_try_new(const char* name, GThreadFunc func, void* data, GError** error)
{
if (error != nullptr)
{
*error = nullptr;
}
if (error != nullptr)
{
*error = nullptr;
}
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_t attr;
pthread_attr_init(&attr);
GThread* thread = new GThread;
pthread_create(&thread->thread, &attr, func, data);
thread->ref_count = 1;
GThread* thread = new GThread;
pthread_create(&thread->thread, &attr, func, data);
thread->ref_count = 1;
pthread_attr_destroy(&attr);
pthread_attr_destroy(&attr);
return thread;
return thread;
}
void* g_thread_join(GThread* thread)
{
void* result = nullptr;
pthread_join(thread->thread, &result);
return result;
void* result = nullptr;
pthread_join(thread->thread, &result);
return result;
}
void g_thread_unref(GThread* thread)
{
if (__sync_sub_and_fetch(&thread->ref_count, 1) == 0)
{
g_thread_join(thread);
delete thread;
}
if (__sync_sub_and_fetch(&thread->ref_count, 1) == 0)
{
g_thread_join(thread);
delete thread;
}
}
}