将正则表达式表示为上下文无关文法

Question

我正在为一个简单的正则表达式引擎编写解析器。

引擎支持a .. z | *以及串联和括号

这是我制作的CFG：

 exp = concat factor1
 factor1 = "|" exp | e
 concat = term factor2
 factor2 = concat | e
 term = element factor3
 factor3 = * | e
 element = (exp) | a .. z

等于

 S = T X
 X = "|" S | E
 T = F Y 
 Y = T | E
 F = U Z
 Z = *| E
 U = (S) | a .. z

对于交替和关闭，我可以轻松地处理它们，方法是向前看，然后根据令牌选择产品。 但是，由于它是隐式的，因此无法通过向前看来处理串联。

我想知道如何处理串联或语法有问题吗？

这是我的OCaml代码进行解析：

type regex = 
  | Closure of regex
  | Char of char
  | Concatenation of regex * regex
  | Alternation of regex * regex
  (*| Epsilon*)


exception IllegalExpression of string

type token = 
  | End
  | Alphabet of char
  | Star
  | LParen
  | RParen
  | Pipe

let rec parse_S (l : token list) : (regex * token list) = 
  let (a1, l1) = parse_T l in
  let (t, rest) = lookahead l1 in 
  match t with
  | Pipe ->                                   
      let (a2, l2) = parse_S rest in
      (Alternation (a1, a2), l2)
  | _ -> (a1, l1)                             

and parse_T (l : token list) : (regex * token list) = 
  let (a1, l1) = parse_F l in
  let (t, rest) = lookahead l1 in 
  match t with
  | Alphabet c -> (Concatenation (a1, Char c), rest)
  | LParen -> 
     (let (a, l1) = parse_S rest in
      let (t1, l2) = lookahead l1 in
      match t1 with
      | RParen -> (Concatenation (a1, a), l2)
      | _ -> raise (IllegalExpression "Unbalanced parentheses"))
  | _ -> 
      let (a2, rest) = parse_T l1 in
      (Concatenation (a1, a2), rest)


and parse_F (l : token list) : (regex * token list) = 
  let (a1, l1) = parse_U l in 
  let (t, rest) = lookahead l1 in 
  match t with
  | Star -> (Closure a1, rest)
  | _ -> (a1, l1)

and parse_U (l : token list) : (regex * token list) = 
  let (t, rest) = lookahead l in
  match t with
  | Alphabet c -> (Char c, rest)
  | LParen -> 
     (let (a, l1) = parse_S rest in
      let (t1, l2) = lookahead l1 in
      match t1 with
      | RParen -> (a, l2)
      | _ -> raise (IllegalExpression "Unbalanced parentheses"))
  | _ -> raise (IllegalExpression "Unknown token")

Answer 1

对于LL语法，FIRST集是允许作为规则的第一个标记的标记。 可以迭代地构造它们，直到达到固定点为止。

1. 以令牌开头的规则在其FIRST集合中具有该令牌
2. 以术语开头的规则在其FIRST集中具有该术语的FIRST集
3. 规则T = A | B具有FIRST（A）和FIRST（B）的并集作为FIRST集

从第1步开始，然后重复第2步和第3步，直到FIRST设置达到固定点（不要更改）。 现在，您已经有了语法的真正第一集，并且可以使用前瞻性来确定每个规则。

注意：在您的代码中，parse_T函数与FIRST（T）集不匹配。 例如，如果您查看“ a | b”，则输入parse_T，而“ a”与parse_F调用匹配。 然后，前瞻为“ |” 在您的语法中匹配epsilon，但在您的代码中不匹配。