The rs-json Reference Manual

This is the rs-json Reference Manual, version 1.2.5, generated automatically by Declt version 4.0 beta 2 "William Riker" on Sun Dec 08 19:30:16 2024 GMT+0.

Table of Contents


1 Introduction


2 Systems

The main system appears first, followed by any subsystem dependency.


2.1 rs-json

Yet another JSON decoder/encoder.

Author

Ralph Schleicher <>

License

Modified BSD License

Version

1.2.5

Dependencies
  • alexandria (system).
  • iterate (system).
  • cl-unicode (system).
Source

rs-json.asd.

Child Components

3 Files

Files are sorted by type and then listed depth-first from the systems components trees.


3.1 Lisp


3.1.1 rs-json/rs-json.asd

Source

rs-json.asd.

Parent Component

rs-json (system).

ASDF Systems

rs-json.


3.1.2 rs-json/packages.lisp

Source

rs-json.asd.

Parent Component

rs-json (system).

Packages

de.ralph-schleicher.json.


3.1.3 rs-json/specials.lisp

Dependency

packages.lisp (file).

Source

rs-json.asd.

Parent Component

rs-json (system).

Public Interface
Internals

*pretty-printer* (special variable).


3.1.4 rs-json/common.lisp

Dependency

specials.lisp (file).

Source

rs-json.asd.

Parent Component

rs-json (system).

Public Interface
Internals

3.1.5 rs-json/decoder.lisp

Dependency

common.lisp (file).

Source

rs-json.asd.

Parent Component

rs-json (system).

Public Interface

parse (function).

Internals

3.1.6 rs-json/encoder.lisp

Dependency

decoder.lisp (file).

Source

rs-json.asd.

Parent Component

rs-json (system).

Public Interface
Internals

4 Packages

Packages are listed by definition order.


4.1 de.ralph-schleicher.json

Yet 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.

Source

packages.lisp.

Nickname

rs-json

Use List
  • common-lisp.
  • iterate.
Public Interface
Internals

5 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.


5.1 Public Interface


5.1.1 Constants

Constant: serializer

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.

Package

de.ralph-schleicher.json.

Source

encoder.lisp.


5.1.2 Special variables

Special Variable: *allow-duplicate-object-keys*

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.

Package

de.ralph-schleicher.json.

Source

specials.lisp.

Special Variable: *allow-lax-numbers*

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.

Package

de.ralph-schleicher.json.

Source

specials.lisp.

Special Variable: *allow-literal-object-keys*

Whether or not to accept literal names as keys of object members. Default is false.

Package

de.ralph-schleicher.json.

Source

specials.lisp.

Special Variable: *allow-trailing-comma*

Whether or not to accept a comma after the last object member or after the last array element. Default is false.

Package

de.ralph-schleicher.json.

Source

specials.lisp.

Special Variable: *allow-unicode-graphic*

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.

Package

de.ralph-schleicher.json.

Source

specials.lisp.

Special Variable: *allow-unicode-whitespace*

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.

Package

de.ralph-schleicher.json.

Source

specials.lisp.

Special Variable: *array-as*

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.

Package

de.ralph-schleicher.json.

Source

specials.lisp.

Special Variable: *decode-array-hook*

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.

Package

de.ralph-schleicher.json.

Source

specials.lisp.

Special Variable: *decode-object-hook*

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.

Package

de.ralph-schleicher.json.

Source

specials.lisp.

Special Variable: *encode-symbol-hook*

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.

Package

de.ralph-schleicher.json.

Source

specials.lisp.

Special Variable: *false*

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.

Package

de.ralph-schleicher.json.

Source

specials.lisp.

Special Variable: *list-encoder*

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.

Package

de.ralph-schleicher.json.

Source

specials.lisp.

Special Variable: *maximum-nesting-depth*

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.

Package

de.ralph-schleicher.json.

Source

specials.lisp.

Special Variable: *nil-encoder*

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.

Package

de.ralph-schleicher.json.

Source

specials.lisp.

Special Variable: *null*

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.

Package

de.ralph-schleicher.json.

Source

specials.lisp.

Special Variable: *object-as*

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.

Package

de.ralph-schleicher.json.

Source

specials.lisp.

Special Variable: *object-key-decoder*

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!

Package

de.ralph-schleicher.json.

Source

specials.lisp.

Special Variable: *true*

The symbol to represent the JSON value ‘true’. Default is ‘:true’, but ‘t’ may be appropriate, too.

Package

de.ralph-schleicher.json.

Source

specials.lisp.


5.1.3 Macros

Macro: with-array (&body body)

Encode a JSON array.

The BODY calls ‘(array-element VALUE)’ to encode an array element.

Package

de.ralph-schleicher.json.

Source

encoder.lisp.

Macro: with-default-values ((&rest ignored) &body body)

Establish a lexical environment with all special variables bound to their default values.

Package

de.ralph-schleicher.json.

Source

specials.lisp.

Macro: with-object (&body body)

Encode a JSON object.

The BODY calls ‘(object-member KEY VALUE)’ to encode the key/value pair of an object member.

Package

de.ralph-schleicher.json.

