nabaztag_hack_kit 0.1.0.beta3 → 0.1.0.beta8

data/ext/mtl_linux/inc/vcomp/interpreter.h

@@ -0,0 +1,121 @@
+//-------------------
+// MV
+// version WIN32 et POCKETPC
+// Sylvain Huet
+// Premiere version : 07/01/2003
+// Derniere mise a jour : 07/01/2003
+//
+
+#ifndef _INTERPRETER_
+#define _INTERPRETER_
+
+
+class Memory;
+class Prodbuffer;
+
+
+class Interpreter
+{
+private:
+    Memory* m;
+    int callstack;
+    char *pc; // pointeur vers le prochain bytecode
+    char *bc; // pointeur vers le d�but du bytecode
+    int locals; // pointeur vers les variable locales dans la pile
+    int* globals; // pointeur vers les variable globales
+
+public:
+    Prodbuffer* output;
+
+    Interpreter(Memory* memory);
+    ~Interpreter();
+    int start();
+    void stop();
+
+    int go();
+
+    int TFCtest(char* p);
+
+    int BCexec();
+    int BCret();
+    int BCdrop();
+    int BCdup();
+    int BCnil();
+    int BCgetlocal();
+    int BCsetlocal();
+    int BCgetglobal();
+    int BCgetglobalb();
+    int BCint();
+    int BCgoto();
+    int BCelse();
+    int BCfetch();
+    int BCstore();
+    int BCdeftab();
+    int BCnop();
+    int BCadd();
+    int BCsub();
+    int BCmul();
+    int BCdiv();
+    int BCneg();
+    int BCand();
+    int BCor();
+    int BCeor();
+    int BCnot();
+    int BCshl();
+    int BCshr();
+    int BCeq();
+    int BCne();
+    int BClt();
+    int BCgt();
+    int BCle();
+    int BCge();
+    int BCnon();
+    int BCsearch();
+    int BCfloat();
+    int BCcall();
+    int BCaddf();
+    int BCsubf();
+    int BCmulf();
+    int BCdivf();
+    int BCnegf();
+    int BCltf();
+    int BCgtf();
+    int BClef();
+    int BCgef();
+    int BCsetlocal2();
+    int BCsetglobal2();
+    int BCexecnative();
+    int BCgetlocalb();
+    int BCfetchb();
+    int BCdeftabb();
+    int BCsetlocalb();
+    int BCfirst();
+    int BCmod();
+    int BCmktab();
+    int BCmktabb();
+    int BCsetstruct();
+    int BCsetstructb();
+    int BCcallr();
+    int BCcallrb();
+    int BCgetglobalval();
+    int BCgetglobalvalb();
+    int BCupdate();
+    int BCupdateb();
+    int BCintb();
+
+};
+
+typedef int (Interpreter::*BCfunction)();
+typedef int (*EXTfunction)(void*);
+
+#include"vm/vbc.h"
+
+#define CALLSTACK_LENGTH 6 // taille de la callstack sans les variables locales
+#define CALLSTACK_BC 0	// pointeur bytecode
+#define CALLSTACK_PC 1	// index bytecode
+#define CALLSTACK_REF 2	// table r�f�rences globales
+#define CALLSTACK_PREV 3	// callstack pr�c�dente
+#define CALLSTACK_NBARGS 4	// nombre d'arguments et variables globales
+#define CALLSTACK_FUN 5	// pointeur vers la r�f�rence de la fonction en cours
+
+#endif

data/{bytecode/src/mtl → ext/mtl_linux/inc}/vcomp/memory.h

@@ -37,15 +37,15 @@ class Stack
 {
 private:
 public:
-	Stack();
-	~Stack();
-	int size;	// taille du bloc allou�
-	int* base;	// d�but de la pile
-	int* pp;	// pointeur de pile
-
-	void initialize(int s);
-	int bigger(Memory* m);
-	void dump(FILE* f);
+    Stack();
+    ~Stack();
+    intptr_t size;	// taille du bloc allou�
+    intptr_t* base;	// d�but de la pile
+    intptr_t* pp;	// pointeur de pile
+
+    void initialize(int s);
+    int bigger(Memory* m);
+    void dump(FILE* f);
 };
 
 typedef void (*FORGET)(Memory*, void*);
