/usr/share/common-lisp/source/esrap/example-function-terminals.lisp is in cl-esrap 20151218-1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 | ;;;; Esrap example: some grammars with function-based terminals.
(require :esrap)
(defpackage :esrap-example.function-terminals
(:use :cl :esrap)
(:export #:indented-block #:common-lisp))
(in-package :esrap-example.function-terminals)
;;; Ex. 1. Using a custom terminal for context sensitive parsing.
;;;
;;; Among many other things, this can be used to implement
;;; indentation-based grammars such as Python's.
(defrule whitespace (+ #\space)
(:constant nil))
;; *CURRENT-INDENT* tracks the current indentation and CURRENT-INDENT
;; *succeeds when it can consume exactly CURRENT-INDENT* units of
;; *indentation.
(defvar *current-indent* 0)
(defun current-indent-p (indent)
(= indent *current-indent*))
(defrule indent (* #\space)
(:function length))
(defrule current-indent
(current-indent-p indent))
;; Just a dummy rule for the statement-like elements of the
;; grammar. This is not the focus of this example. For simplicity,
;; each statement is on one line.
(defrule statement (+ (character-ranges (#\a #\z)))
(:text t))
(defrule line (and statement #\newline)
(:function first))
(defrule block-content
(or if line))
(defrule indented-block-content
(and current-indent block-content)
(:function second))
;; PARSE-INDENTED-BLOCK is the real meat. It determines the new
;; indentation depth via a nested (PARSE INDENT ...) call which does
;; not consume input. The block's content can then be parsed with a
;; suitably increased current indent.
;;
;; The result of the second PARSE call is returned "raw" in case of
;; success. This allows the associated result tree to be attached to
;; the global result tree and permits lazy computation of rule
;; productions within the sub-tree (beneficial if e.g. the result of
;; the parse, despite successful, is not used in the global result).
(defun parse-indented-block (text position end)
(multiple-value-bind (new-indent new-position)
(parse 'indent text :start position :end end
:junk-allowed t)
(if (> new-indent *current-indent*)
(let ((*current-indent* new-indent))
(parse '(+ indented-block-content) text
:start position :end end :raw t))
(values nil new-position "Expected indent"))))
(defrule indented-block #'parse-indented-block)
(defrule if
(and (and "if" whitespace) statement (and #\: #\Newline)
indented-block
(? (and (and current-indent "else" #\: #\Newline)
indented-block)))
(:destructure (if-keyword condition colon then
(&optional else-keyword else))
(declare (ignore if-keyword colon else-keyword))
(list* 'if condition then (when else (list else)))))
(defun test-indentation ()
(parse 'indented-block
" foo
bar
quux
if foo:
bla
if baz:
bli
blo
else:
whoop
blu
"))
;;; Ex. 2. Using CL:READ to parse lisp.
(defun parse-using-read (text position end)
(handler-case
;; When successful, READ-FROM-STRING returns the read object and
;; the position up to which TEXT has been consumed.
(read-from-string text t nil :start position :end end)
;; When READ-FROM-STRING fails, indicate the parse failure,
;; including CONDITION as explanation.
(stream-error (condition)
;; For STREAM-ERRORs, we can try to determine and return the
;; exact position of the failure.
(let ((position (ignore-errors
(file-position (stream-error-stream condition)))))
(values nil position condition)))
(error (condition)
;; For general ERRORs, we cannot determine the exact position of
;; the failure.
(values nil nil condition))))
(defrule common-lisp #'parse-using-read)
;; When parsing anything by using CL:READ, it is probably a good idea
;; to disable *READ-EVAL*. The package in which symbols will be
;; interned has to be kept in mind as well.
(defun test-read ()
(with-standard-io-syntax
(let (; (*package* (find-package :my-package-for-symbols))
(*read-eval* nil))
;; This contains deliberate syntax errors to highlight the error
;; position and error message reporting implemented in
;; PARSE-USING-READ.
(parse 'common-lisp "(list 'i :::love 'lisp"))))
|