;;; ;;; SRFI-180 - JSON ;;; ;;; Copyright (c) 2020-2024 Shiro Kawai ;;; ;;; Redistribution and use in source and binary forms, with or without ;;; modification, are permitted provided that the following conditions ;;; are met: ;;; ;;; 1. Redistributions of source code must retain the above copyright ;;; notice, this list of conditions and the following disclaimer. ;;; ;;; 2. Redistributions in binary form must reproduce the above copyright ;;; notice, this list of conditions and the following disclaimer in the ;;; documentation and/or other materials provided with the distribution. ;;; ;;; 3. Neither the name of the authors nor the names of its contributors ;;; may be used to endorse or promote products derived from this ;;; software without specific prior written permission. ;;; ;;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ;;; "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT ;;; LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR ;;; A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT ;;; OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ;;; SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED ;;; TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR ;;; PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF ;;; LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING ;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS ;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ;;; ;; A wrapper of rfc.json (define-module srfi.180 (use gauche.vport) (use parser.peg) (use scheme.list) (use rfc.json) (export json-error? json-error-reason json-null? json-nesting-depth-limit ; in rfc.json json-number-of-character-limit json-generator json-fold json-read json-lines-read json-sequence-read json-accumulator json-write )) (select-module srfi.180) (define (json-error? obj) (or (is-a? obj ) (is-a? obj ))) (define (json-error-reason obj) (~ obj'message)) (define (json-null? obj) (eq? obj 'null)) ;; json-nesting-depth-limit is in rfc.json (define json-number-of-character-limit (make-parameter +inf.0)) ;; internal ;; we use peek-char to keep the last read char in the port, since ;; lseq read ahead one character and we don't want that character to ;; be missed in the subsequent read from the port. (define (port/gen->json-lseq port) (define nchars 0) (if (port? port) (generator->lseq (^[] (unless (= nchars 0) (read-char port)) (let1 c (peek-char port) (cond [(eof-object? c) c] [(>= nchars (json-number-of-character-limit)) (error "Input length exceeds json-number-of-character-limit")] [else (inc! nchars) c])))) (generator->lseq port))) ;assume it's a char-generator ;; API: streaming parser ;; NB: srfi's json-generator doesn't take a char generator, but for ;; the upper layers, we accept it for the convenience. (define (json-generator :optional (port (current-input-port))) (define inner-gen (peg-parser->generator json-tokenizer (port/gen->json-lseq port))) (define (nexttok) (guard (e ([ e] ;; not to expose parser.peg's . (error :position (~ e'position) :objects (~ e'objects) :message (~ e'message)))) (case (inner-gen) [(true) #t] [(false) #f] [else => identity]))) (define nesting '()) (define (push-nesting kind) (when (>= (length nesting) (json-nesting-depth-limit)) (error "Input JSON nesting is too deep.")) (push! nesting (cons kind gen))) (define (pop-nesting kind) (unless (pair? nesting) (errorf "Stray close ~a" kind)) (unless (eq? (caar nesting) kind) (errorf "Unmatched open ~a" (car nesting))) (set! gen (cdr (pop! nesting)))) (define (badtok tok) (error (format "Invalid token: ~s" tok))) ;; Read one value. array-end and object-end are returned as-is, and the ;; caller should handle it---they can appear in value context input is empty ;; array and empty object. (define (value) (case (nexttok) [(array-start) (push-nesting 'array) (set! gen array-element) 'array-start] [(object-start) (push-nesting 'object) (set! gen object-key) 'object-start] [(#\: #\,) => badtok] [else => identity])) ;; State machine ;; Each state is a thunk, set! to variable 'gen'. ;; Initial state (define (init) (set! gen fini) (case (value) [(array-end object-end) => badtok] [else => identity])) ;; We've already read a whole item. (define (fini) (eof-object)) ;; Reading an array element. (define (array-element) (set! gen array-element-after) (case (value) [(array-end) (pop-nesting 'array) 'array-end] [(object-end) => badtok] [else => identity])) ;; Just read an array element. (define (array-element-after) (case (nexttok) [(#\,) (array-element)] [(array-end) (pop-nesting 'array) 'array-end] [else => badtok])) ;; Reading an object key (define (object-key) (let1 t (nexttok) (cond [(string? t) (set! gen object-key-after) t] [(eq? t 'object-end) (pop-nesting 'object) 'object-end] [else (badtok t)]))) ;; Just read an object key (define (object-key-after) (case (nexttok) [(#\:) (set! gen object-value-after) (case (value) [(array-end object-end) => badtok] [else => identity])] [else => badtok])) ;; Just read an object value (define (object-value-after) (case (nexttok) [(#\,) (object-key)] [(object-end) (pop-nesting 'object) 'object-end] [else => badtok])) ;; 'gen' will be set! to the next state handler. (define gen init) ;; Entry point (^[] (gen))) ;; API (define (json-fold proc array-start array-end object-start object-end seed :optional (port-or-generator (current-input-port))) (define gen (json-generator port-or-generator)) (define (rec seed stack) (let1 tok (gen) (cond [(eof-object? tok) seed] [(eq? tok 'array-start) (rec (array-start seed) (cons seed stack))] [(eq? tok 'array-end) (rec (proc (array-end seed) (car stack)) (cdr stack))] [(eq? tok 'object-start) (rec (object-start seed) (cons seed stack))] [(eq? tok 'object-end) (rec (proc (object-end seed) (car stack)) (cdr stack))] [else (rec (proc tok seed) stack)]))) (rec seed '())) ;; Common utility to adapt rfc.json with SRFI-180 API. We skip ;; json-fold/json-generator stuff entirely. (define (with-json-parser proc lseq) (parameterize ((json-special-handler (^x (case x [(true) #t] [(false) #f] [else x]))) (json-object-handler (^x (map (^p `(,(string->symbol (car p)) . ,(cdr p))) x)))) (guard (e ([ e] ;; not to expose parser.peg's . (error :position (~ e'position) :objects (~ e'objects) :message (~ e'message)))) (proc lseq)))) ;; API ;; We skip json-fold/json-generator stuff entirely. (define (json-read :optional (port-or-generator (current-input-port))) (with-json-parser (^s (values-ref (peg-run-parser json-parser s) 0)) (port/gen->json-lseq port-or-generator))) ;; API (define (json-lines-read :optional (port-or-generator (current-input-port))) (let1 lseq (port/gen->json-lseq port-or-generator) (^[] (with-json-parser (^s (receive (r next) (peg-run-parser json-parser s) (set! lseq next) r)) lseq)))) ;; API ;; : ( #x1e json-text )* ;; Skip unparsable json-text. (define (json-sequence-read :optional (port-or-generator (current-input-port))) (define (skip-to-rs lseq) (drop-while (^c (not (eqv? c #\x1e))) lseq)) (define (skip-rs lseq) (drop-while (^c (eqv? c #\x1e)) lseq)) (define (fetch lseq) (let1 start (skip-rs lseq) (if (null? start) (values (eof-object) '()) (receive (json next) (guard (e [( e) (values 'error (skip-to-rs start))]) (with-json-parser (cut peg-run-parser json-parser <>) start)) (if (eq? json 'error) (fetch next) (values json next)))))) (let1 lseq (skip-to-rs (port/gen->json-lseq port-or-generator)) (^[] (receive (json next) (fetch lseq) (set! lseq next) json)))) ;; API (define (json-accumulator port-or-accumulator) (define acc (if (port? port-or-accumulator) (^o (if (string? o) (write-string o port-or-accumulator) (write-char o port-or-accumulator))) port-or-accumulator)) (define (err-input obj) (error :message (format "Unexpected token ~a as json-accumulator input" obj))) (define stack '()) ; (kind . #) (define (push-state!) (push! stack gen)) (define (pop-state! tok) (when (null? stack) (err-input tok)) (set! gen (pop! stack))) (define (value obj) (cond [(eof-object? obj)] [(eq? obj 'array-start) (acc #\[) (push-state!) (set! gen a0)] [(eq? obj 'object-start) (acc #\{) (push-state!) (set! gen k0)] [(or (eq? obj 'null) (boolean? obj) (string? obj) (number? obj)) (acc (construct-json-string obj))] [else (err-input obj)])) (define (init obj) (set! gen fini) (value obj)) (define (fini obj) (unless (eof-object? obj) (error :message "json-accumulator no longer accepting events."))) ;; initial element of array (define (a0 obj) (if (eq? obj 'array-end) (begin (acc #\]) (pop-state! obj)) (begin (set! gen a1) (value obj)))) ;; subsequent element of array (define (a1 obj) (if (eq? obj 'array-end) (begin (acc #\]) (pop-state! obj)) (begin (acc #\,) (value obj)))) ;; initial key of object (define (k0 obj) (cond [(eq? obj 'object-end) (acc #\}) (pop-state! obj)] [(string? obj) (acc obj) (set! gen v)] [else (err-input obj)])) ;; value of object (define (v obj) (set! gen k1) (acc #\:) (value obj)) ;; subsequent key of object (define (k1 obj) (cond [(eq? obj 'object-end) (acc #\}) (pop-state! obj)] [(string? obj) (acc #\,) (acc obj) (set! gen v)] [else (err-input obj)])) (define gen init) (^[obj] (gen obj))) ;; API (define (json-write obj :optional (port-or-accumulator (current-output-port))) (construct-json obj (if (port? port-or-accumulator) port-or-accumulator (open-output-accumulator port-or-accumulator))))