@@ -55,54 +55,54 @@ class Memory
 {
 private:
 
-	// gestion du GC
-	int root;	// bloc racine (initialis� avec le premier bloc allou�)
+    // gestion du GC
+    int root;	// bloc racine (initialis� avec le premier bloc allou�)
 
-	int size0;
+    int size0;
 
 public:
-	int gcincperiod;
-	int abort;
-	// stack courante
-	Stack stack;
-	Terminal* term;
-	FileSystem* filesystem;
-	Util *util;
-	Winutil *winutil;
-	Memory(int size,Terminal *t,FileSystem *fs);
-	~Memory();
-
-	int start();
-	void stop();
-
-	int addroot(int* p);
-	void removeroot(int *p);
-
-	int* malloc(int size,int type);	// allocation (type vaut TYPE_BINARY ou TYPE_TAB)
-	int* mallocClear(int size);	// allocation de type TYPE_TAB avec initialisation � NIL
-	int* mallocExternal(void* pnt,FORGET fun);	// allocation de type TYPE_EXT (la fonction fun(pnt) sera appel�e lors de l'oubli du bloc)
-	int pushmalloc(int size,int type);	// allocation (type vaut TYPE_BINARY ou TYPE_TAB)
-	int pushmallocClear(int size);	// allocation de type TYPE_TAB avec initialisation � NIL
-	int pushExternal(void* pnt,FORGET fun);
-
-	int push(int val);
-	void tabset(int* p,int i,int val);
-	void stackset(int* p,int val);
-
-
-	int* storestring(const char* src);
-	int* storebinary(const char* src,int size);
-	int* storenosrc(int size);
-	int pushstring(const char* src);
-	int pushbinary(const char* src,int size);
-	int pushnosrc(int size);
-	int pushpnt(void* pnt);
-
-	int deftab(int size);
-
-	void listing();
-	const char* errorname(int err);
-	void dump();
+    int gcincperiod;
+    int abort;
+    // stack courante
+    Stack stack;
+    Terminal* term;
+    FileSystem* filesystem;
+    Util *util;
+    Winutil *winutil;
+    Memory(int size,Terminal *t,FileSystem *fs);
+    ~Memory();
+
+    int start();
+    void stop();
+
+    intptr_t addroot(intptr_t* p);
+    void removeroot(intptr_t *p);
+
+    intptr_t* malloc(int size,int type);	// allocation (type vaut TYPE_BINARY ou TYPE_TAB)
+    intptr_t* mallocClear(int size);	// allocation de type TYPE_TAB avec initialisation � NIL
+    intptr_t* mallocExternal(void* pnt,FORGET fun);	// allocation de type TYPE_EXT (la fonction fun(pnt) sera appel�e lors de l'oubli du bloc)
+    intptr_t pushmalloc(int size,int type);	// allocation (type vaut TYPE_BINARY ou TYPE_TAB)
+    intptr_t pushmallocClear(int size);	// allocation de type TYPE_TAB avec initialisation � NIL
+    intptr_t pushExternal(void* pnt,FORGET fun);
+
+    intptr_t push(int val);
+    void tabset(intptr_t* p,int i,int val);
+    void stackset(intptr_t* p,int val);
+
+
+    intptr_t* storestring(const char* src);
+    intptr_t* storebinary(const char* src,int size);
+    intptr_t* storenosrc(int size);
+    intptr_t pushstring(const char* src);
+    intptr_t pushbinary(char* src,int size);
+    intptr_t pushnosrc(int size);
+    intptr_t pushpnt(void* pnt);
+
+    int deftab(int size);
+
+    void listing();
+    const char* errorname(int err);
+    void dump();
 };
 
 // structures en m�moire
