posts - 8,  comments - 4,  trackbacks - 0

一个简单的虚拟机,虚拟机有100个字的内存,几个寄存器——指令计数器、指令寄存器、操作码寄存器、内存地址寄存器、累加寄存器。可以——输入01、输出02、加载数据到寄存器03、存放数据到内存04、简单的加05060708运算、转移09、小于零转移10、等于零转移11、终止12。程序输入完,输入0000结束。

 

打印两个数中的较大数

0120 //输入一个数到内存20

0121 //输入一个数到内存21

0320 //加载内存20的数据到累加器

0621 //累加器数据减去内存21 的数据

1007 //如果小于零转移到内存07

0220 //输出内存20的数据

1200 //终止

0221 //输出内存21的数据

1200 //终止

0000 //输入结束

 

运行

Virtual machine is booting...

Complete booting.

 

Please input your program.

00 0120

01 0121

02 0320

03 0621

04 1007

05 0220

06 1200

07 0221

08 1200

09 0000

Good job.

 

Virtual machine is loading the program...

Complete loading.

 

Virtual machine is printing the program...

00 0120

01 0121

02 0320

03 0621

04 1007

05 0220

06 1200

07 0221

08 1200

Complete printing.


Virtual machine is running the program...

opcode address

01        20

100


opcode address

01        21

200


opcode address

03        20


opcode address

06        21


opcode address

10        07


opcode address

02        21

200


Complete running.

Virtual machine is shutting...

Complete shutting.


//leaf_core_test.cpp
文件

//Copyright (c) LeafCore
#include <iostream>
#include 
"leaf_core_virtual_machine.hpp"

using namespace std;

int main(int argc, char *argv[])
{
    CVirtualMachine virtual_machine; 
//创建虚拟机对象
    int program[100]; //存放程序
    int buffer;

    
//启动虚拟机
    virtual_machine.boot();

    
//输入程序
    cout<<"Please enter your program"<<endl;
    cout
<<"00\t";
    cin
>>buffer;
    
for (int index = 0; (program[index] = buffer)!=0; index++) {
        cout
<<(index+1)/10<<(index+1)%10<<"\t";
        cin
>>buffer;
    }
    cout
<<"Good job.\n"<<endl;

    
//加载程序到虚拟机内存
    virtual_machine.load_program(program);
    
//打印程序
    virtual_machine.print_program();
    
//运行程序
    virtual_machine.run_program();

    
//关闭虚拟机
    virtual_machine.shut();

    
char ch;
    cout
<<"Window closing"<<endl;
    cin
>>ch;
    
return 0;
}


//leaf_core_virtual_machine.hpp文件

//Copyright (c) LeafCore
#ifndef __leaf_core_virtual_machine_hpp__
#define __leaf_core_virtual_machine_hpp__

class CVirtualMachine {
private:
    
int m_memory[100]; //内存
    int m_instruction_counter; //指令计数器
    int m_instruction_register; //指令寄存器
    int m_opcode; //操作码
    int m_address; //内存地址
    int m_accumulator; //寄存器
public:
//Virtual Machine操作码
    static const int const_input = 1//存放用户输入数据到内存
    static const int const_print = 2//输出内存数据到屏幕
    static const int const_load = 3//加载内存数据到寄存器
    static const int const_store = 4//存放寄存器数据到内存
    static const int const_plus = 5//寄存器数据加上内存数据
    static const int const_minus = 6//寄存器数据减去内存数据
    static const int const_multiply = 7//寄存器数据乘以内存数据
    static const int const_divide = 8//寄存器数据除以内存数据
    static const int const_branch = 9//转移
    static const int const_branch_below = 10//寄存器数据小于零转移
    static const int const_branch_zero = 11//寄存器数据等于零转移
    static const int const_halt = 12//终止
public:
    CVirtualMachine();
    
~CVirtualMachine();

    
void boot(); //启动虚拟机
    void shut(); //关闭虚拟机
    void load_program(int *program); //加载程序到虚拟机内存
    void print_program(); //打印程序
    void run_program(); //运行程序
};

#endif


//leaf_core_virtual_machine.cpp文件

//Copyright (c) LeafCore
#include <iostream>
#include 
"leaf_core_virtual_machine.hpp"

using namespace std;

//初始化虚拟机
CVirtualMachine::CVirtualMachine()
{
    m_instruction_counter 
= 0;
    m_instruction_register 
= 0;
    m_opcode 
= 0;
    m_address 
= 0;
}

