精易论坛

标题: 汇编极速分割文本演示带源码无模块 [打印本页]
作者: jr21066    时间: 2018-9-10 22:30
标题: 汇编极速分割文本演示带源码无模块
易语言的分割文本速度真的慢.偏偏论坛里经常有人在用这个功能.这几天基本都没抢回帖.一直在折腾这个了.
过程跳过,最后的结果是这样.不能变成一个很完整的模块功能,在使用上有一点点小限制.但我觉得还是有实用价值的.所以放上来测试一下.

附件里是例子,使用要注意的都有注释.这里也说一下.
易所有使用的变量都是要回收的.在结束的时间.所以定义数组时要进行预定义.我加的大.实际可以根据需要设置.每个成员占一个整数的位置.也就是4字节.怕麻烦的就设置大一些.关系不大.
第一句取数组成员数也是完成数组内存分配的.这个没办法去掉了.
过程很简单.给字节集内容.给数组.分隔符暂时没有考虑.如果功能真的实用了.再考虑.
使用字节集也是为了专门处理大文件.起码可以少转换一次.
最后献上不太长的代码..最后要说的是没有模块.源码是使用了汇编_取随机数做演示才用到了模块.

  
窗口程序集名保 留  保 留备 注
程序集1   
子程序名返回值类型公开备 注
_启动子程序整数型 本子程序在程序启动后最先执行
变量名类 型静态数组备 注
文本数组1文本型99999999牵扯内存释放,所以要预分配,只要大于你分割后的数组成员就行
文本内容字节集这里是要分割的文本字节集内容,这里将存在数组内容,数组只是一个指针集合
计数器整数型 
行数整数型 
时间1整数型 
取数组成员数 (文本数组1)  ' 程序结束时易会释放所有变量,需要这一句来给数组预申请内存空间
文本内容 ＝ 读入文件 (“R:\Desktop\123.txt”) ＋ { 0 }
' 文本内容2 ＝ 到文本 (文本内容)
如果真 (取字节集长度 (文本内容) ＜ 4)
调试输出 (“文件为空”)

时间1 ＝ 取启动时间 ()
汇编_分割文本 (文本内容, 文本数组1)
调试输出 (“分割用时: ”, 取启动时间 () － 时间1)
调试输出 (“共”, 取数组成员数 (文本数组1), “成员”)
计次循环首 (4, )
行数 ＝ 汇编_取随机数 (1, 取数组成员数 (文本数组1))
调试输出 (行数, 文本数组1 [行数])
计次循环尾 ()
返回 (0)  ' 可以根据您的需要返回任意数值
子程序名返回值类型公开备 注
汇编_分割文本整数型 
参数名类 型参考可空数组备 注
参_文本内容字节集
参_文本数组文本型
置入代码 ({ 141, 85, 8, 139, 18, 139, 18, 139, 74, 4, 131, 194, 8, 141, 93, 12, 139, 27, 139, 27, 131, 195, 4, 184, 1, 0, 0, 0, 137, 3, 137, 83, 4, 138, 2, 60, 13, 117, 7, 49, 192, 136, 2, 66, 226, 243, 60, 10, 117, 19, 49, 192, 136, 2, 66, 139, 3, 64, 137, 3, 193, 224, 2, 1, 216, 137, 16, 226, 220, 66, 226, 217, 139, 3, 201, 194, 8, 0 })
返回 (0)


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

汇编_分割文本.e

742.19 KB, 下载次数: 258, 下载积分: 精币 -2 枚

作者: e4nzat    时间: 2018-9-10 23:20
谢谢，收下了~
作者: う网淅乄    时间: 2018-9-11 00:30
只能换行符?
作者: 浪漫伊波啦    时间: 2018-9-11 02:22

谢谢，收下了~.很强大
作者: jr21066    时间: 2018-9-11 06:15
う网淅乄 发表于 2018-9-11 00:30
只能换行符?

先测试吧.其它的分隔符也可以.要另写代码.
如果分隔符太长.就会变慢不少的.
作者: cf2006a    时间: 2018-9-11 06:53
没能 正确取出数据 还是我用法错误！！
作者: cf2006a    时间: 2018-9-11 07:05
本帖最后由 cf2006a 于 2018-9-11 07:10 编辑

mov edx, dword [edx] mov edx, dword [edx]


mov ebx, dword [ebx]
mov ebx, dword [ebx]


请教下为什么要取两次一样的 值



loop Label2 看了下用了三个 循环 那它的结束条件是什么呢
作者: jr21066    时间: 2018-9-11 07:35
cf2006a 发表于 2018-9-11 07:05
mov edx, dword [edx] mov edx, dword [edx]

数值是传址模式.参数也是传址.就加了两次
结束条件是字节集文本内容的长度.
所以你的例子里没有给文本内容加东西.是空的.因为这里的数据将来是直接给文本数组使用的.可以省掉易重新分配内存的过程.
作者: dice1412    时间: 2018-9-11 09:02
建议再加个参数  自定义分割的字符
作者: hellohexiang    时间: 2018-9-11 09:06
千万级别的 如果连续处理 好像容易崩溃 是不是内存没有释放结束？
作者: jr21066    时间: 2018-9-11 09:33
hellohexiang 发表于 2018-9-11 09:06
千万级别的 如果连续处理 好像容易崩溃 是不是内存没有释放结束？

因为省略了内存分配 过程.所以能使用的最大数量取决于文本数组所定义的数组最大数.
例子里我加的是99999999.好象最大是1410065407.可以试下.
越大.使用的内存越大.大小是整数,四字节.
作者: cf2006a    时间: 2018-9-11 09:33
  
