yaml.el - dotemacs - My Emacs configuration

yaml.el (108137B)
      1 ;;; yaml.el --- YAML parser for Elisp -*- lexical-binding: t -*-
      2 
      3 ;; Copyright © 2021 Zachary Romero <zkry@posteo.org>
      4 
      5 ;; Author: Zachary Romero <zkry@posteo.org>
      6 ;; Version: 0.5.1
      7 ;; Package-Version: 0.5.2
      8 ;; Package-Commit: a19fbf948a945571300e5a20ff1dbfa6ecfa0d16
      9 ;; Homepage: https://github.com/zkry/yaml.el
     10 ;; Package-Requires: ((emacs "25.1"))
     11 ;; Keywords: tools
     12 
     13 ;; yaml.el requires at least GNU Emacs 25.1
     14 
     15 ;; This file is not part of GNU Emacs
     16 
     17 ;; This file is free software; you can redistribute it and/or modify
     18 ;; it under the terms of the GNU General Public License as published by
     19 ;; the Free Software Foundation; either version 3, or (at your option)
     20 ;; any later version.
     21 
     22 ;; This program is distributed in the hope that it will be useful,
     23 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
     24 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     25 ;; GNU General Public License for more details.
     26 
     27 ;; For a full copy of the GNU General Public License
     28 ;; see <http://www.gnu.org/licenses/>.
     29 
     30 
     31 ;;; Commentary:
     32 
     33 ;; yaml.el contains the code for parsing YAML natively in Elisp with
     34 ;; no dependencies.  The main function to parse YAML provided is
     35 ;; `yaml-parse-string'.  `yaml-encode' is also provided to encode a
     36 ;; Lisp object to YAML.  The following are some examples of its usage:
     37 ;;
     38 ;; (yaml-parse-string "key1: value1\nkey2: value2")
     39 ;; (yaml-parse-string "key1: value1\nkey2: value2" :object-type 'alist)
     40 ;; (yaml-parse-string "numbers: [1, 2, 3]" :sequence-type 'list)
     41 ;;
     42 ;; (yaml-encode '((count . 3) (value . 10) (items ("ruby" "diamond"))))
     43 
     44 ;;; Code:
     45 
     46 (require 'subr-x)
     47 (require 'seq)
     48 (require 'cl-lib)
     49 
     50 (defconst yaml-parser-version "0.5.1")
     51 
     52 (defvar yaml--parse-debug nil
     53   "Turn on debugging messages when parsing YAML when non-nil.
     54 
     55 This flag is intended for development purposes.")
     56 
     57 (defconst yaml--tracing-ignore '("s-space"
     58                                  "s-tab"
     59                                  "s-white"
     60                                  "l-comment"
     61                                  "b-break"
     62                                  "b-line-feed"
     63                                  "b-carriage-return"
     64                                  "s-b-comment"
     65                                  "b-comment"
     66                                  "l-comment"
     67                                  "ns-char"
     68                                  "nb-char"
     69                                  "b-char"
     70                                  "c-printable"
     71                                  "b-as-space"))
     72 
     73 (defvar yaml--parsing-input ""
     74   "The string content of the current item being processed.")
     75 (defvar yaml--parsing-position 0
     76   "The position that the parser is currently looking at.")
     77 (defvar yaml--states nil
     78   "Stack of parsing states.")
     79 
     80 (defvar yaml--parsing-object-type nil)
     81 (defvar yaml--parsing-object-key-type nil)
     82 (defvar yaml--parsing-sequence-type nil)
     83 (defvar yaml--parsing-null-object nil)
     84 (defvar yaml--parsing-false-object nil)
     85 (defvar yaml--parsing-store-position nil)
     86 (defvar yaml--string-values nil)
     87 
     88 (cl-defstruct (yaml--state (:constructor yaml--state-create)
     89                            (:copier nil))
     90   doc tt m name lvl beg end)
     91 
     92 (defmacro yaml--parse (data &rest forms)
     93   "Parse DATA according to FORMS."
     94   (declare (indent defun))
     95   `(progn (setq yaml--parsing-input ,data)
     96           (setq yaml--parsing-position 0)
     97           (yaml--initialize-state)
     98           ,@forms))
     99 
    100 (defun yaml--state-curr ()
    101   "Return the current state."
    102   (or (car yaml--states)
    103       (yaml--state-create
    104        :name nil :doc nil :lvl 0 :beg 0 :end 0 :m nil :tt nil)))
    105 
    106 (defun yaml--state-set-m (val)
    107   "Set the current value of t to VAL."
    108   (let* ((states yaml--states))
    109     (while states
    110       (let* ((top-state (car states))
    111              (new-state (yaml--state-create :doc (yaml--state-doc top-state)
    112                                             :tt (yaml--state-tt top-state)
    113                                             :m val
    114                                             :name (yaml--state-name top-state)
    115                                             :lvl (yaml--state-lvl top-state)
    116                                             :beg (yaml--state-beg top-state)
    117                                             :end (yaml--state-end top-state))))
    118         (setcar states new-state))
    119       (setq states (cdr states)))))
    120 
    121 (defun yaml--state-set-t (val)
    122   "Set the current value of t to VAL."
    123   (let* ((states yaml--states))
    124     (while states
    125       (let* ((top-state (car states))
    126              (new-state (yaml--state-create :doc (yaml--state-doc top-state)
    127                                             :tt val
    128                                             :m (yaml--state-m top-state)
    129                                             :name (yaml--state-name top-state)
    130                                             :lvl (yaml--state-lvl top-state)
    131                                             :beg (yaml--state-beg top-state)
    132                                             :end (yaml--state-end top-state))))
    133         (setcar states new-state))
    134       (setq states (cdr states)))))
    135 
    136 (defun yaml--state-curr-doc ()
    137   "Return the doc property of current state."
    138   (yaml--state-doc (yaml--state-curr)))
    139 
    140 (defun yaml--state-curr-t ()
    141   "Return the doc property of current state."
    142   (yaml--state-tt (yaml--state-curr)))
    143 
    144 (defun yaml--state-curr-m ()
    145   "Return the doc property of current state."
    146   (or (yaml--state-m (yaml--state-curr)) 1))
    147 
    148 (defun yaml--state-curr-end ()
    149   "Return the doc property of current state."
    150   (yaml--state-end (yaml--state-curr)))
    151 
    152 (defun yaml--push-state (name)
    153   "Add a new state frame with NAME."
    154   (let* ((curr-state (yaml--state-curr))
    155          (new-state (yaml--state-create
    156                      :doc (yaml--state-curr-doc)
    157                      :tt (yaml--state-curr-t)
    158                      :m (yaml--state-curr-m)
    159                      :name name
    160                      :lvl (1+ (yaml--state-lvl curr-state))
    161                      :beg yaml--parsing-position
    162                      :end nil)))
    163     (push new-state yaml--states)))
    164 
    165 (defun yaml--pop-state ()
    166   "Pop the current state."
    167   (let ((popped-state (car yaml--states)))
    168     (setq yaml--states (cdr yaml--states))
    169     (let ((top-state (car yaml--states)))
    170       (when top-state
    171         (setcar yaml--states
    172                 (yaml--state-create :doc (yaml--state-doc top-state)
    173                                     :tt (yaml--state-tt top-state)
    174                                     :m (yaml--state-m top-state)
    175                                     :name (yaml--state-name top-state)
    176                                     :lvl (yaml--state-lvl top-state)
    177                                     :beg (yaml--state-beg popped-state)
    178                                     :end yaml--parsing-position))))))
    179 
    180 (defun yaml--initialize-state ()
    181   "Initialize the yaml state for parsing."
    182   (setq yaml--states
    183         (list (yaml--state-create :doc nil
    184                                   :tt nil
    185                                   :m nil
    186                                   :name nil
    187                                   :lvl 0
    188                                   :beg nil
    189                                   :end nil))))
    190 
    191 (defconst yaml--grammar-resolution-rules
    192   '(("ns-plain" . literal))
    193   "Alist determining how to resolve grammar rule.")
    194 
    195 ;;; Receiver Functions
    196 
    197 (defvar yaml--document-start-version nil)
    198 (defvar yaml--document-start-explicit nil)
    199 (defvar yaml--document-end-explicit nil)
    200 (defvar yaml--tag-map nil)
    201 (defvar yaml--tag-handle nil)
    202 (defvar yaml--document-end nil)
    203 
    204 (defvar yaml--cache nil
    205   "Stack of data for temporary calculations.")
    206 (defvar yaml--object-stack nil
    207   "Stack of objects currently being build.")
    208 (defvar yaml--state-stack nil
    209   "The state that the YAML parser is with regards to incoming events.")
    210 (defvar yaml--root nil)
    211 
    212 (defvar yaml--anchor-mappings nil
    213   "Hashmap containing the anchor mappings of the current parsing run.")
    214 (defvar yaml--resolve-aliases nil
    215   "Flag determining if the event processing should attempt to resolve aliases.")
    216 
    217 (defun yaml--parse-block-header (header)
    218   "Parse the HEADER string returning chomping style and indent count."
    219   (let* ((pos 0)
    220          (chomp-indicator :clip)
    221          (indentation-indicator nil)
    222          (char (and (< pos (length header)) (aref header pos)))
    223          (process-char (lambda (char)
    224                          (when char
    225                            (cond
    226                             ((< ?0 char ?9)
    227                              (progn (setq indentation-indicator (- char ?0))))
    228                             ((equal char ?\-) (setq chomp-indicator :strip))
    229                             ((equal char ?\+) (setq chomp-indicator :keep)))
    230                            (setq pos (1+ pos))))))
    231     (when (or (eq char ?\|) (eq char ?\>))
    232       (setq pos (1+ pos))
    233       (setq char (and (< pos (length header)) (aref header pos))))
    234     (funcall process-char char)
    235     (let ((char (and (< pos (length header)) (aref header pos)))) ;
    236       (funcall process-char char)
    237       (list chomp-indicator indentation-indicator))))
    238 
    239 (defun yaml--chomp-text (text-body chomp)
    240   "Change the ending newline of TEXT-BODY based on CHOMP."
    241   (cond ((eq :clip chomp)
    242          (concat (replace-regexp-in-string "\n*\\'" "" text-body) "\n"))
    243         ((eq :strip chomp)
    244          (replace-regexp-in-string "\n*\\'" "" text-body))
    245         ((eq :keep chomp)
    246          text-body)))
    247 
    248 (defun yaml--process-folded-text (text)
    249   "Remvoe the header line for a folded match and return TEXT body formatted."
    250   (let* ((text (yaml--process-literal-text text))
    251          (done))
    252     (while (not done)
    253       (let ((replaced (replace-regexp-in-string "\\([^\n]\\)\n\\([^\n ]\\)"
    254                                                 "\\1 \\2"
    255                                                 text)))
    256         (when (equal replaced text)
    257           (setq done t))
    258         (setq text replaced)))
    259     (replace-regexp-in-string
    260      "\\(\\(?:^\\|\n\\)[^ \n][^\n]*\\)\n\\(\n+\\)\\([^\n ]\\)" "\\1\\2\\3"
    261      text)))
    262 
    263 (defun yaml--process-literal-text (text)
    264   "Remove the header line for a folded match and return TEXT body formatted."
    265   (let ((n (get-text-property 0 'yaml-n text)))
    266     (remove-text-properties 0 (length text) '(yaml-n nil) text)
    267     (let* ((header-line (substring text 0 (string-match "\n" text)))
    268            (text-body (substring text (1+ (string-match "\n" text))))
    269            (parsed-header (yaml--parse-block-header header-line))
    270            (chomp (car parsed-header))
    271            (starting-spaces-ct
    272             (or (and (cadr parsed-header) (+ (or n 0) (cadr parsed-header)))
    273                 (let ((_ (string-match "^\n*\\( *\\)" text-body)))
    274                   (length (match-string 1 text-body)))))
    275            (lines (split-string text-body "\n"))
    276            (striped-lines
    277             (seq-map (lambda (l)
    278                        (replace-regexp-in-string
    279                         (format "\\` \\{0,%d\\}" starting-spaces-ct) "" l))
    280                      lines))
    281            (text-body (string-join striped-lines "\n")))
    282       (yaml--chomp-text text-body chomp))))
    283 
    284 ;; TODO: Process tags and use them in this function.
    285 (defun yaml--resolve-scalar-tag (scalar)
    286   "Convert a SCALAR string to it's corresponding object."
    287   (cond
    288    (yaml--string-values
    289     scalar)
    290    ;; tag:yaml.org,2002:null
    291    ((or (equal "null" scalar)
    292         (equal "Null" scalar)
    293         (equal "NULL" scalar)
    294         (equal "~" scalar))
    295     yaml--parsing-null-object)
    296    ;; tag:yaml.org,2002:bool
    297    ((or (equal "true" scalar)
    298         (equal "True" scalar)
    299         (equal "TRUE" scalar)) t)
    300    ((or (equal "false" scalar)
    301         (equal "False" scalar)
    302         (equal "FALSE" scalar))
    303     yaml--parsing-false-object)
    304    ;; tag:yaml.org,2002:int
    305    ((string-match "^0$\\|^-?[1-9][0-9]*$" scalar)
    306     (string-to-number scalar))
    307    ((string-match "^[-+]?[0-9]+$" scalar)
    308     (string-to-number scalar))
    309    ((string-match "^0o[0-7]+$" scalar)
    310     (string-to-number scalar 8))
    311    ((string-match "^0x[0-9a-fA-F]+$" scalar)
    312     (string-to-number scalar 16))
    313    ;; tag:yaml.org,2002:float
    314    ((string-match
    315      "^[-+]?\\(\\.[0-9]+\\|[0-9]+\\(\\.[0-9]*\\)?\\)\\([eE][-+]?[0-9]+\\)?$"
    316      scalar)
    317     (string-to-number scalar 10))
    318    ((string-match "^[-+]?\\(\\.inf\\|\\.Inf\\|\\.INF\\)$" scalar)
    319     1.0e+INF)
    320    ((string-match "^[-+]?\\(\\.nan\\|\\.NaN\\|\\.NAN\\)$" scalar)
    321     1.0e+INF)
    322    ((string-match "^0$\\|^-?[1-9]\\(\\.[0-9]*\\)?\\(e[-+][1-9][0-9]*\\)?$"
    323                   scalar)
    324     (string-to-number scalar))
    325    (t scalar)))
    326 
    327 (defun yaml--hash-table-to-alist (hash-table)
    328   "Convert HASH-TABLE to a alist."
    329   (let ((alist nil))
    330     (maphash
    331      (lambda (k v)
    332        (setq alist (cons (cons k v) alist)))
    333      hash-table)
    334     alist))
    335 
    336 (defun yaml--hash-table-to-plist (hash-table)
    337   "Convert HASH-TABLE to a plist."
    338   (let ((plist nil))
    339     (maphash
    340      (lambda (k v)
    341        (setq plist (cons k (cons v plist))))
    342      hash-table)
    343     plist))
    344 
    345 (defun yaml--format-object (hash-table)
    346   "Convert HASH-TABLE to alist of plist if specified."
    347   (cond
    348    ((equal yaml--parsing-object-type 'hash-table)
    349     hash-table)
    350    ((equal yaml--parsing-object-type 'alist)
    351     (yaml--hash-table-to-alist hash-table))
    352    ((equal yaml--parsing-object-type 'plist)
    353     (yaml--hash-table-to-plist hash-table))
    354    (t hash-table)))
    355 
    356 (defun yaml--format-list (l)
    357   "Convert L to array if specified."
    358   (cond
    359    ((equal yaml--parsing-sequence-type 'list)
    360     l)
    361    ((equal yaml--parsing-sequence-type 'array)
    362     (apply #'vector l))
    363    (t l)))
    364 
    365 (defun yaml--stream-start-event ()
    366   "Create the data for a stream-start event."
    367   '(:stream-start))
    368 
    369 (defun yaml--stream-end-event ()
    370   "Create the data for a stream-end event."
    371   '(:stream-end))
    372 
    373 (defun yaml--mapping-start-event (_)
    374   "Process event indicating start of mapping."
    375   ;; NOTE: currently don't have a use for FLOW
    376   (push :mapping yaml--state-stack)
    377   (push (make-hash-table :test 'equal) yaml--object-stack))
    378 
    379 (defun yaml--mapping-end-event ()
    380   "Process event indicating end of mapping."
    381   (pop yaml--state-stack)
    382   (let ((obj (pop yaml--object-stack)))
    383     (yaml--scalar-event nil obj))
    384   '(:mapping-end))
    385 
    386 (defun yaml--sequence-start-event (_)
    387   "Process event indicating start of sequence according to FLOW."
    388   ;; NOTE: currently don't have a use for FLOW
    389   (push :sequence yaml--state-stack)
    390   (push nil yaml--object-stack)
    391   '(:sequence-start))
    392 
    393 (defun yaml--sequence-end-event ()
    394   "Process event indicating end of sequence."
    395   (pop yaml--state-stack)
    396   (let ((obj (pop yaml--object-stack)))
    397     (yaml--scalar-event nil obj))
    398   '(:sequence-end))
    399 
    400 (defun yaml--anchor-event (name)
    401   "Process event indicating an anchor has been defined with NAME."
    402   (push :anchor yaml--state-stack)
    403   (push `(:anchor ,name) yaml--object-stack))
    404 
    405 (defun yaml--scalar-event (style value)
    406   "Process the completion of a scalar VALUE.
    407 
    408  Note that VALUE may be a complex object here.  STYLE is
    409  currently unused."
    410   (let ((top-state (car yaml--state-stack))
    411         (value* (cond
    412                  ((stringp value) (yaml--resolve-scalar-tag value))
    413                  ((listp value) (yaml--format-list value))
    414                  ((hash-table-p value) (yaml--format-object value))
    415                  ((vectorp value) value)
    416                  ((not value) nil))))
    417     (cond
    418      ((not top-state)
    419       (setq yaml--root value*))
    420      ((equal top-state :anchor)
    421       (let* ((anchor (pop yaml--object-stack))
    422              (name (nth 1 anchor)))
    423         (puthash name value yaml--anchor-mappings)
    424         (pop yaml--state-stack)
    425         (yaml--scalar-event nil value)))
    426      ((equal top-state :sequence)
    427       (let ((l (car yaml--object-stack)))
    428         (setcar yaml--object-stack (append l (list value*)))))
    429      ((equal top-state :mapping)
    430       (progn
    431         (push :mapping-value yaml--state-stack)
    432         (push value* yaml--cache)))
    433      ((equal top-state :mapping-value)
    434       (progn
    435         (let ((key (pop yaml--cache))
    436               (table (car yaml--object-stack)))
    437           (when (stringp key)
    438             (cond
    439              ((eql 'symbol yaml--parsing-object-key-type)
    440               (setq key (intern key)))
    441              ((eql 'keyword yaml--parsing-object-key-type)
    442               (setq key (intern (format ":%s" key))))))
    443           (puthash key value* table))
    444         (pop yaml--state-stack)))
    445      ((equal top-state :trail-comments)
    446       (pop yaml--state-stack)
    447       (let ((comment-text (pop yaml--object-stack)))
    448         (unless (stringp value*)
    449           (error "Trail-comments can't be nested under non-string"))
    450         (yaml--scalar-event
    451          style
    452          (replace-regexp-in-string (concat (regexp-quote comment-text) "\n*\\'")
    453                                    ""
    454                                    value*))))
    455      ((equal top-state nil))))
    456   '(:scalar))
    457 
    458 (defun yaml--alias-event (name)
    459   "Process a node has been defined via alias NAME."
    460   (if yaml--resolve-aliases
    461       (let ((resolved (gethash name yaml--anchor-mappings)))
    462         (unless resolved (error "Undefined alias '%s'" name))
    463         (yaml--scalar-event nil resolved))
    464     (yaml--scalar-event nil (vector :alias name)))
    465   '(:alias))
    466 
    467 (defun yaml--trail-comments-event (text)
    468   "Process trailing comments of TEXT which should be trimmed from parent."
    469   (push :trail-comments yaml--state-stack)
    470   (push text yaml--object-stack)
    471   '(:trail-comments))
    472 
    473 
    474 
    475 (defun yaml--check-document-end ()
    476   "Return non-nil if at end of document."
    477   ;; NOTE: currently no need for this.  May be needed in the future.
    478   t)
    479 
    480 (defun yaml--reverse-at-list ()
    481   "Reverse the list at the top of the object stack.
    482 
    483 This is needed to get the correct order as lists are processed in
    484 reverse order."
    485   (setcar yaml--object-stack (reverse (car yaml--object-stack))))
    486 
    487 (defconst yaml--grammar-events-in
    488   '(("l-yaml-stream" . (lambda ()
    489                          (yaml--stream-start-event)
    490                          (setq yaml--document-start-version nil)
    491                          (setq yaml--document-start-explicit nil)
    492                          (setq yaml--tag-map (make-hash-table))))
    493     ("c-flow-mapping" . (lambda ()
    494                           (yaml--mapping-start-event t)))
    495     ("c-flow-sequence" . (lambda ()
    496                            (yaml--sequence-start-event nil)))
    497     ("l+block-mapping" . (lambda ()
    498                            (yaml--mapping-start-event nil)))
    499     ("l+block-sequence" . (lambda ()
    500                             (yaml--sequence-start-event nil)))
    501     ("ns-l-compact-mapping" . (lambda ()
    502                                 (yaml--mapping-start-event nil)))
    503     ("ns-l-compact-sequence" . (lambda ()
    504                                  (yaml--sequence-start-event nil)))
    505     ("ns-flow-pair" . (lambda ()
    506                         (yaml--mapping-start-event t)))
    507     ("ns-l-block-map-implicit-entry" . (lambda ()))
    508     ("ns-l-compact-mapping" . (lambda ()))
    509     ("c-l-block-seq-entry" . (lambda ())))
    510   "List of functions for matched rules that run on the entering of a rule.")
    511 
    512 (defconst yaml--grammar-events-out
    513   '(("c-b-block-header" .
    514      (lambda (text)
    515        nil))
    516     ("l-yaml-stream" .
    517      (lambda (text)
    518        (yaml--check-document-end)
    519        (yaml--stream-end-event)))
    520     ("ns-yaml-version" .
    521      (lambda (text)
    522        (when yaml--document-start-version
    523          (throw 'error "Multiple %YAML directives not allowed."))
    524        (setq yaml--document-start-version text)))
    525     ("c-tag-handle" .
    526      (lambda (text)
    527        (setq yaml--tag-handle text)))
    528     ("ns-tag-prefix" .
    529      (lambda (text)
    530        (puthash yaml--tag-handle text yaml--tag-map)))
    531     ("c-directives-end" .
    532      (lambda (text)
    533        (yaml--check-document-end)
    534        (setq yaml--document-start-explicit t)))
    535     ("c-document-end" .
    536      (lambda (text)
    537        (when (not yaml--document-end)
    538          (setq yaml--document-end-explicit t))
    539        (yaml--check-document-end)))
    540     ("c-flow-mapping" .
    541      (lambda (text)
    542        (yaml--mapping-end-event)))
    543     ("c-flow-sequence" .
    544      (lambda (text)
    545        (yaml--sequence-end-event )))
    546     ("l+block-mapping" .
    547      (lambda (text)
    548        (yaml--mapping-end-event)))
    549     ("l+block-sequence" .
    550      (lambda (text)
    551        (yaml--reverse-at-list)
    552        (yaml--sequence-end-event)))
    553     ("ns-l-compact-mapping" .
    554      (lambda (text)
    555        (yaml--mapping-end-event)))
    556     ("ns-l-compact-sequence" .
    557      (lambda (text)
    558        (yaml--sequence-end-event)))
    559     ("ns-flow-pair" .
    560      (lambda (text)
    561        (yaml--mapping-end-event)))
    562     ("ns-plain" .
    563      (lambda (text)
    564        (let* ((replaced (if (and (zerop (length yaml--state-stack))
    565                                  (string-match "\\(^\\|\n\\)\\.\\.\\.\\'" text))
    566                             ;; Hack to not send the document parse end.
    567                             ;; Will only occur with bare ns-plain at top level.
    568                             (replace-regexp-in-string "\\(^\\|\n\\)\\.\\.\\.\\'"
    569                                                       ""
    570                                                       text)
    571                           text))
    572               (replaced (replace-regexp-in-string
    573                          "\\(?:[ \t]*\r?\n[ \t]*\\)"
    574                          "\n"
    575                          replaced))
    576               (replaced (replace-regexp-in-string
    577                          "\\(\n\\)\\(\n*\\)"
    578                          (lambda (x)
    579                            (if (> (length x) 1)
    580                                (substring x 1)
    581                              " "))
    582                          replaced)))
    583          (yaml--scalar-event "plain" replaced))))
    584     ("c-single-quoted" .
    585      (lambda (text)
    586        (let* ((replaced (replace-regexp-in-string
    587                          "\\(?:[ \t]*\r?\n[ \t]*\\)"
    588                          "\n"
    589                          text))
    590               (replaced (replace-regexp-in-string
    591                          "\\(\n\\)\\(\n*\\)"
    592                          (lambda (x)
    593                            (if (> (length x) 1)
    594                                (substring x 1)
    595                              " "))
    596                          replaced))
    597               (replaced (if (not (equal "''" replaced))
    598                             (replace-regexp-in-string
    599                              "''"
    600                              (lambda (x)
    601                                (if (> (length x) 1)
    602                                    (substring x 1)
    603                                  "'"))
    604                              replaced)
    605                           replaced)))
    606          (yaml--scalar-event "single"
    607                              (substring replaced 1 (1- (length replaced)))))))
    608     ("c-double-quoted" .
    609      (lambda (text)
    610        (let* ((replaced (replace-regexp-in-string
    611                          "\\(?:[ \t]*\r?\n[ \t]*\\)"
    612                          "\n"
    613                          text))
    614               (replaced (replace-regexp-in-string
    615                          "\\(\n\\)\\(\n*\\)"
    616                          (lambda (x)
    617                            (if (> (length x) 1)
    618                                (substring x 1)
    619                              " "))
    620                          replaced))
    621               (replaced (replace-regexp-in-string "\\\\\\([\"\\/]\\)"
    622                                                   "\\1"
    623                                                   replaced))
    624               (replaced (replace-regexp-in-string "\\\\ " " " replaced))
    625               (replaced (replace-regexp-in-string "\\\\ " " " replaced))
    626               (replaced (replace-regexp-in-string "\\\\b" "\b" replaced))
    627               (replaced (replace-regexp-in-string "\\\\t" "\t" replaced))
    628               (replaced (replace-regexp-in-string "\\\\n" "\n" replaced))
    629               (replaced (replace-regexp-in-string "\\\\r" "\r" replaced))
    630               (replaced (replace-regexp-in-string "\\\\r" "\r" replaced))
    631               (replaced (replace-regexp-in-string
    632                          "\\\\x\\([0-9a-fA-F]\\{2\\}\\)"
    633                          (lambda (x)
    634                            (let ((char-pt (substring 2 x)))
    635                              (string (string-to-number char-pt 16))))
    636                          replaced))
    637               (replaced (replace-regexp-in-string
    638                          "\\\\x\\([0-9a-fA-F]\\{2\\}\\)"
    639                          (lambda (x)
    640                            (let ((char-pt (substring x 2)))
    641                              (string (string-to-number char-pt 16))))
    642                          replaced))
    643               (replaced (replace-regexp-in-string
    644                          "\\\\x\\([0-9a-fA-F]\\{4\\}\\)"
    645                          (lambda (x)
    646                            (let ((char-pt (substring x 2)))
    647                              (string (string-to-number char-pt 16))))
    648                          replaced))
    649               (replaced (replace-regexp-in-string
    650                          "\\\\x\\([0-9a-fA-F]\\{8\\}\\)"
    651                          (lambda (x)
    652                            (let ((char-pt (substring x 2)))
    653                              (string (string-to-number char-pt 16))))
    654                          replaced))
    655               (replaced (replace-regexp-in-string
    656                          "\\\\\\\\"
    657                          "\\"
    658                          replaced))
    659               (replaced (substring replaced 1 (1- (length replaced)))))
    660          (yaml--scalar-event "double" replaced))))
    661     ("c-l+literal" .
    662      (lambda (text)
    663        (when (equal (car yaml--state-stack) :trail-comments)
    664          (pop yaml--state-stack)
    665          (let ((comment-text (pop yaml--object-stack)))
    666            (setq text (replace-regexp-in-string
    667                        (concat (regexp-quote comment-text) "\n*\\'") "" text))))
    668        (let* ((processed-text (yaml--process-literal-text text)))
    669          (yaml--scalar-event "folded" processed-text))))
    670     ("c-l+folded" .
    671      (lambda (text)
    672        (when (equal (car yaml--state-stack) :trail-comments)
    673          (pop yaml--state-stack)
    674          (let ((comment-text (pop yaml--object-stack)))
    675            (setq text (replace-regexp-in-string
    676                        (concat (regexp-quote comment-text) "\n*\\'") "" text))))
    677        (let* ((processed-text (yaml--process-folded-text text)))
    678          (yaml--scalar-event "folded" processed-text))))
    679     ("e-scalar" .
    680      (lambda (text)
    681        (yaml--scalar-event "plain" "null")))
    682     ("c-ns-anchor-property" .
    683      (lambda (text)
    684        (yaml--anchor-event (substring text 1))))
    685     ("c-ns-tag-property" .
    686      (lambda (text)
    687        ;; TODO: Implement tags
    688        ))
    689     ("l-trail-comments" .
    690      (lambda (text)
    691        (yaml--trail-comments-event text)))
    692     ("c-ns-alias-node" .
    693      (lambda (text)
    694        (yaml--alias-event (substring text 1)))))
    695   "List of functions for matched rules that run on the exiting of a rule.")
    696 
    697 (defconst yaml--terminal-rules
    698   '( "l-nb-literal-text"
    699      "l-nb-diff-lines"
    700      "ns-plain"
    701      "c-single-quoted"
    702      "c-double-quoted")
    703   "List of rules that indicate at which the parse tree should stop.
    704 
    705 This addition is a hack to prevent the parse tree from going too deep and thus
    706 risk hitting the stack depth limit.  Each of these rules are recursive and
    707 repeat for each character in a text.")
    708 
    709 (defun yaml--walk-events (tree)
    710   "Event walker iterates over the parse TREE and signals events from the rules."
    711   (when (consp tree)
    712     (if (stringp (car tree))
    713         (let ((grammar-rule (car tree))
    714               (text (cadr tree))
    715               (children (cl-caddr tree)))
    716           (let ((in-fn (cdr (assoc grammar-rule yaml--grammar-events-in)))
    717                 (out-fn (cdr (assoc grammar-rule yaml--grammar-events-out))))
    718             (when in-fn
    719               (funcall in-fn))
    720             (yaml--walk-events children)
    721             (when out-fn
    722               (funcall out-fn text))))
    723       (yaml--walk-events (car tree))
    724       (yaml--walk-events (cdr tree)))))
    725 
    726 (defmacro yaml--frame (name rule)
    727   "Add a new state frame of NAME for RULE."
    728   (declare (indent defun))
    729   (let ((res-symbol (make-symbol "res")))
    730     `(let ((beg yaml--parsing-position)
    731            (_ (when (and yaml--parse-debug
    732                          (not (member ,name yaml--tracing-ignore)))
    733                 (message "|%s>%s %40s args=%s '%s'"
    734                          (make-string (length yaml--states) ?-)
    735                          (make-string (- 70 (length yaml--states)) ?\s)
    736                          ,name
    737                          args
    738                          (replace-regexp-in-string
    739                           "\n"
    740                           "↓"
    741                           (yaml--slice yaml--parsing-position)))))
    742            (_ (yaml--push-state ,name))
    743            (,res-symbol ,rule))
    744        (when (and yaml--parse-debug
    745                   ,res-symbol
    746                   (not (member ,name yaml--tracing-ignore)))
    747          (message "<%s|%s %40s = '%s'"
    748                   (make-string (length yaml--states) ?-)
    749                   (make-string (- 70 (length yaml--states)) ?\s)
    750                   ,name
    751                   (replace-regexp-in-string
    752                    "\n"
    753                    "↓"
    754                    (substring yaml--parsing-input beg yaml--parsing-position))))
    755        (yaml--pop-state)
    756        (if (not ,res-symbol)
    757            nil
    758          (let ((res-type (cdr (assoc ,name yaml--grammar-resolution-rules)))
    759                (,res-symbol (if (member ,name yaml--terminal-rules)
    760                                 ;; Ignore children if at-rule is
    761                                 ;; indicated to be terminal.
    762                                 t
    763                               ,res-symbol)))
    764            (cond
    765             ((or (assoc ,name yaml--grammar-events-in)
    766                  (assoc ,name yaml--grammar-events-out))
    767              (let ((str (substring yaml--parsing-input beg yaml--parsing-position)))
    768                (when yaml--parsing-store-position
    769                  (setq str (propertize str 'yaml-position
    770                                        (cons (1+ beg)
    771                                              (1+ yaml--parsing-position)))))
    772                (when (member ,name '("c-l+folded" "c-l+literal"))
    773                  (setq str (propertize str 'yaml-n (max 0 n))))
    774                (list ,name
    775                      (if yaml--parsing-store-position
    776                          (propertize str 'yaml-position (cons (1+ beg)
    777                                                               (1+ yaml--parsing-position)))
    778                        str)
    779                      ,res-symbol)))
    780             ((equal res-type 'list) (list ,name ,res-symbol))
    781             ((equal res-type 'literal)
    782              (substring yaml--parsing-input beg yaml--parsing-position))
    783             (t ,res-symbol)))))))
    784 
    785 (defun yaml--end-of-stream ()
    786   "Return non-nil if the current position is after the end of the document."
    787   (>= yaml--parsing-position (length yaml--parsing-input)))
    788 
    789 (defun yaml--char-at-pos (pos)
    790   "Return the character at POS."
    791   (aref yaml--parsing-input pos))
    792 
    793 (defun yaml--slice (pos)
    794   "Return the character at POS."
    795   (substring yaml--parsing-input pos))
    796 
    797 (defun yaml--at-char ()
    798   "Return the current character."
    799   (yaml--char-at-pos yaml--parsing-position))
    800 
    801 (defun yaml--char-match (at &rest chars)
    802   "Return non-nil if AT match any of CHARS."
    803   (if (not chars)
    804       nil
    805     (or (equal at (car chars))
    806         (apply #'yaml--char-match (cons at (cdr chars))))))
    807 
    808 (defun yaml--chr (c)
    809   "Try to match the character C."
    810   (if (or (yaml--end-of-stream) (not (equal (yaml--at-char) c)))
    811       nil
    812     (setq yaml--parsing-position (1+ yaml--parsing-position))
    813     t))
    814 
    815 (defun yaml--chr-range (min max)
    816   "Return non-nil if the current character is between MIN and MAX."
    817   (if (or (yaml--end-of-stream) (not (<= min (yaml--at-char) max)))
    818       nil
    819     (setq yaml--parsing-position (1+ yaml--parsing-position))
    820     t))
    821 
    822 (defun yaml--run-all (&rest funcs)
    823   "Return list of all evaluated FUNCS if all of FUNCS pass."
    824   (let* ((start-pos yaml--parsing-position)
    825          (ress '())
    826          (break))
    827     (while (and (not break) funcs)
    828       (let ((res (funcall (car funcs))))
    829         (when (not res)
    830           (setq break t))
    831         (setq ress (append ress (list res)))
    832         (setq funcs (cdr funcs))))
    833     (when break
    834       (setq yaml--parsing-position start-pos))
    835     (if break nil ress)))
    836 
    837 (defmacro yaml--all (&rest forms)
    838   "Pass and return all forms if all of FORMS pass."
    839   `(yaml--run-all
    840     ,@(mapcar (lambda (form)
    841                 `(lambda () ,form))
    842               forms)))
    843 
    844 (defmacro yaml--any (&rest forms)
    845   "Pass if any of FORMS pass."
    846   (if (= 1 (length forms))
    847       (car forms)
    848     (let ((start-pos-sym (make-symbol "start"))
    849           (rules-sym (make-symbol "rules"))
    850           (res-sym (make-symbol "res")))
    851       `(let ((,start-pos-sym yaml--parsing-position)
    852              (,rules-sym ,(cons 'list
    853                                 (seq-map (lambda (form) `(lambda () ,form))
    854                                          forms)))
    855              (,res-sym))
    856          (while (and (not ,res-sym) ,rules-sym)
    857            (setq ,res-sym (funcall (car ,rules-sym)))
    858            (unless ,res-sym
    859              (setq yaml--parsing-position ,start-pos-sym))
    860            (setq ,rules-sym (cdr ,rules-sym)))
    861          ,res-sym))))
    862 
    863 (defmacro yaml--exclude (_)
    864   "Set the excluded characters according to RULE.
    865 
    866 This is currently unimplemented."
    867   ;; NOTE: This is currently not implemented.
    868   't)
    869 
    870 (defmacro yaml--max (_)
    871   "Automatically pass."
    872   t)
    873 
    874 (defun yaml--empty ()
    875   "Return non-nil indicating that empty rule needs nothing to pass."
    876   't)
    877 
    878 (defun yaml--sub (a b)
    879   "Return A minus B."
    880   (- a b))
    881 
    882 (defun yaml--match ()
    883   "Return the content of the previous sibling completed."
    884   (let* ((states yaml--states)
    885          (res nil))
    886     (while (and states (not res))
    887       (let ((top-state (car states)))
    888         (if (yaml--state-end top-state)
    889             (let ((beg (yaml--state-beg top-state))
    890                   (end (yaml--state-end top-state)))
    891               (setq res (substring yaml--parsing-input beg end)))
    892           (setq states (cdr states)))))
    893     res))
    894 
    895 (defun yaml--auto-detect (n)
    896   "Detect the indentation given N."
    897   (let* ((slice (yaml--slice yaml--parsing-position))
    898          (match (string-match
    899                  "^.*\n\\(\\(?: *\n\\)*\\)\\( *\\)"
    900                  slice)))
    901     (if (not match)
    902         1
    903       (let ((pre (match-string 1 slice))
    904             (m (- (length (match-string 2 slice)) n)))
    905         (if (< m 1)
    906             1
    907           (when (string-match (format "^.\\{%d\\}." m) pre)
    908             (error "Spaces found after indent in auto-detect (5LLU)"))
    909           m)))))
    910 
    911 (defun yaml--auto-detect-indent (n)
    912   "Detect the indentation given N."
    913   (let* ((pos yaml--parsing-position)
    914          (in-seq (and
    915                   (> pos 0)
    916                   (yaml--char-match (yaml--char-at-pos (1- pos)) ?\- ?\? ?\:)))
    917          (slice (yaml--slice pos))
    918          (_ (string-match
    919              "^\\(\\(?: *\\(?:#.*\\)?\n\\)*\\)\\( *\\)"
    920              slice))
    921          (pre (match-string 1 slice))
    922          (m (length (match-string 2 slice))))
    923     (if (and in-seq (= (length pre) 0))
    924         (when (= n -1)
    925           (setq m (1+ m)))
    926       (setq m (- m n)))
    927     (when (< m 0)
    928       (setq m 0))
    929     m))
    930 
    931 (defun yaml--the-end ()
    932   "Return non-nil if at the end of input (?)."
    933   (or (>= yaml--parsing-position (length yaml--parsing-input))
    934       (and (yaml--state-curr-doc)
    935            (yaml--start-of-line)
    936            (string-match
    937             "\\^g\\(?:---|\\.\\.\\.\\)\\([[:blank:]]\\|$\\)"
    938             (substring yaml--parsing-input yaml--parsing-position)))))
    939 
    940 (defun yaml--ord (f)
    941   "Convert an ASCII number returned by F to a number."
    942   (let ((res (funcall f)))
    943     (- (aref res 0) 48)))
    944 
    945 (defun yaml--but (&rest fs)
    946   "Match the first FS but none of the others."
    947   (if (yaml--the-end)
    948       nil
    949     (let ((pos1 yaml--parsing-position))
    950       (if (not (funcall (car fs)))
    951           nil
    952         (let ((pos2 yaml--parsing-position))
    953           (setq yaml--parsing-position pos1)
    954           (if (equal ':error (catch 'break
    955                                (dolist (f (cdr fs))
    956                                  (if (funcall f)
    957                                      (progn
    958                                        (setq yaml--parsing-position pos1)
    959                                        (throw 'break ':error))))))
    960               nil
    961             (setq yaml--parsing-position pos2)
    962             t))))))
    963 
    964 (defmacro yaml--rep (min max func)
    965   "Repeat FUNC between MIN and MAX times."
    966   (declare (indent 2))
    967   `(yaml--rep2 ,min ,max ,func))
    968 
    969 (defun yaml--rep2 (min max func)
    970   "Repeat FUNC between MIN and MAX times."
    971   (declare (indent 2))
    972   (if (and max (< max 0))
    973       nil
    974     (let* ((res-list '())
    975            (count 0)
    976            (pos yaml--parsing-position)
    977            (pos-start pos)
    978            (break nil))
    979       (while (and (not break) (or (not max) (< count max)))
    980         (let ((res (funcall func)))
    981           (if (or (not res) (= yaml--parsing-position pos))
    982               (setq break t)
    983             (setq res-list (cons res res-list))
    984             (setq count (1+ count))
    985             (setq pos yaml--parsing-position))))
    986       (if (and (>= count min)
    987                (or (not max) (<= count max)))
    988           (progn
    989             (setq yaml--parsing-position pos)
    990             (if (zerop count)
    991                 t
    992               res-list))
    993         (setq yaml--parsing-position pos-start)
    994         nil))))
    995 
    996 (defun yaml--start-of-line ()
    997   "Return non-nil if start of line."
    998   (or (= yaml--parsing-position 0)
    999       (>= yaml--parsing-position (length yaml--parsing-input))
   1000       (equal (yaml--char-at-pos (1- yaml--parsing-position)) ?\n)))
   1001 
   1002 (defun yaml--top ()
   1003   "Perform top level YAML parsing rule."
   1004   (yaml--parse-from-grammar 'l-yaml-stream))
   1005 
   1006 (defmacro yaml--set (variable value)
   1007   "Set the current state of VARIABLE to VALUE."
   1008   (let ((res-sym (make-symbol "res")))
   1009     `(let ((,res-sym ,value))
   1010        (when ,res-sym
   1011          (,(cond ((equal "m" (symbol-name variable)) 'yaml--state-set-m)
   1012                  ((equal "t" (symbol-name variable)) 'yaml--state-set-t))
   1013           ,res-sym)
   1014          ,res-sym))))
   1015 
   1016 (defmacro yaml--chk (type expr)
   1017   "Check if EXPR is non-nil at the parsing position.
   1018 
   1019 If TYPE is \"<=\" then check at the previous position.  If TYPE
   1020 is \"!\" ensure that EXPR is nil.  Otherwise, if TYPE is \"=\"
   1021 then check EXPR at the current position."
   1022   (let ((start-symbol (make-symbol "start"))
   1023         (ok-symbol (make-symbol "ok")))
   1024     `(let ((,start-symbol yaml--parsing-position)
   1025            (_ (when (equal ,type "<=")
   1026                 (setq yaml--parsing-position (1- yaml--parsing-position))))
   1027            (,ok-symbol (and (>= yaml--parsing-position 0) ,expr)))
   1028        (setq yaml--parsing-position ,start-symbol)
   1029        (if (equal ,type "!")
   1030            (not ,ok-symbol)
   1031          ,ok-symbol))))
   1032 
   1033 (cl-defun yaml--initialize-parsing-state
   1034     (&key (null-object :null)
   1035           (false-object :false)
   1036           object-type
   1037           object-key-type
   1038           sequence-type
   1039           string-values)
   1040   "Initialize state required for parsing according to plist ARGS."
   1041   (setq yaml--cache nil)
   1042   (setq yaml--object-stack nil)
   1043   (setq yaml--state-stack nil)
   1044   (setq yaml--root nil)
   1045   (setq yaml--anchor-mappings (make-hash-table :test 'equal))
   1046   (setq yaml--resolve-aliases nil)
   1047   (setq yaml--parsing-null-object null-object)
   1048   (setq yaml--parsing-false-object false-object)
   1049   (cond
   1050    ((or (not object-type)
   1051         (equal object-type 'hash-table))
   1052     (setq yaml--parsing-object-type 'hash-table))
   1053    ((equal 'alist object-type)
   1054     (setq yaml--parsing-object-type 'alist))
   1055    ((equal 'plist object-type)
   1056     (setq yaml--parsing-object-type 'plist))
   1057    (t (error "Invalid object-type.  Must be hash-table, alist, or plist")))
   1058   (cond
   1059    ((or (not object-key-type)
   1060         (equal 'symbol object-key-type))
   1061     (if (equal 'plist yaml--parsing-object-type)
   1062         (setq yaml--parsing-object-key-type 'keyword)
   1063       (setq yaml--parsing-object-key-type 'symbol)))
   1064    ((equal 'string object-key-type)
   1065     (setq yaml--parsing-object-key-type 'string))
   1066    ((equal 'keyword object-key-type)
   1067     (setq yaml--parsing-object-key-type 'keyword))
   1068    (t (error "Invalid object-key-type.  Must be string, keyword, or symbol")))
   1069   (cond
   1070    ((or (not sequence-type)
   1071         (equal sequence-type 'array))
   1072     (setq yaml--parsing-sequence-type 'array))
   1073    ((equal 'list sequence-type)
   1074     (setq yaml--parsing-sequence-type 'list))
   1075    (t (error "Invalid sequence-type.  sequence-type must be list or array")))
   1076   (if string-values
   1077       (setq yaml--string-values t)
   1078     (setq yaml--string-values nil)))
   1079 
   1080 (cl-defun yaml-parse-string (string
   1081                              &key
   1082                              (null-object :null)
   1083                              (false-object :false)
   1084                              object-type
   1085                              object-key-type
   1086                              sequence-type
   1087                              string-values)
   1088   "Parse the YAML value in STRING.
   1089 
   1090 OBJECT-TYPE specifies the Lisp object to use for representing
   1091 key-value YAML mappings.  Possible values for OBJECT-TYPE are
   1092 the symbols `hash-table' (default), `alist', and `plist'.
   1093 
   1094 OBJECT-KEY-TYPE specifies the Lisp type to use for keys in
   1095 key-value YAML mappings.  Possible values are the symbols
   1096 `string', `symbol', and `keyword'.  By default, this is `symbol';
   1097 if OBJECT-TYPE is `plist', the default is `keyword' (and `symbol'
   1098 becomes synonym for `keyword').
   1099 
   1100 SEQUENCE-TYPE specifies the Lisp object to use for representing
   1101 YAML sequences.  Possible values for SEQUENCE-TYPE are the symbols
   1102 `list', and `array' (default).
   1103 
   1104 NULL-OBJECT contains the object used to represent the null value.
   1105 It defaults to the symbol `:null'.
   1106 
   1107 FALSE-OBJECT contains the object used to represent the false
   1108 value.  It defaults to the symbol `:false'."
   1109   (yaml--initialize-parsing-state
   1110    :null-object null-object
   1111    :false-object false-object
   1112    :object-type object-type
   1113    :object-key-type object-key-type
   1114    :sequence-type sequence-type
   1115    :string-values string-values)
   1116   (let ((res (yaml--parse string
   1117                (yaml--top))))
   1118     (when (< yaml--parsing-position (length yaml--parsing-input))
   1119       (error
   1120        "Unable to parse YAML.  Parser finished before end of input %s/%s"
   1121        yaml--parsing-position
   1122        (length yaml--parsing-input)))
   1123     (when yaml--parse-debug (message "Parsed data: %s" (pp-to-string res)))
   1124     (yaml--walk-events res)
   1125     (if (hash-table-empty-p yaml--anchor-mappings)
   1126         yaml--root
   1127       ;; Run event processing twice to resolve aliases.
   1128       (let ((yaml--root nil)
   1129             (yaml--resolve-aliases t))
   1130         (yaml--walk-events res)
   1131         yaml--root))))
   1132 
   1133 (defun yaml-parse-tree (string)
   1134   "Parse the YAML value in STRING and return its parse tree."
   1135   (yaml--initialize-parsing-state)
   1136   (let* ((yaml--parsing-store-position t)
   1137          (res (yaml--parse string
   1138                 (yaml--top))))
   1139     (when (< yaml--parsing-position (length yaml--parsing-input))
   1140       (error
   1141        "Unable to parse YAML.  Parser finished before end of input %s/%s"
   1142        yaml--parsing-position
   1143        (length yaml--parsing-input)))
   1144     res))
   1145 
   1146 (defun yaml-parse-string-with-pos (string)
   1147   "Parse the YAML value in STRING, storing positions as text properties.
   1148 
   1149 NOTE: This is an experimental feature and may experience API
   1150 changes in the future."
   1151   (let ((yaml--parsing-store-position t))
   1152     (yaml-parse-string string
   1153                        :object-type 'alist
   1154                        :object-key-type 'string
   1155                        :string-values t)))
   1156 
   1157 (defun yaml--parse-from-grammar (state &rest args)
   1158   "Parse YAML grammar for given STATE and ARGS.
   1159 
   1160 Rules for this function are defined by the yaml-spec JSON file."
   1161   (pcase state
   1162     ('c-flow-sequence
   1163      (let ((n (nth 0 args))
   1164            (c (nth 1 args)))
   1165        (yaml--frame "c-flow-sequence"
   1166          (yaml--all
   1167           (yaml--chr ?\[)
   1168           (yaml--rep 0 1
   1169             (lambda () (yaml--parse-from-grammar 's-separate n c)))
   1170           (yaml--rep 0 1
   1171             (lambda ()
   1172               (yaml--parse-from-grammar
   1173                'ns-s-flow-seq-entries n
   1174                (yaml--parse-from-grammar 'in-flow c))))
   1175           (yaml--chr ?\])))))
   1176 
   1177     ('c-indentation-indicator
   1178      (let ((m (nth 0 args)))
   1179        (yaml--frame "c-indentation-indicator"
   1180          (yaml--any (when (yaml--parse-from-grammar 'ns-dec-digit)
   1181                       (yaml--set m (yaml--ord (lambda () (yaml--match)))) t)
   1182                     (when (yaml--empty)
   1183                       (let ((new-m (yaml--auto-detect m)))
   1184                         (yaml--set m new-m))
   1185                       t)))))
   1186 
   1187     ('ns-reserved-directive
   1188      (yaml--frame "ns-reserved-directive"
   1189        (yaml--all (yaml--parse-from-grammar 'ns-directive-name)
   1190                   (yaml--rep2 0 nil
   1191                     (lambda ()
   1192                       (yaml--all
   1193                        (yaml--parse-from-grammar 's-separate-in-line)
   1194                        (yaml--parse-from-grammar 'ns-directive-parameter)))))))
   1195 
   1196     ('ns-flow-map-implicit-entry
   1197      (let ((n (nth 0 args))
   1198            (c (nth 1 args)))
   1199        (yaml--frame "ns-flow-map-implicit-entry"
   1200          ;; NOTE: I ran into a bug with the order of these rules. It seems
   1201          ;; sometimes ns-flow-map-yaml-key-entry succeeds with an empty
   1202          ;; when the correct answer should be
   1203          ;; c-ns-flow-map-json-key-entry.  Changing the order seemed to
   1204          ;; have fix this but this seems like a bandage fix.
   1205          (yaml--any
   1206           (yaml--parse-from-grammar 'c-ns-flow-map-json-key-entry n c)
   1207           (yaml--parse-from-grammar 'ns-flow-map-yaml-key-entry n c)
   1208           (yaml--parse-from-grammar 'c-ns-flow-map-empty-key-entry n c)))))
   1209 
   1210     ('ns-esc-double-quote
   1211      (yaml--frame "ns-esc-double-quote"
   1212        (yaml--chr ?\")))
   1213 
   1214     ('c-mapping-start
   1215      (yaml--frame "c-mapping-start" (yaml--chr ?\{)))
   1216 
   1217     ('ns-flow-seq-entry
   1218      (let ((n (nth 0 args))
   1219            (c (nth 1 args)))
   1220        (yaml--frame "ns-flow-seq-entry"
   1221          (yaml--any (yaml--parse-from-grammar 'ns-flow-pair n c)
   1222                     (yaml--parse-from-grammar 'ns-flow-node n c)))))
   1223 
   1224     ('l-empty
   1225      (let ((n (nth 0 args))
   1226            (c (nth 1 args)))
   1227        (yaml--frame "l-empty"
   1228          (yaml--all (yaml--any (yaml--parse-from-grammar 's-line-prefix n c)
   1229                                (yaml--parse-from-grammar 's-indent-lt n))
   1230                     (yaml--parse-from-grammar 'b-as-line-feed)))))
   1231 
   1232     ('c-primary-tag-handle
   1233      (yaml--frame "c-primary-tag-handle" (yaml--chr ?\!)))
   1234 
   1235     ('ns-plain-safe-out
   1236      (yaml--frame "ns-plain-safe-out"
   1237        (yaml--parse-from-grammar 'ns-char)))
   1238 
   1239     ('c-ns-shorthand-tag
   1240      (yaml--frame "c-ns-shorthand-tag"
   1241        (yaml--all
   1242         (yaml--parse-from-grammar 'c-tag-handle)
   1243         (yaml--rep 1 nil (lambda () (yaml--parse-from-grammar 'ns-tag-char))))))
   1244 
   1245     ('nb-ns-single-in-line
   1246      (yaml--frame "nb-ns-single-in-line"
   1247        (yaml--rep2 0 nil
   1248          (lambda ()
   1249            (yaml--all (yaml--rep2 0 nil
   1250                         (lambda () (yaml--parse-from-grammar 's-white)))
   1251                       (yaml--parse-from-grammar 'ns-single-char))))))
   1252 
   1253     ('l-strip-empty
   1254      (let ((n (nth 0 args)))
   1255        (yaml--frame "l-strip-empty"
   1256          (yaml--all
   1257           (yaml--rep2 0 nil
   1258             (lambda () (yaml--all
   1259                         (yaml--parse-from-grammar 's-indent-le n)
   1260                         (yaml--parse-from-grammar 'b-non-content))))
   1261           (yaml--rep 0 1
   1262             (lambda () (yaml--parse-from-grammar 'l-trail-comments n)))))))
   1263 
   1264     ('c-indicator
   1265      (yaml--frame "c-indicator"
   1266        (yaml--any (yaml--chr ?\-)
   1267                   (yaml--chr ?\?)
   1268                   (yaml--chr ?\:)
   1269                   (yaml--chr ?\,)
   1270                   (yaml--chr ?\[)
   1271                   (yaml--chr ?\])
   1272                   (yaml--chr ?\{)
   1273                   (yaml--chr ?\})
   1274                   (yaml--chr ?\#)
   1275                   (yaml--chr ?\&)
   1276                   (yaml--chr ?\*)
   1277                   (yaml--chr ?\!)
   1278                   (yaml--chr ?\|)
   1279                   (yaml--chr ?\>)
   1280                   (yaml--chr ?\')
   1281                   (yaml--chr ?\")
   1282                   (yaml--chr ?\%)
   1283                   (yaml--chr ?\@)
   1284                   (yaml--chr ?\`))))
   1285 
   1286     ('c-l+literal
   1287      (let ((n (nth 0 args)))
   1288        (yaml--frame "c-l+literal"
   1289          (progn
   1290            (yaml--all
   1291             (yaml--chr ?\|)
   1292             (yaml--parse-from-grammar 'c-b-block-header n (yaml--state-curr-t))
   1293             (yaml--parse-from-grammar 'l-literal-content
   1294                                       (max (+ n (yaml--state-curr-m)) 1)
   1295                                       (yaml--state-curr-t)))))))
   1296 
   1297     ('c-single-quoted
   1298      (let ((n (nth 0 args))
   1299            (c (nth 1 args)))
   1300        (yaml--frame "c-single-quoted"
   1301          (yaml--all (yaml--chr ?\')
   1302                     (yaml--parse-from-grammar 'nb-single-text n c)
   1303                     (yaml--chr ?\')))))
   1304 
   1305     ('c-forbidden
   1306      (yaml--frame "c-forbidden"
   1307        (yaml--all (yaml--start-of-line)
   1308                   (yaml--any
   1309                    (yaml--parse-from-grammar 'c-directives-end)
   1310                    (yaml--parse-from-grammar 'c-document-end))
   1311                   (yaml--any
   1312                    (yaml--parse-from-grammar 'b-char)
   1313                    (yaml--parse-from-grammar 's-white)
   1314                    (yaml--end-of-stream)))))
   1315 
   1316     ('c-ns-alias-node
   1317      (yaml--frame "c-ns-alias-node"
   1318        (yaml--all (yaml--chr ?\*)
   1319                   (yaml--parse-from-grammar 'ns-anchor-name))))
   1320 
   1321     ('c-secondary-tag-handle
   1322      (yaml--frame "c-secondary-tag-handle"
   1323        (yaml--all (yaml--chr ?\!) (yaml--chr ?\!))))
   1324 
   1325     ('ns-esc-next-line
   1326      (yaml--frame "ns-esc-next-line" (yaml--chr ?N)))
   1327 
   1328     ('l-nb-same-lines
   1329      (let ((n (nth 0 args)))
   1330        (yaml--frame "l-nb-same-lines"
   1331          (yaml--all
   1332           (yaml--rep2 0 nil
   1333             (lambda () (yaml--parse-from-grammar 'l-empty n "block-in")))
   1334           (yaml--any (yaml--parse-from-grammar 'l-nb-folded-lines n)
   1335                      (yaml--parse-from-grammar 'l-nb-spaced-lines n))))))
   1336 
   1337     ('c-alias
   1338      (yaml--frame "c-alias" (yaml--chr ?\*)))
   1339 
   1340     ('ns-single-char
   1341      (yaml--frame "ns-single-char"
   1342        (yaml--but (lambda () (yaml--parse-from-grammar 'nb-single-char))
   1343                   (lambda () (yaml--parse-from-grammar 's-white)))))
   1344 
   1345     ('c-l-block-map-implicit-value
   1346      (let ((n (nth 0 args)))
   1347        (yaml--frame "c-l-block-map-implicit-value"
   1348          (yaml--all (yaml--chr ?\:)
   1349                     (yaml--any
   1350                      (yaml--parse-from-grammar 's-l+block-node n "block-out")
   1351                      (yaml--all (yaml--parse-from-grammar 'e-node)
   1352                                 (yaml--parse-from-grammar 's-l-comments)))))))
   1353 
   1354     ('ns-uri-char
   1355      (yaml--frame "ns-uri-char"
   1356        (yaml--any (yaml--all (yaml--chr ?\%)
   1357                              (yaml--parse-from-grammar 'ns-hex-digit)
   1358                              (yaml--parse-from-grammar 'ns-hex-digit))
   1359                   (yaml--parse-from-grammar 'ns-word-char)
   1360                   (yaml--chr ?\#)
   1361                   (yaml--chr ?\;)
   1362                   (yaml--chr ?\/)
   1363                   (yaml--chr ?\?)
   1364                   (yaml--chr ?\:)
   1365                   (yaml--chr ?\@)
   1366                   (yaml--chr ?\&)
   1367                   (yaml--chr ?\=)
   1368                   (yaml--chr ?\+)
   1369                   (yaml--chr ?\$)
   1370                   (yaml--chr ?\,)
   1371                   (yaml--chr ?\_)
   1372                   (yaml--chr ?\.)
   1373                   (yaml--chr ?\!)
   1374                   (yaml--chr ?\~)
   1375                   (yaml--chr ?\*)
   1376                   (yaml--chr ?\')
   1377                   (yaml--chr ?\()
   1378                   (yaml--chr ?\))
   1379                   (yaml--chr ?\[)
   1380                   (yaml--chr ?\]))))
   1381 
   1382     ('ns-esc-16-bit
   1383      (yaml--frame "ns-esc-16-bit"
   1384        (yaml--all (yaml--chr ?u)
   1385                   (yaml--rep 4 4
   1386                     (lambda () (yaml--parse-from-grammar 'ns-hex-digit))))))
   1387 
   1388     ('l-nb-spaced-lines
   1389      (let ((n (nth 0 args)))
   1390        (yaml--frame "l-nb-spaced-lines"
   1391          (yaml--all
   1392           (yaml--parse-from-grammar 's-nb-spaced-text n)
   1393           (yaml--rep2 0 nil
   1394             (lambda () (yaml--all
   1395                         (yaml--parse-from-grammar 'b-l-spaced n)
   1396                         (yaml--parse-from-grammar 's-nb-spaced-text n))))))))
   1397 
   1398     ('ns-plain
   1399      (let ((n (nth 0 args))
   1400            (c (nth 1 args)))
   1401        (yaml--frame "ns-plain"
   1402          (pcase c
   1403            ("block-key" (yaml--parse-from-grammar 'ns-plain-one-line c))
   1404            ("flow-in" (yaml--parse-from-grammar 'ns-plain-multi-line n c))
   1405            ("flow-key" (yaml--parse-from-grammar 'ns-plain-one-line c))
   1406            ("flow-out" (yaml--parse-from-grammar 'ns-plain-multi-line n c))))))
   1407 
   1408     ('c-printable
   1409      (yaml--frame "c-printable"
   1410        (yaml--any (yaml--chr ?\x09)
   1411                   (yaml--chr ?\x0A)
   1412                   (yaml--chr ?\x0D)
   1413                   (yaml--chr-range ?\x20 ?\x7E)
   1414                   (yaml--chr ?\x85)
   1415                   (yaml--chr-range ?\xA0 ?\xD7FF)
   1416                   (yaml--chr-range ?\xE000 ?\xFFFD)
   1417                   (yaml--chr-range ?\x010000 ?\x10FFFF))))
   1418 
   1419     ('c-mapping-value
   1420      (yaml--frame "c-mapping-value" (yaml--chr ?\:)))
   1421 
   1422     ('l-nb-literal-text
   1423      (let ((n (nth 0 args)))
   1424        (yaml--frame "l-nb-literal-text"
   1425          (yaml--all
   1426           (yaml--rep2 0 nil
   1427             (lambda () (yaml--parse-from-grammar 'l-empty n "block-in")))
   1428           (yaml--parse-from-grammar 's-indent n)
   1429           (yaml--rep 1 nil
   1430             (lambda () (yaml--parse-from-grammar 'nb-char)))))))
   1431 
   1432     ('ns-plain-char
   1433      (let ((c (nth 0 args)))
   1434        (yaml--frame "ns-plain-char"
   1435          (yaml--any
   1436           (yaml--but
   1437            (lambda () (yaml--parse-from-grammar 'ns-plain-safe c))
   1438            (lambda () (yaml--chr ?\:)) (lambda () (yaml--chr ?\#)))
   1439           (yaml--all
   1440            (yaml--chk "<=" (yaml--parse-from-grammar 'ns-char))
   1441            (yaml--chr ?\#))
   1442           (yaml--all
   1443            (yaml--chr ?\:)
   1444            (yaml--chk "=" (yaml--parse-from-grammar 'ns-plain-safe c)))))))
   1445 
   1446     ('ns-anchor-char
   1447      (yaml--frame "ns-anchor-char"
   1448        (yaml--but (lambda () (yaml--parse-from-grammar 'ns-char))
   1449                   (lambda () (yaml--parse-from-grammar 'c-flow-indicator)))))
   1450 
   1451     ('s-l+block-scalar
   1452      (let ((n (nth 0 args)) (c (nth 1 args)))
   1453        (yaml--frame "s-l+block-scalar"
   1454          (yaml--all (yaml--parse-from-grammar 's-separate (+ n 1) c)
   1455                     (yaml--rep 0 1
   1456                       (lambda ()
   1457                         (yaml--all
   1458                          (yaml--parse-from-grammar 'c-ns-properties (+ n 1) c)
   1459                          (yaml--parse-from-grammar 's-separate (+ n 1) c))))
   1460                     (yaml--any (yaml--parse-from-grammar 'c-l+literal n)
   1461                                (yaml--parse-from-grammar 'c-l+folded n))))))
   1462 
   1463     ('ns-plain-safe-in
   1464      (yaml--frame "ns-plain-safe-in"
   1465        (yaml--but (lambda () (yaml--parse-from-grammar 'ns-char))
   1466                   (lambda () (yaml--parse-from-grammar 'c-flow-indicator)))))
   1467 
   1468     ('nb-single-text
   1469      (let ((n (nth 0 args)) (c (nth 1 args)))
   1470        (yaml--frame "nb-single-text"
   1471          (pcase c
   1472            ("block-key" (yaml--parse-from-grammar 'nb-single-one-line))
   1473            ("flow-in" (yaml--parse-from-grammar 'nb-single-multi-line n))
   1474            ("flow-key" (yaml--parse-from-grammar 'nb-single-one-line))
   1475            ("flow-out" (yaml--parse-from-grammar 'nb-single-multi-line n))))))
   1476 
   1477     ('s-indent-le
   1478      (let ((n (nth 0 args)))
   1479        (yaml--frame "s-indent-le"
   1480          (yaml--all (yaml--rep2 0 nil
   1481                       (lambda () (yaml--parse-from-grammar 's-space)))
   1482                     (<= (length (yaml--match)) n)))))
   1483 
   1484     ('ns-esc-carriage-return
   1485      (yaml--frame "ns-esc-carriage-return" (yaml--chr ?r)))
   1486 
   1487     ('l-chomped-empty
   1488      (let ((n (nth 0 args))
   1489            (tt (nth 1 args)))
   1490        (yaml--frame "l-chomped-empty"
   1491          (pcase tt
   1492            ("clip" (yaml--parse-from-grammar 'l-strip-empty n))
   1493            ("keep" (yaml--parse-from-grammar 'l-keep-empty n))
   1494            ("strip" (yaml--parse-from-grammar 'l-strip-empty n))))))
   1495 
   1496     ('c-s-implicit-json-key
   1497      (let ((c (nth 0 args)))
   1498        (yaml--frame "c-s-implicit-json-key"
   1499          (yaml--all
   1500           (yaml--max 1024)
   1501           (yaml--parse-from-grammar 'c-flow-json-node nil c)
   1502           (yaml--rep 0 1
   1503             (lambda () (yaml--parse-from-grammar 's-separate-in-line)))))))
   1504 
   1505     ('b-as-space
   1506      (yaml--frame "b-as-space"
   1507        (yaml--parse-from-grammar 'b-break)))
   1508 
   1509     ('ns-s-flow-seq-entries
   1510      (let ((n (nth 0 args)) (c (nth 1 args)))
   1511        (yaml--frame "ns-s-flow-seq-entries"
   1512          (yaml--all
   1513           (yaml--parse-from-grammar 'ns-flow-seq-entry n c)
   1514           (yaml--rep 0 1
   1515             (lambda () (yaml--parse-from-grammar 's-separate n c)))
   1516           (yaml--rep 0 1
   1517             (lambda ()
   1518               (yaml--all
   1519                (yaml--chr ?\,)
   1520                (yaml--rep 0 1
   1521                  (lambda () (yaml--parse-from-grammar 's-separate n c)))
   1522                (yaml--rep 0 1
   1523                  (lambda ()
   1524                    (yaml--parse-from-grammar 'ns-s-flow-seq-entries
   1525                                              n
   1526                                              c))))))))))
   1527 
   1528     ('l-block-map-explicit-value
   1529      (let ((n (nth 0 args)))
   1530        (yaml--frame "l-block-map-explicit-value"
   1531          (yaml--all
   1532           (yaml--parse-from-grammar 's-indent n)
   1533           (yaml--chr ?\:)
   1534           (yaml--parse-from-grammar 's-l+block-indented n "block-out")))))
   1535 
   1536     ('c-ns-flow-map-json-key-entry
   1537      (let ((n (nth 0 args)) (c (nth 1 args)))
   1538        (yaml--frame "c-ns-flow-map-json-key-entry"
   1539          (yaml--all
   1540           (yaml--parse-from-grammar 'c-flow-json-node n c)
   1541           (yaml--any
   1542            (yaml--all
   1543             (yaml--rep 0 1
   1544               (lambda () (yaml--parse-from-grammar 's-separate n c)))
   1545             (yaml--parse-from-grammar 'c-ns-flow-map-adjacent-value n c))
   1546            (yaml--parse-from-grammar 'e-node))))))
   1547 
   1548     ('c-sequence-entry
   1549      (yaml--frame "c-sequence-entry" (yaml--chr ?\-)))
   1550 
   1551     ('l-bare-document
   1552      (yaml--frame "l-bare-document"
   1553        (yaml--all (yaml--exclude "c-forbidden")
   1554                   (yaml--parse-from-grammar 's-l+block-node -1 "block-in"))))
   1555 
   1556     ;; TODO: don't use the symbol t as a variable.
   1557     ('b-chomped-last
   1558      (let ((tt (nth 0 args)))
   1559        (yaml--frame "b-chomped-last"
   1560          (pcase tt
   1561            ("clip"
   1562             ;; TODO: Fix this
   1563             (yaml--any (yaml--parse-from-grammar 'b-as-line-feed)
   1564                        (yaml--end-of-stream)))
   1565            ("keep"
   1566             (yaml--any (yaml--parse-from-grammar 'b-as-line-feed)
   1567                        (yaml--end-of-stream)))
   1568            ("strip"
   1569             (yaml--any (yaml--parse-from-grammar 'b-non-content)
   1570                        (yaml--end-of-stream)))))))
   1571 
   1572     ('l-trail-comments
   1573      (let ((n (nth 0 args)))
   1574        (yaml--frame "l-trail-comments"
   1575          (yaml--all (yaml--parse-from-grammar 's-indent-lt n)
   1576                     (yaml--parse-from-grammar 'c-nb-comment-text)
   1577                     (yaml--parse-from-grammar 'b-comment)
   1578                     (yaml--rep2 0 nil
   1579                       (lambda () (yaml--parse-from-grammar 'l-comment)))))))
   1580 
   1581     ('ns-flow-map-yaml-key-entry
   1582      (let ((n (nth 0 args)) (c (nth 1 args)))
   1583        (yaml--frame "ns-flow-map-yaml-key-entry"
   1584          (yaml--all
   1585           (yaml--parse-from-grammar 'ns-flow-yaml-node n c)
   1586           (yaml--any
   1587            (yaml--all
   1588             (yaml--rep 0 1
   1589               (lambda () (yaml--parse-from-grammar 's-separate n c)))
   1590             (yaml--parse-from-grammar 'c-ns-flow-map-separate-value n c))
   1591            (yaml--parse-from-grammar 'e-node))))))
   1592 
   1593     ('s-indent
   1594      (let ((n (nth 0 args)))
   1595        (yaml--frame "s-indent"
   1596          (yaml--rep n n (lambda () (yaml--parse-from-grammar 's-space))))))
   1597 
   1598     ('ns-esc-line-separator
   1599      (yaml--frame "ns-esc-line-separator" (yaml--chr ?L)))
   1600 
   1601     ('ns-flow-yaml-node
   1602      (let ((n (nth 0 args)) (c (nth 1 args)))
   1603        (yaml--frame "ns-flow-yaml-node"
   1604          (yaml--any
   1605           (yaml--parse-from-grammar 'c-ns-alias-node)
   1606           (yaml--parse-from-grammar 'ns-flow-yaml-content n c)
   1607           (yaml--all
   1608            (yaml--parse-from-grammar 'c-ns-properties n c)
   1609            (yaml--any
   1610             (yaml--all
   1611              (yaml--parse-from-grammar 's-separate n c)
   1612              (yaml--parse-from-grammar 'ns-flow-yaml-content n c))
   1613             (yaml--parse-from-grammar 'e-scalar)))))))
   1614 
   1615     ('ns-yaml-version
   1616      (yaml--frame "ns-yaml-version"
   1617        (yaml--all (yaml--rep 1 nil
   1618                     (lambda () (yaml--parse-from-grammar 'ns-dec-digit)))
   1619                   (yaml--chr ?\.)
   1620                   (yaml--rep 1 nil
   1621                     (lambda () (yaml--parse-from-grammar 'ns-dec-digit))))))
   1622 
   1623     ('c-folded
   1624      (yaml--frame "c-folded" (yaml--chr ?\>)))
   1625 
   1626     ('c-directives-end
   1627      (yaml--frame "c-directives-end"
   1628        (yaml--all (yaml--chr ?\-) (yaml--chr ?\-) (yaml--chr ?\-))))
   1629 
   1630     ('s-double-break
   1631      (let ((n (nth 0 args)))
   1632        (yaml--frame "s-double-break"
   1633          (yaml--any (yaml--parse-from-grammar 's-double-escaped n)
   1634                     (yaml--parse-from-grammar 's-flow-folded n)))))
   1635 
   1636     ('s-nb-spaced-text
   1637      (let ((n (nth 0 args)))
   1638        (yaml--frame "s-nb-spaced-text"
   1639          (yaml--all (yaml--parse-from-grammar 's-indent n)
   1640                     (yaml--parse-from-grammar 's-white)
   1641                     (yaml--rep2 0 nil
   1642                       (lambda () (yaml--parse-from-grammar 'nb-char)))))))
   1643 
   1644     ('l-folded-content
   1645      (let ((n (nth 0 args))
   1646            (tt (nth 1 args)))
   1647        (yaml--frame "l-folded-content"
   1648          (yaml--all
   1649           (yaml--rep 0 1
   1650             (lambda ()
   1651               (yaml--all (yaml--parse-from-grammar 'l-nb-diff-lines n)
   1652                          (yaml--parse-from-grammar 'b-chomped-last tt))))
   1653           (yaml--parse-from-grammar 'l-chomped-empty n tt)))))
   1654 
   1655     ('nb-ns-plain-in-line
   1656      (let ((c (nth 0 args)))
   1657        (yaml--frame "nb-ns-plain-in-line"
   1658          (yaml--rep2 0 nil
   1659            (lambda () (yaml--all
   1660                        (yaml--rep2 0 nil
   1661                          (lambda () (yaml--parse-from-grammar 's-white)))
   1662                        (yaml--parse-from-grammar 'ns-plain-char c)))))))
   1663 
   1664     ('nb-single-multi-line
   1665      (let ((n (nth 0 args)))
   1666        (yaml--frame "nb-single-multi-line"
   1667          (yaml--all
   1668           (yaml--parse-from-grammar 'nb-ns-single-in-line)
   1669           (yaml--any
   1670            (yaml--parse-from-grammar 's-single-next-line n)
   1671            (yaml--rep2 0 nil
   1672              (lambda () (yaml--parse-from-grammar 's-white))))))))
   1673 
   1674     ('l-document-suffix
   1675      (yaml--frame "l-document-suffix"
   1676        (yaml--all (yaml--parse-from-grammar 'c-document-end)
   1677                   (yaml--parse-from-grammar 's-l-comments))))
   1678 
   1679     ('c-sequence-start
   1680      (yaml--frame "c-sequence-start"
   1681        (yaml--chr ?\[)))
   1682 
   1683     ('ns-l-block-map-entry
   1684      (yaml--frame "ns-l-block-map-entry"
   1685        (yaml--any
   1686         (yaml--parse-from-grammar 'c-l-block-map-explicit-entry
   1687                                   (nth 0 args))
   1688         (yaml--parse-from-grammar 'ns-l-block-map-implicit-entry
   1689                                   (nth 0 args)))))
   1690 
   1691     ('ns-l-compact-mapping
   1692      (yaml--frame "ns-l-compact-mapping"
   1693        (yaml--all
   1694         (yaml--parse-from-grammar 'ns-l-block-map-entry (nth 0 args))
   1695         (yaml--rep2 0 nil
   1696           (lambda ()
   1697             (yaml--all
   1698              (yaml--parse-from-grammar 's-indent (nth 0 args))
   1699              (yaml--parse-from-grammar 'ns-l-block-map-entry (nth 0 args))))))))
   1700 
   1701     ('ns-esc-space
   1702      (yaml--frame "ns-esc-space" (yaml--chr ?\x20)))
   1703     ('ns-esc-vertical-tab
   1704      (yaml--frame "ns-esc-vertical-tab" (yaml--chr ?v)))
   1705 
   1706     ('ns-s-implicit-yaml-key
   1707      (let ((c (nth 0 args)))
   1708        (yaml--frame "ns-s-implicit-yaml-key"
   1709          (yaml--all
   1710           (yaml--max 1024)
   1711           (yaml--parse-from-grammar 'ns-flow-yaml-node nil c)
   1712           (yaml--rep 0 1
   1713             (lambda () (yaml--parse-from-grammar 's-separate-in-line)))))))
   1714 
   1715     ('b-l-folded
   1716      (let ((n (nth 0 args)) (c (nth 1 args)))
   1717        (yaml--frame "b-l-folded"
   1718          (yaml--any (yaml--parse-from-grammar 'b-l-trimmed n c)
   1719                     (yaml--parse-from-grammar 'b-as-space)))))
   1720 
   1721     ('s-l+block-collection
   1722      (yaml--frame "s-l+block-collection"
   1723        (yaml--all
   1724         (yaml--rep 0 1
   1725           (lambda ()
   1726             (yaml--all
   1727              (yaml--parse-from-grammar
   1728               's-separate
   1729               (+ (nth 0 args) 1)
   1730               (nth 1 args))
   1731              (yaml--parse-from-grammar
   1732               'c-ns-properties
   1733               (+ (nth 0 args) 1)
   1734               (nth 1 args)))))
   1735         (yaml--parse-from-grammar 's-l-comments)
   1736         (yaml--any
   1737          (yaml--parse-from-grammar
   1738           'l+block-sequence
   1739           (yaml--parse-from-grammar 'seq-spaces (nth 0 args) (nth 1 args)))
   1740          (yaml--parse-from-grammar 'l+block-mapping (nth 0 args))))))
   1741 
   1742     ('c-quoted-quote
   1743      (yaml--frame "c-quoted-quote" (yaml--all (yaml--chr ?\') (yaml--chr ?\'))))
   1744 
   1745     ('l+block-sequence
   1746      (yaml--frame "l+block-sequence"
   1747        ;; NOTE: deviated from the spec example here by making new-m at least 1.
   1748        ;; The wording and examples lead me to believe this is how it's done.
   1749        ;; ie /* For some fixed auto-detected m > 0 */
   1750        (let ((new-m (max (yaml--auto-detect-indent (nth 0 args)) 1)))
   1751          (yaml--all
   1752           (yaml--set m new-m)
   1753           (yaml--rep 1 nil
   1754             (lambda ()
   1755               (yaml--all
   1756                (yaml--parse-from-grammar
   1757                 's-indent
   1758                 (+ (nth 0 args) new-m))
   1759                (yaml--parse-from-grammar
   1760                 'c-l-block-seq-entry
   1761                 (+ (nth 0 args) new-m)))))))))
   1762 
   1763     ('c-double-quote
   1764      (yaml--frame "c-double-quote"
   1765        (yaml--chr ?\")))
   1766 
   1767     ('ns-esc-backspace
   1768      (yaml--frame "ns-esc-backspace"
   1769        (yaml--chr ?b)))
   1770 
   1771     ('c-flow-json-content
   1772      (let ((n (nth 0 args)) (c (nth 1 args)))
   1773        (yaml--frame "c-flow-json-content"
   1774          (yaml--any (yaml--parse-from-grammar 'c-flow-sequence n c)
   1775                     (yaml--parse-from-grammar 'c-flow-mapping n c)
   1776                     (yaml--parse-from-grammar 'c-single-quoted n c)
   1777                     (yaml--parse-from-grammar 'c-double-quoted n c)))))
   1778 
   1779     ('c-mapping-end
   1780      (yaml--frame "c-mapping-end" (yaml--chr ?\})))
   1781 
   1782     ('nb-single-char
   1783      (yaml--frame "nb-single-char"
   1784        (yaml--any (yaml--parse-from-grammar 'c-quoted-quote)
   1785                   (yaml--but (lambda () (yaml--parse-from-grammar 'nb-json))
   1786                              (lambda () (yaml--chr ?\'))))))
   1787 
   1788     ('ns-flow-node
   1789      (let ((n (nth 0 args)) (c (nth 1 args)))
   1790        (yaml--frame "ns-flow-node"
   1791          (yaml--any
   1792           (yaml--parse-from-grammar 'c-ns-alias-node)
   1793           (yaml--parse-from-grammar 'ns-flow-content n c)
   1794           (yaml--all
   1795            (yaml--parse-from-grammar 'c-ns-properties n c)
   1796            (yaml--any
   1797             (yaml--all (yaml--parse-from-grammar 's-separate n c)
   1798                        (yaml--parse-from-grammar 'ns-flow-content n c))
   1799             (yaml--parse-from-grammar 'e-scalar)))))))
   1800 
   1801     ('c-non-specific-tag
   1802      (yaml--frame "c-non-specific-tag" (yaml--chr ?\!)))
   1803 
   1804     ('l-directive-document
   1805      (yaml--frame "l-directive-document"
   1806        (yaml--all (yaml--rep 1 nil
   1807                     (lambda () (yaml--parse-from-grammar 'l-directive)))
   1808                   (yaml--parse-from-grammar 'l-explicit-document))))
   1809 
   1810     ('c-l-block-map-explicit-entry
   1811      (let ((n (nth 0 args)))
   1812        (yaml--frame "c-l-block-map-explicit-entry"
   1813          (yaml--all
   1814           (yaml--parse-from-grammar 'c-l-block-map-explicit-key n)
   1815           (yaml--any (yaml--parse-from-grammar 'l-block-map-explicit-value n)
   1816                      (yaml--parse-from-grammar 'e-node))))))
   1817 
   1818     ('e-node
   1819      (yaml--frame "e-node"
   1820        (yaml--parse-from-grammar 'e-scalar)))
   1821 
   1822     ('seq-spaces
   1823      (let ((n (nth 0 args)) (c (nth 1 args)))
   1824        (yaml--frame "seq-spaces"
   1825          (pcase c
   1826            ("block-in" n)
   1827            ("block-out" (yaml--sub n 1))))))
   1828 
   1829     ('l-yaml-stream
   1830      (yaml--frame "l-yaml-stream"
   1831        (yaml--all
   1832         (yaml--rep2 0 nil
   1833           (lambda () (yaml--parse-from-grammar 'l-document-prefix)))
   1834         (yaml--rep 0 1
   1835           (lambda () (yaml--parse-from-grammar 'l-any-document)))
   1836         (yaml--rep2 0 nil
   1837           (lambda ()
   1838             (yaml--any
   1839              (yaml--all
   1840               (yaml--rep 1 nil
   1841                 (lambda () (yaml--parse-from-grammar 'l-document-suffix)))
   1842               (yaml--rep2 0 nil
   1843                 (lambda () (yaml--parse-from-grammar 'l-document-prefix)))
   1844               (yaml--rep 0 1
   1845                 (lambda () (yaml--parse-from-grammar 'l-any-document))))
   1846              (yaml--all
   1847               (yaml--rep2 0 nil
   1848                 (lambda () (yaml--parse-from-grammar 'l-document-prefix)))
   1849               (yaml--rep 0 1
   1850                 (lambda ()
   1851                   (yaml--parse-from-grammar 'l-explicit-document))))))))))
   1852 
   1853     ('nb-double-one-line
   1854      (yaml--frame "nb-double-one-line"
   1855        (yaml--rep2 0 nil
   1856          (lambda () (yaml--parse-from-grammar 'nb-double-char)))))
   1857 
   1858     ('s-l-comments
   1859      (yaml--frame "s-l-comments"
   1860        (yaml--all (yaml--any
   1861                    (yaml--parse-from-grammar 's-b-comment)
   1862                    (yaml--start-of-line))
   1863                   (yaml--rep2 0 nil
   1864                     (lambda () (yaml--parse-from-grammar 'l-comment))))))
   1865 
   1866     ('nb-char
   1867      (yaml--frame "nb-char"
   1868        (yaml--but (lambda () (yaml--parse-from-grammar 'c-printable))
   1869                   (lambda () (yaml--parse-from-grammar 'b-char))
   1870                   (lambda () (yaml--parse-from-grammar 'c-byte-order-mark)))))
   1871 
   1872     ('ns-plain-first
   1873      (let ((c (nth 0 args)))
   1874        (yaml--frame "ns-plain-first"
   1875          (yaml--any
   1876           (yaml--but (lambda () (yaml--parse-from-grammar 'ns-char))
   1877                      (lambda () (yaml--parse-from-grammar 'c-indicator)))
   1878           (yaml--all
   1879            (yaml--any (yaml--chr ?\?)
   1880                       (yaml--chr ?\:)
   1881                       (yaml--chr ?\-))
   1882            (yaml--chk "=" (yaml--parse-from-grammar 'ns-plain-safe c)))))))
   1883 
   1884     ('c-ns-esc-char
   1885      (yaml--frame "c-ns-esc-char"
   1886        (yaml--all
   1887         (yaml--chr ?\\)
   1888         (yaml--any (yaml--parse-from-grammar 'ns-esc-null)
   1889                    (yaml--parse-from-grammar 'ns-esc-bell)
   1890                    (yaml--parse-from-grammar 'ns-esc-backspace)
   1891                    (yaml--parse-from-grammar 'ns-esc-horizontal-tab)
   1892                    (yaml--parse-from-grammar 'ns-esc-line-feed)
   1893                    (yaml--parse-from-grammar 'ns-esc-vertical-tab)
   1894                    (yaml--parse-from-grammar 'ns-esc-form-feed)
   1895                    (yaml--parse-from-grammar 'ns-esc-carriage-return)
   1896                    (yaml--parse-from-grammar 'ns-esc-escape)
   1897                    (yaml--parse-from-grammar 'ns-esc-space)
   1898                    (yaml--parse-from-grammar 'ns-esc-double-quote)
   1899                    (yaml--parse-from-grammar 'ns-esc-slash)
   1900                    (yaml--parse-from-grammar 'ns-esc-backslash)
   1901                    (yaml--parse-from-grammar 'ns-esc-next-line)
   1902                    (yaml--parse-from-grammar 'ns-esc-non-breaking-space)
   1903                    (yaml--parse-from-grammar 'ns-esc-line-separator)
   1904                    (yaml--parse-from-grammar 'ns-esc-paragraph-separator)
   1905                    (yaml--parse-from-grammar 'ns-esc-8-bit)
   1906                    (yaml--parse-from-grammar 'ns-esc-16-bit)
   1907                    (yaml--parse-from-grammar 'ns-esc-32-bit)))))
   1908 
   1909     ('ns-flow-map-entry
   1910      (let ((n (nth 0 args)) (c (nth 1 args)))
   1911        (yaml--frame "ns-flow-map-entry"
   1912          (yaml--any
   1913           (yaml--all (yaml--chr ?\?)
   1914                      (yaml--parse-from-grammar 's-separate n c)
   1915                      (yaml--parse-from-grammar 'ns-flow-map-explicit-entry n c))
   1916           (yaml--parse-from-grammar 'ns-flow-map-implicit-entry n c)))))
   1917 
   1918     ('l-explicit-document
   1919      (yaml--frame "l-explicit-document"
   1920        (yaml--all
   1921         (yaml--parse-from-grammar 'c-directives-end)
   1922         (yaml--any (yaml--parse-from-grammar 'l-bare-document)
   1923                    (yaml--all (yaml--parse-from-grammar 'e-node)
   1924                               (yaml--parse-from-grammar 's-l-comments))))))
   1925 
   1926     ('s-white
   1927      (yaml--frame "s-white"
   1928        (yaml--any (yaml--parse-from-grammar 's-space)
   1929                   (yaml--parse-from-grammar 's-tab))))
   1930 
   1931     ('l-keep-empty
   1932      (let ((n (nth 0 args)))
   1933        (yaml--frame "l-keep-empty"
   1934          (yaml--all
   1935           (yaml--rep2 0 nil
   1936             (lambda () (yaml--parse-from-grammar 'l-empty n "block-in")))
   1937           (yaml--rep 0 1
   1938             (lambda () (yaml--parse-from-grammar 'l-trail-comments n)))))))
   1939 
   1940     ('ns-tag-prefix
   1941      (yaml--frame "ns-tag-prefix"
   1942        (yaml--any (yaml--parse-from-grammar 'c-ns-local-tag-prefix)
   1943                   (yaml--parse-from-grammar 'ns-global-tag-prefix))))
   1944 
   1945     ('c-l+folded
   1946      (let ((n (nth 0 args)))
   1947        (yaml--frame "c-l+folded"
   1948          (yaml--all
   1949           (yaml--chr ?\>)
   1950           (yaml--parse-from-grammar 'c-b-block-header
   1951                                     n
   1952                                     (yaml--state-curr-t))
   1953           (yaml--parse-from-grammar 'l-folded-content
   1954                                     (max (+ n (yaml--state-curr-m)) 1)
   1955                                     (yaml--state-curr-t))))))
   1956 
   1957     ('ns-directive-name
   1958      (yaml--frame "ns-directive-name"
   1959        (yaml--rep 1 nil (lambda () (yaml--parse-from-grammar 'ns-char)))))
   1960 
   1961     ('b-char
   1962      (yaml--frame "b-char"
   1963        (yaml--any (yaml--parse-from-grammar 'b-line-feed)
   1964                   (yaml--parse-from-grammar 'b-carriage-return))))
   1965 
   1966     ('ns-plain-multi-line
   1967      (let ((n (nth 0 args)) (c (nth 1 args)))
   1968        (yaml--frame "ns-plain-multi-line"
   1969          (yaml--all
   1970           (yaml--parse-from-grammar 'ns-plain-one-line c)
   1971           (yaml--rep2 0 nil
   1972             (lambda ()
   1973               (yaml--parse-from-grammar 's-ns-plain-next-line n c)))))))
   1974 
   1975     ('ns-char
   1976      (yaml--frame "ns-char"
   1977        (yaml--but (lambda () (yaml--parse-from-grammar 'nb-char))
   1978                   (lambda () (yaml--parse-from-grammar 's-white)))))
   1979 
   1980     ('s-space
   1981      (yaml--frame "s-space" (yaml--chr ?\x20)))
   1982 
   1983     ('c-l-block-seq-entry
   1984      (yaml--frame "c-l-block-seq-entry"
   1985        (yaml--all (yaml--chr ?\-)
   1986                   (yaml--chk "!" (yaml--parse-from-grammar 'ns-char))
   1987                   (yaml--parse-from-grammar 's-l+block-indented
   1988                                             (nth 0 args)
   1989                                             "block-in"))))
   1990 
   1991     ('c-ns-properties
   1992      (let ((n (nth 0 args)) (c (nth 1 args)))
   1993        (yaml--frame "c-ns-properties"
   1994          (yaml--any
   1995           (yaml--all
   1996            (yaml--parse-from-grammar 'c-ns-tag-property)
   1997            (yaml--rep 0 1
   1998              (lambda ()
   1999                (yaml--all
   2000                 (yaml--parse-from-grammar 's-separate n c)
   2001                 (yaml--parse-from-grammar 'c-ns-anchor-property)))))
   2002           (yaml--all
   2003            (yaml--parse-from-grammar 'c-ns-anchor-property)
   2004            (yaml--rep 0 1
   2005              (lambda () (yaml--all
   2006                          (yaml--parse-from-grammar 's-separate n c)
   2007                          (yaml--parse-from-grammar 'c-ns-tag-property)))))))))
   2008 
   2009     ('ns-directive-parameter
   2010      (yaml--frame "ns-directive-parameter"
   2011        (yaml--rep 1 nil (lambda () (yaml--parse-from-grammar 'ns-char)))))
   2012 
   2013     ('c-chomping-indicator
   2014      (yaml--frame "c-chomping-indicator"
   2015        (yaml--any (when (yaml--chr ?\-) (yaml--set t "strip") t)
   2016                   (when (yaml--chr ?\+) (yaml--set t "keep") t)
   2017                   (when (yaml--empty) (yaml--set t "clip") t))))
   2018 
   2019     ('ns-global-tag-prefix
   2020      (yaml--frame "ns-global-tag-prefix"
   2021        (yaml--all
   2022         (yaml--parse-from-grammar 'ns-tag-char)
   2023         (yaml--rep2 0 nil
   2024           (lambda () (yaml--parse-from-grammar 'ns-uri-char))))))
   2025 
   2026     ('c-ns-flow-pair-json-key-entry
   2027      (let ((n (nth 0 args)) (c (nth 1 args)))
   2028        (yaml--frame "c-ns-flow-pair-json-key-entry"
   2029          (yaml--all
   2030           (yaml--parse-from-grammar 'c-s-implicit-json-key "flow-key")
   2031           (yaml--parse-from-grammar 'c-ns-flow-map-adjacent-value n c)))))
   2032 
   2033     ('l-literal-content
   2034      (let ((n (nth 0 args))
   2035            (tt (nth 1 args)))
   2036        (yaml--frame "l-literal-content"
   2037          (yaml--all
   2038           (yaml--rep 0 1
   2039             (lambda ()
   2040               (yaml--all (yaml--parse-from-grammar 'l-nb-literal-text n)
   2041                          (yaml--rep2 0 nil
   2042                            (lambda ()
   2043                              (yaml--parse-from-grammar 'b-nb-literal-next n)))
   2044                          (yaml--parse-from-grammar 'b-chomped-last tt))))
   2045           (yaml--parse-from-grammar 'l-chomped-empty n tt)))))
   2046 
   2047     ('c-document-end
   2048      (yaml--frame "c-document-end"
   2049        (yaml--all (yaml--chr ?\.)
   2050                   (yaml--chr ?\.)
   2051                   (yaml--chr ?\.))))
   2052 
   2053     ('nb-double-text
   2054      (let ((n (nth 0 args)) (c (nth 1 args)))
   2055        (yaml--frame "nb-double-text"
   2056          (pcase c
   2057            ("block-key" (yaml--parse-from-grammar 'nb-double-one-line))
   2058            ("flow-in" (yaml--parse-from-grammar 'nb-double-multi-line n))
   2059            ("flow-key" (yaml--parse-from-grammar 'nb-double-one-line))
   2060            ("flow-out" (yaml--parse-from-grammar 'nb-double-multi-line n))))))
   2061 
   2062     ('s-b-comment
   2063      (yaml--frame "s-b-comment"
   2064        (yaml--all
   2065         (yaml--rep 0 1
   2066           (lambda ()
   2067             (yaml--all
   2068              (yaml--parse-from-grammar 's-separate-in-line)
   2069              (yaml--rep 0 1
   2070                (lambda () (yaml--parse-from-grammar 'c-nb-comment-text))))))
   2071         (yaml--parse-from-grammar 'b-comment))))
   2072 
   2073     ('s-block-line-prefix
   2074      (let ((n (nth 0 args)))
   2075        (yaml--frame "s-block-line-prefix"
   2076          (yaml--parse-from-grammar 's-indent n))))
   2077 
   2078     ('c-tag-handle
   2079      (yaml--frame "c-tag-handle"
   2080        (yaml--any (yaml--parse-from-grammar 'c-named-tag-handle)
   2081                   (yaml--parse-from-grammar 'c-secondary-tag-handle)
   2082                   (yaml--parse-from-grammar 'c-primary-tag-handle))))
   2083 
   2084     ('ns-plain-one-line
   2085      (let ((c (nth 0 args)))
   2086        (yaml--frame "ns-plain-one-line"
   2087          (yaml--all (yaml--parse-from-grammar 'ns-plain-first c)
   2088                     (yaml--parse-from-grammar 'nb-ns-plain-in-line c)))))
   2089 
   2090     ('nb-json
   2091      (yaml--frame "nb-json"
   2092        (yaml--any (yaml--chr ?\x09)
   2093                   (yaml--chr-range ?\x20 ?\x10FFFF))))
   2094 
   2095     ('s-ns-plain-next-line
   2096      (let ((n (nth 0 args)) (c (nth 1 args)))
   2097        (yaml--frame "s-ns-plain-next-line"
   2098          (yaml--all (yaml--parse-from-grammar 's-flow-folded n)
   2099                     (yaml--parse-from-grammar 'ns-plain-char c)
   2100                     (yaml--parse-from-grammar 'nb-ns-plain-in-line c)))))
   2101 
   2102     ('c-reserved
   2103      (yaml--frame "c-reserved"
   2104        (yaml--any (yaml--chr ?\@) (yaml--chr ?\`))))
   2105 
   2106     ('b-l-trimmed
   2107      (let ((n (nth 0 args)) (c (nth 1 args)))
   2108        (yaml--frame "b-l-trimmed"
   2109          (yaml--all
   2110           (yaml--parse-from-grammar 'b-non-content)
   2111           (yaml--rep 1 nil
   2112             (lambda () (yaml--parse-from-grammar 'l-empty n c)))))))
   2113 
   2114     ('l-document-prefix
   2115      (yaml--frame "l-document-prefix"
   2116        (yaml--all
   2117         (yaml--rep 0 1
   2118           (lambda () (yaml--parse-from-grammar 'c-byte-order-mark)))
   2119         (yaml--rep2 0 nil
   2120           (lambda () (yaml--parse-from-grammar 'l-comment))))))
   2121 
   2122     ('c-byte-order-mark
   2123      (yaml--frame "c-byte-order-mark" (yaml--chr ?\xFEFF)))
   2124 
   2125     ('c-anchor
   2126      (yaml--frame "c-anchor" (yaml--chr ?\&)))
   2127 
   2128     ('s-double-escaped
   2129      (let ((n (nth 0 args)))
   2130        (yaml--frame "s-double-escaped"
   2131          (yaml--all
   2132           (yaml--rep2 0 nil
   2133             (lambda () (yaml--parse-from-grammar 's-white)))
   2134           (yaml--chr ?\\)
   2135           (yaml--parse-from-grammar 'b-non-content)
   2136           (yaml--rep2 0 nil
   2137             (lambda () (yaml--parse-from-grammar 'l-empty n "flow-in")))
   2138           (yaml--parse-from-grammar 's-flow-line-prefix n)))))
   2139 
   2140     ('ns-esc-32-bit
   2141      (yaml--frame "ns-esc-32-bit"
   2142        (yaml--all
   2143         (yaml--chr ?U)
   2144         (yaml--rep 8 8 (lambda () (yaml--parse-from-grammar 'ns-hex-digit))))))
   2145 
   2146 
   2147     ('b-non-content
   2148      (yaml--frame "b-non-content" (yaml--parse-from-grammar 'b-break)))
   2149 
   2150     ('ns-tag-char
   2151      (yaml--frame "ns-tag-char"
   2152        (yaml--but (lambda () (yaml--parse-from-grammar 'ns-uri-char))
   2153                   (lambda () (yaml--chr ?\!))
   2154                   (lambda () (yaml--parse-from-grammar 'c-flow-indicator)))))
   2155 
   2156     ('b-carriage-return
   2157      (yaml--frame "b-carriage-return" (yaml--chr ?\x0D)))
   2158 
   2159     ('s-double-next-line
   2160      (let ((n (nth 0 args)))
   2161        (yaml--frame "s-double-next-line"
   2162          (yaml--all
   2163           (yaml--parse-from-grammar 's-double-break n)
   2164           (yaml--rep 0 1
   2165             (lambda ()
   2166               (yaml--all
   2167                (yaml--parse-from-grammar 'ns-double-char)
   2168                (yaml--parse-from-grammar 'nb-ns-double-in-line)
   2169                (yaml--any
   2170                 (yaml--parse-from-grammar 's-double-next-line n)
   2171                 (yaml--rep2 0 nil
   2172                   (lambda () (yaml--parse-from-grammar 's-white)))))))))))
   2173 
   2174     ('ns-esc-non-breaking-space
   2175      (yaml--frame "ns-esc-non-breaking-space" (yaml--chr ?\_)))
   2176 
   2177     ('l-nb-diff-lines
   2178      (let ((n (nth 0 args)))
   2179        (yaml--frame "l-nb-diff-lines"
   2180          (yaml--all
   2181           (yaml--parse-from-grammar 'l-nb-same-lines n)
   2182           (yaml--rep2 0 nil
   2183             (lambda ()
   2184               (yaml--all (yaml--parse-from-grammar 'b-as-line-feed)
   2185                          (yaml--parse-from-grammar 'l-nb-same-lines n))))))))
   2186 
   2187     ('s-flow-folded
   2188      (let ((n (nth 0 args)))
   2189        (yaml--frame "s-flow-folded"
   2190          (yaml--all
   2191           (yaml--rep 0 1
   2192             (lambda () (yaml--parse-from-grammar 's-separate-in-line)))
   2193           (yaml--parse-from-grammar 'b-l-folded n "flow-in")
   2194           (yaml--parse-from-grammar 's-flow-line-prefix n)))))
   2195 
   2196     ('ns-flow-map-explicit-entry
   2197      (let ((n (nth 0 args)) (c (nth 1 args)))
   2198        (yaml--frame "ns-flow-map-explicit-entry"
   2199          (yaml--any
   2200           (yaml--parse-from-grammar 'ns-flow-map-implicit-entry n c)
   2201           (yaml--all
   2202            (yaml--parse-from-grammar 'e-node)
   2203            (yaml--parse-from-grammar 'e-node))))))
   2204 
   2205     ('ns-l-block-map-implicit-entry
   2206      (yaml--frame "ns-l-block-map-implicit-entry"
   2207        (yaml--all
   2208         (yaml--any (yaml--parse-from-grammar 'ns-s-block-map-implicit-key)
   2209                    (yaml--parse-from-grammar 'e-node))
   2210         (yaml--parse-from-grammar 'c-l-block-map-implicit-value (nth 0 args)))))
   2211 
   2212     ('l-nb-folded-lines
   2213      (let ((n (nth 0 args)))
   2214        (yaml--frame "l-nb-folded-lines"
   2215          (yaml--all
   2216           (yaml--parse-from-grammar 's-nb-folded-text n)
   2217           (yaml--rep2 0 nil
   2218             (lambda ()
   2219               (yaml--all (yaml--parse-from-grammar 'b-l-folded n "block-in")
   2220                          (yaml--parse-from-grammar 's-nb-folded-text n))))))))
   2221 
   2222     ('c-l-block-map-explicit-key
   2223      (let ((n (nth 0 args)))
   2224        (yaml--frame "c-l-block-map-explicit-key"
   2225          (yaml--all
   2226           (yaml--chr ?\?)
   2227           (yaml--parse-from-grammar 's-l+block-indented n "block-out")))))
   2228 
   2229     ('s-separate
   2230      (let ((n (nth 0 args))
   2231            (c (nth 1 args)))
   2232        (yaml--frame "s-separate"
   2233          (pcase c
   2234            ("block-in" (yaml--parse-from-grammar 's-separate-lines n))
   2235            ("block-key" (yaml--parse-from-grammar 's-separate-in-line))
   2236            ("block-out" (yaml--parse-from-grammar 's-separate-lines n))
   2237            ("flow-in" (yaml--parse-from-grammar 's-separate-lines n))
   2238            ("flow-key" (yaml--parse-from-grammar 's-separate-in-line))
   2239            ("flow-out" (yaml--parse-from-grammar 's-separate-lines n))))))
   2240 
   2241     ('ns-flow-pair-entry
   2242      (let ((n (nth 0 args)) (c (nth 1 args)))
   2243        (yaml--frame "ns-flow-pair-entry"
   2244          (yaml--any
   2245           (yaml--parse-from-grammar 'ns-flow-pair-yaml-key-entry n c)
   2246           (yaml--parse-from-grammar 'c-ns-flow-map-empty-key-entry n c)
   2247           (yaml--parse-from-grammar 'c-ns-flow-pair-json-key-entry n c)))))
   2248 
   2249     ('c-flow-indicator
   2250      (yaml--frame "c-flow-indicator"
   2251        (yaml--any (yaml--chr ?\,)
   2252                   (yaml--chr ?\[)
   2253                   (yaml--chr ?\])
   2254                   (yaml--chr ?\{)
   2255                   (yaml--chr ?\}))))
   2256 
   2257     ('ns-flow-pair-yaml-key-entry
   2258      (let ((n (nth 0 args)) (c (nth 1 args)))
   2259        (yaml--frame "ns-flow-pair-yaml-key-entry"
   2260          (yaml--all
   2261           (yaml--parse-from-grammar 'ns-s-implicit-yaml-key "flow-key")
   2262           (yaml--parse-from-grammar 'c-ns-flow-map-separate-value n c)))))
   2263 
   2264     ('e-scalar
   2265      (yaml--frame "e-scalar" (yaml--empty)))
   2266 
   2267     ('s-indent-lt
   2268      (let ((n (nth 0 args)))
   2269        (yaml--frame "s-indent-lt"
   2270          (yaml--all
   2271           (yaml--rep2 0 nil
   2272             (lambda () (yaml--parse-from-grammar 's-space)))
   2273           (< (length (yaml--match)) n)))))
   2274 
   2275     ('nb-single-one-line
   2276      (yaml--frame "nb-single-one-line"
   2277        (yaml--rep2 0 nil
   2278          (lambda () (yaml--parse-from-grammar 'nb-single-char)))))
   2279 
   2280     ('c-collect-entry
   2281      (yaml--frame "c-collect-entry" (yaml--chr ?\,)))
   2282 
   2283     ('ns-l-compact-sequence
   2284      (let ((n (nth 0 args)))
   2285        (yaml--frame "ns-l-compact-sequence"
   2286          (yaml--all
   2287           (yaml--parse-from-grammar 'c-l-block-seq-entry n)
   2288           (yaml--rep2 0 nil
   2289             (lambda ()
   2290               (yaml--all
   2291                (yaml--parse-from-grammar 's-indent n)
   2292                (yaml--parse-from-grammar 'c-l-block-seq-entry n))))))))
   2293 
   2294     ('c-comment
   2295      (yaml--frame "c-comment" (yaml--chr ?\#)))
   2296 
   2297     ('s-line-prefix
   2298      (let ((n (nth 0 args)) (c (nth 1 args)))
   2299        (yaml--frame "s-line-prefix"
   2300          (pcase c
   2301            ("block-in" (yaml--parse-from-grammar 's-block-line-prefix n))
   2302            ("block-out" (yaml--parse-from-grammar 's-block-line-prefix n))
   2303            ("flow-in" (yaml--parse-from-grammar 's-flow-line-prefix n))
   2304            ("flow-out" (yaml--parse-from-grammar 's-flow-line-prefix n))))))
   2305 
   2306     ('s-tab
   2307      (yaml--frame "s-tab" (yaml--chr ?\x09)))
   2308 
   2309     ('c-directive
   2310      (yaml--frame "c-directive" (yaml--chr ?\%)))
   2311 
   2312     ('ns-flow-pair
   2313      (let ((n (nth 0 args)) (c (nth 1 args)))
   2314        (yaml--frame "ns-flow-pair"
   2315          (yaml--any
   2316           (yaml--all (yaml--chr ?\?)
   2317                      (yaml--parse-from-grammar 's-separate n c)
   2318                      (yaml--parse-from-grammar 'ns-flow-map-explicit-entry n c))
   2319           (yaml--parse-from-grammar 'ns-flow-pair-entry n c)))))
   2320 
   2321     ('s-l+block-indented
   2322      (yaml--frame "s-l+block-indented"
   2323        (let ((m (yaml--auto-detect-indent (nth 0 args))))
   2324          (yaml--any
   2325           (yaml--all
   2326            (yaml--parse-from-grammar 's-indent m)
   2327            (yaml--any
   2328             (yaml--parse-from-grammar 'ns-l-compact-sequence
   2329                                       (+ (nth 0 args) (+ 1 m)))
   2330             (yaml--parse-from-grammar 'ns-l-compact-mapping
   2331                                       (+ (nth 0 args) (+ 1 m)))))
   2332           (yaml--parse-from-grammar 's-l+block-node (nth 0 args) (nth 1 args))
   2333           (yaml--all (yaml--parse-from-grammar 'e-node)
   2334                      (yaml--parse-from-grammar 's-l-comments))))))
   2335 
   2336     ('c-single-quote
   2337      (yaml--frame "c-single-quote" (yaml--chr ?\')))
   2338 
   2339     ('s-flow-line-prefix
   2340      (let ((n (nth 0 args)))
   2341        (yaml--frame "s-flow-line-prefix"
   2342          (yaml--all
   2343           (yaml--parse-from-grammar 's-indent n)
   2344           (yaml--rep 0 1
   2345             (lambda () (yaml--parse-from-grammar 's-separate-in-line)))))))
   2346 
   2347     ('nb-double-char
   2348      (yaml--frame "nb-double-char"
   2349        (yaml--any
   2350         (yaml--parse-from-grammar 'c-ns-esc-char)
   2351         (yaml--but (lambda () (yaml--parse-from-grammar 'nb-json))
   2352                    (lambda () (yaml--chr ?\\)) (lambda () (yaml--chr ?\"))))))
   2353 
   2354     ('l-comment
   2355      (yaml--frame "l-comment"
   2356        (yaml--all
   2357         (yaml--parse-from-grammar 's-separate-in-line)
   2358         (yaml--rep 0 1
   2359           (lambda () (yaml--parse-from-grammar 'c-nb-comment-text)))
   2360         (yaml--parse-from-grammar 'b-comment))))
   2361 
   2362     ('ns-hex-digit
   2363      (yaml--frame "ns-hex-digit"
   2364        (yaml--any
   2365         (yaml--parse-from-grammar 'ns-dec-digit)
   2366         (yaml--chr-range ?\x41 ?\x46)
   2367         (yaml--chr-range ?\x61 ?\x66))))
   2368 
   2369     ('s-l+flow-in-block
   2370      (let ((n (nth 0 args)))
   2371        (yaml--frame "s-l+flow-in-block"
   2372          (yaml--all
   2373           (yaml--parse-from-grammar 's-separate (+ n 1) "flow-out")
   2374           (yaml--parse-from-grammar 'ns-flow-node (+ n 1) "flow-out")
   2375           (yaml--parse-from-grammar 's-l-comments)))))
   2376 
   2377     ('c-flow-json-node
   2378      (let ((n (nth 0 args)) (c (nth 1 args)))
   2379        (yaml--frame "c-flow-json-node"
   2380          (yaml--all
   2381           (yaml--rep 0 1
   2382             (lambda ()
   2383               (yaml--all
   2384                (yaml--parse-from-grammar 'c-ns-properties n c)
   2385                (yaml--parse-from-grammar 's-separate n c))))
   2386           (yaml--parse-from-grammar 'c-flow-json-content n c)))))
   2387 
   2388     ('c-b-block-header
   2389      (let ((m (nth 0 args))
   2390            (tt (nth 1 args)))
   2391        (yaml--frame "c-b-block-header"
   2392          (yaml--all
   2393           (yaml--any
   2394            (and (not (string-match "\\`[-+][0-9]"
   2395                                    (yaml--slice yaml--parsing-position)))
   2396                 ;; hack to not match this case if there is a number.
   2397                 (yaml--all
   2398                  (yaml--parse-from-grammar 'c-indentation-indicator m)
   2399                  (yaml--parse-from-grammar 'c-chomping-indicator tt)))
   2400            (yaml--all
   2401             (yaml--parse-from-grammar 'c-chomping-indicator tt)
   2402             (yaml--parse-from-grammar 'c-indentation-indicator m)))
   2403           (yaml--parse-from-grammar 's-b-comment)))))
   2404 
   2405     ('ns-esc-8-bit
   2406      (yaml--frame "ns-esc-8-bit"
   2407        (yaml--all (yaml--chr ?x)
   2408                   (yaml--rep 2 2
   2409                     (lambda () (yaml--parse-from-grammar 'ns-hex-digit))))))
   2410 
   2411     ('ns-anchor-name
   2412      (yaml--frame "ns-anchor-name"
   2413        (yaml--rep 1 nil
   2414          (lambda () (yaml--parse-from-grammar 'ns-anchor-char)))))
   2415 
   2416     ('ns-esc-slash
   2417      (yaml--frame "ns-esc-slash" (yaml--chr ?\/)))
   2418 
   2419     ('s-nb-folded-text
   2420      (let ((n (nth 0 args)))
   2421        (yaml--frame "s-nb-folded-text"
   2422          (yaml--all (yaml--parse-from-grammar 's-indent n)
   2423                     (yaml--parse-from-grammar 'ns-char)
   2424                     (yaml--rep2 0 nil
   2425                       (lambda () (yaml--parse-from-grammar 'nb-char)))))))
   2426 
   2427     ('ns-word-char
   2428      (yaml--frame "ns-word-char"
   2429        (yaml--any (yaml--parse-from-grammar 'ns-dec-digit)
   2430                   (yaml--parse-from-grammar 'ns-ascii-letter)
   2431                   (yaml--chr ?\-))))
   2432 
   2433     ('ns-esc-form-feed
   2434      (yaml--frame "ns-esc-form-feed" (yaml--chr ?f)))
   2435 
   2436     ('ns-s-block-map-implicit-key
   2437      (yaml--frame "ns-s-block-map-implicit-key"
   2438        (yaml--any
   2439         (yaml--parse-from-grammar 'c-s-implicit-json-key "block-key")
   2440         (yaml--parse-from-grammar 'ns-s-implicit-yaml-key "block-key"))))
   2441 
   2442     ('ns-esc-null (yaml--frame "ns-esc-null" (yaml--chr ?\0)))
   2443 
   2444     ('c-ns-tag-property
   2445      (yaml--frame "c-ns-tag-property"
   2446        (yaml--any (yaml--parse-from-grammar 'c-verbatim-tag)
   2447                   (yaml--parse-from-grammar 'c-ns-shorthand-tag)
   2448                   (yaml--parse-from-grammar 'c-non-specific-tag))))
   2449 
   2450     ('c-ns-local-tag-prefix
   2451      (yaml--frame "c-ns-local-tag-prefix"
   2452        (yaml--all
   2453         (yaml--chr ?\!)
   2454         (yaml--rep2 0 nil
   2455           (lambda () (yaml--parse-from-grammar 'ns-uri-char))))))
   2456 
   2457     ('ns-tag-directive
   2458      (yaml--frame "ns-tag-directive"
   2459        (yaml--all (yaml--chr ?T) (yaml--chr ?A) (yaml--chr ?G)
   2460                   (yaml--parse-from-grammar 's-separate-in-line)
   2461                   (yaml--parse-from-grammar 'c-tag-handle)
   2462                   (yaml--parse-from-grammar 's-separate-in-line)
   2463                   (yaml--parse-from-grammar 'ns-tag-prefix))))
   2464 
   2465     ('c-flow-mapping
   2466      (let ((n (nth 0 args)) (c (nth 1 args)))
   2467        (yaml--frame "c-flow-mapping"
   2468          (yaml--all
   2469           (yaml--chr ?\{)
   2470           (yaml--rep 0 1
   2471             (lambda () (yaml--parse-from-grammar 's-separate n c)))
   2472           (yaml--rep 0 1
   2473             (lambda ()
   2474               (yaml--parse-from-grammar 'ns-s-flow-map-entries
   2475                                         n
   2476                                         (yaml--parse-from-grammar 'in-flow c))))
   2477           (yaml--chr ?\})))))
   2478 
   2479     ('ns-double-char
   2480      (yaml--frame "ns-double-char"
   2481        (yaml--but (lambda () (yaml--parse-from-grammar 'nb-double-char))
   2482                   (lambda () (yaml--parse-from-grammar 's-white)))))
   2483 
   2484     ('ns-ascii-letter
   2485      (yaml--frame "ns-ascii-letter"
   2486        (yaml--any (yaml--chr-range ?\x41 ?\x5A)
   2487                   (yaml--chr-range ?\x61 ?\x7A))))
   2488 
   2489     ('b-break
   2490      (yaml--frame "b-break"
   2491        (yaml--any (yaml--all (yaml--parse-from-grammar 'b-carriage-return)
   2492                              (yaml--parse-from-grammar 'b-line-feed))
   2493                   (yaml--parse-from-grammar 'b-carriage-return)
   2494                   (yaml--parse-from-grammar 'b-line-feed))))
   2495 
   2496     ('nb-ns-double-in-line
   2497      (yaml--frame "nb-ns-double-in-line"
   2498        (yaml--rep2 0 nil
   2499          (lambda ()
   2500            (yaml--all
   2501             (yaml--rep2 0 nil
   2502               (lambda () (yaml--parse-from-grammar 's-white)))
   2503             (yaml--parse-from-grammar 'ns-double-char))))))
   2504 
   2505     ('s-l+block-node
   2506      (yaml--frame "s-l+block-node"
   2507        (yaml--any
   2508         (yaml--parse-from-grammar 's-l+block-in-block (nth 0 args) (nth 1 args))
   2509         (yaml--parse-from-grammar 's-l+flow-in-block (nth 0 args)))))
   2510 
   2511     ('ns-esc-bell
   2512      (yaml--frame "ns-esc-bell" (yaml--chr ?a)))
   2513 
   2514     ('c-named-tag-handle
   2515      (yaml--frame "c-named-tag-handle"
   2516        (yaml--all
   2517         (yaml--chr ?\!)
   2518         (yaml--rep 1 nil (lambda () (yaml--parse-from-grammar 'ns-word-char)))
   2519         (yaml--chr ?\!))))
   2520 
   2521     ('s-separate-lines
   2522      (let ((n (nth 0 args)))
   2523        (yaml--frame "s-separate-lines"
   2524          (yaml--any (yaml--all (yaml--parse-from-grammar 's-l-comments)
   2525                                (yaml--parse-from-grammar 's-flow-line-prefix n))
   2526                     (yaml--parse-from-grammar 's-separate-in-line)))))
   2527 
   2528     ('l-directive
   2529      (yaml--frame "l-directive"
   2530        (yaml--all (yaml--chr ?\%)
   2531                   (yaml--any (yaml--parse-from-grammar 'ns-yaml-directive)
   2532                              (yaml--parse-from-grammar 'ns-tag-directive)
   2533                              (yaml--parse-from-grammar 'ns-reserved-directive))
   2534                   (yaml--parse-from-grammar 's-l-comments))))
   2535 
   2536     ('ns-esc-escape
   2537      (yaml--frame "ns-esc-escape" (yaml--chr ?e)))
   2538 
   2539     ('b-nb-literal-next
   2540      (let ((n (nth 0 args)))
   2541        (yaml--frame "b-nb-literal-next"
   2542          (yaml--all (yaml--parse-from-grammar 'b-as-line-feed)
   2543                     (yaml--parse-from-grammar 'l-nb-literal-text n)))))
   2544 
   2545     ('ns-s-flow-map-entries
   2546      (let ((n (nth 0 args)) (c (nth 1 args)))
   2547        (yaml--frame "ns-s-flow-map-entries"
   2548          (yaml--all
   2549           (yaml--parse-from-grammar 'ns-flow-map-entry n c)
   2550           (yaml--rep 0 1 (lambda () (yaml--parse-from-grammar 's-separate n c)))
   2551           (yaml--rep 0 1
   2552             (lambda ()
   2553               (yaml--all
   2554                (yaml--chr ?\,)
   2555                (yaml--rep 0 1
   2556                  (lambda () (yaml--parse-from-grammar 's-separate n c)))
   2557                (yaml--rep 0 1
   2558                  (lambda ()
   2559                    (yaml--parse-from-grammar 'ns-s-flow-map-entries
   2560                                              n
   2561                                              c))))))))))
   2562 
   2563     ('c-nb-comment-text
   2564      (yaml--frame "c-nb-comment-text"
   2565        (yaml--all
   2566         (yaml--chr ?\#)
   2567         (yaml--rep2 0 nil (lambda () (yaml--parse-from-grammar 'nb-char))))))
   2568 
   2569     ('ns-dec-digit
   2570      (yaml--frame "ns-dec-digit"
   2571        (yaml--chr-range ?\x30 ?\x39)))
   2572 
   2573     ('ns-yaml-directive
   2574      (yaml--frame "ns-yaml-directive"
   2575        (yaml--all (yaml--chr ?Y) (yaml--chr ?A) (yaml--chr ?M) (yaml--chr ?L)
   2576                   (yaml--parse-from-grammar 's-separate-in-line)
   2577                   (yaml--parse-from-grammar 'ns-yaml-version))))
   2578 
   2579     ('c-mapping-key
   2580      (yaml--frame "c-mapping-key" (yaml--chr ?\?)))
   2581 
   2582     ('b-as-line-feed
   2583      (yaml--frame "b-as-line-feed"
   2584        (yaml--parse-from-grammar 'b-break)))
   2585 
   2586     ('s-l+block-in-block
   2587      (yaml--frame "s-l+block-in-block"
   2588        (yaml--any
   2589         (yaml--parse-from-grammar 's-l+block-scalar
   2590                                   (nth 0 args)
   2591                                   (nth 1 args))
   2592         (yaml--parse-from-grammar 's-l+block-collection
   2593                                   (nth 0 args)
   2594                                   (nth 1 args)))))
   2595 
   2596     ('ns-esc-paragraph-separator
   2597      (yaml--frame "ns-esc-paragraph-separator" (yaml--chr ?P)))
   2598 
   2599     ('c-double-quoted
   2600      (let ((n (nth 0 args)) (c (nth 1 args)))
   2601        (yaml--frame "c-double-quoted"
   2602          (yaml--all (yaml--chr ?\")
   2603                     (yaml--parse-from-grammar 'nb-double-text n c)
   2604                     (yaml--chr ?\")))))
   2605 
   2606     ('b-line-feed
   2607      (yaml--frame "b-line-feed" (yaml--chr ?\x0A)))
   2608 
   2609     ('ns-esc-horizontal-tab
   2610      (yaml--frame "ns-esc-horizontal-tab"
   2611        (yaml--any (yaml--chr ?t) (yaml--chr ?\x09))))
   2612 
   2613     ('c-ns-flow-map-empty-key-entry
   2614      (let ((n (nth 0 args)) (c (nth 1 args)))
   2615        (yaml--frame "c-ns-flow-map-empty-key-entry"
   2616          (yaml--all
   2617           (yaml--parse-from-grammar 'e-node)
   2618           (yaml--parse-from-grammar 'c-ns-flow-map-separate-value n c)))))
   2619 
   2620     ('l-any-document
   2621      (yaml--frame "l-any-document"
   2622        (yaml--any (yaml--parse-from-grammar 'l-directive-document)
   2623                   (yaml--parse-from-grammar 'l-explicit-document)
   2624                   (yaml--parse-from-grammar 'l-bare-document))))
   2625 
   2626     ('c-tag (yaml--frame "c-tag" (yaml--chr ?\!)))
   2627 
   2628     ('c-escape (yaml--frame "c-escape" (yaml--chr ?\\)))
   2629 
   2630     ('c-sequence-end (yaml--frame "c-sequence-end" (yaml--chr ?\])))
   2631 
   2632     ('l+block-mapping
   2633      (yaml--frame "l+block-mapping"
   2634        (let ((new-m (yaml--auto-detect-indent (nth 0 args))))
   2635          (if (= 0 new-m)
   2636              nil ;; For some fixed auto-detected m > 0 ;; Is this right???
   2637            (yaml--all
   2638             (yaml--set m new-m)
   2639             (yaml--rep 1 nil
   2640               (lambda ()
   2641                 (yaml--all
   2642                  (yaml--parse-from-grammar 's-indent
   2643                                            (+ (nth 0 args) new-m))
   2644                  (yaml--parse-from-grammar 'ns-l-block-map-entry
   2645                                            (+ (nth 0 args) new-m))))))))))
   2646 
   2647     ('c-ns-flow-map-adjacent-value
   2648      (let ((n (nth 0 args)) (c (nth 1 args)))
   2649        (yaml--frame "c-ns-flow-map-adjacent-value"
   2650          (yaml--all
   2651           (yaml--chr ?\:)
   2652           (yaml--any
   2653            (yaml--all
   2654             (yaml--rep 0 1
   2655               (lambda () (yaml--parse-from-grammar 's-separate n c)))
   2656             (yaml--parse-from-grammar 'ns-flow-node n c))
   2657            (yaml--parse-from-grammar 'e-node))))))
   2658 
   2659     ('s-single-next-line
   2660      (let ((n (nth 0 args)))
   2661        (yaml--frame "s-single-next-line"
   2662          (yaml--all
   2663           (yaml--parse-from-grammar 's-flow-folded n)
   2664           (yaml--rep 0 1
   2665             (lambda ()
   2666               (yaml--all
   2667                (yaml--parse-from-grammar 'ns-single-char)
   2668                (yaml--parse-from-grammar 'nb-ns-single-in-line)
   2669                (yaml--any
   2670                 (yaml--parse-from-grammar 's-single-next-line n)
   2671                 (yaml--rep2 0 nil
   2672                   (lambda () (yaml--parse-from-grammar 's-white)))))))))))
   2673 
   2674     ('s-separate-in-line
   2675      (yaml--frame "s-separate-in-line"
   2676        (yaml--any (yaml--rep 1 nil
   2677                     (lambda () (yaml--parse-from-grammar 's-white)))
   2678                   (yaml--start-of-line))))
   2679 
   2680     ('b-comment
   2681      (yaml--frame "b-comment"
   2682        (yaml--any (yaml--parse-from-grammar 'b-non-content)
   2683                   (yaml--end-of-stream))))
   2684 
   2685     ('ns-esc-backslash
   2686      (yaml--frame "ns-esc-backslash" (yaml--chr ?\\)))
   2687 
   2688     ('c-ns-anchor-property
   2689      (yaml--frame "c-ns-anchor-property"
   2690        (yaml--all (yaml--chr ?\&)
   2691                   (yaml--parse-from-grammar 'ns-anchor-name))))
   2692 
   2693     ('ns-plain-safe
   2694      (let ((c (nth 0 args)))
   2695        (yaml--frame "ns-plain-safe"
   2696          (pcase c
   2697            ("block-key" (yaml--parse-from-grammar 'ns-plain-safe-out))
   2698            ("flow-in" (yaml--parse-from-grammar 'ns-plain-safe-in))
   2699            ("flow-key" (yaml--parse-from-grammar 'ns-plain-safe-in))
   2700            ("flow-out" (yaml--parse-from-grammar 'ns-plain-safe-out))))))
   2701 
   2702     ('ns-flow-content
   2703      (let ((n (nth 0 args)) (c (nth 1 args)))
   2704        (yaml--frame "ns-flow-content"
   2705          (yaml--any (yaml--parse-from-grammar 'ns-flow-yaml-content n c)
   2706                     (yaml--parse-from-grammar 'c-flow-json-content n c)))))
   2707 
   2708     ('c-ns-flow-map-separate-value
   2709      (let ((n (nth 0 args)) (c (nth 1 args)))
   2710        (yaml--frame "c-ns-flow-map-separate-value"
   2711          (yaml--all
   2712           (yaml--chr ?\:)
   2713           (yaml--chk "!" (yaml--parse-from-grammar 'ns-plain-safe c))
   2714           (yaml--any (yaml--all (yaml--parse-from-grammar 's-separate n c)
   2715                                 (yaml--parse-from-grammar 'ns-flow-node n c))
   2716                      (yaml--parse-from-grammar 'e-node))))))
   2717 
   2718     ('in-flow
   2719      (let ((c (nth 0 args)))
   2720        (yaml--frame "in-flow"
   2721          (pcase c
   2722            ("block-key" "flow-key")
   2723            ("flow-in" "flow-in")
   2724            ("flow-key" "flow-key")
   2725            ("flow-out" "flow-in")))))
   2726 
   2727     ('c-verbatim-tag
   2728      (yaml--frame "c-verbatim-tag"
   2729        (yaml--all
   2730         (yaml--chr ?\!)
   2731         (yaml--chr ?\<)
   2732         (yaml--rep 1 nil (lambda () (yaml--parse-from-grammar 'ns-uri-char)))
   2733         (yaml--chr ?\>))))
   2734 
   2735     ('c-literal
   2736      (yaml--frame "c-literal" (yaml--chr ?\|)))
   2737 
   2738     ('ns-esc-line-feed
   2739      (yaml--frame "ns-esc-line-feed" (yaml--chr ?n)))
   2740 
   2741     ('nb-double-multi-line
   2742      (let ((n (nth 0 args)))
   2743        (yaml--frame "nb-double-multi-line"
   2744          (yaml--all
   2745           (yaml--parse-from-grammar 'nb-ns-double-in-line)
   2746           (yaml--any (yaml--parse-from-grammar 's-double-next-line n)
   2747                      (yaml--rep2 0 nil
   2748                        (lambda () (yaml--parse-from-grammar 's-white))))))))
   2749 
   2750     ('b-l-spaced
   2751      (let ((n (nth 0 args)))
   2752        (yaml--frame "b-l-spaced"
   2753          (yaml--all
   2754           (yaml--parse-from-grammar 'b-as-line-feed)
   2755           (yaml--rep2 0 nil
   2756             (lambda () (yaml--parse-from-grammar 'l-empty n "block-in")))))))
   2757 
   2758     ('ns-flow-yaml-content
   2759      (let ((n (nth 0 args)) (c (nth 1 args)))
   2760        (yaml--frame "ns-flow-yaml-content"
   2761          (yaml--parse-from-grammar 'ns-plain n c))))
   2762     (_ (error "Unknown parsing grammar state: %s %s" state args))))
   2763 
   2764 ;;; Encoding
   2765 
   2766 (defun yaml-encode (object)
   2767   "Encode OBJECT to a YAML string."
   2768   (with-temp-buffer
   2769     (yaml--encode-object object 0)
   2770     (buffer-string)))
   2771 
   2772 (defun yaml--encode-object (object indent &optional auto-indent)
   2773   "Encode a Lisp OBJECT to YAML.
   2774 
   2775 INDENT indicates how deeply nested the object will be displayed
   2776 in the YAML.  If AUTO-INDENT is non-nil, then emit the object
   2777 without first inserting a newline."
   2778   (cond
   2779    ((yaml--scalarp object) (yaml--encode-scalar object))
   2780    ((hash-table-p object) (yaml--encode-hash-table object indent auto-indent))
   2781    ((listp object) (yaml--encode-list object indent auto-indent))
   2782    ((arrayp object) (yaml--encode-array object indent auto-indent))
   2783    (t (error "Unknown object %s" object))))
   2784 
   2785 (defun yaml--scalarp (object)
   2786   "Return non-nil if OBJECT correlates to a YAML scalar."
   2787   (or (numberp object)
   2788       (symbolp object)
   2789       (stringp object)
   2790       (not object)))
   2791 
   2792 (defun yaml--encode-escape-string (s)
   2793   "Escape yaml special characters in string S."
   2794   (let* ((s (replace-regexp-in-string "\\\\" "\\\\" s))
   2795          (s (replace-regexp-in-string "\n" "\\\\n" s))
   2796          (s (replace-regexp-in-string "\t" "\\\\t" s))
   2797          (s (replace-regexp-in-string "\r" "\\\\r" s))
   2798          (s (replace-regexp-in-string "\"" "\\\\\"" s)))
   2799     s))
   2800 
   2801 (defun yaml--encode-array (a indent &optional auto-indent)
   2802   "Encode array A to a string in the context of being INDENT deep.
   2803 
   2804 If AUTO-INDENT is non-nil, start the list on the current line,
   2805 auto-detecting the indentation.  Functionality defers to
   2806 `yaml--encode-list'."
   2807   (yaml--encode-list (seq-map #'identity a)
   2808                      indent
   2809                      auto-indent))
   2810 
   2811 
   2812 (defun yaml--encode-scalar (s)
   2813   "Encode scalar S to buffer."
   2814   (cond
   2815    ((not s) (insert "null"))
   2816    ((eql t s) (insert "true"))
   2817    ((symbolp s)
   2818     (cond
   2819      ((eql s :null) (insert "null"))
   2820      ((eql s :false) (insert "false"))
   2821      (t (insert (symbol-name s)))))
   2822    ((numberp s) (insert (number-to-string s)))
   2823    ((stringp s)
   2824     (if (string-match "\\`[-_a-zA-Z0-9]+\\'" s)
   2825         (insert s)
   2826       (insert "\"" (yaml--encode-escape-string s) "\"")))))
   2827 
   2828 (defun yaml--alist-to-hash-table (l)
   2829   "Return hash representation of L if it is an alist, nil otherwise."
   2830   (when (and (listp l)
   2831              (seq-every-p (lambda (x) (and (consp x) (atom (car x)))) l))
   2832     (let ((h (make-hash-table)))
   2833       (seq-map (lambda (cpair)
   2834                  (let* ((k (car cpair))
   2835                         (v (alist-get k l)))
   2836                    (puthash k v h)))
   2837                l)
   2838       h)))
   2839 
   2840 (defun yaml--encode-list (l indent &optional auto-indent)
   2841   "Encode list L to a string in the context of being INDENT deep.
   2842 
   2843 If AUTO-INDENT is non-nil, start the list on the current line,
   2844 auto-detecting the indentation"
   2845   (let ((ht (yaml--alist-to-hash-table l)))
   2846     (cond (ht
   2847            (yaml--encode-hash-table ht indent auto-indent))
   2848           ((zerop (length l))
   2849            (insert "[]"))
   2850           ((seq-every-p #'yaml--scalarp l)
   2851            (insert "[")
   2852            (yaml--encode-object (car l) 0)
   2853            (seq-do (lambda (object)
   2854                      (insert ", ")
   2855                      (yaml--encode-object object 0))
   2856                    (cdr l))
   2857            (insert "]"))
   2858           (t
   2859            (when (zerop indent)
   2860              (setq indent 2))
   2861            (let* ((first t)
   2862                   (indent-string (make-string (- indent 2) ?\s)))
   2863              (seq-do
   2864               (lambda (object)
   2865                 (if (not first)
   2866                     (insert "\n" indent-string "- ")
   2867                   (if auto-indent
   2868                       (let ((curr-indent (yaml--encode-auto-detect-indent)))
   2869                         (insert (make-string (- indent curr-indent) ?\s)  "- "))
   2870                     (insert "\n" indent-string "- "))
   2871                   (setq first nil))
   2872                 (if (or (hash-table-p object)
   2873                         (yaml--alist-to-hash-table object))
   2874                     (yaml--encode-object object indent t)
   2875                   (yaml--encode-object object (+ indent 2) nil)))
   2876               l))))))
   2877 
   2878 (defun yaml--encode-auto-detect-indent ()
   2879   "Return the amount of indentation at current place in encoding."
   2880   (length (thing-at-point 'line)))
   2881 
   2882 (defun yaml--encode-hash-table (m indent &optional auto-indent)
   2883   "Encode hash table M to a string in the context of being INDENT deep.
   2884 
   2885 If AUTO-INDENT is non-nil, auto-detect the indent on the current
   2886 line and insert accordingly."
   2887   (cond ((zerop (hash-table-size m))
   2888          (insert "{}"))
   2889         (t
   2890          (let ((first t)
   2891                (indent-string (make-string indent ?\s)))
   2892            (maphash
   2893             (lambda (k v)
   2894               (if (not first)
   2895                   (insert "\n" indent-string)
   2896                 (if auto-indent
   2897                     (let ((curr-indent (yaml--encode-auto-detect-indent)))
   2898                       (when (> curr-indent indent)
   2899                         (setq indent (+ curr-indent 1)))
   2900                       (insert (make-string (- indent curr-indent) ?\s)))
   2901                   (insert "\n" indent-string))
   2902                 (setq first nil))
   2903               (yaml--encode-object k indent nil)
   2904               (insert ": ")
   2905               (yaml--encode-object v (+ indent 2)))
   2906             m)))))
   2907 
   2908 (provide 'yaml)
   2909 
   2910 ;;; yaml.el ends here
	dotemacs My Emacs configuration
	git clone git://git.entf.net/dotemacs
	Log \| Files \| Refs \| LICENSE