变体型数据结构简单分析

350246356

今天玩到了变体型 就好奇他的结构,找遍全网资料还是挺少的,自己留个笔记吧！

  

子程序名	返回值类型	公开	备 注
_临时子程序

变量名	类 型	静态	数组	备 注
a	文本型

' 本名称子程序用作测试程序用，仅在开发及调试环境中有效，编译发布程序前将被系统自动清空，请将所有用作测试的临时代码放在本子程序中。 ***注意不要修改本子程序的名称、参数及返回值类型。
' 调试输出 (反汇编子程序 (&Test))
' Test ()
变体分析 ()

子程序名	返回值类型	公开	备 注
变体分析

变量名	类 型	静态	数组	备 注
_VAR	变体型
_Addr	整数型
_Addr_1	整数型
_VAR_TYPE	整数型

_VAR.赋值 (“abc啊123”, )
' _VAR.赋值 ({ “b”, “a” }, )
_Addr ＝ 取数据_通用型 (_VAR)
_VAR_TYPE ＝ 指针到整数 (_Addr ＋ 0)
调试输出 (“数据类型: ” ＋ 变体_取类型 (_VAR_TYPE))
调试输出 (“Addr + 0”, _VAR_TYPE)  ' 数据类型
调试输出 (“Addr + 2”, 指针到整数 (_Addr ＋ 2))  ' 保留0
调试输出 (“Addr + 4”, 指针到整数 (_Addr ＋ 4))  ' 保留0
_Addr_1 ＝ 指针到整数 (_Addr ＋ 8)  ' 数组为结构体指针,其他为数据指针。占位4字节
调试输出 (“Addr + 8”, _Addr_1)
如果真 (_VAR_TYPE ＝ 8)  ' 8是文本型
' // 返回的是宽字节文本 每个字算2个字节
' 调试输出 (指针到文本 (_Addr_1)) '这样是不合理的 因为是宽字符 占位2字节 如果是不是双字节字符 以0填充 ，文本结束符也是0所以只能取1个字节
' 调试输出 (指针到文本W (_Addr_1)) '想用汇编实现 奈何不会写哈哈哈~~~
调试输出 (“文本W:”, 指针到字节集 (_Addr_1, 7 × 2 ＋ 2))  ' 文本字数(宽字符) * 占位字节 + 结束符 0 0
调试输出 (“Addr + 12”, 指针到整数 (_Addr ＋ 12))  ' 保留0
如果真 (_VAR_TYPE ＞ 8192)
调试输出 (“------------------------------ 变体数组结构 尺寸为24字节 ------------------------”)
调试输出 (“Addr_1 + 0”, 指针到整数 (_Addr_1 ＋ 0))  ' 维数 也好像是内存大小吧 搞不懂
调试输出 (“Addr_1 + 4”, 指针到整数 (_Addr_1 ＋ 4))  ' 数据占位长度 如整数型占位4字节 就是4
调试输出 (“Addr_1 + 8”, 指针到整数 (_Addr_1 ＋ 8))  ' 保留0
调试输出 (“Addr_1 + 12”, 指针到整数 (_Addr_1 ＋ 12))  ' 数组指针
' // 数组数据如果为文本也是宽字符 解释和
调试输出 (“Addr_1 + 12 - 成员1”, 指针到字节集 (指针到整数 (指针到整数 (_Addr_1 ＋ 12) ＋ 0), 2 ＋ 2))  ' 数组第一个数据指针
调试输出 (“Addr_1 + 12 - 成员2”, 指针到字节集 (指针到整数 (指针到整数 (_Addr_1 ＋ 12) ＋ 4), 2 ＋ 2))  ' 数组第二个数据指针
调试输出 (“Addr_1 + 16”, 指针到整数 (_Addr_1 ＋ 16))  ' 数组成员数
调试输出 (“Addr_1 + 20”, 指针到整数 (_Addr_1 ＋ 20))  ' 保留1

子程序名	返回值类型	公开	备 注
变体_取类型	文本型		部分特殊类型可能不准
参数名	类 型	参考	可空	数组	备 注
Code	整数型

变量名	类 型	静态	数组	备 注
_Code	整数型
_Msg	文本型

如果 (Code ≥ 8192)
_Msg ＝ “ - 数组”
_Code ＝ Code ％ 8192
_Code ＝ Code

