nabaztag_hack_kit 0.0.2

data/ext/mtl/vcomp/compiler_var.cpp

@@ -0,0 +1,289 @@
+//-------------------
+// MV
+// version WIN32 et POCKETPC
+// Sylvain Huet
+// Derniere mise a jour : 07/01/2003
+//
+
+#include <stdio.h>
+#include <string.h>
+
+#include "param.h"
+#include "terminal.h"
+#include "memory.h"
+#include "parser.h"
+#include "prodbuffer.h"
+#include "compiler.h"
+#include "interpreter.h"
+
+
+int Compiler::parseval()
+{
+	int k;
+	
+	if (k=parseval3()) return k;
+	
+	if (!parser->next(0)) return 0;
+	if (strcmp(parser->token,"::"))
+    {
+		parser->giveback();
+		return 0;
+    }
+	if (k=parseval()) return k;	// r�cursion
+
+	if (k=createnodetype(TYPENAME_LIST)) return k;
+	if (k=createnodetype(TYPENAME_UNDEF)) return k;	// noeud �lement
+	TABSET(m,VALTOPNT(STACKGET(m,1)),TYPEHEADER_LENGTH,STACKGET(m,0));	// attachement du noeud �l�ment au noeud list
+	if (k=unif(VALTOPNT(STACKGET(m,0)),VALTOPNT(STACKGET(m,4)))) return k;	// unification �lement
+	if (k=unif(VALTOPNT(STACKGET(m,1)),VALTOPNT(STACKGET(m,2)))) return k;	// unification list
+	STACKSET(m,4,STACKGET(m,1));	// remplacement du type
+
+	int* p=MALLOCCLEAR(m,LIST_LENGTH);	// cr�ation du tuple liste
+	if (!p) return MTLERR_OM;
+	TABSET(m,p,LIST_VAL,STACKGET(m,5));
+	TABSET(m,p,LIST_NEXT,STACKGET(m,3));
+	STACKSET(m,5,PNTTOVAL(p));
+	STACKDROPN(m,4);
+	return 0;
+}
+
+
+int Compiler::parseval3()
+{
+	int k,op,typ;
+	
+	if (k=parseval4()) return k;
+	while(1)
+    {
+		if (!parser->next(0)) return 0;
+		if (!strcmp(parser->token,"+")) { op=OPadd; typ=1;}
+		else if (!strcmp(parser->token,"-")) { op=OPsub; typ=1;}
+		else
+		{
+			parser->giveback();
+			return 0;
+		}
+		if (k=parseval4()) return k;
+		if (op==OPadd) STACKSET(m,3,INTTOVAL(VALTOINT(STACKGET(m,3))+VALTOINT(STACKGET(m,1))));
+		else if (op==OPsub) STACKSET(m,3,INTTOVAL(VALTOINT(STACKGET(m,3))-VALTOINT(STACKGET(m,1))));
+		int* ptyp;
+		if (typ==1) ptyp=VALTOPNT(TABGET(stdtypes,STDTYPE_I));
+		if (k=unif(VALTOPNT(STACKGET(m,0)),ptyp)) return k;
+		if (k=unif(VALTOPNT(STACKGET(m,2)),ptyp)) return k;
+		STACKDROPN(m,2);
+    }
+}
+
+int Compiler::parseval4()
+{
+	int k,op,typ;
+	
+	if (k=parseval5()) return k;
+	while(1)
+    {
+		if (!parser->next(0)) return 0;
+		if (!strcmp(parser->token,"*")) { op=OPmul; typ=1;}
+		else if (!strcmp(parser->token,"/")) { op=OPdiv; typ=1;}
+		else if (!strcmp(parser->token,"%")) { op=OPmod; typ=1;}
+		else
+		{
+			parser->giveback();
+			return 0;
+		}
+		if (k=parseval5()) return k;
+
+		if (op==OPmul) STACKSET(m,3,INTTOVAL(VALTOINT(STACKGET(m,3))*VALTOINT(STACKGET(m,1))));
+		else if (op==OPdiv)
+		{
+			if (VALTOINT(STACKGET(m,1))==0) return MTLERR_DIV;
+			STACKSET(m,3,INTTOVAL(VALTOINT(STACKGET(m,3))/VALTOINT(STACKGET(m,1))));
+		}
+		else if (op==OPmod) STACKSET(m,3,INTTOVAL(VALTOINT(STACKGET(m,3))%VALTOINT(STACKGET(m,1))));
+		int* ptyp;
+		if (typ==1) ptyp=VALTOPNT(TABGET(stdtypes,STDTYPE_I));
+		if (k=unif(VALTOPNT(STACKGET(m,0)),ptyp)) return k;
+		if (k=unif(VALTOPNT(STACKGET(m,2)),ptyp)) return k;
+		STACKDROPN(m,2);
+    }
+}
+
+int Compiler::parseval5()
+{
+	int k,op;
+	
+	if (k=parseval6()) return k;
+	while(1)
+    {
+		if (!parser->next(0)) return 0;
+		if (!strcmp(parser->token,"&")) op=OPand;
+		else if (!strcmp(parser->token,"|")) op=OPor;
+		else if (!strcmp(parser->token,"^")) op=OPeor;
+		else if (!strcmp(parser->token,"<<")) op=OPshl;
+		else if (!strcmp(parser->token,">>")) op=OPshr;
+		else
+		{
+			parser->giveback();
+			return 0;
+		}
+		if (k=parseval6()) return k;
+
+		if (op==OPand) STACKSET(m,3,INTTOVAL(VALTOINT(STACKGET(m,3))&VALTOINT(STACKGET(m,1))));
+		else if (op==OPor) STACKSET(m,3,INTTOVAL(VALTOINT(STACKGET(m,3))|VALTOINT(STACKGET(m,1))));
+		else if (op==OPeor) STACKSET(m,3,INTTOVAL(VALTOINT(STACKGET(m,3))^VALTOINT(STACKGET(m,1))));
+		else if (op==OPshl) STACKSET(m,3,INTTOVAL(VALTOINT(STACKGET(m,3))<<VALTOINT(STACKGET(m,1))));
+		else if (op==OPshr) STACKSET(m,3,INTTOVAL(VALTOINT(STACKGET(m,3))>>VALTOINT(STACKGET(m,1))));
+
+		int* ptyp=VALTOPNT(TABGET(stdtypes,STDTYPE_I));
+		if (k=unif(VALTOPNT(STACKGET(m,0)),ptyp)) return k;
+		if (k=unif(VALTOPNT(STACKGET(m,2)),ptyp)) return k;
+		STACKDROPN(m,2);
+    }
+}
+
+int Compiler::parseval6()
+{
+	int k;
+
+	if (!parser->next(0)) return parseval7();
+	
+	if (!strcmp(parser->token,"-"))
+	{
+		if (!parser->next(0)) return parseval6();
+		if (isdecimal(parser->token))	// gestion des entiers
+		{
+			int i=-mtl_atoi(parser->token);
+			if (k=STACKPUSH(m,INTTOVAL(i))) return k;
+			return STACKPUSH(m,TABGET(stdtypes,STDTYPE_I));
+		}
+		parser->giveback();
+		if (k=parseval6()) return k;
+		STACKSET(m,1,INTTOVAL(-VALTOINT(STACKGET(m,0))));
+		return unif(VALTOPNT(STACKGET(m,0)),VALTOPNT(TABGET(stdtypes,STDTYPE_I)));
+	}
+	else if (!strcmp(parser->token,"~"))
+	{
+		if (k=parseval6()) return k;
+		STACKSET(m,1,INTTOVAL(~VALTOINT(STACKGET(m,0))));
+		return unif(VALTOPNT(STACKGET(m,0)),VALTOPNT(TABGET(stdtypes,STDTYPE_I)));
+	}
+	parser->giveback();
+	return parseval7();
+}
+
+
+int Compiler::parseval7()
+{
+	int k;
+
+	if (!parser->next(0))
+	{
+		PRINTF(m)(LOG_COMPILER,"Compiler : term expected (found EOF)\n");
+		return MTLERR_SN;
+	}
+	if (!strcmp(parser->token,"("))	// gestion des parenth�ses
+	{
+		if (k=parseval()) return k;
+		return parser->parsekeyword(")");
+	}
+	else if (!strcmp(parser->token,"["))	// gestion des tuples
+	{
+		int nval=0;
+		if (k=STACKPUSH(m,NIL)) return k;	// valeur finale
+		if (k=STACKPUSH(m,NIL)) return k;	// type final
+		int sref=STACKREF(m);
+		while(1)
+		{
+			if (!parser->next(0))
+			{
+				PRINTF(m)(LOG_COMPILER,"Compiler : ']' expected (found EOF)\n");
+				return MTLERR_SN;
+			}
+			if (!strcmp(parser->token,"]"))
+			{
+				int* p=MALLOCCLEAR(m,nval);	// cr�ation du tuple liste
+				if (!p) return MTLERR_OM;
+				int i;
+				for(i=0;i<nval;i++) TABSET(m,p,i,STACKGET(m,(nval-i)*2-1));
+				STACKSETFROMREF(m,sref,1,PNTTOVAL(p));
+				if (k=createnodetupleval(nval)) return k;
+				STACKSETFROMREF(m,sref,0,STACKPULL(m));
+				STACKRESTOREREF(m,sref);
+				return 0;
+			}
+			parser->giveback();
+			if (k=parseval()) return k;
+			nval++;
+		}
+	}
+	else if (!strcmp(parser->token,"{"))	// gestion des tableaux
+	{
+		int nval=0;
+		if (k=STACKPUSH(m,NIL)) return k;	// valeur finale
+		if (k=createnodetype(TYPENAME_TAB)) return k;	// type final
+		if (k=createnodetype(TYPENAME_UNDEF)) return k;
+		TABSET(m,VALTOPNT(STACKGET(m,1)),TYPEHEADER_LENGTH,STACKGET(m,0));
+		int* p=VALTOPNT(STACKPULL(m));
+
+		while(1)
+		{
+			if (!parser->next(0))
+			{
+				PRINTF(m)(LOG_COMPILER,"Compiler : '}' expected (found EOF)\n");
+				return MTLERR_SN;
+			}
+			if (!strcmp(parser->token,"}"))
+			{
+
+				if (k=DEFTAB(m,nval)) return k;
+
+				STACKSET(m,2,STACKGET(m,0));	// report de la valeur du tableau
+				STACKDROP(m);
+				return 0;
+			}
+			parser->giveback();
+			if (k=parseval()) return k;
+			if (k=unif(VALTOPNT(STACKGET(m,0)),p)) return k;
+			STACKDROP(m);
+			nval++;
+		}
+	}
+	else if (!strcmp(parser->token,"nil"))	// gestion du nil
+	{
+		if (k=STACKPUSH(m,NIL)) return k;	// valeur
+		return createnodetype(TYPENAME_WEAK);
+	}
+	else if (!strcmp(parser->token,"'"))	// gestion des 'char
+	{
+		if (!parser->next(0))
+		{
+			PRINTF(m)(LOG_COMPILER,"Compiler : 'char expected (found EOF)\n");
+			return MTLERR_SN;
+		}
+		if (k=STACKPUSH(m,INTTOVAL(parser->token[0]&255))) return k;	// valeur
+		if (k=parser->parsekeyword("'")) return k;
+		return STACKPUSH(m,TABGET(stdtypes,STDTYPE_I));
+	}
+	else if (isdecimal(parser->token))	// gestion des entiers
+	{
+		int i=mtl_atoi(parser->token);
+		if (k=STACKPUSH(m,INTTOVAL(i))) return k;	// valeur
+		return STACKPUSH(m,TABGET(stdtypes,STDTYPE_I));
+	}
+	else if ((parser->token[0]=='0')&&(parser->token[1]=='x')
+		&&(ishexadecimal(parser->token+2)))	// gestion des entiers
+	{
+		int i=mtl_htoi(parser->token+2);
+		if (k=STACKPUSH(m,INTTOVAL(i))) return k;	// valeur
+		return STACKPUSH(m,TABGET(stdtypes,STDTYPE_I));
+	}
+	else if (parser->token[0]=='"')	// gestion des chaines
+	{
+		if (k=parser->getstring(m,'"')) return k;
+		return STACKPUSH(m,TABGET(stdtypes,STDTYPE_S));
+	}
+	else
+	{
+		PRINTF(m)(LOG_COMPILER,"Compiler : unexpected term '%s'\n",parser->token);
+		return MTLERR_SN;
+	}
+}

