integrating PCREs

[Michael Montague <mikemon@xxxxxxxxx>]

I propose to integrate PCREs by having the same API work for both. The 
grammer for SREs would be changed to require that they are lists. This 
would remove the ambiguity: strings are PCREs and lists are SREs.

<sre> ::=
     | <cset-sre>                  ; A character set match.
     | <outer-sre>

<outer-sre> ::=
     | (* <inner-sre> ...)               ; 0 or more matches.
     | (+ <inner-sre> ...)               ; 1 or more matches.
     | (? <inner-sre> ...)               ; 0 or 1 matches.
     | (= <n> <inner-sre> ...)           ; <n> matches.
     | (>= <n> <inner-sre> ...)          ; <n> or more matches.
     | (** <n> <m> <inner-sre> ...)      ; <n> to <m> matches.

     | (|  <inner-sre> ...)              ; Alternation.
     | (or <inner-sre> ...)

     | (:   <inner-sre> ...)             ; Sequence.
     | (seq <inner-sre> ...)
     | ($ <inner-sre> ...)               ; Numbered submatch.
     | (submatch <inner-sre> ...)
     | (=> <name> <inner-sre> ...)               ; Named submatch.  
<name> is
     | (submatch-named <name> <inner-sre> ...)   ;  a symbol.

     | (w/case   <inner-sre> ...)        ; Introduce a case-sensitive 
context.
     | (w/nocase <inner-sre> ...)        ; Introduce a case-insensitive 
context.

     | (w/unicode   <inner-sre> ...)     ; Introduce a unicode context.
     | (w/ascii <inner-sre> ...)         ; Introduce an ascii context.
     | (word <inner-sre> ...)            ; A sre wrapped in word 
boundaries.
     | (word+ <inner-cset-sre> ...)      ; A single word restricted to 
a cset.
     | word                        ; A single word.

     | (?? <inner-sre> ...)                ; A non-greedy pattern, 0 or 
1 match.
     | (*? <inner-sre> ...)                ; Non-greedy 0 or more matches.
     | (**? m n <inner-sre> ...)           ; Non-greedy <m> to <n> matches.
     | (look-ahead <inner-sre> ...)        ; Zero-width look-ahead 
assertion.
     | (look-behind <inner-sre> ...)       ; Zero-width look-behind 
assertion.
     | (neg-look-ahead <inner-sre> ...)    ; Zero-width negative 
look-ahead assertion.
     | (neg-look-behind <inner-sre> ...)   ; Zero-width negative 
look-behind assertion.

<inner-sre> ::=
     | <outer-sre>
     | <inner-cset-sre>
     | <string>                    ; A literal string match.
     | bos                         ; Beginning of string.
     | eos                         ; End of string.

     | bol                         ; Beginning of line.
     | eol                         ; End of line.

     | bog                         ; Beginning of grapheme cluster.
     | eog                         ; End of grapheme cluster.
     | graheme                     ; A single grapheme cluster.

     | bow                         ; Beginning of word.
     | eow                         ; End of word.
     | nwb                         ; A non-word boundary.

<cset-sre> ::=
     | (<string>)                  ; literal char set
     | (/ <range-spec> ...)        ; ranges
     | (or <inner-cset-sre> ...)         ; union
     | (and <inner-cset-sre> ...)        ; intersection
     | (- <inner-cset-sre> ...)          ; difference
     | (~ <inner-cset-sre> ...)          ; complement of union
     | (w/case <inner-cset-sre> ...)     ; case and unicode toggling
     | (w/nocase <inner-cset-sre> ...)
     | (w/ascii <inner-cset-sre> ...)
     | (w/unicode <inner-cset-sre> ...)

<inner-cset-sre> ::=
     | <cset-sre>
     | <char>                      ; literal char
     | "<char>"                    ; string of one char
     | <char-set>                  ; embedded SRFI 14 char set
     | any | nonl | ascii | lower-case | lower
     | upper-case | upper | alphabetic | alpha
     | numeric | num | alphanumeric | alphanum | alnum
     | punctuation | punct | symbol | graphic | graph
     | whitespace | white | space | printing | print
     | control | cntrl | hex-digit | xdigit

<range-spec> ::= <string> | <char>