判断 (_Code ＝ 0)
_Msg ＝ “Empty” ＋ _Msg
判断 (_Code ＝ 1)
_Msg ＝ “Null” ＋ _Msg
判断 (_Code ＝ 2)
_Msg ＝ “整数型” ＋ _Msg
判断 (_Code ＝ 3)
_Msg ＝ “长整数型” ＋ _Msg
判断 (_Code ＝ 4)
_Msg ＝ “小数型” ＋ _Msg
判断 (_Code ＝ 5)
_Msg ＝ “双精度小数型” ＋ _Msg
判断 (_Code ＝ 6)
_Msg ＝ “货币型” ＋ _Msg
判断 (_Code ＝ 7)
_Msg ＝ “时间日期型” ＋ _Msg
判断 (_Code ＝ 8)
_Msg ＝ “文本型” ＋ _Msg
判断 (_Code ＝ 9)
_Msg ＝ “对象” ＋ _Msg
判断 (_Code ＝ 10)
_Msg ＝ “错误” ＋ _Msg
判断 (_Code ＝ 11)
_Msg ＝ “逻辑型” ＋ _Msg
判断 (_Code ＝ 12)
_Msg ＝ “变体型” ＋ _Msg
判断 (_Code ＝ 13)
_Msg ＝ “对象” ＋ _Msg
判断 (_Code ＝ 17)
_Msg ＝ “字节型” ＋ _Msg
_Msg ＝ “未知”
返回 (_Msg)

子程序名	返回值类型	公开	备 注
取数据_通用型	整数型		取到的是变量在堆中的地址,和 取变量数据地址() 一样,注意: 字节集数据需要+8,前8位是标准,字节集型数据建议使用 取指针_字节集型()
参数名	类 型	参考	可空	数组	备 注
变量	通用型				基本支持所有类型

置入代码 ({ 139, 69, 8, 139, 0, 201, 194, 4, 0 })
返回 (0)

i支持库列表	支持库注释
spec	特殊功能支持库

