CentumSharedCode.h

Go to the documentation of this file.

#ifdef CENTUMSHAREDCODE_EXPORTS
#define CENTUMSHAREDCODE_API __declspec(dllexport)              
#else
#define CENTUMSHAREDCODE_API __declspec(dllimport)              
#endif

#ifndef CENUTUMSHAREDCODE_H
#define CENUTUMSHAREDCODE_H                                                             

#include <stdlib.h>
#include <malloc.h>
#include <string.h>
#include <windows.h>
#include <time.h>

#define INST_ALIAS                                      0x01                                            
#define INST_CREATE                                     0x02                                            
#define INST_MEMBER                                     0x03                                            

#define FIND_SCOPE                                      0x01                                            
#define FIND_THING                                      0x02                                            
#define FIND_UNDEF                                      0x03                                            

class CScope;
class CThing;
class CThingStack;
class CStringManager;
class CDefinition;
class CThingArray;

#define EXEC_NORMAL             0x00000000                      
#define EXEC_RETURN             0x00000001                      
#define EXEC_EXCEPTION          0x00000002              
#define EXEC_MULTIPLERETURN     0x000FFFFF              
#define EXEC_RETURNTO           0x00000003              
#define EXEC_RETURNFROM         0x00000004              


struct ExecutionReturn
        {
        unsigned long valueofexection;                  
        CThingStack* exception;                                 

        ExecutionReturn()
                {
                valueofexection = EXEC_NORMAL;
                exception = (CThingStack*)0;
                }
        };

#define CTHING_READONLY                         0x80000000                              
#define CTHING_REGISTEREDFUNCTION               0x00000001                      
#define CTHING_DLLFUNCTION                      0x00000002                              
#define CTHING_UNDEF                            0x00000004                              


#define DATA_TYPE_RAW                                   0x80000001                                      
#define DATA_TYPE_SIGNED_LONG                           0x80000002                              
#define DATA_TYPE_FLOAT                                 0x80000003                                      
#define DATA_TYPE_BOOLEAN                               0x80000004                                      
#define DATA_TYPE_STRING                                0x80000005                                      
#define DATA_TYPE_ARRAY                                 0x80000006                                      
#define DATA_TYPE_EXTERNAL_FUNCTION                     0x80000007                              
#define DATA_TYPE_DLL_NAME                              0x80000008                                      
#define DATA_TYPE_DLL_FUNCTION_NAME                     0x80000009                              
#define DATA_TYPE_DLL_FUNCTION_VALUE                    0x8000000A                      
#define DATA_TYPE_CONSOLE                               0x8000000B                                      
#define DATA_TYPE_FILE                                  0x8000000C                                      
#define DATA_TYPE_SOCKET                                0x8000000D                                      
#define DATA_TYPE_CLIENT_CONNECTION                     0x8000000E                      
#define DATA_TYPE_SCRIPT                                0x8000000F                              
#define DATA_TYPE_THREADLIST                            0x80000010                      
#define DATA_TYPE_TIME                                  0x80000011                              
#define DATA_TYPE_FILE_STREAM                           0x80000011                      
#define DATA_TYPE_WORD_TYPE                             0x80000012                              
#define DATA_TYPE_SCOPE                                 0x80000012                              
#define DATA_TYPE_HWND                                  0x80000014                              
#define DATA_TYPE_PYTHON                                0x80000015                              
#define DATA_TYPE_JAVAVM                                0x80000016                              
#define DATA_TYPE_JAVA_CLASS                            0x80000017                      
#define DATA_TYPE_JAVA_OBJECT                           0x80000018                      
#define DATA_TYPE_JAVA_LONG                             0x80000019                              
#define DATA_TYPE_JAVA_METHODID                         0x8000001A                      
#define DATA_TYPE_JAVA_MEMBERID                         0x8000001B                      
#define DATA_TYPE_JAVA_BYTE                             0x8000001C                              
#define DATA_TYPE_JAVA_CHAR                             0x8000001D                              
#define DATA_TYPE_JAVA_SHORT                            0x8000001E                      
#define DATA_TYPE_JAVA_DOUBLE                           0x8000001F                      
#define DATA_TYPE_JAVA_BOOL                             0x80000020                              
#define DATA_TYPE_JAVA_INT                              0x80000021                              
#define DATA_TYPE_JAVA_FLOAT                            0x80000022                      
#define DATA_TYPE_HKEY                                  0x80000023                              
#define DATA_TYPE_HANDLE                                0x80000024                              
#define DATA_TYPE_READANDWRITE                          0x80000025                      

