Visual Prolog 7 - PDC Download site

Visual Prolog 7.2 语 言 参 考 手 册
本 文 档 描 述 Visual Prolog 编 程 语 言 的 语 法 与 语 义 。
Visual Prolog 是 面 向 对 象 的 强 类 型 编 程 语 言 , 它 的 基 础 是 逻 辑 编 程 语 言 Prolog。
一 个 Visual Prolog 程 序 是 由 一 个 目 标 及 一 些 :
• interfaces( 接 口 )
• Class declarations( 类 声 明 ) 及
• Class implementations( 类 实 现 )
构 成 的 , 上 述 这 些 部 件 包 含 有 下 面 这 些 Prolog 实 体 的 声 明 与 定 义 :
• Domains ( 域 )
• Constants ( 常 数 )
• Predicates ( 谓 词 )
• Properties ( 属 性 )
• Fact databases ( 事 实 数 据 库 )。
Visual Prolog 的 实 际 代 码 是 clauses( 子 句 ), 它 在 类 实 现 当 中 , 谓 词 是 由 它 实 现 的 。
基 本 概 念
Types and Subtypes ( 类 型 和 子 类 型 )
Types
Visual Prolog 的 类 型 分 为 对 象 类 型 与 值 类 型 。 对 象 是 易 变 的 而 值 是 非 易 变 的 。
对 象 的 类 型 是 由 interface( 接 口 ) 定 义 的 。
值 的 类 型 包 括 numerical types( 数 值 类 型 )、strings( 串 )、character types( 字 符 类 型 ) 和 compound
domains( 复 合 域 )。 复 合 域 又 称 为 代 数 数 据 类 型 , 它 的 简 单 形 式 有 结 构 及 枚 举 类 型 , 而 其 复 杂 形 式 会 呈
现 为 树 的 结 构 。
Subtypes
类 型 是 由 子 类 型 体 系 构 成 的 。 子 类 型 用 来 引 入 多 态 包 容 性 : 任 何 期 望 某 类 型 值 的 语 境 也 能 很 好 地 接 受
任 意 子 类 型 的 值 。 也 可 以 反 过 来 说 , 某 个 类 型 的 值 在 需 要 的 时 候 可 以 自 动 地 转 换 成 任 意 父 类 型 加 以 应 用 ,
而 不 需 要 显 式 的 类 型 转 换 。
子 类 型 可 以 由 除 代 数 数 据 类 型 而 外 的 任 何 值 类 型 派 生 出 来 。 代 数 数 据 类 型 派 生 出 的 类 型 是 异 名 类 型 而
不 是 子 类 型 , 也 就 是 说 , 它 们 是 相 同 的 类 型 而 非 子 类 型 。
子 类 型 和 子 集 在 概 念 上 很 相 近 , 但 是 一 定 要 注 意 , 即 便 一 个 类 型 “ 算 术 上 ” 是 另 一 个 类 型 的 子 集 它 也
末 必 就 是 一 个 子 类 型 。 只 有 声 明 了 之 后 一 个 类 型 才 可 以 是 另 一 个 类 型 的 子 类 型 。
domains
t1 = [1..17].
t2 = [5..13].
t3 = t1 [5..13].
1

t1 是 整 数 类 型 , 它 的 值 从 1 到 17( 含 )。 而 t2 的 值 是 5 到 13, 所 以 ,t2 是 t1 的 一 个 子 集 , 但 它
并 非 t1 的 一 个 子 类 型 。 另 一 方 面 ,t3( 它 也 含 有 与 t2 一 样 的 值 ) 则 是 t1 的 一 个 子 类 型 , 因 为 声 明 如 此 。
本 语 言 中 有 几 个 隐 含 的 子 类 型 关 系 , 但 一 般 而 言 子 类 型 关 系 都 必 须 在 类 型 定 义 中 显 式 地 说 明 。
对 象 类 型 也 是 由 子 类 型 体 系 构 成 的 , 根 是 预 定 义 的 对 象 类 型 Object, 也 就 是 说 任 意 对 象 类 型 都 是
Object 的 子 类 型 。 对 象 子 类 型 的 定 义 是 通 过 声 明 说 一 个 接 口 支 持 另 一 个 而 实 现 的 。 如 果 一 个 对 象 具 有 支
持 某 个 其 它 接 口 的 接 口 / 对 象 , 那 么 该 对 象 就 有 了 那 个 类 型 , 可 以 无 冲 突 地 当 作 那 个 对 象 来 使 用 。
参 看 :Universal and Root Types( 通 用 类 型 和 根 类 型 )
对 象 系 统
外 视 图
这 一 节 的 描 述 不 是 对 类 的 一 般 性 的 介 绍 , 而 是 对 Visual Prolog 中 类 的 概 念 说 明 , 希 望 读 者 已 经 熟 悉
通 常 的 类 概 念 。 描 述 完 全 是 纯 概 念 意 义 上 的 , 不 涉 及 语 法 、 实 现 等 , 也 不 考 虑 操 作 或 编 程 方 面 的 问 题 。 尽
管 引 入 类 、 对 象 的 主 要 原 因 是 程 序 本 质 上 的 要 求 , 但 只 描 述 基 本 观 念 而 不 去 考 虑 程 序 上 的 原 因 还 是 很 有 价
值 的 。
Visual Prolog 中 类 的 概 念 是 以 如 下 三 个 语 义 实 体 为 基 础 的 :
• objects
• interfaces
• classes
Object
一 个 对 象 , 就 是 一 套 命 名 了 的 对 象 成 员 谓 词 及 一 套 支 持 的 接 口 。
其 实 对 象 也 有 状 态 , 但 这 个 状 态 只 能 通 过 成 员 谓 词 才 能 改 变 和 观 察 。 我 们 称 之 为 状 态 封 装 在 对 象 中 。
这 里 的 封 装 , 意 味 着 对 象 有 隐 藏 其 内 部 数 据 和 方 法 的 能 力 , 使 对 对 象 的 访 问 受 控 。 封 装 和 模 块 化 的 重
要 性 是 众 所 周 知 的 。 封 装 有 助 于 构 建 更 加 结 构 化 和 易 读 的 程 序 , 因 为 对 象 可 以 看 作 为 一 个 黑 盒 子 。 要 解 一
个 复 杂 的 问 题 , 先 找 出 可 以 下 断 言 和 描 述 的 一 部 分 , 把 它 封 装 在 一 个 对 象 里 , 构 造 一 个 接 口 , 接 着 再 往 下 ,
直 到 声 明 了 所 有 子 问 题 。 封 装 了 问 题 对 象 后 , 只 要 保 证 它 们 工 作 正 常 , 就 可 以 从 对 象 中 抽 取 数 据 。
Interface
接 口 是 一 个 对 象 类 型 , 它 有 一 个 名 字 并 定 义 一 组 命 名 了 的 对 象 谓 词 。
接 口 按 支 持 体 系 构 建 ( 这 个 结 构 是 半 格 状 的 , 根 是 interface 对 象 )。 如 果 一 个 对 象 具 有 一 个 接 口 表 示
的 类 型 , 它 也 就 有 所 有 支 持 接 口 的 类 型 。 因 此 , 支 持 体 系 也 是 类 型 体 系 。 一 个 接 口 是 所 有 它 支 持 的 接 口 的
一 个 子 类 型 。 也 可 以 说 对 象 支 持 接 口 , 如 果 接 口 名 为 X, 我 们 可 以 说 这 个 对 象 是 一 个 X, 或 是 一 个 X 对 象 。
Class
类 是 命 名 了 的 对 象 工 厂 , 它 创 建 相 应 于 某 个 接 口 的 对 象 。 任 何 对 象 都 是 由 类 创 建 的 , 如 果 一 个 类 是 用
接 口 C 构 造 对 象 的 , 那 么 这 个 类 创 建 的 所 有 对 象 都 叫 C 对 象 。
由 某 个 类 构 造 的 所 有 对 象 共 享 相 同 的 对 象 成 员 谓 词 定 义 , 但 每 个 对 象 有 其 自 己 的 状 态 。 因 此 , 对 象 成
员 谓 词 实 际 上 是 类 的 一 部 分 , 而 对 象 的 状 态 则 是 对 象 本 身 的 一 部 分 。
2

类 还 含 有 被 称 为 类 成 员 和 类 状 态 的 另 一 组 命 名 了 的 谓 词 和 封 装 的 状 态 。 类 成 员 与 类 状 态 存 在 于 各 个 类
中 , 而 对 象 成 员 与 对 象 状 态 存 在 于 各 个 对 象 中 。 类 成 员 和 对 象 成 员 都 可 以 访 问 类 状 态 。
注 意 ! 一 个 类 所 定 义 的 对 象 成 员 谓 词 组 是 在 该 类 的 接 口 中 声 明 的 谓 词 联 合 体 , 更 明 确 地 说 , 如 果 在 不
同 的 两 个 接 口 中 声 明 了 同 一 个 谓 词 , 类 只 会 提 供 该 谓 词 的 一 个 定 义 。 因 此 , 类 只 是 检 测 实 际 意 义 , 也 就 是
说 只 是 看 这 两 个 继 承 谓 词 的 预 期 语 义 是 否 一 致 。
要 注 意 , 接 口 支 持 必 须 明 确 地 指 定 。 某 个 类 提 供 相 应 某 个 接 口 的 谓 词 并 不 意 味 着 这 个 类 支 持 这 个 接 口 。
Module( 模 块 )
事 实 上 , 类 不 必 非 得 能 产 生 对 象 。 不 产 生 对 象 的 类 只 有 类 成 员 和 类 状 态 , 而 这 样 的 类 当 模 块 看 待 更 恰
当 。
Identity( 标 识 )
每 个 对 象 都 是 唯 一 的 : 对 象 具 有 可 变 的 状 态 , 而 且 对 象 的 状 态 只 能 通 过 它 们 的 成 员 谓 词 观 察 到 , 因 而
对 象 只 与 它 自 己 是 同 一 的 。 这 就 是 说 , 即 使 有 两 个 对 象 的 状 态 是 一 样 的 , 它 们 也 不 是 同 一 的 , 因 为 我 们 可
以 改 变 一 个 对 象 的 状 态 而 不 影 响 另 一 个 对 象 的 状 态 。
我 们 无 法 直 接 访 问 一 个 对 象 的 状 态 , 而 总 是 通 过 对 象 的 引 用 来 访 问 对 象 的 状 态 。 尽 管 对 象 仅 与 自 身 是
同 一 的 , 但 可 以 有 许 多 对 同 一 对 象 的 引 用 。 因 此 , 一 个 对 象 可 以 由 许 多 不 同 的 引 用 来 访 问 。
类 和 接 口 也 是 唯 一 的 , 用 它 们 的 名 字 来 标 识 。 在 一 个 程 序 中 , 两 个 接 口 或 两 个 类 不 能 用 相 同 的 名 字 ,
只 有 当 一 个 类 构 造 一 个 接 口 的 对 象 时 , 这 一 个 类 和 这 一 个 接 口 才 可 以 用 相 同 的 名 字 。
总 之 , 结 构 的 相 同 并 不 意 味 着 同 一 , 对 对 象 、 类 和 接 口 都 是 这 样 的 。
内 视 图
前 一 节 描 述 了 对 象 、 类 及 接 口 的 外 在 表 现 , 这 一 节 描 述 内 部 情 况 。 这 些 内 部 问 题 更 具 程 序 特 性 , 可 以
把 它 们 分 成 声 明 与 实 现 两 个 部 分 来 考 虑 。
从 程 序 的 观 点 , 类 是 核 心 : 代 码 是 包 含 在 类 中 的 。
接 口 主 要 地 是 静 态 特 性 , 实 事 上 , 接 口 只 存 在 于 一 个 程 序 的 文 本 表 示 中 , 运 行 时 没 有 一 个 ( 直 接 的 )
代 表 接 口 的 东 西 。 而 另 一 方 面 , 对 象 主 要 地 是 动 态 特 性 , 它 在 程 序 中 并 不 是 直 接 可 见 的 , 直 到 程 序 实 际 运
行 时 它 才 存 在 。
类 由 声 明 与 实 现 构 成 。 声 明 通 告 了 类 的 public( 公 共 ) 可 访 问 的 部 分 及 它 生 成 的 对 象 。 而 实 现 则 defines
( 定 义 ) 在 类 声 明 中 声 明 了 的 实 体 。 谓 词 的 基 本 实 现 当 然 是 子 句 , 但 谓 词 也 可 以 由 继 承 定 义 , 或 是 由 外
部 的 库 来 确 定 。
在 Visual Prolog 中 , 类 的 声 明 纯 粹 是 说 明 , 它 只 是 陈 述 有 哪 些 实 体 可 以 访 问 , 但 并 不 涉 及 如 何 访 问 及
实 体 在 哪 儿 实 现 。
类 实 现 可 以 声 明 和 定 义 更 多 的 实 体 ( 域 、 谓 词 等 ), 它 们 只 在 类 的 内 部 是 可 见 的 , 也 就 是 说 , 它 们 是
私 有 的 (private)。
对 象 的 状 态 是 存 储 在 对 象 本 身 的 事 实 中 的 , 这 些 事 实 是 在 类 的 实 现 中 普 通 事 实 ( 数 据 库 ) 段 中 声 明 的 。
事 实 对 每 个 对 象 都 是 局 部 的 ( 就 像 其 它 的 对 象 实 体 ), 而 类 事 实 则 由 同 类 的 所 有 对 象 共 享 。
事 实 只 能 在 类 的 实 现 中 声 明 , 因 而 也 就 不 能 从 类 的 外 部 ( 直 接 ) 访 问 。
类 的 实 现 也 可 以 声 明 它 支 持 除 类 声 明 中 提 到 的 以 外 的 其 它 接 口 。 但 这 个 消 息 也 仅 只 在 实 现 本 身 内 部 是
可 见 的 , 因 而 还 是 私 有 的 。
3

代 码 继 承
Visual Prolog 的 代 码 继 承 只 能 在 类 的 实 现 中 进 行 , 可 以 有 多 重 继 承 。 通 过 在 类 实 现 中 特 殊 的 inherits
段 标 记 一 个 类 来 得 到 该 类 的 继 承 。 被 继 承 的 类 称 为 父 类 (parent classes) 或 超 类 (super-classes), 子
类 (Child class) 或 亚 类 (sub-class) 与 父 类 是 成 对 的 , 我 们 也 说 子 类 继 承 自 父 类 。 子 类 只 能 通 过 父 类
的 公 共 接 口 访 问 它 的 父 类 , 也 就 是 说 它 与 其 它 使 用 该 父 类 的 类 一 样 , 并 没 有 接 受 额 外 的 特 权 。
Scoping & Visibility( 范 围 与 可 见 性 )
名 称 类 别
Visual Prolog 中 的 所 有 名 称 ( 标 识 ) 按 语 法 分 成 两 个 大 组 :
• 常 量 名 称 ( 以 小 写 字 母 开 头 )
• 变 量 名 称 ( 以 大 字 字 母 或 下 划 线 开 头 )
常 量 名 称 又 分 为 如 下 几 类 :
• 类 型 名 ( 如 域 和 接 口 );
• 域 载 体 ( 如 类 和 接 口 );
• 不 带 圆 括 号 的 名 称 ( 如 常 数 、 非 函 数 类 型 的 事 实 变 量 及 零 函 子 );
• 返 回 值 的 元 维 为 N 的 名 称 ( 如 函 数 、 函 子 和 函 数 类 型 的 事 实 变 量 );
• 不 返 回 值 的 元 维 为 N 的 名 称 ( 如 谓 词 、 事 实 及 谓 词 类 型 的 事 实 变 量 )。
Visual Prolog 要 求 在 声 明 阶 段 名 称 就 不 能 有 冲 突 , 因 为 在 使 用 阶 段 它 就 不 可 能 解 决 这 样 的 冲 突 了 。 只
有 在 同 一 范 围 的 名 称 才 可 能 会 有 冲 突 , 而 不 同 的 范 围 因 为 范 围 的 限 定 可 以 解 决 冲 突 。 某 个 类 别 的 名 称 决 不
会 与 另 一 个 类 别 中 的 名 称 有 冲 突 , 但 是 我 们 就 要 看 到 在 单 个 声 明 中 可 以 把 一 个 名 字 放 在 几 个 类 别 中 。
Packages( 包 )
包 , 是 Visual Prolog 中 一 般 公 认 的 代 码 组 织 基 本 单 位 , 我 们 用 包 来 组 建 东 西 。 包 的 使 用 , 保 证 了 不 同
工 程 间 构 造 原 则 的 一 致 性 。 包 为 工 程 间 构 造 和 共 享 代 码 的 工 具 确 定 了 标 准 。
包 是 成 组 的 接 口 和 类 的 集 合 体 , 它 为 所 有 这 些 接 口 和 类 提 供 了 某 个 共 同 的 名 称 。 包 里 每 个 接 口 的 各 个
声 明 或 实 现 是 放 在 独 立 的 文 件 中 的 , 这 些 文 件 的 文 件 名 与 在 该 文 件 中 声 明 的 或 实 现 的 类 或 接 口 的 名 称 相 对
应 。 所 有 包 文 件 存 放 在 一 个 独 立 的 包 目 录 下 ( 如 果 一 个 包 有 子 包 , 则 子 包 会 放 在 包 目 录 的 子 目 录 中 )。
包 的 概 念 , 用 来 把 一 些 相 关 的 接 口 与 类 组 合 在 一 起 , 它 起 了 一 个 类 库 角 色 的 作 用 。 在 程 序 中 包 可 以 把
使 用 的 接 口 和 类 集 中 起 来 , 而 不 是 直 接 把 这 些 接 口 和 类 放 在 程 序 里 。
在 帮 助 文 件 中 的 VDE 部 分 , 描 述 了 Visual Prolog 中 可 用 的 包 结 构 及 如 何 将 包 放 到 工 程 中 。( 参 看
Creating a Package in Creating New Project Items)
可 见 性 、 屏 蔽 及 限 定 符
大 多 数 范 围 规 则 上 面 都 说 了 , 这 一 节 最 后 完 善 整 个 内 容 。
接 口 定 义 , 类 声 明 以 及 类 实 现 都 是 范 围 ( 范 围 不 能 嵌 套 )。 实 现 ( 悄 悄 地 ) 扩 展 了 相 应 的 类 声 明 的 范
围 。 在 一 个 范 围 内 , 可 见 性 到 处 都 是 一 样 的 。 这 尤 其 是 指 在 一 个 范 围 内 不 论 某 个 东 西 是 在 哪 儿 声 明 的 , 它
在 整 个 范 围 内 都 是 可 见 的 。
来 自 被 支 持 的 接 口 和 超 类 的 公 用 名 称 , 如 果 它 出 自 何 处 不 模 糊 , 在 一 个 范 围 内 是 直 接 可 用 的 ( 也 就 是
不 需 要 限 定 符 )。 谓 词 调 用 中 的 模 糊 问 题 , 可 以 用 带 类 名 的 谓 词 名 的 修 饰 方 法 ( 如 cc::p) 来 解 决 。
4

这 样 的 限 定 符 , 也 用 于 修 饰 当 前 对 象 对 超 类 的 对 象 成 员 谓 词 的 调 用 中 。
Visual Prolog 有 两 个 屏 蔽 层 级 :
• 局 部 的
• 超 类 及 开 放 范 围 (opened scopes)
开 放 范 围 的 情 况 与 超 类 的 一 样 , 所 以 我 们 下 面 只 说 超 类 。
层 级 的 意 思 是 , 局 部 声 明 会 屏 蔽 超 类 声 明 , 但 两 个 超 类 间 不 会 有 屏 蔽 , 所 有 超 类 都 有 同 样 的 优 选 权 。
如 果 两 个 或 更 多 个 超 类 包 含 有 冲 突 的 声 明 , 那 这 些 声 明 就 只 能 通 过 限 定 符 来 访 问 。
例 设 有 接 口 aa 及 类 aa_class:
interface aa
predicates
p1 : () procedure ().
p2 : () procedure ().
p3 : () procedure ().
end interface
class aa_class : aa
end class
再 假 设 有 bb_class 类 :
class bb_class
predicates
p3 : () procedure ().
p4 : () procedure ().
end class bb_class
在 上 述 情 况 下 , 来 看 看 类 cc_class 的 实 现 :
implement cc_class inherits aa_class
open bb_class
predicates
p2 : () procedure ().
p5 : () procedure ().
clauses
new() :-
p1(),
% aa_class::p1
p2(),
% cc::p2 ( 屏 蔽 了 aa_class::p2)
aa_class::p2(), % aa_class::p2
p3(),
% 错 误 的 模 糊 调 用 : 可 以 是 aa_class::p3 或 bb_class::p3
aa_class::p3(), % aa_class::p3
bb_class::p3(), % bb_class::p3
p4(),
% bb_class::p4
p5(),
% cc::p5
end implement cc_class
词 汇 元 素
源 文 件 要 经 过 Visual Prolog 编 译 器 的 编 译 。 一 个 源 文 件 可 以 包 含 其 它 的 源 文 件 , 从 概 念 上 来 讲 插 入 的
这 些 文 件 与 包 含 它 们 的 文 件 组 成 了 一 个 编 译 单 元 。 一 个 编 译 单 元 的 编 译 要 经 过 两 个 概 念 上 的 步 骤 :
• 首 先 , 输 入 被 转 换 成 记 号 的 序 列 ;
5

• 其 次 , 对 这 些 记 号 进 行 语 法 分 析 并 转 换 成 可 执 行 代 码 。
对 程 序 的 词 汇 分 析 把 编 译 单 元 CompilationUnit 再 细 分 成 输 入 元 素 InputElement 的 表 :
CompilationUnit:
InputElement-list
InputElement:
Comment
WhiteSpace
Token
只 有 记 号 (Token) 对 后 面 的 语 法 分 析 有 意 义 。
注 释
Visual Prolog 的 注 释 可 以 按 以 下 方 法 编 写 :
• 以 /*( 斜 杠 , 星 ) 开 头 , 后 面 是 任 意 字 符 序 列 ( 包 括 换 行 符 ), 结 束 用 */( 星 , 斜 杠 )。 这 样 的 注
释 可 以 有 多 行 , 可 以 嵌 套 。
• 以 %( 百 分 号 ) 开 头 , 后 面 是 任 意 字 符 序 列 。 这 样 的 注 释 在 一 行 的 结 尾 就 结 束 了 , 因 此 通 常 称 之
为 单 行 注 释 。
看 一 下 下 面 的 注 释 :
/* 注 释 1 的 开 头
% 嵌 套 了 注 释 2 */ 这 个 标 记 不 会 结 束 多 行 注 释
因 为 它 插 入 了 一 个 单 行 注 释
这 个 才 是 注 释 1 实 际 结 束 的 标 记 */
空 白
WhiteSpace:
Space
Tab
NewLine
这 里 的 Space 是 空 格 字 符 ,Tab 是 制 表 字 符 而 NewLine 是 换 行 字 符 。
Tokens( 记 号 )
Token:
Identifier( 标 识 )
Keyword( 关 键 字 )
Punctuator( 标 点 )
Operator( 操 作 符 )
Literal( 文 字 )
标 识
Identifier:
LowercaseIdentifier( 小 写 标 识 )
UppercaseIdentifier( 大 写 标 识 )
AnonymousIdentifier( 匿 名 标 识 )
6

Ellipsis( 省 略 号 )
小 写 标 识 是 一 个 以 小 写 字 母 开 头 的 字 母 、 数 字 及 下 划 线 组 成 的 序 列 ; 大 写 标 识 是 一 个 以 大 写 字 母 或 下
划 线 开 头 的 字 母 、 数 字 及 下 划 线 组 成 的 序 列 。 匿 名 标 识 是 一 个 下 划 线 :“_”; 而 省 略 号 则 是 三 个 句 点 :“…”。
关 键 字
关 键 字 分 为 主 关 键 字 和 次 关 键 字 两 类 , 但 这 只 是 表 面 上 的 分 法 , 主 次 关 键 字 并 没 有 形 式 上 的 差 异 。 不
过 我 们 下 面 还 是 用 不 同 颜 色 区 分 它 们 :
Keyword :
MajorKeyword( 主 关 键 字 )
MinorKeyword( 次 关 键 字 )
MajorKeyword : one of
class clauses constants constructors
delegate domains
end
facts
goal guards
implement inherits interface
monitor
namespace
open
predicates
properties
resolve
supports
MinorKeyword : one of
align and anyflow as
bitsize
catch
determ digits div do
else elseif erroneous externally
failure finally foreach from
if
language
mod multi
nondeterm
or
procedure
quot
rem
single
then to try
所 有 关 键 字 除 了 as 和 language 都 是 保 留 字 。
注 意 ,div 和 mod 也 是 保 留 字 , 但 它 们 是 归 类 在 操 作 符 中 的 。
guards 和 monitor 在 语 言 中 并 没 有 使 用 , 但 它 们 是 保 留 给 将 来 使 用 的 。
标 点 符 号
7

标 点 符 号 在 Visual Prolog 中 对 编 译 器 既 有 语 法 意 义 又 有 语 义 意 义 , 但 它 们 本 身 不 是 能 产 生 值 的 操 作 运
算 。 有 的 标 点 符 号 , 单 独 或 组 合 起 来 也 可 以 是 Visual Prolog 的 操 作 符 。
操 作 符
标 点 符 号 有 :
PunctuationMarks: one of
; ! , . # [ ] | ( ) :- : ::
操 作 符 规 定 了 对 相 关 的 操 作 数 要 进 行 的 运 算 操 作 。
Operators: one of
+ - / * ^ = div mod quot rem
< > >< = :=
所 有 操 作 符 都 是 二 元 的 , 但 - 和 + 也 可 以 是 一 元 的 操 作 符 。
div 和 mod 是 保 留 字 。
文 字
整 数 文 字
文 字 概 括 了 下 面 的 内 容 : 整 数 、 字 符 、 浮 点 数 、 串 、 二 进 制 数 字 串 和 表 :
Literal:
IntegerLiteral
RealLiteral
CharacterLiteral
StringLiteral
BinaryLiteral
ListLiteral
CompoundDomainLiteral
IntegerLiteral:
UnaryPlus-opt DecimalDigit-list
UnaryMinus-opt DecimalDigit-list
UnaryPlus-opt OctalPrefix OctalDigit-list
UnaryMinus-opt OctalPrefix OctalDigit-list
UnaryPlus-opt HexadecimalPrefix HexadecimalDigit-list
UnaryMinus-opt HexadecimalPrefix HexadecimalDigit-list
UnaryPlus:
+
UnaryMinus:
-
OctalPrefix:
0o
OctalDigit: one of
0 1 2 3 4 5 6 7
DecimalDigit: one of
0 1 2 3 4 5 6 7 8 9
HexadecimalPrefix:
0x
8

HexadecimalDigit: one of
0 1 2 3 4 5 6 7 8 9 A a B b C c D d E e F f
一 个 整 数 文 字 可 以 属 于 整 数 或 无 符 号 数 域 , 它 不 能 超 过 整 数 或 无 符 号 数 的 最 大 和 最 小 值 。
实 数 文 字
RealLiteral:
UnaryMinus-opt DecimalDigit-list FractionOfFloat-opt Exponent-opt
FractionOfFloat:
. DecimalDigit-list
Exponent:
ExponentSymbol ExponentSign-opt DecimalDigit-list
ExponentSymbol: one of
e E
ExponentSign: one of
- +
浮 点 数 文 字 表 示 的 值 也 应 该 不 要 超 过 实 数 所 能 表 示 的 最 大 最 小 值 。
字 符 文 字
CharacterLiteral:
' CharacterValue '
上 面 的 CharacterValue 可 以 是 任 意 可 打 印 字 符 或 一 个 换 码 序 列 :
• \\ 代 表 \
• \t 代 表 制 表 符
• \n 代 表 换 行 符
• \r 代 表 回 车
• \' 表 单 引 号
• \" 代 表 双 引 号
• \uXXXX, 这 里 的 XXXX 应 该 是 四 位 十 六 进 制 数 ,\uXXXX 代 表 相 应 这 个 数 的 Unicode 字 符 。
串 文 字
StringLiteral:
StringLiteralPart-list
StringLiteralPart:
@" AnyCharacter-list-opt "
" CharacterValue-list-opt "
串 文 字 是 由 一 个 或 多 个 StringLiteralPart( 串 文 字 部 件 ) 连 接 构 成 的 。
以 @ 开 头 的 串 文 字 部 件 不 使 用 换 码 序 列 , 除 了 下 述 情 况 :
• "" 代 表 双 引 号 。
而 不 用 @ 开 头 的 串 文 字 部 件 使 用 下 述 换 码 序 列 :
• \\ 代 表 \
• \t 代 表 制 表 符
• \n 代 表 换 行 符
9

• \r 代 表 回 车
• \" 代 表 双 引 号
• \uXXXX, 这 里 的 XXXX 应 该 是 四 位 十 六 进 制 数 , 代 表 相 应 这 个 数 的 Unicode 字 符 。
二 进 制 数 文 字
255。
BinaryLiteral:
$[ ElementValue-comma-sep-list-opt ]
ElementValue:
IntegerLiteral
ElementValue 可 以 是 任 意 整 数 算 术 表 达 式 ( 如 常 数 ), 在 编 译 时 应 该 是 可 计 算 的 , 值 的 范 围 是 0 到
表 文 字
一 个 表 中 的 所 有 元 素 必 须 属 于 同 一 个 域 ( 或 兼 容 域 )。 域 可 以 是 任 何 内 建 (built-in) 的 或 用 户 定 义 域
(user defined domain), 例 如 , 可 以 是 整 数 、 字 符 、 二 进 制 、 复 合 域 等 等 。
ListLiteral:
[ SimpleLiteral-comma-sep-list-opt ]
[ SimpleLiteral-comma-sep-list | ListLiteral ]
这 里 的 SimpleLiteral( 简 单 文 字 ) 可 以 是 :
例 :
复 合 域 文 字
SimpleLiteral:
IntegerLiteral
RealLiteral
CharacterLiteral
StringLiteral
BinaryLiteral
ListLiteral
CompoundDomainLiteral
[] % 空 表
[1,2,3] % 整 数 表
["abc", "defg"] % 串 表
[1,"abc"]
% 这 个 表 不 合 规 定
用 户 定 义 复 合 域 所 有 的 参 数 如 果 都 是 文 字 的 则 也 可 以 当 文 字 看 待 。
编 译 单 元
一 个 程 序 由 若 干 编 译 单 元 构 成 , 编 译 器 对 每 个 编 译 单 元 分 别 进 行 编 译 , 一 个 编 译 结 果 就 是 一 个 目 标 文
件 。 这 些 目 标 文 件 ( 可 能 还 有 其 它 文 件 ) 链 接 在 一 起 , 就 产 生 了 工 程 的 结 果 。 一 个 程 序 必 须 有 一 个 、 也 只
10

