The maxpc Reference Manual

Table of Contents

Next: , Previous: , Up: (dir)   [Contents][Index]

The maxpc Reference Manual

This is the maxpc Reference Manual, generated automatically by Declt version 2.3 "Robert April" on Tue Feb 20 09:03:17 2018 GMT+0.


Next: , Previous: , Up: Top   [Contents][Index]

1 Introduction

MaxPC

Max’s Parser Combinators is a simple and pragmatic library for writing parsers and lexers based on combinatory parsing. MaxPC is capable of parsing deterministic, context-free languages, provides powerful tools for parse tree transformation and error handling, and can operate on sequences and streams.

Documentation


Next: , Previous: , Up: Top   [Contents][Index]

2 Systems

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


Previous: , Up: Systems   [Contents][Index]

2.1 maxpc

Author

Max Rottenkolber <max@mr.gy>

License

GNU Affero General Public License

Description

Max’s Parser Combinators: a simple and pragmatic library for writing parsers and lexers based on combinatory parsing.

Source

maxpc.asd (file)

Components

Next: , Previous: , Up: Top   [Contents][Index]

3 Files

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


Previous: , Up: Files   [Contents][Index]

3.1 Lisp


Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.1 maxpc.asd

Location

maxpc.asd

Systems

maxpc (system)


Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.2 maxpc/packages.lisp

Parent

maxpc (system)

Location

packages.lisp

Packages

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.3 maxpc/input.lisp

Dependency

packages.lisp (file)

Parent

maxpc (system)

Location

input.lisp

Exported Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.4 maxpc/input/index.lisp

Dependencies
Parent

maxpc (system)

Location

input/index.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.5 maxpc/input/list.lisp

Dependencies
Parent

maxpc (system)

Location

input/list.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.6 maxpc/input/vector.lisp

Dependencies
Parent

maxpc (system)

Location

input/vector.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.7 maxpc/input/stream.lisp

Dependencies
Parent

maxpc (system)

Location

input/stream.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.8 maxpc/interface.lisp

Dependencies
Parent

maxpc (system)

Location

interface.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.9 maxpc/primitives.lisp

Dependencies
Parent

maxpc (system)

Location

primitives.lisp

Exported Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.10 maxpc/more.lisp

Dependencies
Parent

maxpc (system)

Location

more.lisp

Exported Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.11 maxpc/char.lisp

Dependencies
Parent

maxpc (system)

Location

char.lisp

Exported Definitions

Previous: , Up: Lisp files   [Contents][Index]

3.1.12 maxpc/digit.lisp

Dependencies
Parent

maxpc (system)

Location

digit.lisp

Exported Definitions

Next: , Previous: , Up: Top   [Contents][Index]

4 Packages

Packages are listed by definition order.


Next: , Previous: , Up: Packages   [Contents][Index]

4.1 maxpc.input.stream

Implements support for _input sources_ of _type_ {stream}. Input from _streams_ is copied into a temporary buffer lazily as required by the parser. _Streams_ of _type_ {file-stream} are read in as chunks of customizable size.

Source

packages.lisp (file)

Use List
Exported Definitions
Internal Definitions

Next: , Previous: , Up: Packages   [Contents][Index]

4.2 maxpc.input.vector

Source

packages.lisp (file)

Use List
Internal Definitions

Next: , Previous: , Up: Packages   [Contents][Index]

4.3 maxpc.input.list

Source

packages.lisp (file)

Use List
Internal Definitions

Next: , Previous: , Up: Packages   [Contents][Index]

4.4 maxpc.input.index

Source

packages.lisp (file)

Use List
Used By List
Exported Definitions
Internal Definitions

Next: , Previous: , Up: Packages   [Contents][Index]

4.5 maxpc.digit

Parsers for digit numerals in character inputs.

Source

packages.lisp (file)

Use List
Exported Definitions

Next: , Previous: , Up: Packages   [Contents][Index]

4.6 maxpc.char

Utility parsers for character inputs.

Source

packages.lisp (file)

Use List
Exported Definitions

Next: , Previous: , Up: Packages   [Contents][Index]

4.7 maxpc

