mirror/guile
mirror/guile
1
Fork 0
mirror of https://git.savannah.gnu.org/git/guile.git synced 2025-05-01 04:10:18 +02:00
Code Activity

PEG Renames

Browse source 
* module/ice-9/peg.scm: rename 'peg-sexp-compile' to
 'compile-peg-pattern'
* module/ice-9/peg/codegen.scm: same
* module/ice-9/peg/string-peg.scm: same
* module/ice-9/peg/using-parsers.scm: same
* doc/ref/api-peg.texi: same
This commit is contained in:
Noah Lavine 2012-01-22 15:03:13 -05:00 • committed by Andy Wingo
parent 3ebd578616
commit fee87b821f
5 changed files with 23 additions and 23 deletions
Download patch file Download diff file Expand all files Collapse all files

10
doc/ref/api-peg.texi
View file

@ -21,7 +21,7 @@ The module works by compiling PEGs down to lambda expressions. These
can either be stored in variables at compile-time by the define macros can either be stored in variables at compile-time by the define macros
(@code{define-peg-pattern} and @code{define-peg-string-patterns}) or calculated (@code{define-peg-pattern} and @code{define-peg-string-patterns}) or calculated
explicitly at runtime with the compile functions explicitly at runtime with the compile functions
(@code{peg-sexp-compile} and @code{peg-string-compile}). (@code{compile-peg-pattern} and @code{peg-string-compile}).
They can then be used for either parsing (@code{match-pattern}) or searching They can then be used for either parsing (@code{match-pattern}) or searching
(@code{search-for-pattern}). For convenience, @code{search-for-pattern} (@code{search-for-pattern}). For convenience, @code{search-for-pattern}
@ -292,7 +292,7 @@ Compiles the PEG pattern in @var{peg-string} propagating according to
@end deffn @end deffn
@deffn {Scheme Procedure} peg-sexp-compile peg-sexp capture-type @deffn {Scheme Procedure} compile-peg-pattern peg-sexp capture-type
Compiles the PEG pattern in @var{peg-sexp} propagating according to Compiles the PEG pattern in @var{peg-sexp} propagating according to
@var{capture-type} (capture-type can be any of the values from @var{capture-type} (capture-type can be any of the values from
@code{define-peg-pattern}). @code{define-peg-pattern}).
@ -304,7 +304,7 @@ can do the following:
@lisp @lisp
(define exp '(+ "a")) (define exp '(+ "a"))
(define as (compile (peg-sexp-compile exp 'body))) (define as (compile (compile-peg-pattern exp 'body)))
@end lisp @end lisp
You can use this nonterminal with all of the regular PEG functions: You can use this nonterminal with all of the regular PEG functions:
@ -1013,10 +1013,10 @@ in the @code{(ice-9 peg string-peg)} module.
Then, then s-expression PEG that results is compiled into a parsing Then, then s-expression PEG that results is compiled into a parsing
function by the @code{(ice-9 peg codegen)} module. In particular, the function by the @code{(ice-9 peg codegen)} module. In particular, the
function @code{peg-sexp-compile} is called on the s-expression. It then function @code{compile-peg-pattern} is called on the s-expression. It then
decides what to do based on the form it is passed. decides what to do based on the form it is passed.
The PEG syntax can be expanded by providing @code{peg-sexp-compile} more The PEG syntax can be expanded by providing @code{compile-peg-pattern} more
options for what to do with its forms. The extended syntax will be options for what to do with its forms. The extended syntax will be
associated with a symbol, for instance @code{my-parsing-form}, and will associated with a symbol, for instance @code{my-parsing-form}, and will
be called on all PEG expressions of the form be called on all PEG expressions of the form

2
module/ice-9/peg.scm
View file

@ -30,7 +30,7 @@
define-peg-string-patterns define-peg-string-patterns
match-pattern match-pattern
search-for-pattern search-for-pattern
peg-sexp-compile compile-peg-pattern
define-grammar-f define-grammar-f
keyword-flatten keyword-flatten
context-flatten context-flatten

26
module/ice-9/peg/codegen.scm
View file