能 有 一 个 目 标 段 (goalSection), 它 是 整 个 程 序 的 入 口 。
一 个 编 译 单 元 所 有 的 引 用 名 必 须 是 已 经 在 本 单 元 中 声 明 或 定 义 过 的 , 在 这 个 意 义 上 说 一 个 编 译 单 元 必
须 是 独 立 的 。 接 口 定 义 与 类 声 明 可 以 包 含 在 数 个 编 译 单 元 中 ( 定 义 / 声 明 在 其 所 在 的 包 含 单 元 中 必 须 是 一 致
的 ), 而 类 实 现 ( 定 义 ) 只 能 定 义 在 单 一 的 单 元 中 。 工 程 中 也 必 须 定 义 每 个 声 明 项 , 但 有 些 定 义 也 可 以 在
库 中 , 也 就 是 说 不 一 定 非 要 原 文 定 义 。
一 个 编 译 单 元 ( 其 中 可 能 含 有 #include 指 令 ) 是 一 个 编 译 项 的 序 列 。
CompilationUnit :
CompilationItem-list-opt
一 个 编 译 项 可 以 是 一 个 接 口 、 一 个 类 声 明 、 一 个 类 实 现 、 目 标 段 或 是 一 个 条 件 编 译 项 ( 这 个 要 在 条 件
编 译 中 介 绍 )。
CompilationItem :
Directive
NamespaceEntrance
ConditionalItem
InterfaceDefinition
ClassDeclaration
ClassImplementation
GoalSection
请 参 看 :
• Interfaces 接 口
• Classes 类
• Implementations 实 现
• Namespace Entrances 名 称 空 间 入 口
• Goal Section 目 标 段
• Directives 指 令
• Conditional Item 条 件 项
Interfaces( 接 口 )
一 个 接 口 定 义 规 定 了 一 个 已 经 命 名 对 象 的 类 型 。 接 口 可 以 支 持 其 它 的 接 口 , 详 细 内 容 请 参 看 Supports
限 定 符 。
在 一 个 接 口 中 声 明 的 所 有 谓 词 , 都 是 该 接 口 类 型 对 象 中 的 对 象 成 员 。 接 口 也 是 一 个 可 以 定 义 常 数 和 域
的 全 局 范 围 , 因 此 , 在 一 个 接 口 中 定 义 的 常 数 和 域 , 并 不 是 该 接 口 ( 或 其 对 象 具 有 的 ) 类 型 的 部 件 。
上 述 这 样 的 域 和 常 数 可 以 用 该 接 口 名 限 定 符 interface::constant, 或 是 使 用 open 限 定 符 ( 参 看
Open 限 定 符 ) 在 其 它 范 围 中 引 用
InterfaceDeclaration :
interface IinterfaceName ScopeQualifications Sections end interface
IinterfaceName-opt
InterfaceName :
LowerCaseIdentifier
在 上 述 结 构 中 , 结 尾 处 的 接 口 名 (InterfaceName) 要 是 用 的 话 , 一 定 要 和 结 构 开 始 处 的 相 一 致 。
11

ScopeQualifications 的 类 型 必 须 是 :
• Supports 限 定 符
• Open 限 定 符
Sections 的 类 型 必 须 是 :
• ConstantsSection 常 数 段
• DomainsSection 域 段
• PredicatesSection 谓 词 段
• PredicatesFromInterface 来 自 接 口 的 谓 词
• ConditionalSection 条 件 段
在 条 件 段 中 包 含 的 所 有 段 也 必 须 是 这 些 类 型 的 。
The interface: object( 接 口 : 对 象 )
如 果 一 个 接 口 没 有 显 式 地 支 持 任 何 接 口 , 它 意 味 着 支 持 的 只 有 内 建 接 口 object。
object 是 一 个 空 接 口 , 也 就 是 说 , 它 不 含 有 谓 词 等 。 它 的 主 要 用 途 是 作 为 所 有 对 象 的 一 个 通 用 的 基 础
类 型 。
Open 限 定 符
Open 限 定 符 用 来 使 对 类 级 实 体 的 引 用 更 方 便 。Open 段 使 一 个 范 围 内 的 名 称 进 入 到 另 一 个 范 围 , 因 而
可 以 不 用 限 定 符 地 加 以 引 用 。
Open 对 对 象 成 员 的 名 称 没 有 影 响 , 因 为 它 们 只 能 通 过 对 象 来 访 问 。 但 是 对 类 成 员 、 域 、 函 子 及 常 数
的 名 称 , 可 以 不 加 限 定 符 地 访 问 。
用 这 样 的 方 式 把 名 称 带 入 到 一 个 范 围 时 , 可 能 会 引 起 一 些 名 称 的 混 淆 ( 参 看 Scoping)。
Open 段 只 在 它 们 出 现 的 范 围 内 有 影 响 , 这 尤 其 是 指 在 一 个 类 声 明 中 的 open 段 不 会 影 响 到 类 的 实 现 。
Supports 限 定 符
OpenQualification :
open ScopeName-comma-sep-list
Supports 限 定 符 只 能 用 在 接 口 定 义 (interfaceDefinition) 与 类 实 现 (classImplementation) 中 。
它 有 两 个 作 用 :
• 指 定 用 一 个 接 口 A 扩 展 另 一 个 接 口 B, 因 而 使 A 类 型 的 对 象 是 B 类 型 对 象 的 一 个 子 类
• 声 明 某 个 类 的 对 象 相 对 于 原 来 构 造 类 型 规 定 的 来 说 ,“ 私 下 地 ” 有 了 更 多 的 对 象 类 型
supports 是 可 传 递 的 : 如 果 接 口 A supports 接 口 B, 而 B 又 supports C, 则 A 也 supports C。
如 果 一 个 接 口 没 有 显 式 地 支 持 任 何 接 口 , 则 意 味 着 它 是 支 持 预 定 义 的 接 口 object。
从 功 能 上 说 , 一 个 接 口 支 持 某 个 接 口 一 次 或 多 次 ( 直 接 间 接 都 算 ) 没 有 什 么 差 别 , 但 可 能 会 造 成 对 象
表 示 上 的 差 别 。
在 类 的 实 现 中 使 用 supports 时 , 会 导 致 This 不 仅 可 以 与 构 造 类 型 一 道 使 用 , 也 可 以 用 于 任 意 私 有
支 持 的 对 象 类 型 。
SupportsQualification :
supports InterfaceName-comma-sep-list
注 意 , 如 果 各 接 口 间 有 相 互 冲 突 的 谓 词 , 这 样 的 接 口 就 不 能 使 用 同 一 个 supports 限 定 符 。
12

谓 词 冲 突 , 是 指 来 自 不 同 本 原 接 口 的 谓 词 有 相 同 的 名 称 及 变 元 数 。 而 本 原 接 口 , 是 指 谓 词 被 原 文 声 明
的 接 口 , 它 是 相 对 于 用 supports 限 定 符 间 接 声 明 的 接 口 而 言 的 。
因 此 , 如 果 一 个 接 口 在 supports 链 中 出 现 了 两 次 或 多 次 , 一 定 小 心 不 要 引 起 冲 突 。
例 来 看 一 下 下 面 的 定 义 与 声 明 :
interface aaa
predicates
insert : (integer X).
end interface
interface bbb
supports aaa
predicates
insert : (integer X, string Comment).
end interface
interface cc
supports aaa
predicates
extract : () -> integer.
end interface
interface dd
supports aaa, bbb, cc
predicates
extract : (string Comment) -> integer.
end interface
下 面 是 在 dd 中 找 到 的 全 部 谓 词 的 表 ( 按 深 度 遍 历 ):
predicates
insert : (integer).
% dd -> aaa
insert : (integer).
% dd -> bbb -> aaa
insert : (integer, string). % dd -> bbb
insert : (integer).
% dd -> cc -> aaa
extract : () -> integer. % dd -> cc
extract: : (string) -> integer. % dd
这 里 有 些 谓 词 是 相 同 的 , 因 此 实 际 上 dd 中 含 有 的 成 员 如 下 :
predicates
insert : (integer).
% 本 原 接 口 : aaa
insert : (integer, string). % 本 原 接 口 : bbb
extract : () -> integer. % 本 原 接 口 : cc
extract : (string) -> integer. % 本 原 接 口 : dd
例 考 虑 如 下 接 口 :
interface aaa
predicates
insert : (integer X).
end interface
interface bbb
13

predicates
insert : (integer X).
end interface
interface cc
supports aaa, bbb
end interface
% 有 冲 突 的 接 口
接 口 cc 是 不 合 法 的 , 因 为 在 aaa 中 支 持 的 insert/1 以 aaa 为 本 原 接 口 , 而 在 bbb 中 支 持 的 insert/1
以 bbb 为 本 原 接 口 。
Classes( 类 )
类 声 明 向 外 界 定 义 了 类 的 外 观 , 外 界 可 以 看 到 和 准 确 地 使 用 类 声 明 中 记 述 过 的 实 体 。 我 们 说 , 类 声 明
规 定 了 类 的 公 有 部 分 。
类 声 明 可 以 含 有 常 数 和 域 定 义 , 以 及 谓 词 声 明 。
如 果 一 个 类 说 明 了 一 个 构 造 类 型 ConstructionType, 则 它 可 以 构 造 此 种 类 型 的 对 象 。 可 以 构 造 对
象 的 类 至 少 有 一 个 构 造 器 , 但 也 可 以 声 明 多 个 。 没 有 显 式 声 明 任 何 构 造 器 的 类 , 都 自 动 地 拥 有 缺 省 构 造 器
( 即 new/0)。
对 象 是 通 过 调 用 类 的 构 造 器 构 造 出 来 的 。 在 初 始 化 继 承 的 类 时 也 要 用 构 造 器 。
类 声 明 中 所 提 到 的 一 切 是 属 于 类 的 , 而 不 是 属 于 它 所 构 造 的 对 象 的 。 与 对 象 有 关 的 一 切 , 都 要 在 这 个
类 所 构 造 的 对 象 的 构 造 类 型 中 声 明 。
任 何 类 声 明 ClassDeclaration 都 必 须 伴 有 类 实 现 classImplementation。 在 类 声 明 中 声 明 的 谓 词 的
定 义 / 实 现 是 由 类 实 现 提 供 的 。 同 样 , 由 类 构 造 的 对 象 所 支 持 的 谓 词 定 义 也 是 由 类 实 现 提 供 的 。 这 两 种 谓 词
都 可 以 由 子 句 实 现 , 但 对 象 谓 词 还 可 从 其 它 类 继 承 来 实 现 。
需 要 特 别 指 出 , 类 声 明 对 代 码 继 承 没 有 作 任 何 说 明 。 代 码 继 承 完 全 是 “ 私 事 儿 ”, 只 能 在 类 实 现 中 说
明 ( 这 与 许 多 其 它 面 向 对 象 的 语 言 不 同 , 是 要 在 implementation 中 隐 藏 所 有 的 实 现 细 节 )。
如 果 类 没 有 说 明 构 造 类 型 ConstructionType, 则 这 个 类 不 能 产 生 任 何 对 象 ; 此 时 这 个 类 的 角 色 与
其 说 是 “ 类 ” 还 不 如 说 是 个 模 块 更 恰 当 。
ClassDeclaration :
class ClassName ConstructionType-opt ScopeQualifications Sections end class
ClassName-opt
ConstructionType :
: InterfaceName
ClassName :
LowerCaseIdentifier
类 声 明 结 尾 处 的 ClassName( 如 果 要 写 的 话 ) 必 须 与 开 头 的 那 个 完 全 一 样 。
允 许 用 类 的 名 字 ClassName 指 定 该 类 构 造 类 型 的 接 口 名 字 ConstructionType, 就 是 说 可 以 这 样 :
class interfaceAndClassName : interfaceAndClassName
要 注 意 , 类 和 接 口 都 可 以 声 明 域 和 常 数 , 它 们 之 间 必 须 没 有 冲 突 , 因 为 它 们 都 是 在 相 同 的 名 称 空 间 的
( 它 们 只 能 由 相 同 的 接 口 或 类 的 名 称 来 限 定 了 )。
ScopeQualifications 只 能 用 open 限 定 符 。
14

Sections 必 须 是 下 面 的 种 类 :
• Constants 段
• domains 段
• predicates 段
• constructors 段
• 条 件 段
只 有 当 类 中 说 明 了 ConstructionType 时 ,constructors 段 才 是 合 法 的 。
在 条 件 (conditional) 段 中 的 所 有 段 也 必 须 是 这 些 种 类 的 。
Implementations ( 实 现 )
一 个 类 的 实 现 , 用 于 提 供 在 该 类 声 明 中 声 明 的 谓 词 和 构 造 器 的 定 义 , 以 及 由 这 个 类 构 造 的 对 象 支 持 的
谓 词 的 定 义 。
类 可 以 私 有 地 ( 即 在 其 实 现 中 ) 声 明 和 定 义 比 类 声 明 中 提 到 的 更 多 的 实 体 。 特 别 是 , 在 实 现 里 可 以 声
明 事 实 数 据 库 , 而 事 实 数 据 库 可 以 用 于 承 载 类 和 对 象 的 状 态 。
实 现 是 一 个 混 合 的 范 围 , 它 既 包 含 了 类 的 实 现 , 也 包 含 了 类 产 生 的 对 象 的 实 现 。 类 的 类 部 分 是 由 类 的
所 有 对 象 共 享 的 , 而 对 象 部 分 , 则 仅 属 于 各 个 对 象 。 类 部 分 和 对 象 部 分 都 可 以 含 有 事 实 与 谓 词 , 而 域 、 函
子 和 常 数 则 总 是 属 于 类 部 分 , 即 , 它 们 不 是 属 于 哪 个 对 象 个 体 的 。
缺 省 时 , 所 有 在 一 个 类 实 现 中 声 明 的 谓 词 和 事 实 成 员 是 对 象 成 员 。 要 声 明 一 个 类 成 员 , 必 须 在 段 关 键
字 ( 如 predicates、facts) 前 加 关 键 字 class。 在 这 样 的 段 中 声 明 的 所 有 成 员 是 类 成 员 。
类 成 员 可 以 引 用 类 的 类 部 分 , 但 不 能 引 用 对 象 部 分 。
而 另 一 方 面 , 对 象 成 员 既 可 以 访 问 类 的 类 部 分 也 可 以 访 问 类 的 对 象 部 分 。
在 实 现 中 的 代 码 , 所 有 者 对 象 为 全 体 对 象 谓 词 所 包 容 。 而 包 容 的 所 有 者 对 象 , 可 以 直 接 由 特 殊 的 变 量
This 来 访 问 。
ClassImplementation :
implement ClassName ScopeQualifications Sections end implement
ClassName-opt
类 实 现 结 尾 处 的 ClassName( 如 果 要 写 的 话 ) 必 须 与 类 实 现 开 头 的 一 致 。
ScopeQualifications 必 须 是 如 下 的 种 类 :
• supports 限 定 符
• open 限 定 符
• inherit 限 定 符
• delegate 限 定 符
supports 限 定 符 后 列 出 一 个 接 口 表 , 表 示 由 该 类 实 现 私 有 支 持 的 接 口 。
delegate 限 定 符 委 派 来 自 接 口 的 对 象 谓 词 功 能 给 来 自 对 象 的 谓 词 , 它 可 以 如 同 事 实 变 量 一 样 地 存 储 。
Sections 必 须 是 如 下 种 类 :
• constants 段
• resolve 限 定 符
• delegate 限 定 符
• domains 段
• predicates 段
• constructors 段
• facts 段
15

• clauses 段
• conditional 段
constructors 段 只 有 在 ClassName 类 说 明 了 constructionType 时 才 是 合 法 的 。
说 明 ConstructionType 的 子 句 也 是 对 象 的 构 造 器 , 它 按 规 定 的 构 造 类 型 构 造 对 象 。
例 下 面 这 个 例 子 , 要 说 明 类 事 实 在 类 的 对 象 间 共 享 , 而 对 象 事 实 则 不 是 共 享 的 。
设 有 接 口 aa 和 类 aa_class:
interface aa
predicates
setClassFact : (integer Value).
getClassFact : () -> integer.
setObjectFact : (integer Value).
getObjectFact : () -> integer.
end interface
class aa_class : aa
end class
这 些 谓 词 分 别 从 类 事 实 与 对 象 事 实 中 存 取 值 :
implement aa_class
class facts
classFact : integer := 0.
facts
objectFact : integer := 0.
clauses
setClassFact(Value) :-
classFact := Value.
getClassFact() = classFact.
clauses
setObjectFact(Value) :-
objectFact := Value.
getObjectFact() = objectFact.
end implement aa_class
设 有 目 标 为 :
goal
A1 = aa_class::new(),
A2 = aa_class::new(),
A1:setClassFact(1),
A1:setObjectFact(2),
ClassFact = A2:getClassFact(),
ObjectFact = A2:getObjectFact().
类 事 实 是 由 所 有 对 象 共 享 的 , 所 以 用 A1 设 置 类 事 实 会 影 响 到 由 A2 取 得 的 值 , 因 而 ,ClassFact 的
值 是 用 A1 设 置 的 那 个 值 。
与 此 不 同 的 是 , 对 象 事 实 只 属 于 各 个 对 象 。 因 此 , 在 A1 中 设 置 的 对 象 事 实 不 会 影 响 存 储 在 A2 中 的
值 。 这 样 ,ObjectFact 的 值 是 零 , 这 个 值 是 A2 初 始 化 时 的 值 。
Construction( 构 造 )
16

本 节 描 述 对 象 构 造 , 因 而 也 只 涉 及 那 些 构 造 对 象 的 子 句 。
对 象 是 通 过 调 用 构 造 器 (constructor ) 构 造 出 来 的 。 而 构 造 器 则 是 在 类 的 声 明 和 实 现 中 的
constructors 段 显 式 地 声 明 的 ( 参 见 缺 省 构 造 器 )。
一 个 构 造 器 有 两 个 关 联 的 谓 词 :
• 一 个 返 回 新 构 造 的 对 象 的 类 函 数
• 一 个 用 于 初 始 化 继 承 对 象 的 对 象 谓 词
相 关 的 对 象 谓 词 用 于 进 行 对 象 的 初 始 化 , 这 个 谓 词 只 能 在 本 身 的 类 和 继 承 的 类 中 由 构 造 器 来 调 用 ( 也
就 是 基 于 类 的 初 始 化 )。
相 关 的 类 函 数 是 隐 含 定 义 的 , 也 就 是 说 在 哪 儿 都 没 有 它 的 子 句 。 这 个 类 函 数 分 配 内 存 来 存 放 对 象 、 进
行 对 象 的 初 始 化 并 调 用 对 象 构 造 器 来 创 建 对 象 。 最 后 , 作 为 构 造 器 的 执 行 结 果 , 返 回 构 造 的 对 象 。 因 此 ,
在 构 造 器 的 子 句 被 调 用 之 前 :
• 所 有 具 有 初 始 化 表 达 式 的 对 象 事 实 变 量 要 被 初 始 化
• 所 有 具 有 子 句 的 对 象 事 实 要 从 这 些 子 句 开 始 被 初 始 化
在 构 造 器 的 子 句 被 调 用 之 前 , 这 个 初 始 化 也 会 传 递 地 进 行 到 所 有 继 承 的 子 对 象 。
构 造 器 子 句 必 须 要 :
• 初 始 化 那 些 在 进 入 之 前 没 有 初 始 化 的 single 对 象 事 实 及 对 象 事 实 变 量
• 初 始 化 所 有 子 对 象
构 造 器 子 句 还 可 以 做 些 其 它 的 事 , 但 它 必 须 完 成 上 述 初 始 化 工 作 , 以 确 保 对 象 构 造 后 是 有 效 的 。
注 意 : 在 构 造 期 间 对 象 可 能 是 无 效 的 , 要 避 免 访 问 未 初 始 化 的 对 象 部 分 ( 参 看 构 造 对 象 的 规 则 )。
缺 省 构 造 器
缺 省 构 造 器 不 需 要 输 入 参 数 , 名 为 new/0。 如 果 构 造 对 象 的 类 在 其 类 声 明 中 没 有 声 明 任 何 构 造 器 ,
则 意 味 着 在 类 声 明 部 分 隐 含 地 声 明 了 缺 省 的 构 造 器 ( 即 new/0)。 这 也 意 味 着 每 个 类 至 少 有 一 个 构 造 器 ,
因 此 , 这 样 写 :
class aaa
end class aaa
与 下 面 的 写 法 , 结 果 是 一 样 的 :
class aaa
constructors
new : ().
end class aaa
显 式 地 重 新 声 明 缺 省 构 造 器 也 是 合 法 的 。
不 必 定 义 ( 也 就 是 说 , 实 现 ) 缺 省 构 造 器 , 如 果 不 定 义 , 则 隐 含 地 假 设 有 一 个 没 有 什 么 影 响 的 定 义 。
因 此 , 如 果 有 一 个 构 造 器 aaa, 写 :
implement aaa
end implement aaa
与 写 成 下 面 这 样 是 一 样 的 :
implement aaa
clauses
new().
17

end implement aaa
注 意 , 只 是 在 下 面 这 样 的 情 况 中 , 类 才 有 一 个 缺 省 构 造 器 :
• 这 个 类 没 有 公 开 地 声 明 任 何 构 造 器
• 或 是 声 明 了 一 个 new/0 作 为 构 造 器
也 可 以 反 过 来 说 , 如 果 是 下 述 情 况 , 一 个 类 就 没 有 缺 省 的 构 造 器 :
• 这 个 类 公 开 地 声 明 了 构 造 器
• 它 声 明 的 不 是 以 new/0 作 为 构 造 器
例 设 有 接 口 aa, 考 查 下 面 的 代 码 :
class aa_class : aa
end class
类 aa_class 没 有 声 明 构 造 器 , 所 以 , 它 隐 含 地 声 明 了 缺 省 构 造 器 。 因 而 , 可 以 这 样 创 建 一 个 aa_class
类 的 对 象 :
goal
_A = aa_class::new().
% 隐 含 声 明 的 缺 省 构 造 器
例 实 现 隐 含 声 明 的 aa_class 类 的 缺 省 构 造 器 是 合 法 的 :
implement aa_class
clauses
new() :-
...
end implement
例 bb_class 类 显 式 地 声 明 了 一 个 构 造 器 , 因 为 它 不 是 缺 省 构 造 器 , 这 个 类 就 没 有 缺 省 构 造 器 。
class bb_class : aa
constructors
newFromFile : (file File).
end class
例 cc_class 类 声 明 了 构 造 器 newFromFile/1, 但 同 时 也 声 明 了 缺 省 构 造 器 new/0, 所 以 显 然
它 有 缺 省 构 造 器 new/0:
class cc_class : aa
constructors
new : ().
newFromFile : (file File).
end class
% 缺 省 构 造 器
私 有 构 造 器
在 类 实 现 里 , 还 可 以 声 明 “ 私 有 的 ” 构 造 器 。 在 下 面 的 情 况 中 , 可 能 是 有 这 个 需 要 的 :
1. 当 某 个 谓 词 要 返 回 一 个 construction type 的 对 象 时 , 在 类 实 现 中 就 可 以 声 明 、 实 现 并 调 用
“ 私 有 的 ” 构 造 器 来 创 建 这 样 的 对 象
2. 当 某 个 类 里 声 明 了 几 个 “public” 的 构 造 器 、 而 这 些 构 造 器 中 有 很 多 相 同 部 分 时 , 用 一 个 在
类 实 现 中 声 明 的 “ 私 有 的 ” 构 造 器 来 实 现 这 个 “ 相 同 部 分 ” 也 是 合 理 的 。 所 有 这 些 公 共 的 构
18

造 器 的 子 句 只 需 要 调 用 这 个 私 有 的 构 造 器 来 实 现 “ 相 同 部 分 ”。
注 意 , 在 一 个 可 以 构 造 对 象 的 类 中 , 如 果 在 类 声 明 中 没 有 声 明 任 何 构 造 器 , 则 意 味 着 隐 含 地 声 明 了 缺
省 构 造 器 new/0, 这 和 在 类 实 现 中 是 否 声 明 私 有 构 造 器 无 关 。 这 样 一 来 , 可 以 这 样 做 :
子 对 象 的 构 造
interface aa
end interface
class aa : aa
end class
implement aa
constructors
myCreate : ().
clauses
myCreate() :-
...
end implement
% 程 序 代 码
...
Obj = aa::new(), % 这 是 隐 含 声 明 的 缺 省 的 类 构 造 器
...
所 有 构 造 器 都 要 负 责 把 构 造 的 对 象 初 始 化 成 有 效 的 状 态 。 为 要 得 到 这 样 的 有 效 状 态 , 所 有 子 对 象 ( 即
继 承 的 类 ) 也 必 须 初 始 化 。
子 对 象 的 初 始 化 可 以 用 下 述 二 种 方 法 之 一 进 行 : 程 序 员 调 用 被 继 承 类 的 构 造 器 , 或 是 自 动 地 调 用 缺 省
构 造 器 。 后 者 要 求 被 继 承 类 确 实 有 一 个 缺 省 构 造 器 , 这 个 缺 省 构 造 器 是 显 式 声 明 或 是 隐 含 声 明 的 无 关 紧 要 。
如 果 被 继 承 类 没 有 缺 省 构 造 器 , 就 必 须 显 式 地 调 用 别 的 构 造 器 。 被 继 承 类 构 造 器 的 缺 省 调 用 时 刻 是 紧
接 着 初 始 化 事 实 变 量 和 事 实 的 子 句 之 后 , 在 进 入 到 构 造 器 子 句 之 前 。
被 继 承 类 的 构 造 器 调 用 是 按 不 返 回 值 的 模 式 进 行 的 。 如 果 按 返 回 值 的 版 本 来 做 调 用 , 实 际 上 就 创 建 了
一 个 对 象 , 而 不 是 对 This 调 用 构 造 器 ( 参 看 下 面 的 例 子 )。
例 这 个 bb_class 类 的 实 现 继 承 自 类 aa_class,bb_class 类 的 缺 省 构 造 器 调 用 aa_class 类 的
一 个 构 造 器 , 创 建 一 个 新 的 cc_class 类 的 对 象 :
implement bb_class inherits aa_class
clauses
new() :-
C = cc_class::new(), % 创 建 一 个 cc_class 的 对 象
aa_class::newC(C).
...
end implement
% 对 继 承 的 子 对 象 调 用 构 造 器
例 如 果 基 类 不 是 显 式 构 造 的 , 那 它 就 是 用 缺 省 构 造 器 隐 含 构 造 的 , 这 样 的 话 , 写 :
implement bbb
inherits aaa
clauses
myNew() :-
doSomething().
end implement bbb
和 下 面 的 写 法 是 一 样 的 :
19

implement bbb
inherits aaa
clauses
myNew() :-
aaa::new(),
doSomething().
end implement bbb
如 果 aaa 没 有 缺 省 构 造 器 , 这 当 然 就 会 出 错 。
注 意 , 这 个 规 则 当 然 也 可 以 和 前 面 在 缺 省 构 造 器 讨 论 过 的 规 则 结 合 起 来 , 写
implement bbb
inherits aaa
end implement bbb
与 写 成 下 面 的 样 子 ( 根 据 前 面 缺 省 构 造 器 在 中 讨 论 过 的 规 则 ) 是 完 全 相 同 的 :
implement bbb
inherits aaa
clauses
new().
end implement bbb
与 写 成 下 面 的 样 子 ( 按 刚 讨 论 过 的 规 则 ) 也 是 相 同 的 :
implement bbb
inherits aaa
clauses
new() :-
aaa::new().
end implement bbb
single( 对 象 ) 事 实 的 初 始 化
如 同 所 有 构 造 器 必 须 要 初 始 化 / 构 造 子 对 象 一 样 , 它 也 必 须 要 在 第 一 次 引 用 之 前 初 始 化 一 个 对 象 的 所 有
的 事 实 。
注 意 ,single 类 事 实 只 能 由 子 句 初 始 化 , 因 为 它 们 不 是 与 哪 个 对 象 关 联 的 , 类 事 实 在 第 一 个 对 象 创
建 之 前 就 可 以 访 问 了 。
例 这 个 例 子 表 明 (1) 如 何 用 表 达 式 初 始 化 一 个 事 实 变 量 ;(2) 如 何 用 子 句 初 始 化 一 个 single 事 实
(point);(3) 如 何 在 构 造 器 里 初 始 化 一 个 single 事 实 ;(4) 在 哪 儿 调 用 被 继 承 类 的 缺 省 构 造 器 :
implement bb_class inherits aa_class
facts
counter : integer := 0.
point : (integer X, integer Y) single.
c : (cc C) single.
clauses
point(0, 1).
% 创 建 了 对 象 ,counter 和 point 在 进 入 之 前 初 始 化 了
% 缺 省 构 造 器 aa_class::new/0 在 进 入 之 前 也 被 调 用 了
20

new() :-
C = cc_class::new(),
assert(c(C)).
...
end implement
委 托 构 造
除 了 直 接 在 构 造 器 中 构 造 一 个 对 象 , 这 个 工 作 也 可 以 委 托 给 同 一 个 类 的 其 它 构 造 器 。 这 只 需 要 调 用 其
它 的 构 造 器 ( 不 返 回 值 的 版 本 ) 就 可 以 了 。 委 托 构 造 时 , 必 须 要 确 保 对 象 真 的 被 构 造 了 , 而 且 还 不 能 重 复
构 造 。single 事 实 可 以 多 次 赋 值 , 所 以 不 会 构 造 重 复 了 , 而 继 承 的 类 , 只 能 在 对 象 构 造 时 进 行 一 次 初 始 化 。
例 这 个 例 子 表 明 了 委 托 构 造 的 一 个 典 型 应 用 , 构 造 器 new/0 用 缺 省 值 调 用 另 一 个 构 造 器
newFromC/1。
构 造 对 象 的 规 则
implement aa_class
facts
c : (cc C) single.
clauses
new() :-
C = cc_class::new(),
newFromC(C).
newFromC(C) :-
assert(c(C)).
...
end implement
程 序 员 必 须 保 证 :
• 所 有 子 对 象 只 被 初 始 化 / 构 造 了 一 次
• 所 有 single 事 实 被 初 始 化 了 ( 至 少 一 次 )
• 在 初 始 化 / 构 造 之 前 没 有 子 对 象 被 引 用
• 在 初 始 化 之 前 没 有 single 事 实 被 使 用
在 编 译 时 编 译 器 对 这 些 问 题 的 检 测 是 没 有 什 么 保 证 的 。 编 译 器 可 能 会 给 出 一 个 运 行 时 确 认 , 也 可 能 会
不 安 全 地 忽 略 这 样 的 运 行 时 确 认 。
This
对 象 谓 词 总 是 被 应 用 在 一 个 对 象 上 , 这 个 对 象 带 有 对 象 事 实 并 为 对 象 谓 词 的 实 现 所 包 容 。 对 象 谓 词 可
以 访 问 到 这 个 暗 含 的 对 象 , 我 们 称 这 个 对 象 为 This。 可 以 隐 式 和 显 式 两 种 方 式 访 问 This。
显 式 This
在 每 个 对 象 谓 词 的 每 个 子 句 中 , 变 量 This 都 是 隐 含 定 义 了 的 并 绑 定 于 This, 也 就 是 其 成 员 谓 词 正 在
执 行 的 那 个 对 象 。
隐 式 This
21

在 一 个 对 象 成 员 谓 词 的 子 句 里 , 可 以 直 接 调 用 其 它 对 象 成 员 谓 词 , 因 为 隐 含 地 设 定 了 This 来 进 行 这 种
操 作 。 超 类 的 成 员 也 可 以 直 接 被 调 用 , 只 要 需 要 调 用 的 方 法 是 明 确 的 就 行 ( 参 看 范 围 与 可 见 性 )。 同 样 ,
也 可 以 访 问 存 储 在 This 中 的 对 象 事 实 。
This 与 继 承
[ 注 意 这 一 段 的 内 容 有 可 能 发 生 变 化 , 因 为 关 于 语 言 的 这 个 问 题 正 打 算 作 更 动 。]
This 指 的 对 象 , 总 是 属 于 在 使 用 This 的 那 个 类 的 , 如 果 这 个 类 是 被 其 它 的 类 继 承 的 , 仍 然 如 此 。
设 接 口 aa 声 明 如 下 :
interface aa
predicates
action : ().
doAction : ().
end interface
而 类 aa_class 声 明 如 下 :
其 实 现 是 :
则 如 下 目 标 :
写 出 来 的 是 :
class aa_class : aa
end class
implement aa_class
clauses
action() :-
doAction(),
This:doAction().
doAction() :-
write("aa_class::doAction"), nl.
end implement
goal
A = aa_class::new(),
A:action().
aa_class::doAction
aa_class::doAction
再 来 考 虑 如 下 声 明 的 类 bb_class:
其 实 现 是 :
class bb_class : aa
end class
implement bb_class inherits aa_class
clauses
doAction() :-
22

write("bb_class::doAction"), nl.
end implement
这 样 的 目 标 :
goal
B = bb_class::new(),
B:action().
写 出 来 的 也 是 :
aa_class::doAction
aa_class::doAction
因 为 在 类 aa_class 中 ( 显 式 和 隐 式 ) 的 This 都 指 的 是 类 aa_class 的 对 象 。
现 在 来 看 另 一 个 例 子 :
interface iName
predicates
className : () -> string Class.
name: () -> string Class.
nameThis: () -> string Class.
end interface iName
class aaa : iName
end class aaa
implement aaa
clauses
className() = "aaa".
clauses
name() = className().
clauses
nameThis() = This:className().
end implement aaa
class bbb : iName
end class bbb
implement bbb
inherits aaa
clauses
className() = "bbb".
end implement bbb
goal
OOO = bbb::new(),
Class1 = OOO:name(),
Class2 = OOO:nameThis().
bbb 类 从 aaa 继 承 了 name 和 nameThis 的 定 义 , 但 再 实 现 了 className。 在 目 标 中 我 们 创 建 了
一 个 bbb 对 象 , 在 它 的 基 础 上 我 们 调 用 name 和 nameThis。
name 谓 词 直 接 调 用 className, 而 nameThis 调 用 This:className, 它 们 的 效 果 是 不 同 的 。
name 谓 词 调 用 的 className 是 在 aaa 中 定 义 的 。 但 nameThis 调 用 的 className 则 是 定 义 在 This
23

上 的 , 其 实 就 是 bbb::className, 因 为 This 是 一 个 bbb 对 象 。
总 之 ,Class1 的 绑 定 值 是 “aaa”, Class2 而 则 是 “bbb”。
像 nameThis 那 样 在 父 类 中 调 用 子 类 , 是 在 共 享 父 类 中 实 现 一 般 功 能 的 常 用 方 法 。 而 一 般 功 能 则 要
依 靠 子 类 的 对 非 一 般 功 能 的 提 炼 区 分 。
再 看 一 下 这 个 类 :
interface iTest
predicates
test : () -> string Name.
end interface iTest
class ccc : iTest
end class ccc
implement ccc
inherits aaa
clauses
test() = aaa::nameThis().
end implement ccc
ccc 也 继 承 于 aaa, 因 此 这 也 就 意 味 着 ccc 支 持 接 口 iName( 私 有 地 )。 当 aaa 调 用 This:className
时 , 它 调 用 的 是 ccc 提 供 的 东 西 , 而 这 刚 好 又 是 继 承 自 aaa 的 。
再 看 下 面 这 个 例 子 :
class ddd : name
end class ddd
implement ddd
inherits bbb
clauses
className() = "ddd".
end implement ddd
goal
OOO = ddd::new(),
Class1 = OOO:name(),
Class2 = OOO:nameThis().
ddd 继 承 自 bbb, 而 后 者 是 继 承 自 aaa 的 。 当 调 用 nameThis 时 其 实 调 用 的 是 aaa::nameThis,
而 它 调 用 的 是 This:className。 在 这 里 ,This 是 ddd 对 象 , 因 而 实 际 的 调 用 成 了 ddd::className。
总 之 , 对 This:className 的 调 用 最 后 指 向 支 持 含 有 className 的 接 口 的 子 类 。
Inherits 限 定 符
这 个 限 定 符 用 于 说 明 一 个 实 现 是 继 承 自 一 个 或 多 个 类 的 。 继 承 只 对 类 的 对 象 部 分 有 影 响 。
由 其 它 的 类 继 承 的 目 的 , 是 要 从 那 些 类 中 继 承 行 为 。 当 cc 类 继 承 aa 类 , 意 味 着 cc 类 的 实 现 自 动 隐 含
地 ( 私 有 的 ) 支 持 aa 类 的 构 造 类 型 ( 接 口 )。 当 然 , 如 果 类 aa 的 实 现 已 经 显 式 地 支 持 了 cc 的 构 造 类 型 ,
它 们 之 间 就 没 什 么 分 别 了 。
因 此 , 要 注 意 同 一 个 谓 词 , 比 如 说 p, 不 能 在 cc 类 的 构 造 类 型 接 口 中 声 明 又 在 被 继 承 的 aa 类 构 造 类 型
接 口 中 声 明 ( 编 译 器 能 检 测 出 这 个 问 题 并 产 生 错 误 报 告 说 一 个 谓 词 在 两 个 地 方 作 了 声 明 )。 对 这 个 问 题 再
稍 微 仔 细 地 讨 论 一 下 。 假 设 cc 类 有 一 个 构 造 类 型 接 口 cci, 而 另 一 个 aa 类 有 一 个 构 造 类 型 接 口 aai。 在 aai
和 cci 接 口 中 都 声 明 同 一 个 谓 词 p, 只 要 aa 类 和 cc 类 独 立 的 , 编 译 器 都 不 会 检 测 出 问 题 。 但 一 旦 声 明 cc 类
24

继 承 aa 类 , 则 cc 类 也 开 始 支 持 aai 接 口 。 这 样 一 来 ,cc 类 就 遇 到 了 两 个 p 谓 词 的 声 明 , 这 个 问 题 就 会 产 生
编 译 时 的 错 误 。 要 避 免 谓 词 p 声 明 的 这 种 不 确 定 性 , 只 能 在 cci 接 口 声 明 中 使 用 Predicates from Interface
段 , 如 下 :
interface cci
predicates from aai
p(), ...
end interface cci
对 象 谓 词 可 以 被 继 承 : 如 果 一 个 类 没 有 实 现 某 个 它 的 对 象 谓 词 , 但 它 所 继 承 的 一 个 类 实 现 了 这 个 谓 词 ,
则 这 个 谓 词 就 可 以 用 于 这 个 类 。
继 承 的 类 对 被 继 承 的 类 没 有 什 么 特 权 , 它 也 只 能 通 过 该 构 造 类 型 接 口 访 问 其 中 的 对 象 。
继 承 必 须 是 明 确 的 。 如 果 一 个 类 自 己 定 义 了 谓 词 , 这 不 会 含 糊 , 因 为 这 个 谓 词 定 义 是 显 而 易 见 的 。 如
果 只 有 一 个 被 继 承 类 支 持 这 个 谓 词 , 这 也 不 会 有 问 题 。 但 是 , 如 果 有 两 个 或 多 个 类 支 持 这 个 谓 词 , 是 哪 个
类 提 供 的 定 义 就 模 糊 了 。 此 时 , 必 须 用 一 个 resolve 限 定 符 来 解 决 这 个 模 糊 问 题 ( 参 看 Resolve 限 定 符 )。
在 当 前 类 的 对 象 谓 词 中 可 以 直 接 调 用 来 自 被 继 承 类 的 对 象 谓 词 , 因 为 隐 含 使 用 了 作 为 谓 词 所 有 者 的 内
建 子 对 象 。 类 限 定 符 可 解 决 来 自 被 继 承 类 的 对 象 谓 词 调 用 模 糊 问 题 。
Resolve 限 定 符
InheritsQualification :
inherits ClassName-comma-sep-list
已 经 提 到 过 关 于 调 用 谓 词 的 模 糊 问 题 , 可 以 通 过 使 用 指 定 名 称 来 避 免 。 但 当 有 继 承 情 况 出 现 时 , 这 也
还 有 问 题 。 看 下 面 这 个 例 子 :
interface aa
predicates
p : () procedure ().
...
end interface
class bb_class : aa
end class
class cc_class : aa
end class
class dd_class : aa
end class
implement dd_class inherits bb_class, cc_class
end implement
在 这 种 情 况 下 , 是 类 bb_class 还 是 类 cc_class 来 给 类 dd_class 提 供 aa 的 实 现 是 模 糊 的 ( 注 意 ,
我 们 说 一 个 类 实 现 一 个 接 口 , 就 意 味 着 它 对 在 接 口 里 声 明 的 谓 词 提 供 定 义 )。
当 然 可 以 在 dd_class 的 实 现 中 添 加 子 句 , 这 可 以 有 效 地 解 决 问 题 。 比 如 , 下 面 的 子 句 , 它 会 从
bb_class 中 “ 输 出 ” 谓 词 p:
clauses
p() :- bb_class::p().
25

但 这 样 一 来 , 就 并 非 从 bb 继 承 了 , 其 实 是 我 们 的 类 委 托 任 务 给 bb_class。
为 要 解 决 这 样 的 模 糊 ( 真 的 是 继 承 而 非 委 托 ), 可 以 使 用 一 个 resolve 段 。 这 个 段 包 含 一 些 解 决 方 案 :
ResolveQualification :
resolve Resolution-comma-sep-list
Resolution :
InterfaceResolution
PredicateFromClassResolution
PredicateRenameResolution
PpredicateExternallyResolution
限 定 符 resolve 用 于 从 指 定 的 源 中 提 供 实 现 。
谓 词 解 决 方 案
PredicateFromClassResolution :
PredicateNameWithArity from ClassName
来 自 类 的 谓 词 解 决 方 案 , 由 指 定 的 类 提 供 该 谓 词 的 实 现 。
对 一 个 类 的 谓 词 解 决 方 案 来 说 :
• 该 类 必 须 实 现 了 要 解 决 的 谓 词 , 这 也 意 味 着 该 谓 词 必 须 要 与 被 继 承 的 那 个 谓 词 源 于 同 样 的 接 口
• 该 类 已 经 出 现 在 inherits 段
谓 词 重 命 名 解 决 方 案
谓 词 重 命 名 解 决 方 案 , 是 指 由 另 一 个 不 同 名 称 的 谓 词 提 供 该 谓 词 的 实 现 。 这 个 谓 词 必 须 来 自 一 个 继 承
的 类 , 其 类 型 、 模 式 及 流 样 式 必 须 要 完 全 匹 配 。
接 口 解 决 方 案
PredicateRenameResolution :
PredicateNameWithArity from ClassName :: PredicateName
接 口 解 决 方 案 用 来 从 一 个 继 承 的 类 中 提 供 完 整 的 接 口 。 因 而 , 这 个 解 决 方 案 就 是 简 单 地 说 该 接 口 中 的
所 有 谓 词 应 该 由 相 应 的 类 来 解 决 。
InterfaceResolution :
interface InterfaceName from ClassName
该 类 必 须 公 开 地 支 持 提 供 解 决 方 案 的 接 口 。
如 果 谓 词 解 决 方 案 与 接 口 解 决 方 案 都 覆 盖 了 某 个 谓 词 名 , 则 会 使 用 谓 词 解 决 方 案 , 也 就 是 说 精 细 度 高
的 解 决 方 案 优 先 。 当 数 个 接 口 覆 盖 一 个 谓 词 时 , 只 要 它 们 都 是 由 相 同 的 类 提 供 谓 词 的 解 决 方 案 的 , 也 是 这
样 。 另 一 方 面 , 如 果 谓 词 的 解 决 方 案 来 自 不 同 的 类 , 就 必 须 要 用 谓 词 解 决 方 案 来 克 服 模 糊 问 题 。
注 意 , 解 决 方 案 的 语 法 不 能 解 决 谓 词 对 不 同 类 的 不 同 重 载 问 题 。
例 我 们 可 以 用 接 口 解 决 方 案 来 解 决 前 面 例 子 中 的 问 题 。 在 这 种 情 况 下 , 我 们 选 择 aa_class 的 实 现 继
承 cc_class, 但 从 bb_class 继 承 p。
implement dd_class
26

外 部 解 决 方 案
inherits bb_class, cc_class
resolve
interface aa from cc_class
p from bb_class
end implement
谓 词 的 外 部 解 决 方 案 , 是 指 谓 词 根 本 就 不 在 类 本 身 实 现 , 而 是 使 用 外 部 的 库 。 外 部 解 决 方 案 只 适 用 于
类 谓 词 , 对 象 谓 词 不 能 用 这 个 解 决 方 案 。
重 要 的 是 , 调 用 协 议 、 链 接 名 及 参 数 类 型 要 符 合 实 现 库 的 要 求 。
私 有 与 公 用 谓 词 都 可 以 使 用 外 部 解 决 方 案 。
PredicateExternallyResolution : PredicateNameWithArity externally
动 态 外 部 解 决 方 案
谓 词 的 外 部 解 决 方 案 也 提 供 了 动 态 地 从 DLL 中 加 载 私 有 和 公 用 类 谓 词 的 语 法 , 其 为 :
PredicateExternallyResolutionFromDLL :
PredicateNameWithArity externally from DllNameWithPath
DllNameWithPath :
StringLiteral
如 果 在 DLL DllNameWithPath 中 没 有 谓 词 predicateNameWithArity, 动 态 加 载 会 让 程 序 运 行
下 去 , 直 到 程 序 实 际 调 用 这 个 没 有 找 到 的 谓 词 , 这 时 就 会 出 现 运 行 时 错 误 。DllNameWithPath 是 程 序
运 行 的 机 器 上 的 DLL 的 路 径 , 它 可 以 是 绝 对 的 也 可 以 是 相 对 的 。 例 如 , 如 果 需 要 的 dll 是 在 应 用 程 序 所 在 位
置 的 上 一 级 目 录 中 , 就 可 以 用 “../DllName”。 参 看 MSDN 中 的 动 态 库 搜 索 次 序 。
终 结
对 象 一 旦 无 法 为 程 序 所 用 , 就 可 以 被 终 结 了 。 在 本 语 言 的 语 义 中 没 有 准 确 地 说 对 象 什 么 时 候 被 终 结 ,
能 保 证 的 是 : 只 要 程 序 还 能 访 问 某 个 对 象 , 它 就 不 会 被 终 结 。 实 际 上 对 象 的 终 结 , 是 当 它 被 垃 圾 收 集 器 废
掉 的 时 候 。 终 结 是 构 造 的 对 立 面 , 是 把 对 象 从 内 存 中 清 除 出 去 。
类 也 可 以 实 现 一 个 终 结 器 , 这 是 一 个 谓 词 , 一 个 对 象 终 结 时 调 用 它 ( 在 对 象 被 清 出 内 存 之 前 )。
终 结 器 是 一 个 过 程 , 没 有 参 数 , 没 有 返 回 值 , 其 名 称 是 finalize。 这 个 谓 词 是 隐 含 声 明 的 , 不 能 在 程
序 中 直 接 调 用 。
终 结 器 的 主 要 目 的 是 为 了 能 释 放 外 部 资 源 , 但 是 并 没 有 限 制 它 能 够 做 什 么 。 使 用 终 结 器 要 小 心 , 前 面
说 过 , 调 用 它 们 的 时 间 不 能 完 全 确 定 , 因 而 也 就 很 难 预 测 调 用 它 时 整 个 程 序 的 状 态 。
注 意 , 不 可 能 从 在 终 结 器 中 的 对 象 撤 消 对 象 事 实 , 因 为 终 结 过 程 是 自 动 进 行 的 。
程 序 终 止 前 , 所 有 对 象 都 要 被 终 结 ( 除 非 出 现 像 电 源 故 障 这 样 的 异 常 )。
例 这 个 例 子 中 , 用 一 个 终 结 器 来 保 证 正 确 地 关 闭 数 据 库 的 连 接 :
implement aa_class
facts
connection : databaseConnection.
clauses
27

Delegate 限 定 符
finalize() :-
connection:close().
...
end implement aa_class
delegate 段 包 含 有 一 些 委 托 项 :
DelegateQualification :
delegate Delegation-comma-sep-list
Delegation :
PredicateDelegation
InterfaceDelegation
委 托 限 定 符 用 于 将 对 象 谓 词 的 实 现 委 托 给 指 定 的 源 。
委 托 限 定 符 分 为 两 类 ,Predicate Delegation( 谓 词 委 托 ) 和 Interface Delegation( 接 口 委 托 )。
接 口 委 托 用 于 将 一 个 接 口 中 声 明 的 全 体 对 象 谓 词 的 实 现 委 托 给 另 一 个 对 象 的 实 现 , 存 储 为 事 实 变 量 。 这 就
是 说 , 接 口 委 托 就 是 将 该 接 口 声 明 的 所 有 谓 词 的 实 现 委 托 给 另 一 个 对 象 的 实 现 , 存 储 在 事 实 变 量 中 。
委 托 段 与 相 应 的 ( 谓 词 / 接 口 ) 解 决 方 案 段 相 似 , 只 不 过 需 要 委 托 事 实 变 量 来 保 存 构 造 的 类 的 对 象 ,
而 不 是 从 类 中 继 承 。
谓 词 委 托
对 象 谓 词 的 委 托 , 是 指 该 谓 词 的 功 能 委 托 给 由 事 实 变 量 FactVariable_of_InterfaceType 中 指
定 的 对 象 中 的 谓 词 。
PredicateDelegation :
PredicateNameWithArity to FactVariable_of_InterfaceType
要 委 托 一 个 谓 词 给 一 个 由 事 实 变 量 传 递 的 对 象 :
• 事 实 变 量 FactVariable_of_InterfaceType 必 须 具 有 声 明 谓 词 predicateNameWithArity
的 接 口 的 类 型 ( 或 子 类 型 )
• 对 象 支 持 的 接 口 必 须 已 经 构 造 好 了 , 并 且 已 经 与 FactVariable_of_InterfaceType 事 实 变
量 相 关 联 。
看 一 下 下 面 的 例 子 :
interface a
predicates
p1 : () procedure ().
p2 : () procedure ().
end interface
interface aa
supports a
end interface
class bb_class : a
end class
class cc_class : a
28

end class
class dd_class : aa
constructors
new : (a First, a Second).
end class
implement dd_class
delegate p1/0 to fv1, p2/0 to fv2
facts
fv1 : a.
fv2 : a.
clauses
new(I,J):-
fv1 := I,
fv2 := J.
end implement
后 面 , 它 就 可 以 构 造 a 类 型 的 对 象 , 并 将 其 赋 予 事 实 变 量 fv1 和 fv2, 来 定 义 对 象 , 这 个 对 象 的 类 就 是
我 们 实 际 要 委 托 定 义 p1 和 p2 功 能 的 类 。 来 看 :
goal
O_bb = bb_class::new(),
O_cc = cc_class::new(),
O_dd = dd_class::new(O_bb, O_cc),
O_dd : p1(),
% 这 个 p1 来 自 O_bb 对 象
O_dd : p2().
% 这 个 p2 来 自 O_cc 对 象
其 实 ,Visual Prolog 的 委 托 与 在 dd_class 的 实 现 中 添 加 子 句 明 确 地 指 出 要 从 哪 个 类 的 对 象 “ 输 出 ”
谓 词 的 功 能 , 效 果 是 一 样 的 。 对 上 面 这 个 例 子 , 也 就 是 在 dd_class 的 实 现 中 添 加 下 面 的 子 句 :
接 口 委 托
clauses
p1() :- fv1:p1().
如 果 需 要 指 定 在 InterfaceName 接 口 中 声 明 的 所 有 谓 词 的 功 能 都 委 托 给 来 自 相 同 继 承 类 的 对 象 谓
词 , 就 可 以 用 接 口 委 托 :
InterfaceDelegation :
interface InterfaceName to FactVariable_of_InterfaceType
接 口 委 托 就 是 将 在 接 口 InterfaceName 中 声 明 的 所 有 谓 词 的 功 能 委 托 给 存 储 为 事 实 变 量
FactVariable_of_InterfaceType 的 对 象 。 对 象 应 该 已 经 与 FactVariable_of_InterfaceType
事 实 变 量 相 关 联 , 而 这 个 事 实 变 量 的 类 型 应 该 是 InterfaceName 的 ( 或 是 其 子 类 型 )。
要 将 接 口 委 托 给 一 个 由 事 实 变 量 传 递 的 对 象 :
• 事 实 变 量 FactVariable_of_InterfaceType 必 须 是 接 口 InterfaceName 的 类 型 ( 或 是 其
子 类 型 )
• 对 象 支 持 的 接 口 必 须 已 经 构 造 , 并 且 已 经 与 事 实 变 量 FactVariable_of_InterfaceType 相
关 联 。
谓 词 委 托 的 优 先 级 高 于 接 口 委 托 。 如 果 一 个 谓 词 两 个 委 托 都 做 了 , 也 就 是 做 了 谓 词 委 托 , 而 它 又 是 在
一 个 接 口 中 声 明 的 , 这 个 接 口 又 做 了 委 托 , 这 时 , 将 实 现 高 优 先 级 的 谓 词 委 托 。
29

Namespaces( 名 称 空 间 )
名 称 空 间 可 以 用 于 避 免 名 称 冲 突 , 不 需 要 使 用 长 的 冷 僻 名 称 。 在 不 同 名 称 空 间 的 名 字 是 不 会 产 生 冲 突
的 , 但 可 能 需 要 用 名 称 空 间 来 指 定 引 用 以 解 决 模 糊 问 题 。
名 称 空 间 的 声 明 与 定 义 隐 含 地 使 用 NamespaceEntrance:
NamespaceEntrance:
namespace NamespaceIdentifier
NamespaceIdentifier: one of
LowercaseIdentifier
LowercaseIdentifier \ NamespaceIdentifier
简 单 地 说 ,NamespaceIdentifier 是 一 系 列 用 反 斜 杠 分 隔 的 小 写 标 识 。
Namespace 的 入 口 与 区 域
名 称 空 间 入 口 把 源 文 件 分 割 成 一 些 namespace regions( 名 称 空 间 区 域 )。 一 个 名 称 空 间 入 口 标
志 着 一 个 名 称 空 间 区 域 的 起 始 , 这 个 区 域 结 束 于 下 一 个 名 称 空 间 入 口 或 是 文 件 的 结 尾 。 每 个 文 件 开 始 于
root namespace( 根 名 称 空 间 )。
名 称 空 间 区 域 不 会 受 #include 指 令 的 影 响 , 也 就 是 说 , 在 一 个 #include- 文 件 中 的 名 称 空 间 入 口 不
会 改 变 包 括 文 件 的 名 称 空 间 区 域 。
任 何 文 件 都 起 始 于 根 名 称 空 间 ( 即 使 它 是 被 包 括 在 另 一 个 文 件 中 的 内 部 名 称 空 间 也 是 这 样 )。
任 何 在 一 个 名 称 空 间 区 域 中 汇 合 的 接 口 、 类 和 实 现 , 属 于 那 个 名 称 空 间 。
例
class aaa
end class aaa
namespace xxx
class bbb
end class bbb
namespace xxx\yyy
class ccc
end class ccc
这 个 文 件 分 成 了 三 个 区 域 ( 假 设 这 是 一 个 完 整 的 文 件 )。 第 一 个 区 域 是 根 名 称 空 间 (\), 第 二 个 区
域 是 属 于 xxx 名 称 空 间 的 , 而 第 三 个 区 域 是 属 于 xxx\yyy 名 称 空 间 的 。 相 应 地 , 类 aaa 属 于 根 名 称 空 间 ,
类 bbb 属 于 xxx 名 称 空 间 而 类 ccc 属 于 xxx\yyy 名 称 空 间 。
namespaces 中 的 引 用 名
如 果 ccc 是 在 名 称 空 间 xxx\yyy 中 的 一 个 类 , 那 么 ccc 的 全 称 (full name) 就 是 \xxx\yyy\ccc。
30

最 前 面 的 反 斜 杠 表 示 是 从 根 名 称 空 间 开 始 的 。 类 / 接 口 总 是 可 以 用 全 称 来 唯 一 性 地 引 用 。
Open namespaces
全 称 有 时 并 不 方 便 , 我 们 可 以 用 开 放 的 名 称 空 间 来 使 用 简 短 的 名 称 。
ScopeQualification: one of
OpenQualification
...
OpenQualification: one of
open NamespaceIdentifier \
...
开 放 的 名 称 空 间 是 由 结 尾 的 反 斜 杠 与 开 放 的 类 / 接 口 相 区 别 的 。
例
class aaa
open xxx\yyy\
...
end class aaa
名 称 空 间 xxx\yyy 在 aaa 中 是 开 放 的 。
当 一 个 名 称 空 间 是 开 放 的 时 , 其 全 称 部 分 就 可 以 省 掉 。 如 , 全 称 是 \xxx\yyy\zzz\ccc::ddd 的 一
个 域 , 可 以 在 aaa 中 用 zzz\ccc::ddd 来 引 用 , 因 为 xxx\yyy 是 开 放 的 。
注 意 , 略 写 的 名 称 不 是 用 反 斜 杠 开 头 的 , 用 反 斜 杠 开 头 的 名 称 总 是 全 称 。
属 于 某 个 范 围 ( 如 接 口 / 类 / 实 现 ) 的 名 称 空 间 , 在 那 个 范 围 内 部 是 ( 隐 含 地 ) 开 放 的 。
Program Sections( 程 序 段 )
以 下 各 段 用 于 在 范 围 内 声 明 和 定 义 实 体 。
Section :
ConstantsSection 常 数 段
DomainsSection 域 段
PredicatesSection 谓 词 段
ConstructorsSection 构 造 器 段
PropertiesSection 属 性 段
FactsSection 事 实 段
ClausesSection 子 句 段
ConditionalSection 条 件 段
上 面 的 段 并 不 会 都 出 现 在 所 有 类 型 的 范 围 内 , 详 细 情 况 请 参 考 接 口 、 类 声 明 和 类 实 现 。
条 件 段 在 条 件 编 译 一 节 中 叙 述 。
Domains( 域 )
Domains 段
31

域 段 在 当 前 范 围 中 定 义 了 一 组 域 ( 参 看 接 口 、 类 声 明 和 类 实 现 )。
Domain 定 义
DomainsSection:
domains DomainDefinition-dot-term-list-opt
域 定 义 在 当 前 范 围 中 对 一 个 命 名 了 的 域 作 详 细 说 明 。
DomainDefinition:
DomainName FormalTypeParameterList-opt = TypeExpression
如 果 右 边 的 域 表 示 一 个 接 口 或 一 个 复 合 域 , 则 定 义 的 域 与 类 型 表 达 式 是 同 义 的 ( 等 价 的 )。 否 则 , 定
义 的 域 就 是 类 型 表 达 式 表 示 的 域 的 子 类 型 。 这 里 , 域 名 DomainName 必 须 是 小 写 标 识 。
有 的 地 方 必 须 用 域 名 而 不 是 类 型 表 达 式 :
• 作 为 形 式 参 数 类 型 的 声 明 时 ;
• 作 为 常 数 或 事 实 变 量 的 类 型 时 ;
• 作 为 表 域 的 类 型 时 。
类 型 表 达 式
类 型 名
类 型 表 达 式 表 示 一 种 类 型 。
TypeExpression:
TypeName
CompoundDomain
ListDomain
PredicateDomain
IntegralDomain
RealDomain
TypeVariable
TypeApplication
类 型 名 是 一 个 接 口 的 名 字 或 是 一 个 值 域 的 名 字 。 值 域 是 指 其 元 素 是 非 易 变 的 ( 不 可 更 改 的 ) 域 。
这 里 我 们 可 以 说 , 对 象 是 属 于 相 应 于 接 口 名 的 域 , 具 有 易 变 的 状 态 , 而 其 它 的 域 则 是 非 易 变 的 。 因 此 ,
实 际 上 值 类 型 就 是 除 了 对 象 类 型 而 外 的 所 有 的 东 西 。 类 型 名 , 显 而 易 见 是 表 示 相 应 于 已 有 域 的 名 称 的 类 型
的 。
TypeName:
InterfaceName
DomainName
ClassQualifiedDomainName
InterfaceName:
LowercaseIdentifier
DomainName:
LowercaseIdentifier
32

ClassQualifiedDomainName:
ClassName::DomainName
ClassName:
LowercaseIdentifier
这 里 ,InterfaceName 是 接 口 名 ,DomainName 是 值 域 名 而 ClassName 是 类 名 。
例
domains newDomain1 = existingDomain. newDomain2 = myInterface.
在 上 面 这 个 例 子 中 , 分 别 用 域 名 existingDomain 和 接 口 名 myInterface 定 义 了 两 个 新 的 域 。
复 合 域
复 合 域 ( 也 称 为 代 数 数 据 类 型 ) 用 于 表 示 表 、 树 及 其 它 树 状 结 构 的 值 。 它 的 简 单 形 式 可 以 表 示 结 构 和
枚 举 值 。 复 合 域 可 以 递 归 定 义 , 可 以 互 递 归 或 间 接 递 归 。
CompoundDomain:
Alignment-opt FunctorAlternative-semicolon-sep-list>
Alignment:
align IntegralConstantExpression
这 里 的 IntegralConstantExpression 是 一 个 表 达 式 , 在 编 译 时 必 须 能 计 算 得 出 整 数 值 。
复 合 域 声 明 宣 布 了 一 个 函 子 选 项 表 , 还 带 有 可 选 的 alignment, 它 必 须 是 1、2 或 4。
如 果 复 合 域 包 含 一 个 函 子 选 项 , 则 可 以 视 其 为 结 构 , 它 的 表 示 方 法 与 C 语 言 的 相 应 结 构 是 二 进 制 兼 容
的 。
FunctorAlternative:
FunctorName FunctorName ( FormalArgument-comma-sep-list-opt )
这 里 的 FunctorName 是 函 子 选 项 名 称 , 应 该 用 小 写 标 识 。
FormalArgument:
TypeExpression ArgumentName-opt
这 里 的 ArgumentName 可 以 是 任 意 大 写 标 识 。 编 译 器 会 忽 略 它 。
复 合 域 对 其 它 任 何 域 都 没 有 子 类 型 的 关 系 。 如 果 一 个 域 定 义 和 一 个 复 合 域 的 相 同 , 则 这 两 个 域 是 同 义
类 型 的 而 不 是 子 类 型 。 也 就 是 说 , 这 两 个 域 是 不 同 名 称 相 同 类 型 的 。
例
domains
t1 = ff(); gg(integer, t1).
t1 是 一 个 有 两 个 选 项 的 复 合 域 , 第 一 个 选 项 是 零 元 函 子 ff, 而 第 二 个 选 项 是 二 元 函 子 gg, 它 带 有 一
个 integer 和 一 个 域 项 t1 本 身 作 为 参 数 。 因 此 , 域 t1 是 递 归 定 义 的 。
下 面 这 些 表 达 式 都 是 域 t1 的 项 :
33

ff()
gg(77, ff())
gg(33, gg(44, gg(55, ff())))
例
domains
t1 = ff(); gg(t2).
t2 = hh(t1, t1).
t1 是 有 两 个 选 项 的 复 合 域 , 第 一 个 选 项 是 零 元 函 子 ff, 而 第 二 个 选 项 是 一 元 函 子 gg, 它 以 域 项 t2 为
参 数 。t2 也 是 一 个 复 合 域 , 有 一 个 选 项 函 子 hh, 这 个 函 子 以 两 个 t1 项 为 参 数 。 因 而 , 域 t1 和 t2 是 互 递 归
的 。 下 面 这 些 项 都 是 域 t1 的 :
ff()
gg(hh(ff(), ff()))
gg(hh(gg(hh(ff(), ff())), ff()))
ggg(hh(ff(), g(hh(ff(), ff()))))
gg(hh(gg(hh(ff(), ff())), gg(hh(ff(), ff()))))
例 这 个 例 子 中 ,t1 和 t2 是 同 义 类 型 。
domains
t1 = f(); g(integer).
t2 = t1.
通 常 没 有 必 要 在 零 元 函 子 后 使 用 空 的 圆 括 号 。 但 在 域 定 义 中 , 如 果 仅 有 一 个 零 元 函 子 , 就 必 须 用 空 的
圆 括 号 来 与 同 义 / 子 类 型 定 义 相 区 分 。
例 t1 是 一 个 仅 有 一 个 零 元 函 子 的 复 合 域 , 而 t2 是 定 义 为 与 t1 同 义 的 。
domains
t1 = f().
t2 = t1.
List Domains( 表 域 )
表 域 表 示 某 个 域 中 的 一 个 序 列 值 。 因 此 , 所 有 在 表 T 中 的 元 素 都 必 须 是 T 类 型 的 。
ListDomain:
TypeName *
T* 是 T 元 素 表 的 类 型 。
下 面 一 些 语 法 应 用 于 表 :
ListExpression:
[ Term-comma-sep-list-opt ]
[ Term-comma-sep-list | Tail ]
Tail:
34

Term
这 里 Tail 是 其 值 为 ListDomain 类 型 的 项 。 每 个 Term 都 应 该 是 typeName 类 型 的 。
实 际 上 , 表 只 不 过 是 有 两 个 函 子 的 复 合 域 : 表 示 空 表 的 [] 和 表 示 表 头 HD 与 表 尾 TL 的 混 合 固 定 函 子
[HD|TL]。 表 头 必 须 是 基 本 元 素 类 型 , 而 表 尾 必 须 是 相 应 类 型 的 表 。
表 不 过 是 语 法 便 利 化 的 结 果 。
[E1, E2, E3, ..., En | L ] 是 [E1 |[ E2 |[ ...[ En | L ]...]]] 的 简 化 。
[E1, E2, E3, ..., En] 是 [E1, E2, E3, ..., En |[]] 的 简 化 , 而 后 者 又 是 [E1 |[ E2 |[ ...[ En |
[] ]...]]] 的 简 化 。
Predicate Domains( 谓 词 域 )
谓 词 域 的 值 是 带 有 相 同 特 征 的 谓 词 , 而 “ 相 同 特 征 ” 指 的 是 相 同 的 参 数 与 返 回 类 型 、 相 同 的 流 样 式 和
相 同 ( 或 更 强 的 ) 谓 词 模 式 。
返 回 值 的 谓 词 称 为 function( 函 数 ), 而 不 返 回 值 的 谓 词 有 时 也 称 为 原 态 ( 普 通 ) 谓 词 , 以 强 调 其
不 是 一 个 函 数 。
PredicateDomain:
( FormalArgument-comma-sep-list-opt ) ReturnArgument-opt
PredicateModeAndFlow-list-opt CallingConvention-opt
FormalArgument:
PredicateArgumentType VariableName-opt
Ellipsis
ReturnArgument:
-> FormalArgument
PredicateArgumentType:
TypeName
AnonymousIdentifier
VariableName:
UpperCaseIdentifier
谓 词 域 可 以 用 Ellipsis( 省 略 号 ) 参 数 作 为 FormalArgument-comma-sep-list 中 的 最 后 的
FormalArgument。
谓 词 域 可 以 用 AnonymousIdentifier 作 为 一 个 predicateArgumentType, 表 示 这 个 参 数 可 以 是
任 意 类 型 的 。
目 前 , 带 省 略 号 的 谓 词 域 只 能 用 在 谓 词 声 明 中 。
在 域 定 义 中 的 谓 词 域 最 多 只 能 声 明 一 个 流 样 式 。
PredicateModeAndFlow:
PredicateMode-opt
FlowPattern-list-opt
Predicate Mode( 谓 词 模 式 )
规 定 的 谓 词 模 式 适 用 于 其 后 流 样 式 表 中 的 各 个 成 员 。
PredicateMode: one of
35

erroneous
failure procedure
determ multi
nondeterm
谓 词 模 式 可 以 用 以 下 集 合 来 描 述 :
erroneous = {}
failure = {Fail}
procedure = {Succeed}
determ = {Fail, Succeed}
multi = {Succeed, BacktrackPoint}
nondeterm = {Fail, Succeed, BacktrackPoint}
集 合 中 有 Fail 就 意 味 着 这 个 谓 词 可 以 失 败 , 有 succeed 意 味 着 可 以 成 功 , 有 BacktrackPoint 意
味 着 可 以 由 有 效 的 回 溯 点 返 回 。
如 果 一 个 集 合 ( 比 如 说 failure) 是 另 一 个 集 合 ( 比 如 说 nondeterm) 的 子 集 , 则 称 其 模 式 比 另 一
个 强 , 也 就 是 failure 强 于 nondeterm。
谓 词 域 实 际 上 包 含 了 所 有 规 定 的 ( 或 更 强 的 ) 模 式 的 谓 词 ( 带 有 合 适 的 类 型 和 流 样 式 )。
对 构 造 器 声 明 谓 词 模 式 是 非 法 的 , 构 造 器 的 模 式 永 远 是 procedure。
缺 省 的 谓 词 模 式 是 procedure。
缺 省 流 样 式 表 示 所 有 参 数 都 用 于 输 入 。
注 意 , 与 Visual Prolog v. 5.x 不 同 , 实 现 内 部 ( 即 对 一 个 局 部 谓 词 ) 要 求 的 流 及 模 式 不 是 源 于 谓 词
的 用 法 。 现 在 , 在 对 局 部 谓 词 的 声 明 中 省 略 谓 词 模 式 表 示 是 procedure 而 省 略 流 样 式 表 示 所 有 参 数 是 输
入 。
如 果 在 一 个 实 现 内 部 需 要 明 确 地 规 定 一 个 谓 词 使 用 的 所 有 可 能 的 流 样 式 , 仍 然 可 以 把 这 个 责 任 交 给 编
译 器 。 对 类 实 现 内 这 个 任 务 , 可 以 使 用 特 殊 的 流 样 式 anyflow。 在 此 情 况 下 , 编 译 时 编 译 器 会 按 照 谓 词
的 用 法 得 到 需 要 的 流 样 式 。 但 如 果 在 流 样 式 前 anyflow 的 可 选 的 谓 词 模 式 缺 省 了 , 则 总 是 假 设 为
procedure 模 式 。
Flow Pattern( 流 样 式 )
流 样 式 定 义 参 数 的 输 入 / 输 出 流 向 。 参 数 可 以 与 函 子 域 相 结 合 , 使 得 单 个 的 参 数 一 部 分 是 输 入 而 另 一
部 分 是 输 出 。
流 样 式 由 一 个 流 序 列 构 成 , 每 个 流 对 应 于 一 个 参 数 ( 第 一 个 流 对 应 第 一 个 参 数 ,… 等 等 )。
FlowPattern:
( Flow-comma-sep-list-opt ) AnyFlow
Flow: one of
i
o
FunctorFlow
ListFlow
Ellipsis
省 略 流 必 须 与 省 略 参 数 相 对 应 , 因 而 它 只 能 是 流 样 式 中 的 最 后 一 个 流 。
Ellipsis:
...
36

函 子 流 FunctorFlow 说 明 一 个 函 子 及 其 各 成 分 的 流 。 当 然 , 函 子 必 须 在 相 应 参 数 的 域 中 。
FunctorFlow:
FunctorName ( Flow-comma-sep-list-opt )
函 子 流 声 明 中 不 能 含 有 省 略 流 。
表 流 与 函 子 流 相 似 , 只 不 过 是 采 用 了 与 表 域 相 同 的 语 法 加 工 。
ListFlow:
[ Flow-comma-sep-list-opt ListFlowTail-opt]
ListFlowTail:
| Flow
表 流 也 不 能 含 有 省 略 流 。
声 明 谓 词 时 流 样 式 可 以 省 略 。 在 实 现 内 部 ( 即 对 局 部 谓 词 ) 需 要 的 流 样 式 得 自 于 谓 词 的 使 用 方 法 。 在
接 口 或 类 声 明 内 部 ( 即 对 公 有 谓 词 ) 省 略 流 样 式 表 示 所 有 参 数 都 是 输 入 。
特 殊 流 样 式 anyflow 只 能 在 局 部 谓 词 的 声 明 ( 即 在 类 实 现 内 部 的 谓 词 声 明 ) 中 使 用 。 它 表 示 准 确 的
流 样 式 在 编 译 时 确 定 。 如 果 其 前 可 选 的 谓 词 模 式 省 略 了 , 表 示 谓 词 模 式 是 procedure。
例
domains
pp1 = (integer Argument1).
pp1 是 一 个 谓 词 域 。 这 个 具 有 pp1 类 型 的 谓 词 有 一 个 integer 参 数 。 因 为 没 有 写 出 流 样 式 , 表 示 这 个
参 数 是 输 入 , 又 因 为 没 有 写 出 谓 词 模 式 , 表 示 谓 词 是 procedure。
例
domains
pp2 = (integer Argument1) -> integer ReturnType.
pp2 类 型 的 谓 词 有 一 个 integer 参 数 并 返 回 integer 类 型 的 值 。 因 而 ,pp2 是 一 个 函 数 域 , 具 有 pp2
类 型 的 谓 词 实 际 上 是 函 数 。 因 为 没 有 说 明 流 样 式 , 所 以 参 数 是 输 入 的 , 谓 词 模 式 也 没 提 , 故 谓 词 是
procedure 的 。
例
predicates
ppp : (integer Argument1, integer Argument2) determ (o,i) (i,o) nondeterm (o,o).
谓 词 ppp 有 两 个 integer 参 数 , 它 有 三 种 不 同 的 流 样 式 :(o,i) 和 (i,o) 是 determ 的 ,(o,o) 是
nondeterm 的 。
调 用 约 定
调 用 约 定 确 定 了 参 数 等 如 何 传 递 给 谓 词 , 它 也 确 定 了 如 何 由 谓 词 名 得 到 链 接 名 。
37

CallingConvention:
language CallingConventionKind
CallingConventionKind: one of
c stdcall apicall prolog
如 果 没 有 说 明 调 用 约 定 , 则 使 用 prolog 约 定 , 它 是 Prolog 谓 词 使 用 的 标 准 约 定 。
c 调 用 约 定 遵 从 C/C++ 的 标 准 调 用 约 定 。 谓 词 的 链 接 名 是 谓 词 名 前 加 下 划 线 (_)。
的 实 现 :
stdcall 调 用 约 定 使 用 c 的 链 接 名 策 略 , 但 参 数 与 栈 的 处 理 规 则 有 不 同 。 下 表 说 明 了 stdcall 调 用 约 定
特 征
参 数 传 递 顺 序
参 数 传 递 约 定
栈 的 维 护 职 责
名 字 的 装 饰
大 小 写 转 换 约 定
从 右 到 左
实 现
除 复 合 域 项 传 递 , 都 是 传 递 的 值 。 因 此 , 它 不 能 应 用 于 参 数 数 量 可 变 的 谓 词
被 调 用 的 谓 词 从 栈 中 弹 出 自 己 的 参 数
在 谓 词 名 前 的 一 个 下 划 线 (_)
不 做 谓 词 名 的 大 小 写 转 换
apicall 调 用 约 定 使 用 与 stdcall 一 样 的 参 数 和 栈 处 理 规 则 , 但 为 了 方 便 MS Windows API 函 数 的 调
用 使 用 了 大 多 数 MS Windows API 函 数 调 用 所 用 的 命 名 约 定 。 根 据 该 约 定 , 谓 词 的 链 接 名 构 造 方 法 如 下 :
• 在 谓 词 名 前 加 下 划 线 (_);
• 谓 词 名 的 首 字 母 改 为 大 写 ;
• 如 果 参 数 或 返 回 类 型 是 ANSI 的 , 加 后 缀 “A”, 如 果 是 Unicode 的 , 加 后 缀 “W”, 中 性 谓 词
什 么 都 不 加 ;
• 加 “@” 后 缀 ;
• 后 面 附 加 推 入 栈 中 的 字 节 数 。
例
predicates
predicateName : (integer, string) language apicall
这 个 谓 词 的 参 数 类 型 表 明 它 是 一 个 Unicode 谓 词 ( 因 为 string 是 Unicode 串 域 的 )。 一 个 integer 和 一
个 string 各 占 调 用 栈 的 4 字 节 , 因 而 , 它 的 链 接 名 就 是 :
_PredicateNameW@8
如 果 apicall 与 “as” 构 造 一 并 使 用 , 在 “as” 构 造 中 说 明 的 名 称 使 用 与 上 面 相 同 的 方 法 。
apicall 只 能 直 接 使 用 在 谓 词 声 明 中 , 不 能 用 在 谓 词 域 定 义 中 。 谓 词 域 定 义 中 必 须 替 代 使 用 stdcall。
下 表 比 较 了 c、apicall 及 stdcall 调 用 约 定 的 实 现 (prolog 调 用 约 定 有 特 殊 的 实 现 , 这 里 没 有 讨 论 ):
类 型 清 栈 职 责 谓 词 名 大 小 写 转 换 链 接 名 构 造 方 法
c 调 用 谓 词 从 栈 中 弹 出 参 数 不 转 换 谓 词 名 前 加 下 划 线 (_)
stdcall 被 调 用 谓 词 从 栈 中 弹 出 自 己 不 转 换
谓 词 名 前 加 下 划 线 (_)
的 参 数
apicall 被 调 用 谓 词 从 栈 中 弹 出 自 己
的 参 数
谓 词 名 首 字 母 转 换
为 大 写
谓 词 名 前 加 下 划 线 (_), 首 字 母 换 为
大 写 , 加 “A” 或 “W” 后 缀 , 加 “@”
后 缀 , 加 参 数 字 节 数 ( 十 进 制 )
38

Visaul Prolog 谓 词 域 的 概 念 覆 盖 了 类 和 对 象 的 成 员 。 类 成 员 的 处 理 是 直 接 向 前 的 , 但 对 象 成 员 的 处
理 需 要 注 意 。 对 象 谓 词 的 调 用 将 “ 回 退 ” 到 拥 有 该 成 员 的 对 象 关 联 中 。
例
设 有 如 下 声 明 :
interface actionEventSource
domains
actionListener = (actionEventSource Source) procedure (i).
predicates
addActionListener : (actionListener Listener) procedure (i).
...
end interface
再 假 设 有 一 个 button_class 类 支 持 actionEventSource。 点 击 按 钮 时 传 递 事 件 。 在
myDialog_class 类 中 实 现 一 个 对 话 框 , 创 建 一 个 按 钮 并 监 听 它 的 动 作 事 件 以 作 出 反 应 :
implement myDialog_class
clauses
new() :-
OkButton = button_class::new(...),
OkButton:addActionListener(onOk),
...
facts
okPressed : () determ.
predicates
onOk : actionListener.
clauses
onOk(Source) :-
assert(okPressed()).
end implement
在 这 个 例 子 中 重 要 的 是 onOk 是 一 个 对 象 成 员 , 而 且 , 当 按 了 按 钮 后 , 注 册 了 的 onOk 的 调 用 会 将 我
们 带 回 给 拥 有 onOk 的 对 象 。 也 就 是 说 , 我 们 能 访 问 对 象 事 实 okPressed, 这 样 我 们 才 能 插 入 事 实 。
Format Strings( 格 式 串 )
对 谓 词 的 格 式 参 数 , 可 以 用 formatstring 属 性 标 记 成 格 式 串 。 格 式 串 中 可 以 有 原 态 字 符 , 这 样 的 字
符 是 不 加 修 饰 地 原 样 打 印 的 , 还 有 以 百 分 号 (%) 开 头 的 格 式 域 。 如 果 % 后 面 的 是 未 知 字 符 ( 不 是 格 式 符 ),
则 百 分 号 和 这 个 字 符 也 会 原 样 打 印 。
例
predicates
writef : (string Format [formatstring], ...) procedure (i,...).
格 式 域 的 构 成 是 :
[-][0][width][.precision][type]
上 述 所 有 组 份 都 是 可 选 的 。
连 字 符 [-] 表 示 这 个 域 是 右 对 齐 的 ; 缺 省 是 左 对 齐 。 如 果 宽 度 值 [width] 没 有 设 置 , 或 是 实 际 字 符 数 比
宽 度 值 还 要 大 , 则 没 有 效 果 。
宽 度 前 的 零 [0] 表 示 对 值 要 添 加 零 直 到 达 到 最 小 宽 度 。 如 果 零 和 连 字 符 一 同 出 现 , 零 就 被 忽 略 了 。
39

宽 度 [width] 是 正 的 十 进 制 数 , 表 示 域 段 的 最 小 宽 度 。 如 果 实 际 字 符 数 小 于 这 个 值 , 就 要 在 值 的 前 面
( 若 设 置 了 ‘-’ 则 是 在 后 面 ) 添 加 空 格 字 符 。 如 果 实 际 字 符 数 比 这 个 值 大 , 就 没 有 什 么 改 变 。
点 之 后 带 无 符 号 十 进 制 数 [.precision] 表 示 浮 点 数 精 度 , 也 可 以 表 示 从 一 个 串 里 最 多 打 印 出 的 字 符 数 。
[type] 规 定 了 缺 省 之 外 其 它 一 些 格 式 。 如 , 在 该 域 可 以 用 一 个 规 定 符 表 示 一 个 整 数 要 格 式 化 为 一 个 无
符 号 数 。 可 用 值 为 :
f 将 实 数 格 式 化 为 定 点 十 进 制 数 , 如 123.4,0.004321。 这 是 实 数 的 缺 省 格 式 。
e 将 实 数 格 式 化 为 指 数 表 示 法 , 如 1.234e+002,4.321e-003。
g 将 实 数 格 式 化 为 f 和 e 格 式 中 较 短 的 那 种 , 但 当 指 数 值 小 于 -4 或 大 于 等 于 精 度 时 总 是 用 e 格
式 。 尾 零 都 要 被 截 去 。
d 或 D 格 式 化 为 有 符 号 十 进 制 数 。
u 或 U 格 式 化 为 无 符 号 整 数 。
x 或 X 格 式 化 为 十 六 进 制 数 。
o 或 O 格 式 化 为 八 进 制 数 。
c 格 式 化 为 一 个 字 符 。
B 格 式 化 为 Visual Prolog 的 二 进 制 类 型 。
R 格 式 化 为 数 据 库 索 引 数 。
P 格 式 化 为 过 程 参 量 。
s 格 式 化 为 串 。
Integral Domains( 整 数 域 )
整 数 域 用 于 表 示 整 数 , 它 分 成 两 个 主 要 类 型 : 有 符 号 数 和 无 符 号 数 。 整 数 域 也 有 不 同 的 表 示 范 围 , 预
定 义 的 域 integer 和 unsigned 表 示 有 符 号 的 和 无 符 号 的 整 数 , 是 处 理 器 架 构 ( 如 32 位 机 器 上 的 32 位 , 等 )
的 固 定 表 示 长 度 。
IntegralDomain:
DomainName-opt IntegralDomainProperties
如 果 在 IntegralDomainPropertie 前 面 有 DomainName, 那 么 它 本 身 必 须 是 整 数 域 的 , 接 下
来 的 域 是 这 个 域 的 一 个 子 类 型 。 此 时 ,IntegralDomainProperties 不 能 违 反 作 为 一 个 子 类 型 的 可 能
性 , 也 就 是 说 , 数 值 表 示 不 能 超 范 围 , 不 能 改 变 比 特 位 数 。
IntegralDomainProperties:
IntegralSizeDescription IntegralRangeDescription-opt
IntegralRangeDescription IntegralSizeDescription-opt
IntegralSizeDescription:
bitsize DomainSize
DomainSize:
IntegralConstantExpression
IntegralSizeDescription( 整 数 尺 度 描 述 ) 说 明 该 整 数 域 的 DomainSize 大 小 , 以 比 特 为 单 位 。 编
译 器 会 以 不 小 于 这 个 规 定 的 比 特 位 数 实 现 这 个 整 数 域 。DomainSize 的 值 应 该 是 正 数 并 且 不 能 超 过 编 译
器 支 持 的 最 大 值 ( 对 v 6.x 来 说 是 32 位 )。 如 果 省 略 了 整 数 尺 度 描 述 , 就 使 用 和 父 域 一 样 的 尺 度 。 如 果 没
有 父 域 , 则 使 用 处 理 器 的 本 身 的 尺 度 。
IntegralRangeDescription:
40

[ MinimalBoundary-opt .. MaximalBoundary-opt ]
MinimalBoundary:
IntegralConstantExpression
MaximalBoundary:
IntegralConstantExpression
IntegralRangeDescription( 整 数 界 限 描 述 ) 说 明 该 整 数 域 最 小 值 MinimalBoundary 和 最 大 值
MaximalBoundary。 如 果 省 略 了 , 就 使 用 父 域 的 界 限 。 如 果 没 有 父 域 , 就 使 用 DomainSize 来 确 定
相 应 的 最 小 值 和 最 大 值 。
注 意 , 最 小 值 不 能 大 于 最 大 值 , 也 就 是 :
MinimalBoundary

这 里 的 RealConstantExpression 是 一 个 表 达 式 , 在 编 译 时 它 被 计 算 出 一 个 浮 点 值 。 也 就 是 说 ,
在 编 译 时 该 实 数 域 的 精 度 和 界 限 必 须 是 可 计 算 的 。
RealRangeDescription( 实 数 界 限 描 述 ) 说 明 该 实 数 域 最 小 值 和 最 大 值 。 如 果 省 略 了 , 就 使 用 父 域
的 界 限 。 如 果 没 有 父 域 , 就 使 用 最 大 可 用 精 度 。
注 意 , 最 小 值 不 能 大 于 最 大 值 , 也 就 是 :
MinimalBoundary

常 数
Constants 段
constants 段 在 当 前 范 围 内 定 义 一 组 常 数 。
常 数 定 义
ConstantsSection :
constants ConstantDefinition-dot-term-list-opt
常 数 定 义 规 定 命 名 了 的 常 数 , 它 的 类 型 , 它 的 值 。
ConstantDefinition: one of
ConstantName = ConstantValue
ConstantName : TypeName = ConstantValue
ConstantName:
LowerCaseIdentifier
ConstantValue 应 该 为 表 达 式 , 在 编 译 时 应 该 能 计 算 得 到 值 并 且 具 有 相 应 域 的 类 型 。
ConstantName 应 该 是 小 写 标 识 。
只 有 对 下 列 内 建 的 域 才 可 以 省 略 类 型 名 :
1. 数 值 ( 即 整 数 或 实 数 ) 常 数 。 在 这 种 情 况 下 , 对 常 数 使 用 相 应 匿 名 数 字 域 ( 详 细 请 参 见 数 字 域 )。
2. 二 进 制 常 数 。
3. 串 常 数 。
4. 字 符 常 数 。
例
constants
my_char = 'a'.
true_const : boolean = true.
binaryFileName = "mybin".
myBinary = #bininclude(binaryFileName).
Predicates( 谓 词 )
Predicates 段
谓 词 段 在 当 前 范 围 内 声 明 一 组 对 象 或 类 谓 词 。
PredicatesSection :
class-opt predicates PredicateDeclaration-dot-term-list-opt
关 键 字 class 只 能 用 在 类 实 现 中 。 对 于 谓 词 , 在 接 口 中 声 明 的 总 是 对 象 谓 词 , 而 在 类 声 明 中 声 明 的 ,
总 是 类 谓 词 。
43

Predicate Declarations( 谓 词 声 明 )
谓 词 声 明 用 于 在 一 个 范 围 内 声 明 谓 词 , 在 这 个 范 围 内 , 该 谓 词 是 可 见 的 。 当 谓 词 在 接 口 定 义 中 声 明 时 ,
就 意 味 着 相 应 类 型 的 对 象 必 须 支 持 这 些 谓 词 。 当 谓 词 在 类 声 明 中 声 明 时 , 就 意 味 着 该 类 公 有 地 支 持 所 声 明
的 谓 词 。 而 如 果 谓 词 是 在 类 实 现 中 声 明 的 , 则 意 味 着 谓 词 是 局 部 的 。 不 管 在 哪 种 情 况 下 , 必 须 有 谓 词 的 相
应 定 义 。
PredicateDeclaration :
PredicateName : PredicateDomain LinkName-opt
PredicateName : PredicateDomainName LinkName-opt
LinkName :
as StringLiteral
PredicateName :
LowerCaseIdentifier
这 里 ,predicateDomainName( 谓 词 域 名 ) 是 在 域 段 中 声 明 的 谓 词 域 的 名 称 。
谓 词 声 明 规 定 了 谓 词 的 名 称 、 它 的 类 型 、 模 式 、 流 ( 参 见 谓 词 域 ) 及 可 选 的 链 接 名 。
只 有 类 谓 词 才 可 以 有 链 接 名 , 如 果 没 有 说 明 链 接 名 则 会 依 据 调 用 约 定 由 谓 词 名 产 生 相 应 的 链 接 名 。 如
果 调 用 约 定 是 apicall, 则 这 个 链 接 名 还 要 由 as 子 句 加 工 。 如 果 不 做 这 个 加 工 , 就 使 用 替 代 的 stdcall 调 用
约 定 。
链 接 名 的 缀 饰 加 工
有 时 链 接 名 必 须 有 _...@N 的 缀 饰 , 但 apicall 来 的 缺 省 名 则 是 错 的 。 在 这 样 的 缀 饰 中 , 后 缀 的 A 和 后 缀
的 W 可 以 用 于 控 制 缀 饰 加 工 :
predicates
myPredicate : (string X) language stdcall as decorated.
在 这 种 情 况 下 , 链 接 名 会 是 “_MyPredicate@4”, 而 apicall 会 使 它 成 为 “_MyPredicateW@4”。
predicates
myPredicate : (string X) language stdcall as decoratedA.
在 这 种 情 况 下 , 链 接 名 会 是 “_MyPredicateA@4”, 而 apicall 会 使 它 成 为 “_MyPredicate@4”。
predicates
myPredicate : (string X) language stdcall as decoratedW.
在 这 种 情 况 下 , 链 接 名 会 是 “_MyPredicateW@4”, 而 apicall 会 使 它 成 为 “_MyPredicate@4”。
上 述 所 有 情 况 中 , 都 是 把 名 称 由 xxxx 变 为 _Xxxx, 并 加 上 后 缀 @N。 第 一 种 情 况 不 用 后 缀 的 字 母 , 第
二 种 情 况 总 是 后 缀 A, 而 第 三 种 情 况 总 是 后 缀 W。 这 就 是 说 , 编 程 者 负 责 确 定 使 用 需 要 的 后 缀 , 不 过 不 需
要 操 心 计 算 参 数 的 字 节 数 和 起 始 的 “_X”( 加 下 划 线 和 把 首 字 母 改 为 大 写 )。
Constructors 段
constructors 段 声 明 一 组 构 造 器 。 构 造 器 属 于 constructors 段 所 在 的 范 围 ( 参 见 类 声 明 和 类 实
44

现 )。
ConstructorsSection :
constructors ConstructorDeclaration-dot-term-list-opt
构 造 器 段 只 能 在 构 造 对 象 的 类 的 声 明 和 实 现 中 出 现 。
Constructor 声 明
构 造 器 声 明 说 明 类 的 命 名 了 的 构 造 器 。
一 个 构 造 器 实 际 上 有 两 个 相 关 的 谓 词 :
• 一 个 类 函 数 , 这 个 函 数 能 返 回 一 个 新 构 造 的 对 象 ,
• 一 个 对 象 谓 词 , 该 谓 词 用 来 初 始 化 继 承 的 对 象 。
相 关 的 构 造 器 对 象 谓 词 用 于 进 行 对 象 的 初 始 化 。 这 个 谓 词 只 能 在 该 类 本 身 由 该 构 造 器 调 用 , 或 是 由 继
承 这 个 类 的 一 个 类 的 构 造 器 调 用 ( 即 基 类 初 始 化 )。
ConstructorDeclaration :
ConstructorName : PredicateDomain
不 能 对 构 造 器 说 明 谓 词 模 式 , 构 造 器 总 是 procedure 模 式 的 。
例 看 一 下 如 下 的 类 :
class test_class : test
constructors
new : (integer Argument).
end class test_class
相 关 的 类 谓 词 有 如 下 特 征 :
class predicates
new : (integer) -> test.
而 相 关 的 对 象 谓 词 特 征 如 下 :
predicates
new : (integer).
再 来 看 一 下 如 下 的 实 现 :
implement test2_class inherits test_class
clauses
new() :-
test_class::new(7),
% 在 "This" 上 调 用 基 类 构 造 器
p(test_class::new(8)). % 创 建 基 类 一 个 新 对 象 并 把 它 传 递 给 p(...)
...
对 test_class::new 的 第 一 个 调 用 并 不 返 回 一 个 值 , 因 此 它 是 一 个 对 构 造 器 的 非 函 数 对 象 版 本 的 调
用 , 也 就 是 说 , 它 是 在 This 上 的 基 类 构 造 器 的 一 个 调 用 。
而 第 二 个 调 用 则 确 实 返 回 一 个 值 , 因 此 它 是 对 构 造 器 类 函 数 版 本 的 一 个 调 用 , 也 就 是 说 , 它 创 建 一 个
新 的 对 象 。
45

Predicates from Interface( 来 自 接 口 的 谓 词 )
一 个 接 口 可 以 支 持 其 它 接 口 的 一 个 子 集 , 这 是 通 过 在 谓 词 from 段 声 明 谓 词 实 现 的 。predicates
from 段 列 出 接 口 及 所 有 支 持 的 谓 词 。 对 谓 词 的 说 明 可 以 是 谓 词 的 名 称 或 名 称 加 元 维 。
一 个 接 口 支 持 另 外 接 口 的 子 集 时 , 它 既 不 是 这 个 另 外 的 接 口 的 子 类 , 也 不 是 它 的 超 类 。
对 predicates from 段 来 说 , 重 要 的 一 点 是 : 所 有 列 出 的 谓 词 都 保 留 在 原 来 的 接 口 中 , 因 此 :
• 来 自 原 来 接 口 的 谓 词 不 会 有 支 持 冲 突 ;
• 它 们 可 以 作 为 谓 词 由 原 来 的 接 口 中 继 承 。
PredicatesFromInterface :
predicates from InterfaceName PredicateNameWithArity-comma-sep-list-opt
PredicatesFromInterface 只 能 用 在 接 口 定 义 中 。
例
interface aaa
predicates
ppp : ().
qqq : ().
end interface aaa
interface bbb
predicates from aaa
ppp
predicates
rrr : ().
end interface bbb
interface ccc supports aaa, bbb
end interface ccc
尽 管 aaa 和 bbb 都 各 声 明 了 一 个 谓 词 ppp,ccc 还 是 可 以 无 冲 突 地 支 持 这 两 者 , 因 为 在 所 有 情 况 下
ppp 都 有 aaa 作 为 源 接 口 。
例
interface aaa
predicates
ppp : ().
qqq : ().
end interface aaa
interface bbb
predicates from aaa
ppp
predicates
rrr : ().
end interface bbb
class aaa_class : aaa
end class aaa_class
46

class bbb_class : bbb
end class bbb_class
implement aaa_class inherits bbb_class
clauses
qqq().
end implement aaa_class
aaa_class 可 以 由 bbb_class 类 继 承 ppp, 因 为 ppp 在 两 个 类 中 有 aaa 作 为 源 接 口 。
Arity( 元 维 )
一 个 谓 词 带 有 N 个 参 数 时 , 就 称 其 是 N 元 (N-ary) 的 , 或 说 元 维 是 N(arity N) 的 。 不 同 元 维 的 谓
词 是 不 同 的 谓 词 , 即 使 它 们 的 名 称 相 同 也 是 这 样 。
在 大 多 数 情 况 下 , 谓 词 的 元 维 是 清 楚 的 , 可 以 从 上 下 文 中 看 出 来 。 但 有 些 时 候 就 不 明 显 了 , 比 如 在 谓
词 的 from 段 里 以 及 在 使 用 resolve 限 定 符 时 就 可 能 会 出 现 这 样 的 问 题 。
为 了 能 够 区 分 谓 词 的 不 同 元 维 , 在 predicates from 段 里 及 使 用 resolve 限 定 符 时 , 可 以 选 用 谓 词
名 称 加 元 维 的 方 法 来 说 明 。 可 以 使 用 如 下 的 方 法 :
• Name/N 表 示 元 维 是 N 的 本 原 谓 词 Name( 即 不 是 一 个 函 数 ),
• Name/N-> 表 示 元 维 是 N 的 函 数 Name,
• Name/N... 表 示 带 有 N 个 参 数 后 跟 一 个 Ellipsis( 省 略 符 ) 参 数 ( 即 参 数 数 量 可 变 ) 的 本 原 谓
词 Name。( 省 略 号 可 以 在 谓 词 及 谓 词 域 的 声 明 中 作 为 最 后 一 个 形 式 参 数 使 用 , 此 时 它 表 示 所 声
明 的 谓 词 ( 谓 词 域 ) 有 可 变 数 量 的 参 数 。 省 略 流 必 须 与 省 略 参 数 相 匹 配 , 故 此 也 只 能 是 流 样 式 中
的 最 后 一 个 流 。)
• Name/N...-> 表 示 一 个 带 有 N 个 参 数 后 跟 一 个 省 略 参 数 的 函 数 Name。
PredicateNameWithArity :
PredicateName Arity-opt
Arity : one of
/ IntegerLiteral Ellipsis-opt
/ IntegerLiteral Ellipsis-opt ->
在 Name/0... 和 Name/0...-> 的 情 况 中 , 零 是 可 以 省 去 的 , 因 而 也 可 以 分 别 写 成 Name/... 和
Name/...->。
Properties( 属 性 )
属 性 段 声 明 在 当 前 范 围 内 对 象 或 类 的 属 性 。
声 明
PropertyDeclaration :
PropertyName : PropertyType FlowPattern-list-opt.
FlowPattern: one of
(i)
47

(o)
属 性 的 声 明 类 似 于 single 事 实 。
如 果 流 样 式 省 略 了 , 就 认 为 即 可 以 是 (i) 又 可 以 是 (o)。 例 如 :
interface ip
properties
duration : integer.
initialized : boolean.
scale : string.
end interface
属 性 用 起 来 与 实 现 中 的 single 事 实 是 一 样 的 。 可 以 用 范 围 名 称 或 对 象 来 修 饰 限 制 属 性 。
设 X 是 一 个 支 持 接 口 ip 的 对 象 :
X:duration := 5,
if X:initialized = true then ... else ... end if,
X:scale := "meter",
....
在 ip 的 实 现 内 部 , 可 以 如 同 它 们 是 事 实 一 样 来 访 问 它 们 :
duration := 5,
if initialized = true then ... else ... end if,
scale := "meter",
....
Implementation( 实 现 )
属 性 是 通 过 定 义 一 个 获 取 值 的 函 数 及 一 个 适 当 的 设 置 值 的 谓 词 来 实 现 的 。
如 :
clauses
duration() = duration_fact * scale.
duration(D):- duration_fact := D/ scale.
或 是 把 一 个 相 同 名 字 的 事 实 用 作 属 性 :
facts
initialized : boolean := false.
不 能 让 设 置 和 获 取 谓 词 与 事 实 同 名 。 如 果 想 用 一 个 事 实 来 存 放 一 个 属 性 的 值 ( 我 们 经 常 这 样 做 ), 就
必 须 给 事 实 另 一 个 名 字 , 如 :
properties
duration : integer.
facts
duration_fact : integer.
clauses
duration() = duration_fact.
clauses
duration(D) :-
OldDuration = duration_fact,
duration_fact := D,
48

OldDuration D,
!,
sendChanged().
duration(_D).
不 能 把 duration 当 谓 词 ( 这 不 奇 怪 , 因 为 它 们 不 是 声 明 为 谓 词 而 是 声 明 为 属 性 的 ; 它 只 是 实 现 属 性 的
存 和 取 的 方 法 的 )。 但 是 , 谓 词 的 名 称 它 占 用 了 , 所 以 不 能 用 duration\1 或 duration\0-> 再 声 明 谓 词 。
实 现 的 细 节
当 访 问 一 个 在 接 口 中 声 明 的 属 性 时 , 关 于 它 的 实 现 不 能 做 任 何 假 设 , 因 而 也 就 不 得 不 认 为 它 是 用 谓 词
实 现 的 。 如 果 程 序 员 是 把 这 个 属 性 当 事 实 定 义 的 , 编 译 器 就 必 须 产 生 适 当 的 谓 词 , 当 通 过 一 个 接 口 来 访 问
这 个 属 性 时 , 就 使 用 它 们 。 而 在 实 现 内 部 , 定 义 为 事 实 的 属 性 就 可 以 当 成 事 实 来 访 问 。
限 制 读 写
有 的 时 候 , 想 让 一 个 属 性 只 能 读 或 只 能 写 。 假 设 我 们 用 i/o 范 式 声 明 它 们 :
duration : integer (o). % 一 个 只 读 的 属 性
duration : integer (i). % 一 个 只 写 的 属 性
duration : integer (o) (i). % 一 个 正 常 的 属 性 , 可 以 读 也 可 以 写 , 与 什 么 都 不 说 明 一 样
duration : integer. % 与 上 面 声 明 的 一 样 。.
如 果 属 性 声 明 为 只 读 , 就 可 以 只 声 明 取 (get) 谓 词 , 同 样 , 如 果 是 声 明 为 只 写 就 可 以 只 声 明 设 置 (set)
谓 词 。
当 然 , 如 果 属 性 是 当 成 事 实 来 实 现 的 , 在 实 现 内 部 就 可 以 把 它 当 成 一 个 普 通 的 事 实 来 使 用 。
Properties from Interface( 来 自 接 口 的 属 性 )
一 个 接 口 可 以 支 持 另 一 个 接 口 的 子 集 , 这 是 通 过 在 属 性 from 段 声 明 属 性 实 现 的 。properties from
段 列 出 接 口 及 所 有 支 持 的 属 性 。
一 个 接 口 支 持 另 外 接 口 的 子 集 时 , 它 既 不 是 这 个 另 外 的 接 口 的 子 类 , 也 不 是 它 的 超 类 。
对 properties from 段 来 说 , 重 要 的 一 点 是 : 所 有 列 出 的 属 性 都 保 留 在 原 来 的 接 口 中 , 因 此 :
• 它 们 可 以 作 为 属 性 由 原 来 的 接 口 中 继 承 。
PropertiesFromInterface :
properties from InterfaceName PpropertyName-comma-sep-list-opt
PropertiesFromInterface 只 能 用 在 接 口 定 义 中 。
例
interface aaa
properties
pp : integer.
qq : boolean.
end interface aaa
interface bbb
properties from aaa
49

pp
properties
rr : string.
end interface bbb
interface ccc supports aaa, bbb
end interface ccc
尽 管 aaa 和 bbb 都 各 声 明 了 一 个 属 性 ppp,ccc 还 是 可 以 无 冲 突 地 支 持 这 两 者 , 因 为 在 所 有 情 况 下
ppp 都 有 aaa 作 为 源 接 口 。
例
interface aaa
properties
pp : integer.
qq : boolean.
end interface aaa
interface bbb
properties from aaa
pp
properties
rr : string.
end interface bbb
class aaa_class : aaa
end class aaa_class
class bbb_class : bbb
end class bbb_class
implement aaa_class inherits bbb_class
facts
pp_fact(): integer.
clauses
pp()= pp_fact-3.
clauses
pp(D):- pp_fact:=D+3.
end implement aaa_class
aaa_class 可 以 由 bbb_class 类 继 承 pp, 因 为 pp 在 两 个 类 中 有 aaa 作 为 源 接 口 。
Facts
facts 段 声 明 一 个 事 实 数 据 库 , 它 是 由 一 些 事 实 构 成 的 。 事 实 数 据 库 和 事 实 是 属 于 当 前 范 围 的 。
事 实 数 据 库 可 是 是 类 一 级 的 , 也 可 以 是 对 象 一 级 的 。
事 实 数 据 库 只 能 在 类 实 现 中 声 明 。
如 果 事 实 数 据 库 有 名 称 , 也 就 隐 含 地 附 加 定 义 了 一 个 复 合 域 。 这 个 域 具 有 与 事 实 段 相 同 的 名 称 , 并 具
有 与 事 实 段 中 的 事 实 相 对 应 的 函 子 。
如 果 facts 段 有 名 称 , 这 个 名 字 就 表 示 了 内 建 域 factDB 的 一 个 值 。save 和 consult 谓 词 可 以 接 纳 这
50

个 域 的 值 。
FactsSection :
class-opt facts FactsSectionName-opt FactDeclaration-dot-term-list-opt
FactsSectionName :
- LowerCaseIdentifier
Fact 声 明
事 实 声 明 说 明 一 个 事 实 数 据 库 的 事 实 。 事 实 声 明 可 以 是 一 个 事 实 变 量 , 也 可 以 是 一 个 函 子 事 实 。
FactDeclaration :
FactVariableDeclaration
FactFunctorDeclaration
FactFunctorDeclaration :
FactName : ( Argument-comma-sep-list-opt ) FfactMode-opt
FactName :
LowerCaseIdentifier
事 实 函 子 的 声 明 , 缺 省 时 具 有 nondeterm 的 事 实 模 式 。
事 实 函 子 可 以 经 子 句 段 初 始 化 。 这 种 情 况 下 , 子 句 中 的 值 应 该 是 表 达 式 , 在 编 译 时 应 能 得 到 确 切 的 值 。
FactMode : one of
determ nondeterm single
如 果 模 式 是 single, 则 这 个 事 实 总 是 有 一 个 且 只 能 有 一 个 值 ,assert 谓 词 会 把 旧 值 以 新 值 替 代 掉 。
谓 词 retract 不 适 用 于 single 事 实 。
如 果 模 式 是 nondeterm, 则 该 事 实 可 以 有 0、1 或 任 意 个 值 。 如 果 模 式 是 determ, 则 事 实 只 能 有 0
或 1 个 值 。 如 果 事 实 有 0 个 值 , 则 任 何 对 它 的 读 访 问 都 会 失 败 。
事 实 变 量 的 声 明
一 个 事 实 变 量 , 就 如 同 只 有 一 个 参 数 的 single 函 子 事 实 。 不 过 , 语 法 上 它 是 一 个 可 变 量 ( 即 可 以 赋 值 )。
FactVariableDeclaration :
FactVariableName : Domain InitialValue-opt
InitialValue :
:= ConstantValue
:= erroneous
FactVariableName :
LowerCaseIdentifier
常 数 值 ConstantValue 应 该 是 (Domain 类 型 的 ) 一 个 项 , 它 在 编 译 时 应 该 能 得 到 确 切 的 值 。
只 有 当 事 实 变 量 在 一 个 构 造 器 里 被 初 始 化 时 , 常 数 值 才 可 以 省 去 。
类 事 实 变 量 总 是 要 有 初 始 常 数 值 。
注 意 , 关 键 字 erroneous 可 以 当 作 一 个 值 赋 给 一 个 事 实 变 量 。 下 面 两 种 情 况 都 是 允 许 的 :
51

facts
thisWin : vpiDomains::windowHandle := erroneous.
clauses
p() :- thisWin := erroneous.
赋 值 成 erroneous, 是 想 要 在 发 生 了 代 码 错 误 地 使 用 了 没 有 初 始 化 的 事 实 变 量 时 , 给 出 明 确 的 运 行
时 错 误 。
Facts
事 实 只 能 在 一 个 类 的 实 现 中 声 明 , 因 而 , 也 只 能 在 这 个 实 现 中 引 用 。 因 此 , 事 实 的 范 围 是 它 的 声 明 所
在 的 实 现 。 但 是 , 对 象 事 实 的 生 命 期 是 它 所 属 的 对 象 的 生 命 期 , 同 样 , 类 事 实 的 生 命 期 是 从 程 序 的 开 始 一
直 到 程 序 结 束 。
例 下 面 的 类 声 明 了 一 个 对 象 事 实 objectFact 和 一 个 类 事 实 classFact:
implement aaa_class
facts
objectFact : (integer Value) determ.
class facts
classFact : (integer Value) determ.
...
end implement aaa_class
Clauses( 子 句 )
Clauses 段
clauses 段 由 一 些 子 句 构 成 , 它 包 含 了 谓 词 的 实 现 或 事 实 的 初 始 化 值 。
一 个 子 句 段 可 以 包 含 多 个 谓 词 及 事 实 的 子 句 。 另 一 方 面 , 一 个 ( 相 同 名 称 及 元 维 ) 谓 词 / 事 实 的 所 有
子 句 在 一 个 子 句 段 中 必 须 集 中 在 一 起 , 不 能 间 隔 有 别 的 谓 词 / 事 实 的 子 句 。
Clauses
ClausesSection :
clauses Clause-dot-term-list-opt
子 句 用 于 定 义 谓 词 。 一 个 谓 词 由 一 组 子 句 来 定 义 , 每 个 子 句 依 次 执 行 , 直 到 它 们 中 的 一 个 成 功
(succeeds), 或 是 直 到 再 也 没 有 其 它 剩 下 的 子 句 。 如 果 没 有 子 句 成 功 , 那 么 这 个 谓 词 就 失 败 (fails)
了 。
如 果 一 个 子 句 成 功 了 , 而 此 时 在 该 谓 词 中 还 剩 有 其 它 相 关 的 子 句 , 程 序 控 制 就 可 以 在 后 面 再 回 溯
(backtrack) 到 这 个 谓 词 的 这 些 子 句 上 以 寻 求 其 它 的 解 。 因 此 , 一 个 谓 词 可 以 失 败 , 可 以 成 功 , 甚 至
可 以 成 功 多 次 。
一 个 子 句 有 头 部 及 可 选 的 体 部 。
当 一 个 谓 词 被 调 用 时 , 它 的 子 句 依 次 ( 从 上 到 下 ) 被 检 测 。 对 每 个 子 句 来 说 , 头 部 要 与 调 用 参 数 进 行
合 一 , 如 果 合 一 成 功 , 有 体 部 时 才 执 行 体 部 。 只 有 在 头 部 和 体 部 都 成 功 时 , 子 句 才 成 功 , 否 则 就 失 败 了 。
子 句 是 由 头 部 及 一 个 可 选 的 体 部 构 成 的 。
52

Clause :
ClauseHead ReturnValue-opt ClauseBody-opt .
ClauseHead :
LowercaseIdentifier ( Term-comma-sep-list-opt )
ReturnValue :
= Term
ClauseBody :
:- Term
Goal Section( 目 标 段 )
goal 段 是 程 序 的 入 口 。 程 序 开 始 时 就 从 goal 开 始 执 行 ,goal 执 行 完 , 程 序 就 退 出 了 。
GoalSection :
goal Term.
goal 段 是 由 子 句 体 构 成 的 , 这 个 段 定 义 了 自 己 的 范 围 , 因 此 所 有 的 调 用 都 应 包 括 类 限 定 符 。
通 常 , 目 标 必 须 是 procedure 模 式 的 。
Terms 项
本 节 描 述 项 以 及 项 和 子 句 的 执 行 / 计 算 是 如 何 进 行 的 。
从 语 义 上 说 , 有 两 类 项 : 公 式 (formulas) 和 表 达 式 (expressions)。
表 达 式 代 表 值 , 如 数 字 7。
公 式 代 表 逻 辑 说 明 , 如 “ 数 字 7 大 于 数 字 3”。
而 依 语 法 来 看 , 这 两 类 其 实 有 很 大 的 重 叠 , 因 此 语 法 上 把 这 两 类 合 并 成 项 (terms)。
下 面 对 Term 的 定 义 是 简 化 了 的 , 因 为 按 它 包 含 的 语 法 构 造 来 讲 有 些 是 不 合 法 的 。 比 如 ,! + ! 就 是 不
合 法 的 写 法 。 不 过 , 这 种 简 洁 的 语 法 描 述 与 对 语 言 概 念 、 类 型 系 统 及 下 面 描 述 的 算 子 层 次 的 直 觉 理 解 相 结
合 , 还 是 非 常 有 用 的 。
Term:
( Term )
Literal
Variable
Identifier
MemberAccess
PredicateCall
PredicateExpression
UnaryOperator Term
Term BinaryOperator Term
Cut
Ellipsis
FactvariableAssignment
Backtracking( 回 溯 )
53

Prolog 程 序 的 求 值 就 是 对 目 标 的 一 个 解 的 搜 寻 。 对 解 的 搜 索 的 每 一 步 都 有 可 能 成 功 或 失 败 。 程 序 执 行
过 程 中 的 某 个 点 上 , 对 搜 索 解 会 有 多 种 可 能 , 在 这 种 选 择 点 上 就 会 创 建 一 个 回 溯 点 (backtrack point)。
回 溯 点 是 一 种 记 录 , 它 包 含 有 程 序 的 状 态 及 还 未 执 行 的 选 择 的 指 针 。 如 果 先 前 的 一 个 选 择 没 有 能 够 得 到 解
( 也 就 是 失 败 了 ), 程 序 就 会 回 溯 到 记 录 的 回 溯 点 上 来 , 因 而 可 以 恢 复 程 序 的 状 态 再 追 寻 其 它 的 选 择 。 后
面 会 要 描 述 这 个 机 理 并 用 例 子 来 详 细 说 明 。
Literals( 文 字 )
文 字 具 有 通 用 类 型 。
Literal:
IntegerLiteral
RealLiteral
CharacterLiteral
StringLiteral
BinaryLiteral
ListLiteral
CompoundDomainLiteral
参 看 词 汇 元 素 中 的 文 字 。
Variables( 变 量 )
Visual Prolog 中 的 变 量 其 实 是 不 可 变 的 : 一 经 绑 定 为 一 个 值 时 它 们 就 一 直 保 有 这 个 值 , 但 回 溯 可 以
为 变 量 解 除 绑 定 以 恢 复 程 序 的 先 前 状 态 。
一 个 变 量 ( 在 合 一 和 匹 配 时 ) 可 以 被 绑 定 , 如 果 已 经 被 绑 定 了 , 就 用 它 绑 定 的 值 进 行 解 算 。
变 量 名 以 一 个 大 写 字 母 或 一 个 下 划 线 开 头 , 后 跟 字 母 ( 可 以 是 大 写 也 可 以 是 小 写 )、 数 字 和 下 划 线 序
列 ( 称 为 大 写 标 识 ):
Variable:
UppercaseIdentifer
下 面 这 些 都 是 合 法 的 变 量 名 :
My_first_correct_variable_name
_
_Sales_10_11_86
而 下 面 这 些 则 是 不 合 法 的 :
1stattempt
second_attempt
名 字 是 一 个 下 划 线 ( 即 _) 的 变 量 称 为 匿 名 变 量 , 它 用 于 形 式 上 需 要 但 具 体 的 值 我 们 并 不 关 心 的 场
合 。 每 次 出 现 的 匿 名 变 量 都 是 独 立 的 , 也 就 是 说 , 哪 怕 在 一 个 子 句 中 使 用 了 多 次 匿 名 变 量 , 它 们 之 间 也 是
没 有 关 系 的 。
名 字 用 一 个 下 划 线 开 头 的 变 量 并 不 是 匿 名 变 量 , 但 它 的 值 仍 是 我 们 不 关 心 而 忽 略 的 。 如 果 它 的 值 实 际
上 没 有 被 忽 略 , 编 译 器 会 给 出 一 个 警 告 。
Prolog 的 变 量 是 局 限 于 它 所 在 的 子 句 的 , 即 : 如 果 两 个 子 句 都 含 有 变 量 X, 这 两 个 X 变 量 是 独 立 不 相
关 的 。
54

当 一 个 变 量 还 没 有 与 一 个 项 联 系 在 一 起 时 , 称 这 个 变 量 是 自 由 的 ; 而 当 它 与 一 个 项 合 一 后 , 则 称 其
为 绑 定 的 或 实 例 化 了 的 。
Visual Prolog 编 译 器 对 名 称 不 区 分 除 首 字 母 而 外 的 大 小 写 ,SourceCode 和 SOURCECODE 这 两
个 变 量 名 指 的 是 同 一 个 变 量 。
Identifier( 标 识 )
Identifier:
MemberName
GlobalScopeMembername
ScopeQualifiedMemberName
MemberName:
LowerCaseIdentifier
标 识 用 于 指 称 命 名 了 的 实 体 ( 如 类 、 接 口 、 常 数 、 域 、 谓 词 、 事 实 , 等 等 )。
标 识 只 能 是 小 写 标 识 ( 也 就 是 一 个 小 写 字 母 后 跟 字 母 、 数 字 和 下 划 线 字 符 等 的 序 列 )。
许 多 实 体 可 以 有 相 同 的 名 称 , 因 此 , 可 能 需 要 限 定 小 写 标 识 名 的 特 定 的 影 响 范 围 , 或 说 明 名 称 是 全 局
的 。
例 下 面 这 些 是 无 限 定 的 标 识 :
全 局 实 体 的 访 问
integer
mainExe
myPredicate
在 Visual Prolog 中 , 全 局 实 体 只 有 内 建 的 域 、 谓 词 和 常 数 。 全 局 名 称 在 任 何 范 围 内 都 是 可 以 直 接 访
问 的 , 但 也 存 在 全 局 名 称 被 一 个 局 部 名 称 或 引 入 名 称 屏 蔽 的 情 况 。 此 时 , 全 局 实 体 可 以 用 一 个 双 冒 号 “::”
( 不 需 要 前 缀 类 / 接 口 名 称 ) 来 修 饰 。 双 冒 号 可 以 用 在 任 何 地 方 , 但 最 重 要 的 使 用 场 合 是 接 口 名 称 用 于 形 式 参
数 类 型 说 明 符 时 。
GlobalScopeMemberName:
:: MemberName
例 内 建 域 是 定 义 为 全 局 范 围 的 , 为 避 免 含 糊 或 强 调 这 个 特 殊 的 域 , 也 可 以 使 用 其 全 局 范 围 成 员 名 称 :
::integer
类 / 接 口 成 员 的 访 问
类 与 接 口 的 静 态 成 员 的 访 问 是 通 过 带 类 名 称 ( 及 可 选 的 名 称 范 围 前 缀 ) 的 限 定 符 进 行 的 :
ScopeQualifiedMemberName
NamespacePrefix-opt ScopeName :: MemberName
NamespacePrefix:
NamespaceIdentifier-opt \
ScopeName:
LowercaseIdentifier
55

ScopeName 是 定 义 / 声 明 该 名 称 的 类 或 接 口 的 名 字 。
Namespace 的 前 缀 在 Referencing names in namespaces 中 说 明 。
有 些 名 称 的 访 问 可 以 不 要 限 定 符 , 参 看 范 围 与 可 见 性 。
Predicate Call( 谓 词 调 用 )
谓 词 调 用 的 形 式 是 :
PredicateCall:
Term ( Term-comma-sep-list-opt )
第 一 项 必 须 是 一 个 可 以 求 得 谓 词 类 型 的 值 的 表 达 式 。 通 常 , 它 是 一 个 类 中 一 个 谓 词 的 名 称 , 或 是 对 一
个 对 象 的 谓 词 成 员 求 值 的 表 达 式 。
要 注 意 , 有 的 谓 词 是 返 回 值 的 , 而 有 些 则 不 会 返 回 值 。 返 回 值 的 谓 词 是 一 个 表 达 式 , 这 样 的 谓 词 调 用
常 称 为 一 个 函 数 调 用 。 常 规 地 , 谓 词 是 返 回 值 的 。
谓 词 的 调 用 是 通 过 应 用 参 数 于 该 谓 词 来 进 行 的 。 谓 词 必 须 具 有 与 参 数 自 由 / 绑 定 状 态 相 匹 配 的 流 样 式 。
大 多 数 谓 词 是 由 一 组 子 句 定 义 的 , 但 有 的 谓 词 是 由 语 言 内 建 的 , 还 有 的 是 在 外 部 的 DLL 中 定 义 的 ( 可
能 还 是 另 外 的 编 程 语 言 )。
当 调 用 谓 词 时 , 各 个 子 句 依 次 执 行 直 到 其 中 的 一 个 成 功 , 或 是 再 没 有 可 执 行 的 子 句 。 如 果 没 有 子 句 成
功 则 谓 词 就 失 败 了 。
如 果 一 个 子 句 成 功 了 而 还 剩 有 子 句 , 就 会 有 一 个 回 溯 点 创 建 在 下 一 个 相 关 的 子 句 上 。
这 样 , 谓 词 可 以 失 败 , 成 功 , 甚 至 成 功 多 次 。
每 个 子 句 有 头 部 及 可 选 的 体 部 。
调 用 谓 词 时 , 子 句 被 依 次 ( 从 上 到 下 ) 求 值 。 每 个 子 句 在 头 部 的 参 数 与 调 用 的 参 数 进 行 合 一 。 如 果 合
一 成 功 , 有 体 部 时 才 会 执 行 体 部 。 只 有 头 部 成 功 且 体 部 也 成 功 , 子 句 才 成 功 , 否 则 就 失 败 了 。
例
clauses
ppp() :- qqq(X), write(X), fail.
qqq(1).
qqq(2).
qqq(3).
调 用 ppp 时 它 接 着 会 调 用 qqq。 当 qqq 被 调 用 时 , 它 首 先 在 第 二 个 子 句 上 创 建 一 个 回 溯 点 , 然 后 执 行
第 一 个 子 句 。 这 时 ppp 中 的 自 由 变 量 X 与 数 字 1 匹 配 , 这 样 就 将 X 绑 定 为 1。
接 着 ,ppp 的 X( 也 就 是 1) 被 写 出 , 然 后 fail 导 致 回 溯 到 回 溯 点 。 因 而 程 序 控 制 会 转 到 qqq 的 第 二 个
子 句 , 而 程 序 的 状 态 也 会 回 到 第 一 次 进 入 qqq 时 的 状 态 , 即 ppp 中 的 X 又 是 未 绑 定 的 了 。
在 实 际 执 行 qqq 中 的 第 二 个 子 句 之 前 , 会 先 在 第 三 个 子 句 上 创 建 一 个 回 溯 点 。 接 下 来 的 过 程 与 1 的 一
样 。
Unification( 合 一 )
当 调 用 一 个 谓 词 时 , 调 用 的 参 数 会 与 各 子 句 的 头 部 中 的 项 进 行 合 一 。
所 谓 合 一 , 就 是 变 量 绑 定 的 过 程 , 它 使 两 个 项 相 等 , 并 且 尽 量 少 做 绑 定 ( 也 就 是 尽 可 能 多 地 留 下 以 后
绑 定 的 余 地 )。
56

变 量 可 以 绑 定 于 任 何 种 类 的 项 , 包 括 变 量 或 含 有 变 量 的 项 。 而 合 一 可 以 是 可 能 的 , 也 可 以 是 不 可 能 的 ,
也 就 是 说 , 可 以 成 功 , 或 是 失 败 。
变 量 及 其 要 绑 定 的 项 是 有 类 型 的 , 一 个 变 量 只 能 和 与 它 同 类 型 的 或 是 其 子 类 型 的 项 做 绑 定 。 如 果 两 个
变 量 是 互 相 绑 定 的 , 则 它 们 必 须 是 相 同 的 类 型 。
合 一 出 现 在 一 个 谓 词 调 用 和 子 句 的 头 部 间 。 当 两 个 项 进 行 相 等 比 较 时 也 会 出 现 合 一 。
例 考 虑 两 个 项 ( 同 一 类 型 的 ):
T1 = f1(g(), X, 17, Y, 17)
T2 = f1(Z, Z, V, U, 43)
我 们 来 试 试 把 这 两 个 项 从 左 到 右 进 行 合 一 。T1 和 T2 都 是 f1/5 项 , 是 匹 配 的 。 因 此 , 我 们 来 试 着 由 T1
的 参 数 合 一 T2 相 应 的 参 数 。 首 先 要 合 一 Z 和 g(), 这 只 要 把 Z 绑 定 为 g() 就 可 以 了 。 目 前 为 止 还 不 错 , 我 们
得 到 了 第 一 个 绑 定 :
Z = g()
接 下 来 第 二 个 参 数 是 X 和 Z, 而 后 者 已 经 绑 定 为 g() 了 。 只 要 让 X 绑 定 为 g(), 这 两 个 参 数 也 是 可 以 合
一 的 , 这 样 我 们 有 了 第 二 个 绑 定 :
X = Z = g()
再 接 下 来 , 必 须 把 V 绑 定 为 17, 还 要 把 Y 绑 定 为 U。 现 在 已 经 绑 定 的 有 :
X = Z = g()
V = 17
Y = U
两 个 合 一 的 项 现 在 等 价 于 下 面 的 项 :
T1 = f1(g(), g(), 17, Y, 17)
T2 = f1(g(), g(), 17, Y, 43)
但 是 我 们 还 没 有 合 一 最 后 两 个 参 数 , 这 两 个 参 数 是 17 和 43。 没 有 什 么 变 量 绑 定 能 使 这 两 个 项 相 等 ,
所 以 最 终 合 一 失 败 了 。T1 和 T2 不 能 合 一 。
上 面 这 个 例 子 中 ,T1 可 以 是 一 个 谓 词 调 用 而 T2 可 以 是 一 个 子 句 的 头 部 。 当 然 , 它 们 也 可 以 是 两 个 用
“=” 比 较 的 项 。
Matching( 匹 配 )
匹 配 只 有 一 点 与 合 一 不 同 , 这 就 是 匹 配 时 变 量 只 能 绑 定 于 根 基 (grounded) 项 。 所 谓 根 基 项 , 就 是
不 含 任 何 未 绑 定 变 量 的 项 。
正 是 说 明 谓 词 的 流 样 式 , 使 得 我 们 可 以 用 匹 配 而 不 用 全 面 的 合 一 成 为 可 能 。
例
clauses
ppp(Z, Z, 17).
qqq() :-
ppp(g(), X, 17).
57

调 用 ppp 时 合 一 ppp 的 子 句 , 只 要 使 用 下 面 的 绑 定 , 是 可 行 的 :
Z = X = g()
如 果 ppp 的 流 是 (i,o,i), 合 一 就 只 是 一 个 匹 配 :
• g() 是 个 输 入 , 作 为 第 一 个 参 数 , 它 绑 定 于 Z,
• 子 句 中 第 二 个 参 数 因 此 也 可 以 绑 定 并 可 以 输 出 给 X, 这 样 X 就 变 成 绑 定 于 g(),
• 最 后 , 第 三 个 参 数 是 17, 它 是 一 个 输 入 , 这 个 数 只 是 简 单 地 与 子 句 中 的 第 三 个 参 数 作 比 较 。
可 以 看 到 , 正 是 流 样 式 使 得 有 可 能 预 知 子 句 并 不 需 要 实 际 进 行 合 一 。
嵌 套 的 函 数 调 用
要 合 一 或 匹 配 的 项 可 以 包 含 子 项 , 而 子 项 是 表 达 式 或 函 数 调 用 , 它 们 需 要 在 合 一 / 匹 配 完 成 之 前 进 行
求 值 。
这 样 的 子 项 求 值 是 按 需 要 进 行 的 。
在 谓 词 调 用 时 , 所 有 输 入 参 数 在 谓 词 调 用 前 做 求 值 , 所 有 输 出 参 数 是 变 量 , 不 需 要 求 值 。
子 句 头 部 也 可 以 包 含 需 要 求 值 的 项 , 在 合 一 / 匹 配 前 确 定 下 来 。
• 在 求 值 进 行 之 前 , 先 做 不 需 要 做 求 值 处 理 的 合 一 / 匹 配 ;
• 然 后 相 应 于 输 入 的 参 数 从 左 到 右 逐 个 求 值 。 求 值 一 个 就 与 对 应 的 输 入 比 较 一 个 ;
• 接 着 对 子 句 的 体 求 值 ;
• 再 从 左 到 右 对 输 出 参 数 求 值 ;
• 最 后 , 如 果 谓 词 是 函 数 , 就 对 返 回 值 求 值 。
如 果 上 述 过 程 中 出 现 任 何 失 败 , 就 不 进 行 其 它 的 求 值 。
总 之 , 基 本 原 则 是 :
• 输 入 求 值 先 于 体 部 求 值 ;
• 体 部 求 值 之 后 是 输 出 求 值 ;
• 求 值 从 左 向 右 进 行 。
匿 名 谓 词
匿 名 谓 词 是 对 一 个 谓 词 的 值 进 行 计 算 的 表 达 式 , 这 个 值 可 以 绑 定 给 一 个 变 量 , 可 以 作 为 参 数 传 递 或 作
为 结 果 返 回 , 但 这 个 值 没 有 任 何 类 、 接 口 或 实 现 的 名 称 。
匿 名 谓 词 可 以 在 表 达 式 出 现 的 关 联 中 获 取 值 , 可 以 用 它 来 避 免 一 些 冗 长 难 懂 的 代 码 。
语 法
匿 名 谓 词 是 项 :
Term : one of
...
AnonymousPredicate
...
匿 名 谓 词 是 一 个 在 大 括 号 中 的 无 名 子 句 , 某 些 部 分 是 可 选 的 , 形 式 如 下 :
AnonymousPredicate : one of
{ ( Arg-comma-sep-list ) = Term }
58

{ ( Arg-comma-sep-list ) = Term :- Term }
{ ( Arg-comma-sep-list ) :- Term }
{ = Term }
{ = Term :- Term }
{ :- Term }
省 略 参 数 表 意 味 着 “ 需 要 数 量 的 参 数 ”, 用 在 不 需 要 实 际 使 用 参 数 时 。
语 义
匿 名 谓 词 表 达 式 对 一 个 谓 词 求 值 。 看 下 面 的 代 码 :
clauses
run() :-
Inc = { (X) = X+1 },
A = Inc(4),
B = Inc(23),
stdio::writef("A = %, B = %", A, B).
Inc 成 了 一 个 增 量 谓 词 , 程 序 的 结 果 是 :
A = 5, B = 24
上 面 的 代 码 相 当 于 这 样 :
clauses
run() :-
Inc = inc,
A = Inc(4),
B = Inc(23),
stdio::writef("A = %, B = %", A, B).
class predicates
inc : (integer X) -> integer R.
clauses
inc(X) = X+1.
这 里 , 最 后 一 行 可 以 看 到 子 句 (X) = X+1, 在 这 里 它 是 一 个 命 名 了 的 谓 词 。
在 匿 名 谓 词 之 外 ( 即 匿 名 谓 词 出 现 之 前 ) 绑 定 的 变 量 可 以 在 匿 名 谓 词 中 使 用 , 变 量 的 值 将 被 匿 名 谓 词
获 取 。 而 在 匿 名 谓 词 中 绑 定 的 变 量 是 该 匿 名 谓 词 的 局 部 变 量 。
获 取 关 联
匿 名 谓 词 可 以 获 取 关 联 , 也 就 是 说 它 可 以 引 用 关 联 中 定 义 的 东 西 , 尤 其 是 从 子 句 中 引 用 事 实 和 变 量 。
获 取 变 量
匿 名 谓 词 是 出 现 在 子 句 中 的 , 而 这 个 子 句 可 能 含 有 变 量 。 对 那 些 在 匿 名 谓 词 出 现 之 前 绑 定 的 变 量 , 在
匿 名 谓 词 中 可 以 使 用 。 下 面 的 代 码 说 明 了 如 何 获 取 变 量 的 :
domains
pred = (integer) -> integer.
59

class predicates
createAdder : (integer A) -> pred Adder.
clauses
createAdder(A) = { (X) = X+A }.
clauses
run() :-
Add17 = createAdder(17),
A = Add17(4),
B = Add17(20),
stdio::writef("A = %, B = %", A, B).
用 17 做 参 数 调 用 createAdder, 这 时 createAdder 子 句 中 的 A 是 17, 因 而 结 果 是 { (X) = X+17 }。
我 们 说 匿 名 谓 词 获 取 了 变 量 A。Add17 是 一 个 把 17 加 到 自 身 参 数 的 谓 词 , 输 出 的 结 果 就 是 :
获 取 省 略 符
A = 21, B = 37
匿 名 谓 词 可 以 获 取 省 略 符 变 量 :
clauses
ppp(...) :-
W = { () :- stdio::write(...) },
qqq(W).
W 获 取 了 省 略 符 变 量 。qqq 收 到 一 个 0 元 维 的 谓 词 , 当 这 个 谓 词 被 调 用 时 , 获 取 的 省 略 符 变 量 就 会 写
到 标 准 输 出 设 备 上 去 。
获 取 事 实
匿 名 谓 词 可 以 获 取 事 实 。 如 果 匿 名 变 量 是 由 类 谓 词 创 建 的 , 它 就 可 以 访 问 类 事 实 ; 如 果 是 由 对 象 谓 词
创 建 的 , 它 就 既 可 以 访 问 对 象 事 实 又 可 以 访 问 类 事 实 。 下 面 的 代 码 获 取 的 是 类 事 实 :
class facts
count : integer := 0.
clauses
seq() = { () = count :- count := count+1 }.
clauses
run() :-
A = seq(),
B = seq(),
stdio::writef("A1 = %, ", A()),
stdio::writef("B1 = %, ", B()),
stdio::writef("A2 = %, ", A()),
stdio::writef("B2 = %", B()).
A 和 B 都 会 使 类 事 实 计 数 增 加 , 所 以 结 果 是 :
A1 = 1, B1 = 2, A2 = 3, B2 = 4
对 象 谓 词 中 可 以 获 取 对 象 事 实 。 假 设 seq 是 myClass 中 的 对 象 谓 词 , 下 面 的 代 码 说 明 了 获 取 对 象 事 实 :
60

facts
count : integer := 0.
clauses
seq() = { () = count :- count := count+1 }.
clauses
run() :-
A = myClass::new():seq(),
B = myClass::new():seq(),
stdio::writef("A1 = %, ", A()),
stdio::writef("B1 = %, ", B()),
stdio::writef("A2 = %, ", A()),
stdio::writef("B2 = %", B()).
这 里 ,A 和 B 来 自 不 同 的 对 象 , 它 们 有 各 自 的 计 数 , 所 以 输 出 是 :
A1 = 1, B1 = 1, A2 = 2, B2 = 2
技 术 上 来 说 , 类 版 本 的 匿 名 谓 词 其 实 获 取 不 了 什 么 东 西 , 它 很 少 有 权 使 用 事 实 。 同 样 地 , 对 象 版 的 其
实 也 没 有 获 取 事 实 , 它 获 取 的 是 This 并 通 过 This 访 问 了 对 象 事 实 。
获 取 This
嵌 套
如 上 所 述 , 可 以 获 取 This 并 取 得 对 对 象 事 实 的 访 问 权 。 同 样 的 机 制 可 以 调 用 对 象 谓 词 :
clauses
seq() = { () = count :- inc() }.
clauses
inc() :- count := count+1.
This 也 可 以 直 接 使 用 :
clauses
ppp() = { () = aaa::rrr(This) }.
匿 名 谓 词 可 以 嵌 套 :
clauses
run() :-
P = { (A) = { (B) = A+B } },
Q = P(3300),
R = P(2200),
stdio::writef("Q(11) = %, ", Q(11)),
stdio::writef("R(11) = %", R(11)).
要 得 到 Q 用 3300 调 用 P, 这 样 A 是 3300 而 Q 就 是 { (B) = 3300+B} }, 同 样 R 是 { (B) =
2200+B } }, 结 果 是 :
Q(11) = 3311, R(11) = 2211
Syntactic Sugar( 便 利 化 的 语 法 )
61