子程序名返回值类型公开备 注
_按钮1_被单击  
变量名类 型静态数组备 注
数组文本型1000
调试输出 (文本_逐个分割_局部_自编 (“1000W不崩4秒 速度会慢些毕竟内部要取空白填充”, 数组))
子程序名返回值类型公开备 注
文本_逐个分割_局部_自编文本型 1000W不崩4秒 速度会慢些毕竟内部要取空白填充
参数名类 型参考可空数组备 注
要寻找的文本文本型
返回数组文本型如何加入数组呢？
变量名类 型静态数组备 注
ret文本型 
ret ＝ 取空白文本 (取文本长度 (要寻找的文本) × 2)
置入代码 ({ 139, 125, 8, 139, 63, 49, 201, 138, 31, 128, 251, 0, 116, 20, 128, 251, 127, 118, 7, 136, 28, 8, 71, 65, 138, 31, 136, 28, 8, 65, 65, 71, 235, 229, 198, 68, 8, 255, 0, 201, 194, 4, 0 })
返回 (“”)


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


这个之前写的一直没搞明白怎么加入数组 你能帮看下吗？你现在这个我有点看不明白

能把这个改下 让它加入到数组里  谢谢！
作者: cf2006a    时间: 2018-9-11 09:36
jr21066 发表于 2018-9-11 09:33
因为省略了内存分配 过程.所以能使用的最大数量取决于文本数组所定义的数组最大数.
例子里我加的是99999 ...
  
子程序名返回值类型公开备 注
_按钮1_被单击  
变量名类 型静态数组备 注
数组文本型1000
调试输出 (文本_逐个分割_局部_自编 (“1000W不崩4秒 速度会慢些毕竟内部要取空白填充”, 数组))
子程序名返回值类型公开备 注
文本_逐个分割_局部_自编文本型 1000W不崩4秒 速度会慢些毕竟内部要取空白填充
参数名类 型参考可空数组备 注
要寻找的文本文本型
返回数组文本型如何加入数组呢？
变量名类 型静态数组备 注
ret文本型 
ret ＝ 取空白文本 (取文本长度 (要寻找的文本) × 2)
置入代码 ({ 139, 125, 8, 139, 63, 49, 201, 138, 31, 128, 251, 0, 116, 20, 128, 251, 127, 118, 7, 136, 28, 8, 71, 65, 138, 31, 136, 28, 8, 65, 65, 71, 235, 229, 198, 68, 8, 255, 0, 201, 194, 4, 0 })
返回 (“”)


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

这个是逐个分割的代码 之前就想分割到数组 可惜 刚学又没有这方面的 例子  现在看你的代码 还是不太明白
能帮把这个代码加入到数组里吗？

作者: cf2006a    时间: 2018-9-11 09:37
jr21066 发表于 2018-9-11 09:33
因为省略了内存分配 过程.所以能使用的最大数量取决于文本数组所定义的数组最大数.
例子里我加的是99999 ...
  
子程序名返回值类型公开备 注
_按钮1_被单击  
变量名类 型静态数组备 注
数组文本型1000
调试输出 (文本_逐个分割_局部_自编 (“1000W不崩4秒 速度会慢些毕竟内部要取空白填充”, 数组))
子程序名返回值类型公开备 注
文本_逐个分割_局部_自编文本型 1000W不崩4秒 速度会慢些毕竟内部要取空白填充
参数名类 型参考可空数组备 注
要寻找的文本文本型
返回数组文本型如何加入数组呢？
变量名类 型静态数组备 注
ret文本型 
ret ＝ 取空白文本 (取文本长度 (要寻找的文本) × 2)
置入代码 ({ 139, 125, 8, 139, 63, 49, 201, 138, 31, 128, 251, 0, 116, 20, 128, 251, 127, 118, 7, 136, 28, 8, 71, 65, 138, 31, 136, 28, 8, 65, 65, 71, 235, 229, 198, 68, 8, 255, 0, 201, 194, 4, 0 })
返回 (“”)


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

这个是逐个分割的代码 之前就想分割到数组 可惜 现在看你的代码 还是不太明白
能帮把这个代码加入到数组里吗？

作者: cf2006a    时间: 2018-9-11 09:39
本帖最后由 cf2006a 于 2018-9-11 09:41 编辑
  
子程序名返回值类型公开备 注
_按钮1_被单击  
变量名类 型静态数组备 注
数组文本型1000
调试输出 (文本_逐个分割_局部_自编 (“1000W不崩4秒 速度会慢些毕竟内部要取空白填充”, 数组))
子程序名返回值类型公开备 注
文本_逐个分割_局部_自编文本型 1000W不崩4秒 速度会慢些毕竟内部要取空白填充
参数名类 型参考可空数组备 注
要寻找的文本文本型
返回数组文本型如何加入数组呢？
变量名类 型静态数组备 注
ret文本型 
ret ＝ 取空白文本 (取文本长度 (要寻找的文本) × 2)
置入代码 ({ 139, 125, 8, 139, 63, 49, 201, 138, 31, 128, 251, 0, 116, 20, 128, 251, 127, 118, 7, 136, 28, 8, 71, 65, 138, 31, 136, 28, 8, 65, 65, 71, 235, 229, 198, 68, 8, 255, 0, 201, 194, 8, 0 })
返回 (“”)


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


这个是之前写的 逐字分割   本想 直接分割到数组的可惜没这方面的例子所以一直到现在还没弄出来，看了你的代码还是有些不懂，能把这个改下吗？
让它直接分割到数组里
作者: 350246356    时间: 2018-9-11 09:40
分隔符不能自己设置吗
作者: jr21066    时间: 2018-9-11 09:50
cf2006a 发表于 2018-9-11 09:37
[e=0].版本 2
.支持库 spec

