Constant expression evaluation?

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.


This is my first compiler, and I've got no idea how this would
normally be done. Some things I could try are:


1) Add a second expression syntax section in the Bison description
for constant expressions, which get evaluated during compilation. This
sounds really kludgey, and I suspect would lead to lots of conflicts.


2) Add a dedicated stack for expression evaluation. This gets loaded
as normal during compilation, but the expression action code would
also attempt to evaluate the stack. If it's all constant, it returns
that constant; otherwise, it copies the stack elsewhere for run-time
processing.


Any better ideas? Thanks.


Paul

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