CVirtualMachine::
~CVirtualMachine()
{
}

//启动虚拟机
void CVirtualMachine::boot()
{
    cout
<<"Virtual machine is booting"<<endl;
    cout
<<"Complete booting.\n"<<endl;
}

//关闭虚拟机
void CVirtualMachine::shut()
{
    cout
<<"Virtual machine is shutting"<<endl;
    cout
<<"Complete shutting.\n"<<endl;
}

//加载程序到虚拟机内存
void CVirtualMachine::load_program(int *program)
{
    
int index;
    cout
<<"Virtual machine is loading the program"<<endl;
    
for (index = 0; index<100 && program[index]!=0; index++) {
        m_memory[index] 
= program[index];
    }
    m_memory[index] 
= program[index];
    cout
<<"Complete loading.\n"<<endl;
}

//打印程序
void CVirtualMachine::print_program()
{
    
int index;
    cout
<<"Virtual machine is printing the program"<<endl;
    
for (index = 0; index<100 && m_memory[index]!=0; index++) {
        cout
<<index/10<<index%10<<"\t";
        cout
<<m_memory[index]/1000<<m_memory[index]%1000/100
            
<<m_memory[index]%100/10<<m_memory[index]%10<<endl;
    }
    cout
<<"Complete printing.\n"<<endl;
}

//运行程序
void CVirtualMachine::run_program()
{
    
int index;
    cout
<<"Virtual machine is running the program"<<endl;

    
//取出指令
    m_instruction_counter = 0;
    m_instruction_register 
= m_memory[m_instruction_counter++];
    
//指令解码
    m_opcode = m_instruction_register/100;
    m_address 
= m_instruction_register%100;
    
for (index = 0; index<100 && m_opcode!=const_halt; index++) {
        cout
<<"opcode\taddress"<<endl;
        cout
<<m_opcode/10<<m_opcode%10<<"\t"<<m_address/10<<m_address%10<<endl;

        
//执行指令
        switch (m_opcode) {
        
case const_input:
            
int buffer;
            cin
>>buffer;
            m_memory[m_address] 
= buffer;
            
break;
        
case const_print:
            cout
<<m_memory[m_address]<<endl;
            
break;
        
case const_load:
            m_accumulator 
= m_memory[m_address];
            
break;
        
case const_store:
            m_memory[m_address] 
= m_accumulator;
            
break;
        
case const_plus:
            m_accumulator 
+= m_memory[m_address];
            
break;
        
case const_minus:
            m_accumulator 
-= m_memory[m_address];
            
break;
        
case const_multiply:
            m_accumulator 
*= m_memory[m_address];
            
break;
        
case const_divide:
            m_accumulator 
/= m_memory[m_address];
            
break;
        
case const_branch:
            m_instruction_counter 
= m_address;
            
break;
        
case const_branch_below:
            
if (m_accumulator<0) {
                m_instruction_counter 
= m_address;
            }
            
break;
        
case const_branch_zero:
            
if (m_accumulator==0) {
                m_instruction_counter 
= m_address;
            }
            
break;
        
default:
            
break;
        }
        cout
<<endl;

        
//取出指令
        m_instruction_register = m_memory[m_instruction_counter++];
        
//指令解码
        m_opcode = m_instruction_register/100;
        m_address 
= m_instruction_register%100;
    }
    cout
<<"Complete running.\n"<<endl;
}

 

posted on 2011-06-08 19:14 leafcore 阅读(2613) 评论(2)  编辑 收藏 引用

FeedBack:
# re: 一个简单的虚拟机
2011-06-08 20:44 | ooseven
自己做虚拟机的话,我还是偏好堆栈机,本身作为软件模拟寄存器的速度毫无优势,最重要的是当你做编译器的时候,你会发现加了个寄存器为代码优化带来无尽的麻烦.  回复  更多评论
  
# re: 一个简单的虚拟机
2011-06-18 12:37 | 陈森虎
这个东西是不是要学编译原理,能给我一份完整的代码吗?我都用LUA的  回复  更多评论
  

只有注册用户登录后才能发表评论。
【推荐】超50万行VC++源码: 大型组态工控、电力仿真CAD与GIS源码库
网站导航: 博客园   IT新闻   BlogJava   知识库   博问   管理



常用链接

留言簿

文章分类(2)

交流与思索

让生活更轻松

最新评论

阅读排行榜