basic1.c

用C语言写的YABasic解释器

       	     *result++ = STRING_TYPE;
       	     if (*(v+1)=='0'&&*(v+2)!='.') *result++ = '0';       	     	          	     
       	     else if (*(v+1)=='-') *result++='-';
             else *result++='+';
             *result=0;
     }            
}

void do_operation1(char o, char *v, char *result)
{
     switch (o) 
     {
	    case OP_NOT : exec_not(v,result); break;
	    case OP_ABS : exec_abs(v,result); break;
	    case OP_ATN : exec_atn(v,result); break;
	    case OP_COS : exec_cos(v,result); break;
	    case OP_EXP : exec_exp(v,result); break;
	    case OP_INT : exec_int(v,result); break;
	    case OP_LOG : exec_log(v,result); break;
	    case OP_RND : exec_rnd(v,result); break;
	    case OP_SIN : exec_sin(v,result); break;
	    case OP_SQR : exec_sqr(v,result); break;
	    case OP_TAN : exec_tan(v,result); break;
	    case OP_ASC : exec_asc(v,result); break;
	    case OP_CHR : exec_chr(v,result); break;
	    case OP_LEN : exec_len(v,result); break;
/*	    case OP_MKS : exec_mks(v,result); break; */
	    case OP_STR : exec_str(v,result); break;
	    case OP_VAL : exec_val(v,result); break;
/*	    case OP_CVI : exec_cvi(v,result); break;
	    case OP_CVS : exec_cvs(v,result); break;
	    case OP_MKI : exec_mki(v,result); break;   */
	    case OP_EOF : exec_eof(v,result); break;         
	    case OP_SGN : exec_sgn(v,result); break;
	    default :  
	              MemFree(v); 
	              serror(0);  
	              break;
     }
     MemFree(v);
}

char *popup_datastack(Data_List *d_stack)
{
    char *s; 
    Data_List *q,*p;    
    
    p = d_stack;
    if (d_stack->data==(char *)Null) return (char *)Null;
    if (d_stack->next==(Data_List *)Null) 
    { 
    	s = d_stack->data; 
    	d_stack->data = (char *)Null;
    	return s;
    }
    while (p->next!=(Data_List *)Null) 
    { 
    	q = p; 
    	p = p->next; 
    }
    s = p->data;
    q->next = (Data_List *)Null;
    MemFree((UInt8 *)p);
    return s;
}

char popup_opstack(Op_List *o_stack)
{
    char s;
    Op_List *q, *p;
    p = o_stack;
    if (o_stack->cod==0) serror(27);       /***运算非法,缺少运算符***/
    if (o_stack->next==(Op_List *)Null) 
    { 
    	s = o_stack->cod ; 
    	o_stack->cod = 0; 
    	return s;
    }
    while (p->next) 
    { 
    	q = p; 
    	p = p->next;
    }
    s = p->cod; /*p=q->next;*/
    q->next = (Op_List *)Null;
    MemFree((UInt8 *)p);
    return s;
}

void push_datastack(Data_List *d_stack, Op_List *o_stack, char *key)
{
    Data_List *q, *p;
    char *temp;
    
    p = d_stack;    
    IsInteger(key);
    if ((temp=(char *)MemAlloc(Strlen(key)+2))==(char *)Null) serror(1);    /***内存溢出***/
    else 
    { 
    	    Strcpy(temp,key); 
    	    *(temp+Strlen(key)) = 0;
    }
    if (!d_stack->data)
    {
	    d_stack->data = temp;
	    return;
    }
    if (o_stack->cod==0) 
    {
    	MemFree(temp);
    	serror(0);
    }
    if ((q = (Data_List *)MemAlloc(sizeof(Data_List)))==(Data_List *)Null) 
    {
    	     MemFree(temp);
    	     serror(1);       /***内存溢出***/
    }
    q->data = temp;
    q->next = (Data_List *)Null;
    while (p->next!=(Data_List *)Null) p = p->next;
    p->next = q;
}


