#ifndef VG_PLATFORM_H
#define VG_PLATFORM_H
-#include "vg.h"
+//#include "vg.h"
#include "vg_stdint.h"
/* Copyright (C) 2021-2022 Harry Godden (hgn) - All Rights Reserved */
const char *name;
};
+#ifndef VG_STATIC
+#define VG_STATIC static
+#endif
+
#define vg_static_assert _Static_assert
#define vg_list_size( A ) (sizeof(A)/sizeof(A[0]))
#define VG_MUST_USE_RESULT __attribute__((warn_unused_result))
-#ifdef _WIN32
+#ifdef _WIN32_NO
#include <windows.h>
-/* TODO */
-#define VG_DEPRECATED __declspec(deprecated)
+#ifdef I_THINK_THIS_IS_WHAT_MSCV_WANTS_BUT_HAVNT_TESTED_IT_YET
-#else
- #include <pthread.h>
- #include <semaphore.h>
+ #define VG_DEPRECATED __declspec(deprecated)
+ #define VG_THREAD_LOCAL __declspec( thread )
-#define VG_DEPRECATED __attribute__((deprecated))
+#else /* MINGW-64 */
#define VG_THREAD_LOCAL __thread
-
- typedef sem_t vg_semaphore;
- typedef pthread_mutex_t vg_mutex;
+ #define VG_DEPRECATED __attribute__((deprecated))
#endif
-#include <stdlib.h>
-
-/* TODO: If there is no graphics, we dont need to do an exit loop */
+ typedef HANDLE vg_semaphore;
+ typedef HANDLE vg_mutex;
+ typedef u64 vg_timespec;
-static void vg_fatal_exit_loop( const char *error );
-static void *vg_alloc( size_t size )
-{
- void *ptr = malloc( size );
-
- if( !ptr )
- vg_fatal_exit_loop( "Out of memory" );
-
- return ptr;
-}
-
-static void *vg_realloc( void *orig, size_t size )
-{
- void *ptr = realloc( orig, size );
+#else
+ #include <pthread.h>
+ #include <semaphore.h>
- if( !ptr )
- vg_fatal_exit_loop( "Out of memory" );
+ #define VG_DEPRECATED __attribute__((deprecated))
+ #define VG_THREAD_LOCAL __thread
- return ptr;
-}
+ typedef sem_t vg_semaphore;
+ typedef pthread_mutex_t vg_mutex;
+ typedef struct timespec vg_timespec;
-/* seems to be a GCC bug when inlining this, its low priority anyway */
-__attribute__ ((noinline))
-static void vg_free( void *ptr )
-{
- free( ptr );
-}
+#endif
-static void vg_required( void *ptr, const char *path )
+VG_STATIC void vg_strncpy( const char *src, char *dst, u32 len )
{
- if( !ptr )
+ for( u32 i=0; i<len; i++ )
{
- vg_fatal_exit_loop( path );
+ dst[i] = src[i];
+
+ if( !src[i] )
+ break;
}
}
TYPE DECL = FN( PATH,##__VA_ARGS__ ); \
vg_required( DECL, "Resource is required but failed to load: '" PATH "'" );
+#if 0
VG_DEPRECATED
-void *malloc( size_t size );
-
+char *strcpy(char* destination, const char* source);
VG_DEPRECATED
-void *realloc( void *orig, size_t size );
-
+char *strncpy(char *restrict dest, const char *restrict src, size_t n);
+VG_DEPRECATED
+char *strcat(char *restrict dest, const char *restrict src);
VG_DEPRECATED
-void free( void *ptr );
+char *strncat(char *restrict dest, const char *restrict src, size_t n);
+#endif
#include <stdio.h>
#include <dirent.h>
#include <math.h>
#include <assert.h>
-#ifdef _WIN32
+VG_STATIC int vg_thread_run( void *pfunc, void *data );
+VG_STATIC void vg_thread_exit(void);
+VG_STATIC void vg_set_thread_name( const char *name );
+VG_STATIC int vg_semaphore_init( vg_semaphore *sem, u32 value );
+VG_STATIC int vg_semaphore_trywait( vg_semaphore *sem );
+VG_STATIC int vg_semaphore_wait( vg_semaphore *sem );
+VG_STATIC int vg_semaphore_post( vg_semaphore *sem );
+VG_STATIC void vg_semaphore_free( vg_semaphore *sem );
+VG_STATIC int vg_mutex_init( vg_mutex *mutex );
+VG_STATIC int vg_mutex_lock( vg_mutex *mutex );
+VG_STATIC int vg_mutex_unlock( vg_mutex *mutex );
+VG_STATIC void vg_mutex_free( vg_mutex *mutex );
+VG_STATIC void vg_sleep_ms( long msec );
+VG_STATIC double vg_time_diff( vg_timespec start, vg_timespec end );
+
+#ifdef _WIN32_NO
+
+VG_STATIC int vg_thread_run( void *pfunc, void *data )
+{
+ HANDLE hThread = CreateThread
+ (
+ NULL, /* Thread attributes */
+ 0, /* Stack size (0 = use default) */
+ pfunc, /* Thread start address */
+ data, /* Parameter to pass to the thread */
+ 0, /* Creation flags */
+ NULL /* Thread id */
+ );
+
+ if ( hThread == NULL )
+ {
+ /*
+ * Thread creation failed.
+ * More details can be retrieved by calling GetLastError()
+ */
+ return 1;
+ }
+ else
+ {
+ CloseHandle( hThread );
+ return 0;
+ }
+}
+
+VG_STATIC void vg_thread_exit(void)
+{
+ ExitThread(0);
+}
+
+VG_STATIC void vg_set_thread_name( const char *name )
+{
+ /* I believe this is a meaningless concept in windows */
+}
+
+VG_STATIC int vg_semaphore_init( vg_semaphore *sem, u32 value );
+VG_STATIC int vg_semaphore_trywait( vg_semaphore *sem );
+VG_STATIC int vg_semaphore_wait( vg_semaphore *sem );
+VG_STATIC int vg_semaphore_post( vg_semaphore *sem );
+VG_STATIC void vg_semaphore_free( vg_semaphore *sem );
+VG_STATIC int vg_mutex_init( vg_mutex *mutex );
+VG_STATIC int vg_mutex_lock( vg_mutex *mutex );
+VG_STATIC int vg_mutex_unlock( vg_mutex *mutex );
+VG_STATIC void vg_mutex_free( vg_mutex *mutex );
+VG_STATIC void vg_sleep_ms( long msec );
+VG_STATIC double vg_time_diff( vg_timespec start, vg_timespec end );
+
#else
-static void vg_thread_exit(void)
+VG_STATIC int vg_thread_run( void *pfunc, void *data )
+{
+ pthread_t hThread;
+ if( pthread_create( &hThread, NULL, pfunc, data ) )
+ {
+ return 1;
+ }
+ else
+ {
+ pthread_detach( hThread );
+ return 0;
+ }
+}
+
+
+VG_STATIC void vg_thread_exit(void)
{
pthread_exit(NULL);
}
-static void vg_set_thread_name( const char *name )
+VG_STATIC void vg_set_thread_name( const char *name )
{
/* not defined but links?? */
#if 0
#endif
}
-static int vg_semaphore_init( vg_semaphore *sem, u32 value )
+VG_STATIC int vg_semaphore_init( vg_semaphore *sem, u32 value )
{
return !sem_init( sem, 0, value );
}
-static int vg_semaphore_trywait( vg_semaphore *sem )
+VG_STATIC int vg_semaphore_trywait( vg_semaphore *sem )
{
return !sem_trywait( sem );
}
-static int vg_semaphore_wait( vg_semaphore *sem )
+VG_STATIC int vg_semaphore_wait( vg_semaphore *sem )
{
return !sem_wait( sem );
}
-static int vg_semaphore_post( vg_semaphore *sem )
+VG_STATIC int vg_semaphore_post( vg_semaphore *sem )
{
return !sem_post( sem );
}
-static void vg_semaphore_free( vg_semaphore *sem )
+VG_STATIC void vg_semaphore_free( vg_semaphore *sem )
{
sem_destroy( sem );
}
-static int vg_mutex_init( vg_mutex *mutex )
+VG_STATIC int vg_mutex_init( vg_mutex *mutex )
{
memset( mutex, 0, sizeof(vg_mutex) );
return 1;
}
-static int vg_mutex_lock( vg_mutex *mutex )
+VG_STATIC int vg_mutex_lock( vg_mutex *mutex )
{
if( !pthread_mutex_lock( mutex ) )
return 1;
return 0;
}
-static int vg_mutex_unlock( vg_mutex *mutex )
+VG_STATIC int vg_mutex_unlock( vg_mutex *mutex )
{
if( !pthread_mutex_unlock( mutex ) )
return 1;
return 0;
}
-static void vg_mutex_free( vg_mutex *mutex )
+VG_STATIC void vg_mutex_free( vg_mutex *mutex )
{
}
-#endif
-
-
-int vg_thread_run( void *pfunc, void *data )
-{
-#ifdef _WIN32
- HANDLE hThread = CreateThread
- (
- NULL, /* Thread attributes */
- 0, /* Stack size (0 = use default) */
- pfunc, /* Thread start address */
- data, /* Parameter to pass to the thread */
- 0, /* Creation flags */
- NULL /* Thread id */
- );
-
- if ( hThread == NULL )
- {
- /*
- * Thread creation failed.
- * More details can be retrieved by calling GetLastError()
- */
- return 1;
- }
- else
- {
- CloseHandle( hThread );
- return 0;
- }
-#else
- pthread_t hThread;
- if( pthread_create( &hThread, NULL, pfunc, data ) )
- {
- return 1;
- }
- else
- {
- pthread_detach( hThread );
- return 0;
- }
-#endif
-}
-
-static void vg_sleep_ms( long msec )
+VG_STATIC void vg_sleep_ms( long msec )
{
struct timespec ts;
}
/* diff two timespecs in MS */
-static double vg_time_diff( struct timespec start, struct timespec end )
+VG_STATIC double vg_time_diff( struct timespec start, struct timespec end )
{
double elapsed = 1000.0*end.tv_sec + 1e-6*end.tv_nsec
- (1000.0*start.tv_sec + 1e-6*start.tv_nsec);
return elapsed;
}
+#endif
+
#define VG_MIN( A, B ) ((A)<(B)?(A):(B))
#define VG_MAX( A, B ) ((A)>(B)?(A):(B))
-static void *buffer_reserve( void *buffer, u32 count, u32 *cap, u32 amount,
- size_t emsize )
-{
- if( count+amount > *cap )
- {
- *cap = VG_MAX( (*cap)*2, (*cap)+amount );
- return vg_realloc( buffer, (*cap) * emsize );
- }
-
- return buffer;
-}
-
-static void *buffer_fix( void *buffer, u32 count, u32 *cap, size_t emsize )
-{
- *cap = count;
- return vg_realloc( buffer, (*cap) * emsize );
-}
-
#endif