如 果 不 需 要 参 数 , 可 以 把 它 们 略 过 。 下 面 这 个 代 码 片 断 :
P = { (_) :- succeed },
Q = { (_, _) = 0 },
R = { (_, _, _) = _ :- fail }
可 以 简 化 成 这 样 :
P = { :- succeed },
Q = { = 0 },
R = { = _ :- fail }
注 意 , 参 数 部 分 完 全 被 略 去 了 。 如 果 写 () 则 意 味 着 是 零 参 数 , 而 略 去 所 有 参 数 意 思 是 “ 有 适 当 的 ” 参
数 。
实 际 使 用 举 例
这 节 内 容 显 示 了 匿 名 谓 词 的 便 利 性 。 例 子 中 假 定 PFC 中 的 core、std、stdio、list 和 string 等 范 围 是 开
放 的 。
哑 谓 词
适 配
用 匿 名 谓 词 来 创 建 哑 谓 词 值 是 很 方 便 的 :
ppp( { = true } ), % 不 过 滤 (boolean)
qqq( { :- succeed } ), % 不 过 滤 (determ)
rrr( { = 17 } ), % 所 有 行 高 必 须 为 17
有 的 时 候 要 用 一 个 谓 词 , 而 已 经 有 了 一 个 差 不 多 合 适 的 , 这 时 可 以 用 匿 名 谓 词 来 配 合 以 满 足 需 要 。
适 配 索 引
看 一 下 谓 词 write3:
class predicates
write3 : (function{integer, string} Indexer).
clauses
write3(Indexer) :-
foreach I = std::fromTo(0,2) do
write(Indexer(I), "\n")
end foreach.
Indexer 提 供 了 一 个 串 的 “ 数 组 ”,write3 可 以 写 出 以 索 引 号 为 0、1 和 2 的 三 个 串 。 因 此 ,write3
设 定 “ 数 组 ” 索 引 号 是 从 0 开 始 的 。 不 过 , 我 们 想 用 一 个 索 引 号 从 1 开 始 的 “ 数 组 ”:
class predicates
myArray : (integer N) -> string Value.
clauses
62

