[manual index][section index]


Sexprs: Sexp - S-expressions


include "bufio.m";
include "sexprs.m";
sexprs := load Sexprs Sexprs->PATH;

Sexp: adt {
    pick {
    String =>
        s:    string;
        hint: string;
    Binary =>
        data: array of byte;
        hint: string;
    List =>
        l:    cyclic list of ref Sexp;

    read:   fn(b: ref Bufio->Iobuf): (ref Sexp, string);
    parse:  fn(s: string): (ref Sexp, string, string);
    pack:   fn(e: self ref Sexp): array of byte;
    packedsize: fn(e: self ref Sexp): int;
    text:   fn(e: self ref Sexp): string;
    b64text: fn(e: self ref Sexp): string;
    unpack: fn(a: array of byte): (ref Sexp, array of byte, string);

    eq:     fn(e: self ref Sexp, t: ref Sexp): int;
    copy:   fn(e: self ref Sexp): ref Sexp;

    astext: fn(e: self ref Sexp): string;
    asdata: fn(e: self ref Sexp): array of byte;

    islist: fn(e: self ref Sexp): int;
    els:    fn(e: self ref Sexp): list of ref Sexp;
    op:     fn(e: self ref Sexp): string;
    args:   fn(e: self ref Sexp): list of ref Sexp;

init:   fn();


Sexprs provides a data type and I/O for S-expressions, or `symbolic expressions', which represent complex data as trees. This implementation provides the variant defined by Rivest in Internet Draft draft-rivest-sexp-00.txt (4 May 1997), as used for instance by the Simple Public Key Infrastructure (SPKI). It offers a basic set of operations on the internal representation, and input and output in both canonical and advanced transport encodings. Canonical form conveys binary data directly and efficiently (unlike some other schemes such as XML). Canonical encoding must be used when exchanging S-expressions between computers, and when digitally signing an expression. Advanced encoding is a more elaborate form similar to that used by Lisp interpreters, typically using only printable characters: representing any binary data in hexadecimal or base 64 encodings, and quoting strings containing special characters, using escape sequences as required. Unquoted text is called a token, restricted by the standard to a specific alphabet: it must start with a letter or a character from the set -./_:*+=, and contain only letters, digits and characters from that set. Upper- and lower-case letters are distinct. See sexprs(6) for a precise description.

Init must be called before invoking any other operation of the module.

Sexp is the internal representation of S-expression data, as lists and non-list values (atoms) that in general can form a tree structure; that is, a list may contain not just atoms but other lists as its elements, and so on recursively. The atoms are strings of text or binary. A well-formed S-expression might be a tree, but cannot contain cycles.

For convenience in processing, Sexp distinguishes three variants represented in a pick adt:

An atom that can be represented as a textual string s, including all tokens but also any other data that contains no characters outside the 7-bit ASCII set and no control-characters other than space. Hint is the `display hint', typically nil (see the Internet Draft for its intended use).
An atom that must be represented as an array of bytes data (typically because it is purely binary data or contains non-space control-characters). Hint again is the display hint.
A list of S-expression values, l.

Sexp provides the following operations for input and output, using bufio(2)'s buffered channels (directly or indirectly):

Read one S-expression (a list or a single token) from Iobuf b. Return a tuple of the form (e,err), where e is the Sexp representing the data just read, and err is nil on success; b is positioned at the first character after the end of the S-expression. On an error, e is nil, and err contains the diagnostic string. On end-of-file, both e and err are nil.
Parse the first S-expression in string s, and return a tuple (e,t,err), where e is the Sexp representating that expression, t is the unparsed tail of string s, and err is a diagnostic string that is nil on success. On an error, e is nil, t is as before, and err contains the diagnostic.
Return an array of byte that represents Sexp e as an S-expression in canonical transport form.
Return the size in bytes of the canonical transport representation of e.
Return a string that contains the base-64 representation of the canonical representation of e, surrounded by braces.
Return a string that represents e as an S-expression in advanced (`human-readable') transport form containing no newlines. The result of text can always be interpreted by Sexp.read and Sexp.parse, and furthermore Sexp.parse(e.text()) yields the same tree value as e (similarly for Sexp.read).
Parse the first S-expression in array of byte a, and return a tuple (e,r,err), where e is the Sexp representing the S-expression, r is a slice of a giving the portion of a after the S-expression, and err is nil on success. On error, e is nil, r is as before, and err contains a diagnostic string. The data in a is typically in canonical transport form, read from a file or network connection.

All input functions accept S-expression in either canonical or advanced form, or any legal mixture of forms. Expressions can cross line boundaries. For output in canonical form, use pack; for output in advanced form (similar to Lisp's S-expressions), use text.

Sexp provides a further small collection of operations:

Return non-zero if expression e1 and e2 are identical (isomorphic in tree structure and atoms in corresponding positions in e1 and e2 equal); return 0 otherwise.
Return a new Sexp value equal to e, but sharing no storage with it. (In other words, it returns a copy of the whole tree e).
Return true iff e is a list (ie, a value of type Sexp.List).

Two operations provide a shorthand for fetching the value of an atom, returning nil if applied to a list:

Return the value of e as a string; binary data is assumed to be a string in utf(6) representation.
Return the value of e as an array of bytes. A String value will be converted to an array of bytes giving its utf(6).

The remaining operations extract values from lists, and return nil if applied to an atom:

Return the elements of list e; return nil if e is not a list.
Return the first token of list e, if it is a string; return nil if it is not a string or e is not a list. The first token of a list often gives an operation name.
Return a list containing the second and subsequent values in list e; useful when the first value is an operation name and the rest represent parameters (arguments) to that operation.


The following S-expression is in advanced transport form:

(snicker "abc" (#03# |YWJj|))

It represents a list of three elements: the token snicker, the token abc, and a sub-list with two elements (a hexadecimal constant representing the byte 03, and a base-64 constant YWjj that represents the bytes abc).

Here is another in advanced form with two sublists:

     (issuer bob)
     (subject "alice b"))

Its equivalent in canonical form (as produced by pack) is shown below:

(11:certificate(6:issuer3:bob)(7:subject7:alice b))

Nesting parentheses still mark the start and end of lists, but there is no other punctuation or white space, and the byte sequence representing each atom is preceded by a decimal count, so that binary values appear unencoded, and for instance the space in the last string is not a delimiter but part of the token.




bufio(2), xml(2), sexprs(6)

R. Rivest, ``S-expressions'', Network Working Group Internet Draft, http://theory.lcs.mit.edu/~rivest/sexp.txt (4 May 1997), reproduced in /lib/sexp.

SEXPRS(2 ) Rev:  Thu Feb 15 14:43:26 GMT 2007