brag/rules/parser.rkt

#lang racket/base
(require yaragg/parser-tools/yacc
         yaragg/parser-tools/lex
         racket/match
         yaragg/rules/rule-structs)

;; A parser for grammars.

(provide hide-char
         splice-char
         tokens
         token-LPAREN
         token-RPAREN
         token-HIDE ; for hider
         token-SPLICE ; for splicer
         token-LBRACKET
         token-RBRACKET
         token-PIPE
         token-REPEAT
         token-RULE_HEAD
         token-RULE_HEAD_HIDDEN
         token-RULE_HEAD_SPLICED
         token-ID
         token-LIT
         token-EOF
         token-EMPTY
         grammar-parser
         
         current-source
         current-parser-error-handler
         current-prefix-out
         
         [struct-out rule]
         [struct-out lhs-id]
         [struct-out pattern]
         [struct-out pattern-id]
         [struct-out pattern-lit]
         [struct-out pattern-token]
         [struct-out pattern-choice]
         [struct-out pattern-repeat]
         [struct-out pattern-seq])

(define-tokens tokens (LPAREN
                       RPAREN
                       LBRACKET
                       RBRACKET
                       HIDE
                       SPLICE
                       PIPE
                       REPEAT
                       RULE_HEAD
                       RULE_HEAD_HIDDEN
                       RULE_HEAD_SPLICED
                       ID
                       LIT
                       EOF
                       EMPTY))

