这绝对不是所谓的宏替换！
这是真正的全编译，是新的编译器！
代码先编译成中文汇编码，然后经过中汇编译成机器码，最后连接生成可执行文件！

[ 本帖最后由 a2120258 于 2011-10-6 21:01 编辑 ]

编译器在1.69版后已经算稳定了，关键字和C语言一样，只不过多了写中文关键字而已！
执行效率和C语言一样的！
现在正在扩充他的库文件。
你看着变扭是因为，已经看慣了英文代码。
习语言也支持英文代码编译

贪吃蛇编译成中文汇编如下：




[处理器 486]
[指令模式 双字模式]
[外部的 __fltused]
[外部的 __ftol]
[外部的 __chkstk]

;=========数据段定义===========
段声明 .数据

短语_0          定义字节  '得分：%整',00H
短语_1          定义字节  '游戏结束！',00H
短语_2          定义字节  'kernel32.dll',00H
短语_3          定义字节  'Sleep',00H
短语_4          定义字节  '习语言简易版贪吃蛇    by   花心胡萝卜  ',00H
短语_5          定义字节  '习语言 简易贪吃蛇   花心胡萝卜编写。',00H
短语_6          定义字节  '控制方法：上 W，下 S，左 A，右 D。',00H
短语_7          定义字节  '按任意键开始玩。',00H
短语_8          定义字节  '由于刚开始玩习语言，很多不知道的东西！',00H
短语_9          定义字节  '所以导致程序不美观，',00H
短语_10         定义字节  '希望大家见谅！',00H
短语_11         定义字节  '欢迎大家与我讨论习语言！',00H
短语_12         定义字节  'QQ：84613538',00H
短语_13         定义字节  '习语言官方论坛：http://www.',00H
短语_14         定义字节  '习语言QQ群：61440235',00H
短语_15         定义字节  '欢迎使用习语言！',00H


对齐    4

公共的          _计数         4

公共的          _标识         4

公共的          _定时器标识   4

全局的          _得分
_得分           定义双字  00H


全局的          _游戏速度
_游戏速度       定义双字  012cH


公共的          _食物画笔     12

公共的          _蛇画笔       12

公共的          _定时器控制   4

公共的          _定时器按键   4

公共的          _食物         12

公共的          _蛇           1612


;=========代码段定义===========
段声明 .代码


外部的          _图形初始化显示器

外部的          _图形打开显示器

外部的          _图形关闭显示器

外部的          _图形等待显示器关闭

外部的          _图形初始化定时器

外部的          _图形创建定时器

外部的          _图形销毁定时器

外部的          _图形清屏

外部的          _图形设置背景色

外部的          _图形设置画笔

外部的          _图形获取画笔

外部的          _图形设置画刷

外部的          _图形获取画刷

外部的          _图形画方框

外部的          _图形输出文字

外部的          _获取按键

外部的          _格式化

外部的          _取随机数

外部的          _获取模块证

外部的          _获取函数地址


全局的          _显示器消息主处理
_显示器消息主处理:
                入栈        基址指针32
                入栈        基址寄存器32
                入栈        源变址寄存器32
                入栈        终变址寄存器32
                移动        基址指针32, 堆栈指针32
                比较        双字类型 [基址指针32+20], 0100H
                若小于跳转  标签_9
                比较        双字类型 [基址指针32+20], 0100H
                若大于跳转  标签_9
                比较        双字类型 [基址指针32+24], 87
                若相等跳转  标签_0
                比较        双字类型 [基址指针32+24], 119
                若不等跳转  标签_1
标签_0:
                比较        双字类型 [_蛇+1604], 4
                若相等跳转  标签_1
                移动        双字类型 [_蛇+1604], 3
                跳转到      标签_9
标签_1:
                比较        双字类型 [基址指针32+24], 68
                若相等跳转  标签_2
                比较        双字类型 [基址指针32+24], 100
                若不等跳转  标签_3
标签_2:
                比较        双字类型 [_蛇+1604], 2
                若相等跳转  标签_3
                移动        双字类型 [_蛇+1604], 1
                跳转到      标签_9
