[Hugs-users] Hugs Extension Proposed: Introspection Patch (p. 1)

[Dimitry Golubovsky]

This message has been split into two because of 5 kb message size 
limitations.

Dear list members,

I am suggesting one more extension to Hugs: a set of introspection
primitives. These primitives extend the existing Hugs.Internals module
allowing a Haskell program see the internal structure of Hugs'
compilation results.

This may be used for various purposes such as externalization of Hugs'
compilation results in some format and using them with alternative
runtime. With the primitives proposed, such an externalization may be
performed by a Haskell program, and the native part of Hugs does not
need to be modified. Also Hugs may be further extended to be able to
load precompiled functions/modules thus increasing the startup speed.

URL of the diff file:

http://www.golubovsky.org/software/hugs-insider/hugs98-intro.diff

I have been working on these extensions since June 2004, and the diff
file is against the July 11 CVS snapshot, but as I can see from
cvs-hugs, there have not been any significant updates in the repository
that might conflict with this patch.

These extensions work only if enabled with --enable-internal-prims
configure options.

Here is the summary of what has been done so far.

Internals.hs: added primitives to access almost all fields of Hugs'
storage objects (classes, instances, tycons, etc.) Also some upper-level
wrappers are provided to represent Hugs internal structures in a more
convenient way. I followed the same pattern which was used for the Name
type already present in Hugs.Internals. I extended the CellKind type
definition adding more data constructors to represent not only Names,
but also classes, instances, type expressions, etc. I added the whatIs
primitive which does not require an IO monad (unlike classifyCell), but
it operates with restricted set of cell kinds which I suppose do not
vary over time, therefore IO monad is not needed. whatIs also does not
have side effects because it never evaluates the cell whose kind it
retrieves. I also fixed the Haskell representation of bytecode
instructions (it looks like some Gofer stuff still was there) and added
the DIGIT bytecode (same as CELL, used for BIGNUMs because I needed to
distinguish between numbers that may go with the CELL instruction, and
numbers that make up big integers). I improved the representation of the
TABLE instruction: now it captures the names of tycon's variants. The
FLOAT instruction was removed as it seems to no longer exist in Hugs.
The TEST instruction now has a Cell as its operand rather than a Name
(which is not sufficient to cover all the variants of TEST). Data types
representing Module, Class, Instance, Tycon are made in the same way as
the data type for Name - "opaque integers". Also  toplevel functions
were added providing convenient representation of Hugs' storage contents
and improved printer for bytecodes.

I added some fields to Hugs storage objects, including name.endCode
which caused changes in the prototype and implementation of codeGen.

(to be continued)