(define hide-char #\/)
(define splice-char #\@)

(define id-separators-pattern "(:|::=)")

;; grammar-parser: (-> token) -> (listof rule)
(define grammar-parser
  (parser
   (tokens tokens)
   (src-pos)
   (start rules)
   (end EOF)
   
   (grammar
    [rules
     [(rules*) $1]]
    
    [rules*
     [(rule rules*)
      (cons $1 $2)]
     [()
      '()]]
    
    ;; I have a separate token type for rule identifiers to avoid the
    ;; shift/reduce conflict that happens with the implicit sequencing
    ;; of top-level rules.  i.e. the parser can't currently tell, when
    ;; it sees an ID, if it should shift or reduce to a new rule.
    [rule
     [(RULE_HEAD pattern)
      (begin 
        (define trimmed (regexp-replace (pregexp (format "\\s*~a$" id-separators-pattern)) $1 ""))
        (rule (position->pos $1-start-pos)
              (position->pos $2-end-pos)
              (lhs-id (position->pos $1-start-pos)
                      (pos (+ (position-offset $1-start-pos)
                              (string-length trimmed))
                           (position-line $1-start-pos)
                           (position-col $1-start-pos))
                      trimmed
                      #f)
              $2))]
     
     [(RULE_HEAD_HIDDEN pattern) ; slash indicates hiding
      (begin
        (define trimmed (cadr (regexp-match (pregexp (format "~a(\\S+)\\s*~a$" hide-char id-separators-pattern)) $1)))
        (rule (position->pos $1-start-pos)
              (position->pos $2-end-pos)
              (lhs-id (position->pos $1-start-pos)
                      (pos (+ (position-offset $1-start-pos)
                              (string-length trimmed)
                              (string-length "!"))
                           (position-line $1-start-pos)
                           (position-col $1-start-pos))
                      trimmed
                      ''hide) ; symbol needs to be double quoted in this case
              $2))]
     
     [(RULE_HEAD_SPLICED pattern) ; atsign indicates splicing
      (begin
        (define trimmed (cadr (regexp-match (pregexp (format "~a(\\S+)\\s*~a$" splice-char id-separators-pattern)) $1)))
        (rule (position->pos $1-start-pos)
              (position->pos $2-end-pos)
              (lhs-id (position->pos $1-start-pos)
                      (pos (+ (position-offset $1-start-pos)
                              (string-length trimmed)
                              (string-length "@"))
                           (position-line $1-start-pos)
                           (position-col $1-start-pos))
                      trimmed
                      ''splice) ; symbol needs to be double quoted in this case 
              $2))]]
    
    [pattern
     [(implicit-pattern-sequence PIPE pattern)
      (if (pattern-choice? $3)
          (pattern-choice (position->pos $1-start-pos)
                          (position->pos $3-end-pos)
                          (cons $1 (pattern-choice-vals $3))
                          #f)
          (pattern-choice (position->pos $1-start-pos)
                          (position->pos $3-end-pos)
                          (list $1 $3)
                          #f))]
     [(implicit-pattern-sequence)
      $1]]
    
    [implicit-pattern-sequence
     [(repeatable-pattern implicit-pattern-sequence)
      (if (pattern-seq? $2)
          (pattern-seq (position->pos $1-start-pos)
                       (position->pos $2-end-pos)
                       (cons $1 (pattern-seq-vals $2))
                       #f)
          (pattern-seq (position->pos $1-start-pos)
                       (position->pos $2-end-pos)
                       (list $1 $2)
                       #f))]
     [(repeatable-pattern)
      $1]]
    
    [repeatable-pattern
     [(atomic-pattern REPEAT)
      (let ()
        (match-define (cons min-repeat max-repeat)
          (cond [(string=? $2 "*") (cons 0 #f)]
                [(string=? $2 "+") (cons 1 #f)]
                [(string=? $2 "?") (cons 0 1)]
                [(regexp-match #px"^\\{(\\d+)?(,)?(\\d+)?\\}$" $2) ; "{min,max}" with both min & max optional
                 => (λ (m)
                      (match m
                        [(list all min range? max) (let* ([min (if min (string->number min) 0)]
                                                          [max (cond
                                                                 [(and range? max) (string->number max)]
                                                                 [(and (not range?) (not max)) (if (zero? min)
                                                                                                   #f ; {} -> {0,}
                                                                                                   min)] ; {3} -> {3,3}
                                                                 [else #f])])
                                                     (cons min max))]))]
                [else (raise-argument-error 'grammar-parse "unknown repetition operator" $2)]))
        (pattern-repeat (position->pos $1-start-pos)
                        (position->pos $2-end-pos)
                        min-repeat max-repeat $1
                        #f))]
     [(atomic-pattern)
      $1]]
    
    [atomic-pattern
     [(LIT)
      (pattern-lit (position->pos $1-start-pos)
                   (position->pos $1-end-pos)
                   (substring $1 1 (sub1 (string-length $1)))
                   #f)]
     
     [(ID)
      (if (token-id? $1)
          (pattern-token (position->pos $1-start-pos)
                         (position->pos $1-end-pos)
                         $1
                         #f)
          (pattern-id (position->pos $1-start-pos)
                      (position->pos $1-end-pos)
                      $1
                      #f))]

     [(EMPTY)
      (pattern-repeat (position->pos $1-start-pos)
                      (position->pos $1-end-pos)
                      0 0 (pattern-lit (position->pos $1-start-pos)
                                       (position->pos $1-end-pos)
                                       "" #f)
                      #f)]
     
     [(LBRACKET pattern RBRACKET)
      (pattern-repeat (position->pos $1-start-pos)
                      (position->pos $3-end-pos)
                      0 1 $2
                      #f)]
     
     [(LPAREN pattern RPAREN)
      (relocate-pattern $2 (position->pos $1-start-pos) (position->pos $3-end-pos))]
     
     [(HIDE atomic-pattern)
      (relocate-pattern $2 (position->pos $1-start-pos) (position->pos $2-end-pos) 'hide)]

     [(SPLICE ID)
      ;; only works for nonterminals on the right side
      ;; (meaningless with terminals)
      (if (token-id? $2)
          (error 'brag "Can't use splice operator with terminal")
          (pattern-id (position->pos $1-start-pos)
                      (position->pos $2-end-pos)
                      $2
                      'splice))]])
   
   
   (error (lambda (tok-ok? tok-name tok-value start-pos end-pos)
            ((current-parser-error-handler) tok-ok? tok-name tok-value (position->pos start-pos) (position->pos end-pos))))))

;; relocate-pattern: pattern -> pattern
;; Rewrites the pattern's start and end pos accordingly.
(define (relocate-pattern a-pat start-pos end-pos [hide? #f])
  (match a-pat
    [(pattern-id _ _ v h)
     (pattern-id start-pos end-pos v (or hide? h))]
    [(pattern-token _ _ v h)
     (pattern-token start-pos end-pos v (or hide? h))]
    [(pattern-lit _ _ v h)
     (pattern-lit start-pos end-pos v (or hide? h))]
    [(pattern-choice _ _ vs h)
     (pattern-choice start-pos end-pos vs (or hide? h))]
    [(pattern-repeat _ _ min max v h)
     (pattern-repeat start-pos end-pos min max v (or hide? h))]
    [(pattern-seq _ _ vs h)
     (pattern-seq start-pos end-pos vs (or hide? h))]
    [else
     (error 'relocate-pattern "Internal error when relocating ~s\n" a-pat)]))


; token-id: string -> boolean
;; Produces true if the id we see should be treated as the name of a token.
;; By convention, tokens are all upper-cased.
(define (token-id? id)
  (string=? (string-upcase id)
            id))



;; position->pos: position -> pos
;; Coerses position structures from yaragg/parser-tools/lex to our own pos structures.
(define (position->pos a-pos)
  (pos (position-offset a-pos)
       (position-line a-pos)
       (position-col a-pos)))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;; During parsing, we should define the source of the input.
(define current-source (make-parameter #f))

(define current-prefix-out (make-parameter #f))


;; When bad things happen, we need to emit errors with source location.
(struct exn:fail:parse-grammar exn:fail (srclocs)
  #:transparent
  #:property prop:exn:srclocs (lambda (instance)
                                (exn:fail:parse-grammar-srclocs instance)))

(define current-parser-error-handler
  (make-parameter
   (lambda (tok-ok? tok-name tok-value start-pos end-pos)
     (raise (exn:fail:parse-grammar
             (format "Error while parsing grammar near: ~e [line=~a, column=~a, position=~a]"
                     tok-value
                     (pos-line start-pos)
                     (pos-col start-pos)
                     (pos-offset start-pos))
             (current-continuation-marks)
             (list (srcloc (current-source)
                           (pos-line start-pos)
                           (pos-col start-pos)
                           (pos-offset start-pos)
                           (if (and (number? (pos-offset end-pos))
                                    (number? (pos-offset start-pos)))
                               (- (pos-offset end-pos)
                                  (pos-offset start-pos))
                               #f))))))))