// compilation d'une variable
// [name] -> 0
int Compiler::parsevar()
{
int k;
int hasvalue = 0;
if (!parser->next(0))
{
PRINTF(m)(LOG_COMPILER,"Compiler : ';;' expected (found EOF)\n");
return MTLERR_SN;
}
if (!strcmp(parser->token,"="))
{
if (k=parseval()) return k;
hasvalue = 1;
}
else
{
parser->giveback();
if (k=STACKPUSH(m,NIL)) return k;
if (k=createnodetype(TYPENAME_WEAK)) return k;
}
// [val type name]
if (k=parser->parsekeyword(";;")) return k;
int val=INTTOVAL(nblabels(globals));
if (k=addlabel(globals,STRSTART(VALTOPNT(STACKGET(m,2))),val,STACKGET(m,1))) return k; // enregistrement d'une nouvelle globale
// on crée le bloc fonction
newref=MALLOCCLEAR(m,REF_LENGTH);
if (!newref) return MTLERR_OM;
TABSET(m,newref,REF_TYPE,STACKPULL(m));
TABSET(m,newref,REF_VAL,STACKPULL(m));
TABSET(m,newref,REF_NAME,STACKPULL(m));
TABSET(m,newref,REF_CODE,INTTOVAL(CODE_VAR));
// la variable vient d'être créé, elle n'est donc ni utilisée ni modifiée encore
TABSET(m,newref,REF_USED,INTTOVAL(0));
TABSET(m,newref,REF_SET,INTTOVAL(hasvalue));
TABSET(m,newref,REF_USED_IN_IFDEF,INTTOVAL(0));
TABSET(m,newref,REF_PACKAGE,val);
if (k=STACKPUSH(m,PNTTOVAL(newref))) return MTLERR_OM; // [newref]
addreftopackage(newref,newpackage);
STACKDROP(m);
outputbuf->reinit();
outputbuf->printf("Compiler : var %s : ",STRSTART(VALTOPNT(TABGET(newref,REF_NAME))));
echograph(outputbuf,VALTOPNT(TABGET(newref,REF_TYPE)));
PRINTF(m)(LOG_COMPILER,"%s\n",outputbuf->getstart());
return 0;
}
void netScan_(struct rt2501_scan_result *scan_result, void *userparam)
{
char buf[256];
sprintf(buf,">>> %s %d %d %d %d\n",scan_result->ssid,scan_result->rssi,scan_result->channel,scan_result->rateset,scan_result->encryption);
consolestr((UBYTE*)buf);
VPUSH(PNTTOVAL(VMALLOCSTR(scan_result->ssid,strlen(scan_result->ssid))));
VPUSH(PNTTOVAL(VMALLOCSTR((char*)scan_result->mac,6)));
VPUSH(PNTTOVAL(VMALLOCSTR((char*)scan_result->bssid,6)));
VPUSH(INTTOVAL(scan_result->rssi));
VPUSH(INTTOVAL(scan_result->channel));
VPUSH(INTTOVAL(scan_result->rateset));
VPUSH(INTTOVAL(scan_result->encryption));
VMKTAB(7);
nscan++;
}
int Compiler::parseifdef(int ifndef)
{
int k;
if (!parser->next(0))
{
PRINTF(m)(LOG_COMPILER,"Compiler : label expected (found EOF)\n");
return MTLERR_SN;
}
if (!islabel(parser->token))
{
PRINTF(m)(LOG_COMPILER,"Compiler : label expected (found '%s')\n",parser->token);
return MTLERR_SN;
}
int first=1;
int *ref, *type;
if ((!(ref = searchref(PNTTOVAL(newpackage),parser->token)))&&(!(type = searchtype(PNTTOVAL(newpackage),parser->token))))
first=0;
// si c'est une variable on note qu'elle est utlilisé dans un ifdef
// ça nous permet de savoir, plus tard, si elle est seulement
// utilisée dans un/des ifdef - dans ce cas elle n'a pas besoin de
// valeur - ou aussi autre part - dans ce cas elle a besoin d'être
// settée au moins une fois.
if (ref)
{
int curval = VALTOINT(TABGET(ref,REF_USED_IN_IFDEF));
TABSET(m,ref,REF_USED_IN_IFDEF,INTTOVAL(curval+1));
}
if (ifndef) first=!first;
if (k=parser->parsekeyword("{")) return k;
if (first)
{
parsefile(1);
if (k=parser->parsekeyword("}")) return k;
}
else if (k=skipifdef()) return k;
if (!parser->next(0)) return 0;
if (strcmp(parser->token,"else"))
{
parser->giveback();
return 0;
}
else
{
if (k=parser->parsekeyword("{")) return k;
if (!first)
{
parsefile(1);
if (k=parser->parsekeyword("}")) return k;
}
else if (k=skipifdef()) return k;
}
return 0;
}
/**
Gère un evt write sur une socket
*/
int tcpEventWrite(int fd)
{
int idx = tcpbysock(fd);
if (idx<0) {
my_printf(LOG_SIMUNET, "Sockets : idx < 0\n");
return 0;
}
tcp_writeEventToNotify[idx] = 0;
my_printf(LOG_SIMUNET, "Sockets : Write event on %d\n",idx);
VPUSH(INTTOVAL(idx));
VPUSH(INTTOVAL(0));
VPUSH(NIL);
VPUSH(VCALLSTACKGET(sys_start,SYS_CBTCP));
if (VSTACKGET(0)!=NIL) interpGo();
else { VPULL();VPULL();VPULL();}
VPULL();
return 1;
}
int sysFind(char *dst,int i,int ldst,char *src,int j,int lsrc,int len)
{
if ((j<0)||(j+len>lsrc)) return NIL;
src+=j;
if (i<0) i=0;
while(i+len<=ldst)
{
if (!mystrcmp(dst+i,src,len)) return INTTOVAL(i);
i++;
}
return NIL;
}
int sysFindrev(char *dst,int i,int ldst,char *src,int j,int lsrc,int len)
{
if ((j<0)||(j+len>lsrc)) return NIL;
src+=j;
if(i+len>ldst) i=ldst-len;
while(i>=0)
{
if (!mystrcmp(dst+i,src,len)) return INTTOVAL(i);
i--;
}
return NIL;
}
int main(int argc,char **argv)
{
PropLoad("config.txt");
if (!handle_options(argc, argv))
{
return -1;
}
PropDump();
if (!vcompDoit(PropGet("SOURCE")))
{
loadbytecode("foo.bin");
vmemInit(0);
if (!strcmp(PropGet("BOOT"),"firmware"))
{
loaderInit((char*)dumpbc);
}
else
{
loaderInit(srcbytecode);
}
vmemDumpShort();
getchar();
simuInit();
VPUSH(INTTOVAL(0));
interpGo();
VPULL();
while(1)
{
simuDoLoop();
VPUSH(VCALLSTACKGET(sys_start,SYS_CBLOOP));
if (VSTACKGET(0)!=NIL)
{
interpGo();
}
VPULL();
usleep(50 * 1000);
}
getchar();
}
return 0;
}
// compilation d'une constante (const var = val;;)
// [name] -> 0
int Compiler::parseconst()
{
int k;
if (k=parser->parsekeyword("=")) return k;
if (k=parseval()) return k;
if (k=parser->parsekeyword(";;")) return k;
int val=INTTOVAL(nblabels(globals));
if (k=addlabel(globals,STRSTART(VALTOPNT(STACKGET(m,2))),val,STACKGET(m,1))) return k; // enregistrement d'une nouvelle globale
// on crée le bloc fonction
newref=MALLOCCLEAR(m,REF_LENGTH);
if (!newref) return MTLERR_OM;
TABSET(m,newref,REF_TYPE,STACKPULL(m));
TABSET(m,newref,REF_VAL,STACKPULL(m));
TABSET(m,newref,REF_NAME,STACKPULL(m));
TABSET(m,newref,REF_CODE,INTTOVAL(CODE_CONST));
// la constante vient d'être créée, elle n'est donc pas utilisée, mais elle a une valeur
TABSET(m,newref,REF_USED,INTTOVAL(0));
TABSET(m,newref,REF_SET,INTTOVAL(1));
TABSET(m,newref,REF_USED_IN_IFDEF,INTTOVAL(0));
TABSET(m,newref,REF_PACKAGE,val);
if (k=STACKPUSH(m,PNTTOVAL(newref))) return MTLERR_OM; // [newref]
addreftopackage(newref,newpackage);
STACKDROP(m);
outputbuf->reinit();
outputbuf->printf("Compiler : const %s : ",STRSTART(VALTOPNT(TABGET(newref,REF_NAME))));
echograph(outputbuf,VALTOPNT(TABGET(newref,REF_TYPE)));
PRINTF(m)(LOG_COMPILER,"%s\n",outputbuf->getstart());
return 0;
}
/**
UDPEventRead
*/
int udpEventRead(int fd)
{
char buf[4096];
struct sockaddr_in add;
int i=udpbysock(fd);
int l=sizeof(add);
int res=recvfrom(fd,buf,4096,0,(struct sockaddr *)&add,&l);
if (res<0) return 1;
my_printf(LOG_SIMUNET, "Sockets : UDP Read %d bytes on :%d from %s:%d\n",res,udp_port[i],inet_ntoa(add.sin_addr),ntohs(add.sin_port));
VPUSH(INTTOVAL(i));
VPUSH(PNTTOVAL(VMALLOCSTR(buf,res)));
VPUSH(PNTTOVAL(VMALLOCSTR((char*)&add.sin_addr.s_addr,4)));
VPUSH(VCALLSTACKGET(sys_start,SYS_CBUDP));
if (VSTACKGET(0)!=NIL) interpGo();
else { VPULL();VPULL();VPULL();}
VPULL();
return 1;
}
// compilation d'un type
// [name] -> 0
int Compiler::parsetype()
{
int k;
// PRINTF(m)(LOG_DEVCORE,"type %s\n",STRSTART(VALTOPNT(STACKGET(m,0))));
char* name=STRSTART(VALTOPNT(STACKGET(m,0)));
// création des variables de travail
if (k=STACKPUSH(m,NIL)) return k; // LOCALS
locals=STACKREF(m);
newref=searchemptytype(PNTTOVAL(newpackage),name);
int mergetype=1;
if (newref)
{
if (k=createnodetypecore(TABGET(VALTOPNT(TABGET(newref,REF_TYPE)),TYPEHEADER_LENGTH+1))) return k;
}
else
{
mergetype=0;
if (k=createnodetypecore(STACKGET(m,1))) return k;
newref=MALLOCCLEAR(m,REF_LENGTH);
if (!newref) return MTLERR_OM;
TABSET(m,newref,REF_CODE,INTTOVAL(CODE_EMPTYTYPE));
TABSET(m,newref,REF_TYPE,STACKGET(m,0));
if (k=STACKPUSH(m,PNTTOVAL(newref))) return MTLERR_OM; // [newtyp local name]
addreftopackage(newref,newpackage);
STACKDROP(m);
}
int narg=0;
if (parser->next(0))
{
if (strcmp(parser->token,"(")) parser->giveback();
else
{
do
{
if (!parser->next(0))
{
PRINTF(m)(LOG_COMPILER,"Compiler : parameter or ')' expected (found EOF)\n");
return MTLERR_SN;
}
if (islabel(parser->token))
{
if (k=createnodetype(TYPENAME_UNDEF)) return k;
if (k=addlabel(locals,parser->token,STACKGET(m,0),INTTOVAL(narg++))) return k;
}
else if (strcmp(parser->token,")"))
{
PRINTF(m)(LOG_COMPILER,"Compiler : parameter or ')' expected (found '%s')\n",parser->token);
return MTLERR_SN;
}
} while(strcmp(parser->token,")"));
if (k=DEFTAB(m,narg)) return k;
TABSET(m,VALTOPNT(STACKGET(m,1)),TYPEHEADER_LENGTH,STACKGET(m,0));
STACKDROP(m);
}
}
if (!mergetype) STACKDROP(m);
else if (k=unif(VALTOPNT(STACKPULL(m)),VALTOPNT(TABGET(newref,REF_TYPE)))) return k;
if (!parser->next(0))
{
PRINTF(m)(LOG_COMPILER,"Compiler : '=' or ';;' expected (found EOF)\n");
return MTLERR_SN;
}
if (!strcmp(parser->token,"="))
{
if (!parser->next(0))
{
PRINTF(m)(LOG_COMPILER,"Compiler : uncomplete type definition (found EOF)\n");
return MTLERR_SN;
}
if (!strcmp(parser->token,"[")) return parsestruct();
parser->giveback();
return parsesum();
}
else if (!strcmp(parser->token,";;"))
{
STACKDROPN(m,2);
outputbuf->reinit();
outputbuf->printf("Compiler : uncompleted type : ");
echograph(outputbuf,VALTOPNT(TABGET(newref,REF_TYPE)));
PRINTF(m)(LOG_COMPILER,"%s\n",outputbuf->getstart());
return 0;
}
PRINTF(m)(LOG_COMPILER,"Compiler : '=' or ';;' expected (found '%s')\n",parser->token);
return MTLERR_SN;
}
/**
Gère un evt read sur une socket
*/
int tcpEventRead(int fd)
{
/* soit une donnée à lire, soit un accept, soit un close */
/* accept si on l'attend, close si on lit 0 data, read sinon */
int idx = tcpbysock(fd);
if (idx < 0)
{
// TODO gérer l'erreur
return 0;
}
if (tcp_listen[idx])
{
// accept
struct sockaddr_in cor;
int ns;
int sizecor;
int ni,ip,port;
char buf[16];
tcp_listen[idx] = 0;
sizecor=sizeof(cor);
ns=accept(fd,(struct sockaddr*)&cor,&sizecor);
if (ns==-1) return 1;
ni=tcpgetfree();
if (ni<0)
{
close(ns);
return 1;
}
ip=cor.sin_addr.s_addr;
port=ntohs(cor.sin_port);
tcp_sock[ni]=ns;
my_printf(LOG_SIMUNET, "Sockets : accept Tcp from %x:%d (socket=%d)\n",ip,port,ns);
VPUSH(INTTOVAL(ni));
VPUSH(INTTOVAL(2));
sprintf(buf,"%d",idx);
VPUSH(PNTTOVAL(VMALLOCSTR(buf,strlen(buf))));
VPUSH(VCALLSTACKGET(sys_start,SYS_CBTCP));
if (VSTACKGET(0)!=NIL) interpGo();
else { VPULL();VPULL();VPULL();}
VPULL();
return 1;
}
// donnée ou close
else
{
char buf[2048];
int res;
if (!tcp_enable[idx])
{
// Sleep(10);
// recv(sock,buf,0,0);
// printf("disabled\n");
return 1;
}
my_printf(LOG_SIMUNET, "Sockets : Read event on %d\n",fd);
res=recv(fd,buf,2048,0);
helper_write_buffer(buf, res);
VPUSH(INTTOVAL(idx));
if (res>0)
{
VPUSH(INTTOVAL(1));
VPUSH(PNTTOVAL(VMALLOCSTR(buf,res)));
}
else
{
VPUSH(INTTOVAL(-1));
VPUSH(NIL);
}
VPUSH(VCALLSTACKGET(sys_start,SYS_CBTCP));
if (VSTACKGET(0)!=NIL) interpGo();
else { VPULL();VPULL();VPULL();}
VPULL();
return 1;
}
}
void netScan(char* ssid)
{
nscan=0;
#ifdef VSIMU
VPUSH(PNTTOVAL(VMALLOCSTR("foo",3)));
VPUSH(PNTTOVAL(VMALLOCSTR("xyzxyz",6)));
VPUSH(PNTTOVAL(VMALLOCSTR("765432",6)));
VPUSH(INTTOVAL(-20));
VPUSH(INTTOVAL(11));
VPUSH(INTTOVAL(1));
VPUSH(INTTOVAL(0));
VMKTAB(7);
nscan++;
VPUSH(PNTTOVAL(VMALLOCSTR("foo",3)));
VPUSH(PNTTOVAL(VMALLOCSTR("xyzxyz",6)));
VPUSH(PNTTOVAL(VMALLOCSTR("765432",6)));
VPUSH(INTTOVAL(-10));
VPUSH(INTTOVAL(11));
VPUSH(INTTOVAL(1));
VPUSH(INTTOVAL(0));
VMKTAB(7);
nscan++;
VPUSH(PNTTOVAL(VMALLOCSTR("zzzz",3)));
VPUSH(PNTTOVAL(VMALLOCSTR("xyzxyz",6)));
VPUSH(PNTTOVAL(VMALLOCSTR("765432",6)));
VPUSH(INTTOVAL(-10));
VPUSH(INTTOVAL(11));
VPUSH(INTTOVAL(1));
VPUSH(INTTOVAL(0));
VMKTAB(7);
nscan++;
VPUSH(PNTTOVAL(VMALLOCSTR("",3)));
VPUSH(PNTTOVAL(VMALLOCSTR("xyzxyz",6)));
VPUSH(PNTTOVAL(VMALLOCSTR("765432",6)));
VPUSH(INTTOVAL(-10));
VPUSH(INTTOVAL(11));
VPUSH(INTTOVAL(1));
VPUSH(INTTOVAL(0));
VMKTAB(7);
nscan++;
VPUSH(PNTTOVAL(VMALLOCSTR("a\"a<a'a a\\a",strlen("a\"a<a'a a\\a"))));
VPUSH(PNTTOVAL(VMALLOCSTR("xyzxyz",6)));
VPUSH(PNTTOVAL(VMALLOCSTR("765432",6)));
VPUSH(INTTOVAL(-10));
VPUSH(INTTOVAL(11));
VPUSH(INTTOVAL(1));
VPUSH(INTTOVAL(3));
VMKTAB(7);
nscan++;
VPUSH(PNTTOVAL(VMALLOCSTR("foo",3)));
VPUSH(PNTTOVAL(VMALLOCSTR("xyzxyz",6)));
VPUSH(PNTTOVAL(VMALLOCSTR("765432",6)));
VPUSH(INTTOVAL(-30));
VPUSH(INTTOVAL(11));
VPUSH(INTTOVAL(1));
VPUSH(INTTOVAL(0));
VMKTAB(7);
nscan++;
#endif
#ifdef VREAL
rt2501_scan(ssid, netScan_, NULL);
#endif
VPUSH(NIL);
while(nscan--) VMKTAB(2);
}
// compilation d'une fonction
// [name] -> 0
int Compiler::parsefun()
{
int k;
int* type_result;
// PRINTF(m)(LOG_DEVCORE,"fonction %s\n",STRSTART(VALTOPNT(STACKGET(m,0))));
char* name=STRSTART(VALTOPNT(STACKGET(m,0)));
// création des variables de travail
if (k=STACKPUSH(m,NIL)) return k; // LOCALS
locals=STACKREF(m);
if (k=createnodetype(TYPENAME_FUN)) return k;
// recherche des arguments
int narg=0;
do
{
if (!parser->next(0))
{
PRINTF(m)(LOG_COMPILER,"Compiler : argument or '=' expected (found EOF)\n");
return MTLERR_SN;
}
if (islabel(parser->token))
{
if (k=createnodetype(TYPENAME_UNDEF)) return k;
if (k=addlabel(locals,parser->token,INTTOVAL(narg++),STACKGET(m,0))) return k;
}
else if (strcmp(parser->token,"="))
{
PRINTF(m)(LOG_COMPILER,"Compiler : argument or '=' expected (found '%s')\n",parser->token);
return MTLERR_SN;
}
} while(strcmp(parser->token,"="));
// construction du type initial de la fonction
if (k=createnodetuple(narg)) return k;
TABSET(m,VALTOPNT(STACKGET(m,1)),TYPEHEADER_LENGTH,STACKGET(m,0)); // attachement du noeud tuple au noeud fun
STACKDROP(m);
if (k=createnodetype(TYPENAME_UNDEF)) return k; // noeud résultat
TABSET(m,VALTOPNT(STACKGET(m,1)),TYPEHEADER_LENGTH+1,STACKGET(m,0)); // attachement du noeud resultat au noeud fun
type_result=VALTOPNT(STACKPULL(m)); // on garde en mémoire le type du résultat
// ici : [type local global name]
// on crée le bloc fonction
newref=MALLOCCLEAR(m,REF_LENGTH);
if (!newref) return MTLERR_OM;
TABSET(m,newref,REF_TYPE,STACKPULL(m));
TABSET(m,newref,REF_NAME,STACKGET(m,1));
TABSET(m,newref,REF_CODE,INTTOVAL(narg));
// vient d'être déclarée, pas encore utilisée
TABSET(m,newref,REF_USED,INTTOVAL(0));
k=findproto(PNTTOVAL(newpackage),newref);
TABSET(m,newref,REF_PACKAGE,(k!=NIL)?k:INTTOVAL(ifuns++));
if (k=STACKPUSH(m,PNTTOVAL(newref))) return MTLERR_OM; // [newref local global name]
addreftopackage(newref,newpackage);
STACKDROP(m);
// [local global name]
// on poursuit la compilation vers le corps de la fonction
nblocals=narg;
bc->reinit(); // initialisation de la production de bytecode
// [locals globals]
// parsing
if (k=parseprogram()) return k;
// [type locals globals]
// la pile contient le type du résultat de la fonction
if (k=parser->parsekeyword(";;")) return k;
// unifier le type résultat
if (k=unif(type_result,VALTOPNT(STACKGET(m,0)))) return k;
STACKDROP(m);
// [locals globals name]
// créer le bloc programme
int* fun=MALLOCCLEAR(m,FUN_LENGTH);
if (!fun) return MTLERR_OM;
TABSET(m,newref,REF_VAL,PNTTOVAL(fun));
TABSET(m,fun,FUN_NBARGS,INTTOVAL(narg));
TABSET(m,fun,FUN_NBLOCALS,INTTOVAL(nblocals));
// stocker le bytecode
bc->addchar(OPret);
if (k=STRPUSHBINARY(m,bc->getstart(),bc->getsize())) return k;
TABSET(m,fun,FUN_BC,STACKPULL(m));
if (!strcmp(name,"awcConnect"))
displaybc(m,STRSTART(VALTOPNT(TABGET(fun,FUN_BC))));
// construire le tuple des références globales
// int* globalstuple=tuplefromlabels(globals);
// if (!globalstuple) return MTLERR_OM;
// TABSET(m,fun,FUN_REF,PNTTOVAL(globalstuple));
TABSET(m,fun,FUN_REFERENCE,PNTTOVAL(newref));
STACKDROPN(m,2);
// []
// chercher d'éventuels prototypes
if (k=fillproto(PNTTOVAL(newpackage),newref)) return k;
outputbuf->reinit();
outputbuf->printf("Compiler : %s : ",STRSTART(VALTOPNT(TABGET(newref,REF_NAME))));
echograph(outputbuf,VALTOPNT(TABGET(newref,REF_TYPE)));
PRINTF(m)(LOG_COMPILER,"%s\n",outputbuf->getstart());
return 0;
}
// compilation d'un prototype
// [name] -> 0
int Compiler::parseproto()
{
int k;
if (!parser->next(0))
{
PRINTF(m)(LOG_COMPILER,"Compiler : integer or '=' expected (found EOF)\n");
return MTLERR_SN;
}
int nbarg=-1;
if (!strcmp(parser->token,"="))
{
if (k=creategraph(parser,PNTTOVAL(newpackage),0)) return k;
int vp=STACKGET(m,0);
if (vp!=NIL)
{
int* p=VALTOPNT(vp);
if (TABGET(p,TYPEHEADER_CODE)==INTTOVAL(TYPENAME_FUN))
{
vp=TABGET(p,TYPEHEADER_LENGTH);
if (vp!=NIL)
{
int* p=VALTOPNT(vp);
if (TABGET(p,TYPEHEADER_CODE)==INTTOVAL(TYPENAME_TUPLE))
{
nbarg=TABLEN(p)-TYPEHEADER_LENGTH;
}
}
}
}
if (nbarg<0)
{
PRINTF(m)(LOG_COMPILER,"Compiler : function type expected\n");
return MTLERR_SN;
}
}
else if (isdecimal(parser->token))
{
nbarg=mtl_atoi(parser->token);
if (k=createnodetype(TYPENAME_FUN)) return k;
int i;for(i=0;i<nbarg;i++) if (k=createnodetype(TYPENAME_WEAK)) return k;
if (k=createnodetuple(nbarg)) return k;
TABSET(m,VALTOPNT(STACKGET(m,1)),TYPEHEADER_LENGTH,STACKGET(m,0)); // attachement du noeud tuple au noeud fun
STACKDROP(m);
if (k=createnodetype(TYPENAME_WEAK)) return k; // noeud résultat
TABSET(m,VALTOPNT(STACKGET(m,1)),TYPEHEADER_LENGTH+1,STACKGET(m,0)); // attachement du noeud resultat au noeud fun
STACKDROP(m);
}
if (nbarg<0)
{
PRINTF(m)(LOG_COMPILER,"Compiler : integer or '=' expected (found '%s')\n",parser->token);
return MTLERR_SN;
}
if (k=parser->parsekeyword(";;")) return k;
// on crée le bloc fonction
newref=MALLOCCLEAR(m,REF_LENGTH);
if (!newref) return MTLERR_OM;
TABSET(m,newref,REF_TYPE,STACKPULL(m));
TABSET(m,newref,REF_NAME,STACKPULL(m));
TABSET(m,newref,REF_CODE,INTTOVAL(nbarg));
TABSET(m,newref,REF_PACKAGE,INTTOVAL(ifuns++));
if (k=STACKPUSH(m,PNTTOVAL(newref))) return MTLERR_OM; // [newref]
addreftopackage(newref,newpackage);
STACKDROP(m);
outputbuf->reinit();
outputbuf->printf("Compiler : proto %s : ",STRSTART(VALTOPNT(TABGET(newref,REF_NAME))));
echograph(outputbuf,VALTOPNT(TABGET(newref,REF_TYPE)));
PRINTF(m)(LOG_COMPILER,"%s\n",outputbuf->getstart());
return 0;
}
void netScan(char* ssid)
{
nscan=0;
VPUSH(PNTTOVAL(VMALLOCSTR("foo",3)));
VPUSH(PNTTOVAL(VMALLOCSTR("xyzxyz",6)));
VPUSH(PNTTOVAL(VMALLOCSTR("765432",6)));
VPUSH(INTTOVAL(-20));
VPUSH(INTTOVAL(11));
VPUSH(INTTOVAL(1));
VPUSH(INTTOVAL(0));
VMKTAB(7);
nscan++;
VPUSH(PNTTOVAL(VMALLOCSTR("foo",3)));
VPUSH(PNTTOVAL(VMALLOCSTR("xyzxyz",6)));
VPUSH(PNTTOVAL(VMALLOCSTR("765432",6)));
VPUSH(INTTOVAL(-10));
VPUSH(INTTOVAL(11));
VPUSH(INTTOVAL(1));
VPUSH(INTTOVAL(0));
VMKTAB(7);
nscan++;
VPUSH(PNTTOVAL(VMALLOCSTR("zzzz",3)));
VPUSH(PNTTOVAL(VMALLOCSTR("xyzxyz",6)));
VPUSH(PNTTOVAL(VMALLOCSTR("765432",6)));
VPUSH(INTTOVAL(-10));
VPUSH(INTTOVAL(11));
VPUSH(INTTOVAL(1));
VPUSH(INTTOVAL(0));
VMKTAB(7);
nscan++;
VPUSH(PNTTOVAL(VMALLOCSTR("",3)));
VPUSH(PNTTOVAL(VMALLOCSTR("xyzxyz",6)));
VPUSH(PNTTOVAL(VMALLOCSTR("765432",6)));
VPUSH(INTTOVAL(-10));
VPUSH(INTTOVAL(11));
VPUSH(INTTOVAL(1));
VPUSH(INTTOVAL(0));
VMKTAB(7);
nscan++;
VPUSH(PNTTOVAL(VMALLOCSTR("a\"a<a'a a\\a",strlen("a\"a<a'a a\\a"))));
VPUSH(PNTTOVAL(VMALLOCSTR("xyzxyz",6)));
VPUSH(PNTTOVAL(VMALLOCSTR("765432",6)));
VPUSH(INTTOVAL(-10));
VPUSH(INTTOVAL(11));
VPUSH(INTTOVAL(1));
VPUSH(INTTOVAL(3));
VMKTAB(7);
nscan++;
VPUSH(PNTTOVAL(VMALLOCSTR("foo",3)));
VPUSH(PNTTOVAL(VMALLOCSTR("xyzxyz",6)));
VPUSH(PNTTOVAL(VMALLOCSTR("765432",6)));
VPUSH(INTTOVAL(-30));
VPUSH(INTTOVAL(11));
VPUSH(INTTOVAL(1));
VPUSH(INTTOVAL(0));
VMKTAB(7);
nscan++;
VPUSH(NIL);
while(nscan--) VMKTAB(2);
}
// compilation d'une somme
// [locals nom]
int Compiler::parsesum()
{
int k;
// on crée le bloc type
TABSET(m,newref,REF_VAL,INTTOVAL(0));
TABSET(m,newref,REF_CODE,INTTOVAL(CODE_SUM));
// [local name]
int loop=1;
do
{
if (!parser->next(0))
{
PRINTF(m)(LOG_COMPILER,"Compiler : constructor expected (found EOF)\n");
return MTLERR_SN;
}
if (islabel(parser->token))
{
if (k=STRPUSH(m,parser->token)) return k;
// on crée le bloc champ
int* newcons=MALLOCCLEAR(m,REF_LENGTH);
if (!newcons) return MTLERR_OM;
TABSET(m,newcons,REF_NAME,STACKPULL(m));
if (k=STACKPUSH(m,PNTTOVAL(newcons))) return MTLERR_OM; // [newcons local name]
addreftopackage(newcons,newpackage);
STACKDROP(m);
// [local name]
TABSET(m,newcons,REF_VAL,TABGET(newref,REF_VAL));
TABSET(m,newref,REF_VAL,INTTOVAL(1+VALTOINT(TABGET(newref,REF_VAL)))); // incrémentation
if (k=createnodetype(TYPENAME_FUN)) return k;
if ((parser->next(0))&&((!strcmp(parser->token,"|"))||(!strcmp(parser->token,";;"))))
{
parser->giveback();
if (k=createnodetuple(0)) return k;
TABSET(m,newcons,REF_CODE,INTTOVAL(CODE_CONS0));
}
else
{
parser->giveback();
if (k=creategraph(parser,PNTTOVAL(newpackage),1,locals)) return k;
if (k=createnodetuple(1)) return k;
TABSET(m,newcons,REF_CODE,INTTOVAL(CODE_CONS));
}
TABSET(m,VALTOPNT(STACKGET(m,1)),TYPEHEADER_LENGTH,STACKGET(m,0)); // attachement du noeud tuple au noeud fun
STACKDROP(m);
TABSET(m,VALTOPNT(STACKGET(m,0)),TYPEHEADER_LENGTH+1,TABGET(newref,REF_TYPE)); // attachement du type resultat au noeud fun
TABSET(m,newcons,REF_TYPE,STACKPULL(m));
outputbuf->reinit();
outputbuf->printf("Compiler : %s : ",STRSTART(VALTOPNT(TABGET(newcons,REF_NAME))));
echograph(outputbuf,VALTOPNT(TABGET(newcons,REF_TYPE)));
PRINTF(m)(LOG_COMPILER,"%s\n",outputbuf->getstart());
}
else
{
PRINTF(m)(LOG_COMPILER,"Compiler : constructor expected (found '%s')\n",parser->token);
return MTLERR_SN;
}
if (!parser->next(0))
{
PRINTF(m)(LOG_COMPILER,"Compiler : '|' or ';;' expected (found EOF)\n");
return MTLERR_SN;
}
if (!strcmp(parser->token,";;")) loop=0;
else if (strcmp(parser->token,"|"))
{
PRINTF(m)(LOG_COMPILER,"Compiler : '|' or ';;' expected (found '%s')\n",parser->token);
return MTLERR_SN;
}
} while(loop);
STACKDROPN(m,2);
outputbuf->reinit();
outputbuf->printf("Compiler : ");
echograph(outputbuf,VALTOPNT(TABGET(newref,REF_TYPE)));
outputbuf->printf(" : constructor\n");
PRINTF(m)(LOG_COMPILER,"%s\n",outputbuf->getstart());
return 0;
}
// compilation d'une structure (le premier '[' a été lu)
// [locals nom]
int Compiler::parsestruct()
{
int k;
// on crée le bloc type
TABSET(m,newref,REF_VAL,INTTOVAL(0));
TABSET(m,newref,REF_CODE,INTTOVAL(CODE_STRUCT));
// [local name]
int loop=1;
do
{
if (!parser->next(0))
{
PRINTF(m)(LOG_COMPILER,"Compiler : field name or ']' expected (found EOF)\n");
return MTLERR_SN;
}
if (islabel(parser->token))
{
if (k=STRPUSH(m,parser->token)) return k;
// on crée le bloc champ
int* newfield=MALLOCCLEAR(m,REF_LENGTH);
if (!newfield) return MTLERR_OM;
TABSET(m,newfield,REF_NAME,STACKPULL(m));
TABSET(m,newfield,REF_CODE,INTTOVAL(CODE_FIELD));
if (k=STACKPUSH(m,PNTTOVAL(newfield))) return MTLERR_OM; // [newfield local name]
addreftopackage(newfield,newpackage);
STACKDROP(m);
// [local name]
if (k=STACKPUSH(m,TABGET(newref,REF_VAL))) return k;
if (k=STACKPUSH(m,PNTTOVAL(newref))) return k;
if (k=DEFTAB(m,FIELD_LENGTH)) return k;
TABSET(m,newfield,REF_VAL,STACKPULL(m));
TABSET(m,newref,REF_VAL,INTTOVAL(1+VALTOINT(TABGET(newref,REF_VAL)))); // incrémentation
if (k=createnodetype(TYPENAME_FUN)) return k;
if (k=STACKPUSH(m,TABGET(newref,REF_TYPE))) return k;
if (k=createnodetuple(1)) return k;
TABSET(m,VALTOPNT(STACKGET(m,1)),TYPEHEADER_LENGTH,STACKGET(m,0)); // attachement du noeud tuple au noeud fun
STACKDROP(m);
if ((!parser->next(0))||(strcmp(parser->token,":")))
{
parser->giveback();
k=createnodetype(TYPENAME_WEAK);
}
else k=creategraph(parser,PNTTOVAL(newpackage),1,locals);
if (k) return k;
TABSET(m,VALTOPNT(STACKGET(m,1)),TYPEHEADER_LENGTH+1,STACKGET(m,0)); // attachement du noeud resultat au noeud fun
STACKDROP(m);
TABSET(m,newfield,REF_TYPE,STACKPULL(m));
outputbuf->reinit();
outputbuf->printf("Compiler : %s : ",STRSTART(VALTOPNT(TABGET(newfield,REF_NAME))));
echograph(outputbuf,VALTOPNT(TABGET(newfield,REF_TYPE)));
PRINTF(m)(LOG_COMPILER,"%s\n",outputbuf->getstart());
}
else if (!strcmp(parser->token,"]")) loop=0;
else
{
PRINTF(m)(LOG_COMPILER,"Compiler : field name or ']' expected (found '%s')\n",parser->token);
return MTLERR_SN;
}
} while(loop);
if (k=parser->parsekeyword(";;")) return k;
STACKDROPN(m,2);
outputbuf->reinit();
outputbuf->printf("Compiler : ");
echograph(outputbuf,VALTOPNT(TABGET(newref,REF_TYPE)));
outputbuf->printf(" : struct (%d)\n",VALTOINT(TABGET(newref,REF_VAL)));
PRINTF(m)(LOG_COMPILER,"%s\n",outputbuf->getstart());
return 0;
}
