Node:Objects Glossary, Previous:Objects Implementation, Up:Objects


objects.fs Glossary

bind       ... "class" "selector" -- ...         objects       ``bind''
Execute the method for selector in class. 
<bind>       class selector-xt -- xt         objects       ``<bind>''
xt is the method for the selector selector-xt in class. 
bind'       "class" "selector" -- xt         objects       ``bind'''
xt is the method for selector in class. 
[bind]       compile-time: "class" "selector" -- ; run-time: ... object -- ...         objects       ``[bind]''
Compile the method for selector in class. 
class       parent-class -- align offset         objects       ``class''
Start a new class definition as a child of parent-class. align offset are for use by field etc. 
class->map       class -- map         objects       ``class->map''
map is the pointer to class's method map; it points to the place in the map to which the selector offsets refer (i.e., where object-maps point to). 
class-inst-size       class -- addr         objects       ``class-inst-size''
Give the size specification for an instance (i.e. an object) of class; used as class-inst-size 2 ( class -- align size ). 
class-override!       xt sel-xt class-map --         objects       ``class-override!''
xt is the new method for the selector sel-xt in class-map. 
class-previous       class --         objects       ``class-previous''
Drop class's wordlists from the search order. No checking is made whether class's wordlists are actually on the search order. 
class>order       class --         objects       ``class>order''
Add class's wordlists to the head of the search-order. 
construct       ... object --         objects       ``construct''
Initialize the data fields of object. The method for the class object just does nothing: ( object -- ). 
current'       "selector" -- xt         objects       ``current'''
xt is the method for selector in the current class. 
[current]       compile-time: "selector" -- ; run-time: ... object -- ...         objects       ``[current]''
Compile the method for selector in the current class. 
current-interface       -- addr         objects       ``current-interface''
Variable: contains the class or interface currently being defined. 
dict-new       ... class -- object         objects       ``dict-new''
allot and initialize an object of class class in the dictionary. 
end-class       align offset "name" --         objects       ``end-class''
name execution: -- class
End a class definition. The resulting class is class. 
end-class-noname       align offset -- class         objects       ``end-class-noname''
End a class definition. The resulting class is class. 
end-interface       "name" --         objects       ``end-interface''
name execution: -- interface
End an interface definition. The resulting interface is interface. 
end-interface-noname       -- interface         objects       ``end-interface-noname''
End an interface definition. The resulting interface is interface. 
end-methods       --         objects       ``end-methods''
Switch back from defining methods of a class to normal mode (currently this just restores the old search order). 
exitm       --         objects       ``exitm''
exit from a method; restore old this. 
heap-new       ... class -- object         objects       ``heap-new''
allocate and initialize an object of class class. 
implementation       interface --         objects       ``implementation''
The current class implements interface. I.e., you can use all selectors of the interface in the current class and its descendents. 
init-object       ... class object --         objects       ``init-object''
Initialize a chunk of memory (object) to an object of class class; then performs construct. 
inst-value       align1 offset1 "name" -- align2 offset2         objects       ``inst-value''
name execution: -- w
w is the value of the field name in this object. 
inst-var       align1 offset1 align size "name" -- align2 offset2         objects       ``inst-var''
name execution: -- addr
addr is the address of the field name in this object. 
interface       --         objects       ``interface''
Start an interface definition. 
m:       -- xt colon-sys; run-time: object --         objects       ``m:''
Start a method definition; object becomes new this. 
:m       "name" -- xt; run-time: object --         objects       ``:m''
Start a named method definition; object becomes new this. Has to be ended with ;m. 
;m       colon-sys --; run-time: --         objects       ``;m''
End a method definition; restore old this. 
method       xt "name" --         objects       ``method''
name execution: ... object -- ...
Create selector name and makes xt its method in the current class. 
methods       class --         objects       ``methods''
Makes class the current class. This is intended to be used for defining methods to override selectors; you cannot define new fields or selectors. 
object       -- class         objects       ``object''
the ancestor of all classes. 
overrides       xt "selector" --         objects       ``overrides''
replace default method for selector in the current class with xt. overrides must not be used during an interface definition. 
[parent]       compile-time: "selector" -- ; run-time: ... object -- ...         objects       ``[parent]''
Compile the method for selector in the parent of the current class. 
print       object --         objects       ``print''
Print the object. The method for the class object prints the address of the object and the address of its class. 
protected       --         objects       ``protected''
Set the compilation wordlist to the current class's wordlist 
public       --         objects       ``public''
Restore the compilation wordlist that was in effect before the last protected that actually changed the compilation wordlist. 
selector       "name" --         objects       ``selector''
name execution: ... object -- ...
Create selector name for the current class and its descendents; you can set a method for the selector in the current class with overrides. 
this       -- object         objects       ``this''
the receiving object of the current method (aka active object). 
<to-inst>       w xt --         objects       ``<to-inst>''
store w into the field xt in this object. 
[to-inst]       compile-time: "name" -- ; run-time: w --         objects       ``[to-inst]''
store w into field name in this object. 
to-this       object --         objects       ``to-this''
Set this (used internally, but useful when debugging). 
xt-new       ... class xt -- object         objects       ``xt-new''
Make a new object, using xt ( align size -- addr ) to get memory.