行不行？有多少关键字？编译器稳定吗？优化效果怎么样？
是不是我习惯了英文编写了，看着这编出来的程序怎么那么别扭呢
无源代码无凭证

编译器在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
                返回

中文汇编兼容NASM汇编，即可以用英文些的汇编代码，通过习语言的中汇功能也能编译！

敢问你觉得敲字母快还是用拼英或五笔输入法输入汉字快？它是国际化的吗？除了中国还能在哪个国家用？哪个企业会用这样的开发语言（比如易语言）？不管你英文有多差，C就几十个关键字，加上几个括号和运算符，这些都记不住还当什么程序员啊？

顶个！支持，以后我们学习C就不要在这么痛苦的去学英文了。

很多程序不是开发出来就是完美的，后期要经过大量的调试排错。用中文可使源代码的可读性增强，方便排除错误！而习语言也支持编译英文源代码。对与一些不需要公开的源代码，我们可以用中文书写，让老外去哭。对国际接轨的代码段，我们可以用英文书写。这样对外企的保密程度还是有的！
很多时候，你调试自己程序的时间绝对比你编写的时间多！

C Keywords:

auto break case char const continue default do double else enum extern float for goto if int long register return short signed sizeof static struct switch typedef union unsigned void while

数数有多少个吧？

易语言是败在他自己的手里，他的pe结构毁了他！
运行易语言程序还要带他的支持库，很麻烦的，执行效率也不怎么好，最重要的是报毒严重！