模块类_快速文本功能改进

jr21066 · 发表于 2018-9-30 20:21:46

加了一些功能.请测试

窗口程序集名	保留	保留	备注
类_快速文本, , 公开, 文本的快速累加
变量名	类型	数组	备注
_文件句柄	整数型
集_缓冲区	字节集

子程序名	返回值类型	公开	备注
_初始化			当基于本类的对象被创建后，此方法会被自动调用

_文件句柄＝打开内存文件 ()

子程序名	返回值类型	公开	备注
_销毁			当基于本类的对象被销毁前，此方法会被自动调用

关闭文件 (_文件句柄)

子程序名	返回值类型	公开	备注
添加			增加文本内容到最后
参数名	类型	参考	可空	数组	备注
参_文本内容	文本型				增加的文本

写出文本 (_文件句柄, 参_文本内容)

子程序名	返回值类型	公开	备注
插入	逻辑型		在指定字符后(含中文)插入文本内容
参数名	类型	参考	可空	数组	备注
参_插入位置	整数型				字符数,中文也算一个字符,可空,默认最前
参_文本内容	文本型				要插入的文本内容

变量名	类型	静态	数组	备注
局_缓冲区长度	整数型
局_偏移	整数型

写缓存区 ()
局_缓冲区长度＝取字节集长度 (集_缓冲区)
局_偏移＝ 1

如果真 (是否为空 (参_插入位置))