数组的格式是先是一个整数,表明成员数.然后是成员地址.
按这个格式来写数组的.

数组成员要申请内存来放自己的.易是自动的.自己用汇编就要找个地方来放这些东西.不然程序会出错.
作者: 84583728    时间: 2018-9-11 10:09
66666666666666
作者: cf2006a    时间: 2018-9-11 10:31
jr21066 发表于 2018-9-11 09:50
数组的格式是先是一个整数,表明成员数.然后是成员地址.
按这个格式来写数组的.

数组 1    =  整数  1    +  数组 1 地址吗
作者: jr21066    时间: 2018-9-11 12:37
cf2006a 发表于 2018-9-11 10:31
数组 1    =  整数  1    +  数组 1 地址吗

数组就是一个整数数组的样子.
第一个整数是成员数.后边的整数是成员的地址
作者: cf2006a    时间: 2018-9-11 15:45
jr21066 发表于 2018-9-11 12:37
数组就是一个整数数组的样子.
第一个整数是成员数.后边的整数是成员的地址

好像你之前也写过逐个分割 写个例子看下
作者: jr21066    时间: 2018-9-11 16:10
cf2006a 发表于 2018-9-11 15:45
好像你之前也写过逐个分割 写个例子看下

因为一直没用上这功能.也感觉不到有啥用处.所以没写这个.
其实都已经逐字处理了.这时速度已经不是第一位了.

我觉得可以转字节集.读字节出来判断加入新变量中.循环处理完成.
作者: 597911291    时间: 2018-9-11 20:51
看看
作者: xxiaoshujjun    时间: 2018-9-12 21:13
找个只能按行数分割吗？如果我里面文本想按自己的特定符号怎么分？
作者: cf2006a    时间: 2018-9-12 21:33
  
子程序名返回值类型公开备 注
汇编_分割文本整数型 
参数名类 型参考可空数组备 注
参_文本内容字节集
参_文本数组文本型
置入代码 ({ 141, 85, 8, 139, 18, 139, 18, 139, 74, 4, 131, 194, 8, 141, 93, 12, 139, 27, 139, 27, 131, 195, 4, 184, 1, 0, 0, 0, 137, 3, 137, 83, 4, 138, 2, 60, 13, 117, 3, 66, 226, 247, 60, 10, 117, 15, 49, 192, 136, 2, 66, 139, 3, 64, 137, 3, 137, 20, 131, 226, 228, 66, 226, 225, 139, 3, 201, 194, 8, 0 })
返回 (0)

大概知道了点意思 就是把 13 10 那个位置的指针 给数组 成员！
作者: jr21066    时间: 2018-9-12 21:36
xxiaoshujjun 发表于 2018-9-12 21:13
找个只能按行数分割吗？如果我里面文本想按自己的特定符号怎么分？

随后增加.
可能是单字符的分隔
作者: jr21066    时间: 2018-9-12 21:39
cf2006a 发表于 2018-9-12 21:33
[e=0].版本 2

.子程序 汇编_分割文本, 整数型

13 10修改为0.做为字符串结束标记.
分隔符的下一个位置就是下一个字符串的开始位置写到文本数组的成员中

0只需要一个.所以分隔符是可以有单字符的.多字符的话.判断太多.很影响效率.不想做了.越做越慢不如用系统的.还安全.
作者: cf2006a    时间: 2018-9-13 09:27
jr21066 发表于 2018-9-12 21:39
13 10修改为0.做为字符串结束标记.
分隔符的下一个位置就是下一个字符串的开始位置写到文本数组的成员中 ...
  
子程序名返回值类型公开备 注
汇编_分割文本整数型 
参数名类 型参考可空数组备 注
参_文本内容字节集
参_文本数组文本型
置入代码 ({ 141, 85, 8, 139, 18, 139, 18, 139, 74, 4, 131, 194, 8, 141, 93, 12, 139, 27, 139, 27, 131, 195, 4, 199, 3, 1, 0, 0, 0, 137, 83, 4, 138, 2, 60, 10, 117, 13, 198, 2, 0, 66, 255, 3, 139, 3, 137, 20, 131, 226, 237, 66, 226, 234, 139, 3, 201, 194, 8, 0 })
返回 (0)
帮你优化了下代码你看下这样会不会更快些

作者: cf2006a    时间: 2018-9-13 09:29
本帖最后由 cf2006a 于 2018-9-13 10:04 编辑
  
子程序名返回值类型公开备 注
汇编_分割文本整数型 
参数名类 型参考可空数组备 注
参_文本内容字节集
参_文本数组文本型
置入代码 ({ 141, 85, 8, 139, 18, 139, 18, 139, 74, 4, 131, 194, 8, 141, 93, 12, 139, 27, 139, 27, 131, 195, 4, 199, 3, 1, 0, 0, 0, 137, 83, 4, 138, 2, 60, 13, 117, 11, 198, 2, 0, 66, 255, 3, 139, 3, 137, 20, 131, 66, 226, 236, 139, 3, 201, 194, 8, 0 })
返回 (0)

帮你优化了下不知道 对不对 看看会不会比之前的快