标签_3:
                比较        双字类型 [基址指针32+24], 65
                若相等跳转  标签_4
                比较        双字类型 [基址指针32+24], 97
                若不等跳转  标签_5
标签_4:
                比较        双字类型 [_蛇+1604], 1
                若相等跳转  标签_5
                移动        双字类型 [_蛇+1604], 2
                跳转到      标签_9
标签_5:
                比较        双字类型 [基址指针32+24], 83
                若相等跳转  标签_6
                比较        双字类型 [基址指针32+24], 115
                若不等跳转  标签_7
标签_6:
                比较        双字类型 [_蛇+1604], 3
                若相等跳转  标签_7
                移动        双字类型 [_蛇+1604], 4
                跳转到      标签_9
标签_7:
                比较        双字类型 [基址指针32+24], 88
                若相等跳转  标签_8
                比较        双字类型 [基址指针32+24], 120
                若不等跳转  标签_9
标签_8:
                入栈        双字类型 1
                调用        _图形关闭显示器
                加          堆栈指针32, 4
标签_9:
                移动        累加器32, 0
                移动        堆栈指针32, 基址指针32
                出栈        终变址寄存器32
                出栈        源变址寄存器32
                出栈        基址寄存器32
                出栈        基址指针32
                返回


全局的          _游戏结果
_游戏结果:
                入栈        基址指针32
                入栈        基址寄存器32
                入栈        源变址寄存器32
                入栈        终变址寄存器32
                移动        基址指针32, 堆栈指针32
                减          堆栈指针32, 8
                取有效地址  累加器32, [短语_0]
                入栈        双字类型 [_得分]
                入栈        双字类型 累加器32
                入栈        双字类型 20
                入栈        双字类型 [基址指针32-4]
                调用        _格式化
                加          堆栈指针32, 16
                入栈        双字类型 [基址指针32-4]
                入栈        双字类型 22
                入栈        双字类型 55
                调用        _图形输出文字
                加          堆栈指针32, 12
                移动        堆栈指针32, 基址指针32
                出栈        终变址寄存器32
                出栈        源变址寄存器32
                出栈        基址寄存器32
                出栈        基址指针32
                返回


全局的          _游戏结束
_游戏结束:
                入栈        基址指针32
                入栈        基址寄存器32
                入栈        源变址寄存器32
                入栈        终变址寄存器32
                移动        基址指针32, 堆栈指针32
                减          堆栈指针32, 20
                入栈        双字类型 1
                调用        _图形销毁定时器
                加          堆栈指针32, 4
                调用        _图形清屏
                加          堆栈指针32, 0
                取有效地址  累加器32, [基址指针32-12]
                入栈        双字类型 累加器32
                移动        双字类型 [基址指针32-16], 累加器32
                调用        _图形获取画刷
                加          堆栈指针32, 4
                移动        双字类型 [基址指针32-4], 0E4E4DAH
                入栈        双字类型 [基址指针32-16]
                调用        _图形设置画刷
                加          堆栈指针32, 4
                入栈        双字类型 0E4E4DAH
                调用        _图形设置背景色
                加          堆栈指针32, 4
                取有效地址  累加器32, [短语_1]
                入栈        双字类型 累加器32
                入栈        双字类型 230
                入栈        双字类型 0104H
                调用        _图形输出文字
                加          堆栈指针32, 12
                调用        _游戏结果
                加          堆栈指针32, 0
                移动        堆栈指针32, 基址指针32
                出栈        终变址寄存器32
                出栈        源变址寄存器32
                出栈        基址寄存器32
                出栈        基址指针32
                返回


全局的          _延时
_延时:
                入栈        基址指针32
                入栈        基址寄存器32
                入栈        源变址寄存器32
                入栈        终变址寄存器32
                移动        基址指针32, 堆栈指针32
                减          堆栈指针32, 16
                取有效地址  累加器32, [短语_2]
                入栈        双字类型 累加器32
                调用        _获取模块证
                加          堆栈指针32, 4
                移动        双字类型 [基址指针32-4], 累加器32
                取有效地址  累加器32, [短语_3]
                入栈        双字类型 累加器32
                入栈        双字类型 [基址指针32-4]
                调用        _获取函数地址
                加          堆栈指针32, 8
                移动        双字类型 [基址指针32-8], 累加器32
                入栈        双字类型 [基址指针32+20]
                调用        双字类型 [基址指针32-8]
                移动        堆栈指针32, 基址指针32
                出栈        终变址寄存器32
                出栈        源变址寄存器32
                出栈        基址寄存器32
                出栈        基址指针32
                返回


