窗口程序集名 | 保 留 | 保 留 | 备 注 |
程序集1 | | | |
变量名 | 类 型 | 数组 | 备 注 |
集_许可 | 整数型 | |
集_得到的字节集数组 | 字节集 | 0 |
集_每个线程执行数 | 整数型 | |
集_状态 | 状态分类 | 0 |
集_状态2 | 状态分类 | 0 |
集_执行线程数 | 整数型 | |
集_shuzhi | 整数型 | |
集_总行数 | 整数型 | |
变量名 | 类 型 | 静态 | 数组 | 备 注 |
路径 | 文本型 | | |
ret | 双精度小数型 | | |
集_许可 =
创建进入许可证 ()路径 =
取运行目录 () +
“\”创建目录 (路径 +
“分类结果”)ret =
文本状态分类 (读入文件 (路径 +
“测试文本.txt”),
“帐号回收-帐号冻结-帐号正常-改密解冻-永久冻结”, 路径 +
“分类结果\”)信息框 (到文本 (“耗时:” +
到文本 (ret
) +
“秒”), 0, ,
)_临时子程序 () 返回 (0
) |
文本状态分类 | 双精度小数型 | |
|
参_原xx字节集 | 字节集 | | | |
参_状态文本 | 文本型 | | | | 参_需要写到的路径 | 文本型 | | | |
变量名 | 类 型 | 静态 | 数组 | 备 注 |
局_文本数组 | 文本型 | | 0 |
局_成员 | 整数型 | | |
局_c | 整数型 | | |
局_s | 整数型 | | |
局_字节集对象 | 快速字节集对象 | | |
局_xx | 文本型 | | |
局_地址 | 整数型 | | |
如果真 (寻找文本 (参_状态文本,
“-”, ,
假) = -1
)
参_状态文本 = 参_状态文本 +
“-”局_文本数组 = 分割文本 (参_状态文本, “-”, )局_成员 =
取数组成员数 (局_文本数组
)清除数组 (集_状态
)清除数组 (集_状态2
)
如果真 (局_成员 > 0
)
重定义数组 (集_状态, 假, 局_成员
)
重定义数组 (集_状态2, 假, 局_成员
)
计次循环首 (局_成员, 局_c
)

集_状态
[局_c
].状态文本 = 局_文本数组
[局_c
]

集_状态2
[局_c
].状态文本 = 局_文本数组
[局_c
]
计次循环尾 ()
局_字节集对象.
置字节集 ({ })
局_字节集对象.
置字节集 (参_原xx字节集
)
集_得到的字节集数组 = 局_字节集对象.
分割字节集 ({ 13, 10
},
)
局_成员 =
取数组成员数 (集_得到的字节集数组
)
集_总行数 = 局_成员

如果 (局_成员 > 20
) 

集_执行线程数 = 20


集_每个线程执行数 =
取整 (局_成员 ÷ 20
)



集_执行线程数 = 1


集_每个线程执行数 = 局_成员



局_s =
取启动时间 ()
集_shuzhi = 0

计次循环首 (集_执行线程数, 局_c
)

集_shuzhi = 集_shuzhi + 1


局_xx =
到文本 (集_每个线程执行数
) +
“-” +
到文本 (局_c - 1
)

局_地址 =
申请内存 (取文本长度 (局_xx
) + 4,
真)
写到内存 (局_xx, 局_地址,
取文本长度 (局_xx
))

启动线程 (&处理线程, 局_地址,
)
计次循环尾 ()
循环判断首 ()
延时 (20
)

如果真 (集_shuzhi ≤ 0
)

跳出循环 ()



循环判断尾 (1 = 1
)
计次循环首 (取数组成员数 (集_状态
), 局_c
)

集_状态
[局_c
].原文本.
写到文件 (参_需要写到的路径 + 集_状态
[局_c
].状态文本 +
“.txt”)
计次循环尾 ()
返回 (到数值 ( (取启动时间 () - 局_s
) ÷ 1000
))
返回 (0)变量名 | 类 型 | 静态 | 数组 | 备 注 |
局_增加 | 整数型 | | |
局_c | 整数型 | | |
局_成员 | 整数型 | | |
局_b | 整数型 | | |
局_字节集 | 字节集 | | |
局_状态分类 | 状态分类 | | 0 |
局_临时地址 | 整数型 | | |
局_文本 | 文本型 | | |
局_asd | 文本型 | | 0 |
局_循环次数 | 整数型 | | |
局_循坏开始 | 整数型 | | |
进入许可区 (集_许可
)局_临时地址 = 参_地址
退出许可区 (集_许可
)局_文本 =
指针到文本 (局_临时地址
)释放内存 (局_临时地址
)局_asd =
分割文本 (局_文本,
“-”,
)局_循环次数 =
到整数 (局_asd
[1
])局_循坏开始 =
到整数 (局_asd
[2
])
如果 (局_循坏开始 + 1 = 集_执行线程数
)
局_增加 = 局_循环次数 × 局_循坏开始

局_循环次数 = 集_总行数 - 局_增加

局_增加 = 局_循环次数 × 局_循坏开始
复制数组 (局_状态分类, 集_状态2)局_成员 =
取数组成员数 (局_状态分类
)
计次循环首 (局_循环次数, 局_c
)
局_字节集 = 集_得到的字节集数组
[局_增加 + 局_c
]
计次循环首 (局_成员, 局_b
)

如果真 (寻找字节集 (局_字节集,
到字节集 (局_状态分类
[局_b
].状态文本
),
) ≠ -1
)


局_状态分类
[局_b
].原文本.
添加 (局_字节集 +
{ 13, 10
})

跳出循环 ()



计次循环尾 ()
计次循环尾 ()进入许可区 (集_许可
)
计次循环首 (局_成员, 局_c
)
集_状态
[局_c
].原文本.
添加 (局_状态分类
[局_c
].原文本.
取字节集 (, 局_状态分类
[局_c
].原文本.
取长度 ())
)
计次循环尾 ()集_shuzhi = 集_shuzhi - 1
退出许可区 (集_许可
)