mal_interpreter.c

一个内存数据库的源代码这是服务器端还有客户端

#line 66 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/mal/mal_interpreter.mx"
#include "mal_config.h"
#include "mal_interpreter.h"
#include "mal_debugger.h"   /* for mdbStep() */
#include "mal_type.h"

static str runMALsequence( Client cntxt, MalBlkPtr mb, int startpc, 
		int stoppc, MalStkPtr stk, MalStkPtr env, InstrPtr pcicaller);
static str setDynamicType(MalBlkPtr mb, VarPtr v, int tpe, int pc);
static void getVolume(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci, int rd);


#line 79 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/mal/mal_interpreter.mx"

ptr getArgValue(MalStkPtr stk, InstrPtr pci, int k){
	int j=0;
	ValRecord *v;
	ptr val = NULL;
	int tpe ;

	j = pci->argv[k];
	v= &stk->stk[j];
	tpe = v->vtype;
tstagain:
	switch(tpe){
	/* switch(ATOMstorage(v->vtype)){ */
	case TYPE_void: val= (ptr) & v->val.ival; break;
	case TYPE_bit: val= (ptr) & v->val.cval[0]; break;
	case TYPE_chr: val= (ptr) & v->val.cval[0]; break;
	case TYPE_sht: val= (ptr) & v->val.shval; break;
	case TYPE_bat: val= (ptr) & v->val.br.id; break;
	case TYPE_int: val= (ptr) & v->val.ival; break;
	case TYPE_wrd: val= (ptr) & v->val.wval; break;
	case TYPE_bte: val= (ptr) & v->val.btval; break;
	case TYPE_oid: val= (ptr) & v->val.oval; break;
	case TYPE_ptr: val= (ptr) v->val.pval; break;/*!!*/
	case TYPE_flt: val= (ptr) & v->val.fval; break;
	case TYPE_dbl: val= (ptr) & v->val.dval; break;
	case TYPE_lng: val= (ptr) & v->val.lval; break;
	case TYPE_str: val= (ptr) v->val.sval; break;/*!!*/
	default:
		tpe= ATOMstorage(tpe);
		goto tstagain;
	}
	return val;
} 


#line 118 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/mal/mal_interpreter.mx"
INLINE
ptr getArgReference(MalStkPtr stk, InstrPtr pci, int k)
{
#ifdef STRUCT_ALIGNED
	return (ptr) & stk->stk[pci->argv[k]].val.ival;
#else
	int j=0;
	ValRecord *v=0;
	ptr ret = NULL;

	j = pci->argv[k];
	v= &stk->stk[j];

	switch(ATOMstorage(v->vtype)){
	case TYPE_void: ret= (ptr) & v->val.ival; break;
	case TYPE_bit: ret= (ptr) & v->val.cval[0]; break;
	case TYPE_chr: ret= (ptr) & v->val.cval[0]; break;
	case TYPE_sht: ret= (ptr) & v->val.shval; break;
	case TYPE_bat: ret= (ptr) & v->val.br.id; break;
	case TYPE_int: ret= (ptr) & v->val.ival; break;
	case TYPE_wrd: ret= (ptr) & v->val.wval; break;
	case TYPE_bte: ret= (ptr) & v->val.btval; break;
	case TYPE_oid: ret= (ptr) & v->val.oval; break;
	case TYPE_ptr: ret= (ptr) & v->val.pval; break;
	case TYPE_flt: ret= (ptr) & v->val.fval; break;
	case TYPE_dbl: ret= (ptr) & v->val.dval; break;
	case TYPE_lng: ret= (ptr) & v->val.lval; break;
	case TYPE_str: ret= (ptr) & v->val.sval; break;
	default:
		ret= (ptr) & v->val.pval; 
	}
	return ret;
#endif
} 

void showErrors() {
	Client cntxt = MCgetClient();
	int i;
	if (cntxt->errbuf == '\0')
		return;

	if (*cntxt->errbuf) {
		i = strlen(cntxt->errbuf);
		stream_printf(cntxt->fdout, "%s", cntxt->errbuf);
		if (cntxt->errbuf[i - 1] != '\n')
			stream_printf(cntxt->fdout, "\n");
		*cntxt->errbuf = '\0';
	}
}


#line 180 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/mal/mal_interpreter.mx"