全局的          _绘画
_绘画:
                入栈        基址指针32
                入栈        基址寄存器32
                入栈        源变址寄存器32
                入栈        终变址寄存器32
                移动        基址指针32, 堆栈指针32
                减          堆栈指针32, 40
                移动        双字类型 [基址指针32-4], 255
                调用        _图形清屏
                加          堆栈指针32, 0
                取有效地址  累加器32, [基址指针32-16]
                入栈        双字类型 累加器32
                移动        双字类型 [基址指针32-20], 累加器32
                调用        _图形获取画刷
                加          堆栈指针32, 4
                移动        双字类型 [基址指针32-8], 0E4E4DAH
                入栈        双字类型 [基址指针32-20]
                调用        _图形设置画刷
                加          堆栈指针32, 4
                入栈        双字类型 0E4E4DAH
                调用        _图形设置背景色
                加          堆栈指针32, 4
                取有效地址  累加器32, [_蛇画笔]
                入栈        双字类型 累加器32
                移动        双字类型 [基址指针32-24], 累加器32
                调用        _图形获取画笔
                加          堆栈指针32, 4
                移动        累加器32, 双字类型 [基址指针32-4]
                移动        双字类型 [_蛇画笔+8], 累加器32
                移动        双字类型 [_蛇画笔], 0
                入栈        双字类型 [基址指针32-24]
                调用        _图形设置画笔
                加          堆栈指针32, 4
                移动        双字类型 [_计数], 50
                跳转到      标签_11
标签_10:
                移动        累加器32, 双字类型 [_计数]
                加          累加器32, 10
                入栈        双字类型 49
                入栈        双字类型 累加器32
                入栈        双字类型 40
                入栈        双字类型 [_计数]
                移动        双字类型 [基址指针32-28], 累加器32
                调用        _图形画方框
                加          堆栈指针32, 16
                入栈        双字类型 01CCH
                入栈        双字类型 [基址指针32-28]
                入栈        双字类型 01C3H
                入栈        双字类型 [_计数]
                调用        _图形画方框
                加          堆栈指针32, 16
                移动        累加器32, 双字类型 [_计数]
                加          累加器32, 10
                移动        双字类型 [_计数], 累加器32
标签_11:
                比较        双字类型 [_计数], 0258H
                若小等跳转  标签_10
                移动        双字类型 [_计数], 40
                跳转到      标签_13
标签_12:
                移动        累加器32, 双字类型 [_计数]
                加          累加器32, 10
                入栈        双字类型 累加器32
                入栈        双字类型 59
                入栈        双字类型 [_计数]
                入栈        双字类型 50
                移动        双字类型 [基址指针32-36], 累加器32
                调用        _图形画方框
                加          堆栈指针32, 16
                入栈        双字类型 [基址指针32-36]
                入栈        双字类型 0262H
                入栈        双字类型 [_计数]
                入栈        双字类型 0259H
                调用        _图形画方框
                加          堆栈指针32, 16
                移动        累加器32, 双字类型 [_计数]
                加          累加器32, 10
                移动        双字类型 [_计数], 累加器32
标签_13:
                比较        双字类型 [_计数], 01C2H
                若小等跳转  标签_12
                调用        _游戏结果
                加          堆栈指针32, 0
                移动        堆栈指针32, 基址指针32
                出栈        终变址寄存器32
                出栈        源变址寄存器32
                出栈        基址寄存器32
                出栈        基址指针32
                返回


