提取硬件信息模块V0.2

提取硬件信息模块V0.2

@ketion

.版本 2
.支持库 dp1
.支持库 EDataStructure
.支持库 spec

.程序集 硬件信息

.子程序 取计算机类型2, , 公开
.参数 配置文件路径, 文本型
.参数 运行目录, 文本型
.局部变量 类型, 计算机类型
.局部变量 翻译分割, 文本型, , "0"
.局部变量 翻译分割2, 文本型, , "0"
.局部变量 i, 整数型
.局部变量 主板翻译_自定义, 文本型

' ============   www.sanye.cx  =============--
’本站收录资源，如有密码，默认解压密码都为：www.sanye.cx
’三叶资源网官方④群：72857039
' 投稿邮箱：[email protected]
' ============ =====================--
’专注易语言，按键精灵等编程源码分享的网站
’三叶资源网收集的软件和源码，大部分为软件作者或网友推荐，
’版权归原作者所有，仅供学习和研究使用。
’转载本站提供的资源请勿删除本说明文件。
' 本站提供资源只可供研究使用，请在下载24小时内删除，勿用于商业用途，由此引起一切后果与本站无关。
' ============   www.sanye.cx  =============--
' 本源码来自三叶资源网(www.sanye.cx)
类型 ＝ 计算机类型 ()
主板翻译_自定义 ＝ #主板翻译
.如果真 (文件是否存在 (运行目录 ＋ “data\mainboard.dat”) ＝ 真)
    主板翻译_自定义 ＝ 到文本 (解密数据 (读入文件 (运行目录 ＋ “data\mainboard.dat”), “tulading”, 1))
