nepc.c

使用yacc和lex编写的cmm语言的词法分析和语法分析程序.

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




void initSymTable()
{
   int i;
   for(i=0;i<MAX_SYMNUM;i++)
   {
        symtab[i].name = NULL ;
        symtab[i].pstr= NULL ;
   }
   symtop=0;

}
int symname_lookup(char *symname )
{
    int i;
    for(i=0;i<symtop;i++)
    {
        if( strcmp( symtab[i].name, symname )==0 )return i; 
    }
    return SYM_NOTFOUND;
}

int symname_install( char *symname )
{
    int ret;
    ret=symname_lookup(symname);
    if(ret != SYM_NOTFOUND )return ret; 

    if(symtop>MAX_SYMNUM)
    {
        printf("In symname_install(): symbol table overflow!\n");
        return SYMTAB_OVFLW;
    }
    symtab[symtop].name=symname;
    symtop++;
    return (symtop-1);
}

nodeType *con_int(INT value)
{
    nodeType *p;
    size_t nodeSize;
    /* allocate node */
    nodeSize = SIZEOF_NODETYPE(p) + sizeof(intNodeType);
    if ((p = malloc(nodeSize)) == NULL)
        yyerror("In con_int(): malloc fail!");
    /* copy information */
    p->type = typeIntCon;
    p->intCon.val = value;
    return p;
}

nodeType *con_flt(FLT value) 
{
    nodeType *p;
    size_t nodeSize;
    /* allocate node */
    nodeSize = SIZEOF_NODETYPE(p) + sizeof(fltNodeType);
    if ((p = malloc(nodeSize)) == NULL)
        yyerror("out of memory");
    /* copy information */
    p->type = typeFltCon;
    p->fltCon.val = value;
    return p;
}

nodeType *con_str(char * sptr)
{
    int len;
    nodeType *p;
    size_t nodeSize;
    /* allocate node */
    nodeSize = SIZEOF_NODETYPE(p) + sizeof(strNodeType);
    if ((p = malloc(nodeSize)) == NULL)
        yyerror("out of memory");

    len=strlen(sptr);
    p->strCon.ptr = malloc(len+1);
    if( NULL == p->strCon.ptr)
    {
        printf("In con_str(): symbol malloc error!\n");
        return NULL;
    }
    /* copy information */
    p->type = typeStrCon;
    strncpy(p->strCon.ptr, sptr, len);
    p->strCon.ptr[len]='\0';
    
    //printf("in con_str, got string: %s\n",p->strCon.ptr);
    return p;
}

nodeType * var(char * sptr)
{
    int index=symname_lookup(sptr);
    if(index==SYM_NOTFOUND)
    {
        printf(">> '%s' is undefined!\n", sptr);
        return NULL;
    }
    nodeType *p;
    size_t nodeSize;
    /* allocate node */
    nodeSize = SIZEOF_NODETYPE(p) + sizeof(varNodeType);
    if ((p = malloc(nodeSize)) == NULL)
        yyerror("out of memory");
    /* copy information */
    p->type = typeVar;
    p->var.index = index;
    return p;
}

nodeType *opr(int oper, int nops, ...) 
{
    va_list ap;
    nodeType *p;
    size_t nodeSize;
    int i;
 
    nodeSize = SIZEOF_NODETYPE(p) + sizeof(oprNodeType) +
        (nops - 1) * sizeof(nodeType*);
    if ((p = malloc(nodeSize)) == NULL)
        yyerror("out of memory");

    p->type = typeOpr;
    p->opr.name = oper;
    p->opr.number = nops;
    va_start(ap, nops);
    for (i = 0; i < nops; i++)
    {
        p->opr.op[i] = va_arg(ap, nodeType*);
        if( NULL == p->opr.op[i]) return NULL;
    }
    va_end(ap);
    return p;
}

void freeNode(nodeType *p)
{
    int i;
    if (!p) return;
    if (p->type == typeOpr) 
    {
        for (i = 0; i < p->opr.number; i++) 
            freeNode(p->opr.op[i]);
    }
    else if( p->type == typeStrCon)
    {
        free(p->strCon.ptr);
    }
    free (p);
}