lea edx, dword [ebp+0x08]
mov edx, dword [edx]
mov edx, dword [edx]
mov ecx, dword [edx+0x04]
add edx, 0x08
lea ebx, dword [ebp+0x0C]
mov ebx, dword [ebx]
mov ebx, dword [ebx]
add ebx, 0x04
mov dword [ebx], 0x00000001
mov dword [ebx+0x04], edx                                     上面没动和你的一样    下面你用三个loop 我给你减掉两个
Label2:
mov al, byte [edx]
cmp al, 0x0D                                                             如果我没理解错的话找到13 开始在尾部加0截断文本  因为换行符 13 后面会跟一个10  所有13 这里截断就不会有换行符出现
jne Label1
mov byte [edx], 0x00000000
inc edx                                                                     这应加1后该是10  把10这个地址给 下个数组 当成开始的 位置  当然你也可以Edx加2直接给下个数据段开始地址给它不过我觉得没必要因为10                                                                                 是控制符是不会显示出来的对你文本输出调用时没什么影响的
inc dword [ebx]
mov eax, dword [ebx]
mov dword [ebx+eax*4], edx
Label1:
inc edx                                                                      这里10后面加1  是真正数据开始的位置 所有就可以把两个loop 简化成一个 不会影响取出的数据
loop Label2
mov eax, dword [ebx]
leave
retn 0x0008



作者: jr21066    时间: 2018-9-13 12:45
cf2006a 发表于 2018-9-13 09:29
  
子程序名返回值类型公开备 注
汇编_分割文本整数型 
[/quote]
写0a是没有必要的.只是一种完美心理了.
去掉写0a的代码如下.未测试
[e=4]lea edx,[ebp+8]
mov edx,[edx]
mov edx,[edx]
mov ecx,[edx+4];字节集长度
add edx,8;文本字节集地址
lea ebx,[ebp+10h]
mov ebx,[ebx]
mov ebx,[ebx]
add ebx,4;数组成员数地址
mov eax,1;写入第一组内容
mov [ebx],eax
mov [ebx+4],edx
begin:
mov al,byte ptr [edx]
cmp al,13
jnz addr2;回车写回0
xor eax,eax
mov byte ptr [edx],al
inc edx
inc edx
mov eax,[ebx]
inc eax
mov [ebx],eax;成员数加一
shl eax,2
add eax,ebx
mov [eax],edx;写成员地址
loop begin
addr2:
inc edx
loop begin
mov eax,[ebx];取成员数
leave
ret 12

作者: jr21066    时间: 2018-9-13 12:46
cf2006a 发表于 2018-9-13 09:29
  
子程序名返回值类型公开备 注
汇编_分割文本整数型 
[/quote]
写0a是没有必要的.只是一种完美心理了.
去掉0a的代码如下,未测试
[e=4]lea edx,[ebp+8]
mov edx,[edx]
mov edx,[edx]
mov ecx,[edx+4];字节集长度
add edx,8;文本字节集地址
lea ebx,[ebp+10h]
mov ebx,[ebx]
mov ebx,[ebx]
add ebx,4;数组成员数地址
mov eax,1;写入第一组内容
mov [ebx],eax
mov [ebx+4],edx
begin:
mov al,byte ptr [edx]
cmp al,13
jnz addr2;回车写回0
xor eax,eax
mov byte ptr [edx],al
inc edx
inc edx
mov eax,[ebx]
inc eax
mov [ebx],eax;成员数加一
shl eax,2
add eax,ebx
mov [eax],edx;写成员地址
loop begin
addr2:
inc edx
loop begin
mov eax,[ebx];取成员数
leave
ret 12
作者: jr21066    时间: 2018-9-13 12:46
cf2006a 发表于 2018-9-13 09:29
  
子程序名返回值类型公开备 注
汇编_分割文本整数型 
[/quote]
写0a是没有必要的.只是一种完美心理了.
去掉0a的代码如下,未测试
[e=4]lea edx,[ebp+8]
mov edx,[edx]
mov edx,[edx]
mov ecx,[edx+4];字节集长度
add edx,8;文本字节集地址
lea ebx,[ebp+10h]
mov ebx,[ebx]
mov ebx,[ebx]
add ebx,4;数组成员数地址
mov eax,1;写入第一组内容
mov [ebx],eax
mov [ebx+4],edx
begin:
mov al,byte ptr [edx]
cmp al,13
jnz addr2;回车写回0
xor eax,eax
mov byte ptr [edx],al
inc edx
inc edx
mov eax,[ebx]
inc eax
mov [ebx],eax;成员数加一
shl eax,2
add eax,ebx
mov [eax],edx;写成员地址
loop begin
addr2:
inc edx
loop begin
mov eax,[ebx];取成员数
leave
ret 12


作者: jr21066    时间: 2018-9-13 12:48
cf2006a 发表于 2018-9-13 09:29
  
子程序名返回值类型公开备 注
汇编_分割文本整数型 
[/quote]
写0a是没有必要的.只是一种完美心理了.
去掉0a的代码如下,未测试
[e=4]lea edx,[ebp+8]
mov edx,[edx]
mov edx,[edx]
mov ecx,[edx+4];字节集长度
add edx,8;文本字节集地址
lea ebx,[ebp+10h]
mov ebx,[ebx]
mov ebx,[ebx]
add ebx,4;数组成员数地址
mov eax,1;写入第一组内容
mov [ebx],eax
mov [ebx+4],edx
begin:
mov al,byte ptr [edx]
cmp al,13
jnz addr2;回车写回0
xor eax,eax
mov byte ptr [edx],al
inc edx
inc edx
mov eax,[ebx]
inc eax
mov [ebx],eax;成员数加一
shl eax,2
add eax,ebx
mov [eax],edx;写成员地址
loop begin
addr2:
inc edx
loop begin
mov eax,[ebx];取成员数
leave
ret 12
作者: jr21066    时间: 2018-9-13 12:50
cf2006a 发表于 2018-9-13 09:29
[e=0].版本 2

.子程序 汇编_分割文本, 整数型

