Usermode/include/spiderscript.h

   1 /*
   2  *
   3  */
   4 #ifndef _SPIDERSCRIPT_H_
   5 #define _SPIDERSCRIPT_H_
   6
   7 #include <stdint.h>
   8
   9 #define ERRPTR  ((void*)((intptr_t)0-1))
  10
  11 /**
  12  * \brief Opaque script handle
  13  */
  14 typedef struct sSpiderScript    tSpiderScript;
  15
  16 typedef struct sSpiderVariant   tSpiderVariant;
  17 typedef struct sSpiderFunction  tSpiderFunction;
  18 typedef struct sSpiderValue     tSpiderValue;
  19 typedef struct sSpiderObjectDef tSpiderObjectDef;
  20 typedef struct sSpiderObject    tSpiderObject;
  21
  22
  23 /**
  24  * \brief SpiderScript Variable Datatypes
  25  * \todo Expand the descriptions
  26  */
  27 enum eSpiderScript_DataTypes
  28 {
  29         SS_DATATYPE_UNDEF,      //!< Undefined
  30         SS_DATATYPE_NULL,       //!< NULL (Probably will never be used)
  31         SS_DATATYPE_DYNAMIC,    //!< Dynamically typed variable (will this be used?)
  32         SS_DATATYPE_OPAQUE,     //!< Opaque data type
  33         SS_DATATYPE_OBJECT,     //!< Object reference
  34         SS_DATATYPE_ARRAY,      //!< Array
  35         SS_DATATYPE_INTEGER,    //!< Integer (64-bits)
  36         SS_DATATYPE_REAL,       //!< Real Number (double)
  37         SS_DATATYPE_STRING,     //!< String
  38         NUM_SS_DATATYPES
  39 };
  40
  41 /**
  42  * \brief Variant of SpiderScript
  43  */
  44 struct sSpiderVariant
  45 {
  46         const char      *Name;  // Just for debug
  47
  48          int    bDyamicTyped;   //!< Use static typing
  49
  50         tSpiderFunction *Functions;     //!< Functions (Linked List)
  51
  52          int    NConstants;     //!< Number of constants
  53         tSpiderValue    *Constants;     //!< Number of constants
  54 };
  55
  56 /**
  57  * \brief SpiderScript data object
  58  */
  59 struct sSpiderValue
  60 {
  61         enum eSpiderScript_DataTypes    Type;   //!< Variable type
  62          int    ReferenceCount; //!< Reference count
  63
  64         union {
  65                 uint64_t        Integer;        //!< Integer data
  66                 double  Real;   //!< Real Number data
  67                 /**
  68                  * \brief String data
  69                  */
  70                 struct {
  71                          int    Length; //!< Length
  72                         char    Data[]; //!< Actual string (\a Length bytes)
  73                 }       String;
  74                 /**
  75                  * \brief Variable data
  76                  */
  77                 struct {
  78                          int    Length; //!< Length of the array
  79                         tSpiderValue    *Items[];       //!< Array elements (\a Length long)
  80                 }       Array;
  81
  82                 /**
  83                  * \brief Opaque data
  84                  */
  85                 struct {
  86                         void    *Data;  //!< Data (can be anywhere)
  87                         void    (*Destroy)(void *Data); //!< Called on GC
  88                 }       Opaque;
  89
  90                 /**
  91                  * \brief Object Instance
  92                  */
  93                 tSpiderObject   *Object;
  94         };
  95 };
  96
  97 /**
  98  * \brief Object Definition
  99  *
 100  * Internal representation of an arbitary object.
 101  */
 102 struct sSpiderObjectDef
 103 {
 104         /**
 105          */
 106         struct sSpiderObjectDef *Next;  //!< Internal linked list
 107         /**
 108          * \brief Object type name
 109          */
 110         const char*     const Name;
 111         /**
 112          * \brief Construct an instance of the object
 113          * \param NArgs Number of arguments
 114          * \param Args  Argument count
 115          * \return Pointer to an object instance (which must be fully valid)
 116          * \retval NULL Invalid parameter (usually, actually just a NULL value)
 117          * \retval ERRPTR       Invalid parameter count
 118          */
 119         tSpiderObject   *(*Constructor)(int NArgs, tSpiderValue *Args);
 120
 121         /**
 122          * \brief Clean up and destroy the object
 123          * \param This  Object instace
 124          * \note The object pointer (\a This) should be invalidated and freed
 125          *       by this function.
 126          */
 127         void    (*Destructor)(tSpiderObject *This);
 128
 129          int    NAttributes;    //!< Number of attributes
 130
 131         //! Attribute definitions
 132         struct {
 133                 const char      *Name;  //!< Attribute Name
 134                  int    bReadOnly;      //!< Allow writes to the attribute?
 135         }       *AttributeDefs;
 136
 137
 138          int    NMethods;       //!< Number of methods
 139         tSpiderFunction *Methods;       //!< Method Definitions
 140 };
 141
 142 /**
 143  * \brief Object Instance
 144  */
 145 struct sSpiderObject
 146 {
 147         tSpiderObjectDef        *Type;  //!< Object Type
 148          int    NReferences;    //!< Number of references
 149         void    *OpaqueData;    //!< Pointer to the end of the \a Attributes array
 150         tSpiderValue    *Attributes[];  //!< Attribute Array
 151 };
 152
 153 /**
 154  * \brief Represents a function avaliable to a script
 155  */
 156 struct sSpiderFunction
 157 {
 158         /**
 159          * \brief Next function in list
 160          */
 161         struct sSpiderFunction  *Next;
 162
 163         /**
 164          * \brief Function name
 165          */
 166         const char      *Name;
 167         /**
 168          * \brief Function handler
 169          */
 170         tSpiderValue    *(*Handler)(tSpiderScript *Script, int nParams, tSpiderValue **Parameters);
 171         /**
 172          * \brief Argument types
 173          *
 174          * Zero or -1 terminated array of \a eSpiderScript_DataTypes.
 175          * If the final entry is zero, the function has a fixed number of
 176          * parameters, if the final entry is -1, the function has a variable
 177          * number of arguments.
 178          */
 179          int    ArgTypes[];     // Zero (or -1) terminated array of parameter types
 180 };
 181
 182
 183 // === FUNCTIONS ===
 184 /**
 185  * \brief Parse a file into a script
 186  * \param Variant       Variant structure
 187  * \param Filename      File to parse
 188  * \return Script suitable for execution
 189  */
 190 extern tSpiderScript    *SpiderScript_ParseFile(tSpiderVariant *Variant, const char *Filename);
 191 /**
 192  * \brief Execute a method from a script
 193  * \param Script        Script to run
 194  * \param Function      Name of function to run ("" for the 'main')
 195  * \return Return value
 196  */
 197 extern tSpiderValue     *SpiderScript_ExecuteMethod(tSpiderScript *Script,
 198         const char *Function,
 199         int NArguments, tSpiderValue **Arguments
 200         );
 201
 202 /**
 203  * \brief Free a script
 204  * \param Script        Script structure to free
 205  */
 206 extern void     SpiderScript_Free(tSpiderScript *Script);
 207
 208 /**
 209  * \name tSpiderValue Manipulation functions
 210  * \{
 211  */
 212 extern tSpiderValue     *SpiderScript_CreateInteger(uint64_t Value);
 213 extern tSpiderValue     *SpiderScript_CreateReal(double Value);
 214 extern tSpiderValue     *SpiderScript_CreateString(int Length, const char *Data);
 215 extern tSpiderValue     *SpiderScript_CastValueTo(int Type, tSpiderValue *Source);
 216 extern int      SpiderScript_IsValueTrue(tSpiderValue *Value);
 217 extern char     *SpiderScript_DumpValue(tSpiderValue *Value);
 218 /**
 219  * \}
 220  */
 221
 222 #endif