void popup_opstack_all(Data_List * d_stack, Op_List * o_stack, char *result)
{
     char o, *r1, *r2;
     while (o_stack->cod!=0) 
     {
	 if ((o=popup_opstack(o_stack))<OP_NOT)   /*operation2*/	
	 {
		 if ((r2 = popup_datastack(d_stack))==(char*)Null) serror(0);
		 if ((r1 = popup_datastack(d_stack))==(char*)Null) 
		 {
		 	MemFree(r2);
		 	serror(0);
		 }
	         arith(o,r1,r2,result); 
	 }
	 else 
	 {                                 /*operation1*/
	         cod_trace = &o_stack->cod;
	         do_operation1(o, popup_datastack(d_stack),result);	 
	 }
	 push_datastack(d_stack, o_stack, result);
     }
     if (d_stack->data!=(char*)Null)
               Strcpy(result,d_stack->data); 
     if (d_stack->next!=(Data_List *)Null) serror(0);     
     MemFree(d_stack->data);
}

void push_opstack(struct op_list *o_stack, char *key)
{
     struct op_list *q, *p;
     p = o_stack;
     if (o_stack->cod==0) 
     {
	 p->priority = get_priority(key);
	 p->cod = *key;
	 return;
     }
     if ((q = (struct op_list *)MemAlloc(sizeof(Op_List)))==(struct op_list *)Null) serror(1);  /*****内存溢出******/
     q->priority = get_priority(key); 
     q->cod = *key;   
     q->next = (struct op_list *)Null;
     while (p->next) p = p->next;
     p->next = q;     
}

void TestOp(Data_List *d_stack, Op_List *o_stack, char *op2, char *result)
{
     Op_List *op1; 
     char prior, o, *r1, *r2, flag;     /*flag 记录")"操作符*/
     
     
     Strcpy(op_b,op2); 
     prior = get_priority(op_b);
     for (;;)
     {
     	  if (o_stack->cod==0) 
     	  {
     	  	if (*op_b<OP_NOT&&*op_b!=34&&d_stack->data==(char *)Null) serror(0);/*34:是"("*/
        	if (*op2=='-'&&d_stack->data==(char*)Null) push_datastack(d_stack, o_stack, "10");
        	return; 
          }
          op1 = o_stack;
          while (op1->next!=(Op_List*)Null) op1=op1->next;          
          if (op1->priority==15||prior==15) return;
          if (op1->priority>=prior) 
          {
	        if ((o=popup_opstack(o_stack))<OP_NOT) 
	        {	    	  	    	  	    	      	  	 	    	  	  	    	  
	    	      if ((r2 = popup_datastack(d_stack))==(char*)Null) 	    	              
	    	                serror(28);
	    	      if ((r1 = popup_datastack(d_stack))==(char*)Null) {
	    	  	        MemFree(r2);
	    	                serror(28);
	    	      }	    	  	    	  
	              arith(o,r1,r2,result);
	        }
	        else
	              do_operation1(o, popup_datastack(d_stack),result);
	        push_datastack(d_stack, o_stack, result);
          } else
	        return;
     }
}