class CThing;
class CThingArray;
class CScope;
class IMemory;

class CENTUMSHAREDCODE_API CDllList
        {
        private:
                CDllList* next;                                 
                char* name;                                             
                HMODULE dllhandle;                              
        public:
                CDllList();
                ~CDllList();
                CDllList* GetWithName(const char* n);
                static CDllList* NewDll(const char* n,  CDllList* head);
                HMODULE GetHandle() const;
        };

class CENTUMSHAREDCODE_API CDllManager
        {
        private:
                CDllList* head;                                 
        public:
                CDllManager();
                ~CDllManager();
                void Construct();
                void Destruct();
                HMODULE OpenDll(const char* name);
        };

class CENTUMSHAREDCODE_API CThingArray
        {
        public:
                CThing** ar;                            
                unsigned long size;                     
                unsigned long used;                     

                CThingArray();
                ~CThingArray();
                void Construct();
                void Destruct();
                void AddCThing(CThing* t);
                CThing* ReturnAt(unsigned long i) const;
                void AddAt(unsigned long i, CThing* t);
                void RemoveAt(unsigned long i);
                unsigned long NumberOfThings() const;
        };

class CENTUMSHAREDCODE_API PointerArray
        {
        public:
                char** ar;                              
                unsigned long size;             
                unsigned long used;             

                PointerArray();
                ~PointerArray();
                void Construct();
                void Destruct();
                void AddPointer(char* t);
                char* ReturnAt(unsigned long i) const;
                void AddAt(unsigned long i, char* t);
                void RemoveAt(unsigned long i);
                unsigned long NumberOfPointers() const;
        };

class CENTUMSHAREDCODE_API Int8Array
        {
        public:
                unsigned __int8* ar;            
                unsigned long size;                     
                unsigned long used;                     

                Int8Array();
                ~Int8Array();
                void Construct();
                void Destruct();
                void AddInt8(unsigned __int8 t);
                unsigned __int8 ReturnAt(unsigned long i) const;
                void AddAt(unsigned long i, unsigned __int8 t);
                void RemoveAt(unsigned long i);
                unsigned long NumberOfInt8s() const;
                unsigned long Find(unsigned __int8 v) const;
        };

class CENTUMSHAREDCODE_API LongArray
        {
        public:
                unsigned long* ar;                      
                unsigned long size;                     
                unsigned long used;                     

                LongArray();
                ~LongArray();
                void Construct();
                void Destruct();
                void AddLong(unsigned long t);
                unsigned long ReturnAt(unsigned long i) const;
                void AddAt(unsigned long i, unsigned long t);
                void RemoveAt(unsigned long i);
                unsigned long NumberOfLongs() const;
                unsigned long Find(unsigned long v) const;
        };

class CENTUMSHAREDCODE_API CProcessData
        {
        public:
                long references;                                

                IMemory* manager;                               
                CStringManager* strings;                

                CScope* globalscope;                    
                unsigned long processid;                

                HANDLE mutex;                                   
                CDllManager dlls;                               

                CThing* undef;                                  
                CThing* interpterexception;             

                void Construct(IMemory* m, CStringManager* s);
                void Destruct();
                void Finalize();
                void SetBasics(CThing* u, CThing* i);
        };

CENTUMSHAREDCODE_API ExecutionReturn ExecuteSingleFunction(CProcessData* dat, CThing* function, CThingStack* params, CThingStack* usings); 
CENTUMSHAREDCODE_API void AddCProcessDataReference(CProcessData* p);
CENTUMSHAREDCODE_API void ReleaseCProcessData(CProcessData* p);

