inter.m

vb script子集解释器 Makefile.vb用于生成解释器的c代码 可执行程序需要自己写main函数

#include "vbs_context.h"
#include <string>
#include <iostream>
with ast;
using namespace std;

extern "C" void  execute(Statement s, Cvbs_context& c);
extern "C" string evaluate(Expression e, Cvbs_context& c);
void extract_arg(const char* fn,CaseList list,Cvbs_context& c,int i);
void docase(Expression e,CaseList list,Statement s2,Cvbs_context& c);
void set_args(const char* szFn,CaseList list,Cvbs_context& c,int i);
int array_num(CaseList list,Cvbs_context& c,const char* name);
int array_idx(CaseList list,int n,int dim,Cvbs_context& c,const char* name);
string evaluate(Expression e,Cvbs_context& c)
{
   match e {
      rule eq(x,y,p)     :  return c.eq(evaluate(x,c).c_str(),evaluate(y,c).c_str());
      rule ne(x,y,p)     : return c.ne(evaluate(x,c).c_str(),evaluate(y,c).c_str());
      rule lt(x,y,p)     : return c.lt(evaluate(x,c).c_str(),evaluate(y,c).c_str());
      rule le(x,y,p)     : return c.le(evaluate(x,c).c_str(),evaluate(y,c).c_str());
      rule gt(x,y,p)     : return c.gt(evaluate(x,c).c_str(),evaluate(y,c).c_str());
      rule ge(x,y,p)     : return c.ge(evaluate(x,c).c_str(),evaluate(y,c).c_str());
      rule splus(x,y,p)  : return c.plus(evaluate(x,c).c_str(),evaluate(y,c).c_str());
      rule amd(x,y,p)	: return c.amd(evaluate(x,c).c_str(),evaluate(y,c).c_str());
      rule sminus(x,y,p) :  return c.minus(evaluate(x,c).c_str(),evaluate(y,c).c_str());
      rule mult(x,y,p)   :  return c.mult(evaluate(x,c).c_str(),evaluate(y,c).c_str());
      rule divide(x,y,p) :  return c.divide(evaluate(x,c).c_str(),evaluate(y,c).c_str());
      rule neg(x,p)       :  return c.neg(evaluate(x,c).c_str());
      rule value(x,z)    	:   return c.value(x);
      rule name(x,z)      :  return c.namev(x);
      rule name_array(n,i,z): return c.name_av(n,array_idx(i,1,1,c,n));
      rule lbound(n,i,z):	    c.set_var(".","#0");return string("#0");
      rule ubound(n,i,z):     return c.ubound(n,i);
      rule vband(x,y,z):	    return c.vb_and(evaluate(x,c).c_str(),evaluate(y,c).c_str());
      rule vbor(x,y,z):      return c.vb_or(evaluate(x,c).c_str(),evaluate(y,c).c_str());
      rule vbxor(x,y,z):      return c.vb_xor(evaluate(x,c).c_str(),evaluate(y,c).c_str());
      rule vbnot(x,z):	    return c.vb_not(evaluate(x,c).c_str());
      rule clng(x,z):	    return c.clng(evaluate(x,c).c_str());
      rule date(z):	    return c.date();
      rule vbtime(z):	    return c.vbtime();
      rule getstring(x,y,z,u):return c.getString(evaluate(x,c).c_str(),evaluate(y,c).c_str(),evaluate(z,c).c_str());
      rule instr(n,x,y,t,p)  :return c.inStr(evaluate(n,c).c_str(),evaluate(x,c).c_str(),evaluate(y,c).c_str(),evaluate(t,c).c_str());
      rule cstr(x,p)	:   return c.cstr(evaluate(x,c).c_str());
      rule len(x,p)	:   return c.len(evaluate(x,c).c_str());
      rule rnd(x,p)	:   return c.rnd(evaluate(x,c).c_str());
      rule rnd0(p)	:   return c.rnd0();
      rule vyear(x,p)	:   return c.vbyear(evaluate(x,c).c_str());
      rule vmonth(x,p)	:   return c.vbmonth(evaluate(x,c).c_str());
      rule vday(x,p)	:   return c.vbday(evaluate(x,c).c_str());
      rule vweekday(x,p)	:   return c.vbweekday(evaluate(x,c).c_str());
      rule vhour(x,p)	:   return c.vbhour(evaluate(x,c).c_str());
      rule vminute(x,p)	:   return c.vbminute(evaluate(x,c).c_str());
      rule vsecond(x,p)	:   return c.vbsecond(evaluate(x,c).c_str());
   }
}