@@ -120,14 +120,14 @@ public:
 //// les champs suivants ne sont - pour l'instant - remplis que pour
 //// les CODE_VAR et les CODE_CONST
 #define REF_USED 7       // 0 au debut, 1 de plus � chaque fois que la
-												 // r�f�rence est utilis�e
+// r�f�rence est utilis�e
 #define REF_SET 8     // pour les var. 0 si la var ne re�oit jamais de
-											// valeur, 1 si elle a seulement une valeur
-											// donn�e � la d�claration, et 2 si elle est
-											// 'set'-�e dans le programme
+// valeur, 1 si elle a seulement une valeur
+// donn�e � la d�claration, et 2 si elle est
+// 'set'-�e dans le programme
 #define REF_USED_IN_IFDEF 9  // 0 au d�but, 1 de plus � chaque fois que
-													   // la ref est utlis�e comme condition dans
-													   // un ifdef
+// la ref est utlis�e comme condition dans
+// un ifdef
 
 #define CODE_TYPE -1	// type
 #define CODE_VAR -2	// variable
@@ -192,11 +192,11 @@ void AbortMetal(Memory* m,int donotstop);
 #define TYPE_TAB 1	// type table pour allocation
 #define TYPE_EXT 2	// type externe pour allocation
 
-#define PNTTOVAL(p) (1+((int)(p)))	// conversion pointeur vers mot metal
+#define PNTTOVAL(p) (1+((intptr_t)(p)))	// conversion pointeur vers mot metal
 #define INTTOVAL(i) ((i)<<1)	// conversion entier vers mot metal
 #define FLOATTOVAL(v) ((~1)&(*(int*)(&(v))))	// conversion flottant vers mot metal
 
-#define VALTOPNT(v) ((int*)((v)-1))	// conversion mot metal vers pointeur
+#define VALTOPNT(v) ((intptr_t*)((intptr_t)(v)-1))	// conversion mot metal vers pointeur
 #define VALTOINT(v) ((v)>>1)	// conversion mot metal vers entier
 #define VALTOFLOAT(v) (*((mtl_float*)(&(v))))	// conversion mot metal vers flottant
 
@@ -264,63 +264,91 @@ void AbortMetal(Memory* m,int donotstop);
 #define LOG_COMPILER 8
 #define LOG_USER 16
 
-inline int Memory::push(int val)
+inline intptr_t Memory::push(int val)
 {
-	*(++stack.pp)=val;
-	if ((stack.pp-stack.base)>=stack.size-1)
-	{
-		int k; if ((k=stack.bigger(this))) return k;
+    *(++stack.pp)=val;
+    if ((stack.pp-stack.base)>=stack.size-1)
+    {
+        intptr_t k;
+        if ((k=stack.bigger(this)))
+        {
+            return k;
+        }
 //	term->printf(LOG_DEVCORE,"## bigger stack %d\n",stack.size);
 //	stackprint(0);
-	}
-	return 0;
+    }
+    return 0;
 }
 
-inline void Memory::tabset(int* p,int i,int val)
+inline void Memory::tabset(intptr_t* p,int i,int val)
 {
-	p[HEADER_LENGTH+i]=val;	// r�gle une valeur d'une table
+    p[HEADER_LENGTH+i]=val;	// r�gle une valeur d'une table
 }
 
-inline void Memory::stackset(int* p,int val)
+inline void Memory::stackset(intptr_t* p,int val)
 {
-	*p=val;
+    *p=val;
 }
 
-inline int Memory::pushmalloc(int size,int type)
+inline intptr_t Memory::pushmalloc(int size,int type)
 {
-	int* p=malloc(size,type); if (!p) return MTLERR_OM;
-	return push(PNTTOVAL(p));
+    intptr_t* p=malloc(size,type);
+    if (!p)
+    {
+        return MTLERR_OM;
+    }
+    return push(PNTTOVAL(p));
 }
 
