Objsys.h

Go to the documentation of this file.

//===-- temu-c/Objsys.h - T-EMU Object System -------------------*- C++ -*-===//
//
// T-EMU: The Terma Emulator
// (c) Terma 2015
// Authors: Mattias Holm <maho (at) terma.com>
//
//===----------------------------------------------------------------------===//

#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

#if defined(__has_attribute)
#  if __has_attribute(annotate)
#    define TEMU_NO_WRAP __attribute__((annotate("temu-no-wrap")))
#  endif
#endif

#if !defined(TEMU_NO_WRAP)
#  define TEMU_NO_WRAP
#endif

typedef void temu_Class;
typedef void temu_MetaIface;

typedef struct {
  temu_Class *Class;
} temu_Object;


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

// 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_IfaceRefArray {
  uint32_t Size;
  uint32_t Reserved;
  temu_IfaceRef *Ifaces;
} temu_IfaceRefArray;

temu_IfaceRefArray temu_ifaceRefArrayAlloc(unsigned Reserve);

void temu_ifaceRefArrayPush2(temu_IfaceRefArray *Arr, void *Obj, void *Iface);
void temu_ifaceRefArrayPush(temu_IfaceRefArray *Arr, temu_IfaceRef Iface);

unsigned temu_ifaceRefArraySize(temu_IfaceRefArray *Arr); // Return size

void temu_ifaceRefArrayDispose(temu_IfaceRefArray *Arr);


// Used to declare typed interfaces, also declares an array of such
// and inline wrappers for the iface array functions
#define TEMU_IFACE_REFERENCE_TYPE(N)                                    \
  typedef struct {                                                      \
    void *Obj;                                                          \
    N ## Iface *Iface;                                                  \
  } N ## IfaceRef;                                                      \
  typedef struct {                                                      \
    uint32_t Size;                                                      \
    uint32_t Reserved;                                                  \
    N ## IfaceRef *Ifaces;                                              \
  } N ## IfaceRefArray;                                                 \
  static inline N ## IfaceRefArray                                      \
  N ## IfaceRefArrayAlloc(unsigned Reserve)                             \
  {                                                                     \
    temu_IfaceRefArray Arr = temu_ifaceRefArrayAlloc(Reserve);          \
    N ## IfaceRefArray Res;                                             \
    Res.Size = Arr.Size;                                                \
    Res.Reserved = Arr.Reserved;                                        \
    Res.Ifaces = (N##IfaceRef*)Arr.Ifaces;                              \
    return Res;                                                         \
  }                                                                     \
  static inline void                                                    \
  N ## IfaceRefArrayDispose(N ## IfaceRefArray *Arr)                    \
  {                                                                     \
    temu_ifaceRefArrayDispose((temu_IfaceRefArray*)Arr);                \
  }                                                                     \
  static inline void                                                    \
  N ## IfaceRefArrayPush2(N ## IfaceRefArray *Arr, void *Obj, void *Iface) \
  {                                                                     \
    temu_ifaceRefArrayPush2((temu_IfaceRefArray*)Arr, Obj, Iface);      \
  }                                                                     \
  static inline void                                                    \
  N ## IfaceRefArrayPush(N ## IfaceRefArray *Arr, N ## IfaceRef Iface)  \
  {                                                                     \
    temu_IfaceRef Iface2;                                               \
    Iface2.Obj = Iface.Obj;                                             \
    Iface2.Iface = (void*)Iface.Iface;                                  \
                                                                        \
    temu_ifaceRefArrayPush((temu_IfaceRefArray*)Arr, Iface2);           \
  }                                                                     \
  static inline unsigned                                                \
  N ## IfaceRefArraySize(temu_IfaceRefArray *Arr)                       \
  {                                                                     \
    return Arr->Size;                                                   \
  }


#define TEMU_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;                                                   \
  }

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

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

typedef enum temu_Type {
  teTY_Invalid, // Invalid value 0

  // C pointer sized integers
  teTY_Intptr, // 1
  teTY_Uintptr, //2

  // Standard C floating point types
  teTY_Float, //3
  teTY_Double, //4

  // Standard C fixed width integer types
  teTY_U8, //5
  teTY_U16, //6
  teTY_U32, //7
  teTY_U64, //8
  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 references (object and interface pointer pair)
  teTY_IfaceRef,
  teTY_IfaceRefArray, // 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_IfaceRef IfaceRef;
    temu_IfaceRefArray IfaceRefArray;
    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_IfaceRef, IfaceRef, teTY_IfaceRef, IfaceRef)

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);
int temu_getPropDynLength(const void *Obj, const char *PropName);

int temu_isNumber(temu_Propval Pv);
int temu_isReal(temu_Propval Pv);
int temu_isDiscrete(temu_Propval Pv);
int temu_isString(temu_Propval Pv);

int64_t temu_asInteger(temu_Propval Pv);
uint64_t temu_asUnsigned(temu_Propval Pv);
double temu_asDouble(temu_Propval Pv);

/*
  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) TEMU_NO_WRAP;

// 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) TEMU_NO_WRAP;

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)
  TEMU_NO_WRAP;

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)
  TEMU_NO_WRAP;

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_NO_WRAP;

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

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

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



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

#define TEMU_NULL_ARG { NULL, {teTY_Invalid} }

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

void
temu_requireInterface(temu_Class *Cls, const char *PropName,
                      const char *IfaceType);


#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

int temu_setVTable(temu_Class *Cls, void *VTable);
void* temu_getVTableForClass(temu_Class *Cls);
void* temu_getVTable(void *Obj);

int temu_isExternal(void *Obj);
int temu_isCpu(void *Obj);
int temu_isMachine(void *Obj);
void temu_qualifyAsCpu(void *Cls);
void temu_qualifyAsMachine(void *Cls);


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,
                        const temu_CreateArg *Args);



void temu_disposeObject(void *Obj);

temu_Class* temu_classForName(const char *ClsName);
const char* temu_nameForClass(temu_Class *Cls);

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);


int temu_generateObjectGraph(const char *Path, int Display);


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;

TEMU_IFACE_REFERENCE_TYPE(temu_Object);

#ifdef __cplusplus
}
#endif


#endif