struct StackObj
        {
        unsigned long type;                                             
        StackObj* next;                                                 

        union
                {
                struct
                        {
                        unsigned long stroffset;        
                        CThing* objpointer;                     
                        } stringref;                            
                struct
                        {
                        unsigned long dead_value;       
                        CThing* objpointer;                     
                        } bareref;                                      
                } data;                                                 

        };

CENTUMSHAREDCODE_API void ConvertSRefToBRef(StackObj* o);

class CENTUMSHAREDCODE_API CThingStack
        {
        private:
                StackObj* head;                                 
                
        public:
                CThingStack();
                ~CThingStack();

                void Construct();
                void Destruct();
                
                void PushBareRef(CThing* objptr);
                void PushStrRef(CThing* objptr, unsigned long offset);
                void PushStackBlock();
                void PushStackObject(StackObj* s);

                StackObj* GetTop() const;
                StackObj* GetN(unsigned long depth) const;
                StackObj* GetFunc();

                StackObj* Pop();

                void Empty();
                bool IsEmpty() const;

                void Reverse(); 
        
                void ConvertStackToBares();
                CThingStack* GetASubStack();
                CThingStack* GetASubStackUnsafe();
                unsigned int NumberOfObjects() const;
        };

class CENTUMSHAREDCODE_API CScope
        {
        public:                                                         
                long references;                                

                LongArray mynames;                              
                CThingArray myrefs;                             

                CThingStack* params;                    
                CThingStack* usings;                    

                CThingStack     localstack;                     
                CThingStack usingsstack;                

                CThing* currentthing;                   
                unsigned long codeposition;             

                CScope* caller;                                 
                CProcessData* processdata;              

                unsigned long scopedata[3];             
                HANDLE mutex;                                   

        public:

                void Construct(CScope* c, CProcessData* owner);
                void Destruct();
        };

CENTUMSHAREDCODE_API ExecutionReturn CallFunction(CScope* caller, CThing* func, CThingStack* params, CThingStack* usings);
CENTUMSHAREDCODE_API ExecutionReturn ExecuteByteCode(CScope* scope);    
CENTUMSHAREDCODE_API void AddCScopeReference(CScope* scope);
CENTUMSHAREDCODE_API void ReleaseCScope(CScope* scope);


class CENTUMSHAREDCODE_API CStringManager
        {
        private:
                LongArray Originals;                                            
                PointerArray NewAddresses;                                      
                PointerArray Strings;                                           
                char* laststringretrieved;                                      
                unsigned long lastoffsetlookedup;                       

        public:
                ~CStringManager();

                char* RetrieveString(unsigned long number);             
                char* RetrieveString(unsigned long number) const;
                void AddStrings(const char* string, unsigned long length, unsigned long originaloffset);                
                void AddStrings(const char* string, unsigned long length);                                                              
                void Destruct();
                void Construct();

                void RemoveString(unsigned long number);
                unsigned long RetrieveOffset(const char* string) const;
        };

class CThing;

class CENTUMSHAREDCODE_API CLocal
        {
        public:
                CThingArray localrefs;                                          
                PointerArray datumrefs;                                         

                CThing* container;                                                      
                
                //NEW FOR TIE/UNTIE
                CThingArray destobjects;                                        
                LongArray localtierefs;                                         
                LongArray desttierefs;                                          
        public:
                void Construct();
                void Destruct();

                void AddTypedDataAndLength(unsigned long type, unsigned long length, const void* data);
                __int8* GetDataByType(unsigned long type) const;
        };

class CENTUMSHAREDCODE_API CDefinition
        {
        public:
                long refcount;                                                          
                
                LongArray staticnames;                                          
                CThingArray staticrefs;                                         

                LongArray localnames;                                           
                
                LongArray localinstantationnames;                       
                Int8Array localinstantationtypes;                       

                unsigned long codelegth;                                        
                __int8* code;                                                           

                CProcessData* ownerprocess;                                     
                HANDLE mutex;                                                           

        public:
                void Construct(CProcessData* owner);
                void Destruct();
        };

class CENTUMSHAREDCODE_API CThing
        {
        public:
                long refcount;                                                          
                unsigned long flags;                                            

                CDefinition* def;                                                       
                CLocal* local;                                                          

                CProcessData* ownerprocess;                                     
                HANDLE mutex;                                                           

                //NEW FOR GARBAGE COLLECTION
                CThingArray pointedto;                                          
        public:
                void Construct(CProcessData* owner);
                void Destruct();
        };

