|recursive pasrer, arithmetic expansion email@example.com (Matthieu Tourne) (2006-03-22)|
|Re: recursive pasrer, arithmetic expansion firstname.lastname@example.org (Clint Olsen) (2006-03-27)|
|From:||Clint Olsen <email@example.com>|
|Date:||27 Mar 2006 01:27:17 -0500|
|Posted-Date:||27 Mar 2006 01:27:17 EST|
On 2006-03-23, Matthieu Tourne <firstname.lastname@example.org> wrote:
> I'm currently doing a parser for arithmetic expansions in a shell. but
> I'm experiencing some troubles making my parser recursive. My problem
> is: the variable foo can contain the string "2 + 2" the evaluation of
> $((foo + 3)) should be "7" I need to do parse(parse(foo) + 7), but I
> can't achieve it.
1) Yyparse returns an integer (in Lemon it's void). It won't return the
tree you've constructed like you think it will.
2) Is the replacement for 'foo' text substitution? If so, you use a
_stack_ to lex from the text of foo. Then pop the stack when you're
done with foo. The lexer does this and the parser never sees it. This
is how #include is done: Text file inclusion introduces text fragments
into the token stream. It doesn't have to parse correctly in its
3) If the intent is that foo form a proper expression, you can stash away
the tree constructed when you built the tree '2 + 2' when foo was
declared. Then when you see 'foo' later in an expression, you just grab
the tree you built out of a tree or hash table structure and splice it
right into your expression.
You'll need to think about what kind of evaluation you want to do in your
design (lazy or not). Consider how you handle if the symbol 'foo'
contained another symbol 'bar' which is meant to also be replaced? Do you
replace it right at foo definition time or when foo is encountered in an
Bison and flex now both support re-entrant code, so you can recursively
call them, but you need to make sure you know when to use it. Depending on
your strategy, you may not need it at all.
Return to the
Search the comp.compilers archives again.