.如果真结束
写配置项 (配置文件路径, “类型”, “获取成功”, “真”)
翻译分割 ＝ 分割文本 (主板翻译_自定义, #换行符, )
.计次循环首 (取数组成员数 (翻译分割), i)
    翻译分割2 ＝ 分割文本 (翻译分割 [i], “=”, )
    .如果真 (寻找文本 (类型.制造商, 翻译分割2 [1], , 真) ≠ -1)
        类型.制造商 ＝ 子文本替换 (类型.制造商, 翻译分割2 [1], 翻译分割2 [2], , , 假)
        跳出循环 ()
    .如果真结束

.计次循环尾 ()
类型.制造商 ＝ 子文本替换 (类型.制造商, “Technology Co., Ltd.”, “”, , , 假)
类型.制造商 ＝ 子文本替换 (类型.制造商, “COMPUTER INC.”, “”, , , 假)
类型.制造商 ＝ 子文本替换 (类型.制造商, “COMPUTER Co., Ltd”, “”, , , 假)
类型.制造商 ＝ 子文本替换 (类型.制造商, “COMPUTER Co.,Ltd”, “”, , , 假)
类型.制造商 ＝ 子文本替换 (类型.制造商, “Technology And Development Co.,LTD”, “”, , , 假)
类型.制造商 ＝ 子文本替换 (类型.制造商, “ Inc.”, “”, , , 假)
写配置项 (配置文件路径, “类型”, “类型”, 类型.类型)
写配置项 (配置文件路径, “类型”, “厂商”, 类型.制造商)

.子程序 取计算机型号2, , 公开
.参数 配置文件路径, 文本型
.参数 运行目录, 文本型
.局部变量 型号, 型号信息

型号 ＝ 型号信息 ()
.如果 (型号.型号 ＝ “” 或 型号.型号 ＝ “ ”)
    写配置项 (配置文件路径, “类型”, “型号”, “未知型号”)
.否则
    写配置项 (配置文件路径, “类型”, “型号”, 型号.型号)
.如果结束


.子程序 取系统信息_2, , 公开
.参数 配置文件路径, 文本型
.参数 运行目录, 文本型
.局部变量 temp, 文本型
.局部变量 temp1, 文本型
.局部变量 temp2, 整数型

temp ＝ 系统信息 ()
temp ＝ 子文本替换 (temp, “-bit”, “位”, , , 真)
temp1 ＝ 到文本 (读入文件 (配置文件路径))
temp1 ＝ temp1 ＋ #换行符 ＋ “[系统]” ＋ #换行符 ＋ temp ＋ #换行符
写到文件 (配置文件路径, 到字节集 (temp1))
temp2 ＝ 到数值 (读配置项 (配置文件路径, “系统”, “获取成功”, ))
.如果 (temp2 ＜ 1)
    写配置项 (配置文件路径, “系统”, “获取成功”, “假”)
.否则
    写配置项 (配置文件路径, “系统”, “获取成功”, “真”)
.如果结束


.子程序 取处理器信息2, , 公开
.参数 配置文件路径, 文本型
.参数 运行目录, 文本型
.局部变量 temp, 文本型
.局部变量 i, 整数型
.局部变量 核心架构翻译_自定义, 文本型
.局部变量 分割, 文本型, , "0"
.局部变量 分割2, 文本型, , "0"
.局部变量 耐热信息_自定义, 文本型
.局部变量 分割3, 文本型, , "0"
.局部变量 临时, 文本型
.局部变量 i1, 整数型
.局部变量 temp1, 文本型

' ============   www.sanye.cx  =============--
’本站收录资源，如有密码，默认解压密码都为：www.sanye.cx
’三叶资源网官方④群：72857039
' 投稿邮箱：[email protected]
' ============ =====================--
’专注易语言，按键精灵等编程源码分享的网站
’三叶资源网收集的软件和源码，大部分为软件作者或网友推荐，
’版权归原作者所有，仅供学习和研究使用。
’转载本站提供的资源请勿删除本说明文件。
' 本站提供资源只可供研究使用，请在下载24小时内删除，勿用于商业用途，由此引起一切后果与本站无关。
' ============   www.sanye.cx  =============--
' 本源码来自三叶资源网(www.sanye.cx)
temp ＝ 处理器信息 ()
temp1 ＝ 到文本 (读入文件 (配置文件路径))
temp1 ＝ temp1 ＋ #换行符 ＋ “[处理器]” ＋ #换行符 ＋ temp ＋ #换行符
写到文件 (配置文件路径, 到字节集 (temp1))
核心架构翻译_自定义 ＝ #处理器核心架构翻译
.如果真 (文件是否存在 (运行目录 ＋ “data\architecture.dat”) ＝ 真)
    核心架构翻译_自定义 ＝ 到文本 (解密数据 (读入文件 (运行目录 ＋ “data\architecture.dat”), “tulading”, 1))
.如果真结束
分割 ＝ 分割文本 (核心架构翻译_自定义, #换行符, )
耐热信息_自定义 ＝ #核心架构耐热信息
.如果真 (文件是否存在 (运行目录 ＋ “data\LimitTemperature.dat”) ＝ 真)
    耐热信息_自定义 ＝ 到文本 (解密数据 (读入文件 (运行目录 ＋ “data\LimitTemperature.dat”), “tulading”, 1))
.如果真结束
分割3 ＝ 分割文本 (耐热信息_自定义, #换行符, )
.计次循环首 (取数组成员数 (分割), i)
    分割2 ＝ 分割文本 (分割 [i], “=”, )
    .如果真 (寻找文本 (读配置项 (配置文件路径, “处理器”, “处理器架构_数据”, ), 分割2 [1], , 假) ≠ -1)
        写配置项 (配置文件路径, “处理器”, “处理器架构”, 分割2 [2])
        临时 ＝ 分割2 [2]
        跳出循环 ()
    .如果真结束

.计次循环尾 ()
.计次循环首 (取数组成员数 (分割3), i1)
    分割2 ＝ 分割文本 (分割3 [i1], “=”, )
    .如果真 (寻找文本 (读配置项 (配置文件路径, “处理器”, “处理器型号”, ), 分割2 [1], , 假) ≠ -1)
        写配置项 (配置文件路径, “处理器”, “极限温度”, 分割2 [2])
        跳出循环 ()
    .如果真结束

.计次循环尾 ()
.如果真 (寻找文本 (读配置项 (配置文件路径, “处理器”, “处理器接口”, ), “U3E1”, , 真) ≠ -1)
    写配置项 (配置文件路径, “处理器”, “处理器接口”, “未知”)
.如果真结束
.如果真 (寻找文本 (读配置项 (配置文件路径, “处理器”, “处理器接口”, ), “U2E1”, , 真) ≠ -1)
    写配置项 (配置文件路径, “处理器”, “处理器接口”, “未知”)
.如果真结束
.如果真 (寻找文本 (读配置项 (配置文件路径, “处理器”, “处理器接口”, ), “CPU 0”, , 真) ≠ -1)
    写配置项 (配置文件路径, “处理器”, “处理器接口”, “未知”)
.如果真结束
.如果真 (寻找文本 (读配置项 (配置文件路径, “处理器”, “处理器接口”, ), “CPU 1”, , 真) ≠ -1)
    写配置项 (配置文件路径, “处理器”, “处理器接口”, “未知”)
.如果真结束
.如果真 (寻找文本 (读配置项 (配置文件路径, “处理器”, “处理器接口”, ), “CPU0”, , 真) ≠ -1)
    写配置项 (配置文件路径, “处理器”, “处理器接口”, “未知”)
.如果真结束
.如果真 (寻找文本 (读配置项 (配置文件路径, “处理器”, “处理器接口”, ), “CPU1”, , 真) ≠ -1)
    写配置项 (配置文件路径, “处理器”, “处理器接口”, “未知”)
.如果真结束
.如果真 (寻找文本 (读配置项 (配置文件路径, “处理器”, “处理器接口”, ), “CPU SOCKET”, , 真) ≠ -1)
    写配置项 (配置文件路径, “处理器”, “处理器接口”, “未知”)
.如果真结束
.如果真 (读配置项 (配置文件路径, “处理器”, “处理器接口”, ) ＝ “SOCKET0”)
    写配置项 (配置文件路径, “处理器”, “处理器接口”, “未知”)
.如果真结束
.如果真 (读配置项 (配置文件路径, “处理器”, “处理器接口”, ) ＝ “SOCKET1”)
    写配置项 (配置文件路径, “处理器”, “处理器接口”, “未知”)
.如果真结束
.如果真 (读配置项 (配置文件路径, “处理器”, “处理器接口”, ) ＝ “SOCKET 0”)
    写配置项 (配置文件路径, “处理器”, “处理器接口”, “未知”)
.如果真结束
.如果真 (读配置项 (配置文件路径, “处理器”, “处理器接口”, ) ＝ “SOCKET 1”)
    写配置项 (配置文件路径, “处理器”, “处理器接口”, “未知”)
.如果真结束
.如果真 (取文本长度 (读配置项 (配置文件路径, “处理器”, “处理器接口”, )) ＞ 25)
    写配置项 (配置文件路径, “处理器”, “处理器接口”, “未知”)
.如果真结束
.如果 (到数值 (读配置项 (配置文件路径, “处理器”, “处理器数量”, )) ＜ 1)
    写配置项 (配置文件路径, “处理器”, “获取成功”, “假”)
.否则
    写配置项 (配置文件路径, “处理器”, “获取成功”, “真”)
.如果结束



.子程序 取主板信息2, , 公开
.参数 配置文件路径, 文本型
.参数 运行目录, 文本型
.局部变量 temp, 文本型
.局部变量 temp1, 文本型
.局部变量 翻译分割, 文本型, , "0"
.局部变量 翻译分割2, 文本型, , "0"
.局部变量 i, 整数型
.局部变量 主板翻译_自定义, 文本型
.局部变量 temp2, 文本型
.局部变量 temp3, 整数型

temp ＝ 主板信息 ()
temp1 ＝ 到文本 (读入文件 (配置文件路径))
temp1 ＝ temp1 ＋ #换行符 ＋ “[主板]” ＋ #换行符 ＋ temp
写到文件 (配置文件路径, 到字节集 (temp1))
主板翻译_自定义 ＝ #主板翻译
.如果真 (文件是否存在 (运行目录 ＋ “data\mainboard.dat”) ＝ 真)
    主板翻译_自定义 ＝ 到文本 (解密数据 (读入文件 (运行目录 ＋ “data\mainboard.dat”), “tulading”, 1))
.如果真结束
temp2 ＝ 读配置项 (配置文件路径, “主板”, “品牌”, )
temp2 ＝ 子文本替换 (temp2, “Technology Co., Ltd.”, “”, , , 假)
temp2 ＝ 子文本替换 (temp2, “COMPUTER INC.”, “”, , , 假)
temp2 ＝ 子文本替换 (temp2, “COMPUTER”, “”, , , 假)
temp2 ＝ 子文本替换 (temp2, “Corporation”, “”, , , 假)
temp2 ＝ 子文本替换 (temp2, “COMPUTER Co., Ltd”, “”, , , 假)
temp2 ＝ 子文本替换 (temp2, “COMPUTER Co.,Ltd”, “”, , , 假)
temp2 ＝ 子文本替换 (temp2, “Technology And Development Co.,LTD”, “”, , , 假)
temp2 ＝ 子文本替换 (temp2, “ Inc.”, “”, , , 假)
翻译分割 ＝ 分割文本 (主板翻译_自定义, #换行符, )
.计次循环首 (取数组成员数 (翻译分割), i)
    翻译分割2 ＝ 分割文本 (翻译分割 [i], “=”, )
    .如果真 (寻找文本 (temp2, 翻译分割2 [1], , 真) ≠ -1)
        temp2 ＝ 子文本替换 (temp2, 翻译分割2 [1], 翻译分割2 [2], , , 假)
        跳出循环 ()
    .如果真结束

.计次循环尾 ()
写配置项 (配置文件路径, “主板”, “品牌”, temp2)
temp3 ＝ 到数值 (读配置项 (配置文件路径, “主板”, “获取成功”, ))
.如果 (temp3 ＜ 1)
    写配置项 (配置文件路径, “主板”, “获取成功”, “假”)
.否则
    写配置项 (配置文件路径, “主板”, “获取成功”, “真”)
.如果结束


.子程序 取BIOS信息_2, , 公开
.参数 配置文件路径, 文本型
.参数 运行目录, 文本型
.局部变量 temp, 文本型
.局部变量 temp1, 文本型

' ============   www.sanye.cx  =============--
’本站收录资源，如有密码，默认解压密码都为：www.sanye.cx
’三叶资源网官方④群：72857039
' 投稿邮箱：[email protected]
' ============ =====================--
’专注易语言，按键精灵等编程源码分享的网站
’三叶资源网收集的软件和源码，大部分为软件作者或网友推荐，
’版权归原作者所有，仅供学习和研究使用。
’转载本站提供的资源请勿删除本说明文件。
' 本站提供资源只可供研究使用，请在下载24小时内删除，勿用于商业用途，由此引起一切后果与本站无关。
' ============   www.sanye.cx  =============--
' 本源码来自三叶资源网(www.sanye.cx)
temp ＝ BIOS信息 ()
temp1 ＝ 到文本 (读入文件 (配置文件路径))
temp1 ＝ temp1 ＋ #换行符 ＋ “[BIOS]” ＋ #换行符 ＋ temp ＋ #换行符
写到文件 (配置文件路径, 到字节集 (temp1))

.子程序 取内存信息2, , 公开
.参数 配置文件路径, 文本型
.参数 运行目录, 文本型
.局部变量 temp, 文本型
.局部变量 temp1, 文本型
.局部变量 temp2, 长整数型
.局部变量 temp3, 文本型
.局部变量 i, 整数型

temp ＝ 内存信息 ()
temp1 ＝ 到文本 (读入文件 (配置文件路径))
temp1 ＝ temp1 ＋ #换行符 ＋ “[内存]” ＋ #换行符 ＋ temp ＋ #换行符
写到文件 (配置文件路径, 到字节集 (temp1))
temp2 ＝ 到数值 (读配置项 (配置文件路径, “内存”, “数量”, ))
.如果真 (temp2 ＜ 1)
    写配置项 (配置文件路径, “内存”, “获取成功”, “假”)
    返回 ()
.如果真结束
.计次循环首 (temp2, i)
    temp2 ＝ 到数值 (读配置项 (配置文件路径, “内存”, “内存” ＋ 到文本 (i) ＋ “容量”, ))
    temp2 ＝ temp2 ÷ 1024 ÷ 1024 ÷ 1024
    写配置项 (配置文件路径, “内存”, “内存” ＋ 到文本 (i) ＋ “容量”, 到文本 (temp2) ＋ “GB”)
    temp3 ＝ 读配置项 (配置文件路径, “内存”, “内存” ＋ 到文本 (i) ＋ “速度”, )
    .如果 (temp3 ＝ “”)
        写配置项 (配置文件路径, “内存”, “内存” ＋ 到文本 (i) ＋ “速度”, “未知速度”)
    .否则
        写配置项 (配置文件路径, “内存”, “内存” ＋ 到文本 (i) ＋ “速度”, temp3 ＋ “MHz”)
    .如果结束
    temp3 ＝ 读配置项 (配置文件路径, “内存”, “内存” ＋ 到文本 (i) ＋ “厂商”, )
    .如果真 (temp3 ＝ “”)
        写配置项 (配置文件路径, “内存”, “内存” ＋ 到文本 (i) ＋ “厂商”, “未知”)
    .如果真结束
    temp3 ＝ 读配置项 (配置文件路径, “内存”, “内存” ＋ 到文本 (i) ＋ “序列号”, )
    .如果真 (temp3 ＝ “”)
        写配置项 (配置文件路径, “内存”, “内存” ＋ 到文本 (i) ＋ “序列号”, “未知”)
    .如果真结束

.计次循环尾 ()
写配置项 (配置文件路径, “内存”, “获取成功”, “真”)

.子程序 取显卡信息2, , 公开
.参数 配置文件路径, 文本型
.参数 运行目录, 文本型
.局部变量 temp, 文本型
.局部变量 temp1, 文本型
.局部变量 temp2, 整数型
.局部变量 i, 整数型
.局部变量 temp3, 整数型

temp ＝ 显卡信息 ()
temp1 ＝ 到文本 (读入文件 (配置文件路径))
temp1 ＝ temp1 ＋ #换行符 ＋ “[显卡]” ＋ #换行符 ＋ temp ＋ #换行符
写到文件 (配置文件路径, 到字节集 (temp1))
temp2 ＝ 到数值 (读配置项 (配置文件路径, “显卡”, “数量”, ))
.如果真 (temp2 ＜ 0)
    写配置项 (配置文件路径, “显卡”, “获取成功”, “假”)
    返回 ()
.如果真结束
.计次循环首 (temp2, i)
    temp3 ＝ 到数值 (读配置项 (配置文件路径, “显卡”, “显卡” ＋ 到文本 (i) ＋ “显存”, ))
    temp3 ＝ temp3 ÷ 1024 ÷ 1024
    temp3 ＝ 取绝对值 (temp3)
    写配置项 (配置文件路径, “显卡”, “显卡” ＋ 到文本 (i) ＋ “显存”, 到文本 (temp3) ＋ “MB”)
.计次循环尾 ()
写配置项 (配置文件路径, “显卡”, “获取成功”, “真”)

.子程序 取硬盘信息_2, , 公开
.参数 配置文件路径, 文本型
.参数 运行目录, 文本型
.局部变量 temp, 文本型
.局部变量 temp1, 文本型
.局部变量 temp2, 整数型
.局部变量 i, 整数型
.局部变量 temp3, 长整数型

temp ＝ 硬盘信息 ()
temp1 ＝ 到文本 (读入文件 (配置文件路径))
temp1 ＝ temp1 ＋ #换行符 ＋ “[磁盘]” ＋ #换行符 ＋ temp ＋ #换行符
写到文件 (配置文件路径, 到字节集 (temp1))
temp2 ＝ 到数值 (读配置项 (配置文件路径, “磁盘”, “数量”, ))
.如果真 (temp2 ＜ 1)
    写配置项 (配置文件路径, “磁盘”, “获取成功”, “假”)
    返回 ()
.如果真结束
.计次循环首 (temp2, i)
    temp3 ＝ 到数值 (读配置项 (配置文件路径, “磁盘”, “磁盘” ＋ 到文本 (i) ＋ “容量”, ))
    写配置项 (配置文件路径, “磁盘”, “磁盘” ＋ 到文本 (i) ＋ “容量”, 到文本 (到整数 (temp3 ÷ 1000000000)) ＋ “GB”)
    写配置项 (配置文件路径, “磁盘”, “磁盘” ＋ 到文本 (i) ＋ “实际容量”, 到文本 (到整数 (temp3 ÷ 1073741824)) ＋ “GB”)
.计次循环尾 ()
写配置项 (配置文件路径, “磁盘”, “获取成功”, “真”)

.子程序 取声卡信息2, , 公开
.参数 配置文件路径, 文本型
.参数 运行目录, 文本型
.局部变量 temp, 文本型
.局部变量 temp1, 文本型
.局部变量 temp2, 整数型
.局部变量 temp3, 文本型, , "0"
.局部变量 i, 整数型

temp ＝ 声卡信息 ()
temp1 ＝ 到文本 (读入文件 (配置文件路径))
temp1 ＝ temp1 ＋ #换行符 ＋ “[声卡]” ＋ #换行符 ＋ temp ＋ #换行符
写到文件 (配置文件路径, 到字节集 (temp1))
temp2 ＝ 到数值 (读配置项 (配置文件路径, “声卡”, “数量”, ))
.如果真 (temp2 ＜ 1)
    写配置项 (配置文件路径, “声卡”, “获取成功”, “假”)
    返回 ()
.如果真结束
.计次循环首 (temp2, i)
    加入成员 (temp3, 读配置项 (配置文件路径, “声卡”, “声卡” ＋ 到文本 (i) ＋ “型号”, ))
.计次循环尾 ()
数组去重复 (temp3)
temp2 ＝ 取数组成员数 (temp3)
写配置项 (配置文件路径, “声卡”, “数量”, 到文本 (temp2))
.计次循环首 (temp2, i)
    写配置项 (配置文件路径, “声卡”, “声卡” ＋ 到文本 (i) ＋ “型号”, temp3 [i])
.计次循环尾 ()
写配置项 (配置文件路径, “声卡”, “获取成功”, “真”)

.子程序 取网卡信息2, , 公开
.参数 配置文件路径, 文本型
.参数 运行目录, 文本型
.局部变量 temp, 文本型
.局部变量 temp1, 文本型

temp ＝ 网卡信息 ()
temp1 ＝ 到文本 (读入文件 (配置文件路径))
temp1 ＝ temp1 ＋ #换行符 ＋ “[网卡]” ＋ #换行符 ＋ temp ＋ #换行符
写到文件 (配置文件路径, 到字节集 (temp1))
.如果真 (到数值 (读配置项 (配置文件路径, “网卡”, “数量”, )) ＜ 1)
    写配置项 (配置文件路径, “网卡”, “获取成功”, “假”)
    返回 ()
.如果真结束
写配置项 (配置文件路径, “网卡”, “获取成功”, “真”)

.子程序 取显示器信息2, , 公开
.参数 配置文件路径, 文本型
.参数 运行目录, 文本型
.局部变量 temp, 文本型
.局部变量 temp1, 文本型
.局部变量 temp2, 整数型
.局部变量 i, 整数型
.局部变量 详细信息, 显示器详细信息
.局部变量 记次, 整数型
.局部变量 参数c, 文本型

temp ＝ 显示器信息 ()
temp1 ＝ 到文本 (读入文件 (配置文件路径))
temp1 ＝ temp1 ＋ #换行符 ＋ “[显示器]” ＋ #换行符 ＋ temp ＋ #换行符
写到文件 (配置文件路径, 到字节集 (temp1))
temp2 ＝ 到数值 (读配置项 (配置文件路径, “显示器”, “数量”, ))
.如果真 (temp2 ＜ 1)
    写配置项 (配置文件路径, “显示器”, “获取成功”, “假”)
    返回 ()
.如果真结束
.计次循环首 (temp2, i)
    .如果真 (读配置项 (配置文件路径, “显示器”, “显示器” ＋ 到文本 (i) ＋ “参数a”, ) ≠ “” 且 读配置项 (配置文件路径, “显示器”, “显示器” ＋ 到文本 (i) ＋ “参数b”, ) ≠ “”)
        记次 ＝ 记次 ＋ 1
        参数c ＝ 读配置项 (配置文件路径, “显示器”, “显示器” ＋ 到文本 (i) ＋ “参数c”, )
        .如果 (参数c ≠ “”)
            详细信息 ＝ 读取EDID信息 (参数c)
            写配置项 (配置文件路径, “显示器”, “显示器” ＋ 到文本 (记次) ＋ “型号_测试版”, 详细信息.型号)
            写配置项 (配置文件路径, “显示器”, “显示器” ＋ 到文本 (记次) ＋ “ID”, 详细信息.ID)
            写配置项 (配置文件路径, “显示器”, “显示器” ＋ 到文本 (记次) ＋ “尺寸”, 详细信息.尺寸 ＋ “英寸”)
            写配置项 (配置文件路径, “显示器”, “显示器” ＋ 到文本 (记次) ＋ “宽度”, 详细信息.宽度 ＋ “厘米”)
            写配置项 (配置文件路径, “显示器”, “显示器” ＋ 到文本 (记次) ＋ “高度”, 详细信息.高度 ＋ “厘米”)
            写配置项 (配置文件路径, “显示器”, “显示器” ＋ 到文本 (记次) ＋ “生产日期”, 详细信息.生产日期)
            写配置项 (配置文件路径, “显示器”, “显示器” ＋ 到文本 (记次) ＋ “edid版本”, 详细信息.edid版本)
            写配置项 (配置文件路径, “显示器”, “显示器” ＋ 到文本 (记次) ＋ “序列号_测试版”, 详细信息.序列号)
            写配置项 (配置文件路径, “显示器”, “显示器” ＋ 到文本 (记次) ＋ “品牌十六进制数据”, 详细信息.品牌源数据)
            写配置项 (配置文件路径, “显示器”, “数量”, 到文本 (记次))
        .否则
            写配置项 (配置文件路径, “显示器”, “显示器” ＋ 到文本 (记次) ＋ “型号_测试版”, “Default Monitor”)
            写配置项 (配置文件路径, “显示器”, “显示器” ＋ 到文本 (记次) ＋ “ID”, “Default Monitor”)
            写配置项 (配置文件路径, “显示器”, “数量”, 到文本 (记次))
        .如果结束

    .如果真结束

.计次循环尾 ()

.子程序 数组去重复
.参数 文本数组, 文本型, 数组
.局部变量 节点, 节点
.局部变量 去重复数组, 文本型, , "0"
.局部变量 i, 整数型

.计次循环首 (取数组成员数 (文本数组), i)
    .如果真 (节点.加入属性 (文本数组 [i], 真))
        加入成员 (去重复数组, 文本数组 [i])
    .如果真结束

.计次循环尾 ()
文本数组 ＝ 去重复数组

.子程序 取芯片组信息2, , 公开
.参数 配置文件路径, 文本型
.参数 运行目录, 文本型
.局部变量 temp, 文本型
.局部变量 temp1, 文本型
.局部变量 芯片组对比库, 文本型
.局部变量 分割1, 文本型, , "0"
.局部变量 分割2, 文本型, , "0"
.局部变量 是否成功, 逻辑型
.局部变量 i, 整数型
.局部变量 i1, 整数型
.局部变量 a1, 文本型
.局部变量 a2, 文本型, , "0"

a1 ＝ 芯片组信息 ()
是否成功 ＝ 假
写配置项 (配置文件路径, “芯片组”, “获取成功”, “假”)
a2 ＝ 分割文本 (a1, #换行符, )
.如果真 (取数组成员数 (a2) ＞ 0)
    .如果 (文件是否存在 (运行目录 ＋ “data\chip.dat”) ＝ 真)
        芯片组对比库 ＝ #芯片组对比库
        ' 芯片组对比库 ＝ 到文本 (解密数据 (读入文件 (运行目录 ＋ “data\chip.dat”), “tulading”, 2))
    .否则
        芯片组对比库 ＝ #芯片组对比库
    .如果结束
    分割1 ＝ 分割文本 (芯片组对比库, #换行符, )
    调试输出 (取数组成员数 (a2))
    .计次循环首 (取数组成员数 (a2), i)
        .如果真 (寻找文本 (a2 [i], “PCI\\”, , 假) ≠ -1)
            调试输出 (a2 [i])
            .计次循环首 (取数组成员数 (分割1), i1)
                分割2 ＝ 分割文本 (分割1 [i1], “=”, )
                .如果真 (寻找文本 (a2 [i], 分割2 [1], , 真) ≠ -1)
                    是否成功 ＝ 真
                    写配置项 (配置文件路径, “芯片组”, “型号”, 分割2 [2])
                    跳出循环 ()
                .如果真结束

            .计次循环尾 ()

        .如果真结束
        .如果真 (是否成功 ＝ 真)
            跳出循环 ()
        .如果真结束

    .计次循环尾 ()

.如果真结束
.如果真 (是否成功 ＝ 假)
    .如果真 (取数组成员数 (a2) ＞ 0)
        .如果 (文件是否存在 (运行目录 ＋ “data\chip.dat”) ＝ 真)
            芯片组对比库 ＝ #芯片组对比库2
            ' 芯片组对比库 ＝ 到文本 (解密数据 (读入文件 (运行目录 ＋ “data\chip.dat”), “tulading”, 2))
        .否则
            芯片组对比库 ＝ #芯片组对比库2
        .如果结束
        分割1 ＝ 分割文本 (芯片组对比库, #换行符, )
        调试输出 (取数组成员数 (a2))
        .计次循环首 (取数组成员数 (a2), i)
            .如果真 (寻找文本 (a2 [i], “PCI\\”, , 假) ≠ -1)
                调试输出 (a2 [i])
                .计次循环首 (取数组成员数 (分割1), i1)
                    分割2 ＝ 分割文本 (分割1 [i1], “=”, )
                    .如果真 (寻找文本 (a2 [i], 分割2 [1], , 真) ≠ -1)
                        是否成功 ＝ 真
                        写配置项 (配置文件路径, “芯片组”, “型号”, 分割2 [2])
                        跳出循环 ()
                    .如果真结束

                .计次循环尾 ()

            .如果真结束
            .如果真 (是否成功 ＝ 真)
                跳出循环 ()
            .如果真结束

        .计次循环尾 ()

    .如果真结束

.如果真结束
.如果真 (是否成功 ＝ 真)
    写配置项 (配置文件路径, “芯片组”, “获取成功”, “真”)
.如果真结束


.子程序 计算机类型, 计算机类型
.局部变量 脚本, 对象
.局部变量 返回值, 整数型
.局部变量 返回值2, 文本型
.局部变量 类型, 计算机类型

脚本.创建 (“MSScriptControl.ScriptControl”, )
脚本.写属性 (“Language”, “VBScript”)
脚本.数值方法 (“AddCode”, #取计算机类型)
返回值 ＝ 脚本.通用方法 (“Eval”, “GetA()”).取数值 (1)
.如果真 (返回值 ＝ 1)
    类型.类型 ＝ “兼容机”
.如果真结束
.如果真 (返回值 ＝ 2)
    类型.类型 ＝ “兼容机”
.如果真结束
.如果真 (返回值 ＝ 3)
    类型.类型 ＝ “台式电脑”
.如果真结束
.如果真 (返回值 ＝ 4)
    类型.类型 ＝ “Low Profile Desktop”
.如果真结束
.如果真 (返回值 ＝ 5)
    类型.类型 ＝ “披萨盒式计算机”
.如果真结束
.如果真 (返回值 ＝ 6)
    类型.类型 ＝ “微塔式计算机”
.如果真结束
.如果真 (返回值 ＝ 7)
    类型.类型 ＝ “塔式计算机”
.如果真结束
.如果真 (返回值 ＝ 8)
    类型.类型 ＝ “笔记本电脑”
.如果真结束
.如果真 (返回值 ＝ 9)
    类型.类型 ＝ “便携式式计算机”
.如果真结束
.如果真 (返回值 ＝ 10)
    类型.类型 ＝ “笔记本”
.如果真结束
.如果真 (返回值 ＝ 11)
    类型.类型 ＝ “掌上电脑”
.如果真结束
.如果真 (返回值 ＝ 12)
    类型.类型 ＝ “Docking Station”
.如果真结束
.如果真 (返回值 ＝ 13)
    类型.类型 ＝ “一体机”
.如果真结束
.如果真 (返回值 ＝ 14)
    类型.类型 ＝ “轻薄型笔记本”
.如果真结束
.如果真 (返回值 ＝ 15)
    类型.类型 ＝ “Space Saving”
.如果真结束
.如果真 (返回值 ＝ 16)
    类型.类型 ＝ “Lunch Box”
.如果真结束
.如果真 (返回值 ＝ 17)
    类型.类型 ＝ “Main System Chassis”
.如果真结束
.如果真 (返回值 ＝ 18)
    类型.类型 ＝ “扩展机架”
.如果真结束
.如果真 (返回值 ＝ 19)
    类型.类型 ＝ “子机架”
.如果真结束
.如果真 (返回值 ＝ 20)
    类型.类型 ＝ “总线扩展机架”
.如果真结束
.如果真 (返回值 ＝ 21)
    类型.类型 ＝ “外围机架”
.如果真结束
.如果真 (返回值 ＝ 22)
    类型.类型 ＝ “机架式储存”
.如果真结束
.如果真 (返回值 ＝ 23)
    类型.类型 ＝ “机架式服务器”
.如果真结束
.如果真 (返回值 ＝ 24)
    类型.类型 ＝ “密封式计算机”
.如果真结束
脚本.创建 (“MSScriptControl.ScriptControl”, )
脚本.写属性 (“Language”, “VBScript”)
脚本.数值方法 (“AddCode”, #取计算机制造商)
返回值2 ＝ 脚本.通用方法 (“Eval”, “GetA()”).取文本 ()
类型.制造商 ＝ 返回值2
返回 (类型)

.子程序 型号信息, 型号信息
.局部变量 脚本, 对象
.局部变量 返回值, 文本型
.局部变量 返回, 型号信息

脚本.创建 (“MSScriptControl.ScriptControl”, )
脚本.写属性 (“Language”, “VBScript”)
脚本.数值方法 (“AddCode”, #取计算机型号)
返回值 ＝ 脚本.通用方法 (“Eval”, “GetA()”).取文本 ()
返回.型号 ＝ 返回值
返回 (返回)

.子程序 系统信息, 文本型
.局部变量 脚本, 对象
.局部变量 返回值, 文本型

脚本.创建 (“MSScriptControl.ScriptControl”, )
脚本.写属性 (“Language”, “VBScript”)
脚本.数值方法 (“AddCode”, #取系统信息)
返回值 ＝ 脚本.通用方法 (“Eval”, “GetA()”).取文本 ()
返回 (返回值)

.子程序 处理器信息, 文本型
.局部变量 脚本, 对象
.局部变量 返回值, 文本型

脚本.创建 (“MSScriptControl.ScriptControl”, )
脚本.写属性 (“Language”, “VBScript”)
脚本.数值方法 (“AddCode”, #取处理器信息)
返回值 ＝ 脚本.通用方法 (“Eval”, “GetA()”).取文本 ()
返回 (返回值)


.子程序 主板信息, 文本型
.局部变量 脚本, 对象
.局部变量 返回值, 文本型

脚本.创建 (“MSScriptControl.ScriptControl”, )
脚本.写属性 (“Language”, “VBScript”)
脚本.数值方法 (“AddCode”, #取主板信息)
返回值 ＝ 脚本.通用方法 (“Eval”, “GetA()”).取文本 ()
返回 (返回值)


.子程序 BIOS信息, 文本型
.局部变量 脚本, 对象
.局部变量 返回值, 文本型

脚本.创建 (“MSScriptControl.ScriptControl”, )
脚本.写属性 (“Language”, “VBScript”)
脚本.数值方法 (“AddCode”, #取BIOS信息)
返回值 ＝ 脚本.通用方法 (“Eval”, “GetA()”).取文本 ()
返回 (返回值)

.子程序 内存信息, 文本型
.局部变量 脚本, 对象
.局部变量 返回值, 文本型

脚本.创建 (“MSScriptControl.ScriptControl”, )
脚本.写属性 (“Language”, “VBScript”)
脚本.数值方法 (“AddCode”, #取内存信息)
返回值 ＝ 脚本.通用方法 (“Eval”, “GetA()”).取文本 ()
返回 (返回值)

.子程序 显卡信息, 文本型
.局部变量 脚本, 对象
.局部变量 返回值, 文本型

脚本.创建 (“MSScriptControl.ScriptControl”, )
脚本.写属性 (“Language”, “VBScript”)
脚本.数值方法 (“AddCode”, #取显卡信息)
返回值 ＝ 脚本.通用方法 (“Eval”, “GetA()”).取文本 ()
返回 (返回值)

.子程序 硬盘信息, 文本型
.局部变量 脚本, 对象
.局部变量 返回值, 文本型

脚本.创建 (“MSScriptControl.ScriptControl”, )
脚本.写属性 (“Language”, “VBScript”)
脚本.数值方法 (“AddCode”, #取硬盘信息)
返回值 ＝ 脚本.通用方法 (“Eval”, “GetA()”).取文本 ()
返回 (返回值)

.子程序 声卡信息, 文本型
.局部变量 脚本, 对象
.局部变量 返回值, 文本型

脚本.创建 (“MSScriptControl.ScriptControl”, )
脚本.写属性 (“Language”, “VBScript”)
脚本.数值方法 (“AddCode”, #取声卡信息)
返回值 ＝ 脚本.通用方法 (“Eval”, “GetA()”).取文本 ()
返回 (返回值)

.子程序 网卡信息, 文本型
.局部变量 脚本, 对象
.局部变量 返回值, 文本型

脚本.创建 (“MSScriptControl.ScriptControl”, )
脚本.写属性 (“Language”, “VBScript”)
脚本.数值方法 (“AddCode”, #取网卡信息)
返回值 ＝ 脚本.通用方法 (“Eval”, “GetA()”).取文本 ()
返回 (返回值)

.子程序 显示器信息, 文本型
.局部变量 脚本, 对象
.局部变量 返回值, 文本型

脚本.创建 (“MSScriptControl.ScriptControl”, )
脚本.写属性 (“Language”, “VBScript”)
脚本.数值方法 (“AddCode”, #取显示器信息)
返回值 ＝ 脚本.通用方法 (“Eval”, “GetA()”).取文本 ()
返回 (返回值)

.子程序 芯片组信息, 文本型
.局部变量 脚本, 对象
.局部变量 返回值, 文本型

脚本.创建 (“MSScriptControl.ScriptControl”, )
脚本.写属性 (“Language”, “VBScript”)
脚本.数值方法 (“AddCode”, #取芯片组信息2)
返回值 ＝ 脚本.通用方法 (“Eval”, “GetA()”).取文本 ()
返回 (返回值)

.子程序 读取EDID信息, 显示器详细信息
.参数 edid路径, 文本型
.局部变量 字节集变量, 字节集
.局部变量 局部计次变量, 整数型
.局部变量 文本变量, 文本型
.局部变量 内容数组, 文本型, , "0"
.局部变量 生产周, 文本型
.局部变量 生产年, 文本型
.局部变量 水平尺寸, 文本型
.局部变量 垂直尺寸, 文本型
.局部变量 英寸, 小数型
.局部变量 长宽比_二进制, 文本型
.局部变量 长宽比, 文本型
.局部变量 edid版本, 文本型
.局部变量 i, 整数型
.局部变量 name, 文本型
.局部变量 详细信息, 显示器详细信息
.局部变量 文本分割, 文本型, , "0"
.局部变量 品牌, 文本型
.局部变量 品牌1, 文本型
.局部变量 品牌2, 文本型
.局部变量 品牌3, 文本型
.局部变量 分割1, 文本型, , "0"
.局部变量 分割2, 文本型, , "0"
.局部变量 i1, 整数型
.局部变量 序列号, 文本型
.局部变量 品牌源, 文本型

字节集变量 ＝ 取字节集注册项 (#本地机器, “SYSTEM\ControlSet001\Enum\” ＋ edid路径 ＋ “Device Parameters\EDID”, )
.如果真 (取字节集长度 (字节集变量) ＜ 10)
    字节集变量 ＝ 取字节集注册项 (#本地机器, “SYSTEM\ControlSet002\Enum\” ＋ edid路径 ＋ “Device Parameters\EDID”, )
.如果真结束
.如果真 (取字节集长度 (字节集变量) ＜ 10)
    字节集变量 ＝ 取字节集注册项 (#本地机器, “SYSTEM\ControlSet003\Enum\” ＋ edid路径 ＋ “Device Parameters\EDID”, )
.如果真结束
.计次循环首 (取字节集长度 (字节集变量), 局部计次变量)
    文本变量 ＝ 文本变量 ＋ 到文本 (字节集变量 [局部计次变量]) ＋ “,”
.计次循环尾 ()
.如果 (文本变量 ≠ “”)
    内容数组 ＝ 分割文本 (文本变量, “,”, )
    edid版本 ＝ 内容数组 [19] ＋ “.” ＋ 内容数组 [20]
    生产周 ＝ 内容数组 [17]
    生产年 ＝ 到文本 (1990 ＋ 到数值 (内容数组 [18]))
    水平尺寸 ＝ 内容数组 [22]
    垂直尺寸 ＝ 内容数组 [23]
    长宽比_二进制 ＝ 子程序_十进制转二进制 (到数值 (内容数组 [40]))
    长宽比 ＝ 子程序_取长宽比 (长宽比_二进制)
    英寸 ＝ 四舍五入 (求平方根 (求次方 (到数值 (水平尺寸), 2) ＋ 求次方 (到数值 (垂直尺寸), 2)) × 0.393700787, 1)
    i ＝ 96
    .计次循环首 (13, )
        name ＝ name ＋ 十六进制到文本 (十到十六 (内容数组 [i]))
        i ＝ i ＋ 1
    .计次循环尾 ()
    name ＝ 删首尾空去换行符 (name)
    i ＝ 114
    .计次循环首 (13, )
        序列号 ＝ 序列号 ＋ 十六进制到文本 (十到十六 (内容数组 [i]))
        i ＝ i ＋ 1
    .计次循环尾 ()
    品牌 ＝ 十六到二 (内容数组 [9]) ＋ 十六到二 (内容数组 [10])
    品牌源 ＝ 十到十六 (内容数组 [9]) ＋ “ ” ＋ 十到十六 (内容数组 [10])
    ' 品牌 ＝ 十六到二 (“22”) ＋ 十六到二 (“F0”)
    ' 信息框 (品牌, 0, , )
    .如果 (取文本长度 (品牌) ＜ 15)
        .计次循环首 (15 － 取文本长度 (品牌), )
            品牌 ＝ “0” ＋ 品牌
        .计次循环尾 ()
    .否则
        .如果真 (取文本长度 (品牌) ＞ 15)
            品牌 ＝ 取文本右边 (品牌, 15)
        .如果真结束

    .如果结束
    ' 信息框 (品牌, 0, , )
    品牌1 ＝ 取文本左边 (品牌, 5)
    品牌2 ＝ 取文本中间 (品牌, 6, 5)
    品牌3 ＝ 取文本右边 (品牌, 5)
    分割1 ＝ 分割文本 (#显示器制造商翻译, #换行符, )
    .计次循环首 (取数组成员数 (分割1), i1)
        分割2 ＝ 分割文本 (分割1 [i1], “=”, )
        品牌1 ＝ 子文本替换 (品牌1, 分割2 [1], 分割2 [3], , , 真)
        品牌2 ＝ 子文本替换 (品牌2, 分割2 [1], 分割2 [3], , , 真)
        品牌3 ＝ 子文本替换 (品牌3, 分割2 [1], 分割2 [3], , , 真)
    .计次循环尾 ()
    品牌 ＝ 品牌1 ＋ 品牌2 ＋ 品牌3
    .如果真 (寻找文本 (品牌, “0”, , 假) ≠ -1 或 寻找文本 (品牌, “1”, , 假) ≠ -1)
        品牌 ＝ “数据格式不规范或未收录的品牌。”
    .如果真结束

    文本分割 ＝ 分割文本 (edid路径, “”, )
    .如果真 (取数组成员数 (文本分割) ＝ 3)
        详细信息.ID ＝ 文本分割 [2]
        详细信息.ID ＝ 显示器ID翻译 (详细信息.ID)
    .如果真结束
    详细信息.品牌 ＝ 品牌
    详细信息.型号 ＝ name
    详细信息.尺寸 ＝ 到文本 (英寸)
    详细信息.edid版本 ＝ edid版本
    详细信息.高度 ＝ 垂直尺寸
    详细信息.宽度 ＝ 水平尺寸
    详细信息.生产日期 ＝ 生产年 ＋ “年第” ＋ 生产周 ＋ “周”
    详细信息.序列号 ＝ 序列号
    详细信息.品牌源数据 ＝ 品牌源
    详细信息.edid ＝ 字节集变量
    返回 (详细信息)
.否则
    返回 (详细信息)
.如果结束


.子程序 显示器ID翻译, 文本型
.参数 id, 文本型
.局部变量 自定义内容, 文本型
.局部变量 翻译分割1, 文本型, , "0"
.局部变量 翻译分割2, 文本型, , "0"
.局部变量 i, 整数型
.局部变量 返回值, 文本型
.局部变量 a, 逻辑型

a ＝ 假
自定义内容 ＝ #显示器ID翻译
.如果真 (文件是否存在 (运行目录_全局 ＋ “data\MonitorID.dat”) ＝ 真)
    自定义内容 ＝ 到文本 (解密数据 (读入文件 (运行目录_全局 ＋ “data\MonitorID.dat”), “tulading”, 1))
.如果真结束
翻译分割1 ＝ 分割文本 (自定义内容, #换行符, )
.计次循环首 (取数组成员数 (翻译分割1), i)
    翻译分割2 ＝ 分割文本 (翻译分割1 [i], “=”, )
    .如果真 (取文本左边 (id, 3) ＝ 翻译分割2 [1])
        返回值 ＝ 子文本替换 (id, 翻译分割2 [1], 翻译分割2 [2], , , 假)
        a ＝ 真
        跳出循环 ()
    .如果真结束

.计次循环尾 ()
.如果真 (a ＝ 假)
    返回值 ＝ id
.如果真结束
返回 (返回值)

.子程序 删首尾空去换行符, 文本型
.参数 a, 文本型

a ＝ 子文本替换 (a, #换行符, “”, , , 真)
a ＝ 子文本替换 (a, 字符 (13), “”, , , 真)
.判断循环首 (取文本左边 (a, 1) ＝ “ ”)
    a ＝ 取文本右边 (a, 取文本长度 (a) － 1)
.判断循环尾 ()
.判断循环首 (取文本右边 (a, 1) ＝ “ ”)
    a ＝ 取文本左边 (a, 取文本长度 (a) － 1)
.判断循环尾 ()
返回 (a)

.子程序 十到十六, 文本型
.参数 待转, 文本型
.局部变量 arr, 文本型
.局部变量 i, 整数型
.局部变量 temptxt, 文本型
.局部变量 tempint, 整数型
.局部变量 余数数组, 文本型, , "16"
.局部变量 余, 整数型

余数数组 ＝ { “0”, “1”, “2”, “3”, “4”, “5”, “6”, “7”, “8”, “9”, “A”, “B”, “C”, “D”, “E”, “F” }
tempint ＝ 0
arr ＝ “”  ' 先置为空
tempint ＝ 到数值 (待转)  ' 转变为数值型的
.判断循环首 (tempint ≥ 0)  ' 除16取余，结果倒序
    余 ＝ tempint ％ 16
    arr ＝ 余数数组 [余 ＋ 1] ＋ arr
    tempint ＝ (tempint － 余) ÷ 16  ' zc()
    .如果真 (tempint ≤ 0)  ' 如果为0，则跳出循环。
        跳出循环 ()
    .如果真结束

.判断循环尾 ()
.如果真 (取文本长度 (arr) ＝ 1)
    arr ＝ “0” ＋ arr
.如果真结束
返回 (arr)

.子程序 十六进制到文本, 文本型
.参数 Hex, 文本型
.局部变量 长度, 整数型
.局部变量 编辑文本, 文本型
.局部变量 i, 整数型
.局部变量 单文本, 文本型
.局部变量 二次组合文本, 文本型

编辑文本 ＝ Hex
长度 ＝ 取文本长度 (编辑文本)
.如果真 (长度 ％ 2 ＝ 1)
    长度 ＝ 长度 ＋ 1
    编辑文本 ＝ 编辑文本 ＋ “0”
.如果真结束
i ＝ 1
.计次循环首 (长度 ÷ 2, )
    单文本 ＝ 取文本中间 (编辑文本, i, 2)
    二次组合文本 ＝ 二次组合文本 ＋ 字符 (十六到十 (单文本))
    i ＝ i ＋ 2
.计次循环尾 ()
返回 (二次组合文本)

.子程序 十六到十, 整数型
.参数 十六进制文本, 文本型, 可空
.参数 返回结果, 文本型, 参考 可空
.局部变量 中间文本, 文本型
.局部变量 结果, 长整数型
.局部变量 容器1, 整数型

返回结果 ＝ “”
.变量循环首 (1, 取文本长度 (十六进制文本), 1, 容器1)
    中间文本 ＝ 取文本中间 (十六进制文本, 容器1, 1)
    结果 ＝ (寻找文本 (“0123456789ABCDEF”, 中间文本, , 真) － 1) × 求次方 (16, 取文本长度 (十六进制文本) － 容器1) ＋ 结果
.变量循环尾 ()
.如果真 (是否为空 (返回结果) ＝ 假)
    返回结果 ＝ 到文本 (结果)
.如果真结束
返回 (结果)

.子程序 十六到二, 文本型
.参数 十六进制, 文本型
.局部变量 二进制, 文本型
.局部变量 单十六进制, 文本型
.局部变量 单二进制, 文本型
.局部变量 长度, 整数型
.局部变量 变量1, 整数型

长度 ＝ 取文本长度 (十六进制)
.计次循环首 (长度, 变量1)
    单十六进制 ＝ 取文本中间 (十六进制, 变量1, 1)
    .如果真 (单十六进制 ＝ “0”)
        单二进制 ＝ “0000”
    .如果真结束
    .如果真 (单十六进制 ＝ “1”)
        单二进制 ＝ “0001”
    .如果真结束
    .如果真 (单十六进制 ＝ “2”)
        单二进制 ＝ “0010”
    .如果真结束
    .如果真 (单十六进制 ＝ “3”)
        单二进制 ＝ “0011”
    .如果真结束
    .如果真 (单十六进制 ＝ “4”)
        单二进制 ＝ “0100”
    .如果真结束
    .如果真 (单十六进制 ＝ “5”)
        单二进制 ＝ “0101”
    .如果真结束
    .如果真 (单十六进制 ＝ “6”)
        单二进制 ＝ “0110”
    .如果真结束
    .如果真 (单十六进制 ＝ “7”)
        单二进制 ＝ “0111”
    .如果真结束
    .如果真 (单十六进制 ＝ “8”)
        单二进制 ＝ “1000”
    .如果真结束
    .如果真 (单十六进制 ＝ “9”)
        单二进制 ＝ “1001”
    .如果真结束
    .如果真 (单十六进制 ＝ “A”)
        单二进制 ＝ “1010”
    .如果真结束
    .如果真 (单十六进制 ＝ “B”)
        单二进制 ＝ “1011”
    .如果真结束
    .如果真 (单十六进制 ＝ “C”)
        单二进制 ＝ “1100”
    .如果真结束
    .如果真 (单十六进制 ＝ “D”)
        单二进制 ＝ “1101”
    .如果真结束
    .如果真 (单十六进制 ＝ “E”)
        单二进制 ＝ “1110”
    .如果真结束
    .如果真 (单十六进制 ＝ “F”)
        单二进制 ＝ “1111”
    .如果真结束
    二进制 ＝ 二进制 ＋ 单二进制
.计次循环尾 ()
返回 (二进制)

.子程序 子程序_十进制转二进制, 文本型
.参数 十进制, 整数型
.局部变量 十六进制, 文本型
.局部变量 二进制, 文本型
.局部变量 单十六进制, 文本型
.局部变量 单二进制, 文本型
.局部变量 长度, 整数型
.局部变量 变量1, 整数型

十六进制 ＝ 取十六进制文本 (十进制)
长度 ＝ 取文本长度 (十六进制)
.计次循环首 (长度, 变量1)
    单十六进制 ＝ 取文本中间 (十六进制, 变量1, 1)
    .如果真 (单十六进制 ＝ “0”)
        单二进制 ＝ “0000”
    .如果真结束
    .如果真 (单十六进制 ＝ “1”)
        单二进制 ＝ “0001”
    .如果真结束
    .如果真 (单十六进制 ＝ “2”)
        单二进制 ＝ “0010”
    .如果真结束
    .如果真 (单十六进制 ＝ “3”)
        单二进制 ＝ “0011”
    .如果真结束
    .如果真 (单十六进制 ＝ “4”)
        单二进制 ＝ “0100”
    .如果真结束
    .如果真 (单十六进制 ＝ “5”)
        单二进制 ＝ “0101”
    .如果真结束
    .如果真 (单十六进制 ＝ “6”)
        单二进制 ＝ “0110”
    .如果真结束
    .如果真 (单十六进制 ＝ “7”)
        单二进制 ＝ “0111”
    .如果真结束
    .如果真 (单十六进制 ＝ “8”)
        单二进制 ＝ “1000”
    .如果真结束
    .如果真 (单十六进制 ＝ “9”)
        单二进制 ＝ “1001”
    .如果真结束
    .如果真 (单十六进制 ＝ “A”)
        单二进制 ＝ “1010”
    .如果真结束
    .如果真 (单十六进制 ＝ “B”)
        单二进制 ＝ “1011”
    .如果真结束
    .如果真 (单十六进制 ＝ “C”)
        单二进制 ＝ “1100”
    .如果真结束
    .如果真 (单十六进制 ＝ “D”)
        单二进制 ＝ “1101”
    .如果真结束
    .如果真 (单十六进制 ＝ “E”)
        单二进制 ＝ “1110”
    .如果真结束
    .如果真 (单十六进制 ＝ “F”)
        单二进制 ＝ “1111”
    .如果真结束
    二进制 ＝ 二进制 ＋ 单二进制
.计次循环尾 ()
返回 (二进制)


.子程序 子程序_取长宽比, 文本型
.参数 长宽比_二进制, 文本型
.局部变量 长宽比, 文本型
.局部变量 代码, 文本型

代码 ＝ 取文本左边 (长宽比_二进制, 2)
.判断开始 (代码 ＝ “00”)
    长宽比 ＝ “1:1”
.判断 (代码 ＝ “01”)
    长宽比 ＝ “4:3”
.判断 (代码 ＝ “10”)
    长宽比 ＝ “5:4”
.判断 (代码 ＝ “11”)
    长宽比 ＝ “16:9”
.默认

.判断结束

返回 (长宽比)

.子程序 取全部硬件

取BIOS信息_2 ()
取声卡信息2 ()
取网卡信息2 ()
取计算机类型2 ()
取计算机型号2 ()
取显卡信息2 ()
取显示器信息2 ()
取系统信息_2 ()
取主板信息2 ()
取硬盘信息_2 ()
取处理器信息2 ()
取内存信息2 ()


.子程序 取内存容量信息, 文本型, 公开, 取内存容量信息，单位为M（兆）。本命令为初级命令。
.局部变量 内存指针, MEMORYSTATUSEX
.局部变量 返回值, 文本型


内存指针.dwLength ＝ 64
GlobalMemoryStatusEx (内存指针)
返回值 ＝ 到文本 (四舍五入 (内存指针.ullTotalPhys ÷ 1048576 ÷ 1024, )) ＋ “GB”
' 调试输出 (内存指针.ullTotalVirtual ÷ 1048576)
返回 (返回值)