#define SOBJ_TYPE_BLOCK         1                                       
#define SOBJ_TYPE_SREF          2                                       
#define SOBJ_TYPE_BREF          3                                       
#define SOBJ_NULL               ((StackObj*)0)                  

CENTUMSHAREDCODE_API void FillWithStack(CThingArray* a, CThingStack* s);
CENTUMSHAREDCODE_API void ReleaseAll(CThingArray* a);

CENTUMSHAREDCODE_API CThing* CreateCThing(IMemory* m, CProcessData* p);
CENTUMSHAREDCODE_API CDefinition* CreateCDefinition(IMemory* m, CProcessData* p);
CENTUMSHAREDCODE_API CScope* CreateCScope(IMemory* m, CScope* caller, CProcessData* process);
CENTUMSHAREDCODE_API CLocal* CreateCLocal(IMemory* m);
CENTUMSHAREDCODE_API CThingStack* CreateCThingStack(IMemory* m);
CENTUMSHAREDCODE_API void FinishCScope(CScope* s);

namespace FunctionCalls
        {
        CENTUMSHAREDCODE_API ExecutionReturn HandleReturnValue(CScope* scope, ExecutionReturn ret);
        CENTUMSHAREDCODE_API ExecutionReturn HandleUReturnValue(CScope* scope, ExecutionReturn ret);
        CENTUMSHAREDCODE_API void ExtractAndReleaseParamsAndUsings(CScope* scope);
        CENTUMSHAREDCODE_API ExecutionReturn MakeARegisteredCall(CThing* func, CScope* scope);
        CENTUMSHAREDCODE_API ExecutionReturn MakeADLLCall(CThing* func, CScope* scope);
        CENTUMSHAREDCODE_API ExecutionReturn MakeANormalCall(CThing* func, CScope* scope);
        CENTUMSHAREDCODE_API ExecutionReturn HandleReturnValueAll(CScope* scope, ExecutionReturn ret, CThingStack* dest);
        CENTUMSHAREDCODE_API ExecutionReturn HandleReturnedException(CScope* scope, ExecutionReturn ret);
        CENTUMSHAREDCODE_API ExecutionReturn CleanReturnValue(ExecutionReturn ret);
        };

class CENTUMSHAREDCODE_API IMemory
        {
        public:
                virtual void* Request(unsigned long size) = 0;
                virtual void Free(void* ptr) = 0;
        };

class CENTUMSHAREDCODE_API CMemoryTracker : public IMemory
        {
        protected:
                PointerArray listofpointer;                     
                unsigned long numpointers;                      
        public:
                CMemoryTracker();
                ~CMemoryTracker();
        
        //public static interface:
                virtual void* Request(unsigned long length);
                virtual void Free(void* ptr);
        
        //this interface subject to change and/or revision:
                unsigned long GetNumberOfPointers() const;
                void FreeAll();
        };

class CENTUMSHAREDCODE_API CDefaultMemoryManager : public IMemory
        {
        public:
                virtual void* Request(unsigned long length);
                virtual void Free(void* ptr);
        };

CENTUMSHAREDCODE_API extern CMemoryTracker def; 

namespace StackOperations
        {
        CENTUMSHAREDCODE_API CThing* StackObjToCThing(StackObj* p);
        CENTUMSHAREDCODE_API CThing* StackObjToCThingSafe(const StackObj* p);
        CENTUMSHAREDCODE_API void FinishCThingStack(CThingStack* s);
        };

