Análisis en Emacs Lisp

Question

Estoy escribiendo un analizador en Emacs Lisp. Es un programa de análisis de archivos de texto con este aspecto:

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: 
    ... 

Realmente no me importa acerca de la clave (int, cadena, ...). Quiero el valor . Por lo tanto, para el archivo anterior int tiene el valor "1, 2, 3, ...", cadena "y, o, luego, cuando" y el texto "Lorem ..." (excluyendo los guiones).

Estoy pensando en dos soluciones diferentes, pero no sé cuál utilizar. Debería:

1. crear un analizador simple que recorre todas las líneas y para cada línea de partidos con un poco de expresiones regulares y luego agrupar las partes que quiero?

2. ¿hace un analizador más sofisticado con un lexer y un analizador?

En este momento los archivos son muy simples y supongo que no necesito hacer algo tan adelantado como la segunda opción. Pero estos archivos pueden obtener un un poco más complicado, por lo que quiero que sea fácil de ampliar.

¿Cómo solucionaría esto?

Answer 1

para la materia analizador vistazo a la biblioteca semántica de CEDET proyecto

Answer 2

Hay un programa de análisis relativamente simple que puede encontrar en el Wiki 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

¿Está familiarizado con recursive descent parsers? Son relativamente fáciles de escribir a mano en su lenguaje de programación favorito, que incluiría Emacs Lisp. Para un análisis muy simple, a menudo se puede arreglar con looking-at y search-forward. Estos también formarán la base de cualquier rutina tokenizing que su analizador de bajadas recursivo llamará o cualquier otro estilo de analizador.

[11 Feb 2009] Agregué un ejemplo de analizador de descenso recursivo en emacs lisp a continuación. Analiza expresiones aritméticas simples que incluyen suma, resta, multiplicación, división, exponenciación y subexpresiones entre paréntesis. En este momento, asume que todos los tokens están en la variable global *tokens*, pero si modifica gettok y peektok según sea necesario, puede hacer que caminen a través de un búfer. Para usarlo como es, simplemente tratar el siguiente:

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

El código de análisis sigue.

(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")))))