nepc.c

一个小计算器的实现(编译原理),用Lex和bison

/* routines for parse */
#ifndef _NEPC_C_
#define _NEPC_C_

#include "nepc.h"
#include <string.h>
 
#include "nepc.tab.h"
 
sysType* symname_lookup2(char *symname,int level ,int line)
{
	int i;
	sysType*p=NULL;
	p=sysInfo.sysHead;
	
	while(p!=NULL)
	{
		if(
			(strcmp(p->sysCommon->name,symname)==0)&&
			(p->sysCommon->level<=level) &&
			(p->useFlag==1)

		)
		{

                   return p;
		
		}
		p=p->nextNode;
			

	}

    return NULL;
}


sysType* symname_lookup(char *symname,int level ,int line)
{
	int i;
	sysType*p=NULL;
	p=sysInfo.sysHead;
	
	while(p!=NULL)
	{
		if(
			(strcmp(p->sysCommon->name,symname)==0)&&
			(p->sysCommon->level==level) &&
			(p->useFlag==1)

		)
		{

                   return p;
		
		}
		p=p->nextNode;

	}
    printf("sys name can not found\n");
    return NULL;
}

sysType* symname_install(char*name,int level ,int line)
{
    sysType*ret=NULL;
    sysType*p=NULL;

    long*p2;
    int size=0;


    ret=symname_lookup(name,level,line);
    if(ret != NULL )return ret; 
	
    p =(sysType*) malloc(sizeof(sysType));

	
    size=sizeof(commonType);
    p2=(commonType*)malloc(size);
    p->sysCommon=p2;

    p->sysCommon->name=name;
	p->sysCommon->level=level;
    p->nextNode=NULL;
    p->useFlag=1;

   if(sysInfo.first==0)
   	{
		sysInfo.sysHead=p;
		sysInfo.sysTail=p;
		sysInfo.first++;
		sysInfo.sysTail->nextNode=NULL;
   	}
    else
	{
		sysInfo.sysTail->nextNode= p;
		sysInfo.sysTail=p;
		sysInfo.sysTail->nextNode=NULL;
	}
	sysInfo.G_sys_number++;
    return (p);
}

nodeType *con_int(INT value)
{
    nodeType *p;
    long *p2;
    int nodeSize;
    int size;
    /* allocate node */
    nodeSize = sizeof(nodeType);
    if ((p =(nodeType*) malloc(nodeSize)) == NULL)
	{
        //yyerror("In con_int(): malloc fail!");
	}
	
    /* copy information */
    size=sizeof(commonType);
    p2=(commonType*)malloc(size);
    p->nodeCommon=p2;
	
    p->nodeCommon->type=typeInt;
    p->nodeCommon->iValue=value;
    return p;
}

nodeType *con_flt(FLT value) 
{
    nodeType *p;
    long *p2;
    int size;
    /* allocate node */
    size = sizeof(nodeType);
    if ((p =(nodeType*) malloc(size)) == NULL)
	{
       //yyerror("In con_int(): malloc fail!");
	}
    /* copy information */
    size=sizeof(commonType);
    p2=(commonType*)malloc(size);
    p->nodeCommon=p2;
	
    p->nodeCommon->type=typeFloat;
    p->nodeCommon->fValue=value;
    return p;
}

nodeType *con_str(char * sptr)
{
    nodeType *p;
    long *p2;
    int nodeSize;
    int len;
    int size;
    /* allocate node */
    nodeSize = sizeof(nodeType);
    if ((p =(nodeType*) malloc(nodeSize)) == NULL)
	{
        //yyerror("out of memory");
	}
    /* copy information */
    size=sizeof(commonType);
    p2=(commonType*)malloc(size);
    p->nodeCommon=p2;

	
    size=strlen(sptr);
    p2=(char*)malloc(size);
    memcpy(p2,sptr,size);

	
    p->nodeCommon->strValue=p2;
    p->nodeCommon->strValueSize=size;

    
    printf("in con_str, got string: %s\n",sptr);
    return p;
}

nodeType * var(char * sptr,int level,int line)
{
	nodeType *p;
	long *p2;
	sysType *ret;
	int size;
      sysType* sys;
	ret=symname_install(sptr,level,line);
	
    p = (nodeType*)malloc(sizeof(nodeType));

	
    size=sizeof(commonType);
    p2=(commonType*)malloc(size);
    p->nodeCommon=p2;

    size=strlen(sptr);
    p2=(char*)malloc(size);
    memcpy(p2,sptr,size);
    p->nodeCommon->name=p2;
    p->nodeCommon->nameSize=size;

 
    /* copy information */
    p->nodeCommon->type = typeVar;
    p->sysPoint=ret;

    return p;
}

nodeType *opr(int oper, int nops, ...) 
{
    va_list ap;
    nodeType *p;
    long *p2;
    int size;
    int i;
  
    size =  sizeof(nodeType);
    if ((p =(nodeType*) malloc(size)) == NULL)
	{
        //yyerror("out of memory");
	}
	
    size=sizeof(commonType);
    p2=(commonType*)malloc(size);
    p->nodeCommon=p2;
    p->nodeCommon->type=typeOpr;
    p->oprChildNum=nops;
    p->oprCurName=oper;

    size=(nops)*sizeof(nodeType*);
  /*  p2=(nodeType*)malloc(size);
    p->oprChild[0]=p2;*/
	
   va_start(ap, nops);
    for (i = 0; i < nops; i++)
    {
        p->oprChild[i] = (nodeType *)va_arg(ap, nodeType*);
        if(NULL==p->oprChild[i] )
		{
			return NULL;
		}

    }
    va_end(ap);
    return p;
}