namespace ThingManipulation
        {
        struct SFindThing
                {
                unsigned long type;             
                union
                        {
                        CScope* scope;          
                        CThing* thing;          
                        } data;                         
                
                SFindThing()
                        {
                        type = FIND_UNDEF;
                        }
                };

        
        CENTUMSHAREDCODE_API ExecutionReturn CreateExceptionReturn(CScope* scope, const char* message);
        CENTUMSHAREDCODE_API CThing* FindInScope(CScope* s, unsigned long stringindex,  const CStringManager* strings, CThing* newvalue = (CThing*)0, CThing** parent = (CThing**)0, long* name = (long*)0);            //get a thing reference with respect to the specified scope
        CENTUMSHAREDCODE_API CThing*    FindInThing(CThing* t, unsigned long stringindex,  const CStringManager* strings, CThing* newvalue = (CThing*)0, CThing** parent = (CThing**)0, long* name = (long*)0);         //get a thing reference with respect to the passed thing
        CENTUMSHAREDCODE_API CThing* FindInThingSub(CThing* t, unsigned long stringindex,  const CStringManager* strings, CThing* newvalue = (CThing*)0, CThing** parent = (CThing**)0, long* name = (long*)0);
        CENTUMSHAREDCODE_API SFindThing FindInScopeSub(CScope* s, unsigned long stringindex,  const CStringManager* strings, CThing* newvalue = (CThing*)0, CThing** parent = (CThing**)0, long* name = (long*)0);
        CENTUMSHAREDCODE_API SFindThing UniversalFind(SFindThing current, unsigned long stroffset,  const CStringManager* strings, CThing* newvalue = (CThing*)0, CThing** parent = (CThing**)0, long* name = (long*)0);
        CENTUMSHAREDCODE_API SFindThing UniversalArrayFind(SFindThing current, unsigned long stroffset,  const CStringManager* strings, CThingArray* dest, CThing** parent = (CThing**)0, long* name = (long*)0);
        CENTUMSHAREDCODE_API CThing* FindInScopeArray(CScope* s, unsigned long stringindex,  const CStringManager* strings, CThingArray* dest, CThing** parent = (CThing**)0, long* name = (long*)0);

        CENTUMSHAREDCODE_API void ReturnAllTied(CThing* current, unsigned long cname, CThingArray* ta, LongArray* la);

        CENTUMSHAREDCODE_API CThing* ReturnDestructor(const CThing* t);
        CENTUMSHAREDCODE_API CThing* ReturnConstructor(const CThing* t);
        
        CENTUMSHAREDCODE_API CThing* BuildFromDef(CDefinition* def, CScope* scope, CThingStack* params, CThingStack* usings, CThing* owner);
        CENTUMSHAREDCODE_API CThing* BuildFromString(const char* str, CScope* scope, CThingStack* params, CThingStack* usings, CThing* owner);
        CENTUMSHAREDCODE_API void MakeEqual(CThing* dest, CThing* source);
        CENTUMSHAREDCODE_API void CallConstructor(CThing* ret, CScope* scope, CThingStack* params, CThingStack* usings);
        CENTUMSHAREDCODE_API void CallDestructor(CThing* thing);
        CENTUMSHAREDCODE_API char* GetData(const CThing* t, unsigned long type);
        CENTUMSHAREDCODE_API void AddData(CThing* t, unsigned long type, unsigned long length, const char* data);

        CENTUMSHAREDCODE_API long GetLong(const CThing* t, long def = 0);
        CENTUMSHAREDCODE_API float GetFloat(const CThing* t, float def = 0.0);
        CENTUMSHAREDCODE_API char* GetString(const CThing* t, char* def = (char*)0);
        CENTUMSHAREDCODE_API bool HasLong(const CThing* t);
        CENTUMSHAREDCODE_API void RemoveData(CThing* t, unsigned long type);


        CENTUMSHAREDCODE_API bool HasDataType(const CThing* t, unsigned long type);
        CENTUMSHAREDCODE_API unsigned long GetDataLength(const CThing* t, unsigned long type);

        CENTUMSHAREDCODE_API CThing* ReplaceAndReturn(CThingArray* refs, unsigned long index, CThing* rep);
        CENTUMSHAREDCODE_API CThing* ReplaceAndReturnGC(CThingArray* refs, unsigned long index, CThing* rep, CThing* from);
        };

typedef ExecutionReturn (*ExternalCall) (unsigned long, CScope*, CThingStack*, CThingStack*);   

