Subversion Repositories thor

#ifndef _COMPAT_H

#define _COMPAT_H

// Compatibility definitions for compiling with GCC on Linux

// David Banks (hoglet) 2017

#ifndef __GNUC__

// On Windows use Rob's FPP pre processor

// The -b option supresses the banner text

#define PREPROCESSOR_CMD "fpp -b %s %s"

#else

// On Linux use gcc's cpp

// the -P option inhibits line markers, as these causes errors in C64

#define PREPROCESSOR_CMD "cpp -P %s %s"

#include <unistd.h>

#include <stdlib.h>

#include <stdarg.h>

#include <string.h>

#include <libgen.h>

#include <errno.h>

#define _strdup strdup

#define _access access

#define  __int8 char

#define __int16 short

#define __int64 long long

static inline int min (int a, int b) { return a < b ? a : b; }

static inline int max (int a, int b) { return a > b ? a : b; }

static inline int _dupenv_s(char **buffer, size_t *numberOfElements, const char *varname) {

   if (buffer == NULL || numberOfElements == NULL || varname == NULL) {

      return EINVAL;

   }

   char *env = getenv(varname);

   if (env == NULL) {

      *buffer = NULL;

      *numberOfElements = 0;

   } else {

      *numberOfElements = strlen(env);

      *buffer = (char *)malloc(*numberOfElements);

      strcpy(*buffer, env);

   }

   return 0;

}

static inline void _splitpath(char *path, char *drive, char *dir, char *name, char *ext) {

   char *base = basename(path);

   char *dot = rindex(base, '.');

   if (drive) {

      *drive = '\0';

   }

   if (dir) {

      strcpy(dir, dirname(path));

   }

   if (base) {

      strcpy(name, base);

      if (dot) {

         *(name + (dot - base)) = '\0';

      }

   }

   if (ext) {

      if (dot) {

         strcpy(ext, dot + 1);

      } else {

         *ext = '\0';

      }

   }

}

static inline int _splitpath_s(

   char * path,

   char * drive, size_t driveNumberOfElements,

   char * dir, size_t dirNumberOfElements,

   char * name, size_t nameNumberOfElements,

   char * ext, size_t extNumberOfElements

   ) {

   _splitpath(path, drive, dir, name, ext);

   // TODO: Add error handling

   return 0;

}

static inline void ZeroMemory (void *dst, size_t length) {

   memset(dst, 0, length);

}

static inline unsigned int _rotl(

   unsigned int value,

   int shift

   ) {

   return (value << shift) | (value >> (32 - shift));

}

static inline unsigned int _rotr(

   unsigned int value,

   int shift

   ) {

   return (value >> shift) | (value << (32 - shift));

}

static inline char *strtok_s(

   char *strToken,

   const char *strDelimit,

   char **context

   ) {

}

static inline int strncpy_s(

   char *strDestination,

   size_t numberOfElements,

   const char *strSource,

   size_t count

   ) {

   strncpy(strDestination, strSource, count);

   return 0;

}

static inline int strcpy_s(

   char *strDestination,

   size_t numberOfElements,

   const char *strSource

   ) {

   // TODO: Add error handling

   strncpy(strDestination, strSource, numberOfElements);

   return 0;

}

static inline int strcat_s(

   char *strDestination,

   size_t numberOfElements,

   const char *strSource

   ) {

   // TODO: Add error handling

   strncat(strDestination, strSource, numberOfElements);

   return 0;

}

static inline int sprintf_s(char* buffer, size_t sizeOfBuffer, const char* format, ...)

{

    va_list ap;

    va_start(ap, format);

    int result = vsnprintf(buffer, sizeOfBuffer, format, ap);

    va_end(ap);

    return result;

}

#endif

#endif