This collection of four functions is known as the ``hackware package'' in Maple.  These functions allow access to the internal representations of Maple objects and to the addresses pointing to them.

You should become familiar with the internal representation of Maple objects before using this collection of functions. For details, refer to the Appendix in the Maple Programming Guide.

Extreme care is required when using these functions, because their use can lead to various types of unrecoverable internal errors. Maple does some rudimentary checks of the objects created through these functions, but it is not possible to check everything.

The functions assemble and disassemble are a complementary pair of functions:

The first function, assemble, assembles an object identifier and a sequence of integer addresses into a Maple object and returns an integer addr that gives the address of the object.

The second function, disassemble, looks at the Maple object pointed to by the integer address addr, disassembles the object into its component parts, and returns the sequence of addresses of the component parts.

The object identifier objectid represents the type of the object, and can be expressed as an integer, or as a symbolic name. The valid object identifier names are:

The kernelopts function with option dagtag can be used to map among these symbolic names and the corresponding integer values.

The functions pointto and addressof are a complementary pair of functions:

The function pointto takes an integer address addr and returns the Maple expression to which it points.

The addressof function takes a Maple expression and returns the integer address that points to it.

An object whose only reference is through an addressof() reference could be collected by garbage collection. To avoid this, either make sure that all the objects for which you compute addressof() are assigned to variables, or delay garbage collection (see gc).

The assemble, disassemble, pointto and addressof commands are thread-safe as of Maple 15.

For more information on thread safety, see index/threadsafe.

$f≔3x^2+5.0$

$f≔3x^2+5.0$

$a≔\mathrm{addressof}\left(f\right)$

$a≔36893628046471161444$

$\mathrm{pointto}\left(a\right)$

$3x^2+5.0$

$d≔\mathrm{disassemble}\left(a\right)$

$d≔16,36893628046378768108,36893488147419103235,36893628046470314940,36893488147419103231$

$\mathrm{kernelopts}\left(\mathrm{dagtag}=d\left[1\right]\right)$

$\mathrm{SUM}$

$\mathrm{pointto}\left(d\left[2\right]\right)$

$x^2$

$\mathrm{pointto}\left(d\left[3\right]\right)$

$3$

$\mathrm{pointto}\left(d\left[4\right]\right)$

$5.0$

$\mathrm{pointto}\left(d\left[5\right]\right)$

$1$

$g≔\mathrm{assemble}\left(d\left[1\right]\,d\left[2\right]\,d\left[3\right]\right)$

$g≔36893628046368410644$

$\mathrm{pointto}\left(g\right)$

$3x^2$

$\mathrm{addressof}\left(g\right)$

$36893628046369203900$

$h≔y=\mathrm{diff}\left(x^2\,x\right)$

$h≔y=2x$

$b≔\mathrm{addressof}\left(h\right)$

$b≔36893628046368192164$

$j≔\mathrm{disassemble}\left(b\right)$

$j≔22,36893628046379112412,36893628046368192116$

$\mathrm{kernelopts}\left(\mathrm{dagtag}=j\left[1\right]\right)$

$\mathrm{EQUATION}$

$\mathrm{pointto}\left(j\left[2\right]\right)$

$y$

$\mathrm{pointto}\left(j\left[3\right]\right)$

$2x$

$n≔\mathrm{assemble}\left(\mathrm{INEQUAT}\,j\left[2\right]\,j\left[3\right]\right)$

$n≔36893628046367369420$

$\mathrm{pointto}\left(n\right)$

$y\ne 2x$