参_插入位置＝ 0
局_偏移＝字数到位置 (参_插入位置)
局_偏移＝局_偏移－ 1
移动读写位置 (_文件句柄, #文件首, 局_偏移)
返回 (插入文本 (_文件句柄, 参_文本内容))

子程序名	返回值类型	公开	备注
取文本内容	文本型		取出文本内容
参数名	类型	参考	可空	数组	备注
参_起始位置	整数型				可空.默认从第一个字符开始
参_字符数	整数型				可空,默认取全部

变量名	类型	静态	数组	备注
局_偏移	整数型
局_缓冲区长度	整数型
局_偏移2	整数型

如果真 (取读写位置 (_文件句柄) ≠ 0)

移到文件首 (_文件句柄)

如果真 (是否为空 (参_字符数) 且是否为空 (参_起始位置))

返回 (读入文本 (_文件句柄, ))

集_缓冲区＝读入字节集 (_文件句柄, 取文件长度 (_文件句柄))

如果真 (是否为空 (参_起始位置))

参_起始位置＝ 1

如果真 (是否为空 (参_字符数))

参_字符数＝取字节集长度 (集_缓冲区)
参_起始位置＝参_起始位置－ 1
局_偏移＝ 1
局_缓冲区长度＝取字节集长度 (集_缓冲区)
局_偏移＝字数到位置 (参_起始位置)
局_偏移2 ＝字数到位置 (参_起始位置＋参_字符数)
返回 (到文本 (取字节集中间 (集_缓冲区, 局_偏移, 局_偏移2 －局_偏移)))

子程序名	返回值类型	公开	备注
清空内容			清空文本内容

关闭文件 (_文件句柄)
_文件句柄＝打开内存文件 ()

子程序名	返回值类型	公开	备注
删除文本	逻辑型		删除指定位置内容
参数名	类型	参考	可空	数组	备注
参_起始位置	整数型				起始位置
参_字符数	整数型				删除个数,汉字算一个

变量名	类型	静态	数组	备注
局_偏移	整数型
局_缓冲区长度	整数型
局_偏移2	整数型

如果真 (取读写位置 (_文件句柄) ≠ 0)

移到文件首 (_文件句柄)
集_缓冲区＝读入字节集 (_文件句柄, 取文件长度 (_文件句柄))
局_缓冲区长度＝取字节集长度 (集_缓冲区)
局_偏移＝字数到位置 (参_起始位置)
局_偏移2 ＝字数到位置 (参_起始位置＋参_字符数)
移动读写位置 (_文件句柄, #文件首, 局_偏移－ 1)
返回 (删除数据 (_文件句柄, 局_偏移2 －局_偏移))

子程序名	返回值类型	公开	备注
取文件号	整数型		取内存文件句柄

返回 (_文件句柄)

子程序名	返回值类型	公开	备注
替换文本内容	逻辑型		替换指定位置文本
参数名	类型	参考	可空	数组	备注
参_替换位置	整数型				起始位置
参_替换长度	整数型				替换长度
参_替换文本	文本型				替换文本,可空

变量名	类型	静态	数组	备注
局_偏移1	整数型
局_偏移2	整数型
局_缓冲区长度	整数型

写缓存区 ()
局_偏移1 ＝ 1
局_缓冲区长度＝取字节集长度 (集_缓冲区)
局_偏移1 ＝字数到位置 (参_替换位置)
局_偏移2 ＝字数到位置 (参_替换位置＋参_替换长度)
清空内容 ()
返回 (写出字节集 (_文件句柄, 字节集替换 (集_缓冲区, 局_偏移1, 局_偏移2 －局_偏移1, 到字节集 (参_替换文本))))

子程序名	返回值类型	公开	备注
取长度	整数型		取字符数,汉字算一个

如果真 (取读写位置 (_文件句柄) ≠ 0)

移到文件首 (_文件句柄)
返回 (汇编_取字数 (到字节集 (取文本内容 (, ))))

子程序名	返回值类型	公开	备注
寻找文本内容	整数型		寻找文本
参数名	类型	参考	可空	数组	备注
参_寻找文本内容	文本型				欲寻找文本
参_起始寻找位置	整数型				起始位置,可空,默认从最头开始

变量名	类型	静态	数组	备注
局_偏移	整数型
局_文本	字节集

写缓存区 ()
局_偏移＝ 1

如果真 (是否为空 (参_起始寻找位置))

参_起始寻找位置＝ 1
局_偏移＝字数到位置 (参_起始寻找位置)
局_文本＝取字节集左边 (集_缓冲区, 寻找字节集 (集_缓冲区, 到字节集 (参_寻找文本内容), 局_偏移) － 1)

如果 (局_文本＝ { })

返回 (0)

返回 (汇编_取字数 (局_文本) ＋ 1)

子程序名	返回值类型	公开	备注
替换子文本内容	逻辑型		子文本替换
参数名	类型	参考	可空	数组	备注
参_被替换文本	文本型				被替换内容
参_替换为文本	文本型				替换为内容,可空.默认删除
参_起始替换位置	整数型				起始位置,可空,默认从最前开始
参_最大替换次数	整数型				最大替换次数.可空.默认替换所有

变量名	类型	静态	数组	备注
局_偏移	整数型
局_缓冲区长度	整数型

写缓存区 ()
局_偏移＝ 1
局_缓冲区长度＝取字节集长度 (集_缓冲区)

如果真 (是否为空 (参_起始替换位置))

参_起始替换位置＝ 1
局_偏移＝字数到位置 (参_起始替换位置)
清空内容 ()

如果 (是否为空 (参_最大替换次数))

返回 (写出字节集 (_文件句柄, 子字节集替换 (集_缓冲区, 到字节集 (参_被替换文本), 到字节集 (参_替换为文本), 局_偏移, )))

返回 (写出字节集 (_文件句柄, 子字节集替换 (集_缓冲区, 到字节集 (参_被替换文本), 到字节集 (参_替换为文本), 局_偏移, 参_最大替换次数)))

子程序名	返回值类型	公开	备注
汇编_取字数	整数型		取文本中英文字数
参数名	类型	参考	可空	数组	备注
参_内容	字节集

参_内容＝参_内容＋ { 0 }
取变量地址 (参_内容)
置入代码 ({ 139, 24, 139, 75, 4, 141, 115, 8, 172, 132, 192, 116, 7, 168, 128, 116, 1, 70, 226, 244, 139, 67, 4, 41, 200, 201, 194, 4, 0 })
返回 (0)

子程序名	返回值类型	公开	备注
置文本	逻辑型		置文本
参数名	类型	参考	可空	数组	备注
参_文本	文本型				文本内容

关闭文件 (_文件句柄)
_文件句柄＝打开内存文件 ()
返回 (写出文本 (_文件句柄, 参_文本))

子程序名	返回值类型	公开	备注
从文件读入	逻辑型		读文件内容到内存
参数名	类型	参考	可空	数组	备注
参_文件名	文本型				要读入的文件名

关闭文件 (_文件句柄)
_文件句柄＝打开内存文件 ()
返回 (写出字节集 (_文件句柄, 读入文件 (参_文件名)))

子程序名	返回值类型	公开	备注
写出到文件	逻辑型		写内存内容到文件
参数名	类型	参考	可空	数组	备注
参_文件名	文本型				要写出的文件名

如果真 (取读写位置 (_文件句柄) ≠ 0)

移到文件首 (_文件句柄)
返回 (写到文件 (参_文件名, 读入字节集 (_文件句柄, 取文件长度 (_文件句柄))))

子程序名	返回值类型	公开	备注
删全部空格	逻辑型		删除所有中英文空格

变量名	类型	静态	数组	备注
局_计数器	整数型
局_缓冲区长度	整数型

写缓存区 ()
局_缓冲区长度＝取字节集长度 (集_缓冲区)
清空内容 ()
局_计数器＝ 1

判断循环首 (局_缓冲区长度＞局_计数器)

判断 (集_缓冲区 [局_计数器] ＝ 32)

局_计数器＝局_计数器＋ 1

到循环尾 ()

判断 (集_缓冲区 [局_计数器] ＝ 161 且集_缓冲区 [局_计数器＋ 1] ＝ 161)

局_计数器＝局_计数器＋ 2

到循环尾 ()

写出字节集 (_文件句柄, 到字节集 (集_缓冲区 [局_计数器]))

局_计数器＝局_计数器＋ 1

判断循环尾 ()

如果 (取长度 () ＝ 0)

返回 (假)

返回 (真)

子程序名	返回值类型	公开	备注
写缓存区

如果真 (取读写位置 (_文件句柄) ≠ 0)

移到文件首 (_文件句柄)
集_缓冲区＝读入字节集 (_文件句柄, 取文件长度 (_文件句柄))

子程序名	返回值类型	公开	备注
删首尾空格	逻辑型

变量名	类型	静态	数组	备注
局_计数器	整数型
局_缓冲区长度	整数型
局_偏移1	整数型

写缓存区 ()
局_缓冲区长度＝取字节集长度 (集_缓冲区)
清空内容 ()
局_计数器＝ 1

判断循环首 (局_缓冲区长度＞局_计数器)

判断 (集_缓冲区 [局_计数器] ＝ 32)

局_计数器＝局_计数器＋ 1

到循环尾 ()

判断 (集_缓冲区 [局_计数器] ＝ 161 且集_缓冲区 [局_计数器＋ 1] ＝ 161)

局_计数器＝局_计数器＋ 2

到循环尾 ()

跳出循环 ()

判断循环尾 ()
局_偏移1 ＝局_计数器
局_计数器＝局_缓冲区长度

判断循环首 (局_计数器＞ 1)

判断 (集_缓冲区 [局_计数器] ＝ 32)

局_计数器＝局_计数器－ 1

到循环尾 ()

判断 (集_缓冲区 [局_计数器] ＝ 161 且集_缓冲区 [局_计数器－ 1] ＝ 161)

局_计数器＝局_计数器－ 2

到循环尾 ()

跳出循环 ()

判断循环尾 ()
返回 (写出字节集 (_文件句柄, 取字节集中间 (集_缓冲区, 局_偏移1, 局_计数器－局_偏移1 ＋ 1)))

子程序名	返回值类型	公开	备注
删首空格	逻辑型

变量名	类型	静态	数组	备注
局_计数器	整数型
局_缓冲区长度	整数型

写缓存区 ()
局_缓冲区长度＝取字节集长度 (集_缓冲区)
清空内容 ()
局_计数器＝ 1

判断循环首 (局_缓冲区长度＞局_计数器)

判断 (集_缓冲区 [局_计数器] ＝ 32)

局_计数器＝局_计数器＋ 1

到循环尾 ()

判断 (集_缓冲区 [局_计数器] ＝ 161 且集_缓冲区 [局_计数器＋ 1] ＝ 161)

局_计数器＝局_计数器＋ 2

到循环尾 ()

跳出循环 ()

判断循环尾 ()
返回 (写出字节集 (_文件句柄, 取字节集右边 (集_缓冲区, 局_缓冲区长度－局_计数器＋ 1)))

子程序名	返回值类型	公开	备注
删尾空格	逻辑型

变量名	类型	静态	数组	备注
局_计数器	整数型
局_缓冲区长度	整数型

写缓存区 ()
局_缓冲区长度＝取字节集长度 (集_缓冲区)
清空内容 ()
局_计数器＝局_缓冲区长度

判断循环首 (局_计数器＞ 1)

判断 (集_缓冲区 [局_计数器] ＝ 32)

局_计数器＝局_计数器－ 1

到循环尾 ()

判断 (集_缓冲区 [局_计数器] ＝ 161 且集_缓冲区 [局_计数器－ 1] ＝ 161)

局_计数器＝局_计数器－ 2

到循环尾 ()

跳出循环 ()

判断循环尾 ()
返回 (写出字节集 (_文件句柄, 取字节集左边 (集_缓冲区, 局_计数器)))

子程序名	返回值类型	公开	备注
到小写字母	逻辑型
参数名	类型	参考	可空	数组	备注
参_起始位置	整数型
参_转换字母数	整数型

变量名	类型	静态	数组	备注
局_缓冲区长度	整数型
局_偏移	整数型

写缓存区 ()
局_缓冲区长度＝取字节集长度 (集_缓冲区)
清空内容 ()
局_偏移＝ 1

如果真 (是否为空 (参_起始位置))

参_起始位置＝ 1

如果真 (是否为空 (参_转换字母数))

参_转换字母数＝汇编_取字数 (集_缓冲区) －字数到位置 (参_起始位置)
局_偏移＝字数到位置 (参_起始位置)

计次循环首 (参_转换字母数, )

如果真 (局_偏移＞局_缓冲区长度)

跳出循环 ()

如果 (集_缓冲区 [局_偏移] ＞ 128)

局_偏移＝局_偏移＋ 2

如果真 (集_缓冲区 [局_偏移] ＞ 64 且集_缓冲区 [局_偏移] ＜ 91)

集_缓冲区 [局_偏移] ＝位或 (集_缓冲区 [局_偏移], 32)

局_偏移＝局_偏移＋ 1

计次循环尾 ()
返回 (写出字节集 (_文件句柄, 集_缓冲区))

子程序名	返回值类型	公开	备注
到大写字母	逻辑型
参数名	类型	参考	可空	数组	备注
参_起始位置	整数型
参_转换字母数	整数型

变量名	类型	静态	数组	备注
局_缓冲区长度	整数型
局_偏移	整数型

写缓存区 ()
局_缓冲区长度＝取字节集长度 (集_缓冲区)
清空内容 ()
局_偏移＝ 1

如果真 (是否为空 (参_起始位置))

参_起始位置＝ 1

如果真 (是否为空 (参_转换字母数))

参_转换字母数＝汇编_取字数 (集_缓冲区) －字数到位置 (参_起始位置)
局_偏移＝字数到位置 (参_起始位置)

计次循环首 (参_转换字母数, )

如果真 (局_偏移＞局_缓冲区长度)

跳出循环 ()

如果 (集_缓冲区 [局_偏移] ＞ 128)

局_偏移＝局_偏移＋ 2

如果真 (集_缓冲区 [局_偏移] ＞ 96 且集_缓冲区 [局_偏移] ＜ 123)

集_缓冲区 [局_偏移] ＝位与 (集_缓冲区 [局_偏移], 95)

局_偏移＝局_偏移＋ 1

计次循环尾 ()
返回 (写出字节集 (_文件句柄, 集_缓冲区))

子程序名	返回值类型	公开	备注
字数到位置	整数型
参数名	类型	参考	可空	数组	备注
参_字数	整数型

变量名	类型	静态	数组	备注
局_偏移	整数型
局_缓冲区长度	整数型

局_缓冲区长度＝取字节集长度 (集_缓冲区)
局_偏移＝ 1

计次循环首 (参_字数－ 1, )

如果真 (局_偏移＞局_缓冲区长度)

跳出循环 ()

如果 (集_缓冲区 [局_偏移] ＞ 128)

局_偏移＝局_偏移＋ 2

局_偏移＝局_偏移＋ 1

计次循环尾 ()
返回 (局_偏移)

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

.版本 2<br />
.支持库 spec<br />
<br />
.程序集 类_快速文本, , 公开, 文本的快速累加<br />
.程序集变量 _文件句柄, 整数型<br />
.程序集变量 集_缓冲区, 字节集<br />
<br />
.子程序 _初始化, , , 当基于本类的对象被创建后，此方法会被自动调用<br />
<br />
_文件句柄 ＝ 打开内存文件 ()<br />
<br />
.子程序 _销毁, , , 当基于本类的对象被销毁前，此方法会被自动调用<br />
<br />
关闭文件 (_文件句柄)<br />
<br />
.子程序 添加, , 公开, 增加文本内容到最后<br />
.参数 参_文本内容, 文本型, , 增加的文本<br />
<br />
写出文本 (_文件句柄, 参_文本内容)<br />
<br />
.子程序 插入, 逻辑型, 公开, 在指定字符后(含中文)插入文本内容<br />
.参数 参_插入位置, 整数型, 可空, 字符数,中文也算一个字符,可空,默认最前<br />
.参数 参_文本内容, 文本型, , 要插入的文本内容<br />
.局部变量 局_缓冲区长度, 整数型<br />
.局部变量 局_偏移, 整数型<br />
<br />
写缓存区 ()<br />
局_缓冲区长度 ＝ 取字节集长度 (集_缓冲区)<br />
局_偏移 ＝ 1<br />
.如果真 (是否为空 (参_插入位置))<br />
    参_插入位置 ＝ 0<br />
.如果真结束<br />
局_偏移 ＝ 字数到位置 (参_插入位置)<br />
局_偏移 ＝ 局_偏移 － 1<br />
移动读写位置 (_文件句柄, #文件首, 局_偏移)<br />
返回 (插入文本 (_文件句柄, 参_文本内容))<br />
<br />
.子程序 取文本内容, 文本型, 公开, 取出文本内容<br />
.参数 参_起始位置, 整数型, 可空, 可空.默认从第一个字符开始<br />
.参数 参_字符数, 整数型, 可空, 可空,默认取全部<br />
.局部变量 局_偏移, 整数型<br />
.局部变量 局_缓冲区长度, 整数型<br />
.局部变量 局_偏移2, 整数型<br />
<br />
.如果真 (取读写位置 (_文件句柄) ≠ 0)<br />
    移到文件首 (_文件句柄)<br />
.如果真结束<br />
.如果真 (是否为空 (参_字符数) 且 是否为空 (参_起始位置))<br />
    返回 (读入文本 (_文件句柄, ))<br />
.如果真结束<br />
<br />
集_缓冲区 ＝ 读入字节集 (_文件句柄, 取文件长度 (_文件句柄))<br />
.如果真 (是否为空 (参_起始位置))<br />
    参_起始位置 ＝ 1<br />
.如果真结束<br />
.如果真 (是否为空 (参_字符数))<br />
    参_字符数 ＝ 取字节集长度 (集_缓冲区)<br />
.如果真结束<br />
参_起始位置 ＝ 参_起始位置 － 1<br />
局_偏移 ＝ 1<br />
局_缓冲区长度 ＝ 取字节集长度 (集_缓冲区)<br />
局_偏移 ＝ 字数到位置 (参_起始位置)<br />
局_偏移2 ＝ 字数到位置 (参_起始位置 ＋ 参_字符数)<br />
返回 (到文本 (取字节集中间 (集_缓冲区, 局_偏移, 局_偏移2 － 局_偏移)))<br />
<br />
.子程序 清空内容, , 公开, 清空文本内容<br />
<br />
关闭文件 (_文件句柄)<br />
_文件句柄 ＝ 打开内存文件 ()<br />
<br />
<br />
.子程序 删除文本, 逻辑型, 公开, 删除指定位置内容<br />
.参数 参_起始位置, 整数型, , 起始位置<br />
.参数 参_字符数, 整数型, , 删除个数,汉字算一个<br />
.局部变量 局_偏移, 整数型<br />
.局部变量 局_缓冲区长度, 整数型<br />
.局部变量 局_偏移2, 整数型<br />
<br />
.如果真 (取读写位置 (_文件句柄) ≠ 0)<br />
    移到文件首 (_文件句柄)<br />
.如果真结束<br />
集_缓冲区 ＝ 读入字节集 (_文件句柄, 取文件长度 (_文件句柄))<br />
局_缓冲区长度 ＝ 取字节集长度 (集_缓冲区)<br />
局_偏移 ＝ 字数到位置 (参_起始位置)<br />
局_偏移2 ＝ 字数到位置 (参_起始位置 ＋ 参_字符数)<br />
移动读写位置 (_文件句柄, #文件首, 局_偏移 － 1)<br />
返回 (删除数据 (_文件句柄, 局_偏移2 － 局_偏移))<br />
<br />
.子程序 取文件号, 整数型, 公开, 取内存文件句柄<br />
<br />
返回 (_文件句柄)<br />
<br />
.子程序 替换文本内容, 逻辑型, 公开, 替换指定位置文本<br />
.参数 参_替换位置, 整数型, , 起始位置<br />
.参数 参_替换长度, 整数型, , 替换长度<br />
.参数 参_替换文本, 文本型, 可空, 替换文本,可空<br />
.局部变量 局_偏移1, 整数型<br />
.局部变量 局_偏移2, 整数型<br />
.局部变量 局_缓冲区长度, 整数型<br />
<br />
写缓存区 ()<br />
局_偏移1 ＝ 1<br />
局_缓冲区长度 ＝ 取字节集长度 (集_缓冲区)<br />
局_偏移1 ＝ 字数到位置 (参_替换位置)<br />
局_偏移2 ＝ 字数到位置 (参_替换位置 ＋ 参_替换长度)<br />
<br />
清空内容 ()<br />
返回 (写出字节集 (_文件句柄, 字节集替换 (集_缓冲区, 局_偏移1, 局_偏移2 － 局_偏移1, 到字节集 (参_替换文本))))<br />
<br />
<br />
.子程序 取长度, 整数型, 公开, 取字符数,汉字算一个<br />
<br />
.如果真 (取读写位置 (_文件句柄) ≠ 0)<br />
    移到文件首 (_文件句柄)<br />
.如果真结束<br />
返回 (汇编_取字数 (到字节集 (取文本内容 (, ))))<br />
<br />
.子程序 寻找文本内容, 整数型, 公开, 寻找文本<br />
.参数 参_寻找文本内容, 文本型, , 欲寻找文本<br />
.参数 参_起始寻找位置, 整数型, 可空, 起始位置,可空,默认从最头开始<br />
.局部变量 局_偏移, 整数型<br />
.局部变量 局_文本, 字节集<br />
<br />
写缓存区 ()<br />
局_偏移 ＝ 1<br />
.如果真 (是否为空 (参_起始寻找位置))<br />
    参_起始寻找位置 ＝ 1<br />
.如果真结束<br />
局_偏移 ＝ 字数到位置 (参_起始寻找位置)<br />
局_文本 ＝ 取字节集左边 (集_缓冲区, 寻找字节集 (集_缓冲区, 到字节集 (参_寻找文本内容), 局_偏移) － 1)<br />
.如果 (局_文本 ＝ {  })<br />
    返回 (0)<br />
.否则<br />
    返回 (汇编_取字数 (局_文本) ＋ 1)<br />
.如果结束<br />
<br />
<br />
<br />
.子程序 替换子文本内容, 逻辑型, 公开, 子文本替换<br />
.参数 参_被替换文本, 文本型, , 被替换内容<br />
.参数 参_替换为文本, 文本型, 可空, 替换为内容,可空.默认删除<br />
.参数 参_起始替换位置, 整数型, 可空, 起始位置,可空,默认从最前开始<br />
.参数 参_最大替换次数, 整数型, 可空, 最大替换次数.可空.默认替换所有<br />
.局部变量 局_偏移, 整数型<br />
.局部变量 局_缓冲区长度, 整数型<br />
<br />
写缓存区 ()<br />
局_偏移 ＝ 1<br />
局_缓冲区长度 ＝ 取字节集长度 (集_缓冲区)<br />
.如果真 (是否为空 (参_起始替换位置))<br />
    参_起始替换位置 ＝ 1<br />
.如果真结束<br />
局_偏移 ＝ 字数到位置 (参_起始替换位置)<br />
<br />
清空内容 ()<br />
.如果 (是否为空 (参_最大替换次数))<br />
    返回 (写出字节集 (_文件句柄, 子字节集替换 (集_缓冲区, 到字节集 (参_被替换文本), 到字节集 (参_替换为文本), 局_偏移, )))<br />
.否则<br />
    返回 (写出字节集 (_文件句柄, 子字节集替换 (集_缓冲区, 到字节集 (参_被替换文本), 到字节集 (参_替换为文本), 局_偏移, 参_最大替换次数)))<br />
.如果结束<br />
<br />
<br />
.子程序 汇编_取字数, 整数型, , 取文本中英文字数<br />
.参数 参_内容, 字节集<br />
<br />
参_内容 ＝ 参_内容 ＋ { 0 }<br />
取变量地址 (参_内容)<br />
置入代码 ({ 139, 24, 139, 75, 4, 141, 115, 8, 172, 132, 192, 116, 7, 168, 128, 116, 1, 70, 226, 244, 139, 67, 4, 41, 200, 201, 194, 4, 0 })<br />
返回 (0)<br />
<br />
.子程序 置文本, 逻辑型, 公开, 置文本<br />
.参数 参_文本, 文本型, , 文本内容<br />
<br />
关闭文件 (_文件句柄)<br />
_文件句柄 ＝ 打开内存文件 ()<br />
返回 (写出文本 (_文件句柄, 参_文本))<br />
<br />
<br />
.子程序 从文件读入, 逻辑型, 公开, 读文件内容到内存<br />
.参数 参_文件名, 文本型, , 要读入的文件名<br />
<br />
关闭文件 (_文件句柄)<br />
_文件句柄 ＝ 打开内存文件 ()<br />
返回 (写出字节集 (_文件句柄, 读入文件 (参_文件名)))<br />
<br />
<br />
.子程序 写出到文件, 逻辑型, 公开, 写内存内容到文件<br />
.参数 参_文件名, 文本型, , 要写出的文件名<br />
<br />
.如果真 (取读写位置 (_文件句柄) ≠ 0)<br />
    移到文件首 (_文件句柄)<br />
.如果真结束<br />
返回 (写到文件 (参_文件名, 读入字节集 (_文件句柄, 取文件长度 (_文件句柄))))<br />
<br />
<br />
.子程序 删全部空格, 逻辑型, 公开, 删除所有中英文空格<br />
.局部变量 局_计数器, 整数型<br />
.局部变量 局_缓冲区长度, 整数型<br />
<br />
写缓存区 ()<br />
局_缓冲区长度 ＝ 取字节集长度 (集_缓冲区)<br />
清空内容 ()<br />
局_计数器 ＝ 1<br />
<br />
.判断循环首 (局_缓冲区长度 ＞ 局_计数器)<br />
    .判断开始 (集_缓冲区 [局_计数器] ＝ 32)<br />
        局_计数器 ＝ 局_计数器 ＋ 1<br />
        到循环尾 ()<br />
    .判断 (集_缓冲区 [局_计数器] ＝ 161 且 集_缓冲区 [局_计数器 ＋ 1] ＝ 161)<br />
        局_计数器 ＝ 局_计数器 ＋ 2<br />
        到循环尾 ()<br />
    .默认<br />
        写出字节集 (_文件句柄, 到字节集 (集_缓冲区 [局_计数器]))<br />
        局_计数器 ＝ 局_计数器 ＋ 1<br />
    .判断结束<br />
<br />
.判断循环尾 ()<br />
.如果 (取长度 () ＝ 0)<br />
    返回 (假)<br />
.否则<br />
    返回 (真)<br />
.如果结束<br />
<br />
<br />
.子程序 写缓存区<br />
<br />
.如果真 (取读写位置 (_文件句柄) ≠ 0)<br />
    移到文件首 (_文件句柄)<br />
.如果真结束<br />
集_缓冲区 ＝ 读入字节集 (_文件句柄, 取文件长度 (_文件句柄))<br />
<br />
<br />
.子程序 删首尾空格, 逻辑型, 公开<br />
.局部变量 局_计数器, 整数型<br />
.局部变量 局_缓冲区长度, 整数型<br />
.局部变量 局_偏移1, 整数型<br />
<br />
写缓存区 ()<br />
局_缓冲区长度 ＝ 取字节集长度 (集_缓冲区)<br />
清空内容 ()<br />
局_计数器 ＝ 1<br />
<br />
.判断循环首 (局_缓冲区长度 ＞ 局_计数器)<br />
    .判断开始 (集_缓冲区 [局_计数器] ＝ 32)<br />
        局_计数器 ＝ 局_计数器 ＋ 1<br />
        到循环尾 ()<br />
    .判断 (集_缓冲区 [局_计数器] ＝ 161 且 集_缓冲区 [局_计数器 ＋ 1] ＝ 161)<br />
        局_计数器 ＝ 局_计数器 ＋ 2<br />
        到循环尾 ()<br />
    .默认<br />
        跳出循环 ()<br />
    .判断结束<br />
<br />
.判断循环尾 ()<br />
局_偏移1 ＝ 局_计数器<br />
局_计数器 ＝ 局_缓冲区长度<br />
.判断循环首 (局_计数器 ＞ 1)<br />
    .判断开始 (集_缓冲区 [局_计数器] ＝ 32)<br />
        局_计数器 ＝ 局_计数器 － 1<br />
        到循环尾 ()<br />
    .判断 (集_缓冲区 [局_计数器] ＝ 161 且 集_缓冲区 [局_计数器 － 1] ＝ 161)<br />
        局_计数器 ＝ 局_计数器 － 2<br />
        到循环尾 ()<br />
    .默认<br />
        跳出循环 ()<br />
    .判断结束<br />
<br />
.判断循环尾 ()<br />
返回 (写出字节集 (_文件句柄, 取字节集中间 (集_缓冲区, 局_偏移1, 局_计数器 － 局_偏移1 ＋ 1)))<br />
<br />
<br />
.子程序 删首空格, 逻辑型, 公开<br />
.局部变量 局_计数器, 整数型<br />
.局部变量 局_缓冲区长度, 整数型<br />
<br />
写缓存区 ()<br />
局_缓冲区长度 ＝ 取字节集长度 (集_缓冲区)<br />
清空内容 ()<br />
局_计数器 ＝ 1<br />
<br />
.判断循环首 (局_缓冲区长度 ＞ 局_计数器)<br />
    .判断开始 (集_缓冲区 [局_计数器] ＝ 32)<br />
        局_计数器 ＝ 局_计数器 ＋ 1<br />
        到循环尾 ()<br />
    .判断 (集_缓冲区 [局_计数器] ＝ 161 且 集_缓冲区 [局_计数器 ＋ 1] ＝ 161)<br />
        局_计数器 ＝ 局_计数器 ＋ 2<br />
        到循环尾 ()<br />
    .默认<br />
        跳出循环 ()<br />
    .判断结束<br />
<br />
.判断循环尾 ()<br />
返回 (写出字节集 (_文件句柄, 取字节集右边 (集_缓冲区, 局_缓冲区长度 － 局_计数器 ＋ 1)))<br />
<br />
<br />
.子程序 删尾空格, 逻辑型, 公开<br />
.局部变量 局_计数器, 整数型<br />
.局部变量 局_缓冲区长度, 整数型<br />
<br />
写缓存区 ()<br />
局_缓冲区长度 ＝ 取字节集长度 (集_缓冲区)<br />
清空内容 ()<br />
<br />
局_计数器 ＝ 局_缓冲区长度<br />
.判断循环首 (局_计数器 ＞ 1)<br />
    .判断开始 (集_缓冲区 [局_计数器] ＝ 32)<br />
        局_计数器 ＝ 局_计数器 － 1<br />
        到循环尾 ()<br />
    .判断 (集_缓冲区 [局_计数器] ＝ 161 且 集_缓冲区 [局_计数器 － 1] ＝ 161)<br />
        局_计数器 ＝ 局_计数器 － 2<br />
        到循环尾 ()<br />
    .默认<br />
        跳出循环 ()<br />
    .判断结束<br />
<br />
.判断循环尾 ()<br />
返回 (写出字节集 (_文件句柄, 取字节集左边 (集_缓冲区, 局_计数器)))<br />
<br />
<br />
.子程序 到小写字母, 逻辑型, 公开<br />
.参数 参_起始位置, 整数型, 可空<br />
.参数 参_转换字母数, 整数型, 可空<br />
.局部变量 局_缓冲区长度, 整数型<br />
.局部变量 局_偏移, 整数型<br />
<br />
写缓存区 ()<br />
局_缓冲区长度 ＝ 取字节集长度 (集_缓冲区)<br />
清空内容 ()<br />
局_偏移 ＝ 1<br />
.如果真 (是否为空 (参_起始位置))<br />
    参_起始位置 ＝ 1<br />
.如果真结束<br />
.如果真 (是否为空 (参_转换字母数))<br />
    参_转换字母数 ＝ 汇编_取字数 (集_缓冲区) － 字数到位置 (参_起始位置)<br />
.如果真结束<br />
局_偏移 ＝ 字数到位置 (参_起始位置)<br />
<br />
.计次循环首 (参_转换字母数, )<br />
    .如果真 (局_偏移 ＞ 局_缓冲区长度)<br />
        跳出循环 ()<br />
    .如果真结束<br />
    .如果 (集_缓冲区 [局_偏移] ＞ 128)<br />
        局_偏移 ＝ 局_偏移 ＋ 2<br />
    .否则<br />
        .如果真 (集_缓冲区 [局_偏移] ＞ 64 且 集_缓冲区 [局_偏移] ＜ 91)<br />
            集_缓冲区 [局_偏移] ＝ 位或 (集_缓冲区 [局_偏移], 32)<br />
        .如果真结束<br />
        局_偏移 ＝ 局_偏移 ＋ 1<br />
    .如果结束<br />
<br />
.计次循环尾 ()<br />
返回 (写出字节集 (_文件句柄, 集_缓冲区))<br />
<br />
.子程序 到大写字母, 逻辑型, 公开<br />
.参数 参_起始位置, 整数型, 可空<br />
.参数 参_转换字母数, 整数型, 可空<br />
.局部变量 局_缓冲区长度, 整数型<br />
.局部变量 局_偏移, 整数型<br />
<br />
写缓存区 ()<br />
局_缓冲区长度 ＝ 取字节集长度 (集_缓冲区)<br />
清空内容 ()<br />
局_偏移 ＝ 1<br />
.如果真 (是否为空 (参_起始位置))<br />
    参_起始位置 ＝ 1<br />
.如果真结束<br />
.如果真 (是否为空 (参_转换字母数))<br />
    参_转换字母数 ＝ 汇编_取字数 (集_缓冲区) － 字数到位置 (参_起始位置)<br />
.如果真结束<br />
局_偏移 ＝ 字数到位置 (参_起始位置)<br />
<br />
.计次循环首 (参_转换字母数, )<br />
    .如果真 (局_偏移 ＞ 局_缓冲区长度)<br />
        跳出循环 ()<br />
    .如果真结束<br />
    .如果 (集_缓冲区 [局_偏移] ＞ 128)<br />
        局_偏移 ＝ 局_偏移 ＋ 2<br />
    .否则<br />
        .如果真 (集_缓冲区 [局_偏移] ＞ 96 且 集_缓冲区 [局_偏移] ＜ 123)<br />
            集_缓冲区 [局_偏移] ＝ 位与 (集_缓冲区 [局_偏移], 95)<br />
        .如果真结束<br />
        局_偏移 ＝ 局_偏移 ＋ 1<br />
    .如果结束<br />
<br />
.计次循环尾 ()<br />
返回 (写出字节集 (_文件句柄, 集_缓冲区))<br />
<br />
.子程序 字数到位置, 整数型<br />
.参数 参_字数, 整数型<br />
.局部变量 局_偏移, 整数型<br />
.局部变量 局_缓冲区长度, 整数型<br />
<br />
局_缓冲区长度 ＝ 取字节集长度 (集_缓冲区)<br />
局_偏移 ＝ 1<br />
.计次循环首 (参_字数 － 1, )<br />
    .如果真 (局_偏移 ＞ 局_缓冲区长度)<br />
        跳出循环 ()<br />
    .如果真结束<br />
    .如果 (集_缓冲区 [局_偏移] ＞ 128)<br />
        局_偏移 ＝ 局_偏移 ＋ 2<br />
    .否则<br />
        局_偏移 ＝ 局_偏移 ＋ 1<br />
    .如果结束<br />
<br />
.计次循环尾 ()<br />
返回 (局_偏移)