.版本 2<br /> .支持库 spec<br /> <br /> .子程序 _临时子程序<br /> .局部变量 a, 文本型<br /> <br /> ' 本名称子程序用作测试程序用，仅在开发及调试环境中有效，编译发布程序前将被系统自动清空，请将所有用作测试的临时代码放在本子程序中。 ***注意不要修改本子程序的名称、参数及返回值类型。<br /> <br /> ' 调试输出 (反汇编子程序 (&Test))<br /> ' Test ()<br /> 变体分析 ()<br /> <br /> .子程序 变体分析<br /> .局部变量 _VAR, 变体型<br /> .局部变量 _Addr, 整数型<br /> .局部变量 _Addr_1, 整数型<br /> .局部变量 _VAR_TYPE, 整数型<br /> <br /> _VAR.赋值 (“abc啊123”, )<br /> ' _VAR.赋值 ({ “b”, “a” }, )<br /> _Addr ＝ 取数据_通用型 (_VAR)<br /> _VAR_TYPE ＝ 指针到整数 (_Addr ＋ 0)<br /> 调试输出 (“数据类型: ” ＋ 变体_取类型 (_VAR_TYPE))<br /> 调试输出 (“Addr + 0”, _VAR_TYPE)  ' 数据类型<br /> 调试输出 (“Addr + 2”, 指针到整数 (_Addr ＋ 2))  ' 保留0<br /> 调试输出 (“Addr + 4”, 指针到整数 (_Addr ＋ 4))  ' 保留0<br /> _Addr_1 ＝ 指针到整数 (_Addr ＋ 8)  ' 数组为结构体指针,其他为数据指针。占位4字节<br /> 调试输出 (“Addr + 8”, _Addr_1)<br /> .如果真 (_VAR_TYPE ＝ 8)  ' 8是文本型<br />     ' // 返回的是宽字节文本 每个字算2个字节<br />     ' 调试输出 (指针到文本 (_Addr_1)) '这样是不合理的 因为是宽字符 占位2字节 如果是不是双字节字符 以0填充 ，文本结束符也是0所以只能取1个字节<br />     ' 调试输出 (指针到文本W (_Addr_1)) '想用汇编实现 奈何不会写哈哈哈~~~<br />     调试输出 (“文本W:”, 指针到字节集 (_Addr_1, 7 × 2 ＋ 2))  ' 文本字数(宽字符) * 占位字节 + 结束符 0 0<br /> .如果真结束<br /> 调试输出 (“Addr + 12”, 指针到整数 (_Addr ＋ 12))  ' 保留0<br /> .如果真 (_VAR_TYPE ＞ 8192)<br />     调试输出 (“------------------------------ 变体数组结构 尺寸为24字节 ------------------------”)<br />     调试输出 (“Addr_1 + 0”, 指针到整数 (_Addr_1 ＋ 0))  ' 维数 也好像是内存大小吧 搞不懂<br />     调试输出 (“Addr_1 + 4”, 指针到整数 (_Addr_1 ＋ 4))  ' 数据占位长度 如整数型占位4字节 就是4<br />     调试输出 (“Addr_1 + 8”, 指针到整数 (_Addr_1 ＋ 8))  ' 保留0<br />     调试输出 (“Addr_1 + 12”, 指针到整数 (_Addr_1 ＋ 12))  ' 数组指针<br /> <br />     ' // 数组数据如果为文本也是宽字符 解释和<br />     调试输出 (“Addr_1 + 12 - 成员1”, 指针到字节集 (指针到整数 (指针到整数 (_Addr_1 ＋ 12) ＋ 0), 2 ＋ 2))  ' 数组第一个数据指针<br />     调试输出 (“Addr_1 + 12 - 成员2”, 指针到字节集 (指针到整数 (指针到整数 (_Addr_1 ＋ 12) ＋ 4), 2 ＋ 2))  ' 数组第二个数据指针<br />     调试输出 (“Addr_1 + 16”, 指针到整数 (_Addr_1 ＋ 16))  ' 数组成员数<br />     调试输出 (“Addr_1 + 20”, 指针到整数 (_Addr_1 ＋ 20))  ' 保留1<br /> .如果真结束<br /> <br /> <br /> .子程序 变体_取类型, 文本型, 公开, 部分特殊类型可能不准<br /> .参数 Code, 整数型<br /> .局部变量 _Code, 整数型<br /> .局部变量 _Msg, 文本型<br /> <br /> .如果 (Code ≥ 8192)<br />     _Msg ＝ “ - 数组”<br />     _Code ＝ Code ％ 8192<br /> .否则<br />     _Code ＝ Code<br /> .如果结束<br /> <br /> .判断开始 (_Code ＝ 0)<br />     _Msg ＝ “Empty” ＋ _Msg<br /> .判断 (_Code ＝ 1)<br />     _Msg ＝ “Null” ＋ _Msg<br /> .判断 (_Code ＝ 2)<br />     _Msg ＝ “整数型” ＋ _Msg<br /> .判断 (_Code ＝ 3)<br />     _Msg ＝ “长整数型” ＋ _Msg<br /> .判断 (_Code ＝ 4)<br />     _Msg ＝ “小数型” ＋ _Msg<br /> .判断 (_Code ＝ 5)<br />     _Msg ＝ “双精度小数型” ＋ _Msg<br /> .判断 (_Code ＝ 6)<br />     _Msg ＝ “货币型” ＋ _Msg<br /> .判断 (_Code ＝ 7)<br />     _Msg ＝ “时间日期型” ＋ _Msg<br /> .判断 (_Code ＝ 8)<br />     _Msg ＝ “文本型” ＋ _Msg<br /> .判断 (_Code ＝ 9)<br />     _Msg ＝ “对象” ＋ _Msg<br /> .判断 (_Code ＝ 10)<br />     _Msg ＝ “错误” ＋ _Msg<br /> .判断 (_Code ＝ 11)<br />     _Msg ＝ “逻辑型” ＋ _Msg<br /> .判断 (_Code ＝ 12)<br />     _Msg ＝ “变体型” ＋ _Msg<br /> .判断 (_Code ＝ 13)<br />     _Msg ＝ “对象” ＋ _Msg<br /> .判断 (_Code ＝ 17)<br />     _Msg ＝ “字节型” ＋ _Msg<br /> .默认<br />     _Msg ＝ “未知”<br /> .判断结束<br /> 返回 (_Msg)<br /> <br /> .子程序 取数据_通用型, 整数型, , 取到的是变量在堆中的地址,和 取变量数据地址() 一样,注意: 字节集数据需要+8,前8位是标准,字节集型数据建议使用 取指针_字节集型()<br /> .参数 变量, 通用型, 参考, 基本支持所有类型<br /> <br /> 置入代码 ({ 139, 69, 8, 139, 0, 201, 194, 4, 0 })<br /> 返回 (0)

补充内容 (2019-11-1 23:28):
宽字节文本可以用 Unicode宽文本 转 Ansi文本 解码  如 U2A({79,0,0,0})

洗洗脚睡吧

学习 学习

year1970

感谢分享

dnxl

576003133

支持你，下载看看

576003133

下载看看，好东西，

闭眼就天黑

变体型能和json转换吗

kobefu

这个真的感谢！！！

181335249

变体型哪里有视频教程详细介绍的  一头雾水

wjswzj0

支持开源~！感谢分享