只是完美心理的原因. 0a写了一点用也没有.
回帖一直失败.复制一部分看看还出错不

begin:
mov al,byte ptr [edx]
cmp al,13
jnz addr2        ;回车写回0
xor eax,eax
mov byte ptr [edx],al
inc edx
inc edx
mov eax,[ebx]
inc eax
mov [ebx],eax        ;成员数加一
shl eax,2
add eax,ebx
mov [eax],edx        ;写成员地址
loop begin
addr2:
inc edx
loop begin
mov eax,[ebx]                ;取成员数
leave
ret 12

作者: jr21066    时间: 2018-9-13 13:09
cf2006a 发表于 2018-9-13 09:29
[e=0].版本 2

.子程序 汇编_分割文本, 整数型

疯了.前边多了好多重复帖.
这个是又修改了一下的.

begin:
mov al,byte ptr [edx]
cmp al,13
inc edx
jnz addr1


xor eax,eax
mov byte ptr [edx],al
inc edx
dec ecx
mov eax,[ebx]
inc eax
mov [ebx],eax        ;成员数加一
shl eax,2
add eax,ebx
mov [eax],edx        ;写成员地址


addr1:
loop begin


mov eax,[ebx]                ;取成员数
leave
ret 12


作者: cf2006a    时间: 2018-9-13 13:14
本帖最后由 cf2006a 于 2018-9-13 13:25 编辑
jr21066 发表于 2018-9-13 12:50
只是完美心理的原因. 0a写了一点用也没有.
回帖一直失败.复制一部分看看还出错不

自定义分隔符 截断会改变原文本数据吧 像你这个13 10 可以用0去替换截断 要是自定义的话 往哪里加0 截断啊

加进去数据就被破坏了！不适用这种方法
用我的这个方法不是代码更少，更容易理解！试了几次一样可以按换行符分割
Label2:
mov al, byte [edx]
cmp al, 0x0D
jne Label1
mov byte [edx], 0x00000000
inc edx
inc dword [ebx]
mov eax, dword [ebx]
mov dword [ebx+eax*4], edx
Label1:
inc edx
loop Label2
mov eax, dword [ebx]
leave
retn 0x0008


作者: jr21066    时间: 2018-9-13 13:59
cf2006a 发表于 2018-9-13 13:14
自定义分隔符 截断会改变原文本数据吧 像你这个13 10 可以用0去替换截断 要是自定义的话 往哪里加0 截断 ...

我用的还是低版的汇编工具.是不支持直接对内存数操作的.
另外你没有减ecx.
作者: cf2006a    时间: 2018-9-13 15:29
jr21066 发表于 2018-9-13 13:59
我用的还是低版的汇编工具.是不支持直接对内存数操作的.
另外你没有减ecx.

loop 每循环一次   会自动  在 ecx 里减 1
作者: sx大总管    时间: 2018-9-13 15:40
弄一个可以设置分隔符的吧
作者: zhutao3233    时间: 2018-9-13 18:34
方法不错，但是分割的第一个文本的开头 是乱码！
作者: jr21066    时间: 2018-9-13 19:06
zhutao3233 发表于 2018-9-13 18:34
方法不错，但是分割的第一个文本的开头 是乱码！

能提供一下文件开头吗.
作者: cf2006a    时间: 2018-9-13 20:30
jr21066 发表于 2018-9-13 19:06
能提供一下文件开头吗.
  