data/ext/mtl/vcomp/file.cpp

@@ -0,0 +1,79 @@
+//-------------------
+// Moteur 3d
+// version WIN32 et POCKETPC
+// Sylvain Huet
+// Premiere version : 03/09/2002
+// Derniere mise a jour : 05/10/2002
+//
+
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+
+#include "param.h"
+#include "filesystem.h"
+#include "file.h"
+
+///////////////
+// File - gestion simple de fichiers
+
+
+File::File(FileSystem *fs)
+{
+	filesystem=fs;
+	file=NULL;
+	sizeinternalbuffer=64;
+	internalbuffer=new char[sizeinternalbuffer];
+}
+
+File::~File()
+{
+	if (file) fclose(file);
+	delete internalbuffer;
+}
+
+int File::close()
+{
+	if (file) fclose(file);
+	file=NULL;
+	return 0;
+}
+
+
+int File::openread(const char* name)
+{
+	file=fopen(name,"rb");
+	if (file) return 0;
+	return -1;
+}
+
+char* File::getcontent(int *size)
+{
+	if (file==NULL) return NULL;
+
+	fseek(file,0,SEEK_END);
+	*size=ftell(file);
+	fseek(file,0,SEEK_SET);
+
+	char* buffer;
+	buffer=new char[(*size)+1];
+	fread((void*)buffer,1,*size,file);
+	buffer[*size]=0;
+	close();
+	return buffer;
+}
+int File::openwrite(const char* name)
+{
+	file=fopen(name,"wb");
+	if (file) return 0;
+	return -1;
+}
+int File::write(const char *outbuf,int size)
+{
+	if (file==NULL) return 0;
+
+	int k=fwrite((void*)outbuf,1,size,file);
+	if (k<0) return -1;
+	fflush(file);
+	return 0;
+}

