d2c API Reference

The number of bits in a byte.

<integer>

The number of bits in a byte. This is used for documentation in various byte-twiddling operations.

Word boundary for pointers

<object> — really false-or(<integer>)

This variable is initially <false>, and is set by the method seed-representations.

The size of a pointer.

<object> — really false-or(<integer>)

This variable is initially false, and set by seed-representations.

Boundaries based on size of C short ints.

<object> — really false-or(<integer>)

This variable is initially false, and set by seed-representations.

The size in bytes of a C short int.

<object> — really false-or(<integer>)

This variable is initially false, and set by seed-representations.

Natural boundaries for C ints.

<object> — really false-or(<integer>)

This variable is initially false, and set by seed-representations.

The size in bytes of a C int.

<object> — really false-or(<integer>)

This variable is initially false, and set by seed-representations.

Natural boundaries for C longs.

<object> — really false-or(<integer>)

This variable is initially false, and set by seed-representations.

The size in bytes of a C long integer

<object> — really false-or(<integer>)

This variable is initially false, and set by seed-representations.

Boundary for C single-precision floats.

<object> — really false-or(<integer>)

This variable is initially false, and set by seed-representations.

The size in bytes of a C float.

<object> — really false-or(<integer>)

This variable is initially false, and set by seed-representations.

Boundary for C double-precision floats.

<object> — really false-or(<integer>)

This variable is initially false, and set by seed-representations.

Size in bytes of C double-precision floats.

<object> — really false-or(<integer>)

This variable is initially false, and set by seed-representations.

Boundary for C long double floats.

<object> — really false-or(<integer>)

This variable is initially false, and set by seed-representations.

Size in bytes of C long double floats.

<object> — really false-or(<integer>)

This variable is initially false, and set by seed-representations.

Bytes of largest one-word data element

<object> — really false-or(<integer>)

that fits in one word — the max of *long-size* and *pointer-size*. This variable is initially false, and is set by seed-representations.

The abstract supertype of C representations.

<representation> <identity-preserving-mixin>

name:

An instance of false-or(<symbol>).

more-general:

An instance of false-or(<representation>).

to-more-general:

