GNU Smalltalk Library Reference
GNU Smalltalk Library Reference
This document describes the class libraries that are distributed
together with the gnu Smalltalk programming language.
Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.2 or
any later version published by the Free Software Foundation; with no
Invariant Sections, with no Front-Cover Texts, and with no Back-Cover
Texts. A copy of the license is included in the section entitled
“GNU Free Documentation License”.
1 Base classes
Alphabetic list:
Classes documented in this manual are boldfaced.
Autoload
Object
Behavior
ClassDescription
Class
Metaclass
BlockClosure
Boolean
False
True
CFunctionDescriptor
CObject
CAggregate
CArray
CPtr
CString
CCompound
CStruct
VFS.CStatStruct
CUnion
CScalar
CChar
CDouble
CFloat
CInt
CLong
CLongDouble
CShort
CSmalltalk
CUChar
CByte
CBoolean
CUInt
CULong
CUShort
Collection
Bag
HashedCollection
Dictionary
BindingDictionary
AbstractNamespace
Namespace
RootNamespace
SystemDictionary
LookupTable
IdentityDictionary
MethodDictionary
WeakValueLookupTable
WeakValueIdentityDictionary
WeakKeyDictionary
WeakKeyIdentityDictionary
Set
IdentitySet
WeakSet
WeakIdentitySet
MappedCollection
SequenceableCollection
ArrayedCollection
Array
WeakArray
ByteArray
CharacterArray
String
Regex
Symbol
UnicodeString
CompiledCode
CompiledBlock
CompiledMethod
Interval
LargeArrayedCollection
LargeArray
LargeByteArray
LargeWordArray
WordArray
LinkedList
Semaphore
OrderedCollection
RunArray
SortedCollection
ContextPart
BlockContext
MethodContext
Continuation
CType
CPtrCType
CArrayCType
CScalarCType
CStringCType
Delay
DLD
DumperProxy
AlternativeObjectProxy
NullProxy
VersionableObjectProxy
PluggableProxy
SingletonProxy
File
Directory
FileSegment
Getopt
Kernel.PackageInfo
Package
Kernel.TrappableEvent
ExceptionSet
Link
Process
CallinProcess
SymLink
Magnitude
Character
UnicodeCharacter
Date
DateTime
LookupKey
Association
HomedAssociation
VariableBinding
DeferredVariableBinding
Number
Float
FloatD
FloatE
FloatQ
Fraction
Integer
LargeInteger
LargeNegativeInteger
LargePositiveInteger
LargeZeroInteger
SmallInteger
ScaledDecimal
Time
Duration
Memory
Message
DirectedMessage
MethodInfo
NetClients.URIResolver
NetClients.URL
ObjectMemory
PackageLoader
Permission
Point
ProcessorScheduler
Rectangle
RecursionLock
RegexResults
SecurityPolicy
SharedQueue
Signal
Exception
Error
Halt
ArithmeticError
ZeroDivide
MessageNotUnderstood
SystemExceptions.InvalidValue
SystemExceptions.EmptyCollection
SystemExceptions.InvalidArgument
SystemExceptions.AlreadyDefined
SystemExceptions.ArgumentOutOfRange
SystemExceptions.IndexOutOfRange
SystemExceptions.InvalidSize
SystemExceptions.NotFound
SystemExceptions.PackageNotAvailable
SystemExceptions.InvalidProcessState
SystemExceptions.NotIndexable
SystemExceptions.ProcessTerminated
SystemExceptions.ReadOnlyObject
SystemExceptions.WrongClass
SystemExceptions.MustBeBoolean
SystemExceptions.MutationError
SystemExceptions.NotEnoughElements
SystemExceptions.NotImplemented
SystemExceptions.NotYetImplemented
SystemExceptions.ShouldNotImplement
SystemExceptions.SubclassResponsibility
SystemExceptions.WrongMessageSent
SystemExceptions.VMError
SystemExceptions.BadReturn
SystemExceptions.NoRunnableProcess
SystemExceptions.PrimitiveFailed
SystemExceptions.CInterfaceError
SystemExceptions.FileError
SystemExceptions.WrongArgumentCount
SystemExceptions.SecurityError
SystemExceptions.UserInterrupt
SystemExceptions.VerificationError
Notification
SystemExceptions.EndOfStream
SystemExceptions.ProcessBeingTerminated
Warning
Stream
Generator
ObjectDumper
PositionableStream
ReadStream
WriteStream
ReadWriteStream
ByteStream
FileDescriptor
FileStream
Random
TextCollector
UndefinedObject
ValueAdaptor
NullValueHolder
PluggableAdaptor
DelayedAdaptor
ValueHolder
Promise
VFS.VFSHandler
VFS.ArchiveMemberHandler
VFS.TmpFileArchiveMemberHandler
VFS.FileHandlerWrapper
VFS.ArchiveFileHandler
VFS.DecodedFileHandler
VFS.RealFileHandler
1.1 AbstractNamespace
- Defined in namespace Smalltalk
- Superclass: BindingDictionary
- Category: Language-Implementation
- I am a special form of dictionary. Classes hold on
an instance of me; it is called their `environment'.
1.1.1 AbstractNamespace class: instance creation
- new
- Disabled - use #new to create instances
- primNew: parent name: spaceName
- Private - Create a new namespace with the given name and parent, and
add to the parent a key that references it.
1.1.2 AbstractNamespace: accessing
- allAssociations
- Answer a Dictionary with all of the associations in the receiver
and each of its superspaces (duplicate keys are associated to the
associations that are deeper in the namespace hierarchy)
- allBehaviorsDo: aBlock
- Evaluate aBlock once for each class and metaclass in the namespace.
- allClassObjectsDo: aBlock
- Evaluate aBlock once for each class and metaclass in the namespace.
- allClassesDo: aBlock
- Evaluate aBlock once for each class in the namespace.
- allMetaclassesDo: aBlock
- Evaluate aBlock once for each metaclass in the namespace.
- classAt: aKey
- Answer the value corrisponding to aKey if it is a class. Fail
if either aKey is not found or it is associated to something different
from a class.
- classAt: aKey ifAbsent: aBlock
- Answer the value corrisponding to aKey if it is a class. Evaluate
aBlock and answer its result if either aKey is not found or it is
associated to something different from a class.
1.1.3 AbstractNamespace: basic & copying
- = arg
- Answer whether the receiver is equal to arg. The equality test is
by default the same as that for equal objects. = must not fail;
answer false if the receiver cannot be compared to arg
- hash
- Answer an hash value for the receiver. This is the same as the
object's #identityHash.
1.1.4 AbstractNamespace: copying
- copyEmpty: newSize
- Answer an empty copy of the receiver whose size is newSize
- whileCurrentDo: aBlock
- Evaluate aBlock with the current namespace set to the receiver.
Answer the result of the evaluation.
1.1.5 AbstractNamespace: namespace hierarchy
- addSubspace: aSymbol
- Create a namespace named aSymbol, add it to the receiver's
subspaces, and answer it.
- allSubassociationsDo: aBlock
- Invokes aBlock once for every association in each of the receiver's
subspaces.
- allSubspaces
- Answer the direct and indirect subspaces of the receiver in a Set
- allSubspacesDo: aBlock
- Invokes aBlock for all subspaces, both direct and indirect.
- allSuperspaces
- Answer all the receiver's superspaces in a collection
- allSuperspacesDo: aBlock
- Evaluate aBlock once for each of the receiver's superspaces
- includesClassNamed: aString
- Answer whether the receiver or any of its superspaces include the
given class – note that this method (unlike #includesKey:) does not
require aString to be interned and (unlike #includesGlobalNamed:) only
returns true if the global is a class object.
- includesGlobalNamed: aString
- Answer whether the receiver or any of its superspaces include the
given key – note that this method (unlike #includesKey:) does not
require aString to be interned but (unlike #includesClassNamed:)
returns true even if the global is not a class object.
- inheritsFrom: aNamespace
- Answer whether aNamespace is one of the receiver's direct and
indirect superspaces
- removeSubspace: aSymbol
- Remove my subspace named aSymbol from the hierarchy.
- selectSubspaces: aBlock
- Return a Set of subspaces of the receiver satisfying aBlock.
- selectSuperspaces: aBlock
- Return a Set of superspaces of the receiver satisfying aBlock.
- siblings
- Answer all the other children of the same namespace as the receiver.
- siblingsDo: aBlock
- Evaluate aBlock once for each of the other root namespaces,
passing the namespace as a parameter.
- subspaces
- Answer the receiver's direct subspaces
- subspacesDo: aBlock
- Invokes aBlock for all direct subspaces.
- superspace
- Answer the receiver's superspace.
- superspace: aNamespace
- Set the superspace of the receiver to be 'aNamespace'. Also
adds the receiver as a subspace of it.
- withAllSubspaces
- Answer a Set containing the receiver together with its direct and
indirect subspaces
- withAllSubspacesDo: aBlock
- Invokes aBlock for the receiver and all subclasses, both direct
and indirect.
- withAllSuperspaces
- Answer the receiver and all of its superspaces in a collection
- withAllSuperspacesDo: aBlock
- Invokes aBlock for the receiver and all superspaces, both direct
and indirect.
1.1.6 AbstractNamespace: overrides for superspaces
- definedKeys
- Answer a kind of Set containing the keys of the receiver
- definesKey: key
- Answer whether the receiver defines the given key. `Defines'
means that the receiver's superspaces, if any, are not considered.
- hereAt: key
- Return the value associated to the variable named as specified
by `key' *in this namespace*. If the key is not found search will
*not* be carried on in superspaces and the method will fail.
- hereAt: key ifAbsent: aBlock
- Return the value associated to the variable named as specified
by `key' *in this namespace*. If the key is not found search will
*not* be carried on in superspaces and aBlock will be immediately
evaluated.
- inheritedKeys
- Answer a Set of all the keys in the receiver and its superspaces
- set: key to: newValue
- Assign newValue to the variable named as specified by `key'.
This method won't define a new variable; instead if the key
is not found it will search in superspaces and raising an
error if the variable cannot be found in any of the superspaces.
Answer newValue.
- set: key to: newValue ifAbsent: aBlock
- Assign newValue to the variable named as specified by `key'.
This method won't define a new variable; instead if the key
is not found it will search in superspaces and evaluate
aBlock if it is not found. Answer newValue.
- values
- Answer a Bag containing the values of the receiver
1.1.7 AbstractNamespace: printing
- name
- Answer the receiver's name
- name: aSymbol
- Change the receiver's name to aSymbol
- nameIn: aNamespace
- Answer Smalltalk code compiling to the receiver when the current
namespace is aNamespace
- printOn: aStream
- Print a representation of the receiver
- storeOn: aStream
- Store Smalltalk code compiling to the receiver
1.1.8 AbstractNamespace: testing
- isNamespace
- Answer `true'.
- isSmalltalk
- Answer `false'.
1.2 AlternativeObjectProxy
- Defined in namespace Smalltalk
- Superclass: DumperProxy
- Category: Streams-Files
- I am a proxy that uses the same ObjectDumper
to store an object which is not the object to be dumped, but from which the
dumped object can be reconstructed. I am an abstract class, using me would
result in infinite loops because by default I try to store the same object
again and again. See the method comments for more information
1.2.1 AlternativeObjectProxy class: instance creation
- acceptUsageForClass: aClass
- The receiver was asked to be used as a proxy for the class aClass.
Answer whether the registration is fine. By default, answer true
except if AlternativeObjectProxy itself is being used.
- on: anObject
- Answer a proxy to be used to save anObject. IMPORTANT: this method
MUST be overridden so that the overridden version sends #on: to super
passing an object that is NOT the same as anObject (alternatively,
you can override #dumpTo:, which is what NullProxy does), because that
would result in an infinite loop! This also means that
AlternativeObjectProxy must never be used directly – only as
a superclass.
1.2.2 AlternativeObjectProxy: accessing
- object
- Reconstruct the object stored in the proxy and answer it. A
subclass will usually override this
- object: theObject
- Set the object to be dumped to theObject. This should not be
overridden.
- primObject
- Reconstruct the object stored in the proxy and answer it. This
method must not be overridden
1.3 ArithmeticError
- Defined in namespace Smalltalk
- Superclass: Halt
- Category: Language-Exceptions
- An ArithmeticError exception is raised by numeric classes when a program
tries to do something wrong, such as extracting the square root of a
negative number.
1.3.1 ArithmeticError: description
- description
- Answer a textual description of the exception.
1.4 Array
- Defined in namespace Smalltalk
- Superclass: ArrayedCollection
- Category: Collections-Sequenceable
- My instances are objects that have array-like properties: they are directly
indexable by integers starting at 1, and they are fixed in size. I inherit
object creation behavior messages such as #with:, as well as iteration
and general access behavior from SequenceableCollection.
1.4.1 Array class: instance creation
- from: anArray
- Answer anArray, which is expected to be an array specified with a
brace-syntax expression per my inherited protocol.
1.4.2 Array: mutating objects
- multiBecome: anArray
- Transform every object in the receiver in each corresponding
object in anArray. anArray and the receiver must have the same
size
1.4.3 Array: printing
- isLiteralObject
- Answer whether the receiver is expressible as a Smalltalk literal.
- printOn: aStream
- Print a representation for the receiver on aStream
- storeLiteralOn: aStream
- Store a Smalltalk literal compiling to the receiver on aStream
- storeOn: aStream
- Store Smalltalk code compiling to the receiver on aStream
1.4.4 Array: testing
- isArray
- Answer `true'.
1.5 ArrayedCollection
- Defined in namespace Smalltalk
- Superclass: SequenceableCollection
- Category: Collections-Sequenceable
- My instances are objects that are generally fixed size, and are accessed
by an integer index. The ordering of my instance's elements is determined
externally; I will not rearrange the order of the elements.
1.5.1 ArrayedCollection class: instance creation
- join: aCollection
- Where aCollection is a collection of SequenceableCollections,
answer a new instance with all the elements therein, in order.
- join: aCollection separatedBy: sepCollection
- Where aCollection is a collection of SequenceableCollections,
answer a new instance with all the elements therein, in order,
each separated by an occurrence of sepCollection.
- new: size withAll: anObject
- Answer a collection with the given size, whose elements are all set to
anObject
- streamContents: aBlock
- Create a ReadWriteStream on an empty instance of the receiver;
pass the stream to aBlock, then retrieve its contents and
answer them.
- with: element1
- Answer a collection whose only element is element1
- with: element1 with: element2
- Answer a collection whose only elements are the parameters in the order
they were passed
- with: element1 with: element2 with: element3
- Answer a collection whose only elements are the parameters in the order
they were passed
- with: element1 with: element2 with: element3 with: element4
- Answer a collection whose only elements are the parameters in the order
they were passed
- with: element1 with: element2 with: element3 with: element4 with: element5
- Answer a collection whose only elements are the parameters in the order
they were passed
- withAll: aCollection
- Answer a collection whose elements are the same as those in aCollection
1.5.2 ArrayedCollection: basic
- , aSequenceableCollection
- Answer a new instance of an ArrayedCollection containing all the elements
in the receiver, followed by all the elements in aSequenceableCollection
- add: value
- This method should not be called for instances of this class.
- atAll: keyCollection
- Answer a collection of the same kind returned by #collect:, that
only includes the values at the given indices. Fail if any of
the values in keyCollection is out of bounds for the receiver.
- copyFrom: start to: stop
- Answer a new collection containing all the items in the receiver from the
start-th and to the stop-th
- copyWith: anElement
- Answer a new instance of an ArrayedCollection containing all the elements
in the receiver, followed by the single item anElement
- copyWithout: oldElement
- Answer a copy of the receiver to which all occurrences of oldElement are
removed
1.5.3 ArrayedCollection: built ins
- size
- Answer the size of the receiver
1.5.4 ArrayedCollection: copying Collections
- copyReplaceAll: oldSubCollection with: newSubCollection
- Answer a new collection in which all the sequences matching
oldSubCollection are replaced with newSubCollection
- copyReplaceFrom: start to: stop with: replacementCollection
- Answer a new collection of the same class as the receiver that contains the
same elements as the receiver, in the same order, except for elements from
index `start' to index `stop'.
If start < stop, these are replaced by the contents of the
replacementCollection. Instead, If start = (stop + 1), like in
`copyReplaceFrom: 4 to: 3 with: anArray', then every element of the receiver
will be present in the answered copy; the operation will be an append if
stop is equal to the size of the receiver or, if it is not, an insert before
index `start'.
- copyReplaceFrom: start to: stop withObject: anObject
- Answer a new collection of the same class as the receiver that contains the
same elements as the receiver, in the same order, except for elements from
index `start' to index `stop'.
If start < stop, these are replaced by stop-start+1 copies of anObject.
Instead, If start = (stop + 1), then every element of the receiver
will be present in the answered copy; the operation will be an append if
stop is equal to the size of the receiver or, if it is not, an insert before
index `start'.
- reverse
- Answer the receivers' contents in reverse order
1.5.5 ArrayedCollection: enumerating the elements of a collection
- collect: aBlock
- Answer a new instance of an ArrayedCollection containing all the results
of evaluating aBlock passing each of the receiver's elements
- reject: aBlock
- Answer a new instance of an ArrayedCollection containing all the elements
in the receiver which, when passed to aBlock, answer false
- select: aBlock
- Answer a new instance of an ArrayedCollection containing all the elements
in the receiver which, when passed to aBlock, answer true
- with: aSequenceableCollection collect: aBlock
- Evaluate aBlock for each pair of elements took respectively from the re-
ceiver and from aSequenceableCollection; answer a collection of the same
kind of the receiver, made with the block's return values. Fail if the
receiver has not the same size as aSequenceableCollection.
1.5.6 ArrayedCollection: storing
- storeOn: aStream
- Store Smalltalk code compiling to the receiver on aStream
1.5.7 ArrayedCollection: streams
- writeStream
- Answer a WriteStream streaming on the receiver
1.6 Association
- Defined in namespace Smalltalk
- Superclass: LookupKey
- Category: Language-Data types
- My instances represent a mapping between two objects. Typically, my
"key" object is a symbol, but I don't require this. My "value" object has
no conventions associated with it; it can be any object at all.
1.6.1 Association class: basic
- key: aKey value: aValue
- Answer a new association with the given key and value
1.6.2 Association: accessing
- environment
- Answer nil. This is present to achieve polymorphism with
instances of VariableBinding.
- environment: aNamespace
- Do nothing. This is present to achieve polymorphism with
instances of VariableBinding.
- key: aKey value: aValue
- Set the association's key to aKey, and its value to aValue
- value
- Answer the association's value
- value: aValue
- Set the association's value to aValue
1.6.3 Association: finalization
- mourn
- Finalize the receiver
1.6.4 Association: printing
- printOn: aStream
- Put on aStream a representation of the receiver
1.6.5 Association: storing
- storeOn: aStream
- Put on aStream some Smalltalk code compiling to the receiver
1.6.6 Association: testing
- = anAssociation
- Answer whether the association's key and value are the same as
anAssociation's, or false if anAssociation is not an Association.
As a special case, identical values are considered equal even if
#= returns false (as is the case for NaN floating-point values).
- hash
- Answer an hash value for the receiver
1.7 Autoload
- Defined in namespace Smalltalk
- Superclass: none
- Category: Examples-Useful tools
- I am not a part of the normal Smalltalk kernel class system. I provide the
ability to do late ("on-demand") loading of class definitions. Through me,
you can define any class to be loaded when any message is sent to
the class itself (such as to create an instance) or to its metaclass (such
as #methodsFor: to extend it with class-side methods).
1.7.1 Autoload class: instance creation
- class: nameSymbol from: fileNameString
- Make Smalltalk automatically load the class named nameSymbol
from fileNameString when needed
- class: nameSymbol in: aNamespace from: fileNameString
- Make Smalltalk automatically load the class named nameSymbol
and residing in aNamespace from fileNameString when needed
1.7.2 Autoload: accessing
- class
- We need it to access the metaclass instance, because that's what
will load the file.
- doesNotUnderstand: aMessage
- Load the class and resend the message to it
1.8 Bag
- Defined in namespace Smalltalk
- Superclass: Collection
- Category: Collections-Unordered
- My instances are unordered collections of objects. You can think
of me as a set with a memory; that is, if the same object is added to me
twice, then I will report that that element has been stored twice.
1.8.1 Bag class: basic
- new
- Answer a new instance of the receiver
- new: size
- Answer a new instance of the receiver, with space for size distinct
objects
1.8.2 Bag: adding
- add: newObject
- Add an occurrence of newObject to the receiver. Answer newObject.
Fail if newObject is nil.
- add: newObject withOccurrences: anInteger
- If anInteger > 0, add anInteger occurrences of newObject to the
receiver. If anInteger < 0, remove them. Answer newObject. Fail
if newObject is nil.
1.8.3 Bag: enumerating the elements of a collection
- asSet
- Answer a set with the elements of the receiver
- do: aBlock
- Evaluate the block for all members in the collection.
1.8.4 Bag: extracting items
- sortedByCount
- Answer a collection of counts with elements, sorted by decreasing count.
1.8.5 Bag: printing
- printOn: aStream
- Put on aStream a representation of the receiver
1.8.6 Bag: removing
- remove: oldObject ifAbsent: anExceptionBlock
- Remove oldObject from the collection and return it. If can't be
found, answer instead the result of evaluationg anExceptionBlock
1.8.7 Bag: storing
- storeOn: aStream
- Put on aStream some Smalltalk code compiling to the receiver
1.8.8 Bag: testing collections
- = aBag
- Answer whether the receiver and aBag contain the same objects
- hash
- Answer an hash value for the receiver
- includes: anObject
- Answer whether we include anObject
- occurrencesOf: anObject
- Answer the number of occurrences of anObject found in the receiver
- size
- Answer the total number of objects found in the receiver
1.9 Behavior
- Defined in namespace Smalltalk
- Superclass: Object
- Category: Language-Implementation
- I am the parent class of all "class" type methods. My instances know
about the subclass/superclass relationships between classes, contain
the description that instances are created from, and hold the method
dictionary that's associated with each class. I provide methods for
compiling methods, modifying the class inheritance hierarchy, examining the
method dictionary, and iterating over the class hierarchy.
1.9.1 Behavior: accessing class hierarchy
- allSubclasses
- Answer the direct and indirect subclasses of the receiver in a Set
- allSuperclasses
- Answer all the receiver's superclasses in a collection
- subclasses
- Answer the direct subclasses of the receiver in a Set
- superclass
- Answer the receiver's superclass (if any, otherwise answer nil)
- withAllSubclasses
- Answer a Set containing the receiver together with its direct and
indirect subclasses
- withAllSuperclasses
- Answer the receiver and all of its superclasses in a collection
1.9.2 Behavior: accessing instances and variables
- allClassVarNames
- Return all the class variables understood by the receiver
- allInstVarNames
- Answer the names of every instance variables the receiver contained in the
receiver's instances
- allInstances
- Returns a set of all instances of the receiver
- allSharedPools
- Return the names of the shared pools defined by the class and any of
its superclasses
- classPool
- Answer the class pool dictionary. Since Behavior does not support
classes with class variables, we answer an empty one; adding
variables to it results in an error.
- classVarNames
- Answer all the class variables for instances of the receiver
- instVarNames
- Answer an Array containing the instance variables defined by the receiver
- instanceCount
- Return a count of all the instances of the receiver
- sharedPools
- Return the names of the shared pools defined by the class
- subclassInstVarNames
- Answer the names of the instance variables the receiver inherited from its
superclass
1.9.3 Behavior: accessing the methodDictionary
- >> selector
- Return the compiled method associated with selector, from the local
method dictionary. Error if not found.
- allSelectors
- Answer a Set of all the selectors understood by the receiver
- compiledMethodAt: selector
- Return the compiled method associated with selector, from the local
method dictionary. Error if not found.
- compiledMethodAt: selector ifAbsent: aBlock
- Return the compiled method associated with selector, from the local
method dictionary. Evaluate aBlock if not found.
- lookupSelector: aSelector
- Return the compiled method associated with selector, from the local
method dictionary or one of a superclass; return nil if not found.
- parseTreeFor: selector
- Answer the parse tree for the given selector, or nil if there was an
error. Requires the Parser package to be loaded.
- selectorAt: method
- Return selector for the given CompiledMethod
- selectors
- Answer a Set of the receiver's selectors
- sourceCodeAt: selector
- Answer source code (if available) for the given selector.
- sourceMethodAt: selector
- This is too dependent on the original implementation
1.9.4 Behavior: built ins
- basicNewInFixedSpace
- Create a new instance of a class with no indexed instance variables.
The instance is guaranteed not to move across garbage collections.
Like #basicNew, this method should not be overridden.
- basicNewInFixedSpace: numInstanceVariables
- Create a new instance of a class with indexed instance variables. The
instance has numInstanceVariables indexed instance variables. The
instance is guaranteed not to move across garbage collections. Like
#basicNew:, this method should not be overridden.
- flushCache
- Invalidate the method cache kept by the virtual machine. This
message should not need to be called by user programs.
- methodsFor: category ifTrue: condition
- Compile the following code inside the receiver, with the given
category, if condition is true; else ignore it
- primCompile: code
- Compile the code, a string or readable stream, with no
category. Fail if the code does not obey Smalltalk syntax. Answer
the generated CompiledMethod if it does.
Do not send this in user code; use #compile: or related methods
instead.
- primCompile: code ifError: aBlock
- As with #primCompile:, but evaluate aBlock (passing the file
name, line number and description of the error) if the code does
not obey Smalltalk syntax.
Do not send this in user code; use #compile:ifError: or related
methods instead.
- someInstance
- Private - Answer the first instance of the receiver in the object
table
1.9.5 Behavior: builtin
- basicNew
- Create a new instance of a class with no indexed instance variables;
this method must not be overridden.
- basicNew: numInstanceVariables
- Create a new instance of a class with indexed instance variables. The
instance has numInstanceVariables indexed instance variables;
this method must not be overridden.
- new
- Create a new instance of a class with no indexed instance variables
- new: numInstanceVariables
- Create a new instance of a class with indexed instance variables. The
instance has numInstanceVariables indexed instance variables.
1.9.6 Behavior: compilation (alternative)
- methods
- Don't use this, it's only present to file in from Smalltalk/V
- methodsFor
- Don't use this, it's only present to file in from Dolphin Smalltalk
- methodsFor: category ifFeatures: features
- Start compiling methods in the receiver if this implementation of
Smalltalk has the given features, else skip the section
- methodsFor: category stamp: notUsed
- Don't use this, it's only present to file in from Squeak
- privateMethods
- Don't use this, it's only present to file in from IBM Smalltalk
- publicMethods
- Don't use this, it's only present to file in from IBM Smalltalk
1.9.7 Behavior: compiling methods
- methodsFor: aCategoryString
- Calling this method prepares the parser to receive methods to be compiled and installed in the receiver's method dictionary. The methods are put in the category identified by the parameter.
1.9.8 Behavior: creating a class hierarchy
- addSubclass: aClass
- Add aClass asone of the receiver's subclasses.
- removeSubclass: aClass
- Remove aClass from the list of the receiver's subclasses
- superclass: aClass
- Set the receiver's superclass.
1.9.9 Behavior: enumerating
- allInstancesDo: aBlock
- Invokes aBlock for all instances of the receiver
- allSubclassesDo: aBlock
- Invokes aBlock for all subclasses, both direct and indirect.
- allSubinstancesDo: aBlock
- Invokes aBlock for all instances of each of the receiver's subclasses.
- allSuperclassesDo: aBlock
- Invokes aBlock for all superclasses, both direct and indirect.
- selectSubclasses: aBlock
- Return a Set of subclasses of the receiver satisfying aBlock.
- selectSuperclasses: aBlock
- Return a Set of superclasses of the receiver satisfying aBlock.
- subclassesDo: aBlock
- Invokes aBlock for all direct subclasses.
- withAllSubclassesDo: aBlock
- Invokes aBlock for the receiver and all subclasses, both direct
and indirect.
- withAllSuperclassesDo: aBlock
- Invokes aBlock for the receiver and all superclasses, both direct
and indirect.
1.9.10 Behavior: evaluating
- evalString: aString to: anObject
- Answer the stack top at the end of the evaluation of the code in
aString. The code is executed as part of anObject
- evalString: aString to: anObject ifError: aBlock
- Answer the stack top at the end of the evaluation of the code in
aString. If aString cannot be parsed, evaluate aBlock (see
compile:ifError:). The code is executed as part of anObject
- evaluate: code
- Evaluate Smalltalk expression in 'code' and return result.
- evaluate: code ifError: block
- Evaluate 'code'. If a parsing error is detected, invoke 'block'
- evaluate: code notifying: requestor
- Evaluate Smalltalk expression in 'code'. If a parsing error is encountered,
send #error: to requestor
- evaluate: code to: anObject
- Evaluate Smalltalk expression as part of anObject's method definition
- evaluate: code to: anObject ifError: block
- Evaluate Smalltalk expression as part of anObject's method definition. This
method is used to support Inspector expression evaluation. If a parsing error
is encountered, invoke error block, 'block'
1.9.11 Behavior: instance creation
- newInFixedSpace
- Create a new instance of a class without indexed instance variables.
The instance is guaranteed not to move across garbage collections.
If a subclass overrides #new, the changes will apply to this method too.
- newInFixedSpace: numInstanceVariables
- Create a new instance of a class with indexed instance variables. The
instance has numInstanceVariables indexed instance variables. The
instance is guaranteed not to move across garbage collections. If
a subclass overrides #new:, the changes will apply to this method too.
1.9.12 Behavior: instance variables
- addInstVarName: aString
- Add the given instance variable to instance of the receiver
- instanceVariableNames: instVarNames
- Set the instance variables for the receiver to be those
in instVarNames
- removeInstVarName: aString
- Remove the given instance variable from the receiver and recompile
all of the receiver's subclasses
1.9.13 Behavior: method dictionary
- addSelector: selector withMethod: compiledMethod
- Add the given compiledMethod to the method dictionary, giving it
the passed selector. Answer compiledMethod
- compile: code
- Compile method source. If there are parsing errors, answer nil.
Else, return a CompiledMethod result of compilation
- compile: code ifError: block
- Compile method source. If there are parsing errors, invoke
exception block, 'block' passing file name, line number and
error. Return a CompiledMethod result of compilation
to
- compile: code notifying: requestor
- Compile method source. If there are parsing errors, send #error:
to the requestor object, else return a CompiledMethod result of
compilation
- compileAll
- Recompile all selectors in the receiver. Ignore errors.
- compileAll: aNotifier
- Recompile all selectors in the receiver. Notify aNotifier by sen-
ding #error: messages if something goes wrong.
- compileAllSubclasses
- Recompile all selector of all subclasses. Notify aNotifier by sen-
ding #error: messages if something goes wrong.
- compileAllSubclasses: aNotifier
- Recompile all selector of all subclasses. Notify aNotifier by sen-
ding #error: messages if something goes wrong.
- createGetMethod: what
- Create a method accessing the variable `what'.
- createGetMethod: what default: value
- Create a method accessing the variable `what', with a default value
of `value', using lazy initialization
- createSetMethod: what
- Create a method which sets the variable `what'.
- decompile: selector
- Decompile the bytecodes for the given selector.
- defineAsyncCFunc: cFuncNameString withSelectorArgs: selectorAndArgs args: argsArray
- Please lookup the part on the C interface in the manual. This method
is deprecated, you should use the asyncCCall:args: attribute.
- defineCFunc: cFuncNameString withSelectorArgs: selectorAndArgs returning: returnTypeSymbol args: argsArray
- Please lookup the part on the C interface in the manual. This method
is deprecated, you should use the cCall:returning:args: attribute.
- edit: selector
- Open Emacs to edit the method with the passed selector, then compile it
- methodDictionary
- Answer the receiver's method dictionary. Don't modify the method
dictionary unless you exactly know what you're doing
- methodDictionary: aDictionary
- Set the receiver's method dictionary to aDictionary
- recompile: selector
- Recompile the given selector, answer nil if something goes wrong or
the new CompiledMethod if everything's ok.
to
- recompile: selector notifying: aNotifier
- Recompile the given selector. If there are parsing errors, send #error:
to the aNotifier object, else return a CompiledMethod result of
compilation
- removeSelector: selector
- Remove the given selector from the method dictionary, answer
the CompiledMethod attached to that selector
- removeSelector: selector ifAbsent: aBlock
- Remove the given selector from the method dictionary, answer
the CompiledMethod attached to that selector. If the selector cannot
be found, answer the result of evaluating aBlock.
- selectorsAndMethodsDo: aBlock
- Evaluate aBlock, passing for each evaluation a selector that's
defined in the receiver and the corresponding method.
1.9.14 Behavior: parsing class declarations
- parseInstanceVariableString: variableString
- Not commented.
- parseVariableString: aString
- Not commented.
1.9.15 Behavior: pluggable behavior (not yet implemented)
- compilerClass
- Answer the class that can be used to compile parse trees,
or nil if there is none (as is the case now). Not
used for methods if parserClass answers nil, and for
doits if evaluatorClass answers nil.
- debuggerClass
- Answer which class is to be used to debug a chain of contexts which
includes the receiver. nil means 'do not debug'; other classes are
sent #debuggingPriority and the one with the highest priority is
picked.
- decompilerClass
- Answer the class that can be used to decompile methods,
or nil if there is none (as is the case now).
- evaluatorClass
- Answer the class that can be used to evaluate doits,
or nil if there is none (as is the case now).
- parserClass
- Answer the class that can be used to parse methods,
or nil if there is none (as is the case now).
1.9.16 Behavior: printing hierarchy
- hierarchyIndent
- Answer the indent to be used by #printHierarchy - 4 by default
- printHierarchy
- Print my entire subclass hierarchy on the terminal.
- printSubclasses: level using: aBlock
- I print my name, and then all my subclasses, each indented according
to its position in the hierarchy. I pass aBlock a class name and a level
1.9.17 Behavior: still unclassified
- parseNodeAt: selector
- Not commented.
- updateInstanceVars: variableArray shape: shape
- Update instance variables and instance spec of the class and all
its subclasses. variableArray lists the new variables, including
inherited ones.
1.9.18 Behavior: support for lightweight classes
- article
- Answer an article (`a' or `an') which is ok for the receiver's name
- asClass
- Answer the first superclass that is a full-fledged Class object
- environment
- Answer the namespace that this class belongs to - the same as the
superclass, since Behavior does not support namespaces yet.
- name
- Answer the class name; this prints to the name of the superclass
enclosed in braces. This class name is used, for example, to print
the receiver.
- nameIn: aNamespace
- Answer the class name when the class is referenced from aNamespace
- a dummy one, since Behavior does not support names.
- printOn: aStream in: aNamespace
- Answer the class name when the class is referenced from aNamespace
- a dummy one, since Behavior does not support names.
- securityPolicy
- Not commented.
- securityPolicy: aSecurityPolicy
- This method should not be called for instances of this class.
1.9.19 Behavior: testing functionality
- isBehavior
- Answer `true'.
1.9.20 Behavior: testing the class hierarchy
- includesBehavior: aClass
- Returns true if aClass is the receiver or a superclass of the receiver.
- inheritsFrom: aClass
- Returns true if aClass is a superclass of the receiver
- kindOfSubclass
- Return a string indicating the type of class the receiver is
- shape
- Not commented.
#ushort
- shape: shape
- Give the provided shape to the receiver's instances.
The shape can be nil, or one of #byte #int8 #character #short #word
#ushort #int #uint #int64 #uint64 #utf32 #float #double or #pointer.
In addition, the special value #inherit means to use the shape of the
superclass; note however that this is a static setting, and subclasses
that used #inherit are not mutated when the superclass adopts a different
shape.
- shapes
- Not commented.
1.9.21 Behavior: testing the form of the instances
- instSize
- Answer how many fixed instance variables are reserved to each of the
receiver's instances
- isBits
- Not commented.
- isFixed
- Answer whether the receiver's instances have no indexed
instance variables
- isIdentity
- Answer whether x = y implies x == y for instances of the receiver
- isImmediate
- Answer whether, if x is an instance of the receiver, x copy == x
- isPointers
- Answer whether the instance variables of the receiver's instances
are objects
- isVariable
- Answer whether the receiver's instances have indexed instance variables
1.9.22 Behavior: testing the method dictionary
- canUnderstand: selector
- Returns true if the instances of the receiver understand
the given selector
- hasMethods
- Return whether the receiver has any methods defined
- includesSelector: selector
- Returns true if the local method dictionary contains the given selector
- scopeHas: name ifTrue: aBlock
- If methods understood by the receiver's instances have access to a
symbol named 'name', evaluate aBlock
- whichClassIncludesSelector: selector
- Answer which class in the receiver's hierarchy contains the implementation
of selector used by instances of the class (nil if none does)
- whichSelectorsAccess: instVarName
- Answer a Set of selectors which access the given instance variable
- whichSelectorsAssign: instVarName
- Answer a Set of selectors which read the given instance variable
- whichSelectorsRead: instVarName
- Answer a Set of selectors which read the given instance variable
- whichSelectorsReferTo: anObject
- Returns a Set of selectors that refer to anObject
- whichSelectorsReferToByteCode: aByteCode
- Return the collection of selectors in the class which
reference the byte code, aByteCode
1.10 BindingDictionary
- Defined in namespace Smalltalk
- Superclass: Dictionary
- Category: Language-Implementation
- I am a special form of dictionary that provides special ways to access my
keys, which typically begin with an uppercase letter; also, my associations
are actually VariableBinding instances.
My keys are (expected to be) symbols, so I use == to match searched keys
to those in the dictionary – this is done expecting that it brings a bit
more speed.
1.10.1 BindingDictionary: accessing
- define: aSymbol
- Define aSymbol as equal to nil inside the receiver. Fail if such
a variable already exists (use #at:put: if you don't want to fail)
- doesNotUnderstand: aMessage
- Try to map unary selectors to read accesses to the Namespace,
and one-argument keyword selectors to write accesses.
Note that: a) this works only if the selector has an
uppercase first letter; and b) `aNamespace Variable: value' is
the same as `aNamespace set: #Variable to: value', not the same as
`aNamespace at: #Variable put: value' — the latter always
refers to the current namespace, while the former won't
define a new variable, instead searching in superspaces (and
raising an error if the variable cannot be found).
- environment
- Answer the environment to which the receiver is connected. This
can be the class for a dictionary that holds class variables,
or the super-namespace. In general it is used to compute the
receiver's name.
- environment: anObject
- Set the environment to which the receiver is connected. This
can be the class for a dictionary that holds class variables,
or the super-namespace. In general it is used to compute the
receiver's name.
- import: aSymbol from: aNamespace
- Add to the receiver the symbol aSymbol, associated to the
same value as in aNamespace. Fail if aNamespace does not
contain the given key.
- name
- Answer the receiver's name, which by default is the same as the
name of the receiver's environment.
- nameIn: aNamespace
- Answer the receiver's name when referred to from aNamespace; by
default the computation is deferred to the receiver's environment.
1.10.2 BindingDictionary: copying
- copy
- Answer the receiver.
- copyEmpty: newSize
- Answer an empty copy of the receiver whose size is newSize
- copyEmptyForCollect
- Answer an empty copy of the receiver which is filled in to
compute the result of #collect:
- copyEmptyForCollect: size
- Answer an empty copy of the receiver which is filled in to
compute the result of #collect:
- deepCopy
- Answer the receiver.
- shallowCopy
- Answer the receiver.
1.10.3 BindingDictionary: forward declarations
- at: key put: value
- Store value as associated to the given key. If any, recycle Associations
temporarily stored by the compiler inside the `Undeclared' dictionary.
1.10.4 BindingDictionary: printing
- printOn: aStream in: aNamespace
- Print the receiver's name when referred to from aNamespace; by
default the computation is deferred to the receiver's environment.
1.10.5 BindingDictionary: testing
- species
- Answer `IdentityDictionary'.
1.11 BlockClosure
- Defined in namespace Smalltalk
- Superclass: Object
- Category: Language-Implementation
- I am a factotum class. My instances represent Smalltalk blocks, portions
of executeable code that have access to the environment that they were
declared in, take parameters, and can be passed around as objects to be
executed by methods outside the current class.
Block closures are sent a message to compute their value and create a new
execution context; this property can be used in the construction of
control flow methods. They also provide some methods that are used in the
creation of Processes from blocks.
1.11.1 BlockClosure class: instance creation
- block: aCompiledBlock
- Answer a BlockClosure that activates the passed CompiledBlock.
- block: aCompiledBlock receiver: anObject
- Answer a BlockClosure that activates the passed CompiledBlock
with the given receiver.
- block: aCompiledBlock receiver: anObject outerContext: aContext
- Answer a BlockClosure that activates the passed CompiledBlock
with the given receiver.
- exceptionHandlerResetBlock
- Not commented.
- exceptionHandlerSearchBlock
- Not commented.
- numArgs: args numTemps: temps bytecodes: bytecodes depth: depth literals: literalArray
- Answer a BlockClosure for a new CompiledBlock that is created using
the passed parameters. To make it work, you must put the BlockClosure
into a CompiledMethod's literals.
1.11.2 BlockClosure class: testing
- isImmediate
- Answer whether, if x is an instance of the receiver, x copy == x
1.11.3 BlockClosure: accessing
- argumentCount
- Answer the number of arguments passed to the receiver
- block
- Answer the CompiledBlock which contains the receiver's bytecodes
- block: aCompiledBlock
- Set the CompiledBlock which contains the receiver's bytecodes
- finalIP
- Answer the last instruction that can be executed by the receiver
- fixTemps
- This should fix the values of the temporary variables used in the
block that are ordinarily shared with the method in which the block
is defined. Not defined yet, but it is not harmful that it isn't.
Answer the receiver.
- initialIP
- Answer the initial instruction pointer into the receiver.
- method
- Answer the CompiledMethod in which the receiver lies
- numArgs
- Answer the number of arguments passed to the receiver
- numTemps
- Answer the number of temporary variables used by the receiver
- outerContext
- Answer the method/block context which is the immediate outer of
the receiver
- outerContext: containingContext
- Set the method/block context which is the immediate outer of
the receiver
- receiver
- Answer the object that is used as `self' when executing the receiver
(if nil, it might mean that the receiver is not valid though...)
- receiver: anObject
- Set the object that is used as `self' when executing the receiver
- stackDepth
- Answer the number of stack slots needed for the receiver
1.11.4 BlockClosure: built ins
- value
- Evaluate the receiver passing no parameters
- value: arg1
- Evaluate the receiver passing arg1 as the only parameter
- value: arg1 value: arg2
- Evaluate the receiver passing arg1 and arg2 as the parameters
- value: arg1 value: arg2 value: arg3
- Evaluate the receiver passing arg1, arg2 and arg3 as the parameters
- valueWithArguments: argumentsArray
- Evaluate the receiver passing argArray's elements as the parameters
1.11.5 BlockClosure: control structures
- repeat
- Evaluate the receiver 'forever' (actually until a return is executed
or the process is terminated).
- whileFalse
- Evaluate the receiver until it returns true
- whileFalse: aBlock
- Evaluate the receiver. If it returns false, evaluate aBlock and re-
start
- whileTrue
- Evaluate the receiver until it returns false
- whileTrue: aBlock
- Evaluate the receiver. If it returns true, evaluate aBlock and re-
s