马上注册,结交更多好友,享用更多功能,让你轻松玩转社区。
您需要 登录 才可以下载或查看,没有账号?站点注册
×
本帖最后由 pbai 于 2026-10-10 11:09 编辑
PBIDEA:uo_biginteger 大整数全解 —— 29 个方法、任意精度算术与数论(PB10 基准 · PB12.5 双轨实测)
【版本声明】
- 本文以 PBIDEA 当前最新版本为准(版本源由维护方统一核验),并对照随版发布的源码整理。
- 核验日期:2026-10-10;当次核验的 PBIDEA 核心运行库:18,132,992 字节 / 2572 个导出,md5 2816bc51d08e…。
- 版本识别口径:逐项解析 PE 导出表(文件体积、目录名都不能作为判据)。
- 适用平台:Windows XP 及以上(XP / 7 / 10 / 11 均可);PowerBuilder 8 及以上(PB 8/9/10/10.5/11.x/12.x 及以上通用)。本文的实机验证环境为 Windows 10 + PB 10 与 PB 12.5。
- PBIDEA 版本会持续更新,本文只对上述核验时点的最新版本负责;后续若行为有变,以新版为准。
阅读说明
- 适用版本:一律以顶部【版本声明】为准;PB 侧写法 PB 8 及以上通用,本文以 PowerBuilder 10 为语法基准,代码在 PB 10 与 PB 12.5 两条轨道上各自实机跑通并逐字节核对读数。
- 涉及对象:uo_biginteger(PBIDEA 自定义非可视对象,随 PBIDEA 主运行库一起分发)。
- 支持数据库:本文不涉及任何数据库,全部为内存计算,无需配置 DBMS。
- 操作系统与环境要求:Windows XP 及以上;需安装 PBIDEA 运行库(PbIdea.dll),否则调用外部函数时报 Unresolvable external。PB 侧需 PB 8 及以上(PB10 只支持 32 位进程,若用 PB10 请用 32 位运行库)。
- 难度系数:★★★☆☆(调用本身很简单,但少数参数会让进程挂死,第五节必须看)
- 前置知识:会 create / destroy 自定义非可视对象即可;不需要数学背景,用到数论的部分会解释用途。
一、这是什么
uo_biginteger 是 PBIDEA 自带的大整数(任意精度整数)对象,语义对齐 Java 的 BigInteger。它解决的问题很具体:PowerScript 原生没有一个能安全容纳超过 longlong 范围的整数类型。
先说清楚原生类型的天花板,这决定了什么时候必须换对象:
| 类型 | 实测上限 | 说明 | | integer | 32767 | 16位 | | long | 2147483647 | 32位 | | longlong | 9223372036854775807 | 64位,约 9.22×10^18 | | decimal | 字面量上限 18446744073709551615 | 定点小数,约 1.84×10^19,且只能写常量、不能参与任意精度运算 |
也就是说,一旦你的业务出现 19 位以上的整数(微信号、QQ 号、雪花 ID、身份证号、对称加密的模数、哈希的十进制呈现),longlong 就会溢出。而溢出在 PowerScript 里是静默的——不会报错,只会给你一个错的数。
uo_biginteger 就补这块。它是非可视对象、非 autoinstantiate,必须自己 create / destroy。
它现在能做什么:早期版本它只是个「大数容器 + 进制转换器」(5 个方法,不能算);当前版本已经扩展成完整的任意精度计算器——四则运算、幂、模运算、模幂、模逆、模平方根、移位、比较、素数生成全都有。对外方法名从 5 个增加到 29 个(含重载共 35 条签名),底层的 bn* 导出函数从 7 个增加到 31 个。
| 能力 | 早期版本 | 当前版本 | | 载入 / 输出 / 进制 | 有(5 个方法) | 有(8 条签名) | | 加减乘除 / 幂 / 平方 | 没有 | 有(7 条签名) | | 模运算(模加/减/乘/平方/平方根/模幂) | 没有 | 有(6 条签名) | | 数论(gcd / 模逆 / 素数生成) | 没有 | 有(8 条签名) | | 移位 / 比较 / 判定 | 没有 | 有(6 条签名) |
这一节就是全文的定调:旧文里「它只是个容器、不是计算器」的说法,在当前版本上已经作废。
二、完整 API 清单(35 条签名 / 29 个方法名,全部实测通过)
下面五张表按功能分组,逐条对照 PBIDEA 随版源码 uo_biginteger.sru 的 type prototypes 段。所有条目都指向 pbidea.dll 的导出别名(源码里没有一行 PowerScript 实现)。
2.1 构造与转换(8 条签名 / 6 个方法名)
| 方法 | 返回 | 签名 | 作用 | | FromHex | boolean | readonly string hex | 从十六进制字符串载入(新版本认 0x 前缀) | | FromStr | boolean | readonly string dec | 从十进制字符串载入 | | FromNum | boolean | ulong n | 由 32 位无符号整数构造 | | FromNum | boolean | longlong n | 由 64 位整数构造 | | toBlob | blob | 无参 | 转二进制数据(取最小字节数) | | toString | string | 无参 | 转十进制字符串(默认) | | toString | string | int radix | 转指定进制(只有 2 和 16 真正生效) | | Rand | string | int size | 生成随机十六进制串 |
2.2 四则 · 幂 · 平方(7 条签名)
| 方法 | 返回 | 签名 | 作用 | | add | uo_biginteger | readonly uo_biginteger oper | 加 | | sub | uo_biginteger | readonly uo_biginteger oper | 减 | | mul | uo_biginteger | readonly uo_biginteger oper | 乘 | | div | uo_biginteger | readonly uo_biginteger oper | 除(向零截断) | | exp | uo_biginteger | readonly uo_biginteger oper | 幂(this ^ oper) | | mod | uo_biginteger | readonly uo_biginteger oper | 取模(余数符号跟随被除数) | | sqr | uo_biginteger | 无参 | 平方(this ^ 2) |
2.3 模运算(6 条签名)
| 方法 | 返回 | 签名 | 作用 | | modExp | uo_biginteger | readonly uo_biginteger oper_exp, readonly uo_biginteger oper_m | 模幂 (this ^ oper_exp) mod oper_m | | modadd | uo_biginteger | readonly uo_biginteger oper, readonly uo_biginteger oper_m | 模加 (this + oper) mod oper_m | | modsub | uo_biginteger | readonly uo_biginteger oper, readonly uo_biginteger oper_m | 模减 (this - oper) mod oper_m | | modmul | uo_biginteger | readonly uo_biginteger oper, readonly uo_biginteger oper_m | 模乘 (this * oper) mod oper_m | | modSqr | uo_biginteger | readonly uo_biginteger oper | 模平方 (this ^ 2) mod oper | | modSqrt | uo_biginteger | readonly uo_biginteger oper | 模平方根(对奇素数模,见第五节坑 9) |
四个模加减乘与两个模幂模方,结果一律落在 [0, oper_m),不会出现负数——这一点和 mod 不同,下面第四节有读数。
2.4 数论(8 条签名 / 4 个方法名)
| 方法 | 返回 | 签名 | 作用 | | nnmod | uo_biginteger | readonly uo_biginteger oper | 非负余数(结果恒在 [0, oper)) | | gcd | uo_biginteger | readonly uo_biginteger oper | 最大公约数(取绝对值参与) | | modInverse | uo_biginteger | readonly uo_biginteger oper | 模逆(要求与模数互素,否则见坑 9) | | prime | uo_biginteger | 无参 | 生成素数,默认 512 位 | | prime | uo_biginteger | int bits | 指定位数,如 128 / 256 / 512 | | prime | uo_biginteger | int bits, boolean safe | 是否要求安全素数 | | prime | uo_biginteger | int bits, boolean safe, readonly uo_biginteger add | 附加同余约束:形如 k*?+add | | prime | uo_biginteger | int bits, boolean safe, readonly uo_biginteger add, readonly uo_biginteger rem | 完整同余约束(给定无解组合会死循环,见坑 9) |
2.5 移位与判定(6 条签名)
| 方法 | 返回 | 签名 | 作用 | | lshift | uo_biginteger | int n | 左移 n 位(等价乘 2^n) | | rshift | uo_biginteger | int n | 右移 n 位(等价除以 2^n 向零截断,不是算术右移) | | cmp | int | readonly uo_biginteger oper | 比较,返回 -1 / 0 / 1 | | isZero | boolean | 无参 | 是否等于 0 | | isOne | boolean | 无参 | 是否等于 1 | | isOdd | boolean | 无参 | 是否奇数(返回 1 / 0) |
2.6 生命周期(私有,不需要你调用)
| 子程序 | 声明 | 说明 | | bnCreate | private subroutine bnCreate() system library "pbidea.dll" | create 时经 constructor 事件自动调用 | | bnDestroy | private subroutine bnDestroy() system library "pbidea.dll" | destroy 时经 destructor 事件自动调用 |
也就是说:只要 create / destroy 配对写对,底层句柄自己会管;不需要 open / close,也没有任何 SetDataDirectory 之类的前置初始化。
顺带记一个读源码才会注意到的写法:这两个子程序必须是 subroutine,因为 PowerBuilder 没有 void 返回类型——写成 function bnCreate() 是编译不过的。你自己照这个对象的形状扩写时要注意。
三、最小可运行示例:十个方法把能力全覆盖
演示步骤:新建一个非可视对象 nvo_bi_demo(对象名与文件名必须一致),用下面的源码覆盖它;再建一个窗口,在 Open 事件里写 MessageBox("bigint", nvo_bi_demo.of_basic()) 之类的调用,运行即可看到输出。
其中第 10 个方法 of_usage() 调用的是第六节的 nvo_bi_safe,所以请先把第六节那个对象也导入同一个 PBL,再导本对象。前面 9 个方法不依赖它。 - $PBExportHeader$nvo_bi_demo.sru
- forward
- global type nvo_bi_demo from nonvisualobject
- end type
- end forward
- global type nvo_bi_demo from nonvisualobject
- end type
- global nvo_bi_demo nvo_bi_demo
- type prototypes
- end prototypes
- type variables
- end variables
- forward prototypes
- public function string of_basic ()
- public function string of_bignum ()
- public function string of_modarith ()
- public function string of_shift_cmp ()
- public function string of_prime ()
- public function string of_load ()
- public function string of_radix ()
- public function string of_blob_rand ()
- public function string of_ownership ()
- public function string of_usage ()
- private function string of_take (uo_biginteger abi)
- end prototypes
- /*====================================================================
- of_take:接收一个「运算返回的临时对象」,取完值就销毁,避免调用方
- 还要为每个中间结果写一遍 destroy。传进来的对象由本函数负责销毁。
- 用法:of_take(a.add(b))
- ====================================================================*/
- function string of_take(uo_biginteger abi)
- string ls_r
- if IsValid(abi) then
- ls_r = abi.toString()
- destroy abi
- else
- ls_r = 'null'
- end if
- return ls_r
- end function
- /*====================================================================
- 1. 基本算术:加减乘除、幂、取模、平方
- ====================================================================*/
- function string of_basic()
- uo_biginteger a, b, c
- string ls_r
- a = create uo_biginteger
- b = create uo_biginteger
- a.FromNum(10)
- b.FromNum(3)
- ls_r = 'add(10,3) = ' + of_take(a.add(b)) + '~r~n'
- ls_r = ls_r + 'sub(10,3) = ' + of_take(a.sub(b)) + '~r~n'
- ls_r = ls_r + 'mul(10,3) = ' + of_take(a.mul(b)) + '~r~n'
- ls_r = ls_r + 'div(10,3) = ' + of_take(a.div(b)) + ' <- 向零截断~r~n'
- ls_r = ls_r + 'mod(10,3) = ' + of_take(a.mod(b)) + '~r~n'
- ls_r = ls_r + 'exp(10,3) = ' + of_take(a.exp(b)) + '~r~n'
- ls_r = ls_r + 'sqr(10) = ' + of_take(a.sqr()) + '~r~n'
- a.FromStr('-10')
- ls_r = ls_r + 'div(-10,3) = ' + of_take(a.div(b)) + '~r~n'
- ls_r = ls_r + 'mod(-10,3) = ' + of_take(a.mod(b)) + ' <- 余数符号跟随被除数~r~n'
- c = create uo_biginteger
- a.FromNum(10)
- b.FromNum(0)
- ls_r = ls_r + 'exp(10,0) = ' + of_take(a.exp(b))
- destroy c
- destroy b
- destroy a
- return ls_r
- end function
- /*====================================================================
- 2. 超出 longlong 的整数:30 位加减乘、2^64、600 位乘 600 位
- ====================================================================*/
- function string of_bignum()
- uo_biginteger a, b, c
- string ls_r, ls_a, ls_b
- long li_i
- a = create uo_biginteger
- b = create uo_biginteger
- ls_a = '123456789012345678901234567890'
- ls_b = '987654321098765432109876543210'
- a.FromStr(ls_a)
- b.FromStr(ls_b)
- ls_r = '30位 + 30位 = ' + of_take(a.add(b)) + '~r~n'
- ls_r = ls_r + '30位 - 30位 = ' + of_take(a.sub(b)) + '~r~n'
- c = a.mul(b)
- ls_r = ls_r + '30位 x 30位 = ' + c.toString() + ' (长度 ' + String(Len(c.toString())) + ')~r~n'
- destroy c
- a.FromNum(2)
- b.FromNum(64)
- ls_r = ls_r + '2^64 = ' + of_take(a.exp(b)) + '~r~n'
- ls_a = ''
- for li_i = 1 to 600
- ls_a = ls_a + '1'
- next
- a.FromStr(ls_a)
- b.FromNum(1)
- c = a.add(b)
- ls_r = ls_r + '600位 + 1 长度 = ' + String(Len(c.toString())) + ' 头12位=' + Left(c.toString(), 12) + ' 尾12位=' + Right(c.toString(), 12) + '~r~n'
- destroy c
- a.FromStr(ls_a)
- b.FromStr(ls_a)
- c = a.mul(b)
- ls_r = ls_r + '600位 x 600位 长度 = ' + String(Len(c.toString()))
- destroy c
- destroy b
- destroy a
- return ls_r
- end function
- /*====================================================================
- 3. 模运算与数论:modExp / nnmod / modadd / modsub / modmul / modSqr
- / gcd / modInverse
- ====================================================================*/
- function string of_modarith()
- uo_biginteger a, b, m
- string ls_r
- a = create uo_biginteger
- b = create uo_biginteger
- m = create uo_biginteger
- a.FromNum(10)
- b.FromNum(3)
- m.FromNum(7)
- ls_r = 'modExp(10,3,7) = ' + of_take(a.modExp(b, m)) + ' <- (10^3) mod 7~r~n'
- ls_r = ls_r + 'modadd(10,3,7) = ' + of_take(a.modadd(b, m)) + '~r~n'
- ls_r = ls_r + 'modsub(3,10,7) = ' + of_take(b.modsub(a, m)) + ' <- 结果落在 [0,7),不是 -7~r~n'
- ls_r = ls_r + 'modmul(10,3,7) = ' + of_take(a.modmul(b, m)) + '~r~n'
- ls_r = ls_r + 'modSqr(10,7) = ' + of_take(a.modSqr(m)) + '~r~n'
- ls_r = ls_r + 'gcd(10,3) = ' + of_take(a.gcd(b)) + '~r~n'
- a.FromNum(12)
- b.FromNum(18)
- ls_r = ls_r + 'gcd(12,18) = ' + of_take(a.gcd(b)) + ' <- 负数按绝对值参与~r~n'
- a.FromNum(3)
- m.FromNum(7)
- ls_r = ls_r + 'modInverse(3,7) = ' + of_take(a.modInverse(m)) + ' <- 3*5 mod 7 = 1~r~n'
- a.FromStr('-10')
- m.FromNum(7)
- ls_r = ls_r + 'nnmod(-10,7) = ' + of_take(a.nnmod(m)) + ' <- 非负余数~r~n'
- a.FromNum(2)
- m.FromNum(7)
- ls_r = ls_r + 'modSqrt(2,7) = ' + of_take(a.modSqrt(m)) + ' <- 4^2 mod 7 = 2'
- destroy m
- destroy b
- destroy a
- return ls_r
- end function
- /*====================================================================
- 4. 移位、比较、断言:lshift / rshift / cmp / isZero / isOne / isOdd
- ====================================================================*/
- function string of_shift_cmp()
- uo_biginteger a, b
- string ls_r
- a = create uo_biginteger
- b = create uo_biginteger
- a.FromNum(10)
- ls_r = '10 << 3 = ' + of_take(a.lshift(3)) + '~r~n'
- ls_r = ls_r + '10 >> 1 = ' + of_take(a.rshift(1)) + '~r~n'
- a.FromStr('-5')
- ls_r = ls_r + '(-5) >> 1 = ' + of_take(a.rshift(1)) + ' <- 等同于除以 2 并向零截断,不是算术右移~r~n'
- a.FromNum(1)
- ls_r = ls_r + '1 << 100 = ' + of_take(a.lshift(100)) + '~r~n'
- a.FromNum(7)
- b.FromNum(8)
- ls_r = ls_r + 'cmp(7,8) = ' + String(a.cmp(b)) + '~r~n'
- a.FromNum(0)
- ls_r = ls_r + '0: isZero=' + String(a.isZero()) + ' isOne=' + String(a.isOne()) + ' isOdd=' + String(a.isOdd()) + '~r~n'
- a.FromNum(1)
- ls_r = ls_r + '1: isZero=' + String(a.isZero()) + ' isOne=' + String(a.isOne()) + ' isOdd=' + String(a.isOdd()) + '~r~n'
- a.FromStr('-3')
- ls_r = ls_r + '(-3): isOdd=' + String(a.isOdd()) + ' <- 奇数,isOne 为假'
- destroy b
- destroy a
- return ls_r
- end function
- /*====================================================================
- 5. 大素数:prime() 重载
- ====================================================================*/
- function string of_prime()
- uo_biginteger p
- string ls_r, ls_h
- p = create uo_biginteger
- p = p.prime()
- ls_h = p.toString(16)
- ls_r = 'prime() 十六进制长度 = ' + String(Len(ls_h)) + ' (即 512 位)~r~n'
- destroy p
- p = create uo_biginteger
- p = p.prime(128)
- ls_r = ls_r + 'prime(128) 十六进制长度 = ' + String(Len(p.toString(16))) + '~r~n'
- destroy p
- p = create uo_biginteger
- p = p.prime(256, true)
- ls_r = ls_r + 'prime(256,true) 十六进制长度 = ' + String(Len(p.toString(16))) + ' (安全素数)~r~n'
- destroy p
- p = create uo_biginteger
- p = p.prime(64)
- ls_r = ls_r + 'prime(64) 十六进制长度 = ' + String(Len(p.toString(16))) + '~r~n'
- ls_r = ls_r + '随机返回值每次不同,此处只报长度'
- destroy p
- return ls_r
- end function
- /*====================================================================
- 6. 三个载入方法的真实语义(本文最重要的一节)
- ====================================================================*/
- function string of_load()
- uo_biginteger lo
- longlong ll_neg
- string ls_r
- boolean lb
- lo = create uo_biginteger
- lb = lo.FromStr('0')
- ls_r = 'FromStr(0) -> ' + String(lb) + ' 值=' + lo.toString() + '~r~n'
- lb = lo.FromStr('123456789012345678901234567890')
- ls_r = ls_r + 'FromStr(30位) -> ' + String(lb) + ' 值=' + lo.toString() + '~r~n'
- lb = lo.FromStr('12ab34')
- ls_r = ls_r + 'FromStr(12ab34) -> ' + String(lb) + ' 值=' + lo.toString() + ' <- 截断到 12,返回值仍是 true~r~n'
- lo.FromStr('999')
- lb = lo.FromStr('1 2')
- ls_r = ls_r + '预置999 后 (1空格2) -> ' + String(lb) + ' 值=' + lo.toString() + ' <- 最险的一条:静默变成 1,还报成功~r~n'
- lo.FromStr('999')
- lb = lo.FromStr(' 789')
- ls_r = ls_r + '预置999 后 (空格外789) -> ' + String(lb) + ' 值=' + lo.toString() + ' <- 一个数字都没读到,才返回 false 并保留原值~r~n'
- lo.FromStr('999')
- lb = lo.FromStr('')
- ls_r = ls_r + '预置999 后 (空串) -> ' + String(lb) + ' 值=' + lo.toString() + '~r~n'
- lb = lo.FromHex('0x1A')
- ls_r = ls_r + 'FromHex(0x1A) -> ' + String(lb) + ' 值=' + lo.toString() + ' <- 0x 前缀会被正确跳过~r~n'
- lo.FromHex('FF')
- lb = lo.FromHex('0xZZ')
- ls_r = ls_r + '预置FF 后 FromHex(0xZZ) -> ' + String(lb) + ' 值=' + lo.toString() + ' <- 失败并保留原值~r~n'
- lo.FromHex('F')
- ls_r = ls_r + 'FromHex(F) -> 值=' + lo.toString() + ' (奇数位左补零后解析)~r~n'
- lb = lo.FromNum(4000000000)
- ls_r = ls_r + 'FromNum(4000000000) -> ' + String(lb) + ' 值=' + lo.toString() + '~r~n'
- // FromNum 的重载按【实参位宽】挑:字面量/int/long/ulong 都走 32 位的 ulong 重载,
- // 负数被重新解释成 2^32 的无符号数;只有 longlong 类型的实参才走 64 位重载
- lb = lo.FromNum(-1)
- ls_r = ls_r + 'FromNum(-1) -> ' + String(lb) + ' 值=' + lo.toString() + ' <- 字面量走 32 位重载 = 2^32-1~r~n'
- ll_neg = -1
- lb = lo.FromNum(ll_neg)
- ls_r = ls_r + 'FromNum(longlong -1) -> ' + String(lb) + ' 值=' + lo.toString() + ' <- 换成 longlong 变量才是 2^64-1~r~n'
- ls_r = ls_r + ' <- 结论:FromNum 拿不到负数。要负数只能用 FromStr(-10)'
- destroy lo
- return ls_r
- end function
- /*====================================================================
- 7. 进制:toString / toString(radix)
- ====================================================================*/
- function string of_radix()
- uo_biginteger lo
- string ls_r
- lo = create uo_biginteger
- lo.FromStr('255')
- ls_r = '255: 默认=' + lo.toString() + ' r2=' + lo.toString(2) + ' r8=' + lo.toString(8) + ' r16=' + lo.toString(16) + ' r36=' + lo.toString(36) + '~r~n'
- ls_r = ls_r + ' <- 只有 2 与 16 真正生效,其余一律退回十进制~r~n'
- lo.FromStr('1')
- ls_r = ls_r + '1 的 r16=' + lo.toString(16) + ' <- 偶数位补零~r~n'
- lo.FromStr('64')
- ls_r = ls_r + '64 的 r2=' + lo.toString(2) + '~r~n'
- lo.FromStr('-64')
- ls_r = ls_r + '(-64) 的 r16=' + lo.toString(16) + ' r2=' + lo.toString(2) + ' <- 二进制不带负号'
- destroy lo
- return ls_r
- end function
- /*====================================================================
- 8. toBlob 与 Rand
- ====================================================================*/
- function string of_blob_rand()
- uo_biginteger lo
- blob lb
- string ls_r
- lo = create uo_biginteger
- lb = lo.toBlob()
- ls_r = '新建对象 toBlob 长度 = ' + String(Len(lb)) + '~r~n'
- lo.FromStr('65535')
- ls_r = ls_r + '65535 toBlob 长度 = ' + String(Len(lo.toBlob())) + '~r~n'
- lo.FromStr('65536')
- ls_r = ls_r + '65536 toBlob 长度 = ' + String(Len(lo.toBlob())) + '~r~n'
- lo.FromStr('16777216')
- ls_r = ls_r + '16777216 toBlob 长度 = ' + String(Len(lo.toBlob())) + ' <- 取最小字节数,不多补零~r~n'
- ls_r = ls_r + 'Rand(8) = ' + lo.Rand(8) + ' (大写十六进制随机串)~r~n'
- ls_r = ls_r + 'Rand(3) = ' + lo.Rand(3) + ' <- 参数按十六进制字符数理解,奇数向上取偶,所以是 4 位~r~n'
- ls_r = ls_r + 'Rand(0) = [' + lo.Rand(0) + '] Rand(-5) = [' + lo.Rand(-5) + '] <- 都给空串,不会崩'
- destroy lo
- return ls_r
- end function
- /*====================================================================
- 9. 对象归属:运算结果是与源对象无关的独立对象,需自己 destroy
- ====================================================================*/
- function string of_ownership()
- uo_biginteger a, b, c1, c2, c3
- string ls_r
- a = create uo_biginteger
- b = create uo_biginteger
- a.FromNum(12345678901234567890)
- b.FromNum(98765432)
- c1 = a.add(b)
- ls_r = 'c1 = ' + c1.toString() + '~r~n'
- ls_r = ls_r + '运算后源对象未被改动:a = ' + a.toString() + ' b = ' + b.toString() + '~r~n'
- c2 = a.mul(b)
- ls_r = ls_r + 'c2 = ' + c2.toString() + ' <- 与 c1 是两个互不相干的对象~r~n'
- c3 = c1
- ls_r = ls_r + '执行 c3 = c1 之后 IsValid(c3) = ' + String(IsValid(c3)) + ' <- 同一个对象,赋值只是多起了一个别名~r~n'
- destroy c1
- ls_r = ls_r + '销毁 c1 后:IsValid(c1) = ' + String(IsValid(c1)) + ',IsValid(c2) = ' + String(IsValid(c2)) + ',IsValid(c3) = ' + String(IsValid(c3)) + '~r~n'
- ls_r = ls_r + ' <- c2 独立,安然无恙;c3 只是别名,跟着一起没了,千万别再 destroy 它'
- destroy c2
- destroy b
- destroy a
- return ls_r
- end function
- /*====================================================================
- 10. 安全外壳的标准用法:严格解析 + 危险调用防护
- ====================================================================*/
- function string of_usage()
- nvo_bi_safe lns
- uo_biginteger la, lb, lr1, lr2
- string ls_r
- lns = create nvo_bi_safe
- la = create uo_biginteger
- lb = create uo_biginteger
- // 先放一个旧值进去,用来看「校验失败时保留原值」
- la.FromStr('999')
- ls_r = 'of_parse_dec(12ab) -> ' + String(lns.of_parse_dec('12ab', la)) + ' 值保留=' + lns.of_to_dec(la) + '~r~n'
- ls_r = ls_r + 'of_parse_dec( 100 ) -> ' + String(lns.of_parse_dec(' 100 ', la)) + ' 值=' + lns.of_to_dec(la) + '~r~n'
- ls_r = ls_r + 'of_parse_dec(1 2) -> ' + String(lns.of_parse_dec('1 2', la)) + ' 值保留=' + lns.of_to_dec(la) + ' <- 挡住静默截断~r~n'
- la.FromNum(100)
- lb.FromNum(3)
- // ref 参数给【未创建】的变量,让函数自己 create;用完自己 destroy
- ls_r = ls_r + 'of_safe_div(100,3) -> ' + String(lns.of_safe_div(la, lb, lr1)) + ' 值=' + lns.of_to_dec(lr1) + '~r~n'
- lb.FromNum(0)
- ls_r = ls_r + 'of_safe_div(100,0) -> ' + String(lns.of_safe_div(la, lb, lr2)) + ' <- 除数为 0 直接拒绝,不会拖死进程'
- if IsValid(lr1) then destroy lr1
- if IsValid(lr2) then destroy lr2
- destroy lb
- destroy la
- destroy lns
- return ls_r
- end function
复制代码
四、十个方法的实机读数(PB 10 与 PB 12.5 逐字节一致)
下面十段输出是两条轨道各自独立运行的结果,逐字节比对完全一致(唯一例外是含随机数的 Rand 与 prime,那是随机数本身的差别,不是版本差异)。
- add(10,3) = 13
- sub(10,3) = 7
- mul(10,3) = 30
- div(10,3) = 3 <- 向零截断
- mod(10,3) = 1
- exp(10,3) = 1000
- sqr(10) = 100
- div(-10,3) = -3
- mod(-10,3) = -1 <- 余数符号跟随被除数
- exp(10,0) = 1
复制代码
div 与 mod 的符号规则和 Java 的 BigInteger 一样:商向零截断,余数符号跟随被除数。实测 div(-10,-3)=3、mod(-10,-3)=-1,并且四种符号组合都满足恒等式 a = (a / b) * b + a mod b。
- 30位 + 30位 = 1111111110111111111011111111100
- 30位 - 30位 = -864197532086419753208641975320
- 30位 x 30位 = 121932631137021795226185032733622923332237463801111263526900 (长度 60)
- 2^64 = 18446744073709551616
- 600位 + 1 长度 = 600 头12位=111111111111 尾12位=111111111112
- 600位 x 600位 长度 = 1199
复制代码
位数没有上限:600 位乘 600 位得到 1199 位,2^100 = 1267650600228229401496703205376,1 << 200 也正常。这里 c = a.mul(b) 得到的是独立新对象,用完必须自己 destroy c——见坑 10。
- modExp(10,3,7) = 6 <- (10^3) mod 7
- modadd(10,3,7) = 6
- modsub(3,10,7) = 0 <- 结果落在 [0,7),不是 -7
- modmul(10,3,7) = 2
- modSqr(10,7) = 2
- gcd(10,3) = 1
- gcd(12,18) = 6 <- 负数按绝对值参与
- modInverse(3,7) = 5 <- 3*5 mod 7 = 1
- nnmod(-10,7) = 4 <- 非负余数
- modSqrt(2,7) = 4 <- 4^2 mod 7 = 2
复制代码
这一段是全文最实用的一段,几个反直觉点:
- modsub 不会给负数:3 modsub 10 (mod 7) 给 0,不是 -7。所有 mod* 系列都被规约到 [0,m)。
- nnmod 和 mod 不是一回事:mod(-10,3) = -1(跟随被除数),而 nnmod(-10,7) = 4(恒定非负)。做哈希桶下标、取模索引时要用 nnmod。
- gcd 取绝对值:gcd(-12,18) = 6,gcd(0,0) = 0(不崩),gcd(1071,462) = 21。
- modSqrt(2,7) = 4:返回值 r 满足 r^2 mod 7 = 2。注意它只对二次剩余有解,无解时会挂死(坑 9)。
- 10 << 3 = 80
- 10 >> 1 = 5
- (-5) >> 1 = -2 <- 等同于除以 2 并向零截断,不是算术右移
- 1 << 100 = 1267650600228229401496703205376
- cmp(7,8) = -1
- 0: isZero=true isOne=false isOdd=false
- 1: isZero=false isOne=true isOdd=true
- (-3): isOdd=true <- 奇数,isOne 为假
复制代码
rshift 不是算术右移,这是最容易想当然的一条。真正的算术右移 -5 >> 1 应该等于 -3(补符号位),而它给的是 -2,也就是 div(2^n) 的向零截断结果。上一节 (-10) >> 1 = -5 同理。要用它做位掩码运算的话,负数是不能用的。
- prime() 十六进制长度 = 128 (即 512 位)
- prime(128) 十六进制长度 = 32
- prime(256,true) 十六进制长度 = 64 (安全素数)
- prime(64) 十六进制长度 = 16
- 随机返回值每次不同,此处只报长度
复制代码
位数换算关系是 十六进制长度 = bits / 4:prime(128) 给 32 位十六进制、prime(256,true) 给 64 位十六进制、prime(64) 给 16 位十六进制。prime() 无参时默认 512 位(128 位十六进制),返回的一定是奇数。
- FromStr(0) -> true 值=0
- FromStr(30位) -> true 值=123456789012345678901234567890
- FromStr(12ab34) -> true 值=12 <- 截断到 12,返回值仍是 true
- 预置999 后 (1空格2) -> true 值=1 <- 最险的一条:静默变成 1,还报成功
- 预置999 后 (空格外789) -> false 值=999 <- 一个数字都没读到,才返回 false 并保留原值
- 预置999 后 (空串) -> false 值=999
- FromHex(0x1A) -> true 值=26 <- 0x 前缀会被正确跳过
- 预置FF 后 FromHex(0xZZ) -> false 值=255 <- 失败并保留原值
- FromHex(F) -> 值=15 (奇数位左补零后解析)
- FromNum(4000000000) -> true 值=4000000000
- FromNum(-1) -> true 值=4294967295 <- 字面量走 32 位重载 = 2^32-1
- FromNum(longlong -1) -> true 值=18446744073709551615 <- 换成 longlong 变量才是 2^64-1
- <- 结论:FromNum 拿不到负数。要负数只能用 FromStr(-10)
复制代码
这一段是本文最值钱的一段,第五节逐条拆。
- 255: 默认=255 r2=11111111 r8=255 r16=FF r36=255
- <- 只有 2 与 16 真正生效,其余一律退回十进制
- 1 的 r16=01 <- 偶数位补零
- 64 的 r2=01000000
- (-64) 的 r16=-40 r2=01000000 <- 二进制不带负号
复制代码- 新建对象 toBlob 长度 = 0
- 65535 toBlob 长度 = 2
- 65536 toBlob 长度 = 3
- 16777216 toBlob 长度 = 4 <- 取最小字节数,不多补零
- Rand(8) = 926F9568 (大写十六进制随机串)
- Rand(3) = 0B4E <- 参数按十六进制字符数理解,奇数向上取偶,所以是 4 位
- Rand(0) = [] Rand(-5) = [] <- 都给空串,不会崩
复制代码
toBlob 的规律是取能装下这个数的最少字节数(大端):65535 → 2、65536 → 3、16777216 → 4、4294967296 → 5。新建对象的初值是 0,所以长度是 0。新版本依然没有 fromBlob,所以它只适合「导出成二进制落盘/传输」这类单向场景。
- c1 = 12345678901333333322
- 运算后源对象未被改动:a = 12345678901234567890 b = 98765432
- c2 = 1219326310013717430989178480 <- 与 c1 是两个互不相干的对象
- 执行 c3 = c1 之后 IsValid(c3) = true <- 同一个对象,赋值只是多起了一个别名
- 销毁 c1 后:IsValid(c1) = false,IsValid(c2) = true,IsValid(c3) = false
- <- c2 独立,安然无恙;c3 只是别名,跟着一起没了,千万别再 destroy 它
复制代码
第十段是安全外壳的实战:同样三个输入,裸 FromStr 会放行 '1 2',外壳直接拦下。
- of_parse_dec(12ab) -> false 值保留=999
- of_parse_dec( 100 ) -> true 值=100
- of_parse_dec(1 2) -> false 值保留=100 <- 挡住静默截断
- of_safe_div(100,3) -> true 值=33
- of_safe_div(100,0) -> false <- 除数为 0 直接拒绝,不会拖死进程
复制代码
对照上面坑 1 的表:'1 2' 裸调 FromStr 得到 true 和值 1(静默丢掉 2),走 of_parse_dec 则得到 false 且原值 100 原封不动——校验失败的调用不写目标对象,这一点在第六节会再展开。
五、坑清单(本文最值钱的部分)
坑 1:FromStr 的返回值不是「合法/非法」信号,而是「读到过数字吗」
旧版本里 FromStr 的返回值恒为 false,完全没有信息量。当前版本修好了:只要读到了至少一个数字就返回 true,一个都没读到(空串、首字符非法、负号后跟空格)才返回 false。
但静默截断还在,而且现在更危险——因为返回值变成了 true,你更容易信它。
| 输入 | 返回值 | 结果值 | 说明 | | '0' | true | 0 | 正常 | | '123456789012345678901234567890' | true | 完整 30 位 | 正常 | | '12ab34' | true | 12 | 截到第一个非数字,报成功 | | '12 '(尾空格) | true | 12 | 尾部空白被吃掉 | | '1 2'(中间空格) | true | 1 | ← 最险的一条:静默丢掉了 2 | | ' 789'(首空格) | false | 保留原值 | 一个数字都没读到 | | '- 12'(负号后空格) | false | 保留原值 | 同上 | | '+456' | false | 保留原值 | 不认正号 | | '' | false | 保留原值 | 空串 |
所以判定规则是「读到过数字就 true」,'1 2' 这种输入不会被拦下来。拿它解析金额 "12 34",你会收到 12 和一个 true,然后拿 12 去记账。
正确姿势:返回值只能用来判「完全没读到」,合法性必须自己先校验。 第六节给了现成的封装 of_parse_dec。
坑 2:解析失败时保留原值,不清零
这是旧文里写错的一条(旧文说「值都变成 0」,那是在新建的空对象上测的错觉)。对象一旦有值,失败后原值原样留着:
- FromHex('FF') -> 255
- FromHex('0xZZ') -> false,但值仍是 255
- FromStr('999') -> 999
- FromStr(' 789') -> false,但值仍是 999
复制代码
→ 如果你复用一个实例做多次解析,失败后必须显式重新赋值,否则会拿到上一次的陈旧值并当成这一次的结果。
坑 3:FromNum 的重载按实参位宽挑,负数根本进不来
FromNum 有两条签名:FromNum(ulong n) 和 FromNum(longlong n)。PB 挑哪一条,看的是实参本身的类型/位宽,不是它的数值:
| 实参 | 挑中的重载 | 结果 | | 字面量 123 / 2147483647 | ulong(32 位) | 123 / 2147483647 | | 字面量 2147483648(2^31) | ulong | 2147483648 | | 字面量 5000000000(5e9) | longlong(64 位,装不下的下一个) | 5000000000 | | integer / long / ulong 变量 | ulong | 按值 | | longlong 变量 | longlong | 按值 | | 字面量 -1 | ulong | 4294967295(= 2^32 - 1) | | int / long 变量 -1 | ulong | 4294967295 | | longlong 变量 -1 | longlong | 18446744073709551615(= 2^64 - 1) |
规律一句话:字面量按「能装得下的最小重载」挑,装不进 ulong 才升到 longlong;而负数是按无符号位模式重新解释的(-1 变 2^32-1 或 2^64-1)。
→ 结论:FromNum 拿不到负数。 要负数只能用 FromStr('-10')。想靠 FromNum 传负偏移量,会静默得到一个 42 亿或 1844 亿亿的正数。
坑 4:toString(radix) 只认 2 和 16,其余进制静默按十进制返回
这个坑最有欺骗性:它不报错,只是安静地给你十进制。
- 255 的 toString(8) = [255] <- 八进制本应是 377
- 255 的 toString(36) = [255] <- 36 进制本应是 73
- 64 的 toString(3) = [64] <- 三进制本应是 2101
复制代码
而 radix = 2 和 radix = 16 是真的生效的(255 → 11111111 / FF,64 → 01000000 / 40)。越界值同样静默:radix 传 0、1、37、-1、-16,结果全部等于十进制输出。
→ 能用且必须信的只有 2 和 16。 要八进制请自己从二进制每三位切一次。toString() 无参与 toString(10) 完全等价。
坑 5:进制输出的补零规则,长度不是你以为的
- toString(16) 固定输出偶数个字符:1 → 01、15 → 0F、4095 → 0FFF、16 → 10。
- toString(2) 固定补齐到 8 的倍数:5 → 00000101、4 → 00000100、65535 → 16 位、256 → 16 位。
所以 Len(lo.toString(2)) 不能当作有效位数来算,做掩码提取前必须自己剥前导零。
toString(16) 还有一个必须知道的细节:它返回大写(255 → FF,26 → 1A)。要小写请自己 Lower(),别指望有开关参数。
坑 6:二进制输出会丢掉负号
- -64 的 toString() = -64
- -64 的 toString(16) = -40 <- 十六进制保留负号
- -64 的 toString(2) = 01000000 <- 符号没了
复制代码
十六进制保留负号(-FF、-03E8 都一样带负号),唯独二进制不带。对负数做 toString(2) 等于取绝对值的补码展示,务必自己处理符号。
坑 7:Rand 返回的是十六进制串,长度向上取偶
最容易误用的一条。Rand(8) 返回 926F9568——这是十六进制,不是十进制数。它只是恰好每一位都落在 0-9A-F 范围内,实际是随机十六进制串(大写)。
长度不是参数值本身,而是「按十六进制字符数理解,奇数向上取偶」:
- Rand(4) = 99AD len=4
- Rand(8) = 8623B74B len=8
- Rand(1) = 0B len=2 <- 奇数 1 向上取偶给 2 位
- Rand(3) = 0C67 len=4 <- 奇数 3 向上取偶给 4 位
- Rand(32) len=32
- Rand(0) = [] len=0
- Rand(-1) = [] len=0 <- 负数与 0 都给空串,不会崩、不会挂
复制代码
要当十进制随机数用,得自己先做十六进制转十进制再取值;更顺手的用法是把它当「随机十六进制 token」(生成 trace id、临时口令、文件名随机后缀),这才是它的设计用途。
它不可复现:同一实例连续两次 Rand(12) 结果不同,也没有任何 seed 参数。想可复现请用原生 Randomize(seed) + Rand(n) 的组合,但那又回到 32768 上限了。
坑 8:FromHex 认 0x 前缀了(行为变更)
旧版本不认:FromHex('0x1A') 给 0,FromHex('0xZZ') 甚至返回 true 并把原值冲成 0——那是个 bug。当前版本修好了:
- FromHex('0x1A') -> true 值=26 <- 前缀被正确跳过
- FromHex('0X1A') -> true 值=26 <- 大小写都认
- FromHex('0x') -> true 值=0 <- 只有前缀没有数字,当成 0
- FromHex('0xZZ') -> false 值保留 <- 非法内容正确报错且不动原值
- FromHex('x1A') -> false <- 前缀不完整,不认
复制代码
另外,FromHex 对奇数位会左补零再解析:'F' → 15、'fff' → 4095、'aBc' → 2748,与 toString(16) 的偶数位补零规则正好对称,往返因此是自洽的。
坑 9(★ 最重要):五个会让整个进程失效的输入
这一类是旧版本没有的——新版本加进来的算术方法,遇到无解输入时不抛异常、不返回错误码,直接把进程拖住或干掉。这五个输入实测全部复现:
| 输入 | 形态 | 现象 | | a.div(0) / a.mod(0)(除数为 0) | 报错退出 | PB10 轨道约 32 秒后进程终止,输出 BIGNUM failed: ...BN_div:div by zero;PB12.5 轨道超过 45 秒不返回 | | a.rshift(-1)(负移位量) | 卡死 | 两条轨道都超过 45 秒不返回,CPU 时间恒定不变 | | modInverse(2,4)(与模数不互素) | 卡死 | 同上 | | modSqrt(2,11)(非二次剩余) | 卡死 | 同上 | | prime(64,false,add,rem)(同余约束无解) | 死循环 | 2 秒采样窗内 CPU 涨了 3.8 秒 ≈ 一个核在常转,永不返回 |
「CPU 恒定不变」意味着它阻塞在一个看不见的模态错误框上——进程没死,但你的界面永远等不到返回。
处置:调用前自己预检。 第六节的 nvo_bi_safe 已经把这几条全部挡在门外(of_safe_div / of_safe_mod / of_safe_modinv / of_safe_modsqrt / of_safe_prime)。在没加预检之前,不要把用户输入直接喂给这五个方法。
坑 10:返回值是独立的新对象,必须自己 destroy
除了 cmp / isZero / isOne / isOdd / toString / toBlob / Rand 这几个返回简单类型的,所有返回 uo_biginteger 的方法都会新建一个对象:
- c1 = a.add(b) // c1 是一个全新的对象,跟 a、b 都没有引用关系
- destroy c1 // 必须自己销毁
复制代码
三个配套结论(都实测过):
- 运算不改源对象:add 之后 a 还是 10、b 还是 3,没有副作用;
- 销毁源对象不影响结果:c = a.add(b) 之后 destroy a / destroy b,c 依然是 13;
- 链式调用会泄漏:a.add(b).add(b) 可用,但中间那个临时对象没人销毁。要链式就得像示例里的 of_take() 那样,取完值立刻 destroy。
坑 11:c3 = c1 是别名,不是拷贝
PowerBuilder 里对象赋值赋的是引用:
- c1 = a.add(b)
- c3 = c1 // c3 和 c1 指向【同一个】对象
- destroy c1 // c3 跟着一起失效!
复制代码
实测读数:销毁 c1 后:IsValid(c1) = false,IsValid(c2) = true,IsValid(c3) = false。要真拷贝,得用 c3 = c1.add(zero) 这种方式造个新对象。
→ 同理,destroy 之后绝不能再调方法(会访问已释放的底层句柄),本对象没有内置保护。
坑 12:prime(0) / prime(-8) 不按位数生成
位数给 0 或负数时,prime() 不再按位数生成,只返回一个很小的值(实测十进制 1 位、十六进制 1 位)。它不报错,你若不检查就会把一个 1 位数当 512 位密钥用。
坑 13:写自己的封装时的四个语法坑
这些是动手扩写时踩出来的,与 uo_biginteger 本身无关,但每个都会浪费半小时:
| 坑 | 现象 | 正确写法 | | 声明写 readonly、实现不写 | 静态检查报「定义缺少声明 / 声明未实现」 | PB 的约定是声明写 readonly,实现处不写(本文第六节的 nvo_bi_safe 就是照这个写的) | | 用 void 当返回类型 | 编译不过 | PowerBuilder 没有 void,不返回值的用 subroutine | | 循环跳出写成 exitloop | C0015: Undefined variable: exitloop | 关键字是 exit;(必须带分号) | | longlong 字面量带 LL 后缀 | C0031: Syntax error | 直接写 9223372036854775807,不要加 LL |
另外两个只在特定场景才踩到的:
- 一个 .sru 里不能有两个 forward prototypes 块——第二块会让导入端把后面的方法当成「未声明」。
- decimal 字面量上限是 18446744073709551615,超了报 C0077: Integer constant out of range。所以本文示例里的大数一律走字符串常量(ls_a = '1234…890'),不走数字字面量。
六、安全外壳:nvo_bi_safe(12 个方法,可直接抄)
把前面所有结论收敛成一个能直接用的封装。它只做三件事:解析前先自己校验、调用前挡掉会让进程失效的参数、进制与大小写规范化。
- $PBExportHeader$nvo_bi_safe.sru
- forward
- global type nvo_bi_safe from nonvisualobject
- end type
- end forward
- global type nvo_bi_safe from nonvisualobject
- end type
- global nvo_bi_safe nvo_bi_safe
- type prototypes
- end prototypes
- type variables
- end variables
- forward prototypes
- public function boolean of_is_dec_string (readonly string as_in)
- public function boolean of_is_hex_string (readonly string as_in)
- public function boolean of_parse_dec (readonly string as_in, ref uo_biginteger arbi)
- public function boolean of_parse_hex (readonly string as_in, ref uo_biginteger arbi)
- public function boolean of_safe_div (readonly uo_biginteger a, readonly uo_biginteger b, ref uo_biginteger ar)
- public function boolean of_safe_mod (readonly uo_biginteger a, readonly uo_biginteger b, ref uo_biginteger ar)
- public function boolean of_safe_modinv (readonly uo_biginteger a, readonly uo_biginteger m, ref uo_biginteger ar)
- public function boolean of_safe_modsqrt (readonly uo_biginteger a, readonly uo_biginteger m, ref uo_biginteger ar)
- public function boolean of_safe_prime (int ai_bits, boolean ab_safe, ref uo_biginteger ar)
- public function string of_to_dec (readonly uo_biginteger abi)
- public function string of_to_hex (readonly uo_biginteger abi, boolean ab_upper)
- public function string of_random_hex (int ai_len)
- end prototypes
- /*====================================================================
- nvo_bi_safe —— uo_biginteger 的安全外壳
- 这一层只做三件事,件件都是实机踩出来的:
- 1) 解析前先自己校验。uo_biginteger 的 FromStr 遇到脏输入不抛异常,
- 而是【在第一个非法字符处停下,把已读到的数字截下来,还返回 true】:
- FromStr('12ab34') -> true 值 12
- FromStr('1 2') -> true 值 1 <-- 静默丢数据,最危险的一条
- 只有【一个数字都没读到】时才返回 false:' 789' / '- 12' / ''。
- 所以「返回值」根本不足以判断输入是否合法,必须先校验。
- 2) 调用前先挡掉【会让进程失效】的参数:除数为 0、模数为 0、
- 与模数不互素求逆、对非二次剩余开模平方根。
- 这几条实测会把整个 PB 进程拖死或直接终止(详见使用说明.txt 第七节)。
- 3) 进制/大小写规范化。原生 toString(16) 返回【大写】且按字节补零,
- 业务里常要统一成小写。
- 两个入口的宽松度刻意不同,别搞混:
- of_is_dec_string / of_is_hex_string 严格判定,【不 Trim】。
- 首尾有空白一律 false。
- of_parse_dec / of_parse_hex 先 Trim,再走严格判定,再解析。
- 所以 ' 100 ' 能解析成功,值正好是 100,
- 而且绝不会出现上面那种静默截断。
- 使用约定(ref 参数的所有权,务必看清):
- · 函数内部发现 arbi 无效 -> 会 create 一个并绑定回你的变量,用完由你 destroy;
- · 函数内部发现 arbi 有效 -> 就地改写这个对象(不新建),不会多出一个泄漏;
- · 校验失败时 -> 完全不碰 arbi,你手上还是上一次的值。
- ====================================================================*/
- /*--------------------------------- 输入校验 ---------------------------------*/
- function boolean of_is_dec_string(string as_in)
- string ls_ch
- long li_i, li_len, li_start
- boolean lb_ok
- li_len = Len(as_in)
- if li_len = 0 then return false
- li_start = 1
- if Left(as_in, 1) = '-' then li_start = 2
- // 只有负号没有数字,不合法
- if li_start > li_len then return false
- lb_ok = true
- for li_i = li_start to li_len
- ls_ch = Mid(as_in, li_i, 1)
- if Pos('0123456789', ls_ch) = 0 then
- lb_ok = false
- exit
- end if
- next
- return lb_ok
- end function
- function boolean of_is_hex_string(string as_in)
- string ls_ch
- long li_i, li_len
- boolean lb_ok
- li_len = Len(as_in)
- if li_len = 0 then return false
- lb_ok = true
- for li_i = 1 to li_len
- ls_ch = Mid(as_in, li_i, 1)
- if Pos('0123456789abcdefABCDEF', ls_ch) = 0 then
- lb_ok = false
- exit
- end if
- next
- return lb_ok
- end function
- /*--------------------------------- 解析 ---------------------------------*/
- function boolean of_parse_dec(string as_in, ref uo_biginteger arbi)
- string ls_c
- // 先 Trim 再严格判定;判定不过就完全不碰 arbi
- ls_c = Trim(as_in)
- if not of_is_dec_string(ls_c) then return false
- if not IsValid(arbi) then arbi = create uo_biginteger
- // 走到这里的字符串必然只有可选负号 + 纯数字,FromStr 不会再截断
- if not arbi.FromStr(ls_c) then return false
- return true
- end function
- function boolean of_parse_hex(string as_in, ref uo_biginteger arbi)
- string ls_c
- ls_c = Trim(as_in)
- // 容忍 0x / 0X 前缀(新版运行库自己会跳过,这里显式剥一次,保证两版行为一致)
- if Left(ls_c, 2) = '0x' or Left(ls_c, 2) = '0X' then
- ls_c = Mid(ls_c, 3)
- end if
- if not of_is_hex_string(ls_c) then return false
- // 原生 FromHex 对奇数位会左补零后解析('F' -> 15),这里显式补一位,
- // 不去依赖运行库的这个实现细节
- if Mod(Len(ls_c), 2) = 1 then ls_c = '0' + ls_c
- if not IsValid(arbi) then arbi = create uo_biginteger
- if not arbi.FromHex(ls_c) then return false
- return true
- end function
- /*--------------------------------- 危险调用防护 ---------------------------------*/
- function boolean of_safe_div(uo_biginteger a, uo_biginteger b, ref uo_biginteger ar)
- if not IsValid(a) or not IsValid(b) then return false
- // 除数 0 直接挡掉:实测 a.div(0) 会让进程报 OpenSSL BIGNUM 错误后终止
- if b.isZero() then return false
- ar = a.div(b)
- return true
- end function
- function boolean of_safe_mod(uo_biginteger a, uo_biginteger b, ref uo_biginteger ar)
- if not IsValid(a) or not IsValid(b) then return false
- // 模数 0 同样会拖死进程
- if b.isZero() then return false
- ar = a.mod(b)
- return true
- end function
- function boolean of_safe_modinv(uo_biginteger a, uo_biginteger m, ref uo_biginteger ar)
- uo_biginteger lg
- boolean lb_ok
- if not IsValid(a) or not IsValid(m) then return false
- if m.isZero() then return false
- // 实测 modInverse(2,4) 这类不互素的输入会让进程挂死,必须先算 gcd 预检
- lg = a.gcd(m)
- lb_ok = lg.isOne()
- destroy lg
- if not lb_ok then return false
- ar = a.modInverse(m)
- return true
- end function
- function boolean of_safe_modsqrt(uo_biginteger a, uo_biginteger m, ref uo_biginteger ar)
- uo_biginteger lh, ltwo, lt, lr, lone
- boolean lb_ok
- if not IsValid(a) or not IsValid(m) then return false
- // 只对【奇素数】模数成立:欧拉判据 a^((m-1)/2) mod m == 1 才是二次剩余。
- // 注意这是启发式预检,不是证明——模数若是奇数合数,判据可能误判,
- // 因而仍存在挂死风险。本函数请只配素数模数使用。
- if not m.isOdd() then return false
- ltwo = create uo_biginteger
- ltwo.FromNum(2)
- if m.cmp(ltwo) <= 0 then
- destroy ltwo
- return false
- end if
- lr = a.mod(m)
- if lr.isZero() then
- // 此时 ar 与 lr 是【同一个对象】:把所有权交给调用方,由它 destroy,
- // 所以这里绝不能再 destroy lr
- ar = lr
- destroy ltwo
- return true
- end if
- lone = create uo_biginteger
- lone.FromNum(1)
- lh = m.sub(lone)
- lh = lh.div(ltwo)
- lt = a.modExp(lh, m)
- lb_ok = lt.isOne()
- if lb_ok then
- ar = a.modSqrt(m)
- end if
- destroy lt
- destroy lh
- destroy lr
- destroy lone
- destroy ltwo
- return lb_ok
- end function
- function boolean of_safe_prime(int ai_bits, boolean ab_safe, ref uo_biginteger ar)
- uo_biginteger lp
- // 位数给 0 或负数时,原生 prime() 不再按位数生成,只返回一个很小的值(实测十六进制 1 位),
- // 这不是调用方想要的「大素数」,直接挡掉
- if ai_bits < 8 then return false
- if ab_safe and ai_bits < 16 then return false
- lp = create uo_biginteger
- if ab_safe then
- ar = lp.prime(ai_bits, true)
- else
- ar = lp.prime(ai_bits)
- end if
- destroy lp
- return true
- end function
- /*--------------------------------- 输出规范化 ---------------------------------*/
- function string of_to_dec(uo_biginteger abi)
- string ls_r
- ls_r = ''
- if IsValid(abi) then ls_r = abi.toString()
- return ls_r
- end function
- function string of_to_hex(uo_biginteger abi, boolean ab_upper)
- string ls_r
- ls_r = ''
- if IsValid(abi) then
- // 原生 toString(16) 返回大写、且按字节补零(1 -> '01',4095 -> '0FFF')
- ls_r = abi.toString(16)
- if ab_upper then
- ls_r = Upper(ls_r)
- else
- ls_r = Lower(ls_r)
- end if
- end if
- return ls_r
- end function
- function string of_random_hex(int ai_len)
- uo_biginteger lo
- string ls_r
- ls_r = ''
- if ai_len <= 0 then return ls_r
- lo = create uo_biginteger
- // 原样透传 Rand:返回【大写】十六进制,长度是 ai_len 向上取偶数
- // (Rand(3) 给 4 位,Rand(8) 给 8 位;Rand(0) 与 Rand(-1) 都给空串,不会崩)
- ls_r = lo.Rand(ai_len)
- destroy lo
- return ls_r
- end function
复制代码
用法
- nvo_bi_safe lns
- uo_biginteger lbi
- string ls_r
- lns = create nvo_bi_safe
- // 严格入口:' 100 ' 也被 Trim 后正常解析;'12ab' / '1 2' 一律拒绝
- if lns.of_parse_dec(sle_input.Text, lbi) then
- ls_r = '解析成功:' + lns.of_to_dec(lbi)
- else
- ls_r = '输入含非法字符,已拒绝'
- end if
- // 危险调用一律走安全口,不要直接 a.div(b)
- if lns.of_safe_div(lbi, lbi, lbi) then
- ls_r = ls_r + ' 除法的结果长度 ' + String(Len(lns.of_to_dec(lbi)))
- end if
- destroy lbi
- destroy lns
- MessageBox('大整数解析结果', ls_r)
复制代码
封装的方法一览:
| 方法 | 作用 | | of_is_dec_string(as_in) | 严格判十进制串(不 Trim,首尾空白一律 false) | | of_is_hex_string(as_in) | 严格判十六进制串(同上) | | of_parse_dec(as_in, ref arbi) | 先 Trim 再严格判定再解析;失败不碰 arbi | | of_parse_hex(as_in, ref arbi) | 同上,并自动剥 0x、奇数位自动补零 | | of_safe_div(a, b, ref ar) | 除数为 0 → 返回 false,不调用原生 div | | of_safe_mod(a, b, ref ar) | 模数为 0 → 返回 false | | of_safe_modinv(a, m, ref ar) | 先 gcd 预检互素,不互素直接拒绝 | | of_safe_modsqrt(a, m, ref ar) | 先欧拉判据预检二次剩余(只配奇素数模数) | | of_safe_prime(bits, safe, ref ar) | bits < 8(或安全素数 bits < 16)直接拒绝 | | of_to_dec(abi) | 安全读十进制,无效对象返回空串 | | of_to_hex(abi, upper) | 安全读十六进制,可控大小写 | | of_random_hex(len) | 随机十六进制串,len <= 0 返回空串 |
ref 参数的所有权约定(写这类封装最容易泄漏的地方):
- 函数内部发现 arbi 无效 → 会 create 一个并绑定回你的变量,用完由你 destroy;
- 函数内部发现 arbi 有效 → 就地改写这个对象(不新建),不会多出一个泄漏;
- 校验失败时完全不碰 arbi,你手上还是上一次的值——失败分支必须自己决定怎么办。
七、合法输入判定规则(实测归纳)
综合上面所有边界数据,一张速查表:
| 规则 | 内容 | | 允许 | 纯数字 0-9 | | 允许 | 前导 -(负号),如 -9223372036854775809 实测正确 | | 允许 | 前导零,值正常(000000123 → 123,长度归一为 3) | | 拒绝 | 前导 +(+456 → false) | | 拒绝 | 首尾空白(需自己 Trim) | | 截断 | 小数点(12.34 → 12) | | 截断 | 数字中间的空白(1 2 → 1,返回值仍为 true) | | 拒绝 | 任何字母、下划线、中文 | | 拒绝 | 空串、只有负号 |
长度没有上限:实测 120 位十进制数完整进出,Len(toString()) 返回 120;600 位乘 600 位给 1199 位。
八、PB12.5 差异
与 PB10 行为一致,零差异。
本轮把上面 29 个方法名 / 35 条签名逐条在两条轨道上跑了一遍(含约 30 个危险边界输入),读数逐字节比对一致。差异只出现在本来就随机的返回上(Rand(n) 的随机串、prime() 的素数本身),这属于随机数性质,不是版本差异。
口径说明:本文按 PB10 基准 · PB12.5 实测 撰写——代码只用 PB 8 就有的语法(PB10 编译 0 错误、对象齐全),PB 侧行为以 PB 12.5 的实测读数为准;同时 PB10 轨道也做了运行级实测,两条轨道的读数逐字节一致。两版的「编译 + 运行」都做了,没有任何一项是「只编译没运行」。
九、实机验证情况
测试规模:交付包 3 个对象(nvo_bi_demo 10 个方法、nvo_bi_safe 12 个方法、nvo_bi_selftest 2 个方法),验证时「一类一方法」拆分,nvo_bi_demo 的 10 个方法 + nvo_bi_selftest 的 2 个方法各用独立测试脚本单独运行(共 12 次/轨道),避免崩溃类问题互相带偏;nvo_bi_safe 由 of_usage 与 145 条断言的自检对象覆盖。
四项全绿(PB10 与 PB12.5 两条轨道各自独立完成):
| 项目 | PB10 基线 | PB12.5 实测 | | 对象导入 | 0 错(3 个对象全部导入成功) | 0 错 | | 全量编译 | 0 错误 | 0 错误 | | 对象落库校验 | 3 个对象齐全 | 3 个对象齐全 | | PBVM 运行 | 10 + 2 = 12 次运行全 PASS | 12 次运行全 PASS | | 双轨读数比对 | 屏蔽随机行后差异 = 0 | 同 | | 自检断言 | — | 145 项全部通过 | | 静态检查 | — | 0 错误 | | 源码编码检查 | 全部合格(GBK / CRLF / 无 BOM) | 同 |
文章示例代码自验证:第三节的 nvo_bi_demo 与第六节的 nvo_bi_safe,是把将出现在文章里的原文照搬进交付包重新编译并运行的,十个方法 + 一个自检方法在两条轨道上全部通过,输出与文中标注逐字节一致。文中没有任何「未实测、仅静态核对」的段落。
安全外壳的边界实证:nvo_bi_safe 的 12 个方法全部被测到,含「拒绝脏输入且不覆盖旧值」「挡住 FromStr('1 2') 的静默截断」「0x1a 解析成 26」「奇数位自动补零」等断言。
十、与相近方案对比
| 方案 | 上限 | 能否算 | 依赖 | 适用 | | longlong | 9.22×10^18 | 能 | 无 | 绝大多数业务够用,优先用 | | decimal | 1.84×10^19(仅字面量) | 不适合 | 无 | 金额定点 | | uo_biginteger | 实测 600 位无压力 | 能(四则 / 幂 / 模 / 数论齐全) | PbIdea.dll | 超长整数的存取、转换与任意精度运算 | | 自己写字符串大数运算 | 任意 | 能 | 无 | 已经没必要了——除非你要的操作它没提供 |
选型建议:先老老实实用 longlong。只要有下面任一条,就换 uo_biginteger:
- 存/转超长整数(雪花 ID、微信号、二维码内容、大数哈希的十六进制串);
- 需要十进制 ↔ 十六进制 ↔ 二进制互转;
- 需要任意精度的加减乘除、幂、取模;
- 需要 RSA 那一类算法的基础件:modExp(模幂)、modInverse(模逆)、prime(bits)(大素数)、gcd。
能力边界更新:旧文写「它只有 5 个方法、没有任何算术运算、本质是高精度容器不是计算器」——这句已经作废。当前版本是完整的任意精度计算器,Java BigInteger 的主力功能它基本都有(少的是 and / or / xor 这类位运算,以及 modPow 之外的组合算法)。
十一、常见错误速查
| 现象 | 根因 | 处置 | | Unresolvable external | 缺 PbIdea.dll 运行库 | 检查 PBIDEA 是否安装、库是否在工程 liblist 里 | | 解析出 12 而不是报错,还返回 true | 静默截断到第一个非法字符 | 自己写逐字符校验,用包里的 of_parse_dec | | '1 2' 变成 1 | 中间空白只截断不报错 | 同上(of_is_dec_string 会把空格判掉) | | 解析失败后拿到上次的值 | 失败不清零 | 失败分支必须显式重置 | | FromNum(-1) 得到 4294967295 | 重载按实参位宽挑,负数按无符号解释 | 负数用 FromStr('-1') | | div(0) / mod(0) 后进程没了 | 底层 BN_div 除零 | 调用前 isZero() 预检 | | rshift(-1) / modInverse(2,4) / modSqrt(2,11) 卡住 | 底层无解,弹不可见模态框 | 调用前预检(见 of_safe_*) | | prime(64,false,add,rem) 一个核转不动 | 同余约束无解 → 死循环 | 别传无解约束 | | toString(8) 返回十进制 | 只支持 2 和 16 | 八进制从二进制每三位切 | | 十六进制串长度是偶数 / 返回大写 | 补零对齐 + 固定大写输出 | 提取前剥零;要小写自己 Lower() | | 二进制串首字节是 0 | 补齐到 8 的倍数 | 同上 | | 负数 toString(2) 没负号 | 二进制不带符号 | 符号自己处理 | | Rand(3) 给你 4 位 | 长度向上取偶 | 按实际长度用,别假设等于参数 | | 内存一路涨 | 运算返回值是独立对象,没 destroy | 每个返回值都要 destroy | | destroy c1 之后 c3 也不能用了 | c3 = c1 是别名不是拷贝 | 要拷贝就重新造对象 | | 编译报 C0015: exitloop | PowerScript 无此关键字 | 用 exit;(带分号) | | 编译报 C0031: Syntax error | 给 longlong 字面量加了 LL | 去掉后缀 | | 编译报 C0077: Integer constant out of range | decimal 字面量超 1.84×10^19 | 大数走字符串常量 |
十二、小结
uo_biginteger 补的是 PowerScript 最硬的一块短板——超过 longlong 的整数表示。它早就不只是容器了:29 个对外方法(35 条签名)覆盖四则、幂、平方、模运算、模幂模逆模平方根、gcd、素数生成、移位、比较判定。
用好它记住五件事:
- FromStr 的返回值只代表「读到过数字」,'1 2' → 1 也报 true——合法性必须自己校验;
- 解析失败保留原值,不清零,复用实例时必须显式重置;
- FromNum 拿不到负数,负数一律走 FromStr;
- 五个输入会让整个进程失效:div(0) / mod(0) / rshift(负数) / 非互素求模逆 / 非二次剩余开模平方根——调用前必须预检;
- 返回值是独立的新对象,每个都要 destroy;c3 = c1 只是别名,不是拷贝。
配合第六节的 nvo_bi_safe 封装,可以在项目里安全地用起来。完整可运行对象、测试脚本与实测证据见回帖附件。
|