An instance of type-union(<byte-string>, one-of(#t, #f)).

from-more-general:

An instance of type-union(<byte-string>, one-of(#t, #f)).

alignment:

An instance of <integer>. This keyword is required.

size:

An instance of <integer>. This keyword is required.

c-type:

An instance of <string>. This keyword is required.

This class is the abstract superclass of all C representations. There should be more description here, but I'm not sure what.

Returns true if the representation can support bottom.

res	An instance of <representation>.

result

An instance of <boolean>.

This method returns true if the representation class can support a bottom value. (Eg, the immediate form for integers can't, but the full heap representation can.) I'm not sure if bottom is meant in the denotational sense or just as an imprecise shorthand for "this value is not defined."

The default method in the generic

res	An instance of <representation>.

result

An instance of <boolean>.

The default method returns #t.

Writes a string to a stream.

rep	An instance of <c-representation>.

stream

An instance of <stream>.

None

Prints the fields of rep to stream.

<c-representation>

to-more-general:

An instance of type-union(<byte-string>, one-of(#t, #f)).

from-more-general:

An instance of type-union(<byte-string>, one-of(#t, #f)).

A subclass of <c-representation> that represents arbitrary objects of unknown type..

<c-representation>

None

A subclass of <c-representation> representing heap-allocated objects. I'm not sure how this differs from <general-representation> objects.

I think it might be useful in a case when an object needs to be heap allocated, but the type is known and doesn't necessarily need the full object representation — eg, to represent <pair>s with two words of RAM. I won't know for certain, though, until I learn more about d2c.

Representation of "unboxed" values, I think.

<c-representation>

None

I believe this class represents unboxed values that may be larger than one machine word.

Objects that can fit in one C word.

<immediate-representation> <data-word-representation<

class:

An instance of <cclass>. This argument is required.

data-word-member:

An instance of <byte-string>. This argument is required.

This class represents objects whose layout can fit into a single word of memory.

A module variable possibly defining the C representation for general variables.

false-or(<c-representation>)

This variable is set by seed-representations and is dependent on the value of *current-target* — more when I learn more. It's referenced in the cback a lot, but never mutated AFAICT.

Same as *general-rep*, only for heap objects.

false-or(<c-representation>)

This variable is set by seed-representations and is dependent on the value of *current-target*.

Presumably, the representation of boolean values.

false-or(<c-representation>)

This variable is set by seed-representations and is dependent on the value of *current-target*.

The representation of integers fitting a C long.

false-or(<c-representation>)

This variable is set by seed-representations and is dependent on the value of *current-target*.

The representation of integers that fit in a C int.

false-or(<c-representation>)

This variable is set by seed-representations and is dependent on the value of *current-target*.

The representation of integers that fit in a C unsigned int.

false-or(<c-representation>)

This variable is set by seed-representations and is dependent on the value of *current-target*.

The representation of integers that fit in a C short.

false-or(<c-representation>)

This variable is set by seed-representations and is dependent on the value of *current-target*.

The representation of integers that fit in a C unsigned short.

false-or(<c-representation>)

This variable is set by seed-representations and is dependent on the value of *current-target*.

The representation of Dylan ™ objects that fit in a C char.

false-or(<c-representation>)

This type is meant for Dylan ™ objects that can be stuffed into one byte. Usually it will be used for limited(<integer>) types.

This variable is set by seed-representations and is dependent on the value of *current-target*.

The representation of Dylan ™ objects that fit in a C unsigned char.

This type is meant for Dylan ™ objects that can be stuffed into a C short, especially limited(<integer>) objects with min: and max: in the appropriate range.

This variable is set by seed-representations and is dependent on the value of *current-target*.

The C representation for <single-float> numbers.

false-or(<c-representation>)

This variable is set by seed-representations and is dependent on the value of *current-target*.

The C representation for <double-float>.

false-or(<c-representation>)

This variable is set by seed-representations and is dependent on the value of *current-target*.

The C representation for <extended-float>.

false-or

This variable is set by seed-representations and is dependent on the value of *current-target*.

This method sets all the nice globals described above.

None

None

This method will look up *current-target* and try to set all the alignment- and representation-related global variables in this module. It is used to set the following variables:

*pointer-alignment*

*pointer-size*

*short-alignment*

*short-size*

*int-alignment*

*int-size*

*long-alignment*

*long-size*

*single-alignment*

*single-size*

*double-alignment*

*double-size*

*long-double-alignment*

*long-double-size*

*data-word-size*

*general-rep*

*heap-rep*

*boolean-rep*

*long-rep*

*int-rep*

*uint-rep*

*short-rep*

*ushort-rep*

*byte-rep*

*ubyte-rep*

*ptr-rep*

*float-rep*

*double-rep*

*long-double-rep*

Unknown.

<list>

As far as I can tell, this is a dead/obsolete binding. There do not seem to be *any* references to this variable anywhere in the c-representation module, and it is not exported from the module. It's just dead code, which should be removed.

Compute the representations for a compile-time class.

class

An instance of <cclass>.

None

This method computes the representations of class by mutating the slots direct-speed-representation and direct-space-representation of the class parameter.

Compute a <c-data-word-representation> for a <cclass>.

class

An instance of <cclass>.

data-word-type

An instance of <ctype>.

None

Computes a representation for class consistent with data-word-type. This method mutates the slots direct-speed-representation and direct-speed-representation of class.

Compute a <general-representation> for a <cclass>.

class

An instance of <cclass>.

None

This method sets the slots direct-speed-representation and direct-speed-representation of class to *general-rep*.

Pick a representation for a compile-time class.

class

An instance of <cclass>.

optimize-for

An instance of one-of(#"speed", #"space").

rep	An instance of <c-representation>.

Based on the value of optimize-for, pick-representation will set either of the general-speed-representation or general-space-representation slots of class. It uses general-representation to select a representation.

Returns a representation for a compile-time class.

class

An instance of <cclass>.

optimize-for

An instance of one-of(#"speed", #"space").

rep	An instance of <c-representation>.

This method returns a general representation for a compile-time class. It does not mutate any of its arguments.

type	An instance of <direct-instance-type>.

optimize-for

An instance of one-of(#"speed", #"space").

rep	An instance of <c-representation>.

This specialized method returns the direct representation of its type argument. It may mutate the slots direct-speed-representation and direct-space-representation of the object. type.base-class.

Return the representation of the compile-time class.

class

An instance of <cclass>.

optimize-for

An instance of one-of(#"speed", #"space").

rep	An instance of <c-representation>.

This method returns either the direct-speed-representation or direct-space-representation slots of class; if they are unassigned it will set those slots and then return the appropriate value.

Return the representation of the compile-time class.

type	An instance of <limited-ctype>.

optimize-for

An instance of one-of(#"speed", #"space").

rep	An instance of <c-representation>.

This method reinvokes pick-representation on type.base-class, and returns that slot's direct-speed-representation or direct-space-representation; if they are unassigned it may set those slots and then return the appropriate value.

The representation of byte characters.

<object> — really false-or(<c-data-word-representation>)

The representation type of <byte-character>s.

Returns the representation of <byte-character-ctype>

type	An instance of <byte-character-ctype>.

optimize-for

An instance of one-of(#"speed", #"space").

rep	An instance of <c-representation>.

This method returns *byte-char-rep*, first setting it if it is #f.

Returns the representation of compile-time integer types.

type	An instance of <limited-integer-ctype>.

optimize-for

An instance of one-of(#"speed", #"space").

rep	An instance of <c-representation>.

Returns the appropriate representation for limited integer types. Does not mutate any slots.

Returns a representation of union types.

type	An instance of <union-ctype>.

optimize-for

An instance of one-of(#"speed", #"space").

rep	An instance of <c-representation>.

This function merges all the representations in the members slot of type, to return the least general representation that can hold all possible legal values.

This method may modify the direct-{foo}-representation slots of the root types of the type-union tree.

Returns the minimal type that can contain any value in either of its arguments.

rep1	An instance of <c-representation>.

rep2	An instance of <c-representation>.

res	An instance of <c-representation>.

This method returns a new representation that is more general than either of its arguments. It modifies neither of its arguments.

Returns a representation for a type not known at compile time.

type	An instance of <unknown-ctype>.

optimize-for

An instance of one-of(#"speed", #"space").

rep	An instance of <c-representation>.

This method mutates none of its arguments.

Pretty-print error messages.

stream

An instance of <stream>.

string

An instance of <byte-string>.

args	An instance of <object>.

None

Used for error message printing. Turns each space in the control string into a conditional newline, and turns literal newlines into a mandatory newline and 2 space indent.

A method that uses pretty-format.

stream

An instance of <stream>.

control-string

An instance of <byte-string>.

args	An instance of <object>.

None

This method prints error messages using pretty-format. It works by shadowing the condition-format method defined on (<stream>, <string>).

Print an object's classname to a stream.

thing

An instance of <object>.

stream

An instance of <object>.

None

This print's thing's object-class's name to the stream. If the class is anonymous, the default representation of classes is printed to the stream. (This should never happen until d2c learns how to make anonymous classes.)

Prints the address of an object

thing

An instance of <object>.

stream

An instance of <object>.

None

Prints the hexadecimal address of object to the stream stream.

Used to print an object and its fields

thing

An instance of <object>.

stream

An instance of <object>.

fields

An instance of <object>. Plist of fieldnames and values.

None

This method is a tool used to print the constituents of an object. The #rest argument is a list of symbols alternating with values — the symbols are used as the field names for the values.

Vector of English names for numbers.

<vector>

This vector contains the names that are prefixed by numbers less than a hundred — "thousand", "million", etc. It is used in the method integer-to-english.

Vector of the English tens units.

<vector>

This vector contains the names of multiples of ten — "twenty", "thirty", etc. It is used in the method integer-to-english.

Vector of English words for 0 to 20.

<vector>

This vector contains strings naming the integers from 0 to 20. It is used in the method integer-to-english .

Like $thousand-cardinals, except to name positions.

<vector>

This vector lists the ordinals for numbers bigger than 1000 — "millionth", "billionth" and so on. It is used in the method integer-to-english.

Like $ten-cardinals, except to name positions.

<vector>

This vector lists the ordinals for small integers from 0 to 20 — "zeroth", "first", etc. It is used in the method integer-to-english.

Convert an integer to an English string.

int	An instance of <integer>.

as:	An instance of one-of(#"cardinal", #"ordinal").

res	An instance of <byte-string>.

This method converts an <integer> object into the English string for the number it represents. If the keyword as: is set to #"ordinal", then the English string is the name of the n-th position; otherwise it is just the name of the number.