USB/UHCI - Cleanup
[tpg/acess2.git] / 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 sSpiderNamespace tSpiderNamespace;
18 typedef struct sSpiderFunction  tSpiderFunction;
19 typedef struct sSpiderValue     tSpiderValue;
20 typedef struct sSpiderObjectDef tSpiderObjectDef;
21 typedef struct sSpiderObject    tSpiderObject;
22
23
24 /**
25  * \brief SpiderScript Variable Datatypes
26  * \todo Expand the descriptions
27  */
28 enum eSpiderScript_DataTypes
29 {
30         /**
31          * \brief Undefined data
32          * \note Default type of an undefined dynamic variable
33          */
34         SS_DATATYPE_UNDEF,
35         /**
36          * \brief Dynamically typed variable
37          * \note Used to dentote a non-fixed type for function parameters
38          */
39         SS_DATATYPE_DYNAMIC,
40         /**
41          * \brief Opaque Data Pointer
42          * 
43          * Opaque data types are used for resource handles or for system buffers.
44          */
45         SS_DATATYPE_OPAQUE,
46         /**
47          * \brief Object reference
48          * 
49          * A reference to a SpiderScript class instance. Can be accessed
50          * using the -> operator.
51          */
52         SS_DATATYPE_OBJECT,
53         /**
54          * \brief Array data type
55          */
56         SS_DATATYPE_ARRAY,
57         /**
58          * \brief Integer datatype
59          * 
60          * 64-bit integer
61          */
62         SS_DATATYPE_INTEGER,
63         SS_DATATYPE_REAL,       //!< Real Number (double)
64         SS_DATATYPE_STRING,     //!< String
65         NUM_SS_DATATYPES
66 };
67
68 enum eSpiderValueOps
69 {
70         SS_VALUEOP_NOP,
71
72         SS_VALUEOP_ADD,
73         SS_VALUEOP_SUBTRACT,
74         SS_VALUEOP_NEGATE,
75         SS_VALUEOP_MULIPLY,
76         SS_VALUEOP_DIVIDE,
77         SS_VALUEOP_MODULO,
78
79         SS_VALUEOP_BITNOT,
80         SS_VALUEOP_BITAND,
81         SS_VALUEOP_BITOR,
82         SS_VALUEOP_BITXOR,
83
84         SS_VALUEOP_SHIFTLEFT,
85         SS_VALUEOP_SHIFTRIGHT,
86         SS_VALUEOP_ROTATELEFT
87 };
88
89 /**
90  * \brief Namespace definition
91  */
92 struct sSpiderNamespace
93 {
94         tSpiderNamespace        *Next;
95         
96         tSpiderNamespace        *FirstChild;
97         
98         tSpiderFunction *Functions;
99         
100         tSpiderObjectDef        *Classes;
101         
102          int    NConstants;     //!< Number of constants
103         tSpiderValue    *Constants;     //!< Number of constants
104         
105         const char      Name[];
106 };
107
108 /**
109  * \brief Variant of SpiderScript
110  */
111 struct sSpiderVariant
112 {
113         const char      *Name;  // Just for debug
114         
115          int    bDyamicTyped;   //!< Use dynamic typing
116          int    bImplicitCasts; //!< Allow implicit casts (casts to lefthand side)
117         
118         tSpiderFunction *Functions;     //!< Functions (Linked List)
119         
120          int    NConstants;     //!< Number of constants
121         tSpiderValue    *Constants;     //!< Number of constants
122         
123         tSpiderNamespace        RootNamespace;
124 };
125
126 /**
127  * \brief SpiderScript data object
128  */
129 struct sSpiderValue
130 {
131         enum eSpiderScript_DataTypes    Type;   //!< Variable type
132          int    ReferenceCount; //!< Reference count
133         
134         union {
135                 int64_t Integer;        //!< Integer data
136                 double  Real;   //!< Real Number data
137                 /**
138                  * \brief String data
139                  */
140                 struct {
141                          int    Length; //!< Length
142                         char    Data[]; //!< Actual string (\a Length bytes)
143                 }       String;
144                 /**
145                  * \brief Variable data
146                  */
147                 struct {
148                          int    Length; //!< Length of the array
149                         tSpiderValue    *Items[];       //!< Array elements (\a Length long)
150                 }       Array;
151                 
152                 /**
153                  * \brief Opaque data
154                  */
155                 struct {
156                         void    *Data;  //!< Data (can be anywhere)
157                         void    (*Destroy)(void *Data); //!< Called on GC
158                 }       Opaque;
159                 
160                 /**
161                  * \brief Object Instance
162                  */
163                 tSpiderObject   *Object;
164         };
165 };
166
167 /**
168  * \brief Object Definition
169  * 
170  * Internal representation of an arbitary object.
171  */
172 struct sSpiderObjectDef
173 {
174         /**
175          */
176         struct sSpiderObjectDef *Next;  //!< Internal linked list
177         /**
178          * \brief Object type name
179          */
180         const char * const      Name;
181         /**
182          * \brief Construct an instance of the object
183          * \param NArgs Number of arguments
184          * \param Args  Argument array
185          * \return Pointer to an object instance (which must be fully valid)
186          * \retval NULL Invalid parameter (usually, actually just a NULL value)
187          * \retval ERRPTR       Invalid parameter count
188          */
189         tSpiderObject   *(*Constructor)(int NArgs, tSpiderValue **Args);
190         
191         /**
192          * \brief Clean up and destroy the object
193          * \param This  Object instace
194          * \note The object pointer (\a This) should be invalidated and freed
195          *       by this function.
196          */
197         void    (*Destructor)(tSpiderObject *This);
198         
199         tSpiderFunction *Methods;       //!< Method Definitions (linked list)
200         
201          int    NAttributes;    //!< Number of attributes
202         
203         //! Attribute definitions
204         struct {
205                 const char      *Name;  //!< Attribute Name
206                  int    bReadOnly;      //!< Allow writes to the attribute?
207         }       AttributeDefs[];
208 };
209
210 /**
211  * \brief Object Instance
212  */
213 struct sSpiderObject
214 {
215         tSpiderObjectDef        *Type;  //!< Object Type
216          int    ReferenceCount; //!< Number of references
217         void    *OpaqueData;    //!< Pointer to the end of the \a Attributes array
218         tSpiderValue    *Attributes[];  //!< Attribute Array
219 };
220
221 /**
222  * \brief Represents a function avaliable to a script
223  */
224 struct sSpiderFunction
225 {
226         /**
227          * \brief Next function in list
228          */
229         struct sSpiderFunction  *Next;
230         
231         /**
232          * \brief Function name
233          */
234         const char      *Name;
235         /**
236          * \brief Function handler
237          */
238         tSpiderValue    *(*Handler)(tSpiderScript *Script, int nParams, tSpiderValue **Parameters);
239         /**
240          * \brief Argument types
241          * 
242          * Zero or -1 terminated array of \a eSpiderScript_DataTypes.
243          * If the final entry is zero, the function has a fixed number of
244          * parameters, if the final entry is -1, the function has a variable
245          * number of arguments.
246          */
247          int    ArgTypes[];     // Zero (or -1) terminated array of parameter types
248 };
249
250
251 // === FUNCTIONS ===
252 /**
253  * \brief Parse a file into a script
254  * \param Variant       Variant structure
255  * \param Filename      File to parse
256  * \return Script suitable for execution
257  */
258 extern tSpiderScript    *SpiderScript_ParseFile(tSpiderVariant *Variant, const char *Filename);
259 /**
260  * \brief Execute a function from a script
261  * \param Script        Script to run
262  * \param Function      Name of function to run ("" for the 'main')
263  * \return Return value
264  */
265 extern tSpiderValue     *SpiderScript_ExecuteFunction(tSpiderScript *Script,
266         tSpiderNamespace *Namespace, const char *Function,
267         int NArguments, tSpiderValue **Arguments
268         );
269 /**
270  * \brief Execute an object method
271  */
272 extern tSpiderValue     *SpiderScript_ExecuteMethod(tSpiderScript *Script,
273         tSpiderObject *Object, const char *MethodName,
274         int NArguments, tSpiderValue **Arguments
275         );
276 /**
277  * \brief Creates an object instance
278  */
279 extern tSpiderValue     *SpiderScript_CreateObject(tSpiderScript *Script,
280         tSpiderNamespace *Namespace, const char *ClassName,
281         int NArguments, tSpiderValue **Arguments
282         );
283
284 /**
285  * \brief Convert a script to bytecode and save to a file
286  */
287 extern int      SpiderScript_SaveBytecode(tSpiderScript *Script, const char *DestFile);
288 /**
289  * \brief Save the AST of a script to a file
290  */
291 extern int      SpiderScript_SaveAST(tSpiderScript *Script, const char *Filename);
292
293 /**
294  * \brief Free a script
295  * \param Script        Script structure to free
296  */
297 extern void     SpiderScript_Free(tSpiderScript *Script);
298
299 extern tSpiderObject    *SpiderScript_AllocateObject(tSpiderObjectDef *Class, int ExtraBytes);
300
301 /**
302  * \name tSpiderValue Manipulation functions
303  * \{
304  */
305 extern void     SpiderScript_DereferenceValue(tSpiderValue *Object);
306 extern void     SpiderScript_ReferenceValue(tSpiderValue *Object);
307 extern tSpiderValue     *SpiderScript_CreateInteger(uint64_t Value);
308 extern tSpiderValue     *SpiderScript_CreateReal(double Value);
309 extern tSpiderValue     *SpiderScript_CreateString(int Length, const char *Data);
310 extern tSpiderValue     *SpiderScript_StringConcat(const tSpiderValue *Str1, const tSpiderValue *Str2);
311 extern tSpiderValue     *SpiderScript_CastValueTo(int Type, tSpiderValue *Source);
312 extern int      SpiderScript_IsValueTrue(tSpiderValue *Value);
313 extern void     SpiderScript_FreeValue(tSpiderValue *Value);
314 extern char     *SpiderScript_DumpValue(tSpiderValue *Value);
315
316 extern tSpiderValue     *SpiderScript_DoOp(tSpiderValue *Left, enum eSpiderValueOps Op, int bCanCast, tSpiderValue *Right);
317 /**
318  * \}
319  */
320
321 #endif

UCC git Repository :: git.ucc.asn.au