Source

encoder.lisp.


5.1.4 Ordinary functions

Function: array-element (value)

Encode a JSON array element. See the ‘with-array’ macro.

Package

de.ralph-schleicher.json.

Source

encoder.lisp.

Function: encode-array (data)

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*’.

Package

de.ralph-schleicher.json.

Source

encoder.lisp.

Function: encode-false (data)

Constantly print a JSON ‘false’ value.

Mostly useful for binding ‘*nil-encoder*’.

Package

de.ralph-schleicher.json.

Source

encoder.lisp.

Function: encode-list (data)

Encode a list by calling ‘*list-encoder*’.

Mostly useful for binding ‘*nil-encoder*’.

Package

de.ralph-schleicher.json.

Source

encoder.lisp.

Function: encode-null (data)

Constantly print a JSON ‘null’ value.

Mostly useful for binding ‘*nil-encoder*’.

Package

de.ralph-schleicher.json.

Source

encoder.lisp.

Function: encode-object (data)

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.

Package

de.ralph-schleicher.json.

Source

encoder.lisp.

Function: object-member (key value)

Encode a JSON object member. See the ‘with-object’ macro.

Package

de.ralph-schleicher.json.

Source

encoder.lisp.

Function: parse (source &key junk-allowed)

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.

Package

de.ralph-schleicher.json.

Source

decoder.lisp.

Function: serialize (destination data &key pretty)

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.

Package

de.ralph-schleicher.json.

Source

encoder.lisp.

Function: serializer (stream data &optional colonp at-sign-p &rest parameters)

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.

Package

de.ralph-schleicher.json.

Source

encoder.lisp.


5.1.5 Generic functions

Generic Function: encode (data)

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}

Package

de.ralph-schleicher.json.

Source

encoder.lisp.

Methods
Method: encode ((data list))

Encode a list by calling ‘*list-encoder*’.

Method: encode ((data real))

Encode a floating-point number as a JSON number.

Method: encode ((data rational))

Encode a rational number as a JSON number. Affected by ‘*read-default-float-format*’.

Method: encode ((data integer))

Encode an integer as a JSON number.

Method: encode ((data character))

Encode a character as a JSON string.