-inline int Memory::pushmallocClear(int size)
+inline intptr_t Memory::pushmallocClear(int size)
 {
-	int* p=mallocClear(size); if (!p) return MTLERR_OM;
-	return push(PNTTOVAL(p));
+    intptr_t* p=mallocClear(size);
+    if (!p)
+    {
+        return MTLERR_OM;
+    }
+    return push(PNTTOVAL(p));
 }
 
-inline int Memory::pushstring(const char* src)
+inline intptr_t Memory::pushstring(const char* src)
 {
-	int* p=storestring(src); if (!p) return MTLERR_OM;
-	return push(PNTTOVAL(p));
+    intptr_t* p=storestring(src);
+    if (!p)
+    {
+        return MTLERR_OM;
+    }
+    return push(PNTTOVAL(p));
 }
 
-inline int Memory::pushbinary(const char* src,int size)
+inline intptr_t Memory::pushbinary(char* src,int size)
 {
-	int* p=storebinary(src,size); if (!p) return MTLERR_OM;
-	return push(PNTTOVAL(p));
+    intptr_t* p=storebinary(src,size);
+    if (!p)
+    {
+        return MTLERR_OM;
+    }
+    return push(PNTTOVAL(p));
 }
 
-inline int Memory::pushnosrc(int size)
+inline intptr_t Memory::pushnosrc(int size)
 {
-	int* p=storenosrc(size); if (!p) return MTLERR_OM;
-	return push(PNTTOVAL(p));
+    intptr_t* p=storenosrc(size);
+    if (!p)
+    {
+        return MTLERR_OM;
+    }
+    return push(PNTTOVAL(p));
 }
 
-inline int Memory::pushpnt(void* pnt)
+inline intptr_t Memory::pushpnt(void* pnt)
 {
-	int* p=malloc(1,TYPE_BINARY); if (!p) return MTLERR_OM;
-	*(BINSTART(p))=(int)pnt;
-	return push(PNTTOVAL(p));
+    intptr_t* p=malloc(1,TYPE_BINARY);
+    if (!p)
+    {
+        return MTLERR_OM;
+    }
+    *(BINSTART(p))=((intptr_t)pnt);
+    return push(PNTTOVAL(p));
 }
 
 #endif

data/{bytecode/src/mtl → ext/mtl_linux/inc}/vcomp/parser.h

@@ -20,43 +20,43 @@ class Memory;
 class Parser
 {
 private :
-	Terminal* term;
-	char* srcname;	// nom de la source
-	char* src;	// buffer source
-	int index;	// index de lecture
+    Terminal* term;
+    char* srcname;	// nom de la source
+    char* src;	// buffer source
+    int index;	// index de lecture
 
-	char savedchar;	// caract�re sauvegard� (momentan�ment remplac� par \0)
-	int indexsavedchar; //index du caract�re sauvegard�
+    char savedchar;	// caract�re sauvegard� (momentan�ment remplac� par \0)
+    int indexsavedchar; //index du caract�re sauvegard�
 
-	int again;   // token a relire
-	int lign;       // ligne courante
-	int offligne;   // offset caractere debut ligne
+    int again;   // token a relire
+    int lign;       // ligne courante
+    int offligne;   // offset caractere debut ligne
 
-	int lign0;      // ligne courante (DERNIER TOKEN LU)
-	int offligne0;  // offset caractere debut ligne (DERNIER TOKEN LU)
-	int offchar0;   // offset caractere courant (DERNIER TOKEN LU)
+    int lign0;      // ligne courante (DERNIER TOKEN LU)
+    int offligne0;  // offset caractere debut ligne (DERNIER TOKEN LU)
+    int offchar0;   // offset caractere courant (DERNIER TOKEN LU)
 
 
-	void savechar(int i);
-	void restorechar();
-	void againchar();
-	int nextchar();
-	int gettoken(int filter);
+    void savechar(int i);
+    void restorechar();
+    void againchar();
+    int nextchar();
+    int gettoken(int filter);
 
 public :
-	char* token;
-	Parser(Terminal* t,FileSystem* fs,const char *filename);
-	Parser(Terminal* t,const char *buffer);
-	~Parser();
+    char* token;
+    Parser(Terminal* t,FileSystem* fs,char *filename);
+    Parser(Terminal* t,const char *buffer);
+    ~Parser();
 
-	char* next(int filter);
-	void giveback();
+    char* next(int filter);
+    void giveback();
 
-	void echoposition();
+    void echoposition();
 
-	int parsekeyword(const char* keyword);
-	int parsekeyword(const char* keyword,int filter);
-	int getstring(Memory* m,char separator);
+    int parsekeyword(const char* keyword);
+    int parsekeyword(const char* keyword,int filter);
+    int getstring(Memory* m,char separator);
 };
 
 

