Re: Fledgling project nnsearch.el

[kai.grossjohann@gmx.net (Kai Großjohann)]

It seems I'm too stupid to implement a simple parser.  I thought it
would be good for nnsearch.el to accept a standard query syntax, and
to transmogrify these queries into things that the search engines
grok.

I looked at the Namazu query syntax, and I like it.  It goes like
this:

    Query ::= Term
            | Term "and" Query
            | Term "or" Query
            | Term "not" Query
            | "(" Query ")"

    Term  ::= Word
            | Field ":" Word

    Word  ::= { a string of letters }

    Field ::= { name of mail header }

This appears to be simple enough.  But my parser isn't working.  I
tried a recursive descent, and I'm getting weird results.

So does somebody have a good design pattern that could be used to
construct that kind of parser?

It seems to be clear that I need a function that reads a token.
Tokens are: and, or, not, open paren, close paren, colon, words and
fields.  (I guess that word and field can't be distinguished by the
lexer.)

Then it also seems to be clear that I need a function for each
nonterminal in the grammar.  So there will be a parse-query, a
parse-term, a parse-field, and a parse-word.

What should be the argument of each such function and what should be
the return value?

I put the string into a buffer and used point as an indication what
to read next.  For the lookahead I used save-excursion.  The parse-*
functions didn't have arguments, and the return values were (partial)
parse trees.

Help?
-- 
Two cafe au lait please, but without milk.