MalStkPtr
prepareMALstack(MalBlkPtr mb){
	MalStkPtr stk= NULL;
	int i;
	ValPtr lhs,rhs;

	stk= newGlobalStack(mb->vsize);
	memset((char *) stk, 0, stackSize(mb->vtop));
	stk->stktop= mb->vtop; 
	stk->stksize= mb->vsize;
	stk->blk= mb;

	
#line 170 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/mal/mal_interpreter.mx"
	for(i= 1; i< mb->vtop; i++)
	if( isConstant(mb,i) > 0 ){
		lhs = &stk->stk[i];
		rhs = &getVarConstant(mb,i);
		VALcopy2(lhs,rhs);
	} else {
		lhs = &stk->stk[i];
		lhs->vtype = getVarGDKType(mb,i);
	}


#line 193 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/mal/mal_interpreter.mx"

	return stk;
}

str runMAL(Client cntxt, MalBlkPtr mb, int startpc, MalBlkPtr mbcaller, 
	   MalStkPtr env, InstrPtr pcicaller){
	MalStkPtr stk= NULL;
	int i;
	ValPtr lhs,rhs;
	InstrPtr pci=0;
	str ret;

	if (mb->errors) {
		showErrors();
		if (cntxt->itrace == 0) /* permit debugger analysis */
			return createScriptException(mb, 0, MAL, NULL, "Syntax error in script");
	}


#line 222 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/mal/mal_interpreter.mx"
	/* allocate space for value stack */
	/* the global stack should be large enough */
	if( mbcaller== NULL && env != NULL){
		stk = env;
		if( mb != stk->blk) 
			showScriptException(mb,0,MAL,"runMAL:misalignment of symbols\n");
		if( mb->vtop > stk->stksize)
			showScriptException(mb,0,MAL,"stack too small\n");
		pci= pcicaller;
	} else {
		newStack(stk,mb->vsize);
		memset((char *) stk, 0, stackSize(mb->vtop));
		stk->stktop= mb->vtop; 
		stk->stksize= mb->vsize;
		stk->blk= mb;
		stk->cmd= cntxt->itrace; /* set debug mode */
		if( env) {
			stk->stkdepth= stk->stksize + env->stkdepth;
			
#line 686 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/mal/mal_interpreter.mx"
/* Expensive? 70 msec for 1M calls another solution is needed.*/
	if (stk->stkdepth > 50 * 1024 && THRhighwater()) {
		showScriptException(mb,0,MAL,
			"interpret: running out of physical stack space!\n");
		return createScriptException(mb, 0, STKOF, "Interpreter", NULL,
				"stack depth: %d", stk->stkdepth);
	}



#line 240 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/mal/mal_interpreter.mx"

		}
	} 

	if( env && mbcaller){
		InstrPtr pp;
		int k;


#line 253 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/mal/mal_interpreter.mx"
		pci= pcicaller;
		pp = getInstrPtr(mb, 0);
		/* set return types */
		for(i=0; i< pci->retc; i++){
			lhs = &stk->stk[i];
			lhs->vtype =getVarGDKType(mb,i);
		}
		for(k=pp->retc; i<pci->argc; i++,k++){
			lhs = &stk->stk[pp->argv[k]];
			/* variable arguments ? */
			if( k== pp->argc-1) k--; 

			rhs = &env->stk[pci->argv[i]];
			VALcopy2(lhs,rhs);
			if( lhs->vtype == TYPE_bat)
				BBPincref(lhs->val.br.id, TRUE);
		}
		stk->up = env;
		env->down = stk;
	} 


#line 285 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/mal/mal_interpreter.mx"
	
#line 170 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/mal/mal_interpreter.mx"
	for(i= (env && mbcaller)?pci->argc:1; i< mb->vtop; i++)
	if( isConstant(mb,i) > 0 ){
		lhs = &stk->stk[i];
		rhs = &getVarConstant(mb,i);
		VALcopy2(lhs,rhs);
	} else {
		lhs = &stk->stk[i];
		lhs->vtype = getVarGDKType(mb,i);
	}


#line 285 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/mal/mal_interpreter.mx"


	if(stk->cmd  && env && stk->cmd!='f') stk->cmd = env->cmd ;
	ret = runMALsequence(cntxt, mb, startpc,  0, stk, env, pcicaller);

	/* pass the new debug mode to the caller */
	if(stk->cmd  && env && stk->cmd!='f') env->cmd = stk->cmd; 
	if( !stk->keepAlive && garbageControl(getInstrPtr(mb,0)) )
		garbageCollector(mb,stk, env != stk);
	return ret;
}


