This is the rs-json Reference Manual, version 1.2.5, generated automatically by Declt version 4.0 beta 2 "William Riker" on Mon Feb 26 17:48:59 2024 GMT+0.
The main system appears first, followed by any subsystem dependency.
rs-jsonYet another JSON decoder/encoder.
Ralph Schleicher <rs@ralph-schleicher.de>
Modified BSD License
1.2.5
alexandria (system).
iterate (system).
cl-unicode (system).
packages.lisp (file).
specials.lisp (file).
common.lisp (file).
decoder.lisp (file).
encoder.lisp (file).
Files are sorted by type and then listed depth-first from the systems components trees.
rs-json/rs-json.asdrs-json/packages.lisprs-json/specials.lisprs-json/common.lisprs-json/decoder.lisprs-json/encoder.lisprs-json/specials.lisppackages.lisp (file).
rs-json (system).
*allow-duplicate-object-keys* (special variable).
*allow-lax-numbers* (special variable).
*allow-literal-object-keys* (special variable).
*allow-trailing-comma* (special variable).
*allow-unicode-graphic* (special variable).
*allow-unicode-whitespace* (special variable).
*array-as* (special variable).
*decode-array-hook* (special variable).
*decode-object-hook* (special variable).
*encode-symbol-hook* (special variable).
*false* (special variable).
*list-encoder* (special variable).
*maximum-nesting-depth* (special variable).
*nil-encoder* (special variable).
*null* (special variable).
*object-as* (special variable).
*object-key-decoder* (special variable).
*true* (special variable).
with-default-values (macro).
*pretty-printer* (special variable).
rs-json/common.lispspecials.lisp (file).
rs-json (system).
encoding-error (condition).
json-error (condition).
syntax-error (condition).
*scratch* (special variable).
defconst (macro).
defsubst (macro).
initial-scratch-buffer-size (special variable).
make-scratch-buffer (function).
scratch-buffer-growth-rate (special variable).
scratch-buffer-p (function).
syntax-error-position (reader method).
(setf syntax-error-position) (writer method).
unicode-closing-punctuation-p (constant).
unicode-closing-punctuation-p (function).
unicode-connector-punctuation-p (constant).
unicode-connector-punctuation-p (function).
unicode-control-p (constant).
unicode-control-p (function).
unicode-currency-symbol-p (constant).
unicode-currency-symbol-p (function).
unicode-dash-punctuation-p (constant).
unicode-dash-punctuation-p (function).
unicode-decimal-digit-p (constant).
unicode-decimal-digit-p (function).
unicode-enclosing-mark-p (constant).
unicode-enclosing-mark-p (function).
unicode-final-quote-punctuation-p (constant).
unicode-final-quote-punctuation-p (function).
unicode-format-p (function).
unicode-graphic-p (function).
unicode-initial-quote-punctuation-p (constant).
unicode-initial-quote-punctuation-p (function).
unicode-letter-like-number-p (constant).
unicode-letter-like-number-p (function).
unicode-letter-p (constant).
unicode-letter-p (function).
unicode-line-separator-p (constant).
unicode-line-separator-p (function).
unicode-lowercase-letter-p (constant).
unicode-lowercase-letter-p (function).
unicode-mark-p (constant).
unicode-mark-p (function).
unicode-math-symbol-p (constant).
unicode-math-symbol-p (function).
unicode-modifier-letter-p (constant).
unicode-modifier-letter-p (function).
unicode-modifier-symbol-p (constant).
unicode-modifier-symbol-p (function).
unicode-non-spacing-mark-p (constant).
unicode-non-spacing-mark-p (function).
unicode-not-assigned-p (constant).
unicode-not-assigned-p (function).
unicode-number-p (constant).
unicode-number-p (function).
unicode-opening-punctuation-p (constant).
unicode-opening-punctuation-p (function).
unicode-other-format-p (constant).
unicode-other-format-p (function).
unicode-other-letter-p (constant).
unicode-other-letter-p (function).
unicode-other-number-p (constant).
unicode-other-number-p (function).
unicode-other-p (constant).
unicode-other-p (function).
unicode-other-punctuation-p (constant).
unicode-other-punctuation-p (function).
unicode-other-symbol-p (constant).
unicode-other-symbol-p (function).
unicode-paragraph-separator-p (constant).
unicode-paragraph-separator-p (function).
unicode-private-use-p (constant).
unicode-private-use-p (function).
unicode-punctuation-p (constant).
unicode-punctuation-p (function).
unicode-separator-p (constant).
unicode-separator-p (function).
unicode-space-separator-p (constant).
unicode-space-separator-p (function).
unicode-spacing-mark-p (constant).
unicode-spacing-mark-p (function).
unicode-surrogate-p (constant).
unicode-surrogate-p (function).
unicode-symbol-p (constant).
unicode-symbol-p (function).
unicode-titlecase-letter-p (constant).
unicode-titlecase-letter-p (function).
unicode-uppercase-letter-p (constant).
unicode-uppercase-letter-p (function).
unicode-whitespace-p (constant).
unicode-whitespace-p (function).
whitespace-char-p (function).
with-scratch-buffer (macro).
rs-json/decoder.lispcommon.lisp (file).
rs-json (system).
parse (function).
%read (function).
%syntax-error (function).
decr-nesting (function).
incr-nesting (function).
nesting-depth (special variable).
next-char (special variable).
next-char (function).
next-char* (function).
parse-array (function).
parse-literal (function).
parse-number (function).
parse-object (function).
parse-string (function).
parse-unicode-escape (function).
parse-value (function).
rs-json/encoder.lispdecoder.lisp (file).
rs-json (system).
array-element (function).
encode (generic function).
encode-array (function).
encode-false (function).
encode-list (function).
encode-null (function).
encode-object (function).
object-member (function).
serialize (function).
serializer (constant).
serializer (function).
with-array (macro).
with-object (macro).
%array-element (function).
%encoding-error (function).
%object-member (function).
%print (function).
%with-array (function).
%with-object (function).
array-from-vector (function).
char-invert (function).
encode-true (function).
object-from-alist (function).
object-from-hash-table (function).
object-from-plist (function).
output (function).
string-char (function).
string-from-char (function).
string-from-string (function).
string-from-symbol (function).
with-delimiters (macro).
Packages are listed by definition order.
de.ralph-schleicher.jsonYet another JSON decoder/encoder.
If you can’t wait until YASON is fixed, then this library is for you.
The main differences are listed below.
* The parser is strictly RFC 8259 compliant where it makes sense.
However, you can tweak the behavior of the parser to suite your
needs.
* The serializer only supports a compact pretty printing format.
* JSON objects can be represented as hash-tables, associated lists,
or property lists. The default is to use alists.
* JSON arrays can be represented as vectors or lists. The default
is to use vectors.
* The JSON values ‘true’, ‘false’, and ‘null’ are represented by
the keywords ‘:true’, ‘:false’, and ‘:null’ respectively. But
you can change that to suite your needs.
* The default configuration is round-trip save, i.e. you can read
a JSON value and write it back without loss of information. This
is a strict requirement when updating a web resource via an HTTP
GET/PUT cycle.
* Performance is competitive to other “fast” JSON libraries out there.
rs-json
common-lisp.
iterate.
*allow-duplicate-object-keys* (special variable).
*allow-lax-numbers* (special variable).
*allow-literal-object-keys* (special variable).
*allow-trailing-comma* (special variable).
*allow-unicode-graphic* (special variable).
*allow-unicode-whitespace* (special variable).
*array-as* (special variable).
*decode-array-hook* (special variable).
*decode-object-hook* (special variable).
*encode-symbol-hook* (special variable).
*false* (special variable).
*list-encoder* (special variable).
*maximum-nesting-depth* (special variable).
*nil-encoder* (special variable).
*null* (special variable).
*object-as* (special variable).
*object-key-decoder* (special variable).
*true* (special variable).
array-element (function).
encode (generic function).
encode-array (function).
encode-false (function).
encode-list (function).
encode-null (function).
encode-object (function).
encoding-error (condition).
json-error (condition).
object-member (function).
parse (function).
serialize (function).
serializer (constant).
serializer (function).
syntax-error (condition).
with-array (macro).
with-default-values (macro).
with-object (macro).
%array-element (function).
%encoding-error (function).
%object-member (function).
%print (function).
%read (function).
%syntax-error (function).
%with-array (function).
%with-object (function).
*pretty-printer* (special variable).
*scratch* (special variable).
array-from-vector (function).
char-invert (function).
decr-nesting (function).
defconst (macro).
defsubst (macro).
encode-true (function).
incr-nesting (function).
initial-scratch-buffer-size (special variable).
make-scratch-buffer (function).
nesting-depth (special variable).
next-char (special variable).
next-char (function).
next-char* (function).
object-from-alist (function).
object-from-hash-table (function).
object-from-plist (function).
output (function).
parse-array (function).
parse-literal (function).
parse-number (function).
parse-object (function).
parse-string (function).
parse-unicode-escape (function).
parse-value (function).
scratch-buffer-growth-rate (special variable).
scratch-buffer-p (function).
string-char (function).
string-from-char (function).
string-from-string (function).
string-from-symbol (function).
syntax-error-position (generic reader).
(setf syntax-error-position) (generic writer).
unicode-closing-punctuation-p (constant).
unicode-closing-punctuation-p (function).
unicode-connector-punctuation-p (constant).
unicode-connector-punctuation-p (function).
unicode-control-p (constant).
unicode-control-p (function).
unicode-currency-symbol-p (constant).
unicode-currency-symbol-p (function).
unicode-dash-punctuation-p (constant).
unicode-dash-punctuation-p (function).
unicode-decimal-digit-p (constant).
unicode-decimal-digit-p (function).
unicode-enclosing-mark-p (constant).
unicode-enclosing-mark-p (function).
unicode-final-quote-punctuation-p (constant).
unicode-final-quote-punctuation-p (function).
unicode-format-p (function).
unicode-graphic-p (function).
unicode-initial-quote-punctuation-p (constant).
unicode-initial-quote-punctuation-p (function).
unicode-letter-like-number-p (constant).
unicode-letter-like-number-p (function).
unicode-letter-p (constant).
unicode-letter-p (function).
unicode-line-separator-p (constant).
unicode-line-separator-p (function).
unicode-lowercase-letter-p (constant).
unicode-lowercase-letter-p (function).
unicode-mark-p (constant).
unicode-mark-p (function).
unicode-math-symbol-p (constant).
unicode-math-symbol-p (function).
unicode-modifier-letter-p (constant).
unicode-modifier-letter-p (function).
unicode-modifier-symbol-p (constant).
unicode-modifier-symbol-p (function).
unicode-non-spacing-mark-p (constant).
unicode-non-spacing-mark-p (function).
unicode-not-assigned-p (constant).
unicode-not-assigned-p (function).
unicode-number-p (constant).
unicode-number-p (function).
unicode-opening-punctuation-p (constant).
unicode-opening-punctuation-p (function).
unicode-other-format-p (constant).
unicode-other-format-p (function).
unicode-other-letter-p (constant).
unicode-other-letter-p (function).
unicode-other-number-p (constant).
unicode-other-number-p (function).
unicode-other-p (constant).
unicode-other-p (function).
unicode-other-punctuation-p (constant).
unicode-other-punctuation-p (function).
unicode-other-symbol-p (constant).
unicode-other-symbol-p (function).
unicode-paragraph-separator-p (constant).
unicode-paragraph-separator-p (function).
unicode-private-use-p (constant).
unicode-private-use-p (function).
unicode-punctuation-p (constant).
unicode-punctuation-p (function).
unicode-separator-p (constant).
unicode-separator-p (function).
unicode-space-separator-p (constant).
unicode-space-separator-p (function).
unicode-spacing-mark-p (constant).
unicode-spacing-mark-p (function).
unicode-surrogate-p (constant).
unicode-surrogate-p (function).
unicode-symbol-p (constant).
unicode-symbol-p (function).
unicode-titlecase-letter-p (constant).
unicode-titlecase-letter-p (function).
unicode-uppercase-letter-p (constant).
unicode-uppercase-letter-p (function).
unicode-whitespace-p (constant).
unicode-whitespace-p (function).
whitespace-char-p (function).
with-delimiters (macro).
with-scratch-buffer (macro).
Definitions are sorted by export status, category, package, and then by lexicographic order.
Format control for printing a Lisp data structure as a JSON value.
The value of the ‘*print-pretty*’ special variable determines if the
JSON output is pretty printed. For example,
(format t "JSON: ~@?~%" serializer #((("foo" . 42) ("bar" . #("baz" "hack"))) :null))
may print
JSON: [{"foo" : 42,
"bar" : ["baz",
"hack"]},
null]
The value of this constant is a format control function that follows
the conventions for a function created by the ‘formatter’ macro. See
also the ‘serializer’ function for another method for how to print
JSON values with the ‘format’ function.
Whether or not to accept duplicate keys in JSON objects.
If true, the value of an existing object member is replaced by a
successive object member with the same key. Special value ‘:ignore’
means to ignore successive duplicate object members, i.e. the value
of an existing object member will not be replaced. Special value
‘:append’ means to add a duplicate object member to the Lisp data
structure – this feature is only available for alists and plists.
If false, signal a ‘syntax-error’. This is the default.
ECMA-404 says nothing about duplicate object keys. RFC 8259 says that object keys should be unique. Anyway, with this user option, you have the choice.
Whether or not to accept non-standard syntax of numbers.
If true, numbers may have an explicit plus sign and digits before or
after the decimal point may be omitted. Default is false.
Whether or not to accept literal names as keys of object members. Default is false.
Whether or not to accept a comma after the last object member or after the last array element. Default is false.
Whether or not to escape Unicode graphic characters in JSON strings. If true, any Unicode graphic character is printed as is. Otherwise, a graphic character is escaped like any other non-graphic character. Thus, the JSON output is plain US-ASCII. Default is true.
Whether or not to accept any Unicode whitespace character. If true, any character with the Unicode whitespace property is considered a whitespace character. Otherwise, only the space, horizontal tab, line feed, and carriage return character are considered a whitespace character. Default is false.
The Lisp data structure used to represent a JSON array.
Value is either ‘:vector’ or ‘:list’. The default is to use
vectors.
If you want to use lists, you should set the ‘*list-encoder*’ special variable to the ‘encode-array’ function.
Hook to run after a JSON array has been decoded.
Value has to be a function designator. The function is called with
one argument, the Lisp data structure representing the JSON array;
see the ‘*array-as*’ special variable. The return value of the
function is used as the actual array value.
Hook to run after a JSON object has been decoded.
Value has to be a function designator. The function is called with
one argument, the Lisp data structure representing the JSON object;
see the ‘*object-as*’ special variable. The return value of the
function is used as the actual object value.
Hook to convert a symbol into a string.
Value has to be a function designator. The function is called with
the symbol as the only argument. The return value of the function
must be a string.
Special value ‘:upcase’, ‘:downcase’, ‘:capitalize’, ‘:preserve’, or ‘:invert’ means to change the case of the symbol name respectively. See the ‘*print-case*’ special variable and ‘readtable-case’ function. A value of ‘nil’ means to use the value of the ‘*print-case*’ special variable.
The symbol to represent the JSON value ‘false’.
Default is ‘:false’, but ‘nil’ may be appropriate, too. For the
later, please take care of ambiguities since ‘nil’ also represents
the empty list.
The actual function used to encode a list.
Suitable values are ‘encode-object’ or ‘encode-array’ to encode
a list as a JSON object or as a JSON array respectively. Default
is ‘encode-object’ in accordance with the default value of the
‘*object-as*’ special variable.
The function is called with one argument, the list. The return
value of the function is ignored.
See also the ‘*nil-encoder*’ special variable.
The maximum number of nested JSON structures.
Value must be a positive number and should be at least 20. A value
of ‘nil’ means to not limit the depth of nesting. The default value
is 1000. This option only has an effect when reading JSON values.
The actual function used to encode ‘nil’.
Suitable values are ‘encode-list’, ‘encode-false’, or ‘encode-null’ to encode ‘nil’ as a list, as the JSON ‘false’ value, or as the JSON ‘null’ value respectively. Default is ‘encode-list’ in accordance with the default value of the ‘*object-as*’ special variable.
The symbol to represent the JSON value ‘null’.
Default is ‘:null’, but ‘nil’ may be appropriate, too. For the
later, please take care of ambiguities since ‘nil’ also represents
falsity and the empty list.
The Lisp data structure used to represent a JSON object.
Value is either ‘:hash-table’, ‘:alist’, or ‘:plist’. The default
is to use alists.
Object keys are compared with ‘equal’, i.e. using strings as object keys works as expected. This also holds when representing objects as plists.
The function to convert the key string of an object member.
Default is the ‘identity’ function.
The function is called with one argument, the key string. The value
of the function is used as the key for the data structure produced.
See also the ‘*object-as*’ special variable.
If you want to use symbols as objects keys, the simplest solution is
to intern them into the current package.
(let ((*object-key-decoder* #’intern)
(*encode-symbol-hook* :preserve))
(parse "{\"foo\" : 42}"))
⇒ ((|foo| . 42))
Using symbols safes some memory if you have many objects with the same keys. It may also speed up object member access. But please remember: don’t speculate, profile!
The symbol to represent the JSON value ‘true’. Default is ‘:true’, but ‘t’ may be appropriate, too.
Encode a JSON array.
The BODY calls ‘(array-element VALUE)’ to encode an array element.
Establish a lexical environment with all special variables bound to their default values.
Encode a JSON object.
The BODY calls ‘(object-member KEY VALUE)’ to encode the key/value pair of an object member.
Encode a JSON array element. See the ‘with-array’ macro.
Encode Lisp data as a JSON array.
Argument DATA is the Lisp data to be serialized as a JSON array.
Value has to be a sequence, i.e. a vector or a list.
Mostly useful for binding ‘*list-encoder*’.
Constantly print a JSON ‘false’ value.
Mostly useful for binding ‘*nil-encoder*’.
Encode a list by calling ‘*list-encoder*’.
Mostly useful for binding ‘*nil-encoder*’.
Constantly print a JSON ‘null’ value.
Mostly useful for binding ‘*nil-encoder*’.
Encode Lisp data as a JSON object.
Argument DATA is the Lisp data to be serialized as a JSON object.
Value has to be a hash table, an associated list, or a property list.
If DATA is a list, the value of the ‘*object-as*’ special variable
affects the interpretation of DATA.
Mostly useful for binding the ‘*list-encoder*’ special variable.
Encode a JSON object member. See the ‘with-object’ macro.
Read a JSON value.
First argument SOURCE is the input object. Value is either a
stream, a string, or a pathname. The special value ‘t’ is
equal to ‘*standard-input*’
If keyword argument JUNK-ALLOWED is true, do not signal an error
of type ‘syntax-error’ if a non-whitespace character occurs after
the JSON value. Default value is false.
The ‘parse’ function expects exactly one JSON value. Any value
is accepted, not only an object or array. Optional leading and
trailing whitespace is ignored.
Return value is the Lisp representation of the JSON value.
Secondary value is the position where the parsing ends, or
‘nil’ if the position can not be determined.
Exceptional situations:
* Signals an ‘end-of-file’ error if the input ends in the
middle of a JSON value.
* Signals a ‘syntax-error’ if the input contains an invalid
JSON structure.
* May signal an ‘arithmetic-error’ if a JSON number can not
be represented as a Lisp number.
* Signals a ‘program-error’ if JSON objects are parsed as hash tables, ‘*allow-duplicate-object-keys*’ is bound to ‘:append’, and a duplicate object member occurs.
Print a Lisp data structure as a JSON value.
First argument DESTINATION is the output object. Value is either a
stream, a string, or a pathname. The special value ‘t’ is equal to
‘*standard-output*’ and ‘nil’ means to return a string.
Second argument DATA is the Lisp data structure to be serialized.
If keyword argument PRETTY is true, pretty print the JSON value in
a compact format. Default is false.
The actual serialization of Lisp data as a JSON value is performed
by the ‘encode’ methods (which see).
If DESTINATION is a stream, a string, a pathname, or ‘t’, then the
result is ‘nil’. Otherwise, the result is a string containing the
output.
Exceptional situations:
* Signals an ‘encoding-error’ if the Lisp data can not be
encoded as a JSON value.
* May signal an ‘arithmetic-error’ if a rational number is
converted to a floating-point number.
Notes:
If the pretty printer is disabled, JSON output is just a flat
sequence of characters. For example:
[{"foo" : 42, "bar" : ["baz", "hack"]}, null]
There is no explicit or implicit line break since all control
characters are escaped. While this is fast and machine readable,
it’s difficult for humans to reveal the structure of the data.
If the pretty printer is enabled, JSON output is more visually appearing. Here is the same example as above but pretty printed:
[{"foo" : 42,
"bar" : ["baz",
"hack"]},
null]
Explicit line breaks occur after object members and array elements and the items of these compound structures are lined up nicely.
Format function for printing a Lisp data structure as a JSON value.
First argument STREAM is the output stream.
Second argument DATA is the Lisp data structure to be serialized.
If optional third argument COLONP is true, output the JSON value in
a pretty printed format. Default is false.
The remaining arguments are ignored.
This function is designed so that it can be called by a slash format
directive, i.e. ‘~/serializer/’. If the colon modifier is given, use
the pretty printer. For example,
(format t "JSON: ~/serializer/~%" #((("foo" . 42) ("bar" . #("baz" "hack"))) :null))
prints
JSON: [{"foo" : 42, "bar" : ["baz", "hack"]}, null]
whereas
(format t "JSON: ~:/serializer/~%" #((("foo" . 42) ("bar" . #("baz" "hack"))) :null))
prints
JSON: [{"foo" : 42,
"bar" : ["baz",
"hack"]},
null]
See also the ‘serializer’ constant variable for another method for
how to print JSON values with the ‘format’ function.
Encode Lisp data as a JSON value.
Argument DATA is the Lisp data to be serialized.
The JSON output is written to the ‘*standard-output*’ stream.
The return value of an ‘encode’ method is ignored.
The ‘with-object’ and ‘with-array’ macros can be used to define JSON
encoders for your own Lisp data structures. For example, define an
encoder for a CLOS class:
(defclass bank-account ()
((iban
:initarg :iban
:initform (error "Missing IBAN argument."))
(balance
:initarg :balance
:initform 0)))
(defmethod encode ((object bank-account))
"Encode a bank account as a JSON object."
(with-object
(object-member "iban" (slot-value object ’iban))
(object-member "balance" (slot-value object ’balance))))
After that,
(serialize t (make-instance ’bank-account :iban "DE75512108001245126199"))
prints
{"iban" : "DE75512108001245126199", "balance" : 0}
list)) ¶Encode a list by calling ‘*list-encoder*’.
real)) ¶Encode a floating-point number as a JSON number.
rational)) ¶Encode a rational number as a JSON number. Affected by ‘*read-default-float-format*’.
integer)) ¶Encode an integer as a JSON number.
character)) ¶Encode a character as a JSON string.
symbol)) ¶Encode a symbol as a JSON string.
Affected by ‘*true*’, ‘*false*’, ‘*null*’, ‘*encode-symbol-hook*’,
and ‘*print-case*’.
Exceptional situations:
* Signals a ‘program-error’ if the value returned by the ‘*encode-symbol-hook*’ function is not a string.
string)) ¶Encode a string as a JSON string.
(eql nil))) ¶Encode ‘nil’ by calling ‘*nil-encoder*’.
(eql t))) ¶Encode ‘t’ as a JSON ‘true’ value.
(eql :null))) ¶Encode ‘:null’ as a JSON ‘null’ value.
(eql :false))) ¶Encode ‘:false’ as a JSON ‘false’ value.
(eql :true))) ¶Encode ‘:true’ as a JSON ‘true’ value.
vector)) ¶Encode a vector as a JSON array.
hash-table)) ¶Encode a hash table as a JSON object.
The default encoding method. Signals an ‘encoding-error’.
Condition type for an encoding error.
Class precedence list:
‘encoding-error’, ‘json-error’, ...
Base class for all JSON errors.
Class precedence list:
‘json-error’, ‘stream-error’, ‘error’, ...
simple-condition.
stream-error.
Condition type for a syntax error.
Class precedence list:
‘syntax-error’, ‘json-error’, ...
common-lisp.
(quote nil)
:position
Whether or not to enable the pretty printer for JSON output.
The default scratch buffer.
The initial number of characters allocated for a scratch buffer. Value has to be a positive integer.
The current number of nested structures.
The last character read by the ‘next-char’ function.
The number of characters to be added if a scratch buffer has to grow. Quite similar to the rehash size of hash tables.
Define a constant variable.
This is like ‘defconstant’ except that the initially set value is reused when the ‘defconst’ form is evaluated again.
Define an inline function.
This is like ‘defun’ except that the function is globally marked for inline expansion by the compiler.
Print the start delimiter START, evaluate FORMS, then print the end delimiter END.
Establish a new region in a scratch buffer.
The actual ‘array-element’ function.
Signal an encoding error.
The actual ‘object-member’ function.
Common entry point for all print functions.
Common entry point for all read functions.
Signal a syntax error.
Helper function for the ‘with-array’ macro.
Helper function for the ‘with-object’ macro.
Encode vector VECTOR as a JSON array.
Return CHAR with inverted case if that is possible.
Decrease the nesting depth.
Constantly print a JSON ‘true’ value.
Increase the nesting depth.
Create a scratch buffer.
Read the next character from ‘*standard-input*’.
Like the ‘next-char’ function but skip over whitespace characters.
Encode associated list ALIST as a JSON object.
Encode hash table HASH-TABLE as a JSON object.
Encode property list PLIST as a JSON object.
Parse a JSON array.
Parse a JSON literal name token, i.e. ‘true’, ‘false’, or ‘null’.
If optional argument IDENTIFIERP is true, accept any valid JavaScript
identifier.
Return either the Lisp value of the literal name token or the identifier name (a string).
Parse a JSON number.
Parse a JSON object.
Parse a JSON string.
Helper function for ‘parse-string’.
Parse any JSON value.
Return true if BUFFER is a scratch buffer.
Encode the character CHAR as part of a JSON string.
Encode character CHAR as a JSON string.
Encode string STRING as a JSON string.
Encode symbol SYMBOL as a JSON string.
Return true if CHAR is a whitespace character. Argument CHAR has to be a character object.
syntax-error)) ¶syntax-error)) ¶| Jump to: | %
(
A C D E F G I M N O P S U W |
|---|
| Jump to: | %
(
A C D E F G I M N O P S U W |
|---|
| Jump to: | *
C I N P S U |
|---|
| Jump to: | *
C I N P S U |
|---|
| Jump to: | C D E F J P R S |
|---|
| Jump to: | C D E F J P R S |
|---|