data/ext/mtl_linux/inc/vcomp/prodbuffer.h

@@ -0,0 +1,42 @@
+//-------------------
+// MV
+// version WIN32 et POCKETPC
+// Sylvain Huet
+// Premiere version : 07/01/2003
+// Derniere mise a jour : 07/01/2003
+//
+
+#ifndef _PRODBUFFER_
+#define _PRODBUFFER_
+
+class Prodbuffer
+{
+//public:
+private:
+    int size; // taille du buffer de bytecode
+    char* buffer; // buffer de bytecode
+    int index; // index du buffer de bytecode
+
+    void bigger(); // augmentation de la taille du buffer
+
+public:
+    // buffer bytecode
+    Prodbuffer();
+    ~Prodbuffer();
+    void reinit();
+    void addchar(char c);
+    void addint(int i);
+    void addshort(int i);
+    void setchar(int index,char c);
+    void setint(int index,int i);
+    void setshort(int index,int i);
+    void addstr(char *src,int len);
+    void printf(const char *format, ...);
+    void cut(int len);
+    int getsize();
+    char* getstart();
+};
+
+#define PRODBUFFER_FIRSTSIZE 128
+
+#endif

data/{bytecode/src/mtl → ext/mtl_linux/inc}/vcomp/resource.h

@@ -6,7 +6,7 @@
 #define IDI_ICON2                       103
 
 // Next default values for new objects
-// 
+//
 #ifdef APSTUDIO_INVOKED
 #ifndef APSTUDIO_READONLY_SYMBOLS
 #define _APS_NEXT_RESOURCE_VALUE        104

data/{bytecode/src/mtl → ext/mtl_linux/inc}/vcomp/terminal.h

@@ -15,16 +15,16 @@ class Memory;
 class Terminal
 {
 private:
-	char* internalbuffer;
-	int	sizeinternalbuffer;
+    char* internalbuffer;
+    int	sizeinternalbuffer;
 public:
-	Memory* m;
-	Terminal();
-	~Terminal();
+    Memory* m;
+    Terminal();
+    ~Terminal();
 
-	void echo(int mask,char *s);
-	void echo(int mask,char *s,int size);
-	void printf(int mask,const char *format, ...);
+    void echo(int mask,char *s);
+    void echo(int mask,char *s,int size);
+    void printf(int mask,const char *format, ...);
 };
 
 #endif

data/{bytecode/src/mtl → ext/mtl_linux/inc}/vcomp/util.h

@@ -18,14 +18,14 @@ class Interpreter;
 class Util
 {
 private :
-	Memory* m;
+    Memory* m;
 public:
-	Util(Memory* mem);
-	~Util();
-	int start();
-	void stop();
+    Util(Memory* mem);
+    ~Util();
+    int start();
+    void stop();
 
-	Compiler* compiler;
-	Interpreter* interpreter;
+    Compiler* compiler;
+    Interpreter* interpreter;
 };
 #endif

data/{bytecode/src/mtl → ext/mtl_linux/inc/vm}/vbc.h

@@ -156,5 +156,5 @@
 #define OPrfidWrite 149
 #define OPi2cRead 150
 #define OPi2cWrite 151
-
+#define OPstrright 152
 #endif // ! VBC_H_