导言
提到Rebol语言的优秀特性那就不得不说它的解析引擎，简称Parse。这项来自Carl Sassenrath的伟大设计，在过去的15年里，使得Rebol用户免受正则表达式（以不可维护著称）的折磨。现如今，Parse的增强版本在Red语言中重装上阵。
简而言之，Parse是一个使用语法规则来解析输入序列的内部DSL（在Rebol生态圈称为“方言”）。Parse方言是TDPL家族的突出一员。常用来校验，验证，分解，修改输入的数据，甚至是实现内部或者外部DSL。
parse函数的用法很简单：
parse <输入序列> <规则>
<输入序列>: 任意序列类型的值（字符串，文件，区块，路径...）
<规则>: 一个区块（包含有效的Parse方言）
下面的示例代码可以直接复制到Red控制台中运行，即便你不懂Red和Parse方言，也能观其大略，不像正则表达式那样让人不知所云。
使用语法规则验证一些字符串和区块的输入：
parse "a plane" [["a" | "the"] space "plane"] ;规则中可以包含子规则
parse "the car" [["a" | "the"] space ["plane" | "car"]]
parse "123" ["1" "2" ["4" | "3"]]
parse "abbccc" ["a" 2 "b" 3 "c"] ;指定数量
parse "aaabbb" [copy letters some "a" (n: length? letters) n "b"] ;将匹配绑定到变量，使用小括号执行Red表达式
parse [a] ['b | 'a | 'c]
parse [hello nice world] [3 word!] ;匹配区块可以使用类型
parse [a a a b b b] [copy words some 'a (n: length? words) n 'b]
下面展示如何解析IPv4地址：
four: charset "01234" ;charset函数用于创建一个bitset!类型的值
half: charset "012345"
non-zero: charset "123456789"
digit: union non-zero charset "0" ;bitset!类型可以使用Red的集合运算union函数进行组合
byte: [
"25" half
| "2" four digit
| "1" digit digit
| non-zero digit
| digit
]
ipv4: [byte dot byte dot byte dot byte]
parse "192.168.10.1" ipv4
parse "127.0.0.1" ipv4
parse "99.1234" ipv4
parse "10.12.260.1" ipv4
data: {
ID: 121.34
Version: 1.2.3-5.6
Your IP address is: 85.94.114.88.
NOTE: Your IP Address could be different tomorrow.
}
parse data [some [copy value ipv4 | skip]]
probe value ; 输出: "85.94.114.88"
一个粗糙然而实用的email地址验证器：
digit: charset "0123456789"
letters: charset [#"a" - #"z" #"A" - #"Z"]
special: charset "-"
chars: union union letters special digit
word: [some chars]
host: [word]
domain: [word some [dot word]]
email: [host "@" domain]
parse "[email protected]" email
parse "[email protected]" email
parse "[email protected]" email
验证字符串形式的数学表达式（来自Rebol/Core手册）
expr: [term ["+" | "-"] expr | term] ;规则可以递归定义
term: [factor ["*" | "/"] term | factor]
factor: [primary "**" factor | primary]
primary: [some digit | "(" expr ")"]
digit: charset "0123456789"
parse "1+2*(3-2)/4" expr ; 返回 true
parse "1-(3/)+2" expr ; 返回 false
创建简单的解析器用于解析一个HTML子集：
html: {
Test
Hello World
}
ws: charset reduce [space tab cr lf]
parse html tags: [
collect [any [
ws
| "" break
| "<" copy name to ">" skip keep (load name) opt tags
| keep to "<"
]]
]
; parse函数将会返回如下区块树
[
html [
head [
title ["Test"]
]
body [
div [
u ["Hello"]
b ["World"]
]
]
]
]
Parse方言
Parse的核心原则如下：
- 输入序列的位置由语法规则驱动前进，直到顶层规则匹配失败（parse函数返回false）或者遇到输入序列的末尾（parse函数返回true）。（*）
- 有顺序地匹配（例如，在["a" | "ab"]这个规则来说，第二个选项不会被匹配）。
- 语法规则可无限组合。
- 有限的回溯：只有输入和规则的位置可回溯，其他改动仍然保留。
- 两种模式：字符串解析（例如实现外部DSL）或者区块解析（例如实现内部DSL）。
（*）只要规则中使用了collect关键字，parse函数就返回一个区块，不论顶层规则是否匹配成功。
Parse的规则由如下元素构成：
- 关键字：Parse方言预留的单词（见下表）。
- 单字(word)：单字所绑定的值被用于规则。
- 设字(word:)：将单字绑定到当前的输入流位置。
- 取字(:word)：恢复单字绑定的输入流位置。
- 整型数值：指定规则重复的数量或者范围。
- 字面值：匹配输入流中对应的字面值。
- | : 回溯并且尝试匹配其他可选规则。
- [rules]：子规则区块。
- (expression)：脱离Parse方言转而执行Red表达式，执行完毕后返回到Parse方言。
Red的Parse实现可以使用下面的关键字，这些关键字可以自由组合。（共分成了5类）
匹配
ahead rule :预匹配规则，但是输入流位置不前进
end :当前输入流位置处于末尾则返回成功
none :总是返回成功（通用规则）（译者注：有误？实验结果更像是匹配空而不是通配）
not rule :反转子规则的结果
opt rule :预匹配规则，可选性地匹配该规则。
quote value :以字面值匹配（用于Parse方言的转义）
skip :输入流位置前进一个元素（字符或者一个值）
thru rule :前进输入流位置直到成功匹配规则，并将输入流位置放到匹配之后。
to rule :前进输入流位置直到成功匹配规则，并将输入流位置放到匹配之前。
控制流
break :中断匹配循环并返回成功
if (expr) :对Red表达式求值，如果为false或者none，匹配失败并回溯
into rule :转换输入流为已匹配的序列（字符串或者区块）并且使用指定的规则近一步解析
fail :强制当前规则匹配失败并回溯
then :不论接下来的匹配是否成功，都跳过下一个替代规则
reject :中断匹配循环并返回失败
迭代
any rule :重复匹配零次或者多次rule直到匹配失败或者输入流不再前进
some rule :重复匹配一次或者多次rule直到匹配失败或者输入流不再前进
while rule :重复匹配一次或者多次rule直到匹配失败并且忽略输入流是否前进
分解
collect [rule] :以区块的形式返回在匹配规则中收集到的值
collect set word [rule] :将匹配规则中收集到的值放入区块，并将区块绑定到word
collect into word [rule] :将匹配规则中收集到的值插入到word所引用的区块
copy word rule :拷贝匹配的内容并绑定到word
keep rule :拷贝匹配的内容并添加到一个区块
keep (expr) :将Red表达式中的最后一个值添加到一个区块
set word rule :将匹配的第一个值绑定到word
修改
insert only value :在当前输入流的位置插入一个值并将位置放置到该值之后
remove rule :删除匹配项
在Parse的核心原则中提到了两种解析模式。这在Red中是很有必要的（Rebol亦然），因为我们有两种基本的序列类型：string!和block!。当前字符串类型是由Unicode代码点的数组表示的（后来的Red版本中将会支持字符数组），区块类型是任意Red值的数组（包括其他区块）。
这在Parse方言的使用中引起了一些微小的差别。例如，新增的bitset!数据类型可以定义任意地字符集，用于在字符串中一次性匹配大量的字符。下面是使用bitset和迭代进行匹配的示例：
letter: charset [#"a" - #"z"]
digit: charset "0123456789"
parse "hello 123 world" [5 letter space 3 digit space some letter]
Bitset! 数据类型
bitset值是一个存储布尔值的bit数组。在Parse上下文中，bitset可以表达整个Unicode范围内的任意字符集，并用来在单个操作内匹配一个输入字符，这相当有用。bitset!类型是在这次的0.4.1版本引入的，因而对其支持的特性有必要作一番概述。它和Rebol3中的bitset!实现基本是同一个水平。
要创建一个bitset，你需要提供一个或者多个字符作为基本规格。可以使用不同的形式提供：表示Unicode代码点的整型数值，char!类型的值，string!类型的值，前面几种元素的范围或者组合。一个新的bitset使用如下语法创建：
make bitset! <基本规格>
<基本规格>：char!, integer!, string! or block!
例如：
; 创建一个空的bitset，至少可以容纳50个bits
make bitset! 50
; 创建一个bitset，第65位bit被设置
make bitset! #"A"
; 创建一个bitset，第104，105位bit被设置
make bitset! "hi"
; 使用不同的值设置bit位
make bitset! [120 "hello" #"A"]
; 使用char!值的范围来创建bitset
make bitset! [#"0" - #"9" #"a" - #"z"]
两个值（只允许char!和integer!类型）加一个破折号定义了一个范围。
bitset的大小是根据提供的基本规格调整的。跟最高位的字节边界对齐。
charset函数用于方便的创建bitset，因此你可以这样写：
charset "ABCDEF"
charset [120 "hello" #"A"]
charset [#"0" - #"9" #"a" - #"z"]
要读写bitset的某个bit位，路径表示法再方便不过了：
bs: charset [#"a" - #"z"]
bs/97 ; will return true
bs/40 ; will return false
bs/97: false
bs/97 ; will return false
(注意：bitset的索引是从0开始的)
除此之外，bitset类型还支持下面的操作：
pick, poke, find, insert, append, copy, remove, clear, length?, mold, form
关于这些操作的详细用法请参考Rebol3的bitset文档
为了处理Unicode字符这么大的范围，bitset之外的bit位被当作虚拟位来处理，因此访问或者设置这些位不会发生错误，bitset会根据需要自动扩展。然而这还是不足以应付很大的范围，比如除了数字以外的所有Unicode字符。这种情况下通过定义bitset的补集，既可以表达大范围的字符又占用很少的空间。
bitset补集的创建方式和普通bitset一样，只是需要使用not开头而且一般使用区块作为规格：
; 除数字以外的所有字符
charset [not "0123456789"]
; 除十六进制符号外的所有字符
charset [not "ABCDEF" #"0" - #"9"]
; 除空白字符外的所有字符
charset reduce ['not space tab cr lf]
集合运算对于bitset也是可用的，然而当前Red只支持union（毕竟这是bitset用得最多的函数）。使用union，你可以将两个bitset合并为一个新的bitset：
digit: charset "0123456789"
lower: charset [#"a" - #"z"]
upper: charset [#"A" - #"Z"]
letters: union lower upper
hexa: union upper digit
alphanum: union letters digit
Parse的实现
Red中的Parse方言是使用FSM实现的，不同于Rebol3依赖于递归函数调用。使用FSM使得一些有趣的特性成为可能，例如暂停和恢复解析，序列化解析状态然后发送到远端，然后重新加载并继续解析。现在这些都可以轻易办到。
Red的Parse由接近1300行Red/System代码实现，其中相当一部分用于优化常见使用情况下的迭代循环。手写了大约770个单元测试用于覆盖基本特性。
当前Parse是以解释器模式运行的，这对于大部分使用情况都足够快了。为了满足那些需要最大化性能的严重依赖解析的应用，给parse添加静态编译器的相关工作也已经开展。到时生成的Red/System代码应该平均比解释器版本快一个量级。当Red实现自举后，还会实现一个Parse的JIT编译器用于处理静态编译器不能处理的问题。
当Red有了更多新特性后，Parse也会相应的持续改进以便利用这些新特性。将来的多项改进包括，当binary!类型可用后，Parse也会添加对binary!类型的解析，并且当port!类型可用时，流解析也将成为可能。
Red的Parse还支持一个公开的面向事件API，你可以通过/trace refinement给parse函数传递一个回调函数。
parse/trace <输入> <规则> <回调函数>
<回调函数> 规格:
func [
event [word!] ; 跟踪事件
match? [logic!] ; 上次匹配操作的结果
rule [block!] ; 当前位置的对应规则
input [series!] ; 将要匹配的下一个位置的输入序列
stack [block!] ; 内部的解析规则栈
return: [logic!] ; TRUE: 继续匹配, FALSE: 退出
]
事件列表:
- push : 当一个规则或者区块入栈时
- pop : 当一个规则或者区块出栈之前
- fetch : 当一个新的规则被采用之前
- match : 当一个值匹配发生了
- iterate : 当一个新的迭代开始了 (ANY, SOME, ...)
- paren : 当一个小括号中的表达式被求值后
- end : 当到达输入末尾时
该API将来会扩展出更多细粒度的事件。该API可以被用于对Parse进行跟踪，获取状态，调试，... 咱们且拭目以待Red用户们会玩出什么新的花样！;-)
有一个默认的回调函数被用于跟踪。你可以方便的通过使用parse-trace函数来使用它：
parse-trace <输入> <规则>
你可以试着用一些简单的解析规则来查看输出结果。
关于DSL支持
Parse是实现DSL（内部或者外部）解析器的强大工具，它可以在规则中内联Red表达式，从而能够轻易的将DSL语法和其语义关联起来。为了表明这点，下面是一个Parse写的解释器示例，用于解释著名的晦涩语言Brainfuck。
bf: function [prog [string!]][
size: 30000
cells: make string! size
append/dup cells null size
parse prog [
some [
">" (cells: next cells)
| "<" (cells: back cells)
| "+" (cells/1: cells/1 + 1)
| "-" (cells/1: cells/1 - 1)
| "." (prin cells/1)
| "," (cells/1: first input "")
| "[" [if (cells/1 = null) thru "]" | none]
| "]" [
pos: if (cells/1 <> null)
(pos: find/reverse pos #"[") :pos
| none
]
| skip
]
]
]
; This code will print a Hello World! message
bf {
++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.
>++.<<+++++++++++++++.>.+++.------.--------.>+.>.
}
; This one will print a famous quote
bf {
++++++++[>+>++>+++>++++>+++++>++++++>+++++++>++++++++>
+++++++++>++++++++++>+++++++++++>++++++++++++>++++++++
+++++>++++++++++++++>+++++++++++++++>++++++++++++++++<
<<<<<<<<<<<<<<<-]>>>>>>>>>>>----.++++<<<<<<<<<<<>>>>>>>
>>>>>>.<<<<<<<<<<<<<>>>>>>>>>>>>>---.+++<<<<<<<<<<<<<>>
>>>>>>>>>>>>++.--<<<<<<<<<<<<<<>>>>>>>>>>>>>---.+++<<<<
<<<<<<<<<>>>>.<<<<>>>>>>>>>>>>>+.-<<<<<<<<<<<<<>>>>>>>>
>>>>>>+++.---<<<<<<<<<<<<<<>>>>.<<<<>>>>>>>>>>>>>>--.++
<<<<<<<<<<<<<<>>>>>>>>>>>>>>-.+<<<<<<<<<<<<<<>>>>.<<<<>
>>>>>>>>>>>>>+++.---<<<<<<<<<<<<<<>>>>>>>>>>>>>>.<<<<<<
<<<<<<<<>>>>>>>>>>>>>>-.+<<<<<<<<<<<<<<>>>>>>>>>>>>>>-.
+<<<<<<<<<<<<<<>>>>>>>>>>>>>>--.++<<<<<<<<<<<<<<>>>>+.-
<<<<.
}
注意：为了使得实现更加简短，该实现仅限于处理一层的"[...]"结构。使用Parse写的稍长和稍复杂的完整实现点这里。
所以当前应付较小的DSL应该不在话下。对于较复杂的DSL理论上也没问题，然而当DSL的语义变得更复杂时，Parse能起的作用就没这么大了。对于大部分的用户来说，实现一个较高级DSL的解释器或者编译器都绝非易事。针对这个问题，Red将来要着手在Parse之上提供一套元DSL(meta-DSL)包装，暴露一组更高级的API用于抽象解释器或者编译器的核心组件，使得编写复杂DSL变得更容易。要实现一个DSL用来创建其他DSL的想法绝不是痴人说梦，Rascal语言中已经存在这种强大的形式了。Red也会朝着这个方向迈进，然而不会有Rascal这么复杂。