全局的          _定时器事件处理主函数
_定时器事件处理主函数:
                入栈        基址指针32
                入栈        基址寄存器32
                入栈        源变址寄存器32
                入栈        终变址寄存器32
                移动        基址指针32, 堆栈指针32
                减          堆栈指针32, 0104H
                调用        _绘画
                加          堆栈指针32, 0
                比较        双字类型 [_食物+8], 1
                若不等跳转  标签_18
                调用        _取随机数
                加          堆栈指针32, 0
                移动        计数器32, 0190H
                双字扩展
                符号除      计数器32
                移动        双字类型 [基址指针32-8], 数据寄存器32
                移动        累加器32, 双字类型 [基址指针32-8]
                加          累加器32, 60
                移动        双字类型 [_食物], 累加器32
                调用        _取随机数
                加          堆栈指针32, 0
                移动        计数器32, 015EH
                双字扩展
                符号除      计数器32
                移动        双字类型 [基址指针32-20], 数据寄存器32
                移动        累加器32, 双字类型 [基址指针32-20]
                加          累加器32, 60
                移动        双字类型 [_食物+4], 累加器32
                跳转到      标签_15
标签_14:
                加1         双字类型  [_食物]
标签_15:
                移动        累加器32, 双字类型 [_食物]
                移动        计数器32, 10
                双字扩展
                符号除      计数器32
                移动        双字类型 [基址指针32-28], 数据寄存器32
                比较        双字类型 [基址指针32-28], 0
                若不等跳转  标签_14
                跳转到      标签_17
标签_16:
                加1         双字类型  [_食物+4]
标签_17:
                移动        累加器32, 双字类型 [_食物+4]
                移动        计数器32, 10
                双字扩展
                符号除      计数器32
                移动        双字类型 [基址指针32-32], 数据寄存器32
                比较        双字类型 [基址指针32-32], 0
                若不等跳转  标签_16
                移动        双字类型 [_食物+8], 0
标签_18:
                比较        双字类型 [_食物+8], 0
                若不等跳转  标签_19
                取有效地址  累加器32, [_食物画笔]
                入栈        双字类型 累加器32
                移动        双字类型 [基址指针32-36], 累加器32
                调用        _图形获取画笔
                加          堆栈指针32, 4
                移动        双字类型 [_食物画笔+8], 0FF00H
                入栈        双字类型 [基址指针32-36]
                调用        _图形设置画笔
                加          堆栈指针32, 4
                移动        累加器32, 双字类型 [_食物]
                加          累加器32, 10
                移动        计数器32, 双字类型 [_食物+4]
                加          计数器32, 0FFFFFFF6H
                入栈        双字类型 计数器32
                入栈        双字类型 累加器32
                入栈        双字类型 [_食物+4]
                入栈        双字类型 [_食物]
                调用        _图形画方框
                加          堆栈指针32, 16
标签_19:
                移动        累加器32, 双字类型 [_蛇+1600]
                加          累加器32, 0FFFFFFFFH
                移动        双字类型 [_计数], 累加器32
                跳转到      标签_21
标签_20:
                移动        累加器32, 双字类型 [_计数]
                左移        累加器32, 2
                取有效地址  计数器32, [_蛇]
                加          计数器32, 累加器32
                移动        数据寄存器32, 双字类型 [_计数]
                加          数据寄存器32, 0FFFFFFFFH
                左移        数据寄存器32, 2
                取有效地址  基址寄存器32, [_蛇]
                加          基址寄存器32, 数据寄存器32
                移动        源变址寄存器32, 双字类型 [基址寄存器32]
                移动        双字类型 [计数器32], 源变址寄存器32
                取有效地址  终变址寄存器32, [_蛇+800]
                加          终变址寄存器32, 累加器32
                取有效地址  累加器32, [_蛇+800]
                加          累加器32, 数据寄存器32
                移动        计数器32, 双字类型 [累加器32]
                移动        双字类型 [终变址寄存器32], 计数器32
                移动        累加器32, 双字类型 [_计数]
                加          累加器32, 0FFFFFFFFH
                移动        双字类型 [_计数], 累加器32
标签_21:
                比较        双字类型 [_计数], 0
                若大于跳转  标签_20
                比较        双字类型 [_蛇+1604], 1
                若小于跳转  标签_26
                比较        双字类型 [_蛇+1604], 4
                若大于跳转  标签_26
                移动        累加器32, 双字类型 [_蛇+1604]
                减          累加器32, 1


