summaryrefslogtreecommitdiff
path: root/load.lisp
blob: 2377efcc864ffe808fca2c95daada92b09b9daf8 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
(in-package #:json)

(defparameter number-literal
  (let ((signed-digits
          (comp ((sign (optional (one-of (unit #\-)
                                         (unit #\+))))
                 (natural (if sign
                            (crit (many (unit digit-char-p)))
                            (many (unit digit-char-p)))))
            (cons sign natural))))
    (comp ((base signed-digits)
           (dot (optional (unit #\.)))
           (fraction (if dot
                       (crit (many (unit digit-char-p)))
                       nothing))
           (e (optional (one-of (unit #\e) (unit #\E))))
           (exponent (if e
                       (crit signed-digits)
                       nothing)))
      (read-from-string
        (coerce
          (remove nil (append base (cons dot fraction) (cons (when e #\d) exponent)))
          'string)))))

(defparameter string-literal
  (comp ((_ (unit #\"))
         (chars (optional (many (one-of (comp ((slash (unit #\\))
                                               (escaped (unit))
                                               (codepoints (if (char= escaped #\u)
                                                             (repeat (unit digit-char-p) 4)
                                                             nothing)))
                                          (case escaped
                                            (#\n #\Newline)
                                            (#\t #\Tab)
                                            (#\u (read-from-string (coerce (append '(#\# #\\ #\u) codepoints) 'string)))
                                            (t escaped)))
                                        (unit (and (char/= it #\") (char/= it #\\)))))))
         (_ (crit (unit #\"))))
    (coerce chars 'string)))

(defparameter true-symbol
  (comp ((_ (unit #\t))
         (_ (crit (literal "rue"))))
    'true))

(defparameter false-symbol
  (comp ((_ (unit #\f))
         (_ (crit (literal "alse"))))
    'false))

(defparameter null-symbol
  (comp ((_ (unit #\n))
         (_ (crit (literal "ull"))))
    'null))

(defvar json-value)

(defparameter json-array
  (comp ((_ (unit #\[))
         (vn (optional (separated-list json-value (unit #\,))))
         (_ (unit #\])))
    (apply #'vector vn)))

(defparameter json-object
  (let ((json-pair
          (comp ((_ whitespace)
                 (k string-literal)
                 (_ whitespace)
                 (_ (crit (unit #\:)))
                 (v (crit json-value)))
            (cons k v))))
    (comp ((_ (unit #\{))
           (vn (optional (separated-list json-pair (unit #\,))))
           (_ (unit #\})))
      (let* ((obj (make-hash-table :test #'equal :size (length vn))))
        (dolist (v vn)
          (setf (gethash (car v) obj) (cdr v)))
        obj))))

(defparameter json-value
  (comp ((_ whitespace)
         (v (one-of number-literal
                    string-literal
                    json-object
                    json-array
                    true-symbol
                    false-symbol
                    null-symbol))
         (_ whitespace))
    v))

(defun from-string (str)
  (run json-value (input:from-string str)))

(defun from-file (file)
  (run json-value (input:from-file file)))