_Max’s Parser Combinators_¹ is a simple and pragmatic library for writing
parsers and lexers based on combinatory parsing. MaxPC is capable of
parsing deterministic, context-free languages, provides powerful tools for
parse tree transformation and error handling, and can operate on
_sequences_ and _streams_. It supports unlimited backtracking, but does not implement [Packrat Parsing](http://pdos.csail.mit.edu/~baford/packrat/thesis/). Instead, MaxPC achieves good performance through its optimized primitives,
and explicit separation of matching and capturing input. In practice, MaxPC
parsers perform better on typical computer languages—when compared to
Packrat parsers—at the expense of not producing linear-time parsers.²

+ 1. MaxPC is a complete rewrite of [MPC](https://github.com/eugeneia/mpc)
with was in turn a fork of Drew Crampsie’s [Smug](http://smug.drewc.ca/).
+ 2. See [MaxPC: Why? How? / Packrat Parsing](http://mr.gy/blog/maxpc.html#section-3-1) on why the book keeping costs of Packrat parsing diminish the gain in execution time for typical grammars and workloads.

< Basic Concepts

MaxPC _parsers_ are _functions_ that accept an [input](#section-4) as
their only argument and return three values: the remaining _input_ or
{nil}, a _result value_ or {nil}, and a _generalized boolean_ that
indicates if a _result value_ is present. The _type_ of a parser is:

{(function (}_input_{) (or} _input_ {null) * boolean)}

A parser can either succeed or fail when applied to an input at a given
position. A succeeding parser is said to _match_. When a parser matches it
can optionally produce a _result value_, which may be processed by its
parent parsers. New parsers can be created by composing existing parsers
using built-in or user defined _parser combinators_. A parser combinator
is a higher-order _function_ that includes one or more parsers as its
arguments and returns a parser.

By convention, all parsers are defined as higher-order _functions_ that
return the respective parser, even if they are nullary. For instance, the
{?end} parser is obtained using the form “{(?end)}”.

A lexical convention is used to make three different types of parsers
easily distinguishable:

+ Parsers whose names start with a question mark ({?}) never produce a
result value.
+ Parsers whose names start with an equals sign ({=}) always produce a
result value.
+ Parsers whose names start with a percent symbol ({%}) may produce a
result value depending on their arguments.

>

< Example

We will define a parser for a simplistic grammar for Email addresses of
the form:

_email‑address_ := _user_ {@} _host_

First we define a parser for the valid characters in the _user_ and _host_
parts of an address. Just for this example, we choose these to be
alphanumeric characters and then some. {?address-character} uses the {%or} combinator to form the union of two instances of {?satisfies} that match
different sets of characters.

#code#
(defun ?address-character ()
(%or (?satisfies ’alphanumericp)
(?satisfies (lambda (c)
(member c ’(#\- #\_ #\. #\+))))))
#

Then we use {?address-character} to implement our address parser which
matches two sequences of “address characters” separated by an {@}
character, and produces a list of user and host components as its result
value. We match {?address-character} one or more times using {%some}, and
produce the matched subsequence as the result value using {=subseq}. Both
parts of the address separated by an _@_ character are matched in sequence
using {=list}, whose result value is finally transformed by
{=destructure}.

#code#
(defun =email-address ()
(=destructure (user _ host)
(=list (=subseq (%some (?address-character)))
(?eq #\@)
(=subseq (%some (?address-character))))
(list user host)))
#

We can now apply {=email-address} using {parse}:

#code#
(parse "foo_bar@example.com" (=email-address))
⇒ ("foo_bar" "example.com"), T, T
(parse "!!!@@@.com" (=email-address))
⇒ NIL, NIL, NIL
(parse "foo_bar@example.com@baz" (=email-address))
⇒ ("foo_bar" "example.com"), T, NIL
#

>

< Overview

{parse} is the entry point of {MaxPC}. It applies a parser to an input and
returns the parser’s result value, and two _boolean_ values indicating if
the parser matched and if there is unmatched input remaining,
respectively.

< Basic Parsers

+ {?end} matches only when there is no further input.
+ {=element} unconditionally matches the next element of the input _sequence_.
+ {=subseq} produces the subsequence matched by its argument as its
result value.
+ {?satisifies}, {?test}, and {?eq} match input conditionally.
+ {%maybe} matches, even if its argument fails to match.

>

< Logical Combinators

+ {%or} forms the union of its arguments.
+ {%and} forms the intersection of its arguments.
+ {%diff} forms the difference of its arguments.
+ {?not} negates its argument.

>

< Sequence Combinators

+ {?seq} matches its arguments in sequence.
+ {=list} matches its arguments in sequence and produces a list of their
results as its result value.
+ {%any} matches its argument repeatedly any number of times.
+ {%some} matches its argument repeatedly one or more times.

>

< Transformation

+ {=transform} produces the result of applying a _function_ to its
argument’s result value as its result value.
+ {=destructure} is a convenient destructuring _macro_ on top of {=transform}.

>

< Error Handling

+ {?fail} never matches and evaluates its body when it is called.
+ {%handler-case} and {%restart-case} allow you to set up _handlers_ and _restarts_ across parsers.
+ {get-input-position} can be called in error situations to retrieve the
current position in the input.

>

>

< Caveat: Recursive Parsers

A recursive parser can not refer to itself by its constructor, but must
instead call itself by _symbol_—calling its constructor would otherwise
result in unbounded recursion. In order to do so the parser _function_
needs to be _bound_ in the _function namespace_ using {setf}. The example
below implements a parser for balanced parentheses, and illustrates how to
avoid this common caveat.

#code#
(defun ?parens ()
(?seq (?eq #\() (%maybe ’?parens/parser) (?eq #\)))))

(setf (fdefinition ’?parens/parser) (?parens))

(parse "((()))" (?parens)) ⇒ NIL, T, T
#

>

Source

packages.lisp (file)

Use List
Used By List
Exported Definitions
Internal Definitions

Previous: , Up: Packages   [Contents][Index]

4.8 maxpc.input

The generic _input_ interface allows extensions to parse other _types_ of _input sources_. To add a new _input source type_, {make-input} has to be specialized on that _type_. The following methods have to be defined for _inputs_:

+ {input-empty-p}
+ {input-first}
+ {input-rest}

The following methods can optionally be defined for _inputs_:

+ {input-position}
+ {input-element-type}
+ {input-sequence}

Source

packages.lisp (file)

Use List

common-lisp

Used By List
Exported Definitions

Next: , Previous: , Up: Top   [Contents][Index]

5 Definitions

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


Next: , Previous: , Up: Definitions   [Contents][Index]

5.1 Exported definitions


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.1 Special variables

Special Variable: *bound*

*Description:*

{*bound*} can be set to limit the number of elements read from _stream inputs_ in a single call to to {parse}.

Package

maxpc.input.stream

Source

input/stream.lisp (file)

Special Variable: *chunk-size*

*Description:*

{*chunk-size*} controls the size by which the buffer used for _stream inputs_ grows, and the number of elements read at a time when parsing from _streams_ of _type_ {file-stream}.

Package

maxpc.input.stream

Source

input/stream.lisp (file)

Special Variable: *element-type*

*Description:*

{*element-type*} can be set to enforce a specific stream element type when reading from _stream inputs_. This can be useful when dealing with bivalent streams.

Package

maxpc.input.stream

Source

input/stream.lisp (file)

Special Variable: *whitespace*

*Value Type:*

a _list_ of _characters_.

*Description:*

The _value_ of {*whitespace*} is a _list_ of _characters_ considered to be _whitespace characters_.

Package

maxpc.char

Source

char.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.2 Macros

Macro: %handler-case PARSER &body CLAUSES

_clauses_::= {{}↓_error‑clause_{\}}\*

_error‑clause_::=
{(}_typespec_ {([}_var_{])}
{{}_declaration_{\}}\* {{}_form_{\}}\* _parser‑form_{)}

*Arguments and Values:*

_parser_—a _parser_.

_typespec_—a _type specifier_.

_var_—a _variable name_.

_declaration_—a {declare} _expression_; not evaluated.

_form_—a _form_.

_parser‑form_—a _form_ that evaluates to a _parser_.

*Description:*

{%handler-case} executes _parser_ in a _dynamic environment_ where handlers are active as if by {handler-case}. If a _condition_ is handled by {%handler-case}, _parser‑form_ is evaluated and the resulting _parser_ is applied.

*Examples:*

#code#
(defun assert-digit (c)
(or (digit-char-p c)
(error "Not a digit: ~c" c)))

(parse "01x2"
(%any (%handler-case (%and (?satisfies ’assert-digit) (=element))
(error (e)
(format t "Error at position ~a: ~a~%" (get-input-position) e)
(?seq (=element))))))
▷ Error at position 2: Not a digit: x
→ (#\0 #\1 #\2), T, T
#

*See Also:*

{handler-case}.

Package

maxpc

Source

interface.lisp (file)

Macro: %restart-case PARSER &rest CLAUSES

_clauses_::= {{}↓_restart‑clause_{\}}\*

_restart‑clause_::=
{(}_case‑name_ {([}_lambda‑list_{])}
〚{:interactive} _interactive‑expression_ |
{:report} _report‑expression_ |
{:test} _test‑expression_〛
{{}_declaration_{\}}\* {{}_form_{\}}\* _parser‑form_{)}

*Arguments and Values:*

_parser_—a _parser_.

_case‑name_—a _symbol_ or {nil}.

_lambda‑list_—an _ordinary lambda list_.

_interactive‑expression_—a _symbol_ or a _lambda expression_.

_report‑expression_—a _string_, a _symbol_, or a _lambda expression_.

_test‑expression_—a _symbol_ or a _lambda expression_.

_declaration_—a {declare} _expression_; not evaluated.

_form_—a _form_.

_parser‑form_—a _form_ that evaluates to a _parser_.

*Description:*

{%restart-case} executes _parser_ in a _dynamic environment_ where restarts are active as if by {restart-case}. If control is transferred to a _restart‑clause_, _parser‑form_ is evaluated and the resulting _parser_ is applied.

*Examples:*

#code#
(parse "012x3"
(%any (%restart-case
(=transform
(=element)
(lambda (c)
(if (digit-char-p c)
c
(error "Not a digit: ~c" c))))
(skip-element ()
:report "Skip character."
(?seq (=element))))))
▷ Error: Not a digit: x
▷ To continue, type :CONTINUE followed by an option number:
▷ 1: Skip non-digit character.
▷ 2: Return to Lisp Toplevel.
▷ Debug> :continue 1
▷ Invoking restart: Skip character.
→ (#\0 #\1 #\2), T, T
#

*See Also:*

{restart-case}.

Package

maxpc

Source

interface.lisp (file)

Macro: =destructure (&rest LAMBDA-LIST) PARSER &body FORMS

*Arguments and Values:*

_lambda‑list_—a _destructuring lambda list_.

_parser_—a _parser_.

_forms_—an _implicit progn_.

*Description:*

{=destructure} matches _parser_ and destructures its result value as if by {destructuring-bind}. The {_} (underscore) symbol can occur in _lambda‑list_ any number of times, and is substituted with a _fresh_, _uninterned symbol_ and declared {ignorable}. If _parser_ matches {=destructure} evaluates _forms_ and produces the value of the last _form_ as its result value. If no _forms_ are supplied the value of the last, _interned_ variable defined in _lambda‑list_ is produced as the result value instead.

*Examples:*

#code#
(parse ’(10 % 3) (=destructure (x _ y)
(=list (=element) (?eq ’%) (=element))
(mod x y)))
→ 1, T, T

(parse "a," (=destructure (x _)
(=list (=element) (?eq #\,))))
→ #\a, T, T

(parse ’(a b c) (=destructure (x &rest xs)
(%some (=element))))
→ ’(B C), T, T
#

*Exceptional Situations:*

If the result value of _parser_ does not match the destructuring pattern, an _error_ of _type_ {program-error} is signaled.

*See Also:*

{destructuring-bind}

Package

maxpc

Source

more.lisp (file)

Macro: ?fail &body FORMS

*Arguments and Values:*

_forms_—_forms_.

*Description:*

{?fail} always fails to match, and evaluates _forms_ when it is applied.

*Examples:*

#code#
(parse ’(a b c) (?fail (format t "Position: ~a~%" (get-input-position))))
▷ Position: 0
→ NIL, NIL, NIL
#

Package

maxpc

Source

primitives.lisp (file)

Macro: ?test (TEST &rest ARGUMENTS) &optional PARSER

*Arguments and Values:*

_test_—a _designator_ for a _function_ that returns a _generalized boolean_.

_arguments_—_objects_.

_parser_—a _parser_. The default is {(=element)}.

*Description:*

{?test} matches _parser_ if its result value _satisfies the test_ with _arguments_ as additional arguments to _test_.

*Examples:*

#code#
(parse ’(a) (?test (’member ’(a b)))) ⇒ NIL, T, T
(flet ((power-of-p (n e) (= (mod n e) 0)))
(parse ’(42) (?test (#’power-of-p 2)))) ⇒ NIL, T, T
#

*Notes:*

#code#
(?test ({fun} {args}*}))
≡ (?satisfies (lambda (x)
(funcall {fun} x {args}*)))
#

*Exceptional Situations:*

If _test_ accepts less arguments than the number of _arguments_ plus one an _error_ of _type_ {program-error} is signaled.

*See also:*

{?satisfies}

Package

maxpc

Source

more.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.3 Functions

Function: %and &rest PARSERS

*Arguments and Values:*

_parsers_—_parsers_.

*Description:*

{%and} applies _parsers_, and matches the last _parser_ only if all previous _parsers_ succeed. If the last _parser_ produces a result value then {%and} produces that value as its result value. It can be said that {%and} forms the set intersection of _parsers_.

*Examples:*

#code#
(parse ’(:foo) (%and (?satisfies ’symbolp)
(?satisfies ’keywordp)))
→ NIL, T, T
(parse ’(foo) (%and (?satisfies ’symbolp)
(?satisfies ’keywordp)))
→ NIL, NIL, NIL
(parse ’(foo) (%and))
→ NIL, NIL, NIL
(parse ’(foo) (%and (?satisfies ’symbolp) (=element)))
→ FOO, T, T
(parse ’() (%and (%maybe (?fail (princ ’foo)))
(%maybe (?fail (princ ’bar)))
(%maybe (?fail (princ ’baz)))))
▷ FOOBARBAZ
→ NIL, T, T
#

Package

maxpc

Source

primitives.lisp (file)

Function: %any PARSER

*Arguments and Values:*

_parser_—a _parser_.

*Description:*

{%any} matches _parser_ in sequence any number of times. If _parser_ produces a result value and matches at least once then {%any} produces a _list_ of the values as its result value.

*Examples:*

#code#
(parse ’(a b c) (%any (=element))) → (A B C), T, T
(parse ’() (%any (=element))) → NIL, T, T
#

Package

maxpc

Source

primitives.lisp (file)

Function: %diff PARSER &rest NOT-PARSERS

*Arguments and Values:*

_parser_—a _parser_.

_not‑parsers_—_parsers_.

*Description:*

{%diff} matches _parser_ only if applying _not‑parsers_ fails. If _parser_ produces a result value then {%diff} produces that value as its result value. It can be said that {%diff} forms the set difference of _parser_ and the union of _not‑parsers_.

*Examples:*

#code#
(parse ’(foo) (%diff (?satisfies ’symbolp)
(?satisfies ’keywordp)))
→ NIL, T, T
(parse ’(:foo) (%diff (?satisfies ’symbolp)
(?satisfies ’keywordp)))
→ NIL, NIL, NIL
(parse ’(foo) (%diff (?satisfies ’symbolp)))
→ NIL, T, T
(parse ’(:foo) (%diff (?satisfies ’symbolp)))
→ NIL, T, T
#

Package

maxpc

Source

primitives.lisp (file)

Function: %maybe PARSER

*Arguments and Values:*

_parser_—a _parser_.

*Description:*

{%maybe} matches _parser_ or nothing all, but always succeeds. If _parser_ matches and produces a result value then {%maybe} produces that value as its result value.

*Examples:*

#code#
(parse ’(a) (%maybe (=element))) → A, T, T
(parse ’() (%maybe (=element))) → NIL, T, T
(parse ’(42) (%maybe (?satisfies ’evenp))) → NIL, T, T
#

Package

maxpc

Source

more.lisp (file)

Function: %or &rest PARSERS

*Arguments and Values:*

_parsers_—_parsers_.

*Description:*

{%or} attempts to successfully apply _parsers_, and matches the first succeeding _parser_, if any. If that _parser_ produces a result value then {%or} produces that value as its result value. It can be said that {%or} forms the set union of _parsers_.

*Examples:*

#code#
(parse ’(a) (%or (?eq ’a) (?eq ’b))) → NIL, T, T
(parse ’(b) (%or (?eq ’a) (?eq ’b))) → NIL, T, T
(parse ’(a) (%or)) → NIL, NIL, NIL
(parse ’(a) (%or (=element)
(?fail (format t "No element.~%"))))
→ A, T, T
(parse ’() (%or (?fail (princ ’foo))
(?fail (princ ’bar))
(?fail (princ ’baz))))
▷ FOOBARBAZ
→ NIL, NIL, T
#

Package

maxpc

Source

primitives.lisp (file)

Function: %some PARSER

*Arguments and Values:*

_parser_—a _parser_.

*Description:*

{%some} matches _parser_ in sequence one or more times. If _parser_ produces a result value then {%some} produces a _list_ of the values as its result value.

*Examples:*

#code#
(parse ’(a b c) (%some (=element))) → (A B C), T, T
(parse ’() (%some (=element))) → NIL, NIL, T
#

Package

maxpc

Source

more.lisp (file)

Function: =element ()

*Description:*

{=element} matches the next element and produces that element it as its result value.

*Examples:*

#code#
(parse ’(a) (=element)) → A, T, T
(parse ’() (=element)) → NIL, NIL, T
#

Package

maxpc

Source

primitives.lisp (file)

Function: =integer-number &optional RADIX

*Arguments and Values:*

_radix_—a _number_ of _type_ {(integer 2 36)}. The default is {10}.

*Description:*

{=integer-number} matches one or more digit _characters_ in the specified _radix_, optionally lead by a sign character, in sequence, and produces the _integer_ represented by that sequence as its result value. The leading sign can be {#\\+} and {#\\-} for positive and negative values respectively. The default is a positive value.

*Examples:*

#code#
(parse "101010" (=integer-number 2)) → 42, T, T
(parse "+101010" (=integer-number 2)) → 42, T, T
(parse "-101010" (=integer-number 2)) → -42, T, T
(parse "x101010" (=integer-number 2)) → NIL, NIL, NIL
#

*Exceptional Situations:*

If an element attempted to be matched is not a _character_ an _error_ of _type_ {type-error} is signaled.

Package

maxpc.digit

Source

digit.lisp (file)

Function: =line &optional KEEP-NEWLINE-P

*Arguments and Values:*

_keep‑newline‑p_—a _generalized boolean_. The default is _false_.

*Description:*

{=line} matches zero or more _characters_ in sequence followed by a {#\\Newline} _character_ or the end of input, and produces the _string_ of _characters_ as its result value. The terminating {#\\Newline} _character_ is not included in _string_ unless _keep‑newline‑p_ is _true_.

*Examples:*

#code#
(parse (format nil "foo~%bar~%baz") (%any (=line)))
→ ("foo" "bar" "baz"), T, T
#

*Exceptional Situations:*

If an element attempted to be matched is not a _character_ an _error_ of _type_ {type-error} is signaled.

Package

maxpc.char

Source

char.lisp (file)

Function: =list &rest PARSERS

*Arguments and Values:*

_parsers_—_parsers_.

*Description:*

{=list} matches _parsers_ in sequence, and produces a _list_ of the result values of _parsers_ as its result value.

*Examples:*

#code#
(parse ’(a) (=list (=element) (?end)))
→ (A NIL), T, T
(parse ’(a b) (=list (=element) (?end)))
→ NIL, NIL, NIL
(parse ’(a) (=list))
→ NIL, T, NIL
#

Package

maxpc

Source

primitives.lisp (file)

Function: =natural-number &optional RADIX

*Arguments and Values:*

_radix_—a _number_ of _type_ {(integer 2 36)}. The default is {10}.

*Description:*

{=natural-number} matches one or more digit _characters_ in the specified _radix_ in sequence, and produces the natural _number_ represented by that digit sequence as its result value.

*Examples:*

#code#
(parse "234" (=natural-number 2)) → NIL, NIL, NIL
(parse "101010" (=natural-number 2)) → 42, T, T
#

*Exceptional Situations:*

If an element attempted to be matched is not a _character_ an _error_ of _type_ {type-error} is signaled.

Package

maxpc.digit

Source

digit.lisp (file)

Function: =subseq PARSER

*Arguments and Values:*

_parser_—a _parser_.

*Description:*

{=subseq} matches _parser_, and produces the subsequence matched by _parser_ as its result value.

*Examples:*

#code#
(parse ’(1 2 3) (=subseq (%any (?satisfies ’numberp))))
→ (1 2 3), T, T
(parse "123" (=subseq (%any (?satisfies ’digit-char-p))))
→ "123" T, T
#

Package

maxpc

Source

primitives.lisp (file)

Function: =transform PARSER FUNCTION

*Arguments and Values:*

_parser_—a _parser_.

_function_—a _designator_ for a _function_ of one argument.

*Description:*

{%transform} matches _parser_ and produces the result of applying _function_ to the result value of _parser_ as its result value.

*Examples:*

#code#
(parse ’(41) (=transform (=element) ’1+)) → 42, T, T
(parse ’() (=transform (=element) ’1+)) → NIL, NIL, T
#

Package

maxpc

Source

primitives.lisp (file)

Function: ?char CHAR &optional CASE-SENSITIVE-P

*Arguments and Values:*

_char_—a _character_.

_case‑sensitive‑p_—a _generalized boolean_. The default is _true_.

*Description:*

{?char} matches _char_. {?char} is case sensitive unless _case‑sensitive‑p_ is _false_.

*Exceptional Situations:*

If the next element is not a _character_ an _error_ of _type_ {type-error} is signaled.

Package

maxpc.char

Source

char.lisp (file)

Function: ?digit &optional RADIX

*Arguments and Values:*

_radix_—a _number_ of _type_ {(integer 2 36)}. The default is {10}.

*Description:*

{?digit} matches a single digit _character_ in the specified _radix_.

*Exceptional Situations:*

If the next element is not a _character_ an _error_ of _type_ {type-error} is signaled.

Package

maxpc.digit

Source

digit.lisp (file)

Function: ?end ()

*Description:*

{?end} matches the end of input.

*Examples:*

#code#
(parse ’() (?end)) → NIL, T, T (parse ’(a) (?end)) → NIL, NIL, NIL #

Package

maxpc

Source

primitives.lisp (file)

Function: ?eq X &optional PARSER

*Arguments and Values:*

_x_—an _object_.

_parser_—a _parser_. The default is {(=element)}.

*Description:*

{?eq} matches _parser_ if its result value is {eq} to _x_.

*Examples:*

#code#
(parse ’(a) (?eq ’a)) ⇒ NIL, T, T
(parse ’(b) (?eq ’a)) ⇒ NIL, NIL, NIL
#

*See also:*

{?satisfies}

Package

maxpc

Source

more.lisp (file)

Function: ?newline ()

*Description:*

{?newline} matches the {#\\Newline} _character_.

Package

maxpc.char

Source

char.lisp (file)

Function: ?not PARSER

*Arguments and Values:*

_parser_—a _parser_.

*Description:*

{?not} matches the next element unless _parser_ matches.

*Examples:*

#code#
(parse ’(:foo :baz) (?not (?seq (?eq :foo) (?eq :bar)))) → NIL, T, NIL
(parse ’() (?not (?eq :baz))
→ NIL, NIL, NIL
#

Package

maxpc

Source

more.lisp (file)

Function: ?satisfies TEST &optional PARSER

*Arguments and Values:*

_test_—a _designator_ for a _function_ of one argument that returns a _generalized boolean_.

_parser_—a _parser_. The default is {(=element)}.

*Description:*

{?satisfies} matches _parser_ if its result value _satisfies the test_.

*Examples:*

#code#
(parse ’(1) (?satisfies ’numberp)) → NIL, T, T
(parse ’(a) (?satisfies ’numberp)) → NIL, NIL, NIL
(parse ’(a b c)
(?satisfies (lambda (s)
(intersection s ’(b c d)))
(%any (=element))))
⇒ NIL, T, T
#

Package

maxpc

Source

primitives.lisp (file)

Function: ?seq &rest PARSERS

*Arguments and Values:*

_parsers_—_parsers_.

*Description:*

{?seq} matches _parsers_ in sequence.

*Examples:*

#code#
(parse ’(a) (?seq (=element) (?end))) → NIL, T, T
(parse ’(a b) (?seq (=element) (?end))) → NIL, NIL, NIL
(parse ’(a) (?seq))
→ NIL, T, NIL
#

Package

maxpc

Source

primitives.lisp (file)

Function: ?string STRING &optional CASE-SENSITIVE-P

*Arguments and Values:*

_string_—a _string_.

_case‑sensitive‑p_—a _generalized boolean_. The default is _true_.

*Description:*

{?string} matches the _characters_ in _string_ in sequence. {?string} is case sensitive unless _case‑sensitive‑p_ is _false_.

*Exceptional Situations:*

If an element attempted to be matched is not a _character_ an _error_ of _type_ {type-error} is signaled.

Package

maxpc.char

Source

char.lisp (file)

Function: ?whitespace ()

*Description:*

{?whitespace} matches an element that is a member of {*whitespace*}.

*Exceptional Situations:*

If the next element is not a _character_ an _error_ of _type_ {type-error} is signaled.

Package

maxpc.char

Source

char.lisp (file)

Function: get-input-position ()

→ _position_

→ _position_, _line_, _column_

*Arguments and Values:*

_position_, _column_—non-negative _integers_.

_line_—a positive _integer_.

*Description:*

{get-input-position} returns the number of elements read from the input so far. Additionally, _line_ and _column_ positions are returned if the input’s _element type_ is {character}. Lines are counted starting at one while columns are counted starting from zero.

{get-input-position} may only be called from within the body of {?fail}, the handlers of {%handler-case} or the restarts of {%restart-case}.

*Exceptional Situations:*

If {get-input-position} is not evaluated within the dynamic context of {?fail}, {%handler-case} or {%restart-case} an _error_ of _type_ {simple-error} is signaled.

Package

maxpc

Source

interface.lisp (file)

Function: index-position INSTANCE
Package

maxpc.input.index

Source

input/index.lisp (file)

Function: parse INPUT-SOURCE PARSER

→ _result_, _match‑p_, _end‑p_

*Arguments and Values:*

_input-source_—an _input source_.

_parser_—a parser.

_result_—an _object_.

_match‑p_, _end‑p_—_generalized booleans_.

*Description:*

{parse} applies _parser_ to the _input_ and returns the parser’s _result value_ or {nil}. _Match‑p_ is _true_ if _parser_ _matched_ the _input-source_. _End‑p_ is _true_ if _parser_ _matched_ the complete _input-source_. _Input_ is derived from _input-source_ by using {maxpc.input:make-input}.

{parse} accepts _input sources_ of _type_ {sequence} and {stream} out of the box.

*See Also:*

[input](#section-4), [maxpc.input.stream](#section-5)

Package

maxpc

Source

interface.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.4 Generic functions

Generic Function: input-element-type INPUT

→ _typespec_

*Arguments and Values:*

_input_—an _input_.

_typespec_—a _type specifier_.

*Description:*

{input-element-type} returns a _type specifier_ that designates the _type_ of the elements in _input_.

Package

maxpc.input

Source

input.lisp (file)

Methods
Method: input-element-type (INPUT index-stream)
Source

input/stream.lisp (file)

Method: input-element-type (INPUT index-vector)
Source

input/vector.lisp (file)

Method: input-element-type INPUT
Generic Function: input-empty-p INPUT

→ _empty-p_

*Arguments and Values:*

_input_—an _input_.

_empty-p_—a _generalized boolean_.

*Description:*

{input-empty-p} returns _true_ if _input_ is empty.

Package

maxpc.input

Source

input.lisp (file)

Methods
Method: input-empty-p (INPUT index-stream)
Source

input/stream.lisp (file)

Method: input-empty-p (INPUT index-vector)
Source

input/vector.lisp (file)

Method: input-empty-p (INPUT index-list)
Source

input/list.lisp (file)

Generic Function: input-first INPUT

→ _element_

*Arguments and Values:*

_input_—a non-empty _input_.

_element_—an _object_ of the _type_ designated by the _type specifier_ returned by {input-element-type} when called on _input_.

*Description:*

{input-first} returns the first element in _input_.

*Exceptional Situations:*

If _input_ is empty the behavior of {input-first} is unspecified.

Package

maxpc.input

Source

input.lisp (file)

Methods
Method: input-first (INPUT index-stream)
Source

input/stream.lisp (file)

Method: input-first (INPUT index-simple-string)
Source

input/vector.lisp (file)

Method: input-first (INPUT index-simple-vector)
Source

input/vector.lisp (file)

Method: input-first (INPUT index-vector)
Source

input/vector.lisp (file)

Method: input-first (INPUT index-list)
Source

input/list.lisp (file)

Generic Function: input-position INPUT

→ _position_

*Arguments and Values:*

_input_—an _input_.

_position_—an _integer_ between 0 and {array-dimension-limit} inclusively.

*Description:*

{input-position} returns the _position_ of _input_.

Package

maxpc.input

Source

input.lisp (file)

Methods
Method: input-position (INPUT index)
Source

input/index.lisp (file)

Method: input-position INPUT
Generic Function: input-rest INPUT

→ _rest_

*Arguments and Values:*

_input_—a non-empty _input_.

_rest_—the remaining _input_.

*Description:*

{input-rest} returns the remaining _input_ without the first element.

*Exceptional Situations:*

If _input_ is empty the behavior of {input-rest} is unspecified.

Package

maxpc.input

Source

input.lisp (file)

Methods
Method: input-rest (INPUT index-stream)
Source

input/stream.lisp (file)

Method: input-rest (INPUT index-simple-string)
Source

input/vector.lisp (file)

Method: input-rest (INPUT index-simple-vector)
Source

input/vector.lisp (file)

Method: input-rest (INPUT index-vector)
Source

input/vector.lisp (file)

Method: input-rest (INPUT index-list)
Source

input/list.lisp (file)

Generic Function: input-sequence INPUT LENGTH

→ _sequence_

*Arguments and Values:*

_input_—an _input_.

_length_—an _integer_ between 0 and {array-dimension-limit} inclusively.

_sequence_—a _sequence_.

*Description:*

{input-sequence} returns a _sequence_ of the next _length_ elements in _input_.

*Exceptional Situations:*

If the number of elements in _input_ are less than _length_ the behavior of {input-sequence} is unspecified.

Package

maxpc.input

Source

input.lisp (file)

Methods
Method: input-sequence (INPUT index-stream) (LENGTH integer)
Source

input/stream.lisp (file)

Method: input-sequence (INPUT index-vector) (LENGTH integer)
Source

input/vector.lisp (file)

Method: input-sequence (INPUT index-list) (LENGTH integer)
Source

input/list.lisp (file)

Method: input-sequence INPUT (LENGTH integer)
Generic Function: make-input INPUT-SOURCE

*Arguments and Values:*

_input-source_—an _object_.

*Description:*

{make-input} returns an _input_ for _input-source_.

Package

maxpc.input

Source

input.lisp (file)

Methods
Method: make-input (INPUT-SOURCE stream)
Source

input/stream.lisp (file)

Method: make-input (INPUT-SOURCE vector)
Source

input/vector.lisp (file)

Method: make-input (INPUT-SOURCE list)
Source

input/list.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.5 Structures

Structure: index ()

Generic index.

Package

maxpc.input.index

Source

input/index.lisp (file)

Direct superclasses

structure-object (structure)

Direct subclasses
Direct methods

input-position (method)

Direct slots
Slot: position
Type

maxpc.input.index:index-position

Initform

0

Readers

index-position (function)

Writers

(setf index-position) (function)


Previous: , Up: Exported definitions   [Contents][Index]

5.1.6 Types

Type: index-position ()

Array index type used in index structure.

Package

maxpc.input.index

Source

input/index.lisp (file)


Previous: , Up: Definitions   [Contents][Index]

5.2 Internal definitions


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.1 Special variables

Special Variable: *input-fail*
Package

maxpc

Source

interface.lisp (file)

Special Variable: *input-start*
Package

maxpc

Source

interface.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.2 Functions

Function: cases-to-parser-cases CASES INPUT-SYM

Utility macro function for %HANDLER-CASE and %RESTART-CASE.

Package

maxpc

Source

interface.lisp (file)

Function: copy-index INSTANCE
Package

maxpc.input.index

Source

input/index.lisp (file)

Function: copy-index-list INSTANCE
Package

maxpc.input.list

Source

input/list.lisp (file)

Function: copy-index-simple-string INSTANCE
Package

maxpc.input.vector

Source

input/vector.lisp (file)

Function: copy-index-simple-vector INSTANCE
Package

maxpc.input.vector

Source

input/vector.lisp (file)

Function: copy-index-stream INSTANCE
Package

maxpc.input.stream

Source

input/stream.lisp (file)

Function: copy-index-vector INSTANCE
Package

maxpc.input.vector

Source

input/vector.lisp (file)

Function: element-type STREAM
Package

maxpc.input.stream

Source

input/stream.lisp (file)

Function: index-list-list INSTANCE
Package

maxpc.input.list

Source

input/list.lisp (file)

Function: index-list-p OBJECT
Package

maxpc.input.list

Source

input/list.lisp (file)

Function: index-list-position INSTANCE
Package

maxpc.input.list

Source

input/list.lisp (file)

Function: index-p OBJECT
Package

maxpc.input.index

Source

input/index.lisp (file)

Function: index-simple-string-p OBJECT
Package

maxpc.input.vector

Source

input/vector.lisp (file)

Function: index-simple-string-position INSTANCE
Package

maxpc.input.vector

Source

input/vector.lisp (file)

Function: index-simple-string-vector INSTANCE
Package

maxpc.input.vector

Source

input/vector.lisp (file)

Function: index-simple-vector-p OBJECT
Package

maxpc.input.vector

Source

input/vector.lisp (file)

Function: index-simple-vector-position INSTANCE
Package

maxpc.input.vector

Source

input/vector.lisp (file)

Function: index-simple-vector-vector INSTANCE
Package

maxpc.input.vector

Source

input/vector.lisp (file)

Function: index-stream-buffer INSTANCE
Package

maxpc.input.stream

Source

input/stream.lisp (file)

Function: index-stream-p OBJECT
Package

maxpc.input.stream

Source

input/stream.lisp (file)

Function: index-stream-position INSTANCE
Package

maxpc.input.stream

Source

input/stream.lisp (file)

Function: index-stream-stream INSTANCE
Package

maxpc.input.stream

Source

input/stream.lisp (file)

Function: index-vector-p OBJECT
Package

maxpc.input.vector

Source

input/vector.lisp (file)

Function: index-vector-position INSTANCE
Package

maxpc.input.vector

Source

input/vector.lisp (file)

Function: index-vector-vector INSTANCE
Package

maxpc.input.vector

Source

input/vector.lisp (file)

Function: make-index &key (POSITION POSITION)
Package

maxpc.input.index

Source

input/index.lisp (file)

Function: make-index-list &key (POSITION POSITION) (LIST LIST)
Package

maxpc.input.list

Source

input/list.lisp (file)

Function: make-index-simple-string &key (POSITION POSITION) (VECTOR VECTOR)
Package

maxpc.input.vector

Source

input/vector.lisp (file)

Function: make-index-simple-vector &key (POSITION POSITION) (VECTOR VECTOR)
Package

maxpc.input.vector

Source

input/vector.lisp (file)

Function: make-index-stream &key (POSITION POSITION) (STREAM STREAM) (BUFFER BUFFER)
Package

maxpc.input.stream

Source

input/stream.lisp (file)

Function: make-index-vector &key (POSITION POSITION) (VECTOR VECTOR)
Package

maxpc.input.vector

Source

input/vector.lisp (file)

Function: maybe-fill-buffer ()
Package

maxpc.input.stream

Source

input/stream.lisp (file)

Function: parse-line-position INPUT POSITION

Parses line position of POSITION in INPUT.

Package

maxpc

Source

interface.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.3 Generic functions

Generic Function: fill-buffer BUFFER STREAM
Package

maxpc.input.stream

Source

input/stream.lisp (file)

Methods
Method: fill-buffer (BUFFER vector) (STREAM file-stream)
Method: fill-buffer (BUFFER vector) (STREAM stream)

Previous: , Up: Internal definitions   [Contents][Index]

5.2.4 Structures

Structure: index-list ()

Index list.

Package

maxpc.input.list

Source

input/list.lisp (file)

Direct superclasses

index (structure)

Direct methods
Direct slots
Slot: list
Type

list

Initform

(error "must supply list.")

Readers

index-list-list (function)

Writers

(setf index-list-list) (function)

Structure: index-simple-string ()

Index simple string.

Package

maxpc.input.vector

Source

input/vector.lisp (file)

Direct superclasses

index-vector (structure)

Direct methods
Structure: index-simple-vector ()

Index simple vector.

Package

maxpc.input.vector

Source

input/vector.lisp (file)

Direct superclasses

index-vector (structure)

Direct methods
Structure: index-stream ()
Package

maxpc.input.stream

Source

input/stream.lisp (file)

Direct superclasses

index (structure)

Direct methods
Direct slots
Slot: stream
Type

stream

Initform

(error "must supply stream.")

Readers

index-stream-stream (function)

Writers

(setf index-stream-stream) (function)

Slot: buffer
Type

vector

Initform

(error "must supply buffer.")

Readers

index-stream-buffer (function)

Writers

(setf index-stream-buffer) (function)

Structure: index-vector ()

Index vector.

Package

maxpc.input.vector

Source

input/vector.lisp (file)

Direct superclasses

index (structure)

Direct subclasses
Direct methods
Direct slots
Slot: vector
Type

vector

Initform

(error "must supply vector.")

Readers

index-vector-vector (function)

Writers

(setf index-vector-vector) (function)


Previous: , Up: Top   [Contents][Index]

Appendix A Indexes


Next: , Previous: , Up: Indexes   [Contents][Index]

A.1 Concepts

Jump to:   F   L   M  
Index Entry  Section

F
File, Lisp, maxpc.asd: The maxpc<dot>asd file
File, Lisp, maxpc/char.lisp: The maxpc/char<dot>lisp file
File, Lisp, maxpc/digit.lisp: The maxpc/digit<dot>lisp file
File, Lisp, maxpc/input.lisp: The maxpc/input<dot>lisp file
File, Lisp, maxpc/input/index.lisp: The maxpc/input/index<dot>lisp file
File, Lisp, maxpc/input/list.lisp: The maxpc/input/list<dot>lisp file
File, Lisp, maxpc/input/stream.lisp: The maxpc/input/stream<dot>lisp file
File, Lisp, maxpc/input/vector.lisp: The maxpc/input/vector<dot>lisp file
File, Lisp, maxpc/interface.lisp: The maxpc/interface<dot>lisp file
File, Lisp, maxpc/more.lisp: The maxpc/more<dot>lisp file
File, Lisp, maxpc/packages.lisp: The maxpc/packages<dot>lisp file
File, Lisp, maxpc/primitives.lisp: The maxpc/primitives<dot>lisp file

L
Lisp File, maxpc.asd: The maxpc<dot>asd file
Lisp File, maxpc/char.lisp: The maxpc/char<dot>lisp file
Lisp File, maxpc/digit.lisp: The maxpc/digit<dot>lisp file
Lisp File, maxpc/input.lisp: The maxpc/input<dot>lisp file
Lisp File, maxpc/input/index.lisp: The maxpc/input/index<dot>lisp file
Lisp File, maxpc/input/list.lisp: The maxpc/input/list<dot>lisp file
Lisp File, maxpc/input/stream.lisp: The maxpc/input/stream<dot>lisp file
Lisp File, maxpc/input/vector.lisp: The maxpc/input/vector<dot>lisp file
Lisp File, maxpc/interface.lisp: The maxpc/interface<dot>lisp file
Lisp File, maxpc/more.lisp: The maxpc/more<dot>lisp file
Lisp File, maxpc/packages.lisp: The maxpc/packages<dot>lisp file
Lisp File, maxpc/primitives.lisp: The maxpc/primitives<dot>lisp file

M
maxpc.asd: The maxpc<dot>asd file
maxpc/char.lisp: The maxpc/char<dot>lisp file
maxpc/digit.lisp: The maxpc/digit<dot>lisp file
maxpc/input.lisp: The maxpc/input<dot>lisp file
maxpc/input/index.lisp: The maxpc/input/index<dot>lisp file
maxpc/input/list.lisp: The maxpc/input/list<dot>lisp file
maxpc/input/stream.lisp: The maxpc/input/stream<dot>lisp file
maxpc/input/vector.lisp: The maxpc/input/vector<dot>lisp file
maxpc/interface.lisp: The maxpc/interface<dot>lisp file
maxpc/more.lisp: The maxpc/more<dot>lisp file
maxpc/packages.lisp: The maxpc/packages<dot>lisp file
maxpc/primitives.lisp: The maxpc/primitives<dot>lisp file

Jump to:   F   L   M  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.2 Functions

Jump to:   %   =   ?  
C   E   F   G   I   M   P  
Index Entry  Section

%
%and: Exported functions
%any: Exported functions
%diff: Exported functions
%handler-case: Exported macros
%maybe: Exported functions
%or: Exported functions
%restart-case: Exported macros
%some: Exported functions

=
=destructure: Exported macros
=element: Exported functions
=integer-number: Exported functions
=line: Exported functions
=list: Exported functions
=natural-number: Exported functions
=subseq: Exported functions
=transform: Exported functions

?
?char: Exported functions
?digit: Exported functions
?end: Exported functions
?eq: Exported functions
?fail: Exported macros
?newline: Exported functions
?not: Exported functions
?satisfies: Exported functions
?seq: Exported functions
?string: Exported functions
?test: Exported macros
?whitespace: Exported functions

C
cases-to-parser-cases: Internal functions
copy-index: Internal functions
copy-index-list: Internal functions
copy-index-simple-string: Internal functions
copy-index-simple-vector: Internal functions
copy-index-stream: Internal functions
copy-index-vector: Internal functions

E
element-type: Internal functions

F
fill-buffer: Internal generic functions
fill-buffer: Internal generic functions
fill-buffer: Internal generic functions
Function, %and: Exported functions
Function, %any: Exported functions
Function, %diff: Exported functions
Function, %maybe: Exported functions
Function, %or: Exported functions
Function, %some: Exported functions
Function, =element: Exported functions
Function, =integer-number: Exported functions
Function, =line: Exported functions
Function, =list: Exported functions
Function, =natural-number: Exported functions
Function, =subseq: Exported functions
Function, =transform: Exported functions
Function, ?char: Exported functions
Function, ?digit: Exported functions
Function, ?end: Exported functions
Function, ?eq: Exported functions
Function, ?newline: Exported functions
Function, ?not: Exported functions
Function, ?satisfies: Exported functions
Function, ?seq: Exported functions
Function, ?string: Exported functions
Function, ?whitespace: Exported functions
Function, cases-to-parser-cases: Internal functions
Function, copy-index: Internal functions
Function, copy-index-list: Internal functions
Function, copy-index-simple-string: Internal functions
Function, copy-index-simple-vector: Internal functions
Function, copy-index-stream: Internal functions
Function, copy-index-vector: Internal functions
Function, element-type: Internal functions
Function, get-input-position: Exported functions
Function, index-list-list: Internal functions
Function, index-list-p: Internal functions
Function, index-list-position: Internal functions
Function, index-p: Internal functions
Function, index-position: Exported functions
Function, index-simple-string-p: Internal functions
Function, index-simple-string-position: Internal functions
Function, index-simple-string-vector: Internal functions
Function, index-simple-vector-p: Internal functions
Function, index-simple-vector-position: Internal functions
Function, index-simple-vector-vector: Internal functions
Function, index-stream-buffer: Internal functions
Function, index-stream-p: Internal functions
Function, index-stream-position: Internal functions
Function, index-stream-stream: Internal functions
Function, index-vector-p: Internal functions
Function, index-vector-position: Internal functions
Function, index-vector-vector: Internal functions
Function, make-index: Internal functions
Function, make-index-list: Internal functions
Function, make-index-simple-string: Internal functions
Function, make-index-simple-vector: Internal functions
Function, make-index-stream: Internal functions
Function, make-index-vector: Internal functions
Function, maybe-fill-buffer: Internal functions
Function, parse: Exported functions
Function, parse-line-position: Internal functions

G
Generic Function, fill-buffer: Internal generic functions
Generic Function, input-element-type: Exported generic functions
Generic Function, input-empty-p: Exported generic functions
Generic Function, input-first: Exported generic functions
Generic Function, input-position: Exported generic functions
Generic Function, input-rest: Exported generic functions
Generic Function, input-sequence: Exported generic functions
Generic Function, make-input: Exported generic functions
get-input-position: Exported functions

I
index-list-list: Internal functions
index-list-p: Internal functions
index-list-position: Internal functions
index-p: Internal functions
index-position: Exported functions
index-simple-string-p: Internal functions
index-simple-string-position: Internal functions
index-simple-string-vector: Internal functions
index-simple-vector-p: Internal functions
index-simple-vector-position: Internal functions
index-simple-vector-vector: Internal functions
index-stream-buffer: Internal functions
index-stream-p: Internal functions
index-stream-position: Internal functions
index-stream-stream: Internal functions
index-vector-p: Internal functions
index-vector-position: Internal functions
index-vector-vector: Internal functions
input-element-type: Exported generic functions
input-element-type: Exported generic functions
input-element-type: Exported generic functions
input-element-type: Exported generic functions
input-empty-p: Exported generic functions
input-empty-p: Exported generic functions
input-empty-p: Exported generic functions
input-empty-p: Exported generic functions
input-first: Exported generic functions
input-first: Exported generic functions
input-first: Exported generic functions
input-first: Exported generic functions
input-first: Exported generic functions
input-first: Exported generic functions
input-position: Exported generic functions
input-position: Exported generic functions
input-position: Exported generic functions
input-rest: Exported generic functions
input-rest: Exported generic functions
input-rest: Exported generic functions
input-rest: Exported generic functions
input-rest: Exported generic functions
input-rest: Exported generic functions
input-sequence: Exported generic functions
input-sequence: Exported generic functions
input-sequence: Exported generic functions
input-sequence: Exported generic functions
input-sequence: Exported generic functions

M
Macro, %handler-case: Exported macros
Macro, %restart-case: Exported macros
Macro, =destructure: Exported macros
Macro, ?fail: Exported macros
Macro, ?test: Exported macros
make-index: Internal functions
make-index-list: Internal functions
make-index-simple-string: Internal functions
make-index-simple-vector: Internal functions
make-index-stream: Internal functions
make-index-vector: Internal functions
make-input: Exported generic functions
make-input: Exported generic functions
make-input: Exported generic functions
make-input: Exported generic functions
maybe-fill-buffer: Internal functions
Method, fill-buffer: Internal generic functions
Method, fill-buffer: Internal generic functions
Method, input-element-type: Exported generic functions
Method, input-element-type: Exported generic functions
Method, input-element-type: Exported generic functions
Method, input-empty-p: Exported generic functions
Method, input-empty-p: Exported generic functions
Method, input-empty-p: Exported generic functions
Method, input-first: Exported generic functions
Method, input-first: Exported generic functions
Method, input-first: Exported generic functions
Method, input-first: Exported generic functions
Method, input-first: Exported generic functions
Method, input-position: Exported generic functions
Method, input-position: Exported generic functions
Method, input-rest: Exported generic functions
Method, input-rest: Exported generic functions
Method, input-rest: Exported generic functions
Method, input-rest: Exported generic functions
Method, input-rest: Exported generic functions
Method, input-sequence: Exported generic functions
Method, input-sequence: Exported generic functions
Method, input-sequence: Exported generic functions
Method, input-sequence: Exported generic functions
Method, make-input: Exported generic functions
Method, make-input: Exported generic functions
Method, make-input: Exported generic functions

P
parse: Exported functions
parse-line-position: Internal functions

Jump to:   %   =   ?  
C   E   F   G   I   M   P  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.3 Variables

Jump to:   *  
B   L   P   S   V  
Index Entry  Section

*
*bound*: Exported special variables
*chunk-size*: Exported special variables
*element-type*: Exported special variables
*input-fail*: Internal special variables
*input-start*: Internal special variables
*whitespace*: Exported special variables

B
buffer: Internal structures

L
list: Internal structures

P
position: Exported structures

S
Slot, buffer: Internal structures
Slot, list: Internal structures
Slot, position: Exported structures
Slot, stream: Internal structures
Slot, vector: Internal structures
Special Variable, *bound*: Exported special variables
Special Variable, *chunk-size*: Exported special variables
Special Variable, *element-type*: Exported special variables
Special Variable, *input-fail*: Internal special variables
Special Variable, *input-start*: Internal special variables
Special Variable, *whitespace*: Exported special variables
stream: Internal structures

V
vector: Internal structures

Jump to:   *  
B   L   P   S   V  

Previous: , Up: Indexes   [Contents][Index]

A.4 Data types

Jump to:   I   M   P   S   T  
Index Entry  Section

I
index: Exported structures
index-list: Internal structures
index-position: Exported types
index-simple-string: Internal structures
index-simple-vector: Internal structures
index-stream: Internal structures
index-vector: Internal structures

M
maxpc: The maxpc system
maxpc: The maxpc package
maxpc.char: The maxpc<dot>char package
maxpc.digit: The maxpc<dot>digit package
maxpc.input: The maxpc<dot>input package
maxpc.input.index: The maxpc<dot>input<dot>index package
maxpc.input.list: The maxpc<dot>input<dot>list package
maxpc.input.stream: The maxpc<dot>input<dot>stream package
maxpc.input.vector: The maxpc<dot>input<dot>vector package

P
Package, maxpc: The maxpc package
Package, maxpc.char: The maxpc<dot>char package
Package, maxpc.digit: The maxpc<dot>digit package
Package, maxpc.input: The maxpc<dot>input package
Package, maxpc.input.index: The maxpc<dot>input<dot>index package
Package, maxpc.input.list: The maxpc<dot>input<dot>list package
Package, maxpc.input.stream: The maxpc<dot>input<dot>stream package
Package, maxpc.input.vector: The maxpc<dot>input<dot>vector package

S
Structure, index: Exported structures
Structure, index-list: Internal structures
Structure, index-simple-string: Internal structures
Structure, index-simple-vector: Internal structures
Structure, index-stream: Internal structures
Structure, index-vector: Internal structures
System, maxpc: The maxpc system

T
Type, index-position: Exported types

Jump to:   I   M   P   S   T