data/ext/mtl/vcomp/file.h

@@ -0,0 +1,39 @@
+//-------------------
+// Moteur 3d
+// version WIN32 et POCKETPC
+// Sylvain Huet
+// Premiere version : 03/09/2002
+// Derniere mise a jour : 05/10/2002
+//
+
+
+
+#ifndef _FILE_
+#define _FILE_
+
+// commenter pour utiliser les fichiers windows
+#include <stdio.h>
+
+class FileSystem;
+
+class File
+{
+private :
+	FileSystem *filesystem;
+	FILE *file;
+	char* internalbuffer;
+	int	sizeinternalbuffer;
+public:
+	File(FileSystem *fs);
+	~File();
+
+	int openread(const char* name);
+	char* getcontent(int *size);
+
+	int openwrite(const char* name);
+	int write(const char* outbuf,int size);
+
+	int close();
+
+};
+#endif

data/ext/mtl/vcomp/filesystem.h

@@ -0,0 +1,14 @@
+//-------------------
+// Moteur 3d
+// version WIN32 et POCKETPC
+// Sylvain Huet
+// Premiere version : 03/09/2002
+// Derniere mise a jour : 05/10/2002
+//
+
+
+
+#ifndef _FILESYSTEM_
+#define _FILESYSTEM_
+class FileSystem;
+#endif

