[armedbear-devel] Ideas about the integration of WITH-CODE-TO-METHOD

[Erik Huelsmann]

The other day, I started to write a mail about integrating the generic
class file generator into pass2 in more detail. The main idea being
that the macro WITH-CODE-TO-METHOD needed to be used to do the main
integration between the generator and pass2.

Although I still think the macro is the ticket, I'm refining my ideas
about where the macro belongs and why. I'll take some time to write
down here what I think the architectural separation between
jvm-class-file and pass2 should be.

My realization today was that the class file generator should really
be independent from whatever source the methods and their instructions
are coming from. The same should be true for the opcode-resolvers and
other parts.

Given the above, I think that concepts as 'current method', 'current
code attribute', 'current class file' etc, are really concepts of
pass2, not of the class file generator, which doesn't deal with
"catching code" itself.

As a consequence, I think the specials *code*,
*current-code-attribute*, *pool* and *this-class* as well as the
to-be-created specials *method* and *class-file* all belong to pass2
managing its submodules. When this is the role of pass2 and its
specials, the need to remove the pool-* methods (for example) from
pass2 would be less obvious.

What still remains is that the resolvers should be side-effect free,
meaning that they can't be used anymore to resolve their arguments
into pool methods/field references/etc. When this has happened, they
can be moved to their own file (or module if you will), but that's an
issue to be addressed later. They *can* be used to check instruction
arguments, as they are today.


Hmm. I hope the above makes sense, or at least provides some material
for further discussion.

Bye,

Erik.