vg_platform.h

   1 #ifndef VG_PLATFORM_H
   2 #define VG_PLATFORM_H
   3
   4 //#include "vg.h"
   5 #include "vg_stdint.h"
   6
   7 /* Copyright (C) 2021-2022 Harry Godden (hgn) - All Rights Reserved */
   8
   9 typedef unsigned int uint;
  10
  11 typedef int             v2i[2];
  12 typedef int             v3i[3];
  13 typedef int             v4i[4];
  14 typedef float           v2f[2];
  15 typedef float           v3f[3];
  16 typedef float           v4f[4];
  17 typedef v2f                     m2x2f[2];
  18 typedef v3f                     m3x3f[3];
  19 typedef v3f                     m4x3f[4];
  20 typedef v4f       m4x4f[4];
  21 typedef v3f                     boxf[2];
  22
  23 // Resource types
  24 typedef struct vg_tex2d vg_tex2d;
  25
  26 struct vg_achievement
  27 {
  28         int is_set;
  29         const char *name;
  30 };
  31
  32 #define vg_static_assert _Static_assert
  33 #define vg_list_size( A ) (sizeof(A)/sizeof(A[0]))
  34 #define VG_MUST_USE_RESULT __attribute__((warn_unused_result))
  35
  36 #include <stdio.h>
  37 #include <string.h>
  38 #include <stdarg.h>
  39 #include <ctype.h>
  40 #include <math.h>
  41 #include <assert.h>
  42 #include <setjmp.h>
  43 #include <sys/time.h>
  44 #include <math.h>
  45 #include <stdio.h>
  46 #include <errno.h>
  47
  48 enum strncpy_behaviour{
  49    k_strncpy_always_add_null = 0,
  50    k_strncpy_allow_cutoff = 1,
  51    k_strncpy_overflow_fatal = 2
  52 };
  53
  54 static void vg_fatal_error( const char *fmt, ... );
  55 static u32 vg_strncpy( const char *src, char *dst, u32 len,
  56                           enum strncpy_behaviour behaviour )
  57 {
  58    for( u32 i=0; i<len; i++ ){
  59       dst[i] = src[i];
  60
  61       if( !src[i] ) return i;
  62
  63       if( i == len-1 ){
  64          if( behaviour == k_strncpy_always_add_null ){
  65             dst[i] = '\0';
  66             return i;
  67          }
  68          else if( behaviour == k_strncpy_overflow_fatal ){
  69             vg_fatal_error( "Strncpy dest exceeded buffer length\n" );
  70          }
  71       }
  72    }
  73
  74    return 0;
  75 }
  76
  77 typedef struct vg_str vg_str;
  78 struct vg_str{
  79    char *buffer;
  80    i32 i, len;
  81 };
  82
  83 static void vg_strnull( vg_str *str, char *buffer, i32 len ){
  84    str->buffer = buffer;
  85    str->buffer[0] = '\0';
  86    str->i = 0;
  87    str->len = len;
  88
  89    assert(len);
  90 }
  91
  92 static void vg_strcat( vg_str *str, const char *append ){
  93    if( !append ) return;
  94    if( str->i == -1 ) return;
  95
  96    for( u32 i=0; str->i < str->len; str->i ++, i ++ ){
  97       str->buffer[ str->i ] = append[ i ];
  98
  99       if( append[ i ] == '\0' )
 100          return;
 101    }
 102
 103    /* overflow */
 104    str->buffer[ str->len-1 ] = '\0';
 105    str->i = -1;
 106 }
 107
 108 static void vg_strcatch( vg_str *str, char c ){
 109    if( str->i == -1 ) return;
 110    if( (str->i + 2) > str->len ){
 111       str->i = -1;
 112       return;
 113    }
 114    str->buffer[ str->i ++ ] = c;
 115    str->buffer[ str->i ] = '\0';
 116 }
 117
 118 /* FIXME: Negative numbers */
 119 static void vg_strcati32( vg_str *str, i32 value ){
 120    if( value ){
 121       char temp[32];
 122       int i=0;
 123       while( value && (i<31) ){
 124          temp[ i ++ ] = '0' + (value % 10);
 125          value /= 10;
 126       }
 127
 128       char reverse[32];
 129       for( int j=0; j<i; j ++ )
 130          reverse[j] = temp[ i-1-j ];
 131       reverse[i] = '\0';
 132
 133       vg_strcat( str, reverse );
 134    }
 135    else
 136       vg_strcat( str, "0" );
 137 }
 138
 139 static void vg_strcati32r( vg_str *str, i32 value, i32 n, char alt ){
 140    char temp[32];
 141    i32 i=0;
 142    while( value ){
 143       if( i>=n )
 144          break;
 145
 146       temp[ n-1 - (i ++) ] = '0' + (value % 10);
 147       value /= 10;
 148    }
 149
 150    for( ;i<n; i ++ )
 151       temp[ n-1 - i ] = alt;
 152
 153    temp[n]='\0';
 154    vg_strcat( str, temp );
 155 }
 156
 157 static int vg_strgood( vg_str *str ){
 158    if( str->i == -1 ) return 0;
 159    else return 1;
 160 }
 161
 162 static char *vg_strch( vg_str *str, char c ){
 163    char *ptr = NULL;
 164    for( i32 i=0; i<str->i; i++ ){
 165       if( str->buffer[i] == c )
 166          ptr = str->buffer+i;
 167    }
 168
 169    return ptr;
 170 }
 171
 172 static u32 vg_strdjb2( const char *str ){
 173    u32 hash = 5381, c;
 174
 175    while( (c = *str++) )
 176       hash = ((hash << 5) + hash) + c; /* hash * 33 + c */
 177
 178    return hash;
 179 }
 180
 181 static int vg_strdjb2_eq( const char *s1, u32 h1,
 182                              const char *s2, u32 h2 )
 183 {
 184    if( h1 == h2 ){
 185       if(!strcmp(s1, s2)) return 1;
 186       else return 0;
 187    } else return 0;
 188 }
 189
 190 #define VG_STRDJB2_EQ( CS1, S2, H2 ) \
 191    vg_strdjb2_eq( CS1, vg_strdjb2(CS1), S2, H2 )
 192
 193
 194 #define VG_MIN( A, B ) ((A)<(B)?(A):(B))
 195 #define VG_MAX( A, B ) ((A)>(B)?(A):(B))
 196 #endif