Objsys.h

Go to the documentation of this file.

#ifndef TEMU_OBJSYS_C_H
#define TEMU_OBJSYS_C_H

#include <assert.h>
#include <stdint.h>
#include <stdlib.h>
#include <stddef.h>

#ifdef __cplusplus
extern "C" {
#endif

#ifdef __cplusplus
#define TEMU_PLUGIN_INIT \
  extern "C" void temu_pluginInit(void)
#else
#define TEMU_PLUGIN_INIT \
  void temu_pluginInit(void)
#endif

typedef void temu_Class;
typedef void temu_MetaIface;

// Generic interface
typedef struct temu_Iface {
  void *Obj;
  void *Iface;
} temu_Iface;

// In some cases, the number of objects we know about is unknown, so
// we need a dynamic array (e.g. std::vector in C++), but we cannot
// expose std::vector in a known format to LLVM, so we do this simple
// system with a dynamic interface array.
typedef struct temu_IfaceArray {
  uint32_t Size;
  uint32_t Reserved;
  temu_Iface *Ifaces;
} temu_IfaceArray;

temu_IfaceArray temu_ifaceArrayAlloc(unsigned Reserve);

void temu_ifaceArrayPush2(temu_IfaceArray *Arr, void *Obj, void *Iface);
void temu_ifaceArrayPush(temu_IfaceArray *Arr, temu_Iface Iface);

unsigned temu_ifaceArraySize(temu_IfaceArray *Arr); // Return size

void temu_ifaceArrayDispose(temu_IfaceArray *Arr);


// Used to declare typed interfaces, also declares an array of such
// and inline wrappers for the iface array functions
#define OBJSYS_OBJ_TYPE(N)                                              \
  typedef struct {                                                      \
    void *Obj;                                                          \
    N ## Iface *Iface;                                                  \
  } N ## Obj;                                                           \
  typedef struct {                                                      \
    uint32_t Size;                                                      \
    uint32_t Reserved;                                                  \
    N ## Obj *Ifaces;                                                   \
  } N ## ObjArray;                                                      \
  static inline N ## ObjArray                                           \
  N ## ObjArrayAlloc(unsigned Reserve)                                  \
  {                                                                     \
    temu_IfaceArray Arr = temu_ifaceArrayAlloc(Reserve);                \
    N ## ObjArray Res;                                                  \
    Res.Size = Arr.Size;                                                \
    Res.Reserved = Arr.Reserved;                                        \
    Res.Ifaces = (N##Obj*)Arr.Ifaces;                                   \
    return Res;                                                         \
  }                                                                     \
  static inline void                                                    \
  N ## ObjArrayDispose(N ## ObjArray *Arr)                              \
  {                                                                     \
    Arr->Size = 0;                                                      \
    Arr->Reserved = 0;                                                  \
    temu_ifaceArrayDispose((temu_IfaceArray*)&Arr->Ifaces);             \
  }                                                                     \
  static inline void                                                    \
  N ## ObjArrayPush2(N ## ObjArray *Arr, void *Obj, void *Iface)        \
  {                                                                     \
    temu_ifaceArrayPush2((temu_IfaceArray*)Arr, Obj, Iface);            \
  }                                                                     \
  static inline void                                                    \
  N ## ObjArrayPush(N ## ObjArray *Arr, N ## Obj Iface)                 \
  {                                                                     \
    temu_Iface Iface2;                                                  \
    Iface2.Obj = Iface.Obj;                                             \
    Iface2.Iface = (void*)Iface.Iface;                                  \
                                                                        \
    temu_ifaceArrayPush((temu_IfaceArray*)Arr, Iface2);                 \
  }                                                                     \
  static inline unsigned                                                \
  N ## ObjArraySize(temu_IfaceArray *Arr)                               \
  {                                                                     \
    return Arr->Size;                                                   \
  }


#define DYN_ARRAY_TYPE(T, P)                                            \
  typedef struct {                                                      \
    uint32_t Size;                                                      \
    uint32_t Reserved;                                                  \
    T *Values;                                                          \
  } temu_ ## P ## Array;                                                \
  static inline temu_ ## P ## Array                                     \
  temu_ ## P ## ArrayAlloc(unsigned Reserve)                            \
  {                                                                     \
    temu_ ## P ## Array Arr;                                            \
    Arr.Size = 0;                                                       \
    Arr.Reserved = Reserve;                                             \
    Arr.Values = (T*)calloc(Reserve, sizeof(T));                        \
    assert(Arr.Values);                                                 \
    return Arr;                                                         \
  }                                                                     \
  static inline void                                                    \
  temu_ ## P ## ArrayPush(temu_ ## P ## Array *Arr, T Val)              \
  {                                                                     \
    if (Arr->Reserved >= Arr->Size) {                                   \
      T *NewValues = (T*)realloc(Arr->Values, Arr->Reserved * 2);       \
      if (NewValues) {                                                  \
        Arr->Values = NewValues;                                        \
      } else {                                                          \
        abort();                                                        \
      }                                                                 \
    }                                                                   \
    Arr->Values[Arr->Size ++] = Val;                                    \
  }                                                                     \
  static inline unsigned                                                \
  temu_ ## P ## ArraySize(temu_ ## P ## Array *Arr)                     \
  {                                                                     \
    return Arr->Size;                                                   \
  }

DYN_ARRAY_TYPE(int8_t, i8)
DYN_ARRAY_TYPE(int16_t, i16)
DYN_ARRAY_TYPE(int32_t, i32)
DYN_ARRAY_TYPE(int64_t, i64)

DYN_ARRAY_TYPE(uint8_t, u8)
DYN_ARRAY_TYPE(uint16_t, u16)
DYN_ARRAY_TYPE(uint32_t, u32)
DYN_ARRAY_TYPE(uint64_t, u64)

typedef enum temu_Type {
  teTY_Invalid, // Invalid value

  // C pointer sized integers
  teTY_Intptr,
  teTY_Uintptr,

  // Standard C floating point types
  teTY_Float,
  teTY_Double,

  // Standard C fixed width integer types
  teTY_U8,
  teTY_U16,
  teTY_U32,
  teTY_U64,
  teTY_I8,
  teTY_I16,
  teTY_I32,
  teTY_I64,

  // Object pointer, must be saved as an object reference
  teTY_Obj,

  // Internal pointer, points somewhere in the object itself
  // (e.g. bank resolution arrays) This can be saved as an offset...
  teTY_InternalPtr,

  // Interface (object and interface pointer pair)
  teTY_Iface,
  teTY_IfaceArray, // Dynamic object/interface array

  teTY_String, // C-string, useful for serialisation
} temu_Type;

typedef struct temu_Propref {
  temu_Type Typ;
  void *Ptr;
} temu_Propref;

typedef struct temu_Propval {
  temu_Type Typ;
  union {
    intptr_t IntPtr;
    uintptr_t UIntPtr;

    float f;
    double d;

    uint8_t u8;
    uint16_t u16;
    uint32_t u32;
    uint64_t u64;

    int8_t i8;
    int16_t i16;
    int32_t i32;
    int64_t i64;

    void *Obj;
    temu_Iface Iface;
    temu_IfaceArray IfaceArray;
    const char *String;
  };
} temu_Propval;


#ifdef PROP_ASSERTS_ENABLED
#define PROP_ASSERT(p, t) assert(p.Typ == t && "invalid property type")
#else
#define PROP_ASSERT(p, t)
#endif

// Ugly, but we want to be compatible with C++ and C99, meaning:
//   cannot use designated initializers (C99, not C++)
//   cannot use constructors (C++, not C99)

#define PROP_VAL_INITIALIZER(typ, suffix, typetag, valtag)        \
  static inline temu_Propval                                      \
  temu_makeProp ## suffix (typ val)                               \
  {                                                               \
    temu_Propval pv;                                              \
    pv.Typ = typetag;                                             \
    pv.valtag = val;                                              \
    return pv;                                                    \
  }                                                               \
  static inline typ                                               \
  temu_propValue ## suffix (temu_Propval pv)                      \
  {                                                               \
    PROP_ASSERT(pv.Typ, typetag);                                 \
    typ val = pv.valtag;                                          \
    return val;                                                   \
  }

PROP_VAL_INITIALIZER(intptr_t,  IntPtr,  teTY_Intptr,  IntPtr)
PROP_VAL_INITIALIZER(uintptr_t, UIntPtr, teTY_Uintptr, UIntPtr)

PROP_VAL_INITIALIZER(float,  Float,  teTY_Float,  f)
PROP_VAL_INITIALIZER(double, Double, teTY_Double, d)

PROP_VAL_INITIALIZER(uint8_t,  U8,  teTY_U8,  u8)
PROP_VAL_INITIALIZER(uint16_t, U16, teTY_U16, u16)
PROP_VAL_INITIALIZER(uint32_t, U32, teTY_U32, u32)
PROP_VAL_INITIALIZER(uint64_t, U64, teTY_U64, u64)

PROP_VAL_INITIALIZER(int8_t,   I8,  teTY_I8,  i8)
PROP_VAL_INITIALIZER(int16_t,  I16, teTY_I16, i16)
PROP_VAL_INITIALIZER(int32_t,  I32, teTY_I32, i32)
PROP_VAL_INITIALIZER(int64_t,  I64, teTY_I64, i64)

PROP_VAL_INITIALIZER(void*, Obj, teTY_Obj, Obj)
PROP_VAL_INITIALIZER(temu_Iface, Iface, teTY_Iface, Iface)

typedef void (*temu_PropWriter)(void *Obj, temu_Propval Pv, int Idx);

typedef temu_Propval (*temu_PropReader)(void *Obj, int Idx);


temu_Propref temu_getPropref(const void *Obj, const char *PropName);
int temu_getPropLength(const void *Obj, const char *PropName);

/*
  Get and read value are different

  Get value has no side effects, while read value may have side effects.
 */
temu_Propval
temu_getValue(void *Obj, const char *PropName, int Idx);

// Python CTYPES does not like the anonymous union in propval.
uint8_t temu_getValueU8(void *Obj, const char *PropName, int Idx);
uint16_t temu_getValueU16(void *Obj, const char *PropName, int Idx);
uint32_t temu_getValueU32(void *Obj, const char *PropName, int Idx);
uint64_t temu_getValueU64(void *Obj, const char *PropName, int Idx);

int8_t temu_getValueI8(void *Obj, const char *PropName, int Idx);
int16_t temu_getValueI16(void *Obj, const char *PropName, int Idx);
int32_t temu_getValueI32(void *Obj, const char *PropName, int Idx);
int64_t temu_getValueI64(void *Obj, const char *PropName, int Idx);

temu_Propval
temu_readValue(void *Obj, const char *PropName, int Idx);

uint8_t  temu_readValueU8(void *Obj, const char *PropName, int Idx);
uint16_t temu_readValueU16(void *Obj, const char *PropName, int Idx);
uint32_t temu_readValueU32(void *Obj, const char *PropName, int Idx);
uint64_t temu_readValueU64(void *Obj, const char *PropName, int Idx);

int8_t  temu_readValueI8(void *Obj, const char *PropName, int Idx);
int16_t temu_readValueI16(void *Obj, const char *PropName, int Idx);
int32_t temu_readValueI32(void *Obj, const char *PropName, int Idx);
int64_t temu_readValueI64(void *Obj, const char *PropName, int Idx);

void temu_setValue(void *Obj, const char *PropName, temu_Propval Val, int Idx);

void temu_setValueU8(void *Obj, const char *PropName, uint8_t Val, int Idx);
void temu_setValueU16(void *Obj, const char *PropName, uint16_t Val, int Idx);
void temu_setValueU32(void *Obj, const char *PropName, uint32_t Val, int Idx);
void temu_setValueU64(void *Obj, const char *PropName, uint64_t Val, int Idx);

void temu_setValueI8(void *Obj, const char *PropName, int8_t Val, int Idx);
void temu_setValueI16(void *Obj, const char *PropName, int16_t Val, int Idx);
void temu_setValueI32(void *Obj, const char *PropName, int32_t Val, int Idx);
void temu_setValueI64(void *Obj, const char *PropName, int64_t Val, int Idx);

void temu_writeValue(void *Obj, const char *PropName, temu_Propval Val, int Idx);

void temu_writeValueU8(void *Obj, const char *PropName, uint8_t Val, int Idx);
void temu_writeValueU16(void *Obj, const char *PropName, uint16_t Val, int Idx);
void temu_writeValueU32(void *Obj, const char *PropName, uint32_t Val, int Idx);
void temu_writeValueU64(void *Obj, const char *PropName, uint64_t Val, int Idx);

void temu_writeValueI8(void *Obj, const char *PropName, int8_t Val, int Idx);
void temu_writeValueI16(void *Obj, const char *PropName, int16_t Val, int Idx);
void temu_writeValueI32(void *Obj, const char *PropName, int32_t Val, int Idx);
void temu_writeValueI64(void *Obj, const char *PropName, int64_t Val, int Idx);



temu_Propval temu_getNamedObjectProp(const char *Obj, const char *PropName,
                                     int Idx);

temu_Propval temu_readNamedObjectProp(const char *Obj, const char *PropName,
                                      int Idx);

void
temu_setNamedObjectProp(const char *Obj, const char *PropName,
                        temu_Propval Val, int Idx);

void
temu_writeNamedObjectProp(const char *Obj, const char *PropName,
                          temu_Propval Val, int Idx);



typedef struct temu_CreateArg {
  const char *Key;
  temu_Propval Val;
} temu_CreateArg;

typedef void* (*temu_ObjectCreateFunc)(const char *Name,
                                       int Argc, const temu_CreateArg *Argv);
typedef void (*temu_ObjectDisposeFunc)(void*);

temu_Class*
temu_registerClass(const char *ClsName,
                   temu_ObjectCreateFunc Create,
                   temu_ObjectDisposeFunc Dispose);


temu_Class* temu_registerExternalClass(const char *ClsName);

#ifdef __cplusplus

void
temu_addProperty(temu_Class *Cls, const char *PropName,
                 int Offset,
                 temu_Type Typ, int Count,
                 temu_PropWriter Wr = nullptr,
                 temu_PropReader Rd = nullptr,
                 const char *Doc = "");
#else
void
temu_addProperty(temu_Class *Cls, const char *PropName,
                 int Offset,
                 temu_Type Typ, int Count,
                 temu_PropWriter Wr,
                 temu_PropReader Rd,
                 const char *Doc);

#endif

#ifdef __cplusplus


void
temu_addInterface(temu_Class *Cls,
                  const char *IfaceName,
                  const char *IfaceType,
                  void *Iface, int Count = 0,
                  const char *Doc = "");

void*
temu_getInterface(void *Obj,
                  const char *IfaceName, int Idx = 0);

#else
void
temu_addInterface(temu_Class *Cls,

                  const char *IfaceName,
                  const char *IfaceType,
                  void *Iface, int Count,
                  const char *Doc);

void*
temu_getInterface(void *Obj,
                  const char *IfaceName, int Idx);

#endif

void temu_objsysClear(void);

void temu_objsysClearObjects(void);

void* temu_addObject(const char *ClsName, const char *ObjName, void *Obj);


void* temu_createObject(const char *ClsName, const char *ObjName);


void temu_disposeObject(void *Obj);

temu_Class* temu_classForName(const char *ClsName);

temu_Class* temu_classForObject(void *Obj);

temu_Class*
temu_classForObjectName(const char *Obj);


void* temu_objectForName(const char *Name);

const char* temu_nameForObject(const void *Obj);

int temu_loadPlugin(const char *Path);

const char* temu_typeToName(temu_Type Typ);


int temu_connect(void *A, const char *PropName, void *B, const char *IfaceName);

int temu_serialiseJSON(const char *FileName);


int temu_deserialiseJSON(const char *FileName);

void temu_serialiseProp(void *Ctxt, const char *Name, temu_Type Typ,
                        int Count, void *Data);

void temu_deserialiseProp(void *Ctxt, void *Obj, const char *Name);

int temu_checkpointGetLength(void *Ctxt, const char *Name);
temu_Propval temu_checkpointGetValue(void *Ctxt, const char *Name, int Idx);

int temu_checkSanity(int Report);

typedef struct {
  void (*serialise)(void *Obj, const char *BaseName, void *Ctxt); // Optional
  void (*deserialise)(void *Obj, const char *BaseName, void *Ctxt); // Optional

  int (*checkSanity)(void *Obj, int Report); // Optional
} temu_ObjectIface;

OBJSYS_OBJ_TYPE(temu_Object);

#ifdef __cplusplus
}
#endif


#endif