@@ -17,7 +17,8 @@

                  (:file "float")

                  (:file "scalar")

                  (:file "parser")

-                 (:file "emitter"))))

+                 (:file "emitter")

+                 (:file "yaml"))))

   :description "A YAML parser and emitter."

   :long-description

   #.(uiop:read-file-string

@@ -6,7 +6,7 @@

   (:import-from :libyaml.macros

                 :with-parser

                 :with-event)

-  (:export :parse)

+  (:export :parse-string)

   (:documentation "The YAML parser."))

 (in-package :yaml.parser)

@@ -28,50 +28,51 @@

       (with-event (event)

         (loop do

           ;; Parse the next event, checking for errors

-          (if (libyaml.parser:parse parser event)

-              ;; Decide what to do with the event

-              (let ((type (libyaml.event:event-type event)))

-                (flet ((add-to-output (data)

-                         (vector-push-extend data output)))

-                  (cond

-                    ;; Stream events

-                    ((eql type :stream-start-event)

-                     ;; Do nothing

-                     t)

-                    ((eql type :stream-end-event)

-                     (return-from parse-yaml output))

-                    ;; Document events, push them to the output list

-                    ((or (eql type :document-start-event)

-                         (eql type :document-end-event))

-                     (add-to-output (list type)))

-                    ;; Alias and scalar event, push the type and data pair to

-                    ;; the output list

-                    ((eql type :alias-event)

-                     (add-to-output

-                      (cons type

-                            (libyaml.event:event-alias-data event))))

-                    ((eql type :scalar-event)

-                     (add-to-output

-                      (cons type

-                            (libyaml.event:event-scalar-data event))))

-                    ;; Sequence start and end events

-                    ((eql type :sequence-start-event)

-                     (add-to-output

-                      (cons type

-                            (libyaml.event:event-sequence-start-data event))))

-                    ((eql type :sequence-end-event)

-                     (add-to-output (list type)))

-                    ;; Mapping start and end events

-                    ((eql type :mapping-start-event)

-                     (add-to-output

-                      (cons type

-                            (libyaml.event:event-mapping-start-data event))))

-                    ((eql type :mapping-end-event)

-                     (add-to-output (list type)))

-                    (t

-                     t))))

-              ;; Signal an error

-              (signal-reader-error parser)))))))

+          (let ((parsing-result (libyaml.parser:parse parser event)))

+            (if parsing-result

+                ;; Decide what to do with the event

+                (let ((type (libyaml.event:event-type event)))

+                  (flet ((add-to-output (data)

+                           (vector-push-extend data output)))

+                    (cond

+                      ;; Stream events

+                      ((eql type :stream-start-event)

+                       ;; Do nothing

+                       t)

+                      ((eql type :stream-end-event)

+                       (return-from parse-yaml output))

+                      ;; Document events, push them to the output list

+                      ((or (eql type :document-start-event)

+                           (eql type :document-end-event))

+                       (add-to-output (list type)))

+                      ;; Alias and scalar event, push the type and data pair to

+                      ;; the output list

+                      ((eql type :alias-event)

+                       (add-to-output

+                        (cons type

+                              (libyaml.event:event-alias-data event))))

+                      ((eql type :scalar-event)

+                       (add-to-output

+                        (cons type

+                              (libyaml.event:event-scalar-data event))))

+                      ;; Sequence start and end events

+                      ((eql type :sequence-start-event)

+                       (add-to-output

+                        (cons type

+                              (libyaml.event:event-sequence-start-data event))))

+                      ((eql type :sequence-end-event)

+                       (add-to-output (list type)))

+                      ;; Mapping start and end events

+                      ((eql type :mapping-start-event)

+                       (add-to-output

+                        (cons type

+                              (libyaml.event:event-mapping-start-data event))))

+                      ((eql type :mapping-end-event)

+                       (add-to-output (list type)))

+                      (t

+                       t))))

+                ;; Signal an error

+                (signal-reader-error parser))))))))

 (defun parse-tokens (vector)

   (let ((contexts (list nil)))

@@ -87,17 +88,21 @@

                          (cons :document con)))))

         ;; Alias event

         ((:alias-event &key anchor)

-         (print anchor))

+         (declare (ignore anchor))

+         t)

         ;; Scalar

         ((:scalar-event &key anchor tag value)

+         (declare (ignore anchor tag))

          (setf (first contexts)

                (append (first contexts)

                        (list (yaml.scalar:parse-scalar value)))))

         ;; Sequence start event

         ((:sequence-start-event &key anchor tag)

+         (declare (ignore anchor tag))

          (push (list) contexts))

         ;; Mapping start event

         ((:mapping-start-event &key anchor tag)

+         (declare (ignore anchor tag))

          (push (list) contexts))

         ;; End events

         ((:sequence-end-event)

@@ -113,17 +118,11 @@

                           (alexandria:plist-hash-table con :test #'equal))))))

         ;; Do nothing

         ((t &rest rest)

+         (declare (ignore rest))

          t)))

     (first contexts)))

 ;;; The public interface

-(defgeneric parse (input)

-  (:documentation "Parse a YAML string or a pathname to a YAML file into Lisp

- data."))

-

-(defmethod parse ((input string))

-  (parse-tokens (parse-yaml input)))

-

-(defmethod parse ((input pathname))

-  (parse (uiop:read-file-string input)))

+(defun parse-string (yaml-string)

+  (parse-tokens (parse-yaml yaml-string)))

new file mode 100644

@@ -0,0 +1,16 @@

+(in-package :cl-user)

+(defpackage yaml

+  (:use :cl)

+  (:export :parse)

+  (:documentation "The main YAML interface."))

+(in-package :yaml)

+

+(defgeneric parse (input)

+  (:documentation "Parse a YAML string or a pathname to a YAML file into Lisp

+ data."))

+

+(defmethod parse ((input string))

+  (yaml.parser:parse-string input))

+

+(defmethod parse ((input pathname))

+  (parse (uiop:read-file-string input)))