参 数 适 配
myArray(1) = "First" :- !.
myArray(2) = "Second" :- !.
myArray(3) = "Third" :- !.
myArray(_) = _ :-
raiseError().
用 一 个 匿 名 谓 词 , 就 可 以 轻 而 易 举 地 使 索 引 号 从 1 开 始 的 数 组 满 足 索 引 号 从 0 开 始 的 使 用 要 求 :
% myArray is 0-based, write3 requires 1-based
Arr = { (N) = myArray(N+1) },
write3(Arr)
这 样 , 我 们 就 可 以 得 到 期 望 的 输 出 :
First
Second
Third
在 下 面 的 代 码 中 ,listChildren 将 为 每 一 个 “C 是 P 的 孩 子 ” 数 据 对 调 用 谓 词 ChildWriter:
class predicates
listChildren :(predicate{string,string} ChildWriter).
clauses
listChildren(CW) :-
CW("Son1", "Father"),
CW("Son2", "Father").
不 过 , 现 在 我 们 想 用 谓 词 wParent 写 出 “P 是 C 的 父 母 ” 的 列 表 来 :
class predicates
wParent : (string Parent, string Child).
clauses
wParent(P, C) :-
writef("% is the parent of %\n", P, C).
wParent 所 用 的 参 数 刚 好 顺 序 是 相 反 的 , 可 以 很 容 易 地 用 一 个 匿 名 谓 词 来 调 整 它 :
Swap = { (A,B) :- wParent(B,A) },
listChildren(Swap)
输 出 就 是 我 们 想 要 的 了 :
Father is the parent of Son1
Father is the parent of Son2
我 们 还 可 以 丢 掉 不 需 要 的 参 数 , 比 如 调 用 谓 词 时 我 们 只 想 要 “Child”:
class predicates
wKnowParent : (string Child).
clauses
wKnowParent(C) :-
writef("We know a parent of %\n", C).
63