nodeType * interpret(nodeType * p3) 
{

    int nodesize;
    int len;
    int n;
    int size;
    long*p2;
	nodeType *p;
   nodeType *p4;
    nodeType *pret, *pret1, *pret2;
    if ( p3 == NULL ) return NULL;
    p=p3;
    pret=malloc(sizeof(nodeType));
    if( NULL == pret )yyerror("out of memory");

    size=sizeof(commonType);
    p2=(commonType*)malloc(size);
    pret->nodeCommon=p2;

    pret->nodeCommon->type=typeInt;
    pret->nodeCommon->iValue=1;   // default to return "true"
    
    switch(p->nodeCommon->type)
    {
        case typeInt :
            pret->nodeCommon->iValue=p->nodeCommon->iValue;
    		pret->nodeCommon->type=typeInt;
            return pret;
            break;
        case typeFloat:
            pret->nodeCommon->fValue=p->nodeCommon->fValue;
    		pret->nodeCommon->type=typeFloat;
            return pret;
            break;
        case typeString:
            len=strlen(p->nodeCommon->strValueSize);
            pret->nodeCommon->strValue= malloc( len + 1 );
            strncpy(pret->nodeCommon->strValue, p->nodeCommon->strValue, len);
    		pret->nodeCommon->type==typeString;
            return pret;
            break;
        case typeVar:

            size=sizeof(commonType);
            memcpy( pret->nodeCommon, p->sysPoint->sysCommon, size );

            if( p->sysPoint->sysCommon->type == typeString)
            {
	            len=strlen(p->nodeCommon->strValueSize);
	            pret->nodeCommon->strValue= malloc( len + 1 );
	            strncpy(pret->nodeCommon->strValue, p->nodeCommon->strValue, len);
            }
            return pret;
            break;
        case typeOpr:
        switch(p->oprCurName) 
        {

            case PRINT:
                pret1 = interpret(p->oprChild[0]);
                if( NULL==pret1 )return NULL;
                if( pret1->nodeCommon->type == typeInt )PRINTINT(pret1->nodeCommon->iValue);
                else if( pret1->nodeCommon->type == typeFloat )PRINTFLT(pret1->nodeCommon->fValue);
                else if( pret1->nodeCommon->type == typeString )PRINTSTR(pret1->nodeCommon->strValue);
                free(pret1);
                return pret;
                break;
            case ';':
                pret1 = interpret(p->oprChild[0]);
                pret2 = interpret(p->oprChild[1]);
		    if(pret1!=NULL)
                free(pret1);
		    if(pret2!=NULL)
                free(pret2);
                return pret;
                break;
            case '=':
                pret2 = interpret(p->oprChild[1]);
                if( NULL==pret2 )return NULL;
				p4=p->oprChild[0];
                if( pret2->nodeCommon->type== typeInt )
				{   
					p4->sysPoint->sysCommon->iValue= pret2->nodeCommon->iValue;
                	}
                else if( pret2->nodeCommon->type== typeFloat )
			{
					p4->sysPoint->sysCommon->fValue= pret2->nodeCommon->fValue;
                	}
                else if( pret2->nodeCommon->type)
                {
                    if(p->sysPoint->sysCommon->type ==typeString )
                        free( p->sysPoint->sysCommon->strValue );
				p4->sysPoint->sysCommon->strValue=pret2->nodeCommon->strValue;
				p4->sysPoint->sysCommon->strValueSize=pret2->nodeCommon->strValueSize;
                }
                p4->sysPoint->sysCommon->type = pret2->nodeCommon->type;
                free(pret2);
                return pret;
                break;

            case '+':
                pret1=interpret(p->oprChild[0]);
                pret2=interpret(p->oprChild[1]);
                if( NULL==pret1 || NULL==pret2)
                {
                    free(pret1);
                    free(pret2);
                    return NULL;
                }
                if(pret1->nodeCommon->type==typeInt && pret2->nodeCommon->type==typeInt)
                {
                    pret1->nodeCommon->iValue+= pret2->nodeCommon->iValue;
                    free(pret2);
                    return pret1;
                }
                else if(pret1->nodeCommon->type==typeFloat && pret2->nodeCommon->type==typeFloat)
                {
                    pret1->nodeCommon->fValue
						  += pret2->nodeCommon->fValue;
                    free(pret2);
                    return pret1;
                }
                else if(pret1->nodeCommon->type==typeInt && pret2->nodeCommon->type==typeFloat)
                {
                    pret1->nodeCommon->fValue += pret1->nodeCommon->iValue;
                    free(pret1);
                    return pret2;
                }
                else if(pret1->nodeCommon->type==typeFloat && pret2->nodeCommon->type==typeInt)
                {
                    pret1->nodeCommon->fValue += pret2->nodeCommon->iValue;
                    free(pret2);
                    return pret1;
                }
                else if(pret1->nodeCommon->type==typeString && pret2->nodeCommon->type==typeString)
                {
                    int m=pret1->nodeCommon->strValueSize;
                    int n= pret2->nodeCommon->strValueSize;
                    char *s= malloc( m+n);
                    strncpy(s,pret1->nodeCommon->strValue,m);
                    strncat(s,pret2->nodeCommon->strValue,n);

                    free(pret1->nodeCommon->strValue);
                    free(pret2->nodeCommon->strValue);
                    pret1->nodeCommon->strValue=s;
			pret1->nodeCommon->strValueSize=m+n;
                    return pret1;
                }
                else
                {
                    free(pret1);
                    free(pret2);
                    pret->nodeCommon->iValue=0;
                    return pret;
                }
                break;

        default:
        printf("Bad node type!\n");
       }
    }
    pret->nodeCommon->iValue=0;
    return pret;
}
#endif