;=========数据段定义===========
段声明 .数据

_swtchTable1    定义双字  标签_22
                定义双字  标签_23
                定义双字  标签_24
                定义双字  标签_25
               

;=========代码段定义===========
段声明 .代码

                跳转到      双字类型  [_swtchTable1+累加器32*4]
标签_22:
                移动        累加器32, 双字类型 [_蛇]
                加          累加器32, 10
                移动        双字类型 [_蛇], 累加器32
                跳转到      标签_26
标签_23:
                移动        累加器32, 双字类型 [_蛇]
                加          累加器32, 0FFFFFFF6H
                移动        双字类型 [_蛇], 累加器32
                跳转到      标签_26
标签_24:
                移动        累加器32, 双字类型 [_蛇+800]
                加          累加器32, 0FFFFFFF6H
                移动        双字类型 [_蛇+800], 累加器32
                跳转到      标签_26
标签_25:
                移动        累加器32, 双字类型 [_蛇+800]
                加          累加器32, 10
                移动        双字类型 [_蛇+800], 累加器32
标签_26:
                移动        双字类型 [_计数], 3
                跳转到      标签_29
标签_27:
                移动        累加器32, 双字类型 [_计数]
                左移        累加器32, 2
                取有效地址  计数器32, [_蛇]
                加          计数器32, 累加器32
                移动        数据寄存器32, 双字类型 [计数器32]
                移动        双字类型 [基址指针32-140], 数据寄存器32
                比较        数据寄存器32, 双字类型 [_蛇]
                若不等跳转  标签_28
                移动        累加器32, 双字类型 [_计数]
                左移        累加器32, 2
                取有效地址  计数器32, [_蛇+800]
                加          计数器32, 累加器32
                移动        数据寄存器32, 双字类型 [计数器32]
                移动        双字类型 [基址指针32-156], 数据寄存器32
                比较        数据寄存器32, 双字类型 [_蛇+800]
                若不等跳转  标签_28
                调用        _游戏结束
                加          堆栈指针32, 0
                移动        双字类型 [_蛇+1608], 1
                跳转到      标签_30
标签_28:
                加1         双字类型  [_计数]
标签_29:
                移动        累加器32, 双字类型 [_计数]
                比较        累加器32, 双字类型 [_蛇+1600]
                若小于跳转  标签_27
标签_30:
                比较        双字类型 [_蛇], 55
                若小于跳转  标签_31
                比较        双字类型 [_蛇], 0253H
                若大于跳转  标签_31
                比较        双字类型 [_蛇+800], 55
                若小于跳转  标签_31
                比较        双字类型 [_蛇+800], 01C7H
                若小等跳转  标签_32
标签_31:
                调用        _游戏结束
                加          堆栈指针32, 0
                移动        双字类型 [_蛇+1608], 1
标签_32:
                比较        双字类型 [_蛇+1608], 1
                若不等跳转  标签_33
                入栈        双字类型 [_定时器标识]
                调用        _图形销毁定时器
                加          堆栈指针32, 4
                调用        _游戏结束
                加          堆栈指针32, 0