可 以 这 样 来 做 需 要 的 适 配 :
Fewer = { (C,P) :- wKnowParent(C) },
listChildren(Fewer)
输 出 会 是 这 样 :
We know a parent of Son1
We know a parent of Son2
我 们 还 可 以 使 用 哑 参 数 :
More = { (_,P) :- addChildren(P, 1) }
listChildren(More)
这 里 的 addChildren 会 “ 把 孩 子 数 加 到 P 中 ”, 因 为 对 应 每 个 孩 子 的 调 用 addChild 都 提 供 了 一 个 “ 哑
参 数 ”1。More 是 提 供 一 个 哑 参 数 并 丢 弃 一 个 参 数 的 适 配 器 。
筛 选
设 有 谓 词 :
class predicates
writeFiltered :(string L, filterPredicate{integer} Filter).
clauses
writeFiltered(Label, Filter) :-
List = [1,2,3,4,5,6,7,8,9],
FilteredList = filter(List, Filter),
writef("%\t%\n", Label, FilteredList).
过 滤 器 Filter 用 来 筛 选 表 [1,2,3,4,5,6,7,8,9], 筛 选 出 来 的 表 和 标 签 Label 写 到 标 准 输 出 设 备 上 。
我 们 先 用 个 全 选 过 滤 器 :
All = { :- succeed },
writeFiltered("All", All)
这 个 过 滤 器 对 任 何 元 素 都 成 功 , 所 以 输 出 是 全 表 :
All [1,2,3,4,5,6,7,8,9]
创 建 一 个 过 滤 器 对 任 何 元 素 都 失 败 也 很 简 单 :
None = { :- fail },
writeFiltered("None", None)
输 出 就 是 个 空 表 :
None []
也 可 以 创 建 一 个 过 滤 器 选 出 大 于 3 的 元 素 和 能 被 3 整 除 的 元 素 :
GreaterThan3 = { (X) :- X > 3 },
64

输 出 是 :
writeFiltered("> 3", GreaterThan3),
Rem3 = { (X) :- 0 = X rem 3 },
writeFiltered("Rem3", Rem3)
> 3 [4,5,6,7,8,9]
Rem3 [3,6,9]
排 序
表 包 里 有 排 序 谓 词 , 不 过 有 时 缺 省 的 顺 序 不 能 满 足 要 求 , 所 以 表 包 里 还 有 一 个 sortBy 谓 词 , 可 以 按 程
序 员 定 义 的 比 较 操 作 对 元 素 排 序 。 我 们 用 这 个 谓 词 先 来 考 虑 一 下 串 的 排 序 :
class predicates
writeStringsSorted :
(string Label, comparator{string} Comp).
clauses
writeStringsSorted(Label, C) :-
List = ["John Wayne", "Uma Thurman",
"Harrison Ford", "Nicolas Cage",
"Elizabeth Taylor", "Cary Grant",
"Jerry Lewis", "Robert De Niro"],
Sorted = sortBy(C, List),
write(Label, "\n"),
foreach S = list::getMember_nd(Sorted) do
writef(" %\n", S)
end foreach.
我 们 可 以 用 “normal” 比 较 符 调 用 谓 词 , 还 可 以 用 一 个 匿 名 谓 词 很 方 便 地 实 现 降 序 排 序 :
Normal = compare,
writeStringsSorted("Normal", Normal),
Descending = { (A,B) = compare(B,A) },
writeStringsSorted("Descending", Descending)
输 出 是 这 样 的 :
Normal
Cary Grant
Elizabeth Taylor
Harrison Ford
Jerry Lewis
John Wayne
Nicolas Cage
Robert De Niro
Uma Thurman
Descending
Uma Thurman
Robert De Niro
Nicolas Cage
John Wayne
Jerry Lewis
Harrison Ford
Elizabeth Taylor
Cary Grant
65

我 们 再 来 排 序 一 些 更 复 杂 的 元 素 。 下 面 的 一 些 人 名 使 用 这 样 的 域 :
domains
person = p(string First, string Last).
作 为 演 示 , 我 们 用 这 个 谓 词 :
class predicates
writePersonsSorted :
(string Label, comparator{person} Comparator).
clauses
writePersonsSorted(Label, C) :-
List = [p("John","Wayne"),
p("Uma","Thurman"),
p("Harrison","Ford"),
p("Nicolas","Cage"),
p("Elizabeth","Taylor"),
p("Cary","Grant"),
p("Jerry","Lewis"),
p("Robert","De Niro")],
Sorted = sortBy(C, List),
write(Label, "\n"),
foreach p(F,L) = list::getMember_nd(Sorted) do
writef(" % %\n", F, L)
end foreach.
同 样 , 我 们 也 可 以 用 正 常 和 降 序 比 较 符 :
Normal = compare,
writePersonsSorted("Normal", Normal),
Descending = { (A,B) = compare(B,A) },
writePersonsSorted("Descending", Descending)
因 为 比 较 谓 词 对 函 子 使 用 从 左 到 右 的 词 典 顺 序 , 结 果 与 前 面 的 一 样 :
Normal
Cary Grant
Elizabeth Taylor
Harrison Ford
Jerry Lewis
John Wayne
Nicolas Cage
Robert De Niro
Uma Thurman
Descending
Uma Thurman
Robert De Niro
Nicolas Cage
John Wayne
Jerry Lewis
Harrison Ford
Elizabeth Taylor
Cary Grant
但 用 更 复 杂 些 的 域 我 们 还 可 以 创 建 一 个 比 较 符 , 不 是 按 名 而 是 按 姓 来 排 序 :
66

获 取 关 联
LN = { (p(_,L1), p(_, L2)) = compare(L1,L2) },
writePersonsSorted("LastName", LN)
这 正 是 我 们 期 望 的 结 果 :
LastName
Nicolas Cage
Robert De Niro
Harrison Ford
Cary Grant
Jerry Lewis
Elizabeth Taylor
Uma Thurman
John Wayne
前 面 说 过 , 匿 名 谓 词 一 个 很 有 用 的 特 性 是 获 取 关 联 的 能 力 。 下 面 的 例 子 说 明 如 何 使 用 这 个 特 性 。
Background threads( 后 台 线 程 )
启 动 线 程 的 例 程 有 一 个 空 元 谓 词 , 会 在 一 个 新 线 程 中 运 行 它 。 不 过 我 们 常 常 需 要 传 递 一 些 输 入 数 据 给
新 线 程 中 的 作 业 。 可 以 有 多 种 办 法 , 但 最 简 单 的 办 法 是 用 匿 名 谓 词 。Visual Prolog 例 集 ( 可 以 在 IDE 中 安
装 ) 中 的 bgDemo 工 程 用 的 就 是 这 个 办 法 。 这 个 工 程 中 有 一 个 表 格 , 可 以 启 动 后 台 作 业 , 并 用 表 格 中 一
个 jobControl 控 件 显 示 作 业 的 状 态 信 息 。 后 台 作 业 是 一 个 谓 词 , 它 接 收 jobLog, 这 个 控 件 可 以 用 来 报 告
状 态 和 进 度 :
domains
job = (jobLog Log).
jobLog 是 这 样 的 :
interface jobLog
properties
completion : real (i).
properties
status : string (i).
end interface jobLog
作 业 通 过 设 置 完 成 属 性 (0 到 1) 来 报 告 完 成 进 度 。 同 样 , 状 态 属 性 可 以 用 来 反 映 作 业 的 当 前 状 态 。 状
态 和 完 成 进 度 用 一 个 作 业 名 显 示 在 表 格 里 。 作 业 的 启 动 是 通 过 调 用 表 格 的 addJob 谓 词 :
clauses
addJob(JobName, Job) :-
JobCtrl = jobControl::new(This),
JobCtrl:name := JobName,
JobCtrl:show(),
assert(jobCtrl_fact(JobCtrl)),
arrange(),
JobLog = jobLog::new(JobCtrl),
Action = { :- Job(JobLog) },
_ = thread::start(Action).
67

上 面 最 后 三 行 是 我 们 关 心 的 关 联 。thread::start 用 一 个 空 元 谓 词 作 参 数 , 但 作 业 是 一 个 以 jobLog
为 参 数 的 谓 词 。 因 此 , 我 们 用 了 一 个 匿 名 谓 词 Action, 它 没 有 参 数 但 在 JobLog 上 调 用 Job。 匿 名 谓 词 从
关 联 中 既 获 取 了 Job 又 获 取 了 JobLog, 因 而 它 们 的 值 可 以 传 递 给 新 线 程 , 尽 管 线 程 得 到 的 是 一 个 空 元 谓
词 。bgDemo 工 程 中 的 作 业 差 不 多 是 个 空 作 业 , 只 是 操 控 jobLog。 作 业 是 这 个 样 子 的 :
clauses
job(Log, From, To) :-
Log:status := "Step 1",
foreach N1 = std::fromTo(From, To) do
Log:completion :=
(N1-From) / (To-From) / 2,
programControl::sleep(3)
end foreach,
Log:status := "Step 2",
foreach N2 = std::fromTo(From, To) do
Log:completion :=
(N2-From) / (To-From) / 2 + 0.5,
programControl::sleep(3)
end foreach,
Log:status := "finished".
从 From 到 To 这 里 有 两 个 循 环 , 计 算 完 成 进 度 并 把 它 设 置 给 Log。 它 还 要 在 循 环 前 , 循 环 中 和 循 环 后
设 置 状 态 文 字 。 可 以 看 到 , 这 个 作 业 没 有 固 有 的 作 业 类 型 , 因 为 一 个 特 定 的 作 业 只 有 一 个 参 数 (jobLog),
而 这 个 作 业 有 三 个 参 数 。 还 是 匿 名 谓 词 帮 了 忙 。
在 表 格 中 添 加 作 业 的 代 码 是 这 样 的 :
predicates
onFileNew : window::menuItemListener.
clauses
onFileNew(_Source, _MenuTag) :-
JF = jobForm::display(This),
Job11 = {(L) :- job1::job(L, 1, 1000)},
Job12 = {(L) :- job1::job(L, 200, 600)},
Job13 = {(L) :- job1::job(L, 1200, 3000)},
Job14 = {(L) :- job1::job(L, 1, 1000)},
JF:addJob("job1.1", Job11),
JF:addJob("job1.2", Job12),
JF:addJob("job1.3", Job13),
JF:addJob("job1.4", Job14),
...
在 实 际 的 程 序 中 ,From 和 To 不 会 是 常 数 , 它 会 是 从 别 的 地 方 传 递 来 的 参 数 。 在 这 种 情 况 下 , 匿 名 谓
词 也 会 从 关 联 中 获 取 变 量 。 在 bgDemo 中 的 jobLog 说 明 了 匿 名 谓 词 又 一 种 使 用 方 法 , 它 传 递 完 成 进 度 和
状 态 信 息 给 一 个 控 件 jobControl。jobControl 是 jobForm 中 的 一 个 GUI 控 件 , 它 以 适 当 的 形 式 表 现 得
到 的 信 息 。 不 过 , 这 里 有 个 同 步 的 问 题 , 因 为 GUI 控 件 在 线 程 级 并 不 稳 定 , 而 在 这 里 我 们 是 从 一 个 后 台 线
程 中 更 新 控 件 的 。 这 有 可 能 导 致 冲 突 , 因 为 是 主 线 程 在 画 该 控 件 。 解 决 的 办 法 是 把 控 件 的 更 新 交 给 GUI 线
程 。 可 以 通 过 把 动 作 传 递 给 控 件 来 这 样 做 。 状 态 更 新 的 实 现 是 这 样 的 :
clauses
status(Status) :-
Action = { :- jobCtrl:status := Status },
jobCtrl:postAction(Action).
68