#line 307 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/mal/mal_interpreter.mx"
str reenterMAL(Client cntxt, MalBlkPtr mb, int startpc, int stoppc,
	MalStkPtr stk, MalStkPtr env, InstrPtr pcicaller)
{
	str ret;

	if(env && stk && stk->cmd!='f') stk->cmd = env->cmd ;

	ret = runMALsequence(cntxt, mb, startpc,  stoppc, stk, env, pcicaller);

	/* pass the new debug mode to the caller */
	if(env && stk->cmd!='f') env->cmd = stk->cmd;
	if( !stk->keepAlive && garbageControl(getInstrPtr(mb,0)) )
		garbageCollector(mb,stk,env!=stk);
	return ret;
}


#line 330 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/mal/mal_interpreter.mx"
str 
callMAL(Client cntxt, MalBlkPtr mb, MalStkPtr *env, ValPtr argv[], char debug){
	MalStkPtr stk;
	str ret;
	int i;
	ValPtr lhs,rhs;
	InstrPtr p= getInstrPtr(mb,0);

#ifdef DEBUG_CALLMAL
	stream_printf(GDKout,"callMAL\n");
	printInstruction(GDKout,mb,p,LIST_MAL_ALL);
#endif
	switch( p->token){
	case FUNCTIONsymbol:
	case FCNcall:


#line 350 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/mal/mal_interpreter.mx"
		if( *env==NULL){
			stk=newGlobalStack(mb->vsize);
			memset((char *) stk, 0, stackSize(mb->vtop));
			stk->stktop= mb->vtop; 
			stk->stksize= mb->vsize;
			stk->blk= mb;
			stk->up = 0;
			
#line 170 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/mal/mal_interpreter.mx"
	for(i= p->argc; i< mb->vtop; i++)
	if( isConstant(mb,i) > 0 ){
		lhs = &stk->stk[i];
		rhs = &getVarConstant(mb,i);
		VALcopy2(lhs,rhs);
	} else {
		lhs = &stk->stk[i];
		lhs->vtype = getVarGDKType(mb,i);
	}


#line 357 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/mal/mal_interpreter.mx"

			stk->keepAlive = TRUE;
			*env= stk;
		} else stk = *env;
		assert(stk);
		for(i=p->retc; i<p->argc; i++){
			lhs= &stk->stk[p->argv[i]];
			VALcopy2(lhs, argv[i]);
			if( lhs->vtype == TYPE_bat)
				BBPincref(lhs->val.br.id,TRUE);
		}
#ifdef STACKTRACE
	stream_printf(GDKout,"before execution\n");
	printStack(GDKout,mb,stk,0); 
	printFunction(GDKout,mb,LIST_MAL_ALL);
#endif
		stk->cmd = debug;

#ifdef DEBUG_CALLMAL
	stream_printf(GDKout,"start evaluation\n");
#endif
		ret = runMALsequence(cntxt, mb, 1,  0, stk, 0, 0);

#ifdef STACKTRACE
		stream_printf(GDKout,"Stack after loop\n");
		printStack(GDKout,mb,stk,0); 
#endif
		return ret;
	case FACTORYsymbol:
	case FACcall:
		return callFactory(cntxt, mb, argv,debug);
	case PATcall:
	case CMDcall:
	default:
		throw(MAL, "mal.interpreter",
				"Non-supported call the MAL interpreter");
	}
	return MAL_SUCCEED;
}