标签_33:
                移动        累加器32, 双字类型 [_蛇]
                比较        累加器32, 双字类型 [_食物]
                若不等跳转  标签_34
                移动        累加器32, 双字类型 [_蛇+800]
                比较        累加器32, 双字类型 [_食物+4]
                若不等跳转  标签_34
                取有效地址  累加器32, [_食物画笔]
                入栈        双字类型 累加器32
                移动        双字类型 [基址指针32-160], 累加器32
                调用        _图形获取画笔
                加          堆栈指针32, 4
                移动        双字类型 [_食物画笔+8], 0
                入栈        双字类型 [基址指针32-160]
                调用        _图形设置画笔
                加          堆栈指针32, 4
                移动        累加器32, 双字类型 [_食物]
                加          累加器32, 10
                移动        计数器32, 双字类型 [_食物+4]
                加          计数器32, 0FFFFFFF6H
                入栈        双字类型 计数器32
                入栈        双字类型 累加器32
                入栈        双字类型 [_食物+4]
                入栈        双字类型 [_食物]
                调用        _图形画方框
                加          堆栈指针32, 16
                移动        累加器32, 双字类型 [_蛇+1600]
                左移        累加器32, 2
                取有效地址  计数器32, [_蛇]
                加          计数器32, 累加器32
                移动        双字类型 [计数器32], 0FFFFFFECH
                移动        数据寄存器32, 双字类型 [_蛇+1600]
                左移        数据寄存器32, 2
                取有效地址  基址寄存器32, [_蛇+800]
                加          基址寄存器32, 数据寄存器32
                移动        双字类型 [基址寄存器32], 0FFFFFFECH
                加1         双字类型  [_蛇+1600]
                移动        双字类型 [_食物+8], 1
                移动        源变址寄存器32, 双字类型 [_得分]
                加          源变址寄存器32, 10
                移动        双字类型 [_得分], 源变址寄存器32
                调用        _游戏结果
                加          堆栈指针32, 0
标签_34:
                取有效地址  累加器32, [_蛇画笔]
                入栈        双字类型 累加器32
                移动        双字类型 [基址指针32-200], 累加器32
                调用        _图形获取画笔
                加          堆栈指针32, 4
                移动        双字类型 [_蛇画笔+8], 0FF0000H
                入栈        双字类型 [基址指针32-200]
                调用        _图形设置画笔
                加          堆栈指针32, 4
                移动        双字类型 [_计数], 0
                跳转到      标签_36
标签_35:
                移动        累加器32, 双字类型 [_计数]
                左移        累加器32, 2
                取有效地址  计数器32, [_蛇]
                加          计数器32, 累加器32
                移动        数据寄存器32, 双字类型 [计数器32]
                取有效地址  基址寄存器32, [_蛇+800]
                加          基址寄存器32, 累加器32
                移动        源变址寄存器32, 双字类型 [基址寄存器32]
                取有效地址  终变址寄存器32, [_蛇]
                加          终变址寄存器32, 累加器32
                移动        计数器32, 双字类型 [终变址寄存器32]
                加          计数器32, 10
                取有效地址  基址寄存器32, [_蛇+800]
                加          基址寄存器32, 累加器32
                移动        累加器32, 双字类型 [基址寄存器32]
                加          累加器32, 0FFFFFFF6H
                入栈        双字类型 累加器32
                入栈        双字类型 计数器32
                入栈        双字类型 源变址寄存器32
                入栈        双字类型 数据寄存器32
                调用        _图形画方框
                加          堆栈指针32, 16
                加1         双字类型  [_计数]
标签_36:
                移动        累加器32, 双字类型 [_计数]
                比较        累加器32, 双字类型 [_蛇+1600]
                若小于跳转  标签_35
                比较        双字类型 [_蛇+1608], 1
                若不等跳转  标签_37
                入栈        双字类型 [_定时器标识]
                调用        _图形销毁定时器
                加          堆栈指针32, 4
                调用        _游戏结束
                加          堆栈指针32, 0
标签_37:
                移动        累加器32, 0
                移动        堆栈指针32, 基址指针32
                出栈        终变址寄存器32
                出栈        源变址寄存器32
                出栈        基址寄存器32
                出栈        基址指针32
                返回


