ucvm9.cpp

绘制一元函数曲线的工具 输入C语言语法的函数公式, 即可绘制函数的二维曲线 采用内置编译器和虚拟机(这是调整OK的版本)

            switch(((T_VAR *)(m_ins_array[i].ins_data))->var_type)
            {
            case UCVM9_TYPE_CHR:
                *(char *)(((T_VAR *)(m_ins_array[i].ins_data))->var_addr) = rparame_to_chr();
                break;

            case UCVM9_TYPE_STR:
                if(NULL != (char *)(((T_VAR *)(m_ins_array[i].ins_data))->var_addr))
                 delete [] (char *)(((T_VAR *)(m_ins_array[i].ins_data))->var_addr);

                 (char *)(((T_VAR *)(m_ins_array[i].ins_data))->var_addr) = rparame_to_str();
                break;

            case UCVM9_TYPE_INT:
                *(long *)(((T_VAR *)(m_ins_array[i].ins_data))->var_addr) = rparame_to_int();
                break;

            case UCVM9_TYPE_FLT:
                *(REAL *)(((T_VAR *)(m_ins_array[i].ins_data))->var_addr) = rparame_to_flt();
                break;
            }

            m_dat_point ++;

            m_dat_stack[m_dat_point].dat_type =
                ((T_VAR *)(m_ins_array[i].ins_data))->var_type;

            m_dat_stack[m_dat_point].dat_addr =
                ((T_VAR *)(m_ins_array[i].ins_data))->var_addr;

            free_rparame();
            break;

        case 0x17://add_as;
            break;

        case 0x18://sub_as;
            break;

        case 0x19://mul_as;
            break;

        case 0x1a://div_as;
            break;

        case 0x1b://rem_as;
            break;

        case 0x1c://and_as;
            break;

        case 0x1d://xor_as;
            break;

        case 0x1e://oor_as;
            break;

        case 0x1f://shl_as;
            break;

        case 0x20://shr_as;
            break;

        case 0x21://cmp_ne;
            break;

        case 0x22://cmp_eq;
            break;

        case 0x23://cmp_le;
            break;

        case 0x24://cmp_ge;
            break;

        case 0x25://cmp_ll;
            break;

        case 0x26://cmp_gg;
            break;

        case 0x27://jmp_ez;
            break;

        case 0x28://jmp_nz;
            break;

        case 0x29://jmp_to;
            break;

        case 0x2a://jmp_ne;
            break;

        case 0x2b://jmp_eq;
            break;

        case 0x2c://jmp_le;
            break;

        case 0x2d://jmp_ge;
            break;

        case 0x2e://jmp_ll;
            break;

        case 0x2f://jmp_gg;
            break;

        case 0x30://inc_af;
            break;

        case 0x31://inc_bf;
            break;

        case 0x32://dec_af;
            break;

        case 0x33://dec_bf;
            break;

        case 0x34://call_f;
            {
                T_FUN *func;
                long   nmbr;
                void  *addr;
                char   type;

                func = (T_FUN *)(m_ins_array[i].ins_data);
                nmbr = *(long *)(m_dat_stack[m_dat_point --].dat_addr);

                type = func->fun_type;
                addr = func->fun_addr(nmbr, m_dat_stack + m_dat_point);

                while(nmbr -- > 0)
                {
                    if(m_dat_stack[m_dat_point].dat_free != NULL)
                    {
                        delete [] m_dat_stack[m_dat_point].dat_free;
                        m_dat_stack[m_dat_point].dat_free = NULL;
                    }

                    m_dat_point --;
                };

                m_dat_point ++;

                m_dat_stack[m_dat_point].dat_type = type;

                m_dat_stack[m_dat_point].dat_addr =
                m_dat_stack[m_dat_point].dat_free = (char *)addr;
            }
            break;
        }
    }
}
//---------------------------------------------------------------------------
void * TUCVM9::search_fun(char *fun_name)
{
    int i;

    for(i = 0; i < m_fun_count; i ++)
    {
        if(strcmp(fun_name, (const char *)m_fun_array[i].fun_name) == 0)
        {
            return(m_fun_array + i);
        }
    }

    return(0);
}
//---------------------------------------------------------------------------
void * TUCVM9::search_var(char *var_name)
{
    int i;

    for(i = 0; i < m_var_count; i ++)
    {
        if(strcmp(var_name, (const char *)m_var_array[i].var_name) == 0)
        {
            return(m_var_array + i);
        }
    }

    return(0);
}
//---------------------------------------------------------------------------
void * TUCVM9::search_lab(char *lab_name)
{
    int i;

    for(i = 0; i < m_ins_count; i ++)
    {
        if(m_ins_array[i].ins_code == 0x35)
        {
            if(strcmp(lab_name, (const char *)m_ins_array[i].ins_data) == 0)
            {
                delete [] lab_name;

                return(m_ins_array + i);
            }
        }
    }

    delete [] lab_name;

    return(0);
}
//---------------------------------------------------------------------------
char * TUCVM9::cclone_str(char *str_data)
{
    char *result;

    result = new char[strlen(str_data) + 1];

    strcpy(result, str_data);

    return(result);
}
//---------------------------------------------------------------------------
void TUCVM9::pop_rparame()
{
    m_dat_rparame->dat_type = m_dat_stack[m_dat_point].dat_type;
    m_dat_rparame->dat_addr = m_dat_stack[m_dat_point].dat_addr;
    m_dat_rparame->dat_free = m_dat_stack[m_dat_point].dat_free;

    m_dat_stack[m_dat_point].dat_free = NULL;

    m_dat_point --;
}
//---------------------------------------------------------------------------
void TUCVM9::pop_lparame()
{
    m_dat_lparame->dat_type = m_dat_stack[m_dat_point].dat_type;
    m_dat_lparame->dat_addr = m_dat_stack[m_dat_point].dat_addr;
    m_dat_lparame->dat_free = m_dat_stack[m_dat_point].dat_free;

    m_dat_stack[m_dat_point].dat_free = NULL;

    m_dat_point --;
}
//---------------------------------------------------------------------------
void TUCVM9::free_rparame()
{
    if(m_dat_rparame->dat_free != NULL)
        delete [] m_dat_rparame->dat_free;
}
//---------------------------------------------------------------------------
void TUCVM9::free_lparame()
{
    if(m_dat_lparame->dat_free != NULL)
        delete [] m_dat_lparame->dat_free;
}
//---------------------------------------------------------------------------
void TUCVM9::push_chr(char vchr)
{
    m_dat_point ++;

    m_dat_stack[m_dat_point].dat_type = UCVM9_TYPE_CHR;
    m_dat_stack[m_dat_point].dat_addr =
    m_dat_stack[m_dat_point].dat_free = (char *)new char[sizeof(char)];

    *(char *)(m_dat_stack[m_dat_point].dat_free) = vchr;
}
//---------------------------------------------------------------------------
void TUCVM9::push_int(long vint)
{
    m_dat_point ++;

    m_dat_stack[m_dat_point].dat_type = UCVM9_TYPE_INT;
    m_dat_stack[m_dat_point].dat_addr =
    m_dat_stack[m_dat_point].dat_free = (char *)new char[sizeof(long)];

    *(long *)(m_dat_stack[m_dat_point].dat_free) = vint;
}
//---------------------------------------------------------------------------
void TUCVM9::push_flt(REAL vflt)
{
    m_dat_point ++;

    m_dat_stack[m_dat_point].dat_type = UCVM9_TYPE_FLT;
    m_dat_stack[m_dat_point].dat_addr =
    m_dat_stack[m_dat_point].dat_free = (char *)new char[sizeof(REAL)];

    *(REAL *)(m_dat_stack[m_dat_point].dat_free) = vflt;
}
//---------------------------------------------------------------------------
char TUCVM9::rparame_to_chr()
{
    if(m_dat_rparame->dat_type == UCVM9_TYPE_FLT)
        return(*(REAL *)m_dat_rparame->dat_addr);
    else
    if(m_dat_rparame->dat_type == UCVM9_TYPE_INT)
        return(*(long *)m_dat_rparame->dat_addr);
    else
        return(*(char *)m_dat_rparame->dat_addr);
}
//---------------------------------------------------------------------------
char TUCVM9::lparame_to_chr()
{
    if(m_dat_lparame->dat_type == UCVM9_TYPE_FLT)
        return(*(REAL *)m_dat_lparame->dat_addr);
    else
    if(m_dat_lparame->dat_type == UCVM9_TYPE_INT)
        return(*(long *)m_dat_lparame->dat_addr);
    else
        return(*(char *)m_dat_lparame->dat_addr);
}
//---------------------------------------------------------------------------
long TUCVM9::rparame_to_int()
{
    if(m_dat_rparame->dat_type == UCVM9_TYPE_FLT)
        return(*(REAL *)m_dat_rparame->dat_addr);
    else
    if(m_dat_rparame->dat_type == UCVM9_TYPE_INT)
        return(*(long *)m_dat_rparame->dat_addr);
    else
        return(*(char *)m_dat_rparame->dat_addr);
}
//---------------------------------------------------------------------------
long TUCVM9::lparame_to_int()
{
    if(m_dat_lparame->dat_type == UCVM9_TYPE_FLT)
        return(*(REAL *)m_dat_lparame->dat_addr);
    else
    if(m_dat_lparame->dat_type == UCVM9_TYPE_INT)
        return(*(long *)m_dat_lparame->dat_addr);
    else
        return(*(char *)m_dat_lparame->dat_addr);
}
//---------------------------------------------------------------------------
REAL TUCVM9::rparame_to_flt()
{
    if(m_dat_rparame->dat_type == UCVM9_TYPE_FLT)
        return(*(REAL *)m_dat_rparame->dat_addr);
    else
    if(m_dat_rparame->dat_type == UCVM9_TYPE_INT)
        return(*(long *)m_dat_rparame->dat_addr);
    else
        return(*(char *)m_dat_rparame->dat_addr);
}
//---------------------------------------------------------------------------
REAL TUCVM9::lparame_to_flt()
{
    if(m_dat_lparame->dat_type == UCVM9_TYPE_FLT)
        return(*(REAL *)m_dat_lparame->dat_addr);
    else
    if(m_dat_lparame->dat_type == UCVM9_TYPE_INT)
        return(*(long *)m_dat_lparame->dat_addr);
    else
        return(*(char *)m_dat_lparame->dat_addr);
}
//---------------------------------------------------------------------------
char * TUCVM9::rparame_to_str()
{
    if(m_dat_rparame->dat_type == UCVM9_TYPE_STR)
        return(cclone_str((char *)m_dat_rparame->dat_addr));
    else
        return(cclone_str(""));
}
//---------------------------------------------------------------------------
char * TUCVM9::lparame_to_str()
{
    if(m_dat_lparame->dat_type == UCVM9_TYPE_STR)
        return(cclone_str((char *)m_dat_lparame->dat_addr));
    else
        return(cclone_str(""));
}
//---------------------------------------------------------------------------
#endif//UCVM9_CPP