|Constant expression evaluation? mdhe51ATdialDOTpipexDOTcom@eu.uu.net (Paul Davis) (2003-05-14)|
|Re: Constant expression evaluation? email@example.com (Christian Bau) (2003-05-16)|
|Re: Constant expression evaluation? firstname.lastname@example.org (Dierk Ohlerich) (2003-05-16)|
|Re: Constant expression evaluation? email@example.com (Clint Olsen) (2003-05-18)|
|Re: Constant expression evaluation? firstname.lastname@example.org (Niksa Orlic) (2003-05-29)|
|Re: Constant expression evaluation? email@example.com (david lindauer) (2003-05-29)|
|From:||Christian Bau <firstname.lastname@example.org>|
|Date:||16 May 2003 21:57:39 -0400|
|Posted-Date:||16 May 2003 21:57:39 EDT|
Paul Davis <mdhe51ATdialDOTpipexDOTcom@eu.uu.net> wrote:
> I'm hoping to add constant expressions to a simple compiler I've
> written, but it looks like some of my early design decisions will make
> this difficult. I'd appreciate some ideas on better ways to do this.
> Currently, I've got various places, like declarations, where the
> syntax requires a constant. It wasn't obvious that expressions would
> be needed, but it now looks like I need them. For example:
> property A = 6; // this is what I've got
> property B = 2*3; // this is what I need
> My expression evaluator (in Bison) currently creates a set of stacks
> (the actual stack depends on context) which are later processed by an
> RPN calculator. So, when I get '2*3', I push 2 on the stack, followed
> by 3, followed by '*'. The expression doesn't get evaluated to '6'
> till a later time, which is effectively 'runtime' (this is a
> sort-of-interpreted language). My problem is therefore that the
> front-end compiler doesn't know that this is a constant expression,
> and so rejects it as an error because it's not a 'constant'. The Bison
> action code for expressions doesn't calculate the value of an
> expression: it simply pushes the elements of the expression onto the
> required stack.
Write a bit of code that tries to simplify stacks. For example, if your
stack looks like
+, <expr1>, <expr2>
then you check whether <expr1> is a constant and if not, then you try to
simplify it to a constant. If you succeed, then you know where <expr2>
is because now your stack looks like
+, constant, <expr2>
so you check whether <expr2> is a constant and if not you try to
simplify it to a constant. If that succeeds you have
+, constant1, constant2
and replace that with the constant (constant1 + constant2).
That code is invoked every time you require a constant, but you can use
it everywhere. Using trees instead of stacks makes many things easier.
Return to the
Search the comp.compilers archives again.