全局的          _初始化
_初始化:
                入栈        基址指针32
                入栈        基址寄存器32
                入栈        源变址寄存器32
                入栈        终变址寄存器32
                移动        基址指针32, 堆栈指针32
                减          堆栈指针32, 60
                移动        双字类型 [基址指针32-4], 0
                取有效地址  累加器32, [短语_4]
                取有效地址  计数器32, [_显示器消息主处理]
                入栈        双字类型 计数器32
                入栈        双字类型 0
                入栈        双字类型 0
                入栈        双字类型 01F4H
                入栈        双字类型 0294H
                入栈        双字类型 累加器32
                调用        _图形初始化显示器
                加          堆栈指针32, 24
                入栈        双字类型 0
                调用        _图形打开显示器
                加          堆栈指针32, 4
                取有效地址  累加器32, [短语_5]
                入栈        双字类型 累加器32
                入栈        双字类型 30
                入栈        双字类型 50
                调用        _图形输出文字
                加          堆栈指针32, 12
                取有效地址  累加器32, [短语_6]
                入栈        双字类型 累加器32
                入栈        双字类型 60
                入栈        双字类型 50
                调用        _图形输出文字
                加          堆栈指针32, 12
                取有效地址  累加器32, [短语_7]
                入栈        双字类型 累加器32
                入栈        双字类型 90
                入栈        双字类型 50
                调用        _图形输出文字
                加          堆栈指针32, 12
                取有效地址  累加器32, [短语_8]
                入栈        双字类型 累加器32
                入栈        双字类型 120
                入栈        双字类型 50
                调用        _图形输出文字
                加          堆栈指针32, 12
                取有效地址  累加器32, [短语_9]
                入栈        双字类型 累加器32
                入栈        双字类型 150
                入栈        双字类型 50
                调用        _图形输出文字
                加          堆栈指针32, 12
                取有效地址  累加器32, [短语_10]
                入栈        双字类型 累加器32
                入栈        双字类型 180
                入栈        双字类型 50
                调用        _图形输出文字
                加          堆栈指针32, 12
                取有效地址  累加器32, [短语_11]
                入栈        双字类型 累加器32
                入栈        双字类型 210
                入栈        双字类型 50
                调用        _图形输出文字
                加          堆栈指针32, 12
                取有效地址  累加器32, [短语_12]
                入栈        双字类型 累加器32
                入栈        双字类型 240
                入栈        双字类型 50
                调用        _图形输出文字
                加          堆栈指针32, 12
                取有效地址  累加器32, [短语_13]
                入栈        双字类型 累加器32
                入栈        双字类型 0140H
                入栈        双字类型 50
                调用        _图形输出文字
                加          堆栈指针32, 12
                取有效地址  累加器32, [短语_14]
                入栈        双字类型 累加器32
                入栈        双字类型 015EH
                入栈        双字类型 50
                调用        _图形输出文字
                加          堆栈指针32, 12
                取有效地址  累加器32, [短语_15]
                入栈        双字类型 累加器32
                入栈        双字类型 017CH
                入栈        双字类型 50
                调用        _图形输出文字
                加          堆栈指针32, 12
                调用        _获取按键
                加          堆栈指针32, 0
                调用        _绘画
                加          堆栈指针32, 0
                取有效地址  累加器32, [_定时器事件处理主函数]
                入栈        双字类型 累加器32
                调用        _图形初始化定时器
                加          堆栈指针32, 4
                入栈        双字类型 [_游戏速度]
                入栈        双字类型 1
                调用        _图形创建定时器
                加          堆栈指针32, 8
                移动        双字类型 [_定时器控制], 累加器32
                移动        双字类型 [_食物+8], 1
                移动        双字类型 [_蛇+1608], 0
                移动        双字类型 [_蛇+1604], 1
                移动        双字类型 [_蛇], 100
                移动        双字类型 [_蛇+800], 100
                移动        双字类型 [_蛇+4], 110
                移动        双字类型 [_蛇+804], 100
                移动        双字类型 [_蛇+1600], 2
                调用        _图形等待显示器关闭
                加          堆栈指针32, 0
                移动        堆栈指针32, 基址指针32
                出栈        终变址寄存器32
                出栈        源变址寄存器32
                出栈        基址寄存器32
                出栈        基址指针32
                返回


全局的          _主函数
_主函数:
                入栈        基址指针32
                入栈        基址寄存器32
                入栈        源变址寄存器32
                入栈        终变址寄存器32
                移动        基址指针32, 堆栈指针32
                调用        _初始化
                加          堆栈指针32, 0
                入栈        双字类型 1
                调用        _图形关闭显示器
                加          堆栈指针32, 4
                移动        累加器32, 0
                移动        堆栈指针32, 基址指针32
                出栈        终变址寄存器32
                出栈        源变址寄存器32
                出栈        基址寄存器32
                出栈        基址指针32
                返回