nepc.c

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

                }
                else if(pret1->type==typeFlt && pret2->type==typeInt)
                {
                    if(pret1->fval >= pret2->ival) pret->ival =1 ;
                    else pret->ival=0;
                }
                else
                {
                    pret->ival=0;
                }
                free(pret1);
                free(pret2);
                return pret;
                break;
            case LE:
                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)
                {
                    if(pret1->ival <= pret2->ival) pret->ival =1 ;
                    else pret->ival=0;
                }
                else if(pret1->type==typeFlt && pret2->type==typeFlt)
                {
                   if(pret1->fval <= pret2->fval) pret->ival =1 ;
                    else pret->ival=0;
                }
                else if(pret1->type==typeInt && pret2->type==typeFlt)
                {
                    if(pret1->ival <= pret2->fval) pret->ival =1 ;
                    else pret->ival=0;
                }
                else if(pret1->type==typeFlt && pret2->type==typeInt)
                {
                    if(pret1->fval <= pret2->ival) pret->ival =1 ;
                    else pret->ival=0;
                }
                else
                {
                    pret->ival=0;
                }
                free(pret1);
                free(pret2);
                return pret;
                break;
            case NE:
                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)
                {
                    if(pret1->ival != pret2->ival) pret->ival =1 ;
                    else pret->ival=0;
                }
                else if(pret1->type==typeFlt && pret2->type==typeFlt)
                {
                   if(pret1->fval != pret2->fval) pret->ival =1 ;
                    else pret->ival=0;
                }
                else if(pret1->type==typeInt && pret2->type==typeFlt)
                {
                    if(pret1->ival != pret2->fval) pret->ival =1 ;
                    else pret->ival=0;
                }
                else if(pret1->type==typeFlt && pret2->type==typeInt)
                {
                    if(pret1->fval != pret2->ival) pret->ival =1 ;
                    else pret->ival=0;
                }
                else
                {
                    pret->ival=0;
                }
                free(pret1);
                free(pret2);
                return pret;
                break;
            case EQ:
                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)
                {
                    if(pret1->ival == pret2->ival) pret->ival =1 ;
                    else pret->ival=0;
                }
                else if(pret1->type==typeFlt && pret2->type==typeFlt)
                {
                   if(pret1->fval == pret2->fval) pret->ival =1 ;
                    else pret->ival=0;
                }
                else if(pret1->type==typeInt && pret2->type==typeFlt)
                {
                    if(pret1->ival == pret2->fval) pret->ival =1 ;
                    else pret->ival=0;
                }
                else if(pret1->type==typeFlt && pret2->type==typeInt)
                {
                    if(pret1->fval == pret2->ival) pret->ival =1 ;
                    else pret->ival=0;
                }
                else
                {
                    pret->ival=0;
                }
                free(pret1);
                free(pret2);
                return pret;
                break;
            case ACOS:
                pret1=interpret(p->opr.op[0]);
                if( NULL==pret1 )return NULL;
                
                pret->type=typeFlt;
                pret->fval=p_acos(pret1->fval);
                free(pret1);
                return pret;
                break;
            case ASIN:
                pret1=interpret(p->opr.op[0]);
                if( NULL==pret1 )return NULL;
                pret->type=typeFlt;
                pret->fval=p_asin(pret1->fval);
                free(pret1);
                return pret;
                break;
            case ATAN:
                pret1=interpret(p->opr.op[0]);
                if( NULL==pret1 )return NULL;
                pret->type=typeFlt;
                pret->fval=p_atan(pret1->fval);
                free(pret1);
                return pret;
                break;
            case CEIL:
                pret1=interpret(p->opr.op[0]);
                if( NULL==pret1 )return NULL;
                pret->type=typeFlt;
                pret->fval=p_ceil(pret1->fval);
                free(pret1);
                return pret;
                break;
            case COS:
                pret1=interpret(p->opr.op[0]);
                if( NULL==pret1 )return NULL;
                if( pret1->type == typeStr )
                {
                    pret->ival=0;
                    free(pret1);
                    return pret;
                }
                if(pret1->type == typeInt)pret1->fval=(FLT)(pret1->ival);
                pret->type=typeFlt;
                pret->fval=p_cos(pret1->fval);
                free(pret1);
                return pret;
                break;
            case COSH:
                pret1=interpret(p->opr.op[0]);
                if( NULL==pret1 )return NULL;
                if( pret1->type == typeStr )
                {
                    pret->ival=0;
                    free(pret1);
                    return pret;
                }
                if(pret1->type == typeInt)pret1->fval=(FLT)(pret1->ival);
                pret->type=typeFlt;
                pret->fval=p_cosh(pret1->fval);
                free(pret1);
                return pret;
                break;
            case EXP:
                pret1=interpret(p->opr.op[0]);
                if( NULL==pret1 )return NULL;
                if( pret1->type == typeStr )
                {
                    pret->ival=0;
                    free(pret1);
                    return pret;
                }
                if(pret1->type == typeInt)pret1->fval=(FLT)(pret1->ival);
                pret->type=typeFlt;
                pret->fval=p_exp(pret1->fval);
                free(pret1);
                return pret;
                break;
            case FABS:
                pret1=interpret(p->opr.op[0]);
                if( NULL==pret1 )return NULL;
                if( pret1->type == typeStr )
                {
                    pret->ival=0;
                    free(pret1);
                    return pret;
                }
                if(pret1->type == typeInt)pret1->fval=(FLT)(pret1->ival);
                pret->type=typeFlt;
                pret->fval=p_fabs(pret1->fval);
                free(pret1);
                return pret;
                break;
            case FLOOR:
                pret1=interpret(p->opr.op[0]);
                if( NULL==pret1 )return NULL;
                if( pret1->type == typeStr )
                {
                    pret->ival=0;
                    free(pret1);
                    return pret;
                }
                if(pret1->type == typeInt)pret1->fval=(FLT)(pret1->ival);
                pret->type=typeFlt;
                pret->fval=p_floor(pret1->fval);
                free(pret1);
                return pret;
                break;
            case LOG:
                pret1=interpret(p->opr.op[0]);
                if( NULL==pret1 )return NULL;
                if( pret1->type == typeStr )
                {
                    pret->ival=0;
                    free(pret1);
                    return pret;
                }
                if(pret1->type == typeInt)pret1->fval=(FLT)(pret1->ival);
                pret->type=typeFlt;
                pret->fval=p_log(pret1->fval);
                free(pret1);
                return pret;
                break;
            case LOG10:
                pret1=interpret(p->opr.op[0]);
                if( NULL==pret1 )return NULL;
                if( pret1->type == typeStr )
                {
                    pret->ival=0;
                    free(pret1);
                    return pret;
                }
                if(pret1->type == typeInt)pret1->fval=(FLT)(pret1->ival);
                pret->type=typeFlt;
                pret->fval=p_log10(pret1->fval);
                free(pret1);
                return pret;
                break;
            case SIN:
                pret1=interpret(p->opr.op[0]);
                if( NULL==pret1 )return NULL;
                if( pret1->type == typeStr )
                {
                    pret->ival=0;
                    free(pret1);
                    return pret;
                }
                if(pret1->type == typeInt)pret1->fval=(FLT)(pret1->ival);
                pret->type=typeFlt;
                pret->fval=p_sin(pret1->fval);
                free(pret1);
                return pret;
                break;
            case SINH:
                pret1=interpret(p->opr.op[0]);
                if( NULL==pret1 )return NULL;
                if( pret1->type == typeStr )
                {
                    pret->ival=0;
                    free(pret1);
                    return pret;
                }
                if(pret1->type == typeInt)pret1->fval=(FLT)(pret1->ival);
                pret->type=typeFlt;
                pret->fval=p_sinh(pret1->fval);
                free(pret1);
                return pret;
                break;
            case SQRT:
                pret1=interpret(p->opr.op[0]);
                if( NULL==pret1 )return NULL;
                if( pret1->type == typeStr )
                {
                    pret->ival=0;
                    free(pret1);
                    return pret;
                }
                if(pret1->type == typeInt)pret1->fval=(FLT)(pret1->ival);
                pret->type=typeFlt;
                pret->fval=p_sqrt(pret1->fval);
                free(pret1);
                return pret;
                break;
            case TAN:
                pret1=interpret(p->opr.op[0]);
                if( NULL==pret1 )return NULL;
                if( pret1->type == typeStr )
                {
                    pret->ival=0;
                    free(pret1);
                    return pret;
                }
                if(pret1->type == typeInt)pret1->fval=(FLT)(pret1->ival);
                pret->type=typeFlt;
                pret->fval=p_tan(pret1->fval);
                free(pret1);
                return pret;
                break;
            case TANH:
                pret1=interpret(p->opr.op[0]);
                if( NULL==pret1 )return NULL;
                if( pret1->type == typeStr )
                {
                    pret->ival=0;
                    free(pret1);
                    return pret;
                }
                if(pret1->type == typeInt)pret1->fval=(FLT)(pret1->ival);
                pret->type=typeFlt;
                pret->fval=p_tanh(pret1->fval);
                free(pret1);
                return pret;
                break;
            default:
                printf("Bad operator!\n");
        }
        default:
        printf("Bad node type!\n");
    }
    pret->ival=0;
    return pret;
}
#endif