\end{describe*}
\begin{describe}{gf}{file-location @<object> @> @<floc>}
- \begin{describe}{meth}{file-location (@<floc> file-location) @> @<floc>}
+ \begin{describe}{meth}{file-location}
+ {file-location (@<floc> file-location) @> @<floc>}
\end{describe}
- \begin{describe}{meth}{file-location (@<stream> stream) @> @<floc>}
+ \begin{describe}{meth}{stream}
+ {file-location (@<stream> stream) @> @<floc>}
\end{describe}
- \begin{describe}{meth}{file-location (@<any> t) @> @<floc>}
+ \begin{describe}{meth}{t}
+ {file-location (@<any> t) @> @<floc>}
\end{describe}
\end{describe}
\begin{describe}{cls}{condition-with-location (condition) \&key :location}
\end{describe}
-\begin{describe}{meth}
+\begin{describe}{meth}{condition-with-location}
{file-location (@<condition> condition-with-location) @> @<floc>}
\end{describe}
{warning-with-location (condition-with-location warning) \\ \>
\&key :location}
\dhead{cls}
+ {information-with-location (condition-with-location information) \\ \>
+ \&key :location}
+ \dhead{cls}
{enclosing-error-with-location
(enclosing-error-with-location error) \\ \>
\&key :condition :location}
(enclosing-condition-with-location warning) \\ \>
\&key :condition :location}
\dhead{cls}
+ {enclosing-information-with-location
+ (enclosing-condition-with-location information) \\ \>
+ \&key :condition :location}
+ \dhead{cls}
{simple-condition-with-location
(condition-with-location simple-condition) \\ \>
\&key :format-control :format-arguments :location}
\dhead{cls}
{simple-warning-with-location
(warning-with-location simple-warning) \\ \>
+ \&key :format-control :format-arguments :location}
+ \dhead{cls}
+ {simple-information-with-location
+ (information-with-location simple-information) \\ \>
\&key :format-control :format-arguments :location}}
\end{describe*}
+\begin{describe}{gf}
+ {enclosing-condition-with-location-type @<condition> @> @<symbol>}
+\end{describe}
+
\begin{describe}{fun}
{make-condition-with-location @<default-type> @<floc>
@<datum> \&rest @<arguments>
\dhead{fun}{warn-with-location @<floc> @<datum> \&rest @<arguments>}}
\end{describe*}
+\begin{describe*}
+ {\dhead{cls}{parser-error (error) \\ \ind
+ \&key :expected :found \-}
+ \dhead{gf}{parser-error-expected @<condition> @> @<list>}
+ \dhead{gf}{parser-error-found @<condition> @> @<value>}}
+\end{describe*}
+
+\begin{describe}{fun}
+ {report-parser-error @<error> @<stream> @<show-expected> @<show-found>}
+\end{describe}
+
+\begin{describe*}
+ {\quad\=\kill
+ \dhead{cls}{base-lexer-error (error-with-location) \&key :location}
+ \dhead{cls}{simple-lexer-error
+ (base-lexer-error simple-error-with-location) \\\>
+ \&key :format-control :format-arguments :location}
+ \dhead{cls}{base-syntax-error (error-with-location) \&key :location}
+ \dhead{cls}{simple-syntax-error
+ (base-syntax-error simple-error-with-location) \\\>
+ \&key :format-control :format-arguments :location}}
+\end{describe*}
+
\begin{describe}{mac}
{with-default-error-location (@<floc>) @<declaration>^* @<form>^*
@> @<value>^*}
\end{describe}
+\begin{describe}{gf}{classify-condition @<condition> @> @<string>}
+ \begin{describe*}
+ {\dhead{meth}{error}
+ {classify-condition (@<condition> error) @> @<string>}
+ \dhead{meth}{warning}
+ {classify-condition (@<condition> warning) @> @<string>}
+ \dhead{meth}{information}
+ {classify-condition (@<condition> information)
+ @> @<string>}
+ \dhead{meth}{base-lexer-error}
+ {classify-condition (@<condition> base-lexer-error)
+ @> @<string>}
+ \dhead{meth}{base-syntax-error}
+ {classify-condition (@<condition> base-syntax-error)
+ @> @<string>}}
+ \end{describe*}
+\end{describe}
+
\begin{describe}{mac}
{count-and-report-errors () @<declaration>^* @<form>^*
@> @<value> @<n-errors> @<n-warnings>}
rewound to the position held in it.
Depending on how the scanner works, holding onto a captured place might
-consume a lot of memory or case poor performance. For example, if the
+consume a lot of memory or cause poor performance. For example, if the
scanner is reading from an input stream, having a captured place means that
data from that point on must be buffered in case the program needs to rewind
the scanner and read that data again. Therefore it's possible to
\begin{describe}{gf}{scanner-unread @<scanner> @<character>}
Rewind the @<scanner> by one step. The @<chararacter> must be the previous
current character, and becomes the current character again. It is an error
- if: the @<scanner> has reached end-of-file; the @<scanner> is never been
+ if: the @<scanner> has reached end-of-file; the @<scanner> has never been
stepped; or @<character> was not the previous current character.
\end{describe}
\begin{describe}{gf}
{charbuf-scanner-map @<scanner> @<func> \&optional @<fail>
- \nlret @<result> @<successp> @<consumedp>}
+ \nlret @<result> @<success-flag> @<consumed-flag>}
Read characters from the @<scanner>'s buffers.
This is intended to be an efficient and versatile interface for reading
@<start> (inclusive) and @<end> (exclusive) should be processed. If
@<func>'s return value @<donep> is nil then @<used> is ignored: the
function has consumed the entire buffer and wishes to read more. If
- @<donep> is non-nil, then it must be a fixnum such that $@<start> \le
+ @<donep> is non-nil, then @<used> must be a fixnum such that $@<start> \le
@<used> \le @<end>$: the function has consumed the buffer as far as @<used>
(exclusive) and has completed successfully.
\begin{describe}{gf}{parser-step @<context> @> @<form>}
\end{describe}
-\begin{describe}{sym}{it}
-\end{describe}
-
\begin{describe}{mac}
{if-parse (@[[ \=:result @<result-var> @!
:expected @<expected-var> @! \+\\
\end{describe}
\begin{describe}{gf}
- {parser-places-must-be-released-p @<context> @> @<generalized-boolean>>}
+ {parser-places-must-be-released-p @<context> @> @<generalized-boolean>}
\end{describe}
\begin{describe}{mac}
\begin{describe}{parseform}{char @<character>}
\end{describe}
-\begin{describe}[char]{parse}{@<character>}
+\begin{describe}{parse}[char]{@<character>}
\end{describe}
-\begin{describe}[string]{parse}{@<string>}
+\begin{describe}{parse}[string]{@<string>}
\end{describe}
\begin{describe}{parse}{:any}
\begin{describe}{parseform}{token @<type> @[@<value>@] @[:peekp @<peek>@]}
\end{describe}
-\begin{describe}[atom]{parse}{@<atom>}
-\end{describe}
-
-\begin{describe}[string]{parse}{@<string>}
+\begin{describe}{parse}[atom]{@<atom>}
\end{describe}
\begin{describe}{cls}{scanner-context () \&key :scanner}
\begin{describe}{fun}{define-indicator @<indicator> @<description>}
\end{describe}
-\begin{describe}{fun}{syntax-error @<scanner> @<expected> \&key :continuep}
+\begin{describe*}
+ {\dhead{cls}{lexer-error (parser-error base-lexer-error) \\ \ind
+ \&key :expected :found :location \-}
+ \dhead{cls}{syntax-error (parser-error base-syntax-error) \\ \ind
+ \&key :expected :found :location \-}}
+\end{describe*}
+
+\begin{describe}{fun}
+ {syntax-error @<scanner> @<expected> \&key :continuep :location}
\end{describe}
\begin{describe}{fun}
- {lexer-error @<char-scanner> @<expected> @<consumed-flag>}
+ {lexer-error @<char-scanner> @<expected> \&key :location}
\end{describe}
\begin{describe}{parseform}
{skip-until (@[[ :keep-end @<keep-end-flag> @]]) @<token-type>^*}
\end{describe}
-\begin{describe}{parseform}{error () @<sub-parser> @<recover-parser>}
+\begin{describe}{parseform}
+ {error (@[[ :ignore-unconsumed @<flag> @!
+ :force-process @<flag> @]]) \\ \ind\ind
+ @<sub-parser> @<recover-parser> \-\\
+ @<declaration>^* \\
+ @<form>^*}
+\end{describe}
+
+\begin{describe}{parseform}{must @<sub-parser> @[@<default>@]}
\end{describe}
\begin{describe}{fun}
~mdw / sod / blobdiff