FAR void get_exp(char *result)
{
     Op_List 		*o_stack; 
     Data_List 		*d_stack;
     Do_List 		*dltemp, *fdltemp;
     char               ch[3], flag;
     double             c;
          
     if ((dltemp = (Do_List*)MemAlloc(sizeof(Do_List)))==(Do_List*)Null) serror(1);     /***内存溢出***/
     if ((d_stack = (Data_List *)MemAlloc(sizeof(Data_List)))==(Data_List *)Null) 
     {
     	       MemFree((UInt8*)dltemp);
     	       serror(1);          /***内存溢出***/
     }
     if ((o_stack = (Op_List *)MemAlloc(sizeof(Op_List)))==(Op_List *)Null) 
     {
     	    MemFree((UInt8*)dltemp);
     	    MemFree((UInt8*)d_stack);
            serror(1);             /***内存溢出***/
     }          
     if (dl==(Do_List*)Null) dl = dltemp;
     else 
     {
     	      fdltemp = dl;
     	      while (fdltemp->next!=(Do_List*)Null) fdltemp=fdltemp->next;     	      	      
     	      fdltemp->next = dltemp;
     }                    
     dltemp->fd = d_stack; 
     dltemp->od = o_stack; 
     dltemp->next = (Do_List*)Null;      
     d_stack->next=(Data_List *)Null;
     o_stack->next=(Op_List *)Null;
     d_stack->data=(char *)Null;
     o_stack->cod=0;
                  
     flag = 2;
     get_token(1);
     while (token_type==QUOTE||*token!=0x0D&&*token!=0&&token_type!=COMMAND&&!Strchr(";,:",*token)) {
	 if (!*token&&token_type!=QUOTE) serror(28);      /***进行表达式运算时,表达式为空,运算出错***/
	 switch (token_type) 
	 {
		case VARIABLE:
		     if ((*token=='-'||*token=='+')&&*(token+1)!=0)
		     {
		     	       Strcpy(ch,"10");
		     	       push_datastack(d_stack,o_stack, ch);
		     	       if (*token=='-') Strcpy(ch,"-");
		     	       else Strcpy(ch,"+");
		     	       push_opstack(o_stack,ch);
		     	       push_datastack(d_stack, o_stack, get_variables(token+1));
		     	       flag = 1;
		     }
		     else 
		     {
		     	if (flag ==1 ) serror(0);
		     	push_datastack(d_stack, o_stack, get_variables(token));
		     	flag = 1;
		     }
		     break;
		case NUMBER:
		     if (*token=='+') *token=REAL_TYPE;
		     else if (*token=='-')		           
		     {
		     	       Strcpy(ch,"10");
		     	       push_datastack(d_stack,o_stack, ch);
		     	       Strcpy(ch,"-");
		     	       push_opstack(o_stack,ch);
		     	       *token=REAL_TYPE;
		     }
		     else 
		               add_type(token,REAL_TYPE);		     
		     if ((c = atof(token+1))>=1E16) serror(1);
		     if (c==0) Strcpy(token+1,"0");
		     if (flag == 1) serror(0);
		     push_datastack(d_stack, o_stack, token);
		     flag = 1;
		     break;
		case QUOTE:
		     add_type(token,STRING_TYPE);
		     if (flag == 1) serror(0);
		     push_datastack(d_stack, o_stack, token);
		     flag =1;
		     break;
		case BOOL_TYPE:
		     if (flag == 1) serror(0);
		     push_datastack(d_stack, o_stack, token);
		     flag = 1;
		     break;
		case OPERATION1:
		     if (*token=='-'||*token=='+') 
		     {
		     	    if (*prog==0x20&&Stricmp(token+1,"not")) serror(0);
		     	    Strcpy(ch,"10");
		     	    push_datastack(d_stack, o_stack, ch);
		     	    if (*token=='-') Strcpy(ch,"-");
		     	    else Strcpy(ch,"+");
		     	    push_opstack(o_stack,ch);
		     	    push_opstack(o_stack,token+1);		     	    
		     }
		     else 
		     {
		     	    if (*prog==0x20&&Stricmp(token,"not")) serror(0);
		            push_opstack(o_stack,token);		            
		     }
		     break;
	        default:
	             if ((*token=='-'||*token=='+')&&*(token+1)=='(') 
	             {
	             	   Strcpy(ch,"10");
		     	   push_datastack(d_stack, o_stack, ch);
		     	   if (*token=='-') Strcpy(ch,"-");
		     	   else Strcpy(ch,"+");
		     	   push_opstack(o_stack,ch);
		     	   push_opstack(o_stack,token+1); 
	             }
	             else 
	             {	                  	        
		           TestOp(d_stack, o_stack, token, result);
		           if (*token==')') popup_opstack(o_stack);
		           else 
		           {
		           	if (flag == 0&& *token!='(') serror(0);
		           	if (*token!='(') flag = 0;
		           	push_opstack(o_stack, token);		           	
		           }
		     }
		     break;
	 } 
	 get_token(1);
     }
     if (flag==0) serror(0);
     popup_opstack_all(d_stack, o_stack, result);
     putback();
     if (dltemp!=dl)
             fdltemp->next=(Do_List*)Null;
     else 
             dl=(Do_List*)Null;
     MemFree((UInt8 *)o_stack); MemFree((UInt8 *)d_stack);
     MemFree((Int8*)dltemp); 
}

/*
void exec_play()
{
     char *value;
     value=(char *)MemAlloc(VALUE_SIZE);
     if (value==(char *)Null) serror(14);
     get_exp(value);
     if (*value!=STRING_TYPE) serror(0);
     play(value+1);
     MemFree(value);
}

void exec_cvi(char *v, char *result)
{
     *result++=INTEGER_TYPE; v++;
     while (v!='\0') {
     }
}

void exec_cvs(char *v, char *result)
{
}
void exec_mki(char *v, char *result)
{
}
*/