3 %%% Description of the parsing machinery
5 %%% (c) 2015 Straylight/Edgeware
8 %%%----- Licensing notice ---------------------------------------------------
10 %%% This file is part of the Sensible Object Design, an object system for C.
12 %%% SOD is free software; you can redistribute it and/or modify
13 %%% it under the terms of the GNU General Public License as published by
14 %%% the Free Software Foundation; either version 2 of the License, or
15 %%% (at your option) any later version.
17 %%% SOD is distributed in the hope that it will be useful,
18 %%% but WITHOUT ANY WARRANTY; without even the implied warranty of
19 %%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 %%% GNU General Public License for more details.
22 %%% You should have received a copy of the GNU General Public License
23 %%% along with SOD; if not, write to the Free Software Foundation,
24 %%% Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
26 \chapter{Parsing
} \label{ch:parsing
}
28 %%%--------------------------------------------------------------------------
29 \section{The parser protocol
} \label{sec:parsing.proto
}
31 For the purpose of Sod's parsing library,
\emph{parsing
} is the process of
32 reading a sequence of input items, in order, and computing an output value.
34 A
\emph{parser
} is an expression which consumes zero or more input items and
35 returns three values: a
\emph{result
}, a
\emph{success flag
}, and a
36 \emph{consumed flag
}. The two flags are (generalized) booleans. If the
37 success flag is non-nil, then the parser is said to have
\emph{succeeded
},
38 and the result is the parser's output. If the success flag is nil then the
39 parser is said to have
\emph{failed
}, and the result is a list of
40 \emph{indicators
}. Finally, the consumed flag is non-nil if the parser
41 consumed any input items.
43 \begin{describe
}{fun
}{combine-parser-failures @<failures> @> @<list>
}
46 \begin{describe
}{fun
}{parse-empty \&optional @<value> @> @<function>
}
50 {parse-fail @<indicator> \&optional @<consumedp> @> @<function>
}
53 %%%--------------------------------------------------------------------------
54 \section{File locations
} \label{sec:parsing.floc
}
56 \begin{describe
}{cls
}{file-location
}
59 \begin{describe
}{fun
}{file-location-p @<object> @> @<generalized-boolean>
}
63 {make-file-location @<filename> \&optional @<line> @<column>
68 {\dhead{fun
}{file-location-filename @<floc> @> @<string-or-nil>
}
69 \dhead{fun
}{file-location-line @<floc> @> @<fixnum-or-nil>
}
70 \dhead{fun
}{file-location-column @<floc> @> @<fixnum-or-nil>
}}
73 \begin{describe
}{gf
}{file-location @<object> @> @<floc>
}
74 \begin{describe
}{meth
}{file-location
}
75 {file-location (@<floc> file-location) @> @<floc>
}
77 \begin{describe
}{meth
}{stream
}
78 {file-location (@<stream> stream) @> @<floc>
}
80 \begin{describe
}{meth
}{t
}
81 {file-location (@<any> t) @> @<floc>
}
85 \begin{describe
}{cls
}{condition-with-location (condition) \&key :location
}
88 \begin{describe
}{meth
}{condition-with-location
}
89 {file-location (@<condition> condition-with-location) @> @<floc>
}
95 {error-with-location (condition-with-location error) \\ \>
98 {warning-with-location (condition-with-location warning) \\ \>
101 {information-with-location (condition-with-location information) \\ \>
104 {enclosing-error-with-location
105 (enclosing-error-with-location error) \\ \>
106 \&key :condition :location
}
108 {enclosing-warning-with-location
109 (enclosing-condition-with-location warning) \\ \>
110 \&key :condition :location
}
112 {enclosing-information-with-location
113 (enclosing-condition-with-location information) \\ \>
114 \&key :condition :location
}
116 {simple-condition-with-location
117 (condition-with-location simple-condition) \\ \>
118 \&key :format-control :format-arguments :location
}
120 {simple-error-with-location
121 (error-with-location simple-error) \\ \>
122 \&key :format-control :format-arguments :location
}
124 {simple-warning-with-location
125 (warning-with-location simple-warning) \\ \>
126 \&key :format-control :format-arguments :location
}
128 {simple-information-with-location
129 (information-with-location simple-information) \\ \>
130 \&key :format-control :format-arguments :location
}}
134 {enclosing-condition-with-location-type @<condition> @> @<symbol>
}
137 \begin{describe
}{fun
}
138 {make-condition-with-location @<default-type> @<floc>
139 @<datum> \&rest @<arguments>
140 \nlret @<condition-with-location>
}
144 {\dhead{fun
}{error-with-location @<floc> @<datum> \&rest @<arguments>
}
145 \dhead{fun
}{cerror-with-location @<floc> @<continue-string>
146 @<datum> \&rest @<arguments>
}
147 \dhead{fun
}{cerror*-with-location @<floc> @<datum> \&rest @<arguments>
}
148 \dhead{fun
}{warn-with-location @<floc> @<datum> \&rest @<arguments>
}}
152 {\dhead{cls
}{parser-error (error) \\
\ind
153 \&key :expected :found \-
}
154 \dhead{gf
}{parser-error-expected @<condition> @> @<list>
}
155 \dhead{gf
}{parser-error-found @<condition> @> @<value>
}}
158 \begin{describe
}{fun
}
159 {report-parser-error @<error> @<stream> @<show-expected> @<show-found>
}
164 \dhead{cls
}{base-lexer-error (error-with-location) \&key :location
}
165 \dhead{cls
}{simple-lexer-error
166 (base-lexer-error simple-error-with-location) \\\>
167 \&key :format-control :format-arguments :location
}
168 \dhead{cls
}{base-syntax-error (error-with-location) \&key :location
}
169 \dhead{cls
}{simple-syntax-error
170 (base-syntax-error simple-error-with-location) \\\>
171 \&key :format-control :format-arguments :location
}}
174 \begin{describe
}{mac
}
175 {with-default-error-location (@<floc>) @<declaration>^* @<form>^*
179 \begin{describe
}{gf
}{classify-condition @<condition> @> @<string>
}
182 {classify-condition (@<condition> error) @> @<string>
}
183 \dhead{meth
}{warning
}
184 {classify-condition (@<condition> warning) @> @<string>
}
185 \dhead{meth
}{information
}
186 {classify-condition (@<condition> information)
188 \dhead{meth
}{base-lexer-error
}
189 {classify-condition (@<condition> base-lexer-error)
191 \dhead{meth
}{base-syntax-error
}
192 {classify-condition (@<condition> base-syntax-error)
197 \begin{describe
}{mac
}
198 {count-and-
report-errors () @<declaration>^* @<form>^*
199 @> @<value> @<n-errors> @<n-warnings>
}
202 %%%--------------------------------------------------------------------------
203 \section{Scanners
} \label{sec:parsing.scanner
}
205 A
\emph{scanner
} is an object which keeps track of a parser's progress as it
206 works through its input. There's no common base class for scanners: a
207 scanner is simply any object which implements the scanner protocol described
210 A scanner maintains a sequence of items to read. It can step forwards
211 through the items, one at a time, until it reaches the end (if, indeed, the
212 sequence is finite, which it needn't be). Until that point, there is a
213 current item, though there's no protocol for accessing it at this level
214 because the nature of the items is left unspecified.
216 Some scanners support an additional
\emph{place-capture
} protocol which
217 allows rewinding the scanner to an earlier point in the input so that it can
220 \subsection{Basic scanner protocol
} \label{sec:parsing.scanner.basic
}
222 The basic protocol supports stepping the scanner forward through its input
223 sequence, and detecting the end of the sequence.
225 \begin{describe
}{gf
}{scanner-step @<scanner>
}
226 Advance the @<scanner> to the next item, which becomes current.
228 It is an error to step the scanner if the scanner is at end-of-file.
231 \begin{describe
}{gf
}{scanner-at-eof-p @<scanner> @> @<generalized-boolean>
}
232 Return non-nil if the scanner is at end-of-file, i.e., there are no more
235 If nil is returned, there is a current item, and it is safe to step the
236 scanner again; otherwise, it is an error to query the current item or to
240 \subsection{Place-capture scanner protocol
} \label{sec:parsing.scanner.place
}
242 The place-capture protocol allows rewinding to an earlier point in the
243 sequence. Not all scanners support the place-capture protocol.
245 To rewind a scanner to a particular point, that point must be
\emph{captured
}
246 as a
\emph{place
} when it's current -- so you must know in advance that this
247 is an interesting place that's worth capturing. The type of place returned
248 depends on the type of scanner. Given a captured place, the scanner can be
249 rewound to the position held in it.
251 Depending on how the scanner works, holding onto a captured place might
252 consume a lot of memory or cause poor performance. For example, if the
253 scanner is reading from an input stream, having a captured place means that
254 data from that point on must be buffered in case the program needs to rewind
255 the scanner and read that data again. Therefore it's possible to
256 \emph{release
} a place when it turns out not to be needed any more.
258 \begin{describe
}{gf
}{scanner-capture-place @<scanner> @> @<place>
}
259 Capture the @<scanner>'s current position as a place, and return the place.
262 \begin{describe
}{gf
}{scanner-restore-place @<scanner> @<place>
}
263 Rewind the @<scanner> to the state it was in when @<place> was captured.
264 In particular, the item that was current when the @<place> was captured
265 becomes current again.
267 It is an error to restore a @<place> that has been released, or if the
268 @<place> wasn't captured from the @<scanner>.
271 \begin{describe
}{gf
}{scanner-release-place @<scanner> @<place>
}
272 Release the @<place>, to avoid having to maintaining the ability to restore
273 it after it's not needed any more..
275 It is an error if the @<place> wasn't captured from the @<scanner>.
278 \begin{describe
}{mac
}
279 {with-scanner-place (@<place> @<scanner>) @<declarations>^* @<form>^*
281 Capture the @<scanner>'s current position as a place, evaluate the @<form>s
282 as an implicit progn with the variable @<place> bound to the captured
283 place. When control leaves the @<form>s, the place is released. The
284 return values are the values of the final @<form>.
287 \subsection{Scanner file-location protocol
} \label{sec:parsing.scanner.floc
}
289 Some scanners participate in the file-location protocol
290 (
\xref{sec:parsing.floc
}). They implement a method on @|file-location| which
291 collects the necessary information using scanner-specific functions described
294 \begin{describe
}{fun
}{scanner-file-location @<scanner> @> @<file-location>
}
295 Return a @|file-location| object describing the current position of the
298 This calls the @|scanner-filename|, @|scanner-line| and @|scanner-column|
299 generic functions on the scanner, and uses these to fill in an appropriate
302 Since there are default methods on these generic functions, it is not an
303 error to call @|scanner-file-location| on any kind of value, but it might
304 not be very useful. This function exists to do the work of appropriately
305 specialized methods on @|file-location|.
309 {\dhead{gf
}{scanner-filename @<scanner> @> @<string>
}
310 \dhead{gf
}{scanner-line @<scanner> @> @<integer>
}
311 \dhead{gf
}{scanner-column @<scanner> @> @<integer>
}}
312 Return the filename, line and column components of the @<scanner>'s current
313 position, for use in assembling a @<file-location>: see the
314 @|scanner-file-location| function.
316 There are default methods on all three generic functions which simply
320 \subsection{Character scanners
} \label{sec:parsing.scanner.char
}
322 Character scanners are scanners which read sequences of characters.
324 \begin{describe
}{cls
}{character-scanner () \&key
}
325 Base class for character scanners. This provides some very basic
328 Not all character scanners are subclasses of @|character-scanner|.
331 \begin{describe
}{gf
}{scanner-current-char @<scanner> @> @<character>
}
332 Returns the current character.
335 \begin{describe
}{gf
}{scanner-unread @<scanner> @<character>
}
336 Rewind the @<scanner> by one step. The @<chararacter> must be the previous
337 current character, and becomes the current character again. It is an error
338 if: the @<scanner> has reached end-of-file; the @<scanner> has never been
339 stepped; or @<character> was not the previous current character.
343 {scanner-interval @<scanner> @<place-a> \&optional @<place-b>
345 Return the characters in the @<scanner>'s input from @<place-a> up to (but
346 not including) @<place-b>.
348 The characters are returned as a string. If @<place-b> is omitted, return
349 the characters up to (but not including) the current position. It is an
350 error if @<place-b> precedes @<place-a> or they are from different
353 This function is a character-scanner-specific extension to the
354 place-capture protocol; not all character scanners implement the
355 place-capture protocol, and some that do may not implement this function.
358 \subsubsection{Stream access to character scanners
}
359 Sometimes it can be useful to apply the standard Lisp character input
360 operations to the sequence of characters held by a character scanner.
362 \begin{describe
}{gf
}{make-scanner-stream @<scanner> @> @<stream>
}
363 Returns a fresh input @|stream| object which fetches input characters from
364 the character scanner object @<scanner>. Reading characters from the
365 stream steps the scanner. The stream will reach end-of-file when the
366 scanner reports end-of-file. If the scanner implements the file-location
367 protocol then reading from the stream will change the file location in an
370 This is mostly useful for applying standard Lisp stream functions, most
371 particularly the @|read| function, in the middle of a parsing operation.
374 \begin{describe
}{cls
}{character-scanner-stream (stream) \&key :scanner
}
375 A Common Lisp input @|stream| object which works using the character
376 scanner protocol. Any @<scanner> which implements the base scanner and
377 character scanner protocols is suitable. See @|make-scanner-stream|.
380 \subsection{String scanners
} \label{sec:parsing.scanner.string
}
382 A
\emph{string scanner
} is a simple kind of character scanner which reads
383 input from a string object. String scanners implement the character scanner
384 and place-capture protocols.
386 \begin{describe
}{cls
}{string-scanner
}
387 The class of string scanners. The @|string-scanner| class is not a
388 subclass of @|character-scanner|.
391 \begin{describe
}{fun
}{string-scanner-p @<value> @> @<generalized-boolean>
}
392 Return non-nil if @<value> is a @|string-scanner| object; otherwise return
396 \begin{describe
}{fun
}
397 {make-string-scanner @<string> \&key :start :end @> @<string-scanner>
}
398 Construct and return a fresh @|string-scanner| object. The new scanner
399 will read characters from @<string>, starting at index @<start> (which
400 defaults to zero), and continuing until it reaches index @<end> (defaults
401 to the end of the @<string>).
404 \subsection{Character buffer scanners
} \label{sec:parsing.scanner.charbuf
}
406 A
\emph{character buffer scanner
}, or
\emph{charbuf scanner
} for short, is an
407 efficient scanner for reading characters from an input stream. Charbuf
408 scanners implements the basic scanner, character buffer, place-capture, and
409 file-location protocols.
411 \begin{describe
}{cls
}
412 {charbuf-scanner (character-scanner)
413 \&key :stream :filename :line :column
}
414 The class of charbuf scanners. The scanner will read characters from
415 @<stream>. Charbuf scanners implement the file-location protocol: the
416 initial location is set from the given @<filename>, @<line> and @<column>;
417 the scanner will update the location as it reads its input.
420 \begin{describe
}{cls
}{charbuf-scanner-place
}
421 The class of place objects captured by a charbuf scanner.
424 \begin{describe
}{fun
}
425 {charbuf-scanner-place-p @<value> @> @<generalized-boolean>
}
426 Type predicate for charbuf scanner places: returns non-nil if @<value> is a
427 place captured by a charbuf scanner, and nil otherwise.
431 {charbuf-scanner-map @<scanner> @<func> \&optional @<fail>
432 \nlret @<result> @<success-flag> @<consumed-flag>
}
433 Read characters from the @<scanner>'s buffers.
435 This is intended to be an efficient and versatile interface for reading
436 characters from a scanner in bulk. The function @<func> is invoked
439 (multiple-value-bind (@<donep> @<used>) \\
\ind\ind
440 (funcall @<func> @<buf> @<start> @<end>) \-\\
443 The argument @<buf> is a simple string; @<start> and @<end> are two
444 nonnegative fixnums, indicating that the subsequence of @<buf> between
445 @<start> (inclusive) and @<end> (exclusive) should be processed. If
446 @<func>'s return value @<donep> is nil then @<used> is ignored: the
447 function has consumed the entire buffer and wishes to read more. If
448 @<donep> is non-nil, then @<used> must be a fixnum such that $@<start>
\le
449 @<used>
\le @<end>$: the function has consumed the buffer as far as @<used>
450 (exclusive) and has completed successfully.
452 If end-of-file is encountered before @<func> completes successfully then it
453 fails: the @<fail> function is called with no arguments, and is expected to
454 return two values. If omitted, @<fail> defaults to
460 The @|charbuf-scanner-map| function returns three values. The first value
461 is the non-nil @<donep> value returned by @<func> if @|charbuf-scanner-map|
462 succeeded, or the first value returned by @<fail>; the second value is @|t|
463 on success, or the second value returned by @<fail>; the third value is
464 non-nil if @<func> consumed any input, i.e., it returned with @<donep> nil
465 at least once, or with $@<used> > @<start>$.
468 \subsection{Token scanners
} \label{sec:parsing.scanner.token
}
470 \begin{describe
}{cls
}
471 {token-scanner () \&key :filename (:line
1) (:column
0)
}
474 \begin{describe
}{gf
}{token-type @<scanner> @> @<type>
}
477 \begin{describe
}{gf
}{token-value @<scanner> @> @<value>
}
480 \begin{describe
}{gf
}{scanner-token @<scanner> @> @<type> @<value>
}
483 \begin{describe
}{ty
}{token-scanner-place
}
486 \begin{describe
}{fun
}
487 {token-scanner-place-p @<value> @> @<generalized-boolean>
}
490 \subsection{List scanners
}
492 \begin{describe
}{ty
}{list-scanner
}
495 \begin{describe
}{fun
}{list-scanner-p @<value> @> @<generalized-boolean>
}
498 \begin{describe
}{fun
}{make-list-scanner @<list> @> @<list-scanner>
}
501 %%%--------------------------------------------------------------------------
502 \section{Parsing syntax
}
504 \begin{describe
}{gf
}{expand-parser-spec @<context> @<spec> @> @<form>
}
508 {expand-parser-form @<context> @<head> @<tail> @> @<form>
}
511 \begin{describe
}{gf
}{wrap-parser @<context> @<form> @> @<wrapped-form>
}
514 \begin{describe
}{mac
}
515 {defparse @<name> (@
[[ :context (@<var> @<context-class>) @
]]
516 @<destructuring-lambda-list-item>^*) \\
\ind
517 @
[[ @<declaration>^* @! @<doc-string> @
]] \\
522 \begin{describe
}{mac
}
524 (@<context-class> @
{ @<init-keyword> @<value> @
}^*) \\
\ind
530 \begin{describe
}{lmac
}
531 {parse @<parser> @> @<result> @<success-flag> @<consumed-flag>
}
534 \begin{describe
}{mac
}
535 {parser @<lambda-list>
536 @
[[ @<declaration>^* @! @<doc-string> @
]]
541 \begin{describe
}{gf
}{parser-at-eof-p @<context> @> @<form>
}
544 \begin{describe
}{gf
}{parser-step @<context> @> @<form>
}
547 \begin{describe
}{mac
}
548 {if-parse (@
[[ \=:result @<result-var> @!
549 :expected @<expected-var> @! \+\\
550 :consumedp @<consumed-var> @
]]) \-\\
\ind\ind
557 \begin{describe
}{mac
}
558 {when-parse (@
[@<result-var>@
]) @<parser> \\
\ind
563 \begin{describe
}{mac
}
564 {cond-parse (@
[[ \=:result @<result-var> @!
565 :expected @<expected-var> @! \+\\
566 :consumedp @<consumed-var> @
]]) \-\\
\ind
567 @
{ (@<parser> @<form>^*) @
}^*
571 \begin{describe
}{parse
}{:eof
}
574 \begin{describe
}{parseform
}{lisp @<form>^*
}
577 \begin{describe
}{parseform
}{label @<parser>
}
580 \begin{describe
}{parse
}{t
}
583 \begin{describe
}{parseform
}{t @<value>
}
586 \begin{describe
}{parse
}{nil
}
589 \begin{describe
}{parseform
}{nil @<indicator>
}
592 \begin{describe
}{parseform
}{when @<cond> @<parser>
}
595 \begin{describe
}{parseform
}
596 {seq (@
{ @<atomic-parser-spec> @!
597 (@
[@<var>@
] @<parser>) @
}^*) \\
\ind
601 \begin{describe
}{parseform
}{and @<parser>^*
}
604 \begin{describe
}{parseform
}{or @<parser>^*
}
607 \begin{describe
}{parseform
}{? @<parser> @
[@<default>@
]}
610 \begin{describe
}{parseform
}
611 {many (\=@<accumulator-var> @<init-form> @<update-form> \+\\
612 @
[[ \=:new @<new-var> @! :final @<final-form> @! \+\\
613 :min @<minimum> @! :max @<maximum> @! \\
614 :commitp @<commitp> @
]]) \-\-\\
\ind
615 @<item-parser> @
[@<sep-parser>@
]}
618 \begin{describe
}{parseform
}
619 {list (@
[[ :min @<minimum> @! :max @<maximum> @!
620 :commitp @<commitp> @
]]) \\
\ind
621 @<item-parser> @
[@<sep-parser>@
]}
624 \begin{describe
}{parseform
}
625 {skip-many (@
[[ :min @<minimum> @! :max @<maximum> @!
626 :commitp @<commitp> @
]]) \\
\ind
627 @<item-parser> @
[@<sep-parser>@
]}
630 \begin{describe
}{fun
}{call-pluggable-parser @<symbol> \&rest @<args>
}
633 \begin{describe
}{parseform
}{plug @<symbol> @<arg>^*
}
636 \begin{describe
}{fun
}
637 {pluggable-parser-add @<symbol> @<tag> @<parser-function>
}
640 \begin{describe
}{mac
}
641 {define-pluggable-parser @<symbol> @<tag> @<lambda-list>
642 @
[[ @<declaration>^* @! @<doc-string> @
]]
646 \begin{describe
}{gf
}{parser-capture-place @<context> @> @<form>
}
649 \begin{describe
}{gf
}{parser-restore-place @<context> @<place> @> @<form>
}
652 \begin{describe
}{gf
}{parser-release-place @<context> @<place> @> @<form>
}
656 {parser-places-must-be-released-p @<context> @> @<generalized-boolean>
}
659 \begin{describe
}{mac
}
660 {with-parser-place (@<place-var> @<context>)
661 @
[[ @<declaration>^* @! @<doc-string> @
]]
665 \begin{describe
}{parseform
}{peek @<parser>
}
668 \begin{describe
}{parseform
}{commit
}
671 \begin{describe
}{cls
}{character-parser-context () \&key
}
674 \begin{describe
}{gf
}{parser-current-char @<context> @> @<form>
}
677 \begin{describe
}{parseform
}
678 {if-char (@
[@<result-var>@
]) @<condition> @<consequent> @<alternative>
}
681 \begin{describe
}{parseform
}{char @<character>
}
684 \begin{describe
}{parse
}[char
]{@<character>
}
687 \begin{describe
}{parse
}[string
]{@<string>
}
690 \begin{describe
}{parse
}{:any
}
693 \begin{describe
}{parseform
}{satisfies @<predicate>
}
696 \begin{describe
}{parseform
}{not @<character>
}
699 \begin{describe
}{parseform
}{filter @<predicate>
}
702 \begin{describe
}{parse
}{:whitespace
}
705 \begin{describe
}{cls
}{token-parser-context () \&key
}
708 \begin{describe
}{gf
}{parser-token-type @<context> @> @<form>
}
711 \begin{describe
}{gf
}{parser-token-value @<context> @> @<form>
}
714 \begin{describe
}{parseform
}{token @<type> @
[@<value>@
] @
[:peekp @<peek>@
]}
717 \begin{describe
}{parse
}[atom
]{@<atom>
}
720 \begin{describe
}{cls
}{scanner-context () \&key :scanner
}
723 \begin{describe
}{gf
}{parse-scanner @<context> @> @<symbol>
}
726 \begin{describe
}{cls
}
727 {character-scanner-context (scanner-context character-parser-context)
731 \begin{describe
}{cls
}
732 {token-scanner-context (scanner-context token-parser-context)
736 \begin{describe
}{gf
}{push-operator @<operator> @<state>
}
739 \begin{describe
}{gf
}{push-value @<value> @<state>
}
742 \begin{describe
}{gf
}{apply-operator @<operator> @<state>
}
745 \begin{describe
}{gf
}{operator-push-action @<left> @<right>
}
748 \begin{describe
}{parseform
}
749 {expr \=(@
[[ :nestedp @<nestedp-var> @
]]) \+\\
750 @<operand-parser> @<binop-parser>
751 @<preop-parser> @<postop-parser>
}
754 \begin{describe
}{gf
}{operator-left-precedence @<operator> @> @<prec>
}
757 \begin{describe
}{gf
}{operator-right-precedence @<operator> @> @<prec>
}
760 \begin{describe
}{gf
}{operator-associativity @<operator> @> @<assoc>
}
763 \begin{describe
}{cls
}{prefix-operator () \&key
}
766 \begin{describe
}{cls
}{simple-operator () \&key :name :function
}
769 \begin{describe
}{cls
}
770 {simple-unary-operator (simple-operator) \&key :name :function
}
775 \dhead{cls
}{simple-binary-operator (simple-operator) \\ \>
776 \&key :name :function
777 :lprec :rprec :associativity
}
778 \dhead{cls
}{simple-postfix-operator (simple-unary-operator) \\ \>
779 \&key :name :function :lprec :rprec
}
780 \dhead{cls
}{simple-prefix-operator
781 (prefix-operator simple-unary-operator) \\ \>
782 \&key :name :function :rprec
}}
786 {\dhead{mac
}{preop @<name> (@<operand-var> @<lprec>)
787 @<declaration>^* @<form>^*
788 @> @<prefix-operator>
}
789 \dhead{mac
}{postop @<name>
790 (@<operand-var> @<lprec> @
[[ :rprec @<rprec> @
]])
791 @<declaration>^* @<form>^*
792 \nlret @<postfix-operator>
}
793 \dhead{mac
}{binop @<name> (@<operand-var> @<lprec> @<rprec> @<assoc>)
794 @<declaration>^*@<form>^*
795 @> @<binary-operator>
}}
799 {\dhead{cls
}{parenthesis () \&key :tag
}
800 \dhead{cls
}{open-parenthesis (parenthesis prefix-operator) \&key :tag
}
801 \dhead{cls
}{close-parenthesis (parenthesis) \&key :tag
}}
805 {\dhead{fun
}{lparen @<tag> @> @<open-paren>
}
806 \dhead{fun
}{rparen @<tag> @> @<close-paren>
}}
809 %%%-------------------------------------------------------------------------
810 \section{Lexical analyser
}
812 \begin{describe
}{cls
}
813 {sod-token-scanner (token-scanner)
814 \&key :filename (:line
1) (:column
0) :char-scanner
}
817 \begin{describe
}{fun
}{define-indicator @<indicator> @<description>
}
821 {\dhead{cls
}{lexer-error (parser-error base-lexer-error) \\
\ind
822 \&key :expected :found :location \-
}
823 \dhead{cls
}{syntax-error (parser-error base-syntax-error) \\
\ind
824 \&key :expected :found :location \-
}}
827 \begin{describe
}{fun
}
828 {syntax-error @<scanner> @<expected> \&key :continuep :location
}
831 \begin{describe
}{fun
}
832 {lexer-error @<char-scanner> @<expected> \&key :location
}
835 \begin{describe
}{parseform
}
836 {skip-until (@
[[ :keep-end @<keep-end-flag> @
]]) @<token-type>^*
}
839 \begin{describe
}{parseform
}
840 {error (@
[[ :ignore-unconsumed @<flag> @!
841 :force-process @<flag> @
]]) \\
\ind\ind
842 @<sub-parser> @<recover-parser> \-\\
847 \begin{describe
}{parseform
}{must @<sub-parser> @
[@<default>@
]}
850 \begin{describe
}{fun
}
851 {scan-comment @<char-scanner>
852 @> @<result> @<success-flag> @<consumed-flag>
}
855 %%%----- That's all, folks --------------------------------------------------
859 %%% TeX-master: "sod.tex"