Scheme_Object *scheme_make_class(char *name, Scheme_Object *sup, Scheme_Method_Prim *init, int num_methods)
Creates a new primitive class. If an intializer method init is provided, then objects of this class can be created from Scheme. The class sup specifies a superclass for the primitive class; it can be NULL to indicate object%. The num_methods argument must be an upper-bound on the actual number of methods to be installed with scheme_add_method_w_arity or scheme_add_method. Once all of the methods are installed, scheme_made_class must be called.
void scheme_add_method_w_arity(Scheme_Object *cl, char *name, Scheme_Method_Prim *f, short mina, short maxa)
Adds a primitive method to a primitive class. The form of the method f is defined by:
Scheme_Object *Scheme_Method_Prim(Scheme_Object *obj, int argc, Scheme_Object **argv);
void scheme_add_method(Scheme_Object *cl, char *name, Scheme_Method_Prim *f)
Like scheme_add_method_w_arity, but mina and maxa are defaulted to 0 and -1, respectively.
void scheme_made_class(Scheme_Object *cl)
Indicates that all of the methods have been added to the primitive class cl.
Scheme_Object *scheme_make_object(Scheme_Object *sclass, int argc, Scheme_Object **argv)
Creates an instance of the class sclass. The arguments to the object's intialization function are speicified by argc and argv.
Scheme_Object *scheme_make_uninited_object(Scheme_Object *sclass)
Creates a Scheme object instance of sclass without intitializing the object. This is useful for creating a Scheme representation of an existing primitive object.
Scheme_Object *scheme_find_ivar(Scheme_Object *obj, Scheme_Object *sym, int force)
Finds an instance variable by name (as a symbol). Returns NULL if the instance variable is not found. The force argument should be 1.
Scheme_Object *scheme_get_generic_data(Scheme_Object *class_or_intf, Scheme_Object *name)
Creates a Scheme value that contains the essential information of a generic procedure. This information can be applied to an object using scheme_apply_generic_data. If the named field is not found in the specified class, then the NULL pointer is returned.
Scheme_Object *scheme_apply_generic_data(Scheme_Object *gdata, Scheme_Object *sobj, int force)
Given the result of a call to scheme_get_generic_data, extracts a value from the specified Scheme object. If the object is not in the appropriate class, and error is raised.
If force is 0 and the instance variable in the object is implemented as a primitive method, then NULL is returned.
int scheme_is_subclass(Scheme_Object *sub, Scheme_Object *parent)
Returns 1 if the class sub is derived from the class parent, 0 otherwise.
int scheme_is_implementation(Scheme_Object *cl, Scheme_Object *intf)
Returns 1 if the class cl implements the interface intf, 0 otherwise.
int scheme_is_interface_extension(Scheme_Object *sub, Scheme_Object *intf)
Returns 1 if the interface sub is an extension of the interface intf, 0 otherwise.
int scheme_is_a(Scheme_Object *obj, Scheme_Object *sclass)
Returns 1 if obj is an instance of the class sclass or of a class derived from sclass, 0 otherwise.
char *scheme_get_class_name(Scheme_Object *sclass, int *len)
Returns the name of the class sclass if it has one, or NULL otherwise. If the return value is not NULL, *len is set to the length of the string.
struct Scheme_Class_Assembly *scheme_make_class_assembly( const char *name, int n_interface, int n_public, Scheme_Object **publics, int n_override, Scheme_Object **overrides, int n_inh, Scheme_Object **inherits, int n_ren, Scheme_Object **renames, int mina, int maxa, Scheme_Instance_Init_Proc *initproc)
``Compiles'' a class expression, given a name for the class (or NULL), the number of interfaces that will be declared as implemented by the class in n_interfaces, and names for public, override, inherit, and rename instance variables as symbols. The mina and maxa arguments specify the arity of the initialization procedure (i.e., the implicit lambda in a class expression that accepts initialization arguments). The initproc function has the following prototype:
typedef void (*Scheme_Instance_Init_Proc)(Scheme_Object **init_boxes, Scheme_Object **extract_boxes, Scheme_Object *super_init, int argc, Scheme_Object **argv, Scheme_Object *instance, void *data);
When an instance of the class is created, initproc will be called. The first two arguments are arrays of environment boxes (whose values are manipulated with SCHEME_ENVBOX_VAL). These arrays are in parallel: the first array is used for initializing variables from local expressions, and the second array is for looking up the value of a possibly-overridden instance variable. In both arrays, the public, override, inherit, and rename variables are ordered as provided in scheme_make_class_assembly (with public variables first, then override, then private), but init_boxes only contains boxes for public and override variables. The argc and argv arguments specify the values passed in as initialization arguments. The super_init argument is the procedure for initializing the superclass (use _scheme_apply to invoke it). The instance argument is the value of this. The data argument is supplied by the caller of scheme_create_class.
The result from scheme_make_class_assembly is used with scheme_create_class to create an actual class at run-time given the a run-time-determined superclass and interfaces.
Scheme_Object *scheme_create_class(struct Scheme_Class_Assembly *a, void *data, Scheme_Object *super, Scheme_Object **interfaces)
Returns a Scheme class value given the result of a call to scheme_make_class_assembly, a superclass, and an array of interface values. (The number of interfaces values must match the number of interfaces specified in the call to scheme_make_class_assembly.) Type-checking on the superclass and interface array is performed by scheme_create_class.
struct Scheme_Interface_Assembly *scheme_make_interface_assembly( const char *name, int n_supers, int n_names, Scheme_Object **names)
``Compiles'' an interface expression, given the interface's name (or NULL), the number of super interfaces that will be extended by the interface in n_supers, and names for instance variables as symbols.
The result from scheme_make_interface_assembly is used with scheme_create_interface to create an actual class at run-time given the run-time-determined superinterfaces.
Scheme_Object *scheme_create_interface(struct Scheme_Interface_Assembly *a, Scheme_Object **supers)
Returns a Scheme interface value given the result of a call to scheme_make_interface_assembly and an array of superinterface values. (The number of superinterfaces values must match the number of superinterfaces specified in the call to scheme_make_interface_assembly.) Type-checking on the superinterface array is performed by scheme_create_interface.