术语

文件的样子

* Two resistors
* @RNL(type="header") { @VERSION("0.3")}
R1 a b 1k
R2 b 0 1k
* @RNL {
*   {#R1 #R2} @ALIGN("x");
*   &b @WIRE {#R1:2 #R2:1}
* }
.end

// Two resistors in Spectre
// @RNL(type="header") { @VERSION("0.3")}
simulator lang=spectre
R1 (a b) resistor r=1k
R2 (b 0) resistor r=1k
// @RNL {
//   {#R1 #R2} @ALIGN("x");
//   &b @WIRE {#R1:2 #R2:1}
// }

• 记录写在整行注释里：第 1 列的 * 加一个空格（Spectre 里也可以是 //）。记录的每一行都得是这样的行；空一行就写一个单独的 *。行尾注释从来不读（2.2）。
• 第 1 行是标题，从来不读。头段记录排在最前，写在文件层，最早在第 2 行。里面写 @VERSION("0.3")，需要时再写 DEVICE、ALIAS、USE-ALIASES 和 USE-PACKAGE（2.8）。文件按它声明的版本读（16.1）。
• 写在 .subckt … .ends 之间的记录属于那个子电路；写在外面的属于顶层。引用只在自己的层里找。.end 后面的文字不读。
• 记录头字段都写名字：type（默认 "authored"，还有 "generated"、"header"），scope（从顶层写进的子电路），priority，author。

名字和引用

• 默认的端子名（6.12）：M 是 d g s b；Q 是 c b e s；J、Z 是 d g s；D 是 a k；R、C、L、V、I、B、F、H、W 是 p n；E、G、S 是 p n cp cn；T、O 是 p1 n1 p2 n2；U 是 a b ref。X 元件的端子是它的子电路的端口。网表里没有定义的子电路（PDK 器件）没有端子名：在头段记录里用 DEVICE 起名，或者写序号。
• 网表里的名字照宿主的大小写规则；RNL 自己的名字和关键字分大小写。
• 数字不带单位（2u 是错误）；枚举值是字符串，如 "left-to-right"；真假是 true、false；数组写成 […]。没有表达式。
• %#3 是没有名字的对象的编号；只出现在求解器的记录里（5.9）。

语句

• 一条语句是：对象，至多一个关键字和它的参数，以及它用的定义：#M1 @SET-SYMBOL $NMOS。ATTACH 先写定义：$GROUND @ATTACH &vss。
• 按位置的参数在前，写名字的在后：@PLACE(10, 20, priority="high")。参数的括号紧贴关键字：@PLACE (10, 20) 是 PLACE 加一个点。角色的括号紧贴对象：#M1(in_p)。
• => 把一段的结果交给下一段：$GROUND @ATTACH &vss => @PLACE(20, -4)。
• %x = statement 给结果起名；管道里 … => %x 给它左边那一段起名。一个名字在一层里只绑定一次，可以写在它的语句前面使用。
• 收集合的槽位把零散的对象当一个集合：#M1 #M2 @ALIGN("y")。收单个对象的槽位收到集合时，对每个成员各做一次：{#D1 #D2} @ORIENT("MX")。两个槽位要正好两个对象：{#M1 #M2} @SET-SYMBOL $NMOS。
• {…} 里的集合展开一层；{{%a_set} #M3} 让 %a_set 作为一个成员，按中心算。
• 记号之间的自由文本不表示任何意思，所以语句可以读起来像句子：#M1 is at @PLACE(10, 20)。没带前缀的名字也是自由文本：#M1 #M2 M3 @ALIGN("y") 只对齐 M1 和 M2。说明写在 /* */ 里。
• 事实可以叠加；语句的先后只在冲突或互相覆盖时才有关系。

定义、角色和集合

* An input pair with its tail and a mirror load
* @RNL(type="header") { @VERSION("0.3")}
.model nch nmos level=1
.model pch pmos level=1
M1 x inp tail 0 nch
M2 out inn tail 0 nch
M3 x x vdd vdd pch
M4 out x vdd vdd pch
M5 tail vb 0 0 nch
* @RNL {
*   %dp1 = #M1(in_p) #M2(in_n) #M5(tail) @AS $DIFFERENTIAL_PAIR;
*   %cm1 = #M3(ref) #M4(out) @AS $CURRENT_MIRROR;
*   {#M1 #M2 #M5} @AS $MATCHED;
*   $SIDE = @DEFINE(roles=["a", "b"], parameters=[["gap", 4]]) {
*     {?a ?b} @ALIGN("y");
*     ?a ?b @DISTANCE("left-to-right", min=?gap)
*   };
*   #M3(a) #M4(b) @AS(gap=6) $SIDE
* }
.end

• 角色：每一项是一个名字，或 [name, kind]（"instance"、"terminal"、"net"、"point"、"usage"）。"{name}" 是集合角色：收一个集合，可以不填。参数是名字或 [name, default]，写在 AS 或 ATTACH 的括号里（9.4）。
• 套用：对象按角色表的次序写，或全都标上角色。集合角色收一个集合：{#M1 #M2 #M5} @AS $MATCHED。单个角色收到集合时，对每个成员各套用一次。
• 体：?name 指角色和参数；体里起了名的对象，如 %mid = (_, _)，是每个用例的局部对象，从外面写 %u::mid。体里不能写网表对象。
• 用例是一个对象：不管它体里的事实怎样，它都记着这些对象是什么（9.5）。
• 选择给出集合：# @SELECT-INSTANCE(type="pmos")、&en @SELECT-TERMINAL(terminal="g")、# @SELECT-NET(port=true)、# @SELECT-USAGE $DIFFERENTIAL_PAIR、#M1 @SELECT-ANCESTOR-USAGE $CURRENT_MIRROR。条件都写名字；name、model、net、key 可以带 *。model 是 .model 名，X 元件则是子电路名；type 是 .model 的类型；X 元件没有类型（10.1）。

布局的事实

• 成员可以是元件（按原点）、端子（按引脚）、点、文字和画出的用例；作为一个成员的集合按中心算。网络和导线不能做成员。
• 没有"最左边"：相对别的元件写，如 {#M6 #M7} %pout @DISTANCE("left-to-right", min=2)。
• RNL 没定下的，由求解器决定；RNL 只说必须成立的。

优先级

* Priorities
* @RNL(type="header") { @VERSION("0.3")}
.model nch nmos level=1
M1 x inp tail 0 nch
M2 out inn tail 0 nch
M5 tail vb 0 0 nch
* @RNL(priority="high") {
*   %dp1 = #M1(in_p) #M2(in_n) #M5(tail) @AS $DIFFERENTIAL_PAIR;
*   {#M1 #M2} @ALIGN("y");
*   #M5 @PLACE(x=3, priority="low")
* }
* @RNL { %dp1 @PRIORITY("disabled")}
.end

• PLACE、ORIENT、ORIENT-RELATION、四种约束、AS 和 ATTACH 收 priority=："disabled"、"low"、"normal"（默认）、"high"。冲突时先丢低的，一样低时丢先写的；留下的事实不论优先级都是硬的（14.8）。
• 用例的优先级管它体里的全部事实：@AS(priority="high") 把它们都抬高；PRIORITY 事后改它，如 %dp1 @PRIORITY("disabled") 关掉这个差分对的默认画法。
• 记录头的 priority 给没写优先级的语句作默认值，只是 AS、ATTACH 从记录头只取 "disabled"：上例里差分对体里的 low 约束照旧是 low。
• 标准包把默认画法写成 "low"，所以你写的总会胜出。

导线和 ROUTE

* Wires
* @RNL(type="header") { @VERSION("0.3")}
R1 a b 1k
R2 b 0 1k
R3 b c 1k
* @RNL {
*   %j = (0, 0);
*   &b @WIRE {#R1:2 %j #R2:1};
*   &b @WIRE {%j #R3:1};
*   $JUNCTION @ATTACH %j;
*   &a @ROUTE
* }
.end

• WIRE 在网络上画一条导线，经过至少两个点或端子；mode= 是 "auto"（默认）、"straight"、"horizontal-vertical"、"vertical-horizontal"、"manhattan" 或 "manhattan45"（13.1）。
• 导线只在共用同一个点对象或端子时才连上；坐标相同不算。要画 T 形，直通的导线经过一个起了名的点，分支从这个点出发；连接点写成 $JUNCTION @ATTACH %j。
• ROUTE 把整个网络画成导线，一棵经过它上面每个引脚和虚拟元件的树（13.7）。
• 网络槽位里放几个网络就是总线：&D<1:0> @WIRE {%a %b}。
• 不写 WIRE 或 ROUTE，连接就不画成导线。

文字和标签

* Labels
* @RNL(type="header") { @VERSION("0.3")}
.model nch nmos level=1
M1 x inp 0 0 nch W=2u L=0.5u
* @RNL {
*   #M1 @TEXT("${w}/${l}", key="wl", dy=-3);
*   #M1 @TEXT("Min", key="name");
*   (10, 10) @TEXT("bias", size=0.8)
* }
.end

• 附着在对象上的 TEXT 是标签，跟着对象走；附着在点上的是标注。key= 给它起名，#M1::wl；引用名相同的文字替换先写的，如 key="name" 替换符号显示的名字（13.3）。
• ${…} 显示属性：元件的 name、value、model、type 和网表参数（如 ${w}）；端子或导线的 net；用例的角色；路径如 ${pair::in_p::w}（13.6）。
• 标记：_{…}、^{…}、\overline{…}、\frac{…}{…}、\mu、\Omega。还有 dx、dy、halign、valign、rotate 和样式参数。

符号和样式

* A symbol of its own
* @RNL(type="header") { @VERSION("0.3")}
X1 in out buf
.subckt buf in out
R1 in out 1k
.ends
* @RNL {
*   $TRI = @DEFINE-SYMBOL {
*     (-4, 0) @PIN(terminal="in", direction="left");
*     (4, 0) @PIN(terminal="out", direction="right");
*     @LINE {(-2, 2) (2, 0) (-2, -2) (-2, 2)};
*     @LINE {(-4, 0) (-2, 0)};
*     @LINE {(2, 0) (4, 0)};
*     ? @TEXT("${name}", key="name") => @PLACE(-2, 2.5)
*   };
*   #X1 @SET-SYMBOL $TRI;
*   $orange = @DEFINE-STYLE(linecolor="#e07000", textcolor="#e07000") {};
*   #X1 @SET-STYLE $orange
* }
.end

• 符号体用以对象原点为原点的局部坐标。@PIN(terminal=…, direction=…) 放一个端子的引脚；没有引脚的端子不画，连到它的导线失效（9.2.4）。? @TEXT(…) 是用这个符号画出的对象的标签。
• 直接给对象的符号胜过规则给的；同一类里后写的胜，标准包的规则排在最前。规则一次给很多对象符号：# @SELECT-INSTANCE(model="nch") => @SET-SYMBOL $NMOS。
• 样式按属性合并：linecolor、linestyle、linewidth、fillcolor、textcolor、size、font、bold、italic 等（9.3）。颜色写成 "#RRGGBB"。虚拟元件是独立的对象；用规则给它们样式，如 # @SELECT-USAGE $GROUND => @SET-STYLE $grey。
• 子电路里写 # @SET-SYMBOL %blk 给它块符号，上层的元件就用它画（9.2.6）。

标准包

代称和 rnl-zh

* The same pair in Chinese
* @RNL(type="header") { @VERSION("0.3"); @USE-ALIASES(name="rnl-zh")}
.model nch nmos level=1
M1 x inp tail 0 nch
M2 out inn tail 0 nch
* @RNL {
*   #M1(正输入) #M2(负输入) @视作 $"差分对";
*   {#M1 #M2} @对齐("y")
* }
.end

• 头段记录里的 USE-ALIASES 加载一个代称包；rnl-zh 给关键字和标准包里的名字提供中文写法（16.5）。标准写法照样可以用。ALIAS 声明一个代称：@ALIAS("@并排", "@ALIGN")。中文的 $ 名字要加引号，如 $"差分对"。

求解器的记录

* Solved, then dragged
* @RNL(type="header") { @VERSION("0.3")}
R1 a b 1k
R2 b 0 1k
* @RNL { {#R1 #R2} @ALIGN("x")}
* @RNL(type="generated", priority="high", author="rnl-solver") { #R1 @PLACE(0, 4); #R2 @PLACE(0, -4)}
* @RNL(author="editor") { #R2 @PLACE(y=-6, priority="high")}
.end

• 求解器把它决定的写进这一层末尾的一条 type="generated" 记录。这一层再求解时，这条记录不读，并被整个换掉：不要改它（2.8、14.8）。
• 要定住一个位置，在同一层后面的记录里写一条 "high" 的 PLACE，如上；两条 high 的事实里，先写的被丢掉。
• 没有名字的对象在那里写成编号，%#3，由字段 numbering 校验。你自己的记录里不要写编号；给对象起名。

常见错误

* A space before the bracket
* @RNL(type="header") { @VERSION("0.3")}
R1 a 0 1k
* @RNL { #R1 @PLACE (10, 20)}
.end

* A name of the series 0.2
* @RNL(type="header") { @VERSION("0.3")}
R1 a vss 1k
* @RNL { $GND @ATTACH &vss}
.end

交还文件之前

• 头段记录是第一条记录，在第 2 行或更后，声明 @VERSION("0.3")。
• 每条记录的每一行都是整行注释，注释符在第 1 列。
• 每个 #、& 和端子名都在它那一层的网表里；端子名和元件对得上（#M1:d、#Q1:c）。
• 只用标准系列 "0.3" 的名字：$GROUND、$DIFFERENTIAL_PAIR、$RESISTOR、$MIRRORED。
• 括号紧贴关键字或对象；语句用 ; 分开；数字不带单位。
• 每个集合角色都收到一个集合；两个槽位的关键字正好两个对象。
• 没有改动 type="generated" 的记录，别处没有写 %# 编号。
• 当作地和电源的网络加进了 $GROUND_NET_SET 和 $SUPPLY_NET_SET。
• 晶体管有 .model 卡，或者明写了符号。

完整的例子

* Five-transistor OTA
* @RNL(type="header") { @VERSION("0.3")}
.model nch nmos level=1
.model pch pmos level=1
.subckt ota5t inp inn out vdd vss vbias
M1 x    inp   tail vss nch W=2u L=0.5u
M2 out  inn   tail vss nch W=2u L=0.5u
M3 x    x     vdd  vdd pch W=4u L=0.5u
M4 out  x     vdd  vdd pch W=4u L=0.5u
M5 tail vbias vss  vss nch W=4u L=1u
* @RNL {
*   &vss @ADD-TO $GROUND_NET_SET;
*   &vdd @ADD-TO $SUPPLY_NET_SET;
*   %dp1 = #M1(in_p) #M2(in_n) #M5(tail) @AS $DIFFERENTIAL_PAIR;
*   %cm1 = #M3(ref) #M4(out) @AS $CURRENT_MIRROR;
*   %ax = (_, _);
*   #M1(a) #M2(b) %ax(axis) @AS $MIRRORED;
*   #M3(a) #M4(b) %ax(axis) @AS $MIRRORED;
*   #M3 #M1 @DISTANCE("top-to-bottom", min=4);
*   #M1 #M5 @DISTANCE("top-to-bottom", min=4);
*   {#M1 #M2 #M3 #M4 #M5} @GROUP;
*   {#M1 #M2} @TEXT("${w}/${l}", key="wl", dy=-3);
*   #M5:d @CURRENT("in");
*   #M5:s @CURRENT("out")
* }
.ends ota5t
.end

• 两个结构说明电路是什么；它们的体以低优先级把尾管放在中间下方，把每对镜像管关于轴放好。两条 DISTANCE 把负载放在差分对上面、尾管放在它下面。
• CURRENT 说明端子上静态电流的方向；它什么也不画（15.2）。
• 补位加上地、电源和端口标签；没定下的留给求解器决定。

1.1 范围

RNL（Rich Netlist）写在宿主网表的注释里。它描述网表定义的电路怎样理解、怎样呈现为原理图：用哪些符号，元件放在哪里，元件的朝向、对齐、连线、标注和样式怎样，几个元件合起来是什么意思（原则第 1 节）。

器件、类型、参数、连接和子电路接口只由宿主网表定义。RNL 引用它们，不能改变它们。RNL 也不校验绘图暗示的电气含义（原则 2.2）。

本标准定义：

• 怎样从宿主网表的注释里取出 RNL（第 2 章）；
• RNL 文本的词法和文法（第 3、4 章）；
• 文本描述什么对象，名字怎样解析，失效怎样处理，各条描述怎样合在一起生效（第 5–8 章）；
• 各类描述的词汇（第 9–17 章）；
• 标准词表，与本文一起发布，即 rnl-words-0.3.json（5.3、附录 A）。

本标准不规定布局算法和唯一的渲染结果（原则第 1 节），也不规定宿主网表怎样解析（原则 2.1）。标准包 rnl-std 和 rnl-zh 这类代称包是用 RNL 写的；本标准规定包怎样起作用（16.2、16.3、16.5），包的内容另行发布。

本文定义语言的 0.3 版。0.x 各版本之间不承诺兼容（16.1）。

1.2 本标准的结构

本标准由一个抽象模型和一种文本语法组成。抽象模型是对象、事实、消费方式和生效阶段（第 5–8 章）；文本语法是它的书写形式（第 2–4 章）。工具之间交换的是文本。

附录 A 列出各关键字的签名，由标准词表生成，是规范性的。附录 B 给出标准例句，附录 C 列出留给以后版本的内容，附录 D 列出与 0.2 版相比的改动，三者都是说明性的。注和例子是说明性的。其余都是规范性的。

1.3 一瞥

* Five-transistor OTA, input stage
* @RNL(type="header") { @VERSION("0.3")}
.model nch nmos level=1
.subckt ota5t inp inn out vdd vss vbias
M1 x    inp   tail vss nch W=2u L=0.5u
M2 out  inn   tail vss nch W=2u L=0.5u
M5 tail vbias vss  vss nch W=4u L=1u
* @RNL {
*   %dp1 = #M1(in_p) and #M2(in_n) treated @AS $DIFFERENTIAL_PAIR;
*   {#M1 #M2} @ALIGN("y"), i.e., same y;
*   #M5 is at @PLACE(20, 6) => it @ORIENT("R0");
*   %g0 = $GROUND is @ATTACH to &vss;
*   net &vss has a @WIRE connecting {#M5:3 %g0:p}
* }
.ends ota5t
.end

• * 开始一行 SPICE 注释。@RNL {…} 是一条记录，花括号里是用 ; 分开的成员（第 2 章）。文件开头的头段记录声明语言版本（16.1）。
• #M1、&vss、#M5:3 引用宿主的元件、网络和端子。%dp1、%g0 是本层的 RNL 名字。$DIFFERENTIAL_PAIR、$GROUND 是标准包（16.3）里的普通定义（9.4）。%g0 是套用 $GROUND 得到的用例，标准包给它配了地符号，所以画成一个地（第 12 章）。
• @AS、@ALIGN、@PLACE、@ORIENT、@ATTACH、@WIRE 是关键字。参数写在紧贴关键字的括号里，只放字面量。AS 把写在它前面的对象填进写在它后面的那个定义的角色；ATTACH 把写在它前面的定义添在写在它后面的对象上（9.4、第 12 章）。
• (in_p) 标出角色。%dp1 = 给语句的结果起名。=> 把一段的结果交给下一段；后面只跟一个名字时，给前一段的结果起名（5.5）。
• and、treated、, i.e., same y、is at、it、is … to、net、has a … connecting 是自由文本，不改变含义（3.3）。标准例句在记号之间加这类词，让语句读起来像句子（4.5、附录 B）。去掉它们，这条记录就是：

%dp1 = #M1(in_p) #M2(in_n) @AS $DIFFERENTIAL_PAIR;
{#M1 #M2} @ALIGN("y");
#M5 @PLACE(20, 6) => @ORIENT("R0");
%g0 = $GROUND @ATTACH &vss;
&vss @WIRE {#M5:3 %g0:p}

1.4 术语与约定

1.5 核心原则

本标准的规则遵循以下几条原则。第 1–6 条细化原则 2.9；第 7 条说明词汇怎样分工。

1. 一切皆描述。 RNL 文本是一组描述。解释器先收齐全部描述，再给出结果。没有执行过程，名字可以在绑定它的语句之前使用。
2. 书写位置只作排序数据。 描述写在哪里（所在的层和在文本里的先后）只在三处起作用：描述互相矛盾时保留后写的（几何事实先比优先级；8.3、8.4、8.5）；绘制顺序（11.6）；集合成员的次序（5.2）。此外结果与书写顺序无关。管道的每一段有自己的位置：后面的段算比前面的段后写（5.5）。
3. 矛盾。
   • 读不懂的描述（语法错、名字找不到、种类不对等），以及自相矛盾的描述，失效（原则 2.4、2.9；第 7 章）。
   • 能读懂但互相矛盾的描述，在本标准给出确定办法的地方按办法取舍，如按键覆盖（8.4）、外观队列（8.3）和几何事实的取舍（8.5）；可以给提示。
   • 暂时还没有确定办法的，整个解释失败（7.6）。本版没有这种情形（7.5）。以后的版本可以定出办法，改为容错；现在能用的文件不受影响。
4. 每条描述看到的是生效前的状态。 一条描述读到的是它所在阶段开始时的状态；它自己的效果和同一阶段其他描述的效果都不在内（8.2）。
5. 对象与名字。 每条带关键字的语句和每个 {…} 都产生一个新对象，由句柄和事实组成。引用不产生对象。名字只是指向一个对象，在一层里只绑定一次。覆盖针对事实，不针对名字（5.1、6.6）。
6. 不为可读性限制写法。 难读、但含义确定的写法照常允许，由作者自己克制。只有没有确定含义的写法才是错误。
7. 关键字与定义。 实现必须自己懂、用别的描述写不出来的，是关键字。能用已有描述写进普通定义的体里的，是定义，它的名字只作提示（9.5）。

1.6 一致性

文件。 一份宿主网表的记录，按第 2–4 章读、按第 5–17 章解释，不出错误（7.6），包括它使用的包的内容里的错误，这份网表就符合 RNL 0.3。警告和提示不影响一致性。包文件单独检查时（16.2）同样判断。头段记录声明了别的语言版本的文件，不受本版本约束（16.1）。

实现指解释器（只用来检查的解释器也叫 lint）、查看器、求解器、编辑器以及其他读写 RNL 的工具。符合标准的实现：

1. 按第 2 章从宿主的注释里取出 RNL，按第 3、4 章读它；
2. 按第 5–17 章给每条描述应有的效果，使用标准词表里的签名（5.3）；
3. 报告每个错误，给出位置和原因（7.6）；错误不能调低，也不能关掉；
4. 建议报告本标准列出的警告和提示（7.6）；
5. 可以另加自己的检查，但只能是警告或提示：不应让本标准允许生效的条目失效，也不应让本标准规定失效的条目生效；
6. 可以提供更严的模式，停下或拒绝整份输入，但不作为默认；
7. 让用户能看到诊断；怎样呈现由实现决定（7.6）；
8. 声明自己支持哪些语言版本，对不支持的版本的文件按 16.1 处理；
9. 把不认识的关键字、参数和取值当作错误（16.4）；
10. 按 16.3 在根上使用标准包；
11. 写 RNL 时，新语句用标准写法写，不重排用户写的语句（4.3）；保存文件时写头段记录和版本（16.1）；不认识的语句、失效的语句、宿主文字、普通注释和不支持的版本的文件都原样保留（16.4）；只改第 17 章允许它改的记录。
12. 求解时，按 8.5 取舍冲突，把自己定下的每个决定都写回，交给别的工具的结果也只用求解器的记录能含有的形式（14.8）。

本标准不规定求解器在满足约束的各种位置中怎样选，也不规定查看器怎样画 RNL 没有定下的部分；留给它们决定的地方在正文里写明（如 9.2.6、13.1）。

一致性测试查错误（连同位置和每处失效的范围）和得到的场景。警告可以作为可选的期望来查；提示不查（7.6）。

2.1 两层解析

• 宿主适配器：
  • 识别宿主合法的普通注释，判断哪些行是载体（2.2）；
  • 确定每段注释属于哪一层，以及每条记录、每个子电路来自哪个文件、哪一条 include（6.1）；
  • 给出源位置和文本的顺序；
  • 提供宿主对象：元件、网络、端子、子电路端口和模型类型。
• RNL 核心只在这些注释里找记录。它不应对整个网表做不看上下文的 @RNL 搜索：宿主语句、宿主字符串里出现的同样字符不是 RNL。
• 解释器先解析完整的宿主网表，再处理 RNL（原则 2.9）。

2.2 载体

记录写在宿主的整行注释里，这样的注释行叫载体。宿主适配器逐行判断哪些行是载体，去掉注释符和它后面的一个空格，把其余内容交给 RNL 核心（2.1）。

• 只用整行注释。 行尾注释（$、;、//、! 等）不读也不写，也不用块注释。

  • 行尾注释里的 @RNL 只是宿主文字，给警告。
  • 注：行尾那段算不算注释，随方言、模式和选项而变：HSPICE 的 $ 可以紧跟在数后面（1k$x），ngspice 的 ps 方式里 $ 是普通字符，Eldo 可以用 .COMCHAR 改；CDL 里 $SUB= 这类写法是数据。写进行尾还要改宿主语句那一行（原则 2.1）。SPICE 和 Spectre 都没有块注释（Spectre 只在 reliability{} 里有）。

• 各宿主的注释符。

  宿主	注释符
  SPICE 系：SPICE3、ngspice、HSPICE、Xyce、LTspice、PSpice、WRspice、Eldo，以及 CDL 网表	*
  Spectre 语言方式的段落：.scs 文件，或 simulator lang=spectre 之后的文字	// 或 *
  Spectre 里 SPICE 语言方式的段落，包括没有 .scs 后缀、开头也没写 simulator lang=spectre 的被 include 的文件	*

  • * 在 Spectre 的两种语言方式里都是注释。// 只在 Spectre 语言方式里有文档，在 Eldo 和 CDL 的文档里没有。
  • 一条记录的几行可以混用 // 和 *。工具写入记录时应跟随本文件已有的记录；没有记录时，SPICE 方式写 *，Spectre 方式写 //。
  • 载体属于外层写法，外层写法不改（16.1）。以后支持新的宿主时只增加载体，不改已有的。

• 载体行。 记录的每一行都应满足下面两条：

  • 注释符写在第 1 列，前面没有空白。

  • 注释符后面要么什么都没有，或者只有空白，这是空注释行；要么先是一个 ASCII 空格，再写内容。所以 *@RNL、*#M1、//@RNL 都不是载体行。

    注：HSPICE、PSpice 要求 * 在第 1 列；有缩进的行，各家处理不同。紧贴注释符的文字在别的工具里有含义：ngspice、WRspice 把 *# 行当命令执行，WRspice 对 *@ 行也是这样；*. 开始一条 CDL 指令（如 *.PININFO），*| 开始 DSPF 的数据，//pragma 是 Spectre 的加密封套。

  • 记录还没写完时遇到不合这两条的注释行（如 *#M1 …、** …、有缩进的 * …），记录被截断：整条记录失效（2.4）。记录之外，这样的行里的 @RNL 不是入口，给警告。

  • 写 RNL 的行建议不要以 \ 结尾。这样的行给警告，工具不应写出这样的行。RNL 照常读，没有东西失效；危及的是宿主网表。注：WRspice 会把下一行接进这行注释；Spectre 用 -E 运行（先过 C 预处理器）、Eldo 开了 SLASHCONT 时也可能这样；下一行若是宿主语句，就被吞进注释了。

• 不读 RNL 的位置。 这些位置的 @RNL 给警告，工具不应往这些位置写：

  • 每个宿主文件的第 1 行，以及宿主当作标题的别的行（如 WRspice 里 .newjob 的下一行）。主文件的第 1 行是它的标题，被 include 时却不是标题；第 1 行一律不读，同一个文件作主文件和被 include 时读起来就一样。所以头段记录最早写在第 2 行（2.8）。
  • 主文件 .end 之后的文字。注：.end 之后，ngspice 接着读，Xyce 停下，HSPICE、PSpice 可能当作下一个电路。
  • 宿主不当作网表注释的区域：控制脚本（ngspice 会执行 .control … .endc 里的 *# 行）、别的语言的块和文件（WRspice 的 .verilog、Spectre 的 reliability{}、用 ahdl_include 引入的文件）、密文、预处理去掉的部分、没选中的 .lib 段。适配器说不准的区域按不读处理，并给警告。

• 照读但给警告的位置：

  • 语句和它的续行（+ 行）之间的注释行。它们对 RNL 的含义是唯一的，所以照读；但宿主处理不同（PSpice 报错，SPICE 3f4 会把后面的 + 行接到注释上）。这些行给警告，工具不应往这里写。
  • 写成明文的加密区（.prot … .unprot、protect … unprotect）。照读，给警告：加密以后记录就没了。

• 写入建议：

  • RNL 不限制行长（2.4）。建议生成器在空白处换行，每行不超过 132 个字符：这是 PSpice 旧版的上限，在常见的宿主里最严（HSPICE 是 1024，Eldo 是 2000）。知道宿主上限的适配器按宿主的上限。一个记号在一行里放不下时，工具应报错，不应写出（字符串不能续到下一行，3.7）。
  • 编码见 3.1。

2.3 入口

• 记录以 @RNL 开始。入口只认大写。
• 各宿主都用同一个入口 @RNL；它就是原则 2.1 的子标签。
• @RNL 可以写在注释中间；同一行上它之前的文字属于宿主注释。
• @ 前的空格。 入口 @RNL 和关键字的 @，紧前一个字符应是 ASCII 空格（U+0020）；TAB、换行、行首都不算。载体行上，注释符后面的那个空格算作 @ 前的空格，如 * @RNL。字符串、加引号的名字、/* */ 注释里的 @ 不受限制。
  • 所以 {、=>、=、; 后面的关键字前也要留空格：#M1 @SET-SYMBOL { @DEFINE-SYMBOL {…}}、%x = @DEFINE(…)、#M2 @PLACE(30, 20) => @ORIENT("MY")。
  • 注：宿主注释里常有 @，如邮箱地址、@param；有了这条，这类文字不会被当作 RNL。WRspice 还会执行以 *@ 开头的行（2.2）。
  • 记录外的 x@RNL 不是入口，只是宿主注释。记录里前面没有空格的 @ 既不是关键字，也不是自由文本的字符：它是语法错误，所在的成员失效（7.4）。

2.4 记录的范围

• 记录写作 @RNL(…) {…}。括号里的记录头可以省；花括号不能省，单句也要写花括号。记录头的括号紧贴 @RNL，与关键字的参数括号紧贴关键字一样（3.5）：@RNL (type="header") {…} 是错误，整条记录失效。
• 记录从 @RNL 开始，到与它的第一个 { 相配的 } 结束。找相配的 } 时跳过字符串、/* */ 注释和参数括号里的内容。
• 跨行的记录。 一条记录可以写在连续的几行注释（载体，2.2）里。去掉每行的注释前缀，把各行内容接起来；换行是空白（3.5）。
  • 只有 *（或 * 和空白）的空注释行是空白，记录照常继续。
  • 还没写到收尾的 }，就遇到不是载体的行（宿主语句，.subckt、.ends、.include 这类行，完全空白的行，或不按载体写法写的注释行，2.2），或者文件结束，记录就不完整，整条失效。所以记录不会跨子电路和 include 的边界。记录里要留空行，就写一个只有 * 的行。
  • 记录还没结束时，在字符串和注释之外又出现入口 @RNL：前一条记录不完整，整条失效，从新的入口重新读。这样，漏写一个 } 只丢一条记录。
  • 不完整的记录是错误，诊断说明记录不完整，并指出在哪里截断。多打一个空行就让整条记录失效，这很容易发生，不应静默放过（7.6）。
  • 记录里的每一行注释都是 RNL。中间夹一行普通说明，如 * the next line is for M2，会当作自由文本读，含有不能作自由文本的字符时是错误。记录里的说明写在 /* */ 里（3.4）。
  • RNL 不限制行长；宿主的限制归适配器。长语句可以在空白处拆到几行；记号和字符串不能拆开（3.5）。给生成器的建议见 2.2。
• 记录结束后，同一行上再出现记号是错误：这些记号失效，记录本身照常生效。新的 @RNL 除外，所以一行可以写几条记录。
• 记录的外层写法（注释载体、入口 @RNL、记录头、花括号配对）与语言版本无关，以后的版本都不改（16.1）。记录头的字段见 2.8。

2.5 停用记录与宿主文字

• 记录之外、不含 @RNL 的注释行是宿主注释，整行忽略。
• 停用记录。 注释行里的 /*，如果前面只有空白或注释，或者紧跟在一条记录之后，就开始一段注释，到 */ 为止。其间的 @RNL 不是记录。
• 注释行中间文字里的 /*（如 models/*.lib）只是宿主文字。
• 宿主注释的结束。 载体是整行注释（2.2）：宿主注释到行尾结束，行内没有东西能提前结束它，所以宿主注释的结束与 RNL 文字没有冲突。

2.6 层

• 层按文字划分，上下级见 6.1：

  • 主文件的文件层：写在主文件里、不在任何 .subckt … .ends 之内的部分。它就是电路的顶层。
  • 每个被 include 的文件的文件层。.lib 的段同样处理。
  • 每个 .subckt … .ends。

• 记录属于它所在的层（原则 2.5）。

• 多文件的顺序。 被 include 的文件自成一层，排在 include 它的那一层之下（6.1）。所以 include 行写在哪里不影响顺序，这一点与 USE-PACKAGE 不同（16.2）；并列的几个被 include 的文件互不影响。同一层里按文本先后。

• scope。 记录可以用 @RNL(scope="name") 指定目标层。写的是子电路名，指那个子电路的定义。下面的文件里，最后一条记录写在主文件里，作用于子电路 ota：

  * A record written outside its subcircuit
  * @RNL(type="header") { @VERSION("0.3")}
  .model nch nmos level=1
  .subckt ota inp inn out tail vss
  M1 x inp tail vss nch
  M2 out inn tail vss nch
  .ends ota
  X1 vip vin vo vt 0 ota
  * @RNL(scope="ota") { #M1 @PLACE(10, 20)}
  .end

  • 每个子电路只有一张图（6.1），所以 scope 指定义，不指某一个元件。
  • scope 只能向下：目标应是本层在文字上包含的子电路，即本文件里定义的，或本层直接或逐级 include 进来的文件里定义的。子电路里不写 scope：子电路的 RNL 只管它自己。子电路里的记录写了 scope 是错误，当作没写（2.8）。目标找不到或不在本层之下时是错误；记录里的语句没有层可以解析，都失效（第 7 章）。
  • 记录里的引用都在目标层解析。它的语句提交到目标层，绑定的名字也发布到目标层，与目标层自己的记录共享（6.7）；目标层已经把这个名字绑定到别的对象时，再绑定是错误；绑定到同一个对象则可以（6.6）。scope 只影响它自己的记录，不改变宿主网表。
  • 顺序：scope 带进一个子电路的语句排在这个子电路自己的文字之后；几处都 scope 到同一个子电路时，外层的排在后面（8.3、8.5）。外面明确写的覆盖里面写的，与外层用例的优先级盖过它的体同理（14.8）。
  • 求解器的输出和用户在编辑器里做的修改不应使用 scope；它们写进子电路自己的文字（第 17 章）。scope 只用于作者自己选择写在外面的语句。

2.7 包文件

包可以写成单独的包文件，由 USE-PACKAGE 找到（16.2）。包文件是纯 RNL 文件，建议扩展名 .rnl，用 UTF-8 写。它不是网表，不用 .include 加载。

• 包文件的读法与网表里的载体相同（2.2、2.4），只是每一行都是载体，注释符和它后面那个空格都算空的：
  • 行首的 @ 算前面有空格（2.3），所以 @RNL 和关键字可以从第 1 列写起；
  • 空行是空注释行，记录照常继续；
  • 记录之外的文字是说明，忽略，与宿主注释相同（2.5）；/* */ 照常起作用；
  • 第 1 行照读：包文件不是网表，没有标题行（2.2）。
• 包文件里写 @RNL(…) {…} 记录，按 16.1 的顺序解析。第一条记录是头段记录，里面写 VERSION 和 PACKAGE。包里能写什么，包括引用别的包，见 16.2；代称包也是包文件（16.5）。

下面是一个包文件的全文，没有注释前缀。第三行在记录之外，是说明：

@RNL(type="header") { @VERSION("0.3"); @PACKAGE(name="acme-style", version="1.2")}

ACME house style: NMOS symbol and its rule.
@RNL {
  $NMOS_ACME = @DEFINE-SYMBOL {
    $NMOS;
    ? @TEXT("${name}", key="name") => @PLACE(-2.5, 1.5)
  };
  # @SELECT-INSTANCE(type="nmos") => @SET-SYMBOL $NMOS_ACME
}

2.8 记录头

@RNL(…) 括号里的字段作用于记录里的每条语句，都写名字。字段名和 type 的值按标准的拼写写，区分大小写，不能有代称（3.6、16.5）。

* @RNL(type="header") { @VERSION("0.3")}    /* the first record of the file: read as version 0.3 (16.1) */
* @RNL { %dp1 = #M1(in_p) #M2(in_n) @AS $DIFFERENTIAL_PAIR}    /* no type: "authored" */
* @RNL(type="generated", priority="high", author="rnl-solver 0.3", hash="sig1:9f3a62c1") {
*   #M1 @PLACE(12, 20); #M2 @PLACE(28, 20)
* }
* @RNL(author="rnl-editor 0.1") { #M2 @PLACE(x=30, priority="high")}

• type：取值固定，各有确定的行为。
  • "authored"，默认：手写的、编辑器写的或导入的。
  • "generated"：求解器的结果。求解器求解时，不把 type="generated" 的记录算进解释：它们不带来对象、名字或事实，也不约束结果；此外怎样用它们，由求解器自己决定。求完把它们整条换掉，不论作者是谁。编辑器拖动器件时重画的导线也算求解结果（14.8、第 17 章）。type 不隐含优先级：求解器明确写出 priority="high"。
  • "header"：文件的设置（16.1）。头段记录可以不写。写的话，它在文件层，不在 .subckt 里，不带 scope；它是文件的第一条记录，至多一条。里面写 VERSION（16.1）、ALIAS 的代称和 USE-ALIASES 的代称包（16.5）、DEVICE 的端子名（6.12）和 USE-PACKAGE 的根上的包（16.3）；包文件还在这里写 PACKAGE（2.7、16.2）。头段记录本身按标准拼写读，不认代称（16.5）。写在文件后面的头段记录，或第二条头段记录，是错误，整条忽略；已经读过的记录不回头改。经 .lib 读入的一节，按一个文件算（2.6）：它的头段记录是节里的第一条记录。
• 元数据：author、hash、modified 不影响解释；删掉它们，画出来的结果不变。工具拿它们判断怎样处理一条记录（第 17 章）。type、author 都不影响取舍次序（8.3）。
• 出错：
  • 不认识的字段只给警告，忽略；它不影响这条记录和别的字段。这给以后的扩展留了位置。给这个警告时，应指出最接近的字段名。注：这样一来，影响解释的字段拼错了（如 priorty="low"）也只得到警告，记录按优先级 "normal" 生效；以后新增的这类字段，要靠版本（16.1）让旧工具知道自己过时了。
  • 认识的字段写错（值不对，numbering 写在 type 不是 "generated" 或带 scope 的记录里，或同一字段写了两次）是错误，按没写这个字段处理：priority 回到 "normal"，type 回到 "authored"，元数据丢掉。例外是目标找不到的 scope：记录里的语句没有层可以解析，都失效（2.6）。按位置写的字段是错误，忽略。
• 记录没有标识。工具按 type、author 和语句的键（5.8）找自己的记录；在另一条记录里引用一个对象靠它的名字，求解器的记录还可以用编号（5.9）。别的说明写在注释里。
• 求解结果不是要采纳的提案：它直接生效，过时的结果只给提示（第 17 章）。

3.1 字符

• 正式记号都由 ASCII 字符组成。

• 非 ASCII 字符只出现在字符串（包括加引号的名字）、自由文本、注释和代称里，以及不加引号的角色名和参数名里。在自由文本和注释以外，不加引号的非 ASCII 词只出现在 @ 后面和括号里：@ 后面的应是声明过的代称；括号里的是代称，或角色名、参数名本身（3.6、16.5）。

• 编码。 宿主适配器按宿主的规则解码，RNL 处理的是字符。写 RNL 的工具不应改变宿主文件的编码和换行符，不应加字节顺序标记（BOM）；不应写出宿主编码表示不了的字符，改为给警告。新文件建议用 UTF-8。

• 宿主注释里的非 ASCII 字符。 适配器应写明哪些宿主验证过注释里的非 ASCII 字符；在别的宿主上，非 ASCII 字符给提示。

  注：各宿主的支持不一。ngspice（v42 起）、WRspice（标题除外）、Xyce 和新版 LTspice 接受注释里的非 ASCII 字符；HSPICE、PSpice、Eldo 的文档没写；Spectre 的手册说网表是 ASCII 文件；QSPICE 用 Windows-1252。不加 BOM 还有一个原因：旧版 ngspice 会把它粘到被 include 文件的第一个记号上，WRspice 在第 1 行以它开头时中止读入。

3.2 正式记号

括号内（参数、角色和点的 ()，数组的 []）另有字符串、数、,、=、_ 和名字（参数名、角色名、true、false），在普通定义的体里还有参数空位 ?name（6.10）。下标的 <> 和 [] 里只有不带符号的整数、, 和 :（6.11）。

3.3 自由文本

• 括号外，除了下面列出的字符，任何字符都可以作自由文本，包括全部非 ASCII 字符（如中文标点 ：、、、；、（、））和 -、:、'、!、+、/、*、|。例外是：
  • @、#、&、%、$、?、"、;、=、{、}、(、)：在括号外，它们开始正式记号或属于正式记号（3.2）。? 开始空位（6.10）；在符号体里，单独的 ? 指用这个符号画出的对象（13.3）；
  • [、]、<、>：数组和下标的括号（3.7、6.11）；
  • /*：开始注释（3.4）。
• 几条位置规则让含义唯一：
  • 紧贴引用、后面是名字或引号的 : 或 ::，照常是端子或子对象（6.4、6.5）。后面不是名字时，: 是自由文本，如 Input pair: %dp1 = …、#M1: the left one。
  • 紧贴名字的 < 或 [ 是下标（6.11）。
  • 关键字的名字里，- 后面跟字母时才属于名字（关键字见 3.6）。@GROUP- the pair 是 GROUP 加自由文本。
• 自由文本可以写在括号外任意两个记号之间，也可以写在成员开头。
• 自由文本是语句的一部分。 写在里面的引用不是说明，而是这条语句的对象：Unlike #M2, #M1 @PLACE(x=0) 把 M2 也放到了 x = 0。只作说明的文字写进注释（3.4），或者让它单独成为一个成员，用 ; 与下一个成员隔开：只有自由文本的成员是空成员，忽略（4.1）。
• 标准不检查自由文本，自由文本不影响含义（原则 2.8）：do not move #M2 @PLACE(x=30) 仍会移动 M2。对否定词这类词，实现可以另给自己的警告（7.6）。
• 同理，误写的 #M1.d 里，.d 是自由文本，引用的是 M1 本身，不是它的漏极（给警告，见下）。
• 括号内没有自由文本。
• 警告。 下面这些写错可能静默通过；它们给警告（7.6）：
  • 自由文本里的词与这一层的宿主元件名、看得到的 RNL 名字（不带前缀）或关键字名相同，如 #M1 #M2 M3 @ALIGN("y") 里的 M3、WIRE {…} 里的 WIRE：多半漏了 #、%、$ 或 @。网络名常是普通词（如 in、out），不查。
  • 引用后面紧跟 . 加名字，如 #M1.d：端子用 : 写。
  • 引用后面紧跟 -、!、'、+、/、*、\、^、~ 或 |，如 &vdd!、#X1-a：多半是名字里有这个字符，要加引号，如 &"vdd!"（3.6）；不加引号，引用就静默地指 vdd 或 X1。
  • 自由文本里的 |：管道写作 =>（4.2 第 3 条）。
  • 紧贴引用的 : 或 :: 后面跟着非 ASCII 的词，如 %c1::中点：:: 后面含非 ASCII 字符的名字要加引号，如 %c1::"中点"（3.6）；不加引号，:: 和这个词是自由文本，引用指的是 %c1。
• 其余这类写错多数已经是错误：括号里没有自由文本，所以 @ORIENT(MY) 是错误；#M1 @PLACE 1 2 与签名不符；#M1 (in_p) 是错误，因为隔了空白的括号开始一个点，而 (in_p) 不是点（3.5）；R1 -> R2 里的 > 不能作自由文本。
• 给作者的写作参考由标准词表生成（5.3）。求解器和编辑器写的记录不应含自由文本。

3.4 注释

/* … */ 可以写在任何允许空白的地方，包括括号内。注释不能嵌套，里面可以写任何字符。含有引用、或含有 @、#、; 这类字符的说明，写在注释里（3.3）。

3.5 空白与紧邻

• 空白是空格、TAB 和换行。记号不能拆开跨行，字符串也不能跨行。
• 以下位置不允许有空白和注释：前缀与名字之间，%# 与编号之间；:、:: 的两侧；名字与它的下标之间（6.11）；关键字与它的参数括号之间，以及 @RNL 与它的记录头括号之间（2.4）；对象与它的角色括号之间。
• 隔了空白或注释的 ( 开始一个点（3.8）。所以 #M1 @PLACE (10, 20) 是 PLACE 加一个点，PLACE 没有参数：是错误。#M1 (in_p) 是 M1 加一个不合写法的点：也是错误。诊断建议去掉空白。
• 名字（加不加引号都一样）后面紧跟的 < 或 [ 总是开始一个下标（6.11）。点写成 (x, y)，与下标不冲突；名字后面要写点，就用空白隔开，如 &D (1, 2)。下标里可以写空白和注释，如 &D<1, 2:3>（6.11）。
• 紧跟关键字的 . 是自由文本，如 {#M1 #M2} @GROUP. 里的句号；@BUNDLE.LOCK 是 BUNDLE 加自由文本 .LOCK（16.4）。

3.6 名字

• 不加引号的名字是一个或多个 ASCII 字母、数字、下划线，按最长匹配取。
• 宿主名字（#、& 之后）和端子名按宿主方言的规则（原则 2.1）：哪些名字合法，区不区分大小写，能不能以数字开头，如 &0。SPICE 不区分大小写，Spectre 区分。含别的字符的名字加引号，如 #"M1<0>"、&"vdd!"、#XU1:"in+"；引号里的写法与字符串相同（3.7）。名字后面可以紧跟下标：#M1<0> 就是 #"M1<0>"，&D<7:0> 是一组网络（6.11）。引号里的 < 或 [ 是名字的一部分，不解析。
• RNL 名字（%、$、? 之后的名字，角色名，普通定义的参数名）：
  • 区分大小写：$DIFFERENTIAL_PAIR 和 $differential_pair 是两个名字。
  • %、$、? 后面的名字可以以数字开头，如 %1st。在没有前缀的位置（(role) 和 parameter=），不加引号的名字由 ASCII 字母、数字、下划线和任何非 ASCII 字符组成，不以 ASCII 数字开头，免得像数：#M1(正输入)、@AS(间距=3) $X。这两处都在括号里，括号里没有自由文本（3.3），所以不会把别的词吞进名字。
  • 可以加引号，含义相同：$"a" 就是 $a；引号只是转义。含别的字符的名字和非 ASCII 的名字写在引号里，如 %"差分对"、%"input pair"、?"正输入"、%dp::"正输入"。在角色名和参数名的位置上，非 ASCII 的名字可以不加引号（上一条），但空格或别的 ASCII 标点仍要加引号，如 #M1("input pair")。在角色名和参数名的位置上，加引号的名字永远是名字本身，不当代称。这一点不适用于 $ 名字和 :: 后面的名字，它们的非 ASCII 代称本来就写在引号里（16.5）。
  • 按写出的字符逐个比较，不做 Unicode 归一化。空名字是错误。
  • 不收下标（6.11）：后面紧跟 < 或 [ 是错误，如 %p<1, 2>。点写成 (1, 2)，与名字之间隔空白。
• 代称（16.5）在头段记录里声明，或来自代称包。关键字和标准词的代称可以含非 ASCII 的字母；它们只在 @ 后面和括号里不加引号写。$ 名字的代称照 $ 名字写，非 ASCII 的加引号，如 $"接地补位集"。#、&、%、$、? 和 :: 后面不加引号的名字如上所述只含 ASCII 字符，所以 #M1和#M2 是 #M1、自由文本 和 和 #M2。
• 关键字只认大写，词间用 - 连接，如 @AS、@SET-SYMBOL；大写也便于在自由文本里认出它们。@at 是不认识的关键字，除非头段记录把它声明为代称（16.5）。
• 标准词区分大小写，按标准的拼写写：参数名、记录头的字段名、子对象名、选择条件的名字和枚举值（如 "x"、"low"、"MY"）。指宿主东西的值（选择条件里的名字、模型名、网络名）按宿主的规则。别的写法可以通过代称接受（16.5）。
• true 和 false 保留，只认小写。它们不能作角色名或参数名。

3.7 字面量

• 数是十进制。可以带正负号和前导零，可以省略小数点前的零或小数点后的数字，可以带指数：0、+1、01、.5、1.、-2.5E-4。01 就是 1，不是八进制。没有单位和工程后缀（2u、10k 是错误），没有十六进制数，没有 NaN 和 Infinity。位数不限。实现装不下一个值时，这条语句在这个实现里失效，报的错误说明这是实现的限制；不悄悄改值。坐标按容差比较（11.7）。
• 字符串写在双引号里，不能跨行。引号之间的字符照原样取；只有 " 本身写成 ""，如 "say ""hi"""。没有反斜杠转义：\ 是普通字符，没有 \n 或 \uXXXX；非 ASCII 字符直接写。字符串里写不了换行；文字里的换行用文字记号 \\ 写（13.6）。TEXT 有自己的反斜杠命令（13.6）；那是 TEXT 怎样读它的文字，不是字符串的转义。记录头里的字符串也这样写；这属于外层写法，不改（16.1）。
• 数组写作 [value, value, …]。元素是字面量，数组可以嵌套。
• 真假值是 true 和 false。
• 没有别的字面量。枚举写成字符串，如 axis="x"；没有 null、映射和构造值。
• 没有表达式：运算符是错误。

3.8 点

• 点写作 (x, y)，x、y 是数或 _（在普通定义的体里，也可以是参数空位，6.10）。_ 让这一轴自由，由约束或求解器决定。
• 写一个点就是创建一个点对象（5.1）。
• 点没有算术；相对位置写成约束（第 14 章）。
• 点的 ( 前面有空白或注释，或者紧跟在 {、;、=>、= 之后。紧贴关键字或对象的括号放它的参数或角色（3.5）。名字后面紧跟的 < 无论如何都是下标（6.11）。

4.1 文法

记录的文法用 EBNF 给出。每条产生式写作 name = expression ;；| 分开各个选项，[ … ] 是可选的，{ … } 重复零次或多次，( … ) 分组，双引号里的文字照原样写，(* … *) 是注释。

record         = "@RNL" [ parameters ] set ;          (* the bracket touches "@RNL" *)
set            = "{" [ member ] { ";" [ member ] } "}" ;
member         = [ front-naming ] segment { naming } { "=>" segment { naming } } ;
front-naming   = ( "%" rnl-name | "$" rnl-name ) "=" ;
naming         = "=>" ( "%" rnl-name | "$" rnl-name ) ;
segment        = argument { argument } [ call { argument } ]
               | call { argument } ;
call           = keyword [ parameters ] ;          (* the bracket touches the keyword *)
keyword        = "@" keyword-name ;                (* upper case, or a declared alias *)
argument       = object [ "(" role-label ")" ] ;   (* the bracket touches the object *)
object         = reference | placeholder | point | set ;
reference      = "#" [ host-name [ subscript ] ] path
               | "&" host-name [ subscript ] path
               | "%" rnl-name path
               | "%#" integer path                (* a number, in a record of the solver, 5.9 *)
               | "$" rnl-name ;
placeholder    = "?" rnl-name path
               | "?" ;                             (* alone, in a symbol body *)
path           = { ":" terminal-name [ subscript ] | "::" rnl-name } ;
subscript      = "<" subscript-item { "," subscript-item } ">"
               | "[" subscript-item { "," subscript-item } "]" ;
subscript-item = integer [ ":" integer [ ":" integer ] ] ;   (* unsigned, 6.11 *)
host-name      = name | string ;
rnl-name       = name | string ;
terminal-name  = name | string ;
role-label     = bracket-name | string ;
point          = "(" coordinate "," coordinate ")" ;   (* after white space, a comment, "{", ";", "=>" or "=", 3.8 *)
coordinate     = number | "_" | parameter-placeholder ;
parameters     = "(" [ value { "," value } [ "," named-value { "," named-value } ]
                     | named-value { "," named-value } ] ")" ;
named-value    = parameter-name "=" value ;
parameter-name = bracket-name | string ;
value          = number | string | "true" | "false"
               | "[" [ value { "," value } ] "]"
               | parameter-placeholder ;
parameter-placeholder = "?" rnl-name ;

• name、bracket-name、keyword-name、string、number 和 integer 的写法见第 3 章。name 是不加引号的名字（3.6）。bracket-name 是角色括号里或参数的 = 前面不加引号的名字：由 ASCII 字母、数字、_ 和任何非 ASCII 字符组成，不以 ASCII 数字开头（3.6）。keyword-name 由字母、数字和 _ 组成，词间用 - 连接；- 后面跟字母时才属于它（3.3）。标准关键字是大写的（3.6）；代称由任何文字的字母、数字和 _ 组成，不含 -（16.5）。string 和 number 见 3.7；integer 是不带符号的十进制整数。
• rnl-name、host-name、terminal-name、role-label 和 parameter-name 也可以加引号，含义相同，只是在角色名和参数名的位置上，加引号的名字永远不是代称（3.6）。关键字、参数名、角色括号里的槽位名、子对象名、true 和 false 可以写成声明过的代称；不加引号的非 ASCII 代称只用在 @ 后面和括号里，:: 后面的代称加引号（16.5）。
• 下标直接跟在宿主名字或端子名后面，中间不能有空白；下标里可以写空白和注释（3.5、6.11）。哪些名字收下标，见 4.2 第 10 条。
• 参数括号紧贴关键字，角色括号紧贴对象；隔了空白或注释的 ( 开始一个点（3.5）。
• => 是管道还是命名，看它后面是什么（4.2 第 3 条）。
• 带名字的空位只写在普通定义的体里（6.10）。在对象的位置上，它是一个角色，可以带路径；在收字面量的位置上（参数的值、数组的元素、点的坐标），它是定义的一个参数，不带路径（6.10、9.4）。单独的 ? 只写在符号体里（13.3）。
• 自由文本和注释可以写在括号外任意两个记号之间，也可以写在成员开头（3.3、3.4）；空白和注释也可以写在括号里。文法里不写出它们。
• 空成员（如 ;;）忽略；最后一个成员之后的 ; 可以省略。

4.2 文法之外的约束

1. 段不能为空。
2. 一段至多一个关键字。@RNL 只出现在记录开头。
3. 一个 =>，后面是一个 % 或 $ 名字，再往后是 =>、;、} 或成员结束时，它是命名。别的 => 都开始下一段；那一段恰好有一个关键字，写在那里的名字是那一段的对象。管道的第一段可以没有关键字，这时它恰好有一个对象。所以要先给结果起名、再接着管道，写 => %g0 => @PLACE(1, 2)。在 => %g0 @PLACE(1, 2) 里，%g0 是 PLACE 的对象；它通常没有绑定，这条语句因为找不到 %g0 而失效。诊断可以问是不是漏了 =>。
4. 没有关键字的段里，每个实参各是一条语句：{#M1 #M2} 里的 #M1 #M2 是两条语句。这样的段带命名时（%p = 或 => %p），只能有一个对象：写 %p = {#M1 #M2}，不写 %p = #M1 #M2。
5. 角色只标在有关键字的段的实参上。管道后面的段不标角色。
6. 一段里的实参要么全部标角色，要么全部不标。同一个角色只标一次。
7. 收定义的关键字，定义的槽位由关键字定：ATTACH 的定义是写出的第一个对象；AS、SET-SYMBOL、SET-STYLE、SELECT-USAGE 和 SELECT-ANCESTOR-USAGE 的定义是最后一个对象。SELECT-USAGE 可以省略它的定义：最后一个对象是定义时，才填定义的槽位（10.1）。定义不标角色，也不计入第 6 条（5.6）。
8. 命名有两种写法，可以并用。name = 只能是成员的第一个记号（前面可以有自由文本），一个成员至多一个。=> name 跟在段后面，在成员末尾，或在下一段的 => 之前，一个成员可以有几个。第 3 条把它与管道分开。
9. 按位置写的参数在前，写名字的在后：写了一个 name=value 以后，后面的参数都写名字。只有签名里列了位置次序的参数可以按位置写，按那个次序写。同一个参数不写两次。
10. 下标只跟在 # 或 & 后面的宿主名字之后，或 # 引用里的端子名、端口名之后。RNL 名字、用例的端子名（角色名）和子对象名不收下标（6.11）。
11. 一个引用里至多一处下标展开成一组名字（6.11）。

4.3 语序

• 关键字连同参数可以放在对象之间的任何位置；对象之间的先后有意义。#M1 #M2 @DISTANCE(…)、#M1 @DISTANCE(…) #M2、@DISTANCE(…) #M1 #M2 相同。
• 每个关键字有一种标准写法，工具应只写这一种。标准写法记在标准词表里（5.3）：关键字放在哪里，哪些参数按位置写、哪些写名字，标不标角色。
• 默认的标准写法是：对象在前，然后是关键字和参数，定义写在关键字后面。ATTACH 先写定义，再写关键字，再写对象：$GROUND @ATTACH &vss。签名里列了位置次序的参数按位置写，写在前面；其余的写名字，按标准词表的次序：@PLACE(10, 20)、@ORIENT("R90")、@DISTANCE("bottom-to-top", min=4)、@TEXT("W/L", key="wl")。PLACE 只在两轴都写时按位置写 x 和 y；只写一轴时写名字，如 @PLACE(x=10)。去掉也不改变含义的参数不写，如 WIRE 的 mode="auto"。内置关键字不标角色；普通定义有两个或更多角色时，AS 和 ATTACH 标出全部角色。
• 版面：括号里每个逗号后空一格；参数的 = 两边不空；命名的 = 和 => 两边各空一格；关键字紧贴它的括号；{ 和关键字之间空一格，如 { @…（2.3）；数写成能读回同一个值的最短的十进制。
• 命名的标准写法。 没有管道的成员在开头命名，%x = statement；有管道的成员在末尾命名，statement => … => %x，名字跟在它所命名的那一段后面。这样开头的名字总是给整个成员起名，读的人不用猜它指管道的哪一段。文法两种写法都收。
• "只写这一种"指工具新写的语句。工具改写已有的记录时，不应重排用户写的语句（16.4）；只在用户要求格式化时，才把它们改成标准写法。
• 标准例句见 4.5。

4.4 错例

下面每一条都是错误；注释说明原因。

#M1 @PLACE (10, 20)    /* a bracket after white space is a point, and PLACE has no parameters (3.5) */

#M1 (in_p) #M2 (in_n) @AS $DIFFERENTIAL_PAIR    /* role brackets touch the object; a separate bracket is a point (3.5) */

#M2 @PLACE(62, 40) (MY)    /* the second bracket is a point, and its content is not a point */

&vss @ATTACH $GROUND    /* the definition of ATTACH is written first: $GROUND @ATTACH &vss */

R1 -> R2 {#R1 #R2} @ORDER("x")    /* ">" cannot be free text (3.3) */

#M1 @PLACE(1, 2), #M2 @PLACE(3, 4)    /* a comma does not separate statements: two keywords in one segment */

#M1 #M2 @SET-SYMBOL $NMOS    /* three objects, and SET-SYMBOL has two slots (5.2.1); write {#M1 #M2} @SET-SYMBOL $NMOS */

#M1 => #M2    /* the segment after a pipe has no keyword */

#M1 #M2 #M3 @DISTANCE("x", min=1)    /* three objects for two slots */

#M1 @PLACE(x=10, 20)    /* a parameter given by position after one given by name (4.2 item 9) */

{#M1 #M2} @ORDER(axis="x", direction="increasing")
/* ORDER has no axis: the axis and the direction are one parameter, direction, as in @ORDER("left-to-right") (14.3) */

#M1 @SET-SYMBOL($NMOS)    /* brackets hold only literals */

{#M1 #M2} @ALIGN(axis=y)    /* enumerations are written as strings */

%ax = (_, _);
#M1(a) #M2 %ax @AS $MIRRORED    /* roles are marked on all objects or on none */

$NMOS(symbol) #M1(target) @SET-SYMBOL    /* the definition is written last and is not marked with a role */

#R1(source) #R2(chain) #R3(chain) #R4(load) @AS $CHAIN    /* the same role is marked twice */

(0, 0) @PIN(terminal=1)    /* a pin cannot be written in the scene (13.4) */

#M1 @CURRENT("in")    /* CURRENT takes only terminals (15.2) */

&D<1:0>[1:0]    /* a name has at most one subscript (6.11) */

#XI0<1:0>:D<1:0>    /* one reference has at most one expansion (6.11) */

&D<_, 1>    /* a "<" directly after a name starts a subscript, and its content is not a subscript (3.5) */

%p<1, 2>    /* RNL names take no subscript; a point is written (1, 2) (6.11) */

4.5 标准例句

标准例句是用标准写法写、在记号之间加上自由文本、读起来像一句话的语句。标准例句用于写作参考，也用于格式化工具给语句加词或去词。自由文本不影响含义（3.3）：例句只是建议，用户和语言模型可以照写，也可以不写，或写别的词。

• 读作事实。 语句说的是图上成立的事实，不是要做的操作。对象在前当主语，关键字当谓语或名词，参数是它的值。只加连接的词，如英文的 is、are、has、is at、there is，中文的 是、处于、位于、有、的、按……排列。少数语句也可以读作操作，如 #M1 @SET-SYMBOL to $NMOS。
• 词由语句算出。 工具生成的词只取决于关键字、参数、对象的个数和种类、语句写在哪一层，不取决于电路的意思。例如写 is 还是 are 按对象的个数；只给一轴时写 the x of（x 坐标）；选择的候选的说法按范围和要选的种类（附录 B）。这是生成例句的办法，不限制用户。
• 不写像有含义、其实语句没有这个含义的词。 不写 must、required、only（必须）这类词；方向词只在参数有这个方向时写。读的人会相信句子里的词，建议写作参考提醒他们注意这一点。
• 补一句。 读的人未必懂朝向码和轴。可以在关键字后面用 , i.e., …（，即……）说出代码本身的意思，如 #M2 @ORIENT("MX"), i.e., flipped upside down、#M2 @朝向("MX")，即上下镜像。
• ORIENT-RELATION 和 DISTANCE 有两个槽位，读作 from A to B（A 到 B）；中文里 ORIENT-RELATION 接 的，DISTANCE 接 有。方向只是一个轴（"x" 或 "y"）的 DISTANCE 读作 between A and B（A 和 B 之间有）。
• 选择一律读作在候选里选：英文是 among <candidates>, @SELECT-…，中文是 从<候选>中 @选出…。范围是 # 时，候选读作 the <kind> at each level in # and below（本层 # 及以下每一层的<种类>），说出规则在每一层各求一次值（10.4）。种类算不出时，读作 for X,（对于 X，）。
• AS 与 ATTACH。 对象合起来构成这个东西时用 AS：#M1(in_p) and #M2(in_n) are treated @AS $DIFFERENTIAL_PAIR。这个东西添在对象上时用 ATTACH：$GROUND is @ATTACH to &vss（9.4）。
• 管道。 后一段指前一段的结果。英文用 it（前一段是 AS、ATTACH 或单个对象时）或 they（前一段是选择时）；中文一律用 其，与别的对象并列时写 其与。管道里的名字前面写 named（记作），如 … => named %pout（… => 记作 %pout）；它照样是命名（4.2 第 3 条）。
• 命名。 单条语句的名字写在开头（4.3）。给 AS 的语句起名时，英文去掉 are：%dp = #M1(in_p) and #M2(in_n) treated @AS $DIFFERENTIAL_PAIR。
• 集合的名字。 指集合的名字建议以 _SET（$ 名字）或 _set（% 名字）结尾，中文以 集 结尾，如 $GROUND_FILL_SET、%bias_set、%"接地补位集"；标准包照此命名。
• 不写 each。 不写 each（每一个）这类词。一个集合是整个套用还是逐个成员套用，要看定义的角色表，标准例句不说是哪一种。
• 中文。 中文例句用代称包 rnl-zh 的代称（16.5）。中文逗号后面接 @ 时仍要空一格（2.3）。

各关键字的标准例句列在附录 B。

5.1 对象

• 每条带关键字的语句产生一个新的 RNL 对象，由句柄和事实组成。{…} 也产生一个新对象，即集合（5.2）。
• 引用（#M1、&vss、%x、$X，以及端子、子对象）不产生对象，只取已有的句柄。单独的 #M1 也是语句，得到 M1，不带事实；单独的 # 得到本层，不带事实。
• 句柄是被描述的那个东西：宿主的元件、网络、端子，或本层；或由 RNL 创建的点、导线、集合、用例、约束等。句柄不会是另一个 RNL 对象。
• 一条语句的对象，要么用新的句柄（语句创建，如 WIRE、图元、{…}、选择、AS、ATTACH、约束），要么沿用输入的句柄、再加上新的事实（语句修改，如 PLACE、ORIENT、SET-SYMBOL、SET-STYLE、GROUP、CURRENT；ADD-TO、REMOVE-FROM 沿用目标集合的句柄）。是哪一种写在签名里（5.3）；WIRE 收到网络时创建，收到导线时修改（13.1）。
• 两条内容相同的语句是两个对象，如两句 #M1 @PLACE(1, 2)。它们的事实不矛盾，一起生效。
• 事实只在产生它的语句处提交一次（5.4）。本层生效时，同一个句柄的全部事实合在一起，矛盾按 1.5 第 3 条处理。
• 属性就是事实：位置、朝向、符号、样式都是对象上的事实，没有可以改写的属性字段。本层生效时，把同一个句柄的事实合起来算出最终的值：PLACE 的 x、y 按几何事实（5.8、8.5），符号、样式按外观队列（8.3）。
• 句柄的种类由它的来历决定：宿主对象由宿主给出，RNL 对象由创建它的语句决定。签名规定每个对象槽位收哪些种类（附录 A），收到种类不对的对象时，这条描述失效。能在读入时查的读入时查；要到后面才知道的（用例有没有符号、定义的角色）在本层生效时查（7.1）。

对象的种类：

这些种类里，元件、端子、网络、点、导线、标签、叠画、标注、用例有种类名（5.3），text 也是种类名，指任何 TEXT，不论标签还是标注；其余几种在签名里怎样写见附录 A。

另有子对象（6.5），句柄是父对象和名字；以及失效对象（第 7 章）。

5.2 集合

• {…} 产生一个集合对象，成员有序。集合可以命名（%pair_set = {#M1 #M2}），有名字的集合可以被别的语句增删成员（5.2.2）。

• 集合保留重复的成员和写出的次序，如 {#M1 #M2 #M3 #M1}。是不是同一个成员按句柄判断：分别写出的两个 {…} 是两个句柄，内容相同也不是同一个成员。

• 引用打散一层：集合里写的引用如果指向一个集合，就在原处放进那个集合的成员，所以 {%a_set %b_set} 是 a_set 的成员接着 b_set 的成员。结果是集合的语句（如选择）同样打散；下标展开的一组引用（如 &D<7:0>，6.11）也一样。要去重，写 %a_set %b_set @UNION（5.2.2）。

• 直接写的 {…} 保留：集合里直接写的 {…} 作为一个成员保留，所以 {{%a_set} {%b_set}} 是由两个集合组成的集合。

• 散写的对象也打散：只有一个槽位的关键字收到几个不加花括号写的对象时，把它们合在一起，与写在 {…} 里完全相同（5.2.1 第 3 条），所以其中的集合打散。设 %bias_set = {#R1 #R2 #R3}，%lbl 是一段文字：

  • %bias_set %lbl @ALIGN("x") 就是 {%bias_set %lbl} @ALIGN("x")：R1、R2、R3 和文字逐个 x 相同；
  • {%bias_set} %lbl @ALIGN("x") 把集合保留为一个成员：文字与 R1–R3 的中心 x 相同；
  • 集合是唯一的对象时，用的就是它本身：%bias_set @ALIGN("x") 对齐 R1、R2、R3。

  在 ORDER、ALIGN、DISTRIBUTE 的成员里，只有写成 {%x} 的集合才作为一个成员、按它的中心算（14.1）。

  注：打散在约束里最容易读错。{%stage1_set %stage2_set} @ORDER("x") 把两组的成员逐个排序，常与组内的 ALIGN 矛盾。要在两组之间排序，写 {{%stage1_set} {%stage2_set}} @ORDER("x")，或用 DISTANCE 的两个槽位（14.5）。保留打散，是因为它是把集合拼起来的唯一写法。散写的对象完全按写在 {…} 里读，这样多加花括号不会让含义颠倒：要是散写的对象不打散，%bias_set @ALIGN("x") 会把集合算作一个成员，什么也不对齐；{%bias_set} @ALIGN("x") 会打散它，对齐 R1–R3；{{%bias_set}} @ALIGN("x") 又把它整个保留。

• 集合的内容在用到它的阶段求出，与选择一样：初始内容和各条增删语句里的选择，都按这个阶段开始之前的状态求值，增删按写的次序（它们的位置，8.5）处理。所以写在前面的使用也看到全部增删（1.5 第 1 条）；同一个集合在不同阶段可以不同：生成对象的规则看到的不含生成的对象，样式规则看到的含（8.2）。

  注：内容不在某一步一次算完，因为那样给选择起个名字就会改变结果：%g_set = # @SELECT-USAGE $GROUND; %g_set @SET-STYLE $grey 会选不到生成的地，而不起名的同一个选择选得到；名字只是引用对象的另一种写法（1.5 第 5 条）。

5.3 语句与签名

• 语句由至多一个关键字、若干对象和一组参数组成。

• 每个关键字有签名，声明：

  • 对象的个数，每个对象槽位的名字和它收的种类。AS、ATTACH 的个数是定义的角色表的长度，再加定义本身（AS 写在最后，ATTACH 写在最前），种类是角色声明的种类（9.4）；
  • 参数：名字、类型、是否必需、可选值，以及按位置写时的顺序；
  • 输出：新对象、输入的句柄、子对象、定义，或没有句柄；WIRE 收到网络时给出新导线，收到导线时给出这条导线（13.1）；
  • 每个输入的消费方式（5.4），以及对失效严格还是容错（7.3）；
  • 关键字能写在哪里（见下面的标准词表）。

• 对象个数固定，个数不定的用集合。没有可选槽位，例外是：AS、ATTACH 没填的集合角色是空集合（9.4）；SELECT-USAGE 的定义可以省略（10.1）；USE-PACKAGE 的体可以省略（16.2）。定义也占一个槽位。

• 对象按角色或按顺序对到槽位，全标或全不标；同一个角色只能标一次。管道送来的对象算第一个对象；AS、ATTACH 按角色配它，它不占定义的槽位（5.5）。对象怎样对到槽位，见 5.2.1。

• 不论什么关键字，语句里写出的对象都能标角色。角色名就是签名里的槽位名：#M5:3(to) #M1:3(from) @DISTANCE("x", min=1) 与按顺序写的 #M1:3 #M5:3 @DISTANCE("x", min=1) 相同。角色名不是这个关键字的槽位名时，这条语句失效，不会被忽略（原则 2.3、2.8）。只有一个槽位的关键字，对象也能标角色，但标了不增加什么。

• AS、ATTACH 的参数是定义的参数表里的参数（9.4），另有一个标准参数 priority（14.8）；定义的参数不能叫 priority。

• 标准词表：每个语言版本发布一份机器可读的标准词表，是标准的一部分。各关键字收什么、有哪些参数只写在表里，正文写它们的含义。附录 A 由表生成，两者矛盾算勘误。解释器的检查、文档、编辑器的补全、一致性测试的骨架、给 LLM 的写作参考都从表生成。0.3 版的表发布为 rnl-words-0.3.json。

  • 表里收全部标准词：关键字及其签名、槽位名、参数名和取值、记录头的字段、种类名、子对象名、${…} 读的属性名、样式属性，以及 true、false。代称（16.5）是给表里的词声明的，版本检查和"最接近的名字"都查这张表。
  • 表是 JSON 文件，JSON Schema rnl-words.schema.json 说明表本身的结构。读写它的是工具和标准的维护者，不是描述电路的人。每个词带 since，即加它的版本；预留的词标出来（0.3 版没有预留的关键字）。文件声明的版本里还没有的词，按不认识的词处理，诊断说明要哪个版本（16.1）。
  • 表里为每个关键字写：
    • 每个槽位：名字、收哪些种类、要单个对象还是要集合（5.2.1）、消费方式（5.4，严格或容错由它决定，7.3）；定义的槽位；AS、ATTACH 的槽位按定义的角色表；
    • 每个参数：名字；类型（数、字符串、真假值，或数组及元素的类型；取值固定的列出取值）；必需与否；默认值；能按位置写的参数的次序（其余的只能写名字）；以及组合条件，如 PLACE 的 x、y 至少写一个，RECTANGLE 的中心写法和对角写法只能写一种；
    • 输出：新对象及其种类、沿用输入、沿用目标（ADD-TO）、定义、子对象（写了 key= 的 TEXT），或没有；WIRE 另记它收到哪种对象时改写这个对象（13.1）；
    • 能写在哪里：层里；只在符号体里（PIN）；只在头段记录里（如 VERSION、ALIAS、DEVICE）；只在包文件的头段记录里（PACKAGE）；
    • 事实怎样覆盖（5.8）：按键覆盖，及其键；按几何事实（8.5）；按外观队列（8.3）；或累加；
    • 标准写法和标准例句（4.3、4.5、附录 B）；
    • 一句说明和正文的节号。
  • 不进表的：含义（关键字产生什么事实、在哪个阶段、怎样冲突）写在正文。包里普通定义的签名就是它的角色表和参数表（9.4）。

  {
   "keyword": "PLACE",
   "since": "0.2",
   "group": "Placement and appearance",
   "summary": "Puts the origin of an object at a point; one axis is enough.",
   "section": "11.1",
   "where": [
    "level",
    "symbol"
   ],
   "slots": [
    {
     "name": "target",
     "takes": "one",
     "kinds": [
      "instance",
      "usage",
      "bundle",
      "point",
      "text",
      "position"
     ],
     "mode": "absorb"
    }
   ],
   "params": [
    {
     "name": "x",
     "type": "number",
     "since": "0.2"
    },
    {
     "name": "y",
     "type": "number",
     "since": "0.2"
    },
    {
     "name": "priority",
     "type": "enum",
     "values": [
      "disabled",
      "low",
      "normal",
      "high"
     ],
     "since": "0.2"
    }
   ],
   "positional": [
    "x",
    "y"
   ],
   "at_least_one": [
    "x",
    "y"
   ],
   "output": "same",
   "override": "geometry",
   "key": "object and axis",
   "form": "{target} @PLACE(x, y)",
   "sentence": "#M1 is at @PLACE(10, 20)"
  }

• 内置关键字的槽位名：每个槽位都有名字，就是能标的角色名。槽位名是标准词，与关键字一样随版本，改名就是不兼容的改动；同一关键字的各槽位不重名。定义的槽位也有名字，表里、诊断里用，但不能标（4.2 第 7 条）。种类名只有一套，签名和定义的角色声明（9.4）共用：instance、terminal、net、point、wire、usage、bundle、text、annotation、label（附录 A）。

5.4 消费方式

• 一个成员的产物是它各段、各嵌套集合产生的全部事实，不只是最后的句柄。它们随所在的顶层成员一起提交。
• 记录里的每条语句都提交，有没有名字都一样。提交后起什么作用，看对象是什么：场景里的描述画出来或参与求解；定义可以被使用，本身不画；引用和只由引用组成的集合不起作用。普通 {…} 里的语句随所在的成员提交，所以 { @LINE {…}} 的线会画出来（13.4）。
• 定义体里的语句不提交，只成为定义的内容。普通定义在套用时才展开（9.4）。
• 带体的 USE-PACKAGE 也按封装方式收体：体里的语句是包的内容，不提交到本层。包里的名字怎样可见，见 16.2。

5.5 管道与嵌套

• a => @K(…) 把 a 的结果作为 K 的第一个对象；AS、ATTACH 把它填进第一个角色，不填进定义的槽位。结果是集合也只算一个对象（5.2.1）。=> 后面的段只能按位置收这个对象，不能给它标角色。
• 管道不是逐步执行的，而是展开成用句柄连起来的几条描述：每一段描述的是前一段结果的句柄；逐个成员做的一段展开成多条平行的描述（1.5 第 1 条）。
• 各段的先后。每一段有自己的位置；凡是书写位置起作用的地方（1.5 第 2 条），后面的段都算比前面的段后写：按键覆盖（8.4）、外观队列（8.3）、取舍次序（8.5）、绘制顺序（11.6），以及导线的改写（13.1）。所以在 #M1 @SET-SYMBOL $A => @SET-SYMBOL $B 里，M1 用 $B 画。
• 失效只波及依赖它的描述。 一条描述失效，只有两种原因：它自己读不懂或自相矛盾；或者它要用的句柄本该由一条失效的描述创建。
  • $GROUND @ATTACH &vss => @PLACE("20", 38) => @ORIENT("R90") => %g1 里只有 PLACE 失效（PLACE 要数的地方写了字符串，5.3）；地照样创建，ORIENT 照样生效。
  • #XI0<3:0> @BUNDLE(bad=1) => @PLACE(10, 20) => %s 里叠画没建成（BUNDLE 没有参数 bad），PLACE 没有要描述的对象，也跟着失效。
• 名字绑定什么：写在开头的 %x = 绑定整条管道最后的句柄；=> %x 绑定它左边那一段的结果，写在末尾就是最后的句柄，写在中间就是那一段的结果，如 #M1 @AS $A => %a => @AS $B => %b。PLACE、ORIENT、SET-SYMBOL、SET-STYLE、GROUP 沿用输入的句柄，所以 $GROUND @ATTACH &vss => @PLACE(24, 38) => %g0 里的名字 %g0 是这次套用的用例，也就是这个地。AS、ATTACH 产生新句柄：#M1 @AS $A => @AS $B 的第二段把 $B 套用到第一段产生的用例上（嵌套），不是 M1。要给 M1 套用两个定义，写成两条语句。名字左边那一段失效时：它本来沿用输入的句柄，名字仍指这个句柄（上例的 %g1 是那个地）；它本来要创建新对象，名字指失效对象（上例的 %s）。
• 对象可以写成一个集合，集合里是语句（嵌套）。嵌套集合里绑定的名字只在该集合内有效。嵌套的语句各是一条描述：{%a = #M1 @PLACE(1, 2); #M9} @ALIGN("y") 在宿主没有 M9 时 ALIGN 失效，M1 的坐标照常生效。
• 标准写法是平铺的：给对象起名，再在别的语句里引用它。单条语句在开头写 %x = 起名，管道用 => %x（4.3）。

5.6 定义作为对象

用到定义的关键字把定义作为它的一个对象，定义在哪个槽位由关键字定：ATTACH 的定义是写出的第一个对象；SET-SYMBOL、SET-STYLE、AS、SELECT-USAGE、SELECT-ANCESTOR-USAGE 的定义是最后一个对象，SELECT-USAGE 的可以省略（10.1）。

%ax = (_, _);
%w13 = &x @WIRE {#M1:1 #M3:1};
#M1 @SET-SYMBOL $NMOS;
%w13 @SET-STYLE $signal;
#M1(a) #M2(b) %ax(axis) @AS $MIRRORED;
$GROUND @ATTACH &vss;
# @SELECT-USAGE $GROUND => @SET-SYMBOL $GROUND_SYMBOL

• 定义不标角色，也不计入"全标或全不标"。定义也是对象、占一个槽位，所以 {#M1 #M2} @SET-SYMBOL $X 是两个对象（5.2.1）。
• 定义的槽位由关键字固定，所以解析语句时不用知道一个 $ 名字指的是定义还是集合：$GROUND_STUB @ATTACH $GROUND_FILL_SET 里前一个是定义，后一个是集合。
• 定义不能经管道送入：送来的对象填第一个槽位，AS、ATTACH 按角色配它，不占定义的槽位（5.5）。所以 $GROUND @ATTACH &vss 不能写成 $GROUND => @ATTACH &vss。
• 定义可以是嵌套的匿名定义：#M1 @SET-SYMBOL { @DEFINE-SYMBOL {…}}。
• 普通定义可能写在后面或别的层里，所以 AS、ATTACH 的对象个数、角色名和参数在本层生效时核对（7.1）。

5.7 句柄与名字

• 宿主对象的句柄由宿主给出：元件名、网络名。端子是元件加端子序号，所以 #M1:1 与 #M1:d 是同一个端子。
• RNL 创建的东西，句柄由创建它的语句产生。别的语句只能通过名字引用它：名字是找到它的唯一办法；例外是求解器的记录，它用编号引用没有名字的对象（5.9）。除此以外，没有名字的对象只能在它自己的语句里使用（管道、嵌套）。
• 一个名字不会指两个东西：同一层里只绑定一次（6.6）。
• 子对象的句柄是父对象和它的名字，不必另起名字。
• 普通定义展开出的局部对象，句柄是用例和局部名，从外面写作 %c1::mid（9.4）。没有名字的用例，它的局部对象只在诊断里按位置显示；只有求解器的记录能经用例的编号引用它们，如 %#5::mid（5.9）。
• 生成集里的单个对象没有名字，不能单独引用：不按种类和关联的对象认对象（没有自然键），集合也不提供按下标引用。

5.8 事实的键

• 有键的事实按键覆盖：同一个键，后写的生效；后写的失效时，保留较早的有效值。
• 几何事实例外：PLACE 的 x、y（每个坐标一个键）和 ORIENT（每个对象一个键）。同一个键写了两个不同的值就是冲突，按 8.5 取舍：优先级相同时保留后写的，与按键覆盖结果相同；优先级不同时保留高的。PLACE 只改它写出的坐标，从没写过的坐标是自由的。
• 用已经绑定的名字再创建对象，不是按键覆盖：名字同一层只绑定一次（6.6）。要改 RNL 创建的对象，写修改它的语句，如 %g0 @PLACE(40, 38)。
• 没有键的事实累加：不冲突的并存，冲突的按 8.5 取舍。
• SET-SYMBOL、SET-STYLE 不按键覆盖，按外观队列生效（8.3）。
• VERSION 只在头段记录里写一次（16.1），所以谈不上覆盖。
• CURRENT 每个端子一个键（15.2），LAYER 每个对象一个键（11.6）。
• 用例没有键：一个定义套用几次就是几个用例，互不覆盖。两句相同的套用产生两个用例，所以 $GROUND @ATTACH &vss 写两次就画两个地。对一个用例写的修改语句（如 PLACE），其事实是有键的，照上面的规则处理。
• 对象的优先级是一条有键的事实；优先级之间按什么次序覆盖，见 14.8。
• 写了引用名（key=）的 TEXT，每个附着对象、每个引用名是一段文字，后写的按项覆盖它（13.3）。没写引用名的 TEXT 不按键覆盖：每写一次就多一段文字（13.3）。
• 导线没有键：写两次就是两条导线（13.1）。WIRE 收到导线时改写它；改写有键，键是这条导线，后写的改写换掉先写的（13.1）。
• 约束没有键。要改一条约束，就把它关掉（"disabled"，14.8）再写新的，或者直接改文本。

5.9 没有名字的对象的编号

* @RNL(type="header") { @VERSION("0.3")}
.model nch nmos level=1
.subckt amp in out vdd vss
M1 out in vss vss nch
R1 vdd out 10k
* @RNL {
*   #M1 #R1 @ALIGN("x");
*   &out @WIRE {#M1:1 (_, _) #R1:2};         /* %#1: the wire; %#2: the free point */
*   {#M1 #R1} @TEXT("${name}")               /* %#3: the label of M1; %#4: that of R1 */
* }
* @RNL(type="generated", priority="high", author="rnl-solver 0.1", hash="sig1:…", numbering="…") {
*   #M1 @PLACE(10, 0); #R1 @PLACE(10, 8);
*   %#2 @PLACE(12, 4);
*   %#1 @WIRE(mode="straight") {#M1:1 (12, 2) %#2 (12, 6) #R1:2};
*   %#3 @PLACE(13, 1); %#4 @PLACE(13, 9)
* }
.ends amp

• 求解器的记录用编号引用经名字找不到的对象，以便写回它的每个决定（14.8）。编号写作 %# 加一个无符号整数，如 %#3，用法同名字：%#5:p 是用例 %#5 的端子，%#5::mid 是它的一个局部对象。编号只用来引用它的对象，不像名字那样绑定，所以 %#3 = … 和 => %#3 是语法错误（4.1）。

• 哪些对象：没有自己的名字、也不能经 :: 从有名字或有编号的对象找到的点、导线、标签、叠画、标注和用例（6.5、9.4）。只在嵌套集合里绑定的名字（6.7）不算，因为求解器的记录用不了它。对求解器的一条记录，这些对象依次是：

  1. 本层作者记录（type="authored"，2.8）的成员产生的，以及这些成员产生的用例的定义体里产生的。它们按求解器看到的那样数，即不带 type="generated" 的记录来解释这一层（2.8）；带上这些记录解释时，编号不变；
  2. 这条记录自己的成员产生的，以及它们产生的用例的定义体里产生的。它们按记录写出的文本数，当作其中的编号都能解析；下面的校验值对不对得上，不改变它们。

  约束和集合不编号。规则逐个生成的对象（10.5）也不编号：求解器把它们写成显式语句，落在第 2 项里。求解器的每条记录各有自己的编号：第 1 项对每条记录都一样，第 2 项只数这条记录自己的成员。

• 次序：作者记录按 2.6 的次序取：本层自己的文本，再是从外面用 scope 写进本层的记录。一个成员里，按产生对象的记号的先后编号：点是它的 (，其余对象是关键字。一个记号为集合的每个成员各产生一个对象时（5.2.1），每个对象各有一个编号，按集合成员的次序。用例定义体里的对象紧接在用例之后编号，按定义体的次序，嵌套的用例照此一层层往下。编号从 1 起。

• 写在哪：编号只能写在 type="generated"、带字段 numbering、不带 scope 的记录里（2.6、2.8）。写在别处是错误：作者记录用名字引用对象。在它所在的记录里，编号可以用在产生其对象的成员之前，名字也是这样（6.7）。

• 校验值：numbering 是编号对象来历的校验值。按编号的次序，每个编号一行：

  • 产生这个对象的那个成员（记录或定义体里的成员，连同它的各段，4.1）的记号，去掉自由文本和注释，记号之间隔一个空格。这里的记号指词法单位：关键字；引用，连同它的端子、子对象和下标，中间不留空白；照原样写的字符串或数；名字；_；以及 { } ( ) [ ] , = ; => 中的一个。所以 &out @WIRE {#M1:1 (_, _) #R1:2} 写成 &out @WIRE { #M1:1 ( _ , _ ) #R1:2 }；
  • 对象在用例的定义体里时，先写这个用例的那一行（用例本身有没有编号，都照样写），再接一个制表符和定义体里那个成员的记号，照定义里的写法；
  • 那个记号为集合的每个成员各产生一个对象时，后面接一个制表符和这个成员的句柄，写成引用：宿主元件或网络写名字；端子写元件和端子号，如 #M1:1；对象的位置或某个键上的文字，写对象后接 ::position，或 :: 和键；RNL 对象写本层绑定给它的 % 名字，有几个时取按 2.6 的次序最先绑定的那个，不管集合里写的是哪个名字；没有这样的名字的对象写编号，或作为用例的局部对象，写用例的引用（照这几条写）、:: 和局部名字：有几个局部名字时，取定义体里最先绑定的那个，同一个成员里也一样（%p = (0, 0) => %q 里取 p），不管集合里写的是哪个名字；几个用例都把它当作局部对象时，经最先套用的那个用例写。名字只由 ASCII 字母、数字和 _ 组成时照写，否则写在双引号里，" 写两个（3.6）。例如在 %p = (0, 0); %q = %p; %s = {%q} 之后，%s @TEXT("x") 产生的标注那一行是 %s @TEXT ( "x" )、一个制表符和 %p，校验值是 675df5171032726d。用 $D = @DEFINE(roles=["x"]) { %p = (0, 0) => %q }; %u = #M1 @AS $D; %s = {%u::q} 时，%s @TEXT("x") 那一行末尾是一个制表符和 %u::p，校验值是 a8c9571193175903。

  校验值是这些行（每行以换行符结束）的 UTF-8 文本的 SHA-256 的前 16 位十六进制，小写。

• 一条记录的校验值与本层对不上时，记录里用到编号的语句都不生效；有这样的语句时，整条记录给一个提示：求解结果对没有名字的对象已经过时。不用编号的记录可以不写 numbering。记录里的其他语句照常生效（第 17 章）。编号超过最后一个编号对象是错误。

• 例子里，校验值对六个编号各有一行：WIRE 那个成员两行（先是导线，再是点），TEXT 那个成员两行，后面分别接 #M1 和 #R1；改写导线的 WIRE 里写成坐标的两个点是这条记录自己的对象，编号 5 和 6，再占两行。不求解的查看器照求解器选定的样子画出自由点、导线的走法和两个标签。

• 改写成 {#R1 #M1}，标签 3、4 就对调了：校验值对不上，用到编号的语句在这一层重新求解之前都不生效，M1、R1 的位置照旧。改动 ALIGN，或移动 M1，编号都不变。

• 注：校验值只看编号对象是怎样产生的。移动器件、改不产生无名对象的语句，编号都不变；增、删、改、调换产生这类对象的成员，编号就过时，直到这一层重新求解。求解器的记录一般不含改集合或定义的语句；不论有没有，第 1 项都不带这些记录来数。

6.1 层级

• 层级按文字的包含关系。 一个层的 RNL 作用于本层，以及它在文字上包含的各层；谁实例化谁不起作用。

  • 文件包含它定义的子电路和它 include 的文件。
  • 写在子电路里的 .include，和嵌套在子电路里的 .subckt 定义（SPICE3、ngspice 的局部定义），挂在那个子电路下面。

• 从上往下，到一个子电路的层级链是：根上的包（标准包，以及头段记录里 USE-PACKAGE 的包，16.3）→ 主文件的文件层 → ……（逐级 include 的文件）→ 定义这个子电路的文件 → 子电路自己。例如：

  packages at the root (the standard package)
  └─ file level of tb.sp (the top level)
     ├─ load                    a subcircuit defined in tb.sp
     ├─ file level of ota.sp    a file included by tb.sp
     │  ├─ ota                  ota instantiates cell
     │  └─ cell
     └─ file level of bias.sp
        └─ bias                 also instantiates cell, but neither the RNL of bias.sp nor that of bias reaches cell

• 子电路的 RNL 只管它自己。 取舍时它的语句排在各文件层的内容之后，因而优先于它们（8.5）；但不传给它实例化的子电路，嵌套定义在它里面的除外。amp 实例化了 cell，amp 的定义和规则到不了 cell。

• 被 include 的文件影响不到 include 它的层。 它的文件层的定义、规则、USE-PACKAGE 只作用于它的子电路和它再 include 的文件。从网表看，它写在子电路之外的器件属于 include 它的那一层，但它的 RNL 改不到这些器件。所以一个文件不会被它 include 的文件改动。

• 被 include 的文件的文件层没有自己的电路。 只有主文件的文件层是电路。被 include 的文件在文件层写的宿主引用（#M1、&vss）失效（6.3），在那里起作用的只有定义、规则、USE-PACKAGE 和 scope。单独打开的文件就是主文件。

• 被 include 的文件继承 include 它的层。 主文件的风格（它的规则和 USE-PACKAGE 的包）一直传到库文件的子电路里。所以同一个库文件在不同的主文件下，或单独打开时，可能画得不同，而它的求解结果只存一份（第 17 章）。要让库里用到的符号不受上层外观规则的影响，在库文件或子电路里用 USE-PACKAGE 再用一次标准包（16.2）。只想钉住标准包的版本、仍让上层的风格盖过它，就把 USE-PACKAGE 写在库文件的头段记录里（16.3）。主文件里只该作用于顶层的规则，写 recursive=false（10.1）。

• 一个子电路一张图。 查看器不展开子电路：子电路的元件总是用它的符号画，子电路内部单独画、单独求解。每个子电路只有一条上层链，所以一份文档里每个子电路恰好一张图。

• 包。 @USE-PACKAGE 写在哪层，包的 $ 定义和规则就在那层及以下生效（16.2）。标准包隐式用在根上，头段记录里 USE-PACKAGE 的包也放在根上（16.3）。include 把文件放在本层下面，文件继承本层；USE-PACKAGE 把包放在本层上面，本层继承包。

• 规则按定义对待。 写在某层的规则在该层和下面每一层各求一次，每次只看那一层（10.4）。选择加 recursive=false 就只在写规则的那一层选，规则实际上只作用于这一层。这正是原则 2.5 对定义的要求：定义能把自己的生效范围限定在当前层，或让下层继承，未限定时默认继承。原则 2.5 说只属于所在层的描述，指逐个对象写的语句，它们的宿主引用本来就只在本层解析。

6.2 前缀

$X 与 %X 是两个不同的名字。

6.3 宿主引用

• #M1、&vss 只在本层的宿主里解析，不跨层（原则 2.5）。不同子电路里的同名元件互不相关。
• 找不到的宿主引用失效（原则 2.4）。被 include 的文件的文件层没有自己的电路，所以那里的宿主引用都失效（6.1）。
• 名字后面可以紧跟下标，表示一个或一组宿主名字，如 &D<3>、#XI0<3:0>（6.11）。
• 某一层有哪些网络，由宿主适配器按宿主的语义决定：
  • 局部网络：这一层的网表行用到的结点，含端口。
  • 全局网络：0 在各种 SPICE 方言里都是全局地。仿真器自己认的地的别名（如 ngspice 的 gnd，HSPICE 的 GND、GND!、!GND、GROUND）由这种方言的适配器并到 0；并入后 &gnd 与 &0 是同一个句柄。.GLOBAL vdd（Spectre 写 global vdd）声明的名字，在任何子电路里都是同一个结点。名字以 ! 结尾（如 vdd!）是 Virtuoso 原理图的习惯，起作用的是声明。
  • 全局网络在用到它的每一层各有一个句柄，即这一层里的那一份；网表行没有用到它的层没有这一份。所以 &0 指写它的那一层的那一份：每张图各画各的，事实属于那一层，下层的描述改不到上层。
  • 要指每一层里的那个全局网络，在上层按名字选，加条件 global=true（10.1）。

6.4 端子

• object:terminal 是端子：#M1:1、#M1:d、#XU1:inp、%g0:p。#:inp 是本层的端口 inp。
• 数字是宿主的端子序号，从 1 起。
• 名字是宿主的端子名：头段记录里 @DEVICE 给的名字（6.12），或子电路的端口名。不能不加引号写的名字（3.6）要加引号，如 #XU1:"in+"。端子名、端口名后面可以紧跟下标，如 #X1:D<7:0>、#:D<7:0>（6.11）。
• 大小写：子电路的端口名和 DEVICE 给的端子名都按宿主的规则：SPICE 不分大小写，#M1:D 也行；Spectre 区分。用例的端子名是它的定义的角色表里的名字，按 RNL 名字的规则（3.6）。
• 引脚的 label= 只用于显示，不能用来引用端子：端子属于网表，引用端子不取决于用的是哪个符号。
• 用例的端子就是它的定义的角色，按角色表的顺序编号；集合角色不是端子（9.4）。只有带符号的用例，它的端子才有引脚、能接导线（第 12 章）。
• 找不到的端子失效。端子在符号里有没有引脚，在定了符号之后检查（7.1）。
• 除了子电路的端口名，端子名由 DEVICE 给出；SPICE 系的标准名字见 6.12。
• 网表里没有定义的子电路（如 XM1 … sky130_fd_pr__nfet_01v8 里的 PDK 器件），只有用户在头段记录里用 DEVICE 给出端子名（6.12），或用了写有 DEVICE 语句的包（16.2）时，才有端子名；否则只能写序号。

6.5 子对象

• object::name 是子对象。它总是对象，不是数值。它的句柄是父对象和名字。
• 子对象有：
  • 文字的引用名：写了 key= 的 TEXT 在它附着的对象上产生的子对象，如 #M1::wl。符号里写了引用名的文字，是用这个符号画出的每个对象的子对象（13.3）。::name、::value 不是标准子对象，只是常用的引用名（13.3）。
  • ::position：对象的原点。#M1::position @PLACE(…) 等于 #M1 @PLACE(…)。对画出来的用例，它是画这个用例的那个点：主对象有坐标点时就是那个点，否则是用例自己的原点（12.1）。对 TEXT，它是文字自己的位置（13.3）；对中心写法的 RECTANGLE、CIRCLE、ELLIPSE，它是中心（13.4）。
  • 端子的 ::net：它所在的网络，如 #M5:1::net 就是 &tail。叠画的端子见 11.8：成员接在不同网络上时，是这些网络的集合。
  • 用例的角色名：填进这个角色的对象，如 %dp1::in_p 是 M1，%g0::p 是网络 vss。集合角色取到的是那个集合。
  • 用例体里起了名的局部对象，如 %c1::mid（9.4）。
  • 集合的 ::position：成员所占范围的中点，按每个成员的那一点（原点、引脚或点）算；嵌套的集合一直取到最里层的对象，与符号无关。%pair_set::position @PLACE(10, 20) 把 pair_set 的中心放在 (10, 20)。集合的范围没有子对象：要让两组分开，写 DISTANCE（14.5）；要把一组作为约束的一个成员，写成 {%x}（14.1）。
• 标准子对象名保留：普通定义的角色名、参数名、局部名，以及文字的引用名，都不能与它们相同（按原样比较，3.6）。局部名不能与角色名相同，文字的引用名也不能与它所附着的用例的角色名、局部名相同。局部名可以与参数名相同：参数是值，:: 不取值。定义的参数也不能叫 priority（14.8）。
• :: 后面的名字按这个次序找：用例自己的角色名和局部名；它们的 definition= 代称；标准子对象名和它们的代称；文字的引用名（代称见 16.5）。
  • 引用名排在最后，所以不能与排在它前面的名字拼写相同：标准子对象名和本文件声明的它们的代称（如 rnl-zh 的 "位置"）、用例的角色名和局部名，以及这些名字的 definition= 代称。这样的引用名是错误，与上面的重名一样（13.3）。
• :: 只取对象自己的部分；在场景里按条件找对象，一律用选择关键字。所以"某个定义的全部用例"写成选择（10.1），不写成定义的子对象。要用例成员的范围，就给成员的集合起名。
• 端子用 :、子对象用 ::，免得以后的版本新增的子对象名与网表的端口名冲突。
• 子对象名：标准子对象名有两个，position 和 net，都保留。其余子对象名都是动态的：文字的引用名、用例的角色名、定义体里的局部名。以后的版本新增的标准子对象名按版本区分（16.1）：旧版本的文件里，同名的引用名照旧有效。

6.6 命名

• %name = statement、$name = statement 给语句的结果起名；管道里 => %name、=> $name 给它们左边那一段的结果起名（5.5）。名字只是引用对象的另一种写法，不产生对象。
• $name 绑定定义或集合，含选择的结果。$ 集合在某层求值时只含这一层的成员（10.3）。其他场景对象属于某一层，不能有 $ 名字。
• %name 可以绑定本层的任何对象：本条语句创建的对象、已有的对象（%tail = #M5）、集合（%pair_set = {#M1 #M2}），或只在本层用的定义。
• 同一层里一个名字只绑定一次。 再绑定同一个对象可以，如 %x = #M1 写两次；绑定别的对象是错误，名字保留第一个有效的绑定。只有全部绑定都失效时，名字才绑定到失效对象（7.2）。创建对象的语句、定义、集合、选择的结果都一样。
• 覆盖针对事实，不针对名字：要改 RNL 创建的对象，写修改它的语句，如 %g0 @PLACE(40, 38)（5.8）。

6.7 名字的范围

• @RNL 提交的名字发布到本层：本层的所有记录共享，名字可以在绑定它的语句之前使用（原则 2.9）。
• 嵌套集合里绑定的名字只在该集合内有效。
• 定义体里绑定的名字是体内局部的（6.9）。

6.8 继承与遮蔽

• $ 定义沿层级（6.1）向下继承，绝不向上：进本文件的子电路，也进被 include 的文件。一个层看不到它 include 的文件里的 $ 定义；要给上层提供定义，做成包，用 USE-PACKAGE 使用（16.2）。子电路符号是唯一向上的例外（9.2.6）。
• 下层定义了与继承来的同名的 $X，就在这一层及其下层遮蔽继承来的定义，并给提示；上层看到的仍是自己的。
• 一层里 USE-PACKAGE 的包，它的 $ 定义算作这一层上面的一层（16.2）。它们遮蔽上面各层或根上的包的定义时，与任何遮蔽一样给提示。头段记录里使用的包定义了标准包里的名字，或排在它前面、放在根上的包里的名字时，也给提示（16.3）。
• % 名字只在本层有效，不继承：不进本文件的子电路，也不跨 include。包里的 % 定义是包内私有的辅助定义。

6.9 定义体里的名字

• 定义体里的名字在写定义的地方解析，套用处不重新解析。
• 所以遮蔽一个定义只改变这个名字指什么：别的定义内部已经用到的定义不变。例如在下层遮蔽 $DIFFERENTIAL_PAIR，不会改变上层写的定义体内用到的差分对。
• 体内的 %name 先在体内的局部名里找，再在本层的定义里找。本层的场景对象（点、导线等）不能从体内引用，这样的引用是错误。
• 体内的写法：角色和参数写 ?name。局部名用 %name =（管道里用 => %name）绑定，用 %name 引用。从外面经用例引用局部名（9.4）。
• 定义体看不到正在定义的名字：$NMOS = @DEFINE-SYMBOL {$NMOS; …} 里，体内的 $NMOS 是外面（上层或包里）这个名字的定义。下层就是这样遮蔽并扩展上层定义的；外面没有这样的定义时是错误。
• DEFINE-SYMBOL、DEFINE 体里的宿主引用是错误：#M1、&vss、#:inp、#M1:d 和单独的 # 都不能写在那里。体里的名字在写定义的地方解析，普通定义却会在别的层、别的文件里套用，在那里宿主引用仍会指到定义所在的那一层，含义不唯一。普通定义要用宿主对象，经角色传进来。
• 普通定义的体什么时候检查：
  • 按定义查一次：不依赖实参的都在这时查，包括关键字、签名（对象个数、参数名和类型）、$ 和 % 名字（在写定义的地方解析）、宿主引用、局部名的撞名（9.4），以及声明了种类的角色用得对不对：角色 t 声明为 "instance" 时，体里写 ?t::net 是错误。签名在读入时查（7.1）；名字要整层读完才能解析，所以要用到名字的检查在本层生效时做。两者每个定义都只做一次，与套用几次无关。
  • 按套用查：依赖实参的，如没声明种类的角色收到的对象、符号里有没有那个引脚，每次套用时查，报在套用处，并指出普通定义里的原句。
  • 错误的范围：体里查出错的语句（含撞名的局部名）在定义处报一次，每次展开都不含它，体的其余部分照常（体是容错的，9.1）。角色表、参数表写错（重名、与标准子对象名撞名、不认识的种类名），整个普通定义失效，用到它的套用也都随之失效。
  • 从没被套用的普通定义也查。这些检查与套用无关，所以能查出包里没用到的定义的错误。

6.10 空位

• ?name 只出现在普通定义的体里，名字应在角色表或参数表里；否则读入时就是错误。
• 写在对象的位置是角色，如 ?t、?t::net；写在字面量的位置是参数，如 min=?gap、[?w, 2]、(?x, 0)（9.4）。角色写在字面量的位置，或参数写在对象的位置，读入时就是错误。角色名和参数名在同一张表里，不能重名。
• 角色的空位可以带路径，如 ?t::net；参数的空位不带路径。

6.11 下标

• 网表里没有总线：Virtuoso 等工具出网表时把总线拆成单个的位，如 Spectre 网表里的 D\<3\>；子电路的总线端口、叠合元件也拆开。下标是写一个或一组这类名字的简写。它只是拼名字，不靠宿主认总线，所以含义唯一。
• 写法：宿主名字（加不加引号都行）后面紧跟 <…> 或 […]，里面是用 , 分开的若干项。每项是 i、a:b 或 a:b:s，几种可以混写。i、a、b、s 都是不带符号的十进制整数，s 至少为 1。名字与括号之间没有空白；括号里可以有空白和注释（3.5）。
• 展开：各项按写的次序展开、拼接，重复的照留。a:b 从 a 到 b，a:b:s 每次走 s，不越过 b：<7:0> 是 7、6、…、0，<0:7:2> 是 0、2、4、6。步长写在最后，与 Virtuoso、Xschem 相同，与 MATLAB 的 a:s:b 不同。生成的名字是括号前的名字、左括号、不带前导零的十进制数和右括号，括号照写的那一种：&D<07> 是 D<7>，&D[3] 是 D[3]。
• 一个还是一组：只有一项且是单个数时，是一个引用：&D<3> 就是 &"D<3>"。否则是一组，即对一个集合的引用，如 &D<3:3>、&D<3,5>。一组放进集合时打散一层（5.2）；作语句唯一的对象时先拆一层（5.2.1），所以 #XI0<3:0> @ALIGN("y") 对齐四个元件；放在要单个对象的槽位时逐个成员做；放在 WIRE 的网络槽位时整个收下，是一根总线（13.1）。
• 用在哪里：#、& 之后的宿主名字，以及 # 引用里的端子名、端口名。RNL 名字（%、$、? 之后的）、用例的端子名（即定义的角色名）和子对象名不收下标，后面紧跟 <、[ 是错误。
• 名字后面不能直接写点：名字后紧跟的 <、[ 一律开始一个下标，后面不合写法就是语法错误，不会读成点。要在名字后面写点，就隔开，如 &D (1, 2)。
• 一处展开：一个名字后面至多一个下标，所以 A<1>[2] 这样的名字加引号写，&"A<1>[2]"。一个引用里至多一处下标展开成一组：#XI0<3:0>:a、#X1:D<7:0> 可以，#XI0<1:0>:D<1:0> 是错误；两处都是单个数的可以，如 #XI0<3>:D<1>。展开成一组的引用后面接 :: 时，对每个成员各取子对象，如 #XI0<3:0>::name。
• 引号里的不解析：&"D<7:0>" 指名字就叫 D<7:0> 的结点；&"D"<7:0> 才展开。网表里的名字含有不表示总线位的 <、[ 时，加引号照原样引用。
• 比的是适配器读出的名字（3.6）：Spectre 网表里的 D\<7\>（反斜杠是 Spectre 的转义）由适配器读成 D<7>，所以 &D<7> 能引用它。
• 每个成员各自解析。找不到的成员是失效对象，按收它的槽位的规定严格或容错处理（7.3）。
• 参数里的字符串不展开，如 PIN 的 terminal=（9.2.4）、选择的条件 name=。
• 不收：Virtuoso 的重复 <*2>A、A<0:2*2> 和并列 A,B（集合已经能写）；KiCad、Xschem 的 D[0..7]，它的成员是不带括号的 D0 … D7。
• 叠合元件（如 Virtuoso 的 I0<3:0>：几个宿主元件画成一个）写成叠画：#XI0<3:0> @BUNDLE（11.8）。

6.12 端子名：DEVICE

* sky130 transistors, defined in the PDK and not in this netlist
* @RNL(type="header") {
*   @VERSION("0.3");
*   @DEVICE(name="X*", model="sky130_fd_pr__nfet_*", terminals=["d", "g", "s", "b"]);
*   @DEVICE(name="X*", model="sky130_fd_pr__pfet_*", terminals=["d", "g", "s", "b"])
* }
XM1 out in 0 0 sky130_fd_pr__nfet_01v8 w=1 l=0.15
XM2 out in vdd vdd sky130_fd_pr__pfet_01v8 w=2 l=0.15
* @RNL { #XM1:d @CURRENT("in") /* XM1 is a sky130 NMOS; its terminal 1 is named d */}
.end

• 端子名由 RNL 起。 @DEVICE 给一类器件的端子起名：terminals 按网表行上结点的顺序列出名字。它只给宿主的端子序号起名，不改端子的顺序，也不改子电路的接口；它是原则 2.2 允许的显示别名。

• 只写在头段记录里（2.8）：DEVICE 写在别处是错误。包文件的头段记录也算（16.2）。内嵌的包里不能写 DEVICE，要写在文件的头段记录里。

• 匹配：name 比元件名，可以用通配符 *（任意多个字符）。model 可以不写；它比元件行上写的模型名或子电路名（Spectre 里是元件的 master，原生器件如 resistor），也可以用 *。两项都按宿主的大小写规则比，两项都对上，DEVICE 才与元件匹配。选择条件里比名字的条件也收 *，规则相同（10.1）。

• 几条都匹配时后写的生效：适配器的默认在最前，然后是这一层用到的包里的 DEVICE 语句（按包的排序位置，16.2），再是外层文件的头段记录里的，再是被 include 的文件的；同一条头段记录里按写的先后。所以文件自己写的盖过它的包，包盖过适配器；具体的语句建议写在通用的后面。所有包的 DEVICE 语句都排在各文件的之前，不论它们的 USE-PACKAGE 写在哪里：头段记录总在文件最前面，要是按 USE-PACKAGE 的位置排包，包反倒会盖过文件自己写的。写了 model 的 DEVICE 不算更具体，不另设特异性规则。

• 范围：文件的头段记录里的 DEVICE，作用于这个文件和它 include 的文件；被 include 的文件只能改它自己和它再 include 的文件（6.1）。包文件的头段记录里的 DEVICE，作用于用到这个包的各层（16.2）。例如一个 sky130 的包可以写 DEVICE 语句、符号和选符号的规则，用户写一条 @USE-PACKAGE(name="sky130-rnl") 就既有端子名又有符号。

• 适配器的默认：每种方言的标准元件定义，算作写在最外层。不用写进文件，工具也可以把它们写出来。同一种方言的工具应给出相同的定义。它们是元件那一行所在文件的版本的默认（16.1），与那个文件头段记录里的 DEVICE 一样。SPICE 系：

  @DEVICE(name="M*", terminals=["d", "g", "s", "b"]);
  @DEVICE(name="Q*", terminals=["c", "b", "e", "s"]);
  @DEVICE(name="J*", terminals=["d", "g", "s"]);
  @DEVICE(name="Z*", terminals=["d", "g", "s"]);
  @DEVICE(name="D*", terminals=["a", "k"]);
  @DEVICE(name="R*", terminals=["p", "n"]);             /* and one each like it for C, L, V, I, B, F, H, W */
  @DEVICE(name="E*", terminals=["p", "n", "cp", "cn"]);  /* and one each like it for G, S */
  @DEVICE(name="T*", terminals=["p1", "n1", "p2", "n2"]); /* and one like it for O */
  @DEVICE(name="U*", terminals=["a", "b", "ref"])

  Spectre 的元件名不以元件字母开头，所以默认的定义按 model，即元件的 master 来认。Spectre 的原生器件：

  @DEVICE(name="*", model="resistor", terminals=["p", "n"]);      /* and one each like it for capacitor, inductor, vsource, isource, ccvs, cccs, bsource, port */
  @DEVICE(name="*", model="diode", terminals=["a", "k"]);
  @DEVICE(name="*", model="vcvs", terminals=["p", "n", "cp", "cn"]); /* and one each like it for vccs, relay */
  @DEVICE(name="*", model="transformer", terminals=["p_plus", "p_minus", "s_plus", "s_minus"])

  • switch 每个结点一个端子，按 Spectre 给位置的编号命名：t0 是公共端，t1 到 tn 是各个掷点。
  • 模型卡的元件，master 是一条 model 语句的名字，端子名按那个模型的 master 所属的器件族取。它的类型（选择条件 type，10.1）用 SPICE 的写法：

  器件族	模型的 master	端子	类型
  MOS	bsim1、bsim2、bsim3、bsim3v3、bsim4、bsim6、bsimbulk、bsimsoi、bsimcmg、bsimimg、b3soipd、mos0、mos1、mos2、mos3、mos9、mos11、mos705、mos902、mos903、psp102、psp103、psp104、pspnqs102、pspnqs103、ekv、hisim、hisim2、hisimhv、hvmos、bta_soi、ucsd_hvmos	d g s b	nmos；模型的 type 是 p 或 pmos 时为 pmos
  双极晶体管	bjt、bjt500、bjt503、bjt504、bjt504t、bjt3500、bjt301、vbic、hicum、hicum0、hicum2、mextram	c b e s	npn；模型的 type 是 pnp 时为 pnp
  二极管	diode、juncap、juncap200	a k	d
  JFET	jfet	d g s	njf；模型的 type 是 p 或 pjf 时为 pjf
  电阻	resistor、rdiff、r3	p n	r
  电容	capacitor	p n	c
  电感	inductor	p n	l
  继电器	relay	p n cp cn	sw

• 网表里有定义的子电路（含 include、lib 进来的库文件里的）：端口名照定义，这是宿主的事实（原则 2.2）。DEVICE 不改它们；与这样的元件匹配而名字不同的 DEVICE 给警告。DEVICE 只给没有端子名的器件起名：原生器件，以及网表里没有定义的子电路（PDK 器件），后者由用户或 LLM 写 DEVICE。

• 名字的个数：元件的结点比 terminals 的名字多时，多出的端子只有序号；比它少时，引用多出的名字失效。

• 大小写：DEVICE 给的端子名按宿主的规则比（6.4）。

• 序号总能用，子电路的端口名和 #:port 也一样。

7.1 两个检查阶段

• 读入：词法；文法；内置关键字的签名，即对象个数、种类和参数（含数组的形状）；以及普通定义的体里每个 ?name 是否在它的角色表或参数表里、写的位置合不合适（6.10）。普通定义的体里不依赖实参的签名错误也在这时报（6.9）。
• 生效：
  • 整层读完后，解析名字和宿主引用，并检查名字所指对象的种类；
  • 普通定义的体里的名字按定义各解析一次，不随套用重复（6.9）；
  • 核对 AS、ATTACH 的对象个数、角色名、角色声明的种类和参数（9.4）；
  • 每次套用检查展开结果里依赖实参的部分；
  • 定了符号以后，检查导线和约束接到的端子在符号里有没有引脚，以及 PLACE、ORIENT、约束作用到的用例和导线接到的用例有没有符号；作用于画在主对象坐标点上的用例的 PLACE 和约束失效（12.1）。

7.2 失效对象

• 失效的语句产生失效对象，带有诊断：原因、位置和上游原因。
• 失效对象留在成员中的原位，其他成员也留在原位。所以宿主网表里没有 M9 时，{#M1 #M2 #M9} @ALIGN("y") 整句失效，不会变成只对齐 M1、M2。
• 名字绑定到失效对象时（包括读入时就失效的定义），引用这个名字的语句收到的也是失效对象。依赖失效描述的语句随之失效，不论先后（原则 2.9）；它们也是错误，诊断写明上游原因（7.6）。
• 名字第二次绑定别的对象是错误，名字保留第一个有效的绑定；只有全部绑定都失效时，名字才绑定到失效对象（6.6）。

7.3 严格与容错的输入

• 签名为每个输入声明严格还是容错：
  • 严格：输入里有失效对象时，整条语句失效；
  • 容错：去掉失效的成员并记录诊断，其余照常生效。
• 默认：吸收的输入严格；封装的输入（定义体）和提交的输入（@RNL）容错（5.4）。
• AS、ATTACH 的实参严格；展开出的语句容错：失效的逐条单独丢弃。
• 管道和嵌套里，失效只波及依赖它的描述（5.5）：严格的输入里有失效对象时，这条语句失效，但嵌套在里面、与失效无关的语句照常生效；语句对每个成员各做一次时，每个成员是一条描述，各自失效。

7.4 恢复

• 语法错误使它所在的成员整个失效，范围到下一个 ; 或所在集合的末尾。
• 括号不配对时，整条记录失效。
• 记录还没写完就被截断时，整条记录失效，诊断说明记录不完整（2.4）。
• 从错误中恢复，绝不超出它所在的记录：别的记录照常读（原则 2.9）。

7.5 冲突不是失效

• 冲突在整层读完后按确定的办法处理：按键覆盖（8.4）、外观队列（8.3）和几何事实的取舍（8.5）。
• 还没有确定办法的冲突，使整个解释失败（1.5 第 3 条；7.6）。本版没有这种情形：集合成环，失效的是闭合环的那条语句（5.2.2）。

7.6 诊断

• 检查与解释是同一个过程。 解释器读入输入，给出生效后的场景和一份诊断；只用来检查时也叫 lint。本标准只规定这一份诊断。编辑器为即时反馈做的局部检查（如语法高亮）不是这里说的诊断：本节不约束它们，它们也不能代替诊断。
• 条目。 失效针对一个条目：记录头的一个字段、一条语句、一条记录、一个文件，或整个解释。是哪一种，在定义各种失效的地方写明（见下面的失效范围）。
• 三级：
  • 错误：条目失效，不论原因在它自己、在别的条目，还是在它依赖的上游。错误包括原则 2.4 的基本错误（语法错误、不认识的词、签名不符、引用找不到、种类不对、自相矛盾、版本不支持）、本标准另定的失效（如没有符号的用例收到 ORIENT、端子在符号里没有引脚；12.1、9.2.4），以及随之失效的（7.2）。
  • 警告：条目合法、照常生效（本标准另有规定的除外，如没判定完而丢弃的事实，8.5），但可能不是作者想要的，如给要单个对象的槽位直接写出的空集合，像 {} @PLACE(1, 2)（5.2.1）；直接写作记录的成员、没有嵌套在语句里的无名定义（9.1）；生成规则带不到下层的角色（10.5）；记录头里不认识的字段（2.8）；包的版本被另一个替代（16.2）；导线接到的端子不在导线标的网络上（13.1）；检查没在求解器的时间上限内做完而丢弃的几何事实（8.5）。
  • 提示：常见的覆盖、遮蔽、取舍，也可能是误用，如下层或下层使用的包遮蔽上层或根上的包的定义（6.8）；后 USE-PACKAGE 的包遮蔽先 USE-PACKAGE 的（16.2）；取舍时丢弃的几何事实（8.5）；没写版本而用了包的最新版本（16.2）；没声明版本的主文件按工具的默认版本读（16.1）；编号已经过时的求解器记录（5.9）。
• 失效范围在定义各种失效的地方给出：字段（记录头认识的字段写错，按没写处理，2.8）；语句（大多数情况）；记录（括号不配对、记录被截断、scope 的目标找不到；7.4、2.4、2.6）；文件（版本不支持，16.1）；整个解释（还没有确定办法的冲突，1.5 第 3 条：整个解释停止，什么也不画；以后的版本可能把这种情况改为容错；本版没有这种情形）。
• 要求：
  • 错误必须给出。警告和提示是本标准列出的那些，建议实现给出。
  • 实现可以另加自己的检查，但只能是警告或提示；它们不应让条目失效，否则不同的实现会画出不同的结果。
  • 实现应让用户能看到诊断；怎样呈现由实现决定（原则 2.9）。
  • 实现可以更严，如停下或拒绝整份输入（原则 2.9），但不应以此为默认。它可以让用户调高、调低警告和提示的级别；错误不能调低，因为错误就是失效。
  • 一致性测试查错误（位置和失效范围）和生效后的场景；警告可以作可选的期望；提示不测。
  • 注：警告是猜作者的意图，会随经验改变，写成要求就把这些猜法冻进了标准。原则 2.4 也只要求基本错误。
• 内容：诊断给出
  • 位置：文件、行列或范围；哪条记录、哪条语句、哪个字段或引用（原则 2.8）；
  • 原因：期望什么、收到什么，如"in_p 要元件，收到的是网络"（9.4）；名字找不到时，给最接近的名字；
  • 上游原因：随之失效的语句各自写明上游原因，呈现时可以把它们收在根源下面，免得一个笔误报出全图几十条错。同一条规则在许多对象上失效时，可以合成一条诊断，列出这些对象，如包给每个 MOS 写 W/L=${w}/${l}，而有的元件没有 w；
  • 来历：普通定义展开出的语句，同时指出套用处和定义里的原句；规则产生的，指出规则和求值的那一层；包里的，指出包名、版本和文件（16.2）。
• 诊断的文字和语言不规定。本版没有标准的诊断码；实现可以给诊断编号，编号不另成容错类别。
• 包：在用了包的文档里，包内容的错误照常报告，归到包；包内容的警告和提示只在检查包本身时给。注：用户改不了包；要是照常给警告，包作者有意写的宽泛规则会让用户被警告刷屏。
• 文件不能压制诊断，也不能要求更严的模式。
• 不认识的关键字、参数和取值是错误，与语法错误一样（原则 2.3）：这条语句失效（16.4）。本版识别但不解释的内容只有记录头里不认识的字段，它只给警告（2.8）。

8.1 整层读完再生效

• 解释器解析完整的宿主网表，读入全部记录，再让每层按 8.2 的阶段生效。
• 同一层内，语句的先后只在 1.5 第 2 条说的几处起作用，不影响名字和引用的解析（原则 2.9）。
• 两层之间谁覆盖谁，按层级决定，不看文本的先后（原则 2.9；8.3）。

8.2 阶段

1. 读入：词法、文法、签名。
2. 名字与定义：解析 $ 名字、% 名字和宿主引用；求出 DEFINE-SYMBOL、DEFINE-STYLE 的定义体。
3. 创建对象：创建显式写出的场景对象（点、导线、标签、叠画、图元、约束、用例）和集合，展开普通定义的体。选择不在这里展开。
4. 符号队列：SET-SYMBOL 生效，给第 3 步的对象定符号。这个队列里规则的选择，这时才在各层求值。
5. 逐个生成：以选择的结果为对象的 AS、ATTACH，以及附着在选择结果上的 TEXT（10.5、13.3），按包、上层、本层的顺序，在每层各求一次。
6. 给生成的对象定符号：同一个符号队列再对新对象走一遍。生成看到的是生成之前的符号；展开时若给已有对象换了符号，这次生成不回头重算。
7. 几何：PLACE、ORIENT、约束按取舍次序逐条纳入，与已纳入的冲突就丢弃（8.5、14.8），然后求解。这一步要用到引脚的位置和符号的外框（9.2.3），所以放在定符号之后；作用于没有符号的用例的 PLACE、ORIENT、约束在这里失效。画在主对象坐标点上的用例（12.1），位置在这里由主对象算出，作用于它的 PLACE、约束失效。没有任何位置和约束的对象由求解器摆放，并把位置写回（14.8）。
8. 样式队列：SET-STYLE 生效，按 8.3 的两级取值。符号图元没写的样式属性和 fill= 的颜色，这时才从所属对象的样式落到具体值。
9. 渲染。

• 这些阶段就是 1.5 第 4 条说的内部顺序：一条描述读到的是它所在阶段开始之前的状态，它自己和同阶段其他描述的效果都不在内。
• 集合在用到它的阶段求值（5.2）：同一个集合，在第 5 步用到时不含生成的对象，在第 8 步用到时含。
• 选择条件只读前面阶段已定的信息：
  • 宿主信息、对象种类、用例、端子的电流方向、显式导线在第 3 步就定了；
  • 符号队列里的选择不能按对象用了哪个符号选；
  • 生成规则能看到符号。
• 端子在符号里有没有引脚，在第 6 步之后检查（7.1）。
• 求解和渲染的方法不由本标准规定，本标准只规定它们的输入（原则第 1 节）。

8.3 外观队列

• 有两个队列：符号队列收 SET-SYMBOL，样式队列收 SET-STYLE。
• 某一层的每个队列依次由下面几组组成：
  1. 根上的包的规则：标准包在最前，再是头段记录里 USE-PACKAGE 的包（16.3）；某个包在本层或上层（文件层或子电路）又用 USE-PACKAGE 使用时，它改排在那个 USE-PACKAGE 的位置（16.2）；
  2. 子电路给自己的 # 指派的符号，即子电路符号（只在符号队列；9.2.6）；
  3. 上层的规则，由外到内；
  4. 本层写的全部 SET-SYMBOL 或 SET-STYLE，包括规则和逐个对象写的语句；
  5. 外面用 scope 写进本层的 SET-SYMBOL 或 SET-STYLE，外层的在后（2.6）。
• 每组内按文本先后。别的包的内容排在它的 USE-PACKAGE 所在的位置（16.2）：在上层用到的随上层排，在本层用到的排在本层文本里 USE-PACKAGE 的位置。逐个生成产生的 SET-SYMBOL、SET-STYLE 归入生成它的规则所在的组，位置取规则的位置。
• 分两级：
  • 直接的：直接指明这个对象的 SET-SYMBOL、SET-STYLE，即输入是它的句柄、名字或指向它的 :: 路径，或是在 {…} 里把它列为成员的集合（这种集合起了名也算）。对象定义时写的样式参数（9.2.5、9.3）也算，相当于在创建它的语句处对它写了一次 SET-STYLE。
  • 传来的、选出来的：成员经选择或逐个生成收到的；所属对象传给它符号里图元的（9.2.5）；对象传给附着在它上面的文字的（11.3）；用例传给它的符号和它体里创建的可画对象的，经嵌套的用例一层层往下，但不传给填进它角色的成员（12.1 第 4 条）。传来的事实带着原语句的位置。
  • 每个属性（符号队列里就是符号）先看直接的事实，有就取位置最后的；没有再看传来的、选出来的，取位置最后的；都没有，用渲染器的默认（9.3）。位置按上面的队列次序。
  • 所以编辑器单独给某个对象改的符号、样式，不会被后写的规则盖掉；规则、包、主题照样管没有单独改过的对象。
• 记录头的 type、author 不影响先后（2.8）。
• 符号整体替换；样式按属性合并。应用一个样式，等于把它定义的每个属性各写一次，所以只定义了 linewidth 的样式只改线宽。
• 规则作用于写它的层及其下层，不作用于上层；包里的规则作用于用到这个包的所有层（10.4）。规则在每一层各求一次，只看那一层的对象；选择加 recursive=false 的规则只在写它的那一层生效（10.4）。

8.4 按键覆盖

有键的事实（5.8）按键覆盖，后写的生效（原则 2.9）。覆盖是合法的描述方式，不是错误；是否提示由实现决定。PLACE、ORIENT 是几何事实，按 8.5 取舍（5.8）。

8.5 冲突

几何事实合在一起可能没有解，即使两两之间都不矛盾，如 {#M1 #M2} @ALIGN("y")、#M1 @PLACE(y=0) 和 #M2 @PLACE(y=10)。下面的规则决定丢弃哪些事实。

• 几何事实是：四种原子约束（ALIGN、ORDER、DISTRIBUTE、DISTANCE）、朝向关系 ORIENT-RELATION（14.9）、PLACE 的每个坐标、TEXT 的 dx 和 dy（13.3；它们与 PLACE 在同一轴上互相取代，不在这里取舍），以及 ORIENT。符号（SET-SYMBOL）不在其中，它在几何之前就定了（8.2）。实现自己的准则（器件不重叠、网格等）也不在其中：它们是求解器自己的考量，排在全部语言描述之后。描述逼得器件重叠，就重叠。
• 取舍的单位：
  • 一条原子约束语句是一个单位，冲突时整条丢弃（ORIENT-RELATION 也是）；不会只留下它的一部分成员。这与失效一致：原子约束的成员是严格输入（7.3）。要单个对象的槽位收到集合、语句对每个成员各做一次时，每条这样的描述各是一个单位（5.2.1）。
  • 一条 PLACE 是两个单位：x 一个，y 一个，可以各自丢弃。TEXT 的 dx、dy 也各是一个单位；它们先与同一段文字同一轴上的 PLACE 按位置互相取代（13.3），留下的再参加取舍。
  • ORIENT 是一个单位：这个对象的朝向等于某个值。没有 ORIENT 就没有约束：由求解器选，并把朝向写回（14.8）；没有求解结果的渲染器按 "R0" 画。朝向是取 8 个值的变量，端子的位置由它算出；检查冲突时可以直接试各种朝向，不必改写成端子的相对位置。
  • 普通定义不是约束：用例展开出的每个事实各是一个单位，各自排序、各自丢弃。
• 自相矛盾的事实：每条事实先单独检查。单独就无解的事实，如从一个对象到它自己、min=4 的 DISTANCE（9.5），是自相矛盾：它失效（7.6），不参加取舍。只有单独有解的事实才排序、纳入。
• 取舍次序：几何事实排成一个次序。先按优先级 priority 排，"high" 高于 "normal" 高于 "low"（14.8）；优先级相同，按位置，后写的在前。位置：
  • 按层和文本先后：根上的包（16.3）、上层的内容、本层的语句、外面用 scope 写进本层的语句（外层的在后，2.6）；别的包的内容在离本层最近的那个 USE-PACKAGE 所在的位置（16.2）；
  • 普通定义展开出的事实取 AS 或 ATTACH 语句的位置，逐个生成的事实取生成规则的位置（10.5）；
  • 一条语句产生几个事实时：展开出的按定义体里的先后，对每个成员各做一次的按成员次序，PLACE 先 x 后 y；每种情况都是后面的在前。管道的各段是各自的描述，后面的段算后写（5.5）：#R1 @PLACE(0, 0) => @PLACE(5, 5) 的事实次序是 y = 5、x = 5、y = 0、x = 0；#M1 @PLACE(0, 0) => @ORIENT("R90") 里 ORIENT 排在 PLACE 前。
• 取舍：按取舍次序逐条纳入；每纳入一条，就检查已纳入的还有没有解，没有解，就丢弃这一条。结果唯一，就是按这个次序字典序最大的一致子集。有解，是指有实数的坐标，并给每个没定的朝向在 8 个值里取一个，使这些事实在容差内全部成立（11.7）；整数格点只是求解器的目标。
• 时间上限：检查有没有解可能要很久，因为有些事实有几种成立的方式，要逐一去试：只给轴的 ORDER 或 DISTANCE、集合之间 DISTANCE 的上界、三个以上成员的集合的中心，以及没定的朝向。所以实现可以限定检查所花的时间。这个上限是求解器的选项，用户可以设定（14.8）；本标准不规定它的值。一条事实的检查没在上限内做完，就丢弃这条事实，并给警告，说明它没有判定（7.6）；这时结果可能与上面定义的不同，每次运行也可能不同。不设上限，或者每次检查都没到上限时，结果就是上面定义的那个。
• 纳入的事实对求解器都是硬的；丢弃的不再起作用。优先级为 "disabled" 的事实在排序之前就去掉（14.8）。
• 注：本节规定的是保留哪些事实，不是怎样求出它们。实现可以一次检查一整段事实，只在这段无解时再去找要丢弃的那一条；也可以只检查与新事实有共同对象的那些事实；只要保留的事实相同。
• 求解的实现应按本节的规定取舍冲突，结果应满足全部纳入的事实。不求解的实现只画显式几何，不要求它检查语句之间的冲突（原则 2.4）。
• 丢弃是合法的取舍，给提示，实现可以把它升为警告。给出时，提示列出每一组已纳入、与被丢弃的事实一起无解、而且少了其中哪一条都不再无解的事实，每条事实按写它的语句指出（7.6）。这些组里的事实所在的语句，也各给一条提示，列出因它而丢弃的事实，让作者看到哪些语句因它失去了作用。找全这些组没在时间上限内做完时，提示说明它列得不全。丢弃 "low" 的事实是预期内的，这些提示可以不给（7.6）：实现可以不列出与它冲突的那些组，也不给组里的语句提示。
• 冲突不是失效（7.5）。语句之间高层语义的冲突，以及与网表是否一致，不要求检查（原则 2.4）。

9.1 共同规则

• 有三种定义：DEFINE-SYMBOL 产生符号，DEFINE-STYLE 产生样式，DEFINE 产生普通定义。符号和样式是特殊的定义（1.4.4）。它们都收一个集合作定义体；体内的语句逐条容错（7.3）。
• 定义是对象，用 $name = 或 %name = 命名（6.6），作关键字的对象被使用，所在的槽位由关键字定（5.6）。
• 提交一个定义只是发布它的名字。定义本身不画任何东西，只在被使用时起作用：符号在被 SET-SYMBOL 指派时，样式在被 SET-STYLE 指派时，普通定义在被 AS 或 ATTACH 套用时。
• 直接写作记录的成员、不嵌套在语句里、又没有名字的定义，不会被用到，给警告。嵌套在语句里的匿名定义照常使用。
• 并入：DEFINE-SYMBOL 或 DEFINE-STYLE 的定义体里引用同类的定义，就是在该处并入它的内容。有键的成员后写的覆盖先写的；没有键的成员累加。没有 base= 参数。
• 普通定义之间不并入，用体内的 AS、ATTACH 组合。派生和扩充也这样做；没有继承关系（9.4）。

9.2 符号：DEFINE-SYMBOL

$RES_BOX = @DEFINE-SYMBOL {
  %p = (0, 3) @PIN(terminal=1, label="P", direction="up");
  %n = (0, -3) @PIN(terminal=2, label="N", direction="down");
  @LINE {%p (0, 1.5)};
  @LINE {(0, -1.5) %n};
  (0, 0) @RECTANGLE(width=1.2, height=3)
}

%ota5t = @DEFINE-SYMBOL(box=[-4, -4, 4, 4]) {
  (-4, 1) @PIN(terminal="inp");
  (-4, -1) @PIN(terminal="inn");
  (4, 0) @PIN(terminal="out");
  @LINE {(-4, -4) (-4, 4) (4, 0) (-4, -4)};
  ? @TEXT("${name}", key="name") => @PLACE(-1, 0)
};
# @SET-SYMBOL %ota5t

$NMOS_BULK = @DEFINE-SYMBOL(box=[-3, -3, 2, 3]) {
  $NMOS;
  %b = (1, 0) @PIN(terminal=4, label="B", direction="right");
  @LINE {(0, 0) %b}
}

9.3 样式：DEFINE-STYLE

$ink = @DEFINE-STYLE(linecolor="#202020", textcolor="#202020", fillcolor="#ffffff", size=1.2) {};
$accent = @DEFINE-STYLE(linecolor="#1f4fd8", linestyle="bold") {$ink};
$shade = @DEFINE-STYLE(fillcolor="#1f4fd833") {}

• 括号里的参数是这个样式自己的属性，最后生效。集合里只能引用别的样式，在该处并入它们的属性，后写的覆盖先写的。没有基样式的样式写 {}。
• 样式只在被 SET-STYLE 指派时生效（11.3）。同样的属性也能作参数直接写在图元、TEXT 和 WIRE 上（9.2.5、13.1），按 8.3 的两级取值。
• 样式只管描线上色：位置、朝向、形状（符号或图元的点）和文字的内容都不属于样式。
• 属性：

• 线只有颜色、线型、线宽、线端、转角五个属性。"bold" 画两倍的线宽，线宽为 0 时画两倍的细线；虚线的划长和间隔、双线的间距由实现决定，随线宽成比例。以后的语言版本可以给 linestyle 增加取值（16.1）。
• "none" 不画线，线端的箭头也不画（箭头属于线，9.2.5）；fill="linecolor" 照样取 linecolor 的颜色，所以只填充、不描边的图形写 fill="linecolor", linestyle="none"，它的颜色照样随主题变。导线和图元都收它；导线写了它就是一根看不见的导线，但仍是导线（13.1）。
• 颜色照 CSS 的十六进制写法："#RRGGBB" 或 "#RRGGBBAA"，或简写 "#RGB"、"#RGBA"。透明度在后：00 全透明，FF 不透明；不写就是不透明。线和填充各有各的颜色，所以透明度也分开设，如上例 $shade 只让填充部分透明。本版不收颜色名和 rgb()。颜色是字符串。
• 本版不设：图案填充、渐变、阴影；可见性 visible（显示和隐藏是查看器的事，16.2）；主题、profile 这类对象（主题就是一个带样式和规则的包，用 USE-PACKAGE 引入，16.2）。
• 某个属性没有任何样式或参数给值时，用渲染器自己的默认值，这不是错误（原则 2.7）。标准包给出可移植的默认外观（16.3），用户写的规则和语句覆盖它。
• 不认识的属性与语法错误同等处理（原则 2.3）。

9.4 普通定义：DEFINE

$TAIL_MID = @DEFINE(roles=["a", "b", "t"]) {
  %mid = (_, _);
  {?a %mid ?b} @DISTRIBUTE("x");
  {%mid ?t} @ALIGN("x")
};
$CHAIN_ROW = @DEFINE(roles=["source", "{chain}", "load"]) {
  {?source ?chain ?load} @ORDER("x")
};
$GND_BELOW = @DEFINE(roles=[["t", "terminal"]], parameters=[["gap", 2]]) {
  %g = $GROUND @ATTACH ?t::net;
  ?t::net @WIRE {?t %g:p};
  {?t %g:p} @ALIGN("x");
  %g:p ?t @DISTANCE("bottom-to-top", exact=?gap)
};
%c1 = #M1:3(a) #M2:3(b) #M5:1(t) @AS $TAIL_MID;
#R1(source) {#R2 #R3}(chain) #R4(load) @AS $CHAIN_ROW;
# @SELECT-TERMINAL(net="vss", wired=false) => $GND_BELOW @ATTACH(gap=3)

• 普通定义由角色表、参数表和定义体组成。体内用 ?name 引用角色和参数（6.10）。定义做什么由它的内容决定，见 9.5。

• 套用：AS 和 ATTACH 把对象填进定义的角色，产生一个用例。两个关键字做同一件事，只是定义写的位置不同：

  • AS 的定义写在最后，读作"这些对象，作为某某"，用于语义和摆法，如 #M1(in_p) #M2(in_n) @AS $DIFFERENTIAL_PAIR；
  • ATTACH 的定义写在最前，在写出的对象之前，标准写法把关键字放在定义后面，如 $GROUND @ATTACH &vss；读作"某某，添在这些对象上"，用于虚拟元件和补位（第 12 章、10.5）。
  • 挑了另一个关键字不算错，只是读着别扭；定义写错位置才是错误（4.2 第 7 条）。管道送来的对象直接按角色配位，两个关键字写出来一样；这时照定义的用途挑。
  • 怎样挑：对象合起来构成这个东西时用 AS，如电路结构、摆法、由这几个对象组成的局部画法；这个东西添在对象上时用 ATTACH，如地、端口符号、无连接标记、汇合圆点、每个元件一个的标签、补位。标准例句分别是 #M1(in_p) and #M2(in_n) are treated @AS $DIFFERENTIAL_PAIR 和 $GROUND is @ATTACH to &vss（4.5）。

• 角色表：参数 roles，是一个数组，每项是角色名，或 [name, kind] 对。DEFINE 的两个参数都只能写名字。

  • 写成 "{name}" 的项是集合角色，整个收下一个集合；其余是单个角色（5.2.1 第 4 条）。
  • 集合角色收到单个对象，当作只有它的集合；收到空集合也合法，体里成员不够的约束自然成立（第 14 章）。
  • 单个角色收到集合，就对每个成员各套用一次，空集合就是零次；一次套用里至多一个单个角色可以收到多成员的集合（否则语句失效，5.2.1）。
  • 集合角色的 ?name 写在 {…} 里时，集合打散一层，所以上例的 ORDER 排的是 R1、R2、R3 和 R4。
  • 集合角色收到含集合成员的集合时原样收下，由体决定怎样用。
  • 集合角色不对应端子（6.4）。
  • 一次套用里每个角色只能标一次；要给集合角色多个对象，就写成集合，如上例的 {#R2 #R3}(chain)。
  • 种类：写成 [name, kind] 的项声明这个角色收哪种对象；只写名字的项收任何种类。种类名就是词表里的（5.3）："instance"、"terminal"、"net"、"point"、"wire"、"usage"、"bundle"、"text"、"annotation" 和 "label"。在角色声明里，"instance" 也收叠画，"terminal" 也收叠画的端子（11.8）；写成数组表示几种之一，如 ["p", ["net", "terminal"]]。集合角色的种类管它的每个成员，如 ["{members}", "instance"]。没有"某个定义的用例"这一种。
  • 角色收到的对象种类不对时，整个套用失效，诊断写明哪个角色、要什么、收到了什么；集合角色里有一个成员种类不对也一样。选择逐个产生套用时，只有收错对象的那一次套用失效。
  • 注：体为空的定义，没有什么检查角色填的是什么，所以只有声明了种类，才查得出填错的角色；体不为空时，展开出的每条语句也各自检查（9.5）。声明了种类，体里对角色的用法也能在定义处检查（6.9）。
  • 可选的角色与个数：单个角色应填上；集合角色可以不填，不填就是空集合。按顺序给出对象而对象少于角色时，剩下的角色应都是集合角色；给对象标角色时，没写的集合角色是空集合。没有最少、最多个数：成员不够的约束自然成立（第 14 章）。形状不同的变体写成另一个定义（见下面的派生与扩充）。同一对象填两个角色、期望的连接这类合法性规则，见 9.5。

• 参数表：参数 parameters，可以不写。每项是参数名，或 [name, default]。

  • 参数在 AS、ATTACH 的括号里传入，如 $GND_BELOW @ATTACH(gap=3)，按参数表的顺序按位置写，或写名字；两种都用时，按位置的在前（4.2 第 9 条）。标准写法写名字（4.3）。名字不在参数表里，这次套用失效。选择逐个产生套用时，每次套用都用同一组参数。
  • 体里能写字面量的地方都能改写参数的空位：参数的值、数组的元素、点的坐标。所以在定义体里，"参数里只放字面量"（4.1）这条规则成了"字面量或参数的空位"；展开后它们仍是字面量。AS、ATTACH 自己的参数只能是字面量，不能传对象；对象经角色传入。
  • 没传、也没有默认值的参数，在用到它的地方当作没写：作具名的参数时就是没写这个参数，如 @TEXT(?label, size=?size) 里的 size=?size，这时文字用 TEXT 自己的默认字号或它的样式的字号（11.3）；作点的坐标时就是 _；写在按位置的参数里或数组的元素里没有确定含义，那条语句失效。所以不需要"必填"标记。
  • 参数用于数值、文字这类量；结构不同的变体建议写成独立的定义，语言不强制这一点。参数只传进体里；不能按参数的值选择用例。

• 角色名和参数名在同一张表里，应各不相同；它们都不能是标准子对象名（6.5）。参数不能叫 priority，它是 AS 和 ATTACH 的标准参数（14.8）。

• 体内绑定的 % 名字是局部名：每次套用都为它们生成新的对象，从外面经用例引用（见下）。几次套用共用的对象，如对称轴，经角色传入。

• 套用可以给对象标角色（#M1(a) #M2(b) … @AS $T、$T @ATTACH #M1(a) #M2(b) …），也可以按角色表的顺序给出对象（#M1 #M2 … @AS $T）。单个角色没填，或给的对象多于角色时，整条语句失效；没填的集合角色是空集合。

• 一次套用产生一个用例，它记下定义和每个角色填了什么，可以命名（如 %c1）。删掉这条语句，展开出的描述也一起消失。用例没有键：每次套用都是一个单独的对象（5.8）。

• 展开：

  • 空位换成实参和参数值；
  • 局部名换成新句柄"用例 + 局部名"，写作 %c1::mid；匿名的用例在诊断里按语句的位置显示；
  • 体外的名字不在套用处重新解析（6.9）；
  • 展开的结果在 AS 或 ATTACH 语句的位置提交，冲突取舍时也取这个位置（8.5）。

• 嵌套的用例逐层往下取（%c1::inner::mid）。用例也可以填进别的定义的角色：有了自己写的定义 $OTA = @DEFINE(roles=[["pair", "usage"], ["load", "usage"]]) {}，#M1(in_p) #M2(in_n) @AS $DIFFERENTIAL_PAIR => %cm1 @AS $OTA 是一个放大器，它的角色 pair 填的是差分对的用例，角色 load 填的是电流镜 %cm1（5.5）。

• 循环套用：展开中的一次套用，若直接或经别的定义套用了某个外围用例正在展开的定义，就闭合了一个循环。这次套用失效，诊断列出整条链；其余照常生效。下例把 $A 套用到 M1 时展开 $B，其中对 $A 的套用闭合了循环 $A → $B → $A，失效；$B 里的 ORIENT 照样把 M1 翻转：

  $A = @DEFINE(roles=["x"]) {?x @AS $B};
  $B = @DEFINE(roles=["x"]) {
    ?x @AS $A;               /* closes the cycle $A → $B → $A: this application fails */
    ?x @ORIENT("MY")
  };
  #M1 @AS $A

• 从外面引用局部对象：

  $DP_BLOCK = @DEFINE(roles=["in_p", "in_n"]) {
    %pair = {?in_p ?in_n} @GROUP
  };
  %dp1 = #M1(in_p) #M2(in_n) @AS $DP_BLOCK;
  %c1::mid @PLACE(x=20);              /* moves the midpoint of c1 */
  {%c1::mid #M9:1} @ALIGN("x");       /* aligns the drain of M9 with the midpoint of c1 */
  %dp1::pair @PRIORITY("disabled")    /* turns off only the group expanded for dp1 */

  • 体里每个起了名的局部对象，都能经用例从外面引用，写作 usage::local_name；没起名的够不着，只有求解器的记录能用编号引用它们（5.9）。起不起名由定义的作者选择，与"要引用就命名"（5.7）一样；不另设导出表。
  • 路径可以连写：%st1::dp::mid 是 st1 体里的局部用例 dp 的 mid。经角色走也一样：%st1::pair::mid 是填进角色 pair 的那个用例的 mid。
  • 它们是普通的引用：可以加事实（PLACE、SET-STYLE、TEXT、PRIORITY 等），可以用在别的语句里，可以填进别的定义的角色；与展开出的事实冲突时按 8.5 取舍。不能从外面给局部名重新绑定：%c1::mid = … 是错误。
  • 名字：经 :: 从一个用例取到的名字应唯一。所以局部名不能与角色名或标准子对象名相同，这在定义处检查；用例上文字的引用名也不能与这些名字中的任何一个相同（6.5、13.3）。局部名可以与参数名相同：参数是值，:: 不取值。
  • 优先级：从外面直接写在局部对象上的 PRIORITY 语句，盖过用例的优先级（14.8）。
  • 够不着的：匿名用例的局部对象（求解器的记录可以用编号引用，5.9），以及选择逐个生成的用例的局部对象。以用例为范围的选择仍只选它的角色成员，不选局部对象（10.1）：局部对象只能按名字引用，包里的规则看不到定义内部。
  • 所以局部名是定义的接口的一部分：定义改了局部名，外面的引用就找不到它，失效（第 7 章），求解结果随之过时，并给提示建议重新求解（第 17 章）。标准包写明它的定义中哪些局部名可以依赖。

• 体内的写法：角色和参数写 ?name，局部名写 %name（6.9、6.10）。

• 派生与扩充：只用组合，没有继承关系（9.1）。派生定义的体里套用基础定义，再加自己的语句：

  $FILTER = @DEFINE(roles=["in", "out"]) {};
  $LOWPASS = @DEFINE(roles=["in", "out", "r", "c"]) {
    %f = ?in(in) ?out(out) @AS $FILTER;
    {?r ?c} @ORDER("x")
  }

  • 增加内容靠体里的语句，数值上的变体靠参数；要在下层遮蔽并扩充一个定义，体里引用外层的同名定义（6.9）。
  • 按基础定义选择不需要特别的规则：派生定义展开出的 FILTER 用例本来就在场景里，所以 # @SELECT-USAGE $FILTER 选得到它，按 $FILTER 写的规则对低通滤波器同样起作用，只作用在里面那个 FILTER 用例上，不作用于派生定义自己加的语句。
  • 没有专门去掉基础定义一部分的机制：派生定义的体可以写 %f::x @PRIORITY("disabled") 关掉其中一部分，但外层用例上的优先级会盖过它（14.8）；要稳定地少一部分，就把基础定义拆小，或另写一个。

9.5 普通定义的用途

定义做什么由它的内容决定，不由关键字决定：

$PAIR = @DEFINE(roles=["in_p", "in_n"]) {};                /* meaning: roles only */
$SIDE_BY_SIDE = @DEFINE(roles=["a", "b"]) {               /* layout: constraints in the body */
  {?a ?b} @ALIGN("y");
  {?a ?b} @ORDER("left-to-right")
};
$PROBE = @DEFINE(roles=["p"]) {};                          /* virtual part: a rule gives its usages a symbol (chapter 12) */
$PROBE_SYM = @DEFINE-SYMBOL {(0, 0) @PIN(terminal=1); (0, 0) @CIRCLE(radius=0.5)};
# @SELECT-USAGE $PROBE => @SET-SYMBOL $PROBE_SYM

标准包里的 $CURRENT_MIRROR、$MIRRORED 和 $GROUND 分别属于这三种；$DIFFERENTIAL_PAIR 有它的角色，体里还有一个默认的布局（见下）。

• 它们都是同一种东西：一个用例（记下套用了哪个定义、每个角色填了什么），加上定义体展开出的描述。两部分的使用者不同：

  • 体展开出的约束由求解器处理，必须满足，冲突时按 8.5 取舍；
  • 用例给人和 LLM 读，也给 RNL 自己的选择和规则用（10.1）。

  所以布局定义的用例同样带有语义；体为空的定义，如 $PAIR，只用角色记录含义，它的含义由标准包或它的作者写明。记录含义的定义，体里也可以带画法（见下）。

• 语义用例不是注释：它的引用应找得到，角色应对得上，基本合法性受检查（原则 2.4），选择和规则也能用它；不规定的只是怎样画。

• "是什么"和"怎么画"可以写在一个定义里，也可以写成两个。定义可以在体里带一个默认的画法，优先级用 "low"：作者自己写的事实排在它前面，用例的优先级能关掉或抬高它，如 %dp1 @PRIORITY("disabled")，或者对这个定义的每个用例写 # @SELECT-USAGE $DIFFERENTIAL_PAIR => @PRIORITY("disabled")，用例仍记着这些对象是什么（14.8）。从语义到画法这一步也可以写成包里的规则，换包就换了画法：# @SELECT-USAGE $DIFFERENTIAL_PAIR => @AS $DP_LAYOUT；删掉布局的用例不影响语义的用例。标准包把默认画法写在定义体里，其中的约束优先级都是 "low"，如差分对的尾管放在两管中间、$BRANCH 的成员同一列、$CHAIN 从左到右（16.3）。

• 画法都写成 RNL：某种语义画成某个样子，只能靠 RNL 写出来，写在它的定义体里，或写成布局定义再用规则套用，如上一条，可以放在包里；不要依赖渲染器对某种语义的默认约定。定义带不带画法由它的包决定，本标准不另作规定。RNL 没有描述的部分怎样摆由实现决定（原则第 1 节），但那不是对某种语义的画法约定，不能依赖。渲染器决定没有描述的对象的默认符号和样式（原则 2.7），是另一回事。

• 词汇归标准包：首批语义定义和标准虚拟元件都是标准包的内容，标准包不属于语言标准（16.3）。标准包里的定义怎样写明含义和角色，也由标准包决定。用户的定义的含义就是它的体，名字只给人读。

• 基本合法性（原则 2.4）：定义的语法不检查两个角色是否填了同一个对象。一次套用的基本合法性是：引用找得到，角色收到的种类对，单个角色都已填上（9.4），以及展开出的每条语句自身合法。

  $DP_LAYOUT = @DEFINE(roles=[["in_p", "instance"], ["in_n", "instance"]]) {
    {?in_p ?in_n} @ALIGN("y");
    ?in_p ?in_n @DISTANCE("x", min=4)
  };
  #M1(in_p) #M1(in_n) @AS $DP_LAYOUT      /* the expanded DISTANCE asks M1 to be at least 4 from itself */

  • 上例展开出的 DISTANCE 自相矛盾：它失效并给诊断，只丢弃这一条（5.5、7.3）；ALIGN 照常成立。体为空的定义，如上面的 $PAIR，查不出这种填法：#M1(in_p) #M1(in_n) @AS $PAIR 不报错。
  • 两端接在同一网络上的虚拟元件有确定的含义，所以"同一对象填两个角色"一般不能算错误。
  • 更多的检查，如要求两个角色不同，本版不提供。

• 关键字与普通定义（1.5 第 7 条）：实现必须自己懂、用别的描述写不出来的，是关键字，如原子约束、GROUP、WIRE、TEXT、CURRENT；能写进普通定义的体的，是普通定义，如差分对、电流镜、地和电源、信号流向（14.6）。DEFINE-SYMBOL、DEFINE-STYLE、SET-SYMBOL、SET-STYLE 也是关键字：符号体用局部坐标，在定义处求值；样式的属性是字面量；SET-SYMBOL、SET-STYLE 给已有的对象设一个属性，在全部对象都齐了以后在队列里决定，而 AS、ATTACH 每次产生一个新对象。

• 定义按它的名字解析到的定义认，不按名字字符串：下层自己定义了 $DIFFERENTIAL_PAIR，那就是另一个定义，包里按标准的 $DIFFERENTIAL_PAIR 写的规则不认它。

10.1 选择关键字

选出的每种对象各有一个选择关键字，每个的条件固定。选择的结果是集合（5.2）。

每个选择关键字收一个范围对象。# 表示求值时所在的那一层（10.3）。给一个对象或集合，就在这些对象里选：比如给网络的集合时，SELECT-TERMINAL 选接在这些网络上的端子（怎样从范围走到要选的种类，见表后）。范围不能省略，所以简单的选择也写 #：# @SELECT-INSTANCE(name="R*") => @SET-SYMBOL $RESISTOR。

除此之外，每个选择关键字都收条件 recursive，前六个还收 role，它只在范围里有用例时才有意义（两者都见下）。

• 每种一个关键字。 每个选择关键字按它选出的种类命名，如某个网络的导线写 &clk @SELECT-WIRE => @SET-STYLE $signal，M1 的标签写 #M1 @SELECT-LABEL。没有一种选择能选出所有种类的对象：要覆盖每一种，就每种写一条规则，标准包给每个对象配基础样式就是这样做的。

• 范围怎样走到要选的种类。 范围里的每个对象朝要选的种类走一步；走不到的对象不选出东西，这不是错误：

  • SELECT-INSTANCE：元件就是它自己；端子走到所属的元件；网络走到在上面有引脚的元件。
  • SELECT-TERMINAL：元件走到它的端子；网络走到接在上面的端子；端子就是它自己。
  • SELECT-NET：网络就是它自己；元件走到它各个端子所在的网络；端子走到它所在的网络；导线走到它所在的网络。
  • SELECT-WIRE：网络走到画在上面的导线；导线就是它自己。SELECT-LABEL：对象走到附着在它上面的标签；标签就是它自己。SELECT-ANNOTATION 只取范围里的标注。
  • 经过端子的一步只算符号里有引脚的端子，与 SELECT-TERMINAL、补位、ROUTE 相同（9.2.4）。所以 &vss @SELECT-INSTANCE 就是 &vss @SELECT-TERMINAL => @SELECT-INSTANCE：用三端符号画的 NMOS 只有衬底接在 vss 上时选不到；对这样的管子 M1，#M1 @SELECT-NET 也不含 vss。本层的端口，如 #:inp，照样走到它的网络。符号队列给出符号之前，全部端子都算（8.2）。
  • 以用例为范围时，只取要选种类的成员；成员不再当作范围（见下）。
  • 例：受时钟控制的管子是 &clk @SELECT-INSTANCE；只要栅极接 clk 的，是 &clk @SELECT-TERMINAL(terminal="g") => @SELECT-INSTANCE；M1 接的网络是 #M1 @SELECT-NET。
  • 注：只算有引脚的端子，选出来的就与画出来的一致，后面的规则加上的地、导线和样式都与图对得上。

• 只选本层。 每个选择关键字都有条件 recursive，默认 true。写 recursive=false 时只选写这条语句那一层的对象；在下层求值时为空，所以规则只在它自己那一层生效（10.4）：# @SELECT-TERMINAL(net="vss", wired=false, recursive=false) => $GROUND_STUB @ATTACH 只给本层补地。单个宿主对象直接引用即可，如 &vss：宿主引用本来就只在本层解析。

• SELECT-USAGE 和 SELECT-ANCESTOR-USAGE。 两个都按名字解析到的定义认定义（9.5），选出的总是用例，都没有 role=。

  • SELECT-USAGE 往里找，与别的选择关键字一样。范围给 # 时，选求值那一层的用例；给用例或用例的集合时，选这些用例本身和它们里面的用例，一直到最里层。范围里的元件、网络和端子不是用例，选不出东西；这时给警告，提示要找它们所在的用例用 SELECT-ANCESTOR-USAGE。
  • SELECT-ANCESTOR-USAGE 往外找：选出把范围里的对象当成员的用例，直接的、间接的都算（见下例）。范围里的用例本身不算在内。范围写 # 是错误：一层不是任何东西的成员。

• 以用例为范围。 以用例为范围时，别的选择关键字选出这些用例里本种类的成员，role= 只取那个角色的成员。是用例的成员继续往里走，一直到最里层：

  $OTA = @DEFINE(roles=[["pair", "usage"], ["load", "usage"]]) {};
  %dp1 = #M1(in_p) #M2(in_n) #M5(tail) @AS $DIFFERENTIAL_PAIR;
  %cm1 = #M3(ref) #M4(out) @AS $CURRENT_MIRROR;
  %ota1 = %dp1(pair) %cm1(load) @AS $OTA;
  %all_set = %ota1 @SELECT-INSTANCE;                 /* {#M1 #M2 #M5 #M3 #M4} */
  %pair_set = %ota1 @SELECT-INSTANCE(role="pair");   /* {#M1 #M2 #M5} */
  %up_set = #M1 @SELECT-ANCESTOR-USAGE $OTA          /* {%ota1} */

  • role= 的值也认这个用例的定义的 definition= 代称（16.5）。只要直接成员，就把角色当子对象用，如 %dp1::tail。遇到已经走过的用例就停。成员指填进角色的对象，不含体里的局部对象（9.4）。
  • 只取本种类的成员。 成员不再当作范围往下走，别的种类的成员不算。SELECT-TERMINAL 只取端子成员：$GROUND @ATTACH &0; $GROUND @ATTACH #M5:3 之后，# @SELECT-USAGE $GROUND => @SELECT-TERMINAL 只是 ，不含网络 0 上的其他端子。差分对 %dp1 的成员是元件，所以 %dp1 @SELECT-TERMINAL 是空集合。要成员元件的端子，写 %dp1 @SELECT-INSTANCE => @SELECT-TERMINAL(terminal=2)（三个管子的栅极，尾管也在内）；要成员网络上的端子，写 … => @SELECT-NET => @SELECT-TERMINAL。每一段只做一件事；要往下走，就多写一段。范围里直接给的对象照前面的规则：网络给出它上面的端子，元件给出它的端子。

• 在场景里按条件找对象，一律用选择关键字；:: 只取对象自身的部分（6.5）。

• 叠画。 叠画的成员选不到，选到的是叠画（11.8）。SELECT-INSTANCE 按叠画第一个成员的条件选到叠画本身，每个叠画只算一次。SELECT-TERMINAL 选到叠画的端子，net= 对上其中任何一个成员的网络就算对上。

• 条件写名字，形如 name=value；写出的条件都满足时才选中。要"或"，就写几条规则。比较名字的条件（name、model、net）收通配符 *，它匹配任意多个字符，与 DEVICE 一样按宿主的大小写规则比较（6.12）。按元件字母选，写 name="R*"。Spectre 的元件名不以元件字母开头，按 model 选，如 model="resistor"（6.12）。

• model 比较元件行上写在模型位置的名字：M、Q、D 等元件是 .model 名；X 元件是子电路名，包括网表里没有定义的 PDK 器件，如 # @SELECT-INSTANCE(model="sky130_fd_pr__nfet_01v8")；Spectre 里是 master。它与 DEVICE 的 model= 相同（6.12）。type 比较 .model 里的类型；X 元件没有类型。

• 比较照 3.6：条件名和标准的枚举值区分大小写；指宿主东西的值（名字、模型名、网络名）按宿主的规则。

• 网络可以按名字选：# @SELECT-NET(name="0") 选这个网络，# @SELECT-TERMINAL(net="0") 选接在它上面的端子。对象也可以按语义选：# @SELECT-USAGE $DIFFERENTIAL_PAIR => @SELECT-INSTANCE(role="in_p") 选出每个差分对的正输入管。

• 没有求交集的关键字，如求一个集合里属于某个用例的成员；用两次 REMOVE-FROM 写（5.2.2）：

  %s_set = {#M1 #M3 #M5};
  %s_set @SELECT-ANCESTOR-USAGE $DIFFERENTIAL_PAIR => @SELECT-INSTANCE => %dp_m_set;
  %out_set = {%s_set};
  %dp_m_set @REMOVE-FROM %out_set;    /* the members of %s_set in no differential pair */
  %in_set = {%s_set};
  %out_set @REMOVE-FROM %in_set       /* the members of %s_set in a differential pair */

• 地和电源网络由标准包提供的集合给出：$GROUND_NET_SET（默认是网络 0）和 $SUPPLY_NET_SET（默认为空）。没有网络类别。

  • 包里不能写宿主引用（16.2），所以这种集合的默认内容只能写成选择，如 # @SELECT-NET(name="0")。

  • 用户用 ADD-TO 和 REMOVE-FROM 增删网络：

    &vss @ADD-TO $GROUND_NET_SET;                                       /* the vss of this level */
    # @SELECT-NET(name="vss") => @ADD-TO $GROUND_NET_SET;               /* the nets named vss of every level */
    # @SELECT-NET(name="vdd!", global=true) => @ADD-TO $SUPPLY_NET_SET  /* only the global vdd! */

    第二条语句也会加上子电路里叫 vss 的局部网络。只在某处不算某个网络，就复制一份集合，再从副本里删掉它：%g_set = {$GROUND_NET_SET}; &vss2 @REMOVE-FROM %g_set。

  • 补位规则用这样的集合作范围，如 $GROUND_NET_SET @SELECT-TERMINAL(wired=false) => $GROUND_STUB @ATTACH。

  • 在自己的层里写 $GROUND_NET_SET = … 会遮蔽包里的集合，包里的规则看不到新的这个（6.8）。

  • 不按网络名猜哪些是地和电源。导入器把编辑器文件里网络的电源域（如 powerDomain）写成 ADD-TO。

  • 求解器可以把标准集合当提示读（如电源在上、地在下），与它可以读标准包里的定义一样；这不作要求。

  • 注：地和电源网络没有关键字（1.5 第 7 条）：这些集合的用处，如选端子补地、换符号，都能写成包里的规则。

• 全局网络。 SELECT-NET 的条件 global=true 只选全局网络（6.3）。不同层里同名的局部网络是不同的结点，按名字选会都选上；只要全局的那一个，就加这个条件。