#line 401 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/mal/mal_interpreter.mx"
str runMALsequence( Client cntxt, MalBlkPtr mb, int startpc, 
		int stoppc, MalStkPtr stk, MalStkPtr env, InstrPtr pcicaller)
{   
	ValPtr lhs,rhs,v;
	int stkpc,i,k; 
	InstrPtr pci=0; 
	int exceptionVar, exceptionPC;
	str ret=0;
	int stamp= -1;
	int backup[MAXARG];
	str sbackup[MAXARG];
	lng oldtimer=0;
	struct mallinfo oldMemory;
#ifdef HAVE_SYS_RESOURCE_H
	int oldinblock=0;
	int oldoublock=0;
	struct rusage oldResource;
#endif
	
#line 1466 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/mal/mal_interpreter.mx"
#ifdef MALprofiler
	lng newclk=0;
#endif


#line 419 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/mal/mal_interpreter.mx"


	if( cntxt->flags & timerFlag)
		oldtimer= cntxt->timer= GDKusec();
	oldMemory.arena= 0;
		
	stkpc = startpc;
	exceptionVar = exceptionPC = -1;
	(void)exceptionPC; /* TODO maybe we should use this variable somewhere*/
	while(stkpc < mb->stop && stkpc != stoppc ){
		pci = getInstrPtr(mb,stkpc);
		if( stk->cmd  ) {
			lng t=0;
			if( oldtimer)
				t= GDKusec();
			mdbStep(cntxt,mb,stk,stkpc);
			if( stk->cmd == 'x') {
				stkpc = mb->stop;
				continue;
			}
			if( oldtimer ) {
				/* ignore debugger waiting time*/
				t= GDKusec()-t;
				oldtimer += t;
#ifdef HAVE_SYS_RESOURCE_H
				getrusage(RUSAGE_SELF, &oldResource);
#endif
				oldMemory= MT_mallinfo();
			}
		}

		
#line 1470 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/mal/mal_interpreter.mx"
#ifdef MALprofiler
	if( malProfileMode == 0)
		/* mostly true */;
	else {
		if( mb->profiler== NULL)
			initProfiler(mb);
		mb->profiler[stkpc].clk= GDKusec();
		time(&mb->profiler[stkpc].clock);
#ifdef HAVE_TIMES
		times(&mb->profiler[stkpc].timer);
#endif
	}
#endif


#line 450 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/mal/mal_interpreter.mx"

		
#line 710 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/mal/mal_interpreter.mx"
	ret = 0;
	switch( pci->token){
	case ASSIGNsymbol: 
#line 875 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/mal/mal_interpreter.mx"
{	
	
#line 928 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/mal/mal_interpreter.mx"
#ifdef STACKTRACE
	printf("safeTarget %d\n", needsCleanup(pci));
	printInstruction(GDKout,mb,pci, LIST_MAL_ALL);
#endif
	if( needsCleanup(pci) ){ 
		for(i=0; i<pci->retc; i++) {
			sbackup[i]= 0;  
			backup[i]= 0;  
			if( stk->stk[getArg(pci,i)].vtype == TYPE_bat){
				backup[i]= stk->stk[getArg(pci,i)].val.br.id;
				stamp= BBPcurstamp();
			} else if( stk->stk[getArg(pci,i)].vtype == TYPE_str){
					backup[i]= stk->stk[getArg(pci,i)].len;
					sbackup[i]= stk->stk[getArg(pci,i)].val.sval;
			} 
		}
	} 


#line 876 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/mal/mal_interpreter.mx"

	for(k=0, i=pci->retc; k<pci->retc && i<pci->argc; i++,k++){
		lhs = &stk->stk[pci->argv[k]];
		rhs = &stk->stk[pci->argv[i]];
		VALcopy2(lhs,rhs);
		if( lhs->vtype == TYPE_bat)
			BBPincref(lhs->val.br.id, TRUE);
	}
	
#line 953 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/mal/mal_interpreter.mx"
#ifdef STACKTRACE
	printf("restoreTarget %d\n", needsCleanup(pci));
#endif
	if( needsCleanup(pci) ){ 
		for(i=0; i<pci->retc; i++)
		if( stk->stk[getArg(pci,i)].vtype == TYPE_bat){
			if( backup[i] ){
				if( backup[i]== stk->stk[getArg(pci,i)].val.br.id){
				/* target and source are identical, which means its
				   logical reference count is one too high . */
					BBPreleaselref(backup[i]);
				} else /* possible garbage collect the variable */
					BBPdecref(backup[i],TRUE);
			} 
		} else 
		if( stk->stk[getArg(pci,i)].vtype == TYPE_str){
			int a= getArg(pci,i);
			if( sbackup[i] && sbackup[i]!= stk->stk[a].val.sval){
				if( backup[i] > 0) 
					GDKfree(sbackup[i]);
				backup[i]=0;
				sbackup[i]=0;
			} 
		} 
	}
	/* Provide debugging support */
	if( GDKdebug & 10 ){
		BAT *b;
		str oldmsg =0;

		for( i=0; i< pci->retc; i++)