namespace bytecodes
        {
        CENTUMSHAREDCODE_API ExecutionReturn CallFunction(CScope* scope);                       
        CENTUMSHAREDCODE_API ExecutionReturn CallUFunction(CScope* scope);
        CENTUMSHAREDCODE_API ExecutionReturn Equality(CScope* scope);
        CENTUMSHAREDCODE_API ExecutionReturn Alias(CScope* scope);
        CENTUMSHAREDCODE_API ExecutionReturn IsA(CScope* scope);
        CENTUMSHAREDCODE_API ExecutionReturn PopParameter(CScope* scope);
        CENTUMSHAREDCODE_API ExecutionReturn ClearStack(CScope* scope);
        CENTUMSHAREDCODE_API ExecutionReturn StackBlock(CScope* scope);
        CENTUMSHAREDCODE_API ExecutionReturn UStackBlock(CScope* scope);
        CENTUMSHAREDCODE_API ExecutionReturn ClearUStack(CScope* scope);
        CENTUMSHAREDCODE_API ExecutionReturn Return(CScope* scope);
        CENTUMSHAREDCODE_API ExecutionReturn ThrowException(CScope* scope);
        CENTUMSHAREDCODE_API ExecutionReturn PushParameterN(CScope* scope, unsigned __int16 n);
        CENTUMSHAREDCODE_API ExecutionReturn PushUsingN(CScope* scope, unsigned __int16 n);
        CENTUMSHAREDCODE_API ExecutionReturn PushParameterNU(CScope* scope, unsigned __int16 n);
        CENTUMSHAREDCODE_API ExecutionReturn PushUsingNU(CScope* scope, unsigned __int16 n);
        CENTUMSHAREDCODE_API ExecutionReturn MultipleReturn(CScope* scope, unsigned __int16 n);
        CENTUMSHAREDCODE_API ExecutionReturn PushCThingS(CScope* scope, unsigned long index);
        CENTUMSHAREDCODE_API ExecutionReturn PushCThingU(CScope* scope, unsigned long index);
        CENTUMSHAREDCODE_API ExecutionReturn Instantiate(CScope* scope);
        CENTUMSHAREDCODE_API ExecutionReturn PushParams(CScope* scope);
        CENTUMSHAREDCODE_API ExecutionReturn PushUsings(CScope* scope);
        CENTUMSHAREDCODE_API ExecutionReturn PushParamsU(CScope* scope);
        CENTUMSHAREDCODE_API ExecutionReturn PushUsingsU(CScope* scope);
        CENTUMSHAREDCODE_API ExecutionReturn CreateMy(CScope* scope, unsigned long index);
        CENTUMSHAREDCODE_API ExecutionReturn ClearBothStacks(CScope* scope);
        CENTUMSHAREDCODE_API ExecutionReturn BlockBothStacks(CScope* scope);
        CENTUMSHAREDCODE_API ExecutionReturn CopyLocals(CScope* scope);
        CENTUMSHAREDCODE_API ExecutionReturn Are(CScope* scope);
        CENTUMSHAREDCODE_API ExecutionReturn AddLabel(CScope* scope, unsigned long index);
        CENTUMSHAREDCODE_API ExecutionReturn InstantiateU(CScope* scope);
        CENTUMSHAREDCODE_API ExecutionReturn LastParam(CScope* scope);
        CENTUMSHAREDCODE_API ExecutionReturn Tie(CScope* scope);
        CENTUMSHAREDCODE_API ExecutionReturn Untie(CScope* scope);
        };

namespace ThingReferences
        {
        CENTUMSHAREDCODE_API void AddCThingReference(CThing* thing);
        CENTUMSHAREDCODE_API void AddDefReference(CDefinition* def);

        CENTUMSHAREDCODE_API void ReleaseCThing(CThing* thing);
        CENTUMSHAREDCODE_API void ReleaseCDefinition(CDefinition* def);

        CENTUMSHAREDCODE_API void AddCThingReferenceGC(CThing* thing, CThing* from);
        CENTUMSHAREDCODE_API void ReleaseCThingGC(CThing* thing, CThing* from);
        CENTUMSHAREDCODE_API void GarbageCollect(CThing* thing);
        };

extern CENTUMSHAREDCODE_API char rootpath[512];

#endif

---