Action 是 一 个 空 元 谓 词 , 它 会 设 置 jobCtrl 中 的 状 态 。 我 们 把 这 个 动 作 传 递 给 jobCtrl, 当 它 接 收 到
action 时 就 会 调 用 Action 完 成 更 新 。 这 样 , 控 件 的 实 际 更 新 是 由 GUI 线 程 完 成 的 , 这 个 匿 名 谓 词 不 仅 获 取
Status 变 量 而 且 获 取 了 jobCtrl 事 实 。
匿 名 回 叫
考 虑 一 下 给 远 端 服 务 发 送 命 令 的 情 况 。 命 令 的 执 行 是 异 步 的 , 所 以 执 行 一 个 命 令 也 还 需 要 一 个 回 叫 动
作 , 执 行 完 了 命 令 就 调 用 这 个 动 作 。 也 就 是 说 , 为 执 行 命 令 需 要 调 用 这 样 的 谓 词 :
predicates
executeCommand :
(command Cmd, predicate{} OnDone).
基 于 这 个 谓 词 , 还 可 以 创 建 一 个 可 以 执 行 一 个 命 令 表 的 谓 词 , 前 一 个 命 令 执 行 完 了 接 着 执 行 下 一 个 命
令 。 执 行 命 令 表 也 是 异 步 的 , 所 以 命 令 脚 本 都 执 行 完 了 也 需 要 调 用 一 个 动 作 。 脚 本 执 行 的 形 式 是 这 样 的 :
predicates
executeScript :
(command* Script, predicate{} OnDone).
如 果 脚 本 空 了 , 就 调 用 OnDone。 若 脚 本 有 一 个 命 令 H 及 剩 下 的 脚 本 T, 必 须 先 执 行 H, 完 成 之 后 执
行 剩 下 的 脚 本 T。So the OnDone action we supply when executing H must execute T. 总 之 , 实 现
会 是 这 样 的 :
clauses
executeScript([], OnDone) :-
OnDone().
executeScript([H|T], OnDone) :-
DoneH = { :- executeScript(T, OnDone) },
executeCommand(H, DoneH).
我 们 用 了 一 个 匿 名 谓 词 来 完 成 剩 余 脚 本 的 执 行 , 这 个 谓 词 获 取 T 和 OnDone。
事 实 变 量 的 赋 值
赋 值 算 子 := 用 于 给 事 实 变 量 FactVariable 赋 予 新 值 。Term 必 须 能 求 值 得 到 适 当 的 类 型 ( 与 事 实 变
量 相 同 的 类 型 或 是 其 子 类 型 )。
事 实
FactVariableAssignment:
FactVariable := Term
事 实 数 据 库 包 含 有 若 干 完 全 实 例 化 的 ( 根 基 ) 谓 词 头 部 的 相 应 事 实 , 这 些 事 实 是 在 事 实 段 声 明 的 。 事
实 可 以 由 谓 词 调 用 来 访 问 , 只 要 把 事 实 名 当 谓 词 名 就 行 了 。 各 个 事 实 依 次 与 谓 词 调 用 进 行 匹 配 , 每 次 谓 词
调 用 与 事 实 匹 配 了 则 成 功 , 可 能 还 会 带 有 对 下 一 个 事 实 的 回 溯 点 ; 当 事 实 数 据 库 中 再 也 没 有 其 它 的 事 实 时
这 个 谓 词 调 用 就 失 败 了 。
可 以 用 谓 词 assert/1、asserta/1 和 assertz/1 插 入 新 的 事 实 。assert/1 和 assertz/1 是 一 样 的 , 把 新 事
实 插 入 到 事 实 列 表 的 尾 部 , 而 asserta/1 则 把 新 事 实 插 入 到 列 表 的 开 头 。
69

已 有 的 事 实 可 以 用 谓 词 retract/1 和 retractAll 撤 消 。retract/1 撤 消 第 一 个 与 参 数 匹 配 的 事 实 , 并 且 可
以 通 过 回 溯 撤 消 更 多 的 事 实 。retractAll 能 撤 消 所 有 与 参 数 匹 配 的 事 实 , 它 总 能 成 功 。
运 算 符
运 算 符 ( 算 子 ) 按 优 先 级 分 组 , 下 面 各 组 的 算 子 在 组 内 具 有 相 同 的 优 先 级 , 而 在 前 面 的 组 优 先 级 高 于
后 面 组 的 优 先 级 。 如 , 一 元 加 减 号 ( 也 就 是 正 负 号 ) 优 先 级 高 于 幂 算 子 , 而 幂 算 子 的 优 先 级 又 高 于 乘 法 算
子 , 等 等 。 圆 括 号 可 以 用 来 标 示 优 先 级 使 之 更 清 晰 。
UnaryOperator: one of
- +
BinaryOperator: one of
PowerOperator
MultiplicationOperator
AdditionOperator
RelationOperator
AndOperator
OrOperator
只 有 幂 算 子 是 右 结 合 的 , 其 它 所 有 算 子 都 是 左 结 合 的 。
例 下 面 的 项 :
7 + 3 * 5 * 13 + 4 + 3 = X / 6 ; A < 7, p(X)
与 下 面 的 项 是 一 样 的 :
((((7 + ((3 * 5) * 13)) + 4) + 3) = (X / 6)) ; ((A < 7) , p(X))
也 就 是 说 , 最 外 层 是 两 个 “ 或 ” 关 系 的 项 , 其 中 第 一 个 项 是 一 个 “ 等 号 ” 关 系 项 而 第 二 个 是 一 个 “ 与 ”
项 。
算 术 运 算 符
算 术 运 算 符 用 于 对 数 进 行 算 术 运 算 。 它 们 是 表 达 式 , 并 以 表 达 式 为 参 数 。 参 数 是 根 类 型 的 , 而 返 回 的
结 果 具 有 通 用 类 型 ( 参 看 通 用 类 型 和 根 类 型 )。
关 系 运 算 符
PowerOperator:
^
MultiplicationOperator: one of
* / div mod quot rem
AdditionOperator: one of
+ -
关 系 运 算 符 是 公 式 , 以 表 达 式 为 参 数 。 由 于 这 个 特 性 , 所 以 它 们 是 非 结 合 的 。
70

RelationOperator: one of
= > < >= <
先 对 左 边 的 项 做 计 算 , 而 后 是 右 边 的 , 最 后 将 结 果 做 比 较 。
注 意 , 并 非 双 算 子 的 =, 是 比 较 两 个 值 , 而 = 是 要 合 一 两 个 项 ( 至 少 通 常 情 况 下 是 这 样 )。
对 偶 的 表 达 式 A = B 与 (A = B) 也 是 有 差 别 的 。
逻 辑 运 算 符
与 算 子 (AndOperator) 和 或 算 子 (OrOperator) 是 公 式 , 以 公 式 为 参 数 , 它 们 都 是 左 结 合 的 。
“,” 和 “and” 是 一 回 事 ,“;” 和 “or” 也 是 一 回 事 。
AndOperator: one of
, and
OrOperator: one of
; or
And (,)
一 个 “and” 项 “A, B” 的 处 理 过 程 如 下 : 先 对 左 子 项 A 求 值 , 如 果 求 值 失 败 , 整 个 “and” 项 就 失
败 了 。 如 果 A 成 功 了 , 再 对 右 子 项 B 求 值 , 如 果 失 败 ,“and” 项 失 败 。 否 则 “and” 项 就 成 功 了 。 因 此 ,
如 果 子 项 A 成 功 了 , 只 需 要 对 第 二 个 子 项 B 求 值 就 行 了 。
例
clauses
ppp() :-
qqq(), rrr().
当 调 用 ppp 时 , 首 先 会 调 用 qqq, 如 果 qqq 成 功 了 , 则 会 调 用 rrr。 如 果 rrr 成 功 , 则 “and” 项 成 功 ,
进 而 整 个 子 句 成 功 。
Or (;)
一 个 “or” 项 “A; B” 的 处 理 过 程 如 下 : 首 先 在 第 二 项 B 上 创 建 一 个 回 溯 点 , 然 后 对 第 一 项 A 求 值 。
如 果 求 值 成 功 , 则 整 个 “or” 项 成 功 , 并 留 有 一 个 第 二 项 B 的 回 溯 点 。 如 果 第 一 项 求 值 失 败 了 , 第 二 项 上
的 回 溯 点 就 被 激 活 。 激 活 后 ( 无 论 是 第 一 项 失 败 而 激 活 的 还 是 以 后 调 用 过 程 中 激 活 的 ), 就 对 第 二 项 B 求
值 , 如 果 B 成 功 则 整 个 “or” 项 成 功 。 因 此 , 一 个 “or” 项 可 以 在 一 个 回 溯 点 上 成 功 , 而 回 溯 中 仅 需 要 对
第 二 个 子 项 B 求 值 。
注 意 , 目 前 “or” 项 只 能 用 在 子 句 体 的 最 外 层 , 或 是 用 在 目 标 中 。 以 后 的 版 本 会 对 此 作 出 修 改 。
例
clauses
ppp() :-
qqq(V), write(V), fail.
qqq(X) :-
X = 3 ; X = 7.
调 用 ppp 时 首 先 调 用 qqq。qqq 会 先 在 X = 7 上 创 建 一 个 回 溯 点 , 再 计 算 X = 3。 这 时 ,X 会 绑 定 为 3,
qqq 返 回 。 而 这 时 ppp 中 的 V 会 绑 定 为 3, 写 V( 即 3) 然 后 碰 到 fail,fail 总 是 失 败 , 这 样 就 又 会 回 到 qqq
71

中 的 回 溯 点 。 回 溯 会 解 除 创 建 回 溯 点 以 来 所 有 的 绑 定 , 所 以 ppp 中 的 V 和 qqq 中 的 X 绑 定 都 解 除 了 。 然 后
计 算 qqq 中 的 X = 7,X 被 绑 定 为 7, 回 到 ppp 中 ,V 被 绑 定 为 7 并 写 出 来 。 又 碰 到 fail, 此 时 在 ppp 中 已 经
没 有 回 溯 点 了 , 所 以 ppp 失 败 。
深 层 嵌 套 的 “or”
可 以 在 子 句 中 嵌 套 “or”。
clauses
p(X) = Y :-
(X = 1, !, Z = 3 or Z = 7), Y = 2*Z.
这 里 使 用 了 关 键 字 “or”, 但 也 可 以 用 分 号 “;”, 推 荐 使 用 “or”。 它 主 要 是 用 在 条 件 测 试 中 :
clauses
isOutside(X) :-
(X < 10 or X > 90),!.
“or” 是 一 个 非 确 定 性 的 结 构 , 因 此 很 多 情 况 下 需 要 用 截 断 使 代 码 是 确 定 性 的 。 尤 其 是 在
“if-then-else” 结 构 中 , 需 要 使 用 截 断 。
clauses
p(X) :-
if (X = 1 or X > 17),! then
...
end if.
今 后 的 版 本 中 非 确 定 性 条 件 是 允 许 的 , 因 而 截 断 会 隐 含 在 这 样 的 条 件 中 。 这 种 变 化 是 向 后 兼 容 的 , 已
有 程 序 不 需 要 改 变 。
Not
not/1 用 一 个 项 作 参 数 。not(A) 的 计 算 , 首 先 计 算 A, 如 果 A 成 功 , 则 not(A) 失 败 , 如 果 A 失 败 , 则
not(A) 成 功 。
注 意 ,not(A) 不 会 绑 定 任 何 变 量 。 因 为 如 果 not(A) 成 功 则 A 会 失 败 , 而 失 败 的 项 不 会 绑 定 任 何 东 西 ;
而 如 果 not(A) 失 败 , 也 不 会 绑 定 任 何 变 量 , 因 为 该 项 本 身 是 失 败 的 。 还 要 注 意 ,not(A) 不 会 在 带 有 回 溯
点 的 情 况 下 成 功 , 因 为 如 果 not(A) 成 功 则 A 是 失 败 的 , 而 失 败 的 项 不 可 能 还 有 回 溯 点 。 这 也 就 意 味 着 , 所
有 A 成 功 的 可 能 都 已 经 穷 尽 了 。
fail/0 和 succeed/0
fail/0 和 succeed/0 是 两 个 内 建 的 空 元 谓 词 , 前 者 总 是 失 败 而 后 者 总 是 成 功 , 此 外 它 们 没 有 别 的 效 果 。
Cut( 截 断 )
截 断 “!” 将 进 入 当 前 谓 词 以 来 创 建 的 所 有 回 溯 点 都 消 除 掉 , 这 包 括 对 后 继 子 句 的 所 有 回 溯 点 , 以 及 谓
词 调 用 在 当 前 子 句 “!” 之 前 建 立 的 回 溯 点 。
Cut:
72

!
例
clauses
ppp(X) :-
X > 7,
!,
write("Greater than seven").
ppp(_X) :-
write("Not greater than seven").
执 行 ppp 时 , 首 先 在 第 二 个 子 句 上 创 建 一 个 回 溯 点 , 然 后 执 行 第 一 个 子 句 。 如 果 “X > 7” 成 功 了 ,
就 碰 到 了 截 断 “!”, 它 会 消 除 第 二 个 子 句 上 的 回 溯 点 。
例
clauses
ppp() :-
qqq(X),
X > 7,
!,
write("Found one").
ppp() :-
write("Did not find one").
clauses
qqq(3).
qqq(12).
qqq(13).
当 执 行 ppp 时 首 先 在 ppp 第 二 个 子 句 创 建 一 个 回 溯 点 , 接 着 调 用 qqq。 而 qqq 会 在 它 的 第 二 个 子 句 上
创 建 一 个 回 溯 点 并 执 行 第 一 个 子 句 , 返 回 值 3。 这 样 , 在 ppp 中 的 X 就 绑 定 为 这 个 值 并 与 7 相 比 较 , 它 失 败
了 , 控 制 就 会 回 退 到 qqq 的 第 二 个 子 句 上 。 在 执 行 qqq 的 第 二 个 子 句 之 前 , 会 在 它 的 第 三 个 子 句 上 创 建 一
个 回 溯 点 , 执 行 第 二 个 子 句 返 回 的 值 是 12。 这 次 与 7 的 比 较 成 功 了 , 执 行 截 断 , 它 会 把 在 qqq 上 剩 下 的 回
溯 点 以 及 在 ppp 第 二 个 子 句 上 的 回 溯 点 都 取 消 。
Cut 范 围
cut 范 围 是 指 截 断 的 作 用 域 , 其 意 义 是 : 一 个 cut, 只 能 撤 消 在 其 作 用 范 围 内 的 回 溯 点 , 而 在 这 个 范 围
之 外 的 回 溯 点 则 不 受 影 响 , 仍 然 保 留 。
谓 词 的 子 句 是 一 个 cut 范 围 , 也 就 是 说 , 一 个 cut( 至 多 ) 会 撤 消 进 入 这 个 谓 词 之 后 创 建 的 回 溯 点 , 在
进 入 这 个 谓 词 之 前 创 建 的 那 些 回 溯 点 将 保 留 下 来 。
例
clauses
aaa() :- p1_nd(), qqq().
qqq() :- p2_nd(), !.
aaa 调 用 p1_nd, 会 留 下 一 个 回 溯 点 , 然 后 又 调 用 qqq;qqq 又 调 用 p2_nd, 也 会 留 下 一 个 回 溯 点 ,
接 着 就 碰 到 一 个 截 断 (cut)。 这 个 截 断 是 在 qqq 谓 词 的 截 断 范 围 内 的 , 所 以 它 只 能 废 掉 p2_nd 上 的 那 个
回 溯 点 , 而 p1_nd 上 的 仍 然 保 留 。
73

有 几 个 项 涉 及 到 截 断 范 围 ( 参 看 list comprehension、if-thenelse、foreach)。 这 里 以 if-then-else
为 例 来 说 明 一 下 截 断 范 围 的 影 响 。 来 看 下 面 这 个 示 例 性 的 if-then-else 项 :
if Cond then T1 else T2 end if
条 件 Cond 是 一 个 截 断 范 围 , 在 Cond 中 的 cut 只 在 Cond 中 起 作 用 。 另 一 方 面 , 在 T1 和 T2 中 的 Cut,
其 作 用 则 会 超 出 if-then-else 的 语 句 。 看 下 面 的 代 码 片 断 :
X = getMember_nd([3,1,2]),
if X = getMember_nd([3,3]), ! then
write(X)
else
!
end if,
fail
getMember_nd 是 一 个 非 确 定 谓 词 。 这 段 代 码 的 计 算 过 程 如 下 : 首 先 X 绑 定 为 3,getMember_nd
留 下 一 个 回 溯 点 ( 这 样 以 后 X 还 可 以 为 1 再 为 2)。 接 着 , 要 计 算 if-then-else 项 的 条 件 , 这 个 条 件 的 第 一
部 分 会 成 功 , 因 为 3 是 [3,3] 的 一 个 成 员 。 第 一 部 分 也 一 样 会 留 下 一 个 回 溯 点 , 这 样 它 就 能 多 次 检 查 X 是 否
为 一 个 成 员 。 接 下 来 , 碰 到 一 个 截 断 , 这 个 截 断 是 在 if-then-else 语 句 条 件 部 分 中 的 , 故 只 在 这 个 范 围 中
起 作 用 , 也 就 是 说 它 只 废 掉 了 第 二 个 getMember_nd 上 的 回 溯 点 , 而 第 一 个 getMember_nd 谓 词 上 的
回 溯 点 仍 然 保 留 。 整 个 条 件 部 分 成 功 , 现 在 进 入 到 then- 部 分 , 写 出 “3”。if-then-else 之 后 我 们 遇 到
了 fail, 这 样 就 又 回 溯 到 第 一 个 getMember_nd, 它 又 绑 定 X 为 1, 留 下 一 个 回 溯 点 ( 以 后 再 回 溯 时 可 以
使 X 为 2)。 再 次 进 行 if-then-else 的 条 件 部 分 的 计 算 , 条 件 的 第 一 部 分 失 败 了 , 因 为 1 不 是 [3,3] 的 成 员 。
这 样 就 进 入 到 else- 部 分 , 在 这 儿 遇 到 一 个 截 断 , 这 个 cut 是 在 选 择 项 的 else- 部 分 的 , 它 的 作 用 会 超 越
if-then-else 项 , 因 此 第 一 个 getMember_nd 上 的 回 溯 点 被 撤 消 了 。 在 if-then-else 项 之 后 遇 到 了 fail,
而 此 时 代 码 中 已 经 没 有 回 溯 点 , 这 段 代 码 就 失 败 了 , 而 X 总 也 不 会 为 2。
List Comprehension( 述 求 表 )
ListComprehensionTerm :
[ Term || Term ]
述 求 表 项 是 一 个 表 的 表 达 式 。 看 下 面 的 示 例 项 :
[ Exp || Gen ]
通 常 Gen 是 一 个 nondeterm 项 , 而 Exp 是 收 集 Gen 的 各 个 解 计 算 得 到 的 。 它 形 成 了 一 个 表 , 相 应 于
Gen 的 第 一 个 解 的 是 Exp 的 表 中 的 第 一 个 元 素 , 等 等 。 这 个 表 , 是 述 求 表 项 的 结 果 。Exp 必 须 是 procedure
( 或 erroneous)。Exp 和 Gen 都 是 cut 范 围 。
述 求 表 一 般 读 为 : 如 Gen 所 述 , 那 样 的 Exp 的 表 。
例
[ X || X = getMember_nd(L), X div 2 = 0 ]
它 可 以 读 为 :X 在 L 中 并 且 X 是 偶 数 的 X 的 表 。 所 以 , 这 个 表 达 式 是 L 中 的 偶 数 成 员 。
例
[ X + 1 || X = getMember_nd(L), X div 2 = 0 ]
74