void execute (Statement s, Cvbs_context& c)
{
   match s {
      rule assignment(name(x,p),rhs,q):
	 c.set_var(x, evaluate(rhs,c).c_str());
      rule assignment(name_array(n,i,p),rhs,q):
	 c.set_array_val(n,array_idx(i,1,1,c,n),evaluate(rhs,c).c_str());         
      rule print(x,p) :
	 c.printv(evaluate(x,c).c_str());
      rule eval(x,p):
	 c.do_eval(evaluate(x,c).c_str());
      rule decl(x,p):
	 c.set_var(x,"");
      rule ifstmt(c1, s1, s2,p):
	 if(c.true_value(evaluate(c1,c).c_str()))
	 {
		 execute(s1,c); 
	 } 
	 else 
	 {
		 execute(s2,c);
	 }
      rule whilestmt(c1, s,p) :
	 while(c.true_value(evaluate(c1,c).c_str())) execute(s,c);
      rule dowhileloop(c1,s,p):
	 try { while(c.true_value(evaluate(c1,c).c_str())) execute(s,c);}
	 catch(int n ) {if (n!=1) throw;}
      rule dountilloop(c1,s,p):
	 try { while(!c.true_value(evaluate(c1,c).c_str())) execute(s,c);}
	 catch(int n) {if (n!=1) throw;}	 
      rule doloopwhile(s,c1,p):
	 try  {do { execute(s,c);} while (c.true_value(evaluate(c1,c).c_str()));}
	 catch(int n) {if (n!=1) throw;}
      rule doloopuntil(s,c1,p):
         try {do { execute(s,c);} while (!c.true_value(evaluate(c1,c).c_str()));}
	 catch(int n) {if (n!=1) throw;}
      rule exitdo(p):
	 throw 1;
      rule exitfor(p):
	 throw 2;
      rule exitsub(p):
         throw 3;
      rule fornext(n,from,to,step,st,p):
	 execute(assignment(n,from,p),c);
	 int i;
         char tmp[32];
	 try{ 
	 	for( i = c.int_value(evaluate(from,c).c_str());
			i <= c.int_value(evaluate(to,c).c_str());
			i+=c.int_value(evaluate(step,c).c_str()))
	    	{
	 		sprintf(tmp,"#%d",i);
         		execute(assignment(n,value(tmp,p),p),c);
			execute(st,c);
	    	}
	 }
	 catch(int n )
	 {
		if (n!=2) throw;
	 }
      rule select_case(e,s1,s2,p):
	 docase(e,s1,s2,c);
      rule seq(s1, s2,p) :
	 execute(s1,c); execute(s2,c);
      rule declsub(n,args,body,p):
	 execute(decl(n,p),c);
	 extract_arg(n,args,c,1);
	 c.save_func(n,body);
      rule callsub(n,b,p):
	 set_args(n,b,c,1);
	 c.call(n); 
      rule declarray(s,subs,p):
	 c.create_array(s,array_num(subs,c,s));
      rule randomize(x,p):
	 c.init_rnd(evaluate(x,c).c_str());
      rule randomize0(p):
	 c.init_rnd0();	
      rule empty(p) :
	 ;
   }
}

int array_idx(CaseList list,int n,int dim,Cvbs_context& c,const char* name)
{
   int idx;
   int the_dim;
   int ii;
   
   match list
   {
        rule subs(i,next,p):
           
           the_dim = c.get_array_dim(name,n)+1;
           idx = (1==n)? i + array_idx(next,n+1,the_dim*dim,c,name) : dim*i + array_idx(next,n+1,the_dim*dim,c,name);
	rule argreflist(e,next,p):
	   ii = c.int_value(evaluate(e,c).c_str());
	   the_dim = c.get_array_dim(name,n)+1;
	   idx = (1==n)? ii + array_idx(next,n+1,the_dim*dim,c,name) : dim*ii + array_idx(next,n+1,the_dim*dim,c,name);
        rule null():
	   idx = 0;
   }
   return idx;
}

int array_num(CaseList list,Cvbs_context& c,const char* name)
{
   int m;
   string v;
   char tmp[32];
   match list
   {
        rule subs(n,next,p):
           m = (n+1)*array_num(next,c,name);
           v=c.get_var(name);
	   sprintf(tmp,"%u",n+1);
	   c.set_array_dim(name,n);
        rule null():
           m = 1 ;
   }
   return m;
}

void set_args(const char* szFn,CaseList list,Cvbs_context& c,int i)
{
   string v;
   match list
   {
        rule argreflist(a,next,p):
                v = evaluate(a,c);
                c.set_arg_val(szFn,i,v.c_str());
                set_args(szFn,next,c,i+1);
        rule null():
                ;
   }
}

void extract_arg(const char* fn,CaseList list,Cvbs_context& c,int i)
{
   
   char tmp[32];
   string at;
   match list
   {
	rule arglist(name(a,p),next,q):
		at = fn;
		at += "@";
		at += a;
		sprintf(tmp,"@%u",i);
		at += tmp;
		execute(decl(at.c_str(),q),c);
		extract_arg(fn,next,c,i+1);
	rule null(p):
		;
   }
}


void docase(Expression e,CaseList list,Statement s2,Cvbs_context& c)
{
  match list
  {
       rule case_node(cond,st,next,p):
                if (c.true_value(evaluate(eq(e,cond,p),c).c_str()))
                {
                       execute(st,c);
		}
                else
                {
                       docase(e,next,s2,c);
                }
                      
       rule null():
                execute(s2,c);
  }             
}