@ -18,7 +18,7 @@
;;;; ;;;;
(define-module (ice-9 peg codegen) (define-module (ice-9 peg codegen)
#:export (peg-sexp-compile wrap-parser-for-users add-peg-compiler!) #:export (compile-peg-pattern wrap-parser-for-users add-peg-compiler!)
#:use-module (ice-9 pretty-print) #:use-module (ice-9 pretty-print)
#:use-module (system base pmatch)) #:use-module (system base pmatch))
@ -144,14 +144,14 @@ return EXP."
(define (cg-ignore pat accum) (define (cg-ignore pat accum)
(syntax-case pat () (syntax-case pat ()
((inner) ((inner)
(peg-sexp-compile #'inner 'none)))) (compile-peg-pattern #'inner 'none))))
(define (cg-capture pat accum) (define (cg-capture pat accum)
(syntax-case pat () (syntax-case pat ()
((inner) ((inner)
(peg-sexp-compile #'inner 'body)))) (compile-peg-pattern #'inner 'body))))
;; Filters the accum argument to peg-sexp-compile for buildings like string ;; Filters the accum argument to compile-peg-pattern for buildings like string
;; literals (since we don't want to tag them with their name if we're doing an ;; literals (since we don't want to tag them with their name if we're doing an
;; "all" accum). ;; "all" accum).
(define (builtin-accum-filter accum) (define (builtin-accum-filter accum)
@ -174,7 +174,7 @@ return EXP."
(() (()
(cggr accum 'cg-and #`(reverse #,body) at)) (cggr accum 'cg-and #`(reverse #,body) at))
((first rest ...) ((first rest ...)
#`(let ((res (#,(peg-sexp-compile #'first accum) #,str #,strlen #,at))) #`(let ((res (#,(compile-peg-pattern #'first accum) #,str #,strlen #,at)))
(and res (and res
;; update AT and BODY then recurse ;; update AT and BODY then recurse
(let ((newat (car res)) (let ((newat (car res))
@ -194,7 +194,7 @@ return EXP."
(() (()
#f) #f)
((first rest ...) ((first rest ...)
#`(or (#,(peg-sexp-compile #'first accum) #,str #,strlen #,at) #`(or (#,(compile-peg-pattern #'first accum) #,str #,strlen #,at)
#,(cg-or-int #'(rest ...) accum str strlen at))))) #,(cg-or-int #'(rest ...) accum str strlen at)))))
(define (cg-* args accum) (define (cg-* args accum)
@ -203,7 +203,7 @@ return EXP."
#`(lambda (str strlen at) #`(lambda (str strlen at)
(let ((body '())) (let ((body '()))
(let lp ((end at) (count 0)) (let lp ((end at) (count 0))
(let* ((match (#,(peg-sexp-compile #'pat (baf accum)) (let* ((match (#,(compile-peg-pattern #'pat (baf accum))
str strlen end)) str strlen end))
(new-end (if match (car match) end)) (new-end (if match (car match) end))
(count (if (> new-end end) (1+ count) count))) (count (if (> new-end end) (1+ count) count)))
@ -223,7 +223,7 @@ return EXP."
#`(lambda (str strlen at) #`(lambda (str strlen at)
(let ((body '())) (let ((body '()))
(let lp ((end at) (count 0)) (let lp ((end at) (count 0))
(let* ((match (#,(peg-sexp-compile #'pat (baf accum)) (let* ((match (#,(compile-peg-pattern #'pat (baf accum))
str strlen end)) str strlen end))
(new-end (if match (car match) end)) (new-end (if match (car match) end))
(count (if (> new-end end) (1+ count) count))) (count (if (> new-end end) (1+ count) count)))
@ -243,7 +243,7 @@ return EXP."
#`(lambda (str strlen at) #`(lambda (str strlen at)
(let ((body '())) (let ((body '()))
(let lp ((end at) (count 0)) (let lp ((end at) (count 0))
(let* ((match (#,(peg-sexp-compile #'pat (baf accum)) (let* ((match (#,(compile-peg-pattern #'pat (baf accum))
str strlen end)) str strlen end))
(new-end (if match (car match) end)) (new-end (if match (car match) end))
(count (if (> new-end end) (1+ count) count))) (count (if (> new-end end) (1+ count) count)))
@ -263,7 +263,7 @@ return EXP."
#`(lambda (str strlen at) #`(lambda (str strlen at)
(let ((body '())) (let ((body '()))
(let lp ((end at) (count 0)) (let lp ((end at) (count 0))
(let* ((match (#,(peg-sexp-compile #'pat (baf accum)) (let* ((match (#,(compile-peg-pattern #'pat (baf accum))
str strlen end)) str strlen end))
(new-end (if match (car match) end)) (new-end (if match (car match) end))
(count (if (> new-end end) (1+ count) count))) (count (if (> new-end end) (1+ count) count)))
@ -282,7 +282,7 @@ return EXP."
#`(lambda (str strlen at) #`(lambda (str strlen at)
(let ((body '())) (let ((body '()))
(let lp ((end at) (count 0)) (let lp ((end at) (count 0))
(let* ((match (#,(peg-sexp-compile #'pat (baf accum)) (let* ((match (#,(compile-peg-pattern #'pat (baf accum))
str strlen end)) str strlen end))
(new-end (if match (car match) end)) (new-end (if match (car match) end))
(count (if (> new-end end) (1+ count) count))) (count (if (> new-end end) (1+ count) count)))
@ -315,8 +315,8 @@ return EXP."
(add-peg-compiler! 'not-followed-by cg-not-followed-by) (add-peg-compiler! 'not-followed-by cg-not-followed-by)
;; Takes an arbitrary expressions and accumulation variable, then parses it. ;; Takes an arbitrary expressions and accumulation variable, then parses it.
;; E.g.: (peg-sexp-compile syntax '(and "abc" (or "-" (range #\a #\z))) 'all) ;; E.g.: (compile-peg-pattern syntax '(and "abc" (or "-" (range #\a #\z))) 'all)
(define (peg-sexp-compile pat accum) (define (compile-peg-pattern pat accum)
(syntax-case pat (peg-any) (syntax-case pat (peg-any)
(peg-any (peg-any
(cg-peg-any (baf accum))) (cg-peg-any (baf accum)))

4
module/ice-9/peg/string-peg.scm
View file

@ -59,7 +59,7 @@ RB < ']'
(lambda (x) (lambda (x)
(syntax-case x () (syntax-case x ()
((_ sym accum pat) ((_ sym accum pat)
(let* ((matchf (peg-sexp-compile #'pat (syntax->datum #'accum))) (let* ((matchf (compile-peg-pattern #'pat (syntax->datum #'accum)))
(accumsym (syntax->datum #'accum)) (accumsym (syntax->datum #'accum))
(syn (wrap-parser-for-users x matchf accumsym #'sym))) (syn (wrap-parser-for-users x matchf accumsym #'sym)))
#`(define sym #,syn)))))) #`(define sym #,syn))))))
@ -262,7 +262,7 @@ RB < ']'
(syntax-case args () (syntax-case args ()
((str-stx) (string? (syntax->datum #'str-stx)) ((str-stx) (string? (syntax->datum #'str-stx))
(let ((string (syntax->datum #'str-stx))) (let ((string (syntax->datum #'str-stx)))
(peg-sexp-compile (compile-peg-pattern
(compressor (compressor
(peg-pattern->defn (peg-pattern->defn
(peg:tree (match-pattern peg-pattern string)) #'str-stx) (peg:tree (match-pattern peg-pattern string)) #'str-stx)

4
module/ice-9/peg/using-parsers.scm
View file

@ -57,7 +57,7 @@ execute the STMTs and try again."
(lambda (x) (lambda (x)
(syntax-case x () (syntax-case x ()
((_ sym accum pat) ((_ sym accum pat)
(let ((matchf (peg-sexp-compile #'pat (syntax->datum #'accum))) (let ((matchf (compile-peg-pattern #'pat (syntax->datum #'accum)))
(accumsym (syntax->datum #'accum))) (accumsym (syntax->datum #'accum)))
;; CODE is the code to parse the string if the result isn't cached. ;; CODE is the code to parse the string if the result isn't cached.
(let ((syn (wrap-parser-for-users x matchf accumsym #'sym))) (let ((syn (wrap-parser-for-users x matchf accumsym #'sym)))
@ -75,7 +75,7 @@ execute the STMTs and try again."
(syntax-case x () (syntax-case x ()
((_ pattern string-uncopied) ((_ pattern string-uncopied)
(let ((pmsym (syntax->datum #'pattern))) (let ((pmsym (syntax->datum #'pattern)))
(let ((matcher (peg-sexp-compile (peg-like->peg #'pattern) 'body))) (let ((matcher (compile-peg-pattern (peg-like->peg #'pattern) 'body)))
;; We copy the string before using it because it might have been ;; We copy the string before using it because it might have been
;; modified in-place since the last time it was parsed, which would ;; modified in-place since the last time it was parsed, which would
;; invalidate the cache. Guile uses copy-on-write for strings, so ;; invalidate the cache. Guile uses copy-on-write for strings, so