Method: encode ((data 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.

Method: encode ((data string))

Encode a string as a JSON string.

Method: encode ((data (eql nil)))

Encode ‘nil’ by calling ‘*nil-encoder*’.

Method: encode ((data (eql t)))

Encode ‘t’ as a JSON ‘true’ value.

Method: encode ((data (eql :null)))

Encode ‘:null’ as a JSON ‘null’ value.

Method: encode ((data (eql :false)))

Encode ‘:false’ as a JSON ‘false’ value.

Method: encode ((data (eql :true)))

Encode ‘:true’ as a JSON ‘true’ value.

Method: encode ((data vector))

Encode a vector as a JSON array.

Method: encode ((data hash-table))

Encode a hash table as a JSON object.

Method: encode (data)

The default encoding method. Signals an ‘encoding-error’.


5.1.6 Conditions

Condition: encoding-error

Condition type for an encoding error.

Class precedence list:

‘encoding-error’, ‘json-error’, ...

Package

de.ralph-schleicher.json.

Source

common.lisp.

Direct superclasses

json-error.

Condition: json-error

Base class for all JSON errors.

Class precedence list:

‘json-error’, ‘stream-error’, ‘error’, ...

Package

de.ralph-schleicher.json.

Source

common.lisp.

Direct superclasses
  • simple-condition.
  • stream-error.
Direct subclasses
Condition: syntax-error

Condition type for a syntax error.

Class precedence list:

‘syntax-error’, ‘json-error’, ...

Package

de.ralph-schleicher.json.

Source

common.lisp.

Direct superclasses

json-error.

Direct methods
Direct slots
Slot: position
Package

common-lisp.

Initform

(quote nil)

Initargs

:position

Readers

syntax-error-position.

Writers

(setf syntax-error-position).


5.2 Internals


5.2.1 Constants

Constant: unicode-closing-punctuation-p
Package

de.ralph-schleicher.json.

Source

common.lisp.

Constant: unicode-connector-punctuation-p
Package

de.ralph-schleicher.json.

Source

common.lisp.

Constant: unicode-control-p
Package

de.ralph-schleicher.json.

Source

common.lisp.

Constant: unicode-currency-symbol-p
Package

de.ralph-schleicher.json.

Source

common.lisp.

Constant: unicode-dash-punctuation-p
Package

de.ralph-schleicher.json.

Source

common.lisp.

Constant: unicode-decimal-digit-p
Package

de.ralph-schleicher.json.

Source

common.lisp.

Constant: unicode-enclosing-mark-p
Package

de.ralph-schleicher.json.

Source

common.lisp.

Constant: unicode-final-quote-punctuation-p
Package

de.ralph-schleicher.json.

Source

common.lisp.

Constant: unicode-initial-quote-punctuation-p
Package

de.ralph-schleicher.json.

Source

common.lisp.

Constant: unicode-letter-like-number-p
Package

de.ralph-schleicher.json.

Source

common.lisp.

Constant: unicode-letter-p
Package

de.ralph-schleicher.json.

Source

common.lisp.

Constant: unicode-line-separator-p
Package

de.ralph-schleicher.json.

Source

common.lisp.

Constant: unicode-lowercase-letter-p
Package

de.ralph-schleicher.json.

Source

common.lisp.

Constant: unicode-mark-p
Package

de.ralph-schleicher.json.

Source

common.lisp.

Constant: unicode-math-symbol-p
Package

de.ralph-schleicher.json.

Source

common.lisp.

Constant: unicode-modifier-letter-p
Package

de.ralph-schleicher.json.

Source

common.lisp.

Constant: unicode-modifier-symbol-p
Package

de.ralph-schleicher.json.

Source

common.lisp.

Constant: unicode-non-spacing-mark-p
Package

de.ralph-schleicher.json.

Source

common.lisp.

Constant: unicode-not-assigned-p
Package

de.ralph-schleicher.json.

Source

common.lisp.

Constant: unicode-number-p
Package

de.ralph-schleicher.json.

Source

common.lisp.

Constant: unicode-opening-punctuation-p
Package

de.ralph-schleicher.json.

Source

common.lisp.

Constant: unicode-other-format-p
Package

de.ralph-schleicher.json.

Source

common.lisp.

Constant: unicode-other-letter-p
Package

de.ralph-schleicher.json.

Source

common.lisp.

Constant: unicode-other-number-p
Package

de.ralph-schleicher.json.

Source

common.lisp.

Constant: unicode-other-p
Package

de.ralph-schleicher.json.

Source

common.lisp.

Constant: unicode-other-punctuation-p
Package

de.ralph-schleicher.json.

Source

common.lisp.

Constant: unicode-other-symbol-p
Package

de.ralph-schleicher.json.

Source

common.lisp.

Constant: unicode-paragraph-separator-p
Package

de.ralph-schleicher.json.

Source

common.lisp.

Constant: unicode-private-use-p
Package

de.ralph-schleicher.json.

Source

common.lisp.

Constant: unicode-punctuation-p
Package

de.ralph-schleicher.json.

Source

common.lisp.

Constant: unicode-separator-p
Package

de.ralph-schleicher.json.

Source

common.lisp.

Constant: unicode-space-separator-p
Package

de.ralph-schleicher.json.

Source

common.lisp.

Constant: unicode-spacing-mark-p
Package

de.ralph-schleicher.json.

Source

common.lisp.

Constant: unicode-surrogate-p
Package

de.ralph-schleicher.json.

Source

common.lisp.

Constant: unicode-symbol-p
Package

de.ralph-schleicher.json.

Source

common.lisp.

Constant: unicode-titlecase-letter-p
Package

de.ralph-schleicher.json.

Source

common.lisp.

Constant: unicode-uppercase-letter-p
Package

de.ralph-schleicher.json.

Source

common.lisp.

Constant: unicode-whitespace-p
Package

de.ralph-schleicher.json.

Source

common.lisp.


5.2.2 Special variables

Special Variable: *pretty-printer*

Whether or not to enable the pretty printer for JSON output.

Package

de.ralph-schleicher.json.

Source

specials.lisp.

Special Variable: *scratch*

The default scratch buffer.

Package

de.ralph-schleicher.json.

Source

common.lisp.

Special Variable: initial-scratch-buffer-size

The initial number of characters allocated for a scratch buffer. Value has to be a positive integer.

Package

de.ralph-schleicher.json.

Source

common.lisp.

Special Variable: nesting-depth

The current number of nested structures.

Package

de.ralph-schleicher.json.

Source

decoder.lisp.

Special Variable: next-char

The last character read by the ‘next-char’ function.

Package

de.ralph-schleicher.json.

Source

decoder.lisp.

Special Variable: scratch-buffer-growth-rate

The number of characters to be added if a scratch buffer has to grow. Quite similar to the rehash size of hash tables.

Package

de.ralph-schleicher.json.

Source

common.lisp.


5.2.3 Macros

Macro: defconst (name value &optional doc)

Define a constant variable.

This is like ‘defconstant’ except that the initially set value is reused when the ‘defconst’ form is evaluated again.

Package

de.ralph-schleicher.json.

Source

common.lisp.

Macro: defsubst (name arg-list &body body)

Define an inline function.

This is like ‘defun’ except that the function is globally marked for inline expansion by the compiler.

Package

de.ralph-schleicher.json.

Source

common.lisp.

Macro: with-delimiters (start end &body forms)

Print the start delimiter START, evaluate FORMS, then print the end delimiter END.

Package

de.ralph-schleicher.json.

Source

encoder.lisp.

Macro: with-scratch-buffer ((&optional buffer) &body body)

Establish a new region in a scratch buffer.

Package

de.ralph-schleicher.json.

Source

common.lisp.


5.2.4 Ordinary functions

Function: %array-element (value firstp)

The actual ‘array-element’ function.

Package

de.ralph-schleicher.json.

Source

encoder.lisp.

Function: %encoding-error (&optional datum &rest arguments)

Signal an encoding error.

Package

de.ralph-schleicher.json.

Source

encoder.lisp.

Function: %object-member (key value firstp)

The actual ‘object-member’ function.

Package

de.ralph-schleicher.json.

Source

encoder.lisp.

Function: %print (stream data &optional pretty)

Common entry point for all print functions.

Package

de.ralph-schleicher.json.

Source

encoder.lisp.

Function: %read (stream &optional junk-allowed)

Common entry point for all read functions.

Package

de.ralph-schleicher.json.

Source

decoder.lisp.

Function: %syntax-error (&optional datum &rest arguments)

Signal a syntax error.

Package

de.ralph-schleicher.json.

Source

decoder.lisp.

Function: %with-array (body)

Helper function for the ‘with-array’ macro.

Package

de.ralph-schleicher.json.

Source

encoder.lisp.

Function: %with-object (body)

Helper function for the ‘with-object’ macro.

Package

de.ralph-schleicher.json.

Source

encoder.lisp.

Function: array-from-vector (vector)

Encode vector VECTOR as a JSON array.

Package

de.ralph-schleicher.json.

Source

encoder.lisp.

Function: char-invert (char)

Return CHAR with inverted case if that is possible.

Package

de.ralph-schleicher.json.

Source

encoder.lisp.

Function: decr-nesting ()

Decrease the nesting depth.

Package

de.ralph-schleicher.json.

Source

decoder.lisp.

Function: encode-true (data)

Constantly print a JSON ‘true’ value.

Package

de.ralph-schleicher.json.

Source

encoder.lisp.

Function: incr-nesting ()

Increase the nesting depth.

Package

de.ralph-schleicher.json.

Source

decoder.lisp.

Function: make-scratch-buffer (&optional size)

Create a scratch buffer.

Package

de.ralph-schleicher.json.

Source

common.lisp.

Function: next-char (&optional eof-error-p)

Read the next character from ‘*standard-input*’.

Package

de.ralph-schleicher.json.

Source

decoder.lisp.

Function: next-char* (&optional eof-error-p)

Like the ‘next-char’ function but skip over whitespace characters.

Package

de.ralph-schleicher.json.

Source

decoder.lisp.

Function: object-from-alist (alist)

Encode associated list ALIST as a JSON object.

Package

de.ralph-schleicher.json.

Source

encoder.lisp.

Function: object-from-hash-table (hash-table)

Encode hash table HASH-TABLE as a JSON object.

Package

de.ralph-schleicher.json.

Source

encoder.lisp.

Function: object-from-plist (plist)

Encode property list PLIST as a JSON object.

Package

de.ralph-schleicher.json.

Source

encoder.lisp.

Function: output (object)
Package

de.ralph-schleicher.json.

Source

encoder.lisp.

Function: parse-array ()

Parse a JSON array.

Package

de.ralph-schleicher.json.

Source

decoder.lisp.

Function: parse-literal (&optional identifierp)

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).

Package

de.ralph-schleicher.json.

Source

decoder.lisp.

Function: parse-number ()

Parse a JSON number.

Package

de.ralph-schleicher.json.

Source

decoder.lisp.

Function: parse-object ()

Parse a JSON object.

Package

de.ralph-schleicher.json.

Source

decoder.lisp.

Function: parse-string ()

Parse a JSON string.

Package

de.ralph-schleicher.json.

Source

decoder.lisp.

Function: parse-unicode-escape ()

Helper function for ‘parse-string’.

Package

de.ralph-schleicher.json.

Source

decoder.lisp.

Function: parse-value ()

Parse any JSON value.

Package

de.ralph-schleicher.json.

Source

decoder.lisp.

Function: scratch-buffer-p (&optional buffer)

Return true if BUFFER is a scratch buffer.

Package

de.ralph-schleicher.json.

Source

common.lisp.

Function: string-char (char)

Encode the character CHAR as part of a JSON string.

Package

de.ralph-schleicher.json.

Source

encoder.lisp.

Function: string-from-char (char)

Encode character CHAR as a JSON string.

Package

de.ralph-schleicher.json.

Source

encoder.lisp.

Function: string-from-string (string)

Encode string STRING as a JSON string.

Package

de.ralph-schleicher.json.

Source

encoder.lisp.

Function: string-from-symbol (symbol &optional char-encoder)

Encode symbol SYMBOL as a JSON string.

Package

de.ralph-schleicher.json.

Source

encoder.lisp.

Function: unicode-closing-punctuation-p (c)
Package

de.ralph-schleicher.json.

Source

common.lisp.

Function: unicode-connector-punctuation-p (c)
Package

de.ralph-schleicher.json.

Source

common.lisp.

Function: unicode-control-p (c)
Package

de.ralph-schleicher.json.

Source

common.lisp.

Function: unicode-currency-symbol-p (c)
Package

de.ralph-schleicher.json.

Source

common.lisp.

Function: unicode-dash-punctuation-p (c)
Package

de.ralph-schleicher.json.

Source

common.lisp.

Function: unicode-decimal-digit-p (c)
Package

de.ralph-schleicher.json.

Source

common.lisp.

Function: unicode-enclosing-mark-p (c)
Package

de.ralph-schleicher.json.

Source

common.lisp.

Function: unicode-final-quote-punctuation-p (c)
Package

de.ralph-schleicher.json.

Source

common.lisp.

Function: unicode-format-p (c)
Package

de.ralph-schleicher.json.

Source

common.lisp.

Function: unicode-graphic-p (c)
Package

de.ralph-schleicher.json.

Source

common.lisp.

Function: unicode-initial-quote-punctuation-p (c)
Package

de.ralph-schleicher.json.

Source

common.lisp.

Function: unicode-letter-like-number-p (c)
Package

de.ralph-schleicher.json.

Source

common.lisp.

Function: unicode-letter-p (c)
Package

de.ralph-schleicher.json.

Source

common.lisp.

Function: unicode-line-separator-p (c)
Package

de.ralph-schleicher.json.

Source

common.lisp.

Function: unicode-lowercase-letter-p (c)
Package

de.ralph-schleicher.json.

Source

common.lisp.

Function: unicode-mark-p (c)
Package

de.ralph-schleicher.json.

Source

common.lisp.

Function: unicode-math-symbol-p (c)
Package

de.ralph-schleicher.json.

Source

common.lisp.

Function: unicode-modifier-letter-p (c)
Package

de.ralph-schleicher.json.

Source

common.lisp.

Function: unicode-modifier-symbol-p (c)
Package

de.ralph-schleicher.json.

Source

common.lisp.

Function: unicode-non-spacing-mark-p (c)
Package

de.ralph-schleicher.json.

Source

common.lisp.

Function: unicode-not-assigned-p (c)
Package

de.ralph-schleicher.json.

Source

common.lisp.

Function: unicode-number-p (c)
Package

de.ralph-schleicher.json.

Source

common.lisp.

Function: unicode-opening-punctuation-p (c)
Package

de.ralph-schleicher.json.

Source

common.lisp.

Function: unicode-other-format-p (c)
Package

de.ralph-schleicher.json.

Source

common.lisp.

Function: unicode-other-letter-p (c)
Package

de.ralph-schleicher.json.

Source

common.lisp.

Function: unicode-other-number-p (c)
Package

de.ralph-schleicher.json.

Source

common.lisp.

Function: unicode-other-p (c)
Package

de.ralph-schleicher.json.

Source

common.lisp.

Function: unicode-other-punctuation-p (c)
Package

de.ralph-schleicher.json.

Source

common.lisp.

Function: unicode-other-symbol-p (c)
Package

de.ralph-schleicher.json.

Source

common.lisp.

Function: unicode-paragraph-separator-p (c)
Package

de.ralph-schleicher.json.

Source

common.lisp.

Function: unicode-private-use-p (c)
Package

de.ralph-schleicher.json.

Source

common.lisp.

Function: unicode-punctuation-p (c)
Package

de.ralph-schleicher.json.

Source

common.lisp.

Function: unicode-separator-p (c)
Package

de.ralph-schleicher.json.

Source

common.lisp.

Function: unicode-space-separator-p (c)
Package

de.ralph-schleicher.json.

Source

common.lisp.

Function: unicode-spacing-mark-p (c)
Package

de.ralph-schleicher.json.

Source

common.lisp.

Function: unicode-surrogate-p (c)
Package

de.ralph-schleicher.json.

Source

common.lisp.

Function: unicode-symbol-p (c)
Package

de.ralph-schleicher.json.

Source

common.lisp.

Function: unicode-titlecase-letter-p (c)
Package

de.ralph-schleicher.json.

Source

common.lisp.

Function: unicode-uppercase-letter-p (c)
Package

de.ralph-schleicher.json.

Source

common.lisp.

Function: unicode-whitespace-p (c)
Package

de.ralph-schleicher.json.

Source

common.lisp.

Function: whitespace-char-p (char)

Return true if CHAR is a whitespace character. Argument CHAR has to be a character object.

Package

de.ralph-schleicher.json.

Source

common.lisp.


5.2.5 Generic functions

Generic Reader: syntax-error-position (condition)
Generic Writer: (setf syntax-error-position) (condition)
Package

de.ralph-schleicher.json.

Methods
Reader Method: syntax-error-position ((condition syntax-error))
Writer Method: (setf syntax-error-position) ((condition syntax-error))
Source

common.lisp.

Target Slot

position.


Appendix A Indexes


A.1 Concepts


A.2 Functions

Jump to:   %   (  
A   C   D   E   F   G   I   M   N   O   P   S   U   W  
Index Entry  Section

%
%array-element: Private ordinary functions
%encoding-error: Private ordinary functions
%object-member: Private ordinary functions
%print: Private ordinary functions
%read: Private ordinary functions
%syntax-error: Private ordinary functions
%with-array: Private ordinary functions
%with-object: Private ordinary functions

(
(setf syntax-error-position): Private generic functions
(setf syntax-error-position): Private generic functions

A
array-element: Public ordinary functions
array-from-vector: Private ordinary functions

C
char-invert: Private ordinary functions

D
decr-nesting: Private ordinary functions
defconst: Private macros
defsubst: Private macros

E
encode: Public generic functions
encode: Public generic functions
encode: Public generic functions
encode: Public generic functions
encode: Public generic functions
encode: Public generic functions
encode: Public generic functions
encode: Public generic functions
encode: Public generic functions
encode: Public generic functions
encode: Public generic functions
encode: Public generic functions
encode: Public generic functions
encode: Public generic functions
encode: Public generic functions
encode: Public generic functions
encode-array: Public ordinary functions
encode-false: Public ordinary functions
encode-list: Public ordinary functions
encode-null: Public ordinary functions
encode-object: Public ordinary functions
encode-true: Private ordinary functions

F
Function, %array-element: Private ordinary functions
Function, %encoding-error: Private ordinary functions
Function, %object-member: Private ordinary functions
Function, %print: Private ordinary functions
Function, %read: Private ordinary functions
Function, %syntax-error: Private ordinary functions
Function, %with-array: Private ordinary functions
Function, %with-object: Private ordinary functions
Function, array-element: Public ordinary functions
Function, array-from-vector: Private ordinary functions
Function, char-invert: Private ordinary functions
Function, decr-nesting: Private ordinary functions
Function, encode-array: Public ordinary functions
Function, encode-false: Public ordinary functions
Function, encode-list: Public ordinary functions
Function, encode-null: Public ordinary functions
Function, encode-object: Public ordinary functions
Function, encode-true: Private ordinary functions
Function, incr-nesting: Private ordinary functions
Function, make-scratch-buffer: Private ordinary functions
Function, next-char: Private ordinary functions
Function, next-char*: Private ordinary functions
Function, object-from-alist: Private ordinary functions
Function, object-from-hash-table: Private ordinary functions
Function, object-from-plist: Private ordinary functions
Function, object-member: Public ordinary functions
Function, output: Private ordinary functions
Function, parse: Public ordinary functions
Function, parse-array: Private ordinary functions
Function, parse-literal: Private ordinary functions
Function, parse-number: Private ordinary functions
Function, parse-object: Private ordinary functions
Function, parse-string: Private ordinary functions
Function, parse-unicode-escape: Private ordinary functions
Function, parse-value: Private ordinary functions
Function, scratch-buffer-p: Private ordinary functions
Function, serialize: Public ordinary functions
Function, serializer: Public ordinary functions
Function, string-char: Private ordinary functions
Function, string-from-char: Private ordinary functions
Function, string-from-string: Private ordinary functions
Function, string-from-symbol: Private ordinary functions
Function, unicode-closing-punctuation-p: Private ordinary functions
Function, unicode-connector-punctuation-p: Private ordinary functions
Function, unicode-control-p: Private ordinary functions
Function, unicode-currency-symbol-p: Private ordinary functions
Function, unicode-dash-punctuation-p: Private ordinary functions
Function, unicode-decimal-digit-p: Private ordinary functions
Function, unicode-enclosing-mark-p: Private ordinary functions
Function, unicode-final-quote-punctuation-p: Private ordinary functions
Function, unicode-format-p: Private ordinary functions
Function, unicode-graphic-p: Private ordinary functions
Function, unicode-initial-quote-punctuation-p: Private ordinary functions
Function, unicode-letter-like-number-p: Private ordinary functions
Function, unicode-letter-p: Private ordinary functions
Function, unicode-line-separator-p: Private ordinary functions
Function, unicode-lowercase-letter-p: Private ordinary functions
Function, unicode-mark-p: Private ordinary functions
Function, unicode-math-symbol-p: Private ordinary functions
Function, unicode-modifier-letter-p: Private ordinary functions
Function, unicode-modifier-symbol-p: Private ordinary functions
Function, unicode-non-spacing-mark-p: Private ordinary functions
Function, unicode-not-assigned-p: Private ordinary functions
Function, unicode-number-p: Private ordinary functions
Function, unicode-opening-punctuation-p: Private ordinary functions
Function, unicode-other-format-p: Private ordinary functions
Function, unicode-other-letter-p: Private ordinary functions
Function, unicode-other-number-p: Private ordinary functions
Function, unicode-other-p: Private ordinary functions
Function, unicode-other-punctuation-p: Private ordinary functions
Function, unicode-other-symbol-p: Private ordinary functions
Function, unicode-paragraph-separator-p: Private ordinary functions
Function, unicode-private-use-p: Private ordinary functions
Function, unicode-punctuation-p: Private ordinary functions
Function, unicode-separator-p: Private ordinary functions
Function, unicode-space-separator-p: Private ordinary functions
Function, unicode-spacing-mark-p: Private ordinary functions
Function, unicode-surrogate-p: Private ordinary functions
Function, unicode-symbol-p: Private ordinary functions
Function, unicode-titlecase-letter-p: Private ordinary functions
Function, unicode-uppercase-letter-p: Private ordinary functions
Function, unicode-whitespace-p: Private ordinary functions
Function, whitespace-char-p: Private ordinary functions

G
Generic Function, (setf syntax-error-position): Private generic functions
Generic Function, encode: Public generic functions
Generic Function, syntax-error-position: Private generic functions

I
incr-nesting: Private ordinary functions

M
Macro, defconst: Private macros
Macro, defsubst: Private macros
Macro, with-array: Public macros
Macro, with-default-values: Public macros
Macro, with-delimiters: Private macros
Macro, with-object: Public macros
Macro, with-scratch-buffer: Private macros
make-scratch-buffer: Private ordinary functions
Method, (setf syntax-error-position): Private generic functions
Method, encode: Public generic functions
Method, encode: Public generic functions
Method, encode: Public generic functions
Method, encode: Public generic functions
Method, encode: Public generic functions
Method, encode: Public generic functions
Method, encode: Public generic functions
Method, encode: Public generic functions
Method, encode: Public generic functions
Method, encode: Public generic functions
Method, encode: Public generic functions
Method, encode: Public generic functions
Method, encode: Public generic functions
Method, encode: Public generic functions
Method, encode: Public generic functions
Method, syntax-error-position: Private generic functions

N
next-char: Private ordinary functions
next-char*: Private ordinary functions

O
object-from-alist: Private ordinary functions
object-from-hash-table: Private ordinary functions
object-from-plist: Private ordinary functions
object-member: Public ordinary functions
output: Private ordinary functions

P
parse: Public ordinary functions
parse-array: Private ordinary functions
parse-literal: Private ordinary functions
parse-number: Private ordinary functions
parse-object: Private ordinary functions
parse-string: Private ordinary functions
parse-unicode-escape: Private ordinary functions
parse-value: Private ordinary functions

S
scratch-buffer-p: Private ordinary functions
serialize: Public ordinary functions
serializer: Public ordinary functions
string-char: Private ordinary functions
string-from-char: Private ordinary functions
string-from-string: Private ordinary functions
string-from-symbol: Private ordinary functions
syntax-error-position: Private generic functions
syntax-error-position: Private generic functions

U
unicode-closing-punctuation-p: Private ordinary functions
unicode-connector-punctuation-p: Private ordinary functions
unicode-control-p: Private ordinary functions
unicode-currency-symbol-p: Private ordinary functions
unicode-dash-punctuation-p: Private ordinary functions
unicode-decimal-digit-p: Private ordinary functions
unicode-enclosing-mark-p: Private ordinary functions
unicode-final-quote-punctuation-p: Private ordinary functions
unicode-format-p: Private ordinary functions
unicode-graphic-p: Private ordinary functions
unicode-initial-quote-punctuation-p: Private ordinary functions
unicode-letter-like-number-p: Private ordinary functions
unicode-letter-p: Private ordinary functions
unicode-line-separator-p: Private ordinary functions
unicode-lowercase-letter-p: Private ordinary functions
unicode-mark-p: Private ordinary functions
unicode-math-symbol-p: Private ordinary functions
unicode-modifier-letter-p: Private ordinary functions
unicode-modifier-symbol-p: Private ordinary functions
unicode-non-spacing-mark-p: Private ordinary functions
unicode-not-assigned-p: Private ordinary functions
unicode-number-p: Private ordinary functions
unicode-opening-punctuation-p: Private ordinary functions
unicode-other-format-p: Private ordinary functions
unicode-other-letter-p: Private ordinary functions
unicode-other-number-p: Private ordinary functions
unicode-other-p: Private ordinary functions
unicode-other-punctuation-p: Private ordinary functions
unicode-other-symbol-p: Private ordinary functions
unicode-paragraph-separator-p: Private ordinary functions
unicode-private-use-p: Private ordinary functions
unicode-punctuation-p: Private ordinary functions
unicode-separator-p: Private ordinary functions
unicode-space-separator-p: Private ordinary functions
unicode-spacing-mark-p: Private ordinary functions
unicode-surrogate-p: Private ordinary functions
unicode-symbol-p: Private ordinary functions
unicode-titlecase-letter-p: Private ordinary functions
unicode-uppercase-letter-p: Private ordinary functions
unicode-whitespace-p: Private ordinary functions

W
whitespace-char-p: Private ordinary functions
with-array: Public macros
with-default-values: Public macros
with-delimiters: Private macros
with-object: Public macros
with-scratch-buffer: Private macros


A.3 Variables

Jump to:   *  
C   I   N   P   S   U  
Index Entry  Section

*
*allow-duplicate-object-keys*: Public special variables
*allow-lax-numbers*: Public special variables
*allow-literal-object-keys*: Public special variables
*allow-trailing-comma*: Public special variables
*allow-unicode-graphic*: Public special variables
*allow-unicode-whitespace*: Public special variables
*array-as*: Public special variables
*decode-array-hook*: Public special variables
*decode-object-hook*: Public special variables
*encode-symbol-hook*: Public special variables
*false*: Public special variables
*list-encoder*: Public special variables
*maximum-nesting-depth*: Public special variables
*nil-encoder*: Public special variables
*null*: Public special variables
*object-as*: Public special variables
*object-key-decoder*: Public special variables
*pretty-printer*: Private special variables
*scratch*: Private special variables
*true*: Public special variables

C
Constant, serializer: Public constants
Constant, unicode-closing-punctuation-p: Private constants
Constant, unicode-connector-punctuation-p: Private constants
Constant, unicode-control-p: Private constants
Constant, unicode-currency-symbol-p: Private constants
Constant, unicode-dash-punctuation-p: Private constants
Constant, unicode-decimal-digit-p: Private constants
Constant, unicode-enclosing-mark-p: Private constants
Constant, unicode-final-quote-punctuation-p: Private constants
Constant, unicode-initial-quote-punctuation-p: Private constants
Constant, unicode-letter-like-number-p: Private constants
Constant, unicode-letter-p: Private constants
Constant, unicode-line-separator-p: Private constants
Constant, unicode-lowercase-letter-p: Private constants
Constant, unicode-mark-p: Private constants
Constant, unicode-math-symbol-p: Private constants
Constant, unicode-modifier-letter-p: Private constants
Constant, unicode-modifier-symbol-p: Private constants
Constant, unicode-non-spacing-mark-p: Private constants
Constant, unicode-not-assigned-p: Private constants
Constant, unicode-number-p: Private constants
Constant, unicode-opening-punctuation-p: Private constants
Constant, unicode-other-format-p: Private constants
Constant, unicode-other-letter-p: Private constants
Constant, unicode-other-number-p: Private constants
Constant, unicode-other-p: Private constants
Constant, unicode-other-punctuation-p: Private constants
Constant, unicode-other-symbol-p: Private constants
Constant, unicode-paragraph-separator-p: Private constants
Constant, unicode-private-use-p: Private constants
Constant, unicode-punctuation-p: Private constants
Constant, unicode-separator-p: Private constants
Constant, unicode-space-separator-p: Private constants
Constant, unicode-spacing-mark-p: Private constants
Constant, unicode-surrogate-p: Private constants
Constant, unicode-symbol-p: Private constants
Constant, unicode-titlecase-letter-p: Private constants
Constant, unicode-uppercase-letter-p: Private constants
Constant, unicode-whitespace-p: Private constants

I
initial-scratch-buffer-size: Private special variables

N
nesting-depth: Private special variables
next-char: Private special variables

P
position: Public conditions

S
scratch-buffer-growth-rate: Private special variables
serializer: Public constants
Slot, position: Public conditions
Special Variable, *allow-duplicate-object-keys*: Public special variables
Special Variable, *allow-lax-numbers*: Public special variables
Special Variable, *allow-literal-object-keys*: Public special variables
Special Variable, *allow-trailing-comma*: Public special variables
Special Variable, *allow-unicode-graphic*: Public special variables
Special Variable, *allow-unicode-whitespace*: Public special variables
Special Variable, *array-as*: Public special variables
Special Variable, *decode-array-hook*: Public special variables
Special Variable, *decode-object-hook*: Public special variables
Special Variable, *encode-symbol-hook*: Public special variables
Special Variable, *false*: Public special variables
Special Variable, *list-encoder*: Public special variables
Special Variable, *maximum-nesting-depth*: Public special variables
Special Variable, *nil-encoder*: Public special variables
Special Variable, *null*: Public special variables
Special Variable, *object-as*: Public special variables
Special Variable, *object-key-decoder*: Public special variables
Special Variable, *pretty-printer*: Private special variables
Special Variable, *scratch*: Private special variables
Special Variable, *true*: Public special variables
Special Variable, initial-scratch-buffer-size: Private special variables
Special Variable, nesting-depth: Private special variables
Special Variable, next-char: Private special variables
Special Variable, scratch-buffer-growth-rate: Private special variables

U
unicode-closing-punctuation-p: Private constants
unicode-connector-punctuation-p: Private constants
unicode-control-p: Private constants
unicode-currency-symbol-p: Private constants
unicode-dash-punctuation-p: Private constants
unicode-decimal-digit-p: Private constants
unicode-enclosing-mark-p: Private constants
unicode-final-quote-punctuation-p: Private constants
unicode-initial-quote-punctuation-p: Private constants
unicode-letter-like-number-p: Private constants
unicode-letter-p: Private constants
unicode-line-separator-p: Private constants
unicode-lowercase-letter-p: Private constants
unicode-mark-p: Private constants
unicode-math-symbol-p: Private constants
unicode-modifier-letter-p: Private constants
unicode-modifier-symbol-p: Private constants
unicode-non-spacing-mark-p: Private constants
unicode-not-assigned-p: Private constants
unicode-number-p: Private constants
unicode-opening-punctuation-p: Private constants
unicode-other-format-p: Private constants
unicode-other-letter-p: Private constants
unicode-other-number-p: Private constants
unicode-other-p: Private constants
unicode-other-punctuation-p: Private constants
unicode-other-symbol-p: Private constants
unicode-paragraph-separator-p: Private constants
unicode-private-use-p: Private constants
unicode-punctuation-p: Private constants
unicode-separator-p: Private constants
unicode-space-separator-p: Private constants
unicode-spacing-mark-p: Private constants
unicode-surrogate-p: Private constants
unicode-symbol-p: Private constants
unicode-titlecase-letter-p: Private constants
unicode-uppercase-letter-p: Private constants
unicode-whitespace-p: Private constants