data/ext/mtl/vcomp/interpreter.cpp

@@ -0,0 +1,85 @@
+//-------------------
+// MV
+// version WIN32 et POCKETPC
+// Sylvain Huet
+// Premiere version : 07/01/2003
+// Derniere mise a jour : 07/01/2003
+//
+
+#include <stdio.h>
+#include <string.h>
+
+#include "param.h"
+#include "terminal.h"
+#include "prodbuffer.h"
+#include "memory.h"
+#include "util.h"
+#include "interpreter.h"
+#include "compiler.h"
+
+#include"../vbc_str.h"
+
+void displaybc(Memory* m,char* p)
+{
+	PRINTF(m)(LOG_DEVCORE,"dump %x\n",p);
+	const char* spaces="         ";
+	int ind=0;
+	while(1)
+	{
+		int i=*p;
+		if ((i<0)||(i>=MaxOpcode)) PRINTF(m)(LOG_DEVCORE,"%4d   ??\n",ind);
+		else if ((i==OPint))
+		{
+			p++;
+			int v=(p[0]&255)+((p[1]&255)<<8)+((p[2]&255)<<16)+((p[3]&255)<<24);
+			PRINTF(m)(LOG_DEVCORE,"%4d   %s%s %d\n",ind,strbytecod[i],spaces+strlen(strbytecod[i]),v);
+			ind+=4;
+			p+=3;
+		}
+		else if ((i==OPgoto)||(i==OPelse))
+		{
+			p++;
+			int v=(p[0]&255)+((p[1]&255)<<8);
+			PRINTF(m)(LOG_DEVCORE,"%4d   %s%s %d\n",ind,strbytecod[i],spaces+strlen(strbytecod[i]),v);
+			ind+=2;
+			p+=1;
+		}		else if ((i==OPgetlocalb)||(i==OPgetglobalb)||(i==OPfetchb)||(i==OPdeftabb)||(i==OPsetlocalb)||
+			(i==OPmktabb)||(i==OPsetstructb)||(i==OPcallrb)||(i==OPintb))
+		{
+			p++;
+			int v=p[0]&255;
+			PRINTF(m)(LOG_DEVCORE,"%4d   %s%s %d\n",ind,strbytecod[i],spaces+strlen(strbytecod[i]),v);
+			ind++;
+		}
+		else if (i==OPret)
+		{
+			PRINTF(m)(LOG_DEVCORE,"%4d   %s%s\n",ind,strbytecod[i],spaces+strlen(strbytecod[i]));
+			return;
+		}
+		else PRINTF(m)(LOG_DEVCORE,"%4d   %s%s\n",ind,strbytecod[i],spaces+strlen(strbytecod[i]));
+	ind++;
+	p++;
+	}
+}
+
+
+Interpreter::Interpreter(Memory* memory)
+{
+	m=memory;
+	output=new Prodbuffer();
+};
+
+Interpreter::~Interpreter()
+{
+	delete output;
+};
+
+int Interpreter::start()
+{
+	return 0;
+}
+
+void Interpreter::stop()
+{
+}
+

data/ext/mtl/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"../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