Re: OpenToken: Parsing Ada (subset)?

[Stephen Leake <stephen_leake@stephe-leake.org>]

"Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> writes:

> On Tue, 16 Jun 2015 07:43:49 -0500, Stephen Leake wrote:
>
>> "Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> writes:
>> 
>> Here's the regular expression I use for Ada numeric literals:
>> 
>> "\([0-9]+#\)?[-+0-9a-fA-F.]+\(#\)?"
>> 
>> Given that you are at least a little familiar with regular expressions,
>> there's nothing hard about that.
>
> It is hard.

Ok, I gather you are not "at least a little familiar with regular
expressions". Too bad.

>> It does not enforce all the lexical rules for numbers; it allows
>> repeated, leading, and trailing underscores; it doesn't enforce pairs of
>> '#'.
>
> That is exactly the point. It does not parse literal right 

It's _not_ a "parser"; it's a "lexer".

Define "right". The line between lexer and parser is a design decision,
not set in stone. 

> and you have to
> reparse the matched chunk of text once again. What was the gain? 

Doing it this way allows reusing a regexp engine, which is easier than
writing a lexer from scatch.

>> It took a few minutes to write the regular expression, and I reused the
>> tests; no bugs found yet.
>
>> Obviously, if you are not familiar with regular expressions, they will
>> be harder to write. But a software engineer should be willing to learn
>> the appropriate language for the job at hand.
>
> That is not the point. I am familiar with C, but I am avoiding writing
> anything in C. Regular expressions is a far worse language than C and,
> additionally, incapable to parse Ada literals. Why bother with that
> mess?

As I have explained several times, I believe this approach is easier
than writing a lexer by hand; why bother with _that_ mess?

It's your choice. It would be nice if you could admit that other people can
make other choices, and still write good code.

Perhaps you could post lexer code that does this "right" by your
definition, so we could judge for ourselves?

>> I would guess that the average good programmer, starting with no
>> knowledge of either, can learn enough about regular expressions to write
>> the above faster than they can learn enough about writing scanners in
>> Ada to do that job well.
>
> The problem is that writing a correct pattern for anything more complex
> than trivial is hard even for people doing this on daily basis. For an
> average programmer it is patently impossible.

"patently" is overkill here; this is simply not my experience.

-- 
-- Stephe