这 里 的 收 集 表 达 式 更 复 杂 了 , 要 说 这 个 项 也 更 麻 烦 了 : 这 样 的 (X+1) 的 表 …。 上 面 这 个 表 达 式 还 是
找 L 中 的 偶 数 成 员 , 但 结 果 表 则 是 把 它 们 各 加 1。 因 而 , 它 与 下 面 这 个 表 达 式 是 完 全 等 价 的 :
[ Y || X = getMember_nd(L), X div 2 = 0 , Y = X+1 ]
这 个 项 就 比 较 易 于 说 :X 则 在 L 中 并 且 X 是 偶 数 ,Y 是 X+1, 那 样 的 Y 的 表 。
访 问 对 象 成 员
无 论 什 么 时 候 , 只 要 我 们 引 用 了 一 个 对 象 , 我 们 就 可 以 访 问 这 个 对 象 的 对 象 成 员 谓 词 。
MemberAccess:
Term : Identifier
( 目 前 term( 项 ) 只 能 是 一 个 变 量 或 一 个 事 实 变 量 )。
标 识 必 须 是 项 的 类 型 。
在 实 现 内 部 , 调 用 对 象 成 员 谓 词 时 不 必 引 用 对 象 , 因 为 包 含 了 “This”, 参 看 范 围 。
访 问 域 、 函 子 和 常 数
对 域 、 函 子 和 常 数 , 可 以 将 它 们 视 为 类 成 员 来 访 问 , 即 便 是 在 接 口 中 声 明 的 也 一 样 。 这 也 意 味 着 , 如
要 对 它 们 做 限 定 , 总 是 用 类 / 接 口 名 加 双 冒 号 。
foreach
ForeachTerm :
foreach Term do Term end foreach
看 下 面 的 foreach 示 例 项 :
foreach Gen do Body end foreach
通 常 Gen 是 一 个 nondeterm 项 。Body 对 每 一 个 Gen 的 解 求 值 。 当 Gen 失 败 则 foreach 项 成 功 , 不
需 要 进 行 Body 计 算 。Body 必 须 是 procedure( 或 erroneous)。Gen 和 Body 都 是 cut 范 围 。
这 个 示 例 的 项 , 类 似 于 下 面 的 fail 循 环 :
Gen,
Body,
fail
两 者 的 主 要 差 别 是 , 重 复 后 foreach 项 成 功 , 而 fail 循 环 是 失 败 。 因 此 ,foreach 项 可 以 后 跟 其 它 的
项 , 还 可 以 嵌 套 。
例
foreach L = list::getMember_nd(LL) do
write("

write(" >>\n")
end foreach.
这 里 的 LL 假 设 是 一 个 表 的 表 。 外 层 的 foreach 循 环 用 L 遍 访 这 个 表 , 所 以 L 是 一 个 表 。 内 层 的 foreach
循 环 用 X 遍 访 L 中 的 元 素 。
有 几 点 需 要 注 意 :
• 在 关 键 字 do 和 end foreach 之 前 都 没 有 逗 号 ;
• foreach 项 的 Body 是 一 个 cut 范 围 , 所 以 在 体 中 的 cut 不 会 影 响 重 复 ;
• foreach 项 总 是 成 功 ( 或 引 起 异 常 ), 在 它 求 值 完 成 之 后 , 没 有 额 外 的 变 量 被 绑 定 。 因 此 ,foreach
项 只 能 使 用 其 辅 助 功 能 。
例
clauses
p(L) :-
foreach X = list::getMember_nd(L) do
stdio::write(X, "\n")
end foreach,
stdio::write("Finished\n").
Foreach 可 以 用 来 替 代 传 统 的 fail 循 环 :
clauses
p(L) :-
X = list::getMember_nd(L),
stdio::write(X, "\n"),
fail.
p(_L) :-
stdio::write("Finished\n").
在 这 种 情 况 下 , 体 的 过 程 性 是 很 有 好 处 的 , 因 为 在 fail 循 环 中 就 怕 在 到 达 循 环 的 fail 之 前 的 偶 尔 失 败 。
还 有 一 个 便 利 之 处 是 ,foreach 循 环 在 循 环 结 束 时 是 成 功 的 , 不 像 fail 循 环 是 失 败 , 所 以 可 以 在 同 一 个 子 句
内 继 续 进 行 下 去 。
foreach 还 可 以 嵌 套 :
if-then-else
clauses
p(LL) :-
foreach L = list::getMember_nd(LL) do
foreach X = list::getMember_nd(L) do
stdio::write(X, "\n")
end foreach,
stdio::write("Finished a list\n")
end foreach,
stdio::write("Finished all lists\n").
按 不 同 条 件 执 行 一 组 语 句 。
IfThenElseTerm:
if Condition then Term Elseif-list-opt Else-opt end if
76

Elseif:
elseif Condition then Term
Else:
else Term
下 面 两 个 项 是 等 价 的 :
if Cond1 then T1 elseif Cond2 then T2 else T3 end if
if Cond1 then T1 else
if Cond2 then T2 else T3 end if
end if
来 看 一 下 示 例 的 if then else 项 :
if Cond then T1 else T2 end if
首 先 对 Cond 求 值 , 如 果 成 功 则 对 T1 求 值 , 否 则 对 T2 求 值 。Cond 不 允 许 有 回 溯 点 , 也 就 是 说 它 不 能
是 多 态 的 (multi) 或 非 确 定 的 (nondeterm)。Cond 是 一 个 cut 范 围 ( 参 看 cut 范 围 )。
例
clauses
w(X) :-
if X div 2 = 0 and X > 3 then
write("X is good")
else
write("X is bad"),
nl
end if,
nl.
这 个 例 子 中 , 要 注 意 几 点 :
• 在 所 有 三 个 子 项 中 , 可 以 使 用 and 和 or 逻 辑 操 作 符 以 及 其 它 “ 组 合 ” 项 ;
• 在 关 键 字 then、elseif、else 和 end if 之 前 没 有 逗 号 。
为 有 良 好 的 可 读 性 , 推 荐 用 “or” 替 代 “;”。 同 样 , 当 表 示 一 个 逻 辑 条 件 时 ( 如 上 例 中 的 情 况 ),
推 荐 用 “and” 替 代 “,”。
省 去 else 部 分 是 “else succeed” 的 简 化 形 式 , 即 :
if Cond then T1 end if
是 下 面 的 简 写 形 式 :
try-catch-finally
if Cond then T1 else succeed end if
try-catch-finally 语 句 提 供 了 一 种 处 理 给 定 程 序 代 码 块 中 可 能 出 现 异 常 的 方 法 。
TryCatchTerm:
try Term CatchFinally-list end try
77

CatchFinally: one of
catch Variable do Trap-Handler
finally Finally-Handler
Handler:
Term
try 结 构 有 一 个 项 及 一 个 捕 获 变 量 和 最 终 异 常 处 理 过 程 的 表 。 项 和 异 常 处 理 过 程 都 不 能 留 有 回 溯 点 ( 即
不 能 是 multi 或 nondeterm)。
带 有 多 个 异 常 处 理 过 程 的 try 结 构 等 效 于 单 个 异 常 处 理 过 程 的 try 结 构 的 嵌 套 , 下 面 的 项 :
try
Body
catch Var1 do
Handler1
finally
Handler2
catch Var2 do
Handler3
end try
与 下 面 的 嵌 套 项 是 等 价 的 :
try
try
try
Body
catch Var1 do
Handler1
end try
finally
Handler2
end try
catch Var2 do
Handler3
end try
try-catch
看 下 面 这 个 try-catch 结 构 :
try
Body
catch Var do
Handler
end try
首 先 是 对 Body 求 值 。 如 果 Body 失 败 或 成 功 , 则 整 个 try 结 构 失 败 或 成 功 。 即 : 若 Body 并 未 因 一 个
异 常 而 终 止 , 则 try 结 构 就 相 当 于 对 Body 求 值 。
如 果 由 于 一 个 异 常 而 使 Body 终 止 了 , 这 个 异 常 就 被 捕 获 , 意 思 是 Var 首 先 被 绑 定 为 该 异 常 ( 在 PFC
关 联 中 这 个 异 常 是 一 个 traceId), 接 着 对 Handler 求 值 。 这 种 情 况 下 该 结 构 就 是 带 有 绑 定 于 捕 获 异 常 的
Var 对 Handler 的 求 值 。
注 意 , 如 果 Body 因 异 常 而 终 止 了 , 它 本 身 并 不 会 绑 定 什 么 东 西 。
78

例 处 理 一 个 文 件 不 能 读 的 情 况 :
clauses
read(Filename) = Contents :-
try
Contents = file::readFile(Filename)
catch TraceId do
stdio::writef("Could not read the file: %\n", Filename),
exceptionDump::dumpToStdio(TraceId),
Contents = ""
end try.
首 先 , 求 解 Contents = file::readFile(Filename), 如 果 它 并 未 因 为 read 异 常 而 终 止 , 就 会 返 回
文 件 的 内 容 。
如 果 出 现 了 异 常 , 就 会 带 着 绑 定 于 该 异 常 的 TraceId 对 异 常 处 理 过 程 求 解 。 此 时 , 会 将 一 个 消 息 写 到
stdio 并 把 异 常 输 出 到 stdio, 最 后 把 Contents 设 为 空 串 作 为 结 果 返 回 。
try-finally
看 下 面 的 try-finally 结 构 :
try
Body
finally
Handler
end try
这 个 结 构 的 目 标 是 在 Body 之 后 对 Handler 求 值 , 而 不 管 Body 是 如 何 结 束 的 , 即 它 是 成 功 也 好 , 失
败 也 好 , 因 异 常 而 终 止 也 好 ( 这 时 不 能 留 有 回 溯 点 ), 都 要 对 Handler 求 值 。
求 值 过 程 是 这 样 的 :
先 对 Body 求 值 , 若 成 功 再 执 行 Handler,try-finally 结 构 成 功 ; 若 失 败 也 执 行 Handler,try-finally
结 构 失 败 ; 若 出 现 异 常 Exn, 还 是 执 行 Handler,try-finally 结 构 带 着 Exn 异 常 终 止 。
例 确 保 在 使 用 过 后 odbcStatement 是 自 由 的 :
clauses
tryGetName(Connection, PersonId) = Name :-
Stmt = odbcStatement::new(Connection),
try
Stmt:setParameterValue(1, core::integer(PersonId)),
Stmt:execDirect("select name from person where id=?"),
Stmt:fetch(),
Name = Stmt:getParameterValue_string(1)
finally
Stmt:free()
end try.
即 使 fetch 失 败 或 是 其 它 什 么 原 因 出 现 异 常 了 ,Stmt 也 是 自 由 的 。
转 换
79

视 类 型 与 构 造 类 型
接 口 定 义 对 象 的 类 型 , 支 持 某 个 接 口 的 所 有 对 象 都 具 有 这 个 接 口 定 义 的 类 型 。 以 后 , 我 们 把 对 象 类 型
与 接 口 定 义 的 类 型 视 为 同 义 语 。
接 口 定 义 了 类 型 , 这 些 类 型 就 可 以 在 谓 词 及 事 实 声 明 和 域 定 义 中 用 作 正 式 的 类 型 说 明 符 。
对 象 具 有 了 任 意 它 所 支 持 接 口 的 对 象 类 型 , 它 也 就 可 以 当 作 任 意 这 些 类 型 的 对 象 来 使 用 , 也 就 是 说 ,
对 象 类 型 被 转 换 为 任 意 支 持 的 对 象 类 型 。 下 面 要 说 明 , 这 种 转 换 多 数 情 况 下 是 自 动 进 行 的 。
因 此 , 同 一 个 对 象 在 不 同 关 联 中 可 以 视 为 具 有 不 同 的 类 型 。 这 样 观 察 的 对 象 类 型 被 称 为 视 类 型 , 而 构
造 对 象 的 类 的 类 型 被 称 作 构 造 类 型 或 定 义 类 型 。 构 造 类 型 也 是 一 个 视 类 型 。
类 型 转 换
如 上 所 述 , 对 象 可 以 当 成 任 意 它 所 支 持 的 接 口 的 类 型 来 使 用 。 这 一 节 要 描 述 各 种 支 持 类 型 的 转 换 是 怎
么 进 行 的 。
Conversion Upwards( 向 上 转 换 )
如 果 某 个 项 静 态 地 归 类 于 某 个 类 型 T1, 而 T1 又 声 明 支 持 T2, 那 么 很 明 显 该 变 量 引 用 的 任 何 对 象 肯 定
是 支 持 的 T2。 因 此 , 向 上 支 持 的 消 息 是 静 态 获 取 的 。 因 而 , 在 支 持 层 级 上 的 所 有 向 上 转 换 是 自 动 进 行 的 。
例 假 设 有 接 口 bb, 它 支 持 接 口 aa 及 构 造 类 型 为 bb 的 类 bb_class。 来 看 下 面 的 代 码 :
implement ...
predicates
ppp : (aa AA).
clauses
... :-
BB = bb_class::new(), % (1)
ppp(B). % (2)
clauses
ppp(AA) :- % (3)
...
BB = convert(bb,AA), % 可 以 转 换 , 因 为 AA 的 定 义 类 型 是 bb
...
在 (1) 那 行 我 们 创 建 了 一 个 bb_class 对 象 , 该 对 象 具 有 构 造 类 型 bb。 变 量 BB 是 对 这 个 新 对 象 的 引
用 , 它 提 供 了 对 该 对 象 的 视 类 型 bb。 在 (2) 那 一 行 该 对 象 作 为 一 个 aa 对 象 传 递 给 了 ppp, 从 视 类 型 bb
到 视 类 型 aa 的 转 换 是 隐 含 进 行 的 。 到 了 (3) 那 行 对 象 的 视 类 型 就 是 aa 了 , 尽 管 此 时 构 造 类 型 仍 是 bb。
显 式 转 换
显 式 转 换 是 通 过 调 用 转 换 谓 词 来 完 成 的 , 可 用 的 转 换 谓 词 有 若 干 个 。
Checked Conversion
谓 词 convert/2-> 和 tryConvert/2-> 用 于 安 全 地 完 成 从 一 个 类 型 到 另 一 个 类 型 的 转 换 。 这 两 个 谓 词 都
给 不 出 真 实 的 声 明 , 伪 声 明 如 下 :
predicates
80

convert : ("type" Type, _ Value) -> Type ConvertedValue.
tryConvert : ("type" Type, _ Value) -> Type ConvertedValue determ.
convert/2-> 和 tryConvert/2-> 这 两 个 谓 词 都 用 “type” 作 第 一 个 参 数 , 以 任 意 类 型 的 一 个 值 做 第
二 个 参 数 , 并 把 转 换 的 值 作 为 结 果 返 回 。
如 果 不 能 进 行 转 换 ,convert/2-> 会 产 生 一 个 异 常 , 而 tryConvert/2-> 只 会 失 败 。
注 意 , 如 果 源 类 型 是 目 标 类 型 的 子 类 型 , 使 用 convert/2-> 和 tryConvert/2-> 就 总 是 多 余 的 , 因 为 此
时 会 隐 含 地 进 行 转 换 。
报 告 。
这 两 个 谓 词 可 以 用 在 以 下 场 合 :
• 从 一 个 数 域 到 另 一 个 数 域 的 转 换 ;
• 将 一 个 对 象 转 换 到 另 一 个 类 型 。
编 译 器 如 果 能 确 定 一 个 转 换 肯 定 不 会 成 功 ( 比 如 要 转 换 的 数 域 间 根 本 没 有 交 集 ), 会 有 ( 但 并 非 总 有 )
Conversion Downward( 向 下 转 换 )
当 一 个 对 象 转 换 成 超 类 型 ( 如 支 持 的 接 口 ) 时 , 这 个 对 象 的 信 息 就 “ 不 记 得 ” 了 。 当 然 能 力 并 不 是 真
的 丢 失 了 , 而 只 是 从 这 种 弱 化 能 力 接 口 的 关 联 中 来 看 对 象 时 看 不 到 了 。 在 很 多 情 况 下 需 要 恢 复 对 象 的 实 际
能 力 , 因 此 需 要 对 它 们 进 行 向 下 及 向 上 的 转 换 。
向 下 转 换 ( 一 般 ) 无 法 静 态 地 验 证 , 因 此 , 当 恢 复 “ 丢 失 ” 的 接 口 时 需 要 显 式 地 转 换 。
例 尽 管 要 弄 个 在 支 持 层 级 中 向 上 转 换 类 型 的 有 意 义 的 说 明 例 子 很 简 单 , 但 说 明 有 意 义 的 向 下 转 换 的
用 法 还 是 需 要 一 个 “ 真 实 ” 的 例 子 , 这 里 我 们 给 出 一 个 较 “ 真 实 ” 的 例 子 。
假 设 我 们 要 实 现 一 组 相 似 类 型 的 对 象 , 比 如 一 组 支 持 某 个 视 类 型 的 对 象 , 我 们 需 要 这 样 的 集 合 用 于 若
干 对 象 类 型 。 因 此 , 我 们 打 算 这 么 办 : 即 要 使 不 同 类 型 的 对 象 能 接 受 , 又 要 保 持 这 些 对 象 的 同 质 性 。
方 法 是 标 准 化 的 : 我 们 使 集 合 的 实 际 实 现 基 于 对 象 的 类 型 , 这 个 类 型 是 所 有 对 象 都 支 持 的 。 然 后 用 一
个 在 实 际 类 型 和 对 象 间 转 换 的 薄 层 来 构 造 集 合 的 特 殊 版 本 。 没 有 对 象 集 合 的 实 际 实 现 , 我 们 只 需 要 假 设 它
形 式 上 存 在 于 下 面 的 类 和 接 口 中 :
interface objectSet
predicates
insert : (object Elem).
getSomeElem : () -> object determ.
...
end interface
class objectSet_class : objectSet
end class
假 设 有 某 个 对 象 类 型 myObject 而 我 们 想 要 创 建 相 应 的 “set” 类 myObjectSet_class。 这 样 声 明
myObjectSet_class:
interface myObjectSet
predicates
insert : (myObject Elem).
getSomeElem : () -> myObject determ.
...
end interface
class myObjectSet_class : myObjectSet
end class
即 ,myObjectSet 有 objectSet 的 所 有 谓 词 , 但 每 当 object 出 现 时 就 替 换 成 myObject。
81

myObjectSet_class 的 实 现 继 承 自 objectSet_class, 这 个 内 置 / 继 承 的 objectSet 将 取 得 该 集 合 的 成
员 。 该 实 现 会 执 行 如 下 的 不 变 性 : 内 置 的 objectSet 将 只 包 含 myObject 类 型 的 对 象 ( 尽 管 从 “ 技 术 ” 上
说 它 们 具 有 object 类 型 )。
实 现 如 下 :
implement myObjectSet_class
inherit objectSet_class
clauses
insert(Elem) :-
objectSet_class::insert(Elem). % (1)
getSomeElem() = Some :-
SomeObject = objectSet_class::getSomeElem(), % (2)
Some = convert(myObject, SomeObject). % (3)
...
end implement
在 (1) 行 ,Elem 自 动 从 类 型 myObject 转 换 为 object。 在 (2) 那 行 , 从 内 置 的 object 集 中 取 回
一 个 对 象 。 理 论 上 说 这 个 对 象 具 有 object 类 型 , 但 从 不 变 性 上 看 这 个 对 象 也 支 持 myObject。 因 而 我 们
可 以 安 全 地 恢 复 myObject 接 口 , 在 (3) 中 显 式 地 这 样 做 了 。
Private 类 型 和 Public 类 型
由 构 造 器 创 建 的 对 象 , 返 回 时 是 构 造 类 型 。 这 样 的 对 象 可 以 自 动 转 换 成 任 意 所 支 持 的 接 口 类 型 并 又 被
显 式 地 返 回 。
即 使 实 现 对 象 的 类 已 经 声 明 所 支 持 的 接 口 是 私 有 的 , 也 可 以 把 “ 公 用 ” 对 象 转 换 成 这 些 私 有 的 类 型 。
无 论 怎 样 , 在 实 现 内 部 , 对 象 是 可 以 用 任 意 私 有 支 持 的 类 型 访 问 的 。 而 且 ,“This” 可 以 用 任 意 这 些
私 有 支 持 的 类 型 递 交 到 实 现 之 外 。
对 象 这 样 的 “ 私 有 ” 版 本 还 可 以 在 其 层 级 上 隐 含 地 向 上 转 换 并 显 式 地 向 下 转 换 回 来 。 事 实 上 , 这 样 的
“ 私 有 ” 对 象 可 以 显 式 地 转 换 成 任 意 公 用 或 私 有 支 持 的 接 口 。
所 以 , 一 个 对 象 会 有 两 面 , 公 用 的 一 面 和 私 有 的 一 面 , 而 私 有 的 一 面 包 括 了 公 用 类 型 。 对 象 不 能 从 一
面 转 换 到 另 一 面 , 但 因 为 私 有 的 一 面 包 括 了 公 用 类 型 , 所 以 私 有 的 一 面 可 以 转 换 成 任 意 支 持 的 类 型 。
Unchecked Conversion
谓 词 uncheckedConvert/2 用 于 进 行 基 于 内 存 表 示 法 的 非 安 全 性 转 换 。 这 个 谓 词 并 不 对 内 存 做 任 何 修
改 , 它 只 是 强 迫 编 译 器 对 所 指 的 存 储 片 断 解 释 为 另 外 的 类 型 。
注 意 , 这 个 谓 词 是 很 不 安 全 的 , 使 用 时 要 小 心 。
这 个 谓 词 主 要 用 于 与 其 它 语 言 的 接 口 , 来 解 释 其 它 语 言 对 内 存 映 象 的 使 用 方 法 。 它 只 能 使 用 在 大 小 完
全 一 样 的 内 存 片 上 , 而 有 很 多 种 数 据 是 用 指 针 代 表 的 , 这 样 的 数 据 有 相 同 的 大 小 。
例
predicates
uncheckedConvert : ("type" Type, _ Value) -> Type ConvertedValue.
predicates
interpretBufferAsString : (pointer BufferPointer) -> string Value.
clauses
interpretBufferAsString(BufferPointer) = uncheckedConvert(string,BufferPointer).
82

这 个 谓 词 将 把 一 个 指 针 表 示 的 缓 冲 区 解 释 ( 转 换 ) 为 一 个 串 。 只 有 这 个 内 存 块 真 的 可 以 正 确 地 表 示 成
一 个 串 , 它 才 是 有 意 义 的 。
异 常 处 理
本 节 描 述 Visual Prolog 中 异 常 处 理 的 低 级 结 构 。PFC 在 这 个 低 级 机 制 之 上 还 有 一 个 较 高 级 的 层 次 ( 参
看 异 常 处 理 指 南 )。
异 常 处 理 的 基 础 是 基 于 内 建 谓 词 errorExit/1 及 try-catch 语 言 结 构 的 。
• errorExit/1 产 生 一 个 异 常
• try-catch 为 某 个 计 算 设 置 异 常 处 理 程 序 。
当 errorExit/1 调 用 时 , 当 前 激 活 的 异 常 处 理 程 序 被 调 用 , 这 个 异 常 处 理 程 序 是 按 原 来 的 关 联 执 行 的 ,
这 个 关 联 是 原 来 设 置 的 而 不 是 发 生 异 常 那 里 的 关 联 。 调 用 时 的 参 数 传 递 给 了 异 常 处 理 程 序 , 这 个 参 数 必 须
以 某 种 方 式 提 供 需 要 的 异 常 描 述 。
与 其 它 运 行 时 例 程 一 道 , 在 这 个 系 统 之 上 就 可 以 建 立 起 高 级 的 异 常 处 理 机 制 了 。 不 过 运 行 时 系 统 访 问
程 序 及 其 如 何 处 理 异 常 等 问 题 已 经 超 出 本 文 档 的 范 围 , 就 不 介 绍 了 。
try-catch 的 第 一 个 参 数 是 与 新 异 常 处 理 程 序 一 道 执 行 的 项 ; 第 二 个 参 数 必 须 是 一 个 变 量 。 如 果 异 常 处
理 程 序 被 激 活 , 这 个 变 量 将 绑 定 于 errorExit/1 被 调 用 时 的 值 。 第 三 个 参 数 是 异 常 处 理 程 序 , 如 果
errorExit/1 被 调 用 则 会 激 活 这 个 异 常 处 理 程 序 。
异 常 处 理 程 序 可 以 访 问 第 二 个 参 数 说 明 的 变 量 , 因 而 可 以 检 查 发 生 了 什 么 异 常 。
例
clauses
p(X) :-
try
dangerous(X)
catch Exception do
handleDangerous(Exception)
end try.
如 果 在 执 行 dangerous 时 出 现 了 异 常 ,Exception 就 会 绑 定 为 异 常 值 ,try-catch 控 制 将 转 到 的 第 三
个 参 数 , 在 这 里 就 是 把 Exception 传 递 给 handleDangerous。
内 建 实 体
Visual Prolog 有 一 个 内 含 的 类 , 提 供 了 所 有 内 建 的 常 数 、 域 及 谓 词 的 声 明 和 实 现 。 这 些 内 建 的 常 数 、
域 及 谓 词 既 可 以 用 在 编 译 时 ( 如 在 #if ... 结 构 中 ) 也 可 以 用 在 实 现 中 ( 由 运 行 时 支 持 )。 每 个 编 译 单 元 隐
含 地 包 括 了 这 个 内 含 类 的 声 明 。 可 以 在 内 建 项 的 名 称 前 使 用 “::” 以 与 其 它 同 名 的 实 体 相 区 分 。
注 意 , 子 句 变 量 This 是 在 对 象 谓 词 子 句 中 自 动 定 义 的 。
运 算 符
运 算 符 描 述 备 注
83

-( 一 元 ) 一 元 减 ( 负 号 )
^ 幂 对 64 位 整 数 没 有 定 义
*, / 乘 、 除 法
div, mod 整 数 除 法 取 商 和 取 余 对 实 数 无 定 义
quot, rem 整 数 除 法 取 商 和 取 余 对 实 数 无 定 义
+, - 加 、 减 法
• 上 面 的 运 算 符 是 按 优 先 级 由 高 到 低 排 列 的 ;
• 所 有 的 乘 法 和 除 法 运 算 符 优 先 级 是 一 样 的 ;
• 幂 运 算 符 是 右 结 合 的 ;
• 所 有 其 它 运 算 符 都 是 左 结 合 的 。
所 有 二 元 运 算 符 都 有 两 个 参 数 , 这 两 个 参 数 基 类 型 相 同 , 返 回 的 值 也 是 同 样 的 基 类 型 。 操 作 数 和 结 果
的 类 型 可 以 应 用 普 通 子 类 型 规 则 进 行 转 换 。
整 数 除 法
当 计 算 结 果 是 正 数 时 ,div 与 quot 没 有 什 么 区 别 ; 但 当 结 果 是 负 值 时 ,div 的 取 整 使 用 最 接 近 的 最 小
整 数 而 quot 是 使 用 最 接 近 的 最 大 整 数 。mod 是 对 应 于 div 的 余 数 , 而 rem 是 对 应 于 quot 的 余 数 。
A B A div B A mod B A quot B A rem B
15 7 2 1 2 1
-15 7 -3 6 -2 -1
15 -7 -3 -6 -2 1
-15 -7 2 -1 2 -1
常 数
compilation date
compilation time
compiler buildDate
compiler version
maxFloatDigits
null
nullHandle
invalidHandle
platform bits
platform name
编 译 日 期
编 译 时 间
编 译 器 的 构 建 日 期
编 译 器 版 本
定 义 编 译 器 支 持 的 数 字 位 数 的 最 大 值
缺 省 的 空 指 针
值 为 零 的 句 柄 类 型 的 一 个 特 殊 常 数
表 示 非 法 的 ( 值 为 -1) 句 柄 类 型 的 一 个 特 殊 常 数
定 义 编 译 平 台 的 数 字 能 力
定 义 目 标 平 台 名 称
编 译 日 期
compilation_date : string = "YYYY-MM-DD".
84

这 里 的 YYYY 是 代 表 年 的 数 字 ,MM 是 代 表 月 份 的 数 字 ,DD 是 代 表 日 的 数 字 。
编 译 时 间
compilation_time : string = "HH-MM-SS".
这 里 的 HH 代 表 小 时 ,MM 代 表 分 钟 ,SS 代 表 秒 。
编 译 器 构 建 日 期
compiler_buildDate : string = "YYYY-MM-DD HH-MM-SS".
编 译 器 的 构 建 日 期 。
编 译 器 版 本
编 译 器 的 版 本 , 这 个 数 值 与 编 译 器 的 版 本 相 关 。
maxFloatDigits
compiler_version = 6003.
定 义 编 译 器 支 持 的 数 字 位 数 的 最 大 值 。
maxFloatDigits = 19.
null
null : pointer = uncheckedConvert(pointer, 0).
值 为 零 的 指 针 类 型 的 一 个 特 殊 常 数 。
nullHandle
值 为 零 的 句 柄 类 型 的 一 个 特 殊 常 数 。
invalidHandle
nullHandle : handle = uncheckedConvert(handle, 0).
其 值 (-1) 表 示 非 法 的 句 柄 类 型 的 一 个 特 殊 常 数 。
platform_bits
invalidHandle : handle = uncheckedConvert(handle, 0xFFFFFFFF).
编 译 平 台 的 数 字 能 力 。
platform_bits = 32.
85

platform_name
域
目 标 编 译 平 台 名 称 。
platform_name : string = "Windows 32bits".
char
string
string8
symbol
binary
binaryNonAtomic
integer
integer64
unsigned
unsigned64
real
real32
pointer
handle
boolean
factDB
compareResult
宽 ( 两 字 节 ) 字 符
以 两 个 零 字 节 结 尾 的 宽 字 符 序 列
以 一 个 零 字 节 结 尾 的 ASCII ( 单 字 节 ) 字 符 序 列
以 两 个 零 字 节 结 尾 的 宽 字 符 序 列
字 节 序 列
字 节 序 列
有 符 号 整 数
有 符 号 整 数
无 符 号 整 数
无 符 号 整 数
浮 点 数
浮 点 数
指 向 内 存 地 点 的 4 字 节 指 针
指 向 内 存 地 点 的 4 字 节 指 针
布 尔 值
命 名 了 的 内 部 数 据 库 描 述 符
比 较 结 果 的 值
char
宽 字 符 。
char
这 个 域 的 值 是 UNICODE 字 符 , 由 两 个 字 节 无 符 号 数 实 现 。
对 这 个 域 的 值 的 操 作 , 只 能 有 赋 值 和 ( 字 典 意 义 上 的 ) 比 较 。 字 符 映 象 语 法 如 下 :
Char_image :
' Char_value '
Char_value :
Letter
Digit
Graphical_symbol
\ Escape_seq
Escape_seq:
t
n
r
86

\
'
"
u HHHH
上 面 的 HHHH 对 应 于 4 个 十 六 进 制 数 。 还 有 , 反 斜 杠 和 单 引 号 只 能 由 换 码 序 列 来 表 示 。
compareResult
这 是 一 个 内 建 的 域 , 用 来 定 义 一 个 比 较 结 果 。 内 建 谓 词 compare 的 结 果 就 是 这 个 域 的 。
domains
compareResult = less; equal; greater.
string
以 宽 零 结 尾 的 宽 字 符 序 列 。
string
串 是 UNICODE 字 符 序 列 。 它 是 由 一 个 指 向 以 宽 零 结 尾 的 宽 字 符 序 列 的 指 针 实 现 的 。 这 个 域 的 值 只 能
进 行 赋 值 与 ( 字 典 意 义 上 的 ) 比 较 操 作 。 在 源 代 码 中 , 可 以 用 以 双 引 号 括 起 的 字 符 序 列 表 示 一 个 字 符 串 。
StringLiteral:
StringLiteralPart-list
StringLiteralPart :
@" AnyCharacter-list-opt "
" CharacterValue-list-opt "
字 符 串 由 一 个 或 多 个 连 接 起 来 的 StringLiteralPart 组 成 。 带 有 @ 的 StringLiteralPart 不 使 用 换 码
序 列 , 而 不 带 @ 的 StringLiteralPart 则 使 用 以 下 的 换 码 序 列 :
• \\ 表 示 \
• \t 表 示 制 表 符
• \n 表 示 换 行 符
• \r 表 示 回 车
• \' 表 示 单 引 号
• \" 表 示 双 引 号
• \u 后 跟 四 个 十 六 进 制 数 表 示 相 应 的 Unicode 字 符 。
串 中 的 双 引 号 只 能 由 换 码 序 列 来 表 示 , 而 单 引 号 可 以 用 换 码 序 列 或 图 形 符 号 两 种 方 法 来 表 示 。
string8
内 建 的 string8 域 这 个 项 是 一 个 ASCII 字 符 序 列 。 它 是 由 一 个 指 向 零 结 尾 的 ASCII 字 符 序 列 的 指 针 实 现
的 。 这 个 域 的 值 只 能 进 行 赋 值 与 ( 字 典 意 义 上 的 ) 相 等 比 较 操 作 。 目 前 , 对 这 个 域 来 说 , 不 能 使 用 文 字 。
(Currently no literals are allowed for this domain.)
symbol
87

以 宽 零 结 尾 的 宽 字 符 序 列 。
symbol
与 串 一 样 ,symbol 也 是 一 个 UNICODE 字 符 序 列 。 它 是 由 一 个 指 向 包 含 串 的 symbol 表 的 入 口 指 针 实
现 的 。 对 它 可 以 做 的 操 作 与 串 一 样 。
symbol 的 映 象 是 由 串 文 字 ( 用 双 引 号 包 围 的 串 ) 来 表 示 的 。 它 与 串 在 很 大 程 度 上 是 可 以 互 换 的 , 但
它 们 的 存 储 方 式 不 相 同 。symbol 被 放 在 一 个 关 注 表 中 , 它 们 的 地 址 ( 而 不 是 symbol 本 身 ) 存 储 起 来 用 于
代 表 对 象 。 这 意 味 着 symbol 可 以 快 速 地 匹 配 , 而 且 如 果 它 重 复 地 出 现 在 程 序 中 时 占 用 存 储 空 间 很 小 。 串
则 不 是 放 在 关 注 表 中 的 , 进 行 匹 配 时 Visual Prolog 要 逐 个 字 符 地 进 行 检 查 。
binary
N 个 字 节 的 序 列 。
binary
这 个 域 的 值 用 于 保 存 二 进 制 数 。 它 是 由 指 向 这 个 字 节 序 列 的 一 个 指 针 实 现 的 。 这 个 项 的 长 度 放 在 字 节
序 列 的 前 面 , 占 四 个 字 节 。 这 四 个 字 节 的 值 为 :
TotalNumberOfBytesOccupiedByBinary = ByteLen + 4
ByteLen 是 二 进 制 项 本 身 的 长 度 。
对 这 个 域 的 值 只 能 进 行 赋 值 和 比 较 操 作 。 比 较 操 作 的 方 法 如 下 :
• 如 果 两 个 项 长 度 不 一 , 长 度 大 的 那 个 项 大 ;
• 如 果 两 个 项 长 度 一 样 , 就 按 无 符 号 数 逐 字 节 地 比 较 , 比 较 到 不 一 样 的 字 节 时 就 停 止 , 那 个 字 节 的
比 较 结 果 就 是 这 两 个 项 的 比 较 结 果 。 如 果 字 节 都 一 样 , 那 就 是 相 等 。
二 进 制 映 象 的 内 容 语 法 由 Binary 规 则 确 定 :
Binary :
$ [ Byte_value-comma-sep-list-opt ]
Byte_value :
Expression
各 个 表 达 式 的 值 应 是 在 编 译 时 可 计 算 得 到 的 , 且 值 的 范 围 在 0 到 255 之 间 。
binaryNonAtomic
N 个 字 节 的 序 列 。
binaryNonAtomic
同 binary, 但 包 含 指 针 。
integer
有 符 号 整 数 。
integer
88

这 个 域 的 值 占 四 个 字 节 。 可 以 进 行 算 术 运 算 (+, -, /, *, ^)、 比 较 、 赋 值 、div、mod、quot 及 rem
操 作 。 值 的 范 围 是 -2147483648 到 2147483647。
它 的 文 字 表 示 方 法 由 Integer 规 则 确 定 :
Integer :
Add_operation-opt 0o Oct_number
Add_operation-opt Dec_number
Add_operation-opt 0x Hex_number
Add_operation :
+
-
Oct_number :
Oct_digit-list
Oct_digit : one of
0 1 2 3 4 5 6 7
Dec_number :
Dec_digit-list
Dec_digit : one of
Oct_digit 8 9
Hex_number :
Hex_digit-list
Hex_digit : one of
Dec_digit a b c d e f A B C D E F
integer64
有 符 号 整 数 。
integer64
这 个 域 的 值 占 八 个 字 节 。 值 的 范 围 是 -2^63 = -9,223,372,036,854,775,808 到 2^63-1 =
9,223,372,036,854,775,807。 其 文 字 表 示 方 法 及 可 以 进 行 的 操 作 与 integer 相 同 。
unsigned
无 符 号 整 数 。
unsigned
这 个 域 的 值 占 四 个 字 节 。 可 以 进 行 算 术 运 算 (+, -, /, *, ^)、 比 较 、 赋 值 、div、mod、quot 及 rem
操 作 。 值 的 范 围 是 0 到 4294967295。 它 的 表 示 方 法 同 integer, 只 是 不 能 使 用 负 号 。
unsigned64
无 符 号 整 数 。
unsigned64
这 个 域 的 值 占 八 个 字 节 。 值 的 范 围 是 0 到 2^64-1 = 18,446,744,073,709,551,615。 它 的 表 示
方 法 同 integer64, 只 是 不 能 使 用 负 号 。 可 以 进 行 的 操 作 同 unsigned。
89

eal
浮 点 数 ( 实 数 )。
real
这 个 域 的 值 占 八 个 字 节 。 这 个 域 只 是 为 了 方 便 用 户 引 入 的 , 可 以 进 行 所 有 的 算 术 、 赋 值 及 比 较 操 作 。
它 的 值 范 围 是 -1.7e+308 到 1.7e+308。 需 要 的 时 候 , 整 数 域 的 值 会 自 动 地 转 换 成 实 数 域 的 值 。 它 的 文
字 表 示 方 法 由 Real 规 则 确 定 :
Real :
Add_operation-opt Fraction Exponent-opt
Fraction :
Dec_number Fractional_part-opt
Fractional_part :
. Dec_number
Exponent :
Exp Add_operation-opt Dec_number
Exp :
e
E
Add_operation :
+
-
Dec_number :
Dec_digit-list
Dec_digit : one of
0 1 2 3 4 5 6 7 8 9
real32
浮 点 数 。
real32
这 个 域 的 值 占 四 个 字 节 。 它 只 是 为 了 用 户 的 方 便 而 引 入 的 , 可 以 进 行 所 有 的 算 术 、 赋 值 及 比 较 操 作 。
它 的 值 范 围 是 -3.4e+38 到 3.4e+38。 表 示 方 法 同 real。
pointer
内 存 地 址 的 指 针 。
pointer
指 针 直 接 对 应 于 内 存 地 址 , 只 能 进 行 相 等 操 作 。 这 个 类 型 中 有 一 个 内 建 的 常 数 null。
handle
handle( 句 柄 ) 用 于 Windows API 类 函 数 调 用 , 它 占 四 个 字 节 , 不 能 对 它 进 行 什 么 操 作 , 也 不 能 从
别 的 域 转 换 来 或 转 换 到 别 的 域 ( 除 非 是 uncheckedConvert)。 这 个 类 型 中 有 内 建 的 常 数 nullHandle 及
90

invalidHandle。
boolean
布 尔 值 。
boolean
这 个 域 只 是 为 了 用 户 方 便 而 引 入 的 , 它 可 以 看 成 如 下 定 义 的 复 合 域 :
domains
boolean = false(); true().
factDB
命 名 了 的 内 部 数 据 库 描 述 符 。
factDB
这 个 域 有 如 下 隐 含 的 元 声 明 :
domains
factDB = struct @factdb( named_internal_database_domain, object ).
事 实 段 中 所 有 用 户 定 义 的 名 称 都 是 这 个 域 的 常 数 。 需 要 时 , 编 译 器 自 动 地 从 这 些 常 数 中 构 建 相 应 的 复
合 项 。 在 运 行 时 , 这 个 结 构 的 第 一 项 含 有 相 应 域 描 述 符 的 地 址 而 第 二 项 或 是 零 ( 对 类 事 实 段 ) 或 是 一 个 对
象 的 指 针 ( 即 This, 对 对 象 事 实 段 )。
谓 词
assert/1
asserta/1
assertz/1
bound/1 determ
class_Name/0->
compare/2->
convert/2->
digitsOf/1->
errorExit/1 erroneous
fail/0 failure
free/1 determ
hasDomain/2
isErroneous/1 determ
lowerBound/1->
maxDigits/1->
not/1 determ
在 相 应 内 部 数 据 库 的 末 尾 插 入 指 定 的 事 实
在 相 应 内 部 数 据 库 的 最 前 面 插 入 指 定 的 事 实
在 相 应 内 部 数 据 库 的 末 尾 插 入 指 定 的 事 实
测 试 指 定 变 量 是 否 已 经 绑 定
这 个 编 译 时 的 谓 词 返 回 代 表 当 前 接 口 或 类 的 名 称 的 串
返 回 变 量 比 较 的 结 果
有 核 查 的 项 转 换
返 回 指 定 实 数 域 的 精 度
以 指 定 的 返 回 代 码 ErrorNumber 完 成 一 次 运 行 时 错 误 , 并 设 置 内 部 错 误 消 息
引 发 回 溯
检 查 一 个 变 量 是 否 是 自 由 的
检 查 一 个 变 量 是 否 是 指 定 域 的
检 查 事 实 变 量 是 否 为 erroneous 的
返 回 指 定 数 字 域 的 下 界 值
获 取 相 应 实 数 域 的 精 度 值
子 目 标 结 果 (success/fail) 取 非
91

predicate_fullname/0->
predicate name/0->
retract/1 nondeterm
retractall/1
retractFactDb/1
sizeBitsOf/1->
sizeOf/1->
sizeOfDomain/1->
sourcefile lineno/0->
sourcefile_name/0->
sourcefile_timestamp/0->
succeed/0
toBinary/1->
toBoolean/1->
toString/1->
toTerm/1->
tryToTerm/1->
tryConvert/2-> determ
uncheckedConvert/2->
upperBound/1->
返 回 调 用 这 个 谓 词 的 谓 词 全 称
返 回 调 用 这 个 谓 词 的 谓 词 名
由 相 应 内 部 数 据 库 中 删 除 相 应 的 事 实
由 相 应 内 部 数 据 库 中 删 除 所 有 相 应 的 事 实
由 相 应 内 部 数 据 库 中 删 除 所 有 事 实
获 取 指 定 域 的 实 体 所 占 内 存 的 比 特 数
获 取 指 定 项 所 占 内 存 的 字 节 数
获 取 指 定 域 的 实 体 所 占 内 存 的 字 节 数
返 回 编 译 器 处 理 的 源 文 件 的 当 前 行 号
返 回 编 译 器 处 理 的 源 文 件 名
返 回 表 示 编 译 器 处 理 的 源 文 件 时 间 的 串
该 谓 词 总 是 成 功
将 指 定 的 项 转 换 成 二 进 制 表 示
这 个 元 谓 词 的 目 标 是 要 把 ( 对 一 个 谓 词 或 事 实 的 ) 确 定 性 的 调 用 转 换 成
procedure 的 , 返 回 boolean 域 的 值 。
将 指 定 的 项 转 换 成 串 表 示
将 指 定 的 串 / 二 进 制 表 示 项 转 换 为 相 应 域 的 返 回 值 变 量 的 Prolog 的 项
将 指 定 的 串 / 二 进 制 表 示 项 转 换 为 相 应 域 的 返 回 值 变 量 的 Prolog 的 项
核 查 输 入 项 能 否 被 严 格 地 转 换 为 指 定 域 的 项 , 返 回 转 换 后 的 项
没 有 核 查 的 域 转 换
返 回 指 定 数 字 域 的 上 界 值
下 面 的 谓 词 已 经 不 再 使 用 :
finally/2
findall/3
trap/3 determ
用 try ... finally ... end try 替 代
用 述 求 表 [ ... || ... ] 替 代
用 try ... catch V do ... end try 替 代
assert/1
assert : ( FactTerm).
assert(Fact) 把 指 定 的 事 实 Fact 插 入 到 相 应 的 内 部 事 实 数 据 库 的 最 后 面 。Fact 必 须 是 属 于 内 部 事 实
数 据 库 域 的 一 个 项 。(assert/1 applied to a single fact changes the existing instance of a fact to
the specified one.), 它 与 assertz/1 效 果 是 一 样 的 。 还 可 以 参 看 asserta/1。
注 意 ,retract/1 和 assert/1 两 者 的 如 下 组 合 会 导 致 死 循 环 :
loop() :-
retract(fct(X)),
... % 由 X 建 立 Y
assert(fct(Y)),
fail.
问 题 在 于 , 在 第 一 行 的 retract 将 最 后 删 除 插 入 到 最 后 一 行 的 事 实 , 因 为 在 事 实 链 中 它 是 最 后 插 入 的 。
异 常
插 入 一 个 声 明 为 determ 的 事 实 , 而 那 个 事 实 实 例 已 经 存 在 了 。
92

asserta/1
asserta : ( FactTerm).
插 入 一 个 事 实 到 相 应 内 部 数 据 库 的 最 前 面 。
描 述
asserta(Fact) 把 指 定 的 事 实 Fact 插 入 到 相 应 的 内 部 事 实 数 据 库 的 最 前 面 。Fact 必 须 是 属 于 内 部 事
实 数 据 库 域 的 一 个 项 。(asserta/1 applied to a single fact changes the existing instance of a fact
to the specified one.)。 可 以 参 看 assert/1 和 assertz/1。
异 常
插 入 一 个 声 明 为 determ 的 事 实 , 而 那 个 事 实 实 例 已 经 存 在 了 。
assertz/1
assertz : ( FactTerm).
assertz 与 assert/1 谓 词 完 全 一 样 。
bound/1
bound : ( Variable) determ.
测 试 指 定 的 变 量 是 否 已 经 绑 定 了 一 个 值 。
描 述
如 果 Variable 已 经 被 绑 定 ,bound(Variable) 成 功 , 反 之 则 失 败 。 谓 词 用 于 控 制 流 样 式 以 及 检 查 引
用 的 变 量 绑 定 情 况 , 如 果 Variable 的 任 意 一 部 分 已 经 实 例 化 了 , 都 将 视 为 已 经 绑 定
参 看 free/1。
class_Name/0->
class_Name : () -> string ClassName.
这 个 编 译 时 谓 词 返 回 一 个 串 , 这 个 串 是 当 前 接 口 或 类 的 名 称 。
compare/2->
compare : (A Left, A Right) -> compareResult CompareResult.
对 相 同 域 的 两 个 项 进 行 比 较 。 这 里 的 CompareResult 是 compareResult 域 的 结 果 变 量 。
例
CompareResult = compare("123","abc")
convert/2->
convert : ( Type, Term) -> Converted.
有 核 查 的 项 转 换 。
93

描 述
这 个 函 数 的 调 用 模 板 是 :
ReturnTerm = convert(returnDomain, InputTerm)
参 数 :
returnDomain: 指 定 要 将 InputTerm 转 换 到 该 域 , 它 必 须 是 内 建 的 Visual Prolog 域 或 接 口 域 的 名 称 ,
或 是 用 户 定 义 的 与 内 建 的 Visual Prolog 域 、 数 字 域 、 二 进 制 域 、 指 针 域 同 义 的 名 称 。 这 个 名 称 在 编 译 时 必 须 是
确 定 的 , 也 就 是 说 , 不 能 用 变 量 来 表 示 。
InputTerm: 指 定 要 转 换 的 值 , 它 可 以 是 任 意 Prolog 项 或 表 达 式 。 如 果 是 表 达 式 , 在 转 换 时 应 有 明
确 的 计 算 结 果 。
ReturnTerm: 返 回 参 数 ReturnTerm 是 returnDomain 类 型 的 。
备 注
谓 词 convert 把 InputTerm 彻 底 转 换 到 指 定 的 returnDomain 域 , 返 回 新 的 项 ReturnTerm。 如 果
它 不 能 完 成 要 求 的 转 换 , 就 会 产 生 一 个 错 误 。 还 有 一 个 功 能 上 相 似 的 谓 词 tryConvert/2->, 但 这 个 谓 词 如
果 完 成 不 了 指 定 的 转 换 就 只 是 失 败 , 不 会 产 生 任 何 运 行 时 错 误 。
允 许 的 转 换 :
• 数 字 域 间 ;
• 接 口 类 型 间 ;
• string 和 symbol 间 ;
• 从 binary 转 换 到 pointer;
• 上 述 各 项 的 同 义 域 间 ;
• reference 域 间 及 相 应 的 non-reference 域 间 。
与 谓 词 uncheckedConvert/2-> 对 比 一 下 ,uncheckedConvert/2-> 可 以 对 两 个 项 进 行 非 核 查 的 转
换 , 对 域 的 类 型 没 有 规 定 , 只 要 这 两 个 域 的 比 特 位 长 短 一 样 就 行 。
当 编 译 时 对 源 及 目 标 域 静 态 已 知 的 情 况 下 ,convert/2->( 或 tryConvert/2->) 谓 词 进 行 一 个 有 核
查 的 显 式 的 转 换 。 这 种 显 式 转 换 的 结 果 是 下 列 情 况 之 一 :
• ok- 成 功 转 换 到 目 标 域 ;
• run-time-check- 转 换 到 目 标 域 , 但 带 有 一 个 运 行 时 兼 容 性 的 核 查 ;
• error- 不 可 能 转 换 , 产 生 错 误 。
带 核 查 的 显 式 转 换 规 则 :
• 同 义 域 使 用 相 应 的 域 本 身 转 换 的 规 则 ;
• 数 字 域 只 能 转 换 为 数 字 域 ;
• 匿 名 整 数 域 [const .. const] 由 整 数 常 数 代 表 ;
• 匿 名 实 数 域 digits dig [const.. const] 由 实 数 常 数 代 表 , 这 里 的 是 尾 数 中 去 掉 无 意 义 的 零 后
的 数 字 位 数 ;
• symbol 域 和 string 域 的 值 可 以 相 互 转 换 ;
• binary 域 的 值 可 以 转 换 为 pointer 域 ;
• 对 接 口 隐 含 引 入 的 域 只 能 按 下 面 要 介 绍 的 规 则 转 换 到 该 接 口 域 ;
• 其 它 的 域 间 不 能 转 换 。
94

数 字 域 间 的 转 换 :
这 种 转 换 首 先 要 考 虑 数 值 的 范 围 , 如 果 源 的 范 围 与 目 标 的 不 重 合 , 就 会 产 生 错 误 ; 而 如 果 只 是 部 分 重
合 , 就 会 有 运 行 时 的 核 查 。 还 有 , 如 果 一 个 是 整 数 域 一 个 是 实 数 域 , 就 要 在 比 较 前 把 整 数 范 围 转 换 成 实 数
范 围 。
如 果 输 入 项 是 实 数 而 输 出 项 是 整 数 ,convert/2-> 及 tryConvert/2-> 谓 词 就 会 把 输 入 值 截 断 成 最 接
近 零 的 近 似 整 数 值 。
接 口 类 型 的 转 换
谓 词 convert/2-> 允 许 把 任 意 对 象 转 换 成 任 意 接 口 类 型 的 , 而 这 种 转 换 的 实 际 正 确 性 在 运 行 时 作 核
查 。 当 创 建 一 个 对 象 时 , 保 存 了 它 的 类 型 , 因 而 这 个 对 象 作 为 参 数 传 递 时 它 是 知 道 自 己 原 来 的 类 型 的 , 这
个 原 来 的 类 型 可 以 用 来 核 查 允 许 的 转 换 。 例 如 :
interface x
supports a, b
end interface x
如 果 对 象 是 由 实 现 接 口 x 的 类 创 建 的 , 而 后 对 象 又 以 类 型 a 的 参 数 传 递 给 某 个 谓 词 , 那 么 就 允 许 转 换 这
个 对 象 到 类 型 b。
异 常
• 核 查 范 围 出 错 ;
• 不 支 持 的 接 口 类 型 。
digitsOf/1->
digitsOf : ( Domain) -> unsigned.
返 回 实 数 域 表 示 的 精 度 。
描 述
这 个 函 数 的 调 用 模 板 是 :
Precision = digitsof(domainName)
这 个 编 译 时 谓 词 的 输 入 参 数 domainName 是 一 个 实 数 域 , 编 译 时 domainName 应 该 是 明 确 的 ( 也 就
是 说 它 不 能 来 自 变 量 )。 谓 词 返 回 的 Precision 数 值 由 该 域 声 明 中 的 digits 属 性 确 定 。
编 译 器 保 证 domainName 域 的 值 至 少 具 有 Precision 个 有 效 十 进 制 位 数 。
errorExit/1
errorExit : (unsigned ErrorNumber) erroneous.
以 指 定 的 返 回 代 码 ErrorNumber 完 成 一 次 运 行 时 错 误 , 错 误 代 码 可 以 用 在 try-catch-finally 中 。
fail/0
fail : () failure.
95

引 起 回 溯 。
描 述
fail 谓 词 强 迫 一 个 谓 词 失 败 , 因 而 总 是 引 起 回 溯 。 一 个 以 fail 结 尾 的 子 句 , 无 法 为 子 句 绑 定 输 出 参 数 。
free/1
free : ( Variable) determ.
检 查 一 个 变 量 是 否 为 自 由 的 。
描 述
这 个 谓 词 的 调 用 模 板 是 :
free(Variable)
如 果 指 定 的 变 量 Variable 是 自 由 的 ,free 这 个 谓 词 就 成 功 , 而 如 果 Variable 是 绑 定 的 , 则 失 败 。 如
果 Variable 的 任 意 部 分 实 例 化 了 ,free 谓 词 将 认 为 它 是 绑 定 的 。
参 看 bound/1。
hasDomain/2
hasDomain : ( Type, Variable) procedure.
检 查 变 量 VariableName 的 域 名 是 否 为 domainName。
描 述
这 个 谓 词 的 调 用 模 板 是 :
hasDomain(domainName, VariableName)
谓 词 声 明 VariableName 属 于 参 数 domainName 说 明 的 域 。domainName 参 数 应 当 是 一 个 标 准 的 或
用 户 定 义 的 域 的 名 称 , 这 个 域 名 在 编 译 时 应 该 是 确 定 的 ( 也 就 是 说 不 能 来 自 一 个 变 量 )。
lowerBound/1->
lowerBound : ( NumericDomain) -> LowerBound.
返 回 指 定 的 NumericDomain 域 的 下 限 值 LowerBound。
描 述
这 个 谓 词 的 调 用 模 板 是 :
LowerBoundValue = lowerBound(domainName)
这 是 一 个 编 译 时 谓 词 , 它 返 回 指 定 的 数 字 域 domainName 的 下 限 值 LowerBoundValue, 这 个 值 也
是 domainName 域 的 。 域 名 domainName 在 编 译 时 应 该 是 确 定 的 ( 也 就 是 说 不 能 来 自 一 个 变 量 )。
参 看 upperBound/1->。
96

异 常
如 果 指 定 的 domainName 域 不 是 数 字 域 , 编 译 时 会 出 错 。
isErroneous/1
isErroneous : ( FactVariable) determ.
如 果 指 定 的 事 实 变 量 是 erroneous 的 , 这 个 谓 词 就 成 功 。
描 述
这 个 谓 词 的 调 用 模 板 是 :
isErroneous(factVariableName)
如 果 指 定 的 事 实 变 量 factVariableName 具 有 erroneous 的 值 , 这 个 谓 词 就 会 成 功 , 否 则 就 失 败 。
maxDigits/1->
maxDigits : ( RealDomain) -> unsigned MaxDigits
获 取 相 应 于 domainName 指 定 的 实 数 域 的 精 度 值 。
描 述
这 个 谓 词 的 调 用 模 板 是 :
MaxDigitsNumber = maxdigits(domainName)
返 回 对 应 domainName 参 数 的 最 大 位 数 MaxDigitsNumber。domainName 应 该 是 real 域 名 。
not/1
not : ( SubGoal) determ.
如 果 SubGoal 失 败 则 该 谓 词 成 功 , 反 之 则 失 败
描 述
这 个 谓 词 的 调 用 模 板 是 :
not(SubGoal)
求 值 时 , 如 果 SubGoal 失 败 , 则 not 成 功 。 注 意 ,SubGoal 无 法 绑 定 任 何 变 量 , 因 为 只 有 当 SubGoal
失 败 not(SubGoal) 才 能 成 功 ( 而 失 败 的 目 标 无 法 绑 定 任 何 东 西 )。
predicate_fullname/0->
predicate_fullname : () -> string PredicateFullName.
这 个 谓 词 返 回 调 用 它 的 谓 词 全 称 PredicateFullName, 全 称 中 带 有 范 围 名 称 的 限 定 。
97

描 述
谓 词 predicate_fullname 只 能 用 在 一 个 谓 词 定 义 的 子 句 体 中 , 如 果 在 其 它 的 地 方 使 用 这 个 谓 词 , 会
在 编 译 时 出 错 。 参 看 predicate_name。
predicate_name/0->
predicate_name : () -> string PredicateName.
这 个 谓 词 返 回 调 用 它 的 谓 词 名 称 PredicateName。
描 述
谓 词 predicate_fullname 只 能 用 在 一 个 谓 词 定 义 的 子 句 体 中 , 如 果 在 其 它 的 地 方 使 用 这 个 谓 词 , 会
在 编 译 时 出 错 。 参 看 predicate_fullname。
retract/1
retract : ( FactTerm) nondeterm anyfow.
从 事 实 数 据 库 中 删 除 了 第 一 个 匹 配 的 事 实 时 成 功 , 如 果 没 有 匹 配 的 事 实 则 失 败 。
描 述
这 个 谓 词 的 调 用 模 板 是 :
retract(FactTemplate)
这 里 的 FactTemplate 应 该 是 一 个 事 实 项 。retract/1 谓 词 从 相 应 的 事 实 数 据 库 中 删 除 第 一 个 匹 配 的
FactTemplate; 通 过 回 溯 还 可 以 删 除 剩 余 的 匹 配 事 实 。
注 意 ,FactTemplate 可 以 是 实 例 的 任 意 层 级 , 它 是 与 事 实 数 据 库 中 的 事 实 匹 配 , 这 意 味 着 所 有 自 由
变 量 在 retract/1 调 用 时 都 会 被 绑 定 。
FactTemplate 可 以 有 任 意 个 匿 名 变 量 , 也 就 是 变 量 名 可 以 仅 是 一 个 下 划 线 或 以 一 个 下 划 线 开 头 的 变
量 名 , 只 要 是 这 个 变 量 在 子 句 中 只 出 现 一 次 。 例 如 :
retract(person("Hans", _Age)),
它 会 删 除 第 一 个 匹 配 的 事 实 , 这 个 事 实 的 第 一 个 参 数 是 “Hans” 而 第 二 个 参 数 可 以 是 任 意 的 。
当 删 除 的 事 实 声 明 是 determ 的 时 , 对 retract/1 的 调 用 将 是 确 定 性 的 。
参 看 retractall/1 和 retractFactDb。
提 示
retract/1 谓 词 不 能 应 用 于 single 事 实 或 事 实 变 量 。
如 果 在 工 程 当 前 范 围 中 声 明 了 single 事 实 , 以 自 由 的 FactTemplate 变 量 调 用 retract/1 时 要 特 别 小
心 。 要 是 对 single 事 实 做 retract, 会 产 生 运 行 时 错 误 。
在 没 有 匹 配 的 事 实 时 ,retract/1 谓 词 失 败 。
retractall/1
retractall : ( FactTerm) .
98

从 事 实 数 据 库 中 删 除 所 有 匹 配 的 事 实 。
描 述
这 个 谓 词 的 调 用 模 板 是 :
retractall(FactTemplate)
FactTemplate 应 是 一 个 事 实 项 。
retractall/1 删 除 所 有 与 给 定 的 FactTemplate 匹 配 的 事 实 ( 在 未 命 名 的 事 实 数 据 库 中 是 事 实 数 据 库
谓 词 for facts database predicates in unnamed facts databases)。 它 总 是 成 功 , 即 使 没 有 删 除 什 么
事 实 时 也 会 成 功 。
注 意 , 因 为 不 可 能 删 除 single 事 实 , 所 以 这 个 谓 词 不 会 删 除 在 未 命 名 事 实 数 据 库 中 匹 配 的 single 事 实
或 事 实 变 量 。 不 过 , 如 果 编 译 时 编 译 器 发 现 匹 配 的 事 实 只 有 一 些 single 事 实 , 就 会 产 生 编 译 时 的 错 误 。
由 retractall/1 不 可 能 得 到 任 何 输 出 值 , 因 此 , 调 用 时 所 有 变 量 必 须 都 是 绑 定 的 或 是 单 个 下 划 线 ( 匿
名 的 )。 注 意 ,FactTemplate 可 以 是 实 例 的 任 意 层 级 , 但 自 由 变 量 必 须 是 单 个 下 划 线 ( 无 条 件 匿 名 ),
与 retract/1 不 同 , 以 下 划 线 开 头 的 条 件 匿 名 变 量 ( 如 _AnyValue) 不 能 在 retractall/1 中 使 用 。
参 看 retract/1 和 retractFactDb/1。
retractFactDb/1
retractFactDb : (factDB FactDB).
从 命 名 的 内 部 事 实 数 据 库 FactDB 中 删 除 所 有 的 事 实 。
描 述
这 个 谓 词 的 调 用 模 板 是 :
retractFactDb(FactDB)
retractFactDb/1 从 命 名 的 内 部 事 实 数 据 库 FactDB 中 删 除 所 有 的 事 实 。 注 意 , 对 single 的 事 实 或
事 实 变 量 仍 会 原 样 保 留 下 来 。 参 看 retractall/1 和 retract/1。
retractall/2
废 弃 的 谓 词 ! 用 retractFactDb/1 替 代 。
sizeBitsOf/1->
sizeBitsOf : ( DomainName) -> unsigned BitSize.
获 取 指 定 域 DomainName 的 实 体 在 内 存 中 占 用 的 比 特 位 数 。
描 述
这 个 谓 词 的 调 用 模 板 是 :
BitSize = sizeBitsOf(DomainName)
这 个 编 译 时 谓 词 以 域 DomainName 为 输 入 参 数 , 返 回 该 域 的 实 体 占 用 内 存 的 大 小 , 结 果 以 比 特 位 计 。
99

对 整 数 域 sizeBitsOf/1-> 返 回 的 值 是 域 声 明 中 的 size 字 段 的 定 义 值 。 对 整 数 域 来 说 , 下 面 的 关 系 总
是 成 立 的 :
sizeOfDomain(domain)*8 - 7
sizeOf : ( Term) -> unsigned ByteSize.
获 取 指 定 项 Term 占 用 的 内 存 字 节 数 。
描 述
这 个 谓 词 的 调 用 模 板 是 :
ByteSize = sizeOf(Term)
sizeOf/1-> 函 数 以 一 个 项 为 输 入 参 数 , 返 回 Term 项 占 用 内 存 的 字 节 数 ByteSize, 这 个 值 是 无 符 号
整 数 值 。
sizeOfDomain/1->
sizeOfDomain : ( DomainName) -> unsigned ByteSize.
获 取 指 定 域 DomainName 的 实 体 在 内 存 中 占 用 的 字 节 数 。
描 述
这 个 谓 词 的 调 用 模 板 是 :
ByteSize = sizeOfDomain(DomainName)
这 个 编 译 时 谓 词 以 域 DomainName 为 输 入 参 数 , 返 回 该 域 的 实 体 占 用 内 存 的 大 小 , 结 果 以 字 节 计 ,
ByteSize 的 值 是 无 符 号 整 数 域 的 。 可 以 对 比 一 下 sizeBitsOf/1->, 在 它 那 里 以 比 特 计 算 大 小 。
sourcefile_lineno/0->
sourcefile_lineno : () -> unsigned LineNumber.
返 回 编 译 器 处 理 的 源 文 件 的 当 前 行 号 。
描 述
这 个 编 译 时 谓 词 返 回 编 译 器 正 在 处 理 的 源 文 件 的 当 前 行 号 。
sourcefile_name/0->
sourcefile_name : () -> string FileName.
返 回 编 译 器 处 理 的 源 文 件 名 。
100

描 述
这 个 编 译 时 谓 词 返 回 表 示 编 译 器 正 在 处 理 的 源 文 件 名 的 串 。
sourcefile_timestamp/0->
sourcefile_timestamp : () -> string TimeStamp..
返 回 表 示 编 译 器 处 理 的 源 文 件 日 期 时 间 的 串 。
描 述
这 个 编 译 时 谓 词 按 YYYY-MM-DD HH:MM:SS 格 式 返 回 表 示 编 译 器 正 在 处 理 的 源 文 件 日 期 时 间 的
串 , 格 式 中 :
YYYY – 年
MM – 月
DD – 日
HH – 小 时
MM – 分 钟
SS – 秒
succeed/0
succeed : ().
谓 词 succeed/0 总 是 成 功 。
描 述
标 准 谓 词 succeed/0 明 确 地 成 功 一 次 。
toBinary/1->
toBinary : (Term) -> binary Serialized.
将 项 Term 转 换 成 binary 表 示 。
描 述
这 个 谓 词 的 调 用 模 板 是 :
Serialized = toBinary(Term)
当 ( 某 个 域 domainName) 的 项 Term 转 换 成 二 进 制 项 时 , 可 以 安 全 地 存 储 在 文 件 中 或 是 在 网 络 上 传
给 另 一 个 程 序 。 以 后 这 个 二 进 制 项 值 Serialized 还 可 以 用 函 数 toTerm/1-> 转 换 回 Visual Prolog 项 ( 反
转 项 的 域 要 适 合 于 domainName)。
toBoolean/1->
toBoolean : ( SubGoal) -> boolean Succeed.
101

这 个 元 谓 词 的 目 标 是 要 把 ( 对 一 个 谓 词 或 事 实 的 ) 确 定 性 的 调 用 转 换 成 procedure 的 , 返 回 boolean
域 的 值 。
描 述
这 个 谓 词 的 调 用 模 板 是 :
True_or_False = toBoolean(deterministic_call)
元 谓 词 toBoolean/1-> 返 回 boolean 值 。 如 果 确 定 性 调 用 成 功 则 返 回 结 果 是 true, 如 果 确 定 性 调 用
失 败 返 回 结 果 是 false。
toString/1->
toString : (Term) -> string Serialized.
将 指 定 的 项 Term 转 换 为 串 表 示 。
描 述
这 个 谓 词 的 调 用 模 板 是 :
Serialized = toString(Term)
当 ( 某 个 域 的 )Term 项 转 换 成 一 个 串 时 , 它 可 以 安 全 地 保 存 在 文 件 中 或 是 经 网 络 传 送 给 另 外 的 程 序 。
以 后 串 值 还 可 以 用 函 数 toTerm/1-> 转 换 回 Visual Prolog 项 ( 反 转 项 的 域 要 适 合 于 domainName)。
toTerm/1->
toTerm : (string Serialized) -> Term.
toTerm : (binary Serialized) -> Term.
将 指 定 的 项 Serialized 的 串 / 二 进 制 表 示 转 换 为 相 应 域 的 返 回 值 变 量 的 Prolog 的 Term。
描 述
这 个 谓 词 的 调 用 模 板 是 :
Term = toTerm(Serialized)
在 编 译 时 , 编 译 器 可 以 确 定 返 回 值 Term 的 域 。 要 注 意 , 二 进 制 版 的 toTerm 谓 词 几 乎 是 逐 字 节 地 做
转 换 , 并 且 只 检 查 返 回 值 Term 的 域 所 要 求 的 与 Serialized 数 据 的 兼 容 性 。 保 证 提 供 的 Serialized 二 进 制
数 可 以 正 确 地 转 换 到 期 望 的 域 是 程 序 员 的 事 情 。
toTerm 谓 词 与 toBinary/1-> 和 toString/1-> 谓 词 是 配 套 的 , 当 ( 某 个 域 的 )Term 项 由 toBinary/1->
或 toString/1-> 转 换 成 一 个 二 进 制 或 串 的 Serialized 时 , 它 可 以 安 全 地 保 存 在 文 件 中 或 是 经 网 络 传 送 给 另
外 的 程 序 。 以 后 用 对 应 的 函 数 toTerm/1-> 还 可 以 把 这 个 串 / 二 进 制 值 Serialized 转 换 回 Visual Prolog
的 项 Term。 为 正 确 地 反 转 项 , 子 句 变 量 Term 的 域 要 适 合 于 原 来 的 域 domainName。
参 看 tryToTerm。
异 常
如 果 编 译 时 编 译 器 不 能 确 定 返 回 值 的 域 , 则 出 现 编 译 时 错 误 。
102

当 toTerm/1-> 谓 词 不 能 转 换 串 或 二 进 制 项 为 指 定 域 的 项 时 , 会 产 生 运 行 时 错 误 。
tryToTerm/1->
tryToTerm : (string Serialized)-> Term determ.
tryToTerm : (binary Serialized)-> Term determ.
如 同 toTerm 一 样 , 转 换 相 应 的 串 或 二 进 制 表 示 的 Serialized 为 项 Term, 它 们 之 间 的 差 别 是 : 谓 词
tryToTerm 如 果 不 能 把 相 应 的 串 或 二 进 制 项 转 换 为 指 定 域 的 项 时 就 失 败 , 而 toTerm 谓 词 则 会 产 生 异 常 。
参 看 toTerm。
tryConvert/2->
tryConvert : ( Type, Value) determ -> Converted determ.
核 查 输 入 项 Value 能 否 被 严 格 地 转 换 为 指 定 域 Type 的 项 , 返 回 转 换 后 的 项 Converted。
描 述
这 个 谓 词 的 调 用 模 板 是 :
ReturnTerm = tryConvert(returnDomain, InputTerm)
参 数 :
returnDomain: 规 定 tryConvert/2-> 谓 词 尝 试 将 指 定 项 InputTerm 转 换 到 该 域 , 它 可 以 是 当 前
范 围 可 访 问 的 任 何 域 。 域 名 returnDomain 在 编 译 时 必 须 是 确 定 的 , 即 不 能 来 自 于 变 量 。
InputTerm: 要 转 换 的 项 , 它 可 以 是 任 意 Prolog 项 或 表 达 式 , 如 果 是 表 达 式 , 转 换 前 要 求 值 。
ReturnTerm: 返 回 的 项 , 它 是 returnDomai 域 的 。
备 注
转 换 规 则 tryConvert/2-> 与 内 含 谓 词 convert/2-> 是 一 样 的 , 但 convert/2-> 产 生 转 换 错 误 时 , 同
样 条 件 下 的 tryConvert/2-> 会 是 失 败 。
如 果 相 应 的 转 换 成 功 则 这 个 谓 词 成 功 , 反 之 它 就 失 败 。 该 谓 词 尝 试 把 InputTerm 彻 底 转 换 到 指 定 的
returnDomain 域 , 若 它 不 能 完 成 要 求 的 转 换 , 就 会 失 败 。 当 tryConvert/2-> 谓 词 成 功 时 , 它 会 返 回 转
换 到 指 定 域 returnDomain 的 项 ReturnTerm。
允 许 的 转 换 及 规 则 请 参 看 带 核 查 的 显 式 转 换 谓 词 convert/2->。 还 可 参 看 uncheckedConvert/2->。
uncheckedConvert/2->
uncheckedConvert : ( Type, Value) -> Converted.
将 值 转 换 为 另 一 个 类 型 , 不 带 核 查 。
描 述
这 个 谓 词 的 调 用 模 板 是 :
ReturnTerm = uncheckedConvert(returnDomain, InputTerm)
参 数 :
103

eturnDomain: 指 定 uncheckedConvert 要 将 InputTerm 非 安 全 性 地 转 换 到 该 域 , 它 可 以 是 当 前 范
围 能 够 访 问 的 任 何 域 。ReturnTerm 和 InputTerm 的 比 特 位 的 长 短 应 该 是 一 样 的 。 域 名 称 returnDomain
在 编 译 时 必 须 是 确 定 的 , 也 就 是 说 , 不 能 用 变 量 来 表 示 。
InputTerm: 指 定 要 转 换 的 值 , 它 可 以 是 任 意 Prolog 项 或 表 达 式 。 如 果 是 表 达 式 , 在 转 换 前 先 要 求
值 。
ReturnTerm: 返 回 参 数 ReturnTerm 是 returnDomain 类 型 的 。
备 注
uncheckedConvert 谓 词 进 行 一 个 很 武 断 的 转 换 。 它 对 InputTerm 进 行 预 求 值 ( 如 果 它 是 一 个 表
达 式 的 话 ), 将 其 当 前 的 类 型 转 换 到 returnDomain 的 类 型 并 与 ReturnTerm 合 一 。 它 在 运 行 时 不 做 核 查 ,
所 以 差 不 多 任 何 项 都 可 以 很 莽 撞 地 转 换 为 别 的 类 型 。 因 而 , 不 正 确 地 使 用 它 可 能 会 导 致 很 糟 糕 的 结 果 , 一
定 要 小 心 ! 强 烈 建 议 , 只 要 可 能 就 避 免 使 用 它 而 代 之 以 convert/2-> 和 tryConvert/2->。 不 过 , 当 对 象 是
由 COM 系 统 返 回 的 时 候 , 需 要 用 uncheckedConvert 来 进 行 转 换 , 因 为 Prolog 程 序 没 有 关 于 它 的 实 际 类
型 的 信 息 。
upperBound/1->
upperBound : ( NumericDomain) -> UpperBound.
返 回 指 定 数 字 域 的 上 限 值 。
描 述
这 个 谓 词 的 调 用 模 板 是 :
UpperBound = upperBound(domainName)
upperBound 是 一 个 编 译 时 谓 词 , 它 返 回 指 定 数 字 域 domainName 的 上 限 值 。upperBound 谓 词 返
回 的 值 UpperBound 也 是 domainName 域 的 。domainName 参 数 必 须 是 任 意 数 字 域 的 名 称 , 编 译 时 必 须
是 确 定 的 ( 即 不 能 来 自 于 变 量 )。
参 看 lowerBound/1->。
异 常
如 果 指 定 的 域 不 是 数 字 域 , 则 会 出 现 编 译 时 错 误 。
编 译 指 令
编 译 器 的 每 个 指 令 都 是 以 字 符 # 开 头 的 , 所 支 持 的 指 令 如 下 :
• #include, #bininclude – 文 件 包 含 ;
• #if, #then, #else, #elseif, #endif – 条 件 语 句 ;
• #export, #externally – 输 出 及 引 入 类 ;
• #message, #error, #requires, #orrequires – 编 译 时 间 信 息 ;
• #options – 编 译 器 选 项 。
源 文 件 的 包 含
104

编 译 指 令 #include 用 于 将 其 它 文 件 的 内 容 在 编 译 时 包 含 进 用 户 开 发 的 程 序 代 码 中 。 其 语 法 如 下 :
Pp_dir_include :
#include String_literal
文 字 串 (string literal) 应 该 指 向 一 个 已 有 文 件 名 。 文 件 名 可 以 包 含 路 径 名 , 但 要 记 住 : 用 于 子 目 录
的 反 斜 杠 字 符 \ 是 一 个 换 码 序 列 符 , 因 此 在 要 使 用 它 的 地 方 要 写 两 次 :
#include "pfc\\exception\\exception.ph"
% 包 含 pfc\exception\exception.ph 文 件
或 者 用 @ 字 符 在 文 件 名 前 作 前 缀 , 像 这 样 :
#include @"pfc\vpi\vpimessage\vpimessage.ph"
pfc\vpi\vpimessage\vpimessage.ph 文 件
% 包 含
从 语 义 上 来 讲 , 这 个 指 令 使 用 “ 仅 包 含 第 一 次 出 现 的 文 件 ” 策 略 , 也 就 是 说 , 如 果 一 个 编 译 单 元 中 对
同 一 个 文 件 有 多 个 包 括 指 令 , 则 只 采 用 第 一 个 出 现 的 包 括 指 令 。
各 包 含 文 件 必 须 含 有 分 开 的 已 经 完 成 的 范 围 。 包 含 文 件 不 能 含 有 未 完 成 的 范 围 , 也 就 是 说 , 它 含 有 的
是 分 开 的 已 经 完 成 的 接 口 声 明 、 类 声 明 、 类 实 现 或 / 和 分 开 的 编 译 指 令 。
编 译 器 按 下 述 方 法 来 查 找 指 定 包 括 的 源 文 件 :
1. 如 果 文 件 名 中 包 括 了 绝 对 路 径 , 就 直 接 包 括 该 文 件 ;
2. 否 则 , 编 译 器 就 按 命 令 行 选 项 /Include 定 义 的 路 径 搜 索 指 定 的 包 含 文 件 名 , 有 多 个 路 径 时 按 顺
序 使 用 。 可 以 在 VDE 中 Project Settings 的 Directories 标 签 里 的 Include Directories 中 设
置 这 些 路 径 。
如 果 编 译 器 找 不 到 指 定 文 件 , 就 会 出 现 编 译 时 错 误 。
二 进 制 文 件 的 包 含
编 译 指 定 #bininclude 用 于 ( 将 由 string literal 串 指 定 的 ) 文 件 内 容 作 为 ::binary 类 型 的 常 数 包 含 进
用 户 开 发 的 程 序 源 代 码 中 。 其 语 法 如 下 :
Pp_dir_bininclude :
#bininclude ( String_literal )
#bininclude 编 译 指 令 告 诉 编 译 器 把 指 定 文 件 的 内 容 当 作 一 个 ::binary 常 数 的 值 插 入 。 这 个 指 令 可 以
用 在 任 何 ::binary 常 数 可 以 使 用 的 地 方 。
典 型 的 使 用 方 法 如 下 :
constants
myBin : ::binary = #bininclude ("Bin.bin"). % 由 “Bin.bin” 文 件 创 建 一 个 二 进 制 常 数 值
myBin2 = #bininclude ("Bin2.bin"). % 初 始 化 一 个 二 进 制 常 数 的 简 式
在 上 面 这 个 例 子 中 , 分 析 第 一 个 常 数 myBin 的 声 明 时 , 编 译 器 碰 到 了 #bininclude ("Bin.bin") 指
令 。 于 是 它 在 包 含 #bininclude ("Bin.bin") 这 个 指 令 的 源 文 件 所 在 的 目 录 中 、 在 Project Settings 对
话 框 的 Include Directories 表 框 中 指 定 的 目 录 中 ( 在 /Include 命 令 行 选 项 指 定 的 目 录 中 ) 查 找 是 否 有
这 个 Bin.bin 文 件 。 如 果 找 到 了 , 编 译 器 就 读 这 个 文 件 , 按 该 文 件 的 内 容 形 成 正 确 的 ::binary 域 的 数 据 并
将 其 作 为 myBin 常 数 的 值 。 比 如 说 ,Bin.bin 文 件 中 只 有 一 个 字 符 A,myBin 常 数 就 会 有 下 面 这 样 的 值 :
105

myBin = $[0x41]
% 这 里 的 0x41 是 'A' 的 十 六 进 制 ASCII 码 值
string literal 应 该 指 向 一 个 已 有 文 件 名 。 这 个 指 令 的 语 法 与 前 面 “ 源 文 件 的 包 含 ” 中 的 #include 指
令 是 一 样 的 , 搜 索 指 定 文 件 的 方 法 也 一 样 。
输 出 和 引 入 类
编 译 指 令 #export 和 #externally 分 别 用 于 确 定 要 输 出 的 类 及 要 引 入 的 类 。 其 语 法 如 下 :
Pp_dir_export :
#export ClassNames-comma-sep-list
Pp_dir_export :
#externally ClassNames-comma-sep-list
这 两 个 编 译 指 令 只 能 用 于 不 构 造 对 象 的 类 classNames。 而 且 , 它 们 也 只 能 用 于 外 部 范 围 , 这 就 是 说 ,
它 们 不 能 用 在 接 口 和 类 的 声 明 里 , 也 不 能 用 在 类 的 实 现 里 。
缺 省 时 , 在 一 个 执 行 单 元 内 部 的 谓 词 对 其 它 执 行 单 元 来 说 是 完 全 隐 藏 的 。 而 编 译 指 令 #export 使 它 所
指 定 的 那 些 类 名 对 外 部 开 放 了 , 因 而 运 行 时 这 些 类 中 声 明 的 模 块 里 的 所 有 谓 词 对 其 它 执 行 单 元 就 是 可 访 问
的 。
一 般 情 况 下 ,#export 编 译 指 令 用 在 目 标 模 块 是 DLL 的 工 程 中 , 它 列 出 一 个 DLL 中 所 声 明 的 类 , 这 些
列 出 的 类 就 可 以 被 使 用 这 个 DLL 的 其 它 模 块 所 访 问 。
如 果 某 个 编 译 单 元 输 出 一 个 类 , 该 编 译 单 元 就 应 该 含 有 这 个 类 的 实 现 。( 译 注 : 原 文 为 “If a compilation
unit export some class, then this compilation unit should not contain this class implementation.”
not 应 该 是 错 误 的 )
#export 编 译 指 令 还 可 以 用 在 #if 编 译 指 令 中 规 定 condition 表 达 式 。 例 如 , 假 设 在 一 个 编 译 单 元 开 始
的 地 方 编 译 器 碰 到 了 这 样 的 #export 编 译 指 令 :
#export className
而 在 后 面 编 译 器 又 遇 到 一 个 #if 编 译 指 令 , 它 以 #export 编 译 指 令 为 条 件 表 达 式 , 比 如 说 是 这 样 的 :
#if #export className #then ... #endif
那 么 , 编 译 器 就 会 对 #export 条 件 表 达 式 求 值 , 在 我 们 这 里 其 结 果 是 true, 接 着 就 会 执 行 条 件 编 译
指 令 的 #then 分 支 。
比 如 , 下 面 这 个 例 子 中 , 就 能 保 证 把 some.pack 包 包 含 到 所 编 译 的 单 元 中 :
#export className
...
#if #export className #then #requires "some.pack" #endif
而 另 一 方 面 , 如 果 没 有 前 一 个 #export 编 译 指 令 , 编 译 器 对 #export 条 件 表 达 式 的 求 值 就 会 是 false,
也 就 不 会 执 行 #if 的 分 支 #then, 比 如 例 子 是 这 样 :
#if #export className #then #requires "some.pack" #endif
这 时 , 就 不 会 请 求 包 含 some.pack 包 。
#externally 编 译 指 令 是 与 #export 编 译 指 令 配 对 的 , 它 可 以 替 代 ( 也 可 以 同 时 使 用 )IMPORTS
106

指 令 用 于 定 义 文 件 中 。 这 个 指 令 列 出 一 些 类 , 它 们 是 在 一 个 模 块 中 声 明 的 但 却 是 在 其 它 模 块 中 实 现 的 。 这
样 , 当 编 译 器 遇 到 这 样 的 类 时 就 不 会 发 生 错 误 。 引 述 的 类 可 以 是 在 DLL 中 实 现 ( 并 输 出 ) 的 , 运 行 时 可 以
将 这 些 DLL 链 接 到 这 个 模 块 上 来 。
#export 和 #externally 编 译 指 令 可 以 在 Conditional Directives 中 用 作 条 件 布 尔 表 达 式 。 例 如 :
#if #export className #then #include "Some package.pack" #endif
编 译 时 消 息
在 编 译 工 程 模 块 时 , 可 以 用 编 译 指 令 #message、#requires、#orrequires 和 #error 来 发 布 用
户 定 义 的 消 息 到 一 个 列 表 文 件 中 或 中 断 编 译 过 程 。
这 些 指 令 既 可 以 用 在 范 围 ( 接 口 声 明 、 类 声 明 或 类 实 现 ) 之 外 , 也 可 以 用 在 范 围 内 但 在 段 之 外 。 其 语
法 如 下 :
Pp_dir_message :
#message String_literal
Pp_dir_error :
#error String_literal
Pp_dir_requires :
#requires String_literal Pp_dir_orrequires-list-opt
Pp_dir_orrequires :
#orrequires String_literal
当 编 译 器 遇 到 上 列 任 何 一 个 指 令 时 , 都 会 产 生 相 应 的 警 告 信 息 并 把 指 令 的 文 本 内 容 写 到 一 个 列 表 文 件
中 去 。
编 译 指 令 中 可 以 指 定 一 个 列 表 文 件 名 :
/listingfile:"FileName"
注 意 , 在 冒 号 前 后 都 不 要 有 空 格 。
缺 省 时 , 编 译 器 不 会 为 #message、#requires 和 #orrequires 指 令 产 生 消 息 , 程 序 员 可 以 用 编 译
器 选 项 打 开 这 些 消 息 :
/listing:message
/listing:requires
/listing:ALL
在 这 种 情 况 下 , 当 编 译 器 遇 到 这 些 指 令 , 比 如 :
#message "Some message"
就 会 把 下 面 的 文 本 写 到 列 表 文 件 中 去 :
C:\Tests\test\test.pro(14,10) : information c062: #message "Some message"
#requires (#orrequires) 指 令 会 把 用 户 定 义 的 关 于 需 要 源 ( 目 标 ) 文 件 的 消 息 放 到 列 表 文 件 中 去 。
#orrequires 指 令 不 能 单 独 使 用 , 紧 靠 它 之 前 ( 用 空 格 或 注 释 隔 开 ) 应 有 #requires 指 令 。
107

#error 指 令 总 是 终 止 编 译 并 发 布 用 户 定 义 的 错 误 消 息 到 列 表 文 件 中 , 如 :
C:\Tests\test\test.pro(14,10) : error c080: #error "Compilation is interrupted"
可 以 对 这 些 消 息 进 行 分 析 并 接 受 所 要 求 的 事 情 。 例 如 ,VDE 会 对 #requires 和 #orrequires 指 令 给
出 的 消 息 进 行 分 析 , 自 动 地 添 加 所 有 需 要 的 PFC 包 及 标 准 库 到 被 编 译 的 工 程 ( 参 看 Handling Project
Modules 主 题 )。
#requires 和 #orrequires 指 令 的 例 子 :
#requires @"\Common\Sources\CommonTypes.pack"
#orrequires @"\Common\Lib\CommonTypes.lib"
#orrequires @"\Common\Obj\Foreign.obj"
#if someClass::debugLevel > 0 #then
#requires @"\Sources\Debug\Tools.pack"
#orrequires @"\Lib\Debug\Tools.lib"
#else
#requires @"\Sources\Release\Tools.pack"
#orrequires @"\Lib\Release\Tools.lib"
#endif
#orrequires "SomeLibrary.lib"
#requires "SomePackage.pack"
#if someClass::debugLevel > 0 #then
#orrequires @"\Debug\SomePackage.lib"
#else
#orrequires @"\Release\SomePackage.lib"
#endif
#message 指 令 的 例 子 :
#message "Some text"
#if someClass::someConstant > 0 #then
#message "someClass::someConstant > 0"
#else
#message "someClass::someConstant

编 译 指 令 #options 影 响 整 个 编 译 单 元 。 这 个 指 令 只 能 用 在 外 部 范 围 及 源 文 件 的
条 件 编 译 语 句 中 ( 编 译 单 元 通 过 这 个 源 文 件 传 递 给 编 译 器 ), 否 则 就 会 出 现 编 译 时 的 警 告 消 息 并 忽 略 这 个
指 令 。
只 能 包 含 下 面 的 编 译 选 项 :
"/Warning"
"/Check"
"/NOCheck"
"/Optimize"
"/DEBug"
"/GOAL"
"/MAXErrors"
"/MAXWarnings"
对 其 它 的 输 入 编 译 器 会 产 生 非 法 选 项 的 错 误 消 息 。 如 果 有 若 干 个 #options 指 令 , 则 会 按 文 本 顺 序 处
理 它 们 。
条 件 编 译
条 件 编 程 结 构 是 Visual Prolog 的 部 件 。 编 译 单 元 和 程 序 段 ( 包 括 空 的 ) 可 以 条 件 化 。 其 语 法 如 下 :
ConditionalItem :
#if Condition #then CompilationItem-list-opt ElseIfItem-list-opt
ElseItem-opt #endif
ElseIfItem :
#elseif Condition #then CompilationItem
ElseItem :
#else CompilationItem
这 里 的 Condition 可 以 是 任 意 表 达 式 , 它 在 编 译 时 应 能 得 到 失 败 或 成 功 的 求 值 结 果 。
各 个 条 件 编 译 语 句 必 须 在 一 个 文 件 中 , 也 就 是 说 , 嵌 套 的 相 同 层 次 的 编 译 指 令 #if、#then、#elseif
和 #else( 如 果 有 的 话 ) 及 #endif 必 须 在 一 个 文 件 中 。
编 译 时 , 编 译 器 会 对 条 件 求 值 , 以 便 确 定 哪 些 部 分 要 包 括 在 最 终 文 件 中 。 排 除 在 最 终 程 序 外 的 那 些 部
分 称 为 死 分 支 。
所 有 条 件 编 译 分 支 项 都 要 进 行 语 法 检 查 , 语 法 上 必 须 正 确 。 即 便 是 对 死 分 支 , 语 法 上 也 要 正 确 。 但 编
译 器 只 对 所 需 要 的 条 件 做 求 值 运 算 , 不 会 对 死 分 支 上 的 条 件 求 值 。
在 条 件 句 中 出 现 的 条 件 文 本 , 不 应 该 依 赖 于 任 何 代 码 。
乙 丁 译
its2u@qq.com
109