在Emacs Lisp中解析

Question

我正在Emacs Lisp中編寫解析器。它是文本文件 尋找這樣的解析器：

rule: 
    int: 1, 2, 3, ... 
    string: and, or, then, when 
    text: 
    ---------- 
    Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Pellentesque 
    in tellus. In pharetra consequat augue. In congue. Curabitur 
    pellentesque iaculis eros. Proin magna odio, posuere sed, commodo nec, 
    varius nec, tortor. 
    ---------- 
    more: ... 

rule: 
    ... 

我真的不關心鍵（INT，字符串，...）。我想要 值。因此，對於上面的文件int值爲「1，2，3，...」，字符串 「，或者，然後，當」和文本「Lorem ...」（不包括破折號）。

我在考慮兩種不同的解決方案，但我不會使用哪一種解決方案。我應該：

1. 創建一個簡單的分析程序，通過所有行和每個 線迴路與一些正則表達式匹配，然後組我想出來的零件？

2. 用詞法分析器和解析器做更復雜的解析器嗎？

眼下文件是非常簡單的，我想我並不需要做什麼 作爲推進作爲第二選擇。但是這些文件可能會更復雜一點，所以我想讓它更容易擴展。

你會如何解決這個問題？

Answer 1

的解析器的東西看語義庫從CEDET項目

Answer 2

有一個相對簡單的解析器，您可以找到在Emacs的維基：ParserCompiler

The Parser Compiler for Emacs creates Recursive Descent parsers in pure elisp.

The goal of the project is to create a useful Parser Compiler that is both innovative and practically useful. This is an original work created by Mike Mattie - codermattie@gmail.com

Parsers are compiled by a Macro that translates a parser definition DSL to pure elisp. The syntax supports the PEG grammar class currently.

Answer 3

你已經熟悉了recursive descent parsers？他們使用您最喜愛的編程語言（包括Emacs Lisp）手寫相對容易。對於非常簡單的解析，您可以經常通過looking-at和search-forward。這些也將構成將由遞歸下降解析器調用的任何tokenizing例程的基礎，或任何其他類型的解析器。

[2009年2月11日]我在下面的emacs lisp中添加了一個遞歸下降解析器的例子。它分析簡單的算術表達式，包括加法，減法，乘法，除法，求冪和帶括號的子表達式。現在，它假定所有令牌都位於全局變量*tokens*中，但如果您根據需要修改gettok和peektok，則可以讓它們遍歷緩衝區。要原樣使用它，請嘗試以下：

(setq *token* '(3^5^7 + 5 * 3 + 7/11)) 
(rdh/expr) 
=> (+ (+ (^ 3 (^ 5 7)) (* 5 3)) (/ 7 11)) 

解析代碼如下。

(defun gettok() 
    (and *token* (pop *token*))) 
(defun peektok() 
    (and *token* (car *token*))) 

(defun rdh/expr() 
    (rdh/expr-tail (rdh/factor))) 

(defun rdh/expr-tail (expr) 
    (let ((tok (peektok))) 
    (cond ((or (null tok) 
      (equal tok ")")) 
     expr) 
     ((member tok '(+ -)) 
     (gettok) 
     (let ((fac (rdh/factor))) 
     (rdh/expr-tail (list tok expr fac)))) 
     (t (error "bad expr"))))) 

(defun rdh/factor() 
    (rdh/factor-tail (rdh/term))) 

(defun rdh/factor-tail (fac) 
    (let ((tok (peektok))) 
    (cond ((or (null tok) 
      (member tok '(")" + -))) 
     fac) 
     ((member tok '(* /)) 
     (gettok) 
     (let ((term (rdh/term))) 
     (rdh/factor-tail (list tok fac term)))) 
     (t (error "bad factor"))))) 

(defun rdh/term() 
    (let* ((prim (rdh/prim)) 
     (tok (peektok))) 
    (cond ((or (null tok) 
       (member tok '(")" + -/*))) 
      prim) 
      ((equal tok '^) 
      (gettok) 
      (list tok prim (rdh/term))) 
      (t (error "bad term"))))) 

(defun rdh/prim() 
    (let ((tok (gettok))) 
    (cond ((numberp tok) tok) 
     ((equal tok "(") 
     (let* ((expr (rdh/expr)) 
      (tok (peektok))) 
     (if (not (equal tok ")")) 
     (error "bad parenthesized expr") 
      (gettok) 
      expr))) 
     (t (error "bad prim")))))