void freeSymTable()
{
    int i;
    for(i=0;i<symtop;i++)
    {
        free( symtab[i].name );
        if(symtab[i].type == typeStr)
        {
            free(symtab[i].pstr);
            symtab[i].pstr=NULL;
        }
    }
    symtop=0;
}
itpType * interpret(nodeType *p) 
{
    if ( p == NULL ) return NULL;
    int nodesize;
    int len;
    int n;
    itpType *pret, *pret1, *pret2;
    pret=malloc(sizeof(itpType));
    if( NULL == pret )yyerror("out of memory");
    pret->type=typeInt;
    pret->ival=1;   // default to return "true"

    switch(p->type)
    {
        case typeIntCon:
            pret->ival=p->intCon.val;
            pret->type=typeInt;
            return pret;
            break;
        case typeFltCon:
            pret->fval=p->fltCon.val;
            pret->type=typeFlt;
            return pret;
            break;
        case typeStrCon:
            len=strlen(p->strCon.ptr);
            pret->pstr = malloc( len + 1 );
            strncpy(pret->pstr, p->strCon.ptr, len);
            pret->pstr[len]='\0';
            pret->type=typeStr;
            return pret;
            break;
        case typeVar:
            nodesize=sizeof( symType );
            memcpy( pret, &symtab[p->var.index], nodesize );
            if( pret->type == typeStr)
            {
                len= strlen(pret->pstr);
                pret->pstr= malloc( len+1 );
                if(pret->pstr == NULL )yyerror("out of memory");
                strncpy(pret->pstr, symtab[p->var.index].pstr, len );
                pret->pstr[len]='\0';
            }
            return pret;
            break;
        case typeOpr:
        switch(p->opr.name) 
        {
            case WHILE:
                pret1=interpret(p->opr.op[0]);
                if( NULL==pret1 )return NULL;
                while((pret1->type==typeInt && pret1->ival)||
                      (pret1->type==typeFlt && pret1->fval)||
                      (pret1->type==typeStr && pret1->pstr))
                {
                        pret2=interpret(p->opr.op[1]);
                        free(pret2);
                        free(pret1);
                        pret1=interpret(p->opr.op[0]);
                        if( NULL==pret1 )return NULL;
                }
                free(pret1);
                return pret;
                break;
            case IF:
                pret1=interpret(p->opr.op[0]);
                if( NULL==pret1 )return NULL;
                if((pret1->type==typeInt && pret1->ival)||
                   (pret1->type==typeFlt && pret1->fval)||
                   (pret1->type==typeStr && pret1->pstr))
                {
                    pret2=interpret(p->opr.op[1]);
                    free(pret2);
                    free(pret1);
                }
                else if (p->opr.number > 2)
                {
                    pret2=interpret(p->opr.op[2]);
                    free(pret2);
                    free(pret1);
                }
                return pret;
                break;
            case PRINT:
                pret1 = interpret(p->opr.op[0]);
                if( NULL==pret1 )return NULL;
                if( pret1->type == typeInt )PRINTINT(pret1);
                else if( pret1->type == typeFlt )PRINTFLT(pret1);
                else if( pret1->type == typeStr )PRINTSTR(pret1);
                free(pret1);
                return pret;
                break;
            case ';':
                pret1 = interpret(p->opr.op[0]);
                pret2 = interpret(p->opr.op[1]);
                free(pret1);
                free(pret2);
                return pret;
                break;
            case '=':
                pret2 = interpret(p->opr.op[1]);
                if( NULL==pret2 )return NULL;
                if( pret2->type == typeInt )symtab[p->opr.op[0]->var.index].ival = pret2->ival ;
                else if( pret2->type == typeFlt )symtab[p->opr.op[0]->var.index].fval = pret2->fval ;
                else if( pret2->type == typeStr )
                {
                    if(symtab[p->opr.op[0]->var.index].type ==typeStr )
                        free( symtab[p->opr.op[0]->var.index].pstr );
                    symtab[p->opr.op[0]->var.index].pstr = pret2->pstr ;
                }
                symtab[p->opr.op[0]->var.index].type = pret2->type;
                free(pret2);
                return pret;
                break;
            case UMINUS:
                pret1=interpret(p->opr.op[0]);
                if( NULL==pret1 )return NULL;
                if( pret1->type == typeInt ) pret1->ival= - pret1->ival;
                else if( pret1->type == typeFlt ) pret1->fval= - pret1->fval;
                return pret1;
                break;
            case PP:
                if( symtab[p->opr.op[0]->var.index].type == typeInt )
                {
                    symtab[p->opr.op[0]->var.index].ival += 1;
                    pret->ival=symtab[p->opr.op[0]->var.index].ival;
                }
                else if( symtab[p->opr.op[0]->var.index].type == typeFlt )
                {
                    symtab[p->opr.op[0]->var.index].fval += 1.0;
                    pret->type=typeFlt;
                    pret->fval=symtab[p->opr.op[0]->var.index].fval;
                }
                else return 0;
                return pret;
                break;
            case SS:
                if( symtab[p->opr.op[0]->var.index].type == typeInt )
                {
                    symtab[p->opr.op[0]->var.index].ival -= 1;
                    pret->ival=symtab[p->opr.op[0]->var.index].ival;
                }
                else if( symtab[p->opr.op[0]->var.index].type == typeFlt )
                {
                    symtab[p->opr.op[0]->var.index].fval -= 1.0;
                    pret->type=typeFlt;
                    pret->fval=symtab[p->opr.op[0]->var.index].fval;
                }
                else pret->ival=0;
                return pret;
                break;
            case '+':
                pret1=interpret(p->opr.op[0]);
                pret2=interpret(p->opr.op[1]);
                if( NULL==pret1 || NULL==pret2)
                {
                    free(pret1);
                    free(pret2);
                    return NULL;
                }
                if(pret1->type==typeInt && pret2->type==typeInt)
                {
                    pret1->ival += pret2->ival;
                    free(pret2);
                    return pret1;
                }
                else if(pret1->type==typeFlt && pret2->type==typeFlt)
                {
                    pret1->fval += pret2->fval;
                    free(pret2);
                    return pret1;
                }
                else if(pret1->type==typeInt && pret2->type==typeFlt)
                {
                    pret2->fval += pret1->ival;
                    free(pret1);
                    return pret2;
                }