子程序名返回值类型公开备 注
__启动窗口_创建完毕  
变量名类 型静态数组备 注
文本数组1文本型99999999牵扯内存释放,所以要预分配,只要大于你分割后的数组成员就行
文本内容文本型这里是要分割的文本字节集内容,这里将存在数组内容,数组只是一个指针集合
文本内容 ＝ “可以根据您的需要返回任意数值” ＋ “ ” ＋ “句来给数组预申请内存空间” ＋ “ ” ＋ “汇编_取随机数”
调试输出 (汇编_分割文本 (文本内容, 文本数组1, “ ”), 文本数组1, #换行符, 文本内容)  ' 可以看到原文本被截断数据被破坏，所以用此命令要保存下原文本
子程序名返回值类型公开备 注
汇编_分割文本整数型 返回分割总个数
参数名类 型参考可空数组备 注
参_文本内容文本型
参_文本数组文本型
参_分隔符文本型
置入代码 ({ 141, 85, 8, 139, 18, 139, 18, 131, 194, 8, 141, 93, 12, 139, 27, 139, 27, 131, 195, 4, 199, 3, 1, 0, 0, 0, 137, 83, 4, 139, 77, 16, 139, 9, 138, 41, 138, 10, 128, 249, 0, 116, 20, 56, 233, 117, 13, 198, 2, 0, 66, 255, 3, 139, 3, 137, 20, 131, 235, 232, 66, 235, 229, 139, 3, 201, 194, 12, 0 })
返回 (0)
修改了下可以指定分割符 目前只支持单字符


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

作者: zhutao3233    时间: 2018-9-13 21:34
jr21066 发表于 2018-9-13 19:06
能提供一下文件开头吗.

锘縣ttps://img02.sogoucdn.com/app/a/100520020/59b3bf5986902026366e0062851cd7a3
https://img02.sogoucdn.com/app/a/100520024/6795f74b35e0297629e7a6a878b6fcc9
作者: jr21066    时间: 2018-9-13 21:43
zhutao3233 发表于 2018-9-13 21:34
锘縣ttps://img02.sogoucdn.com/app/a/100520020/59b3bf5986902026366e0062851cd7a3
https://img02.sogo ...

图很棒.有文本吗?
分割字节集的没有做
作者: cf2006a    时间: 2018-9-13 21:54
  
子程序名返回值类型公开备 注
汇编_分割文本整数型 返回分割总个数
参数名类 型参考可空数组备 注
参_文本内容文本型
参_文本数组文本型
参_分隔符文本型
置入代码 ({ 141, 85, 8, 139, 18, 139, 18, 131, 194, 8, 141, 93, 12, 139, 27, 139, 27, 131, 195, 4, 199, 3, 1, 0, 0, 0, 137, 83, 4, 139, 77, 16, 139, 9, 138, 41, 138, 10, 128, 249, 0, 116, 20, 56, 233, 117, 13, 198, 2, 0, 66, 255, 3, 139, 3, 137, 20, 131, 235, 232, 66, 235, 229, 139, 3, 201, 194, 12, 0 })
返回 (0)


这个是带分割符的  只支持一个单字符  多字符还是得你来弄 我弄不来
作者: zhutao3233    时间: 2018-9-14 00:45
jr21066 发表于 2018-9-13 21:43
图很棒.有文本吗?
分割字节集的没有做

文本就是这个啊
https://img02.sogoucdn.com/app/a/100520020/59b3bf5986902026366e0062851cd7a3
https://img02.sogoucdn.com/app/a/100520024/6795f74b35e0297629e7a6a878b6fcc9
作者: jr21066    时间: 2018-9-14 06:53
zhutao3233 发表于 2018-9-14 00:45
文本就是这个啊
https://img02.sogoucdn.com/app/a/100520020/59b3bf5986902026366e0062851cd7a3
https ...

还是没试出来.这是我这边的结果

正在编译...
正在生成主程序入口代码
程序代码编译成功
正在封装易格式目的代码
开始运行被调试程序
* “分割用时: ” | 0.000000
* “共” | 2 | “成员”
* 2 | “https://img02.sogoucdn.com/app/a/100520024/6795f74b35e0297629e7a6a878b6fcc9”
* 2 | “https://img02.sogoucdn.com/app/a/100520024/6795f74b35e0297629e7a6a878b6fcc9”
* 2 | “https://img02.sogoucdn.com/app/a/100520024/6795f74b35e0297629e7a6a878b6fcc9”
* 1 | “https://img02.sogoucdn.com/app/a/100520020/59b3bf5986902026366e0062851cd7a3”
被调试易程序运行完毕
作者: 太行山搬书    时间: 2018-9-14 12:06
学习了，谢谢分享
作者: cf2006a    时间: 2018-9-14 20:03
cf2006a 发表于 2018-9-13 20:30
[e=0].版本 2
.支持库 spec

.版本 2

.子程序 汇编_分割文本, 整数型, 公开, 返回分割总个数
.参数 参_文本内容, 文本型
.参数 参_文本数组, 文本型, 数组
.参数 参_分隔符, 文本型

置入代码 ({ 139, 85, 8, 139, 18, 139, 93, 12, 139, 27, 131, 195, 4, 199, 3, 1, 0, 0, 0, 137, 83, 4, 139, 77, 16, 139, 9, 138, 41, 138, 10, 128, 249, 0, 116, 25, 56, 233, 117, 18, 56, 106, 1, 116, 13, 198, 2, 0, 66, 255, 3, 139, 3, 137, 20, 131, 235, 227, 66, 235, 224, 201, 194, 12, 0 })
返回 (0)
作者: 陈宁    时间: 2018-9-17 01:01
本帖最后由 15291367 于 2018-9-17 01:13 编辑
*F006a 发表于 2018-9-14 20:03
.版本 2

.子程序 汇编_分割文本, 整数型, 公开, 返回分割总个数

发现了点bug，分隔符为，的时候，分割出来的结果只有第一个正确，剩下的都是乱码。
如下：



  1. <p>.版本 2
  2. .支持库 spec

  4. .局部变量 数组, 文本型, , "0"
  5. .局部变量 i, 整数型

  7. 汇编_分割文本 (“啊，是，你，嘛”, 数组, “，”)
  8. .计次循环首 (取数组成员数 (数组), i)
  9.     调试输出 (数组 [i])
  10. .计次循环尾 ()
  11. </p>
复制代码
作者: 天行    时间: 2018-9-17 13:51
不用汇编，汇编在多线程下不稳定，会导致程序崩溃
作者: taohongsen1990    时间: 2018-9-17 15:01
谢谢楼主分享
作者: 09M73    时间: 2018-9-20 14:25
感谢分享~~~
作者: cf2006a    时间: 2018-9-21 14:14
多字符分割弄好了吗 ，弄好了分享个！
作者: jr21066    时间: 2018-9-21 22:27
cf2006a 发表于 2018-9-21 14:14
多字符分割弄好了吗 ，弄好了分享个！

多字符会比较影响效率.如果超过四字节就很影响了.
不如用系统的.

作者: love`Z    时间: 2018-9-22 15:45
奈斯，支持
作者: siniandd    时间: 2018-9-22 22:20
15291367 发表于 2018-9-17 01:01
发现了点bug，分隔符为，的时候，分割出来的结果只有第一个正确，剩下的都是乱码。
如下：

层主说了 只支持 单字符
中文的, 是双字节吧
作者: 陈宁    时间: 2018-9-22 22:33
siniandd 发表于 2018-9-22 22:20
层主说了 只支持 单字符
中文的, 是双字节吧

表示只看了第一页- -，后面没看
作者: siniandd    时间: 2018-9-22 22:39
15291367 发表于 2018-9-22 22:33
表示只看了第一页- -，后面没看

汇编的确快好多
手中有个大神给的模块 1000w QQ 500-600毫秒 支持任意字符
层主的 100毫秒左右 可惜只支持 单字符 不过用来分割qq啥的 足够了
作者: 陈宁    时间: 2018-9-22 23:11
siniandd 发表于 2018-9-22 22:39
汇编的确快好多
手中有个大神给的模块 1000w QQ 500-600毫秒 支持任意字符
层主的 100毫秒左右 可惜 ...

求分享啊~~
作者: siniandd    时间: 2018-9-22 23:18
15291367 发表于 2018-9-22 23:11
求分享啊~~

他说的 自己用的模块 你懂的
不过推荐你 空之影 数组支持库
1000w 编译后 1秒左右 问题是 功能多啊 去重复啥的 爽歪歪
作者: jr21066    时间: 2018-9-23 14:57
新的修改代码加简单的测试代码.建议使用新的代码使用前一定要使用 取数组成员数来分配内存.如果你不想这么麻烦.可以把变量修改为静态变量放到调用里.,但这样会占用大量内存的.


  
表1 ＝ 到字节集 (“ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890-_”)
表长度 ＝ 取字节集长度 (表1)
计次循环首 (99999, 计数器)
计次循环首 (汇编_取随机数 (1, 30), )
分割内容.添加 (取字节集中间 (表1, 汇编_取随机数 (1, 表长度), 1))
计次循环尾 ()
分割内容.添加 ({ 13, 10 })
计次循环尾 ()
写到文件 (取特定目录 ( #系统桌面 ) ＋ “\测试文本_换行符.txt”, 分割内容.取字节集 (, ))
取数组成员数 (内容数组)
内容 ＝ 读入文件 (取特定目录 ( #系统桌面 ) ＋ “\测试文本_换行符.txt”)
汇编_分割文本 (内容, 内容数组, )
调试输出 (取数组成员数 (内容数组), 内容数组 [汇编_取随机数 (1, 取数组成员数 (内容数组))], 内容数组 [汇编_取随机数 (1, 取数组成员数 (内容数组))], 内容数组 [汇编_取随机数 (1, 取数组成员数 (内容数组))])
子程序名返回值类型公开备 注
汇编_分割文本整数型 调用前请先定义数组最大值(大于成员数).并使用命令[取数组成员数]进行内存分配
参数名类 型参考可空数组备 注
参_文本内容字节集需要处理的文本内容字节集形式,此变量内容会被修改后用于文本数组,请先保留备份.
参_文本数组文本型数组要先定义成员数,最大1410065407.越大消耗内存越大,可到1G.
参_分隔符文本型为了简单高效.分隔符只考虑了单字节情况.
变量名类 型静态数组备 注
局_分隔符字节型 
如果真 (取字节集长度 (参_文本内容) ＜ 4)
返回 (0)
局_分隔符 ＝ 取代码 (参_分隔符, )
如果 (是否为空 (参_分隔符))
置入代码 ({ 139, 85, 8, 139, 18, 139, 74, 4, 131, 194, 8, 139, 93, 12, 139, 27, 131, 195, 4, 184, 1, 0, 0, 0, 137, 3, 137, 83, 4, 138, 2, 60, 13, 117, 26, 51, 192, 136, 2, 66, 139, 194, 64, 59, 200, 115, 17, 139, 3, 64, 137, 3, 193, 224, 2, 3, 195, 137, 16, 235, 1, 66, 226, 221, 139, 3, 201, 194, 12, 0 })
置入代码 ({ 141, 85, 8, 139, 18, 139, 18, 139, 74, 4, 131, 194, 8, 141, 93, 12, 139, 27, 139, 27, 131, 195, 4, 139, 117, 252, 184, 1, 0, 0, 0, 137, 3, 137, 83, 4, 15, 182, 2, 59, 198, 117, 26, 51, 192, 136, 2, 66, 139, 194, 64, 59, 200, 115, 17, 139, 3, 64, 137, 3, 193, 224, 2, 3, 195, 137, 16, 235, 1, 66, 226, 220, 139, 3, 201, 194, 12, 0 })

返回 (0)
' 使用注意事项
 ' 首先定义数组成员数,需要大于返回的成员数
 ' 使用[取数组成员数]命令对文本数组进行内存分配
 ' 命令返回后,参数文本内容中的内容将会被修改并用于文本数组读取,请先保留备份并在文本数组使用完成前保持变量内容不变.
 ' 文本数组实际只有一组地址指针,内容指向文本内容变量.所以省下了大量的内存分配过程
 ' 分割符默认为#换行符.自定义分隔符只加入了单字节.



i支持库列表   支持库注释   
commobj通用对象支持库
shell操作系统界面功能支持库
spec特殊功能支持库


作者: jr21066    时间: 2018-9-29 14:18
加上分隔符参数了.使用时注意第一条指令一定是 取数组成员数()

  
子程序名返回值类型公开备 注
汇编_分割文本 快速分割文本
参数名类 型参考可空数组备 注
参_内容字节集字节集待分割文本
参_文本数组文本型请在第一条语句执行取数组成员数来分配数组内存
参_分隔符字节集分割符,可空
变量名类 型静态数组备 注
局_内容字节集使用局部变量,不再破坏参数内容,会增加内存使用
' 如果内容为空,返回
如果真 (取字节集长度 (参_内容) ＝ 0)
返回 ()
' 默认使用换行符分割
如果真 (是否为空 (参_分隔符))
参_分隔符 ＝ { 13, 10 }
局_内容 ＝ 参_内容
' 补齐分隔符
如果真 (取字节集右边 (局_内容, 取字节集长度 (参_分隔符)) ≠ 参_分隔符)
局_内容 ＝ 局_内容 ＋ 参_分隔符
' 将变量地址传到代码里,这个是可以直接取的.如果命令取的话.局部变量的存放位置就可以随意调整了
取变量地址 (局_内容)
置入代码 ({ 137, 195, 139, 27, 139, 75, 4, 141, 123, 8, 139, 69, 16, 139, 0, 139, 80, 4, 139, 69, 12, 139, 24, 131, 195, 4, 49, 192, 137, 3, 255, 3, 137, 123, 4, 252, 139, 69, 16, 139, 0, 141, 112, 8, 172, 242, 174, 227, 35, 65, 79, 81, 137, 209, 78, 243, 166, 117, 19, 137, 209, 49, 192, 41, 215, 243, 170, 255, 3, 139, 3, 193, 224, 2, 1, 216, 137, 56, 89, 41, 215, 71, 226, 208, 139, 69, 16, 139, 0, 138, 64, 8, 58, 71, 255, 116, 4, 255, 11, 235, 5, 49, 192, 137, 71, 255 })
' ------------------使用说明----------------------
 ' 代码调用前需要两个变量.一个是字节集的等分割内容.第二个是文本数组,需要提前定义成员数并在第一条命令执行 取数组成员数(文本数组) 来分配内存
 ' 代码调用完成后,形成映像文本数组,实际内容存放在第一个字节集变量中.两者配合形成真正的数组.在使用完成前不要修改第一个变量的值.
 ' 测试时发现很多奇怪的分隔符,所以分隔符使用字节集了.方便调试和调用.
 ' mov ebx, eax  传进来的局部变量地址
 ' mov ebx, dword [ebx]  取指针地址
 ' mov ecx, dword [ebx+0x04]  取字节集长度
 ' lea edi, dword [ebx+0x08]  取内容开始地址
 ' mov eax, dword [ebp+0x10]  取分隔符地址
 ' mov eax, dword [eax]
 ' mov edx, dword [eax+0x04]  取分隔符长度
 ' mov eax, dword [ebp+0x0C]  取数组地址
 ' mov ebx, dword [eax]
 ' add ebx, 0x04  保存数组成员数地址
 ' xor eax, eax
 ' mov dword [ebx], eax  重置数组成员数
 ' inc dword [ebx]  加入第一位成员
 ' mov dword [ebx+0x04], edi  第一位成员地址指针
 ' cld
 ' Label3:
 ' mov eax, dword [ebp+0x10]  取分隔符
 ' mov eax, dword [eax]
 ' lea esi, dword [eax+0x08]
 ' lodsb
 ' repne scasb  扫描分隔符
 ' jecxz Label1  内容扫描结束
 ' inc ecx  退回一格进行完整的分隔符比较
 ' dec edi
 ' push ecx  保存计数
 ' mov ecx, edx  分隔符长度
 ' dec esi
 ' rep cmpsb  比较分隔符
 ' jne Label2  不是分隔符,跳
 ' mov ecx, edx  将分隔符填充为0
 ' xor eax, eax
 ' sub edi, edx
 ' rep stosb
 ' inc dword [ebx]  成员数加一
 ' mov eax, dword [ebx]  取数组成员数
 ' shl eax, 0x02  计算数组成员指针地址
 ' add eax, ebx
 ' mov dword [eax], edi  写数据地址指针到成员表
 ' Label2:
 ' pop ecx  恢复计数
 ' sub edi, edx  修正指针位置
 ' inc edi
 ' loop Label3  循环处理
 ' Label1:
 ' mov eax, dword [ebp+0x10]  如果是单字节分隔符时
 ' mov eax, dword [eax]
 ' mov al,byte ptr  [eax+0x08]
 ' cmp al,byte ptr [edi-1]  比较是否是分隔符
 ' jz addr3
 ' dec dword [ebx]  不符合时减去开始增加的那个分隔符
 ' jmp addrend
 ' addr3:
 ' xor eax,eax  写文本结束符
 ' mov [edi-1],eax
 ' addrend:



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

作者: jr21066    时间: 2018-10-5 15:10
用图片说明一下数组的结构.
易的分割文本为什么慢呢.这是因为每增加一个成员时,都需要先申请内存,写数据内容,写数据指针.修改成员数.次数多了就会很慢的.
好处是增加删除成员时很方便.内存管理也方便.在过程结束时系统会自动释放临时变量使用的内存的.

幻灯片1.JPG (39.63 KB, 下载次数: 0)

幻灯片1.JPG

幻灯片2.JPG (42.04 KB, 下载次数: 0)

幻灯片2.JPG
作者: 未离吖    时间: 2018-10-22 16:44
大佬，为啥我运行的时候执行两次分割就会崩啊嘤嘤嘤
作者: jr21066    时间: 2018-10-22 17:11
未离吖 发表于 2018-10-22 16:44
大佬，为啥我运行的时候执行两次分割就会崩啊嘤嘤嘤

分割不会出错.但数组成员没有分配内存就不行.

两种.一种是在最开始就设置一个大的成员数.
第二种时在子程序返回前将数组重定义回0
作者: carmen9804    时间: 2019-3-3 20:12
作者: a3960382663    时间: 2019-4-5 00:31
全汇编文本操作模块速度
作者: 遵义静以修身    时间: 2019-5-1 13:27
感谢大神分享
作者: tasbox    时间: 2019-6-16 13:34
很快  使用,比自带的快很多了
作者: 0312    时间: 2019-8-16 00:43
66666666666666
作者: 13804061190    时间: 2020-1-7 21:34
作者吱吱吱吱吱吱吱吱



欢迎光临 精易论坛 (https://125.confly.eu.org/) Powered by Discuz! X3.4