Re: Parsing implicit operators with recursive descent?

On Fri, 06 Feb 2009 02:34:56 +0000, Johann 'Myrkraverk' Oskarsson wrote:


> That is, to be explicit, is it possible to make a recursive descent
> parser that produces (*) the following parse tree on this input "aab":
>
> @
> / \
> @ b
> / \
> a a
>
> Where @ is the implicit concatenation operator?


Yes, it is possible. There are two techniques I m using:


1. When a table of tokens expected in the infix operation context does not
match the input, a "missing operation" handler is called. This handler
emulates some default operation. It can be "multiply" or "catenation" as in
the case of pattern expressions.


2. Simply put an empty token into the table of infix operations (*). This
approach is straightforward, but it will require "missing operand" handler
that would discard always matched empty token when that was recognized at
the expression end. Usually I have also some context check that verifies
matched tokens not to break some rules. For example "ab" is not accepted
when found in "abcdef," but accepted when found in "ab(1)" etc. Such checks
can be deployed here to avoid empty token match at the expression end.


--------------------------------------
* I do not tokenize the source, this makes dealing things like empty tokens
a lot easier. Token tables are matched directly against the source.


--
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de

Return to the comp.compilers page.
Search the comp.compilers archives again.