This is gst-base.info, produced by makeinfo version 4.5 from
/tmp/a/ports/lang/smalltalk/work/smalltalk-2.1.2/doc/gst-base-fixed.texi.

INFO-DIR-SECTION GNU Smalltalk
START-INFO-DIR-ENTRY
* Base classes: (gst-base).             The GNU Smalltalk base classes.
END-INFO-DIR-ENTRY

This file documents GNU Smalltalk Version 2.1.2.  It was last updated
on 9 May 2003.

   Copyright (C) 1988-92, 1994-95, 1999-2001 Free Software Foundation,
Inc.

   This document is released under the terms of the GNU Free
Documentation License as published by the Free Software Foundation;
either version 1.1, or (at your option) any later version.

   You should have received a copy of the GNU Free Documentation
License along with GNU Smalltalk; see the file `COPYING.DOC'.  If not,
write to the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.

   There are no Cover Texts and no Invariant Sections; this text, along
with its equivalent in the printed manual, constitutes the Title Page.

File: gst-base.info,  Node: Top,  Up: (DIR)



   This document describes the class libraries that are distributed
together with the GNU Smalltalk programming language.

This file documents GNU Smalltalk Version 2.1.2.  It was last updated
on 9 May 2003.

   Copyright (C) 1988-92, 1994-95, 1999-2001 Free Software Foundation,
Inc.

   This document is released under the terms of the GNU Free
Documentation License as published by the Free Software Foundation;
either version 1.1, or (at your option) any later version.

   You should have received a copy of the GNU Free Documentation
License along with GNU Smalltalk; see the file `COPYING.DOC'.  If not,
write to the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.

   There are no Cover Texts and no Invariant Sections; this text, along
with its equivalent in the printed manual, constitutes the Title Page.
* Menu:

* Base classes::        The class reference

* Class index::         Index to the classes in the class reference
* Method index::        Index to the method selectors in the class reference
* Cross-reference::     Cross-reference between selectors


File: gst-base.info,  Node: Base classes,  Next: Class index,  Prev: Top,  Up: Top

Base classes
************

* Menu:


Alphabetic list:
* AbstractNamespace::
* AlternativeObjectProxy::
* ArithmeticError::
* Array::
* ArrayedCollection::
* Association::
* Autoload::
* AutoloadClass::
* Bag::
* Behavior::
* BindingDictionary::
* BlockClosure::
* BlockContext::
* Boolean::
* ByteArray::
* ByteStream::
* CAggregate::
* CallinProcess::
* CArray::
* CArrayCType::
* CBoolean::
* CByte::
* CChar::
* CCompound::
* CDouble::
* CFloat::
* CFunctionDescriptor::
* Character::
* CharacterArray::
* CInt::
* Class::
* ClassDescription::
* CLong::
* CObject::
* Collection::
* CompiledBlock::
* CompiledCode::
* CompiledMethod::
* ContextPart::
* CoreException::
* CPtr::
* CPtrCType::
* CScalar::
* CScalarCType::
* CShort::
* CSmalltalk::
* CString::
* CStringCType::
* CStruct::
* CType::
* CUChar::
* CUInt::
* CULong::
* CUnion::
* CUShort::
* Date::
* DateTime::
* Delay::
* DelayedAdaptor::
* Dictionary::
* DirectedMessage::
* Directory::
* DLD::
* DumperProxy::
* Duration::
* Error::
* Exception::
* ExceptionSet::
* False::
* File::
* FileDescriptor::
* FileSegment::
* FileStream::
* Float::
* FloatD::
* FloatE::
* FloatQ::
* Fraction::
* Halt::
* HashedCollection::
* HomedAssociation::
* IdentityDictionary::
* IdentitySet::
* Integer::
* Interval::
* LargeArray::
* LargeArrayedCollection::
* LargeArraySubpart::
* LargeByteArray::
* LargeInteger::
* LargeNegativeInteger::
* LargePositiveInteger::
* LargeWordArray::
* LargeZeroInteger::
* Link::
* LinkedList::
* LookupKey::
* LookupTable::
* Magnitude::
* MappedCollection::
* Memory::
* Message::
* MessageNotUnderstood::
* Metaclass::
* MethodContext::
* MethodDictionary::
* MethodInfo::
* Namespace::
* NetClients.URIResolver::
* NetClients.URL::
* Notification::
* NullProxy::
* NullValueHolder::
* Number::
* Object::
* ObjectDumper::
* ObjectMemory::
* OrderedCollection::
* Package::
* PackageLoader::
* PluggableAdaptor::
* PluggableProxy::
* Point::
* PositionableStream::
* Process::
* ProcessorScheduler::
* Promise::
* Random::
* ReadStream::
* ReadWriteStream::
* Rectangle::
* RecursionLock::
* RootNamespace::
* RunArray::
* ScaledDecimal::
* Semaphore::
* SequenceableCollection::
* Set::
* SharedQueue::
* Signal::
* SingletonProxy::
* SmallInteger::
* SortedCollection::
* Stream::
* String::
* Symbol::
* SymLink::
* SystemDictionary::
* SystemExceptions.AlreadyDefined::
* SystemExceptions.ArgumentOutOfRange::
* SystemExceptions.BadReturn::
* SystemExceptions.CInterfaceError::
* SystemExceptions.EmptyCollection::
* SystemExceptions.EndOfStream::
* SystemExceptions.FileError::
* SystemExceptions.IndexOutOfRange::
* SystemExceptions.InvalidArgument::
* SystemExceptions.InvalidProcessState::
* SystemExceptions.InvalidSize::
* SystemExceptions.InvalidValue::
* SystemExceptions.MustBeBoolean::
* SystemExceptions.MutationError::
* SystemExceptions.NoRunnableProcess::
* SystemExceptions.NotFound::
* SystemExceptions.NotImplemented::
* SystemExceptions.NotIndexable::
* SystemExceptions.NotYetImplemented::
* SystemExceptions.PrimitiveFailed::
* SystemExceptions.ProcessBeingTerminated::
* SystemExceptions.ProcessTerminated::
* SystemExceptions.ReadOnlyObject::
* SystemExceptions.ShouldNotImplement::
* SystemExceptions.SubclassResponsibility::
* SystemExceptions.UserInterrupt::
* SystemExceptions.VMError::
* SystemExceptions.WrongArgumentCount::
* SystemExceptions.WrongClass::
* SystemExceptions.WrongMessageSent::
* TextCollector::
* Time::
* TokenStream::
* TrappableEvent::
* True::
* UndefinedObject::
* ValueAdaptor::
* ValueHolder::
* VariableBinding::
* VersionableObjectProxy::
* VFS.ArchiveFileHandler::
* VFS.ArchiveMemberHandler::
* VFS.DecodedFileHandler::
* VFS.ExternalArchiveFileHandler::
* VFS.RealFileHandler::
* VFS.VFSHandler::
* Warning::
* WeakArray::
* WeakIdentitySet::
* WeakKeyDictionary::
* WeakKeyIdentityDictionary::
* WeakSet::
* WeakValueIdentityDictionary::
* WeakValueLookupTable::
* WordArray::
* WriteStream::
* ZeroDivide::


Class tree:
* Autoload::
* AutoloadClass::
* Object::
*   Behavior::
*     ClassDescription::
*       Class::
*       Metaclass::
*   BlockClosure::
*   Boolean::
*     False::
*     True::
*   CFunctionDescriptor::
*   CObject::
*     CAggregate::
*       CArray::
*       CPtr::
*         CString::
*     CCompound::
*       CStruct::
*       CUnion::
*     CScalar::
*       CChar::
*       CDouble::
*       CFloat::
*       CInt::
*       CLong::
*       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::
*             Symbol::
*         CompiledCode::
*           CompiledBlock::
*           CompiledMethod::
*         Interval::
*         LargeArrayedCollection::
*           LargeArray::
*           LargeByteArray::
*           LargeWordArray::
*         WordArray::
*       LinkedList::
*         Semaphore::
*       OrderedCollection::
*         RunArray::
*         SortedCollection::
*   ContextPart::
*     BlockContext::
*     MethodContext::
*   CType::
*     CPtrCType::
*       CArrayCType::
*     CScalarCType::
*       CStringCType::
*   Delay::
*   DLD::
*   DumperProxy::
*     AlternativeObjectProxy::
*       NullProxy::
*         VersionableObjectProxy::
*       PluggableProxy::
*       SingletonProxy::
*   File::
*     Directory::
*   FileSegment::
*   Link::
*     Process::
*       CallinProcess::
*     SymLink::
*   Magnitude::
*     Character::
*     Date::
*       DateTime::
*     LargeArraySubpart::
*     LookupKey::
*       Association::
*         HomedAssociation::
*           VariableBinding::
*     Number::
*       Float::
*         FloatD::
*         FloatE::
*         FloatQ::
*       Fraction::
*       Integer::
*         LargeInteger::
*           LargeNegativeInteger::
*           LargePositiveInteger::
*             LargeZeroInteger::
*         SmallInteger::
*       ScaledDecimal::
*     Time::
*       Duration::
*   Memory::
*   Message::
*     DirectedMessage::
*   MethodInfo::
*   NetClients.URIResolver::
*   NetClients.URL::
*   ObjectMemory::
*   Package::
*   PackageLoader::
*   Point::
*   ProcessorScheduler::
*   Rectangle::
*   RecursionLock::
*   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.InvalidProcessState::
*           SystemExceptions.MustBeBoolean::
*           SystemExceptions.NotIndexable::
*           SystemExceptions.ProcessTerminated::
*           SystemExceptions.ReadOnlyObject::
*           SystemExceptions.WrongClass::
*         SystemExceptions.MutationError::
*         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.UserInterrupt::
*       Notification::
*         SystemExceptions.EndOfStream::
*         SystemExceptions.ProcessBeingTerminated::
*         Warning::
*   Stream::
*     ObjectDumper::
*     PositionableStream::
*       ReadStream::
*       WriteStream::
*         ReadWriteStream::
*           ByteStream::
*             FileDescriptor::
*               FileStream::
*     Random::
*     TextCollector::
*     TokenStream::
*   TrappableEvent::
*     CoreException::
*     ExceptionSet::
*   UndefinedObject::
*   ValueAdaptor::
*     NullValueHolder::
*     PluggableAdaptor::
*       DelayedAdaptor::
*     ValueHolder::
*       Promise::
*   VFS.VFSHandler::
*     VFS.ArchiveMemberHandler::
*     VFS.RealFileHandler::
*       VFS.ArchiveFileHandler::
*         VFS.ExternalArchiveFileHandler::
*       VFS.DecodedFileHandler::


File: gst-base.info,  Node: AbstractNamespace,  Next: AlternativeObjectProxy,  Up: Base classes

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'.

* Menu:

* AbstractNamespace class-instance creation::  (class)
* AbstractNamespace-accessing::  (instance)
* AbstractNamespace-basic & copying::  (instance)
* AbstractNamespace-copying::  (instance)
* AbstractNamespace-namespace hierarchy::  (instance)
* AbstractNamespace-overrides for superspaces::  (instance)
* AbstractNamespace-printing::  (instance)
* AbstractNamespace-testing::  (instance)


File: gst-base.info,  Node: AbstractNamespace class-instance creation,  Next: AbstractNamespace-accessing,  Up: AbstractNamespace

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.



File: gst-base.info,  Node: AbstractNamespace-accessing,  Next: AbstractNamespace-basic & copying,  Prev: AbstractNamespace class-instance creation,  Up: AbstractNamespace

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.

allClassesDo: aBlock
     Evaluate aBlock once for each class in the namespace.

allClassObjectsDo: aBlock
     Evaluate aBlock once for each class and metaclass 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.



File: gst-base.info,  Node: AbstractNamespace-basic & copying,  Next: AbstractNamespace-copying,  Prev: AbstractNamespace-accessing,  Up: AbstractNamespace

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.



File: gst-base.info,  Node: AbstractNamespace-copying,  Next: AbstractNamespace-namespace hierarchy,  Prev: AbstractNamespace-basic & copying,  Up: AbstractNamespace

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.



File: gst-base.info,  Node: AbstractNamespace-namespace hierarchy,  Next: AbstractNamespace-overrides for superspaces,  Prev: AbstractNamespace-copying,  Up: AbstractNamespace

AbstractNamespace: namespace hierarchy
--------------------------------------

addSubspace: aSymbol
     Add aNamespace to the set of the receiver's subspaces

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

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.



File: gst-base.info,  Node: AbstractNamespace-overrides for superspaces,  Next: AbstractNamespace-printing,  Prev: AbstractNamespace-namespace hierarchy,  Up: AbstractNamespace

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



File: gst-base.info,  Node: AbstractNamespace-printing,  Next: AbstractNamespace-testing,  Prev: AbstractNamespace-overrides for superspaces,  Up: AbstractNamespace

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



File: gst-base.info,  Node: AbstractNamespace-testing,  Prev: AbstractNamespace-printing,  Up: AbstractNamespace

AbstractNamespace: testing
--------------------------

isNamespace
     Answer `true'.

isSmalltalk
     Answer `false'.



File: gst-base.info,  Node: AlternativeObjectProxy,  Next: ArithmeticError,  Prev: AbstractNamespace,  Up: Base classes

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

* Menu:

* AlternativeObjectProxy class-instance creation::  (class)
* AlternativeObjectProxy-accessing::  (instance)


File: gst-base.info,  Node: AlternativeObjectProxy class-instance creation,  Next: AlternativeObjectProxy-accessing,  Up: AlternativeObjectProxy

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.



File: gst-base.info,  Node: AlternativeObjectProxy-accessing,  Prev: AlternativeObjectProxy class-instance creation,  Up: AlternativeObjectProxy

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



File: gst-base.info,  Node: ArithmeticError,  Next: Array,  Prev: AlternativeObjectProxy,  Up: Base classes

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.

* Menu:

* ArithmeticError-description::  (instance)


File: gst-base.info,  Node: ArithmeticError-description,  Up: ArithmeticError

ArithmeticError: description
----------------------------

description
     Answer a textual description of the exception.



File: gst-base.info,  Node: Array,  Next: ArrayedCollection,  Prev: ArithmeticError,  Up: Base classes

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.

* Menu:

* Array-mutating objects::  (instance)
* Array-printing::  (instance)
* Array-testing::  (instance)


File: gst-base.info,  Node: Array-mutating objects,  Next: Array-printing,  Up: Array

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



File: gst-base.info,  Node: Array-printing,  Next: Array-testing,  Prev: Array-mutating objects,  Up: Array

Array: printing
---------------

printOn: aStream
     Print a representation for the receiver on aStream



File: gst-base.info,  Node: Array-testing,  Prev: Array-printing,  Up: Array

Array: testing
--------------

isArray
     Answer `true'.



File: gst-base.info,  Node: ArrayedCollection,  Next: Association,  Prev: Array,  Up: Base classes

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.

* Menu:

* ArrayedCollection class-instance creation::  (class)
* ArrayedCollection-basic::  (instance)
* ArrayedCollection-built ins::  (instance)
* ArrayedCollection-copying Collections::  (instance)
* ArrayedCollection-enumerating the elements of a collection::  (instance)
* ArrayedCollection-storing::  (instance)


File: gst-base.info,  Node: ArrayedCollection class-instance creation,  Next: ArrayedCollection-basic,  Up: ArrayedCollection

ArrayedCollection class: instance creation
------------------------------------------

new: size withAll: anObject
     Answer a collection with the given size, whose elements are all
     set to anObject

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



File: gst-base.info,  Node: ArrayedCollection-basic,  Next: ArrayedCollection-built ins,  Prev: ArrayedCollection class-instance creation,  Up: ArrayedCollection

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.

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



File: gst-base.info,  Node: ArrayedCollection-built ins,  Next: ArrayedCollection-copying Collections,  Prev: ArrayedCollection-basic,  Up: ArrayedCollection

ArrayedCollection: built ins
----------------------------

size
     Answer the size of the receiver



File: gst-base.info,  Node: ArrayedCollection-copying Collections,  Next: ArrayedCollection-enumerating the elements of a collection,  Prev: ArrayedCollection-built ins,  Up: ArrayedCollection

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



File: gst-base.info,  Node: ArrayedCollection-enumerating the elements of a collection,  Next: ArrayedCollection-storing,  Prev: ArrayedCollection-copying Collections,  Up: ArrayedCollection

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.



File: gst-base.info,  Node: ArrayedCollection-storing,  Prev: ArrayedCollection-enumerating the elements of a collection,  Up: ArrayedCollection

ArrayedCollection: storing
--------------------------

storeOn: aStream
     Store Smalltalk code compiling to the receiver on aStream



File: gst-base.info,  Node: Association,  Next: Autoload,  Prev: ArrayedCollection,  Up: Base classes

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.

* Menu:

* Association class-basic::  (class)
* Association-accessing::  (instance)
* Association-finalization::  (instance)
* Association-printing::  (instance)
* Association-storing::  (instance)
* Association-testing::  (instance)


File: gst-base.info,  Node: Association class-basic,  Next: Association-accessing,  Up: Association

Association class: basic
------------------------

key: aKey value: aValue
     Answer a new association with the given key and value



File: gst-base.info,  Node: Association-accessing,  Next: Association-finalization,  Prev: Association class-basic,  Up: Association

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



File: gst-base.info,  Node: Association-finalization,  Next: Association-printing,  Prev: Association-accessing,  Up: Association

Association: finalization
-------------------------

mourn
     Finalize the receiver



File: gst-base.info,  Node: Association-printing,  Next: Association-storing,  Prev: Association-finalization,  Up: Association

Association: printing
---------------------

printOn: aStream
     Put on aStream a representation of the receiver



File: gst-base.info,  Node: Association-storing,  Next: Association-testing,  Prev: Association-printing,  Up: Association

Association: storing
--------------------

storeOn: aStream
     Put on aStream some Smalltalk code compiling to the receiver



File: gst-base.info,  Node: Association-testing,  Prev: Association-storing,  Up: Association

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

hash
     Answer an hash value for the receiver



File: gst-base.info,  Node: Autoload,  Next: AutoloadClass,  Prev: Association,  Up: Base classes

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).

* Menu:

* Autoload class-instance creation::  (class)
* Autoload-accessing::  (instance)


File: gst-base.info,  Node: Autoload class-instance creation,  Next: Autoload-accessing,  Up: Autoload

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



File: gst-base.info,  Node: Autoload-accessing,  Prev: Autoload class-instance creation,  Up: Autoload

Autoload: accessing
-------------------

doesNotUnderstand: aMessage
     Load the class and resend the message to it



File: gst-base.info,  Node: AutoloadClass,  Next: Bag,  Prev: Autoload,  Up: Base classes

AutoloadClass
=============

Defined in namespace Smalltalk
Superclass: none
Category: Examples-Useful tools
     I represent the metaclass of an autoloaded class before it is
     autoloaded.  Having a proxy for the metaclass as well allows one
     to send messages to the metaclass (such as #methodsFor: to extend
     it with class-side methods) and have the class autoloaded.

* Menu:

* AutoloadClass-accessing::  (instance)


File: gst-base.info,  Node: AutoloadClass-accessing,  Up: AutoloadClass

AutoloadClass: accessing
------------------------

doesNotUnderstand: aMessage
     Load the class and resend the message to its metaclass.

environment
     Answer the namespace in which the class will be autoloaded

environment: aNamespace
     Set to aNamespace the namespace in which the class will be
     autoloaded

fileName
     Answer the name of the file from which the class will be autoloaded

fileName: aString
     Set to aString the name of the file from which the class will be
     autoloaded

loadedClass
     File-in the file and answer the new value of the association which
     held the receiver

loadedMetaclass
     File-in the file and answer the metaclass for the new value of the
     association which held the receiver

name
     Answer the name of the class to be autoloaded

name: aSymbol
     Set to aSymbol the name of the class to be autoloaded



File: gst-base.info,  Node: Bag,  Next: Behavior,  Prev: AutoloadClass,  Up: Base classes

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.

* Menu:

* Bag class-basic::  (class)
* Bag-adding::  (instance)
* Bag-enumerating the elements of a collection::  (instance)
* Bag-extracting items::  (instance)
* Bag-printing::  (instance)
* Bag-removing::  (instance)
* Bag-storing::  (instance)
* Bag-testing collections::  (instance)


File: gst-base.info,  Node: Bag class-basic,  Next: Bag-adding,  Up: Bag

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



File: gst-base.info,  Node: Bag-adding,  Next: Bag-enumerating the elements of a collection,  Prev: Bag class-basic,  Up: Bag

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.



File: gst-base.info,  Node: Bag-enumerating the elements of a collection,  Next: Bag-extracting items,  Prev: Bag-adding,  Up: Bag

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.



File: gst-base.info,  Node: Bag-extracting items,  Next: Bag-printing,  Prev: Bag-enumerating the elements of a collection,  Up: Bag

Bag: extracting items
---------------------

sortedByCount
     Answer a collection of counts with elements, sorted by decreasing
     count.



File: gst-base.info,  Node: Bag-printing,  Next: Bag-removing,  Prev: Bag-extracting items,  Up: Bag

Bag: printing
-------------

printOn: aStream
     Put on aStream a representation of the receiver



File: gst-base.info,  Node: Bag-removing,  Next: Bag-storing,  Prev: Bag-printing,  Up: Bag

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



File: gst-base.info,  Node: Bag-storing,  Next: Bag-testing collections,  Prev: Bag-removing,  Up: Bag

Bag: storing
------------

storeOn: aStream
     Put on aStream some Smalltalk code compiling to the receiver



File: gst-base.info,  Node: Bag-testing collections,  Prev: Bag-storing,  Up: Bag

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



File: gst-base.info,  Node: Behavior,  Next: BindingDictionary,  Prev: Bag,  Up: Base classes

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.

* Menu:

* Behavior-accessing class hierarchy::  (instance)
* Behavior-accessing instances and variables::  (instance)
* Behavior-accessing the methodDictionary::  (instance)
* Behavior-built ins::  (instance)
* Behavior-compilation (alternative)::  (instance)
* Behavior-compiling methods::  (instance)
* Behavior-creating a class hierarchy::  (instance)
* Behavior-enumerating::  (instance)
* Behavior-evaluating::  (instance)
* Behavior-instance creation::  (instance)
* Behavior-instance variables::  (instance)
* Behavior-method dictionary::  (instance)
* Behavior-pluggable behavior (not yet implemented)::  (instance)
* Behavior-printing hierarchy::  (instance)
* Behavior-support for lightweight classes::  (instance)
* Behavior-testing functionality::  (instance)
* Behavior-testing the class hierarchy::  (instance)
* Behavior-testing the form of the instances::  (instance)
* Behavior-testing the method dictionary::  (instance)


File: gst-base.info,  Node: Behavior-accessing class hierarchy,  Next: Behavior-accessing instances and variables,  Up: Behavior

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



File: gst-base.info,  Node: Behavior-accessing instances and variables,  Next: Behavior-accessing the methodDictionary,  Prev: Behavior-accessing class hierarchy,  Up: Behavior

Behavior: accessing instances and variables
-------------------------------------------

allClassVarNames
     Return all the class variables understood by the receiver

allInstances
     Returns a set of all instances of the receiver

allInstVarNames
     Answer the names of every instance variables the receiver
     contained in the receiver's instances

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

instanceCount
     Return a count of all the instances of the receiver

instVarNames
     Answer an Array containing the instance variables defined by 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



File: gst-base.info,  Node: Behavior-accessing the methodDictionary,  Next: Behavior-built ins,  Prev: Behavior-accessing instances and variables,  Up: Behavior

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.

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 compiledMethod

sourceMethodAt: selector
     This is too dependent on the original implementation



File: gst-base.info,  Node: Behavior-built ins,  Next: Behavior-compilation (alternative),  Prev: Behavior-accessing the methodDictionary,  Up: Behavior

Behavior: built ins
-------------------

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.

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.

compileString: aString
     Compile the code in aString, with no category. Fail if the code
     does not obey Smalltalk syntax. Answer the generated CompiledMethod
     if it does

compileString: aString ifError: aBlock
     Compile the code in aString, with no category. Evaluate aBlock
     (passing the file name, line number and description of the error)
     if the code does not obey Smalltalk syntax. Answer the generated
     CompiledMethod if it does

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

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.

someInstance
     Private - Answer the first instance of the receiver in the object
     table



File: gst-base.info,  Node: Behavior-compilation (alternative),  Next: Behavior-compiling methods,  Prev: Behavior-built ins,  Up: Behavior

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



File: gst-base.info,  Node: Behavior-compiling methods,  Next: Behavior-creating a class hierarchy,  Prev: Behavior-compilation (alternative),  Up: Behavior

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.



File: gst-base.info,  Node: Behavior-creating a class hierarchy,  Next: Behavior-enumerating,  Prev: Behavior-compiling methods,  Up: Behavior

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.



File: gst-base.info,  Node: Behavior-enumerating,  Next: Behavior-evaluating,  Prev: Behavior-creating a class hierarchy,  Up: Behavior

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.



File: gst-base.info,  Node: Behavior-evaluating,  Next: Behavior-instance creation,  Prev: Behavior-enumerating,  Up: Behavior

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
     compileString: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'



File: gst-base.info,  Node: Behavior-instance creation,  Next: Behavior-instance variables,  Prev: Behavior-evaluating,  Up: Behavior

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.



File: gst-base.info,  Node: Behavior-instance variables,  Next: Behavior-method dictionary,  Prev: Behavior-instance creation,  Up: Behavior

Behavior: instance variables
----------------------------

addInstVarName: aString
     Add the given instance variable to instance of the receiver

removeInstVarName: aString
     Remove the given instance variable from the receiver and recompile
     all of the receiver's subclasses



File: gst-base.info,  Node: Behavior-method dictionary,  Next: Behavior-pluggable behavior (not yet implemented),  Prev: Behavior-instance variables,  Up: Behavior

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.
     description. 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.

defineCFunc: cFuncNameString
     withSelectorArgs: selectorAndArgs     returning: returnTypeSymbol
       args: argsArray Please lookup the part on the C interface in
     the manual.

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.



File: gst-base.info,  Node: Behavior-pluggable behavior (not yet implemented),  Next: Behavior-printing hierarchy,  Prev: Behavior-method dictionary,  Up: Behavior

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).



File: gst-base.info,  Node: Behavior-printing hierarchy,  Next: Behavior-support for lightweight classes,  Prev: Behavior-pluggable behavior (not yet implemented),  Up: Behavior

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



File: gst-base.info,  Node: Behavior-support for lightweight classes,  Next: Behavior-testing functionality,  Prev: Behavior-printing hierarchy,  Up: Behavior

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.



File: gst-base.info,  Node: Behavior-testing functionality,  Next: Behavior-testing the class hierarchy,  Prev: Behavior-support for lightweight classes,  Up: Behavior

Behavior: testing functionality
-------------------------------

isBehavior
     Answer `true'.



File: gst-base.info,  Node: Behavior-testing the class hierarchy,  Next: Behavior-testing the form of the instances,  Prev: Behavior-testing functionality,  Up: Behavior

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



File: gst-base.info,  Node: Behavior-testing the form of the instances,  Next: Behavior-testing the method dictionary,  Prev: Behavior-testing the class hierarchy,  Up: Behavior

Behavior: testing the form of the instances
-------------------------------------------

instSize
     Answer how many fixed instance variables are reserved to each of
     the receiver's instances

isBits
     Answer whether the instance variables of the receiver's instances
     are bytes or words

isBytes
     Answer whether the instance variables of the receiver's instances
     are bytes

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

isWords
     Answer whether the instance variables of the receiver's instances
     are words



File: gst-base.info,  Node: Behavior-testing the method dictionary,  Prev: Behavior-testing the form of the instances,  Up: Behavior

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



File: gst-base.info,  Node: BindingDictionary,  Next: BlockClosure,  Prev: Behavior,  Up: Base classes

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.

* Menu:

* BindingDictionary-accessing::  (instance)
* BindingDictionary-copying::  (instance)
* BindingDictionary-forward declarations::  (instance)
* BindingDictionary-printing::  (instance)
* BindingDictionary-testing::  (instance)


File: gst-base.info,  Node: BindingDictionary-accessing,  Next: BindingDictionary-copying,  Up: BindingDictionary

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.



File: gst-base.info,  Node: BindingDictionary-copying,  Next: BindingDictionary-forward declarations,  Prev: BindingDictionary-accessing,  Up: BindingDictionary

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:

deepCopy
     Answer the receiver.

shallowCopy
     Answer the receiver.



File: gst-base.info,  Node: BindingDictionary-forward declarations,  Next: BindingDictionary-printing,  Prev: BindingDictionary-copying,  Up: BindingDictionary

BindingDictionary: forward declarations
---------------------------------------

add: aVariableBinding
     Store value as associated to the given key. If any, recycle
     Associations temporarily stored by the compiler inside the
     `Undeclared' dictionary.

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.



File: gst-base.info,  Node: BindingDictionary-printing,  Next: BindingDictionary-testing,  Prev: BindingDictionary-forward declarations,  Up: BindingDictionary

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.



File: gst-base.info,  Node: BindingDictionary-testing,  Prev: BindingDictionary-printing,  Up: BindingDictionary

BindingDictionary: testing
--------------------------

species
     Answer `IdentityDictionary'.



File: gst-base.info,  Node: BlockClosure,  Next: BlockContext,  Prev: BindingDictionary,  Up: Base classes

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.

* Menu:

* BlockClosure class-instance creation::  (class)
* BlockClosure class-testing::  (class)
* BlockClosure-accessing::  (instance)
* BlockClosure-built ins::  (instance)
* BlockClosure-control structures::  (instance)
* BlockClosure-exception handling::  (instance)
* BlockClosure-multiple process::  (instance)
* BlockClosure-overriding::  (instance)
* BlockClosure-testing::  (instance)
* BlockClosure-unwind protection::  (instance)


File: gst-base.info,  Node: BlockClosure class-instance creation,  Next: BlockClosure class-testing,  Up: BlockClosure

BlockClosure class: instance creation
-------------------------------------

block: aCompiledBlock
     Answer a BlockClosure that activates the passed CompiledBlock.

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.



File: gst-base.info,  Node: BlockClosure class-testing,  Next: BlockClosure-accessing,  Prev: BlockClosure class-instance creation,  Up: BlockClosure

BlockClosure class: testing
---------------------------

isImmediate
     Answer whether, if x is an instance of the receiver, x copy == x



File: gst-base.info,  Node: BlockClosure-accessing,  Next: BlockClosure-built ins,  Prev: BlockClosure class-testing,  Up: BlockClosure

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



File: gst-base.info,  Node: BlockClosure-built ins,  Next: BlockClosure-control structures,  Prev: BlockClosure-accessing,  Up: BlockClosure

BlockClosure: built ins
-----------------------

blockCopy: outerContext
     Generate a BlockClosure identical to the receiver, with the given
     context as its outer context.

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



File: gst-base.info,  Node: BlockClosure-control structures,  Next: BlockClosure-exception handling,  Prev: BlockClosure-built ins,  Up: BlockClosure

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-
     start



File: gst-base.info,  Node: BlockClosure-exception handling,  Next: BlockClosure-multiple process,  Prev: BlockClosure-control structures,  Up: BlockClosure

BlockClosure: exception handling
--------------------------------

ifError: aBlock
     Evaluate the receiver; when #error: is called, pass to aBlock the
     receiver and the parameter, and answer the result of evaluating
     aBlock.  If another exception is raised, it is passed to an outer
     handler; if no exception is raised, the result of evaluating the
     receiver is returned.

on: anException do: aBlock
     Evaluate the receiver; when anException is signaled, evaluate
     aBlock passing a Signal describing the exception. Answer either
     the result of evaluating the receiver or the parameter of a
     Signal>>#return:

on: e1 do: b1 on: e2 do: b2
     Evaluate the receiver; when e1 or e2 are signaled, evaluate
     respectively b1 or b2, passing a Signal describing the exception.
     Answer either the result of evaluating the receiver or the
     argument of a Signal>>#return:

on: e1 do: b1 on: e2 do: b2 on: e3 do: b3
     Evaluate the receiver; when e1, e2 or e3 are signaled, evaluate
     respectively b1, b2 or b3, passing a Signal describing the
     exception.  Answer either the result of evaluating the receiver or
     the parameter of a Signal>>#return:

on: e1 do: b1 on: e2 do: b2 on: e3 do: b3 on: e4 do: b4
     Evaluate the receiver; when e1, e2, e3 or e4 are signaled, evaluate
     respectively b1, b2, b3 or b4, passing a Signal describing the
     exception.  Answer either the result of evaluating the receiver or
     the parameter of a Signal>>#return:

on: e1 do: b1 on: e2 do: b2 on: e3 do: b3 on: e4 do: b4 on: e5 do: b5
     Evaluate the receiver; when e1, e2, e3, e4 or e5 are signaled,
     evaluate respectively b1, b2, b3, b4 or b5, passing a Signal
     describing the exception.  Answer either the result of evaluating
     the receiver or the parameter of a Signal>>#return:



File: gst-base.info,  Node: BlockClosure-multiple process,  Next: BlockClosure-overriding,  Prev: BlockClosure-exception handling,  Up: BlockClosure

BlockClosure: multiple process
------------------------------

fork
     Create a new process executing the receiver and start it

forkAt: priority
     Create a new process executing the receiver with given priority
     and start it

forkWithoutPreemption
     Evaluate the receiver in a process that cannot be preempted.  If
     the receiver expect a parameter, pass the current process (can be
     useful for queuing interrupts from within the uninterruptible
     process).

newProcess
     Create a new process executing the receiver in suspended state.
     The priority is the same as for the calling process. The receiver
     must not contain returns

newProcessWith: anArray
     Create a new process executing the receiver with the passed
     arguments, and leave it in suspended state. The priority is the
     same as for the calling process. The receiver must not contain
     returns

valueWithoutInterrupts
     Evaluate aBlock and delay all interrupts that are requested to the
     active process during its execution to after aBlock returns.

valueWithoutPreemption
     Evaluate the receiver with external interrupts disabled.  This
     effectively disables preemption as long as the block does not
     explicitly yield control, wait on semaphores, and the like.



File: gst-base.info,  Node: BlockClosure-overriding,  Next: BlockClosure-testing,  Prev: BlockClosure-multiple process,  Up: BlockClosure

BlockClosure: overriding
------------------------

deepCopy
     Answer the receiver.

shallowCopy
     Answer the receiver.



File: gst-base.info,  Node: BlockClosure-testing,  Next: BlockClosure-unwind protection,  Prev: BlockClosure-overriding,  Up: BlockClosure

BlockClosure: testing
---------------------

hasMethodReturn
     Answer whether the block contains a method return



File: gst-base.info,  Node: BlockClosure-unwind protection,  Prev: BlockClosure-testing,  Up: BlockClosure

BlockClosure: unwind protection
-------------------------------

ensure: aBlock
     Evaluate the receiver; when any exception is signaled exit
     returning the result of evaluating aBlock; if no exception is
     raised, return the result of evaluating aBlock when the receiver
     has ended

ifCurtailed: aBlock
     Evaluate the receiver; if its execution triggers an unwind which
     truncates the execution of the block (`curtails' the block),
     evaluate aBlock.  The three cases which can curtail the execution
     of the receiver are: a non-local return in the receiver, a
     non-local return in a block evaluated by the receiver which
     returns past the receiver itself, and an exception raised and not
     resumed during the execution of the receiver.

valueWithUnwind
     Evaluate the receiver. Any errors caused by the block will cause a
     backtrace, but execution will continue in the method that sent
     #valueWithUnwind, after that call. Example: [ 1 / 0 ]
     valueWithUnwind.  'unwind works!' printNl.  Important: this method
     is public, but it is intended to be used in very special cases (as
     a rule of thumb, use it only when the corresponding C code uses
     the _gst_prepare_execution_environment and
     _gst_finish_execution_environment functions). You should usually
     rely on #ensure: and #on:do:.



File: gst-base.info,  Node: BlockContext,  Next: Boolean,  Prev: BlockClosure,  Up: Base classes

BlockContext
============

Defined in namespace Smalltalk
Superclass: ContextPart
Category: Language-Implementation
     My instances represent executing Smalltalk blocks, which are
     portions of executeable code that have access to the environment
     that they were declared in, take parameters, and result from
     BlockClosure objects created to be executed by methods outside the
     current class.  Block contexts are created by messages sent to
     compute a closure's value.  They contain a stack and also provide
     some methods that can be used in inspection or debugging.

* Menu:

* BlockContext-accessing::  (instance)
* BlockContext-printing::  (instance)


File: gst-base.info,  Node: BlockContext-accessing,  Next: BlockContext-printing,  Up: BlockContext

BlockContext: accessing
-----------------------

caller
     Answer the context that called the receiver

home
     Answer the MethodContext to which the receiver refers, or nil if
     it has been optimized away

isBlock
     Answer whether the receiver is a block context

     block

isDisabled
     Answers false, because contexts that are skipped when doing a
     return are always MethodContexts.  BlockContexts are removed from
     the chain whenever a non-local return is done, because
     MethodContexts need to stay there in case there is a non-local
     return from the #ensure: block.

isEnvironment
     To create a valid execution environment for the interpreter even
     before it starts, GST creates a fake context whose selector is nil
     and which can be used as a marker for the current execution
     environment.  Answer whether the receiver is that kind of context
     (always false, since those contexts are always MethodContexts).

isUnwind
     Answers whether the context must continue execution even after a
     non-local return (a return from the enclosing method of a block, or
     a call to the #continue: method of ContextPart).  Such contexts are
     created only by #ensure: and are always MethodContexts.

nthOuterContext: n
     Answer the n-th outer block/method context for the receiver

outerContext
     Answer the outer block/method context for the receiver



File: gst-base.info,  Node: BlockContext-printing,  Prev: BlockContext-accessing,  Up: BlockContext

BlockContext: printing
----------------------

printOn: aStream
     Print a representation for the receiver on aStream



File: gst-base.info,  Node: Boolean,  Next: ByteArray,  Prev: BlockContext,  Up: Base classes

Boolean
=======

Defined in namespace Smalltalk
Superclass: Object
Category: Language-Data types
     I have two instances in the Smalltalk system: true and false.  I
     provide methods that are conditional on boolean values, such as
     conditional execution and loops, and conditional testing, such as
     conditional and and conditional or.  I should say that I appear to
     provide those operations; my subclasses True and False actually
     provide those operations.

* Menu:

* Boolean class-testing::  (class)
* Boolean-basic::  (instance)
* Boolean-C hacks::  (instance)
* Boolean-overriding::  (instance)
* Boolean-storing::  (instance)


File: gst-base.info,  Node: Boolean class-testing,  Next: Boolean-basic,  Up: Boolean

Boolean class: testing
----------------------

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



File: gst-base.info,  Node: Boolean-basic,  Next: Boolean-C hacks,  Prev: Boolean class-testing,  Up: Boolean

Boolean: basic
--------------

& aBoolean
     This method's functionality should be implemented by subclasses of
     Boolean

and: aBlock
     This method's functionality should be implemented by subclasses of
     Boolean

eqv: aBoolean
     This method's functionality should be implemented by subclasses of
     Boolean

ifFalse: falseBlock
     This method's functionality should be implemented by subclasses of
     Boolean

ifFalse: falseBlock ifTrue: trueBlock
     This method's functionality should be implemented by subclasses of
     Boolean

ifTrue: trueBlock
     This method's functionality should be implemented by subclasses of
     Boolean

ifTrue: trueBlock ifFalse: falseBlock
     This method's functionality should be implemented by subclasses of
     Boolean

not
     This method's functionality should be implemented by subclasses of
     Boolean

or: aBlock
     This method's functionality should be implemented by subclasses of
     Boolean

xor: aBoolean
     This method's functionality should be implemented by subclasses of
     Boolean

| aBoolean
     This method's functionality should be implemented by subclasses of
     Boolean



File: gst-base.info,  Node: Boolean-C hacks,  Next: Boolean-overriding,  Prev: Boolean-basic,  Up: Boolean

Boolean: C hacks
----------------

asCBooleanValue
     This method's functionality should be implemented by subclasses of
     Boolean



File: gst-base.info,  Node: Boolean-overriding,  Next: Boolean-storing,  Prev: Boolean-C hacks,  Up: Boolean

Boolean: overriding
-------------------

deepCopy
     Answer the receiver.

shallowCopy
     Answer the receiver.



File: gst-base.info,  Node: Boolean-storing,  Prev: Boolean-overriding,  Up: Boolean

Boolean: storing
----------------

storeOn: aStream
     Store on aStream some Smalltalk code which compiles to the receiver



File: gst-base.info,  Node: ByteArray,  Next: ByteStream,  Prev: Boolean,  Up: Base classes

ByteArray
=========

Defined in namespace Smalltalk
Superclass: ArrayedCollection
Category: Collections-Sequenceable
     My instances are similar to strings in that they are both
     represented as a sequence of bytes, but my individual elements are
     integers, where as a String's elements are characters.

* Menu:

* ByteArray-built ins::  (instance)
* ByteArray-converting::  (instance)
* ByteArray-more advanced accessing::  (instance)


File: gst-base.info,  Node: ByteArray-built ins,  Next: ByteArray-converting,  Up: ByteArray

ByteArray: built ins
--------------------

asCData: aCType
     Convert the receiver to a CObject with the given type

byteAt: index
     Answer the index-th indexed instance variable of the receiver

byteAt: index put: value
     Store the `value' byte in the index-th indexed instance variable
     of the receiver

hash
     Answer an hash value for the receiver

primReplaceFrom: start to: stop with: aByteArray startingAt: srcIndex
     Private - Replace the characters from start to stop with the ASCII
     codes contained in aString (which, actually, can be any variable
     byte class), starting at the srcIndex location of aString

replaceFrom: start to: stop with: aByteArray startingAt: replaceStart
     Replace the characters from start to stop with the bytes contained
     in aByteArray (which, actually, can be any variable byte class),
     starting at the replaceStart location of aByteArray

replaceFrom: start to: stop withString: aString startingAt: replaceStart
     Replace the characters from start to stop with the ASCII codes
     contained in aString (which, actually, can be any variable byte
     class), starting at the replaceStart location of aString



File: gst-base.info,  Node: ByteArray-converting,  Next: ByteArray-more advanced accessing,  Prev: ByteArray-built ins,  Up: ByteArray

ByteArray: converting
---------------------

asString
     Answer a String whose character's ASCII codes are the receiver's
     contents



File: gst-base.info,  Node: ByteArray-more advanced accessing,  Prev: ByteArray-converting,  Up: ByteArray

ByteArray: more advanced accessing
----------------------------------

charAt: index
     Access the C char at the given index in the receiver. The value is
     returned as a Smalltalk Character.  Indices are 1-based just like
     for other Smalltalk access.

charAt: index put: value
     Store as a C char the Smalltalk Character or Integer object
     identified by `value', at the given index in the receiver, using
     sizeof(char) bytes - i.e. 1 byte.  Indices are 1-based just like
     for other Smalltalk access.

doubleAt: index
     Access the C double at the given index in the receiver.  Indices
     are 1-based just like for other Smalltalk access.

doubleAt: index put: value
     Store the Smalltalk Float object identified by `value', at the
     given index in the receiver, writing it like a C double.  Indices
     are 1-based just like for other Smalltalk access.

floatAt: index
     Access the C float at the given index in the receiver.  Indices
     are 1-based just like for other Smalltalk access.

floatAt: index put: value
     Store the Smalltalk Float object identified by `value', at the
     given index in the receiver, writing it like a C float.  Indices
     are 1-based just like for other Smalltalk access.

intAt: index
     Access the C int at the given index in the receiver.  Indices are
     1-based just like for other Smalltalk access.

intAt: index put: value
     Store the Smalltalk Integer object identified by `value', at the
     given index in the receiver, using sizeof(int) bytes.  Indices are
     1-based just like for other Smalltalk access.

longAt: index
     Access the C long int at the given index in the receiver.  Indices
     are 1-based just like for other Smalltalk access.

longAt: index put: value
     Store the Smalltalk Integer object identified by `value', at the
     given index in the receiver, using sizeof(long) bytes.  Indices
     are 1-based just like for other Smalltalk access.

objectAt: index
     Access the Smalltalk object (OOP) at the given index in the
     receiver.  Indices are 1-based just like for other Smalltalk
     access.

objectAt: index put: value
     Store a pointer (OOP) to the Smalltalk object identified by
     `value', at the given index in the receiver.  Indices are 1-based
     just like for other Smalltalk access.

shortAt: index
     Access the C short int at the given index in the receiver.
     Indices are 1-based just like for other Smalltalk access.

shortAt: index put: value
     Store the Smalltalk Integer object identified by `value', at the
     given index in the receiver, using sizeof(short) bytes.  Indices
     are 1-based just like for other Smalltalk access.

stringAt: index
     Access the string pointed by the C `char *' at the given index in
     the receiver. Indices are 1-based just like for other Smalltalk
     access.

stringAt: index put: value
     Store the Smalltalk String object identified by `value', at the
     given index in the receiver, writing it like a *FRESHLY ALLOCATED*
     C string. It is the caller's responsibility to free it if
     necessary.  Indices are 1-based just like for other Smalltalk
     access.

ucharAt: index
     Access the C unsigned char at the given index in the receiver.
     The value is returned as a Smalltalk Character.  Indices are
     1-based just like for other Smalltalk access.

ucharAt: index put: value
     Store as a C char the Smalltalk Character or Integer object
     identified by `value', at the given index in the receiver, using
     sizeof(char) bytes - i.e. 1 byte.  Indices are 1-based just like
     for other Smalltalk access.

uintAt: index
     Access the C unsigned int at the given index in the receiver.
     Indices are 1-based just like for other Smalltalk access.

uintAt: index put: value
     Store the Smalltalk Integer object identified by `value', at the
     given index in the receiver, using sizeof(int) bytes.  Indices are
     1-based just like for other Smalltalk access.

ulongAt: index
     Access the C unsigned long int at the given index in the receiver.
     Indices are 1-based just like for other Smalltalk access.

ulongAt: index put: value
     Store the Smalltalk Integer object identified by `value', at the
     given index in the receiver, using sizeof(long) bytes.  Indices
     are 1-based just like for other Smalltalk access.

unsignedCharAt: index
     Access the C unsigned char at the given index in the receiver.
     The value is returned as a Smalltalk Character.  Indices are
     1-based just like for other Smalltalk access.

unsignedCharAt: index put: value
     Store as a C char the Smalltalk Character or Integer object
     identified by `value', at the given index in the receiver, using
     sizeof(char) bytes - i.e. 1 byte.  Indices are 1-based just like
     for other Smalltalk access.

unsignedIntAt: index
     Access the C unsigned int at the given index in the receiver.
     Indices are 1-based just like for other Smalltalk access.

unsignedIntAt: index put: value
     Store the Smalltalk Integer object identified by `value', at the
     given index in the receiver, using sizeof(int) bytes.  Indices are
     1-based just like for other Smalltalk access.

unsignedLongAt: index
     Access the C unsigned long int at the given index in the receiver.
     Indices are 1-based just like for other Smalltalk access.

unsignedLongAt: index put: value
     Store the Smalltalk Integer object identified by `value', at the
     given index in the receiver, using sizeof(long) bytes.  Indices
     are 1-based just like for other Smalltalk access.

unsignedShortAt: index
     Access the C unsigned short int at the given index in the receiver.
     Indices are 1-based just like for other Smalltalk access.

unsignedShortAt: index put: value
     Store the Smalltalk Integer object identified by `value', at the
     given index in the receiver, using sizeof(short) bytes.  Indices
     are 1-based just like for other Smalltalk access.

ushortAt: index
     Access the C unsigned short int at the given index in the receiver.
     Indices are 1-based just like for other Smalltalk access.

ushortAt: index put: value
     Store the Smalltalk Integer object identified by `value', at the
     given index in the receiver, using sizeof(short) bytes.  Indices
     are 1-based just like for other Smalltalk access.



File: gst-base.info,  Node: ByteStream,  Next: CAggregate,  Prev: ByteArray,  Up: Base classes

ByteStream
==========

Defined in namespace Smalltalk
Superclass: ReadWriteStream
Category: Streams-Collections
     My instances are read/write streams specially crafted for
     ByteArrays.  They are able to write binary data to them.

* Menu:

* ByteStream-basic::  (instance)


File: gst-base.info,  Node: ByteStream-basic,  Up: ByteStream

ByteStream: basic
-----------------

next
     Return the next *character* in the ByteArray

nextByte
     Return the next byte in the byte array

nextByteArray: numBytes
     Return the next numBytes bytes in the byte array

nextLong
     Return the next 4 bytes in the byte array, interpreted as a 32 bit
     signed int

nextPut: aChar
     Store aChar on the byte array

nextPutAll: aCollection
     Write all the objects in aCollection to the receiver

nextPutByte: anInteger
     Store anInteger (range: -128..255) on the byte array

nextPutByteArray: aByteArray
     Store aByteArray on the byte array

nextPutLong: anInteger
     Store anInteger (range: -2^31..2^32-1) on the byte array as 4 bytes

nextPutShort: anInteger
     Store anInteger (range: -32768..65535) on the byte array as 2 bytes

nextShort
     Return the next 2 bytes in the byte array, interpreted as a 16 bit
     signed int

nextSignedByte
     Return the next byte in the byte array, interpreted as a 8 bit
     signed number

nextUlong
     Return the next 4 bytes in the byte array, interpreted as a 32 bit
     unsigned int

nextUshort
     Return the next 2 bytes in the byte array, interpreted as a 16 bit
     unsigned int



File: gst-base.info,  Node: CAggregate,  Next: CallinProcess,  Prev: ByteStream,  Up: Base classes

CAggregate
==========

Defined in namespace Smalltalk
Superclass: CObject
Category: Language-C interface

* Menu:

* CAggregate class-accessing::  (class)
* CAggregate-accessing::  (instance)


File: gst-base.info,  Node: CAggregate class-accessing,  Next: CAggregate-accessing,  Up: CAggregate

CAggregate class: accessing
---------------------------

alignof
     Answer the receiver's instances required aligment

sizeof
     Answer the receiver's instances size



File: gst-base.info,  Node: CAggregate-accessing,  Prev: CAggregate class-accessing,  Up: CAggregate

CAggregate: accessing
---------------------

elementType
     Answer the type over which the receiver is constructed.



File: gst-base.info,  Node: CallinProcess,  Next: CArray,  Prev: CAggregate,  Up: Base classes

CallinProcess
=============

Defined in namespace Smalltalk
Superclass: Process
Category: Language-Processes
     I represent a unit of computation for which external C code
     requested execution, so I must store the returned value once my
     computation terminates.  I am otherwise equivalent to a Process.

* Menu:


File: gst-base.info,  Node: CArray,  Next: CArrayCType,  Prev: CallinProcess,  Up: Base classes

CArray
======

Defined in namespace Smalltalk
Superclass: CAggregate
Category: Language-C interface

* Menu:

* CArray-accessing::  (instance)


File: gst-base.info,  Node: CArray-accessing,  Up: CArray

CArray: accessing
-----------------

alignof
     Answer the receiver's required aligment

sizeof
     Answer the receiver's size



File: gst-base.info,  Node: CArrayCType,  Next: CBoolean,  Prev: CArray,  Up: Base classes

CArrayCType
===========

Defined in namespace Smalltalk
Superclass: CPtrCType
Category: Language-C interface

* Menu:

* CArrayCType class-instance creation::  (class)
* CArrayCType-accessing::  (instance)


File: gst-base.info,  Node: CArrayCType class-instance creation,  Next: CArrayCType-accessing,  Up: CArrayCType

CArrayCType class: instance creation
------------------------------------

elementType: aCType
     This method should not be called for instances of this class.

elementType: aCType numberOfElements: anInteger
     Answer a new instance of CPtrCType that maps an array whose
     elements are of the given CType, and whose size is exactly
     anInteger elements (of course, anInteger only matters for
     allocation, not for access, since no out-of-bounds protection is
     provided for C objects).



File: gst-base.info,  Node: CArrayCType-accessing,  Prev: CArrayCType class-instance creation,  Up: CArrayCType

CArrayCType: accessing
----------------------

alignof
     Answer the alignment of the receiver's instances

numberOfElements
     Answer the number of elements in the receiver's instances

sizeof
     Answer the size of the receiver's instances



File: gst-base.info,  Node: CBoolean,  Next: CByte,  Prev: CArrayCType,  Up: Base classes

CBoolean
========

Defined in namespace Smalltalk
Superclass: CByte
Category: Language-C interface
     I return true if a byte is not zero, false otherwise.

* Menu:

* CBoolean-accessing::  (instance)


File: gst-base.info,  Node: CBoolean-accessing,  Up: CBoolean

CBoolean: accessing
-------------------

value
     Get the receiver's value - answer true if it is != 0, false if it
     is 0.

value: aBoolean
     Set the receiver's value - it's the same as for CBytes, but we get
     a Boolean, not a Character



File: gst-base.info,  Node: CByte,  Next: CChar,  Prev: CBoolean,  Up: Base classes

CByte
=====

Defined in namespace Smalltalk
Superclass: CUChar
Category: Language-C interface
     You're a marine.  You adapt - you improvise - you overcome

     - Gunnery Sgt. Thomas Highway
     Heartbreak Ridge

* Menu:

* CByte class-conversion::  (class)
* CByte-accessing::  (instance)


File: gst-base.info,  Node: CByte class-conversion,  Next: CByte-accessing,  Up: CByte

CByte class: conversion
-----------------------

scalarIndex
     Nothing special in the default case - answer a CType for the
     receiver

type
     Nothing special in the default case - answer a CType for the
     receiver



File: gst-base.info,  Node: CByte-accessing,  Prev: CByte class-conversion,  Up: CByte

CByte: accessing
----------------

scalarIndex
     Nothing special in the default case - answer the receiver's CType

type
     Answer a CType for the receiver

value
     Answer the value the receiver is pointing to. The returned value
     is a SmallInteger

value: aValue
     Set the receiver to point to the value, aValue (a SmallInteger).



File: gst-base.info,  Node: CChar,  Next: CCompound,  Prev: CByte,  Up: Base classes

CChar
=====

Defined in namespace Smalltalk
Superclass: CScalar
Category: Language-C interface

* Menu:

* CChar class-accessing::  (class)
* CChar-accessing::  (instance)


File: gst-base.info,  Node: CChar class-accessing,  Next: CChar-accessing,  Up: CChar

CChar class: accessing
----------------------

alignof
     Answer the receiver's instances required aligment

scalarIndex
     Private - Answer an index referring to the receiver's instances
     scalar type

sizeof
     Answer the receiver's instances size



File: gst-base.info,  Node: CChar-accessing,  Prev: CChar class-accessing,  Up: CChar

CChar: accessing
----------------

alignof
     Answer the receiver's required aligment

scalarIndex
     Private - Answer an index referring to the receiver's scalar type

sizeof
     Answer the receiver's size



File: gst-base.info,  Node: CCompound,  Next: CDouble,  Prev: CChar,  Up: Base classes

CCompound
=========

Defined in namespace Smalltalk
Superclass: CObject
Category: Language-C interface

* Menu:

* CCompound class-instance creation::  (class)
* CCompound class-subclass creation::  (class)
* CCompound-instance creation::  (instance)


File: gst-base.info,  Node: CCompound class-instance creation,  Next: CCompound class-subclass creation,  Up: CCompound

CCompound class: instance creation
----------------------------------

new
     Allocate a new instance of the receiver. To free the memory after
     GC, remember to call #addToBeFinalized.

type
     Answer a CType for the receiver



File: gst-base.info,  Node: CCompound class-subclass creation,  Next: CCompound-instance creation,  Prev: CCompound class-instance creation,  Up: CCompound

CCompound class: subclass creation
----------------------------------

alignof
     Answer 1, the alignment of an empty struct

compileDeclaration: array
     This method's functionality should be implemented by subclasses of
     CCompound

compileDeclaration: array inject: startOffset into: aBlock
     Compile methods that implement the declaration in array.  To
     compute the offset after each field, the value of the old offset
     plus the new field's size is passed to aBlock, together with the
     new field's alignment requirements.

compileSize: size align: alignment
     Private - Compile sizeof and alignof methods

computeAggregateType: type block: aBlock
     Private - Called by computeTypeString:block: for pointers/arrays.
     Format of type: (array int 3) or (ptr FooStruct)

computeArrayType: type block: aBlock
     Private - Called by computeAggregateType:block: for arrays

computePtrType: type block: aBlock
     Private - Called by computeAggregateType:block: for pointers

computeTypeString: type block: aBlock
     Private - Pass the size, alignment, and description of CType for
     aBlock, given the field description in `type' (the second element
     of each pair).

emitInspectTo: str for: name
     Private - Emit onto the given stream the code for adding the given
     selector to the CCompound's inspector.

initialize
     Initialize the receiver's TypeMap

newStruct: structName declaration: array
     The old way to create a CStruct.  Superseded by
     #subclass:declaration:...

sizeof
     Answer 0, the size of an empty struct

subclass: structName declaration: array
     classVariableNames: cvn poolDictionaries: pd category: category
     Create a new class with the given name that contains code to
     implement the given C struct.  All the parameters except `array'
     are the same as for a standard class creation message; see
     documentation for more information



File: gst-base.info,  Node: CCompound-instance creation,  Prev: CCompound class-subclass creation,  Up: CCompound

CCompound: instance creation
----------------------------

inspect
     Inspect the contents of the receiver

inspectSelectorList
     Answer a list of selectors whose return values should be inspected
     by #inspect.



File: gst-base.info,  Node: CDouble,  Next: CFloat,  Prev: CCompound,  Up: Base classes

CDouble
=======

Defined in namespace Smalltalk
Superclass: CScalar
Category: Language-C interface

* Menu:

* CDouble class-accessing::  (class)
* CDouble-accessing::  (instance)


File: gst-base.info,  Node: CDouble class-accessing,  Next: CDouble-accessing,  Up: CDouble

CDouble class: accessing
------------------------

alignof
     Answer the receiver's instances required aligment

scalarIndex
     Private - Answer an index referring to the receiver's instances
     scalar type

sizeof
     Answer the receiver's instances size



File: gst-base.info,  Node: CDouble-accessing,  Prev: CDouble class-accessing,  Up: CDouble

CDouble: accessing
------------------

alignof
     Answer the receiver's required aligment

scalarIndex
     Private - Answer an index referring to the receiver's scalar type

sizeof
     Answer the receiver's size



File: gst-base.info,  Node: CFloat,  Next: CFunctionDescriptor,  Prev: CDouble,  Up: Base classes

CFloat
======

Defined in namespace Smalltalk
Superclass: CScalar
Category: Language-C interface

* Menu:

* CFloat class-accessing::  (class)
* CFloat-accessing::  (instance)


File: gst-base.info,  Node: CFloat class-accessing,  Next: CFloat-accessing,  Up: CFloat

CFloat class: accessing
-----------------------

alignof
     Answer the receiver's instances required aligment

scalarIndex
     Private - Answer an index referring to the receiver's instances
     scalar type

sizeof
     Answer the receiver's instances size



File: gst-base.info,  Node: CFloat-accessing,  Prev: CFloat class-accessing,  Up: CFloat

CFloat: accessing
-----------------

alignof
     Answer the receiver's required aligment

scalarIndex
     Private - Answer an index referring to the receiver's scalar type

sizeof
     Answer the receiver's size



File: gst-base.info,  Node: CFunctionDescriptor,  Next: Character,  Prev: CFloat,  Up: Base classes

CFunctionDescriptor
===================

Defined in namespace Smalltalk
Superclass: Object
Category: Language-C interface
     I am not part of the Smalltalk definition.  My instances contain
     information about C functions that can be called from within
     Smalltalk, such as number and type of parameters.  This
     information is used by the C callout mechanism to perform the
     actual call-out to C routines.

* Menu:

* CFunctionDescriptor class-instance creation::  (class)
* CFunctionDescriptor class-testing::  (class)
* CFunctionDescriptor-accessing::  (instance)
* CFunctionDescriptor-calling::  (instance)
* CFunctionDescriptor-printing::  (instance)


File: gst-base.info,  Node: CFunctionDescriptor class-instance creation,  Next: CFunctionDescriptor class-testing,  Up: CFunctionDescriptor

CFunctionDescriptor class: instance creation
--------------------------------------------

for: funcNameString returning: returnTypeSymbol withArgs: argsArray
     Private - Answer a CFunctionDescriptor



File: gst-base.info,  Node: CFunctionDescriptor class-testing,  Next: CFunctionDescriptor-accessing,  Prev: CFunctionDescriptor class-instance creation,  Up: CFunctionDescriptor

CFunctionDescriptor class: testing
----------------------------------

addressOf: function
     Answer whether a function is registered (on the C side) with the
     given name or is dynamically loadable.

isFunction: function
     Answer whether a function is registered (on the C side) with the
     given name.



File: gst-base.info,  Node: CFunctionDescriptor-accessing,  Next: CFunctionDescriptor-calling,  Prev: CFunctionDescriptor class-testing,  Up: CFunctionDescriptor

CFunctionDescriptor: accessing
------------------------------

address
     Answer the address (CObject) of the function represented by the
     receiver

address: aCObject
     Set to aCObject the address of the function represented by the
     receiver

isValid
     Answer whether the function represented by the receiver is actually
     a registered one

name
     Answer the name of the function (on the C side) represented by the
     receiver



File: gst-base.info,  Node: CFunctionDescriptor-calling,  Next: CFunctionDescriptor-printing,  Prev: CFunctionDescriptor-accessing,  Up: CFunctionDescriptor

CFunctionDescriptor: calling
----------------------------

asyncCallFrom: aContext
     Perform the call-out for the function represented by the receiver.
     The arguments (and the receiver if one of the arguments has type
     #self or #selfSmalltalk) are taken from the base of the stack of
     aContext.  Asynchronous call-outs don't return a value, but if the
     function calls back into Smalltalk the process that started the
     call-out is not suspended.

asyncCallNoRetryFrom: aContext
     Perform the call-out for the function represented by the receiver.
     The arguments (and the receiver if one of the arguments has type
     #self or #selfSmalltalk) are taken from the base of the stack of
     aContext.  Asynchronous call-outs don't return a value, but if the
     function calls back into Smalltalk the process that started the
     call-out is not suspended.  Unlike #asyncCallFrom:, this method
     does not attempt to find functions in shared objects.

callFrom: aContext into: aValueHolder
     Perform the call-out for the function represented by the receiver.
     The arguments (and the receiver if one of the arguments has type
     #self or #selfSmalltalk) are taken from the base of the stack of
     aContext, and the result is stored into aValueHolder.  aValueHolder
     is also returned.

callNoRetryFrom: aContext into: aValueHolder
     Perform the call-out for the function represented by the receiver.
     The arguments (and the receiver if one of the arguments has type
     #self or #selfSmalltalk) are taken from the base of the stack of
     aContext, and the result is stored into aValueHolder.  aValueHolder
     is also returned.  Unlike #callFrom:into:, this method does not
     attempt to find functions in shared objects.



File: gst-base.info,  Node: CFunctionDescriptor-printing,  Prev: CFunctionDescriptor-calling,  Up: CFunctionDescriptor

CFunctionDescriptor: printing
-----------------------------

printOn: aStream
     Print a representation of the receiver onto aStream



File: gst-base.info,  Node: Character,  Next: CharacterArray,  Prev: CFunctionDescriptor,  Up: Base classes

Character
=========

Defined in namespace Smalltalk
Superclass: Magnitude
Category: Language-Data types
     My instances represent the 256 characters of the character set.  I
     provide messages to translate between integers and character
     objects, and provide names for some of the common unprintable
     characters.

* Menu:

* Character class-built ins::  (class)
* Character class-constants::  (class)
* Character class-initializing lookup tables::  (class)
* Character class-instance creation::  (class)
* Character class-testing::  (class)
* Character-built ins::  (instance)
* Character-coercion methods::  (instance)
* Character-comparing::  (instance)
* Character-converting::  (instance)
* Character-printing::  (instance)
* Character-storing::  (instance)
* Character-testing::  (instance)
* Character-testing functionality::  (instance)


File: gst-base.info,  Node: Character class-built ins,  Next: Character class-constants,  Up: Character

Character class: built ins
--------------------------

asciiValue: anInteger
     Returns the character object corresponding to anInteger.  Error if
     anInteger is not an integer, or not in 0..255.  #codePoint:,
     #asciiValue: and #value: are synonyms.

codePoint: anInteger
     Returns the character object corresponding to anInteger.  Error if
     anInteger is not an integer, or not in 0..255.  #codePoint:,
     #asciiValue: and #value: are synonyms.

value: anInteger
     Returns the character object corresponding to anInteger.  Error if
     anInteger is not an integer, or not in 0..255.  #codePoint:,
     #asciiValue: and #value: are synonyms.



File: gst-base.info,  Node: Character class-constants,  Next: Character class-initializing lookup tables,  Prev: Character class-built ins,  Up: Character

Character class: constants
--------------------------

backspace
     Returns the character 'backspace'

bell
     Returns the character 'bel'

cr
     Returns the character 'cr'

eof
     Returns the character 'eof', also known as 'sub'

eot
     Returns the character 'eot', also known as 'Ctrl-D'

esc
     Returns the character 'esc'

lf
     Returns the character 'lf', also known as 'nl'

newPage
     Returns the character 'newPage', also known as 'ff'

nl
     Returns the character 'nl', also known as 'lf'

nul
     Returns the character 'nul'

space
     Returns the character 'space'

tab
     Returns the character 'tab'



File: gst-base.info,  Node: Character class-initializing lookup tables,  Next: Character class-instance creation,  Prev: Character class-constants,  Up: Character

Character class: initializing lookup tables
-------------------------------------------

initialize
     Initialize the lookup table which is used to make case and
     digit-to-char conversions faster.  Indices in Table are ASCII
     values incremented by one. Indices 1-256 classify chars (0 =
     nothing special, 2 = separator, 48 = digit, 55 = uppercase, 3 =
     lowercase), indices 257-512 map to lowercase chars, indices
     513-768 map to uppercase chars.



File: gst-base.info,  Node: Character class-instance creation,  Next: Character class-testing,  Prev: Character class-initializing lookup tables,  Up: Character

Character class: instance creation
----------------------------------

digitValue: anInteger
     Returns a character that corresponds to anInteger.  0-9 map to
     $0-$9, 10-35 map to $A-$Z



File: gst-base.info,  Node: Character class-testing,  Next: Character-built ins,  Prev: Character class-instance creation,  Up: Character

Character class: testing
------------------------

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



File: gst-base.info,  Node: Character-built ins,  Next: Character-coercion methods,  Prev: Character class-testing,  Up: Character

Character: built ins
--------------------

= char
     Boolean return value; true if the characters are equal

asciiValue
     Returns the integer value corresponding to self.  #codePoint,
     #asciiValue, #value, and #asInteger are synonyms.

asInteger
     Returns the integer value corresponding to self.  #codePoint,
     #asciiValue, #value, and #asInteger are synonyms.

codePoint
     Returns the integer value corresponding to self.  #codePoint,
     #asciiValue, #value, and #asInteger are synonyms.

value
     Returns the integer value corresponding to self.  #codePoint,
     #asciiValue, #value, and #asInteger are synonyms.



File: gst-base.info,  Node: Character-coercion methods,  Next: Character-comparing,  Prev: Character-built ins,  Up: Character

Character: coercion methods
---------------------------

asLowercase
     Returns self as a lowercase character if it's an uppercase letter,
     otherwise returns the character unchanged.

asString
     Returns the character self as a string.

asSymbol
     Returns the character self as a symbol.

asUppercase
     Returns self as a uppercase character if it's an lowercase letter,
     otherwise returns the character unchanged.



File: gst-base.info,  Node: Character-comparing,  Next: Character-converting,  Prev: Character-coercion methods,  Up: Character

Character: comparing
--------------------

< aCharacter
     Compare the character's ASCII value. Answer whether the receiver's
     is the least.

<= aCharacter
     Compare the character's ASCII value. Answer whether the receiver's
     is the least or their equal.

> aCharacter
     Compare the character's ASCII value. Answer whether the receiver's
     is the greatest.

>= aCharacter
     Compare the character's ASCII value. Answer whether the receiver's
     is the greatest or their equal.



File: gst-base.info,  Node: Character-converting,  Next: Character-printing,  Prev: Character-comparing,  Up: Character

Character: converting
---------------------

digitValue
     Returns the value of self interpreted as a digit.  Here, 'digit'
     means either 0-9, or A-Z, which maps to 10-35.



File: gst-base.info,  Node: Character-printing,  Next: Character-storing,  Prev: Character-converting,  Up: Character

Character: printing
-------------------

displayOn: aStream
     Print a representation of the receiver on aStream. Unlike
     #printOn:, this method strips the leading dollar.

printOn: aStream
     Store a representation of the receiver on aStream



File: gst-base.info,  Node: Character-storing,  Next: Character-testing,  Prev: Character-printing,  Up: Character

Character: storing
------------------

storeOn: aStream
     Store Smalltalk code compiling to the receiver on aStream



File: gst-base.info,  Node: Character-testing,  Next: Character-testing functionality,  Prev: Character-storing,  Up: Character

Character: testing
------------------

isAlphaNumeric
     True if self is a letter or a digit

isDigit
     True if self is a 0-9 digit

isLetter
     True if self is an upper- or lowercase letter

isLowercase
     True if self is a lowercase letter

isPunctuation
     Returns true if self is one of '.,:;!?'

isSeparator
     Returns true if self is a space, cr, tab, nl, or newPage

isUppercase
     True if self is uppercase

isVowel
     Returns true if self is a, e, i, o, or u; case insensitive



File: gst-base.info,  Node: Character-testing functionality,  Prev: Character-testing,  Up: Character

Character: testing functionality
--------------------------------

isCharacter
     Answer True. We're definitely characters



File: gst-base.info,  Node: CharacterArray,  Next: CInt,  Prev: Character,  Up: Base classes

CharacterArray
==============

Defined in namespace Smalltalk
Superclass: ArrayedCollection
Category: Language-Data types
     My instances represent a generic textual (string) data type.  I
     provide accessing and manipulation methods for strings.

* Menu:

* CharacterArray class-basic::  (class)
* CharacterArray-basic::  (instance)
* CharacterArray-built ins::  (instance)
* CharacterArray-comparing::  (instance)
* CharacterArray-converting::  (instance)
* CharacterArray-printing::  (instance)
* CharacterArray-storing::  (instance)
* CharacterArray-string processing::  (instance)
* CharacterArray-testing functionality::  (instance)


File: gst-base.info,  Node: CharacterArray class-basic,  Next: CharacterArray-basic,  Up: CharacterArray

CharacterArray class: basic
---------------------------

fromString: aCharacterArray
     Make up an instance of the receiver containing the same characters
     as aCharacterArray, and answer it.

lineDelimiter
     Answer a CharacterArray which one can use as a line delimiter.



File: gst-base.info,  Node: CharacterArray-basic,  Next: CharacterArray-built ins,  Prev: CharacterArray class-basic,  Up: CharacterArray

CharacterArray: basic
---------------------

basicAt: index
     Answer the index-th character of the receiver. This is an exception
     to the `do not override' rule that allows storage optimization by
     storing the characters as values instead of as objects.

basicAt: index put: anObject
     Set the index-th character of the receiver to be anObject. This
     method must not be overridden; override at: instead. String
     overrides it so that it looks like it contains character objects
     even though it contains bytes



File: gst-base.info,  Node: CharacterArray-built ins,  Next: CharacterArray-comparing,  Prev: CharacterArray-basic,  Up: CharacterArray

CharacterArray: built ins
-------------------------

valueAt: index
     Answer the ascii value of index-th character variable of the
     receiver

valueAt: index put: value
     Store (Character value: value) in the index-th indexed instance
     variable of the receiver



File: gst-base.info,  Node: CharacterArray-comparing,  Next: CharacterArray-converting,  Prev: CharacterArray-built ins,  Up: CharacterArray

CharacterArray: comparing
-------------------------

< aCharacterArray
     Return true if the receiver is less than aCharacterArray, ignoring
     case differences.

<= aCharacterArray
     Returns true if the receiver is less than or equal to
     aCharacterArray, ignoring case differences.  If is receiver is an
     initial substring of aCharacterArray, it is considered to be less
     than aCharacterArray.

> aCharacterArray
     Return true if the receiver is greater than aCharacterArray,
     ignoring case differences.

>= aCharacterArray
     Returns true if the receiver is greater than or equal to
     aCharacterArray, ignoring case differences.  If is aCharacterArray
     is an initial substring of the receiver, it is considered to be
     less than the receiver.

indexOf: aCharacterArray matchCase: aBoolean startingAt: anIndex
     Answer an Interval of indices in the receiver which match the
     aCharacterArray pattern. # in aCharacterArray means 'match any
     character', * in aCharacterArray means 'match any sequence of
     characters'. The first item of the returned in- terval is >=
     anIndex. If aBoolean is false, the search is case-insen- sitive,
     else it is case-sensitive.  If no Interval matches the pattern,
     answer nil.

match: aCharacterArray
     Answer whether aCharacterArray matches the pattern contained in the
     receiver. # in the receiver means 'match any character', * in
     receiver means 'match any sequence of characters'.

match: aCharacterArray ignoreCase: aBoolean
     Answer whether aCharacterArray matches the pattern contained in the
     receiver. # in the receiver means 'match any character', * in
     receiver means 'match any sequence of characters'.  The case of
     alphabetic characters is ignored if aBoolean is true.

sameAs: aCharacterArray
     Returns true if the receiver is the same CharacterArray as
     aCharacterArray, ignoring case differences.

startsWith: aCharacterArray
     Returns true if the receiver starts with the same characters as
     aCharacterArray.



File: gst-base.info,  Node: CharacterArray-converting,  Next: CharacterArray-printing,  Prev: CharacterArray-comparing,  Up: CharacterArray

CharacterArray: converting
--------------------------

asByteArray
     Return the receiver, converted to a ByteArray of ASCII values

asClassPoolKey
     Return the receiver, ready to be put in a class pool dictionary

asGlobalKey
     Return the receiver, ready to be put in the Smalltalk dictionary

asInteger
     Parse an Integer number from the receiver until the input character
     is invalid and answer the result at this point

asLowercase
     Returns a copy of self as a lowercase CharacterArray

asNumber
     Parse a Number from the receiver until the input character is
     invalid and answer the result at this point

asPoolKey
     Return the receiver, ready to be put in a pool dictionary

asString
     But I already am a String!  Really!

asSymbol
     Returns the symbol corresponding to the CharacterArray

asUppercase
     Returns a copy of self as an uppercase CharacterArray

fileName
     But I don't HAVE a file name!

filePos
     But I don't HAVE a file position!

isNumeric
     Answer whether the receiver denotes a number

trimSeparators
     Return a copy of the reciever without any spaces on front or back.
     The implementation is protected against the `all blanks' case.



File: gst-base.info,  Node: CharacterArray-printing,  Next: CharacterArray-storing,  Prev: CharacterArray-converting,  Up: CharacterArray

CharacterArray: printing
------------------------

displayOn: aStream
     Print a representation of the receiver on aStream. Unlike
     #printOn:, this method strips extra quotes.

displayString
     Answer a String representing the receiver. For most objects this
     is simply its #printString, but for CharacterArrays and characters,
     superfluous dollars or extra pair of quotes are stripped.

printOn: aStream
     Print a representation of the receiver on aStream



File: gst-base.info,  Node: CharacterArray-storing,  Next: CharacterArray-string processing,  Prev: CharacterArray-printing,  Up: CharacterArray

CharacterArray: storing
-----------------------

storeOn: aStream
     Print Smalltalk code compiling to the receiver on aStream



File: gst-base.info,  Node: CharacterArray-string processing,  Next: CharacterArray-testing functionality,  Prev: CharacterArray-storing,  Up: CharacterArray

CharacterArray: string processing
---------------------------------

bindWith: s1
     Answer the receiver with every %1 replaced by the displayString of
     s1

bindWith: s1 with: s2
     Answer the receiver with every %1 or %2 replaced by s1 or s2,
     respectively.  s1 and s2 are `displayed' (i.e. their displayString
     is used) upon replacement.

bindWith: s1 with: s2 with: s3
     Answer the receiver with every %1, %2 or %3 replaced by s1, s2 or
     s3, respectively.  s1, s2 and s3 are `displayed' (i.e. their
     displayString is used) upon replacement.

bindWith: s1 with: s2 with: s3 with: s4
     Answer the receiver with every %1, %2, %3 or %4 replaced by s1,
     s2, s3 or s4, respectively.  s1, s2, s3 and s4 are `displayed'
     (i.e. their displayString is used) upon replacement.

bindWithArguments: anArray
     Answer the receiver with every %n (1<=n<=9) replaced by the n-th
     element of anArray.  The replaced elements are `displayed' (i.e.
     their displayString is used).  In addition, the special pattern
     %<trueString|falseString>n is replaced with one of the two strings
     depending on the n-th element of anArray being true or false.

contractTo: smallSize
     Either return myself, or a copy shortened to smallSize characters
     by inserting an ellipsis (three dots: ...)

subStrings
     Answer an OrderedCollection of substrings of the receiver. A new
     substring start at the start of the receiver, or after every
     sequence of white space characters

substrings
     Answer an OrderedCollection of substrings of the receiver. A new
     substring start at the start of the receiver, or after every
     sequence of white space characters.  This message is preserved for
     backwards compatibility; the ANSI standard mandates `subStrings',
     with an uppercase s.

substrings: aCharacter
     Answer an OrderedCollection of substrings of the receiver. A new
     substring start at the start of the receiver, or after every
     sequence of characters matching aCharacter.  This message is
     preserved for backwards compatibility; the ANSI standard mandates
     `subStrings:', with an uppercase s.

subStrings: aCharacter
     Answer an OrderedCollection of substrings of the receiver. A new
     substring start at the start of the receiver, or after every
     sequence of characters matching aCharacter



File: gst-base.info,  Node: CharacterArray-testing functionality,  Prev: CharacterArray-string processing,  Up: CharacterArray

CharacterArray: testing functionality
-------------------------------------

isCharacterArray
     Answer `true'.



File: gst-base.info,  Node: CInt,  Next: Class,  Prev: CharacterArray,  Up: Base classes

CInt
====

Defined in namespace Smalltalk
Superclass: CScalar
Category: Language-C interface

* Menu:

* CInt class-accessing::  (class)
* CInt-accessing::  (instance)


File: gst-base.info,  Node: CInt class-accessing,  Next: CInt-accessing,  Up: CInt

CInt class: accessing
---------------------

alignof
     Answer the receiver's required aligment

scalarIndex
     Private - Answer an index referring to the receiver's instances
     scalar type

sizeof
     Answer the receiver's size



File: gst-base.info,  Node: CInt-accessing,  Prev: CInt class-accessing,  Up: CInt

CInt: accessing
---------------

alignof
     Answer the receiver's instances required aligment

scalarIndex
     Private - Answer an index referring to the receiver's scalar type

sizeof
     Answer the receiver's instances size



File: gst-base.info,  Node: Class,  Next: ClassDescription,  Prev: CInt,  Up: Base classes

Class
=====

Defined in namespace Smalltalk
Superclass: ClassDescription
Category: Language-Implementation
     I am THE class object.  My instances are the classes of the system.
     I provide information commonly attributed to classes: namely, the
     class name, class comment (you wouldn't be reading this if it
     weren't for me), a list of the instance variables of the class, and
     the class category.

* Menu:

* Class-accessing instances and variables::  (instance)
* Class-filing::  (instance)
* Class-instance creation::  (instance)
* Class-instance creation - alternative::  (instance)
* Class-printing::  (instance)
* Class-saving and loading::  (instance)
* Class-testing::  (instance)
* Class-testing functionality::  (instance)


File: gst-base.info,  Node: Class-accessing instances and variables,  Next: Class-filing,  Up: Class

Class: accessing instances and variables
----------------------------------------

addClassVarName: aString
     Add a class variable with the given name to the class pool
     dictionary

addSharedPool: aDictionary
     Add the given shared pool to the list of the class' pool
     dictionaries

allClassVarNames
     Answer the names of the variables in the receiver's class pool
     dictionary and in each of the superclasses' class pool dictionaries

bindingFor: aString
     Answer the variable binding for the class variable with the given
     name

category
     Answer the class category

category: aString
     Change the class category to aString

classPool
     Answer the class pool dictionary

classVarNames
     Answer the names of the variables in the class pool dictionary

comment
     Answer the class comment

comment: aString
     Change the class name

environment
     Answer `environment'.

environment: aNamespace
     Set the receiver's environment to aNamespace and recompile
     everything

initialize
     redefined in children (?)

name
     Answer the class name

removeClassVarName: aString
     Removes the class variable from the class, error if not present, or
     still in use.

removeSharedPool: aDictionary
     Remove the given dictionary to the list of the class' pool
     dictionaries

sharedPools
     Return the names of the shared pools defined by the class



File: gst-base.info,  Node: Class-filing,  Next: Class-instance creation,  Prev: Class-accessing instances and variables,  Up: Class

Class: filing
-------------

fileOutDeclarationOn: aFileStream
     File out class definition to aFileStream

fileOutHeaderOn: aFileStream
     Write date and time stamp to aFileStream

fileOutOn: aFileStream
     File out complete class description:  class definition, class and
     instance methods



File: gst-base.info,  Node: Class-instance creation,  Next: Class-instance creation - alternative,  Prev: Class-filing,  Up: Class

Class: instance creation
------------------------

extend
     Redefine a version of the receiver in the current namespace.  Note:
     this method can bite you in various ways when sent to system
     classes; read the section on namespaces in the manual for some
     examples of the problems you can encounter.

subclass: classNameString
     instanceVariableNames: stringInstVarNames     classVariableNames:
     stringOfClassVarNames     poolDictionaries: stringOfPoolNames
     category: categoryNameString Define a fixed subclass of the
     receiver with the given name, instance variables, class variables,
     pool dictionaries and category. If the class is already defined,
     if necessary, recompile everything needed.

variableByteSubclass: classNameString
     instanceVariableNames: stringInstVarNames   classVariableNames:
     stringOfClassVarNames   poolDictionaries: stringOfPoolNames
     category: categoryNameString Define a byte variable subclass of
     the receiver with the given name, instance variables (must be "),
     class variables, pool dictionaries and category. If the class is
     already defined, if necessary, recompile everything needed.

variableSubclass: classNameString
     instanceVariableNames: stringInstVarNames     classVariableNames:
     stringOfClassVarNames     poolDictionaries: stringOfPoolNames
     category: categoryNameString Define a variable pointer subclass of
     the receiver with the given name, instance variables, class
     variables, pool dictionaries and category. If the class is already
     defined, if necessary, recompile everything needed.

variableWordSubclass: classNameString
     instanceVariableNames: stringInstVarNames   classVariableNames:
     stringOfClassVarNames   poolDictionaries: stringOfPoolNames
     category: categoryNameString Define a word variable subclass of
     the receiver with the given name, instance variables (must be "),
     class variables, pool dictionaries and category. If the class is
     already defined, if necessary, recompile everything needed.



File: gst-base.info,  Node: Class-instance creation - alternative,  Next: Class-printing,  Prev: Class-instance creation,  Up: Class

Class: instance creation - alternative
--------------------------------------

categoriesFor: method are: categories
     Don't use this, it is only present to file in from IBM Smalltalk

subclass: classNameString classInstanceVariableNames: stringClassInstVarNames instanceVariableNames: stringInstVarNames classVariableNames: stringOfClassVarNames poolDictionaries: stringOfPoolNames
     Don't use this, it is only present to file in from IBM Smalltalk

subclass: classNameString instanceVariableNames: stringInstVarNames classVariableNames: stringOfClassVarNames poolDictionaries: stringOfPoolNames
     Don't use this, it is only present to file in from IBM Smalltalk

variableByteSubclass: classNameString classInstanceVariableNames: stringClassInstVarNames classVariableNames: stringOfClassVarNames poolDictionaries: stringOfPoolNames
     Don't use this, it is only present to file in from IBM Smalltalk

variableByteSubclass: classNameString classVariableNames: stringOfClassVarNames poolDictionaries: stringOfPoolNames
     Don't use this, it is only present to file in from IBM Smalltalk

variableLongSubclass: classNameString classInstanceVariableNames: stringClassInstVarNames classVariableNames: stringOfClassVarNames poolDictionaries: stringOfPoolNames
     Don't use this, it is only present to file in from IBM Smalltalk

variableLongSubclass: classNameString classVariableNames: stringOfClassVarNames poolDictionaries: stringOfPoolNames
     Don't use this, it is only present to file in from IBM Smalltalk

variableSubclass: classNameString classInstanceVariableNames: stringClassInstVarNames instanceVariableNames: stringInstVarNames classVariableNames: stringOfClassVarNames poolDictionaries: stringOfPoolNames
     Don't use this, it is only present to file in from IBM Smalltalk

variableSubclass: classNameString instanceVariableNames: stringInstVarNames classVariableNames: stringOfClassVarNames poolDictionaries: stringOfPoolNames
     Don't use this, it is only present to file in from IBM Smalltalk



File: gst-base.info,  Node: Class-printing,  Next: Class-saving and loading,  Prev: Class-instance creation - alternative,  Up: Class

Class: printing
---------------

article
     Answer an article (`a' or `an') which is ok for the receiver's name

printOn: aStream
     Print a representation of the receiver on aStream

storeOn: aStream
     Store Smalltalk code compiling to the receiver on aStream



File: gst-base.info,  Node: Class-saving and loading,  Next: Class-testing,  Prev: Class-printing,  Up: Class

Class: saving and loading
-------------------------

binaryRepresentationVersion
     Answer a number >= 0 which represents the current version of the
     object's representation.  The default implementation answers zero.

convertFromVersion: version withFixedVariables: fixed
     indexedVariables: indexed                       for: anObjectDumper
     This method is called if a VersionableObjectProxy is attached to a
     class.  It receives the version number that was stored for the
     object (or nil if the object did not use a VersionableObjectProxy),
     the fixed instance variables, the indexed instance variables, and
     the ObjectDumper that has read the object.  The default
     implementation ignores the version and simply fills in an instance
     of the receiver with the given fixed and indexed instance
     variables (nil if the class instances are of fixed size).  If
     instance variables were removed from the class, extras are
     ignored; if the class is now fixed and used to be indexed, indexed
     is not used.

nonVersionedInstSize
     Answer the number of instance variables that the class used to have
     when objects were stored without using a VersionableObjectProxy.
     The default implementation answers the current instSize.



File: gst-base.info,  Node: Class-testing,  Next: Class-testing functionality,  Prev: Class-saving and loading,  Up: Class

Class: testing
--------------

= aClass
     Returns true if the two class objects are to be considered equal.



File: gst-base.info,  Node: Class-testing functionality,  Prev: Class-testing,  Up: Class

Class: testing functionality
----------------------------

asClass
     Answer the receiver.

isClass
     Answer `true'.



File: gst-base.info,  Node: ClassDescription,  Next: CLong,  Prev: Class,  Up: Base classes

ClassDescription
================

Defined in namespace Smalltalk
Superclass: Behavior
Category: Language-Implementation
     My instances provide methods that access classes by category, and
     allow whole categories of classes to be filed out to external disk
     files.

* Menu:

* ClassDescription-compiling::  (instance)
* ClassDescription-conversion::  (instance)
* ClassDescription-copying::  (instance)
* ClassDescription-filing::  (instance)
* ClassDescription-organization of messages and classes::  (instance)
* ClassDescription-printing::  (instance)


File: gst-base.info,  Node: ClassDescription-compiling,  Next: ClassDescription-conversion,  Up: ClassDescription

ClassDescription: compiling
---------------------------

compile: code classified: categoryName
     Compile code in the receiver, assigning the method to the given
     category.  Answer the newly created CompiledMethod, or nil if an
     error was found.

compile: code classified: categoryName ifError: block
     Compile method source and install in method category,
     categoryName.  If there are parsing errors, invoke exception
     block, 'block' (see compile:ifError:).  Return the method

compile: code classified: categoryName notifying: requestor
     Compile method source and install in method category,
     categoryName.  If there are parsing errors, send an error message
     to requestor



File: gst-base.info,  Node: ClassDescription-conversion,  Next: ClassDescription-copying,  Prev: ClassDescription-compiling,  Up: ClassDescription

ClassDescription: conversion
----------------------------

asClass
     This method's functionality should be implemented by subclasses of
     ClassDescription

asMetaclass
     Answer the metaclass associated to the receiver

binding
     Answer a VariableBinding object whose value is the receiver



File: gst-base.info,  Node: ClassDescription-copying,  Next: ClassDescription-filing,  Prev: ClassDescription-conversion,  Up: ClassDescription

ClassDescription: copying
-------------------------

copy: selector from: aClass
     Copy the given selector from aClass, assigning it the same category

copy: selector from: aClass classified: categoryName
     Copy the given selector from aClass, assigning it the given
     category

copyAll: arrayOfSelectors from: class
     Copy all the selectors in arrayOfSelectors from class, assigning
     them the same category they have in class

copyAll: arrayOfSelectors from: class classified: categoryName
     Copy all the selectors in arrayOfSelectors from aClass, assigning
     them the given category

copyAllCategoriesFrom: aClass
     Copy all the selectors in aClass, assigning them the original
     category

copyCategory: categoryName from: aClass
     Copy all the selectors in from aClass that belong to the given
     category

copyCategory: categoryName from: aClass classified: newCategoryName
     Copy all the selectors in from aClass that belong to the given
     category, reclassifying them as belonging to the given category



File: gst-base.info,  Node: ClassDescription-filing,  Next: ClassDescription-organization of messages and classes,  Prev: ClassDescription-copying,  Up: ClassDescription

ClassDescription: filing
------------------------

fileOut: fileName
     Open the given file and to file out a complete class description
     to it

fileOutCategory: categoryName to: fileName
     File out all the methods belonging to the method category,
     categoryName, to the fileName file

fileOutCategory: category toStream: aFileStream
     File out all the methods belonging to the method category,
     categoryName, to aFileStream

fileOutOn: aFileStream
     File out complete class description:  class definition, class and
     instance methods

fileOutSelector: selector to: fileName
     File out the given selector to fileName



File: gst-base.info,  Node: ClassDescription-organization of messages and classes,  Next: ClassDescription-printing,  Prev: ClassDescription-filing,  Up: ClassDescription

ClassDescription: organization of messages and classes
------------------------------------------------------

classify: aSelector under: aString
     Put the method identified by the selector aSelector under the
     category given by aString.

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'.

defineAsyncCFunc: cFuncNameString
     withSelectorArgs: selectorAndArgs     args: argsArray See
     documentation. Too complex to describe it here ;-)

defineCFunc: cFuncNameString
     withSelectorArgs: selectorAndArgs     returning: returnTypeSymbol
       args: argsArray See documentation. Too complex to describe it
     here ;-)

removeCategory: aString
     Remove from the receiver every method belonging to the given
     category

whichCategoryIncludesSelector: selector
     Answer the category for the given selector, or nil if the selector
     is not found



File: gst-base.info,  Node: ClassDescription-printing,  Prev: ClassDescription-organization of messages and classes,  Up: ClassDescription

ClassDescription: printing
--------------------------

classVariableString
     This method's functionality should be implemented by subclasses of
     ClassDescription

instanceVariableString
     Answer a string containing the name of the receiver's instance
     variables.

nameIn: aNamespace
     Answer the class name when the class is referenced from aNamespace

printOn: aStream in: aNamespace
     Print on aStream the class name when the class is referenced from
     aNamespace

sharedVariableString
     This method's functionality should be implemented by subclasses of
     ClassDescription



File: gst-base.info,  Node: CLong,  Next: CObject,  Prev: ClassDescription,  Up: Base classes

CLong
=====

Defined in namespace Smalltalk
Superclass: CScalar
Category: Language-C interface

* Menu:

* CLong class-accessing::  (class)
* CLong-accessing::  (instance)


File: gst-base.info,  Node: CLong class-accessing,  Next: CLong-accessing,  Up: CLong

CLong class: accessing
----------------------

alignof
     Answer the receiver's instances required aligment

scalarIndex
     Private - Answer an index referring to the receiver's instances
     scalar type

sizeof
     Answer the receiver's instances size



File: gst-base.info,  Node: CLong-accessing,  Prev: CLong class-accessing,  Up: CLong

CLong: accessing
----------------

alignof
     Answer the receiver's required aligment

scalarIndex
     Private - Answer an index referring to the receiver's scalar type

sizeof
     Answer the receiver's size



File: gst-base.info,  Node: CObject,  Next: Collection,  Prev: CLong,  Up: Base classes

CObject
=======

Defined in namespace Smalltalk
Superclass: Object
Category: Language-C interface
     I am not part of the standard Smalltalk kernel class hierarchy.
     My instances contain values that are not interpreted by the
     Smalltalk system; they frequently hold "pointers" to data outside
     of the Smalltalk environment.  The C callout mechanism allows my
     instances to be transformed into their corresponding C values for
     use in external routines.

* Menu:

* CObject class-conversion::  (class)
* CObject class-instance creation::  (class)
* CObject-accessing::  (instance)
* CObject-C data access::  (instance)
* CObject-conversion::  (instance)
* CObject-finalization::  (instance)
* CObject-pointer-like behavior::  (instance)


File: gst-base.info,  Node: CObject class-conversion,  Next: CObject class-instance creation,  Up: CObject

CObject class: conversion
-------------------------

scalarIndex
     Nothing special in the default case - answer a CType for the
     receiver

type
     Nothing special in the default case - answer a CType for the
     receiver



File: gst-base.info,  Node: CObject class-instance creation,  Next: CObject-accessing,  Prev: CObject class-conversion,  Up: CObject

CObject class: instance creation
--------------------------------

address: anInteger
     Answer a new object pointing to the passed address, anInteger

alloc: nBytes
     Allocate nBytes bytes and return an instance of the receiver

alloc: nBytes type: cTypeObject
     Allocate nBytes bytes and return a CObject of the given type

new
     Answer a new object pointing to NULL.

new: nBytes
     Allocate nBytes bytes and return an instance of the receiver



File: gst-base.info,  Node: CObject-accessing,  Next: CObject-C data access,  Prev: CObject class-instance creation,  Up: CObject

CObject: accessing
------------------

address
     Answer the address the receiver is pointing to.

address: anInteger
     Set the receiver to point to the passed address, anInteger

printOn: aStream
     Print a representation of the receiver

type: aCType
     Set the receiver's type to aCType.



File: gst-base.info,  Node: CObject-C data access,  Next: CObject-conversion,  Prev: CObject-accessing,  Up: CObject

CObject: C data access
----------------------

at: byteOffset put: aValue type: aType
     Store aValue as data of the given type from byteOffset bytes after
     the pointer stored in the receiver

at: byteOffset type: aType
     Answer some data of the given type from byteOffset bytes after the
     pointer stored in the receiver

free
     Free the receiver's pointer and set it to null. Big trouble hits
     you if the receiver doesn't point to the base of a malloc-ed area.



File: gst-base.info,  Node: CObject-conversion,  Next: CObject-finalization,  Prev: CObject-C data access,  Up: CObject

CObject: conversion
-------------------

castTo: aType
     Answer another CObject, pointing to the same address as the
     receiver, but belonging to the aType CType.

scalarIndex
     Nothing special in the default case - answer the receiver's CType

type
     Answer a CType for the receiver



File: gst-base.info,  Node: CObject-finalization,  Next: CObject-pointer-like behavior,  Prev: CObject-conversion,  Up: CObject

CObject: finalization
---------------------

finalize
     To make the VM call this, use #addToBeFinalized. It frees
     automatically any memory pointed to by the CObject. It is not
     automatically enabled because big trouble hits you if you use
     #free and the receiver doesn't point to the base of a malloc-ed
     area.



File: gst-base.info,  Node: CObject-pointer-like behavior,  Prev: CObject-finalization,  Up: CObject

CObject: pointer-like behavior
------------------------------

+ anInteger
     Return another instance of the receiver's class which points at
     &receiver[anInteger] (or, if you prefer, what `receiver +
     anInteger' does in C).

- intOrPtr
     If intOrPtr is an integer, return another instance of the
     receiver's class pointing at &receiver[-anInteger] (or, if you
     prefer, what `receiver - anInteger' does in C).  If it is the same
     class as the receiver, return the difference in chars, i.e. in
     bytes, between the two pointed addresses (or, if you prefer, what
     `receiver - anotherCharPtr' does in C)

addressAt: anIndex
     Return a new CObject of the element type, corresponding to an
     object that is anIndex places past the receiver (remember that
     CObjects represent pointers and that C pointers behave like
     arrays).  anIndex is zero-based, just like with all other C-style
     accessing.

at: anIndex
     Dereference a pointer that is anIndex places past the receiver
     (remember that CObjects represent pointers and that C pointers
     behave like arrays).  anIndex is zero-based, just like with all
     other C-style accessing.

at: anIndex put: aValue
     Store anIndex places past the receiver the passed Smalltalk object
     or CObject `aValue'; if it is a CObject is dereferenced: that is,
     this method is equivalent either to cobj[anIndex]=aValue or
     cobj[anIndex]=*aValue.  anIndex is zero-based, just like with all
     other C-style accessing.  In both cases, aValue should be of the
     element type or of the corresponding Smalltalk type (that is, a
     String is ok for an array of CStrings) to avoid typing problems
     which however will not be signaled because C is untyped.

decr
     Adjust the pointer by sizeof(dereferencedType) bytes down (i.e.
     -receiver)

decrBy: anInteger
     Adjust the pointer by anInteger elements down (i.e. receiver -=
     anInteger)

incr
     Adjust the pointer by sizeof(dereferencedType) bytes up (i.e.
     ++receiver)

incrBy: anInteger
     Adjust the pointer by anInteger elements up (i.e. receiver +=
     anInteger)



File: gst-base.info,  Node: Collection,  Next: CompiledBlock,  Prev: CObject,  Up: Base classes

Collection
==========

Defined in namespace Smalltalk
Superclass: Object
Category: Collections
     I am an abstract class.  My instances are collections of objects.
     My subclasses may place some restrictions or add some definitions
     to how the objects are stored or organized; I say nothing about
     this.  I merely provide some object creation and access routines
     for general collections of objects.

* Menu:

* Collection class-instance creation::  (class)
* Collection-adding::  (instance)
* Collection-converting::  (instance)
* Collection-copying Collections::  (instance)
* Collection-enumeration::  (instance)
* Collection-finalization::  (instance)
* Collection-printing::  (instance)
* Collection-removing::  (instance)
* Collection-storing::  (instance)
* Collection-testing collections::  (instance)


File: gst-base.info,  Node: Collection class-instance creation,  Next: Collection-adding,  Up: Collection

Collection class: instance creation
-----------------------------------

with: anObject
     Answer a collection whose only element is anObject

with: firstObject with: secondObject
     Answer a collection whose only elements are the parameters in the
     order they were passed

with: firstObject with: secondObject with: thirdObject
     Answer a collection whose only elements are the parameters in the
     order they were passed

with: firstObject with: secondObject with: thirdObject with: fourthObject
     Answer a collection whose only elements are the parameters in the
     order they were passed

with: firstObject with: secondObject with: thirdObject with: fourthObject with: fifthObject
     Answer a collection whose only elements are the parameters in the
     order they were passed

withAll: aCollection
     Answer a collection whose elements are all those in aCollection



File: gst-base.info,  Node: Collection-adding,  Next: Collection-converting,  Prev: Collection class-instance creation,  Up: Collection

Collection: adding
------------------

add: newObject
     Add newObject to the receiver, answer it

addAll: aCollection
     Adds all the elements of 'aCollection' to the receiver, answer
     aCollection



File: gst-base.info,  Node: Collection-converting,  Next: Collection-copying Collections,  Prev: Collection-adding,  Up: Collection

Collection: converting
----------------------

asArray
     Answer an Array containing all the elements in the receiver

asBag
     Answer a Bag containing all the elements in the receiver

asByteArray
     Answer a ByteArray containing all the elements in the receiver

asOrderedCollection
     Answer an OrderedCollection containing all the elements in the
     receiver

     order

asRunArray
     Answer the receiver converted to a RunArray. If the receiver is not
     ordered the order of the elements in the RunArray might not be the
     #do: order.

asSet
     Answer a Set containing all the elements in the receiver with no
     duplicates

asSortedCollection
     Answer a SortedCollection containing all the elements in the
     receiver with the default sort block - [ :a :b | a <= b ]

asSortedCollection: aBlock
     Answer a SortedCollection whose elements are the elements of the
     receiver, sorted according to the sort block aBlock



File: gst-base.info,  Node: Collection-copying Collections,  Next: Collection-enumeration,  Prev: Collection-converting,  Up: Collection

Collection: copying Collections
-------------------------------

copyReplacing: targetObject withObject: newObject
     Copy replacing each object which is = to targetObject with
     newObject

copyWith: newElement
     Answer a copy of the receiver to which newElement is added

copyWithout: oldElement
     Answer a copy of the receiver to which all occurrences of
     oldElement are removed



File: gst-base.info,  Node: Collection-enumeration,  Next: Collection-finalization,  Prev: Collection-copying Collections,  Up: Collection

Collection: enumeration
-----------------------

allSatisfy: aBlock
     Search the receiver for an element for which aBlock returns false.
     Answer true if none does, false otherwise.

anyOne
     Answer an unspecified element of the collection. Example usage:
     ^coll inject: coll anyOne into: [ :max :each | max max: each ] to
     be used when you don't have a valid lowest-possible-value (which
     happens in common cases too, such as with arbitrary numbers

anySatisfy: aBlock
     Search the receiver for an element for which aBlock returns true.
     Answer true if some does, false otherwise.

beConsistent
     This method is private, but it is quite interesting so it is
     documented. It ensures that a collection is in a consistent state
     before attempting to iterate on it; its presence reduces the
     number of overrides needed by collections who try to amortize
     their execution times.  The default implementation does nothing,
     so it is optimized out by the virtual machine and so it loses very
     little on the performance side.  Note that descendants of
     Collection have to call it explicitly since #do: is abstract in
     Collection.

collect: aBlock
     Answer a new instance of a Collection containing all the results
     of evaluating aBlock passing each of the receiver's elements

conform: aBlock
     Search the receiver for an element for which aBlock returns false.
     Answer true if none does, false otherwise.

contains: aBlock
     Search the receiver for an element for which aBlock returns true.
     Answer true if some does, false otherwise.

detect: aBlock
     Search the receiver for an element for which aBlock returns true.
     If some does, answer it. If none does, fail

detect: aBlock ifNone: exceptionBlock
     Search the receiver for an element for which aBlock returns true.
     If some does, answer it. If none does, answer the result of
     evaluating aBlock

do: aBlock
     Enumerate each object of the receiver, passing them to aBlock

do: aBlock separatedBy: separatorBlock
     Enumerate each object of the receiver, passing them to aBlock.
     Between every two invocations of aBlock, invoke separatorBlock

inject: thisValue into: binaryBlock
     Pass to binaryBlock receiver thisValue and the first element of the
     receiver; for each subsequent element, pass the result of the
     previous evaluation and an element. Answer the result of the last
     invocation.

reject: aBlock
     Answer a new instance of a Collection containing all the elements
     in the receiver which, when passed to aBlock, don't answer true

select: aBlock
     Answer a new instance of a Collection containing all the elements
     in the receiver which, when passed to aBlock, answer true



File: gst-base.info,  Node: Collection-finalization,  Next: Collection-printing,  Prev: Collection-enumeration,  Up: Collection

Collection: finalization
------------------------

mourn: anObject
     Private - anObject has been found to have a weak key, remove it
     and possibly finalize the key.



File: gst-base.info,  Node: Collection-printing,  Next: Collection-removing,  Prev: Collection-finalization,  Up: Collection

Collection: printing
--------------------

inspect
     Print all the instance variables and objects in the receiver on the
     Transcript

printOn: aStream
     Print a representation of the receiver on aStream



File: gst-base.info,  Node: Collection-removing,  Next: Collection-storing,  Prev: Collection-printing,  Up: Collection

Collection: removing
--------------------

empty
     Remove everything from the receiver.

remove: oldObject
     Remove oldObject from the receiver. If absent, fail, else answer
     oldObject.

remove: oldObject ifAbsent: anExceptionBlock
     Remove oldObject from the receiver. If absent, evaluate
     anExceptionBlock and answer the result, else answer oldObject.

removeAll: aCollection
     Remove each object in aCollection, answer aCollection, fail if some
     of them is absent. Warning: this could leave the collection in a
     semi-updated state.

removeAll: aCollection ifAbsent: aBlock
     Remove each object in aCollection, answer aCollection; if some
     element is absent, pass it to aBlock.



File: gst-base.info,  Node: Collection-storing,  Next: Collection-testing collections,  Prev: Collection-removing,  Up: Collection

Collection: storing
-------------------

storeOn: aStream
     Store Smalltalk code compiling to the receiver on aStream



File: gst-base.info,  Node: Collection-testing collections,  Prev: Collection-storing,  Up: Collection

Collection: testing collections
-------------------------------

capacity
     Answer how many elements the receiver can hold before having to
     grow.

identityIncludes: anObject
     Answer whether we include the anObject object

includes: anObject
     Answer whether we include anObject

isEmpty
     Answer whether we are (still) empty

notEmpty
     Answer whether we include at least one object

occurrencesOf: anObject
     Answer how many occurrences of anObject we include

size
     Answer how many objects we include



File: gst-base.info,  Node: CompiledBlock,  Next: CompiledCode,  Prev: Collection,  Up: Base classes

CompiledBlock
=============

Defined in namespace Smalltalk
Superclass: CompiledCode
Category: Language-Implementation
     I represent a block that has been compiled.

* Menu:

* CompiledBlock class-instance creation::  (class)
* CompiledBlock-accessing::  (instance)
* CompiledBlock-basic::  (instance)
* CompiledBlock-printing::  (instance)
* CompiledBlock-saving and loading::  (instance)


File: gst-base.info,  Node: CompiledBlock class-instance creation,  Next: CompiledBlock-accessing,  Up: CompiledBlock

CompiledBlock class: instance creation
--------------------------------------

newMethod: numBytecodes header: anInteger method: outerMethod
     Answer a new CompiledMethod with room for the given bytes and the
     given header

numArgs: args numTemps: temps bytecodes: bytecodes depth: depth literals: literalArray
     Answer an (almost) full fledged CompiledBlock.  To make it
     complete, you must either set the new object's `method' variable,
     or put it into a BlockClosure and put the BlockClosure into a
     CompiledMethod's literals.  The clean-ness of the block is
     automatically computed.



File: gst-base.info,  Node: CompiledBlock-accessing,  Next: CompiledBlock-basic,  Prev: CompiledBlock class-instance creation,  Up: CompiledBlock

CompiledBlock: accessing
------------------------

flags
     Answer the `cleanness' of the block.  0 = clean; 1 = access to
     receiver variables and/or self; 2-30 = access to variables that
     are 1-29 contexts away; 31 = return from method or push thisContext

method
     Answer the CompiledMethod in which the receiver lies

methodClass
     Answer the class in which the receiver is installed.

methodClass: methodClass
     Set the receiver's class instance variable

numArgs
     Answer the number of arguments passed to the receiver

numLiterals
     Answer the number of literals for the receiver

numTemps
     Answer the number of temporary variables used by the receiver

selector
     Answer the selector through which the method is called

selector: aSymbol
     Set the selector through which the method is called

stackDepth
     Answer the number of stack slots needed for the receiver



File: gst-base.info,  Node: CompiledBlock-basic,  Next: CompiledBlock-printing,  Prev: CompiledBlock-accessing,  Up: CompiledBlock

CompiledBlock: basic
--------------------

= aMethod
     Answer whether the receiver and aMethod are equal

methodCategory
     Answer the method category

methodCategory: aCategory
     Set the method category to the given string

methodSourceCode
     Answer the method source code (a FileSegment or String or nil)

methodSourceFile
     Answer the file where the method source code is stored

methodSourcePos
     Answer the location where the method source code is stored in the
     methodSourceFile

methodSourceString
     Answer the method source code as a string



File: gst-base.info,  Node: CompiledBlock-printing,  Next: CompiledBlock-saving and loading,  Prev: CompiledBlock-basic,  Up: CompiledBlock

CompiledBlock: printing
-----------------------

printOn: aStream
     Print the receiver's class and selector on aStream



File: gst-base.info,  Node: CompiledBlock-saving and loading,  Prev: CompiledBlock-printing,  Up: CompiledBlock

CompiledBlock: saving and loading
---------------------------------

     to

binaryRepresentationObject
     This method is implemented to allow for a PluggableProxy to be used
     with CompiledBlocks.  Answer a DirectedMessage which sends
     #blockAt: to the CompiledMethod containing the receiver.



File: gst-base.info,  Node: CompiledCode,  Next: CompiledMethod,  Prev: CompiledBlock,  Up: Base classes

CompiledCode
============

Defined in namespace Smalltalk
Superclass: ArrayedCollection
Category: Language-Implementation
     I represent code that has been compiled.  I am an abstract
     superclass for blocks and methods

* Menu:

* CompiledCode class-cache flushing::  (class)
* CompiledCode class-instance creation::  (class)
* CompiledCode-accessing::  (instance)
* CompiledCode-basic::  (instance)
* CompiledCode-copying::  (instance)
* CompiledCode-debugging::  (instance)
* CompiledCode-decoding bytecodes::  (instance)
* CompiledCode-testing accesses::  (instance)
* CompiledCode-translation::  (instance)


File: gst-base.info,  Node: CompiledCode class-cache flushing,  Next: CompiledCode class-instance creation,  Up: CompiledCode

CompiledCode class: cache flushing
----------------------------------

flushTranslatorCache
     Answer any kind of cache mantained by a just-in-time code
     translator in the virtual machine (if any).  Do nothing for now.



File: gst-base.info,  Node: CompiledCode class-instance creation,  Next: CompiledCode-accessing,  Prev: CompiledCode class-cache flushing,  Up: CompiledCode

CompiledCode class: instance creation
-------------------------------------

newMethod: numBytecodes header: anInteger literals: literals
     Answer a new CompiledMethod with room for the given bytes and the
     given header

newMethod: numBytecodes header: anInteger numLiterals: numLiterals
     Answer a new CompiledMethod with room for the given bytes and the
     given header



File: gst-base.info,  Node: CompiledCode-accessing,  Next: CompiledCode-basic,  Prev: CompiledCode class-instance creation,  Up: CompiledCode

CompiledCode: accessing
-----------------------

at: anIndex put: aBytecode
     Store aBytecode as the anIndex-th bytecode

blockAt: anIndex
     Answer the CompiledBlock attached to the anIndex-th literal,
     assuming that the literal is a BlockClosure.

bytecodeAt: anIndex
     Answer the anIndex-th bytecode

bytecodeAt: anIndex put: aBytecode
     Store aBytecode as the anIndex-th bytecode

flags
     Private - Answer the optimization flags for the receiver

literalAt: anIndex
     Answer the anIndex-th literal

literalAt: anInteger put: aValue
     Store aValue as the anIndex-th literal

literals
     Answer `literals'.

methodClass
     Answer the class in which the receiver is installed.

methodClass: methodClass
     Set the receiver's class instance variable

numArgs
     Answer the number of arguments for the receiver

numLiterals
     Answer the number of literals for the receiver

numTemps
     Answer the number of temporaries for the receiver

primitive
     Answer the primitive called by the receiver

selector
     Answer the selector through which the method is called

selector: aSymbol
     Set the selector through which the method is called

stackDepth
     Answer the number of stack slots needed for the receiver



File: gst-base.info,  Node: CompiledCode-basic,  Next: CompiledCode-copying,  Prev: CompiledCode-accessing,  Up: CompiledCode

CompiledCode: basic
-------------------

= aMethod
     Answer whether the receiver and aMethod are equal

hash
     Answer an hash value for the receiver

methodCategory
     Answer the method category

methodCategory: aCategory
     Set the method category to the given string

methodSourceCode
     Answer the method source code (a FileSegment or String or nil)

methodSourceFile
     Answer the file where the method source code is stored

methodSourcePos
     Answer the location where the method source code is stored in the
     methodSourceFile

methodSourceString
     Answer the method source code as a string



File: gst-base.info,  Node: CompiledCode-copying,  Next: CompiledCode-debugging,  Prev: CompiledCode-basic,  Up: CompiledCode

CompiledCode: copying
---------------------

deepCopy
     Answer a deep copy of the receiver



File: gst-base.info,  Node: CompiledCode-debugging,  Next: CompiledCode-decoding bytecodes,  Prev: CompiledCode-copying,  Up: CompiledCode

CompiledCode: debugging
-----------------------

inspect
     Print the contents of the receiver in a verbose way.



File: gst-base.info,  Node: CompiledCode-decoding bytecodes,  Next: CompiledCode-testing accesses,  Prev: CompiledCode-debugging,  Up: CompiledCode

CompiledCode: decoding bytecodes
--------------------------------

dispatchTo: anObject with: param
     Disassemble the bytecodes and tell anObject about them in the form
     of message sends.  param is given as an argument to every message
     send.



File: gst-base.info,  Node: CompiledCode-testing accesses,  Next: CompiledCode-translation,  Prev: CompiledCode-decoding bytecodes,  Up: CompiledCode

CompiledCode: testing accesses
------------------------------

accesses: instVarIndex
     Answer whether the receiver accesses the instance variable with
     the given index

assigns: instVarIndex
     Answer whether the receiver writes to the instance variable with
     the given index

containsLiteral: anObject
     Answer if the receiver contains a literal which is equal to
     anObject.

hasBytecode: byte between: firstIndex and: lastIndex
     Answer whether the receiver includes the `byte' bytecode in any of
     the indices between firstIndex and lastIndex.

jumpDestinationAt: anIndex
     Answer where the jump at bytecode index `anIndex' lands

reads: instVarIndex
     Answer whether the receiver reads the instance variable with the
     given index

refersTo: anObject
     Answer whether the receiver refers to the given object

sourceCodeMap
     Answer an array which maps bytecode indices to source code line
     numbers.  0 values represent invalid instruction pointer indices.



File: gst-base.info,  Node: CompiledCode-translation,  Prev: CompiledCode-testing accesses,  Up: CompiledCode

CompiledCode: translation
-------------------------

discardTranslation
     Flush the just-in-time translated code for the receiver (if any).



File: gst-base.info,  Node: CompiledMethod,  Next: ContextPart,  Prev: CompiledCode,  Up: Base classes

CompiledMethod
==============

Defined in namespace Smalltalk
Superclass: CompiledCode
Category: Language-Implementation
     I represent methods that have been compiled.  I can recompile
     methods from their source code, I can invoke Emacs to edit the
     source code for one of my instances, and I know how to access
     components of my instances.

* Menu:

* CompiledMethod class-instance creation::  (class)
* CompiledMethod class-lean images::  (class)
* CompiledMethod-accessing::  (instance)
* CompiledMethod-basic::  (instance)
* CompiledMethod-printing::  (instance)
* CompiledMethod-saving and loading::  (instance)
* CompiledMethod-testing::  (instance)


File: gst-base.info,  Node: CompiledMethod class-instance creation,  Next: CompiledMethod class-lean images,  Up: CompiledMethod

CompiledMethod class: instance creation
---------------------------------------

literals: lits numArgs: numArg numTemps: numTemp
     primitive: primIndex bytecodes: bytecodes depth: depth Answer a
     full fledged CompiledMethod. Construct the method header from the
     parameters, and set the literals and bytecodes to the provided
     ones.  Also, the bytecodes are optimized and any embedded
     CompiledBlocks modified to refer to these literals and to the
     newly created CompiledMethod.



File: gst-base.info,  Node: CompiledMethod class-lean images,  Next: CompiledMethod-accessing,  Prev: CompiledMethod class-instance creation,  Up: CompiledMethod

CompiledMethod class: lean images
---------------------------------

stripSourceCode
     Remove all the references to method source code from the system



File: gst-base.info,  Node: CompiledMethod-accessing,  Next: CompiledMethod-basic,  Prev: CompiledMethod class-lean images,  Up: CompiledMethod

CompiledMethod: accessing
-------------------------

allBlocksDo: aBlock
     Evaluate aBlock, passing to it all the CompiledBlocks it holds

allLiterals
     Answer the literals referred to by the receiver and all the blocks
     in it

flags
     Private - Answer the optimization flags for the receiver

methodClass
     Answer the class in which the receiver is installed.

methodClass: methodClass
     Set the receiver's class instance variable

numArgs
     Answer the number of arguments for the receiver

numTemps
     Answer the number of temporaries for the receiver

primitive
     Answer the primitive called by the receiver

selector
     Answer the selector through which the method is called

selector: aSymbol
     Set the selector through which the method is called

stackDepth
     Answer the number of stack slots needed for the receiver

withAllBlocksDo: aBlock
     Evaluate aBlock, passing the receiver and all the CompiledBlocks it
     holds

withNewMethodClass: class
     Answer either the receiver or a copy of it, with the method class
     set to class

withNewMethodClass: class selector: selector
     Answer either the receiver or a copy of it, with the method class
     set to class



File: gst-base.info,  Node: CompiledMethod-basic,  Next: CompiledMethod-printing,  Prev: CompiledMethod-accessing,  Up: CompiledMethod

CompiledMethod: basic
---------------------

= aMethod
     Answer whether the receiver and aMethod are equal

hash
     Answer an hash value for the receiver

methodCategory
     Answer the method category

methodCategory: aCategory
     Set the method category to the given string

methodSourceCode
     Answer the method source code (a FileSegment or String or nil)

methodSourceFile
     Answer the file where the method source code is stored

methodSourcePos
     Answer the location where the method source code is stored in the
     methodSourceFile

methodSourceString
     Answer the method source code as a string



File: gst-base.info,  Node: CompiledMethod-printing,  Next: CompiledMethod-saving and loading,  Prev: CompiledMethod-basic,  Up: CompiledMethod

CompiledMethod: printing
------------------------

printOn: aStream
     Print the receiver's class and selector on aStream

storeOn: aStream
     Print code to create the receiver on aStream



File: gst-base.info,  Node: CompiledMethod-saving and loading,  Next: CompiledMethod-testing,  Prev: CompiledMethod-printing,  Up: CompiledMethod

CompiledMethod: saving and loading
----------------------------------

     to

binaryRepresentationObject
     This method is implemented to allow for a PluggableProxy to be used
     with CompiledMethods.  Answer a DirectedMessage which sends #>> to
     the class object containing the receiver.



File: gst-base.info,  Node: CompiledMethod-testing,  Prev: CompiledMethod-saving and loading,  Up: CompiledMethod

CompiledMethod: testing
-----------------------

accesses: instVarIndex
     Answer whether the receiver or the blocks it contains accesses the
     instance variable with the given index

assigns: instVarIndex
     Answer whether the receiver or the blocks it contains writes to
     the instance variable with the given index

reads: instVarIndex
     Answer whether the receiver or the blocks it contains reads to the
     instance variable with the given index



File: gst-base.info,  Node: ContextPart,  Next: CoreException,  Prev: CompiledMethod,  Up: Base classes

ContextPart
===========

Defined in namespace Smalltalk
Superclass: Object
Category: Language-Implementation
     My instances represent executing Smalltalk code, which represent
     the local environment of executable code. They contain a stack and
     also provide some methods that can be used in inspection or
     debugging.

* Menu:

* ContextPart class-exception handling::  (class)
* ContextPart-accessing::  (instance)
* ContextPart-built ins::  (instance)
* ContextPart-copying::  (instance)
* ContextPart-debugging::  (instance)
* ContextPart-enumerating::  (instance)
* ContextPart-exception handling::  (instance)
* ContextPart-printing::  (instance)


File: gst-base.info,  Node: ContextPart class-exception handling,  Next: ContextPart-accessing,  Up: ContextPart

ContextPart class: exception handling
-------------------------------------

backtrace
     Print a backtrace from the caller to the bottom of the stack on the
     Transcript

backtraceOn: aStream
     Print a backtrace from the caller to the bottom of the stack on
     aStream

lastUnwindPoint
     Private - Return the last context marked as an unwind point, or
     our environment if none is.

removeLastUnwindPoint
     Private - Return and remove the last context marked as an unwind
     point, or our environment if the last unwind point belongs to
     another environment.

unwind
     Return execution to the last context marked as an unwind point,
     returning nil on that stack.

unwind: returnValue
     Return execution to the last context marked as an unwind point,
     returning returnValue on that stack.



File: gst-base.info,  Node: ContextPart-accessing,  Next: ContextPart-built ins,  Prev: ContextPart class-exception handling,  Up: ContextPart

ContextPart: accessing
----------------------

client
     Answer the client of this context, that is, the object that sent
     the message that created this context. Fail if the receiver has no
     parent

environment
     To create a valid execution environment for the interpreter even
     before it starts, GST creates a fake context whose selector is nil
     and which can be used as a marker for the current execution
     environment. This method answers that context.  For processes, it
     answers the process block itself

home
     Answer the MethodContext to which the receiver refers

initialIP
     Answer the value of the instruction pointer when execution starts
     in the current context

ip
     Answer the current instruction pointer into the receiver

ip: newIP
     Set the instruction pointer for the receiver

isBlock
     Answer whether the receiver is a block context

isDisabled
     Answers whether the context is skipped when doing a return.
     Contexts are marked as disabled whenever a non-local return is
     done (either by returning from the enclosing method of a block, or
     with the #continue: method of ContextPart) and there are unwind
     contexts such as those created by #ensure:.  All non-unwind
     contexts are then marked as disabled.

isEnvironment
     To create a valid execution environment for the interpreter even
     before it starts, GST creates a fake context whose selector is nil
     and which can be used as a marker for the current execution
     environment.  Answer whether the receiver is that kind of context.

isProcess
     Answer whether the receiver represents a process context, i.e. a
     context created by BlockClosure>>#newProcess. Such a context can
     be recognized because it has no parent but its flags are different
     from those of the contexts created by the VM's
     prepareExecutionEnvironment function.

isUnwind
     Answers whether the context must continue execution even after a
     non-local return (a return from the enclosing method of a block, or
     a call to the #continue: method of ContextPart).  Such contexts are
     created by #ensure:.

method
     Return the CompiledMethod being executed

methodClass
     Return the class in which the CompiledMethod being executed is
     defined

numArgs
     Answer the number of arguments passed to the receiver

numTemps
     Answer the number of temporaries used by the receiver

parentContext
     Answer the context that called the receiver

parentContext: aContext
     Set the context to which the receiver will return

receiver
     Return the receiver (self) for the method being executed

selector
     Return the selector for the method being executed

size
     Answer the number of valid fields for the receiver. Any read
     access from (self size + 1) to (self basicSize) has undefined
     results - even crashing

sp
     Answer the current stack pointer into the receiver

sp: newSP
     Set the stack pointer for the receiver.

validSize
     Answer how many elements in the receiver should be inspected



File: gst-base.info,  Node: ContextPart-built ins,  Next: ContextPart-copying,  Prev: ContextPart-accessing,  Up: ContextPart

ContextPart: built ins
----------------------

continue: anObject
     Resume execution from the receiver, faking that the context on top
     of it in the execution chain has returned anObject.  The receiver
     must belong to the same process as the executing context,
     otherwise the results are not predictable.  All #ensure: (and
     possibly #ifCurtailed:) blocks between the currently executing
     context and the receiver are evaluated (which is not what would
     happen if you directly bashed at the parent context of
     thisContext).



File: gst-base.info,  Node: ContextPart-copying,  Next: ContextPart-debugging,  Prev: ContextPart-built ins,  Up: ContextPart

ContextPart: copying
--------------------

deepCopy
     Answer a shallow copy of the receiver - duplicating e.g. the
     method and the instance variables that have been pushed is almost
     surely not the right thing.



File: gst-base.info,  Node: ContextPart-debugging,  Next: ContextPart-enumerating,  Prev: ContextPart-copying,  Up: ContextPart

ContextPart: debugging
----------------------

debuggerClass
     Answer which debugger should be used to debug the current context
     chain.  The class with the highest debugging priority is picked
     among those mentioned in the chain.

isInternalExceptionHandlingContext
     Answer whether the receiver is a context that should be hidden to
     the user when presenting a backtrace



File: gst-base.info,  Node: ContextPart-enumerating,  Next: ContextPart-exception handling,  Prev: ContextPart-debugging,  Up: ContextPart

ContextPart: enumerating
------------------------

scanBacktraceFor: selectors do: aBlock
     Scan the backtrace for contexts whose selector is among those
     listed in selectors; if one is found, invoke aBlock passing the
     selector.



File: gst-base.info,  Node: ContextPart-exception handling,  Next: ContextPart-printing,  Prev: ContextPart-enumerating,  Up: ContextPart

ContextPart: exception handling
-------------------------------

mark
     Add the receiver as a possible unwind point



File: gst-base.info,  Node: ContextPart-printing,  Prev: ContextPart-exception handling,  Up: ContextPart

ContextPart: printing
---------------------

backtrace
     Print a backtrace from the receiver to the bottom of the stack on
     the Transcript.

backtraceOn: aStream
     Print a backtrace from the caller to the bottom of the stack on
     aStream.



File: gst-base.info,  Node: CoreException,  Next: CPtr,  Prev: ContextPart,  Up: Base classes

CoreException
=============

Defined in namespace Smalltalk
Superclass: TrappableEvent
Category: Language-Exceptions
     My instances describe a single event that can be trapped using
     #on:do:..., contain whether such execution can be resumed after
     such an event, a description of what happened, and a block that is
     used as an handler by default. Using my methods you can raise
     exceptions and create new exceptions.  Exceptions are organized in
     a kind of hierarchy (different from the class hierarchy):
     intercepting an exception will intercept all its children too.

     CoreExceptions are different from ANSI Exceptions in that the
     signaled exception is not an instance of the CoreException,
     instead it belongs to a different class, Signal.  ANSI Exceptions
     inherit from Signal but hold on to a CoreException via a
     class-instance variable.

* Menu:

* CoreException class-instance creation::  (class)
* CoreException-accessing::  (instance)
* CoreException-basic::  (instance)
* CoreException-enumerating::  (instance)
* CoreException-exception handling::  (instance)
* CoreException-instance creation::  (instance)


File: gst-base.info,  Node: CoreException class-instance creation,  Next: CoreException-accessing,  Up: CoreException

CoreException class: instance creation
--------------------------------------

new
     Create a new exception whose parent is ExAll



File: gst-base.info,  Node: CoreException-accessing,  Next: CoreException-basic,  Prev: CoreException class-instance creation,  Up: CoreException

CoreException: accessing
------------------------

defaultHandler
     Answer the default handler for the receiver

defaultHandler: aBlock
     Set the default handler of the receiver to aBlock. A Signal object
     will be passed to aBlock

description
     Answer a description of the receiver

description: aString
     Set the description of the receiver to aString

isResumable
     Answer true if the receiver is resumable

isResumable: aBoolean
     Set the resumable flag of the receiver to aBoolean

parent
     Answer the parent of the receiver

signalClass
     Answer the subclass of Signal to be passed to handler blocks that
     handle the receiver

signalClass: aClass
     Set which subclass of Signal is to be passed to handler blocks
     that handle the receiver



File: gst-base.info,  Node: CoreException-basic,  Next: CoreException-enumerating,  Prev: CoreException-accessing,  Up: CoreException

CoreException: basic
--------------------

postCopy
     Modify the receiver so that the description is deep copied



File: gst-base.info,  Node: CoreException-enumerating,  Next: CoreException-exception handling,  Prev: CoreException-basic,  Up: CoreException

CoreException: enumerating
--------------------------

allExceptionsDo: aBlock
     Private - Evaluate aBlock for every exception in the receiver. As
     it contains just one exception, evaluate it just once, passing the
     receiver

goodness: exception
     Answer how good the receiver is at handling the given exception.  A
     negative value indicates that the receiver is not able to handle
     the exception.

handles: exceptionOrSignal
     Answer whether the receiver handles `exceptionOrSignal'.



File: gst-base.info,  Node: CoreException-exception handling,  Next: CoreException-instance creation,  Prev: CoreException-enumerating,  Up: CoreException

CoreException: exception handling
---------------------------------

signal
     Raise the exception described by the receiver, passing no
     parameters

signalWith: arg
     Raise the exception described by the receiver, passing the
     parameter arg

signalWith: arg with: arg2
     Raise the exception described by the receiver, passing the
     parameters arg and arg2

signalWithArguments: args
     Raise the exception described by the receiver, passing the
     parameters in args



File: gst-base.info,  Node: CoreException-instance creation,  Prev: CoreException-exception handling,  Up: CoreException

CoreException: instance creation
--------------------------------

newChild
     Answer a child exception of the receiver. Its properties are set
     to those of the receiver



File: gst-base.info,  Node: CPtr,  Next: CPtrCType,  Prev: CoreException,  Up: Base classes

CPtr
====

Defined in namespace Smalltalk
Superclass: CAggregate
Category: Language-C interface

* Menu:

* CPtr-accessing::  (instance)


File: gst-base.info,  Node: CPtr-accessing,  Up: CPtr

CPtr: accessing
---------------

alignof
     Answer the receiver's required aligment

sizeof
     Answer the receiver's size

value
     Answer the address of the location pointed to by the receiver.

value: anObject
     Set the address of the location pointed to by the receiver to
     anObject, which can be either an Integer or a CObject.  if
     anObject is an Integer, it is interpreted as a 32-bit or 64-bit
     address.  If it is a CObject, its address is stored.



File: gst-base.info,  Node: CPtrCType,  Next: CScalar,  Prev: CPtr,  Up: Base classes

CPtrCType
=========

Defined in namespace Smalltalk
Superclass: CType
Category: Language-C interface

* Menu:

* CPtrCType class-instance creation::  (class)
* CPtrCType-accessing::  (instance)


File: gst-base.info,  Node: CPtrCType class-instance creation,  Next: CPtrCType-accessing,  Up: CPtrCType

CPtrCType class: instance creation
----------------------------------

elementType: aCType
     Answer a new instance of CPtrCType that maps pointers to the given
     CType



File: gst-base.info,  Node: CPtrCType-accessing,  Prev: CPtrCType class-instance creation,  Up: CPtrCType

CPtrCType: accessing
--------------------

elementType
     Answer the type of the elements in the receiver's instances

new: size
     Allocate space for `size' objects like those that the receiver
     points to, and with the type (class) identified by the receiver.
     It is the caller's responsibility to free the memory allocated for
     it.



File: gst-base.info,  Node: CScalar,  Next: CScalarCType,  Prev: CPtrCType,  Up: Base classes

CScalar
=======

Defined in namespace Smalltalk
Superclass: CObject
Category: Language-C interface

* Menu:

* CScalar class-instance creation::  (class)
* CScalar-accessing::  (instance)


File: gst-base.info,  Node: CScalar class-instance creation,  Next: CScalar-accessing,  Up: CScalar

CScalar class: instance creation
--------------------------------

type
     Answer a CType for the receiver - for example, CByteType if the
     receiver is CByte.

value: anObject
     Answer a newly allocated CObject containing the passed value,
     anObject. Remember to call #addToBeFinalized if you want the
     CObject to be automatically freed



File: gst-base.info,  Node: CScalar-accessing,  Prev: CScalar class-instance creation,  Up: CScalar

CScalar: accessing
------------------

cObjStoredType
     Private - Provide a conversion from a CObject to a Smalltalk object
     to be stored by #at:put:

value
     Answer the value the receiver is pointing to. The exact returned
     value depends on the receiver's class

value: aValue
     Set the receiver to point to the value, aValue. The exact meaning
     of aValue depends on the receiver's class



File: gst-base.info,  Node: CScalarCType,  Next: CShort,  Prev: CScalar,  Up: Base classes

CScalarCType
============

Defined in namespace Smalltalk
Superclass: CType
Category: Language-C interface

* Menu:

* CScalarCType-accessing::  (instance)
* CScalarCType-storing::  (instance)


File: gst-base.info,  Node: CScalarCType-accessing,  Next: CScalarCType-storing,  Up: CScalarCType

CScalarCType: accessing
-----------------------

valueType
     valueType is used as a means to communicate to the interpreter the
     underlying type of the data.  For scalars, it is supplied by the
     CObject subclass.



File: gst-base.info,  Node: CScalarCType-storing,  Prev: CScalarCType-accessing,  Up: CScalarCType

CScalarCType: storing
---------------------

storeOn: aStream
     Store Smalltalk code that compiles to the receiver



File: gst-base.info,  Node: CShort,  Next: CSmalltalk,  Prev: CScalarCType,  Up: Base classes

CShort
======

Defined in namespace Smalltalk
Superclass: CScalar
Category: Language-C interface

* Menu:

* CShort class-accessing::  (class)
* CShort-accessing::  (instance)


File: gst-base.info,  Node: CShort class-accessing,  Next: CShort-accessing,  Up: CShort

CShort class: accessing
-----------------------

alignof
     Answer the receiver's instances required aligment

scalarIndex
     Private - Answer an index referring to the receiver's instances
     scalar type

sizeof
     Answer the receiver's instances size



File: gst-base.info,  Node: CShort-accessing,  Prev: CShort class-accessing,  Up: CShort

CShort: accessing
-----------------

alignof
     Answer the receiver's required aligment

scalarIndex
     Private - Answer an index referring to the receiver's scalar type

sizeof
     Answer the receiver's size



File: gst-base.info,  Node: CSmalltalk,  Next: CString,  Prev: CShort,  Up: Base classes

CSmalltalk
==========

Defined in namespace Smalltalk
Superclass: CScalar
Category: Language-C interface

* Menu:

* CSmalltalk class-accessing::  (class)
* CSmalltalk-accessing::  (instance)


File: gst-base.info,  Node: CSmalltalk class-accessing,  Next: CSmalltalk-accessing,  Up: CSmalltalk

CSmalltalk class: accessing
---------------------------

alignof
     Answer the receiver's instances required aligment

scalarIndex
     Private - Answer an index referring to the receiver's instances
     scalar type

sizeof
     Answer the receiver's instances size



File: gst-base.info,  Node: CSmalltalk-accessing,  Prev: CSmalltalk class-accessing,  Up: CSmalltalk

CSmalltalk: accessing
---------------------

alignof
     Answer the receiver's required aligment

scalarIndex
     Private - Answer an index referring to the receiver's scalar type

sizeof
     Answer the receiver's size



File: gst-base.info,  Node: CString,  Next: CStringCType,  Prev: CSmalltalk,  Up: Base classes

CString
=======

Defined in namespace Smalltalk
Superclass: CPtr
Category: Language-C interface
     Technically, CString is really a pointer to type char.  However,
     it's so darn useful as a distinct datatype, and it is a separate
     datatype in Smalltalk, so we allow developers to express their
     semantics more precisely by using a more descriptive type.

     In general, I behave like a cross between an array of characters
     and a pointer to a character.  I provide the protocol for both
     data types.  My #value method returns a Smalltalk String, as you
     would expect for a scalar datatype.


* Menu:

* CString class-instance creation::  (class)
* CString-accessing::  (instance)


File: gst-base.info,  Node: CString class-instance creation,  Next: CString-accessing,  Up: CString

CString class: instance creation
--------------------------------

type
     Answer a CType for the receiver - for example, CByteType if the
     receiver is CByte.

value: anObject
     Answer a newly allocated CObject containing the passed value,
     anObject. Remember to call #addToBeFinalized if you want the
     CObject to be automatically freed



File: gst-base.info,  Node: CString-accessing,  Prev: CString class-instance creation,  Up: CString

CString: accessing
------------------

cObjStoredType
     Private - Provide a conversion from a CObject to a Smalltalk object
     to be stored by #at:put:

value
     Answer the value the receiver is pointing to. The exact returned
     value depends on the receiver's class

value: aValue
     Set the receiver to point to the value, aValue. The exact meaning
     of aValue depends on the receiver's class



File: gst-base.info,  Node: CStringCType,  Next: CStruct,  Prev: CString,  Up: Base classes

CStringCType
============

Defined in namespace Smalltalk
Superclass: CScalarCType
Category: Language-C interface

* Menu:

* CStringCType-accessing::  (instance)


File: gst-base.info,  Node: CStringCType-accessing,  Up: CStringCType

CStringCType: accessing
-----------------------

elementType
     Answer the type of the elements in the receiver's instances



File: gst-base.info,  Node: CStruct,  Next: CType,  Prev: CStringCType,  Up: Base classes

CStruct
=======

Defined in namespace Smalltalk
Superclass: CCompound
Category: Language-C interface

* Menu:

* CStruct class-subclass creation::  (class)


File: gst-base.info,  Node: CStruct class-subclass creation,  Up: CStruct

CStruct class: subclass creation
--------------------------------

compileDeclaration: array
     Compile methods that implement the declaration in array.



File: gst-base.info,  Node: CType,  Next: CUChar,  Prev: CStruct,  Up: Base classes

CType
=====

Defined in namespace Smalltalk
Superclass: Object
Category: Language-C interface
     I am not part of the standard Smalltalk kernel class hierarchy.  I
     contain type information used by subclasses of CObject, which
     represents external C data items.

     My only instance variable, cObjectType, is used to hold onto the
     CObject subclass that gets created for a given CType.  Used
     primarily in the C part of the interpreter because internally it
     cannot execute methods to get values, so it has a simple way to
     access instance variable which holds the desired subclass.

     My subclasses have instances which represent the actual data
     types; for the scalar types, there is only one instance created of
     each, but for the aggregate types, there is at least one instance
     per base type and/or number of elements.

* Menu:

* CType class-C instance creation::  (class)
* CType-accessing::  (instance)
* CType-C instance creation::  (instance)
* CType-storing::  (instance)


File: gst-base.info,  Node: CType class-C instance creation,  Next: CType-accessing,  Up: CType

CType class: C instance creation
--------------------------------

cObjectType: aCObjectSubclass
     Create a new CType for the given subclass of CObject



File: gst-base.info,  Node: CType-accessing,  Next: CType-C instance creation,  Prev: CType class-C instance creation,  Up: CType

CType: accessing
----------------

alignof
     Answer the size of the receiver's instances

arrayType: size
     Answer a CArrayCType which represents an array with the given size
     of CObjects whose type is in turn represented by the receiver

cObjectType
     Answer the CObject subclass whose instance is created when new is
     sent to the receiver

ptrType
     Answer a CPtrCType which represents a pointer to CObjects whose
     type is in turn represented by the receiver

sizeof
     Answer the size of the receiver's instances

valueType
     valueType is used as a means to communicate to the interpreter the
     underlying type of the data.  For anything but scalars, it's just
     'self'



File: gst-base.info,  Node: CType-C instance creation,  Next: CType-storing,  Prev: CType-accessing,  Up: CType

CType: C instance creation
--------------------------

address: cObjOrInt
     Create a new CObject with the type (class) identified by the
     receiver, pointing to the given address (identified by an Integer
     or CObject).

new
     Allocate a new CObject with the type (class) identified by the
     receiver.  It is the caller's responsibility to free the memory
     allocated for it.



File: gst-base.info,  Node: CType-storing,  Prev: CType-C instance creation,  Up: CType

CType: storing
--------------

storeOn: aStream
     Store Smalltalk code that compiles to the receiver



File: gst-base.info,  Node: CUChar,  Next: CUInt,  Prev: CType,  Up: Base classes

CUChar
======

Defined in namespace Smalltalk
Superclass: CScalar
Category: Language-C interface

* Menu:

* CUChar class-getting info::  (class)
* CUChar-accessing::  (instance)


File: gst-base.info,  Node: CUChar class-getting info,  Next: CUChar-accessing,  Up: CUChar

CUChar class: getting info
--------------------------

alignof
     Answer the receiver's instances required aligment

scalarIndex
     Private - Answer an index referring to the receiver's instances
     scalar type

sizeof
     Answer the receiver's instances size



File: gst-base.info,  Node: CUChar-accessing,  Prev: CUChar class-getting info,  Up: CUChar

CUChar: accessing
-----------------

alignof
     Answer the receiver's required aligment

scalarIndex
     Private - Answer an index referring to the receiver's scalar type

sizeof
     Answer the receiver's size



File: gst-base.info,  Node: CUInt,  Next: CULong,  Prev: CUChar,  Up: Base classes

CUInt
=====

Defined in namespace Smalltalk
Superclass: CScalar
Category: Language-C interface

* Menu:

* CUInt class-accessing::  (class)
* CUInt-accessing::  (instance)


File: gst-base.info,  Node: CUInt class-accessing,  Next: CUInt-accessing,  Up: CUInt

CUInt class: accessing
----------------------

alignof
     Answer the receiver's instances required aligment

scalarIndex
     Private - Answer an index referring to the receiver's instances
     scalar type

sizeof
     Answer the receiver's instances size



File: gst-base.info,  Node: CUInt-accessing,  Prev: CUInt class-accessing,  Up: CUInt

CUInt: accessing
----------------

alignof
     Answer the receiver's required aligment

scalarIndex
     Private - Answer an index referring to the receiver's scalar type

sizeof
     Answer the receiver's size



File: gst-base.info,  Node: CULong,  Next: CUnion,  Prev: CUInt,  Up: Base classes

CULong
======

Defined in namespace Smalltalk
Superclass: CScalar
Category: Language-C interface

* Menu:

* CULong class-accessing::  (class)
* CULong-accessing::  (instance)


File: gst-base.info,  Node: CULong class-accessing,  Next: CULong-accessing,  Up: CULong

CULong class: accessing
-----------------------

alignof
     Answer the receiver's instances required aligment

scalarIndex
     Private - Answer an index referring to the receiver's instances
     scalar type

sizeof
     Answer the receiver's instances size



File: gst-base.info,  Node: CULong-accessing,  Prev: CULong class-accessing,  Up: CULong

CULong: accessing
-----------------

alignof
     Answer the receiver's required aligment

scalarIndex
     Private - Answer an index referring to the receiver's scalar type

sizeof
     Answer the receiver's size



File: gst-base.info,  Node: CUnion,  Next: CUShort,  Prev: CULong,  Up: Base classes

CUnion
======

Defined in namespace Smalltalk
Superclass: CCompound
Category: Language-C interface

* Menu:

* CUnion class-subclass creation::  (class)


File: gst-base.info,  Node: CUnion class-subclass creation,  Up: CUnion

CUnion class: subclass creation
-------------------------------

compileDeclaration: array
     Compile methods that implement the declaration in array.



File: gst-base.info,  Node: CUShort,  Next: Date,  Prev: CUnion,  Up: Base classes

CUShort
=======

Defined in namespace Smalltalk
Superclass: CScalar
Category: Language-C interface

* Menu:

* CUShort class-accessing::  (class)
* CUShort-accessing::  (instance)


File: gst-base.info,  Node: CUShort class-accessing,  Next: CUShort-accessing,  Up: CUShort

CUShort class: accessing
------------------------

alignof
     Answer the receiver's instances required aligment

scalarIndex
     Private - Answer an index referring to the receiver's instances
     scalar type

sizeof
     Answer the receiver's instances size



File: gst-base.info,  Node: CUShort-accessing,  Prev: CUShort class-accessing,  Up: CUShort

CUShort: accessing
------------------

alignof
     Answer the receiver's required aligment

scalarIndex
     Private - Answer an index referring to the receiver's scalar type

sizeof
     Answer the receiver's size



File: gst-base.info,  Node: Date,  Next: DateTime,  Prev: CUShort,  Up: Base classes

Date
====

Defined in namespace Smalltalk
Superclass: Magnitude
Category: Language-Data types
     My instances represent dates.  My base date is defined to be Jan
     1, 1901.  I provide methods for instance creation (including via
     "symbolic" dates, such as "Date newDay: 14 month: #Feb year: 1990".

     PLEASE BE WARNED - use this class only for dates after 1582 AD;
     that's the beginning of the epoch. Dates before 1582 will not be
     correctly printed. In addition, since ten days were lost from
     October 5 through October 15, operations between a Gregorian date
     (after 15-Oct-1582) and a Julian date (before 5-Oct-1582) will
     give incorrect results; or, 4-Oct-1582 + 2 days will yield
     6-Oct-1582 (a non-existent day!), not 16-Oct-1582.

     In fact, if you pass a year < 1582 to a method like
     #newDay:month:year: it will assume that it is a two-digit year
     (e.g. 90=1990, 1000=2900). The only way to create Julian calendar
     dates is with the #fromDays: instance creation method.

* Menu:

* Date class-basic::  (class)
* Date class-instance creation (ANSI)::  (class)
* Date class-instance creation (Blue Book)::  (class)
* Date-basic::  (instance)
* Date-compatibility (non-ANSI)::  (instance)
* Date-date computations::  (instance)
* Date-printing::  (instance)
* Date-storing::  (instance)
* Date-testing::  (instance)


File: gst-base.info,  Node: Date class-basic,  Next: Date class-instance creation (ANSI),  Up: Date

Date class: basic
-----------------

abbreviationOfDay: dayIndex
     Answer the abbreviated name of the day of week corresponding to
     the given index

dayOfWeek: dayName
     Answer the index of the day of week corresponding to the given name

daysInMonth: monthName forYear: yearInteger
     Answer the number of days in the given (named) month for the given
     year

daysInYear: i
     Answer the number of days in the given year

indexOfMonth: monthName
     Answer the index of the month corresponding to the given name

initDayNameDict
     Initialize the DayNameDict to the names of the days

initialize
     Initialize the receiver

initMonthNameDict
     Initialize the MonthNameDict to the names of the months

nameOfDay: dayIndex
     Answer the name of the day of week corresponding to the given index

nameOfMonth: monthIndex
     Answer the name of the month corresponding to the given index

shortNameOfMonth: monthIndex
     Answer the name of the month corresponding to the given index



File: gst-base.info,  Node: Date class-instance creation (ANSI),  Next: Date class-instance creation (Blue Book),  Prev: Date class-basic,  Up: Date

Date class: instance creation (ANSI)
------------------------------------

year: y day: d hour: h minute: min second: s
     Answer a Date denoting the d-th day of the given year

year: y month: m day: d hour: h minute: min second: s
     Answer a Date denoting the d-th day of the given (as a number)
     month and year



File: gst-base.info,  Node: Date class-instance creation (Blue Book),  Next: Date-basic,  Prev: Date class-instance creation (ANSI),  Up: Date

Date class: instance creation (Blue Book)
-----------------------------------------

dateAndTimeNow
     Answer an array containing the current date and time

fromDays: dayCount
     Answer a Date denoting dayCount days past 1/1/1901

fromJulian: jd
     Answer a Date denoting the jd-th day in the astronomical Julian
     calendar.

fromSeconds: time
     Answer a Date denoting the date time seconds past Jan 1st, 1901

newDay: day month: monthName year: yearInteger
     Answer a Date denoting the dayCount day of the given (named) month
     and year

newDay: day monthIndex: monthIndex year: yearInteger
     Answer a Date denoting the dayCount day of the given (as a number)
     month and year

newDay: dayCount year: yearInteger
     Answer a Date denoting the dayCount day of the yearInteger year

readFrom: aStream
     Parse an instance of the receiver from aStream

today
     Answer a Date denoting the current date in local time

utcDateAndTimeNow
     Answer an array containing the current date and time in Coordinated
     Universal Time (UTC)

utcToday
     Answer a Date denoting the current date in Coordinated Universal
     Time (UTC)



File: gst-base.info,  Node: Date-basic,  Next: Date-compatibility (non-ANSI),  Prev: Date class-instance creation (Blue Book),  Up: Date

Date: basic
-----------

addDays: dayCount
     Answer a new Date pointing dayCount past the receiver

subtractDate: aDate
     Answer the number of days between aDate and the receiver (negative
     if the receiver is before aDate)

subtractDays: dayCount
     Answer a new Date pointing dayCount before the receiver



File: gst-base.info,  Node: Date-compatibility (non-ANSI),  Next: Date-date computations,  Prev: Date-basic,  Up: Date

Date: compatibility (non-ANSI)
------------------------------

day
     Answer the day represented by the receiver

dayName
     Answer the day of week of the receiver as a Symbol

shortMonthName
     Answer the abbreviated name of the month represented by the
     receiver



File: gst-base.info,  Node: Date-date computations,  Next: Date-printing,  Prev: Date-compatibility (non-ANSI),  Up: Date

Date: date computations
-----------------------

asSeconds
     Answer the date as the number of seconds from 1/1/1901.

dayOfMonth
     Answer the day represented by the receiver (same as #day)

dayOfWeek
     Answer the day of week of the receiver. 1 = Monday, 7 = Sunday

dayOfWeekAbbreviation
     Answer the day of week of the receiver as a Symbol

dayOfWeekName
     Answer the day of week of the receiver as a Symbol

dayOfYear
     Answer the days passed since 31/12 of last year; e.g. New Year's
     Day is 1

daysFromBaseDay
     Answer the days passed since 1/1/1901

daysInMonth
     Answer the days in the month represented by the receiver

daysInYear
     Answer the days in the year represented by the receiver

daysLeftInMonth
     Answer the days to the end of the month represented by the receiver

daysLeftInYear
     Answer the days to the end of the year represented by the receiver

firstDayOfMonth
     Answer a Date representing the first day of the month represented
     by the receiver

isLeapYear
     Answer whether the receiver refers to a date in a leap year.

lastDayOfMonth
     Answer a Date representing the last day of the month represented
     by the receiver

month
     Answer the month represented by the receiver

monthAbbreviation
     Answer the abbreviated name of the month represented by the
     receiver

monthName
     Answer the name of the month represented by the receiver

year
     Answer the year represented by the receiver



File: gst-base.info,  Node: Date-printing,  Next: Date-storing,  Prev: Date-date computations,  Up: Date

Date: printing
--------------

printOn: aStream
     Print a representation for the receiver on aStream



File: gst-base.info,  Node: Date-storing,  Next: Date-testing,  Prev: Date-printing,  Up: Date

Date: storing
-------------

storeOn: aStream
     Store on aStream Smalltalk code compiling to the receiver



File: gst-base.info,  Node: Date-testing,  Prev: Date-storing,  Up: Date

Date: testing
-------------

< aDate
     Answer whether the receiver indicates a date preceding aDate

= aDate
     Answer whether the receiver indicates the same date as aDate

hash
     Answer an hash value for the receievr



File: gst-base.info,  Node: DateTime,  Next: Delay,  Prev: Date,  Up: Base classes

DateTime
========

Defined in namespace Smalltalk
Superclass: Date
Category: Language-Data types
     My instances represent timestamps.

* Menu:

* DateTime class-information::  (class)
* DateTime class-instance creation::  (class)
* DateTime class-instance creation (non-ANSI)::  (class)
* DateTime-basic::  (instance)
* DateTime-computations::  (instance)
* DateTime-printing::  (instance)
* DateTime-splitting in dates & times::  (instance)
* DateTime-storing::  (instance)
* DateTime-testing::  (instance)
* DateTime-time zones::  (instance)


File: gst-base.info,  Node: DateTime class-information,  Next: DateTime class-instance creation,  Up: DateTime

DateTime class: information
---------------------------

clockPrecision
     Answer `ClockPrecision'.

initialize
     Initialize the receiver's class variables



File: gst-base.info,  Node: DateTime class-instance creation,  Next: DateTime class-instance creation (non-ANSI),  Prev: DateTime class-information,  Up: DateTime

DateTime class: instance creation
---------------------------------

now
     Answer an instance of the receiver referring to the current date
     and time.

readFrom: aStream
     Parse an instance of the receiver from aStream

year: y day: d hour: h minute: min second: s
     Answer a DateTime denoting the d-th day of the given year, and
     setting the time part to the given hour, minute, and second

year: y day: d hour: h minute: min second: s offset: ofs
     Answer a DateTime denoting the d-th day of the given year.  Set
     the offset field to ofs (a Duration), and the time part to the
     given hour, minute, and second

year: y month: m day: d hour: h minute: min second: s
     Answer a DateTime denoting the d-th day of the given (as a number)
     month and year, setting the time part to the given hour, minute,
     and second

year: y month: m day: d hour: h minute: min second: s offset: ofs
     Answer a DateTime denoting the d-th day of the given (as a number)
     month and year. Set the offset field to ofs (a Duration), and the
     the time part to the given hour, minute, and second



File: gst-base.info,  Node: DateTime class-instance creation (non-ANSI),  Next: DateTime-basic,  Prev: DateTime class-instance creation,  Up: DateTime

DateTime class: instance creation (non-ANSI)
--------------------------------------------

fromDays: days seconds: secs offset: ofs
     Answer a DateTime denoting the d-th day of the given (as a number)
     month and year. Set the offset field to ofs (a Duration), and the
     the time part to the given hour, minute, and second



File: gst-base.info,  Node: DateTime-basic,  Next: DateTime-computations,  Prev: DateTime class-instance creation (non-ANSI),  Up: DateTime

DateTime: basic
---------------

+ aDuration
     Answer a new Date pointing dayCount past the receiver

- aDateTimeOrDuration
     Answer a new Date pointing dayCount before the receiver



File: gst-base.info,  Node: DateTime-computations,  Next: DateTime-printing,  Prev: DateTime-basic,  Up: DateTime

DateTime: computations
----------------------

asSeconds
     Answer the date as the number of seconds from 1/1/1901.

dayOfWeek
     Answer the day of week of the receiver. Unlike Dates, DateAndTimes
     have 1 = Sunday, 7 = Saturday

hour
     Answer the hour in a 24-hour clock

hour12
     Answer the hour in a 12-hour clock

hour24
     Answer the hour in a 24-hour clock

meridianAbbreviation
     Answer either #AM (for anti-meridian) or #PM (for post-meridian)

minute
     Answer the minute

second
     Answer the month represented by the receiver



File: gst-base.info,  Node: DateTime-printing,  Next: DateTime-splitting in dates & times,  Prev: DateTime-computations,  Up: DateTime

DateTime: printing
------------------

printOn: aStream
     Print a representation for the receiver on aStream



File: gst-base.info,  Node: DateTime-splitting in dates & times,  Next: DateTime-storing,  Prev: DateTime-printing,  Up: DateTime

DateTime: splitting in dates & times
------------------------------------

asDate
     Answer a Date referring to the same day as the receiver

asTime
     Answer a Time referring to the same time (from midnight) as the
     receiver

at: anIndex
     Since in the past timestamps were referred to as Arrays containing
     a Date and a Time (in this order), this method provides access to
     DateTime objects like if they were two-element Arrays.



File: gst-base.info,  Node: DateTime-storing,  Next: DateTime-testing,  Prev: DateTime-splitting in dates & times,  Up: DateTime

DateTime: storing
-----------------

storeOn: aStream
     Store on aStream Smalltalk code compiling to the receiver



File: gst-base.info,  Node: DateTime-testing,  Next: DateTime-time zones,  Prev: DateTime-storing,  Up: DateTime

DateTime: testing
-----------------

< aDateTime
     Answer whether the receiver indicates a date preceding aDate

= aDateTime
     Answer whether the receiver indicates the same date as aDate

hash
     Answer an hash value for the receievr



File: gst-base.info,  Node: DateTime-time zones,  Prev: DateTime-testing,  Up: DateTime

DateTime: time zones
--------------------

asLocal
     Answer the receiver, since DateTime objects store themselves in
     Local time

asUTC
     Convert the receiver to UTC time, and answer a new DateTime object.

offset
     Answer the receiver's offset from UTC to local time (e.g. +3600
     seconds for Central Europe Time, -3600*6 seconds for Eastern
     Standard Time).  The offset is expressed as a Duration

offset: anOffset
     Answer a copy of the receiver with the offset from UTC to local
     time changed to anOffset (a Duration).

timeZoneAbbreviation
     Answer an abbreviated indication of the receiver's offset,
     expressed as `shhmm', where `hh' is the number of hours and `mm'
     is the number of minutes between UTC and local time, and `s' can
     be `+' for the Eastern hemisphere and `-' for the Western
     hemisphere.

timeZoneName
     Answer the time zone name for the receiver (currently, it is
     simply `GMT +xxxx', where `xxxx' is the receiver's
     #timeZoneAbbreviation).



File: gst-base.info,  Node: Delay,  Next: DelayedAdaptor,  Prev: DateTime,  Up: Base classes

Delay
=====

Defined in namespace Smalltalk
Superclass: Object
Category: Language-Processes
     I am the ultimate agent for frustration in the world.  I cause
     things to wait (typically much more than is appropriate, but it is
     those losing operating systems' fault).  When a process sends one
     of my instances a wait message, that process goes to sleep for the
     interval specified when the instance was created.

* Menu:

* Delay class-general inquiries::  (class)
* Delay class-initialization::  (class)
* Delay class-instance creation::  (class)
* Delay-accessing::  (instance)
* Delay-comparing::  (instance)
* Delay-process delay::  (instance)


File: gst-base.info,  Node: Delay class-general inquiries,  Next: Delay class-initialization,  Up: Delay

Delay class: general inquiries
------------------------------

millisecondClockValue
     Private - Answer the number of milliseconds since midnight



File: gst-base.info,  Node: Delay class-initialization,  Next: Delay class-instance creation,  Prev: Delay class-general inquiries,  Up: Delay

Delay class: initialization
---------------------------

initialize
     Private - Initialize the receiver and the associated process



File: gst-base.info,  Node: Delay class-instance creation,  Next: Delay-accessing,  Prev: Delay class-initialization,  Up: Delay

Delay class: instance creation
------------------------------

forMilliseconds: millisecondCount
     Answer a Delay waiting for millisecondCount milliseconds

forSeconds: secondCount
     Answer a Delay waiting for secondCount seconds

untilMilliseconds: millisecondCount
     Answer a Delay waiting for millisecondCount milliseconds after
     midnight



File: gst-base.info,  Node: Delay-accessing,  Next: Delay-comparing,  Prev: Delay class-instance creation,  Up: Delay

Delay: accessing
----------------

resumptionTime
     Answer the time when a process waiting on a Delay will resume



File: gst-base.info,  Node: Delay-comparing,  Next: Delay-process delay,  Prev: Delay-accessing,  Up: Delay

Delay: comparing
----------------

= aDelay
     Answer whether the receiver and aDelay denote the same delay

hash
     Answer an hash value for the receiver



File: gst-base.info,  Node: Delay-process delay,  Prev: Delay-comparing,  Up: Delay

Delay: process delay
--------------------

wait
     Wait until the amount of time represented by the instance of Delay
     elapses



File: gst-base.info,  Node: DelayedAdaptor,  Next: Dictionary,  Prev: Delay,  Up: Base classes

DelayedAdaptor
==============

Defined in namespace Smalltalk
Superclass: PluggableAdaptor
Category: Language-Data types
     I can be used where many expensive updates must be performed. My
     in- stances buffer the last value that was set, and only actually
     set the value when the #trigger message is sent. Apart from this,
     I'm equi- valent to PluggableAdaptor.

* Menu:

* DelayedAdaptor-accessing::  (instance)


File: gst-base.info,  Node: DelayedAdaptor-accessing,  Up: DelayedAdaptor

DelayedAdaptor: accessing
-------------------------

trigger
     Really set the value of the receiver.

value
     Get the value of the receiver.

value: anObject
     Set the value of the receiver - actually, the value is cached and
     is not set until the #trigger method is sent.



File: gst-base.info,  Node: Dictionary,  Next: DirectedMessage,  Prev: DelayedAdaptor,  Up: Base classes

Dictionary
==========

Defined in namespace Smalltalk
Superclass: HashedCollection
Category: Collections-Keyed
     I implement a dictionary, which is an object that is indexed by
     unique objects (typcially instances of Symbol), and associates
     another object with that index.  I use the equality operator = to
     determine equality of indices.

* Menu:

* Dictionary class-instance creation::  (class)
* Dictionary-accessing::  (instance)
* Dictionary-awful ST-80 compatibility hacks::  (instance)
* Dictionary-dictionary enumerating::  (instance)
* Dictionary-dictionary removing::  (instance)
* Dictionary-dictionary testing::  (instance)
* Dictionary-polymorphism hacks::  (instance)
* Dictionary-printing::  (instance)
* Dictionary-rehashing::  (instance)
* Dictionary-storing::  (instance)
* Dictionary-testing::  (instance)


File: gst-base.info,  Node: Dictionary class-instance creation,  Next: Dictionary-accessing,  Up: Dictionary

Dictionary class: instance creation
-----------------------------------

new
     Create a new dictionary with a default size



File: gst-base.info,  Node: Dictionary-accessing,  Next: Dictionary-awful ST-80 compatibility hacks,  Prev: Dictionary class-instance creation,  Up: Dictionary

Dictionary: accessing
---------------------

add: newObject
     Add the newObject association to the receiver

associationAt: key
     Answer the key/value Association for the given key. Fail if the key
     is not found

associationAt: key ifAbsent: aBlock
     Answer the key/value Association for the given key. Evaluate aBlock
     (answering the result) if the key is not found

at: key
     Answer the value associated to the given key. Fail if the key is
     not found

at: key ifAbsent: aBlock
     Answer the value associated to the given key, or the result of
     evaluating aBlock if the key is not found

at: aKey ifAbsentPut: aBlock
     Answer the value associated to the given key. If the key is not
     found, evaluate aBlock and associate the result to aKey before
     returning.

at: aKey ifPresent: aBlock
     If aKey is absent, answer nil. Else, evaluate aBlock passing the
     associated value and answer the result of the invocation

at: key put: value
     Store value as associated to the given key

keyAtValue: value
     Answer the key associated to the given value, or nil if the value
     is not found

keyAtValue: value ifAbsent: exceptionBlock
     Answer the key associated to the given value. Evaluate
     exceptionBlock (answering the result) if the value is not found.
     IMPORTANT: == is used to compare values

keys
     Answer a kind of Set containing the keys of the receiver

values
     Answer an Array containing the values of the receiver



File: gst-base.info,  Node: Dictionary-awful ST-80 compatibility hacks,  Next: Dictionary-dictionary enumerating,  Prev: Dictionary-accessing,  Up: Dictionary

Dictionary: awful ST-80 compatibility hacks
-------------------------------------------

findKeyIndex: key
     Tries to see if key exists as a the key of an indexed variable. As
     soon as nil or an association with the correct key is found, the
     index of that slot is answered



File: gst-base.info,  Node: Dictionary-dictionary enumerating,  Next: Dictionary-dictionary removing,  Prev: Dictionary-awful ST-80 compatibility hacks,  Up: Dictionary

Dictionary: dictionary enumerating
----------------------------------

associationsDo: aBlock
     Pass each association in the dictionary to aBlock

collect: aBlock
     Answer a new dictionary where the keys are the same and the values
     are obtained by passing each value to aBlock and collecting the
     return values

do: aBlock
     Pass each value in the dictionary to aBlock

keysAndValuesDo: aBlock
     Pass each key/value pair in the dictionary as two distinct
     parameters to aBlock

keysDo: aBlock
     Pass each key in the dictionary to aBlock

reject: aBlock
     Answer a new dictionary containing the key/value pairs for which
     aBlock returns false. aBlock only receives the value part of the
     pairs.

select: aBlock
     Answer a new dictionary containing the key/value pairs for which
     aBlock returns true. aBlock only receives the value part of the
     pairs.



File: gst-base.info,  Node: Dictionary-dictionary removing,  Next: Dictionary-dictionary testing,  Prev: Dictionary-dictionary enumerating,  Up: Dictionary

Dictionary: dictionary removing
-------------------------------

remove: anAssociation
     Remove anAssociation's key from the dictionary

remove: anAssociation ifAbsent: aBlock
     Remove anAssociation's key from the dictionary

removeAllKeys: keys
     Remove all the keys in keys, without raising any errors

removeAllKeys: keys ifAbsent: aBlock
     Remove all the keys in keys, passing the missing keys as parameters
     to aBlock as they're encountered

removeKey: key
     Remove the passed key from the dictionary, fail if it is not found

removeKey: key ifAbsent: aBlock
     Remove the passed key from the dictionary, answer the result of
     evaluating aBlock if it is not found



File: gst-base.info,  Node: Dictionary-dictionary testing,  Next: Dictionary-polymorphism hacks,  Prev: Dictionary-dictionary removing,  Up: Dictionary

Dictionary: dictionary testing
------------------------------

includes: anObject
     Answer whether the receiver contains anObject as one of its values

includesAssociation: anAssociation
     Answer whether the receiver contains the key which is
     anAssociation's key and its value is anAssociation's value

includesKey: key
     Answer whether the receiver contains the given key

occurrencesOf: aValue
     Answer whether the number of occurrences of aValue as one of the
     receiver's values



File: gst-base.info,  Node: Dictionary-polymorphism hacks,  Next: Dictionary-printing,  Prev: Dictionary-dictionary testing,  Up: Dictionary

Dictionary: polymorphism hacks
------------------------------

withAllSuperspaces
     This method is needed by the compiler



File: gst-base.info,  Node: Dictionary-printing,  Next: Dictionary-rehashing,  Prev: Dictionary-polymorphism hacks,  Up: Dictionary

Dictionary: printing
--------------------

inspect
     Print all the instance variables and objects in the receiver on the
     Transcript

printOn: aStream
     Print a representation of the receiver on aStream



File: gst-base.info,  Node: Dictionary-rehashing,  Next: Dictionary-storing,  Prev: Dictionary-printing,  Up: Dictionary

Dictionary: rehashing
---------------------

rehash
     Rehash the receiver



File: gst-base.info,  Node: Dictionary-storing,  Next: Dictionary-testing,  Prev: Dictionary-rehashing,  Up: Dictionary

Dictionary: storing
-------------------

storeOn: aStream
     Print Smalltalk code compiling to the receiver on aStream



File: gst-base.info,  Node: Dictionary-testing,  Prev: Dictionary-storing,  Up: Dictionary

Dictionary: testing
-------------------

= aDictionary
     Answer whether the receiver and aDictionary are equal

hash
     Answer the hash value for the receiver



File: gst-base.info,  Node: DirectedMessage,  Next: Directory,  Prev: Dictionary,  Up: Base classes

DirectedMessage
===============

Defined in namespace Smalltalk
Superclass: Message
Category: Language-Implementation
     I represent a message send: I contain the receiver, selector and
     arguments for a message.

* Menu:

* DirectedMessage class-creating instances::  (class)
* DirectedMessage-accessing::  (instance)
* DirectedMessage-basic::  (instance)
* DirectedMessage-multiple process::  (instance)
* DirectedMessage-saving and loading::  (instance)


File: gst-base.info,  Node: DirectedMessage class-creating instances,  Next: DirectedMessage-accessing,  Up: DirectedMessage

DirectedMessage class: creating instances
-----------------------------------------

selector: aSymbol arguments: anArray
     This method should not be called for instances of this class.

selector: aSymbol arguments: anArray receiver: anObject
     Create a new instance of the receiver



File: gst-base.info,  Node: DirectedMessage-accessing,  Next: DirectedMessage-basic,  Prev: DirectedMessage class-creating instances,  Up: DirectedMessage

DirectedMessage: accessing
--------------------------

receiver
     Answer the receiver

receiver: anObject
     Change the receiver



File: gst-base.info,  Node: DirectedMessage-basic,  Next: DirectedMessage-multiple process,  Prev: DirectedMessage-accessing,  Up: DirectedMessage

DirectedMessage: basic
----------------------

printOn: aStream
     Print a representation of the receiver on aStream

send
     Send the message

value
     Send the message (this message provides interoperability between
     DirectedMessages and blocks)



File: gst-base.info,  Node: DirectedMessage-multiple process,  Next: DirectedMessage-saving and loading,  Prev: DirectedMessage-basic,  Up: DirectedMessage

DirectedMessage: multiple process
---------------------------------

fork
     Create a new process executing the receiver and start it

forkAt: priority
     Create a new process executing the receiver with given priority
     and start it

newProcess
     Create a new process executing the receiver in suspended state.
     The priority is the same as for the calling process. The receiver
     must not contain returns



File: gst-base.info,  Node: DirectedMessage-saving and loading,  Prev: DirectedMessage-multiple process,  Up: DirectedMessage

DirectedMessage: saving and loading
-----------------------------------

reconstructOriginalObject
     This method is used when DirectedMessages are used together with
     PluggableProxies (see ObjectDumper).  It sends the receiver to
     reconstruct the object that was originally stored.



File: gst-base.info,  Node: Directory,  Next: DLD,  Prev: DirectedMessage,  Up: Base classes

Directory
=========

Defined in namespace Smalltalk
Superclass: File
Category: Streams-Files
     I am the counterpart of File in a tree-structured file system: I
     can iterate through the file that I contain and construct new
     instances of File and Directory.  In addition I have the notion of
     a current working directory (which alas must be a real directory
     and not a virtual one).

* Menu:

* Directory class-C functions::  (class)
* Directory class-file name management::  (class)
* Directory class-file operations::  (class)
* Directory class-reading system defaults::  (class)
* Directory-accessing::  (instance)
* Directory-enumerating::  (instance)


File: gst-base.info,  Node: Directory class-C functions,  Next: Directory class-file name management,  Up: Directory

Directory class: C functions
----------------------------

primWorking: dirName
     C call-out to chdir. Do not modify!

working
     C call-out to getCurDirName. Do not modify!



File: gst-base.info,  Node: Directory class-file name management,  Next: Directory class-file operations,  Prev: Directory class-C functions,  Up: Directory

Directory class: file name management
-------------------------------------

append: fileName to: directory
     Answer the name of a file named `fileName' which resides in a
     directory named `directory'.

pathSeparator
     Answer (as a Character) the character used to separate directory
     names

pathSeparatorString
     Answer (in a String) the character used to separate directory names



File: gst-base.info,  Node: Directory class-file operations,  Next: Directory class-reading system defaults,  Prev: Directory class-file name management,  Up: Directory

Directory class: file operations
--------------------------------

create: dirName
     Create a directory named dirName.

working: dirName
     Change the current working directory to dirName.



File: gst-base.info,  Node: Directory class-reading system defaults,  Next: Directory-accessing,  Prev: Directory class-file operations,  Up: Directory

Directory class: reading system defaults
----------------------------------------

home
     Answer the path to the user's home directory

image
     Answer the path to GNU Smalltalk's image file

kernel
     Answer the path in which a local version of the GNU Smalltalk
     kernel's Smalltalk source files were searched when the image was
     created

localKernel
     Answer the path in which a local version of the GNU Smalltalk
     kernel's Smalltalk source files were found

module
     Answer the path to GNU Smalltalk's dynamically loaded modules

systemKernel
     Answer the path to the GNU Smalltalk kernel's Smalltalk source
     files

temporary
     Answer the path in which temporary files can be created.  This is
     read from the environment, and guessed if that fails.



File: gst-base.info,  Node: Directory-accessing,  Next: Directory-enumerating,  Prev: Directory class-reading system defaults,  Up: Directory

Directory: accessing
--------------------

at: aName
     Answer a File object for a file named `aName' residing in the
     directory represented by the receiver.

directoryAt: aName
     Answer a Directory object for a file named `aName' residing in the
     directory represented by the receiver.

fullNameAt: aName
     Answer a String containing the full path to a file named `aName'
     which resides in the directory represented by the receiver.

includes: aName
     Answer whether a file named `aName' exists in the directory
     represented by the receiver.

nameAt: aName
     Answer a String containing the path to a file named `aName' which
     resides in the directory represented by the receiver.



File: gst-base.info,  Node: Directory-enumerating,  Prev: Directory-accessing,  Up: Directory

Directory: enumerating
----------------------

contents
     Answer an Array with the names of the files in the directory
     represented by the receiver.

do: aBlock
     Evaluate aBlock once for each file in the directory represented by
     the receiver, passing its name. aBlock should not return.

filesMatching: aPattern do: block
     Evaluate block on the File objects that match aPattern (according
     to String>>#match:) in the directory named by the receiver.

namesMatching: aPattern do: block
     Evaluate block on the file names that match aPattern (according to
     String>>#match:) in the directory named by the receiver.



File: gst-base.info,  Node: DLD,  Next: DumperProxy,  Prev: Directory,  Up: Base classes

DLD
===

Defined in namespace Smalltalk
Superclass: Object
Category: Language-C interface
     ...and Gandalf said: "Many folk like to know beforehand what is to
     be set on the table; but those who have laboured to prepare the
     feast like to keep their secret; for wonder makes the words of
     praise louder."

     I am just an ancillary class used to reference some C functions.
     Most of my actual functionality is used by redefinitions of methods
     in CFunctionDescriptor.

* Menu:

* DLD class-C functions::  (class)
* DLD class-dynamic linking::  (class)


File: gst-base.info,  Node: DLD class-C functions,  Next: DLD class-dynamic linking,  Up: DLD

DLD class: C functions
----------------------

defineCFunc: aName as: aFuncAddr
     C call-out to defineCFunc. Do not modify!

library: libHandle getFunc: aFuncString
     C call-out to dldGetFunc. Do not modify!

linkFile: aFileName
     C call-out to dldLink. Do not modify!



File: gst-base.info,  Node: DLD class-dynamic linking,  Prev: DLD class-C functions,  Up: DLD

DLD class: dynamic linking
--------------------------

addLibrary: library
     Add library to the search path of libraries to be used by DLD.

addModule: library
     Add library to the list of modules to be loaded when the image is
     started.  The gst_initModule function in the library is called,
     but the library will not be put in the search path used whenever a
     C function is requested but not registered.

defineExternFunc: aFuncName
     This method calls #primDefineExternFunc: to try to link to a
     function with the given name, and answers whether the linkage was
     successful. You can redefine this method to restrict the ability
     to do dynamic linking.

initialize
     Private - Initialize the receiver's class variables

libraryList
     Answer a copy of the search path of libraries to be used by DLD

moduleList
     Answer a copy of the modules reloaded when the image is started

primDefineExternFunc: aFuncName
     This method tries to link to a function with the given name, and
     answers whether the linkage was successful. It should not be
     overridden.

update: aspect
     Called on startup - Make DLD re-link and reset the addresses of
     all the externally defined functions



File: gst-base.info,  Node: DumperProxy,  Next: Duration,  Prev: DLD,  Up: Base classes

DumperProxy
===========

Defined in namespace Smalltalk
Superclass: Object
Category: Streams-Files
     I am an helper class for ObjectDumper. When an object cannot be
     saved in the standard way, you can register a subclass of me to
     provide special means to save that object.

* Menu:

* DumperProxy class-accessing::  (class)
* DumperProxy class-instance creation::  (class)
* DumperProxy-saving and restoring::  (instance)


File: gst-base.info,  Node: DumperProxy class-accessing,  Next: DumperProxy class-instance creation,  Up: DumperProxy

DumperProxy class: accessing
----------------------------

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

loadFrom: anObjectDumper
     Reload a proxy stored in anObjectDumper and reconstruct the object



File: gst-base.info,  Node: DumperProxy class-instance creation,  Next: DumperProxy-saving and restoring,  Prev: DumperProxy class-accessing,  Up: DumperProxy

DumperProxy class: instance creation
------------------------------------

on: anObject
     Answer a proxy to be used to save anObject. This method MUST be
     overridden and anObject must NOT be stored in the object's
     instance variables unless you override #dumpTo:, because that
     would result in an infinite loop!



File: gst-base.info,  Node: DumperProxy-saving and restoring,  Prev: DumperProxy class-instance creation,  Up: DumperProxy

DumperProxy: saving and restoring
---------------------------------

dumpTo: anObjectDumper
     Dump the proxy to anObjectDumper - the #loadFrom: class method
     will reconstruct the original object.

object
     Reconstruct the object stored in the proxy and answer it



File: gst-base.info,  Node: Duration,  Next: Error,  Prev: DumperProxy,  Up: Base classes

Duration
========

Defined in namespace Smalltalk
Superclass: Time
Category: Language-Data types
     My instances represent differences between timestamps.

* Menu:

* Duration class-instance creation::  (class)
* Duration class-instance creation (non ANSI)::  (class)
* Duration-arithmetics::  (instance)


File: gst-base.info,  Node: Duration class-instance creation,  Next: Duration class-instance creation (non ANSI),  Up: Duration

Duration class: instance creation
---------------------------------

days: d
     Answer a duration of `d' days

days: d hours: h minutes: m seconds: s
     Answer a duration of `d' days and the given number of hours,
     minutes, and seconds.

initialize
     Initialize the receiver's instance variables

zero
     Answer a duration of zero seconds.



File: gst-base.info,  Node: Duration class-instance creation (non ANSI),  Next: Duration-arithmetics,  Prev: Duration class-instance creation,  Up: Duration

Duration class: instance creation (non ANSI)
--------------------------------------------

fromDays: days seconds: secs offset: unused
     Answer a duration of `d' days and `secs' seconds.  The last
     parameter is unused; this message is available for interoperability
     with the DateTime class.



File: gst-base.info,  Node: Duration-arithmetics,  Prev: Duration class-instance creation (non ANSI),  Up: Duration

Duration: arithmetics
---------------------

* factor
     Answer a Duration that is `factor' times longer than the receiver

+ aDuration
     Answer a Duration that is the sum of the receiver and aDuration's
     lengths.

- aDuration
     Answer a Duration that is the difference of the receiver and
     aDuration's lengths.

/ factorOrDuration
     If the parameter is a Duration, answer the ratio between the
     receiver and factorOrDuration.  Else divide the receiver by
     factorOrDuration (a Number) and answer a new Duration that is
     correspondingly shorter.

abs
     Answer a Duration that is as long as the receiver, but always in
     the future.

days
     Answer the number of days in the receiver

negated
     Answer a Duration that is as long as the receiver, but with past
     and future exchanged.

negative
     Answer whether the receiver is in the past.

positive
     Answer whether the receiver is a zero-second duration or is in the
     future.

printOn: aStream
     Print a represention of the receiver on aStream.



File: gst-base.info,  Node: Error,  Next: Exception,  Prev: Duration,  Up: Base classes

Error
=====

Defined in namespace Smalltalk
Superclass: Exception
Category: Language-Exceptions
     Error represents a fatal error.  Instances of it are not resumable.

* Menu:

* Error-exception description::  (instance)


File: gst-base.info,  Node: Error-exception description,  Up: Error

Error: exception description
----------------------------

description
     Answer a textual description of the exception.

isResumable
     Answer false.  Error exceptions are by default unresumable;
     subclasses can override this method if desired.



File: gst-base.info,  Node: Exception,  Next: ExceptionSet,  Prev: Error,  Up: Base classes

Exception
=========

Defined in namespace Smalltalk
Superclass: Signal
Category: Language-Exceptions
     An Exception defines the characteristics of an exceptional event
     in a different way than CoreExceptions.  Instead of creating an
     hierarchy of objects and setting attributes of the objects, you
     create an hierarchy of classes and override methods in those
     classes; instances of those classes are passed to the handlers
     instead of instances of the common class Signal.

     Internally, Exception and every subclass of it hold onto a
     CoreException, so the two mechanisms are actually interchangeable.

* Menu:

* Exception class-comparison::  (class)
* Exception class-creating ExceptionCollections::  (class)
* Exception class-initialization::  (class)
* Exception class-instance creation::  (class)
* Exception class-interoperability with TrappableEvents::  (class)
* Exception-comparison::  (instance)
* Exception-exception description::  (instance)
* Exception-exception signaling::  (instance)


File: gst-base.info,  Node: Exception class-comparison,  Next: Exception class-creating ExceptionCollections,  Up: Exception

Exception class: comparison
---------------------------

goodness: anException
     Answer how good the receiver is at handling the given exception.  A
     negative value indicates that the receiver is not able to handle
     the exception.

handles: anException
     Answer whether the receiver handles `anException'.



File: gst-base.info,  Node: Exception class-creating ExceptionCollections,  Next: Exception class-initialization,  Prev: Exception class-comparison,  Up: Exception

Exception class: creating ExceptionCollections
----------------------------------------------

, aTrappableEvent
     Answer an ExceptionCollection containing all the exceptions in the
     receiver and all the exceptions in aTrappableEvent



File: gst-base.info,  Node: Exception class-initialization,  Next: Exception class-instance creation,  Prev: Exception class-creating ExceptionCollections,  Up: Exception

Exception class: initialization
-------------------------------

initialize
     Initialize the `links' between the core exception handling system
     and the ANSI exception handling system.



File: gst-base.info,  Node: Exception class-instance creation,  Next: Exception class-interoperability with TrappableEvents,  Prev: Exception class-initialization,  Up: Exception

Exception class: instance creation
----------------------------------

new
     Create an instance of the receiver, which you will be able to
     signal later.

signal
     Create an instance of the receiver, give it default attributes,
     and signal it immediately.

signal: messageText
     Create an instance of the receiver, set its message text, and
     signal it immediately.



File: gst-base.info,  Node: Exception class-interoperability with TrappableEvents,  Next: Exception-comparison,  Prev: Exception class-instance creation,  Up: Exception

Exception class: interoperability with TrappableEvents
------------------------------------------------------

allExceptionsDo: aBlock
     Private - Pass the coreException to aBlock

coreException
     Private - Answer the coreException which represents instances of
     the receiver

whenSignalledIn: onDoBlock do: handlerBlock exitBlock: exitBlock
     Private - Create an ExceptionHandler from the arguments and
     register it



File: gst-base.info,  Node: Exception-comparison,  Next: Exception-exception description,  Prev: Exception class-interoperability with TrappableEvents,  Up: Exception

Exception: comparison
---------------------

= anObject
     Answer whether the receiver is equal to anObject.  This is true if
     either the receiver or its coreException are the same object as
     anObject.

hash
     Answer an hash value for the receiver.



File: gst-base.info,  Node: Exception-exception description,  Next: Exception-exception signaling,  Prev: Exception-comparison,  Up: Exception

Exception: exception description
--------------------------------

defaultAction
     Execute the default action that is attached to the receiver.

description
     Answer a textual description of the exception.

isResumable
     Answer true.  Exceptions are by default resumable.



File: gst-base.info,  Node: Exception-exception signaling,  Prev: Exception-exception description,  Up: Exception

Exception: exception signaling
------------------------------

signal
     Raise the exceptional event represented by the receiver

signal: messageText
     Raise the exceptional event represented by the receiver, setting
     its message text to messageText.



File: gst-base.info,  Node: ExceptionSet,  Next: False,  Prev: Exception,  Up: Base classes

ExceptionSet
============

Defined in namespace Smalltalk
Superclass: TrappableEvent
Category: Language-Exceptions
     My instances are not real exceptions: they can only be used as
     arguments to #on:do:... methods in BlockClosure. They act as
     shortcuts that allows you to use the same handler for many
     exceptions without having to write duplicate code

* Menu:

* ExceptionSet class-instance creation::  (class)
* ExceptionSet-enumerating::  (instance)


File: gst-base.info,  Node: ExceptionSet class-instance creation,  Next: ExceptionSet-enumerating,  Up: ExceptionSet

ExceptionSet class: instance creation
-------------------------------------

new
     Private - Answer a new, empty ExceptionSet



File: gst-base.info,  Node: ExceptionSet-enumerating,  Prev: ExceptionSet class-instance creation,  Up: ExceptionSet

ExceptionSet: enumerating
-------------------------

allExceptionsDo: aBlock
     Private - Evaluate aBlock for every exception in the receiver.
     Answer the receiver

goodness: exception
     Answer how good the receiver is at handling the given exception.  A
     negative value indicates that the receiver is not able to handle
     the exception.

handles: exception
     Answer whether the receiver handles `exception'.



File: gst-base.info,  Node: False,  Next: File,  Prev: ExceptionSet,  Up: Base classes

False
=====

Defined in namespace Smalltalk
Superclass: Boolean
Category: Language-Data types
     I always tell lies.  I have a single instance in the system, which
     represents the value false.

* Menu:

* False-basic::  (instance)
* False-C hacks::  (instance)
* False-printing::  (instance)


File: gst-base.info,  Node: False-basic,  Next: False-C hacks,  Up: False

False: basic
------------

& aBoolean
     We are false - anded with anything, we always answer false

and: aBlock
     We are false - anded with anything, we always answer false

eqv: aBoolean
     Answer whether the receiver and aBoolean represent the same
     boolean value

ifFalse: falseBlock
     We are false - evaluate the falseBlock

ifFalse: falseBlock ifTrue: trueBlock
     We are false - evaluate the falseBlock

ifTrue: trueBlock
     We are false - answer nil

ifTrue: trueBlock ifFalse: falseBlock
     We are false - evaluate the falseBlock

not
     We are false - answer true

or: aBlock
     We are false - ored with anything, we always answer the other
     operand, so evaluate aBlock

xor: aBoolean
     Answer whether the receiver and aBoolean represent different
     boolean values

| aBoolean
     We are false - ored with anything, we always answer the other
     operand



File: gst-base.info,  Node: False-C hacks,  Next: False-printing,  Prev: False-basic,  Up: False

False: C hacks
--------------

asCBooleanValue
     Answer `0'.



File: gst-base.info,  Node: False-printing,  Prev: False-C hacks,  Up: False

False: printing
---------------

printOn: aStream
     Print a representation of the receiver on aStream



File: gst-base.info,  Node: File,  Next: FileDescriptor,  Prev: False,  Up: Base classes

File
====

Defined in namespace Smalltalk
Superclass: Object
Category: Streams-Files
     I expose the syntax of file names, including paths.  I know how to
     manipulate such a path by splitting it into its components.  In
     addition, I expose information about files (both real and virtual)
     such as their size and timestamps.

* Menu:

* File class-C functions::  (class)
* File class-file name management::  (class)
* File class-file operations::  (class)
* File class-instance creation::  (class)
* File class-reading system defaults::  (class)
* File class-testing::  (class)
* File-accessing::  (instance)
* File-file name management::  (instance)
* File-file operations::  (instance)
* File-testing::  (instance)


File: gst-base.info,  Node: File class-C functions,  Next: File class-file name management,  Up: File

File class: C functions
-----------------------

errno
     C call-out to errno. Do not modify!

stringError: errno
     C call-out to strerror. Do not modify!



File: gst-base.info,  Node: File class-file name management,  Next: File class-file operations,  Prev: File class-C functions,  Up: File

File class: file name management
--------------------------------

extensionFor: aString
     Answer the extension of a file named `aString'.  Note: the
     extension includes an initial dot.

fullNameFor: aString
     Answer the full path to a file called `aString', resolving the `.'
     and `..' directory entries, and answer the result.  `/..' is the
     same as '/'.

pathFor: aString
     Determine the path of the name of a file called `aString', and
     answer the result.  With the exception of the root directory, the
     final slash is stripped.

stripExtensionFrom: aString
     Remove the extension from the name of a file called `aString', and
     answer the result.

stripFileNameFor: aString
     Determine the path of the name of a file called `aString', and
     answer the result as a directory name including the final slash.

stripPathFrom: aString
     Remove the path from the name of a file called `aString', and
     answer the file name plus extension.



File: gst-base.info,  Node: File class-file operations,  Next: File class-instance creation,  Prev: File class-file name management,  Up: File

File class: file operations
---------------------------

checkError
     Return whether an error had been reported or not.  If there had
     been one, raise an exception too

checkError: errno
     The error with the C code `errno' has been reported.  If errno >=
     1, raise an exception

remove: fileName
     Remove the file with the given path name

rename: oldFileName to: newFileName
     Rename the file with the given path name oldFileName to newFileName



File: gst-base.info,  Node: File class-instance creation,  Next: File class-reading system defaults,  Prev: File class-file operations,  Up: File

File class: instance creation
-----------------------------

name: aName
     Answer a new file with the given path. The path is not validated
     until some of the fields of the newly created objects are accessed

on: aVFSHandler
     Answer a new file with the given path. The handler that returns
     the information is aVFSHandler



File: gst-base.info,  Node: File class-reading system defaults,  Next: File class-testing,  Prev: File class-instance creation,  Up: File

File class: reading system defaults
-----------------------------------

image
     Answer the full path to the image being used.



File: gst-base.info,  Node: File class-testing,  Next: File-accessing,  Prev: File class-reading system defaults,  Up: File

File class: testing
-------------------

exists: fileName
     Answer whether a file with the given name exists

isAccessible: fileName
     Answer whether a directory with the given name exists and can be
     accessed

isExecutable: fileName
     Answer whether a file with the given name exists and can be
     executed

isReadable: fileName
     Answer whether a file with the given name exists and is readable

isWriteable: fileName
     Answer whether a file with the given name exists and is writeable



File: gst-base.info,  Node: File-accessing,  Next: File-file name management,  Prev: File class-testing,  Up: File

File: accessing
---------------

creationTime
     Answer the creation time of the file identified by the receiver.
     On some operating systems, this could actually be the last change
     time (the `last change time' has to do with permissions, ownership
     and the like).

lastAccessTime
     Answer the last access time of the file identified by the receiver

lastChangeTime
     Answer the last change time of the file identified by the receiver
     (the `last change time' has to do with permissions, ownership and
     the like). On some operating systems, this could actually be the
     file creation time.

lastModifyTime
     Answer the last modify time of the file identified by the receiver
     (the `last modify time' has to do with the actual file contents).

name
     Answer the name of the file identified by the receiver

refresh
     Refresh the statistics for the receiver

size
     Answer the size of the file identified by the receiver



File: gst-base.info,  Node: File-file name management,  Next: File-file operations,  Prev: File-accessing,  Up: File

File: file name management
--------------------------

extension
     Answer the extension of the receiver

fullName
     Answer the full name of the receiver, resolving the `.' and `..'
     directory entries, and answer the result.  Answer nil if the name
     is invalid (such as '/usr/../../badname')

path
     Answer the path (if any) of the receiver

stripExtension
     Answer the path (if any) and file name of the receiver

stripFileName
     Answer the path of the receiver, always including a directory name
     (possibly `.') and the final directory separator

stripPath
     Answer the file name and extension (if any) of the receiver



File: gst-base.info,  Node: File-file operations,  Next: File-testing,  Prev: File-file name management,  Up: File

File: file operations
---------------------

contents
     Open a read-only FileStream on the receiver, read its contents,
     close the stream and answer the contents

open: mode
     Open the receiver in the given mode (as answered by FileStream's
     class constant methods)

open: mode ifFail: aBlock
     Open the receiver in the given mode (as answered by FileStream's
     class constant methods). Upon failure, evaluate aBlock.

openDescriptor: mode
     Open the receiver in the given mode (as answered by FileStream's
     class constant methods). Upon failure, evaluate aBlock.

readStream
     Open a read-only FileStream on the receiver

remove
     Remove the file identified by the receiver

renameTo: newName
     Remove the file identified by the receiver

writeStream
     Open a write-only FileStream on the receiver



File: gst-base.info,  Node: File-testing,  Prev: File-file operations,  Up: File

File: testing
-------------

exists
     Answer whether a file with the name contained in the receiver does
     exist.

isAccessible
     Answer whether a directory with the name contained in the receiver
     does exist and can be accessed

isDirectory
     Answer whether a file with the name contained in the receiver does
     exist and identifies a directory.

isExecutable
     Answer whether a file with the name contained in the receiver does
     exist and is executable

isFile
     Answer whether a file with the name contained in the receiver does
     exist and does not identify a directory.

isReadable
     Answer whether a file with the name contained in the receiver does
     exist and is readable

isWriteable
     Answer whether a file with the name contained in the receiver does
     exist and is writeable



File: gst-base.info,  Node: FileDescriptor,  Next: FileSegment,  Prev: File,  Up: Base classes

FileDescriptor
==============

Defined in namespace Smalltalk
Superclass: ByteStream
Category: Streams-Files
     My instances are what conventional programmers think of as files.
     My instance creation methods accept the name of a disk file (or
     any named file object, such as /dev/rmt0 on UNIX or MTA0: on VMS).
     In addition, they accept a virtual filesystem path like
     `configure.gz#ugz' which can be used to transparently extract or
     decompress files from archives, or do arbitrary processing on the
     files.

* Menu:

* FileDescriptor class-initialization::  (class)
* FileDescriptor class-instance creation::  (class)
* FileDescriptor-accessing::  (instance)
* FileDescriptor-basic::  (instance)
* FileDescriptor-built ins::  (instance)
* FileDescriptor-class type methods::  (instance)
* FileDescriptor-initialize-release::  (instance)
* FileDescriptor-low-level access::  (instance)
* FileDescriptor-overriding inherited methods::  (instance)
* FileDescriptor-printing::  (instance)
* FileDescriptor-testing::  (instance)


File: gst-base.info,  Node: FileDescriptor class-initialization,  Next: FileDescriptor class-instance creation,  Up: FileDescriptor

FileDescriptor class: initialization
------------------------------------

initialize
     Initialize the receiver's class variables

update: aspect
     Close open files before quitting



File: gst-base.info,  Node: FileDescriptor class-instance creation,  Next: FileDescriptor-accessing,  Prev: FileDescriptor class-initialization,  Up: FileDescriptor

FileDescriptor class: instance creation
---------------------------------------

append
     Open for writing.  The file is created if it does not exist.  The
     stream is positioned at the end of the file.

create
     Open for reading and writing.  The file is created if it does not
     exist, otherwise it is truncated.  The stream is positioned at the
     beginning of the file.

fopen: fileName mode: fileMode
     Open fileName in the required mode - answered by #append, #create,
     #readWrite, #read or #write - and fail if the file cannot be
     opened.  Else answer a new FileStream. For mode anyway you can use
     any standard C non-binary fopen mode.  The file will be
     automatically closed upon GC if the object is not referenced
     anymore, but it is better to close it as soon as you're finished
     with it anyway, using #close. To keep a file open even when no
     references exist anymore, send it #removeToBeFinalized

fopen: fileName mode: fileMode ifFail: aBlock
     Open fileName in the required mode - answered by #append, #create,
     #readWrite, #read or #write - and evaluate aBlock if the file
     cannot be opened. Else answer a new FileStream. For mode anyway
     you can use any The file will be automatically closed upon GC if
     the object is not referenced anymore, but it is better to close it
     as soon as you're finished with it anyway, using #close. To keep a
     file open even when no references exist anymore, send it
     #removeToBeFinalized

on: fd
     Open a FileDescriptor on the given file descriptor.  Read-write
     access is assumed.

open: fileName
     Open fileName in read-write mode - fail if the file cannot be
     opened.  Else answer a new FileStream.  The file will be
     automatically closed upon GC if the object is not referenced
     anymore, but you should close it with #close anyway.  To keep a
     file open, send it #removeToBeFinalized

open: fileName mode: fileMode
     Open fileName in the required mode - answered by #append, #create,
     #readWrite, #read or #write - and fail if the file cannot be
     opened.  Else answer a new FileStream. For mode anyway you can use
     any standard C non-binary fopen mode.  fileName can be a `virtual
     filesystem' path, including URLs and '#' suffixes that are
     inspected by the virtual filesystem layers and replaced with tasks
     such as un-gzipping a file or extracting a file from an archive.
     The file will be automatically closed upon GC if the object is not
     referenced anymore, but it is better to close it as soon as you're
     finished with it anyway, using #close. To keep a file open even
     when no references exist anymore, send it #removeToBeFinalized

open: fileName mode: fileMode ifFail: aBlock
     Open fileName in the required mode - answered by #append, #create,
     #readWrite, #read or #write - and evaluate aBlock if the file
     cannot be opened. Else answer a new instance of the receiver. For
     mode anyway you can use any standard C non-binary fopen mode.
     fileName can be a `virtual filesystem' path, including URLs and
     '#' suffixes that are inspected by the virtual filesystem layers
     and replaced with tasks such as un-gzipping a file or extracting a
     file from an archive.  The file will be automatically closed upon
     GC if the object is not referenced anymore, but it is better to
     close it as soon as you're finished with it anyway, using #close.
     To keep a file open even when no references exist anymore, send it
     #removeToBeFinalized

openTemporaryFile: baseName
     Open for writing a file whose name starts with baseName, followed
     by six random alphanumeric characters.  The file is created with
     mode read/write and permissions 0666 or 0600 on most recent
     operating systems (beware, the former behavior might constitute a
     security problem).  The file is opened with the O_EXCL flag,
     guaranteeing that when the method returns successfully we are the
     only user.

popen: commandName dir: direction
     Open a pipe on the given command and fail if the file cannot be
     opened.  Else answer a new FileStream.  The pipe will not be
     automatically closed upon GC, even if the object is not referenced
     anymore, because when you close a pipe you have to wait for the
     associated process to terminate. To enforce automatic closing of
     the pipe, send it #addToBeFinalized.  direction is returned by
     #read or #write ('r' or 'w') and is interpreted from the point of
     view of Smalltalk: reading means Smalltalk reads the standard
     output of the command, writing means Smalltalk writes the standard
     input of the command. The other channel (stdin when reading,
     stdout when writing) is the same as GST's, unless commandName
     alters it.

popen: commandName dir: direction ifFail: aBlock
     Open a pipe on the given command and evaluate aBlock file cannot
     be opened. Else answer a new FileStream.  The pipe will not be
     automatically closed upon GC, even if the object is not referenced
     anymore, because when you close a pipe you have to wait for the
     associated process to terminate. To enforce automatic closing of
     the pipe, send it #addToBeFinalized.  direction is interpreted
     from the point of view of Smalltalk: reading means that Smalltalk
     reads the standard output of the command, writing means that
     Smalltalk writes the standard input of the command

read
     Open text file for reading.  The stream is positioned at the
     beginning of the file.

readWrite
     Open for reading and writing.  The stream is positioned at the
     beginning of the file.

write
     Truncate file to zero length or create text file for writing.  The
     stream is positioned at the beginning of the file.



File: gst-base.info,  Node: FileDescriptor-accessing,  Next: FileDescriptor-basic,  Prev: FileDescriptor class-instance creation,  Up: FileDescriptor

FileDescriptor: accessing
-------------------------

canRead
     Answer whether the file is open and we can read from it

canWrite
     Answer whether the file is open and we can write from it

ensureReadable
     If the file is open, wait until data can be read from it.  The wait
     allows other Processes to run.

ensureWriteable
     If the file is open, wait until we can write to it.  The wait
     allows other Processes to run.

exceptionalCondition
     Answer whether the file is open and an exceptional condition (such
     as presence of out of band data) has occurred on it

fd
     Return the OS file descriptor of the file

isOpen
     Answer whether the file is still open

isPipe
     Answer whether the file is a pipe or an actual disk file

name
     Return the name of the file

waitForException
     If the file is open, wait until an exceptional condition (such as
     presence of out of band data) has occurred on it.  The wait allows
     other Processes to run.



File: gst-base.info,  Node: FileDescriptor-basic,  Next: FileDescriptor-built ins,  Prev: FileDescriptor-accessing,  Up: FileDescriptor

FileDescriptor: basic
---------------------

close
     Close the file

contents
     Answer the whole contents of the file

copyFrom: from to: to
     Answer the contents of the file between the two given positions

finalize
     Close the file if it is still open by the time the object becomes
     garbage.

invalidate
     Invalidate a file descriptor

next
     Return the next character in the file, or nil at eof

nextByte
     Return the next byte in the file, or nil at eof

nextPut: aCharacter
     Store aCharacter on the file

nextPutByte: anInteger
     Store the byte, anInteger, on the file

nextPutByteArray: aByteArray
     Store aByteArray on the file

peek
     Returns the next element of the stream without moving the pointer.
     Returns nil when at end of stream.

position
     Answer the zero-based position from the start of the file

position: n
     Set the file pointer to the zero-based position n

reset
     Reset the stream to its beginning

size
     Return the current size of the file, in bytes

truncate
     Truncate the file at the current position



File: gst-base.info,  Node: FileDescriptor-built ins,  Next: FileDescriptor-class type methods,  Prev: FileDescriptor-basic,  Up: FileDescriptor

FileDescriptor: built ins
-------------------------

fileOp: ioFuncIndex
     Private - Used to limit the number of primitives used by
     FileStreams

fileOp: ioFuncIndex ifFail: aBlock
     Private - Used to limit the number of primitives used by
     FileStreams.

fileOp: ioFuncIndex with: arg1
     Private - Used to limit the number of primitives used by
     FileStreams

fileOp: ioFuncIndex with: arg1 ifFail: aBlock
     Private - Used to limit the number of primitives used by
     FileStreams.

fileOp: ioFuncIndex with: arg1 with: arg2
     Private - Used to limit the number of primitives used by
     FileStreams

fileOp: ioFuncIndex with: arg1 with: arg2 ifFail: aBlock
     Private - Used to limit the number of primitives used by
     FileStreams.

fileOp: ioFuncIndex with: arg1 with: arg2 with: arg3
     Private - Used to limit the number of primitives used by
     FileStreams

fileOp: ioFuncIndex with: arg1 with: arg2 with: arg3 ifFail: aBlock
     Private - Used to limit the number of primitives used by
     FileStreams.



File: gst-base.info,  Node: FileDescriptor-class type methods,  Next: FileDescriptor-initialize-release,  Prev: FileDescriptor-built ins,  Up: FileDescriptor

FileDescriptor: class type methods
----------------------------------

isBinary
     We answer characters, so answer false

isExternalStream
     We stream on an external entity (a file), so answer true

isText
     We answer characters, so answer true



File: gst-base.info,  Node: FileDescriptor-initialize-release,  Next: FileDescriptor-low-level access,  Prev: FileDescriptor-class type methods,  Up: FileDescriptor

FileDescriptor: initialize-release
----------------------------------

initialize
     Initialize the receiver's instance variables

newBuffer
     Private - Answer a String to be used as the receiver's buffer

nextHunk
     Answer the next buffers worth of stuff in the Stream represented
     by the receiver.  Do at most one actual input operation.



File: gst-base.info,  Node: FileDescriptor-low-level access,  Next: FileDescriptor-overriding inherited methods,  Prev: FileDescriptor-initialize-release,  Up: FileDescriptor

FileDescriptor: low-level access
--------------------------------

read: byteArray
     Ignoring any buffering, try to fill byteArray with the contents of
     the file

read: byteArray from: position to: end
     Ignoring any buffering, try to fill the given range of byteArray
     with the contents of the file

read: byteArray numBytes: anInteger
     Ignoring any buffering, try to fill anInteger bytes of byteArray
     with the contents of the file

write: byteArray
     Ignoring any buffering, try to write the contents of byteArray in
     the file

write: byteArray from: position to: end
     Ignoring any buffering, try to write to the file the given range
     of byteArray, starting at the position-th element and ending at
     the end-th.

write: byteArray numBytes: anInteger
     Ignoring any buffering, try to write to the file the first
     anInteger bytes of byteArray



File: gst-base.info,  Node: FileDescriptor-overriding inherited methods,  Next: FileDescriptor-printing,  Prev: FileDescriptor-low-level access,  Up: FileDescriptor

FileDescriptor: overriding inherited methods
--------------------------------------------

isEmpty
     Answer whether the receiver is empty

next: anInteger
     Return the next 'anInteger' characters from the stream, as a
     String.

nextByteArray: anInteger
     Return the next 'anInteger' bytes from the stream, as a ByteArray.

nextPutAll: aCollection
     Put all the characters in aCollection in the file

reverseContents
     Return the contents of the file from the last byte to the first

setToEnd
     Reset the file pointer to the end of the file

skip: anInteger
     Skip anInteger bytes in the file



File: gst-base.info,  Node: FileDescriptor-printing,  Next: FileDescriptor-testing,  Prev: FileDescriptor-overriding inherited methods,  Up: FileDescriptor

FileDescriptor: printing
------------------------

printOn: aStream
     Print a representation of the receiver on aStream



File: gst-base.info,  Node: FileDescriptor-testing,  Prev: FileDescriptor-printing,  Up: FileDescriptor

FileDescriptor: testing
-----------------------

atEnd
     Answer whether data has come to an end



File: gst-base.info,  Node: FileSegment,  Next: FileStream,  Prev: FileDescriptor,  Up: Base classes

FileSegment
===========

Defined in namespace Smalltalk
Superclass: Object
Category: Language-Implementation
     My instances represent sections of files.  I am primarily used by
     the compiler to record source code locations.  I am not a part of
     the normal Smalltalk-80 kernel; I am specific to the GNU Smalltalk
     implementation.

* Menu:

* FileSegment class-basic::  (class)
* FileSegment class-installing::  (class)
* FileSegment-basic::  (instance)
* FileSegment-equality::  (instance)


File: gst-base.info,  Node: FileSegment class-basic,  Next: FileSegment class-installing,  Up: FileSegment

FileSegment class: basic
------------------------

on: aFile startingAt: startPos for: sizeInteger
     Create a new FileSegment referring to the contents of the given
     file, from the startPos-th byte and for sizeInteger bytes



File: gst-base.info,  Node: FileSegment class-installing,  Next: FileSegment-basic,  Prev: FileSegment class-basic,  Up: FileSegment

FileSegment class: installing
-----------------------------

relocateFrom: startPath to: endPath
     Remove startPath from all paths that start with it, and replace it
     with endPath.  Needed to support $(DESTDIR) when installing



File: gst-base.info,  Node: FileSegment-basic,  Next: FileSegment-equality,  Prev: FileSegment class-installing,  Up: FileSegment

FileSegment: basic
------------------

asString
     Answer a String containing the required segment of the file

fileName
     Answer the name of the file containing the segment

filePos
     Answer the position in the file where the segment starts

relocateFrom: startPath to: endPath map: map
     If the path starts with startPath, remove that part of the path
     and replace it with endPath.  map is a Dictionary that is used so
     that equal filenames stay equal, without increasing the amount of
     memory that the image uses.

size
     Answer the length of the segment

withFileDo: aBlock
     Evaluate aBlock passing it the FileStream in which the segment
     identified by the receiver is stored



File: gst-base.info,  Node: FileSegment-equality,  Prev: FileSegment-basic,  Up: FileSegment

FileSegment: equality
---------------------

= aFileSegment
     Answer whether the receiver and aFileSegment are equal.

hash
     Answer an hash value for the receiver.



File: gst-base.info,  Node: FileStream,  Next: Float,  Prev: FileSegment,  Up: Base classes

FileStream
==========

Defined in namespace Smalltalk
Superclass: FileDescriptor
Category: Streams-Files
     My instances are what conventional programmers think of as files.
     My instance creation methods accept the name of a disk file (or
     any named file object, such as /dev/rmt0 on UNIX or MTA0: on VMS).

* Menu:

* FileStream class-file-in::  (class)
* FileStream class-standard streams::  (class)
* FileStream-basic::  (instance)
* FileStream-buffering::  (instance)
* FileStream-filing in::  (instance)
* FileStream-overriding inherited methods::  (instance)
* FileStream-testing::  (instance)


File: gst-base.info,  Node: FileStream class-file-in,  Next: FileStream class-standard streams,  Up: FileStream

FileStream class: file-in
-------------------------

fileIn: aFileName
     File in the aFileName file. During a file in operation, global
     variables (starting with an uppercase letter) that are not
     declared yet don't yield an `unknown variable' error. Instead,
     they are defined as nil in the `Undeclared' dictionary (a global
     variable residing in Smalltalk).  As soon as you add the variable
     to a namespace (for example by creating a class) the Association
     will be removed from Undeclared and reused in the namespace, so
     that the old references will automagically point to the new value.

fileIn: aFileName ifMissing: aSymbol
     Conditionally do a file in, only if the key (often a class)
     specified by 'aSymbol' is not present in the Smalltalk system
     dictionary already.  During a file in operation, global variables
     (starting with an uppercase letter) that are not declared don't
     yield an `unknown variable' error. Instead, they are defined as
     nil in the `Undeclared' dictionary (a global variable residing in
     Smalltalk).  As soon as you add the variable to a namespace (for
     example by creating a class) the Association will be removed from
     Undeclared and reused in the namespace, so that the old references
     will automagically point to the new value.

fileIn: aFileName ifTrue: aBoolean
     Conditionally do a file in, only if the supplied boolean is true.
     During a file in operation, global variables (starting with an
     uppercase letter) that are not declared don't yield an `unknown
     variable' error. Instead, they are defined as nil in the
     `Undeclared' dictionary (a global variable residing in Smalltalk).
     As soon as you add the variable to a namespace (for example by
     creating a class) the Association will be removed from Undeclared
     and reused in the namespace, so that the old references will
     automagically point to the new value.

fileIn: aFileName line: lineInteger from: realFileName at: aCharPos
     File in the aFileName file giving errors such as if it was loaded
     from the given line, file name and starting position (instead of
     1).

generateMakefileOnto: aStream
     Generate a make file for the file-ins since record was last set to
     true.  Store it on aStream

initialize
     Private - Initialize the receiver's class variables

record: recordFlag
     Set whether Smalltalk should record information aboutnested
     file-ins.  When recording is enabled, use #generateMakefileOnto:
     to automatically generate a valid makefile for the intervening
     file-ins.

require: assoc
     Conditionally do a file in from the value of assoc, only if the
     key of assoc is not present in the Smalltalk system dictionary
     already.  During a file in operation, global variables (starting
     with an uppercase letter) that are not declared don't yield an
     `unknown variable' error. Instead, they are defined as nil in the
     `Undeclared' dictionary (a global variable residing in Smalltalk).
     As soon as you add the variable to a namespace (for example by
     creating a class) the Association will be removed from Undeclared
     and reused in the namespace, so that the old references will
     automagically point to the new value.

verbose: verboseFlag
     Set whether Smalltalk should output debugging messages when filing
     in



File: gst-base.info,  Node: FileStream class-standard streams,  Next: FileStream-basic,  Prev: FileStream class-file-in,  Up: FileStream

FileStream class: standard streams
----------------------------------

stderr
     Answer a FileStream that is attached the Smalltalk program's
     standard error file handle, which can be used for error messages
     and diagnostics issued by the program.

stdin
     Answer a FileStream that is attached the Smalltalk program's
     standard input file handle, which is the normal source of input
     for the program.

stdout
     Answer a FileStream that is attached the Smalltalk program's
     standard output file handle; this is used for normal output from
     the program.



File: gst-base.info,  Node: FileStream-basic,  Next: FileStream-buffering,  Prev: FileStream class-standard streams,  Up: FileStream

FileStream: basic
-----------------

copyFrom: from to: to
     Answer the contents of the file between the two given positions

next
     Return the next character in the file, or nil at eof

nextByte
     Return the next byte in the file, or nil at eof

nextPut: aCharacter
     Store aCharacter on the file

nextPutByte: anInteger
     Store the byte, anInteger, on the file

nextPutByteArray: aByteArray
     Store aByteArray on the file

peek
     Return the next character in the file, or nil at eof.  Don't
     advance the file pointer.

position
     Answer the zero-based position from the start of the file

position: n
     Set the file pointer to the zero-based position n

size
     Return the current size of the file, in bytes

truncate
     Truncate the file at the current position



File: gst-base.info,  Node: FileStream-buffering,  Next: FileStream-filing in,  Prev: FileStream-basic,  Up: FileStream

FileStream: buffering
---------------------

basicFlush
     Private - Flush the output buffer, fail if it is empty

bufferSize
     Answer the file's current buffer

bufferSize: bufSize
     Flush the file and set the buffer's size to bufSize

clean
     Synchronize the file descriptor's state with the object's state.

fill
     Private - Fill the input buffer

flush
     Flush the output buffer

newBuffer
     Private - Answer a String to be used as the receiver's buffer

nextHunk
     Answer the next buffers worth of stuff in the Stream represented
     by the receiver.  Do at most one actual input operation.

pendingWrite
     Answer whether the output buffer is full



File: gst-base.info,  Node: FileStream-filing in,  Next: FileStream-overriding inherited methods,  Prev: FileStream-buffering,  Up: FileStream

FileStream: filing in
---------------------

fileIn
     File in the contents of the receiver.  During a file in operation,
     global variables (starting with an uppercase letter) that are not
     declared don't yield an `unknown variable' error. Instead, they
     are defined as nil in the `Undeclared' dictionary (a global
     variable residing in Smalltalk).  As soon as you add the variable
     to a namespace (for example by creating a class) the Association
     will be removed from Undeclared and reused in the namespace, so
     that the old references will automagically point to the new value.

fileInLine: lineNum fileName: aString at: charPosInt
     Private - Much like a preprocessor #line directive; it is used by
     the Emacs Smalltalk mode.



File: gst-base.info,  Node: FileStream-overriding inherited methods,  Next: FileStream-testing,  Prev: FileStream-filing in,  Up: FileStream

FileStream: overriding inherited methods
----------------------------------------

next: anInteger
     Return the next 'anInteger' characters from the stream, as a
     String.

nextByteArray: anInteger
     Return the next 'anInteger' bytes from the stream, as a ByteArray.

nextPutAll: aCollection
     Put all the characters in aCollection in the file

nextPutAllFlush: aCollection
     Put all the characters in aCollection in the file, then flush the
     file buffers



File: gst-base.info,  Node: FileStream-testing,  Prev: FileStream-overriding inherited methods,  Up: FileStream

FileStream: testing
-------------------

atEnd
     Answer whether data has come to an end



File: gst-base.info,  Node: Float,  Next: FloatD,  Prev: FileStream,  Up: Base classes

Float
=====

Defined in namespace Smalltalk
Superclass: Number
Category: Language-Data types
     My instances represent floating point numbers that have arbitrary
     precision.  Besides the standard numerical operations, they provide
     transcendental operations too.  They implement IEEE-754 correctly
     if the hardware supports it.

* Menu:

* Float class-byte-order dependancies::  (class)
* Float class-characterization::  (class)
* Float-arithmetic::  (instance)
* Float-basic::  (instance)
* Float-built ins::  (instance)
* Float-coercing::  (instance)
* Float-printing::  (instance)
* Float-storing::  (instance)
* Float-testing::  (instance)
* Float-testing functionality::  (instance)


File: gst-base.info,  Node: Float class-byte-order dependancies,  Next: Float class-characterization,  Up: Float

Float class: byte-order dependancies
------------------------------------

signByte
     Answer the byte of the receiver that contains the exponent



File: gst-base.info,  Node: Float class-characterization,  Next: Float-arithmetic,  Prev: Float class-byte-order dependancies,  Up: Float

Float class: characterization
-----------------------------

denormalized
     Answer whether instances of the receiver can be in denormalized
     form.

e
     Returns the value of e. Hope is that it is precise enough

epsilon
     Return the smallest Float x for which is 1 + x ~= 1

fmin
     Return the smallest Float that is > 0.

fminDenormalized
     Return the smallest Float that is > 0 if denormalized values are
     supported, else return 0.

ln10
     Returns the value of ln 10. Hope is that it is precise enough

log10Base2
     Returns the value of log2 10. Hope is that it is precise enough

pi
     Returns the value of pi. Hope is that it is precise enough

radix
     Answer the base in which computations between instances of the
     receiver are made.  This should be 2 on about every known
     computer, so GNU Smalltalk always answers 2.



File: gst-base.info,  Node: Float-arithmetic,  Next: Float-basic,  Prev: Float class-characterization,  Up: Float

Float: arithmetic
-----------------

integerPart
     Return the receiver's integer part

negated
     Return the negation of the receiver.  Unlike 0-self, this converts
     correctly signed zeros.



File: gst-base.info,  Node: Float-basic,  Next: Float-built ins,  Prev: Float-arithmetic,  Up: Float

Float: basic
------------

hash
     Answer an hash value for the receiver



File: gst-base.info,  Node: Float-built ins,  Next: Float-coercing,  Prev: Float-basic,  Up: Float

Float: built ins
----------------

arcCos
     Answer the arc-cosine of the receiver

arcSin
     Answer the arc-sine of the receiver

arcTan
     Answer the arc-tangent of the receiver

ceiling
     Answer the integer part of the receiver, truncated towards
     +infinity

cos
     Answer the cosine of the receiver

exp
     Answer 'e' (2.718281828459...) raised to the receiver

floor
     Answer the integer part of the receiver, truncated towards
     -infinity

ln
     Answer the logarithm of the receiver in base 'e'
     (2.718281828459...)

primHash
     Private - Answer an hash value for the receiver

raisedTo: aNumber
     Answer the receiver raised to its aNumber power

sin
     Answer the sine of the receiver

sqrt
     Answer the square root of the receiver

tan
     Answer the tangent of the receiver



File: gst-base.info,  Node: Float-coercing,  Next: Float-printing,  Prev: Float-built ins,  Up: Float

Float: coercing
---------------

asExactFraction
     Convert the receiver into a fraction with optimal approximation,
     but with usually huge terms.

asFloat
     Just defined for completeness.  Return the receiver.

asFraction
     Convert the receiver into a fraction with a good (but undefined)
     approximation

estimatedLog
     Answer an estimate of (self abs floorLog: 10)

truncated
     Convert the receiver to an Integer.  Only used for LargeIntegers,
     there are primitives for the other cases.



File: gst-base.info,  Node: Float-printing,  Next: Float-storing,  Prev: Float-coercing,  Up: Float

Float: printing
---------------

printOn: aStream
     Print a representation of the receiver on aStream



File: gst-base.info,  Node: Float-storing,  Next: Float-testing,  Prev: Float-printing,  Up: Float

Float: storing
--------------

storeOn: aStream
     Print a representation of the receiver on aStream



File: gst-base.info,  Node: Float-testing,  Next: Float-testing functionality,  Prev: Float-storing,  Up: Float

Float: testing
--------------

isFinite
     Answer whether the receiver does not represent infinity, nor a NaN

isInfinite
     Answer whether the receiver represents positive or negative
     infinity

isNaN
     Answer whether the receiver represents a NaN

negative
     Answer whether the receiver is negative

positive
     Answer whether the receiver is positive.  Negative zero is not
     positive, so the definition is not simply >= 0.

sign
     Answer 1 if the receiver is greater than 0, -1 if less than 0,
     else 0.  Negative zero is the same as positive zero.

strictlyPositive
     Answer whether the receiver is > 0



File: gst-base.info,  Node: Float-testing functionality,  Prev: Float-testing,  Up: Float

Float: testing functionality
----------------------------

isFloat
     Answer `true'.



File: gst-base.info,  Node: FloatD,  Next: FloatE,  Prev: Float,  Up: Base classes

FloatD
======

Defined in namespace Smalltalk
Superclass: Float
Category: Language-Data types
     My instances represent floating point numbers that have 64 bits of
     precision (well, less than that in precision; they are precisely
     the same as C's "double" datatype).  Besides the standard
     numerical operations, I provide transcendental operations too.

* Menu:

* FloatD class-byte-order dependancies::  (class)
* FloatD class-characterization::  (class)
* FloatD class-converting::  (class)
* FloatD-built ins::  (instance)
* FloatD-coercing::  (instance)


File: gst-base.info,  Node: FloatD class-byte-order dependancies,  Next: FloatD class-characterization,  Up: FloatD

FloatD class: byte-order dependancies
-------------------------------------

signByte
     Answer the byte of the receiver that contains the exponent



File: gst-base.info,  Node: FloatD class-characterization,  Next: FloatD class-converting,  Prev: FloatD class-byte-order dependancies,  Up: FloatD

FloatD class: characterization
------------------------------

decimalDigits
     Return the number of decimal digits of precision for a FloatD.
     Technically, if P is the precision for the representation, then
     the decimal precision Q is the maximum number of decimal digits
     such that any floating point number with Q base 10 digits can be
     rounded to a floating point number with P base 2 digits and back
     again, without change to the Q decimal digits.

emax
     Return the maximum allowable exponent for a FloatD that is finite.

emin
     Return the maximum allowable exponent for a FloatD that is finite.

fmax
     Return the largest normalized FloatD that is not infinite.

fminNormalized
     Return the smallest normalized FloatD that is > 0

infinity
     Return a FloatD that represents positive infinity.

nan
     Return a FloatD that represents a mathematically indeterminate
     value (e.g. Inf - Inf, Inf / Inf).

negativeInfinity
     Return a FloatD that represents negative infinity.

precision
     Answer the number of bits in the mantissa. 1 + (2^-precision) = 1



File: gst-base.info,  Node: FloatD class-converting,  Next: FloatD-built ins,  Prev: FloatD class-characterization,  Up: FloatD

FloatD class: converting
------------------------

coerce: aNumber
     Answer aNumber converted to a FloatD



File: gst-base.info,  Node: FloatD-built ins,  Next: FloatD-coercing,  Prev: FloatD class-converting,  Up: FloatD

FloatD: built ins
-----------------

* arg
     Multiply the receiver and arg and answer another Number

+ arg
     Sum the receiver and arg and answer another Number

- arg
     Subtract arg from the receiver and answer another Number

/ arg
     Divide the receiver by arg and answer another FloatD

< arg
     Answer whether the receiver is less than arg

<= arg
     Answer whether the receiver is less than or equal to arg

= arg
     Answer whether the receiver is equal to arg

> arg
     Answer whether the receiver is greater than arg

>= arg
     Answer whether the receiver is greater than or equal to arg

asFloatE
     Answer the receiver converted to a FloatE

asFloatQ
     Answer the receiver converted to a FloatQ

exponent
     Answer the exponent of the receiver in mantissa*2^exponent
     representation ( |mantissa|<=1 )

fractionPart
     Answer the fractional part of the receiver

timesTwoPower: arg
     Answer the receiver multiplied by 2^arg

truncated
     Truncate the receiver towards zero and answer the result

~= arg
     Answer whether the receiver is not equal to arg



File: gst-base.info,  Node: FloatD-coercing,  Prev: FloatD-built ins,  Up: FloatD

FloatD: coercing
----------------

asFloatD
     Just defined for completeness.  Return the receiver.

coerce: aNumber
     Coerce aNumber to the receiver's class

generality
     Answer the receiver's generality

unity
     Coerce 1 to the receiver's class

zero
     Coerce 0 to the receiver's class



File: gst-base.info,  Node: FloatE,  Next: FloatQ,  Prev: FloatD,  Up: Base classes

FloatE
======

Defined in namespace Smalltalk
Superclass: Float
Category: Language-Data types
     My instances represent floating point numbers that have 64 bits of
     precision (well, less than that in precision; they are precisely
     the same as C's "double" datatype).  Besides the standard
     numerical operations, I provide transcendental operations too.

* Menu:

* FloatE class-byte-order dependancies::  (class)
* FloatE class-characterization::  (class)
* FloatE class-converting::  (class)
* FloatE-built ins::  (instance)
* FloatE-coercing::  (instance)


File: gst-base.info,  Node: FloatE class-byte-order dependancies,  Next: FloatE class-characterization,  Up: FloatE

FloatE class: byte-order dependancies
-------------------------------------

signByte
     Answer the byte of the receiver that contains the exponent



File: gst-base.info,  Node: FloatE class-characterization,  Next: FloatE class-converting,  Prev: FloatE class-byte-order dependancies,  Up: FloatE

FloatE class: characterization
------------------------------

decimalDigits
     Return the number of decimal digits of precision for a FloatE.
     Technically, if P is the precision for the representation, then
     the decimal precision Q is the maximum number of decimal digits
     such that any floating point number with Q base 10 digits can be
     rounded to a floating point number with P base 2 digits and back
     again, without change to the Q decimal digits.

e
     Returns the value of e. Hope is that it is precise enough

emax
     Return the maximum allowable exponent for a FloatE that is finite.

emin
     Return the maximum allowable exponent for a FloatE that is finite.

fmax
     Return the largest normalized FloatE that is not infinite.

fminNormalized
     Return the smallest normalized FloatE that is > 0

infinity
     Return a FloatE that represents positive infinity.

ln10
     Returns the value of ln 10. Hope is that it is precise enough

log10Base2
     Returns the value of log2 10. Hope is that it is precise enough

nan
     Return a FloatE that represents a mathematically indeterminate
     value (e.g. Inf - Inf, Inf / Inf).

negativeInfinity
     Return a FloatE that represents negative infinity.

pi
     Returns the value of pi. Hope is that it is precise enough

precision
     Answer the number of bits in the mantissa. 1 + (2^-precision) = 1



File: gst-base.info,  Node: FloatE class-converting,  Next: FloatE-built ins,  Prev: FloatE class-characterization,  Up: FloatE

FloatE class: converting
------------------------

coerce: aNumber
     Answer aNumber converted to a FloatE



File: gst-base.info,  Node: FloatE-built ins,  Next: FloatE-coercing,  Prev: FloatE class-converting,  Up: FloatE

FloatE: built ins
-----------------

* arg
     Multiply the receiver and arg and answer another Number

+ arg
     Sum the receiver and arg and answer another Number

- arg
     Subtract arg from the receiver and answer another Number

/ arg
     Divide the receiver by arg and answer another FloatE

< arg
     Answer whether the receiver is less than arg

<= arg
     Answer whether the receiver is less than or equal to arg

= arg
     Answer whether the receiver is equal to arg

> arg
     Answer whether the receiver is greater than arg

>= arg
     Answer whether the receiver is greater than or equal to arg

asFloatD
     Answer the receiver converted to a FloatD

asFloatQ
     Answer the receiver converted to a FloatQ

exponent
     Answer the exponent of the receiver in mantissa*2^exponent
     representation ( |mantissa|<=1 )

fractionPart
     Answer the fractional part of the receiver

timesTwoPower: arg
     Answer the receiver multiplied by 2^arg

truncated
     Truncate the receiver towards zero and answer the result

~= arg
     Answer whether the receiver is not equal to arg



File: gst-base.info,  Node: FloatE-coercing,  Prev: FloatE-built ins,  Up: FloatE

FloatE: coercing
----------------

asFloatE
     Just defined for completeness.  Return the receiver.

coerce: aNumber
     Coerce aNumber to the receiver's class

generality
     Answer the receiver's generality

unity
     Coerce 1 to the receiver's class

zero
     Coerce 0 to the receiver's class



File: gst-base.info,  Node: FloatQ,  Next: Fraction,  Prev: FloatE,  Up: Base classes

FloatQ
======

Defined in namespace Smalltalk
Superclass: Float
Category: Language-Data types
     My instances represent floating point numbers that have 64 bits of
     precision (well, less than that in precision; they are precisely
     the same as C's "double" datatype).  Besides the standard
     numerical operations, I provide transcendental operations too.

* Menu:

* FloatQ class-byte-order dependancies::  (class)
* FloatQ class-characterization::  (class)
* FloatQ class-converting::  (class)
* FloatQ-built ins::  (instance)
* FloatQ-coercing::  (instance)


File: gst-base.info,  Node: FloatQ class-byte-order dependancies,  Next: FloatQ class-characterization,  Up: FloatQ

FloatQ class: byte-order dependancies
-------------------------------------

signByte
     Answer the byte of the receiver that contains the exponent



File: gst-base.info,  Node: FloatQ class-characterization,  Next: FloatQ class-converting,  Prev: FloatQ class-byte-order dependancies,  Up: FloatQ

FloatQ class: characterization
------------------------------

decimalDigits
     Return the number of decimal digits of precision for a FloatQ.
     Technically, if P is the precision for the representation, then
     the decimal precision Q is the maximum number of decimal digits
     such that any floating point number with Q base 10 digits can be
     rounded to a floating point number with P base 2 digits and back
     again, without change to the Q decimal digits.

e
     Returns the value of e. Hope is that it is precise enough

emax
     Return the maximum allowable exponent for a FloatQ that is finite.

emin
     Return the maximum allowable exponent for a FloatQ that is finite.

fmax
     Return the largest normalized FloatQ that is not infinite.

fminNormalized
     Return the smallest normalized FloatQ that is > 0

infinity
     Return a FloatQ that represents positive infinity.

ln10
     Returns the value of ln 10. Hope is that it is precise enough

log10Base2
     Returns the value of log2 10. Hope is that it is precise enough

nan
     Return a FloatQ that represents a mathematically indeterminate
     value (e.g. Inf - Inf, Inf / Inf).

negativeInfinity
     Return a FloatQ that represents negative infinity.

pi
     Returns the value of pi. Hope is that it is precise enough

precision
     Answer the number of bits in the mantissa. 1 + (2^-precision) = 1



File: gst-base.info,  Node: FloatQ class-converting,  Next: FloatQ-built ins,  Prev: FloatQ class-characterization,  Up: FloatQ

FloatQ class: converting
------------------------

coerce: aNumber
     Answer aNumber converted to a FloatQ



File: gst-base.info,  Node: FloatQ-built ins,  Next: FloatQ-coercing,  Prev: FloatQ class-converting,  Up: FloatQ

FloatQ: built ins
-----------------

* arg
     Multiply the receiver and arg and answer another Number

+ arg
     Sum the receiver and arg and answer another Number

- arg
     Subtract arg from the receiver and answer another Number

/ arg
     Divide the receiver by arg and answer another FloatQ

< arg
     Answer whether the receiver is less than arg

<= arg
     Answer whether the receiver is less than or equal to arg

= arg
     Answer whether the receiver is equal to arg

> arg
     Answer whether the receiver is greater than arg

>= arg
     Answer whether the receiver is greater than or equal to arg

asFloatD
     Answer the receiver converted to a FloatD

asFloatE
     Answer the receiver converted to a FloatE

exponent
     Answer the exponent of the receiver in mantissa*2^exponent
     representation ( |mantissa|<=1 )

fractionPart
     Answer the fractional part of the receiver

timesTwoPower: arg
     Answer the receiver multiplied by 2^arg

truncated
     Truncate the receiver towards zero and answer the result

~= arg
     Answer whether the receiver is not equal to arg



File: gst-base.info,  Node: FloatQ-coercing,  Prev: FloatQ-built ins,  Up: FloatQ

FloatQ: coercing
----------------

asFloatQ
     Just defined for completeness.  Return the receiver.

coerce: aNumber
     Coerce aNumber to the receiver's class

generality
     Answer the receiver's generality

unity
     Coerce 1 to the receiver's class

zero
     Coerce 0 to the receiver's class



File: gst-base.info,  Node: Fraction,  Next: Halt,  Prev: FloatQ,  Up: Base classes

Fraction
========

Defined in namespace Smalltalk
Superclass: Number
Category: Language-Data types
     I represent rational numbers in the form (p/q) where p and q are
     integers.  The arithmetic operations  *, +, -, /,  on fractions,
     all return a reduced fraction.

* Menu:

* Fraction class-converting::  (class)
* Fraction class-instance creation::  (class)
* Fraction-accessing::  (instance)
* Fraction-arithmetic::  (instance)
* Fraction-coercing::  (instance)
* Fraction-comparing::  (instance)
* Fraction-converting::  (instance)
* Fraction-optimized cases::  (instance)
* Fraction-printing::  (instance)
* Fraction-testing::  (instance)


File: gst-base.info,  Node: Fraction class-converting,  Next: Fraction class-instance creation,  Up: Fraction

Fraction class: converting
--------------------------

coerce: aNumber
     Answer aNumber converted to a Fraction



File: gst-base.info,  Node: Fraction class-instance creation,  Next: Fraction-accessing,  Prev: Fraction class-converting,  Up: Fraction

Fraction class: instance creation
---------------------------------

initialize
     Initialize the receiver's class variables

numerator: nInteger denominator: dInteger
     Answer a new instance of fraction (nInteger/dInteger)



File: gst-base.info,  Node: Fraction-accessing,  Next: Fraction-arithmetic,  Prev: Fraction class-instance creation,  Up: Fraction

Fraction: accessing
-------------------

denominator
     Answer the receiver's denominator

numerator
     Answer the receiver's numerator



File: gst-base.info,  Node: Fraction-arithmetic,  Next: Fraction-coercing,  Prev: Fraction-accessing,  Up: Fraction

Fraction: arithmetic
--------------------

* aNumber
     Multiply two numbers and answer the result.

+ aNumber
     Sum two numbers and answer the result.

- aNumber
     Subtract aNumber from the receiver and answer the result.

/ aNumber
     Divide the receiver by aNumber and answer the result.

// aNumber
     Return the integer quotient of dividing the receiver by aNumber
     with truncation towards negative infinity.

\\ aNumber
     Return the remainder from dividing the receiver by aNumber, (using
     //).

estimatedLog
     Answer an estimate of (self abs floorLog: 10)



File: gst-base.info,  Node: Fraction-coercing,  Next: Fraction-comparing,  Prev: Fraction-arithmetic,  Up: Fraction

Fraction: coercing
------------------

ceiling
     Truncate the receiver towards positive infinity and return the
     truncated result

coerce: aNumber
     Coerce aNumber to the receiver's class

floor
     Truncate the receiver towards negative infinity and return the
     truncated result

generality
     Return the receiver's generality

truncated
     Truncate the receiver and return the truncated result

unity
     Coerce 1 to the receiver's class

zero
     Coerce 0 to the receiver's class



File: gst-base.info,  Node: Fraction-comparing,  Next: Fraction-converting,  Prev: Fraction-coercing,  Up: Fraction

Fraction: comparing
-------------------

< arg
     Test if the receiver is less than arg.

<= arg
     Test if the receiver is less than or equal to arg.

= arg
     Test if the receiver equals arg.

> arg
     Test if the receiver is more than arg.

>= arg
     Test if the receiver is greater than or equal to arg.

hash
     Answer an hash value for the receiver



File: gst-base.info,  Node: Fraction-converting,  Next: Fraction-optimized cases,  Prev: Fraction-comparing,  Up: Fraction

Fraction: converting
--------------------

asFloatD
     Answer the receiver converted to a FloatD

asFloatE
     Answer the receiver converted to a FloatD

asFloatQ
     Answer the receiver converted to a FloatD

asFraction
     Answer the receiver, it is already a Fraction

integerPart
     Answer the integer part of the receiver, expressed as a Fraction



File: gst-base.info,  Node: Fraction-optimized cases,  Next: Fraction-printing,  Prev: Fraction-converting,  Up: Fraction

Fraction: optimized cases
-------------------------

negated
     Return the receiver, with its sign changed.

raisedToInteger: anInteger
     Return self raised to the anInteger-th power.

reciprocal
     Return the reciprocal of the receiver

squared
     Return the square of the receiver.



File: gst-base.info,  Node: Fraction-printing,  Next: Fraction-testing,  Prev: Fraction-optimized cases,  Up: Fraction

Fraction: printing
------------------

printOn: aStream
     Print a representation of the receiver on aStream

storeOn: aStream
     Store Smalltalk code compiling to the receiver on aStream



File: gst-base.info,  Node: Fraction-testing,  Prev: Fraction-printing,  Up: Fraction

Fraction: testing
-----------------

isRational
     Answer whether the receiver is rational - true



File: gst-base.info,  Node: Halt,  Next: HashedCollection,  Prev: Fraction,  Up: Base classes

Halt
====

Defined in namespace Smalltalk
Superclass: Error
Category: Language-Exceptions
     Halt represents a resumable error, usually a bug.

* Menu:

* Halt-description::  (instance)


File: gst-base.info,  Node: Halt-description,  Up: Halt

Halt: description
-----------------

description
     Answer a textual description of the exception.

isResumable
     Answer true.  #halt exceptions are by default resumable.



File: gst-base.info,  Node: HashedCollection,  Next: HomedAssociation,  Prev: Halt,  Up: Base classes

HashedCollection
================

Defined in namespace Smalltalk
Superclass: Collection
Category: Collections-Unordered
     I am an hashed collection that can store objects uniquely and give
     fast responses on their presence in the collection.

* Menu:

* HashedCollection class-instance creation::  (class)
* HashedCollection-accessing::  (instance)
* HashedCollection-builtins::  (instance)
* HashedCollection-copying::  (instance)
* HashedCollection-enumerating the elements of a collection::  (instance)
* HashedCollection-rehashing::  (instance)
* HashedCollection-removing::  (instance)
* HashedCollection-saving and loading::  (instance)
* HashedCollection-storing::  (instance)
* HashedCollection-testing collections::  (instance)


File: gst-base.info,  Node: HashedCollection class-instance creation,  Next: HashedCollection-accessing,  Up: HashedCollection

HashedCollection class: instance creation
-----------------------------------------

new
     Answer a new instance of the receiver with a default size

new: anInteger
     Answer a new instance of the receiver with the given size



File: gst-base.info,  Node: HashedCollection-accessing,  Next: HashedCollection-builtins,  Prev: HashedCollection class-instance creation,  Up: HashedCollection

HashedCollection: accessing
---------------------------

add: newObject
     Add newObject to the set, if and only if the set doesn't already
     contain an occurrence of it. Don't fail if a duplicate is found.
     Answer anObject

at: index
     This method should not be called for instances of this class.

at: index put: value
     This method should not be called for instances of this class.



File: gst-base.info,  Node: HashedCollection-builtins,  Next: HashedCollection-copying,  Prev: HashedCollection-accessing,  Up: HashedCollection

HashedCollection: builtins
--------------------------

primAt: anIndex
     Private - Answer the anIndex-th item of the hash table for the
     receiver.  Using this instead of basicAt: allows for easier
     changes in the representation

primAt: anIndex put: value
     Private - Store value in the anIndex-th item of the hash table for
     the receiver. Using this instead of basicAt:put: allows for easier
     changes in the representation

primSize
     Private - Answer the size of the hash table for the receiver.
     Using this instead of basicSize allows for easier changes in the
     representation



File: gst-base.info,  Node: HashedCollection-copying,  Next: HashedCollection-enumerating the elements of a collection,  Prev: HashedCollection-builtins,  Up: HashedCollection

HashedCollection: copying
-------------------------

deepCopy
     Returns a deep copy of the receiver (the instance variables are
     copies of the receiver's instance variables)

shallowCopy
     Returns a shallow copy of the receiver (the instance variables are
     not copied)



File: gst-base.info,  Node: HashedCollection-enumerating the elements of a collection,  Next: HashedCollection-rehashing,  Prev: HashedCollection-copying,  Up: HashedCollection

HashedCollection: enumerating the elements of a collection
----------------------------------------------------------

do: aBlock
     Enumerate all the non-nil members of the set



File: gst-base.info,  Node: HashedCollection-rehashing,  Next: HashedCollection-removing,  Prev: HashedCollection-enumerating the elements of a collection,  Up: HashedCollection

HashedCollection: rehashing
---------------------------

rehash
     Rehash the receiver



File: gst-base.info,  Node: HashedCollection-removing,  Next: HashedCollection-saving and loading,  Prev: HashedCollection-rehashing,  Up: HashedCollection

HashedCollection: removing
--------------------------

remove: oldObject ifAbsent: anExceptionBlock
     Remove oldObject to the set. If it is found, answer oldObject.
     Otherwise, evaluate anExceptionBlock and return its value.



File: gst-base.info,  Node: HashedCollection-saving and loading,  Next: HashedCollection-storing,  Prev: HashedCollection-removing,  Up: HashedCollection

HashedCollection: saving and loading
------------------------------------

postLoad
     Called after loading an object; rehash the collection because
     identity objects will most likely mutate their hashes.

postStore
     Called after an object is dumped.  Do nothing - necessary because
     by default this calls #postLoad by default



File: gst-base.info,  Node: HashedCollection-storing,  Next: HashedCollection-testing collections,  Prev: HashedCollection-saving and loading,  Up: HashedCollection

HashedCollection: storing
-------------------------

storeOn: aStream
     Store on aStream some Smalltalk code which compiles to the receiver



File: gst-base.info,  Node: HashedCollection-testing collections,  Prev: HashedCollection-storing,  Up: HashedCollection

HashedCollection: testing collections
-------------------------------------

= aHashedCollection
     Returns true if the two sets have the same membership, false if not

capacity
     Answer how many elements the receiver can hold before having to
     grow.

hash
     Return the hash code for the members of the set.  Since order is
     unimportant, we use a commutative operator to compute the hash
     value.

includes: anObject
     Answer whether the receiver contains an instance of anObject.

isEmpty
     Answer whether the receiver is empty.

occurrencesOf: anObject
     Return the number of occurrences of anObject.  Since we're a set,
     this is either 0 or 1.  Nil is never directly in the set, so we
     special case it (the result is always 1).

size
     Answer the receiver's size



File: gst-base.info,  Node: HomedAssociation,  Next: IdentityDictionary,  Prev: HashedCollection,  Up: Base classes

HomedAssociation
================

Defined in namespace Smalltalk
Superclass: Association
Category: Language-Data types
     My instances represent know about their parent namespace, which is
     of use when implementing weak collections and finalizations.

* Menu:

* HomedAssociation class-basic::  (class)
* HomedAssociation-accessing::  (instance)
* HomedAssociation-finalization::  (instance)
* HomedAssociation-storing::  (instance)


File: gst-base.info,  Node: HomedAssociation class-basic,  Next: HomedAssociation-accessing,  Up: HomedAssociation

HomedAssociation class: basic
-----------------------------

key: aKey value: aValue environment: aNamespace
     Answer a new association with the given key and value



File: gst-base.info,  Node: HomedAssociation-accessing,  Next: HomedAssociation-finalization,  Prev: HomedAssociation class-basic,  Up: HomedAssociation

HomedAssociation: accessing
---------------------------

environment
     Answer the namespace in which I live.

environment: aNamespace
     Set the namespace in which I live to be aNamespace.



File: gst-base.info,  Node: HomedAssociation-finalization,  Next: HomedAssociation-storing,  Prev: HomedAssociation-accessing,  Up: HomedAssociation

HomedAssociation: finalization
------------------------------

mourn
     This message is sent to the receiver when the object is made
     ephemeron (which is common when HomedAssociations are used by a
     WeakKeyDictionary or a WeakSet).  The mourning of the object's key
     is first of all demanded to the environment (which will likely
     remove the object from itself), and then performed as usual by
     clearing the key and value fields.



File: gst-base.info,  Node: HomedAssociation-storing,  Prev: HomedAssociation-finalization,  Up: HomedAssociation

HomedAssociation: storing
-------------------------

storeOn: aStream
     Put on aStream some Smalltalk code compiling to the receiver



File: gst-base.info,  Node: IdentityDictionary,  Next: IdentitySet,  Prev: HomedAssociation,  Up: Base classes

IdentityDictionary
==================

Defined in namespace Smalltalk
Superclass: LookupTable
Category: Collections-Keyed
     I am similar to LookupTable, except that I use the object identity
     comparision message == to determine equivalence of indices.

* Menu:


File: gst-base.info,  Node: IdentitySet,  Next: Integer,  Prev: IdentityDictionary,  Up: Base classes

IdentitySet
===========

Defined in namespace Smalltalk
Superclass: Set
Category: Collections-Unordered
     I am the typical set object; I can store any objects uniquely.  I
     use the == operator to determine duplication of objects.

* Menu:

* IdentitySet-testing::  (instance)


File: gst-base.info,  Node: IdentitySet-testing,  Up: IdentitySet

IdentitySet: testing
--------------------

identityIncludes: anObject
     Answer whether we include the anObject object; for IdentitySets
     this is identical to #includes:



File: gst-base.info,  Node: Integer,  Next: Interval,  Prev: IdentitySet,  Up: Base classes

Integer
=======

Defined in namespace Smalltalk
Superclass: Number
Category: Language-Data types
     I am the abstract integer class of the GNU Smalltalk system.  My
     subclasses' instances can represent signed integers of various
     sizes (a subclass is picked according to the size), with varying
     efficiency.

* Menu:

* Integer class-converting::  (class)
* Integer-accessing::  (instance)
* Integer-basic::  (instance)
* Integer-bit operators::  (instance)
* Integer-converting::  (instance)
* Integer-extension::  (instance)
* Integer-iterators::  (instance)
* Integer-math methods::  (instance)
* Integer-printing::  (instance)
* Integer-storing::  (instance)
* Integer-testing functionality::  (instance)


File: gst-base.info,  Node: Integer class-converting,  Next: Integer-accessing,  Up: Integer

Integer class: converting
-------------------------

coerce: aNumber
     Answer aNumber converted to a kind of Integer



File: gst-base.info,  Node: Integer-accessing,  Next: Integer-basic,  Prev: Integer class-converting,  Up: Integer

Integer: accessing
------------------

denominator
     Answer `1'.

numerator
     Answer the receiver.



File: gst-base.info,  Node: Integer-basic,  Next: Integer-bit operators,  Prev: Integer-accessing,  Up: Integer

Integer: basic
--------------

hash
     Answer an hash value for the receiver



File: gst-base.info,  Node: Integer-bit operators,  Next: Integer-converting,  Prev: Integer-basic,  Up: Integer

Integer: bit operators
----------------------

allMask: anInteger
     True if all 1 bits in anInteger are 1 in the receiver

anyMask: anInteger
     True if any 1 bits in anInteger are 1 in the receiver

bitAt: index
     Answer the index-th bit of the receiver (the LSB has an index of 1)

bitAt: index put: value
     Answer an integer which is identical to the receiver, possibly
     with the exception of the index-th bit of the receiver (the LSB
     having an index of 1), which assumes a value equal to the
     low-order bit of the second parameter.

bitClear: aMask
     Answer an Integer equal to the receiver, except that all the bits
     that are set in aMask are cleared.

bitInvert
     Return the 1's complement of the bits of the receiver

clearBit: index
     Clear the index-th bit of the receiver and answer a new Integer

highBit
     Return the index of the highest order 1 bit of the receiver

isBitSet: index
     Answer whether the index-th bit of the receiver is set

noMask: anInteger
     True if no 1 bits in anInteger are 1 in the receiver

setBit: index
     Set the index-th bit of the receiver and answer a new Integer



File: gst-base.info,  Node: Integer-converting,  Next: Integer-extension,  Prev: Integer-bit operators,  Up: Integer

Integer: converting
-------------------

asCharacter
     Return self as an ascii character

asFraction
     Return the receiver converted to a fraction

asScaledDecimal: n
     Answer the receiver, converted to a ScaledDecimal object.  The
     scale is forced to be 0.

ceiling
     Return the receiver - it's already truncated

coerce: aNumber
     Coerce aNumber to the receiver's class

floor
     Return the receiver - it's already truncated

rounded
     Return the receiver - it's already truncated

truncated
     Return the receiver - it's already truncated



File: gst-base.info,  Node: Integer-extension,  Next: Integer-iterators,  Prev: Integer-converting,  Up: Integer

Integer: extension
------------------

alignTo: anInteger
     Answer the receiver, truncated to the first higher or equal
     multiple of anInteger (which must be a power of two)



File: gst-base.info,  Node: Integer-iterators,  Next: Integer-math methods,  Prev: Integer-extension,  Up: Integer

Integer: iterators
------------------

timesRepeat: aBlock
     Evaluate aBlock a number of times equal to the receiver's value.
     Compiled in-line for no argument aBlocks without temporaries, and
     therefore not overridable.



File: gst-base.info,  Node: Integer-math methods,  Next: Integer-printing,  Prev: Integer-iterators,  Up: Integer

Integer: math methods
---------------------

binomial: anInteger
     Compute the number of combinations of anInteger objects among a
     number of objects given by the receiver.

estimatedLog
     Answer an estimate of (self abs floorLog: 10)

even
     Return whether the receiver is even

factorial
     Return the receiver's factorial.

floorLog: radix
     return (self log: radix) floor. Optimized to answer an integer.

gcd: anInteger
     Return the greatest common divisor (Euclid's algorithm) between the
     receiver and anInteger

lcm: anInteger
     Return the least common multiple between the receiver and anInteger

odd
     Return whether the receiver is odd



File: gst-base.info,  Node: Integer-printing,  Next: Integer-storing,  Prev: Integer-math methods,  Up: Integer

Integer: printing
-----------------

printOn: aStream
     Print on aStream the base 10 representation of the receiver

printOn: aStream base: b
     Print on aStream the base b representation of the receiver

printOn: str base: baseInteger showRadix: showRadix
     Append to str the base baseInteger representation of the receiver

printString: baseInteger
     Return the base b representation of the receiver

printStringRadix: baseInteger
     Return the base b representation of the receiver, with BBr in
     front of it

     instead

radix: baseInteger
     Return the base b representation of the receiver, with BBr in
     front of it.  This method is deprecated, use #printStringRadix:
     instead.

storeOn: aStream base: b
     Print on aStream Smalltalk code compiling to the receiver,
     represented in base b



File: gst-base.info,  Node: Integer-storing,  Next: Integer-testing functionality,  Prev: Integer-printing,  Up: Integer

Integer: storing
----------------

storeOn: aStream
     Print on aStream the base 10 representation of the receiver



File: gst-base.info,  Node: Integer-testing functionality,  Prev: Integer-storing,  Up: Integer

Integer: testing functionality
------------------------------

isInteger
     Answer `true'.

isRational
     Answer whether the receiver is rational - true



File: gst-base.info,  Node: Interval,  Next: LargeArray,  Prev: Integer,  Up: Base classes

Interval
========

Defined in namespace Smalltalk
Superclass: ArrayedCollection
Category: Collections-Sequenceable
     My instances represent ranges of objects, typically Number type
     objects.  I provide iteration/enumeration messages for producing
     all the members that my instance represents.

* Menu:

* Interval class-instance creation::  (class)
* Interval-basic::  (instance)
* Interval-printing::  (instance)
* Interval-storing::  (instance)
* Interval-testing::  (instance)


File: gst-base.info,  Node: Interval class-instance creation,  Next: Interval-basic,  Up: Interval

Interval class: instance creation
---------------------------------

from: startInteger to: stopInteger
     Answer an Interval going from startInteger to the stopInteger,
     with a step of 1

from: startInteger to: stopInteger by: stepInteger
     Answer an Interval going from startInteger to the stopInteger,
     with a step of stepInteger

withAll: aCollection
     Answer an Interval containing the same elements as aCollection.
     Fail if it is not possible to create one.



File: gst-base.info,  Node: Interval-basic,  Next: Interval-printing,  Prev: Interval class-instance creation,  Up: Interval

Interval: basic
---------------

at: index
     Answer the index-th element of the receiver.

at: index put: anObject
     This method should not be called for instances of this class.

collect: aBlock
     Evaluate the receiver for each element in aBlock, collect in an
     array the result of the evaluations.

do: aBlock
     Evaluate the receiver for each element in aBlock

reverse
     Answer a copy of the receiver with all of its items reversed

size
     Answer the number of elements in the receiver.

species
     Answer `Array'.



File: gst-base.info,  Node: Interval-printing,  Next: Interval-storing,  Prev: Interval-basic,  Up: Interval

Interval: printing
------------------

printOn: aStream
     Print a representation for the receiver on aStream



File: gst-base.info,  Node: Interval-storing,  Next: Interval-testing,  Prev: Interval-printing,  Up: Interval

Interval: storing
-----------------

storeOn: aStream
     Store Smalltalk code compiling to the receiver on aStream



File: gst-base.info,  Node: Interval-testing,  Prev: Interval-storing,  Up: Interval

Interval: testing
-----------------

= anInterval
     Answer whether anInterval is the same interval as the receiver

hash
     Answer an hash value for the receiver



File: gst-base.info,  Node: LargeArray,  Next: LargeArrayedCollection,  Prev: Interval,  Up: Base classes

LargeArray
==========

Defined in namespace Smalltalk
Superclass: LargeArrayedCollection
Category: Collections-Sequenceable
     I am similar to a plain array, but I'm specially designed to save
     memory when lots of items are nil.

* Menu:

* LargeArray-overridden::  (instance)


File: gst-base.info,  Node: LargeArray-overridden,  Up: LargeArray

LargeArray: overridden
----------------------

newCollection: size
     Create an Array of the given size



File: gst-base.info,  Node: LargeArrayedCollection,  Next: LargeArraySubpart,  Prev: LargeArray,  Up: Base classes

LargeArrayedCollection
======================

Defined in namespace Smalltalk
Superclass: ArrayedCollection
Category: Collections-Sequenceable
     I am an abstract class specially designed to save memory when lots
     of items have the same value.

* Menu:

* LargeArrayedCollection class-instance creation::  (class)
* LargeArrayedCollection-accessing::  (instance)
* LargeArrayedCollection-basic::  (instance)


File: gst-base.info,  Node: LargeArrayedCollection class-instance creation,  Next: LargeArrayedCollection-accessing,  Up: LargeArrayedCollection

LargeArrayedCollection class: instance creation
-----------------------------------------------

new: anInteger
     Answer a new instance of the receiver, with room for anInteger
     elements.



File: gst-base.info,  Node: LargeArrayedCollection-accessing,  Next: LargeArrayedCollection-basic,  Prev: LargeArrayedCollection class-instance creation,  Up: LargeArrayedCollection

LargeArrayedCollection: accessing
---------------------------------

at: anIndex
     Answer the anIndex-th item of the receiver.

at: anIndex put: anObject
     Replace the anIndex-th item of the receiver with anObject.

compress
     Arrange the representation of the array for maximum memory saving.



File: gst-base.info,  Node: LargeArrayedCollection-basic,  Prev: LargeArrayedCollection-accessing,  Up: LargeArrayedCollection

LargeArrayedCollection: basic
-----------------------------

= aLargeArray
     Answer whether the receiver and aLargeArray have the same contents

hash
     Answer an hash value for the receiver

size
     Answer the maximum valid index for the receiver



File: gst-base.info,  Node: LargeArraySubpart,  Next: LargeByteArray,  Prev: LargeArrayedCollection,  Up: Base classes

LargeArraySubpart
=================

Defined in namespace Smalltalk
Superclass: Magnitude
Category: Collections-Sequenceable
     This class is an auxiliary class used to store information about a
     LargeArrayedCollection's contents.  LargeArrayedCollections store
     their items non-contiguously in a separate storage object, and use
     a SortedCollection to map between indices in the array and indices
     in the storage object; instances of this class represent a block of
     indices that is stored contiguously in the storage object.

* Menu:

* LargeArraySubpart class-instance creation::  (class)
* LargeArraySubpart-accessing::  (instance)
* LargeArraySubpart-comparing::  (instance)
* LargeArraySubpart-modifying::  (instance)


File: gst-base.info,  Node: LargeArraySubpart class-instance creation,  Next: LargeArraySubpart-accessing,  Up: LargeArraySubpart

LargeArraySubpart class: instance creation
------------------------------------------

first: first last: last index: index
     Answer a LargeArraySubpart which answers first, last, and index
     when it is sent (respectively) #first, #last and #firstIndex.



File: gst-base.info,  Node: LargeArraySubpart-accessing,  Next: LargeArraySubpart-comparing,  Prev: LargeArraySubpart class-instance creation,  Up: LargeArraySubpart

LargeArraySubpart: accessing
----------------------------

first
     Answer the index of the first item of the LargeArrayedCollection
     that the receiver refers to.

first: firstIndex last: lastIndex index: storagePosition
     Set up the receiver so that it answers first, last, and index when
     it is sent (respectively) #first, #last and #firstIndex.

firstIndex
     Answer the index in the collection's storage object of the first
     item of the LargeArrayedCollection that the receiver refers to.

last
     Answer the index of the last item of the LargeArrayedCollection
     that the receiver refers to.

lastIndex
     Answer the index in the collection's storage object of the last
     item of the LargeArrayedCollection that the receiver refers to.



File: gst-base.info,  Node: LargeArraySubpart-comparing,  Next: LargeArraySubpart-modifying,  Prev: LargeArraySubpart-accessing,  Up: LargeArraySubpart

LargeArraySubpart: comparing
----------------------------

< anObject
     Answer whether the receiver points to a part of the array that is
     before anObject (this makes sense only if the receiver and
     anObject are two LargeArraySubparts referring to the same
     LargeArrayedCollection).

<= anObject
     Answer whether the receiver points to a part of the array that is
     before anObject or starts at the same point (this makes sense only
     if the receiver and anObject are two LargeArraySubparts referring
     to the same LargeArrayedCollection).

= anObject
     Answer whether the receiver and anObject are equal (assuming that
     the receiver and anObject are two LargeArraySubparts referring to
     the same LargeArrayedCollection, which the receiver cannot check
     for).

hash
     Answer an hash value for the receiver



File: gst-base.info,  Node: LargeArraySubpart-modifying,  Prev: LargeArraySubpart-comparing,  Up: LargeArraySubpart

LargeArraySubpart: modifying
----------------------------

cutAt: position
     Answer a new LargeArraySubpart whose lastIndex is position - 1,
     and apply a #removeFirst: to the receiver so that the firstIndex
     becomes position

grow
     Add one to last and lastIndex

growBy: numberOfElements
     Add numberOfElements to last and lastIndex

relocateTo: position
     Move the firstIndex to position, and the lastIndex accordingly.

removeFirst: n
     Sum n to first and firstIndex, but leave last/lastIndex untouched

removeLast: n
     Subtract n from last and lastIndex, but leave first/firstIndex
     untouched



File: gst-base.info,  Node: LargeByteArray,  Next: LargeInteger,  Prev: LargeArraySubpart,  Up: Base classes

LargeByteArray
==============

Defined in namespace Smalltalk
Superclass: LargeArrayedCollection
Category: Collections-Sequenceable
     I am similar to a plain ByteArray, but I'm specially designed to
     save memory when lots of items are zero.

* Menu:

* LargeByteArray-overridden::  (instance)


File: gst-base.info,  Node: LargeByteArray-overridden,  Up: LargeByteArray

LargeByteArray: overridden
--------------------------

costOfNewIndex
     Answer the maximum number of consecutive items set to the
     defaultElement that can be present in a compressed array.

defaultElement
     Answer the value which is hoped to be the most common in the array

newCollection: size
     Create a ByteArray of the given size



File: gst-base.info,  Node: LargeInteger,  Next: LargeNegativeInteger,  Prev: LargeByteArray,  Up: Base classes

LargeInteger
============

Defined in namespace Smalltalk
Superclass: Integer
Category: Language-Data types
     I represent a large integer, which has to be stored as a long
     sequence of bytes. I have methods to do arithmetics and
     comparisons, but I need some help from my children,
     LargePositiveInteger and LargeNegativeInteger, to speed them up a
     bit.

* Menu:

* LargeInteger-arithmetic::  (instance)
* LargeInteger-bit operations::  (instance)
* LargeInteger-built-ins::  (instance)
* LargeInteger-coercion::  (instance)
* LargeInteger-disabled::  (instance)
* LargeInteger-primitive operations::  (instance)
* LargeInteger-testing::  (instance)


File: gst-base.info,  Node: LargeInteger-arithmetic,  Next: LargeInteger-bit operations,  Up: LargeInteger

LargeInteger: arithmetic
------------------------

* aNumber
     Multiply aNumber and the receiver, answer the result

+ aNumber
     Sum the receiver and aNumber, answer the result

- aNumber
     Sum the receiver and aNumber, answer the result

/ aNumber
     Divide aNumber and the receiver, answer the result (an Integer or
     Fraction)

// aNumber
     Divide aNumber and the receiver, answer the result truncated
     towards -infinity

\\ aNumber
     Divide aNumber and the receiver, answer the remainder truncated
     towards -infinity

estimatedLog
     Answer an estimate of (self abs floorLog: 10)

negated
     Answer the receiver's negated

quo: aNumber
     Divide aNumber and the receiver, answer the result truncated
     towards 0

rem: aNumber
     Divide aNumber and the receiver, answer the remainder truncated
     towards 0



File: gst-base.info,  Node: LargeInteger-bit operations,  Next: LargeInteger-built-ins,  Prev: LargeInteger-arithmetic,  Up: LargeInteger

LargeInteger: bit operations
----------------------------

bitAnd: aNumber
     Answer the receiver ANDed with aNumber

bitAt: aNumber
     Answer the aNumber-th bit in the receiver, where the LSB is 1

bitInvert
     Answer the receiver's 1's complement

bitOr: aNumber
     Answer the receiver ORed with aNumber

bitShift: aNumber
     Answer the receiver shifted by aNumber places

bitXor: aNumber
     Answer the receiver XORed with aNumber



File: gst-base.info,  Node: LargeInteger-built-ins,  Next: LargeInteger-coercion,  Prev: LargeInteger-bit operations,  Up: LargeInteger

LargeInteger: built-ins
-----------------------

at: anIndex
     Answer the anIndex-th byte in the receiver's representation

at: anIndex put: aNumber
     Set the anIndex-th byte in the receiver's representation

digitAt: anIndex
     Answer the anIndex-th base-256 digit in the receiver's
     representation

digitAt: anIndex put: aNumber
     Set the anIndex-th base-256 digit in the receiver's representation

digitLength
     Answer the number of base-256 digits in the receiver

hash
     Answer an hash value for the receiver

primReplaceFrom: start to: stop with: replacementString
     startingAt: replaceStart Private - Replace the characters from
     start to stop with new characters contained in replacementString
     (which, actually, can be any variable byte class), starting at the
     replaceStart location of replacementString

size
     Answer the number of indexed instance variable in the receiver



File: gst-base.info,  Node: LargeInteger-coercion,  Next: LargeInteger-disabled,  Prev: LargeInteger-built-ins,  Up: LargeInteger

LargeInteger: coercion
----------------------

coerce: aNumber
     Truncate the number; if needed, convert it to LargeInteger
     representation.

generality
     Answer the receiver's generality

unity
     Coerce 1 to the receiver's class

zero
     Coerce 0 to the receiver's class



File: gst-base.info,  Node: LargeInteger-disabled,  Next: LargeInteger-primitive operations,  Prev: LargeInteger-coercion,  Up: LargeInteger

LargeInteger: disabled
----------------------

asObject
     This method always fails. The number of OOPs is far less than the
     minimum number represented with a LargeInteger.

asObjectNoFail
     Answer `nil'.



File: gst-base.info,  Node: LargeInteger-primitive operations,  Next: LargeInteger-testing,  Prev: LargeInteger-disabled,  Up: LargeInteger

LargeInteger: primitive operations
----------------------------------

basicLeftShift: totalShift
     Private - Left shift the receiver by aNumber places

basicRightShift: totalShift
     Private - Right shift the receiver by 'shift' places

largeNegated
     Private - Same as negated, but always answer a LargeInteger



File: gst-base.info,  Node: LargeInteger-testing,  Prev: LargeInteger-primitive operations,  Up: LargeInteger

LargeInteger: testing
---------------------

< aNumber
     Answer whether the receiver is smaller than aNumber

<= aNumber
     Answer whether the receiver is smaller than aNumber or equal to it

= aNumber
     Answer whether the receiver and aNumber identify the same number

> aNumber
     Answer whether the receiver is greater than aNumber

>= aNumber
     Answer whether the receiver is greater than aNumber or equal to it

~= aNumber
     Answer whether the receiver and aNumber identify the same number



File: gst-base.info,  Node: LargeNegativeInteger,  Next: LargePositiveInteger,  Prev: LargeInteger,  Up: Base classes

LargeNegativeInteger
====================

Defined in namespace Smalltalk
Superclass: LargeInteger
Category: Language-Data types
     Just like my brother LargePositiveInteger, I provide a few methods
     that allow LargeInteger to determine the sign of a large integer
     in a fast way during its calculations. For example, I know that I
     am smaller than any LargePositiveInteger

* Menu:

* LargeNegativeInteger-converting::  (instance)
* LargeNegativeInteger-numeric testing::  (instance)
* LargeNegativeInteger-reverting to LargePositiveInteger::  (instance)


File: gst-base.info,  Node: LargeNegativeInteger-converting,  Next: LargeNegativeInteger-numeric testing,  Up: LargeNegativeInteger

LargeNegativeInteger: converting
--------------------------------

asFloatD
     Answer the receiver converted to a FloatD

asFloatE
     Answer the receiver converted to a FloatE

asFloatQ
     Answer the receiver converted to a FloatQ



File: gst-base.info,  Node: LargeNegativeInteger-numeric testing,  Next: LargeNegativeInteger-reverting to LargePositiveInteger,  Prev: LargeNegativeInteger-converting,  Up: LargeNegativeInteger

LargeNegativeInteger: numeric testing
-------------------------------------

abs
     Answer the receiver's absolute value.

negative
     Answer whether the receiver is < 0

positive
     Answer whether the receiver is >= 0

sign
     Answer the receiver's sign

strictlyPositive
     Answer whether the receiver is > 0



File: gst-base.info,  Node: LargeNegativeInteger-reverting to LargePositiveInteger,  Prev: LargeNegativeInteger-numeric testing,  Up: LargeNegativeInteger

LargeNegativeInteger: reverting to LargePositiveInteger
-------------------------------------------------------

+ aNumber
     Sum the receiver and aNumber, answer the result

- aNumber
     Sum the receiver and aNumber, answer the result

gcd: anInteger
     Return the greatest common divisor between the receiver and
     anInteger

highBit
     Answer the receiver's highest bit's index



File: gst-base.info,  Node: LargePositiveInteger,  Next: LargeWordArray,  Prev: LargeNegativeInteger,  Up: Base classes

LargePositiveInteger
====================

Defined in namespace Smalltalk
Superclass: LargeInteger
Category: Language-Data types
     Just like my brother LargeNegativeInteger, I provide a few methods
     that allow LargeInteger to determine the sign of a large integer
     in a fast way during its calculations.  For example, I know that I
     am larger than any LargeNegativeInteger.  In addition I implement
     the guts of arbitrary precision arithmetic.

* Menu:

* LargePositiveInteger-arithmetic::  (instance)
* LargePositiveInteger-converting::  (instance)
* LargePositiveInteger-helper byte-level methods::  (instance)
* LargePositiveInteger-numeric testing::  (instance)
* LargePositiveInteger-primitive operations::  (instance)


File: gst-base.info,  Node: LargePositiveInteger-arithmetic,  Next: LargePositiveInteger-converting,  Up: LargePositiveInteger

LargePositiveInteger: arithmetic
--------------------------------

+ aNumber
     Sum the receiver and aNumber, answer the result

- aNumber
     Subtract aNumber from the receiver, answer the result

gcd: anInteger
     Calculate the GCD between the receiver and anInteger

highBit
     Answer the receiver's highest bit's index



File: gst-base.info,  Node: LargePositiveInteger-converting,  Next: LargePositiveInteger-helper byte-level methods,  Prev: LargePositiveInteger-arithmetic,  Up: LargePositiveInteger

LargePositiveInteger: converting
--------------------------------

asFloatD
     Answer the receiver converted to a FloatD

asFloatE
     Answer the receiver converted to a FloatE

asFloatQ
     Answer the receiver converted to a FloatQ

reverseStringBase: radix on: str
     Return in a Stream str the base radix representation of the
     receiver in reverse order



File: gst-base.info,  Node: LargePositiveInteger-helper byte-level methods,  Next: LargePositiveInteger-numeric testing,  Prev: LargePositiveInteger-converting,  Up: LargePositiveInteger

LargePositiveInteger: helper byte-level methods
-----------------------------------------------

bytes: byteArray1 from: j compare: byteArray2
     Private - Answer the sign of byteArray2 - byteArray1; the j-th
     byte of byteArray1 is compared with the first of byteArray2, the
     j+1-th with the second, and so on.

bytes: byteArray1 from: j subtract: byteArray2
     Private - Sutract the bytes in byteArray2 from those in byteArray1

bytes: bytes multiply: anInteger
     Private - Multiply the bytes in bytes by anInteger, which must be
     < 255.  Put the result back in bytes.

bytesLeftShift: aByteArray
     Private - Left shift by 1 place the bytes in aByteArray

bytesLeftShift: aByteArray big: totalShift
     Private - Left shift the bytes in aByteArray by totalShift places

bytesLeftShift: aByteArray n: shift
     Private - Left shift by shift places the bytes in aByteArray
     (shift <= 7)

bytesRightShift: aByteArray big: totalShift
     Private - Right shift the bytes in aByteArray by totalShift places

bytesRightShift: bytes n: aNumber
     Private - Right shift the bytes in `bytes' by 'aNumber' places
     (shift <= 7)

bytesTrailingZeros: bytes
     Private - Answer the number of trailing zero bits in the receiver

primDivide: rhs
     Private - Implements Knuth's divide and correct algorithm from
     `Seminumerical Algorithms' 3rd Edition, section 4.3.1 (which is
     basically an enhanced version of the divide `algorithm' for
     two-digit divisors which is taught in primary school!!!)



File: gst-base.info,  Node: LargePositiveInteger-numeric testing,  Next: LargePositiveInteger-primitive operations,  Prev: LargePositiveInteger-helper byte-level methods,  Up: LargePositiveInteger

LargePositiveInteger: numeric testing
-------------------------------------

abs
     Answer the receiver's absolute value

negative
     Answer whether the receiver is < 0

positive
     Answer whether the receiver is >= 0

sign
     Answer the receiver's sign

strictlyPositive
     Answer whether the receiver is > 0



File: gst-base.info,  Node: LargePositiveInteger-primitive operations,  Prev: LargePositiveInteger-numeric testing,  Up: LargePositiveInteger

LargePositiveInteger: primitive operations
------------------------------------------

divide: aNumber using: aBlock
     Private - Divide the receiver by aNumber (unsigned division).
     Evaluate aBlock passing the result ByteArray, the remainder
     ByteArray, and whether the division had a remainder

isSmall
     Private - Answer whether the receiver is small enough to employ
     simple scalar algorithms for division and multiplication

multiply: aNumber
     Private - Multiply the receiver by aNumber (unsigned multiply)



File: gst-base.info,  Node: LargeWordArray,  Next: LargeZeroInteger,  Prev: LargePositiveInteger,  Up: Base classes

LargeWordArray
==============

Defined in namespace Smalltalk
Superclass: LargeArrayedCollection
Category: Collections-Sequenceable
     I am similar to a plain WordArray, but I'm specially designed to
     save memory when lots of items are zero.

* Menu:

* LargeWordArray-overridden::  (instance)


File: gst-base.info,  Node: LargeWordArray-overridden,  Up: LargeWordArray

LargeWordArray: overridden
--------------------------

defaultElement
     Answer the value which is hoped to be the most common in the array

newCollection: size
     Create a WordArray of the given size



File: gst-base.info,  Node: LargeZeroInteger,  Next: Link,  Prev: LargeWordArray,  Up: Base classes

LargeZeroInteger
================

Defined in namespace Smalltalk
Superclass: LargePositiveInteger
Category: Language-Data types
     I am quite a strange class. Indeed, the concept of a "large
     integer" that is zero is a weird one. Actually my only instance is
     zero but is represented like LargeIntegers, has the same
     generality as LargeIntegers, and so on. That only instance is
     stored in the class variable Zero, and is used in arithmetical
     methods, when we have to coerce a parameter that is zero.

* Menu:

* LargeZeroInteger-accessing::  (instance)
* LargeZeroInteger-arithmetic::  (instance)
* LargeZeroInteger-numeric testing::  (instance)
* LargeZeroInteger-printing::  (instance)


File: gst-base.info,  Node: LargeZeroInteger-accessing,  Next: LargeZeroInteger-arithmetic,  Up: LargeZeroInteger

LargeZeroInteger: accessing
---------------------------

at: anIndex
     Answer `0'.

hash
     Answer `0'.

size
     Answer `0'.



File: gst-base.info,  Node: LargeZeroInteger-arithmetic,  Next: LargeZeroInteger-numeric testing,  Prev: LargeZeroInteger-accessing,  Up: LargeZeroInteger

LargeZeroInteger: arithmetic
----------------------------

* aNumber
     Multiply aNumber and the receiver, answer the result

+ aNumber
     Sum the receiver and aNumber, answer the result

- aNumber
     Subtract aNumber from the receiver, answer the result

/ aNumber
     Divide aNumber and the receiver, answer the result (an Integer or
     Fraction)

// aNumber
     Divide aNumber and the receiver, answer the result truncated
     towards -infinity

\\ aNumber
     Divide aNumber and the receiver, answer the remainder truncated
     towards -infinity

quo: aNumber
     Divide aNumber and the receiver, answer the result truncated
     towards 0

rem: aNumber
     Divide aNumber and the receiver, answer the remainder truncated
     towards 0



File: gst-base.info,  Node: LargeZeroInteger-numeric testing,  Next: LargeZeroInteger-printing,  Prev: LargeZeroInteger-arithmetic,  Up: LargeZeroInteger

LargeZeroInteger: numeric testing
---------------------------------

sign
     Answer the receiver's sign

strictlyPositive
     Answer whether the receiver is > 0



File: gst-base.info,  Node: LargeZeroInteger-printing,  Prev: LargeZeroInteger-numeric testing,  Up: LargeZeroInteger

LargeZeroInteger: printing
--------------------------

reverseStringBase: radix on: str
     Return in a string the base radix representation of the receiver in
     reverse order



File: gst-base.info,  Node: Link,  Next: LinkedList,  Prev: LargeZeroInteger,  Up: Base classes

Link
====

Defined in namespace Smalltalk
Superclass: Object
Category: Collections-Sequenceable
     I represent simple linked lists.  Generally, I am not used by
     myself, but rather a subclass adds other instance variables that
     hold the information for each node, and I hold the glue that keeps
     them together.

* Menu:

* Link class-instance creation::  (class)
* Link-basic::  (instance)
* Link-iteration::  (instance)


File: gst-base.info,  Node: Link class-instance creation,  Next: Link-basic,  Up: Link

Link class: instance creation
-----------------------------

nextLink: aLink
     Create an instance with the given next link



File: gst-base.info,  Node: Link-basic,  Next: Link-iteration,  Prev: Link class-instance creation,  Up: Link

Link: basic
-----------

nextLink
     Answer the next item in the list

nextLink: aLink
     Set the next item in the list



File: gst-base.info,  Node: Link-iteration,  Prev: Link-basic,  Up: Link

Link: iteration
---------------

at: index
     Retrieve a node (instance of Link) that is at a distance of `index'
     after the receiver.

at: index put: object
     This method should not be called for instances of this class.

do: aBlock
     Evaluate aBlock for each element in the list

size
     Answer the number of elements in the list. Warning: this is O(n)



File: gst-base.info,  Node: LinkedList,  Next: LookupKey,  Prev: Link,  Up: Base classes

LinkedList
==========

Defined in namespace Smalltalk
Superclass: SequenceableCollection
Category: Collections-Sequenceable
     I provide methods that access and manipulate linked lists.  I
     assume that the elements of the linked list are subclasses of
     Link, because I use the methods that class Link supplies to
     implement my methods.

* Menu:

* LinkedList-accessing::  (instance)
* LinkedList-adding::  (instance)
* LinkedList-enumerating::  (instance)
* LinkedList-testing::  (instance)


File: gst-base.info,  Node: LinkedList-accessing,  Next: LinkedList-adding,  Up: LinkedList

LinkedList: accessing
---------------------

at: index
     Return the element that is index into the linked list.

at: index put: object
     This method should not be called for instances of this class.



File: gst-base.info,  Node: LinkedList-adding,  Next: LinkedList-enumerating,  Prev: LinkedList-accessing,  Up: LinkedList

LinkedList: adding
------------------

add: aLink
     Add aLink at the end of the list; return aLink.

addFirst: aLink
     Add aLink at the head of the list; return aLink.

addLast: aLink
     Add aLink at then end of the list; return aLink.

remove: aLink ifAbsent: aBlock
     Remove aLink from the list and return it, or invoke aBlock if it's
     not found in the list.

removeFirst
     Remove the first element from the list and return it, or error if
     the list is empty.

removeLast
     Remove the final element from the list and return it, or error if
     the list is empty.



File: gst-base.info,  Node: LinkedList-enumerating,  Next: LinkedList-testing,  Prev: LinkedList-adding,  Up: LinkedList

LinkedList: enumerating
-----------------------

do: aBlock
     Enumerate each object in the list, passing it to aBlock (actual
     behavior might depend on the subclass of Link that is being used).



File: gst-base.info,  Node: LinkedList-testing,  Prev: LinkedList-enumerating,  Up: LinkedList

LinkedList: testing
-------------------

isEmpty
     Returns true if the list contains no members

notEmpty
     Returns true if the list contains at least a member

size
     Answer the number of elements in the list. Warning: this is O(n)



File: gst-base.info,  Node: LookupKey,  Next: LookupTable,  Prev: LinkedList,  Up: Base classes

LookupKey
=========

Defined in namespace Smalltalk
Superclass: Magnitude
Category: Language-Data types
     I represent a key for looking up entries in a data structure.
     Subclasses of me, such as Association, typically represent
     dictionary entries.

* Menu:

* LookupKey class-basic::  (class)
* LookupKey-accessing::  (instance)
* LookupKey-printing::  (instance)
* LookupKey-storing::  (instance)
* LookupKey-testing::  (instance)


File: gst-base.info,  Node: LookupKey class-basic,  Next: LookupKey-accessing,  Up: LookupKey

LookupKey class: basic
----------------------

key: aKey
     Answer a new instance of the receiver with the given key and value



File: gst-base.info,  Node: LookupKey-accessing,  Next: LookupKey-printing,  Prev: LookupKey class-basic,  Up: LookupKey

LookupKey: accessing
--------------------

key
     Answer the receiver's key

key: aKey
     Set the receiver's key to aKey



File: gst-base.info,  Node: LookupKey-printing,  Next: LookupKey-storing,  Prev: LookupKey-accessing,  Up: LookupKey

LookupKey: printing
-------------------

printOn: aStream
     Put on aStream a representation of the receiver



File: gst-base.info,  Node: LookupKey-storing,  Next: LookupKey-testing,  Prev: LookupKey-printing,  Up: LookupKey

LookupKey: storing
------------------

storeOn: aStream
     Put on aStream some Smalltalk code compiling to the receiver



File: gst-base.info,  Node: LookupKey-testing,  Prev: LookupKey-storing,  Up: LookupKey

LookupKey: testing
------------------

< aLookupKey
     Answer whether the receiver's key is less than aLookupKey's

= aLookupKey
     Answer whether the receiver's key and value are the same as
     aLookupKey's, or false if aLookupKey is not an instance of the
     receiver

hash
     Answer an hash value for the receiver



File: gst-base.info,  Node: LookupTable,  Next: Magnitude,  Prev: LookupKey,  Up: Base classes

LookupTable
===========

Defined in namespace Smalltalk
Superclass: Dictionary
Category: Collections-Keyed
     I am similar to Dictionary, except that my representation is
     different (more efficient, but not useful to store a variable
     binding). I use the object equality comparison message #= to
     determine equivalence of indices.

* Menu:

* LookupTable class-instance creation::  (class)
* LookupTable-accessing::  (instance)
* LookupTable-copying::  (instance)
* LookupTable-enumerating::  (instance)
* LookupTable-rehashing::  (instance)
* LookupTable-removing::  (instance)
* LookupTable-storing::  (instance)


File: gst-base.info,  Node: LookupTable class-instance creation,  Next: LookupTable-accessing,  Up: LookupTable

LookupTable class: instance creation
------------------------------------

new
     Create a new LookupTable with a default size



File: gst-base.info,  Node: LookupTable-accessing,  Next: LookupTable-copying,  Prev: LookupTable class-instance creation,  Up: LookupTable

LookupTable: accessing
----------------------

add: anAssociation
     Add the anAssociation key to the receiver

associationAt: key ifAbsent: aBlock
     Answer the key/value Association for the given key. Evaluate aBlock
     (answering the result) if the key is not found

at: key ifAbsent: aBlock
     Answer the value associated to the given key, or the result of
     evaluating aBlock if the key is not found

at: aKey ifPresent: aBlock
     If aKey is absent, answer nil. Else, evaluate aBlock passing the
     associated value and answer the result of the invocation

at: key put: value
     Store value as associated to the given key



File: gst-base.info,  Node: LookupTable-copying,  Next: LookupTable-enumerating,  Prev: LookupTable-accessing,  Up: LookupTable

LookupTable: copying
--------------------

deepCopy
     Returns a deep copy of the receiver (the instance variables are
     copies of the receiver's instance variables)



File: gst-base.info,  Node: LookupTable-enumerating,  Next: LookupTable-rehashing,  Prev: LookupTable-copying,  Up: LookupTable

LookupTable: enumerating
------------------------

associationsDo: aBlock
     Pass each association in the LookupTable to aBlock

keysAndValuesDo: aBlock
     Pass each key/value pair in the LookupTable as two distinct
     parameters to aBlock



File: gst-base.info,  Node: LookupTable-rehashing,  Next: LookupTable-removing,  Prev: LookupTable-enumerating,  Up: LookupTable

LookupTable: rehashing
----------------------

rehash
     Rehash the receiver



File: gst-base.info,  Node: LookupTable-removing,  Next: LookupTable-storing,  Prev: LookupTable-rehashing,  Up: LookupTable

LookupTable: removing
---------------------

remove: anAssociation
     Remove anAssociation's key from the dictionary

remove: anAssociation ifAbsent: aBlock
     Remove anAssociation's key from the dictionary

removeKey: key ifAbsent: aBlock
     Remove the passed key from the LookupTable, answer the result of
     evaluating aBlock if it is not found



File: gst-base.info,  Node: LookupTable-storing,  Prev: LookupTable-removing,  Up: LookupTable

LookupTable: storing
--------------------

storeOn: aStream
     Print Smalltalk code compiling to the receiver on aStream



File: gst-base.info,  Node: Magnitude,  Next: MappedCollection,  Prev: LookupTable,  Up: Base classes

Magnitude
=========

Defined in namespace Smalltalk
Superclass: Object
Category: Language-Data types
     I am an abstract class.  My objects represent things that are
     discrete and map to a number line.  My instances can be compared
     with < and >.

* Menu:

* Magnitude-basic::  (instance)
* Magnitude-misc methods::  (instance)


File: gst-base.info,  Node: Magnitude-basic,  Next: Magnitude-misc methods,  Up: Magnitude

Magnitude: basic
----------------

< aMagnitude
     Answer whether the receiver is less than aMagnitude

<= aMagnitude
     Answer whether the receiver is less than or equal to aMagnitude

= aMagnitude
     Answer whether the receiver is equal to aMagnitude

> aMagnitude
     Answer whether the receiver is greater than aMagnitude

>= aMagnitude
     Answer whether the receiver is greater than or equal to aMagnitude



File: gst-base.info,  Node: Magnitude-misc methods,  Prev: Magnitude-basic,  Up: Magnitude

Magnitude: misc methods
-----------------------

between: min and: max
     Returns true if object is inclusively between min and max.

max: aMagnitude
     Returns the greatest object between the receiver and aMagnitude

min: aMagnitude
     Returns the least object between the receiver and aMagnitude



File: gst-base.info,  Node: MappedCollection,  Next: Memory,  Prev: Magnitude,  Up: Base classes

MappedCollection
================

Defined in namespace Smalltalk
Superclass: Collection
Category: Collections-Keyed
     I represent collections of objects that are indirectly indexed by
     names.  There are really two collections involved: domain and a
     map.  The map maps between external names and indices into domain,
     which contains the real association.  In order to work properly,
     the domain must be an instance of a subclass of
     SequenceableCollection, and the map must be an instance of
     Dictionary, or of a subclass of SequenceableCollection.

     As an example of using me, consider implenting a Dictionary whose
     elements are indexed. The domain would be a SequenceableCollection
     with n elements, the map a Dictionary associating each key to an
     index in the domain. To access by key, to perform enumeration,
     etc. you would ask an instance of me; to access by index, you
     would access the domain directly.

     Another idea could be to implement row access or column access to
     a matrix implemented as a single n*m Array: the Array would be the
     domain, while the map would be an Interval.


* Menu:

* MappedCollection class-instance creation::  (class)
* MappedCollection-basic::  (instance)


File: gst-base.info,  Node: MappedCollection class-instance creation,  Next: MappedCollection-basic,  Up: MappedCollection

MappedCollection class: instance creation
-----------------------------------------

collection: aCollection map: aMap
     Answer a new MappedCollection using the given domain (aCollection)
     and map

new
     This method should not be used; instead, use #collection:map: to
     create MappedCollection.



File: gst-base.info,  Node: MappedCollection-basic,  Prev: MappedCollection class-instance creation,  Up: MappedCollection

MappedCollection: basic
-----------------------

add: anObject
     This method should not be called for instances of this class.

at: key
     Answer the object at the given key

at: key put: value
     Store value at the given key

collect: aBlock
     Answer a MappedCollection with a copy of the receiver's map and a
     domain obtained by passing each object through aBlock

contents
     Answer a bag with the receiver's values

do: aBlock
     Evaluate aBlock for each object

domain
     Answer the domain

map
     Answer the map

reject: aBlock
     Answer the objects in the domain for which aBlock returns false

select: aBlock
     Answer the objects in the domain for which aBlock returns true

size
     Answer the receiver's size



File: gst-base.info,  Node: Memory,  Next: Message,  Prev: MappedCollection,  Up: Base classes

Memory
======

Defined in namespace Smalltalk
Superclass: Object
Category: Language-Implementation
     I provide access to actual machine addresses of OOPs and objects.
     I have no instances; you send messages to my class to map between
     an object and the address of its OOP or object. In addition I
     provide direct memory access with different C types (ints, chars,
     OOPs, floats,...).

* Menu:

* Memory class-accessing::  (class)


File: gst-base.info,  Node: Memory class-accessing,  Up: Memory

Memory class: accessing
-----------------------

at: anAddress
     Access the Smalltalk object (OOP) at the given address.

at: anAddress put: aValue
     Store a pointer (OOP) to the Smalltalk object identified by `value'
     at the given address.

bigEndian
     Answer whether we're running on a big- or little-endian system.

charAt: anAddress
     Access the C char at the given address. The value is returned as a
     Smalltalk Character.

charAt: anAddress put: aValue
     Store as a C char the Smalltalk Character or Integer object
     identified by `value', at the given address, using sizeof(char)
     bytes - i.e. 1 byte.

deref: anAddress
     Access the C int pointed by the given address

doubleAt: anAddress
     Access the C double at the given address.

doubleAt: anAddress put: aValue
     Store the Smalltalk Float object identified by `value', at the
     given address, writing it like a C double.

floatAt: anAddress
     Access the C float at the given address.

floatAt: anAddress put: aValue
     Store the Smalltalk Float object identified by `value', at the
     given address, writing it like a C float.

intAt: anAddress
     Access the C int at the given address.

intAt: anAddress put: aValue
     Store the Smalltalk Integer object identified by `value', at the
     given address, using sizeof(int) bytes.

longAt: anAddress
     Access the C long int at the given address.

longAt: anAddress put: aValue
     Store the Smalltalk Integer object identified by `value', at the
     given address, using sizeof(long) bytes.

shortAt: anAddress
     Access the C short int at the given address.

shortAt: anAddress put: aValue
     Store the Smalltalk Integer object identified by `value', at the
     given address, using sizeof(short) bytes.

stringAt: anAddress
     Access the string pointed by the C `char *' at the given given
     address.

stringAt: anAddress put: aValue
     Store the Smalltalk String object identified by `value', at the
     given address in memory, writing it like a *FRESHLY ALLOCATED* C
     string. It is the caller's responsibility to free it if necessary.

ucharAt: anAddress put: aValue
     Store as a C char the Smalltalk Character or Integer object
     identified by `value', at the given address, using sizeof(char)
     bytes - i.e. 1 byte.

uintAt: anAddress put: aValue
     Store the Smalltalk Integer object identified by `value', at the
     given address, using sizeof(int) bytes.

ulongAt: anAddress put: aValue
     Store the Smalltalk Integer object identified by `value', at the
     given address, using sizeof(long) bytes.

unsignedCharAt: anAddress
     Access the C unsigned char at the given address.  The value is
     returned as a Smalltalk Character.

unsignedCharAt: anAddress put: aValue
     Store as a C char the Smalltalk Character or Integer object
     identified by `value', at the given address, using sizeof(char)
     bytes - i.e. 1 byte.

unsignedIntAt: anAddress
     Access the C unsigned int at the given address.

unsignedIntAt: anAddress put: aValue
     Store the Smalltalk Integer object identified by `value', at the
     given address, using sizeof(int) bytes.

unsignedLongAt: anAddress
     Access the C unsigned long int at the given address.

unsignedLongAt: anAddress put: aValue
     Store the Smalltalk Integer object identified by `value', at the
     given address, using sizeof(long) bytes.

unsignedShortAt: anAddress
     Access the C unsigned short int at the given address.

unsignedShortAt: anAddress put: aValue
     Store the Smalltalk Integer object identified by `value', at the
     given address, using sizeof(short) bytes.

ushortAt: anAddress put: aValue
     Store the Smalltalk Integer object identified by `value', at the
     given address, using sizeof(short) bytes.



File: gst-base.info,  Node: Message,  Next: MessageNotUnderstood,  Prev: Memory,  Up: Base classes

Message
=======

Defined in namespace Smalltalk
Superclass: Object
Category: Language-Implementation
     I am a virtually existent class.  By that I mean that logically
     instances of my class are created whenever a message is sent to an
     object, but in reality my instances are only created to hold a
     message that has failed, so that error reporting methods can
     examine the sender and arguments.

* Menu:

* Message class-creating instances::  (class)
* Message-accessing::  (instance)
* Message-basic::  (instance)


File: gst-base.info,  Node: Message class-creating instances,  Next: Message-accessing,  Up: Message

Message class: creating instances
---------------------------------

selector: aSymbol arguments: anArray
     Create a new Message with the given selector and arguments



File: gst-base.info,  Node: Message-accessing,  Next: Message-basic,  Prev: Message class-creating instances,  Up: Message

Message: accessing
------------------

argument
     Answer the first of the receiver's arguments

arguments
     Answer the receiver's arguments

arguments: anArray
     Set the receiver's arguments

selector
     Answer the receiver's selector

selector: aSymbol
     Set the receiver's selector



File: gst-base.info,  Node: Message-basic,  Prev: Message-accessing,  Up: Message

Message: basic
--------------

printOn: aStream
     Print a representation of the receiver on aStream

reinvokeFor: aReceiver
     Resend to aReceiver - present for compatibility

sendTo: aReceiver
     Resend to aReceiver



File: gst-base.info,  Node: MessageNotUnderstood,  Next: Metaclass,  Prev: Message,  Up: Base classes

MessageNotUnderstood
====================

Defined in namespace Smalltalk
Superclass: Halt
Category: Language-Exceptions
     MessageNotUnderstood represents an error during message lookup.
     Signaling it is the default action of the #doesNotUnderstand:
     handler

* Menu:

* MessageNotUnderstood-accessing::  (instance)
* MessageNotUnderstood-description::  (instance)


File: gst-base.info,  Node: MessageNotUnderstood-accessing,  Next: MessageNotUnderstood-description,  Up: MessageNotUnderstood

MessageNotUnderstood: accessing
-------------------------------

message
     Answer the message that wasn't understood

receiver
     Answer the object to whom the message send was directed



File: gst-base.info,  Node: MessageNotUnderstood-description,  Prev: MessageNotUnderstood-accessing,  Up: MessageNotUnderstood

MessageNotUnderstood: description
---------------------------------

description
     Answer a textual description of the exception.



File: gst-base.info,  Node: Metaclass,  Next: MethodContext,  Prev: MessageNotUnderstood,  Up: Base classes

Metaclass
=========

Defined in namespace Smalltalk
Superclass: ClassDescription
Category: Language-Implementation
     I am the root of the class hierarchy.  My instances are
     metaclasses, one for each real class.  My instances have a single
     instance, which they hold onto, which is the class that they are
     the metaclass of.  I provide methods for creation of actual class
     objects from metaclass object, and the creation of metaclass
     objects, which are my instances.  If this is confusing to you, it
     should be...the Smalltalk metaclass system is strange and complex.

* Menu:

* Metaclass class-instance creation::  (class)
* Metaclass-accessing::  (instance)
* Metaclass-basic::  (instance)
* Metaclass-delegation::  (instance)
* Metaclass-filing::  (instance)
* Metaclass-printing::  (instance)
* Metaclass-testing functionality::  (instance)


File: gst-base.info,  Node: Metaclass class-instance creation,  Next: Metaclass-accessing,  Up: Metaclass

Metaclass class: instance creation
----------------------------------

subclassOf: superMeta
     Answer a new metaclass representing a subclass of superMeta



File: gst-base.info,  Node: Metaclass-accessing,  Next: Metaclass-basic,  Prev: Metaclass class-instance creation,  Up: Metaclass

Metaclass: accessing
--------------------

instanceClass
     Answer the only instance of the metaclass

primaryInstance
     Answer the only instance of the metaclass - present for
     compatibility

soleInstance
     Answer the only instance of the metaclass - present for
     compatibility



File: gst-base.info,  Node: Metaclass-basic,  Next: Metaclass-delegation,  Prev: Metaclass-accessing,  Up: Metaclass

Metaclass: basic
----------------

instanceVariableNames: classInstVarNames
     Set the class-instance variables for the receiver to be those in
     classInstVarNames

name: newName
     environment: aNamespace     subclassOf: superclass
     instanceVariableNames: stringOfInstVarNames     variable:
     variableBoolean     words: wordBoolean     pointers: pointerBoolean
        classVariableNames: stringOfClassVarNames
     poolDictionaries: stringOfPoolNames     category: categoryName
     Private - create a full featured class and install it, or change an
     existing one

newMeta: className
     environment: aNamespace     subclassOf: superclass
     instanceVariableNames: stringOfInstVarNames     variable:
     variableBoolean     words: wordBoolean     pointers: pointerBoolean
        classVariableNames: stringOfClassVarNames
     poolDictionaries: stringOfPoolNames     category: categoryName
     Private - create a full featured class and install it



File: gst-base.info,  Node: Metaclass-delegation,  Next: Metaclass-filing,  Prev: Metaclass-basic,  Up: Metaclass

Metaclass: delegation
---------------------

addClassVarName: aString
     Add a class variable with the given name to the class pool
     dictionary

addSharedPool: aDictionary
     Add the given shared pool to the list of the class' pool
     dictionaries

allClassVarNames
     Answer the names of the variables in the receiver's class pool
     dictionary and in each of the superclasses' class pool dictionaries

allSharedPools
     Return the names of the shared pools defined by the class and any
     of its superclasses

category
     Answer the class category

classPool
     Answer the class pool dictionary

classVarNames
     Answer the names of the variables in the class pool dictionary

comment
     Answer the class comment

debuggerClass
     Answer the debugger class that was set in the instance class

environment
     Answer the namespace in which the receiver is implemented

name
     Answer the class name - it has none, actually

removeClassVarName: aString
     Removes the class variable from the class, error if not present, or
     still in use.

removeSharedPool: aDictionary
     Remove the given dictionary to the list of the class' pool
     dictionaries

sharedPools
     Return the names of the shared pools defined by the class



File: gst-base.info,  Node: Metaclass-filing,  Next: Metaclass-printing,  Prev: Metaclass-delegation,  Up: Metaclass

Metaclass: filing
-----------------

fileOutOn: aFileStream
     File out complete class description:  class definition, class and
     instance methods



File: gst-base.info,  Node: Metaclass-printing,  Next: Metaclass-testing functionality,  Prev: Metaclass-filing,  Up: Metaclass

Metaclass: printing
-------------------

nameIn: aNamespace
     Answer the class name when the class is referenced from aNamespace.

printOn: aStream
     Print a represention of the receiver on aStream

printOn: aStream in: aNamespace
     Print on aStream the class name when the class is referenced from
     aNamespace.

storeOn: aStream
     Store Smalltalk code compiling to the receiver on aStream



File: gst-base.info,  Node: Metaclass-testing functionality,  Prev: Metaclass-printing,  Up: Metaclass

Metaclass: testing functionality
--------------------------------

asClass
     Answer `instanceClass'.

isMetaclass
     Answer `true'.



File: gst-base.info,  Node: MethodContext,  Next: MethodDictionary,  Prev: Metaclass,  Up: Base classes

MethodContext
=============

Defined in namespace Smalltalk
Superclass: ContextPart
Category: Language-Implementation
     My instances represent an actively executing method.  They record
     various bits of information about the execution environment, and
     contain the execution stack.

* Menu:

* MethodContext-accessing::  (instance)
* MethodContext-printing::  (instance)


File: gst-base.info,  Node: MethodContext-accessing,  Next: MethodContext-printing,  Up: MethodContext

MethodContext: accessing
------------------------

home
     Answer the MethodContext to which the receiver refers (i.e. the
     receiver itself)

isBlock
     Answer whether the receiver is a block context

     block

isDisabled
     Answers whether the receiver has actually ended execution and will
     be skipped when doing a return.  BlockContexts are removed from the
     chain whenever a non-local return is done, but MethodContexts need
     to stay there in case there is a non-local return from the #ensure:
     block.

isEnvironment
     To create a valid execution environment for the interpreter even
     before it starts, GST creates a fake context whose selector is nil
     and which can be used as a marker for the current execution
     environment.  Answer whether the receiver is that kind of context.

isUnwind
     Answers whether the context must continue execution even after a
     non-local return (a return from the enclosing method of a block, or
     a call to the #continue: method of ContextPart).  Such contexts are
     created only by #ensure:.

sender
     Return the context from which the receiver was sent



File: gst-base.info,  Node: MethodContext-printing,  Prev: MethodContext-accessing,  Up: MethodContext

MethodContext: printing
-----------------------

printOn: aStream
     Print a representation for the receiver on aStream



File: gst-base.info,  Node: MethodDictionary,  Next: MethodInfo,  Prev: MethodContext,  Up: Base classes

MethodDictionary
================

Defined in namespace Smalltalk
Superclass: LookupTable
Category: Language-Implementation
     I am similar to an IdentityDictionary, except that removal and
     rehashing operations inside my instances look atomic to the
     interpreter.

* Menu:

* MethodDictionary-adding::  (instance)
* MethodDictionary-rehashing::  (instance)
* MethodDictionary-removing::  (instance)


File: gst-base.info,  Node: MethodDictionary-adding,  Next: MethodDictionary-rehashing,  Up: MethodDictionary

MethodDictionary: adding
------------------------

at: key put: value
     Store value as associated to the given key



File: gst-base.info,  Node: MethodDictionary-rehashing,  Next: MethodDictionary-removing,  Prev: MethodDictionary-adding,  Up: MethodDictionary

MethodDictionary: rehashing
---------------------------

rehash
     Rehash the receiver



File: gst-base.info,  Node: MethodDictionary-removing,  Prev: MethodDictionary-rehashing,  Up: MethodDictionary

MethodDictionary: removing
--------------------------

remove: anAssociation
     Remove anAssociation's key from the dictionary

removeKey: anElement ifAbsent: aBlock
     Remove the passed key from the dictionary, answer the result of
     evaluating aBlock if it is not found



File: gst-base.info,  Node: MethodInfo,  Next: Namespace,  Prev: MethodDictionary,  Up: Base classes

MethodInfo
==========

Defined in namespace Smalltalk
Superclass: Object
Category: Language-Implementation
     I provide information about particular methods.  I can produce the
     category that a method was filed under, and can be used to access
     the source code of the method.

* Menu:

* MethodInfo-accessing::  (instance)
* MethodInfo-equality::  (instance)


File: gst-base.info,  Node: MethodInfo-accessing,  Next: MethodInfo-equality,  Up: MethodInfo

MethodInfo: accessing
---------------------

category
     Answer the method category

category: aCategory
     Set the method category

methodClass
     Answer the class in which the method is defined

methodClass: aClass
     Set the class in which the method is defined

selector
     Answer the selector through which the method is called

selector: aSymbol
     Set the selector through which the method is called

sourceCode
     Answer a FileSegment or String or nil containing the method source
     code

sourceFile
     Answer the name of the file where the method source code is

sourcePos
     Answer the starting position of the method source code in the
     sourceFile

sourceString
     Answer a String containing the method source code

stripSourceCode
     Remove the reference to the source code for the method



File: gst-base.info,  Node: MethodInfo-equality,  Prev: MethodInfo-accessing,  Up: MethodInfo

MethodInfo: equality
--------------------

= aMethodInfo
     Compare the receiver and aMethodInfo, answer whether they're equal

hash
     Answer an hash value for the receiver



File: gst-base.info,  Node: Namespace,  Next: NetClients.URIResolver,  Prev: MethodInfo,  Up: Base classes

Namespace
=========

Defined in namespace Smalltalk
Superclass: AbstractNamespace
Category: Language-Implementation
     I am a Namespace that has a super-namespace.

* Menu:

* Namespace class-accessing::  (class)
* Namespace class-disabling instance creation::  (class)
* Namespace class-initialization::  (class)
* Namespace-accessing::  (instance)
* Namespace-namespace hierarchy::  (instance)
* Namespace-overrides for superspaces::  (instance)
* Namespace-printing::  (instance)
* Namespace-testing::  (instance)


File: gst-base.info,  Node: Namespace class-accessing,  Next: Namespace class-disabling instance creation,  Up: Namespace

Namespace class: accessing
--------------------------

current
     Answer the current namespace

current: aNamespaceOrClass
     Set the current namespace to be aNamespace or, if it is a class,
     its class pool (the Dictionary that holds class variables).



File: gst-base.info,  Node: Namespace class-disabling instance creation,  Next: Namespace class-initialization,  Prev: Namespace class-accessing,  Up: Namespace

Namespace class: disabling instance creation
--------------------------------------------

new
     Disabled - use #addSubspace: to create instances

new: size
     Disabled - use #addSubspace: to create instances



File: gst-base.info,  Node: Namespace class-initialization,  Next: Namespace-accessing,  Prev: Namespace class-disabling instance creation,  Up: Namespace

Namespace class: initialization
-------------------------------

initialize
     This actually is not needed, the job could be done in dict.c
     (function namespace_new).  But I'm lazy and I prefer to rely on
     the Smalltalk implementation of IdentitySet.



File: gst-base.info,  Node: Namespace-accessing,  Next: Namespace-namespace hierarchy,  Prev: Namespace class-initialization,  Up: Namespace

Namespace: accessing
--------------------

inheritedKeys
     Answer a Set of all the keys in the receiver and its superspaces



File: gst-base.info,  Node: Namespace-namespace hierarchy,  Next: Namespace-overrides for superspaces,  Prev: Namespace-accessing,  Up: Namespace

Namespace: namespace hierarchy
------------------------------

siblings
     Answer all the other namespaces that inherit from the receiver's
     superspace.

siblingsDo: aBlock
     Evaluate aBlock once for each of the other namespaces that inherit
     from the receiver's superspace, passing the namespace as a
     parameter.



File: gst-base.info,  Node: Namespace-overrides for superspaces,  Next: Namespace-printing,  Prev: Namespace-namespace hierarchy,  Up: Namespace

Namespace: overrides for superspaces
------------------------------------

associationAt: key ifAbsent: aBlock
     Return the key/value pair associated to the variable named as
     specified by `key'. If the key is not found search will be brought
     on in superspaces, finally evaluating aBlock if the variable
     cannot be found in any of the superspaces.

associationsDo: aBlock
     Pass each association in the namespace to aBlock

at: key ifAbsent: aBlock
     Return the value associated to the variable named as specified by
     `key'. If the key is not found search will be brought on in
     superspaces, finally evaluating aBlock if the variable cannot be
     found in any of the superspaces.

at: key ifPresent: aBlock
     If aKey is absent from the receiver and all its superspaces,
     answer nil. Else, evaluate aBlock passing the associated value and
     answer the result of the invocation

do: aBlock
     Pass each value in the namespace to aBlock

includesKey: key
     Answer whether the receiver or any of its superspaces contain the
     given key

keysAndValuesDo: aBlock
     Pass to aBlock each of the receiver's keys and values, in two
     separate parameters

keysDo: aBlock
     Pass to aBlock each of the receiver's keys

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.

size
     Answer the number of keys in the receiver and each of its
     superspaces



File: gst-base.info,  Node: Namespace-printing,  Next: Namespace-testing,  Prev: Namespace-overrides for superspaces,  Up: Namespace

Namespace: printing
-------------------

nameIn: aNamespace
     Answer Smalltalk code compiling to the receiver when the current
     namespace is aNamespace

printOn: aStream in: aNamespace
     Print on aStream some Smalltalk code compiling to the receiver
     when the current namespace is aNamespace

storeOn: aStream
     Store Smalltalk code compiling to the receiver



File: gst-base.info,  Node: Namespace-testing,  Prev: Namespace-printing,  Up: Namespace

Namespace: testing
------------------

isSmalltalk
     Answer `true'.



File: gst-base.info,  Node: NetClients.URIResolver,  Next: NetClients.URL,  Prev: Namespace,  Up: Base classes

NetClients.URIResolver
======================

Defined in namespace Smalltalk.NetClients
Superclass: Object
Category: NetClients-URIResolver
     This class publishes methods to download files from the Internet.

* Menu:

* NetClients.URIResolver class-api::  (class)
* NetClients.URIResolver class-instance creation::  (class)


File: gst-base.info,  Node: NetClients.URIResolver class-api,  Next: NetClients.URIResolver class-instance creation,  Up: NetClients.URIResolver

NetClients.URIResolver class: api
---------------------------------

openOn: aURI
     Always raise an error, as this method is not supported without
     loading the additional NetClients package.

openOn: aURI ifFail: aBlock
     Always evaluate aBlock and answer the result if the additional
     NetClients package is not loaded.  If it is, instead, return a
     WebEntity with the contents of the resource specified by anURI,
     and only evaluate the block if loading the resource fails.

openStreamOn: aURI
     Check if aURI can be fetched from the Internet or from the local
     system, and if so return a Stream with its contents.  If this is
     not possible, raise an exception.

openStreamOn: aURI ifFail: aBlock
     Check if aURI can be fetched from the Internet or from the local
     system, and if so return a Stream with its contents.  If this is
     not possible, instead, evaluate the zero-argument block aBlock and
     answer the result of the evaluation.



File: gst-base.info,  Node: NetClients.URIResolver class-instance creation,  Prev: NetClients.URIResolver class-api,  Up: NetClients.URIResolver

NetClients.URIResolver class: instance creation
-----------------------------------------------

on: anURL
     Answer a new URIResolver that will do its best to fetch the data
     for anURL from the Internet.



File: gst-base.info,  Node: NetClients.URL,  Next: Notification,  Prev: NetClients.URIResolver,  Up: Base classes

NetClients.URL
==============

Defined in namespace Smalltalk.NetClients
Superclass: Object
Category: NetClients-URIResolver
     Copyright (c) Kazuki Yasumatsu, 1995. All rights reserved.


* Menu:

* NetClients.URL class-encoding URLs::  (class)
* NetClients.URL class-instance creation::  (class)
* NetClients.URL-accessing::  (instance)
* NetClients.URL-comparing::  (instance)
* NetClients.URL-copying::  (instance)
* NetClients.URL-initialize-release::  (instance)
* NetClients.URL-printing::  (instance)
* NetClients.URL-testing::  (instance)
* NetClients.URL-utilities::  (instance)


File: gst-base.info,  Node: NetClients.URL class-encoding URLs,  Next: NetClients.URL class-instance creation,  Up: NetClients.URL

NetClients.URL class: encoding URLs
-----------------------------------

decode: aString
     Decode a text/x-www-form-urlencoded String into a text/plain
     String.

encode: anURL
     Encode a text/plain into a text/x-www-form-urlencoded String (those
     things with lots of % in them).

initialize
     Initialize the receiver's class variables.



File: gst-base.info,  Node: NetClients.URL class-instance creation,  Next: NetClients.URL-accessing,  Prev: NetClients.URL class-encoding URLs,  Up: NetClients.URL

NetClients.URL class: instance creation
---------------------------------------

fromString: aString
     Parse the given URL and answer an URL object based on it.

new
     Answer a 'blank' URL.

scheme: schemeString host: hostString port: portNumber path: pathString
     Answer an URL object made from all the parts passed as arguments.

scheme: schemeString path: pathString
     Answer an URL object made from all the parts passed as arguments.

scheme: schemeString username: userString password: passwordString host: hostString port: portNumber path: pathString
     Answer an URL object made from all the parts passed as arguments.



File: gst-base.info,  Node: NetClients.URL-accessing,  Next: NetClients.URL-comparing,  Prev: NetClients.URL class-instance creation,  Up: NetClients.URL

NetClients.URL: accessing
-------------------------

decodedFields
     Convert the form fields to a Dictionary, answer nil if no question
     mark is found in the URL.

decodedFile
     Answer the file part of the URL, decoding it from
     x-www-form-urlencoded format.

decodedFragment
     Answer the fragment part of the URL, decoding it from
     x-www-form-urlencoded format.

fragment
     Answer the fragment part of the URL, leaving it in
     x-www-form-urlencoded format.

fragment: aString
     Set the fragment part of the URL, which should be in
     x-www-form-urlencoded format.

fullRequestString
     Answer the full request string corresponding to the URL.  This is
     how the URL would be printed in the address bar of a web browser,
     except that the query data is printed even if it is to be sent
     through a POST request.

hasPostData
     Answer whether the URL has a query part but is actually for an
     HTTP POST request and not really part of the URL (as it would be
     for the HTTP GET request).

hasPostData: aBoolean
     Set whether the query part of the URL is actually the data for an
     HTTP POST request and not really part of the URL (as it would be
     for the HTTP GET request).

host
     Answer the host part of the URL.

host: aString
     Set the host part of the URL to aString.

newsGroup
     If the receiver is an nntp url, return the news group.

password
     Answer the password part of the URL.

password: aString
     Set the password part of the URL to aString.

path
     Answer the path part of the URL.

path: aString
     Set the path part of the URL to aString.

port
     Answer the port number part of the URL.

port: anInteger
     Set the port number part of the URL to anInteger.

postData
     Answer whether the URL has a query part and it is meant for an
     HTTP POST request, answer it.  Else answer nil.

postData: aString
     Associate to the URL some data that is meant to be sent through an
     HTTP POST request, answer it.

query
     Answer the query data associated to the URL.

query: aString
     Set the query data associated to the URL to aString.

requestString
     Answer the URL as it would be sent in an HTTP stream (that is, the
     path and the query data, the latter only if it is to be sent with
     an HTTP POST request).

scheme
     Answer the URL's scheme.

scheme: aString
     Set the URL's scheme to be aString.

username
     Answer the username part of the URL.

username: aString
     Set the username part of the URL to aString.



File: gst-base.info,  Node: NetClients.URL-comparing,  Next: NetClients.URL-copying,  Prev: NetClients.URL-accessing,  Up: NetClients.URL

NetClients.URL: comparing
-------------------------

= anURL
     Answer whether the two URLs are equal.  The file and anchor are
     converted to full 8-bit ASCII (contrast with urlencoded) and the
     comparison is case-sensitive; on the other hand, the protocol and
     host are compared without regard to case.

hash
     Answer an hash value for the receiver



File: gst-base.info,  Node: NetClients.URL-copying,  Next: NetClients.URL-initialize-release,  Prev: NetClients.URL-comparing,  Up: NetClients.URL

NetClients.URL: copying
-----------------------

copyWithoutAuxiliaryParts
     Answer a copy of the receiver where the fragment and query parts
     of the URL have been cleared.

copyWithoutFragment
     Answer a copy of the receiver where the fragment parts of the URL
     has been cleared.

postCopy
     All the variables are copied when an URL object is copied.



File: gst-base.info,  Node: NetClients.URL-initialize-release,  Next: NetClients.URL-printing,  Prev: NetClients.URL-copying,  Up: NetClients.URL

NetClients.URL: initialize-release
----------------------------------

initialize
     Initialize the object to a consistent state.



File: gst-base.info,  Node: NetClients.URL-printing,  Next: NetClients.URL-testing,  Prev: NetClients.URL-initialize-release,  Up: NetClients.URL

NetClients.URL: printing
------------------------

printOn: stream
     Print a representation of the URL on the given stream.



File: gst-base.info,  Node: NetClients.URL-testing,  Next: NetClients.URL-utilities,  Prev: NetClients.URL-printing,  Up: NetClients.URL

NetClients.URL: testing
-----------------------

canCache
     Answer whether the URL is cacheable.  The current implementation
     considers file URLs not to be cacheable, and everything else to be.

hasFragment
     Answer whether the URL points to a particular fragment (anchor) of
     the resource.

hasQuery
     Answer whether the URL includes query arguments to be submitted
     when retrieving the resource.

isFileScheme
     Answer whether the URL is a file URL.

isFragmentOnly
     Answer whether the URL only includes the name of a particular
     fragment (anchor) of the resource to which it refers.



File: gst-base.info,  Node: NetClients.URL-utilities,  Prev: NetClients.URL-testing,  Up: NetClients.URL

NetClients.URL: utilities
-------------------------

construct: anURL
     Construct an absolute URL based on the relative URL anURL and the
     base path represented by the receiver



File: gst-base.info,  Node: Notification,  Next: NullProxy,  Prev: NetClients.URL,  Up: Base classes

Notification
============

Defined in namespace Smalltalk
Superclass: Exception
Category: Language-Exceptions
     Notification represents a resumable, exceptional yet non-erroneous,
     situation.  Signaling a notification in absence of an handler
     simply returns nil.

* Menu:

* Notification-exception description::  (instance)


File: gst-base.info,  Node: Notification-exception description,  Up: Notification

Notification: exception description
-----------------------------------

defaultAction
     Do the default action for notifications, which is to resume
     execution of the context which signaled the exception.

description
     Answer a textual description of the exception.

isResumable
     Answer true.  Notification exceptions are by default resumable.



File: gst-base.info,  Node: NullProxy,  Next: NullValueHolder,  Prev: Notification,  Up: Base classes

NullProxy
=========

Defined in namespace Smalltalk
Superclass: AlternativeObjectProxy
Category: Streams-Files
     I am a proxy that does no special processing on the object to be
     saved. I can be used to disable proxies for particular subclasses.
     My subclasses add to the stored information, but share the fact
     that the format is about the same as that of #dump: without a
     proxy.

* Menu:

* NullProxy class-instance creation::  (class)
* NullProxy-accessing::  (instance)


File: gst-base.info,  Node: NullProxy class-instance creation,  Next: NullProxy-accessing,  Up: NullProxy

NullProxy class: instance creation
----------------------------------

loadFrom: anObjectDumper
     Reload the object stored in anObjectDumper



File: gst-base.info,  Node: NullProxy-accessing,  Prev: NullProxy class-instance creation,  Up: NullProxy

NullProxy: accessing
--------------------

dumpTo: anObjectDumper
     Dump the object stored in the proxy to anObjectDumper



File: gst-base.info,  Node: NullValueHolder,  Next: Number,  Prev: NullProxy,  Up: Base classes

NullValueHolder
===============

Defined in namespace Smalltalk
Superclass: ValueAdaptor
Category: Language-Data types
     I pretend to store my value in a variable, but I don't actually.
     You can use the only instance of my class (returned by
     `ValueHolder null') if you're not interested in a value that is
     returned as described in ValueHolder's comment.

* Menu:

* NullValueHolder class-creating instances::  (class)
* NullValueHolder-accessing::  (instance)


File: gst-base.info,  Node: NullValueHolder class-creating instances,  Next: NullValueHolder-accessing,  Up: NullValueHolder

NullValueHolder class: creating instances
-----------------------------------------

new
     Not used - use `ValueHolder null' instead



File: gst-base.info,  Node: NullValueHolder-accessing,  Prev: NullValueHolder class-creating instances,  Up: NullValueHolder

NullValueHolder: accessing
--------------------------

value
     Retrive the value of the receiver. Always answer nil

value: anObject
     Set the value of the receiver. Do nothing, discard the value



File: gst-base.info,  Node: Number,  Next: Object,  Prev: NullValueHolder,  Up: Base classes

Number
======

Defined in namespace Smalltalk
Superclass: Magnitude
Category: Language-Data types
     I am an abstract class that provides operations on numbers, both
     floating point and integer.  I provide some generic predicates,
     and supply the implicit type coercing code for binary operations.

* Menu:

* Number class-converting::  (class)
* Number class-testing::  (class)
* Number-arithmetic::  (instance)
* Number-comparing::  (instance)
* Number-converting::  (instance)
* Number-copying::  (instance)
* Number-error raising::  (instance)
* Number-misc math::  (instance)
* Number-point creation::  (instance)
* Number-retrying::  (instance)
* Number-shortcuts and iterators::  (instance)
* Number-testing::  (instance)
* Number-truncation and round off::  (instance)


File: gst-base.info,  Node: Number class-converting,  Next: Number class-testing,  Up: Number

Number class: converting
------------------------

coerce: aNumber
     Answer aNumber - whatever class it belongs to, it is good

readFrom: aStream
     Answer the number read from the rest of aStream, converted to an
     instance of the receiver. If the receiver is number, the class of
     the result is undefined - but the result is good.



File: gst-base.info,  Node: Number class-testing,  Next: Number-arithmetic,  Prev: Number class-converting,  Up: Number

Number class: testing
---------------------

isImmediate
     Answer whether, if x is an instance of the receiver, x copy == x



File: gst-base.info,  Node: Number-arithmetic,  Next: Number-comparing,  Prev: Number class-testing,  Up: Number

Number: arithmetic
------------------

* aNumber
     Subtract the receiver and aNumber, answer the result

+ aNumber
     Sum the receiver and aNumber, answer the result

- aNumber
     Subtract aNumber from the receiver, answer the result

/ aNumber
     Divide the receiver by aNumber, answer the result (no loss of
     precision).  Raise a ZeroDivide exception or return a valid
     (possibly infinite) continuation value if aNumber is zero.

// aNumber
     Return the integer quotient of dividing the receiver by aNumber
     with truncation towards negative infinity.  Raise a ZeroDivide
     exception if aNumber is zero

\\ aNumber
     Return the remainder of dividing the receiver by aNumber with
     truncation towards negative infinity.  Raise a ZeroDivide
     exception if aNumber is zero

quo: aNumber
     Return the integer quotient of dividing the receiver by aNumber
     with truncation towards zero.  Raise a ZeroDivide exception if
     aNumber is zero

reciprocal
     Return the reciprocal of the receiver

rem: aNumber
     Return the remainder of dividing the receiver by aNumber with
     truncation towards zero.  Raise a ZeroDivide exception if aNumber
     is zero



File: gst-base.info,  Node: Number-comparing,  Next: Number-converting,  Prev: Number-arithmetic,  Up: Number

Number: comparing
-----------------

max: aNumber
     Redefined to ensure that a NaN is never answered.  Answer the
     maximum between the receiver and aNumber.

min: aNumber
     Redefined to ensure that a NaN is never answered.  Answer the
     minimum between the receiver and aNumber.



File: gst-base.info,  Node: Number-converting,  Next: Number-copying,  Prev: Number-comparing,  Up: Number

Number: converting
------------------

asFloat
     Convert the receiver to an arbitrary subclass of Float

asFloatD
     This method's functionality should be implemented by subclasses of
     Number

asFloatE
     This method's functionality should be implemented by subclasses of
     Number

asFloatQ
     This method's functionality should be implemented by subclasses of
     Number

asRectangle
     Answer an empty rectangle whose origin is (self asPoint)

asScaledDecimal: n
     Answer the receiver, converted to a ScaledDecimal object.

asScaledDecimal: denDigits scale: n
     Answer the receiver, divided by 10^denDigits and converted to a
     ScaledDecimal object.

coerce: aNumber
     Answer aNumber - whatever class it belongs to, it is good

degreesToRadians
     Convert the receiver to radians

generality
     Answer the receiver's generality

radiansToDegrees
     Convert the receiver from radians to degrees

unity
     Coerce 1 to the receiver's class. The default implementation works,
     but is inefficient

zero
     Coerce 0 to the receiver's class. The default implementation works,
     but is inefficient



File: gst-base.info,  Node: Number-copying,  Next: Number-error raising,  Prev: Number-converting,  Up: Number

Number: copying
---------------

deepCopy
     Return the receiver - it's an immediate (immutable) object

shallowCopy
     Return the receiver - it's an immediate (immutable) object



File: gst-base.info,  Node: Number-error raising,  Next: Number-misc math,  Prev: Number-copying,  Up: Number

Number: error raising
---------------------

arithmeticError: msg
     Raise an ArithmeticError exception having msg as its message text.

zeroDivide
     Raise a division-by-zero (ZeroDivide) exception whose dividend is
     the receiver.



File: gst-base.info,  Node: Number-misc math,  Next: Number-point creation,  Prev: Number-error raising,  Up: Number

Number: misc math
-----------------

abs
     Answer the absolute value of the receiver

arcCos
     return the arc cosine of the receiver

arcSin
     return the arc sine of the receiver

arcTan
     return the arc tangent of the receiver

cos
     return the cosine of the receiver

estimatedLog
     Answer an estimate of (self abs floorLog: 10). This method should
     be overridden by subclasses, but Number's implementation does not
     raise errors - simply, it gives a correct result, so it is slow.

exp
     return e raised to the receiver

floorLog: radix
     return (self log: radix) floor. Optimized to answer an integer.

ln
     return log base e of the receiver

log
     return log base aNumber of the receiver

log: aNumber
     return log base aNumber of the receiver

negated
     Answer the negated of the receiver

positiveDifference: aNumber
     Answer the positive difference of the receiver and aNumber, that
     is self - aNumber if it is positive, 0 otherwise.

raisedTo: aNumber
     Return self raised to aNumber power

raisedToInteger: anInteger
     Return self raised to the anInteger-th power

sin
     return the sine of the receiver

sqrt
     return the square root of the receiver

squared
     Answer the square of the receiver

tan
     return the tangent of the receiver

withSignOf: aNumber
     Answer the receiver, with its sign possibly changed to match that
     of aNumber.



File: gst-base.info,  Node: Number-point creation,  Next: Number-retrying,  Prev: Number-misc math,  Up: Number

Number: point creation
----------------------

@ y
     Answer a new point whose x is the receiver and whose y is y

asPoint
     Answer a new point, self @ self



File: gst-base.info,  Node: Number-retrying,  Next: Number-shortcuts and iterators,  Prev: Number-point creation,  Up: Number

Number: retrying
----------------

retry: aSymbol coercing: aNumber
     Coerce to the other number's class the one number between the
     receiver and aNumber which has the lowest, and retry calling
     aSymbol.  aSymbol is supposed not to be #= or #~= (since those
     don't fail if aNumber is not a Number).

retryDifferenceCoercing: aNumber
     Coerce to the other number's class the one number between the
     receiver and aNumber which has the lowest, and retry calling #-.

retryDivisionCoercing: aNumber
     Coerce to the other number's class the one number between the
     receiver and aNumber which has the lowest, and retry calling #/.

retryEqualityCoercing: aNumber
     Coerce to the other number's class the one number between the
     receiver and aNumber which has the lowest, and retry calling #=.

retryError
     Raise an error--a retrying method was called with two arguments
     having the same generality.

retryInequalityCoercing: aNumber
     Coerce to the other number's class the one number between the
     receiver and aNumber which has the lowest, and retry calling #~=.

retryMultiplicationCoercing: aNumber
     Coerce to the other number's class the one number between the
     receiver and aNumber which has the lowest, and retry calling #*.

retryRelationalOp: aSymbol coercing: aNumber
     Coerce to the other number's class the one number between the
     receiver and aNumber which has the lowest, and retry calling
     aSymbol (<, <=, >, >=).

retrySumCoercing: aNumber
     Coerce to the other number's class the one number between the
     receiver and aNumber which has the lowest, and retry calling #+.



File: gst-base.info,  Node: Number-shortcuts and iterators,  Next: Number-testing,  Prev: Number-retrying,  Up: Number

Number: shortcuts and iterators
-------------------------------

to: stop
     Return an interval going from the receiver to stop by 1

to: stop by: step
     Return an interval going from the receiver to stop with the given
     step

to: stop by: step do: aBlock
     Evaluate aBlock for each value in the interval going from the
     receiver to stop with the given step. Compiled in-line for integer
     literal steps, and for one-argument aBlocks without temporaries,
     and therefore not overridable.

to: stop do: aBlock
     Evaluate aBlock for each value in the interval going from the
     receiver to stop by 1. Compiled in-line for one-argument aBlocks
     without temporaries, and therefore not overridable.



File: gst-base.info,  Node: Number-testing,  Next: Number-truncation and round off,  Prev: Number-shortcuts and iterators,  Up: Number

Number: testing
---------------

closeTo: num
     Answer whether the receiver can be considered sufficiently close
     to num (this is done by checking equality if num is not a number,
     and by checking with 0.01% tolerance if num is a number).

even
     Returns true if self is divisible by 2

isFinite
     Answer whether the receiver represents a finite quantity.  Most
     numeric classes are for finite quantities, so the default is to
     answer true rather than calling #subclassResponsibility.

isInfinite
     Answer whether the receiver represents an infinite quantity.  Most
     numeric classes are for finite quantities, so the default is to
     answer false rather than calling #subclassResponsibility.

isNaN
     Answer whether the receiver is a Not-A-Number.  Most numeric
     classes don't handle nans, so the default is to answer false
     rather than calling #subclassResponsibility.

isNumber
     Answer `true'.

isRational
     Answer whether the receiver is rational - false by default

negative
     Answer whether the receiver is < 0

odd
     Returns true if self is not divisible by 2

positive
     Answer whether the receiver is >= 0

sign
     Returns the sign of the receiver.

strictlyPositive
     Answer whether the receiver is > 0



File: gst-base.info,  Node: Number-truncation and round off,  Prev: Number-testing,  Up: Number

Number: truncation and round off
--------------------------------

asInteger
     Answer the receiver, rounded to the nearest integer

floor
     Return the integer nearest the receiver toward negative infinity.

fractionPart
     Answer a number which, summed to the #integerPart of the receiver,
     gives the receiver itself.

integerPart
     Answer the receiver, truncated towards zero

rounded
     Returns the integer nearest the receiver

roundTo: aNumber
     Answer the receiver, truncated to the nearest multiple of aNumber

truncated
     Answer the receiver, truncated towards zero

truncateTo: aNumber
     Answer the receiver, truncated towards zero to a multiple of
     aNumber



File: gst-base.info,  Node: Object,  Next: ObjectDumper,  Prev: Number,  Up: Base classes

Object
======

Defined in namespace Smalltalk
Superclass: none
Category: Language-Implementation
     I am the root of the Smalltalk class system.  All classes in the
     system are subclasses of me.

* Menu:

* Object class-initialization::  (class)
* Object-built ins::  (instance)
* Object-change and update::  (instance)
* Object-class type methods::  (instance)
* Object-conversion::  (instance)
* Object-copying::  (instance)
* Object-debugging::  (instance)
* Object-dependents access::  (instance)
* Object-error raising::  (instance)
* Object-exception handling::  (instance)
* Object-finalization::  (instance)
* Object-printing::  (instance)
* Object-relational operators::  (instance)
* Object-saving and loading::  (instance)
* Object-storing::  (instance)
* Object-syntax shortcuts::  (instance)
* Object-testing functionality::  (instance)


File: gst-base.info,  Node: Object class-initialization,  Next: Object-built ins,  Up: Object

Object class: initialization
----------------------------

dependencies
     Answer a dictionary that associates an object with its dependents.

dependencies: anObject
     Use anObject as the dictionary that associates an object with its
     dependents.

finalizableObjects
     Answer a set of finalizable objects.

initialize
     Initialize the Dependencies dictionary to be an
     IdentityDictionary.  In a later phase of the bootstrap process
     this is changed to be a WeakKeyIdentityDictionary.

update: aspect
     Do any global tasks for the ObjectMemory events.



File: gst-base.info,  Node: Object-built ins,  Next: Object-change and update,  Prev: Object class-initialization,  Up: Object

Object: built ins
-----------------

= 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

== arg
     Answer whether the receiver is the same object as arg. This is a
     very fast test and is called 'identity'

asOop
     Answer the object index associated to the receiver. The object
     index doesn't change when garbage collection is performed.

at: anIndex
     Answer the index-th indexed instance variable of the receiver

at: anIndex put: value
     Store value in the index-th indexed instance variable of the
     receiver

basicAt: anIndex
     Answer the index-th indexed instance variable of the receiver.
     This method must not be overridden, override at: instead

basicAt: anIndex put: value
     Store value in the index-th indexed instance variable of the
     receiver This method must not be overridden, override at:put:
     instead

basicPrint
     Print a basic representation of the receiver

basicSize
     Answer the number of indexed instance variable in the receiver

become: otherObject
     Change all references to the receiver into references to
     otherObject.  Depending on the implementation, references to
     otherObject might or might not be transformed into the receiver
     (respectively, 'two-way become' and 'one-way become').
     Implementations doing one-way become answer the receiver (so that
     it is not lost). Most implementations doing two-way become answer
     otherObject, but this is not assured - so do answer the receiver
     for consistency.  GNU Smalltalk does two-way become and answers
     otherObject, but this might change in future versions: programs
     should not rely on the behavior and results of #become: .

changeClassTo: aBehavior
     Mutate the class of the receiver to be aBehavior.  Note: Tacitly
     assumes that the structure is the same for the original and new
     class!!

checkIndexableBounds: index
     Private - Check the reason why an access to the given indexed
     instance variable failed

checkIndexableBounds: index put: object
     Private - Check the reason why a store to the given indexed
     instance variable failed

class
     Answer the class to which the receiver belongs

halt
     Called to enter the debugger

hash
     Answer an hash value for the receiver. This hash value is ok for
     objects that do not redefine ==.

identityHash
     Answer an hash value for the receiver. This method must not be
     overridden

instVarAt: index
     Answer the index-th instance variable of the receiver.  This
     method must not be overridden.

instVarAt: index put: value
     Store value in the index-th instance variable of the receiver.
     This method must not be overridden.

isReadOnly
     Answer whether the object's indexed instance variables can be
     written

makeEphemeron
     Make the object an 'ephemeron'.  An ephemeron is marked after all
     other objects, and if no references are found to the key except
     from the object itself, it is sent the #mourn message.

makeFixed
     Avoid that the receiver moves in memory across garbage collections.

makeReadOnly: aBoolean
     Set whether the object's indexed instance variables can be written

makeWeak
     Make the object a 'weak' one. When an object is only referenced by
     weak objects, it is collected and the slots in the weak objects
     are changed to nils by the VM; the weak object is then sent the
     #mourn message.

mark: aSymbol
     Private - use this method to mark code which needs to be reworked,
     removed, etc. You can then find all senders of #mark: to find all
     marked methods or you can look for all senders of the symbol that
     you sent to #mark: to find a category of marked methods.

nextInstance
     Private - answer another instance of the receiver's class, or nil
     if the entire object table has been walked

notYetImplemented
     Called when a method defined by a class is not yet implemented,
     but is going to be

perform: selectorOrMessageOrMethod
     Send the unary message named selectorOrMessageOrMethod (if a
     Symbol) to the receiver, or the message and arguments it
     identifies (if a Message or DirectedMessage), or finally execute
     the method within the receiver (if a CompiledMethod).  In the last
     case, the method need not reside on the hierarchy from the
     receiver's class to Object - it need not reside at all in a
     MethodDictionary, in fact - but doing bad things will compromise
     stability of the Smalltalk virtual machine (and don't blame
     anybody but yourself).  This method should not be overridden

perform: selectorOrMethod with: arg1
     Send the message named selectorOrMethod (if a Symbol) to the
     receiver, passing arg1 to it, or execute the method within the
     receiver (if a CompiledMethod).  In the latter case, the method
     need not reside on the hierarchy from the receiver's class to
     Object - it need not reside at all in a MethodDictionary, in fact
     - but doing bad things will compromise stability of the Smalltalk
     virtual machine (and don't blame anybody but yourself).  This
     method should not be overridden

perform: selectorOrMethod with: arg1 with: arg2
     Send the message named selectorOrMethod (if a Symbol) to the
     receiver, passing arg1 and arg2 to it, or execute the method
     within the receiver (if a CompiledMethod).  In the latter case,
     the method need not reside on the hierarchy from the receiver's
     class to Object - it need not reside at all in a MethodDictionary,
     in fact - but doing bad things will compromise stability of the
     Smalltalk virtual machine (and don't blame anybody but yourself).
     This method should not be overridden

perform: selectorOrMethod with: arg1 with: arg2 with: arg3
     Send the message named selectorOrMethod (if a Symbol) to the
     receiver, passing the other arguments to it, or execute the method
     within the receiver (if a CompiledMethod).  In the latter case,
     the method need not reside on the hierarchy from the receiver's
     class to Object - it need not reside at all in a MethodDictionary,
     in fact - but doing bad things will compromise stability of the
     Smalltalk virtual machine (and don't blame anybody but yourself).
     This method should not be overridden

perform: selectorOrMethod withArguments: argumentsArray
     Send the message named selectorOrMethod (if a Symbol) to the
     receiver, passing the elements of argumentsArray as parameters, or
     execute the method within the receiver (if a CompiledMethod).  In
     the latter case, the method need not reside on the hierarchy from
     the receiver's class to Object - it need not reside at all in a
     MethodDictionary, in fact - but doing bad things will compromise
     stability of the Smalltalk virtual machine (and don't blame
     anybody but yourself).  This method should not be overridden

primError: message
     This might start the debugger... Note that we use #basicPrint
     'cause #printOn: might invoke an error.

primitiveFailed
     Called when a VM primitive fails

shallowCopy
     Returns a shallow copy of the receiver (the instance variables are
     not copied)

shouldNotImplement
     Called when objects belonging to a class should not answer a
     selector defined by a superclass

size
     Answer the number of indexed instance variable in the receiver

subclassResponsibility
     Called when a method defined by a class should be overridden in a
     subclass

tenure
     Move the object to oldspace.



File: gst-base.info,  Node: Object-change and update,  Next: Object-class type methods,  Prev: Object-built ins,  Up: Object

Object: change and update
-------------------------

broadcast: aSymbol
     Send the unary message aSymbol to each of the receiver's dependents

broadcast: aSymbol with: anObject
     Send the message aSymbol to each of the receiver's dependents,
     passing anObject

broadcast: aSymbol with: arg1 with: arg2
     Send the message aSymbol to each of the receiver's dependents,
     passing arg1 and arg2 as parameters

broadcast: aSymbol withArguments: anArray
     Send the message aSymbol to each of the receiver's dependents,
     passing the parameters in anArray

broadcast: aSymbol withBlock: aBlock
     Send the message aSymbol to each of the receiver's dependents,
     passing the result of evaluating aBlock with each dependent as the
     parameter

changed
     Send update: for each of the receiver's dependents, passing them
     the receiver

changed: aParameter
     Send update: for each of the receiver's dependents, passing them
     aParameter

update: aParameter
     Default behavior is to do nothing. Called by #changed and #changed:



File: gst-base.info,  Node: Object-class type methods,  Next: Object-conversion,  Prev: Object-change and update,  Up: Object

Object: class type methods
--------------------------

species
     This method has no unique definition. Generally speaking, methods
     which always return the same type usually don't use #class, but
     #species.  For example, a PositionableStream's species is the
     class of the collection on which it is streaming (used by upTo:,
     upToAll:, upToEnd). Stream uses species for obtaining the class of
     next:'s return value, Collection uses it in its #copyEmpty:
     message, which in turn is used by all collection-re- turning
     methods. An Interval's species is Array (used by collect:, select:,
     reject:, etc.).

yourself
     Answer the receiver



File: gst-base.info,  Node: Object-conversion,  Next: Object-copying,  Prev: Object-class type methods,  Up: Object

Object: conversion
------------------

asValue
     Answer a ValueHolder whose initial value is the receiver.



File: gst-base.info,  Node: Object-copying,  Next: Object-debugging,  Prev: Object-conversion,  Up: Object

Object: copying
---------------

copy
     Returns a shallow copy of the receiver (the instance variables are
     not copied). The shallow copy receives the message postCopy and the
     result of postCopy is passed back.

deepCopy
     Returns a deep copy of the receiver (the instance variables are
     copies of the receiver's instance variables)

postCopy
     Performs any changes required to do on a copied object. This is the
     place where one could, for example, put code to replace objects
     with copies of the objects



File: gst-base.info,  Node: Object-debugging,  Next: Object-dependents access,  Prev: Object-copying,  Up: Object

Object: debugging
-----------------

breakpoint: context return: return
     Called back by the system. Must return the value passed through the
     second parameter

inspect
     Print all the instance variables of the receiver on the Transcript

validSize
     Answer how many elements in the receiver should be inspected



File: gst-base.info,  Node: Object-dependents access,  Next: Object-error raising,  Prev: Object-debugging,  Up: Object

Object: dependents access
-------------------------

addDependent: anObject
     Add anObject to the set of the receiver's dependents. Important:
     if an object has dependents, it won't be garbage collected.

dependents
     Answer a collection of the receiver's dependents.

release
     Remove all of the receiver's dependents from the set and allow the
     receiver to be garbage collected.

removeDependent: anObject
     Remove anObject to the set of the receiver's dependents. No problem
     if anObject is not in the set of the receiver's dependents.



File: gst-base.info,  Node: Object-error raising,  Next: Object-exception handling,  Prev: Object-dependents access,  Up: Object

Object: error raising
---------------------

doesNotUnderstand: aMessage
     Called by the system when a selector was not found. message is a
     Message containing information on the receiver

error: message
     Display a walkback for the receiver, with the given error message.
     Signal an `Error' exception (you can trap it the old way too, with
     `ExError'

halt: message
     Display a walkback for the receiver, with the given error message.
     Signal an `Halt' exception (you can trap it the old way too, with
     `ExHalt')



File: gst-base.info,  Node: Object-exception handling,  Next: Object-finalization,  Prev: Object-error raising,  Up: Object

Object: exception handling
--------------------------

badReturnError
     Called back when a block performs a bad return.

mustBeBoolean
     Called by the system when ifTrue:*, ifFalse:*, and: or or: are
     sent to anything but a boolean

noRunnableProcess
     Called back when all processes are suspended

userInterrupt
     Called back when the user presses Ctrl-Break



File: gst-base.info,  Node: Object-finalization,  Next: Object-printing,  Prev: Object-exception handling,  Up: Object

Object: finalization
--------------------

addToBeFinalized
     Arrange things so that #finalize is sent to the object when the
     garbage collector finds out there are only weak references to it.

finalize
     Do nothing by default

mourn
     This method is sent by the VM to weak and ephemeron objects when
     one of their fields is found out to be garbage collectable (this
     means, for weak objects, that there are no references to it from
     non-weak objects, and for ephemeron objects, that the only paths
     to the first instance variable pass through other instance
     variables of the same ephemeron).  The default behavior is to do
     nothing.

removeToBeFinalized
     Unregister the object, so that #finalize is no longer sent to the
     object when the garbage collector finds out there are only weak
     references to it.



File: gst-base.info,  Node: Object-printing,  Next: Object-relational operators,  Prev: Object-finalization,  Up: Object

Object: printing
----------------

basicPrintNl
     Print a basic representation of the receiver, followed by a new
     line.

basicPrintOn: aStream
     Print a represention of the receiver on aStream

     representation

display
     Print a represention of the receiver on the Transcript (stdout the
     GUI is not active). For most objects this is simply its #print
     representation, but for strings and characters, superfluous dollars
     or extra pair of quotes are stripped.

displayNl
     Print a represention of the receiver, then put a new line on the
     Transcript (stdout the GUI is not active). For most objects this
     is simply its #printNl representation, but for strings and
     characters, superfluous dollars or extra pair of quotes are
     stripped.

displayOn: aStream
     Print a represention of the receiver on aStream. For most objects
     this is simply its #printOn: representation, but for strings and
     characters, superfluous dollars or extra pair of quotes are
     stripped.

displayString
     Answer a String representing the receiver. For most objects this
     is simply its #printString, but for strings and characters,
     superfluous dollars or extra pair of quotes are stripped.

print
     Print a represention of the receiver on the Transcript (stdout the
     GUI is not active)

printNl
     Print a represention of the receiver on stdout, put a new line the
     Transcript (stdout the GUI is not active)

printOn: aStream
     Print a represention of the receiver on aStream

printString
     Answer a String representing the receiver



File: gst-base.info,  Node: Object-relational operators,  Next: Object-saving and loading,  Prev: Object-printing,  Up: Object

Object: relational operators
----------------------------

~= anObject
     Answer whether the receiver and anObject are not equal

~~ anObject
     Answer whether the receiver and anObject are not the same object



File: gst-base.info,  Node: Object-saving and loading,  Next: Object-storing,  Prev: Object-relational operators,  Up: Object

Object: saving and loading
--------------------------

binaryRepresentationObject
     This method must be implemented if PluggableProxies are used with
     the receiver's class.  The default implementation raises an
     exception.

postLoad
     Called after loading an object; must restore it to the state before
     `preStore' was called.  Do nothing by default

postStore
     Called after an object is dumped; must restore it to the state
     before `preStore' was called.  Call #postLoad by default

preStore
     Called before dumping an object; it must *change* it (it must not
     answer a new object) if necessary.  Do nothing by default

reconstructOriginalObject
     Used if an instance of the receiver's class is returned as the
     #binaryRepresentationObject of another object.  The default
     implementation raises an exception.



File: gst-base.info,  Node: Object-storing,  Next: Object-syntax shortcuts,  Prev: Object-saving and loading,  Up: Object

Object: storing
---------------

store
     Put a String of Smalltalk code compiling to the receiver on the
     Transcript (stdout the GUI is not active)

storeNl
     Put a String of Smalltalk code compiling to the receiver, followed
     by a new line, on the Transcript (stdout the GUI is not active)

storeOn: aStream
     Put Smalltalk code compiling to the receiver on aStream

storeString
     Answer a String of Smalltalk code compiling to the receiver



File: gst-base.info,  Node: Object-syntax shortcuts,  Next: Object-testing functionality,  Prev: Object-storing,  Up: Object

Object: syntax shortcuts
------------------------

-> anObject
     Creates a new instance of Association with the receiver being the
     key and the argument becoming the value



File: gst-base.info,  Node: Object-testing functionality,  Prev: Object-syntax shortcuts,  Up: Object

Object: testing functionality
-----------------------------

ifNil: nilBlock
     Evaluate nilBlock if the receiver is nil, else answer self

ifNil: nilBlock ifNotNil: notNilBlock
     Evaluate nilBlock if the receiver is nil, else evaluate
     notNilBlock, passing the receiver.

ifNotNil: notNilBlock
     Evaluate notNiilBlock if the receiver is not nil, passing the
     receiver.  Else answer nil.

ifNotNil: notNilBlock ifNil: nilBlock
     Evaluate nilBlock if the receiver is nil, else evaluate
     notNilBlock, passing the receiver.

isArray
     Answer `false'.

isBehavior
     Answer `false'.

isCharacter
     Answer `false'.

isCharacterArray
     Answer `false'.

isClass
     Answer `false'.

isFloat
     Answer `false'.

isInteger
     Answer `false'.

isKindOf: aClass
     Answer whether the receiver's class is aClass or a subclass of
     aClass

isMemberOf: aClass
     Returns true if the receiver is an instance of the class 'aClass'

isMeta
     Same as isMetaclass

isMetaclass
     Answer `false'.

isMetaClass
     Same as isMetaclass

isNamespace
     Answer `false'.

isNil
     Answer whether the receiver is nil

isNumber
     Answer `false'.

isSmallInteger
     Answer `false'.

isString
     Answer `false'.

isSymbol
     Answer `false'.

notNil
     Answer whether the receiver is not nil

respondsTo: aSymbol
     Returns true if the receiver understands the given selector



File: gst-base.info,  Node: ObjectDumper,  Next: ObjectMemory,  Prev: Object,  Up: Base classes

ObjectDumper
============

Defined in namespace Smalltalk
Superclass: Stream
Category: Streams-Files
     I'm not part of a normal Smalltalk system, but most Smalltalks
     provide a similar feature: that is, support for storing objects in
     a binary format; there are many advantages in using me instead of
     #storeOn: and the Smalltalk compiler.

     The data is stored in a very compact format, which has the side
     effect of making loading much faster when compared with compiling
     the Smalltalk code prepared by #storeOn:.  In addition, my
     instances support circular references between objects, while
     #storeOn: supports it only if you know of such references at
     design time and you override #storeOn: to deal with them

* Menu:

* ObjectDumper class-establishing proxy classes::  (class)
* ObjectDumper class-instance creation::  (class)
* ObjectDumper class-shortcuts::  (class)
* ObjectDumper class-testing::  (class)
* ObjectDumper-accessing::  (instance)
* ObjectDumper-loading/dumping objects::  (instance)
* ObjectDumper-stream interface::  (instance)


File: gst-base.info,  Node: ObjectDumper class-establishing proxy classes,  Next: ObjectDumper class-instance creation,  Up: ObjectDumper

ObjectDumper class: establishing proxy classes
----------------------------------------------

disableProxyFor: aClass
     Disable proxies for instances of aClass and its descendants

hasProxyFor: aClass
     Answer whether a proxy class has been registered for instances of
     aClass.

proxyClassFor: anObject
     Answer the class of a valid proxy for an object, or nil if none
     could be found

proxyFor: anObject
     Answer a valid proxy for an object, or the object itself if none
     could be found

registerProxyClass: aProxyClass for: aClass
     Register the proxy class aProxyClass - descendent of DumperProxy -
     to be used for instances of aClass and its descendants



File: gst-base.info,  Node: ObjectDumper class-instance creation,  Next: ObjectDumper class-shortcuts,  Prev: ObjectDumper class-establishing proxy classes,  Up: ObjectDumper

ObjectDumper class: instance creation
-------------------------------------

new
     This method should not be called for instances of this class.

on: aFileStream
     Answer an ObjectDumper working on aFileStream.



File: gst-base.info,  Node: ObjectDumper class-shortcuts,  Next: ObjectDumper class-testing,  Prev: ObjectDumper class-instance creation,  Up: ObjectDumper

ObjectDumper class: shortcuts
-----------------------------

dump: anObject to: aFileStream
     Dump anObject to aFileStream. Answer anObject

loadFrom: aFileStream
     Load an object from aFileStream and answer it



File: gst-base.info,  Node: ObjectDumper class-testing,  Next: ObjectDumper-accessing,  Prev: ObjectDumper class-shortcuts,  Up: ObjectDumper

ObjectDumper class: testing
---------------------------

example
     This is a real torture test: it outputs recursive objects,
     identical objects multiple times, classes, metaclasses, integers,
     characters and proxies (which is also a test of more complex
     objects)!



File: gst-base.info,  Node: ObjectDumper-accessing,  Next: ObjectDumper-loading/dumping objects,  Prev: ObjectDumper class-testing,  Up: ObjectDumper

ObjectDumper: accessing
-----------------------

flush
     `Forget' any information on previously stored objects.

stream
     Answer the ByteStream to which the ObjectDumper will write and
     from which it will read.

stream: aByteStream
     Set the ByteStream to which the ObjectDumper will write and from
     which it will read.



File: gst-base.info,  Node: ObjectDumper-loading/dumping objects,  Next: ObjectDumper-stream interface,  Prev: ObjectDumper-accessing,  Up: ObjectDumper

ObjectDumper: loading/dumping objects
-------------------------------------

dump: anObject
     Dump anObject on the stream associated with the receiver. Answer
     anObject

load
     Load an object from the stream associated with the receiver and
     answer it



File: gst-base.info,  Node: ObjectDumper-stream interface,  Prev: ObjectDumper-loading/dumping objects,  Up: ObjectDumper

ObjectDumper: stream interface
------------------------------

atEnd
     Answer whether the underlying stream is at EOF

next
     Load an object from the underlying stream

nextPut: anObject
     Store an object on the underlying stream



File: gst-base.info,  Node: ObjectMemory,  Next: OrderedCollection,  Prev: ObjectDumper,  Up: Base classes

ObjectMemory
============

Defined in namespace Smalltalk
Superclass: Object
Category: Language-Implementation
     I provide a few methods that enable one to tune the virtual
     machine's usage of memory.  In addition, I can signal to my
     dependants some `events' that can happen during the virtual
     machine's life.

     ObjectMemory has both class-side and instance-side methods.  In
     general, class-side methods provide means to tune the parameters
     of the memory manager, while instance-side methods are used
     together with the #current class-side method to take a look at
     statistics on the memory manager's state.

* Menu:

* ObjectMemory class-accessing::  (class)
* ObjectMemory class-builtins::  (class)
* ObjectMemory class-dependancy::  (class)
* ObjectMemory class-initialization::  (class)
* ObjectMemory class-saving the image::  (class)
* ObjectMemory-accessing::  (instance)
* ObjectMemory-builtins::  (instance)
* ObjectMemory-derived information::  (instance)


File: gst-base.info,  Node: ObjectMemory class-accessing,  Next: ObjectMemory class-builtins,  Up: ObjectMemory

ObjectMemory class: accessing
-----------------------------

current
     Return a snapshot of the VM's memory management statistics.



File: gst-base.info,  Node: ObjectMemory class-builtins,  Next: ObjectMemory class-dependancy,  Prev: ObjectMemory class-accessing,  Up: ObjectMemory

ObjectMemory class: builtins
----------------------------

abort
     Quit the Smalltalk environment, dumping core.

addressOf: anObject
     Returns the address of the actual object that anObject references.
     Note that, with the exception of fixed objects this address is
     only valid until the next garbage collection; thus it's pretty
     risky to count on the address returned by this method for very
     long.

addressOfOOP: anObject
     Returns the address of the OOP (object table slot) for anObject.
     The address is an Integer and will not change over time (i.e. is
     immune from garbage collector action) except if the virtual machine
     is stopped and restarted.

bigObjectThreshold
     Answer the smallest size for objects that are allocated outside
     the main heap in the hope of providing more locality of reference
     between small objects.

bigObjectThreshold: bytes
     Set the smallest size for objects that are allocated outside the
     main heap in the hope of providing more locality of reference
     between small objects.  bytes must be a positive SmallInteger.

compact
     Force a full garbage collection, including compaction of oldspace

finishIncrementalGC
     Do a step in the incremental garbage collection.

gcMessage
     Answer whether messages indicating that garbage collection is
     taking place are printed on stdout

gcMessage: aBoolean
     Set whether messages indicating that garbage collection is taking
     place are printed on stdout

globalGarbageCollect
     Force a full garbage collection

growThresholdPercent
     Answer the percentage of the amount of memory used by the system
     grows which has to be full for the system to allocate more memory

growThresholdPercent: growPercent
     Set the percentage of the amount of memory used by the system grows
     which has to be full for the system to allocate more memory

growTo: numBytes
     Grow the amount of memory used by the system grows to numBytes.

incrementalGCStep
     Do a step in the incremental garbage collection.

quit
     Quit the Smalltalk environment. Whether files are closed and other
     similar cleanup occurs depends on the platform

quit: exitStatus
     Quit the Smalltalk environment, passing the exitStatus integer to
     the OS. Files are closed and other similar cleanups occur.

scavenge
     Force a minor garbage collection

smoothingFactor
     Answer the factor (between 0 and 1) used to smooth the statistics
     provided by the virtual machine about memory handling.  0 disables
     updating the averages, 1 disables the smoothing (the statistics
     return the last value).

smoothingFactor: rate
     Set the factor (between 0 and 1) used to smooth the statistics
     provided by the virtual machine about memory handling.  0 disables
     updating the averages, 1 disables the smoothing (the statistics
     return the last value).

snapshot: aString
     Save an image on the aString file

spaceGrowRate
     Answer the rate with which the amount of memory used by the system
     grows

spaceGrowRate: rate
     Set the rate with which the amount of memory used by the system
     grows



File: gst-base.info,  Node: ObjectMemory class-dependancy,  Next: ObjectMemory class-initialization,  Prev: ObjectMemory class-builtins,  Up: ObjectMemory

ObjectMemory class: dependancy
------------------------------

update: aspect
     Do any global tasks for the ObjectMemory events.



File: gst-base.info,  Node: ObjectMemory class-initialization,  Next: ObjectMemory class-saving the image,  Prev: ObjectMemory class-dependancy,  Up: ObjectMemory

ObjectMemory class: initialization
----------------------------------

initialize
     Initialize the globals



File: gst-base.info,  Node: ObjectMemory class-saving the image,  Next: ObjectMemory-accessing,  Prev: ObjectMemory class-initialization,  Up: ObjectMemory

ObjectMemory class: saving the image
------------------------------------

snapshot
     Save a snapshot on the image file that was loaded on startup.



File: gst-base.info,  Node: ObjectMemory-accessing,  Next: ObjectMemory-builtins,  Prev: ObjectMemory class-saving the image,  Up: ObjectMemory

ObjectMemory: accessing
-----------------------

allocFailures
     Answer the number of times that the old-space allocator found no
     block that was at least as big as requested, and had to ask the
     operating system for more memory.

allocMatches
     Answer the number of times that the old-space allocator found a
     block that was exactly as big as requested.

allocProbes
     Answer the number of free blocks that the old-space allocator had
     to examine so far to allocate all the objects that are in old-space

allocSplits
     Answer the number of times that the old-space allocator could not
     find a block that was exactly as big as requested, and had to split
     a larger free block in two parts.

bytesPerOOP
     Answer the number of bytes that is taken by an ordinary object
     pointer (in practice, a field such as a named instance variable).

bytesPerOTE
     Answer the number of bytes that is taken by an object table entry
     (in practice, the overhead incurred by every object in the system,
     with the sole exception of SmallIntegers).

edenSize
     Answer the number of bytes in the `eden' area of the young
     generation (in practice, the number of allocated bytes between two
     scavenges).

edenUsedBytes
     Answer the number of bytes that are currently filled in the `eden'
     area of the young generation.

fixedSpaceSize
     Answer the number of bytes in the special heap devoted to objects
     that the garbage collector cannot move around in memory.

fixedSpaceUsedBytes
     Answer the number of bytes that are currently filled in the
     special heap devoted to objects that the garbage collector cannot
     move around in memory.

numCompactions
     Answer the number of oldspace compactions that happened since the
     VM was started.

numFixedOOPs
     Answer the number of objects that the garbage collector cannot
     move around in memory.

numFreeOTEs
     Answer the number of entries that are currently free in the object
     table.

numGlobalGCs
     Answer the number of global garbage collections (collection of the
     entire heap) that happened since the VM was started.

numGrowths
     Answer the number of times that oldspace was grown since the VM
     was started.

numOldOOPs
     Answer the number of objects that reside in the old generation.

numOTEs
     Answer the number of entries that are currently allocated for the
     object table.

numScavenges
     Answer the number of scavenges (fast collections of the young
     generation) that happened since the VM was started.

numWeakOOPs
     Answer the number of weak objects that the garbage collector is
     currently tracking.

oldSpaceSize
     Answer the number of bytes in the old generation.

oldSpaceUsedBytes
     Answer the number of bytes that are currently filled in the old
     generation.

reclaimedBytesPerGlobalGC
     Answer the average number of bytes that are found to be garbage
     during a global garbage collections.

reclaimedBytesPerScavenge
     Answer the average number of bytes that are found to be garbage
     during a scavenge.

reclaimedPercentPerScavenge
     Answer the average percentage of allocated bytes that are found to
     be garbage during a scavenge.  If this number falls below 60-70
     you should definitely increment the size of the eden, because you
     risk that scavenging is eating a considerable fraction of your
     execution time; do the measurement on a restarted image, so that
     the extra tenuring incurred when creating long-lived objects such
     as classes or methods is not considered.

survSpaceSize
     Answer the number of bytes in the `survivor' area of the young
     generation (the area to which young objects are relocated during
     scavenges).

survSpaceUsedBytes
     Answer the number of bytes that are currently filled in the
     `survivor' area of the young generation.

tenuredBytesPerScavenge
     Answer the average number of bytes that are promoted to oldspace
     during a scavenge.

timeBetweenGlobalGCs
     Answer the average number of milliseconds between two global
     garbage collections.

timeBetweenGrowths
     Answer the average number of milliseconds between decisions to
     grow the heap.

timeBetweenScavenges
     Answer the average number of milliseconds between two scavenges
     (fast collections of the young generation).

timeToCollect
     Answer the average number of milliseconds that a global garbage
     collection takes.

timeToCompact
     Answer the average number of milliseconds that compacting the heap
     takes.  This the same time that is taken by growing the heap.

timeToScavenge
     Answer the average number of milliseconds that a scavenge takes
     (fast collections of the young generation).



File: gst-base.info,  Node: ObjectMemory-builtins,  Next: ObjectMemory-derived information,  Prev: ObjectMemory-accessing,  Up: ObjectMemory

ObjectMemory: builtins
----------------------

update
     Update the values in the object to the current state of the VM.



File: gst-base.info,  Node: ObjectMemory-derived information,  Prev: ObjectMemory-builtins,  Up: ObjectMemory

ObjectMemory: derived information
---------------------------------

scavengesBeforeTenuring
     Answer the number of scavenges that an object must on average
     survive before being promoted to oldspace; this is however only an
     estimate because objects that are reachable from oldspace have a
     higher probability to be tenured soon, while objects that are only
     reachable from thisContext have a lower probability to be tenured.
     Anyway, if this number falls below 2-3 you should definitely
     increment the size of eden and/or of survivor space, because you
     are tenuring too often and relying too much on global garbage
     collection to keep your heap clean; do the measurement on a
     restarted image, so that the extra tenuring incurred when creating
     long-lived objects such as classes or methods is not considered.



File: gst-base.info,  Node: OrderedCollection,  Next: Package,  Prev: ObjectMemory,  Up: Base classes

OrderedCollection
=================

Defined in namespace Smalltalk
Superclass: SequenceableCollection
Category: Collections-Sequenceable
     My instances represent ordered collections of arbitrary typed
     objects which are not directly accessible by an index.  They can
     be accessed indirectly through an index, and can be manipulated by
     adding to the end or based on content (such as add:after:)

* Menu:

* OrderedCollection class-instance creation::  (class)
* OrderedCollection-accessing::  (instance)
* OrderedCollection-adding::  (instance)
* OrderedCollection-removing::  (instance)


File: gst-base.info,  Node: OrderedCollection class-instance creation,  Next: OrderedCollection-accessing,  Up: OrderedCollection

OrderedCollection class: instance creation
------------------------------------------

new
     Answer an OrderedCollection of default size

new: anInteger
     Answer an OrderedCollection of size anInteger



File: gst-base.info,  Node: OrderedCollection-accessing,  Next: OrderedCollection-adding,  Prev: OrderedCollection class-instance creation,  Up: OrderedCollection

OrderedCollection: accessing
----------------------------

at: anIndex
     Answer the anIndex-th item of the receiver

at: anIndex put: anObject
     Store anObject at the anIndex-th item of the receiver, answer
     anObject

size
     Return the number of objects in the receiver



File: gst-base.info,  Node: OrderedCollection-adding,  Next: OrderedCollection-removing,  Prev: OrderedCollection-accessing,  Up: OrderedCollection

OrderedCollection: adding
-------------------------

add: anObject
     Add anObject in the receiver, answer it

add: newObject after: oldObject
     Add newObject in the receiver just after oldObject, answer it.
     Fail if oldObject can't be found

add: newObject afterIndex: i
     Add newObject in the receiver just after the i-th, answer it.
     Fail if i < 0 or i > self size

add: newObject before: oldObject
     Add newObject in the receiver just before oldObject, answer it.
     Fail if oldObject can't be found

add: newObject beforeIndex: i
     Add newObject in the receiver just before the i-th, answer it.
     Fail if i < 1 or i > self size + 1

addAll: aCollection
     Add every item of aCollection to the receiver, answer it

addAll: newCollection after: oldObject
     Add every item of newCollection to the receiver just after
     oldObject, answer it. Fail if oldObject is not found

addAll: newCollection afterIndex: i
     Add every item of newCollection to the receiver just after the
     i-th, answer it. Fail if i < 0 or i > self size

addAll: newCollection before: oldObject
     Add every item of newCollection to the receiver just before
     oldObject, answer it. Fail if oldObject is not found

addAll: newCollection beforeIndex: i
     Add every item of newCollection to the receiver just before the
     i-th, answer it. Fail if i < 1 or i > self size + 1

addAllFirst: aCollection
     Add every item of newCollection to the receiver right at the start
     of the receiver. Answer aCollection

addAllLast: aCollection
     Add every item of newCollection to the receiver right at the end
     of the receiver. Answer aCollection

addFirst: newObject
     Add newObject to the receiver right at the start of the receiver.
     Answer newObject

addLast: newObject
     Add newObject to the receiver right at the end of the receiver.
     Answer newObject



File: gst-base.info,  Node: OrderedCollection-removing,  Prev: OrderedCollection-adding,  Up: OrderedCollection

OrderedCollection: removing
---------------------------

remove: anObject ifAbsent: aBlock
     Remove anObject from the receiver. If it can't be found, answer the
     result of evaluating aBlock

removeAtIndex: anIndex
     Remove the object at index anIndex from the receiver. Fail if the
     index is out of bounds

removeFirst
     Remove an object from the start of the receiver. Fail if the
     receiver is empty

removeLast
     Remove an object from the end of the receiver. Fail if the receiver
     is empty



File: gst-base.info,  Node: Package,  Next: PackageLoader,  Prev: OrderedCollection,  Up: Base classes

Package
=======

Defined in namespace Smalltalk
Superclass: Object
Category: Language-Packaging
     I am not part of a standard Smalltalk system. I store internally
     the information on a Smalltalk package, and can output my
     description in XML.

* Menu:

* Package-accessing::  (instance)


File: gst-base.info,  Node: Package-accessing,  Up: Package

Package: accessing
------------------

builtFiles
     Answer a (modifiable) Set of files that are part of the package
     but are not distributed.

callouts
     Answer a (modifiable) Set of call-outs that are required to load
     the package.  Their presence is checked after the libraries and
     modules are loaded so that you can do a kind of versioning.

directory
     Answer the base directory from which to load the package.

directory: dir forBaseDir: baseDir
     Set the base directory from which to load the package to dir.  If
     dir is a relative directory, store an absolute path composed from
     the (already absolute) baseDir and from dir.

fileIns
     Answer a (modifiable) OrderedCollections of files that are to be
     filed-in to load the package.  This is usually a subset of `files'
     and `builtFiles'.

files
     Answer a (modifiable) Set of files that are part of the package.

libraries
     Answer a (modifiable) Set of shared library names that are
     required to load the package.

modules
     Answer a (modifiable) Set of modules that are required to load the
     package.

name
     Answer the name of the package.

name: aString
     Set to aString the name of the package.

prerequisites
     Answer a (modifiable) Set of prerequisites.

printOn: aStream
     Print a representation of the receiver on aStream (it happens to
     be XML.

printXmlOn: aStream collection: aCollection tag: aString
     Private - Print aCollection on aStream as a sequence of aString
     tags.



File: gst-base.info,  Node: PackageLoader,  Next: PluggableAdaptor,  Prev: Package,  Up: Base classes

PackageLoader
=============

Defined in namespace Smalltalk
Superclass: Object
Category: Language-Packaging
     I am not part of a standard Smalltalk system. I provide methods for
     retrieving package information from an XML file and to load
     packages into a Smalltalk image, correctly handling dependencies.

* Menu:

* PackageLoader class-accessing::  (class)
* PackageLoader class-loading::  (class)
* PackageLoader class-testing::  (class)


File: gst-base.info,  Node: PackageLoader class-accessing,  Next: PackageLoader class-loading,  Up: PackageLoader

PackageLoader class: accessing
------------------------------

builtFilesFor: package
     Answer a Set of Strings containing the filenames of the given
     package's machine-generated files (relative to the directory
     answered by #directoryFor:)

calloutsFor: package
     Answer a Set of Strings containing the filenames of the given
     package's required callouts (relative to the directory answered by
     #directoryFor:)

directoryFor: package
     Answer a complete path to the given package's files

fileInsFor: package
     Answer a Set of Strings containing the filenames of the given
     package's file-ins (relative to the directory answered by
     #directoryFor:)

filesFor: package
     Answer a Set of Strings containing the filenames of the given
     package's files (relative to the directory answered by
     #directoryFor:)

flush
     Set to reload the `packages.xml' file the next time it is needed.

ignoreCallouts
     Answer whether unavailable C callouts must generate errors or not.

ignoreCallouts: aBoolean
     Set whether unavailable C callouts must generate errors or not.

librariesFor: package
     Answer a Set of Strings containing the filenames of the given
     package's libraries (relative to the directory answered by
     #directoryFor:)

modulesFor: package
     Answer a Set of Strings containing the filenames of the given
     package's modules (relative to the directory answered by
     #directoryFor:)

prerequisitesFor: package
     Answer a Set of Strings containing the prerequisites for the given
     package

refreshDependencies
     Reload the `packages.xml' file in the image and kernel directories



File: gst-base.info,  Node: PackageLoader class-loading,  Next: PackageLoader class-testing,  Prev: PackageLoader class-accessing,  Up: PackageLoader

PackageLoader class: loading
----------------------------

extractDependenciesFor: packagesList onError: aBlock
     Answer an OrderedCollection containing all the packages which you
     have to load to enable the packages in packagesList, in an
     appropriate order. For example PackageLoader
     extractDependenciesFor: #('BloxTestSuite' 'Blox' 'Browser') on a
     newly built image will evaluate to an OrderedCollection containing
     'Kernel', 'Blox', 'BloxTestSuite' and 'Browser'. Note that Blox
     has been moved before BloxTestSuite.  Pass an error message to
     aBlock if any of the packages needs prerequisites which are not
     defined.

fileInPackage: package
     File in the given package into GNU Smalltalk.

fileInPackages: packagesList
     File in all the packages in packagesList into GNU Smalltalk.



File: gst-base.info,  Node: PackageLoader class-testing,  Prev: PackageLoader class-loading,  Up: PackageLoader

PackageLoader class: testing
----------------------------

canLoad: package
     Answer whether all the needed pre-requisites for package are
     available.



File: gst-base.info,  Node: PluggableAdaptor,  Next: PluggableProxy,  Prev: PackageLoader,  Up: Base classes

PluggableAdaptor
================

Defined in namespace Smalltalk
Superclass: ValueAdaptor
Category: Language-Data types
     I mediate between complex get/set behavior and the #value/#value:
     protocol used by ValueAdaptors. The get/set behavior can be
     implemented by two blocks, or can be delegated to another object
     with messages such as #someProperty to get and #someProperty: to
     set.

* Menu:

* PluggableAdaptor class-creating instances::  (class)
* PluggableAdaptor-accessing::  (instance)


File: gst-base.info,  Node: PluggableAdaptor class-creating instances,  Next: PluggableAdaptor-accessing,  Up: PluggableAdaptor

PluggableAdaptor class: creating instances
------------------------------------------

getBlock: getBlock putBlock: putBlock
     Answer a PluggableAdaptor using the given blocks to implement
     #value and #value:

on: anObject aspect: aSymbol
     Answer a PluggableAdaptor using anObject's aSymbol message to
     implement #value, and anObject's aSymbol: message (aSymbol
     followed by a colon) to implement #value:

on: anObject getSelector: getSelector putSelector: putSelector
     Answer a PluggableAdaptor using anObject's getSelector message to
     implement #value, and anObject's putSelector message to implement
     #value:

     message

on: anObject index: anIndex
     Answer a PluggableAdaptor using anObject's #at: and #at:put:
     message to implement #value and #value:; the first parameter of
     #at: and #at:put: is anIndex

on: aDictionary key: aKey
     Same as #on:index:. Provided for clarity and completeness.



File: gst-base.info,  Node: PluggableAdaptor-accessing,  Prev: PluggableAdaptor class-creating instances,  Up: PluggableAdaptor

PluggableAdaptor: accessing
---------------------------

value
     Get the value of the receiver.

value: anObject
     Set the value of the receiver.



File: gst-base.info,  Node: PluggableProxy,  Next: Point,  Prev: PluggableAdaptor,  Up: Base classes

PluggableProxy
==============

Defined in namespace Smalltalk
Superclass: AlternativeObjectProxy
Category: Streams-Files
     I am a proxy that stores a different object and, upon load, sends
     #reconstructOriginalObject to that object (which can be a
     DirectedMessage, in which case the message is sent).  The object
     to be stored is retrieved by sending #binaryRepresentationObject to
     the object.

* Menu:

* PluggableProxy class-accessing::  (class)
* PluggableProxy-saving and restoring::  (instance)


File: gst-base.info,  Node: PluggableProxy class-accessing,  Next: PluggableProxy-saving and restoring,  Up: PluggableProxy

PluggableProxy class: accessing
-------------------------------

on: anObject
     Answer a proxy to be used to save anObject.  The proxy stores a
     different object obtained by sending to anObject the
     #binaryRepresentationObject message (embedded between #preStore
     and #postStore as usual).



File: gst-base.info,  Node: PluggableProxy-saving and restoring,  Prev: PluggableProxy class-accessing,  Up: PluggableProxy

PluggableProxy: saving and restoring
------------------------------------

object
     Reconstruct the object stored in the proxy and answer it; the
     binaryRepresentationObject is sent the #reconstructOriginalObject
     message, and the resulting object is sent the #postLoad message.



File: gst-base.info,  Node: Point,  Next: PositionableStream,  Prev: PluggableProxy,  Up: Base classes

Point
=====

Defined in namespace Smalltalk
Superclass: Object
Category: Language-Data types
     Beginning of a Point class for simple display manipulation.  Has
     not been  exhaustively tested but appears to work for the basic
     primitives and for  the needs of the Rectangle class.

* Menu:

* Point class-instance creation::  (class)
* Point-accessing::  (instance)
* Point-arithmetic::  (instance)
* Point-comparing::  (instance)
* Point-converting::  (instance)
* Point-point functions::  (instance)
* Point-printing::  (instance)
* Point-storing::  (instance)
* Point-truncation and round off::  (instance)


File: gst-base.info,  Node: Point class-instance creation,  Next: Point-accessing,  Up: Point

Point class: instance creation
------------------------------

new
     Create a new point with both coordinates set to 0

x: xInteger y: yInteger
     Create a new point with the given coordinates



File: gst-base.info,  Node: Point-accessing,  Next: Point-arithmetic,  Prev: Point class-instance creation,  Up: Point

Point: accessing
----------------

x
     Answer the x coordinate

x: aNumber
     Set the x coordinate to aNumber

x: anXNumber y: aYNumber
     Set the x and y coordinate to anXNumber and aYNumber, respectively

y
     Answer the y coordinate

y: aNumber
     Set the y coordinate to aNumber



File: gst-base.info,  Node: Point-arithmetic,  Next: Point-comparing,  Prev: Point-accessing,  Up: Point

Point: arithmetic
-----------------

* scale
     Multiply the receiver by scale, which can be a Number or a Point

+ delta
     Sum the receiver and delta, which can be a Number or a Point

- delta
     Subtract delta, which can be a Number or a Point, from the receiver

/ scale
     Divide the receiver by scale, which can be a Number or a Point,
     with no loss of precision

// scale
     Divide the receiver by scale, which can be a Number or a Point,
     with truncation towards -infinity

abs
     Answer a new point whose coordinates are the absolute values of the
     receiver's



File: gst-base.info,  Node: Point-comparing,  Next: Point-converting,  Prev: Point-arithmetic,  Up: Point

Point: comparing
----------------

< aPoint
     Answer whether the receiver is higher and to the left of aPoint

<= aPoint
     Answer whether aPoint is equal to the receiver, or the receiver is
     higher and to the left of aPoint

= aPoint
     Answer whether the receiver is equal to aPoint

> aPoint
     Answer whether the receiver is lower and to the right of aPoint

>= aPoint
     Answer whether aPoint is equal to the receiver, or the receiver is
     lower and to the right of aPoint

max: aPoint
     Answer self if it is lower and to the right of aPoint, aPoint
     otherwise

min: aPoint
     Answer self if it is higher and to the left of aPoint, aPoint
     otherwise



File: gst-base.info,  Node: Point-converting,  Next: Point-point functions,  Prev: Point-comparing,  Up: Point

Point: converting
-----------------

asPoint
     Answer the receiver.

asRectangle
     Answer an empty rectangle whose origin is self

corner: aPoint
     Answer a Rectangle whose origin is the receiver and whose corner
     is aPoint

extent: aPoint
     Answer a Rectangle whose origin is the receiver and whose extent
     is aPoint

hash
     Answer an hash value for the receiver



File: gst-base.info,  Node: Point-point functions,  Next: Point-printing,  Prev: Point-converting,  Up: Point

Point: point functions
----------------------

arcTan
     Answer the angle (measured counterclockwise) between the receiver
     and a ray starting in (0, 0) and moving towards (1, 0) - i.e. 3
     o'clock

dist: aPoint
     Answer the distance between the receiver and aPoint

dotProduct: aPoint
     Answer the dot product between the receiver and aPoint

grid: aPoint
     Answer a new point whose coordinates are rounded towards the
     nearest multiple of aPoint

normal
     Rotate the Point 90degrees clockwise and get the unit vector

transpose
     Answer a new point whose coordinates are the receiver's coordinates
     exchanged (x becomes y, y becomes x)

truncatedGrid: aPoint
     Answer a new point whose coordinates are rounded towards -infinity,
     to a multiple of grid (which must be a Point)



File: gst-base.info,  Node: Point-printing,  Next: Point-storing,  Prev: Point-point functions,  Up: Point

Point: printing
---------------

printOn: aStream
     Print a representation for the receiver on aStream



File: gst-base.info,  Node: Point-storing,  Next: Point-truncation and round off,  Prev: Point-printing,  Up: Point

Point: storing
--------------

storeOn: aStream
     Print Smalltalk code compiling to the receiver on aStream



File: gst-base.info,  Node: Point-truncation and round off,  Prev: Point-storing,  Up: Point

Point: truncation and round off
-------------------------------

rounded
     Answer a new point whose coordinates are rounded to the nearest
     integer

truncateTo: grid
     Answer a new point whose coordinates are rounded towards -infinity,
     to a multiple of grid (which must be a Number)



File: gst-base.info,  Node: PositionableStream,  Next: Process,  Prev: Point,  Up: Base classes

PositionableStream
==================

Defined in namespace Smalltalk
Superclass: Stream
Category: Streams-Collections
     My instances represent streams where explicit positioning is
     permitted.  Thus, my streams act in a manner to normal disk files:
     you can read or write sequentially, but also position the file to
     a particular place whenever you choose.  Generally, you'll want to
     use ReadStream, WriteStream or ReadWriteStream instead of me to
     create and use streams.

* Menu:

* PositionableStream class-instance creation::  (class)
* PositionableStream-accessing-reading::  (instance)
* PositionableStream-class type methods::  (instance)
* PositionableStream-positioning::  (instance)
* PositionableStream-testing::  (instance)
* PositionableStream-truncating::  (instance)


File: gst-base.info,  Node: PositionableStream class-instance creation,  Next: PositionableStream-accessing-reading,  Up: PositionableStream

PositionableStream class: instance creation
-------------------------------------------

on: aCollection
     Answer an instance of the receiver streaming on the whole contents
     of aCollection

on: aCollection from: firstIndex to: lastIndex
     Answer an instance of the receiver streaming from the
     firstIndex-th item of aCollection to the lastIndex-th



File: gst-base.info,  Node: PositionableStream-accessing-reading,  Next: PositionableStream-class type methods,  Prev: PositionableStream class-instance creation,  Up: PositionableStream

PositionableStream: accessing-reading
-------------------------------------

close
     Disassociate a stream from its backing store.

contents
     Returns a collection of the same type that the stream accesses, up
     to and including the final element.

copyFrom: start to: end
     Answer the collection on which the receiver is streaming, from the
     start-th item to the end-th

next
     Answer the next item of the receiver.  Returns nil when at end of
     stream.

peek
     Returns the next element of the stream without moving the pointer.
     Returns nil when at end of stream.

peekFor: anObject
     Returns true and gobbles the next element from the stream of it is
     equal to anObject, returns false and doesn't gobble the next
     element if the next element is not equal to anObject.

reverseContents
     Returns a collection of the same type that the stream accesses, up
     to and including the final element, but in reverse order.



File: gst-base.info,  Node: PositionableStream-class type methods,  Next: PositionableStream-positioning,  Prev: PositionableStream-accessing-reading,  Up: PositionableStream

PositionableStream: class type methods
--------------------------------------

isExternalStream
     We stream on a collection residing in the image, so answer false

species
     The collections returned by #upTo: etc. are the same kind as those
     returned by the collection with methods such as #select:



File: gst-base.info,  Node: PositionableStream-positioning,  Next: PositionableStream-testing,  Prev: PositionableStream-class type methods,  Up: PositionableStream

PositionableStream: positioning
-------------------------------

basicPosition: anInteger
     Move the stream pointer to the anInteger-th object

position
     Answer the current value of the stream pointer

position: anInteger
     Move the stream pointer to the anInteger-th object

reset
     Move the stream back to its first element. For write-only streams,
     the stream is truncated there.

setToEnd
     Move the current position to the end of the stream.

size
     Answer the size of data on which we are streaming.

skip: anInteger
     Move the current position by anInteger places, either forwards or
     backwards.

skipSeparators
     Advance the receiver until we find a character that is not a
     separator.  Answer false if we reach the end of the stream, else
     answer true; in this case, sending #next will return the first
     non-separator character (possibly the same to which the stream
     pointed before #skipSeparators was sent).



File: gst-base.info,  Node: PositionableStream-testing,  Next: PositionableStream-truncating,  Prev: PositionableStream-positioning,  Up: PositionableStream

PositionableStream: testing
---------------------------

atEnd
     Answer whether the objects in the stream have reached an end

basicAtEnd
     Answer whether the objects in the stream have reached an end.
     This method must NOT be overridden.

isEmpty
     Answer whether the stream has no objects



File: gst-base.info,  Node: PositionableStream-truncating,  Prev: PositionableStream-testing,  Up: PositionableStream

PositionableStream: truncating
------------------------------

truncate
     Truncate the receiver to the current position - only valid for
     writing streams



File: gst-base.info,  Node: Process,  Next: ProcessorScheduler,  Prev: PositionableStream,  Up: Base classes

Process
=======

Defined in namespace Smalltalk
Superclass: Link
Category: Language-Processes
     I represent a unit of computation.  My instances are independantly
     executable blocks that have a priority associated with them, and
     they can suspend themselves and resume themselves however they
     wish.

* Menu:

* Process-accessing::  (instance)
* Process-basic::  (instance)
* Process-builtins::  (instance)
* Process-printing::  (instance)


File: gst-base.info,  Node: Process-accessing,  Next: Process-basic,  Up: Process

Process: accessing
------------------

externalInterruptsEnabled
     Answer whether the receiver is executed with interrupts enabled

name
     Answer the user-friendly name of the process.

name: aString
     Give the name aString to the process

priority
     Answer the receiver's priority

priority: anInteger
     Change the receiver's priority to anInteger

queueInterrupt: aBlock
     Force the receiver to be interrupted and to evaluate aBlock as
     soon as it becomes the active process (this could mean NOW if the
     receiver is active).  If the process is temporarily suspended or
     waiting on a semaphore, it is temporarily woken up so that the
     interrupt is processed as soon as the process priority allows to
     do.  Answer the receiver.

setPriorityFrom: activePriority to: anInteger suspend: aBoolean
     Change the priority to anInteger.  If aBoolean is true, suspend
     the process after having done so; if it is false, check if it is
     nicer to relinquish control from the running process (based on the
     priority of the active process, that is passed in activePriority)
     and if this is the case, preempt it.

suspendedContext
     Answer the context that the process was executing at the time it
     was suspended.

valueWithoutInterrupts: aBlock
     Evaluate aBlock and delay all interrupts that are requested during
     its execution to after aBlock returns.



File: gst-base.info,  Node: Process-basic,  Next: Process-builtins,  Prev: Process-accessing,  Up: Process

Process: basic
--------------

lowerPriority
     Lower a bit the priority of the receiver. A #lowerPriority will
     cancel a previous #raisePriority, and vice versa.

primTerminate
     Terminate the receiver - This is nothing more than prohibiting to
     resume the process, then suspending it.

raisePriority
     Raise a bit the priority of the receiver. A #lowerPriority will
     cancel a previous #raisePriority, and vice versa.

singleStep
     Execute a limited amount of code (usually a bytecode, or up to the
     next backward jump, or up to the next message send) of the
     receiver, which must in a ready-to-run state (neither executing
     nor terminating nor suspended), then restart running the current
     process.  The current process should have higher priority than the
     receiver.  For better performance, use the underlying primitive,
     Process>>#singleStepWaitingOn:.

suspend
     Do nothing if we're already suspended. Note that the blue book made
     suspend a primitive - but the real primitive is yielding control to
     another process. Suspending is nothing more than taking ourselves
     out of every scheduling list and THEN yielding control to another
     process

terminate
     Terminate the receiver after having evaluated all the #ensure: and
     #ifCurtailed: blocks that are active in it.  This is done by
     signalling a ProcessBeingTerminated notification.



File: gst-base.info,  Node: Process-builtins,  Next: Process-printing,  Prev: Process-basic,  Up: Process

Process: builtins
-----------------

resume
     Resume the receiver's execution

singleStepWaitingOn: aSemaphore
     Execute a limited amount of code (usually a bytecode, or up to the
     next backward jump, or up to the next message send) of the
     receiver, which must in a ready-to-run state (neither executing
     nor terminating nor suspended), then restart running the current
     process.  aSemaphore is used as a means to synchronize the
     execution of the current process and the receiver and should have
     no signals on it.  The current process should have higher priority
     than the receiver.

yield
     Yield control from the receiver to other processes



File: gst-base.info,  Node: Process-printing,  Prev: Process-builtins,  Up: Process

Process: printing
-----------------

printOn: aStream
     Print a representation of the receiver on aStream



File: gst-base.info,  Node: ProcessorScheduler,  Next: Promise,  Prev: Process,  Up: Base classes

ProcessorScheduler
==================

Defined in namespace Smalltalk
Superclass: Object
Category: Language-Processes
     I provide methods that control the execution of processes.

* Menu:

* ProcessorScheduler class-instance creation::  (class)
* ProcessorScheduler-basic::  (instance)
* ProcessorScheduler-built ins::  (instance)
* ProcessorScheduler-idle tasks::  (instance)
* ProcessorScheduler-printing::  (instance)
* ProcessorScheduler-priorities::  (instance)
* ProcessorScheduler-storing::  (instance)
* ProcessorScheduler-timed invocation::  (instance)


File: gst-base.info,  Node: ProcessorScheduler class-instance creation,  Next: ProcessorScheduler-basic,  Up: ProcessorScheduler

ProcessorScheduler class: instance creation
-------------------------------------------

new
     Error--new instances of ProcessorScheduler should not be created.



File: gst-base.info,  Node: ProcessorScheduler-basic,  Next: ProcessorScheduler-built ins,  Prev: ProcessorScheduler class-instance creation,  Up: ProcessorScheduler

ProcessorScheduler: basic
-------------------------

activePriority
     Answer the active process' priority

activeProcess
     Answer the active process

changePriorityListOf: aProcess to: aPriority suspend: aBoolean
     Private - Move aProcess to the execution list for aPriority,
     answer the new execution list

processesAt: aPriority
     Answer a linked list of processes at the given priority

terminateActive
     Terminate the active process

timeSlice
     Answer the timeslice that is assigned to each Process before it is
     automatically preempted by the system (in milliseconds).  An
     answer of zero means that preemptive multitasking is disabled.
     Note that the system by default is compiled without preemptive
     multitasking, and that even if it is enabled it will work only
     under BSD derivatives (or, in general, systems that support
     ITIMER_VIRTUAL).

timeSlice: milliSeconds
     Set the timeslice that is assigned to each Process before it is
     automatically preempted by the system.  Setting this to zero
     disables preemptive multitasking.  Note that the system by default
     is compiled with preemptive multitasking disabled, and that even
     if it is enabled it will surely work only under BSD derivatives
     (or, in general, systems that support ITIMER_VIRTUAL).

yield
     Let the active process yield control to other processes



File: gst-base.info,  Node: ProcessorScheduler-built ins,  Next: ProcessorScheduler-idle tasks,  Prev: ProcessorScheduler-basic,  Up: ProcessorScheduler

ProcessorScheduler: built ins
-----------------------------

     twice

disableInterrupts
     Disable interrupts caused by external events while the current
     process is executing.  Note that interrupts are disabled on a
     per-process basis, and that calling #disableInterrupts twice
     requires calling #enableInterrupts twice as well to re-enable
     interrupts.

enableInterrupts
     Re-enable interrupts caused by external events while the current
     process is executing.  By default, interrupts are enabled.



File: gst-base.info,  Node: ProcessorScheduler-idle tasks,  Next: ProcessorScheduler-printing,  Prev: ProcessorScheduler-built ins,  Up: ProcessorScheduler

ProcessorScheduler: idle tasks
------------------------------

idle
     Private - Call the next idle task

idleAdd: aBlock
     Register aBlock to be executed when things are idle



File: gst-base.info,  Node: ProcessorScheduler-printing,  Next: ProcessorScheduler-priorities,  Prev: ProcessorScheduler-idle tasks,  Up: ProcessorScheduler

ProcessorScheduler: printing
----------------------------

printOn: aStream
     Store onto aStream a printed representation of the receiver



File: gst-base.info,  Node: ProcessorScheduler-priorities,  Next: ProcessorScheduler-storing,  Prev: ProcessorScheduler-printing,  Up: ProcessorScheduler

ProcessorScheduler: priorities
------------------------------

highestPriority
     Answer the highest valid priority

highIOPriority
     Answer the priority for system high-priority I/O processes, such
     as a process handling input from a network.

lowestPriority
     Answer the lowest valid priority

lowIOPriority
     Answer the priority for system low-priority I/O processes.
     Examples are the process handling input from the user (keyboard,
     pointing device, etc.) and the process distributing input from a
     network.

priorityName: priority
     Private - Answer a name for the given process priority

rockBottomPriority
     Answer the lowest valid priority

systemBackgroundPriority
     Answer the priority for system background-priority processes.
     Examples are an incremental garbage collector or status checker.

timingPriority
     Answer the priority for system real-time processes.

unpreemptedPriority
     Answer the highest priority avilable in the system; never create a
     process with this priority, instead use
     BlockClosure>>#valueWithoutPreemption.

userBackgroundPriority
     Answer the priority for user background-priority processes

userInterruptPriority
     Answer the priority for user interrupt-priority processes.
     Processes run at this level will preempt the window scheduler and
     should, therefore, not consume the processor forever.

userSchedulingPriority
     Answer the priority for user standard-priority processes



File: gst-base.info,  Node: ProcessorScheduler-storing,  Next: ProcessorScheduler-timed invocation,  Prev: ProcessorScheduler-priorities,  Up: ProcessorScheduler

ProcessorScheduler: storing
---------------------------

storeOn: aStream
     Store onto aStream a Smalltalk expression which evaluates to the
     receiver



File: gst-base.info,  Node: ProcessorScheduler-timed invocation,  Prev: ProcessorScheduler-storing,  Up: ProcessorScheduler

ProcessorScheduler: timed invocation
------------------------------------

isTimeoutProgrammed
     Private - Answer whether there is a pending call to
     #signal:atMilliseconds:

signal: aSemaphore atMilliseconds: millis
     Private - signal 'aSemaphore' after 'millis' milliseconds have
     elapsed

signal: aSemaphore onInterrupt: anIntegerSignalNumber
     Private - signal 'aSemaphore' when the given C signal occurs



File: gst-base.info,  Node: Promise,  Next: Random,  Prev: ProcessorScheduler,  Up: Base classes

Promise
=======

Defined in namespace Smalltalk
Superclass: ValueHolder
Category: Language-Data types
     I store my value in a variable, and know whether I have been
     initialized or not.  If you ask for my value and I have not been
     initialized, I suspend the process until a value has been assigned.

* Menu:

* Promise class-creating instances::  (class)
* Promise-accessing::  (instance)
* Promise-initializing::  (instance)
* Promise-printing::  (instance)


File: gst-base.info,  Node: Promise class-creating instances,  Next: Promise-accessing,  Up: Promise

Promise class: creating instances
---------------------------------

null
     This method should not be called for instances of this class.



File: gst-base.info,  Node: Promise-accessing,  Next: Promise-initializing,  Prev: Promise class-creating instances,  Up: Promise

Promise: accessing
------------------

hasValue
     Answer whether we already have a value.

value
     Get the value of the receiver.

value: anObject
     Set the value of the receiver.



File: gst-base.info,  Node: Promise-initializing,  Next: Promise-printing,  Prev: Promise-accessing,  Up: Promise

Promise: initializing
---------------------

initialize
     Private - set the initial state of the receiver



File: gst-base.info,  Node: Promise-printing,  Prev: Promise-initializing,  Up: Promise

Promise: printing
-----------------

printOn: aStream
     Print a representation of the receiver



File: gst-base.info,  Node: Random,  Next: ReadStream,  Prev: Promise,  Up: Base classes

Random
======

Defined in namespace Smalltalk
Superclass: Stream
Category: Streams
     My instances are generator streams that produce random numbers,
     which are floating point values between 0 and 1.

* Menu:

* Random class-instance creation::  (class)
* Random class-shortcuts::  (class)
* Random-basic::  (instance)
* Random-testing::  (instance)


File: gst-base.info,  Node: Random class-instance creation,  Next: Random class-shortcuts,  Up: Random

Random class: instance creation
-------------------------------

new
     Create a new random number generator whose seed is given by the
     current time on the millisecond clock

seed: aFloat
     Create a new random number generator whose seed is aFloat



File: gst-base.info,  Node: Random class-shortcuts,  Next: Random-basic,  Prev: Random class-instance creation,  Up: Random

Random class: shortcuts
-----------------------

between: low and: high
     Return a random integer between the given extrema

next
     Return a random number between 0 and 1 (excluded)



File: gst-base.info,  Node: Random-basic,  Next: Random-testing,  Prev: Random class-shortcuts,  Up: Random

Random: basic
-------------

atEnd
     This stream never ends. Always answer false.

between: low and: high
     Return a random integer between low and high.

next
     Return the next random number in the sequence.

nextPut: value
     This method should not be called for instances of this class.



File: gst-base.info,  Node: Random-testing,  Prev: Random-basic,  Up: Random

Random: testing
---------------

chiSquare
     Compute the chi-square of the random that this class generates.

chiSquare: n range: r
     Return the chi-square deduced from calculating n random numbers in
     the 0..r range.



File: gst-base.info,  Node: ReadStream,  Next: ReadWriteStream,  Prev: Random,  Up: Base classes

ReadStream
==========

Defined in namespace Smalltalk
Superclass: PositionableStream
Category: Streams-Collections
     I implement the set of read-only stream objects.  You may read from
     my objects, but you may not write to them.

* Menu:

* ReadStream class-instance creation::  (class)
* ReadStream-accessing-reading::  (instance)


File: gst-base.info,  Node: ReadStream class-instance creation,  Next: ReadStream-accessing-reading,  Up: ReadStream

ReadStream class: instance creation
-----------------------------------

on: aCollection
     Answer a new stream working on aCollection from its start.



File: gst-base.info,  Node: ReadStream-accessing-reading,  Prev: ReadStream class-instance creation,  Up: ReadStream

ReadStream: accessing-reading
-----------------------------

reverseContents
     May be faster than generic stream reverseContents.

size
     Answer the receiver's size.



File: gst-base.info,  Node: ReadWriteStream,  Next: Rectangle,  Prev: ReadStream,  Up: Base classes

ReadWriteStream
===============

Defined in namespace Smalltalk
Superclass: WriteStream
Category: Streams-Collections
     I am the class of streams that may be read and written from
     simultaneously.  In some sense, I am the best of both ReadStream
     and WriteStream.

* Menu:

* ReadWriteStream class-instance creation::  (class)
* ReadWriteStream-positioning::  (instance)


File: gst-base.info,  Node: ReadWriteStream class-instance creation,  Next: ReadWriteStream-positioning,  Up: ReadWriteStream

ReadWriteStream class: instance creation
----------------------------------------

on: aCollection
     Answer a new stream working on aCollection from its start. The
     stream starts at the front of aCollection

with: aCollection
     Answer a new instance of the receiver which streams from the end
     of aCollection.



File: gst-base.info,  Node: ReadWriteStream-positioning,  Prev: ReadWriteStream class-instance creation,  Up: ReadWriteStream

ReadWriteStream: positioning
----------------------------

position: anInteger
     Unlike WriteStreams, ReadWriteStreams don't truncate the stream

skip: anInteger
     Unlike WriteStreams, ReadWriteStreams don't truncate the stream



File: gst-base.info,  Node: Rectangle,  Next: RecursionLock,  Prev: ReadWriteStream,  Up: Base classes

Rectangle
=========

Defined in namespace Smalltalk
Superclass: Object
Category: Language-Data types
     Beginning of the Rectangle class for simple display manipulation.
     Rectangles require the Point class to be available.  An extension
     to the Point class is made here that since it requires Rectangles
     to be defined (see converting)

* Menu:

* Rectangle class-instance creation::  (class)
* Rectangle-accessing::  (instance)
* Rectangle-copying::  (instance)
* Rectangle-printing::  (instance)
* Rectangle-rectangle functions::  (instance)
* Rectangle-testing::  (instance)
* Rectangle-transforming::  (instance)
* Rectangle-truncation and round off::  (instance)


File: gst-base.info,  Node: Rectangle class-instance creation,  Next: Rectangle-accessing,  Up: Rectangle

Rectangle class: instance creation
----------------------------------

left: leftNumber right: rightNumber top: topNumber bottom: bottomNumber
     Answer a rectangle with the given coordinates

new
     Answer the (0 @ 0 corner: 0 @ 0) rectangle

origin: originPoint corner: cornerPoint
     Answer a rectangle with the given corners

origin: originPoint extent: extentPoint
     Answer a rectangle with the given origin and size



File: gst-base.info,  Node: Rectangle-accessing,  Next: Rectangle-copying,  Prev: Rectangle class-instance creation,  Up: Rectangle

Rectangle: accessing
--------------------

bottom
     Answer the corner's y of the receiver

bottom: aNumber
     Set the corner's y of the receiver

bottomCenter
     Answer the center of the receiver's bottom side

bottomLeft
     Answer the bottom-left corner of the receiver

bottomLeft: aPoint
     Answer the receiver with the bottom-left changed to aPoint

bottomRight
     Answer the bottom-right corner of the receiver

bottomRight: aPoint
     Change the bottom-right corner of the receiver

center
     Answer the center of the receiver

corner
     Answer the corner of the receiver

corner: aPoint
     Set the corner of the receiver

extent
     Answer the extent of the receiver

extent: aPoint
     Change the size of the receiver, keeping the origin the same

height
     Answer the height of the receiver

height: aNumber
     Set the height of the receiver

left
     Answer the x of the left edge of the receiver

left: aValue
     Set the x of the left edge of the receiver

left: l top: t right: r bottom: b
     Change all four the coordinates of the receiver's corners

leftCenter
     Answer the center of the receiver's left side

origin
     Answer the top-left corner of the receiver

origin: aPoint
     Change the top-left corner of the receiver to aPoint

origin: pnt1 corner: pnt2
     Change both the origin (top-left corner) and the corner
     (bottom-right corner) of the receiver

origin: pnt1 extent: pnt2
     Change the top-left corner and the size of the receiver

right
     Answer the x of the bottom-right corner of the receiver

right: aNumber
     Change the x of the bottom-right corner of the receiver

rightCenter
     Answer the center of the receiver's right side

top
     Answer the y of the receiver's top-left corner

top: aValue
     Change the y of the receiver's top-left corner

topCenter
     Answer the center of the receiver's top side

topLeft
     Answer the receiver's top-left corner

topLeft: aPoint
     Change the receiver's top-left corner's coordinates to aPoint

topRight
     Answer the receiver's top-right corner

topRight: aPoint
     Change the receiver's top-right corner to aPoint

width
     Answer the receiver's width

width: aNumber
     Change the receiver's width to aNumber



File: gst-base.info,  Node: Rectangle-copying,  Next: Rectangle-printing,  Prev: Rectangle-accessing,  Up: Rectangle

Rectangle: copying
------------------

copy
     Return a deep copy of the receiver for safety.



File: gst-base.info,  Node: Rectangle-printing,  Next: Rectangle-rectangle functions,  Prev: Rectangle-copying,  Up: Rectangle

Rectangle: printing
-------------------

printOn: aStream
     Print a representation of the receiver on aStream

storeOn: aStream
     Store Smalltalk code compiling to the receiver on aStream



File: gst-base.info,  Node: Rectangle-rectangle functions,  Next: Rectangle-testing,  Prev: Rectangle-printing,  Up: Rectangle

Rectangle: rectangle functions
------------------------------

amountToTranslateWithin: aRectangle
     Answer a Point so that if aRectangle is translated by that point,
     its origin lies within the receiver's.

area
     Answer the receiver's area. The area is the width times the height,
     so it is possible for it to be negative if the rectangle is not
     normalized.

areasOutside: aRectangle
     Answer a collection of rectangles containing the parts of the
     receiver outside of aRectangle. For all points in the receiver,
     but outside aRectangle, exactly one rectangle in the collection
     will contain that point.

expandBy: delta
     Answer a new rectangle that is the receiver expanded by aValue: if
     aValue is a rectangle, calculate origin=origin-aValue origin,
     corner=corner+aValue corner; else calculate origin=origin-aValue,
     corner=corner+aValue.

insetBy: delta
     Answer a new rectangle that is the receiver inset by aValue: if
     aValue is a rectangle, calculate origin=origin+aValue origin,
     corner=corner-aValue corner; else calculate origin=origin+aValue,
     corner=corner-aValue.

insetOriginBy: originDelta corner: cornerDelta
     Answer a new rectangle that is the receiver inset so that
     origin=origin+originDelta, corner=corner-cornerDelta.  The deltas
     can be points or numbers

intersect: aRectangle
     Returns the rectangle (if any) created by the overlap of
     rectangles A and B.

merge: aRectangle
     Answer a new rectangle which is the smallest rectangle containing
     both the receiver and aRectangle.

translatedToBeWithin: aRectangle
     Answer a copy of the receiver that does not extend beyond
     aRectangle.



File: gst-base.info,  Node: Rectangle-testing,  Next: Rectangle-transforming,  Prev: Rectangle-rectangle functions,  Up: Rectangle

Rectangle: testing
------------------

= aRectangle
     Answer whether the receiver is equal to aRectangle

contains: aRectangle
     Answer true if the receiver contains (see containsPoint:) both
     aRectangle's origin and aRectangle's corner

containsPoint: aPoint
     Answer true if aPoint is equal to, or below and to the right of,
     the receiver's origin; and aPoint is above and to the left of the
     receiver's corner

hash
     Answer an hash value for the receiver

intersects: aRectangle
     Answer true if the receiver intersect aRectangle, i.e. if it
     contains (see containsPoint:) any of aRectangle corners or if
     aRectangle contains the receiver



File: gst-base.info,  Node: Rectangle-transforming,  Next: Rectangle-truncation and round off,  Prev: Rectangle-testing,  Up: Rectangle

Rectangle: transforming
-----------------------

moveBy: aPoint
     Change the receiver so that the origin and corner are shifted by
     aPoint

moveTo: aPoint
     Change the receiver so that the origin moves to aPoint and the size
     remains unchanged

scaleBy: scale
     Answer a copy of the receiver in which the origin and corner are
     multiplied by scale

translateBy: factor
     Answer a copy of the receiver in which the origin and corner are
     shifted by aPoint



File: gst-base.info,  Node: Rectangle-truncation and round off,  Prev: Rectangle-transforming,  Up: Rectangle

Rectangle: truncation and round off
-----------------------------------

rounded
     Answer a copy of the receiver with the coordinates rounded to the
     nearest integers



File: gst-base.info,  Node: RecursionLock,  Next: RootNamespace,  Prev: Rectangle,  Up: Base classes

RecursionLock
=============

Defined in namespace Smalltalk
Superclass: Object
Category: Language-Processes

* Menu:

* RecursionLock class-instance creation::  (class)
* RecursionLock-accessing::  (instance)
* RecursionLock-mutual exclusion::  (instance)
* RecursionLock-printing::  (instance)


File: gst-base.info,  Node: RecursionLock class-instance creation,  Next: RecursionLock-accessing,  Up: RecursionLock

RecursionLock class: instance creation
--------------------------------------

new
     Answer a new semaphore



File: gst-base.info,  Node: RecursionLock-accessing,  Next: RecursionLock-mutual exclusion,  Prev: RecursionLock class-instance creation,  Up: RecursionLock

RecursionLock: accessing
------------------------

isOwnerProcess
     Answer whether the receiver is the owner of the lock.

name
     Answer a user-defined name for the lock.

name: aString
     Set to aString the user-defined name for the lock.

waitingProcesses
     Answer the set of processes that are waiting on the semaphore.

wouldBlock
     Answer whether sending #wait to the receiver would suspend the
     active process.



File: gst-base.info,  Node: RecursionLock-mutual exclusion,  Next: RecursionLock-printing,  Prev: RecursionLock-accessing,  Up: RecursionLock

RecursionLock: mutual exclusion
-------------------------------

critical: aBlock
     Wait for the receiver to be free, execute aBlock and signal the
     receiver again. Return the result of evaluating aBlock.



File: gst-base.info,  Node: RecursionLock-printing,  Prev: RecursionLock-mutual exclusion,  Up: RecursionLock

RecursionLock: printing
-----------------------

printOn: aStream
     Print a human-readable represention of the receiver on aStream.



File: gst-base.info,  Node: RootNamespace,  Next: RunArray,  Prev: RecursionLock,  Up: Base classes

RootNamespace
=============

Defined in namespace Smalltalk
Superclass: AbstractNamespace
Category: Language-Implementation
     I am a special form of dictionary.  Classes hold on an instance of
     me; it is called their `environment'.

* Menu:

* RootNamespace class-instance creation::  (class)
* RootNamespace-namespace hierarchy::  (instance)
* RootNamespace-overrides for superspaces::  (instance)
* RootNamespace-printing::  (instance)


File: gst-base.info,  Node: RootNamespace class-instance creation,  Next: RootNamespace-namespace hierarchy,  Up: RootNamespace

RootNamespace class: instance creation
--------------------------------------

new: spaceName
     Create a new root namespace with the given name, and add to
     Smalltalk a key that references it.



File: gst-base.info,  Node: RootNamespace-namespace hierarchy,  Next: RootNamespace-overrides for superspaces,  Prev: RootNamespace class-instance creation,  Up: RootNamespace

RootNamespace: namespace hierarchy
----------------------------------

siblings
     Answer all the other root namespaces

siblingsDo: aBlock
     Evaluate aBlock once for each of the other root namespaces,
     passing the namespace as a parameter.



File: gst-base.info,  Node: RootNamespace-overrides for superspaces,  Next: RootNamespace-printing,  Prev: RootNamespace-namespace hierarchy,  Up: RootNamespace

RootNamespace: overrides for superspaces
----------------------------------------

inheritedKeys
     Answer a Set of all the keys in the receiver and its superspaces

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.



File: gst-base.info,  Node: RootNamespace-printing,  Prev: RootNamespace-overrides for superspaces,  Up: RootNamespace

RootNamespace: printing
-----------------------

nameIn: aNamespace
     Answer Smalltalk code compiling to the receiver when the current
     namespace is aNamespace

printOn: aStream in: aNamespace
     Print on aStream some Smalltalk code compiling to the receiver
     when the current namespace is aNamespace

storeOn: aStream
     Store Smalltalk code compiling to the receiver



File: gst-base.info,  Node: RunArray,  Next: ScaledDecimal,  Prev: RootNamespace,  Up: Base classes

RunArray
========

Defined in namespace Smalltalk
Superclass: OrderedCollection
Category: Collections-Sequenceable
     My instances are OrderedCollections that automatically apply Run
     Length Encoding compression to the things they store. Be careful
     when using me: I can provide great space savings, but my instances
     don't grant linear access time. RunArray's behavior currently is
     similar to that of OrderedCollection (you can add elements to
     RunArrays); maybe it should behave like an ArrayedCollection.

* Menu:

* RunArray class-instance creation::  (class)
* RunArray-accessing::  (instance)
* RunArray-adding::  (instance)
* RunArray-basic::  (instance)
* RunArray-copying::  (instance)
* RunArray-enumerating::  (instance)
* RunArray-removing::  (instance)
* RunArray-searching::  (instance)
* RunArray-testing::  (instance)


File: gst-base.info,  Node: RunArray class-instance creation,  Next: RunArray-accessing,  Up: RunArray

RunArray class: instance creation
---------------------------------

new
     Answer an empty RunArray

new: aSize
     Answer a RunArray with space for aSize runs



File: gst-base.info,  Node: RunArray-accessing,  Next: RunArray-adding,  Prev: RunArray class-instance creation,  Up: RunArray

RunArray: accessing
-------------------

at: anIndex
     Answer the element at index anIndex

at: anIndex put: anObject
     Replace the element at index anIndex with anObject and answer
     anObject



File: gst-base.info,  Node: RunArray-adding,  Next: RunArray-basic,  Prev: RunArray-accessing,  Up: RunArray

RunArray: adding
----------------

add: anObject afterIndex: anIndex
     Add anObject after the element at index anIndex

addAll: aCollection afterIndex: anIndex
     Add all the elements of aCollection after the one at index
     anIndex. If aCollection is unordered, its elements could be added
     in an order which is not the #do: order

addAllFirst: aCollection
     Add all the elements of aCollection at the beginning of the
     receiver. If aCollection is unordered, its elements could be added
     in an order which is not the #do: order

addAllLast: aCollection
     Add all the elements of aCollection at the end of the receiver. If
     aCol- lection is unordered, its elements could be added in an
     order which is not the #do: order

addFirst: anObject
     Add anObject at the beginning of the receiver. Watch out: this
     operation can cause serious performance pitfalls

addLast: anObject
     Add anObject at the end of the receiver



File: gst-base.info,  Node: RunArray-basic,  Next: RunArray-copying,  Prev: RunArray-adding,  Up: RunArray

RunArray: basic
---------------

first
     Answer the first element in the receiver

last
     Answer the last element of the receiver

size
     Answer the number of elements in the receiver



File: gst-base.info,  Node: RunArray-copying,  Next: RunArray-enumerating,  Prev: RunArray-basic,  Up: RunArray

RunArray: copying
-----------------

deepCopy
     Answer a copy of the receiver containing copies of the receiver's
     elements (#copy is used to obtain them)

shallowCopy
     Answer a copy of the receiver. The elements are not copied



File: gst-base.info,  Node: RunArray-enumerating,  Next: RunArray-removing,  Prev: RunArray-copying,  Up: RunArray

RunArray: enumerating
---------------------

do: aBlock
     Enumerate all the objects in the receiver, passing each one to
     aBlock

objectsAndRunLengthsDo: aBlock
     Enumerate all the runs in the receiver, passing to aBlock two
     parameters for every run: the first is the repeated object, the
     second is the number of copies



File: gst-base.info,  Node: RunArray-removing,  Next: RunArray-searching,  Prev: RunArray-enumerating,  Up: RunArray

RunArray: removing
------------------

removeAtIndex: anIndex
     Remove the object at index anIndex from the receiver and answer the
     removed object

removeFirst
     Remove the first object from the receiver and answer the removed
     object

removeLast
     Remove the last object from the receiver and answer the removed
     object



File: gst-base.info,  Node: RunArray-searching,  Next: RunArray-testing,  Prev: RunArray-removing,  Up: RunArray

RunArray: searching
-------------------

indexOf: anObject startingAt: anIndex ifAbsent: aBlock
     Answer the index of the first copy of anObject in the receiver,
     starting the search at the element at index anIndex. If no equal
     object is found, answer the result of evaluating aBlock



File: gst-base.info,  Node: RunArray-testing,  Prev: RunArray-searching,  Up: RunArray

RunArray: testing
-----------------

= anObject
     Answer true if the receiver is equal to anObject

hash
     Answer an hash value for the receiver



File: gst-base.info,  Node: ScaledDecimal,  Next: Semaphore,  Prev: RunArray,  Up: Base classes

ScaledDecimal
=============

Defined in namespace Smalltalk
Superclass: Number
Category: Language-Data types
     ScaledDecimal provides a numeric representation of fixed point
     decimal numbers able to accurately represent decimal fractions.
     It supports unbounded precision, with no limit to the number of
     digits before and after the decimal point.

* Menu:

* ScaledDecimal class-constants::  (class)
* ScaledDecimal class-instance creation::  (class)
* ScaledDecimal-arithmetic::  (instance)
* ScaledDecimal-coercion::  (instance)
* ScaledDecimal-comparing::  (instance)
* ScaledDecimal-constants::  (instance)
* ScaledDecimal-printing::  (instance)
* ScaledDecimal-storing::  (instance)


File: gst-base.info,  Node: ScaledDecimal class-constants,  Next: ScaledDecimal class-instance creation,  Up: ScaledDecimal

ScaledDecimal class: constants
------------------------------

initialize
     Initialize the receiver's class variables



File: gst-base.info,  Node: ScaledDecimal class-instance creation,  Next: ScaledDecimal-arithmetic,  Prev: ScaledDecimal class-constants,  Up: ScaledDecimal

ScaledDecimal class: instance creation
--------------------------------------

newFromNumber: aNumber scale: scale
     Answer a new instance of ScaledDecimal, representing a decimal
     fraction with a decimal representation considered valid up to the
     scale-th digit.



File: gst-base.info,  Node: ScaledDecimal-arithmetic,  Next: ScaledDecimal-coercion,  Prev: ScaledDecimal class-instance creation,  Up: ScaledDecimal

ScaledDecimal: arithmetic
-------------------------

* aNumber
     Multiply two numbers and answer the result.

+ aNumber
     Sum two numbers and answer the result.

- aNumber
     Subtract aNumber from the receiver and answer the result.

/ aNumber
     Divide two numbers and answer the result.

// aNumber
     Answer the integer quotient after dividing the receiver by aNumber
     with truncation towards negative infinity.

\\ aNumber
     Answer the remainder after integer division the receiver by aNumber
     with truncation towards negative infinity.



File: gst-base.info,  Node: ScaledDecimal-coercion,  Next: ScaledDecimal-comparing,  Prev: ScaledDecimal-arithmetic,  Up: ScaledDecimal

ScaledDecimal: coercion
-----------------------

asFloatD
     Answer the receiver, converted to a FloatD

asFloatE
     Answer the receiver, converted to a FloatE

asFloatQ
     Answer the receiver, converted to a FloatQ

asFraction
     Answer the receiver, converted to a Fraction

ceiling
     Answer the receiver, converted to an Integer and truncated towards
     +infinity.

coerce: aNumber
     Answer aNumber, converted to a ScaledDecimal with the same scale
     as the receiver.

fractionPart
     Answer the fractional part of the receiver.

generality
     Return the receiver's generality

integerPart
     Answer the fractional part of the receiver.

truncated
     Answer the receiver, converted to an Integer and truncated towards
     -infinity.



File: gst-base.info,  Node: ScaledDecimal-comparing,  Next: ScaledDecimal-constants,  Prev: ScaledDecimal-coercion,  Up: ScaledDecimal

ScaledDecimal: comparing
------------------------

< aNumber
     Answer whether the receiver is less than arg.

<= aNumber
     Answer whether the receiver is less than or equal to arg.

= arg
     Answer whether the receiver is equal to arg.

> aNumber
     Answer whether the receiver is greater than arg.

>= aNumber
     Answer whether the receiver is greater than or equal to arg.

hash
     Answer an hash value for the receiver.

~= arg
     Answer whether the receiver is not equal arg.



File: gst-base.info,  Node: ScaledDecimal-constants,  Next: ScaledDecimal-printing,  Prev: ScaledDecimal-comparing,  Up: ScaledDecimal

ScaledDecimal: constants
------------------------

one
     Answer the receiver's representation of one.

zero
     Answer the receiver's representation of zero.



File: gst-base.info,  Node: ScaledDecimal-printing,  Next: ScaledDecimal-storing,  Prev: ScaledDecimal-constants,  Up: ScaledDecimal

ScaledDecimal: printing
-----------------------

displayOn: aStream
     Print a representation of the receiver on aStream, intended to be
     directed to a user.  In this particular case, the `scale' part of
     the #printString is not emitted.

printOn: aStream
     Print a representation of the receiver on aStream.



File: gst-base.info,  Node: ScaledDecimal-storing,  Prev: ScaledDecimal-printing,  Up: ScaledDecimal

ScaledDecimal: storing
----------------------

storeOn: aStream
     Print Smalltalk code that compiles to the receiver on aStream.



File: gst-base.info,  Node: Semaphore,  Next: SequenceableCollection,  Prev: ScaledDecimal,  Up: Base classes

Semaphore
=========

Defined in namespace Smalltalk
Superclass: LinkedList
Category: Language-Processes
     My instances represent counting semaphores.  I provide methods for
     signalling the semaphore's availability, and methods for waiting
     for its availability.  I also provide some methods for
     implementing critical sections.

* Menu:

* Semaphore class-instance creation::  (class)
* Semaphore-accessing::  (instance)
* Semaphore-builtins::  (instance)
* Semaphore-mutual exclusion::  (instance)
* Semaphore-printing::  (instance)


File: gst-base.info,  Node: Semaphore class-instance creation,  Next: Semaphore-accessing,  Up: Semaphore

Semaphore class: instance creation
----------------------------------

forMutualExclusion
     Answer a new semaphore with a signal on it. These semaphores are a
     useful shortcut when you use semaphores as critical sections.

new
     Answer a new semaphore



File: gst-base.info,  Node: Semaphore-accessing,  Next: Semaphore-builtins,  Prev: Semaphore class-instance creation,  Up: Semaphore

Semaphore: accessing
--------------------

name
     Answer a user-friendly name for the receiver

name: aString
     Answer a user-friendly name for the receiver

waitingProcesses
     Answer an Array of processes currently waiting on the receiver.

wouldBlock
     Answer whether waiting on the receiver would suspend the current
     process.



File: gst-base.info,  Node: Semaphore-builtins,  Next: Semaphore-mutual exclusion,  Prev: Semaphore-accessing,  Up: Semaphore

Semaphore: builtins
-------------------

lock
     Without putting the receiver to sleep, force processes that try to
     wait on the semaphore to block.  Answer whether this was the case
     even before.

notify
     Resume one of the processes that were waiting on the semaphore if
     there were any.  Do not leave a signal on the semaphore if no
     process is waiting.

notifyAll
     Resume all the processes that were waiting on the semaphore if
     there were any.  Do not leave a signal on the semaphore if no
     process is waiting.

signal
     Signal the receiver, resuming a waiting process' if there is one

wait
     Wait for the receiver to be signalled, suspending the executing
     process if it is not yet

     is

waitAfterSignalling: aSemaphore
     Signal aSemaphore then, atomically, wait for the receiver to be
     signalled, suspending the executing process if it is not yet.  This
     is needed to avoid race conditions when the #notify and #notifyAll
     is used together with the receiver: otherwise, if a process sends
     one of them between the time aSemaphore is signaled and the time
     the process starts waiting on the receiver, the notification is
     lost.



File: gst-base.info,  Node: Semaphore-mutual exclusion,  Next: Semaphore-printing,  Prev: Semaphore-builtins,  Up: Semaphore

Semaphore: mutual exclusion
---------------------------

critical: aBlock
     Wait for the receiver to be free, execute aBlock and signal the
     receiver again. Return the result of evaluating aBlock.



File: gst-base.info,  Node: Semaphore-printing,  Prev: Semaphore-mutual exclusion,  Up: Semaphore

Semaphore: printing
-------------------

printOn: aStream
     Print a human-readable represention of the receiver on aStream.



File: gst-base.info,  Node: SequenceableCollection,  Next: Set,  Prev: Semaphore,  Up: Base classes

SequenceableCollection
======================

Defined in namespace Smalltalk
Superclass: Collection
Category: Collections-Sequenceable
     My instances represent collections of objects that are ordered.  I
     provide some access and manipulation methods.

* Menu:

* SequenceableCollection class-instance creation::  (class)
* SequenceableCollection-basic::  (instance)
* SequenceableCollection-copying SequenceableCollections::  (instance)
* SequenceableCollection-enumerating::  (instance)
* SequenceableCollection-replacing items::  (instance)
* SequenceableCollection-testing::  (instance)


File: gst-base.info,  Node: SequenceableCollection class-instance creation,  Next: SequenceableCollection-basic,  Up: SequenceableCollection

SequenceableCollection class: instance creation
-----------------------------------------------

streamContents: aBlock
     Create a ReadWriteStream on an empty instance of the receiver;
     pass the stream to aBlock, then retrieve its contents and answer
     them.



File: gst-base.info,  Node: SequenceableCollection-basic,  Next: SequenceableCollection-copying SequenceableCollections,  Prev: SequenceableCollection class-instance creation,  Up: SequenceableCollection

SequenceableCollection: basic
-----------------------------

after: oldObject
     Return the element after oldObject.  Error if oldObject not found
     or if no following object is available

at: anIndex ifAbsent: aBlock
     Answer the anIndex-th item of the collection, or evaluate aBlock
     and answer the result if the index is out of range

atAll: aCollection put: anObject
     Put anObject at every index contained in aCollection

atAllPut: anObject
     Put anObject at every index in the receiver

before: oldObject
     Return the element before oldObject.  Error if oldObject not found
     or if no preceding object is available

first
     Answer the first item in the receiver

identityIncludes: anObject
     Answer whether we include the anObject object

identityIndexOf: anElement
     Answer the index of the first occurrence of an object identical to
     anElement in the receiver. Answer 0 if no item is found

identityIndexOf: anElement ifAbsent: exceptionBlock
     Answer the index of the first occurrence of an object identical to
     anElement in the receiver. Invoke exceptionBlock and answer its
     result if no item is found

identityIndexOf: anElement startingAt: anIndex
     Answer the first index > anIndex which contains an object identical
     to anElement. Answer 0 if no item is found

identityIndexOf: anObject startingAt: anIndex ifAbsent: exceptionBlock
     Answer the first index > anIndex which contains an object exactly
     identical to anObject.  Invoke exceptionBlock and answer its
     result if no item is found

includes: anObject
     Answer whether we include anObject

indexOf: anElement
     Answer the index of the first occurrence of anElement in the
     receiver.  Answer 0 if no item is found

indexOf: anElement ifAbsent: exceptionBlock
     Answer the index of the first occurrence of anElement in the
     receiver.  Invoke exceptionBlock and answer its result if no item
     is found

indexOf: anElement startingAt: anIndex
     Answer the first index > anIndex which contains anElement.  Answer
     0 if no item is found

indexOf: anElement startingAt: anIndex ifAbsent: exceptionBlock
     Answer the first index > anIndex which contains anElement.  Invoke
     exceptionBlock and answer its result if no item is found

indexOfSubCollection: aSubCollection
     Answer the first index > anIndex at which starts a sequence of
     items matching aSubCollection. Answer 0 if no such sequence is
     found.

indexOfSubCollection: aSubCollection ifAbsent: exceptionBlock
     Answer the first index > anIndex at which starts a sequence of
     items matching aSubCollection. Answer 0 if no such sequence is
     found.

indexOfSubCollection: aSubCollection startingAt: anIndex
     Answer the first index > anIndex at which starts a sequence of
     items matching aSubCollection. Answer 0 if no such sequence is
     found.

indexOfSubCollection: aSubCollection startingAt: anIndex ifAbsent: exceptionBlock
     Answer the first index > anIndex at which starts a sequence of
     items matching aSubCollection.  Invoke exceptionBlock and answer
     its result if no such sequence is found

last
     Answer the last item in the receiver



File: gst-base.info,  Node: SequenceableCollection-copying SequenceableCollections,  Next: SequenceableCollection-enumerating,  Prev: SequenceableCollection-basic,  Up: SequenceableCollection

SequenceableCollection: copying SequenceableCollections
-------------------------------------------------------

, aSequenceableCollection
     Append aSequenceableCollection at the end of the receiver (using
     #add:), and answer a new collection

copyFrom: start
     Answer a new collection containing all the items in the receiver
     from the start-th.

copyFrom: start to: stop
     Answer a new collection containing all the items in the receiver
     from the start-th and to the stop-th

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'.

copyUpTo: anObject
     Answer a new collection holding all the elements of the receiver
     from the first up to the first occurrence of anObject, excluded.



File: gst-base.info,  Node: SequenceableCollection-enumerating,  Next: SequenceableCollection-replacing items,  Prev: SequenceableCollection-copying SequenceableCollections,  Up: SequenceableCollection

SequenceableCollection: enumerating
-----------------------------------

anyOne
     Answer an unspecified element of the collection. Example usage:
     ^coll inject: coll anyOne into: [ :max :each | max max: each ] to
     be used when you don't have a valid lowest-possible-value (which
     happens in common cases too, such as with arbitrary numbers

do: aBlock
     Evaluate aBlock for all the elements in the sequenceable collection

do: aBlock separatedBy: sepBlock
     Evaluate aBlock for all the elements in the sequenceable
     collection.  Between each element, evaluate sepBlock without
     parameters.

doWithIndex: aBlock
     Evaluate aBlock for all the elements in the sequenceable
     collection, passing the index of each element as the second
     parameter.  This method is mantained for backwards compatibility
     and is not mandated by the ANSI standard; use #keysAndValuesDo:

findFirst: aBlock
     Returns the index of the first element of the sequenceable
     collection for which aBlock returns true, or 0 if none

findLast: aBlock
     Returns the index of the last element of the sequenceable
     collection for which aBlock returns true, or 0 if none does

from: startIndex to: stopIndex do: aBlock
     Evaluate aBlock for all the elements in the sequenceable
     collection whose indices are in the range index to stopIndex

from: startIndex to: stopIndex doWithIndex: aBlock
     Evaluate aBlock for all the elements in the sequenceable
     collection whose indices are in the range index to stopIndex,
     passing the index of each element as the second parameter.  This
     method is mantained for backwards compatibility and is not
     mandated by the ANSI standard; use #from:to:keysAndValuesDo:

from: startIndex to: stopIndex keysAndValuesDo: aBlock
     Evaluate aBlock for all the elements in the sequenceable
     collection whose indices are in the range index to stopIndex,
     passing the index of each element as the first parameter and the
     element as the second.

keysAndValuesDo: aBlock
     Evaluate aBlock for all the elements in the sequenceable
     collection, passing the index of each element as the first
     parameter and the element as the second.

readStream
     Answer a ReadStream streaming on the receiver

readWriteStream
     Answer a ReadWriteStream which streams on the receiver

reverse
     Answer the receivers' contents in reverse order

reverseDo: aBlock
     Evaluate aBlock for all elements in the sequenceable collection,
     from the last to the first.

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.

with: aSequenceableCollection do: aBlock
     Evaluate aBlock for each pair of elements took respectively from
     the re- ceiver and from aSequenceableCollection. Fail if the
     receiver has not the same size as aSequenceableCollection.

writeStream
     Answer a WriteStream streaming on the receiver



File: gst-base.info,  Node: SequenceableCollection-replacing items,  Next: SequenceableCollection-testing,  Prev: SequenceableCollection-enumerating,  Up: SequenceableCollection

SequenceableCollection: replacing items
---------------------------------------

replaceAll: anObject with: anotherObject
     In the receiver, replace every occurrence of anObject with
     anotherObject.

replaceFrom: start to: stop with: replacementCollection
     Replace the items from start to stop with replacementCollection's
     items from 1 to stop-start+1 (in unexpected order if the
     collection is not sequenceable).

replaceFrom: start to: stop with: replacementCollection startingAt: repStart
     Replace the items from start to stop with replacementCollection's
     items from repStart to repStart+stop-start

replaceFrom: anIndex to: stopIndex withObject: replacementObject
     Replace every item from start to stop with replacementObject.



File: gst-base.info,  Node: SequenceableCollection-testing,  Prev: SequenceableCollection-replacing items,  Up: SequenceableCollection

SequenceableCollection: testing
-------------------------------

= aCollection
     Answer whether the receiver's items match those in aCollection

hash
     Answer an hash value for the receiver

inspect
     Print all the instance variables and context of the receiver on the
     Transcript



File: gst-base.info,  Node: Set,  Next: SharedQueue,  Prev: SequenceableCollection,  Up: Base classes

Set
===

Defined in namespace Smalltalk
Superclass: HashedCollection
Category: Collections-Unordered
     I am the typical set object; I also known how to do arithmetic on
     my instances.

* Menu:

* Set-arithmetic::  (instance)
* Set-awful ST-80 compatibility hacks::  (instance)
* Set-comparing::  (instance)


File: gst-base.info,  Node: Set-arithmetic,  Next: Set-awful ST-80 compatibility hacks,  Up: Set

Set: arithmetic
---------------

& aSet
     Compute the set intersection of the receiver and aSet.

+ aSet
     Compute the set union of the receiver and aSet.

- aSet
     Compute the set difference of the receiver and aSet.



File: gst-base.info,  Node: Set-awful ST-80 compatibility hacks,  Next: Set-comparing,  Prev: Set-arithmetic,  Up: Set

Set: awful ST-80 compatibility hacks
------------------------------------

findObjectIndex: object
     Tries to see if anObject exists as an indexed variable. As soon as
     nil or anObject is found, the index of that slot is answered



File: gst-base.info,  Node: Set-comparing,  Prev: Set-awful ST-80 compatibility hacks,  Up: Set

Set: comparing
--------------

< aSet
     Answer whether the receiver is a strict subset of aSet

<= aSet
     Answer whether the receiver is a subset of aSet

> aSet
     Answer whether the receiver is a strict superset of aSet

>= aSet
     Answer whether the receiver is a superset of aSet



File: gst-base.info,  Node: SharedQueue,  Next: Signal,  Prev: Set,  Up: Base classes

SharedQueue
===========

Defined in namespace Smalltalk
Superclass: Object
Category: Language-Processes
     My instances provide a guaranteed safe mechanism to allow for
     communication between processes.  All access to the underlying
     data structures is controlled with critical sections so that
     things proceed smoothly.

* Menu:

* SharedQueue class-instance creation::  (class)
* SharedQueue-accessing::  (instance)


File: gst-base.info,  Node: SharedQueue class-instance creation,  Next: SharedQueue-accessing,  Up: SharedQueue

SharedQueue class: instance creation
------------------------------------

new
     Create a new instance of the receiver

sortBlock: sortBlock
     Create a new instance of the receiver which implements a priority
     queue with the given sort block



File: gst-base.info,  Node: SharedQueue-accessing,  Prev: SharedQueue class-instance creation,  Up: SharedQueue

SharedQueue: accessing
----------------------

isEmpty
     Answer whether there is an object on the queue

next
     Wait for an object to be on the queue, then remove it and answer it

nextPut: value
     Put value on the queue and answer it

peek
     Wait for an object to be on the queue if necessary, then answer the
     same object that #next would answer without removing it.



File: gst-base.info,  Node: Signal,  Next: SingletonProxy,  Prev: SharedQueue,  Up: Base classes

Signal
======

Defined in namespace Smalltalk
Superclass: Object
Category: Language-Exceptions
     My instances describe an exception that has happened, and are
     passed to exception handlers. Apart from containing information on
     the generated exception and its arguments, they contain methods
     that allow you to resume execution, leave the #on:do:... snippet,
     and pass the exception to an handler with a lower priority.

* Menu:

* Signal-accessing::  (instance)
* Signal-exception handling::  (instance)


File: gst-base.info,  Node: Signal-accessing,  Next: Signal-exception handling,  Up: Signal

Signal: accessing
-----------------

argument
     Answer the first argument of the receiver

argumentCount
     Answer how many arguments the receiver has

arguments
     Answer the arguments of the receiver

basicMessageText
     Answer an exception's message text.  Do not override this method.

description
     Answer the description of the raised exception

exception
     Answer the CoreException that was raised

messageText
     Answer an exception's message text.

messageText: aString
     Set an exception's message text.

tag
     Answer an exception's tag value.  If not specified, it is the same
     as the message text.

tag: anObject
     Set an exception's tag value.  If nil, the tag value will be the
     same as the message text.



File: gst-base.info,  Node: Signal-exception handling,  Prev: Signal-accessing,  Up: Signal

Signal: exception handling
--------------------------

defaultAction
     Execute the default handler for the raised exception

isNested
     Answer whether the current exception handler is within the scope of
     another handler for the same exception.

isResumable
     Answer whether the exception that instantiated the receiver is
     resumable.

outer
     Raise the exception that instantiated the receiver, passing the
     same parameters.  If the receiver is resumable and the evaluated
     exception action resumes then the result returned from #outer will
     be the resumption value of the evaluated exception action. If the
     receiver is not resumable or if the exception action does not
     resume then this message will not return, and #outer will be
     equivalent to #pass.

pass
     Yield control to the enclosing exception action for the receiver.
     Similar to #outer, but control does not return to the currently
     active exception handler.

resignalAs: replacementException
     Reinstate all handlers and execute the handler for
     `replacementException'; control does not return to the currently
     active exception handler. The new Signal object that is created
     has the same arguments as the receiver (this might or not be
     correct - if it isn't you can use an idiom such as `sig
     retryUsing: [ replacementException signal ])

resume
     If the exception is resumable, resume the execution of the block
     that raised the exception; the method that was used to signal the
     exception will answer the receiver.  Use this method IF AND ONLY
     IF you know who caused the exception and if it is possible to
     resume it in that particular case

resume: anObject
     If the exception is resumable, resume the execution of the block
     that raised the exception; the method that was used to signal the
     exception will answer anObject.  Use this method IF AND ONLY IF
     you know who caused the exception and if it is possible to resume
     it in that particular case

retry
     Re-execute the receiver of the #on:do: message. All handlers are
     reinstated: watch out, this can easily cause an infinite loop.

retryUsing: aBlock
     Execute aBlock reinstating all handlers, and return its result from
     the #signal method.

return
     Exit the #on:do: snippet, answering anObject to its caller

return: anObject
     Exit the #on:do: snippet, answering anObject to its caller



File: gst-base.info,  Node: SingletonProxy,  Next: SmallInteger,  Prev: Signal,  Up: Base classes

SingletonProxy
==============

Defined in namespace Smalltalk
Superclass: AlternativeObjectProxy
Category: Streams-Files
     I am a proxy that stores the class of an object rather than the
     object itself, and pretends that a registered instance (which most
     likely is a singleton instance of the stored class) was stored
     instead.

* Menu:

* SingletonProxy class-accessing::  (class)
* SingletonProxy class-instance creation::  (class)
* SingletonProxy-saving and restoring::  (instance)


File: gst-base.info,  Node: SingletonProxy class-accessing,  Next: SingletonProxy class-instance creation,  Up: SingletonProxy

SingletonProxy class: accessing
-------------------------------

acceptUsageForClass: aClass
     The receiver was asked to be used as a proxy for the class aClass.
     The registration is fine if the class is actually a singleton.



File: gst-base.info,  Node: SingletonProxy class-instance creation,  Next: SingletonProxy-saving and restoring,  Prev: SingletonProxy class-accessing,  Up: SingletonProxy

SingletonProxy class: instance creation
---------------------------------------

on: anObject
     Answer a proxy to be used to save anObject.  The proxy stores the
     class and restores the object by looking into a dictionary of
     class -> singleton objects.



File: gst-base.info,  Node: SingletonProxy-saving and restoring,  Prev: SingletonProxy class-instance creation,  Up: SingletonProxy

SingletonProxy: saving and restoring
------------------------------------

object
     Reconstruct the object stored in the proxy and answer it; the
     binaryRepresentationObject is sent the #reconstructOriginalObject
     message, and the resulting object is sent the #postLoad message.



File: gst-base.info,  Node: SmallInteger,  Next: SortedCollection,  Prev: SingletonProxy,  Up: Base classes

SmallInteger
============

Defined in namespace Smalltalk
Superclass: Integer
Category: Language-Data types
     I am the integer class of the GNU Smalltalk system.  My instances
     can represent signed 30 bit integers and are as efficient as
     possible.

* Menu:

* SmallInteger class-getting limits::  (class)
* SmallInteger class-testing::  (class)
* SmallInteger-bit arithmetic::  (instance)
* SmallInteger-built ins::  (instance)
* SmallInteger-builtins::  (instance)
* SmallInteger-coercion methods::  (instance)
* SmallInteger-testing functionality::  (instance)


File: gst-base.info,  Node: SmallInteger class-getting limits,  Next: SmallInteger class-testing,  Up: SmallInteger

SmallInteger class: getting limits
----------------------------------

bits
     Answer the number of bits (excluding the sign) that can be
     represented directly in an object pointer

largest
     Answer the largest integer represented directly in an object
     pointer

smallest
     Answer the smallest integer represented directly in an object
     pointer



File: gst-base.info,  Node: SmallInteger class-testing,  Next: SmallInteger-bit arithmetic,  Prev: SmallInteger class-getting limits,  Up: SmallInteger

SmallInteger class: testing
---------------------------

isIdentity
     Answer whether x = y implies x == y for instances of the receiver



File: gst-base.info,  Node: SmallInteger-bit arithmetic,  Next: SmallInteger-built ins,  Prev: SmallInteger class-testing,  Up: SmallInteger

SmallInteger: bit arithmetic
----------------------------

highBit
     Return the index of the highest order 1 bit of the receiver



File: gst-base.info,  Node: SmallInteger-built ins,  Next: SmallInteger-builtins,  Prev: SmallInteger-bit arithmetic,  Up: SmallInteger

SmallInteger: built ins
-----------------------

* arg
     Multiply the receiver and arg and answer another Number

+ arg
     Sum the receiver and arg and answer another Number

- arg
     Subtract arg from the receiver and answer another Number

/ arg
     Divide the receiver by arg and answer another Integer or Fraction

// arg
     Dividing receiver by arg (with truncation towards -infinity) and
     answer the result

< arg
     Answer whether the receiver is less than arg

<= arg
     Answer whether the receiver is less than or equal to arg

= arg
     Answer whether the receiver is equal to arg

== arg
     Answer whether the receiver is the same object as arg

> arg
     Answer whether the receiver is greater than arg

>= arg
     Answer whether the receiver is greater than or equal to arg

\\ arg
     Calculate the remainder of dividing receiver by arg (with
     truncation towards -infinity) and answer it

asFloatD
     Convert the receiver to a FloatD, answer the result

asFloatE
     Convert the receiver to a FloatE, answer the result

asFloatQ
     Convert the receiver to a FloatQ, answer the result

asObject
     Answer the object whose index is in the receiver, nil if there is
     a free object, fail if index is out of bounds

asObjectNoFail
     Answer the object whose index is in the receiver, or nil if no
     object is found at that index

bitAnd: arg
     Do a bitwise AND between the receiver and arg, answer the result

bitOr: arg
     Do a bitwise OR between the receiver and arg, answer the result

bitShift: arg
     Shift the receiver by arg places to the left if arg > 0, by arg
     places to the right if arg < 0, answer another Number

bitXor: arg
     Do a bitwise XOR between the receiver and arg, answer the result

nextValidOop
     Answer the index of the first non-free OOP after the receiver.
     This is used internally; it is placed here to avoid polluting
     Object.

quo: arg
     Dividing receiver by arg (with truncation towards zero) and answer
     the result

~= arg
     Answer whether the receiver is not equal to arg

~~ arg
     Answer whether the receiver is not the same object as arg



File: gst-base.info,  Node: SmallInteger-builtins,  Next: SmallInteger-coercion methods,  Prev: SmallInteger-built ins,  Up: SmallInteger

SmallInteger: builtins
----------------------

at: anIndex
     Answer the index-th indexed instance variable of the receiver.
     This method always fails.

at: anIndex put: value
     Store value in the index-th indexed instance variable of the
     receiver This method always fails.

basicAt: anIndex
     Answer the index-th indexed instance variable of the receiver.
     This method always fails.

basicAt: anIndex put: value
     Store value in the index-th indexed instance variable of the
     receiver This method always fails.

scramble
     Answer the receiver with its bits mixed and matched.



File: gst-base.info,  Node: SmallInteger-coercion methods,  Next: SmallInteger-testing functionality,  Prev: SmallInteger-builtins,  Up: SmallInteger

SmallInteger: coercion methods
------------------------------

generality
     Return the receiver's generality

unity
     Coerce 1 to the receiver's class

zero
     Coerce 0 to the receiver's class



File: gst-base.info,  Node: SmallInteger-testing functionality,  Prev: SmallInteger-coercion methods,  Up: SmallInteger

SmallInteger: testing functionality
-----------------------------------

isSmallInteger
     Answer `true'.



File: gst-base.info,  Node: SortedCollection,  Next: Stream,  Prev: SmallInteger,  Up: Base classes

SortedCollection
================

Defined in namespace Smalltalk
Superclass: OrderedCollection
Category: Collections-Sequenceable
     I am a collection of objects, stored and accessed according to some
     sorting criteria.  I store things using heap sort and quick sort.
     My instances have a comparison block associated with them; this
     block takes two arguments and is a predicate which returns true if
     the first argument should be sorted earlier than the second.  The
     default block is [ :a :b | a <= b ], but I will accept any block
     that conforms to the above criteria - actually any object which
     responds to #value:value:.

* Menu:

* SortedCollection class-hacking::  (class)
* SortedCollection class-instance creation::  (class)
* SortedCollection-basic::  (instance)
* SortedCollection-copying::  (instance)
* SortedCollection-disabled::  (instance)
* SortedCollection-enumerating::  (instance)
* SortedCollection-saving and loading::  (instance)
* SortedCollection-searching::  (instance)


File: gst-base.info,  Node: SortedCollection class-hacking,  Next: SortedCollection class-instance creation,  Up: SortedCollection

SortedCollection class: hacking
-------------------------------

defaultSortBlock
     Answer a default sort block for the receiver.



File: gst-base.info,  Node: SortedCollection class-instance creation,  Next: SortedCollection-basic,  Prev: SortedCollection class-hacking,  Up: SortedCollection

SortedCollection class: instance creation
-----------------------------------------

new
     Answer a new collection with a default size and sort block

new: aSize
     Answer a new collection with a default sort block and the given
     size

sortBlock: aSortBlock
     Answer a new collection with a default size and the given sort
     block



File: gst-base.info,  Node: SortedCollection-basic,  Next: SortedCollection-copying,  Prev: SortedCollection class-instance creation,  Up: SortedCollection

SortedCollection: basic
-----------------------

last
     Answer the last item of the receiver

removeLast
     Remove an object from the end of the receiver. Fail if the receiver
     is empty

sortBlock
     Answer the receiver's sort criteria

sortBlock: aSortBlock
     Change the sort criteria for a sorted collection, resort the
     elements of the collection, and return it.



File: gst-base.info,  Node: SortedCollection-copying,  Next: SortedCollection-disabled,  Prev: SortedCollection-basic,  Up: SortedCollection

SortedCollection: copying
-------------------------

copyEmpty: newSize
     Answer an empty copy of the receiver, with the same sort block as
     the receiver



File: gst-base.info,  Node: SortedCollection-disabled,  Next: SortedCollection-enumerating,  Prev: SortedCollection-copying,  Up: SortedCollection

SortedCollection: disabled
--------------------------

add: anObject afterIndex: i
     This method should not be called for instances of this class.

addAll: aCollection afterIndex: i
     This method should not be called for instances of this class.

addAllFirst: aCollection
     This method should not be called for instances of this class.

addAllLast: aCollection
     This method should not be called for instances of this class.

addFirst: anObject
     This method should not be called for instances of this class.

addLast: anObject
     This method should not be called for instances of this class.

at: index put: anObject
     This method should not be called for instances of this class.



File: gst-base.info,  Node: SortedCollection-enumerating,  Next: SortedCollection-saving and loading,  Prev: SortedCollection-disabled,  Up: SortedCollection

SortedCollection: enumerating
-----------------------------

beConsistent
     Prepare the receiver to be walked through with #do: or another
     enumeration method.



File: gst-base.info,  Node: SortedCollection-saving and loading,  Next: SortedCollection-searching,  Prev: SortedCollection-enumerating,  Up: SortedCollection

SortedCollection: saving and loading
------------------------------------

postLoad
     Restore the default sortBlock if it is nil

preStore
     Store the default sortBlock as nil



File: gst-base.info,  Node: SortedCollection-searching,  Prev: SortedCollection-saving and loading,  Up: SortedCollection

SortedCollection: searching
---------------------------

includes: anObject
     Private - Answer whether the receiver includes an item which is
     equal to anObject

indexOf: anObject startingAt: index ifAbsent: aBlock
     Answer the first index > anIndex which contains anElement.  Invoke
     exceptionBlock and answer its result if no item is found

occurrencesOf: anObject
     Answer how many occurrences of anObject can be found in the
     receiver



File: gst-base.info,  Node: Stream,  Next: String,  Prev: SortedCollection,  Up: Base classes

Stream
======

Defined in namespace Smalltalk
Superclass: Object
Category: Streams
     I am an abstract class that provides interruptable sequential
     access to objects.  I can return successive objects from a source,
     or accept successive objects and store them sequentially on a
     sink.  I provide some simple iteration over the contents of one of
     my instances, and provide for writing collections sequentially.

* Menu:

* Stream-accessing-reading::  (instance)
* Stream-accessing-writing::  (instance)
* Stream-basic::  (instance)
* Stream-character writing::  (instance)
* Stream-enumerating::  (instance)
* Stream-filing out::  (instance)
* Stream-positioning::  (instance)
* Stream-printing::  (instance)
* Stream-providing consistent protocols::  (instance)
* Stream-storing::  (instance)
* Stream-testing::  (instance)


File: gst-base.info,  Node: Stream-accessing-reading,  Next: Stream-accessing-writing,  Up: Stream

Stream: accessing-reading
-------------------------

contents
     Answer the whole contents of the receiver, from the next object to
     the last

next
     Return the next object in the receiver

next: anInteger
     Return the next anInteger objects in the receiver

nextAvailable: anInteger
     Return up to anInteger objects in the receiver, stopping if the
     end of the stream is reached

nextLine
     Returns a collection of the same type that the stream accesses, up
     to but not including the object anObject.  Returns the entire rest
     of the stream's contents if anObject is not present.

nextMatchFor: anObject
     Answer whether the next object is equal to anObject. Even if it
     does not, anObject is lost

splitAt: anObject
     Answer an OrderedCollection of parts of the receiver. A new
     (possibly empty) part starts at the start of the receiver, or
     after every occurrence of an object which is equal to anObject (as
     compared by #=).

upTo: anObject
     Returns a collection of the same type that the stream accesses, up
     to but not including the object anObject.  Returns the entire rest
     of the stream's contents if anObject is not present.

upToAll: aCollection
     If there is a sequence of objects remaining in the stream that is
     equal to the sequence in aCollection, set the stream position just
     past that sequence and answer the elements up to, but not
     including, the sequence. Else, set the stream position to its end
     and answer all the remaining elements.

upToEnd
     Answer every item in the collection on which the receiver is
     streaming, from the next one to the last



File: gst-base.info,  Node: Stream-accessing-writing,  Next: Stream-basic,  Prev: Stream-accessing-reading,  Up: Stream

Stream: accessing-writing
-------------------------

next: anInteger put: anObject
     Write anInteger copies of anObject to the receiver

next: n putAll: aCollection startingAt: start
     Write n objects to the stream, reading them from aCollection and
     starting at the start-th item.

nextPut: anObject
     Write anObject to the receiver

nextPutAll: aCollection
     Write all the objects in aCollection to the receiver



File: gst-base.info,  Node: Stream-basic,  Next: Stream-character writing,  Prev: Stream-accessing-writing,  Up: Stream

Stream: basic
-------------

species
     Answer `Array'.



File: gst-base.info,  Node: Stream-character writing,  Next: Stream-enumerating,  Prev: Stream-basic,  Up: Stream

Stream: character writing
-------------------------

cr
     Store a cr on the receiver

crTab
     Store a cr and a tab on the receiver

nl
     Store a new line on the receiver

nlTab
     Store a new line and a tab on the receiver

space
     Store a space on the receiver

space: n
     Store n spaces on the receiver

tab
     Store a tab on the receiver

tab: n
     Store n tabs on the receiver



File: gst-base.info,  Node: Stream-enumerating,  Next: Stream-filing out,  Prev: Stream-character writing,  Up: Stream

Stream: enumerating
-------------------

do: aBlock
     Evaluate aBlock once for every object in the receiver



File: gst-base.info,  Node: Stream-filing out,  Next: Stream-positioning,  Prev: Stream-enumerating,  Up: Stream

Stream: filing out
------------------

fileOut: aClass
     File out aClass on the receiver. If aClass is not a metaclass,
     file out class and instance methods; if aClass is a metaclass,
     file out only the class methods



File: gst-base.info,  Node: Stream-positioning,  Next: Stream-printing,  Prev: Stream-filing out,  Up: Stream

Stream: positioning
-------------------

skip: anInteger
     Move the position forwards by anInteger places

skipTo: anObject
     Move the current position to after the next occurrence of anObject
     and return true if anObject was found.  If anObject doesn't exist,
     the pointer is atEnd, and false is returned.

skipToAll: aCollection
     If there is a sequence of objects remaining in the stream that is
     equal to the sequence in aCollection, set the stream position just
     past that sequence and answer true. Else, set the stream position
     to its end and answer false.



File: gst-base.info,  Node: Stream-printing,  Next: Stream-providing consistent protocols,  Prev: Stream-positioning,  Up: Stream

Stream: printing
----------------

<< anObject
     This method is a short-cut for #display:; it prints anObject on the
     receiver by sending displayOn: to anObject. This method is provided
     so that you can use cascading and obtain better-looking code

display: anObject
     Print anObject on the receiver by sending displayOn: to anObject.
     This method is provided so that you can use cascading and obtain
     better-looking code

print: anObject
     Print anObject on the receiver by sending printOn: to anObject.
     This method is provided so that you can use cascading and obtain
     better-looking code



File: gst-base.info,  Node: Stream-providing consistent protocols,  Next: Stream-storing,  Prev: Stream-printing,  Up: Stream

Stream: providing consistent protocols
--------------------------------------

close
     Do nothing. This is provided for consistency with file streams

flush
     Do nothing. This is provided for consistency with file streams



File: gst-base.info,  Node: Stream-storing,  Next: Stream-testing,  Prev: Stream-providing consistent protocols,  Up: Stream

Stream: storing
---------------

store: anObject
     Print Smalltalk code compiling to anObject on the receiver, by
     sending storeOn: to anObject. This method is provided so that you
     can use cascading and obtain better-looking code



File: gst-base.info,  Node: Stream-testing,  Prev: Stream-storing,  Up: Stream

Stream: testing
---------------

atEnd
     Answer whether the stream has got to an end

isExternalStream
     Answer whether the receiver streams on a file or socket.  By
     default, answer false.



File: gst-base.info,  Node: String,  Next: Symbol,  Prev: Stream,  Up: Base classes

String
======

Defined in namespace Smalltalk
Superclass: CharacterArray
Category: Language-Data types
     My instances represent ASCII string data types.  Being a very
     common case, they are particularly optimized.

* Menu:

* String class-basic::  (class)
* String class-instance creation::  (class)
* String-built ins::  (instance)
* String-converting::  (instance)
* String-storing::  (instance)
* String-testing functionality::  (instance)
* String-useful functionality::  (instance)


File: gst-base.info,  Node: String class-basic,  Next: String class-instance creation,  Up: String

String class: basic
-------------------

, aString
     Answer a new instance of an ArrayedCollection containing all the
     elements in the receiver, followed by all the elements in
     aSequenceableCollection



File: gst-base.info,  Node: String class-instance creation,  Next: String-built ins,  Prev: String class-basic,  Up: String

String class: instance creation
-------------------------------

fromCData: aCObject size: anInteger
     Answer a String containing anInteger bytes starting at the
     location pointed to by aCObject



File: gst-base.info,  Node: String-built ins,  Next: String-converting,  Prev: String class-instance creation,  Up: String

String: built ins
-----------------

asCData: aCType
     Convert the receiver to a CObject with the given type

at: index
     Answer the index-th character of the receiver.

at: index put: value
     Change the index-th character of the receiver.

basicAt: index
     Answer the index-th character of the receiver. This method must
     not be overridden; override at: instead. String overrides it so
     that it looks like it contains character objects even though it
     contains bytes

basicAt: index put: value
     Change the index-th character of the receiver. This method must
     not be overridden; override at: instead. String overrides it so
     that it looks like it contains character objects even though it
     contains bytes

hash
     Answer an hash value for the receiver

primReplaceFrom: start to: stop with: replacementString
     startingAt: replaceStart Private - Replace the characters from
     start to stop with new characters contained in replacementString
     (which, actually, can be any variable byte class, starting at the
     replaceStart location of replacementString

replaceFrom: start to: stop with: aString startingAt: replaceStart
     Replace the characters from start to stop with new characters whose
     ASCII codes are contained in aString, starting at the replaceStart
     location of aString

replaceFrom: start to: stop withByteArray: byteArray startingAt: replaceStart
     Replace the characters from start to stop with new characters whose
     ASCII codes are contained in byteArray, starting at the
     replaceStart location of byteArray

similarityTo: aString
     Answer a number that denotes the similarity between aString and
     the receiver.  0 indicates equality, negative numbers indicate
     some difference.  Implemented as a primitive for speed.

size
     Answer the size of the receiver



File: gst-base.info,  Node: String-converting,  Next: String-storing,  Prev: String-built ins,  Up: String

String: converting
------------------

asByteArray
     Return the receiver, converted to a ByteArray of ASCII values

asString
     But I already am a String!  Really!

asSymbol
     Returns the symbol corresponding to the receiver



File: gst-base.info,  Node: String-storing,  Next: String-testing functionality,  Prev: String-converting,  Up: String

String: storing
---------------

storeOn: aStream
     Print Smalltalk code compiling to the receiver on aStream



File: gst-base.info,  Node: String-testing functionality,  Next: String-useful functionality,  Prev: String-storing,  Up: String

String: testing functionality
-----------------------------

isString
     Answer `true'.



File: gst-base.info,  Node: String-useful functionality,  Prev: String-testing functionality,  Up: String

String: useful functionality
----------------------------

linesDo: aBlock
     Send 'aBlock' a substring of the receiver for each newline
     delimited line in the receiver



File: gst-base.info,  Node: Symbol,  Next: SymLink,  Prev: String,  Up: Base classes

Symbol
======

Defined in namespace Smalltalk
Superclass: String
Category: Language-Implementation
     My instances are unique throughout the Smalltalk system.  My
     instances behave for the most part like strings, except that they
     print differently, and I guarantee that any two instances that
     have the same printed representation are in fact the same instance.

* Menu:

* Symbol class-built ins::  (class)
* Symbol class-instance creation::  (class)
* Symbol class-symbol table::  (class)
* Symbol-basic::  (instance)
* Symbol-built ins::  (instance)
* Symbol-converting::  (instance)
* Symbol-misc::  (instance)
* Symbol-storing::  (instance)
* Symbol-testing::  (instance)
* Symbol-testing functionality::  (instance)


File: gst-base.info,  Node: Symbol class-built ins,  Next: Symbol class-instance creation,  Up: Symbol

Symbol class: built ins
-----------------------

intern: aString
     Private - Same as 'aString asSymbol'



File: gst-base.info,  Node: Symbol class-instance creation,  Next: Symbol class-symbol table,  Prev: Symbol class-built ins,  Up: Symbol

Symbol class: instance creation
-------------------------------

internCharacter: aCharacter
     Answer the one-character symbol associated to the given character.

new
     This method should not be called for instances of this class.

new: size
     This method should not be called for instances of this class.

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



File: gst-base.info,  Node: Symbol class-symbol table,  Next: Symbol-basic,  Prev: Symbol class-instance creation,  Up: Symbol

Symbol class: symbol table
--------------------------

hasInterned: aString ifTrue: aBlock
     If aString has not been interned yet, answer false.  Else, pass the
     interned version to aBlock and answer true.  Note that this works
     because String>>#hash calculates the same hash value used by the
     VM when interning strings into the SymbolTable.  Changing one of
     the hashing methods without changing the other will break this
     method.

isSymbolString: aString
     Answer whether aString has already been interned. Note that this
     works because String>>#hash calculates the same hash value used by
     the VM when interning strings into the SymbolTable.  Changing one
     of the hashing methods without changing the other will break this
     method.

     calculates

rebuildTable
     Rebuild the SymbolTable, thereby garbage-collecting unreferenced
     Symbols.  While this process is done, preemption is disabled
     because it is not acceptable to leave the SymbolTable in a
     partially updated state.  Note that this works because
     String>>#hash calculates the same hash value used by the VM when
     interning strings into the SymbolTable.  Changing one of the
     hashing methods without changing the other will break this method.



File: gst-base.info,  Node: Symbol-basic,  Next: Symbol-built ins,  Prev: Symbol class-symbol table,  Up: Symbol

Symbol: basic
-------------

deepCopy
     Returns a deep copy of the receiver. As Symbols are identity
     objects, we actually return the receiver itself.

keywords
     Answer an array of keywords that compose the receiver, which is
     supposed to be a valid message name (#+, #not, #printOn:,
     #ifTrue:ifFalse:, etc.)

numArgs
     Answer the number of arguments supported by the receiver, which is
     supposed to be a valid message name (#+, #not, #printOn:,
     #ifTrue:ifFalse:, etc.)

shallowCopy
     Returns a deep copy of the receiver. As Symbols are identity
     objects, we actually return the receiver itself.



File: gst-base.info,  Node: Symbol-built ins,  Next: Symbol-converting,  Prev: Symbol-basic,  Up: Symbol

Symbol: built ins
-----------------

= aSymbol
     Answer whether the receiver and aSymbol are the same object

hash
     Answer an hash value for the receiver. Symbols are optimized for
     speed



File: gst-base.info,  Node: Symbol-converting,  Next: Symbol-misc,  Prev: Symbol-built ins,  Up: Symbol

Symbol: converting
------------------

asString
     Answer a String with the same characters as the receiver

asSymbol
     But we are already a Symbol, and furthermore, Symbols are identity
     objects!  So answer the receiver.



File: gst-base.info,  Node: Symbol-misc,  Next: Symbol-storing,  Prev: Symbol-converting,  Up: Symbol

Symbol: misc
------------

species
     Answer `String'.



File: gst-base.info,  Node: Symbol-storing,  Next: Symbol-testing,  Prev: Symbol-misc,  Up: Symbol

Symbol: storing
---------------

displayOn: aStream
     Print a represention of the receiver on aStream. For most objects
     this is simply its #printOn: representation, but for strings and
     characters, superfluous dollars or extra pairs of quotes are
     stripped.

displayString
     Answer a String representing the receiver. For most objects this
     is simply its #printString, but for strings and characters,
     superfluous dollars or extra pair of quotes are stripped.

printOn: aStream
     Print a represention of the receiver on aStream.



File: gst-base.info,  Node: Symbol-testing,  Next: Symbol-testing functionality,  Prev: Symbol-storing,  Up: Symbol

Symbol: testing
---------------

isSimpleSymbol
     Answer whether the receiver must be represented in quoted-string
     (e.g. #'abc-def') form.



File: gst-base.info,  Node: Symbol-testing functionality,  Prev: Symbol-testing,  Up: Symbol

Symbol: testing functionality
-----------------------------

isString
     Answer `false'.

isSymbol
     Answer `true'.



File: gst-base.info,  Node: SymLink,  Next: SystemDictionary,  Prev: Symbol,  Up: Base classes

SymLink
=======

Defined in namespace Smalltalk
Superclass: Link
Category: Language-Implementation
     I am used to implement the Smalltalk symbol table.  My instances
     are links that contain symbols, and the symbol table basically a
     hash table that points to chains of my instances.

* Menu:

* SymLink class-instance creation::  (class)
* SymLink-accessing::  (instance)
* SymLink-iteration::  (instance)
* SymLink-printing::  (instance)


File: gst-base.info,  Node: SymLink class-instance creation,  Next: SymLink-accessing,  Up: SymLink

SymLink class: instance creation
--------------------------------

symbol: aSymbol nextLink: aSymLink
     Answer a new SymLink, which refers to aSymbol and points to
     aSymLink as the next SymLink in the chain.



File: gst-base.info,  Node: SymLink-accessing,  Next: SymLink-iteration,  Prev: SymLink class-instance creation,  Up: SymLink

SymLink: accessing
------------------

symbol
     Answer the Symbol that the receiver refers to in the symbol table.

symbol: aSymbol
     Set the Symbol that the receiver refers to in the symbol table.



File: gst-base.info,  Node: SymLink-iteration,  Next: SymLink-printing,  Prev: SymLink-accessing,  Up: SymLink

SymLink: iteration
------------------

do: aBlock
     Evaluate aBlock for each symbol in the list



File: gst-base.info,  Node: SymLink-printing,  Prev: SymLink-iteration,  Up: SymLink

SymLink: printing
-----------------

printOn: aStream
     Print a representation of the receiver on aStream.



File: gst-base.info,  Node: SystemDictionary,  Next: SystemExceptions.AlreadyDefined,  Prev: SymLink,  Up: Base classes

SystemDictionary
================

Defined in namespace Smalltalk
Superclass: RootNamespace
Category: Language-Implementation
     I am a special namespace. I only have one instance, called
     "Smalltalk", which is known to the Smalltalk interpreter.  I define
     several methods that are "system" related, such as #quitPrimitive.
     My instance also helps keep track of dependencies between objects.

* Menu:

* SystemDictionary-basic::  (instance)
* SystemDictionary-builtins::  (instance)
* SystemDictionary-C functions::  (instance)
* SystemDictionary-miscellaneous::  (instance)
* SystemDictionary-printing::  (instance)
* SystemDictionary-special accessing::  (instance)


File: gst-base.info,  Node: SystemDictionary-basic,  Next: SystemDictionary-builtins,  Up: SystemDictionary

SystemDictionary: basic
-----------------------

halt
     Interrupt interpreter

hash
     Smalltalk usually contains a reference to itself, avoid infinite
     loops



File: gst-base.info,  Node: SystemDictionary-builtins,  Next: SystemDictionary-C functions,  Prev: SystemDictionary-basic,  Up: SystemDictionary

SystemDictionary: builtins
--------------------------

basicBacktrace
     Prints the method invocation stack backtrace, as an aid to
     debugging

byteCodeCounter
     Answer the number of bytecodes executed by the VM

debug
     This methods provides a way to break in the VM code.  Set a
     breakpoint in _gst_debug and call this method near the point where
     you think the bug happens.

declarationTrace
     Answer whether compiled bytecodes are printed on stdout

declarationTrace: aBoolean
     Set whether compiled bytecodes are printed on stdout

executionTrace
     Answer whether executed bytecodes are printed on stdout

executionTrace: aBoolean
     Set whether executed bytecodes are printed on stdout

getTraceFlag: anIndex
     Private - Returns a boolean value which is one of the interpreter's
     tracing flags

setTraceFlag: anIndex to: aBoolean
     Private - Sets the value of one of the interpreter's tracing flags
     (indicated by 'anIndex') to the value aBoolean.

verboseTrace
     Answer whether execution tracing prints the object on the stack top

verboseTrace: aBoolean
     Set whether execution tracing prints the object on the stack top



File: gst-base.info,  Node: SystemDictionary-C functions,  Next: SystemDictionary-miscellaneous,  Prev: SystemDictionary-builtins,  Up: SystemDictionary

SystemDictionary: C functions
-----------------------------

getArgc
     C call-out to getArgc. Do not modify!

getArgv: index
     C call-out to getArgv. Do not modify!

getenv: aString
     C call-out to getenv. Do not modify!

putenv: aString
     C call-out to putenv. Do not modify!

system: aString
     C call-out to system. Do not modify!



File: gst-base.info,  Node: SystemDictionary-miscellaneous,  Next: SystemDictionary-printing,  Prev: SystemDictionary-C functions,  Up: SystemDictionary

SystemDictionary: miscellaneous
-------------------------------

arguments
     Return the command line arguments after the -a switch

backtrace
     Print a backtrace on the Transcript.



File: gst-base.info,  Node: SystemDictionary-printing,  Next: SystemDictionary-special accessing,  Prev: SystemDictionary-miscellaneous,  Up: SystemDictionary

SystemDictionary: printing
--------------------------

nameIn: aNamespace
     Answer `'Smalltalk".

printOn: aStream in: aNamespace
     Store Smalltalk code compiling to the receiver

storeOn: aStream
     Store Smalltalk code compiling to the receiver



File: gst-base.info,  Node: SystemDictionary-special accessing,  Prev: SystemDictionary-printing,  Up: SystemDictionary

SystemDictionary: special accessing
-----------------------------------

addFeature: aFeature
     Add the aFeature feature to the Features set

hasFeatures: features
     Returns true if the feature or features in 'features' is one of the
     implementation dependent features present

removeFeature: aFeature
     Remove the aFeature feature to the Features set

version
     Answer the current version of the GNU Smalltalk environment



File: gst-base.info,  Node: SystemExceptions.AlreadyDefined,  Next: SystemExceptions.ArgumentOutOfRange,  Prev: SystemDictionary,  Up: Base classes

SystemExceptions.AlreadyDefined
===============================

Defined in namespace Smalltalk.SystemExceptions
Superclass: SystemExceptions.InvalidArgument
Category: Language-Exceptions
     I am raised when one tries to define a symbol (class or pool
     variable) that is already defined.

* Menu:

* SystemExceptions.AlreadyDefined-accessing::  (instance)


File: gst-base.info,  Node: SystemExceptions.AlreadyDefined-accessing,  Up: SystemExceptions.AlreadyDefined

SystemExceptions.AlreadyDefined: accessing
------------------------------------------

description
     Answer a description for the error



File: gst-base.info,  Node: SystemExceptions.ArgumentOutOfRange,  Next: SystemExceptions.BadReturn,  Prev: SystemExceptions.AlreadyDefined,  Up: Base classes

SystemExceptions.ArgumentOutOfRange
===================================

Defined in namespace Smalltalk.SystemExceptions
Superclass: SystemExceptions.InvalidArgument
Category: Language-Exceptions
     I am raised when one invokes a method with an argument outside of
     its valid range.

* Menu:

* SystemExceptions.ArgumentOutOfRange class-signaling::  (class)
* SystemExceptions.ArgumentOutOfRange-accessing::  (instance)


File: gst-base.info,  Node: SystemExceptions.ArgumentOutOfRange class-signaling,  Next: SystemExceptions.ArgumentOutOfRange-accessing,  Up: SystemExceptions.ArgumentOutOfRange

SystemExceptions.ArgumentOutOfRange class: signaling
----------------------------------------------------

signalOn: value mustBeBetween: low and: high
     Raise the exception.  The given value was not between low and high.



File: gst-base.info,  Node: SystemExceptions.ArgumentOutOfRange-accessing,  Prev: SystemExceptions.ArgumentOutOfRange class-signaling,  Up: SystemExceptions.ArgumentOutOfRange

SystemExceptions.ArgumentOutOfRange: accessing
----------------------------------------------

description
     Answer a textual description of the exception.

high
     Answer the highest value that was permitted.

high: aMagnitude
     Set the highest value that was permitted.

low
     Answer the lowest value that was permitted.

low: aMagnitude
     Set the lowest value that was permitted.



File: gst-base.info,  Node: SystemExceptions.BadReturn,  Next: SystemExceptions.CInterfaceError,  Prev: SystemExceptions.ArgumentOutOfRange,  Up: Base classes

SystemExceptions.BadReturn
==========================

Defined in namespace Smalltalk.SystemExceptions
Superclass: SystemExceptions.VMError
Category: Language-Exceptions
     I am raised when one tries to return from an already-terminated
     method.

* Menu:

* SystemExceptions.BadReturn-accessing::  (instance)


File: gst-base.info,  Node: SystemExceptions.BadReturn-accessing,  Up: SystemExceptions.BadReturn

SystemExceptions.BadReturn: accessing
-------------------------------------

description
     Answer a textual description of the exception.



File: gst-base.info,  Node: SystemExceptions.CInterfaceError,  Next: SystemExceptions.EmptyCollection,  Prev: SystemExceptions.BadReturn,  Up: Base classes

SystemExceptions.CInterfaceError
================================

Defined in namespace Smalltalk.SystemExceptions
Superclass: SystemExceptions.PrimitiveFailed
Category: Language-Exceptions
     I am raised when an error happens that is related to the C
     interface.

* Menu:

* SystemExceptions.CInterfaceError-accessing::  (instance)


File: gst-base.info,  Node: SystemExceptions.CInterfaceError-accessing,  Up: SystemExceptions.CInterfaceError

SystemExceptions.CInterfaceError: accessing
-------------------------------------------

description
     Answer a textual description of the exception.



File: gst-base.info,  Node: SystemExceptions.EmptyCollection,  Next: SystemExceptions.EndOfStream,  Prev: SystemExceptions.CInterfaceError,  Up: Base classes

SystemExceptions.EmptyCollection
================================

Defined in namespace Smalltalk.SystemExceptions
Superclass: SystemExceptions.InvalidValue
Category: Language-Exceptions
     I am raised when one invokes a method on an empty collection.

* Menu:

* SystemExceptions.EmptyCollection-accessing::  (instance)


File: gst-base.info,  Node: SystemExceptions.EmptyCollection-accessing,  Up: SystemExceptions.EmptyCollection

SystemExceptions.EmptyCollection: accessing
-------------------------------------------

description
     Answer a textual description of the exception.



File: gst-base.info,  Node: SystemExceptions.EndOfStream,  Next: SystemExceptions.FileError,  Prev: SystemExceptions.EmptyCollection,  Up: Base classes

SystemExceptions.EndOfStream
============================

Defined in namespace Smalltalk.SystemExceptions
Superclass: Notification
Category: Language-Exceptions
     I am raised when a stream reaches its end.

* Menu:

* SystemExceptions.EndOfStream class-signaling::  (class)
* SystemExceptions.EndOfStream-accessing::  (instance)


File: gst-base.info,  Node: SystemExceptions.EndOfStream class-signaling,  Next: SystemExceptions.EndOfStream-accessing,  Up: SystemExceptions.EndOfStream

SystemExceptions.EndOfStream class: signaling
---------------------------------------------

signalOn: stream
     Answer an exception reporting the parameter has reached its end.



File: gst-base.info,  Node: SystemExceptions.EndOfStream-accessing,  Prev: SystemExceptions.EndOfStream class-signaling,  Up: SystemExceptions.EndOfStream

SystemExceptions.EndOfStream: accessing
---------------------------------------

description
     Answer a textual description of the exception.

stream
     Answer the stream whose end was reached.

stream: anObject
     Set the stream whose end was reached.



File: gst-base.info,  Node: SystemExceptions.FileError,  Next: SystemExceptions.IndexOutOfRange,  Prev: SystemExceptions.EndOfStream,  Up: Base classes

SystemExceptions.FileError
==========================

Defined in namespace Smalltalk.SystemExceptions
Superclass: SystemExceptions.PrimitiveFailed
Category: Language-Exceptions
     I am raised when an error happens that is related to the file
     system.

* Menu:

* SystemExceptions.FileError-accessing::  (instance)


File: gst-base.info,  Node: SystemExceptions.FileError-accessing,  Up: SystemExceptions.FileError

SystemExceptions.FileError: accessing
-------------------------------------

description
     Answer a textual description of the exception.



File: gst-base.info,  Node: SystemExceptions.IndexOutOfRange,  Next: SystemExceptions.InvalidArgument,  Prev: SystemExceptions.FileError,  Up: Base classes

SystemExceptions.IndexOutOfRange
================================

Defined in namespace Smalltalk.SystemExceptions
Superclass: SystemExceptions.ArgumentOutOfRange
Category: Language-Exceptions
     I am raised when one invokes am accessor method with an index
     outside of its valid range.

* Menu:

* SystemExceptions.IndexOutOfRange class-signaling::  (class)
* SystemExceptions.IndexOutOfRange-accessing::  (instance)


File: gst-base.info,  Node: SystemExceptions.IndexOutOfRange class-signaling,  Next: SystemExceptions.IndexOutOfRange-accessing,  Up: SystemExceptions.IndexOutOfRange

SystemExceptions.IndexOutOfRange class: signaling
-------------------------------------------------

signalOn: aCollection withIndex: value
     The given index was out of range in aCollection.



File: gst-base.info,  Node: SystemExceptions.IndexOutOfRange-accessing,  Prev: SystemExceptions.IndexOutOfRange class-signaling,  Up: SystemExceptions.IndexOutOfRange

SystemExceptions.IndexOutOfRange: accessing
-------------------------------------------

collection
     Answer the collection that triggered the error

collection: anObject
     Set the collection that triggered the error

description
     Answer a textual description of the exception.

messageText
     Answer an exception's message text.



File: gst-base.info,  Node: SystemExceptions.InvalidArgument,  Next: SystemExceptions.InvalidProcessState,  Prev: SystemExceptions.IndexOutOfRange,  Up: Base classes

SystemExceptions.InvalidArgument
================================

Defined in namespace Smalltalk.SystemExceptions
Superclass: SystemExceptions.InvalidValue
Category: Language-Exceptions
     I am raised when one invokes a method with an invalid argument.

* Menu:

* SystemExceptions.InvalidArgument-accessing::  (instance)


File: gst-base.info,  Node: SystemExceptions.InvalidArgument-accessing,  Up: SystemExceptions.InvalidArgument

SystemExceptions.InvalidArgument: accessing
-------------------------------------------

messageText
     Answer an exception's message text.



File: gst-base.info,  Node: SystemExceptions.InvalidProcessState,  Next: SystemExceptions.InvalidSize,  Prev: SystemExceptions.InvalidArgument,  Up: Base classes

SystemExceptions.InvalidProcessState
====================================

Defined in namespace Smalltalk.SystemExceptions
Superclass: SystemExceptions.InvalidValue
Category: Language-Exceptions
     I am an error raised when trying to resume a terminated process, or
     stuff like that.

* Menu:

* SystemExceptions.InvalidProcessState-accessing::  (instance)


File: gst-base.info,  Node: SystemExceptions.InvalidProcessState-accessing,  Up: SystemExceptions.InvalidProcessState

SystemExceptions.InvalidProcessState: accessing
-----------------------------------------------

description
     Answer a textual description of the exception.



File: gst-base.info,  Node: SystemExceptions.InvalidSize,  Next: SystemExceptions.InvalidValue,  Prev: SystemExceptions.InvalidProcessState,  Up: Base classes

SystemExceptions.InvalidSize
============================

Defined in namespace Smalltalk.SystemExceptions
Superclass: SystemExceptions.InvalidArgument
Category: Language-Exceptions
     I am raised when an argument has an invalid size.

* Menu:

* SystemExceptions.InvalidSize-accessing::  (instance)


File: gst-base.info,  Node: SystemExceptions.InvalidSize-accessing,  Up: SystemExceptions.InvalidSize

SystemExceptions.InvalidSize: accessing
---------------------------------------

description
     Answer a textual description of the exception.



File: gst-base.info,  Node: SystemExceptions.InvalidValue,  Next: SystemExceptions.MustBeBoolean,  Prev: SystemExceptions.InvalidSize,  Up: Base classes

SystemExceptions.InvalidValue
=============================

Defined in namespace Smalltalk.SystemExceptions
Superclass: Error
Category: Language-Exceptions
     I am raised when one invokes a method with an invalid argument.

* Menu:

* SystemExceptions.InvalidValue class-signaling::  (class)
* SystemExceptions.InvalidValue-accessing::  (instance)


File: gst-base.info,  Node: SystemExceptions.InvalidValue class-signaling,  Next: SystemExceptions.InvalidValue-accessing,  Up: SystemExceptions.InvalidValue

SystemExceptions.InvalidValue class: signaling
----------------------------------------------

signalOn: value
     Answer an exception reporting the parameter as invalid.

signalOn: value reason: reason
     Answer an exception reporting `value' as invalid, for the given
     reason.



File: gst-base.info,  Node: SystemExceptions.InvalidValue-accessing,  Prev: SystemExceptions.InvalidValue class-signaling,  Up: SystemExceptions.InvalidValue

SystemExceptions.InvalidValue: accessing
----------------------------------------

description
     Answer a textual description of the exception.

messageText
     Answer an exception's message text.

value
     Answer the object that was found to be invalid.

value: anObject
     Set the object that was found to be invalid.



File: gst-base.info,  Node: SystemExceptions.MustBeBoolean,  Next: SystemExceptions.MutationError,  Prev: SystemExceptions.InvalidValue,  Up: Base classes

SystemExceptions.MustBeBoolean
==============================

Defined in namespace Smalltalk.SystemExceptions
Superclass: SystemExceptions.InvalidValue
Category: Language-Exceptions
     I am raised when one invokes a boolean method on a non-boolean.

* Menu:


File: gst-base.info,  Node: SystemExceptions.MutationError,  Next: SystemExceptions.NoRunnableProcess,  Prev: SystemExceptions.MustBeBoolean,  Up: Base classes

SystemExceptions.MutationError
==============================

Defined in namespace Smalltalk.SystemExceptions
Superclass: Error
Category: Language-Exceptions
     I am an error raised when a class is mutated in an invalid way.

* Menu:

* SystemExceptions.MutationError-accessing::  (instance)


File: gst-base.info,  Node: SystemExceptions.MutationError-accessing,  Up: SystemExceptions.MutationError

SystemExceptions.MutationError: accessing
-----------------------------------------

description
     Answer a textual description of the exception.



File: gst-base.info,  Node: SystemExceptions.NoRunnableProcess,  Next: SystemExceptions.NotFound,  Prev: SystemExceptions.MutationError,  Up: Base classes

SystemExceptions.NoRunnableProcess
==================================

Defined in namespace Smalltalk.SystemExceptions
Superclass: SystemExceptions.VMError
Category: Language-Exceptions
     I am raised when no runnable process can be found in the image.

* Menu:

* SystemExceptions.NoRunnableProcess-accessing::  (instance)


File: gst-base.info,  Node: SystemExceptions.NoRunnableProcess-accessing,  Up: SystemExceptions.NoRunnableProcess

SystemExceptions.NoRunnableProcess: accessing
---------------------------------------------

description
     Answer a textual description of the exception.



File: gst-base.info,  Node: SystemExceptions.NotFound,  Next: SystemExceptions.NotImplemented,  Prev: SystemExceptions.NoRunnableProcess,  Up: Base classes

SystemExceptions.NotFound
=========================

Defined in namespace Smalltalk.SystemExceptions
Superclass: SystemExceptions.InvalidArgument
Category: Language-Exceptions
     I am raised when something is searched without success.

* Menu:

* SystemExceptions.NotFound class-accessing::  (class)
* SystemExceptions.NotFound-accessing::  (instance)


File: gst-base.info,  Node: SystemExceptions.NotFound class-accessing,  Next: SystemExceptions.NotFound-accessing,  Up: SystemExceptions.NotFound

SystemExceptions.NotFound class: accessing
------------------------------------------

signalOn: value what: aString
     Raise an exception; aString specifies what was not found (a key,
     an object, a class, and so on).



File: gst-base.info,  Node: SystemExceptions.NotFound-accessing,  Prev: SystemExceptions.NotFound class-accessing,  Up: SystemExceptions.NotFound

SystemExceptions.NotFound: accessing
------------------------------------

description
     Answer a textual description of the exception.



File: gst-base.info,  Node: SystemExceptions.NotImplemented,  Next: SystemExceptions.NotIndexable,  Prev: SystemExceptions.NotFound,  Up: Base classes

SystemExceptions.NotImplemented
===============================

Defined in namespace Smalltalk.SystemExceptions
Superclass: Error
Category: Language-Exceptions
     I am raised when a method is called that has not been implemented.

* Menu:

* SystemExceptions.NotImplemented-accessing::  (instance)


File: gst-base.info,  Node: SystemExceptions.NotImplemented-accessing,  Up: SystemExceptions.NotImplemented

SystemExceptions.NotImplemented: accessing
------------------------------------------

description
     Answer a textual description of the exception.



File: gst-base.info,  Node: SystemExceptions.NotIndexable,  Next: SystemExceptions.NotYetImplemented,  Prev: SystemExceptions.NotImplemented,  Up: Base classes

SystemExceptions.NotIndexable
=============================

Defined in namespace Smalltalk.SystemExceptions
Superclass: SystemExceptions.InvalidValue
Category: Language-Exceptions
     I am raised when an object is not indexable.

* Menu:

* SystemExceptions.NotIndexable-accessing::  (instance)


File: gst-base.info,  Node: SystemExceptions.NotIndexable-accessing,  Up: SystemExceptions.NotIndexable

SystemExceptions.NotIndexable: accessing
----------------------------------------

description
     Answer a textual description of the exception.



File: gst-base.info,  Node: SystemExceptions.NotYetImplemented,  Next: SystemExceptions.PrimitiveFailed,  Prev: SystemExceptions.NotIndexable,  Up: Base classes

SystemExceptions.NotYetImplemented
==================================

Defined in namespace Smalltalk.SystemExceptions
Superclass: SystemExceptions.NotImplemented
Category: Language-Exceptions
     I am raised when a method is called that has not been implemented
     yet.

* Menu:

* SystemExceptions.NotYetImplemented-accessing::  (instance)


File: gst-base.info,  Node: SystemExceptions.NotYetImplemented-accessing,  Up: SystemExceptions.NotYetImplemented

SystemExceptions.NotYetImplemented: accessing
---------------------------------------------

description
     Answer a textual description of the exception.



File: gst-base.info,  Node: SystemExceptions.PrimitiveFailed,  Next: SystemExceptions.ProcessBeingTerminated,  Prev: SystemExceptions.NotYetImplemented,  Up: Base classes

SystemExceptions.PrimitiveFailed
================================

Defined in namespace Smalltalk.SystemExceptions
Superclass: SystemExceptions.VMError
Category: Language-Exceptions
     I am raised when a primitive fails for some reason.

* Menu:

* SystemExceptions.PrimitiveFailed-accessing::  (instance)


File: gst-base.info,  Node: SystemExceptions.PrimitiveFailed-accessing,  Up: SystemExceptions.PrimitiveFailed

SystemExceptions.PrimitiveFailed: accessing
-------------------------------------------

description
     Answer a textual description of the exception.



File: gst-base.info,  Node: SystemExceptions.ProcessBeingTerminated,  Next: SystemExceptions.ProcessTerminated,  Prev: SystemExceptions.PrimitiveFailed,  Up: Base classes

SystemExceptions.ProcessBeingTerminated
=======================================

Defined in namespace Smalltalk.SystemExceptions
Superclass: Notification
Category: Language-Exceptions

* Menu:

* SystemExceptions.ProcessBeingTerminated-accessing::  (instance)


File: gst-base.info,  Node: SystemExceptions.ProcessBeingTerminated-accessing,  Up: SystemExceptions.ProcessBeingTerminated

SystemExceptions.ProcessBeingTerminated: accessing
--------------------------------------------------

description
     Answer a textual description of the exception.



File: gst-base.info,  Node: SystemExceptions.ProcessTerminated,  Next: SystemExceptions.ReadOnlyObject,  Prev: SystemExceptions.ProcessBeingTerminated,  Up: Base classes

SystemExceptions.ProcessTerminated
==================================

Defined in namespace Smalltalk.SystemExceptions
Superclass: SystemExceptions.InvalidValue
Category: Language-Exceptions
     I am raised when somebody tries to resume or interrupt a
     terminated process.

* Menu:

* SystemExceptions.ProcessTerminated-accessing::  (instance)


File: gst-base.info,  Node: SystemExceptions.ProcessTerminated-accessing,  Up: SystemExceptions.ProcessTerminated

SystemExceptions.ProcessTerminated: accessing
---------------------------------------------

description
     Answer a textual description of the exception.



File: gst-base.info,  Node: SystemExceptions.ReadOnlyObject,  Next: SystemExceptions.ShouldNotImplement,  Prev: SystemExceptions.ProcessTerminated,  Up: Base classes

SystemExceptions.ReadOnlyObject
===============================

Defined in namespace Smalltalk.SystemExceptions
Superclass: SystemExceptions.InvalidValue
Category: Language-Exceptions
     I am raised when one writes to a read-only object.

* Menu:

* SystemExceptions.ReadOnlyObject-accessing::  (instance)


File: gst-base.info,  Node: SystemExceptions.ReadOnlyObject-accessing,  Up: SystemExceptions.ReadOnlyObject

SystemExceptions.ReadOnlyObject: accessing
------------------------------------------

description
     Answer a textual description of the exception.



File: gst-base.info,  Node: SystemExceptions.ShouldNotImplement,  Next: SystemExceptions.SubclassResponsibility,  Prev: SystemExceptions.ReadOnlyObject,  Up: Base classes

SystemExceptions.ShouldNotImplement
===================================

Defined in namespace Smalltalk.SystemExceptions
Superclass: SystemExceptions.NotImplemented
Category: Language-Exceptions
     I am raised when a method is called that a class wishes that is not
     called.

* Menu:

* SystemExceptions.ShouldNotImplement-accessing::  (instance)


File: gst-base.info,  Node: SystemExceptions.ShouldNotImplement-accessing,  Up: SystemExceptions.ShouldNotImplement

SystemExceptions.ShouldNotImplement: accessing
----------------------------------------------

description
     Answer a textual description of the exception.



File: gst-base.info,  Node: SystemExceptions.SubclassResponsibility,  Next: SystemExceptions.UserInterrupt,  Prev: SystemExceptions.ShouldNotImplement,  Up: Base classes

SystemExceptions.SubclassResponsibility
=======================================

Defined in namespace Smalltalk.SystemExceptions
Superclass: SystemExceptions.ShouldNotImplement
Category: Language-Exceptions
     I am raised when a method is called whose implementation is the
     responsibility of concrete subclass.

* Menu:

* SystemExceptions.SubclassResponsibility-accessing::  (instance)


File: gst-base.info,  Node: SystemExceptions.SubclassResponsibility-accessing,  Up: SystemExceptions.SubclassResponsibility

SystemExceptions.SubclassResponsibility: accessing
--------------------------------------------------

description
     Answer a textual description of the exception.



File: gst-base.info,  Node: SystemExceptions.UserInterrupt,  Next: SystemExceptions.VMError,  Prev: SystemExceptions.SubclassResponsibility,  Up: Base classes

SystemExceptions.UserInterrupt
==============================

Defined in namespace Smalltalk.SystemExceptions
Superclass: SystemExceptions.VMError
Category: Language-Exceptions
     I am raised when one presses Ctrl-C.

* Menu:

* SystemExceptions.UserInterrupt-accessing::  (instance)


File: gst-base.info,  Node: SystemExceptions.UserInterrupt-accessing,  Up: SystemExceptions.UserInterrupt

SystemExceptions.UserInterrupt: accessing
-----------------------------------------

description
     Answer a textual description of the exception.



File: gst-base.info,  Node: SystemExceptions.VMError,  Next: SystemExceptions.WrongArgumentCount,  Prev: SystemExceptions.UserInterrupt,  Up: Base classes

SystemExceptions.VMError
========================

Defined in namespace Smalltalk.SystemExceptions
Superclass: Error
Category: Language-Exceptions
     I am an error related to the innards of the system.

* Menu:

* SystemExceptions.VMError-accessing::  (instance)


File: gst-base.info,  Node: SystemExceptions.VMError-accessing,  Up: SystemExceptions.VMError

SystemExceptions.VMError: accessing
-----------------------------------

description
     Answer a textual description of the exception.



File: gst-base.info,  Node: SystemExceptions.WrongArgumentCount,  Next: SystemExceptions.WrongClass,  Prev: SystemExceptions.VMError,  Up: Base classes

SystemExceptions.WrongArgumentCount
===================================

Defined in namespace Smalltalk.SystemExceptions
Superclass: SystemExceptions.PrimitiveFailed
Category: Language-Exceptions
     I am raised when one tries to evaluate a method (via #perform:...)
     or a block but passes the wrong number of arguments.

* Menu:

* SystemExceptions.WrongArgumentCount-accessing::  (instance)


File: gst-base.info,  Node: SystemExceptions.WrongArgumentCount-accessing,  Up: SystemExceptions.WrongArgumentCount

SystemExceptions.WrongArgumentCount: accessing
----------------------------------------------

description
     Answer a textual description of the exception.



File: gst-base.info,  Node: SystemExceptions.WrongClass,  Next: SystemExceptions.WrongMessageSent,  Prev: SystemExceptions.WrongArgumentCount,  Up: Base classes

SystemExceptions.WrongClass
===========================

Defined in namespace Smalltalk.SystemExceptions
Superclass: SystemExceptions.InvalidValue
Category: Language-Exceptions
     I am raised when an argument is constrained to be an instance of a
     determinate class, and this constraint is not respected by the
     caller.

* Menu:

* SystemExceptions.WrongClass class-signaling::  (class)
* SystemExceptions.WrongClass-accessing::  (instance)


File: gst-base.info,  Node: SystemExceptions.WrongClass class-signaling,  Next: SystemExceptions.WrongClass-accessing,  Up: SystemExceptions.WrongClass

SystemExceptions.WrongClass class: signaling
--------------------------------------------

signalOn: anObject mustBe: aClassOrArray
     Raise an exception.  The given object should have been an instance
     of one of the classes indicated by aClassOrArray (which should be
     a single class or an array of classes).  Whether instances of
     subclasses are allowed should be clear from the context, though in
     general (i.e. with the exception of a few system messages) they
     should be.



File: gst-base.info,  Node: SystemExceptions.WrongClass-accessing,  Prev: SystemExceptions.WrongClass class-signaling,  Up: SystemExceptions.WrongClass

SystemExceptions.WrongClass: accessing
--------------------------------------

description
     Answer a textual description of the exception.

messageText
     Answer an exception's message text.

validClasses
     Answer the list of classes whose instances would have been valid.

validClasses: aCollection
     Set the list of classes whose instances would have been valid.

validClassesString
     Answer the list of classes whose instances would have been valid,
     formatted as a string.



File: gst-base.info,  Node: SystemExceptions.WrongMessageSent,  Next: TextCollector,  Prev: SystemExceptions.WrongClass,  Up: Base classes

SystemExceptions.WrongMessageSent
=================================

Defined in namespace Smalltalk.SystemExceptions
Superclass: SystemExceptions.ShouldNotImplement
Category: Language-Exceptions
     I am raised when a method is called that a class wishes that is not
     called.  This exception also includes a suggestion on which message
     should be sent instead

* Menu:

* SystemExceptions.WrongMessageSent class-signaling::  (class)
* SystemExceptions.WrongMessageSent-accessing::  (instance)


File: gst-base.info,  Node: SystemExceptions.WrongMessageSent class-signaling,  Next: SystemExceptions.WrongMessageSent-accessing,  Up: SystemExceptions.WrongMessageSent

SystemExceptions.WrongMessageSent class: signaling
--------------------------------------------------

signalOn: selector useInstead: aSymbol
     Raise an exception, signaling which selector was sent and
     suggesting a valid alternative.



File: gst-base.info,  Node: SystemExceptions.WrongMessageSent-accessing,  Prev: SystemExceptions.WrongMessageSent class-signaling,  Up: SystemExceptions.WrongMessageSent

SystemExceptions.WrongMessageSent: accessing
--------------------------------------------

messageText
     Answer an exception's message text.

selector
     Answer which selector was sent.

selector: aSymbol
     Set which selector was sent.

suggestedSelector
     Answer a valid alternative to the selector that was used.

suggestedSelector: aSymbol
     Set a valid alternative to the selector that was used.



File: gst-base.info,  Node: TextCollector,  Next: Time,  Prev: SystemExceptions.WrongMessageSent,  Up: Base classes

TextCollector
=============

Defined in namespace Smalltalk
Superclass: Stream
Category: Streams
     I am a thread-safe class that maps between standard Stream
     protocol and a single message to another object (its selector is
     pluggable and should roughly correspond to #nextPutAll:).  I am,
     in fact, the class that implements the global Transcript object.

* Menu:

* TextCollector class-accessing::  (class)
* TextCollector-accessing::  (instance)
* TextCollector-printing::  (instance)
* TextCollector-set up::  (instance)
* TextCollector-storing::  (instance)


File: gst-base.info,  Node: TextCollector class-accessing,  Next: TextCollector-accessing,  Up: TextCollector

TextCollector class: accessing
------------------------------

message: receiverToSelectorAssociation
     Answer a new instance of the receiver, that uses the message
     identified by anAssociation to perform write operations.
     anAssociation's key is the receiver, while its value is the
     selector.

new
     This method should not be called for instances of this class.



File: gst-base.info,  Node: TextCollector-accessing,  Next: TextCollector-printing,  Prev: TextCollector class-accessing,  Up: TextCollector

TextCollector: accessing
------------------------

cr
     Emit a new-line (carriage return) to the Transcript

endEntry
     Emit two new-lines.  This method is present for compatibility with
     VisualWorks.

next: anInteger put: anObject
     Write anInteger copies of anObject to the Transcript

nextPut: aCharacter
     Emit aCharacter to the Transcript

nextPutAll: aString
     Write aString to the Transcript

show: aString
     Write aString to the Transcript

showCr: aString
     Write aString to the Transcript, followed by a new-line character

showOnNewLine: aString
     Write aString to the Transcript, preceded by a new-line character



File: gst-base.info,  Node: TextCollector-printing,  Next: TextCollector-set up,  Prev: TextCollector-accessing,  Up: TextCollector

TextCollector: printing
-----------------------

print: anObject
     Print anObject's representation to the Transcript

printOn: aStream
     Print a representation of the receiver onto aStream



File: gst-base.info,  Node: TextCollector-set up,  Next: TextCollector-storing,  Prev: TextCollector-printing,  Up: TextCollector

TextCollector: set up
---------------------

message
     Answer an association representing the message to be sent to
     perform write operations.  The key is the receiver, the value is
     the selector

message: receiverToSelectorAssociation
     Set the message to be sent to perform write operations to the one
     represented by anAssociation.  anAssociation's key is the
     receiver, while its value is the selector



File: gst-base.info,  Node: TextCollector-storing,  Prev: TextCollector-set up,  Up: TextCollector

TextCollector: storing
----------------------

store: anObject
     Print Smalltalk code which evaluates to anObject on the Transcript

storeOn: aStream
     Print Smalltalk code which evaluates to the receiver onto aStream



File: gst-base.info,  Node: Time,  Next: TokenStream,  Prev: TextCollector,  Up: Base classes

Time
====

Defined in namespace Smalltalk
Superclass: Magnitude
Category: Language-Data types
     My instances represent times of the day.  I provide methods for
     instance creation, methods that access components (hours, minutes,
     and seconds) of a time value, and a block execution timing
     facility.

* Menu:

* Time class-basic (UTC)::  (class)
* Time class-builtins::  (class)
* Time class-clocks::  (class)
* Time class-initialization::  (class)
* Time class-instance creation::  (class)
* Time-accessing (ANSI for DateAndTimes)::  (instance)
* Time-accessing (non ANSI & for Durations)::  (instance)
* Time-arithmetic::  (instance)
* Time-comparing::  (instance)


File: gst-base.info,  Node: Time class-basic (UTC),  Next: Time class-builtins,  Up: Time

Time class: basic (UTC)
-----------------------

utcNow
     Answer a time representing the current time of day in Coordinated
     Universal Time (UTC)

utcSecondClock
     Answer the number of seconds since the midnight of 1/1/1901 (unlike
     #secondClock, the reference time is here expressed as UTC, that is
     as Coordinated Universal Time).



File: gst-base.info,  Node: Time class-builtins,  Next: Time class-clocks,  Prev: Time class-basic (UTC),  Up: Time

Time class: builtins
--------------------

primMillisecondClock
     Returns the number of milliseconds since midnight.

primSecondClock
     Returns the number of seconds to/from 1/1/2000.

timezone
     Answer a String associated with the current timezone (either
     standard or daylight-saving) on this operating system. For
     example, the answer could be `EST' to indicate Eastern Standard
     Time; the answer can be empty and can't be assumed to be a
     three-character code such as `EST'.

timezoneBias
     Specifies the current bias, in minutes, for local time translation
     for the current time. The bias is the difference, in seconds,
     between Coordinated Universal Time (UTC) and local time; a
     positive bias indicates that the local timezone is to the east of
     Greenwich (e.g.  Europe, Asia), while a negative bias indicates
     that it is to the west (e.g. America)



File: gst-base.info,  Node: Time class-clocks,  Next: Time class-initialization,  Prev: Time class-builtins,  Up: Time

Time class: clocks
------------------

millisecondClock
     Answer the number of milliseconds since startup.

millisecondClockValue
     Answer the number of milliseconds since startup

millisecondsPerDay
     Answer the number of milliseconds in a day

millisecondsToRun: timedBlock
     Answer the number of milliseconds which timedBlock took to run

secondClock
     Answer the number of seconds since the midnight of 1/1/1901



File: gst-base.info,  Node: Time class-initialization,  Next: Time class-instance creation,  Prev: Time class-clocks,  Up: Time

Time class: initialization
--------------------------

initialize
     Initialize the Time class after the image has been bootstrapped

update: aspect
     Private - Initialize the receiver's instance variables



File: gst-base.info,  Node: Time class-instance creation,  Next: Time-accessing (ANSI for DateAndTimes),  Prev: Time class-initialization,  Up: Time

Time class: instance creation
-----------------------------

fromSeconds: secondCount
     Answer a Time representing secondCount seconds past midnight

hours: h
     Answer a Time that is the given number of hours past midnight

hours: h minutes: m seconds: s
     Answer a Time that is the given number of hours, minutes and
     seconds past midnight

minutes: m
     Answer a Time that is the given number of minutes past midnight

new
     Answer a Time representing midnight

now
     Answer a time representing the current time of day

readFrom: aStream
     Parse an instance of the receiver (hours/minutes/seconds) from
     aStream

seconds: s
     Answer a Time that is the given number of seconds past midnight



File: gst-base.info,  Node: Time-accessing (ANSI for DateAndTimes),  Next: Time-accessing (non ANSI & for Durations),  Prev: Time class-instance creation,  Up: Time

Time: accessing (ANSI for DateAndTimes)
---------------------------------------

hour
     Answer the number of hours in the receiver

hour12
     Answer the hour in a 12-hour clock

hour24
     Answer the hour in a 24-hour clock

minute
     Answer the number of minutes in the receiver

second
     Answer the number of seconds in the receiver



File: gst-base.info,  Node: Time-accessing (non ANSI & for Durations),  Next: Time-arithmetic,  Prev: Time-accessing (ANSI for DateAndTimes),  Up: Time

Time: accessing (non ANSI & for Durations)
------------------------------------------

asSeconds
     Answer `seconds'.

hours
     Answer the number of hours in the receiver

minutes
     Answer the number of minutes in the receiver

seconds
     Answer the number of seconds in the receiver



File: gst-base.info,  Node: Time-arithmetic,  Next: Time-comparing,  Prev: Time-accessing (non ANSI & for Durations),  Up: Time

Time: arithmetic
----------------

addTime: timeAmount
     Answer a new Time that is timeAmount seconds after the receiver

printOn: aStream
     Print a representation of the receiver on aStream

subtractTime: timeAmount
     Answer a new Time that is timeAmount seconds before the receiver



File: gst-base.info,  Node: Time-comparing,  Prev: Time-arithmetic,  Up: Time

Time: comparing
---------------

< aTime
     Answer whether the receiver is less than aTime

= aTime
     Answer whether the receiver is equal to aTime

hash
     Answer an hash value for the receiver



File: gst-base.info,  Node: TokenStream,  Next: TrappableEvent,  Prev: Time,  Up: Base classes

TokenStream
===========

Defined in namespace Smalltalk
Superclass: Stream
Category: Streams-Collections
     I am not a typical part of the Smalltalk kernel class hierarchy.
     I operate on a stream of characters and return distinct
     whitespace-delimited groups of characters; I am used to parse the
     parameters of class-creation methods.

     Basically, I parse off whitespace separated tokens as substrings
     and return them (next).  If the entire contents of the string are
     requested, I return them as an Array containing the individual
     strings.

* Menu:

* TokenStream class-instance creation::  (class)
* TokenStream-basic::  (instance)
* TokenStream-write methods::  (instance)


File: gst-base.info,  Node: TokenStream class-instance creation,  Next: TokenStream-basic,  Up: TokenStream

TokenStream class: instance creation
------------------------------------

on: aString
     Answer a TokenStream working on aString

onStream: aStream
     Answer a TokenStream working on the collection on which aStream is
     in turn streaming.



File: gst-base.info,  Node: TokenStream-basic,  Next: TokenStream-write methods,  Prev: TokenStream class-instance creation,  Up: TokenStream

TokenStream: basic
------------------

atEnd
     Answer whether the input stream has no more tokens.

next
     Answer a new whitespace-separated token from the input stream



File: gst-base.info,  Node: TokenStream-write methods,  Prev: TokenStream-basic,  Up: TokenStream

TokenStream: write methods
--------------------------

nextPut: anObject
     This method should not be called for instances of this class.



File: gst-base.info,  Node: TrappableEvent,  Next: True,  Prev: TokenStream,  Up: Base classes

TrappableEvent
==============

Defined in namespace Smalltalk
Superclass: Object
Category: Language-Exceptions
     I am an abstract class for arguments passed to #on:do:... methods
     in BlockClosure. I define a bunch of methods that apply to
     CoreExceptions and ExceptionSets: they allow you to create
     ExceptionSets and examine all the exceptions to be trapped.

* Menu:

* TrappableEvent-enumerating::  (instance)
* TrappableEvent-instance creation::  (instance)


File: gst-base.info,  Node: TrappableEvent-enumerating,  Next: TrappableEvent-instance creation,  Up: TrappableEvent

TrappableEvent: enumerating
---------------------------

allExceptionsDo: aBlock
     Execute aBlock, passing it an Exception for every exception in the
     receiver.

goodness: exception
     Answer how good the receiver is at handling the given exception.  A
     negative value indicates that the receiver is not able to handle
     the exception.

handles: exception
     Answer whether the receiver handles `exception'.



File: gst-base.info,  Node: TrappableEvent-instance creation,  Prev: TrappableEvent-enumerating,  Up: TrappableEvent

TrappableEvent: instance creation
---------------------------------

, aTrappableEvent
     Answer an ExceptionSet containing all the exceptions in the
     receiver and all the exceptions in aTrappableEvent



File: gst-base.info,  Node: True,  Next: UndefinedObject,  Prev: TrappableEvent,  Up: Base classes

True
====

Defined in namespace Smalltalk
Superclass: Boolean
Category: Language-Data types
     I represent truth and justice in the world.  My motto is "semper
     veritatis".

* Menu:

* True-basic::  (instance)
* True-C hacks::  (instance)
* True-printing::  (instance)


File: gst-base.info,  Node: True-basic,  Next: True-C hacks,  Up: True

True: basic
-----------

& aBoolean
     We are true - anded with anything, we always answer the other
     operand

and: aBlock
     We are true - anded with anything, we always answer the other
     operand, so evaluate aBlock

eqv: aBoolean
     Answer whether the receiver and aBoolean represent the same
     boolean value

ifFalse: falseBlock
     We are true - answer nil

ifFalse: falseBlock ifTrue: trueBlock
     We are true - evaluate trueBlock

ifTrue: trueBlock
     We are true - evaluate trueBlock

ifTrue: trueBlock ifFalse: falseBlock
     We are true - evaluate trueBlock

not
     We are true - answer false

or: aBlock
     We are true - ored with anything, we always answer true

xor: aBoolean
     Answer whether the receiver and aBoolean represent different
     boolean values

| aBoolean
     We are true - ored with anything, we always answer true



File: gst-base.info,  Node: True-C hacks,  Next: True-printing,  Prev: True-basic,  Up: True

True: C hacks
-------------

asCBooleanValue
     Answer `1'.



File: gst-base.info,  Node: True-printing,  Prev: True-C hacks,  Up: True

True: printing
--------------

printOn: aStream
     Print a representation of the receiver on aStream



File: gst-base.info,  Node: UndefinedObject,  Next: ValueAdaptor,  Prev: True,  Up: Base classes

UndefinedObject
===============

Defined in namespace Smalltalk
Superclass: Object
Category: Language-Implementation
     I have the questionable distinction of being a class with only one
     instance, which is the object "nil".

* Menu:

* UndefinedObject-basic::  (instance)
* UndefinedObject-class creation::  (instance)
* UndefinedObject-class creation - alternative::  (instance)
* UndefinedObject-CObject interoperability::  (instance)
* UndefinedObject-dependents access::  (instance)
* UndefinedObject-printing::  (instance)
* UndefinedObject-storing::  (instance)
* UndefinedObject-testing::  (instance)


File: gst-base.info,  Node: UndefinedObject-basic,  Next: UndefinedObject-class creation,  Up: UndefinedObject

UndefinedObject: basic
----------------------

copy
     Answer the receiver.

deepCopy
     Answer the receiver.

shallowCopy
     Answer the receiver.



File: gst-base.info,  Node: UndefinedObject-class creation,  Next: UndefinedObject-class creation - alternative,  Prev: UndefinedObject-basic,  Up: UndefinedObject

UndefinedObject: class creation
-------------------------------

metaclassFor: classNameString
     Create a Metaclass object for the given class name. The metaclass
     is a subclass of Class

removeSubclass: aClass
     Ignored - necessary to support disjoint class hierarchies

subclass: classNameString
     instanceVariableNames: stringInstVarNames     classVariableNames:
     stringOfClassVarNames     poolDictionaries: stringOfPoolNames
     category: categoryNameString Define a fixed subclass of the
     receiver with the given name, instance variables, class variables,
     pool dictionaries and category. If the class is already defined,
     if necessary, recompile everything needed.

variableByteSubclass: classNameString
     instanceVariableNames: stringInstVarNames   classVariableNames:
     stringOfClassVarNames   poolDictionaries: stringOfPoolNames
     category: categoryNameString Define a byte variable subclass of
     the receiver with the given name, instance variables, class
     variables, pool dictionaries and category. If the class is already
     defined, if necessary, recompile everything needed.

variableSubclass: classNameString
     instanceVariableNames: stringInstVarNames     classVariableNames:
     stringOfClassVarNames     poolDictionaries: stringOfPoolNames
     category: categoryNameString Define a variable pointer subclass of
     the receiver with the given name, instance variables, class
     variables, pool dictionaries and category. If the class is already
     defined, if necessary, recompile everything needed.

variableWordSubclass: classNameString
     instanceVariableNames: stringInstVarNames   classVariableNames:
     stringOfClassVarNames   poolDictionaries: stringOfPoolNames
     category: categoryNameString Define a word variable subclass of
     the receiver with the given name, instance variables, class
     variables, pool dictionaries and category. If the class is already
     defined, if necessary, recompile everything needed.



File: gst-base.info,  Node: UndefinedObject-class creation - alternative,  Next: UndefinedObject-CObject interoperability,  Prev: UndefinedObject-class creation,  Up: UndefinedObject

UndefinedObject: class creation - alternative
---------------------------------------------

subclass: classNameString classInstanceVariableNames: stringClassInstVarNames instanceVariableNames: stringInstVarNames classVariableNames: stringOfClassVarNames poolDictionaries: stringOfPoolNames
     Don't use this, it is only present to file in from IBM Smalltalk

subclass: classNameString instanceVariableNames: stringInstVarNames classVariableNames: stringOfClassVarNames poolDictionaries: stringOfPoolNames
     Don't use this, it is only present to file in from IBM Smalltalk

variableByteSubclass: classNameString classInstanceVariableNames: stringClassInstVarNames instanceVariableNames: stringInstVarNames classVariableNames: stringOfClassVarNames poolDictionaries: stringOfPoolNames
     Don't use this, it is only present to file in from IBM Smalltalk

variableByteSubclass: classNameString instanceVariableNames: stringInstVarNames classVariableNames: stringOfClassVarNames poolDictionaries: stringOfPoolNames
     Don't use this, it is only present to file in from IBM Smalltalk

variableSubclass: classNameString classInstanceVariableNames: stringClassInstVarNames instanceVariableNames: stringInstVarNames classVariableNames: stringOfClassVarNames poolDictionaries: stringOfPoolNames
     Don't use this, it is only present to file in from IBM Smalltalk

variableSubclass: classNameString instanceVariableNames: stringInstVarNames classVariableNames: stringOfClassVarNames poolDictionaries: stringOfPoolNames
     Don't use this, it is only present to file in from IBM Smalltalk

variableWordSubclass: classNameString classInstanceVariableNames: stringClassInstVarNames instanceVariableNames: stringInstVarNames classVariableNames: stringOfClassVarNames poolDictionaries: stringOfPoolNames
     Don't use this, it is only present to file in from IBM Smalltalk

variableWordSubclass: classNameString instanceVariableNames: stringInstVarNames classVariableNames: stringOfClassVarNames poolDictionaries: stringOfPoolNames
     Don't use this, it is only present to file in from IBM Smalltalk



File: gst-base.info,  Node: UndefinedObject-CObject interoperability,  Next: UndefinedObject-dependents access,  Prev: UndefinedObject-class creation - alternative,  Up: UndefinedObject

UndefinedObject: CObject interoperability
-----------------------------------------

free
     Do nothing, a NULL pointer can be safely freed.



File: gst-base.info,  Node: UndefinedObject-dependents access,  Next: UndefinedObject-printing,  Prev: UndefinedObject-CObject interoperability,  Up: UndefinedObject

UndefinedObject: dependents access
----------------------------------

addDependent: ignored
     Refer to the comment in Object|dependents.

release
     Nil release is a no-op



File: gst-base.info,  Node: UndefinedObject-printing,  Next: UndefinedObject-storing,  Prev: UndefinedObject-dependents access,  Up: UndefinedObject

UndefinedObject: printing
-------------------------

printOn: aStream
     Print a representation of the receiver on aStream.



File: gst-base.info,  Node: UndefinedObject-storing,  Next: UndefinedObject-testing,  Prev: UndefinedObject-printing,  Up: UndefinedObject

UndefinedObject: storing
------------------------

storeOn: aStream
     Store Smalltalk code compiling to the receiver on aStream.



File: gst-base.info,  Node: UndefinedObject-testing,  Prev: UndefinedObject-storing,  Up: UndefinedObject

UndefinedObject: testing
------------------------

ifNil: nilBlock
     Evaluate nilBlock if the receiver is nil, else answer nil

ifNil: nilBlock ifNotNil: notNilBlock
     Evaluate nilBlock if the receiver is nil, else evaluate
     notNilBlock, passing the receiver.

ifNotNil: notNilBlock
     Evaluate notNilBlock if the receiver is not nil, passing the
     receiver.  Else answer nil

ifNotNil: notNilBlock ifNil: nilBlock
     Evaluate nilBlock if the receiver is nil, else evaluate
     notNilBlock, passing the receiver.

isNil
     Answer whether the receiver is the undefined object nil. Always
     answer true.

notNil
     Answer whether the receiver is not the undefined object nil. Always
     answer false.



File: gst-base.info,  Node: ValueAdaptor,  Next: ValueHolder,  Prev: UndefinedObject,  Up: Base classes

ValueAdaptor
============

Defined in namespace Smalltalk
Superclass: Object
Category: Language-Data types
     My subclasses are used to access data from different objects with
     a consistent protocol. However, I'm an abstract class.

* Menu:

* ValueAdaptor class-creating instances::  (class)
* ValueAdaptor-accessing::  (instance)
* ValueAdaptor-printing::  (instance)


File: gst-base.info,  Node: ValueAdaptor class-creating instances,  Next: ValueAdaptor-accessing,  Up: ValueAdaptor

ValueAdaptor class: creating instances
--------------------------------------

new
     We don't know enough of subclasses to have a shared implementation
     of new



File: gst-base.info,  Node: ValueAdaptor-accessing,  Next: ValueAdaptor-printing,  Prev: ValueAdaptor class-creating instances,  Up: ValueAdaptor

ValueAdaptor: accessing
-----------------------

value
     Retrive the value of the receiver. Must be implemented by
     ValueAdaptor's subclasses

value: anObject
     Set the value of the receiver. Must be implemented by
     ValueAdaptor's subclasses



File: gst-base.info,  Node: ValueAdaptor-printing,  Prev: ValueAdaptor-accessing,  Up: ValueAdaptor

ValueAdaptor: printing
----------------------

printOn: aStream
     Print a representation of the receiver



File: gst-base.info,  Node: ValueHolder,  Next: VariableBinding,  Prev: ValueAdaptor,  Up: Base classes

ValueHolder
===========

Defined in namespace Smalltalk
Superclass: ValueAdaptor
Category: Language-Data types
     I store my value in a variable. For example, you can use me to
     pass num- bers by reference. Just instance me before calling a
     method and ask for my value after that method. There are a lot of
     other creative uses for my intances, though.

* Menu:

* ValueHolder class-creating instances::  (class)
* ValueHolder-accessing::  (instance)
* ValueHolder-initializing::  (instance)


File: gst-base.info,  Node: ValueHolder class-creating instances,  Next: ValueHolder-accessing,  Up: ValueHolder

ValueHolder class: creating instances
-------------------------------------

new
     Create a ValueHolder whose starting value is nil

null
     Answer the sole instance of NullValueHolder

with: anObject
     Create a ValueHolder whose starting value is anObject



File: gst-base.info,  Node: ValueHolder-accessing,  Next: ValueHolder-initializing,  Prev: ValueHolder class-creating instances,  Up: ValueHolder

ValueHolder: accessing
----------------------

value
     Get the value of the receiver.

value: anObject
     Set the value of the receiver.



File: gst-base.info,  Node: ValueHolder-initializing,  Prev: ValueHolder-accessing,  Up: ValueHolder

ValueHolder: initializing
-------------------------

initialize
     Private - set the initial value of the receiver



File: gst-base.info,  Node: VariableBinding,  Next: VersionableObjectProxy,  Prev: ValueHolder,  Up: Base classes

VariableBinding
===============

Defined in namespace Smalltalk
Superclass: HomedAssociation
Category: Language-Data types
     My instances represent a mapping between a key in a namespace and
     its value.  I print different than a normal Association, and know
     about my parent namespace, otherwise my behavior is the same.

* Menu:

* VariableBinding-printing::  (instance)
* VariableBinding-saving and loading::  (instance)
* VariableBinding-storing::  (instance)
* VariableBinding-testing::  (instance)


File: gst-base.info,  Node: VariableBinding-printing,  Next: VariableBinding-saving and loading,  Up: VariableBinding

VariableBinding: printing
-------------------------

path
     Print a dotted path that compiles to the receiver's value

printOn: aStream
     Put on aStream a representation of the receiver



File: gst-base.info,  Node: VariableBinding-saving and loading,  Next: VariableBinding-storing,  Prev: VariableBinding-printing,  Up: VariableBinding

VariableBinding: saving and loading
-----------------------------------

     to

binaryRepresentationObject
     This method is implemented to allow for a PluggableProxy to be used
     with VariableBindings.  Answer a DirectedMessage which sends #at:
     to the environment that holds the receiver.



File: gst-base.info,  Node: VariableBinding-storing,  Next: VariableBinding-testing,  Prev: VariableBinding-saving and loading,  Up: VariableBinding

VariableBinding: storing
------------------------

storeOn: aStream
     Put on aStream some Smalltalk code compiling to the receiver



File: gst-base.info,  Node: VariableBinding-testing,  Prev: VariableBinding-storing,  Up: VariableBinding

VariableBinding: testing
------------------------

isDefined
     Answer true if this VariableBinding lives outside the Undeclared
     dictionary



File: gst-base.info,  Node: VersionableObjectProxy,  Next: VFS.ArchiveFileHandler,  Prev: VariableBinding,  Up: Base classes

VersionableObjectProxy
======================

Defined in namespace Smalltalk
Superclass: NullProxy
Category: Streams-Files
     I am a proxy that stores additional information to allow different
     versions of an object's representations to be handled by the
     program.  VersionableObjectProxies are backwards compatible, that
     is you can support versioning even if you did not use a
     VersionableObjectProxy for that class when the object was
     originarily dumped.  VersionableObjectProxy does not support
     classes that changed shape across different versions.  See the
     method comments for more information.

* Menu:

* VersionableObjectProxy class-saving and restoring::  (class)
* VersionableObjectProxy-saving and restoring::  (instance)


File: gst-base.info,  Node: VersionableObjectProxy class-saving and restoring,  Next: VersionableObjectProxy-saving and restoring,  Up: VersionableObjectProxy

VersionableObjectProxy class: saving and restoring
--------------------------------------------------

     to

loadFrom: anObjectDumper
     Retrieve the object.  If the version number doesn't match the
     #binaryRepresentationVersion answered by the class, call the class'
     #convertFromVersion:withFixedVariables:instanceVariables:for:
     method.  The stored version number will be the first parameter to
     that method (or nil if the stored object did not employ a
     VersionableObjectProxy), the remaining parameters will be
     respectively the fixed instance variables, the indexed instance
     variables (or nil if the class is fixed), and the ObjectDumper
     itself.  If no VersionableObjectProxy, the class is sent
     #nonVersionedInstSize to retrieve the number of fixed instance
     variables stored for the non-versioned object.



File: gst-base.info,  Node: VersionableObjectProxy-saving and restoring,  Prev: VersionableObjectProxy class-saving and restoring,  Up: VersionableObjectProxy

VersionableObjectProxy: saving and restoring
--------------------------------------------

dumpTo: anObjectDumper
     Save the object with extra versioning information.



File: gst-base.info,  Node: VFS.ArchiveFileHandler,  Next: VFS.ArchiveMemberHandler,  Prev: VersionableObjectProxy,  Up: Base classes

VFS.ArchiveFileHandler
======================

Defined in namespace Smalltalk.VFS
Superclass: VFS.RealFileHandler
Category: Streams-Files
     ArchiveFileHandler handles virtual filesystems that have a
     directory structure of their own.  The directories and files in
     the archive are instances of ArchiveMemberHandler, but the
     functionality resides entirely in ArchiveFileHandler because the
     members will still ask the archive to get directory information on
     them, to extract them to a real file, and so on.

* Menu:

* VFS.ArchiveFileHandler class-registering::  (class)
* VFS.ArchiveFileHandler-ArchiveMemberHandler protocol::  (instance)
* VFS.ArchiveFileHandler-directory operations::  (instance)
* VFS.ArchiveFileHandler-file operations::  (instance)


File: gst-base.info,  Node: VFS.ArchiveFileHandler class-registering,  Next: VFS.ArchiveFileHandler-ArchiveMemberHandler protocol,  Up: VFS.ArchiveFileHandler

VFS.ArchiveFileHandler class: registering
-----------------------------------------

isAccessible
     Answer whether a directory with the name contained in the receiver
     does exist and can be accessed

isDirectory
     Answer true.  The archive can always be considered as a directory.



File: gst-base.info,  Node: VFS.ArchiveFileHandler-ArchiveMemberHandler protocol,  Next: VFS.ArchiveFileHandler-directory operations,  Prev: VFS.ArchiveFileHandler class-registering,  Up: VFS.ArchiveFileHandler

VFS.ArchiveFileHandler: ArchiveMemberHandler protocol
-----------------------------------------------------

extractMember: anArchiveMemberHandler
     Extract the contents of anArchiveMemberHandler into a file that
     resides on disk, and answer the name of the file.

fillMember: anArchiveMemberHandler
     Extract the information on anArchiveMemberHandler.  Answer false
     if it actually does not exist in the archive; otherwise, answer
     true after having told anArchiveMemberHandler about them by
     sending #size:stCtime:stMtime:stAtime:isDirectory: to it.

member: anArchiveMemberHandler do: aBlock
     Evaluate aBlock once for each file in the directory represented by
     anArchiveMemberHandler, passing its name.

newMemberHandlerFor: aName
     Answer a new ArchiveMemberHandler for a file named aName residing
     inside the archive represented by the receiver.

removeMember: anArchiveMemberHandler
     Remove the member represented by anArchiveMemberHandler.

updateMember: anArchiveMemberHandler
     Update the member represented by anArchiveMemberHandler by copying
     the file into which it was extracted back to the archive.



File: gst-base.info,  Node: VFS.ArchiveFileHandler-directory operations,  Next: VFS.ArchiveFileHandler-file operations,  Prev: VFS.ArchiveFileHandler-ArchiveMemberHandler protocol,  Up: VFS.ArchiveFileHandler

VFS.ArchiveFileHandler: directory operations
--------------------------------------------

at: aName
     Answer a VFSHandler for a file named `aName' residing in the
     directory represented by the receiver.

createDir: dirName
     Create a subdirectory of the receiver, naming it dirName.

do: aBlock
     Evaluate aBlock once for each file in the directory represented by
     the receiver, passing its name.

finalize
     Upon finalization, we remove the file that was temporarily holding
     the file contents

release
     Release the resources used by the receiver that don't survive when
     reloading a snapshot.



File: gst-base.info,  Node: VFS.ArchiveFileHandler-file operations,  Prev: VFS.ArchiveFileHandler-directory operations,  Up: VFS.ArchiveFileHandler

VFS.ArchiveFileHandler: file operations
---------------------------------------

remove
     Remove the file with the given path name



File: gst-base.info,  Node: VFS.ArchiveMemberHandler,  Next: VFS.DecodedFileHandler,  Prev: VFS.ArchiveFileHandler,  Up: Base classes

VFS.ArchiveMemberHandler
========================

Defined in namespace Smalltalk.VFS
Superclass: VFS.VFSHandler
Category: Streams-Files
     ArchiveMemberHandler is the handler class for member of archive
     files (instances of ArchiveFileHandler).

* Menu:

* VFS.ArchiveMemberHandler-accessing::  (instance)
* VFS.ArchiveMemberHandler-directory operations::  (instance)
* VFS.ArchiveMemberHandler-file operations::  (instance)
* VFS.ArchiveMemberHandler-finalization::  (instance)
* VFS.ArchiveMemberHandler-initializing::  (instance)
* VFS.ArchiveMemberHandler-testing::  (instance)


File: gst-base.info,  Node: VFS.ArchiveMemberHandler-accessing,  Next: VFS.ArchiveMemberHandler-directory operations,  Up: VFS.ArchiveMemberHandler

VFS.ArchiveMemberHandler: accessing
-----------------------------------

creationTime
     Answer the creation time of the file identified by the receiver.
     On some operating systems, this could actually be the last change
     time (the `last change time' has to do with permissions, ownership
     and the like).

lastAccessTime
     Answer the last access time of the file identified by the receiver

lastChangeTime
     Answer the last change time of the file identified by the receiver
     (the `last change time' has to do with permissions, ownership and
     the like). On some operating systems, this could actually be the
     file creation time.

lastModifyTime
     Answer the last modify time of the file identified by the receiver
     (the `last modify time' has to do with the actual file contents).

parent
     Answer the archive of which the receiver is a member.

refresh
     Refresh the statistics for the receiver

size
     Answer the size of the file identified by the receiver



File: gst-base.info,  Node: VFS.ArchiveMemberHandler-directory operations,  Next: VFS.ArchiveMemberHandler-file operations,  Prev: VFS.ArchiveMemberHandler-accessing,  Up: VFS.ArchiveMemberHandler

VFS.ArchiveMemberHandler: directory operations
----------------------------------------------

at: aName
     Answer a VFSHandler for a file named `aName' residing in the
     directory represented by the receiver.

createDir: dirName
     Create a subdirectory of the receiver, naming it dirName.

do: aBlock
     Evaluate aBlock once for each file in the directory represented by
     the receiver, passing its name.



File: gst-base.info,  Node: VFS.ArchiveMemberHandler-file operations,  Next: VFS.ArchiveMemberHandler-finalization,  Prev: VFS.ArchiveMemberHandler-directory operations,  Up: VFS.ArchiveMemberHandler

VFS.ArchiveMemberHandler: file operations
-----------------------------------------

open: class mode: mode ifFail: aBlock
     Open the receiver in the given mode (as answered by FileStream's
     class constant methods)

remove
     Remove the file with the given path name

renameTo: newFileName
     Rename the file with the given path name oldFileName to newFileName

update: aspect
     Private - Update the in-archive version of the file before closing.



File: gst-base.info,  Node: VFS.ArchiveMemberHandler-finalization,  Next: VFS.ArchiveMemberHandler-initializing,  Prev: VFS.ArchiveMemberHandler-file operations,  Up: VFS.ArchiveMemberHandler

VFS.ArchiveMemberHandler: finalization
--------------------------------------

realFileName
     Answer the real file name which holds the file contents, or nil if
     it does not apply.

release
     Release the resources used by the receiver that don't survive when
     reloading a snapshot.



File: gst-base.info,  Node: VFS.ArchiveMemberHandler-initializing,  Next: VFS.ArchiveMemberHandler-testing,  Prev: VFS.ArchiveMemberHandler-finalization,  Up: VFS.ArchiveMemberHandler

VFS.ArchiveMemberHandler: initializing
--------------------------------------

parent: anArchiveFileHandler
     Set the archive of which the receiver is a member.

size: bytes stCtime: ctime stMtime: mtime stAtime: atime isDirectory: isDir
     Called back by the receiver's parent when the ArchiveMemberHandler
     asks for file information.



File: gst-base.info,  Node: VFS.ArchiveMemberHandler-testing,  Prev: VFS.ArchiveMemberHandler-initializing,  Up: VFS.ArchiveMemberHandler

VFS.ArchiveMemberHandler: testing
---------------------------------

exists
     Answer whether a file with the name contained in the receiver does
     exist.

isAccessible
     Answer whether a directory with the name contained in the receiver
     does exist and is accessible

isDirectory
     Answer whether a file with the name contained in the receiver does
     exist and identifies a directory.

isExecutable
     Answer whether a file with the name contained in the receiver does
     exist and is executable

isReadable
     Answer whether a file with the name contained in the receiver does
     exist and is readable

isWriteable
     Answer whether a file with the name contained in the receiver does
     exist and is writeable



File: gst-base.info,  Node: VFS.DecodedFileHandler,  Next: VFS.ExternalArchiveFileHandler,  Prev: VFS.ArchiveMemberHandler,  Up: Base classes

VFS.DecodedFileHandler
======================

Defined in namespace Smalltalk.VFS
Superclass: VFS.RealFileHandler
Category: Streams-Files
     DecodedFileHandler handles virtual filesystems that take a file
     that is on-disk, run a command on it, and then read from the
     result.

* Menu:

* VFS.DecodedFileHandler class-registering::  (class)
* VFS.DecodedFileHandler-files::  (instance)


File: gst-base.info,  Node: VFS.DecodedFileHandler class-registering,  Next: VFS.DecodedFileHandler-files,  Up: VFS.DecodedFileHandler

VFS.DecodedFileHandler class: registering
-----------------------------------------

fileSystems
     Answer the virtual file systems that can be processed by this
     subclass.  These are #gz (gzip a file), #ugz (uncompress a gzipped
     file), #Z (compress a file via Unix compress), #uZ (uncompress a
     compressed file), #bz2 (compress a file via bzip2), #ubz2
     (uncompress a file via bzip2), #tar (make a tar archive out of a
     directory), #tgz (make a gzipped tar archive out of a directory),
     #nop (do nothing, used for testing) and #strings (use the
     `strings' utility to extract printable strings from a file).

initialize
     Initialize the default virtual filesystems and the associated
     filter commands.

vfsFor: file name: fsName subPath: subPath
     Create a temporary file and use it to construct the contents of
     the given file, under the virtual filesystem fsName. subPath must
     be nil because this class supports single-file virtual filesystems
     only.



File: gst-base.info,  Node: VFS.DecodedFileHandler-files,  Prev: VFS.DecodedFileHandler class-registering,  Up: VFS.DecodedFileHandler

VFS.DecodedFileHandler: files
-----------------------------

finalize
     Upon finalization, we remove the file that was temporarily holding
     the file contents

name: virtualFileName realFileName: temporaryFileName
     Private - Initialize a new object storing the contents of the
     virtualFileName file into temporaryFileName.

realFileName
     Answer the real file name which holds the file contents, or nil if
     it does not apply.

release
     Release the resources used by the receiver that don't survive when
     reloading a snapshot.



File: gst-base.info,  Node: VFS.ExternalArchiveFileHandler,  Next: VFS.RealFileHandler,  Prev: VFS.DecodedFileHandler,  Up: Base classes

VFS.ExternalArchiveFileHandler
==============================

Defined in namespace Smalltalk.VFS
Superclass: VFS.ArchiveFileHandler
Category: Streams-Files
     ExternalArchiveFileHandler allows for easy implementation of
     archive files (for example, transparent unzipping and untarring)
     with a single shell script.  It implements a protocol that that is
     compatible with the Midnight Commander and with GNOME VFS.

* Menu:

* VFS.ExternalArchiveFileHandler class-registering::  (class)
* VFS.ExternalArchiveFileHandler-ArchiveMemberHandler protocol::  (instance)
* VFS.ExternalArchiveFileHandler-members::  (instance)
* VFS.ExternalArchiveFileHandler-releasing::  (instance)


File: gst-base.info,  Node: VFS.ExternalArchiveFileHandler class-registering,  Next: VFS.ExternalArchiveFileHandler-ArchiveMemberHandler protocol,  Up: VFS.ExternalArchiveFileHandler

VFS.ExternalArchiveFileHandler class: registering
-------------------------------------------------

fileSystems
     Answer the virtual file systems that can be processed by this
     subclass.  These are given by the names of the executable files in
     the vfs subdirectory of the image directory, of the parent of the
     kernel directory and of the parent of the system kernel directory.

fileSystemsIn: path
     Registers the executable files in the given directory to be used
     to resolve a virtual file system.

vfsFor: file name: fsName subPath: subPath
     Create a temporary file and use it to construct the contents of
     the given file, under the virtual filesystem fsName. subPath must
     be nil because this class supports single-file virtual filesystems
     only.



File: gst-base.info,  Node: VFS.ExternalArchiveFileHandler-ArchiveMemberHandler protocol,  Next: VFS.ExternalArchiveFileHandler-members,  Prev: VFS.ExternalArchiveFileHandler class-registering,  Up: VFS.ExternalArchiveFileHandler

VFS.ExternalArchiveFileHandler: ArchiveMemberHandler protocol
-------------------------------------------------------------

extractMember: anArchiveMemberHandler
     Extract the contents of anArchiveMemberHandler into a file that
     resides on disk, and answer the name of the file.

fillMember: anArchiveMemberHandler
     Extract the information on anArchiveMemberHandler.  Answer false
     if it actually does not exist in the archive; otherwise, answer
     true after having told anArchiveMemberHandler about them by
     sending #size:stCtime:stMtime:stAtime:isDirectory: to it.

member: anArchiveMemberHandler do: aBlock
     Evaluate aBlock once for each file in the directory represented by
     anArchiveMemberHandler, passing its name.

refresh
     Extract the directory listing from the archive

removeMember: anArchiveMemberHandler
     Remove the member represented by anArchiveMemberHandler.

updateMember: anArchiveMemberHandler
     Update the member represented by anArchiveMemberHandler by copying
     the file into which it was extracted back to the archive.



File: gst-base.info,  Node: VFS.ExternalArchiveFileHandler-members,  Next: VFS.ExternalArchiveFileHandler-releasing,  Prev: VFS.ExternalArchiveFileHandler-ArchiveMemberHandler protocol,  Up: VFS.ExternalArchiveFileHandler

VFS.ExternalArchiveFileHandler: members
---------------------------------------

createDir: dirName
     Create a subdirectory of the receiver, naming it dirName.

do: aBlock
     Evaluate aBlock once for each file in the directory represented by
     the receiver, passing its name.



File: gst-base.info,  Node: VFS.ExternalArchiveFileHandler-releasing,  Prev: VFS.ExternalArchiveFileHandler-members,  Up: VFS.ExternalArchiveFileHandler

VFS.ExternalArchiveFileHandler: releasing
-----------------------------------------

release
     Release the resources used by the receiver that don't survive when
     reloading a snapshot.



File: gst-base.info,  Node: VFS.RealFileHandler,  Next: VFS.VFSHandler,  Prev: VFS.ExternalArchiveFileHandler,  Up: Base classes

VFS.RealFileHandler
===================

Defined in namespace Smalltalk.VFS
Superclass: VFS.VFSHandler
Category: Streams-Files
     RealFileHandler is an handler for files that are on disk, as well
     as for virtual files that end up being on disk when they are
     opened for the first time.

* Menu:

* VFS.RealFileHandler class-C functions::  (class)
* VFS.RealFileHandler class-initialization::  (class)
* VFS.RealFileHandler-accessing::  (instance)
* VFS.RealFileHandler-directory operations::  (instance)
* VFS.RealFileHandler-file operations::  (instance)
* VFS.RealFileHandler-testing::  (instance)


File: gst-base.info,  Node: VFS.RealFileHandler class-C functions,  Next: VFS.RealFileHandler class-initialization,  Up: VFS.RealFileHandler

VFS.RealFileHandler class: C functions
--------------------------------------

working
     C call-out to getCurDirName. Do not modify!



File: gst-base.info,  Node: VFS.RealFileHandler class-initialization,  Next: VFS.RealFileHandler-accessing,  Prev: VFS.RealFileHandler class-C functions,  Up: VFS.RealFileHandler

VFS.RealFileHandler class: initialization
-----------------------------------------

initialize
     Initialize the receiver's class variables



File: gst-base.info,  Node: VFS.RealFileHandler-accessing,  Next: VFS.RealFileHandler-directory operations,  Prev: VFS.RealFileHandler class-initialization,  Up: VFS.RealFileHandler

VFS.RealFileHandler: accessing
------------------------------

creationTime
     Answer the creation time of the file identified by the receiver.
     On some operating systems, this could actually be the last change
     time (the `last change time' has to do with permissions, ownership
     and the like).

lastAccessTime
     Answer the last access time of the file identified by the receiver

lastChangeTime
     Answer the last change time of the file identified by the receiver
     (the `last change time' has to do with permissions, ownership and
     the like). On some operating systems, this could actually be the
     file creation time.

lastModifyTime
     Answer the last modify time of the file identified by the receiver
     (the `last modify time' has to do with the actual file contents).

name: aName
     Private - Initialize the receiver's instance variables

refresh
     Refresh the statistics for the receiver

size
     Answer the size of the file identified by the receiver



File: gst-base.info,  Node: VFS.RealFileHandler-directory operations,  Next: VFS.RealFileHandler-file operations,  Prev: VFS.RealFileHandler-accessing,  Up: VFS.RealFileHandler

VFS.RealFileHandler: directory operations
-----------------------------------------

createDir: dirName
     Create a subdirectory of the receiver, naming it dirName.

do: aBlock
     Evaluate aBlock once for each file in the directory represented by
     the receiver, passing its name. aBlock should not return.



File: gst-base.info,  Node: VFS.RealFileHandler-file operations,  Next: VFS.RealFileHandler-testing,  Prev: VFS.RealFileHandler-directory operations,  Up: VFS.RealFileHandler

VFS.RealFileHandler: file operations
------------------------------------

open: class mode: mode ifFail: aBlock
     Open the receiver in the given mode (as answered by FileStream's
     class constant methods)

remove
     Remove the file with the given path name

renameTo: newFileName
     Rename the file with the given path name oldFileName to newFileName



File: gst-base.info,  Node: VFS.RealFileHandler-testing,  Prev: VFS.RealFileHandler-file operations,  Up: VFS.RealFileHandler

VFS.RealFileHandler: testing
----------------------------

exists
     Answer whether a file with the name contained in the receiver does
     exist.

isDirectory
     Answer whether a file with the name contained in the receiver does
     exist and identifies a directory.

isExecutable
     Answer whether a file with the name contained in the receiver does
     exist and is executable

isReadable
     Answer whether a file with the name contained in the receiver does
     exist and is readable

isWriteable
     Answer whether a file with the name contained in the receiver does
     exist and is writeable



File: gst-base.info,  Node: VFS.VFSHandler,  Next: Warning,  Prev: VFS.RealFileHandler,  Up: Base classes

VFS.VFSHandler
==============

Defined in namespace Smalltalk.VFS
Superclass: Object
Category: Streams-Files
     VFSHandler is the abstract class for implementations of File and
     Directory.  These classes only delegate to the appropriate
     handler, which is in charge of actually accessing or "molding" the
     filesystem.

* Menu:

* VFS.VFSHandler class-initializing::  (class)
* VFS.VFSHandler class-instance creation::  (class)
* VFS.VFSHandler-accessing::  (instance)
* VFS.VFSHandler-C functions::  (instance)
* VFS.VFSHandler-directory operations::  (instance)
* VFS.VFSHandler-file operations::  (instance)
* VFS.VFSHandler-testing::  (instance)


File: gst-base.info,  Node: VFS.VFSHandler class-initializing,  Next: VFS.VFSHandler class-instance creation,  Up: VFS.VFSHandler

VFS.VFSHandler class: initializing
----------------------------------

fileSystems
     Answer the virtual file systems that can be processed by this
     subclass.  The default is to answer an empty array, but subclasses
     can override this.  If you do so, you should override
     #vfsFor:name:subPath: as well or you risk infinite loops.

initialize
     Register the receiver with ObjectMemory

register: fileSystem forClass: vfsHandlerClass
     Register the given file system to be handled by an instance of
     vfsHandlerClass.  This is automatically called if the class
     overrides #fileSystems.

update: aspect
     Private - Remove the files before quitting, and register the
     virtual filesystems specified by the subclasses upon image load.



File: gst-base.info,  Node: VFS.VFSHandler class-instance creation,  Next: VFS.VFSHandler-accessing,  Prev: VFS.VFSHandler class-initializing,  Up: VFS.VFSHandler

VFS.VFSHandler class: instance creation
---------------------------------------

for: fileName
     Answer the (real or virtual) file handler for the file named
     fileName



File: gst-base.info,  Node: VFS.VFSHandler-accessing,  Next: VFS.VFSHandler-C functions,  Prev: VFS.VFSHandler class-instance creation,  Up: VFS.VFSHandler

VFS.VFSHandler: accessing
-------------------------

creationTime
     Answer the creation time of the file identified by the receiver.
     On some operating systems, this could actually be the last change
     time (the `last change time' has to do with permissions, ownership
     and the like).

lastAccessTime
     Answer the last access time of the file identified by the receiver

lastChangeTime
     Answer the last change time of the file identified by the receiver
     (the `last change time' has to do with permissions, ownership and
     the like). On some operating systems, this could actually be the
     file creation time.

lastModifyTime
     Answer the last modify time of the file identified by the receiver
     (the `last modify time' has to do with the actual file contents).

name
     Answer the name of the file identified by the receiver

name: aName
     Private - Initialize the receiver's instance variables

realFileName
     Answer the real file name which holds the file contents, or an
     empty string if it does not apply.

refresh
     Refresh the statistics for the receiver

size
     Answer the size of the file identified by the receiver



File: gst-base.info,  Node: VFS.VFSHandler-C functions,  Next: VFS.VFSHandler-directory operations,  Prev: VFS.VFSHandler-accessing,  Up: VFS.VFSHandler

VFS.VFSHandler: C functions
---------------------------

closeDir: dirObject
     C call-out to closedir. Do not modify!

extractDirentName: dirent
     C call-out to extractDirentName. Do not modify!

openDir: dirName
     C call-out to opendir. Do not modify!

primCreateDir: dirName mode: mode
     C call-out to mkdir. Do not modify!

primIsExecutable: name
     C call-out to fileIsExecutable. Do not modify!

primIsReadable: name
     C call-out to fileIsReadable. Do not modify!

primIsWriteable: name
     C call-out to fileIsWriteable. Do not modify!

primRemoveDir: fileName
     C call-out to rmdir. Do not modify!

primRename: oldFileName to: newFileName
     C call-out to rename. Do not modify!

primUnlink: fileName
     C call-out to unlink. Do not modify!

readDir: dirObject
     C call-out to readdir. Do not modify!

rewindDir: dirObject
     C call-out to rewinddir. Do not modify!

statOn: fileName into: statStruct
     C call-out to stat. Do not modify!



File: gst-base.info,  Node: VFS.VFSHandler-directory operations,  Next: VFS.VFSHandler-file operations,  Prev: VFS.VFSHandler-C functions,  Up: VFS.VFSHandler

VFS.VFSHandler: directory operations
------------------------------------

at: aName
     Answer a VFSHandler for a file named `aName' residing in the
     directory represented by the receiver.

createDir: dirName
     Create a subdirectory of the receiver, naming it dirName.

do: aBlock
     Evaluate aBlock once for each file in the directory represented by
     the receiver, passing its name. aBlock should not return.



File: gst-base.info,  Node: VFS.VFSHandler-file operations,  Next: VFS.VFSHandler-testing,  Prev: VFS.VFSHandler-directory operations,  Up: VFS.VFSHandler

VFS.VFSHandler: file operations
-------------------------------

open: mode ifFail: aBlock
     Open the receiver in the given mode (as answered by FileStream's
     class constant methods)

open: class mode: mode ifFail: aBlock
     Open the receiver in the given mode (as answered by FileStream's
     class constant methods)

openDescriptor: mode ifFail: aBlock
     Open the receiver in the given mode (as answered by FileStream's
     class constant methods)

remove
     Remove the file with the given path name

renameTo: newFileName
     Rename the file with the given path name oldFileName to newFileName



File: gst-base.info,  Node: VFS.VFSHandler-testing,  Prev: VFS.VFSHandler-file operations,  Up: VFS.VFSHandler

VFS.VFSHandler: testing
-----------------------

exists
     Answer whether a file with the name contained in the receiver does
     exist.

isAccessible
     Answer whether a directory with the name contained in the receiver
     does exist and can be accessed

isDirectory
     Answer whether a file with the name contained in the receiver does
     exist and identifies a directory.

isExecutable
     Answer whether a file with the name contained in the receiver does
     exist and is executable

isReadable
     Answer whether a file with the name contained in the receiver does
     exist and is readable

isWriteable
     Answer whether a file with the name contained in the receiver does
     exist and is writeable



File: gst-base.info,  Node: Warning,  Next: WeakArray,  Prev: VFS.VFSHandler,  Up: Base classes

Warning
=======

Defined in namespace Smalltalk
Superclass: Notification
Category: Language-Exceptions
     Warning represents an `important' but resumable error.

* Menu:

* Warning-exception description::  (instance)


File: gst-base.info,  Node: Warning-exception description,  Up: Warning

Warning: exception description
------------------------------

description
     Answer a textual description of the exception.



File: gst-base.info,  Node: WeakArray,  Next: WeakIdentitySet,  Prev: Warning,  Up: Base classes

WeakArray
=========

Defined in namespace Smalltalk
Superclass: Array
Category: Collections-Weak
     I am similar to a plain array, but my items are stored in a weak
     object, so I track which of them are garbage collected.

* Menu:

* WeakArray class-instance creation::  (class)
* WeakArray-accessing::  (instance)
* WeakArray-conversion::  (instance)
* WeakArray-loading::  (instance)


File: gst-base.info,  Node: WeakArray class-instance creation,  Next: WeakArray-accessing,  Up: WeakArray

WeakArray class: instance creation
----------------------------------

new: size
     Private - Initialize the values array; plus, make it weak and
     create the ByteArray used to track garbage collected values



File: gst-base.info,  Node: WeakArray-accessing,  Next: WeakArray-conversion,  Prev: WeakArray class-instance creation,  Up: WeakArray

WeakArray: accessing
--------------------

aliveObjectsDo: aBlock
     Evaluate aBlock for all the elements in the array, excluding the
     garbage collected ones. Note: a finalized object stays alive until
     the next collection (the collector has no means to see whether it
     was resuscitated by the finalizer), so an object being alive does
     not mean that it is usable.

at: index
     Answer the index-th item of the receiver, or nil if it has been
     garbage collected.

at: index put: object
     Store the value associated to the given index; plus, store in
     nilValues whether the object is nil.  nil objects whose associated
     item of nilValues is 1 were touched by the garbage collector.

atAll: indices put: object
     Put object at every index contained in the indices collection

atAllPut: object
     Put object at every index in the receiver

clearGCFlag: index
     Clear the `object has been garbage collected' flag for the item at
     the given index

do: aBlock
     Evaluate aBlock for all the elements in the array, including the
     garbage collected ones (pass nil for those).

isAlive: index
     Answer whether the item at the given index is still alive or has
     been garbage collected. Note: a finalized object stays alive until
     the next collection (the collector has no means to see whether it
     was resuscitated by the finalizer), so an object being alive does
     not mean that it is usable.

size
     Answer the number of items in the receiver



File: gst-base.info,  Node: WeakArray-conversion,  Next: WeakArray-loading,  Prev: WeakArray-accessing,  Up: WeakArray

WeakArray: conversion
---------------------

asArray
     Answer a non-weak version of the receiver

deepCopy
     Returns a deep copy of the receiver (the instance variables are
     copies of the receiver's instance variables)

shallowCopy
     Returns a shallow copy of the receiver (the instance variables are
     not copied)

species
     Answer Array; this method is used in the #copyEmpty: message,
     which in turn is used by all collection-returning methods
     (collect:, select:, reject:, etc.).



File: gst-base.info,  Node: WeakArray-loading,  Prev: WeakArray-conversion,  Up: WeakArray

WeakArray: loading
------------------

postLoad
     Called after loading an object; must restore it to the state before
     `preStore' was called.  Make it weak again



File: gst-base.info,  Node: WeakIdentitySet,  Next: WeakKeyDictionary,  Prev: WeakArray,  Up: Base classes

WeakIdentitySet
===============

Defined in namespace Smalltalk
Superclass: WeakSet
Category: Collections-Weak
     I am similar to a plain identity set, but my keys are stored in a
     weak array; I track which of them are garbage collected and, as
     soon as I encounter one of them, I swiftly remove all the garbage
     collected keys

* Menu:


File: gst-base.info,  Node: WeakKeyDictionary,  Next: WeakKeyIdentityDictionary,  Prev: WeakIdentitySet,  Up: Base classes

WeakKeyDictionary
=================

Defined in namespace Smalltalk
Superclass: Dictionary
Category: Collections-Weak
     I am similar to a plain Dictionary, but my keys are stored in a
     weak array; I track which of them are garbage collected and, as
     soon as I encounter one of them, I swiftly remove all the
     associations for the garbage collected keys

* Menu:

* WeakKeyDictionary-accessing::  (instance)


File: gst-base.info,  Node: WeakKeyDictionary-accessing,  Up: WeakKeyDictionary

WeakKeyDictionary: accessing
----------------------------

add: aVariableBinding
     Store value as associated to the given key. If any, recycle
     Associations temporarily stored by the compiler inside the
     `Undeclared' dictionary.

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.



File: gst-base.info,  Node: WeakKeyIdentityDictionary,  Next: WeakSet,  Prev: WeakKeyDictionary,  Up: Base classes

WeakKeyIdentityDictionary
=========================

Defined in namespace Smalltalk
Superclass: WeakKeyDictionary
Category: Collections-Weak
     I am similar to a plain identity dictionary, but my keys are stored
     in a weak array; I track which of them are garbage collected and,
     as soon as I encounter one of them, I swiftly remove all the
     associations for the garbage collected keys

* Menu:


File: gst-base.info,  Node: WeakSet,  Next: WeakValueIdentityDictionary,  Prev: WeakKeyIdentityDictionary,  Up: Base classes

WeakSet
=======

Defined in namespace Smalltalk
Superclass: Set
Category: Collections-Weak
     I am similar to a plain set, but my items are stored in a weak
     array; I track which of them are garbage collected and, as soon as
     I encounter one of them, I swiftly remove all.

* Menu:

* WeakSet-accessing::  (instance)


File: gst-base.info,  Node: WeakSet-accessing,  Up: WeakSet

WeakSet: accessing
------------------

add: anObject
     Add newObject to the set, if and only if the set doesn't already
     contain an occurrence of it. Don't fail if a duplicate is found.
     Answer anObject

do: aBlock
     Enumerate all the non-nil members of the set

remove: anObject ifAbsent: aBlock
     Remove oldObject to the set. If it is found, answer oldObject.
     Otherwise, evaluate aBlock and return its value.



File: gst-base.info,  Node: WeakValueIdentityDictionary,  Next: WeakValueLookupTable,  Prev: WeakSet,  Up: Base classes

WeakValueIdentityDictionary
===========================

Defined in namespace Smalltalk
Superclass: WeakValueLookupTable
Category: Collections-Weak
     I am similar to a plain identity dictionary, but my values are
     stored in a weak array; I track which of the values are garbage
     collected and, as soon as one of them is accessed, I swiftly
     remove the associations for the garbage collected values

* Menu:


File: gst-base.info,  Node: WeakValueLookupTable,  Next: WordArray,  Prev: WeakValueIdentityDictionary,  Up: Base classes

WeakValueLookupTable
====================

Defined in namespace Smalltalk
Superclass: LookupTable
Category: Collections-Weak
     I am similar to a plain LookupTable, but my values are stored in a
     weak array; I track which of the values are garbage collected and,
     as soon as one of them is accessed, I swiftly remove the
     associations for the garbage collected values

* Menu:

* WeakValueLookupTable-hacks::  (instance)
* WeakValueLookupTable-rehashing::  (instance)


File: gst-base.info,  Node: WeakValueLookupTable-hacks,  Next: WeakValueLookupTable-rehashing,  Up: WeakValueLookupTable

WeakValueLookupTable: hacks
---------------------------

at: key ifAbsent: aBlock
     Answer the value associated to the given key, or the result of
     evaluating aBlock if the key is not found

at: key ifPresent: aBlock
     If aKey is absent, answer nil. Else, evaluate aBlock passing the
     associated value and answer the result of the invocation

includesKey: key
     Answer whether the receiver contains the given key.



File: gst-base.info,  Node: WeakValueLookupTable-rehashing,  Prev: WeakValueLookupTable-hacks,  Up: WeakValueLookupTable

WeakValueLookupTable: rehashing
-------------------------------

rehash
     Rehash the receiver



File: gst-base.info,  Node: WordArray,  Next: WriteStream,  Prev: WeakValueLookupTable,  Up: Base classes

WordArray
=========

Defined in namespace Smalltalk
Superclass: ArrayedCollection
Category: Collections-Sequenceable
     I am similar to a plain array, but my items are 32-bit integers.

* Menu:


File: gst-base.info,  Node: WriteStream,  Next: ZeroDivide,  Prev: WordArray,  Up: Base classes

WriteStream
===========

Defined in namespace Smalltalk
Superclass: PositionableStream
Category: Streams-Collections
     I am the class of writeable streams.  I only allow write
     operations to my instances; reading is strictly forbidden.

* Menu:

* WriteStream class-instance creation::  (class)
* WriteStream-accessing::  (instance)
* WriteStream-accessing-writing::  (instance)
* WriteStream-positioning::  (instance)


File: gst-base.info,  Node: WriteStream class-instance creation,  Next: WriteStream-accessing,  Up: WriteStream

WriteStream class: instance creation
------------------------------------

on: aCollection
     Answer a new instance of the receiver which streams on aCollection.
     Every item of aCollection is discarded.

with: aCollection
     Answer a new instance of the receiver which streams from the end
     of aCollection.

with: aCollection from: firstIndex to: lastIndex
     Answer a new instance of the receiver which streams from the
     firstIndex-th item of aCollection to the lastIndex-th. The pointer
     is moved to the last item in that range.



File: gst-base.info,  Node: WriteStream-accessing,  Next: WriteStream-accessing-writing,  Prev: WriteStream class-instance creation,  Up: WriteStream

WriteStream: accessing
----------------------

size
     Answer how many objects have been written



File: gst-base.info,  Node: WriteStream-accessing-writing,  Next: WriteStream-positioning,  Prev: WriteStream-accessing,  Up: WriteStream

WriteStream: accessing-writing
------------------------------

contents
     Returns a collection of the same type that the stream accesses, up
     to and including the final element.

nextPut: anObject
     Store anObject as the next item in the receiver. Grow the
     collection if necessary

reverseContents
     Returns a collection of the same type that the stream accesses, up
     to and including the final element, but in reverse order.



File: gst-base.info,  Node: WriteStream-positioning,  Prev: WriteStream-accessing-writing,  Up: WriteStream

WriteStream: positioning
------------------------

emptyStream
     Extension - Reset the stream



File: gst-base.info,  Node: ZeroDivide,  Prev: WriteStream,  Up: Base classes

ZeroDivide
==========

Defined in namespace Smalltalk
Superclass: ArithmeticError
Category: Language-Exceptions
     A ZeroDivide exception is raised by numeric classes when a program
     tries to divide by zero.  Information on the dividend is available
     to the handler.

* Menu:

* ZeroDivide class-instance creation::  (class)
* ZeroDivide-accessing::  (instance)
* ZeroDivide-description::  (instance)


File: gst-base.info,  Node: ZeroDivide class-instance creation,  Next: ZeroDivide-accessing,  Up: ZeroDivide

ZeroDivide class: instance creation
-----------------------------------

dividend: aNumber
     Create a new ZeroDivide object remembering that the dividend was
     aNumber.

new
     Create a new ZeroDivide object; the dividend is conventionally set
     to zero.



File: gst-base.info,  Node: ZeroDivide-accessing,  Next: ZeroDivide-description,  Prev: ZeroDivide class-instance creation,  Up: ZeroDivide

ZeroDivide: accessing
---------------------

dividend
     Answer the number that was being divided by zero



File: gst-base.info,  Node: ZeroDivide-description,  Prev: ZeroDivide-accessing,  Up: ZeroDivide

ZeroDivide: description
-----------------------

description
     Answer a textual description of the exception.



File: gst-base.info,  Node: Class index,  Next: Method index,  Prev: Base classes,  Up: Top

Class index
***********

* Menu:

* AbstractNamespace:                     AbstractNamespace.
* AlternativeObjectProxy:                AlternativeObjectProxy.
* ArithmeticError:                       ArithmeticError.
* Array:                                 Array.
* ArrayedCollection:                     ArrayedCollection.
* Association:                           Association.
* Autoload:                              Autoload.
* AutoloadClass:                         AutoloadClass.
* Bag:                                   Bag.
* Behavior:                              Behavior.
* BindingDictionary:                     BindingDictionary.
* BlockClosure:                          BlockClosure.
* BlockContext:                          BlockContext.
* Boolean:                               Boolean.
* ByteArray:                             ByteArray.
* ByteStream:                            ByteStream.
* CAggregate:                            CAggregate.
* CallinProcess:                         CallinProcess.
* CArray:                                CArray.
* CArrayCType:                           CArrayCType.
* CBoolean:                              CBoolean.
* CByte:                                 CByte.
* CChar:                                 CChar.
* CCompound:                             CCompound.
* CDouble:                               CDouble.
* CFloat:                                CFloat.
* CFunctionDescriptor:                   CFunctionDescriptor.
* Character:                             Character.
* CharacterArray:                        CharacterArray.
* CInt:                                  CInt.
* Class:                                 Class.
* ClassDescription:                      ClassDescription.
* CLong:                                 CLong.
* CObject:                               CObject.
* Collection:                            Collection.
* CompiledBlock:                         CompiledBlock.
* CompiledCode:                          CompiledCode.
* CompiledMethod:                        CompiledMethod.
* ContextPart:                           ContextPart.
* CoreException:                         CoreException.
* CPtr:                                  CPtr.
* CPtrCType:                             CPtrCType.
* CScalar:                               CScalar.
* CScalarCType:                          CScalarCType.
* CShort:                                CShort.
* CSmalltalk:                            CSmalltalk.
* CString:                               CString.
* CStringCType:                          CStringCType.
* CStruct:                               CStruct.
* CType:                                 CType.
* CUChar:                                CUChar.
* CUInt:                                 CUInt.
* CULong:                                CULong.
* CUnion:                                CUnion.
* CUShort:                               CUShort.
* Date:                                  Date.
* DateTime:                              DateTime.
* Delay:                                 Delay.
* DelayedAdaptor:                        DelayedAdaptor.
* Dictionary:                            Dictionary.
* DirectedMessage:                       DirectedMessage.
* Directory:                             Directory.
* DLD:                                   DLD.
* DumperProxy:                           DumperProxy.
* Duration:                              Duration.
* Error:                                 Error.
* Exception:                             Exception.
* ExceptionSet:                          ExceptionSet.
* False:                                 False.
* File:                                  File.
* FileDescriptor:                        FileDescriptor.
* FileSegment:                           FileSegment.
* FileStream:                            FileStream.
* Float:                                 Float.
* FloatD:                                FloatD.
* FloatE:                                FloatE.
* FloatQ:                                FloatQ.
* Fraction:                              Fraction.
* Halt:                                  Halt.
* HashedCollection:                      HashedCollection.
* HomedAssociation:                      HomedAssociation.
* IdentityDictionary:                    IdentityDictionary.
* IdentitySet:                           IdentitySet.
* Integer:                               Integer.
* Interval:                              Interval.
* LargeArray:                            LargeArray.
* LargeArrayedCollection:                LargeArrayedCollection.
* LargeArraySubpart:                     LargeArraySubpart.
* LargeByteArray:                        LargeByteArray.
* LargeInteger:                          LargeInteger.
* LargeNegativeInteger:                  LargeNegativeInteger.
* LargePositiveInteger:                  LargePositiveInteger.
* LargeWordArray:                        LargeWordArray.
* LargeZeroInteger:                      LargeZeroInteger.
* Link:                                  Link.
* LinkedList:                            LinkedList.
* LookupKey:                             LookupKey.
* LookupTable:                           LookupTable.
* Magnitude:                             Magnitude.
* MappedCollection:                      MappedCollection.
* Memory:                                Memory.
* Message:                               Message.
* MessageNotUnderstood:                  MessageNotUnderstood.
* Metaclass:                             Metaclass.
* MethodContext:                         MethodContext.
* MethodDictionary:                      MethodDictionary.
* MethodInfo:                            MethodInfo.
* Namespace:                             Namespace.
* NetClients.URIResolver:                NetClients.URIResolver.
* NetClients.URL:                        NetClients.URL.
* Notification:                          Notification.
* NullProxy:                             NullProxy.
* NullValueHolder:                       NullValueHolder.
* Number:                                Number.
* Object:                                Object.
* ObjectDumper:                          ObjectDumper.
* ObjectMemory:                          ObjectMemory.
* OrderedCollection:                     OrderedCollection.
* Package:                               Package.
* PackageLoader:                         PackageLoader.
* PluggableAdaptor:                      PluggableAdaptor.
* PluggableProxy:                        PluggableProxy.
* Point:                                 Point.
* PositionableStream:                    PositionableStream.
* Process:                               Process.
* ProcessorScheduler:                    ProcessorScheduler.
* Promise:                               Promise.
* Random:                                Random.
* ReadStream:                            ReadStream.
* ReadWriteStream:                       ReadWriteStream.
* Rectangle:                             Rectangle.
* RecursionLock:                         RecursionLock.
* RootNamespace:                         RootNamespace.
* RunArray:                              RunArray.
* ScaledDecimal:                         ScaledDecimal.
* Semaphore:                             Semaphore.
* SequenceableCollection:                SequenceableCollection.
* Set:                                   Set.
* SharedQueue:                           SharedQueue.
* Signal:                                Signal.
* SingletonProxy:                        SingletonProxy.
* SmallInteger:                          SmallInteger.
* SortedCollection:                      SortedCollection.
* Stream:                                Stream.
* String:                                String.
* Symbol:                                Symbol.
* SymLink:                               SymLink.
* SystemDictionary:                      SystemDictionary.
* SystemExceptions.AlreadyDefined:       SystemExceptions.AlreadyDefined.
* SystemExceptions.ArgumentOutOfRange:   SystemExceptions.ArgumentOutOfRange.
* SystemExceptions.BadReturn:            SystemExceptions.BadReturn.
* SystemExceptions.CInterfaceError:      SystemExceptions.CInterfaceError.
* SystemExceptions.EmptyCollection:      SystemExceptions.EmptyCollection.
* SystemExceptions.EndOfStream:          SystemExceptions.EndOfStream.
* SystemExceptions.FileError:            SystemExceptions.FileError.
* SystemExceptions.IndexOutOfRange:      SystemExceptions.IndexOutOfRange.
* SystemExceptions.InvalidArgument:      SystemExceptions.InvalidArgument.
* SystemExceptions.InvalidProcessState:  SystemExceptions.InvalidProcessState.
* SystemExceptions.InvalidSize:          SystemExceptions.InvalidSize.
* SystemExceptions.InvalidValue:         SystemExceptions.InvalidValue.
* SystemExceptions.MustBeBoolean:        SystemExceptions.MustBeBoolean.
* SystemExceptions.MutationError:        SystemExceptions.MutationError.
* SystemExceptions.NoRunnableProcess:    SystemExceptions.NoRunnableProcess.
* SystemExceptions.NotFound:             SystemExceptions.NotFound.
* SystemExceptions.NotImplemented:       SystemExceptions.NotImplemented.
* SystemExceptions.NotIndexable:         SystemExceptions.NotIndexable.
* SystemExceptions.NotYetImplemented:    SystemExceptions.NotYetImplemented.
* SystemExceptions.PrimitiveFailed:      SystemExceptions.PrimitiveFailed.
* SystemExceptions.ProcessBeingTerminated: SystemExceptions.ProcessBeingTerminated.
* SystemExceptions.ProcessTerminated:    SystemExceptions.ProcessTerminated.
* SystemExceptions.ReadOnlyObject:       SystemExceptions.ReadOnlyObject.
* SystemExceptions.ShouldNotImplement:   SystemExceptions.ShouldNotImplement.
* SystemExceptions.SubclassResponsibility: SystemExceptions.SubclassResponsibility.
* SystemExceptions.UserInterrupt:        SystemExceptions.UserInterrupt.
* SystemExceptions.VMError:              SystemExceptions.VMError.
* SystemExceptions.WrongArgumentCount:   SystemExceptions.WrongArgumentCount.
* SystemExceptions.WrongClass:           SystemExceptions.WrongClass.
* SystemExceptions.WrongMessageSent:     SystemExceptions.WrongMessageSent.
* TextCollector:                         TextCollector.
* Time:                                  Time.
* TokenStream:                           TokenStream.
* TrappableEvent:                        TrappableEvent.
* True:                                  True.
* UndefinedObject:                       UndefinedObject.
* ValueAdaptor:                          ValueAdaptor.
* ValueHolder:                           ValueHolder.
* VariableBinding:                       VariableBinding.
* VersionableObjectProxy:                VersionableObjectProxy.
* VFS.ArchiveFileHandler:                VFS.ArchiveFileHandler.
* VFS.ArchiveMemberHandler:              VFS.ArchiveMemberHandler.
* VFS.DecodedFileHandler:                VFS.DecodedFileHandler.
* VFS.ExternalArchiveFileHandler:        VFS.ExternalArchiveFileHandler.
* VFS.RealFileHandler:                   VFS.RealFileHandler.
* VFS.VFSHandler:                        VFS.VFSHandler.
* Warning:                               Warning.
* WeakArray:                             WeakArray.
* WeakIdentitySet:                       WeakIdentitySet.
* WeakKeyDictionary:                     WeakKeyDictionary.
* WeakKeyIdentityDictionary:             WeakKeyIdentityDictionary.
* WeakSet:                               WeakSet.
* WeakValueIdentityDictionary:           WeakValueIdentityDictionary.
* WeakValueLookupTable:                  WeakValueLookupTable.
* WordArray:                             WordArray.
* WriteStream:                           WriteStream.
* ZeroDivide:                            ZeroDivide.


File: gst-base.info,  Node: Method index,  Next: Cross-reference,  Prev: Class index,  Up: Top

Method index
************

* Menu:

* & <1>:                                 False-basic.
* & <2>:                                 Set-arithmetic.
* & <3>:                                 True-basic.
* &:                                     Boolean-basic.
* * <1>:                                 LargeZeroInteger-arithmetic.
* * <2>:                                 FloatQ-built ins.
* * <3>:                                 Point-arithmetic.
* * <4>:                                 ScaledDecimal-arithmetic.
* * <5>:                                 FloatE-built ins.
* * <6>:                                 Number-arithmetic.
* * <7>:                                 Fraction-arithmetic.
* * <8>:                                 SmallInteger-built ins.
* * <9>:                                 FloatD-built ins.
* * <10>:                                LargeInteger-arithmetic.
* *:                                     Duration-arithmetics.
* + <1>:                                 FloatE-built ins.
* + <2>:                                 LargeZeroInteger-arithmetic.
* + <3>:                                 CObject-pointer-like behavior.
* + <4>:                                 Duration-arithmetics.
* + <5>:                                 Number-arithmetic.
* + <6>:                                 Set-arithmetic.
* + <7>:                                 DateTime-basic.
* + <8>:                                 Point-arithmetic.
* + <9>:                                 Fraction-arithmetic.
* + <10>:                                LargePositiveInteger-arithmetic.
* + <11>:                                ScaledDecimal-arithmetic.
* + <12>:                                FloatD-built ins.
* + <13>:                                SmallInteger-built ins.
* + <14>:                                LargeInteger-arithmetic.
* + <15>:                                FloatQ-built ins.
* +:                                     LargeNegativeInteger-reverting to LargePositiveInteger.
* , <1>:                                 TrappableEvent-instance creation.
* , <2>:                                 ArrayedCollection-basic.
* , <3>:                                 String class-basic.
* , <4>:                                 Exception class-creating ExceptionCollections.
* ,:                                     SequenceableCollection-copying SequenceableCollections.
* - <1>:                                 FloatD-built ins.
* - <2>:                                 Duration-arithmetics.
* - <3>:                                 ScaledDecimal-arithmetic.
* - <4>:                                 Set-arithmetic.
* - <5>:                                 Fraction-arithmetic.
* - <6>:                                 DateTime-basic.
* - <7>:                                 LargeInteger-arithmetic.
* - <8>:                                 SmallInteger-built ins.
* - <9>:                                 FloatQ-built ins.
* - <10>:                                LargeNegativeInteger-reverting to LargePositiveInteger.
* - <11>:                                LargePositiveInteger-arithmetic.
* - <12>:                                Point-arithmetic.
* - <13>:                                LargeZeroInteger-arithmetic.
* - <14>:                                FloatE-built ins.
* - <15>:                                Number-arithmetic.
* -:                                     CObject-pointer-like behavior.
* ->:                                    Object-syntax shortcuts.
* / <1>:                                 FloatD-built ins.
* / <2>:                                 LargeInteger-arithmetic.
* / <3>:                                 Number-arithmetic.
* / <4>:                                 FloatE-built ins.
* / <5>:                                 LargeZeroInteger-arithmetic.
* / <6>:                                 Point-arithmetic.
* / <7>:                                 FloatQ-built ins.
* / <8>:                                 SmallInteger-built ins.
* / <9>:                                 Fraction-arithmetic.
* / <10>:                                ScaledDecimal-arithmetic.
* /:                                     Duration-arithmetics.
* // <1>:                                SmallInteger-built ins.
* // <2>:                                LargeInteger-arithmetic.
* // <3>:                                Fraction-arithmetic.
* // <4>:                                Number-arithmetic.
* // <5>:                                Point-arithmetic.
* // <6>:                                ScaledDecimal-arithmetic.
* //:                                    LargeZeroInteger-arithmetic.
* < <1>:                                 ScaledDecimal-comparing.
* < <2>:                                 CharacterArray-comparing.
* < <3>:                                 LargeInteger-testing.
* < <4>:                                 LargeArraySubpart-comparing.
* < <5>:                                 FloatQ-built ins.
* < <6>:                                 Point-comparing.
* < <7>:                                 Set-comparing.
* < <8>:                                 Character-comparing.
* < <9>:                                 Date-testing.
* < <10>:                                Time-comparing.
* < <11>:                                LookupKey-testing.
* < <12>:                                DateTime-testing.
* < <13>:                                SmallInteger-built ins.
* < <14>:                                FloatE-built ins.
* < <15>:                                Magnitude-basic.
* < <16>:                                Fraction-comparing.
* <:                                     FloatD-built ins.
* <<:                                    Stream-printing.
* <= <1>:                                FloatD-built ins.
* <= <2>:                                LargeInteger-testing.
* <= <3>:                                FloatE-built ins.
* <= <4>:                                Fraction-comparing.
* <= <5>:                                Character-comparing.
* <= <6>:                                CharacterArray-comparing.
* <= <7>:                                LargeArraySubpart-comparing.
* <= <8>:                                ScaledDecimal-comparing.
* <= <9>:                                FloatQ-built ins.
* <= <10>:                               Set-comparing.
* <= <11>:                               Magnitude-basic.
* <= <12>:                               SmallInteger-built ins.
* <=:                                    Point-comparing.
* = <1>:                                 LookupKey-testing.
* = <2>:                                 Rectangle-testing.
* = <3>:                                 LargeArrayedCollection-basic.
* = <4>:                                 ScaledDecimal-comparing.
* = <5>:                                 Time-comparing.
* = <6>:                                 Magnitude-basic.
* = <7>:                                 HashedCollection-testing collections.
* = <8>:                                 FloatE-built ins.
* = <9>:                                 CompiledCode-basic.
* = <10>:                                LargeArraySubpart-comparing.
* = <11>:                                Dictionary-testing.
* = <12>:                                Point-comparing.
* = <13>:                                Interval-testing.
* = <14>:                                CompiledMethod-basic.
* = <15>:                                NetClients.URL-comparing.
* = <16>:                                Symbol-built ins.
* = <17>:                                Object-built ins.
* = <18>:                                Association-testing.
* = <19>:                                Exception-comparison.
* = <20>:                                AbstractNamespace-basic & copying.
* = <21>:                                CompiledBlock-basic.
* = <22>:                                RunArray-testing.
* = <23>:                                FloatQ-built ins.
* = <24>:                                FloatD-built ins.
* = <25>:                                Class-testing.
* = <26>:                                SmallInteger-built ins.
* = <27>:                                Character-built ins.
* = <28>:                                Date-testing.
* = <29>:                                Delay-comparing.
* = <30>:                                SequenceableCollection-testing.
* = <31>:                                MethodInfo-equality.
* = <32>:                                LargeInteger-testing.
* = <33>:                                FileSegment-equality.
* = <34>:                                DateTime-testing.
* = <35>:                                Bag-testing collections.
* =:                                     Fraction-comparing.
* == <1>:                                SmallInteger-built ins.
* ==:                                    Object-built ins.
* > <1>:                                 CharacterArray-comparing.
* > <2>:                                 LargeInteger-testing.
* > <3>:                                 Character-comparing.
* > <4>:                                 SmallInteger-built ins.
* > <5>:                                 Point-comparing.
* > <6>:                                 ScaledDecimal-comparing.
* > <7>:                                 Magnitude-basic.
* > <8>:                                 FloatQ-built ins.
* > <9>:                                 FloatD-built ins.
* > <10>:                                Set-comparing.
* > <11>:                                FloatE-built ins.
* >:                                     Fraction-comparing.
* >= <1>:                                ScaledDecimal-comparing.
* >= <2>:                                FloatE-built ins.
* >= <3>:                                Set-comparing.
* >= <4>:                                Character-comparing.
* >= <5>:                                FloatD-built ins.
* >= <6>:                                LargeInteger-testing.
* >= <7>:                                CharacterArray-comparing.
* >= <8>:                                Magnitude-basic.
* >= <9>:                                FloatQ-built ins.
* >= <10>:                               SmallInteger-built ins.
* >= <11>:                               Fraction-comparing.
* >=:                                    Point-comparing.
* >>:                                    Behavior-accessing the methodDictionary.
* @:                                     Number-point creation.
* \\ <1>:                                LargeInteger-arithmetic.
* \\ <2>:                                Number-arithmetic.
* \\ <3>:                                LargeZeroInteger-arithmetic.
* \\ <4>:                                SmallInteger-built ins.
* \\ <5>:                                Fraction-arithmetic.
* \\:                                    ScaledDecimal-arithmetic.
* abbreviationOfDay_:                    Date class-basic.
* abort:                                 ObjectMemory class-builtins.
* abs <1>:                               LargeNegativeInteger-numeric testing.
* abs <2>:                               Point-arithmetic.
* abs <3>:                               Duration-arithmetics.
* abs <4>:                               LargePositiveInteger-numeric testing.
* abs:                                   Number-misc math.
* acceptUsageForClass_ <1>:              AlternativeObjectProxy class-instance creation.
* acceptUsageForClass_ <2>:              DumperProxy class-accessing.
* acceptUsageForClass_:                  SingletonProxy class-accessing.
* accesses_ <1>:                         CompiledCode-testing accesses.
* accesses_:                             CompiledMethod-testing.
* activePriority:                        ProcessorScheduler-basic.
* activeProcess:                         ProcessorScheduler-basic.
* add_ <1>:                              Bag-adding.
* add_ <2>:                              Dictionary-accessing.
* add_ <3>:                              WeakSet-accessing.
* add_ <4>:                              HashedCollection-accessing.
* add_ <5>:                              WeakKeyDictionary-accessing.
* add_ <6>:                              LinkedList-adding.
* add_ <7>:                              BindingDictionary-forward declarations.
* add_ <8>:                              Collection-adding.
* add_ <9>:                              ArrayedCollection-basic.
* add_ <10>:                             OrderedCollection-adding.
* add_ <11>:                             MappedCollection-basic.
* add_:                                  LookupTable-accessing.
* add_after_:                            OrderedCollection-adding.
* add_afterIndex_ <1>:                   OrderedCollection-adding.
* add_afterIndex_ <2>:                   SortedCollection-disabled.
* add_afterIndex_:                       RunArray-adding.
* add_before_:                           OrderedCollection-adding.
* add_beforeIndex_:                      OrderedCollection-adding.
* add_withOccurrences_:                  Bag-adding.
* addAll_ <1>:                           Collection-adding.
* addAll_:                               OrderedCollection-adding.
* addAll_after_:                         OrderedCollection-adding.
* addAll_afterIndex_ <1>:                SortedCollection-disabled.
* addAll_afterIndex_ <2>:                RunArray-adding.
* addAll_afterIndex_:                    OrderedCollection-adding.
* addAll_before_:                        OrderedCollection-adding.
* addAll_beforeIndex_:                   OrderedCollection-adding.
* addAllFirst_ <1>:                      SortedCollection-disabled.
* addAllFirst_ <2>:                      OrderedCollection-adding.
* addAllFirst_:                          RunArray-adding.
* addAllLast_ <1>:                       OrderedCollection-adding.
* addAllLast_ <2>:                       RunArray-adding.
* addAllLast_:                           SortedCollection-disabled.
* addClassVarName_ <1>:                  Class-accessing instances and variables.
* addClassVarName_:                      Metaclass-delegation.
* addDays_:                              Date-basic.
* addDependent_ <1>:                     Object-dependents access.
* addDependent_:                         UndefinedObject-dependents access.
* addFeature_:                           SystemDictionary-special accessing.
* addFirst_ <1>:                         RunArray-adding.
* addFirst_ <2>:                         OrderedCollection-adding.
* addFirst_ <3>:                         LinkedList-adding.
* addFirst_:                             SortedCollection-disabled.
* addInstVarName_:                       Behavior-instance variables.
* addLast_ <1>:                          RunArray-adding.
* addLast_ <2>:                          LinkedList-adding.
* addLast_ <3>:                          SortedCollection-disabled.
* addLast_:                              OrderedCollection-adding.
* addLibrary_:                           DLD class-dynamic linking.
* addModule_:                            DLD class-dynamic linking.
* address <1>:                           CObject-accessing.
* address:                               CFunctionDescriptor-accessing.
* address_ <1>:                          CFunctionDescriptor-accessing.
* address_ <2>:                          CObject-accessing.
* address_ <3>:                          CObject class-instance creation.
* address_:                              CType-C instance creation.
* addressAt_:                            CObject-pointer-like behavior.
* addressOf_ <1>:                        ObjectMemory class-builtins.
* addressOf_:                            CFunctionDescriptor class-testing.
* addressOfOOP_:                         ObjectMemory class-builtins.
* addSelector_withMethod_:               Behavior-method dictionary.
* addSharedPool_ <1>:                    Metaclass-delegation.
* addSharedPool_:                        Class-accessing instances and variables.
* addSubclass_:                          Behavior-creating a class hierarchy.
* addSubspace_:                          AbstractNamespace-namespace hierarchy.
* addTime_:                              Time-arithmetic.
* addToBeFinalized:                      Object-finalization.
* after_:                                SequenceableCollection-basic.
* alignof <1>:                           CShort class-accessing.
* alignof <2>:                           CFloat-accessing.
* alignof <3>:                           CFloat class-accessing.
* alignof <4>:                           CDouble-accessing.
* alignof <5>:                           CDouble class-accessing.
* alignof <6>:                           CCompound class-subclass creation.
* alignof <7>:                           CChar-accessing.
* alignof <8>:                           CChar class-accessing.
* alignof <9>:                           CArrayCType-accessing.
* alignof <10>:                          CArray-accessing.
* alignof <11>:                          CInt class-accessing.
* alignof <12>:                          CInt-accessing.
* alignof <13>:                          CUShort-accessing.
* alignof <14>:                          CUShort class-accessing.
* alignof <15>:                          CULong-accessing.
* alignof <16>:                          CULong class-accessing.
* alignof <17>:                          CUInt-accessing.
* alignof <18>:                          CUInt class-accessing.
* alignof <19>:                          CUChar-accessing.
* alignof <20>:                          CUChar class-getting info.
* alignof <21>:                          CAggregate class-accessing.
* alignof <22>:                          CType-accessing.
* alignof <23>:                          CSmalltalk-accessing.
* alignof <24>:                          CSmalltalk class-accessing.
* alignof <25>:                          CShort-accessing.
* alignof <26>:                          CLong class-accessing.
* alignof <27>:                          CLong-accessing.
* alignof:                               CPtr-accessing.
* alignTo_:                              Integer-extension.
* aliveObjectsDo_:                       WeakArray-accessing.
* allAssociations:                       AbstractNamespace-accessing.
* allBehaviorsDo_:                       AbstractNamespace-accessing.
* allBlocksDo_:                          CompiledMethod-accessing.
* allClassesDo_:                         AbstractNamespace-accessing.
* allClassObjectsDo_:                    AbstractNamespace-accessing.
* allClassVarNames <1>:                  Metaclass-delegation.
* allClassVarNames <2>:                  Class-accessing instances and variables.
* allClassVarNames:                      Behavior-accessing instances and variables.
* allExceptionsDo_ <1>:                  TrappableEvent-enumerating.
* allExceptionsDo_ <2>:                  ExceptionSet-enumerating.
* allExceptionsDo_ <3>:                  Exception class-interoperability with TrappableEvents.
* allExceptionsDo_:                      CoreException-enumerating.
* allInstances:                          Behavior-accessing instances and variables.
* allInstancesDo_:                       Behavior-enumerating.
* allInstVarNames:                       Behavior-accessing instances and variables.
* allLiterals:                           CompiledMethod-accessing.
* allMask_:                              Integer-bit operators.
* allMetaclassesDo_:                     AbstractNamespace-accessing.
* alloc_:                                CObject class-instance creation.
* alloc_type_:                           CObject class-instance creation.
* allocFailures:                         ObjectMemory-accessing.
* allocMatches:                          ObjectMemory-accessing.
* allocProbes:                           ObjectMemory-accessing.
* allocSplits:                           ObjectMemory-accessing.
* allSatisfy_:                           Collection-enumeration.
* allSelectors:                          Behavior-accessing the methodDictionary.
* allSharedPools <1>:                    Metaclass-delegation.
* allSharedPools:                        Behavior-accessing instances and variables.
* allSubassociationsDo_:                 AbstractNamespace-namespace hierarchy.
* allSubclasses:                         Behavior-accessing class hierarchy.
* allSubclassesDo_:                      Behavior-enumerating.
* allSubinstancesDo_:                    Behavior-enumerating.
* allSubspaces:                          AbstractNamespace-namespace hierarchy.
* allSubspacesDo_:                       AbstractNamespace-namespace hierarchy.
* allSuperclasses:                       Behavior-accessing class hierarchy.
* allSuperclassesDo_:                    Behavior-enumerating.
* allSuperspaces:                        AbstractNamespace-namespace hierarchy.
* allSuperspacesDo_:                     AbstractNamespace-namespace hierarchy.
* amountToTranslateWithin_:              Rectangle-rectangle functions.
* and_ <1>:                              False-basic.
* and_ <2>:                              True-basic.
* and_:                                  Boolean-basic.
* anyMask_:                              Integer-bit operators.
* anyOne <1>:                            SequenceableCollection-enumerating.
* anyOne:                                Collection-enumeration.
* anySatisfy_:                           Collection-enumeration.
* append:                                FileDescriptor class-instance creation.
* append_to_:                            Directory class-file name management.
* arcCos <1>:                            Float-built ins.
* arcCos:                                Number-misc math.
* arcSin <1>:                            Float-built ins.
* arcSin:                                Number-misc math.
* arcTan <1>:                            Point-point functions.
* arcTan <2>:                            Float-built ins.
* arcTan:                                Number-misc math.
* area:                                  Rectangle-rectangle functions.
* areasOutside_:                         Rectangle-rectangle functions.
* argument <1>:                          Signal-accessing.
* argument:                              Message-accessing.
* argumentCount <1>:                     BlockClosure-accessing.
* argumentCount:                         Signal-accessing.
* arguments <1>:                         Signal-accessing.
* arguments <2>:                         Message-accessing.
* arguments:                             SystemDictionary-miscellaneous.
* arguments_:                            Message-accessing.
* arithmeticError_:                      Number-error raising.
* arrayType_:                            CType-accessing.
* article <1>:                           Behavior-support for lightweight classes.
* article:                               Class-printing.
* asArray <1>:                           WeakArray-conversion.
* asArray:                               Collection-converting.
* asBag:                                 Collection-converting.
* asByteArray <1>:                       String-converting.
* asByteArray <2>:                       CharacterArray-converting.
* asByteArray:                           Collection-converting.
* asCBooleanValue <1>:                   True-C hacks.
* asCBooleanValue <2>:                   Boolean-C hacks.
* asCBooleanValue:                       False-C hacks.
* asCData_ <1>:                          ByteArray-built ins.
* asCData_:                              String-built ins.
* asCharacter:                           Integer-converting.
* asciiValue:                            Character-built ins.
* asciiValue_:                           Character class-built ins.
* asClass <1>:                           Class-testing functionality.
* asClass <2>:                           Metaclass-testing functionality.
* asClass <3>:                           Behavior-support for lightweight classes.
* asClass:                               ClassDescription-conversion.
* asClassPoolKey:                        CharacterArray-converting.
* asDate:                                DateTime-splitting in dates & times.
* asExactFraction:                       Float-coercing.
* asFloat <1>:                           Number-converting.
* asFloat:                               Float-coercing.
* asFloatD <1>:                          SmallInteger-built ins.
* asFloatD <2>:                          FloatE-built ins.
* asFloatD <3>:                          FloatD-coercing.
* asFloatD <4>:                          LargeNegativeInteger-converting.
* asFloatD <5>:                          Fraction-converting.
* asFloatD <6>:                          LargePositiveInteger-converting.
* asFloatD <7>:                          FloatQ-built ins.
* asFloatD <8>:                          ScaledDecimal-coercion.
* asFloatD:                              Number-converting.
* asFloatE <1>:                          Fraction-converting.
* asFloatE <2>:                          FloatE-coercing.
* asFloatE <3>:                          LargePositiveInteger-converting.
* asFloatE <4>:                          SmallInteger-built ins.
* asFloatE <5>:                          FloatQ-built ins.
* asFloatE <6>:                          LargeNegativeInteger-converting.
* asFloatE <7>:                          FloatD-built ins.
* asFloatE <8>:                          ScaledDecimal-coercion.
* asFloatE:                              Number-converting.
* asFloatQ <1>:                          LargeNegativeInteger-converting.
* asFloatQ <2>:                          FloatQ-coercing.
* asFloatQ <3>:                          ScaledDecimal-coercion.
* asFloatQ <4>:                          LargePositiveInteger-converting.
* asFloatQ <5>:                          Number-converting.
* asFloatQ <6>:                          FloatD-built ins.
* asFloatQ <7>:                          Fraction-converting.
* asFloatQ <8>:                          FloatE-built ins.
* asFloatQ:                              SmallInteger-built ins.
* asFraction <1>:                        ScaledDecimal-coercion.
* asFraction <2>:                        Float-coercing.
* asFraction <3>:                        Fraction-converting.
* asFraction:                            Integer-converting.
* asGlobalKey:                           CharacterArray-converting.
* asInteger <1>:                         Character-built ins.
* asInteger <2>:                         Number-truncation and round off.
* asInteger:                             CharacterArray-converting.
* asLocal:                               DateTime-time zones.
* asLowercase <1>:                       CharacterArray-converting.
* asLowercase:                           Character-coercion methods.
* asMetaclass:                           ClassDescription-conversion.
* asNumber:                              CharacterArray-converting.
* asObject <1>:                          SmallInteger-built ins.
* asObject:                              LargeInteger-disabled.
* asObjectNoFail <1>:                    LargeInteger-disabled.
* asObjectNoFail:                        SmallInteger-built ins.
* asOop:                                 Object-built ins.
* asOrderedCollection:                   Collection-converting.
* asPoint <1>:                           Point-converting.
* asPoint:                               Number-point creation.
* asPoolKey:                             CharacterArray-converting.
* asRectangle <1>:                       Point-converting.
* asRectangle:                           Number-converting.
* asRunArray:                            Collection-converting.
* asScaledDecimal_ <1>:                  Number-converting.
* asScaledDecimal_:                      Integer-converting.
* asScaledDecimal_scale_:                Number-converting.
* asSeconds <1>:                         Date-date computations.
* asSeconds <2>:                         Time-accessing (non ANSI & for Durations).
* asSeconds:                             DateTime-computations.
* asSet <1>:                             Bag-enumerating the elements of a collection.
* asSet:                                 Collection-converting.
* assigns_ <1>:                          CompiledCode-testing accesses.
* assigns_:                              CompiledMethod-testing.
* associationAt_:                        Dictionary-accessing.
* associationAt_ifAbsent_ <1>:           LookupTable-accessing.
* associationAt_ifAbsent_ <2>:           Namespace-overrides for superspaces.
* associationAt_ifAbsent_:               Dictionary-accessing.
* associationsDo_ <1>:                   Namespace-overrides for superspaces.
* associationsDo_ <2>:                   Dictionary-dictionary enumerating.
* associationsDo_:                       LookupTable-enumerating.
* asSortedCollection:                    Collection-converting.
* asSortedCollection_:                   Collection-converting.
* asString <1>:                          Symbol-converting.
* asString <2>:                          CharacterArray-converting.
* asString <3>:                          String-converting.
* asString <4>:                          Character-coercion methods.
* asString <5>:                          ByteArray-converting.
* asString:                              FileSegment-basic.
* asSymbol <1>:                          Character-coercion methods.
* asSymbol <2>:                          CharacterArray-converting.
* asSymbol <3>:                          String-converting.
* asSymbol:                              Symbol-converting.
* asTime:                                DateTime-splitting in dates & times.
* asUppercase <1>:                       Character-coercion methods.
* asUppercase:                           CharacterArray-converting.
* asUTC:                                 DateTime-time zones.
* asValue:                               Object-conversion.
* asyncCallFrom_:                        CFunctionDescriptor-calling.
* asyncCallNoRetryFrom_:                 CFunctionDescriptor-calling.
* at_ <1>:                               LargeInteger-built-ins.
* at_ <2>:                               LargeZeroInteger-accessing.
* at_ <3>:                               Link-iteration.
* at_ <4>:                               OrderedCollection-accessing.
* at_ <5>:                               VFS.ArchiveFileHandler-directory operations.
* at_ <6>:                               Dictionary-accessing.
* at_ <7>:                               SmallInteger-builtins.
* at_ <8>:                               LinkedList-accessing.
* at_ <9>:                               Interval-basic.
* at_ <10>:                              HashedCollection-accessing.
* at_ <11>:                              VFS.ArchiveMemberHandler-directory operations.
* at_ <12>:                              String-built ins.
* at_ <13>:                              WeakArray-accessing.
* at_ <14>:                              DateTime-splitting in dates & times.
* at_ <15>:                              RunArray-accessing.
* at_ <16>:                              MappedCollection-basic.
* at_ <17>:                              Object-built ins.
* at_ <18>:                              Memory class-accessing.
* at_ <19>:                              LargeArrayedCollection-accessing.
* at_ <20>:                              Directory-accessing.
* at_ <21>:                              VFS.VFSHandler-directory operations.
* at_:                                   CObject-pointer-like behavior.
* at_ifAbsent_ <1>:                      SequenceableCollection-basic.
* at_ifAbsent_ <2>:                      WeakValueLookupTable-hacks.
* at_ifAbsent_ <3>:                      Dictionary-accessing.
* at_ifAbsent_ <4>:                      Namespace-overrides for superspaces.
* at_ifAbsent_:                          LookupTable-accessing.
* at_ifAbsentPut_:                       Dictionary-accessing.
* at_ifPresent_ <1>:                     WeakValueLookupTable-hacks.
* at_ifPresent_ <2>:                     LookupTable-accessing.
* at_ifPresent_ <3>:                     Namespace-overrides for superspaces.
* at_ifPresent_:                         Dictionary-accessing.
* at_put_ <1>:                           LargeInteger-built-ins.
* at_put_ <2>:                           CompiledCode-accessing.
* at_put_ <3>:                           HashedCollection-accessing.
* at_put_ <4>:                           LookupTable-accessing.
* at_put_ <5>:                           Memory class-accessing.
* at_put_ <6>:                           Dictionary-accessing.
* at_put_ <7>:                           LargeArrayedCollection-accessing.
* at_put_ <8>:                           BindingDictionary-forward declarations.
* at_put_ <9>:                           CObject-pointer-like behavior.
* at_put_ <10>:                          SortedCollection-disabled.
* at_put_ <11>:                          Interval-basic.
* at_put_ <12>:                          LinkedList-accessing.
* at_put_ <13>:                          MethodDictionary-adding.
* at_put_ <14>:                          SmallInteger-builtins.
* at_put_ <15>:                          OrderedCollection-accessing.
* at_put_ <16>:                          Link-iteration.
* at_put_ <17>:                          WeakKeyDictionary-accessing.
* at_put_ <18>:                          String-built ins.
* at_put_ <19>:                          RunArray-accessing.
* at_put_ <20>:                          WeakArray-accessing.
* at_put_ <21>:                          Object-built ins.
* at_put_:                               MappedCollection-basic.
* at_put_type_:                          CObject-C data access.
* at_type_:                              CObject-C data access.
* atAll_put_ <1>:                        SequenceableCollection-basic.
* atAll_put_:                            WeakArray-accessing.
* atAllPut_ <1>:                         SequenceableCollection-basic.
* atAllPut_:                             WeakArray-accessing.
* atEnd <1>:                             TokenStream-basic.
* atEnd <2>:                             FileDescriptor-testing.
* atEnd <3>:                             Stream-testing.
* atEnd <4>:                             FileStream-testing.
* atEnd <5>:                             PositionableStream-testing.
* atEnd <6>:                             Random-basic.
* atEnd:                                 ObjectDumper-stream interface.
* backspace:                             Character class-constants.
* backtrace <1>:                         SystemDictionary-miscellaneous.
* backtrace <2>:                         ContextPart class-exception handling.
* backtrace:                             ContextPart-printing.
* backtraceOn_ <1>:                      ContextPart-printing.
* backtraceOn_:                          ContextPart class-exception handling.
* badReturnError:                        Object-exception handling.
* basicAt_ <1>:                          Object-built ins.
* basicAt_ <2>:                          CharacterArray-basic.
* basicAt_ <3>:                          SmallInteger-builtins.
* basicAt_:                              String-built ins.
* basicAt_put_ <1>:                      Object-built ins.
* basicAt_put_ <2>:                      String-built ins.
* basicAt_put_ <3>:                      SmallInteger-builtins.
* basicAt_put_:                          CharacterArray-basic.
* basicAtEnd:                            PositionableStream-testing.
* basicBacktrace:                        SystemDictionary-builtins.
* basicFlush:                            FileStream-buffering.
* basicLeftShift_:                       LargeInteger-primitive operations.
* basicMessageText:                      Signal-accessing.
* basicNew:                              Behavior-built ins.
* basicNew_:                             Behavior-built ins.
* basicNewInFixedSpace:                  Behavior-built ins.
* basicNewInFixedSpace_:                 Behavior-built ins.
* basicPosition_:                        PositionableStream-positioning.
* basicPrint:                            Object-built ins.
* basicPrintNl:                          Object-printing.
* basicPrintOn_:                         Object-printing.
* basicRightShift_:                      LargeInteger-primitive operations.
* basicSize:                             Object-built ins.
* become_:                               Object-built ins.
* beConsistent <1>:                      SortedCollection-enumerating.
* beConsistent:                          Collection-enumeration.
* before_:                               SequenceableCollection-basic.
* bell:                                  Character class-constants.
* between_and_ <1>:                      Random class-shortcuts.
* between_and_ <2>:                      Magnitude-misc methods.
* between_and_:                          Random-basic.
* bigEndian:                             Memory class-accessing.
* bigObjectThreshold:                    ObjectMemory class-builtins.
* bigObjectThreshold_:                   ObjectMemory class-builtins.
* binaryRepresentationObject <1>:        CompiledBlock-saving and loading.
* binaryRepresentationObject <2>:        VariableBinding-saving and loading.
* binaryRepresentationObject <3>:        Object-saving and loading.
* binaryRepresentationObject:            CompiledMethod-saving and loading.
* binaryRepresentationVersion:           Class-saving and loading.
* binding:                               ClassDescription-conversion.
* bindingFor_:                           Class-accessing instances and variables.
* bindWith_:                             CharacterArray-string processing.
* bindWith_with_:                        CharacterArray-string processing.
* bindWith_with_with_:                   CharacterArray-string processing.
* bindWith_with_with_with_:              CharacterArray-string processing.
* bindWithArguments_:                    CharacterArray-string processing.
* binomial_:                             Integer-math methods.
* bitAnd_ <1>:                           SmallInteger-built ins.
* bitAnd_:                               LargeInteger-bit operations.
* bitAt_ <1>:                            LargeInteger-bit operations.
* bitAt_:                                Integer-bit operators.
* bitAt_put_:                            Integer-bit operators.
* bitClear_:                             Integer-bit operators.
* bitInvert <1>:                         Integer-bit operators.
* bitInvert:                             LargeInteger-bit operations.
* bitOr_ <1>:                            LargeInteger-bit operations.
* bitOr_:                                SmallInteger-built ins.
* bits:                                  SmallInteger class-getting limits.
* bitShift_ <1>:                         LargeInteger-bit operations.
* bitShift_:                             SmallInteger-built ins.
* bitXor_ <1>:                           SmallInteger-built ins.
* bitXor_:                               LargeInteger-bit operations.
* block:                                 BlockClosure-accessing.
* block_ <1>:                            BlockClosure-accessing.
* block_:                                BlockClosure class-instance creation.
* blockAt_:                              CompiledCode-accessing.
* blockCopy_:                            BlockClosure-built ins.
* bottom:                                Rectangle-accessing.
* bottom_:                               Rectangle-accessing.
* bottomCenter:                          Rectangle-accessing.
* bottomLeft:                            Rectangle-accessing.
* bottomLeft_:                           Rectangle-accessing.
* bottomRight:                           Rectangle-accessing.
* bottomRight_:                          Rectangle-accessing.
* breakpoint_return_:                    Object-debugging.
* broadcast_:                            Object-change and update.
* broadcast_with_:                       Object-change and update.
* broadcast_with_with_:                  Object-change and update.
* broadcast_withArguments_:              Object-change and update.
* broadcast_withBlock_:                  Object-change and update.
* bufferSize:                            FileStream-buffering.
* bufferSize_:                           FileStream-buffering.
* builtFiles:                            Package-accessing.
* builtFilesFor_:                        PackageLoader class-accessing.
* byteAt_:                               ByteArray-built ins.
* byteAt_put_:                           ByteArray-built ins.
* bytecodeAt_:                           CompiledCode-accessing.
* bytecodeAt_put_:                       CompiledCode-accessing.
* byteCodeCounter:                       SystemDictionary-builtins.
* bytes_from_compare_:                   LargePositiveInteger-helper byte-level methods.
* bytes_from_subtract_:                  LargePositiveInteger-helper byte-level methods.
* bytes_multiply_:                       LargePositiveInteger-helper byte-level methods.
* bytesLeftShift_:                       LargePositiveInteger-helper byte-level methods.
* bytesLeftShift_big_:                   LargePositiveInteger-helper byte-level methods.
* bytesLeftShift_n_:                     LargePositiveInteger-helper byte-level methods.
* bytesPerOOP:                           ObjectMemory-accessing.
* bytesPerOTE:                           ObjectMemory-accessing.
* bytesRightShift_big_:                  LargePositiveInteger-helper byte-level methods.
* bytesRightShift_n_:                    LargePositiveInteger-helper byte-level methods.
* bytesTrailingZeros_:                   LargePositiveInteger-helper byte-level methods.
* caller:                                BlockContext-accessing.
* callFrom_into_:                        CFunctionDescriptor-calling.
* callNoRetryFrom_into_:                 CFunctionDescriptor-calling.
* callouts:                              Package-accessing.
* calloutsFor_:                          PackageLoader class-accessing.
* canCache:                              NetClients.URL-testing.
* canLoad_:                              PackageLoader class-testing.
* canRead:                               FileDescriptor-accessing.
* canUnderstand_:                        Behavior-testing the method dictionary.
* canWrite:                              FileDescriptor-accessing.
* capacity <1>:                          HashedCollection-testing collections.
* capacity:                              Collection-testing collections.
* castTo_:                               CObject-conversion.
* categoriesFor_are_:                    Class-instance creation - alternative.
* category <1>:                          Metaclass-delegation.
* category <2>:                          MethodInfo-accessing.
* category:                              Class-accessing instances and variables.
* category_ <1>:                         Class-accessing instances and variables.
* category_:                             MethodInfo-accessing.
* ceiling <1>:                           Fraction-coercing.
* ceiling <2>:                           Float-built ins.
* ceiling <3>:                           ScaledDecimal-coercion.
* ceiling:                               Integer-converting.
* center:                                Rectangle-accessing.
* changeClassTo_:                        Object-built ins.
* changed:                               Object-change and update.
* changed_:                              Object-change and update.
* changePriorityListOf_to_suspend_:      ProcessorScheduler-basic.
* charAt_ <1>:                           ByteArray-more advanced accessing.
* charAt_:                               Memory class-accessing.
* charAt_put_ <1>:                       ByteArray-more advanced accessing.
* charAt_put_:                           Memory class-accessing.
* checkError:                            File class-file operations.
* checkError_:                           File class-file operations.
* checkIndexableBounds_:                 Object-built ins.
* checkIndexableBounds_put_:             Object-built ins.
* chiSquare:                             Random-testing.
* chiSquare_range_:                      Random-testing.
* class:                                 Object-built ins.
* class_from_:                           Autoload class-instance creation.
* class_in_from_:                        Autoload class-instance creation.
* classAt_:                              AbstractNamespace-accessing.
* classAt_ifAbsent_:                     AbstractNamespace-accessing.
* classify_under_:                       ClassDescription-organization of messages and classes.
* classPool <1>:                         Class-accessing instances and variables.
* classPool <2>:                         Metaclass-delegation.
* classPool:                             Behavior-accessing instances and variables.
* classVariableString:                   ClassDescription-printing.
* classVarNames <1>:                     Class-accessing instances and variables.
* classVarNames <2>:                     Metaclass-delegation.
* classVarNames:                         Behavior-accessing instances and variables.
* clean:                                 FileStream-buffering.
* clearBit_:                             Integer-bit operators.
* clearGCFlag_:                          WeakArray-accessing.
* client:                                ContextPart-accessing.
* clockPrecision:                        DateTime class-information.
* close <1>:                             PositionableStream-accessing-reading.
* close <2>:                             FileDescriptor-basic.
* close:                                 Stream-providing consistent protocols.
* closeDir_:                             VFS.VFSHandler-C functions.
* closeTo_:                              Number-testing.
* cObjectType:                           CType-accessing.
* cObjectType_:                          CType class-C instance creation.
* cObjStoredType <1>:                    CString-accessing.
* cObjStoredType:                        CScalar-accessing.
* codePoint:                             Character-built ins.
* codePoint_:                            Character class-built ins.
* coerce_ <1>:                           FloatD-coercing.
* coerce_ <2>:                           FloatQ class-converting.
* coerce_ <3>:                           ScaledDecimal-coercion.
* coerce_ <4>:                           Integer class-converting.
* coerce_ <5>:                           FloatE-coercing.
* coerce_ <6>:                           Number-converting.
* coerce_ <7>:                           Fraction-coercing.
* coerce_ <8>:                           FloatQ-coercing.
* coerce_ <9>:                           Fraction class-converting.
* coerce_ <10>:                          FloatD class-converting.
* coerce_ <11>:                          LargeInteger-coercion.
* coerce_ <12>:                          Integer-converting.
* coerce_ <13>:                          Number class-converting.
* coerce_:                               FloatE class-converting.
* collect_ <1>:                          Dictionary-dictionary enumerating.
* collect_ <2>:                          MappedCollection-basic.
* collect_ <3>:                          Interval-basic.
* collect_ <4>:                          Collection-enumeration.
* collect_:                              ArrayedCollection-enumerating the elements of a collection.
* collection:                            SystemExceptions.IndexOutOfRange-accessing.
* collection_:                           SystemExceptions.IndexOutOfRange-accessing.
* collection_map_:                       MappedCollection class-instance creation.
* comment <1>:                           Metaclass-delegation.
* comment:                               Class-accessing instances and variables.
* comment_:                              Class-accessing instances and variables.
* compact:                               ObjectMemory class-builtins.
* compile_:                              Behavior-method dictionary.
* compile_classified_:                   ClassDescription-compiling.
* compile_classified_ifError_:           ClassDescription-compiling.
* compile_classified_notifying_:         ClassDescription-compiling.
* compile_ifError_:                      Behavior-method dictionary.
* compile_notifying_:                    Behavior-method dictionary.
* compileAll:                            Behavior-method dictionary.
* compileAll_:                           Behavior-method dictionary.
* compileAllSubclasses:                  Behavior-method dictionary.
* compileAllSubclasses_:                 Behavior-method dictionary.
* compileDeclaration_ <1>:               CCompound class-subclass creation.
* compileDeclaration_ <2>:               CStruct class-subclass creation.
* compileDeclaration_:                   CUnion class-subclass creation.
* compileDeclaration_inject_into_:       CCompound class-subclass creation.
* compiledMethodAt_:                     Behavior-accessing the methodDictionary.
* compiledMethodAt_ifAbsent_:            Behavior-accessing the methodDictionary.
* compilerClass:                         Behavior-pluggable behavior (not yet implemented).
* compileSize_align_:                    CCompound class-subclass creation.
* compileString_:                        Behavior-built ins.
* compileString_ifError_:                Behavior-built ins.
* compress:                              LargeArrayedCollection-accessing.
* computeAggregateType_block_:           CCompound class-subclass creation.
* computeArrayType_block_:               CCompound class-subclass creation.
* computePtrType_block_:                 CCompound class-subclass creation.
* computeTypeString_block_:              CCompound class-subclass creation.
* conform_:                              Collection-enumeration.
* construct_:                            NetClients.URL-utilities.
* contains_ <1>:                         Rectangle-testing.
* contains_:                             Collection-enumeration.
* containsLiteral_:                      CompiledCode-testing accesses.
* containsPoint_:                        Rectangle-testing.
* contents <1>:                          Directory-enumerating.
* contents <2>:                          File-file operations.
* contents <3>:                          MappedCollection-basic.
* contents <4>:                          FileDescriptor-basic.
* contents <5>:                          WriteStream-accessing-writing.
* contents <6>:                          PositionableStream-accessing-reading.
* contents:                              Stream-accessing-reading.
* continue_:                             ContextPart-built ins.
* contractTo_:                           CharacterArray-string processing.
* convertFromVersion_withFixedVariables_indexedVariables_for_: Class-saving and loading.
* copy <1>:                              BindingDictionary-copying.
* copy <2>:                              Rectangle-copying.
* copy <3>:                              Object-copying.
* copy:                                  UndefinedObject-basic.
* copy_from_:                            ClassDescription-copying.
* copy_from_classified_:                 ClassDescription-copying.
* copyAll_from_:                         ClassDescription-copying.
* copyAll_from_classified_:              ClassDescription-copying.
* copyAllCategoriesFrom_:                ClassDescription-copying.
* copyCategory_from_:                    ClassDescription-copying.
* copyCategory_from_classified_:         ClassDescription-copying.
* copyEmpty_ <1>:                        BindingDictionary-copying.
* copyEmpty_ <2>:                        SortedCollection-copying.
* copyEmpty_:                            AbstractNamespace-copying.
* copyEmptyForCollect:                   BindingDictionary-copying.
* copyFrom_:                             SequenceableCollection-copying SequenceableCollections.
* copyFrom_to_ <1>:                      FileDescriptor-basic.
* copyFrom_to_ <2>:                      SequenceableCollection-copying SequenceableCollections.
* copyFrom_to_ <3>:                      ArrayedCollection-basic.
* copyFrom_to_ <4>:                      FileStream-basic.
* copyFrom_to_:                          PositionableStream-accessing-reading.
* copyReplaceAll_with_ <1>:              ArrayedCollection-copying Collections.
* copyReplaceAll_with_:                  SequenceableCollection-copying SequenceableCollections.
* copyReplaceFrom_to_with_ <1>:          ArrayedCollection-copying Collections.
* copyReplaceFrom_to_with_:              SequenceableCollection-copying SequenceableCollections.
* copyReplaceFrom_to_withObject_ <1>:    ArrayedCollection-copying Collections.
* copyReplaceFrom_to_withObject_:        SequenceableCollection-copying SequenceableCollections.
* copyReplacing_withObject_:             Collection-copying Collections.
* copyUpTo_:                             SequenceableCollection-copying SequenceableCollections.
* copyWith_ <1>:                         Collection-copying Collections.
* copyWith_:                             ArrayedCollection-basic.
* copyWithout_ <1>:                      Collection-copying Collections.
* copyWithout_:                          ArrayedCollection-basic.
* copyWithoutAuxiliaryParts:             NetClients.URL-copying.
* copyWithoutFragment:                   NetClients.URL-copying.
* coreException:                         Exception class-interoperability with TrappableEvents.
* corner:                                Rectangle-accessing.
* corner_ <1>:                           Rectangle-accessing.
* corner_:                               Point-converting.
* cos <1>:                               Float-built ins.
* cos:                                   Number-misc math.
* costOfNewIndex:                        LargeByteArray-overridden.
* cr <1>:                                Character class-constants.
* cr <2>:                                TextCollector-accessing.
* cr:                                    Stream-character writing.
* create:                                FileDescriptor class-instance creation.
* create_:                               Directory class-file operations.
* createDir_ <1>:                        VFS.ExternalArchiveFileHandler-members.
* createDir_ <2>:                        VFS.RealFileHandler-directory operations.
* createDir_ <3>:                        VFS.ArchiveFileHandler-directory operations.
* createDir_ <4>:                        VFS.ArchiveMemberHandler-directory operations.
* createDir_:                            VFS.VFSHandler-directory operations.
* createGetMethod_ <1>:                  ClassDescription-organization of messages and classes.
* createGetMethod_:                      Behavior-method dictionary.
* createGetMethod_default_ <1>:          Behavior-method dictionary.
* createGetMethod_default_:              ClassDescription-organization of messages and classes.
* createSetMethod_ <1>:                  ClassDescription-organization of messages and classes.
* createSetMethod_:                      Behavior-method dictionary.
* creationTime <1>:                      VFS.ArchiveMemberHandler-accessing.
* creationTime <2>:                      File-accessing.
* creationTime <3>:                      VFS.VFSHandler-accessing.
* creationTime:                          VFS.RealFileHandler-accessing.
* critical_ <1>:                         RecursionLock-mutual exclusion.
* critical_:                             Semaphore-mutual exclusion.
* crTab:                                 Stream-character writing.
* current <1>:                           Namespace class-accessing.
* current:                               ObjectMemory class-accessing.
* current_:                              Namespace class-accessing.
* cutAt_:                                LargeArraySubpart-modifying.
* dateAndTimeNow:                        Date class-instance creation (Blue Book).
* day:                                   Date-compatibility (non-ANSI).
* dayName:                               Date-compatibility (non-ANSI).
* dayOfMonth:                            Date-date computations.
* dayOfWeek <1>:                         DateTime-computations.
* dayOfWeek:                             Date-date computations.
* dayOfWeek_:                            Date class-basic.
* dayOfWeekAbbreviation:                 Date-date computations.
* dayOfWeekName:                         Date-date computations.
* dayOfYear:                             Date-date computations.
* days:                                  Duration-arithmetics.
* days_:                                 Duration class-instance creation.
* days_hours_minutes_seconds_:           Duration class-instance creation.
* daysFromBaseDay:                       Date-date computations.
* daysInMonth:                           Date-date computations.
* daysInMonth_forYear_:                  Date class-basic.
* daysInYear:                            Date-date computations.
* daysInYear_:                           Date class-basic.
* daysLeftInMonth:                       Date-date computations.
* daysLeftInYear:                        Date-date computations.
* debug:                                 SystemDictionary-builtins.
* debuggerClass <1>:                     ContextPart-debugging.
* debuggerClass <2>:                     Metaclass-delegation.
* debuggerClass:                         Behavior-pluggable behavior (not yet implemented).
* decimalDigits <1>:                     FloatQ class-characterization.
* decimalDigits <2>:                     FloatE class-characterization.
* decimalDigits:                         FloatD class-characterization.
* declarationTrace:                      SystemDictionary-builtins.
* declarationTrace_:                     SystemDictionary-builtins.
* decode_:                               NetClients.URL class-encoding URLs.
* decodedFields:                         NetClients.URL-accessing.
* decodedFile:                           NetClients.URL-accessing.
* decodedFragment:                       NetClients.URL-accessing.
* decompile_:                            Behavior-method dictionary.
* decompilerClass:                       Behavior-pluggable behavior (not yet implemented).
* decr:                                  CObject-pointer-like behavior.
* decrBy_:                               CObject-pointer-like behavior.
* deepCopy <1>:                          Object-copying.
* deepCopy <2>:                          WeakArray-conversion.
* deepCopy <3>:                          HashedCollection-copying.
* deepCopy <4>:                          CompiledCode-copying.
* deepCopy <5>:                          Number-copying.
* deepCopy <6>:                          BlockClosure-overriding.
* deepCopy <7>:                          UndefinedObject-basic.
* deepCopy <8>:                          RunArray-copying.
* deepCopy <9>:                          ContextPart-copying.
* deepCopy <10>:                         LookupTable-copying.
* deepCopy <11>:                         BindingDictionary-copying.
* deepCopy <12>:                         Boolean-overriding.
* deepCopy:                              Symbol-basic.
* defaultAction <1>:                     Exception-exception description.
* defaultAction <2>:                     Notification-exception description.
* defaultAction:                         Signal-exception handling.
* defaultElement <1>:                    LargeByteArray-overridden.
* defaultElement:                        LargeWordArray-overridden.
* defaultHandler:                        CoreException-accessing.
* defaultHandler_:                       CoreException-accessing.
* defaultSortBlock:                      SortedCollection class-hacking.
* define_:                               BindingDictionary-accessing.
* defineAsyncCFunc_withSelectorArgs_args_ <1>: ClassDescription-organization of messages and classes.
* defineAsyncCFunc_withSelectorArgs_args_: Behavior-method dictionary.
* defineCFunc_as_:                       DLD class-C functions.
* defineCFunc_withSelectorArgs_returning_args_ <1>: Behavior-method dictionary.
* defineCFunc_withSelectorArgs_returning_args_: ClassDescription-organization of messages and classes.
* definedKeys:                           AbstractNamespace-overrides for superspaces.
* defineExternFunc_:                     DLD class-dynamic linking.
* definesKey_:                           AbstractNamespace-overrides for superspaces.
* degreesToRadians:                      Number-converting.
* denominator <1>:                       Fraction-accessing.
* denominator:                           Integer-accessing.
* denormalized:                          Float class-characterization.
* dependencies:                          Object class-initialization.
* dependencies_:                         Object class-initialization.
* dependents:                            Object-dependents access.
* deref_:                                Memory class-accessing.
* description <1>:                       SystemExceptions.EmptyCollection-accessing.
* description <2>:                       ZeroDivide-description.
* description <3>:                       MessageNotUnderstood-description.
* description <4>:                       Exception-exception description.
* description <5>:                       Halt-description.
* description <6>:                       Error-exception description.
* description <7>:                       Notification-exception description.
* description <8>:                       ArithmeticError-description.
* description <9>:                       Signal-accessing.
* description <10>:                      SystemExceptions.WrongClass-accessing.
* description <11>:                      Warning-exception description.
* description <12>:                      SystemExceptions.WrongArgumentCount-accessing.
* description <13>:                      SystemExceptions.VMError-accessing.
* description <14>:                      SystemExceptions.UserInterrupt-accessing.
* description <15>:                      SystemExceptions.SubclassResponsibility-accessing.
* description <16>:                      SystemExceptions.ShouldNotImplement-accessing.
* description <17>:                      SystemExceptions.ReadOnlyObject-accessing.
* description <18>:                      SystemExceptions.ProcessTerminated-accessing.
* description <19>:                      SystemExceptions.ProcessBeingTerminated-accessing.
* description <20>:                      SystemExceptions.PrimitiveFailed-accessing.
* description <21>:                      SystemExceptions.NotYetImplemented-accessing.
* description <22>:                      SystemExceptions.NotIndexable-accessing.
* description <23>:                      SystemExceptions.NotImplemented-accessing.
* description <24>:                      CoreException-accessing.
* description <25>:                      SystemExceptions.NotFound-accessing.
* description <26>:                      SystemExceptions.NoRunnableProcess-accessing.
* description <27>:                      SystemExceptions.MutationError-accessing.
* description <28>:                      SystemExceptions.InvalidValue-accessing.
* description <29>:                      SystemExceptions.InvalidSize-accessing.
* description <30>:                      SystemExceptions.InvalidProcessState-accessing.
* description <31>:                      SystemExceptions.IndexOutOfRange-accessing.
* description <32>:                      SystemExceptions.FileError-accessing.
* description <33>:                      SystemExceptions.EndOfStream-accessing.
* description <34>:                      SystemExceptions.CInterfaceError-accessing.
* description <35>:                      SystemExceptions.BadReturn-accessing.
* description <36>:                      SystemExceptions.ArgumentOutOfRange-accessing.
* description:                           SystemExceptions.AlreadyDefined-accessing.
* description_:                          CoreException-accessing.
* detect_:                               Collection-enumeration.
* detect_ifNone_:                        Collection-enumeration.
* digitAt_:                              LargeInteger-built-ins.
* digitAt_put_:                          LargeInteger-built-ins.
* digitLength:                           LargeInteger-built-ins.
* digitValue:                            Character-converting.
* digitValue_:                           Character class-instance creation.
* directory:                             Package-accessing.
* directory_forBaseDir_:                 Package-accessing.
* directoryAt_:                          Directory-accessing.
* directoryFor_:                         PackageLoader class-accessing.
* disableInterrupts:                     ProcessorScheduler-built ins.
* disableProxyFor_:                      ObjectDumper class-establishing proxy classes.
* discardTranslation:                    CompiledCode-translation.
* dispatchTo_with_:                      CompiledCode-decoding bytecodes.
* display:                               Object-printing.
* display_:                              Stream-printing.
* displayNl:                             Object-printing.
* displayOn_ <1>:                        Object-printing.
* displayOn_ <2>:                        Symbol-storing.
* displayOn_ <3>:                        ScaledDecimal-printing.
* displayOn_ <4>:                        CharacterArray-printing.
* displayOn_:                            Character-printing.
* displayString <1>:                     CharacterArray-printing.
* displayString <2>:                     Symbol-storing.
* displayString:                         Object-printing.
* dist_:                                 Point-point functions.
* divide_using_:                         LargePositiveInteger-primitive operations.
* dividend:                              ZeroDivide-accessing.
* dividend_:                             ZeroDivide class-instance creation.
* do_ <1>:                               Directory-enumerating.
* do_ <2>:                               SymLink-iteration.
* do_ <3>:                               WeakArray-accessing.
* do_ <4>:                               Bag-enumerating the elements of a collection.
* do_ <5>:                               Link-iteration.
* do_ <6>:                               WeakSet-accessing.
* do_ <7>:                               MappedCollection-basic.
* do_ <8>:                               VFS.RealFileHandler-directory operations.
* do_ <9>:                               VFS.ExternalArchiveFileHandler-members.
* do_ <10>:                              Dictionary-dictionary enumerating.
* do_ <11>:                              VFS.ArchiveFileHandler-directory operations.
* do_ <12>:                              Namespace-overrides for superspaces.
* do_ <13>:                              HashedCollection-enumerating the elements of a collection.
* do_ <14>:                              RunArray-enumerating.
* do_ <15>:                              Stream-enumerating.
* do_ <16>:                              Collection-enumeration.
* do_ <17>:                              VFS.VFSHandler-directory operations.
* do_ <18>:                              LinkedList-enumerating.
* do_ <19>:                              Interval-basic.
* do_ <20>:                              SequenceableCollection-enumerating.
* do_:                                   VFS.ArchiveMemberHandler-directory operations.
* do_separatedBy_ <1>:                   SequenceableCollection-enumerating.
* do_separatedBy_:                       Collection-enumeration.
* doesNotUnderstand_ <1>:                AutoloadClass-accessing.
* doesNotUnderstand_ <2>:                Object-error raising.
* doesNotUnderstand_ <3>:                BindingDictionary-accessing.
* doesNotUnderstand_:                    Autoload-accessing.
* domain:                                MappedCollection-basic.
* dotProduct_:                           Point-point functions.
* doubleAt_ <1>:                         ByteArray-more advanced accessing.
* doubleAt_:                             Memory class-accessing.
* doubleAt_put_ <1>:                     Memory class-accessing.
* doubleAt_put_:                         ByteArray-more advanced accessing.
* doWithIndex_:                          SequenceableCollection-enumerating.
* dump_:                                 ObjectDumper-loading/dumping objects.
* dump_to_:                              ObjectDumper class-shortcuts.
* dumpTo_ <1>:                           NullProxy-accessing.
* dumpTo_ <2>:                           DumperProxy-saving and restoring.
* dumpTo_:                               VersionableObjectProxy-saving and restoring.
* e <1>:                                 Float class-characterization.
* e <2>:                                 FloatE class-characterization.
* e:                                     FloatQ class-characterization.
* edenSize:                              ObjectMemory-accessing.
* edenUsedBytes:                         ObjectMemory-accessing.
* edit_:                                 Behavior-method dictionary.
* elementType <1>:                       CPtrCType-accessing.
* elementType <2>:                       CAggregate-accessing.
* elementType:                           CStringCType-accessing.
* elementType_ <1>:                      CPtrCType class-instance creation.
* elementType_:                          CArrayCType class-instance creation.
* elementType_numberOfElements_:         CArrayCType class-instance creation.
* emax <1>:                              FloatQ class-characterization.
* emax <2>:                              FloatE class-characterization.
* emax:                                  FloatD class-characterization.
* emin <1>:                              FloatE class-characterization.
* emin <2>:                              FloatQ class-characterization.
* emin:                                  FloatD class-characterization.
* emitInspectTo_for_:                    CCompound class-subclass creation.
* empty:                                 Collection-removing.
* emptyStream:                           WriteStream-positioning.
* enableInterrupts:                      ProcessorScheduler-built ins.
* encode_:                               NetClients.URL class-encoding URLs.
* endEntry:                              TextCollector-accessing.
* ensure_:                               BlockClosure-unwind protection.
* ensureReadable:                        FileDescriptor-accessing.
* ensureWriteable:                       FileDescriptor-accessing.
* environment <1>:                       Behavior-support for lightweight classes.
* environment <2>:                       Class-accessing instances and variables.
* environment <3>:                       BindingDictionary-accessing.
* environment <4>:                       Metaclass-delegation.
* environment <5>:                       AutoloadClass-accessing.
* environment <6>:                       ContextPart-accessing.
* environment <7>:                       Association-accessing.
* environment:                           HomedAssociation-accessing.
* environment_ <1>:                      HomedAssociation-accessing.
* environment_ <2>:                      Association-accessing.
* environment_ <3>:                      AutoloadClass-accessing.
* environment_ <4>:                      BindingDictionary-accessing.
* environment_:                          Class-accessing instances and variables.
* eof:                                   Character class-constants.
* eot:                                   Character class-constants.
* epsilon:                               Float class-characterization.
* eqv_ <1>:                              Boolean-basic.
* eqv_ <2>:                              False-basic.
* eqv_:                                  True-basic.
* errno:                                 File class-C functions.
* error_:                                Object-error raising.
* esc:                                   Character class-constants.
* estimatedLog <1>:                      Float-coercing.
* estimatedLog <2>:                      Number-misc math.
* estimatedLog <3>:                      LargeInteger-arithmetic.
* estimatedLog <4>:                      Fraction-arithmetic.
* estimatedLog:                          Integer-math methods.
* evalString_to_:                        Behavior-evaluating.
* evalString_to_ifError_:                Behavior-evaluating.
* evaluate_:                             Behavior-evaluating.
* evaluate_ifError_:                     Behavior-evaluating.
* evaluate_notifying_:                   Behavior-evaluating.
* evaluate_to_:                          Behavior-evaluating.
* evaluate_to_ifError_:                  Behavior-evaluating.
* evaluatorClass:                        Behavior-pluggable behavior (not yet implemented).
* even <1>:                              Number-testing.
* even:                                  Integer-math methods.
* example:                               ObjectDumper class-testing.
* exception:                             Signal-accessing.
* exceptionalCondition:                  FileDescriptor-accessing.
* executionTrace:                        SystemDictionary-builtins.
* executionTrace_:                       SystemDictionary-builtins.
* exists <1>:                            File-testing.
* exists <2>:                            VFS.RealFileHandler-testing.
* exists <3>:                            VFS.ArchiveMemberHandler-testing.
* exists:                                VFS.VFSHandler-testing.
* exists_:                               File class-testing.
* exp <1>:                               Number-misc math.
* exp:                                   Float-built ins.
* expandBy_:                             Rectangle-rectangle functions.
* exponent <1>:                          FloatE-built ins.
* exponent <2>:                          FloatQ-built ins.
* exponent:                              FloatD-built ins.
* extend:                                Class-instance creation.
* extension:                             File-file name management.
* extensionFor_:                         File class-file name management.
* extent:                                Rectangle-accessing.
* extent_ <1>:                           Rectangle-accessing.
* extent_:                               Point-converting.
* externalInterruptsEnabled:             Process-accessing.
* extractDependenciesFor_onError_:       PackageLoader class-loading.
* extractDirentName_:                    VFS.VFSHandler-C functions.
* extractMember_ <1>:                    VFS.ArchiveFileHandler-ArchiveMemberHandler protocol.
* extractMember_:                        VFS.ExternalArchiveFileHandler-ArchiveMemberHandler protocol.
* factorial:                             Integer-math methods.
* fd:                                    FileDescriptor-accessing.
* fileIn:                                FileStream-filing in.
* fileIn_:                               FileStream class-file-in.
* fileIn_ifMissing_:                     FileStream class-file-in.
* fileIn_ifTrue_:                        FileStream class-file-in.
* fileIn_line_from_at_:                  FileStream class-file-in.
* fileInLine_fileName_at_:               FileStream-filing in.
* fileInPackage_:                        PackageLoader class-loading.
* fileInPackages_:                       PackageLoader class-loading.
* fileIns:                               Package-accessing.
* fileInsFor_:                           PackageLoader class-accessing.
* fileName <1>:                          FileSegment-basic.
* fileName <2>:                          AutoloadClass-accessing.
* fileName:                              CharacterArray-converting.
* fileName_:                             AutoloadClass-accessing.
* fileOp_:                               FileDescriptor-built ins.
* fileOp_ifFail_:                        FileDescriptor-built ins.
* fileOp_with_:                          FileDescriptor-built ins.
* fileOp_with_ifFail_:                   FileDescriptor-built ins.
* fileOp_with_with_:                     FileDescriptor-built ins.
* fileOp_with_with_ifFail_:              FileDescriptor-built ins.
* fileOp_with_with_with_:                FileDescriptor-built ins.
* fileOp_with_with_with_ifFail_:         FileDescriptor-built ins.
* fileOut_ <1>:                          ClassDescription-filing.
* fileOut_:                              Stream-filing out.
* fileOutCategory_to_:                   ClassDescription-filing.
* fileOutCategory_toStream_:             ClassDescription-filing.
* fileOutDeclarationOn_:                 Class-filing.
* fileOutHeaderOn_:                      Class-filing.
* fileOutOn_ <1>:                        ClassDescription-filing.
* fileOutOn_ <2>:                        Metaclass-filing.
* fileOutOn_:                            Class-filing.
* fileOutSelector_to_:                   ClassDescription-filing.
* filePos <1>:                           CharacterArray-converting.
* filePos:                               FileSegment-basic.
* files:                                 Package-accessing.
* filesFor_:                             PackageLoader class-accessing.
* filesMatching_do_:                     Directory-enumerating.
* fileSystems <1>:                       VFS.VFSHandler class-initializing.
* fileSystems <2>:                       VFS.ExternalArchiveFileHandler class-registering.
* fileSystems:                           VFS.DecodedFileHandler class-registering.
* fileSystemsIn_:                        VFS.ExternalArchiveFileHandler class-registering.
* fill:                                  FileStream-buffering.
* fillMember_ <1>:                       VFS.ExternalArchiveFileHandler-ArchiveMemberHandler protocol.
* fillMember_:                           VFS.ArchiveFileHandler-ArchiveMemberHandler protocol.
* finalIP:                               BlockClosure-accessing.
* finalizableObjects:                    Object class-initialization.
* finalize <1>:                          Object-finalization.
* finalize <2>:                          FileDescriptor-basic.
* finalize <3>:                          VFS.DecodedFileHandler-files.
* finalize <4>:                          CObject-finalization.
* finalize:                              VFS.ArchiveFileHandler-directory operations.
* findFirst_:                            SequenceableCollection-enumerating.
* findKeyIndex_:                         Dictionary-awful ST-80 compatibility hacks.
* findLast_:                             SequenceableCollection-enumerating.
* findObjectIndex_:                      Set-awful ST-80 compatibility hacks.
* finishIncrementalGC:                   ObjectMemory class-builtins.
* first <1>:                             SequenceableCollection-basic.
* first <2>:                             RunArray-basic.
* first:                                 LargeArraySubpart-accessing.
* first_last_index_ <1>:                 LargeArraySubpart-accessing.
* first_last_index_:                     LargeArraySubpart class-instance creation.
* firstDayOfMonth:                       Date-date computations.
* firstIndex:                            LargeArraySubpart-accessing.
* fixedSpaceSize:                        ObjectMemory-accessing.
* fixedSpaceUsedBytes:                   ObjectMemory-accessing.
* fixTemps:                              BlockClosure-accessing.
* flags <1>:                             CompiledCode-accessing.
* flags <2>:                             CompiledMethod-accessing.
* flags:                                 CompiledBlock-accessing.
* floatAt_ <1>:                          ByteArray-more advanced accessing.
* floatAt_:                              Memory class-accessing.
* floatAt_put_ <1>:                      ByteArray-more advanced accessing.
* floatAt_put_:                          Memory class-accessing.
* floor <1>:                             Float-built ins.
* floor <2>:                             Number-truncation and round off.
* floor <3>:                             Integer-converting.
* floor:                                 Fraction-coercing.
* floorLog_ <1>:                         Number-misc math.
* floorLog_:                             Integer-math methods.
* flush <1>:                             FileStream-buffering.
* flush <2>:                             PackageLoader class-accessing.
* flush <3>:                             Stream-providing consistent protocols.
* flush:                                 ObjectDumper-accessing.
* flushCache:                            Behavior-built ins.
* flushTranslatorCache:                  CompiledCode class-cache flushing.
* fmax <1>:                              FloatQ class-characterization.
* fmax <2>:                              FloatE class-characterization.
* fmax:                                  FloatD class-characterization.
* fmin:                                  Float class-characterization.
* fminDenormalized:                      Float class-characterization.
* fminNormalized <1>:                    FloatQ class-characterization.
* fminNormalized <2>:                    FloatE class-characterization.
* fminNormalized:                        FloatD class-characterization.
* fopen_mode_:                           FileDescriptor class-instance creation.
* fopen_mode_ifFail_:                    FileDescriptor class-instance creation.
* for_:                                  VFS.VFSHandler class-instance creation.
* for_returning_withArgs_:               CFunctionDescriptor class-instance creation.
* fork <1>:                              BlockClosure-multiple process.
* fork:                                  DirectedMessage-multiple process.
* forkAt_ <1>:                           DirectedMessage-multiple process.
* forkAt_:                               BlockClosure-multiple process.
* forkWithoutPreemption:                 BlockClosure-multiple process.
* forMilliseconds_:                      Delay class-instance creation.
* forMutualExclusion:                    Semaphore class-instance creation.
* forSeconds_:                           Delay class-instance creation.
* fractionPart <1>:                      ScaledDecimal-coercion.
* fractionPart <2>:                      Number-truncation and round off.
* fractionPart <3>:                      FloatQ-built ins.
* fractionPart <4>:                      FloatE-built ins.
* fractionPart:                          FloatD-built ins.
* fragment:                              NetClients.URL-accessing.
* fragment_:                             NetClients.URL-accessing.
* free <1>:                              CObject-C data access.
* free:                                  UndefinedObject-CObject interoperability.
* from_to_:                              Interval class-instance creation.
* from_to_by_:                           Interval class-instance creation.
* from_to_do_:                           SequenceableCollection-enumerating.
* from_to_doWithIndex_:                  SequenceableCollection-enumerating.
* from_to_keysAndValuesDo_:              SequenceableCollection-enumerating.
* fromCData_size_:                       String class-instance creation.
* fromDays_:                             Date class-instance creation (Blue Book).
* fromDays_seconds_offset_ <1>:          DateTime class-instance creation (non-ANSI).
* fromDays_seconds_offset_:              Duration class-instance creation (non ANSI).
* fromJulian_:                           Date class-instance creation (Blue Book).
* fromSeconds_ <1>:                      Date class-instance creation (Blue Book).
* fromSeconds_:                          Time class-instance creation.
* fromString_ <1>:                       NetClients.URL class-instance creation.
* fromString_:                           CharacterArray class-basic.
* fullName:                              File-file name management.
* fullNameAt_:                           Directory-accessing.
* fullNameFor_:                          File class-file name management.
* fullRequestString:                     NetClients.URL-accessing.
* gcd_ <1>:                              LargeNegativeInteger-reverting to LargePositiveInteger.
* gcd_ <2>:                              LargePositiveInteger-arithmetic.
* gcd_:                                  Integer-math methods.
* gcMessage:                             ObjectMemory class-builtins.
* gcMessage_:                            ObjectMemory class-builtins.
* generality <1>:                        ScaledDecimal-coercion.
* generality <2>:                        Number-converting.
* generality <3>:                        SmallInteger-coercion methods.
* generality <4>:                        LargeInteger-coercion.
* generality <5>:                        Fraction-coercing.
* generality <6>:                        FloatQ-coercing.
* generality <7>:                        FloatE-coercing.
* generality:                            FloatD-coercing.
* generateMakefileOnto_:                 FileStream class-file-in.
* getArgc:                               SystemDictionary-C functions.
* getArgv_:                              SystemDictionary-C functions.
* getBlock_putBlock_:                    PluggableAdaptor class-creating instances.
* getenv_:                               SystemDictionary-C functions.
* getTraceFlag_:                         SystemDictionary-builtins.
* globalGarbageCollect:                  ObjectMemory class-builtins.
* goodness_ <1>:                         CoreException-enumerating.
* goodness_ <2>:                         ExceptionSet-enumerating.
* goodness_ <3>:                         TrappableEvent-enumerating.
* goodness_:                             Exception class-comparison.
* grid_:                                 Point-point functions.
* grow:                                  LargeArraySubpart-modifying.
* growBy_:                               LargeArraySubpart-modifying.
* growThresholdPercent:                  ObjectMemory class-builtins.
* growThresholdPercent_:                 ObjectMemory class-builtins.
* growTo_:                               ObjectMemory class-builtins.
* halt <1>:                              Object-built ins.
* halt:                                  SystemDictionary-basic.
* halt_:                                 Object-error raising.
* handles_ <1>:                          ExceptionSet-enumerating.
* handles_ <2>:                          CoreException-enumerating.
* handles_ <3>:                          TrappableEvent-enumerating.
* handles_:                              Exception class-comparison.
* hasBytecode_between_and_:              CompiledCode-testing accesses.
* hasFeatures_:                          SystemDictionary-special accessing.
* hasFragment:                           NetClients.URL-testing.
* hash <1>:                              ByteArray-built ins.
* hash <2>:                              LargeZeroInteger-accessing.
* hash <3>:                              HashedCollection-testing collections.
* hash <4>:                              Time-comparing.
* hash <5>:                              Integer-basic.
* hash <6>:                              Rectangle-testing.
* hash <7>:                              Delay-comparing.
* hash <8>:                              NetClients.URL-comparing.
* hash <9>:                              ScaledDecimal-comparing.
* hash <10>:                             Exception-comparison.
* hash <11>:                             RunArray-testing.
* hash <12>:                             Association-testing.
* hash <13>:                             DateTime-testing.
* hash <14>:                             Point-converting.
* hash <15>:                             SequenceableCollection-testing.
* hash <16>:                             FileSegment-equality.
* hash <17>:                             LargeArraySubpart-comparing.
* hash <18>:                             MethodInfo-equality.
* hash <19>:                             Date-testing.
* hash <20>:                             Symbol-built ins.
* hash <21>:                             Float-basic.
* hash <22>:                             CompiledCode-basic.
* hash <23>:                             AbstractNamespace-basic & copying.
* hash <24>:                             LargeArrayedCollection-basic.
* hash <25>:                             LookupKey-testing.
* hash <26>:                             String-built ins.
* hash <27>:                             Interval-testing.
* hash <28>:                             Bag-testing collections.
* hash <29>:                             Fraction-comparing.
* hash <30>:                             Object-built ins.
* hash <31>:                             LargeInteger-built-ins.
* hash <32>:                             CompiledMethod-basic.
* hash <33>:                             Dictionary-testing.
* hash:                                  SystemDictionary-basic.
* hasInterned_ifTrue_:                   Symbol class-symbol table.
* hasMethodReturn:                       BlockClosure-testing.
* hasMethods:                            Behavior-testing the method dictionary.
* hasPostData:                           NetClients.URL-accessing.
* hasPostData_:                          NetClients.URL-accessing.
* hasProxyFor_:                          ObjectDumper class-establishing proxy classes.
* hasQuery:                              NetClients.URL-testing.
* hasValue:                              Promise-accessing.
* height:                                Rectangle-accessing.
* height_:                               Rectangle-accessing.
* hereAt_:                               AbstractNamespace-overrides for superspaces.
* hereAt_ifAbsent_:                      AbstractNamespace-overrides for superspaces.
* hierarchyIndent:                       Behavior-printing hierarchy.
* high:                                  SystemExceptions.ArgumentOutOfRange-accessing.
* high_:                                 SystemExceptions.ArgumentOutOfRange-accessing.
* highBit <1>:                           Integer-bit operators.
* highBit <2>:                           LargeNegativeInteger-reverting to LargePositiveInteger.
* highBit <3>:                           LargePositiveInteger-arithmetic.
* highBit:                               SmallInteger-bit arithmetic.
* highestPriority:                       ProcessorScheduler-priorities.
* highIOPriority:                        ProcessorScheduler-priorities.
* home <1>:                              ContextPart-accessing.
* home <2>:                              BlockContext-accessing.
* home <3>:                              MethodContext-accessing.
* home:                                  Directory class-reading system defaults.
* host:                                  NetClients.URL-accessing.
* host_:                                 NetClients.URL-accessing.
* hour <1>:                              DateTime-computations.
* hour:                                  Time-accessing (ANSI for DateAndTimes).
* hour12 <1>:                            Time-accessing (ANSI for DateAndTimes).
* hour12:                                DateTime-computations.
* hour24 <1>:                            DateTime-computations.
* hour24:                                Time-accessing (ANSI for DateAndTimes).
* hours:                                 Time-accessing (non ANSI & for Durations).
* hours_:                                Time class-instance creation.
* hours_minutes_seconds_:                Time class-instance creation.
* identityHash:                          Object-built ins.
* identityIncludes_ <1>:                 SequenceableCollection-basic.
* identityIncludes_ <2>:                 Collection-testing collections.
* identityIncludes_:                     IdentitySet-testing.
* identityIndexOf_:                      SequenceableCollection-basic.
* identityIndexOf_ifAbsent_:             SequenceableCollection-basic.
* identityIndexOf_startingAt_:           SequenceableCollection-basic.
* identityIndexOf_startingAt_ifAbsent_:  SequenceableCollection-basic.
* idle:                                  ProcessorScheduler-idle tasks.
* idleAdd_:                              ProcessorScheduler-idle tasks.
* ifCurtailed_:                          BlockClosure-unwind protection.
* ifError_:                              BlockClosure-exception handling.
* ifFalse_ <1>:                          Boolean-basic.
* ifFalse_ <2>:                          True-basic.
* ifFalse_:                              False-basic.
* ifFalse_ifTrue_ <1>:                   Boolean-basic.
* ifFalse_ifTrue_ <2>:                   True-basic.
* ifFalse_ifTrue_:                       False-basic.
* ifNil_ <1>:                            UndefinedObject-testing.
* ifNil_:                                Object-testing functionality.
* ifNil_ifNotNil_ <1>:                   Object-testing functionality.
* ifNil_ifNotNil_:                       UndefinedObject-testing.
* ifNotNil_ <1>:                         UndefinedObject-testing.
* ifNotNil_:                             Object-testing functionality.
* ifNotNil_ifNil_ <1>:                   UndefinedObject-testing.
* ifNotNil_ifNil_:                       Object-testing functionality.
* ifTrue_ <1>:                           False-basic.
* ifTrue_ <2>:                           Boolean-basic.
* ifTrue_:                               True-basic.
* ifTrue_ifFalse_ <1>:                   Boolean-basic.
* ifTrue_ifFalse_ <2>:                   False-basic.
* ifTrue_ifFalse_:                       True-basic.
* ignoreCallouts:                        PackageLoader class-accessing.
* ignoreCallouts_:                       PackageLoader class-accessing.
* image <1>:                             File class-reading system defaults.
* image:                                 Directory class-reading system defaults.
* import_from_:                          BindingDictionary-accessing.
* includes_ <1>:                         Bag-testing collections.
* includes_ <2>:                         HashedCollection-testing collections.
* includes_ <3>:                         Dictionary-dictionary testing.
* includes_ <4>:                         Directory-accessing.
* includes_ <5>:                         SequenceableCollection-basic.
* includes_ <6>:                         SortedCollection-searching.
* includes_:                             Collection-testing collections.
* includesAssociation_:                  Dictionary-dictionary testing.
* includesBehavior_:                     Behavior-testing the class hierarchy.
* includesClassNamed_:                   AbstractNamespace-namespace hierarchy.
* includesGlobalNamed_:                  AbstractNamespace-namespace hierarchy.
* includesKey_ <1>:                      WeakValueLookupTable-hacks.
* includesKey_ <2>:                      Namespace-overrides for superspaces.
* includesKey_:                          Dictionary-dictionary testing.
* includesSelector_:                     Behavior-testing the method dictionary.
* incr:                                  CObject-pointer-like behavior.
* incrBy_:                               CObject-pointer-like behavior.
* incrementalGCStep:                     ObjectMemory class-builtins.
* indexOf_:                              SequenceableCollection-basic.
* indexOf_ifAbsent_:                     SequenceableCollection-basic.
* indexOf_matchCase_startingAt_:         CharacterArray-comparing.
* indexOf_startingAt_:                   SequenceableCollection-basic.
* indexOf_startingAt_ifAbsent_ <1>:      SequenceableCollection-basic.
* indexOf_startingAt_ifAbsent_ <2>:      SortedCollection-searching.
* indexOf_startingAt_ifAbsent_:          RunArray-searching.
* indexOfMonth_:                         Date class-basic.
* indexOfSubCollection_:                 SequenceableCollection-basic.
* indexOfSubCollection_ifAbsent_:        SequenceableCollection-basic.
* indexOfSubCollection_startingAt_:      SequenceableCollection-basic.
* indexOfSubCollection_startingAt_ifAbsent_: SequenceableCollection-basic.
* infinity <1>:                          FloatD class-characterization.
* infinity <2>:                          FloatE class-characterization.
* infinity:                              FloatQ class-characterization.
* inheritedKeys <1>:                     AbstractNamespace-overrides for superspaces.
* inheritedKeys <2>:                     Namespace-accessing.
* inheritedKeys:                         RootNamespace-overrides for superspaces.
* inheritsFrom_ <1>:                     Behavior-testing the class hierarchy.
* inheritsFrom_:                         AbstractNamespace-namespace hierarchy.
* initDayNameDict:                       Date class-basic.
* initialIP <1>:                         BlockClosure-accessing.
* initialIP:                             ContextPart-accessing.
* initialize <1>:                        NetClients.URL class-encoding URLs.
* initialize <2>:                        ValueHolder-initializing.
* initialize <3>:                        Exception class-initialization.
* initialize <4>:                        Promise-initializing.
* initialize <5>:                        VFS.RealFileHandler class-initialization.
* initialize <6>:                        Fraction class-instance creation.
* initialize <7>:                        VFS.DecodedFileHandler class-registering.
* initialize <8>:                        Class-accessing instances and variables.
* initialize <9>:                        ObjectMemory class-initialization.
* initialize <10>:                       CCompound class-subclass creation.
* initialize <11>:                       DateTime class-information.
* initialize <12>:                       Time class-initialization.
* initialize <13>:                       DLD class-dynamic linking.
* initialize <14>:                       ScaledDecimal class-constants.
* initialize <15>:                       Object class-initialization.
* initialize <16>:                       Delay class-initialization.
* initialize <17>:                       Duration class-instance creation.
* initialize <18>:                       Character class-initializing lookup tables.
* initialize <19>:                       Date class-basic.
* initialize <20>:                       FileStream class-file-in.
* initialize <21>:                       Namespace class-initialization.
* initialize <22>:                       VFS.VFSHandler class-initializing.
* initialize <23>:                       NetClients.URL-initialize-release.
* initialize <24>:                       FileDescriptor-initialize-release.
* initialize:                            FileDescriptor class-initialization.
* initMonthNameDict:                     Date class-basic.
* inject_into_:                          Collection-enumeration.
* insetBy_:                              Rectangle-rectangle functions.
* insetOriginBy_corner_:                 Rectangle-rectangle functions.
* inspect <1>:                           CCompound-instance creation.
* inspect <2>:                           Object-debugging.
* inspect <3>:                           Dictionary-printing.
* inspect <4>:                           Collection-printing.
* inspect <5>:                           SequenceableCollection-testing.
* inspect:                               CompiledCode-debugging.
* inspectSelectorList:                   CCompound-instance creation.
* instanceClass:                         Metaclass-accessing.
* instanceCount:                         Behavior-accessing instances and variables.
* instanceVariableNames_:                Metaclass-basic.
* instanceVariableString:                ClassDescription-printing.
* instSize:                              Behavior-testing the form of the instances.
* instVarAt_:                            Object-built ins.
* instVarAt_put_:                        Object-built ins.
* instVarNames:                          Behavior-accessing instances and variables.
* intAt_ <1>:                            ByteArray-more advanced accessing.
* intAt_:                                Memory class-accessing.
* intAt_put_ <1>:                        ByteArray-more advanced accessing.
* intAt_put_:                            Memory class-accessing.
* integerPart <1>:                       Fraction-converting.
* integerPart <2>:                       Float-arithmetic.
* integerPart <3>:                       ScaledDecimal-coercion.
* integerPart:                           Number-truncation and round off.
* intern_:                               Symbol class-built ins.
* internCharacter_:                      Symbol class-instance creation.
* intersect_:                            Rectangle-rectangle functions.
* intersects_:                           Rectangle-testing.
* invalidate:                            FileDescriptor-basic.
* ip:                                    ContextPart-accessing.
* ip_:                                   ContextPart-accessing.
* isAccessible <1>:                      VFS.VFSHandler-testing.
* isAccessible <2>:                      VFS.ArchiveFileHandler class-registering.
* isAccessible <3>:                      VFS.ArchiveMemberHandler-testing.
* isAccessible:                          File-testing.
* isAccessible_:                         File class-testing.
* isAlive_:                              WeakArray-accessing.
* isAlphaNumeric:                        Character-testing.
* isArray <1>:                           Object-testing functionality.
* isArray:                               Array-testing.
* isBehavior <1>:                        Object-testing functionality.
* isBehavior:                            Behavior-testing functionality.
* isBinary:                              FileDescriptor-class type methods.
* isBits:                                Behavior-testing the form of the instances.
* isBitSet_:                             Integer-bit operators.
* isBlock <1>:                           MethodContext-accessing.
* isBlock <2>:                           ContextPart-accessing.
* isBlock:                               BlockContext-accessing.
* isBytes:                               Behavior-testing the form of the instances.
* isCharacter <1>:                       Object-testing functionality.
* isCharacter:                           Character-testing functionality.
* isCharacterArray <1>:                  CharacterArray-testing functionality.
* isCharacterArray:                      Object-testing functionality.
* isClass <1>:                           Object-testing functionality.
* isClass:                               Class-testing functionality.
* isDefined:                             VariableBinding-testing.
* isDigit:                               Character-testing.
* isDirectory <1>:                       File-testing.
* isDirectory <2>:                       VFS.RealFileHandler-testing.
* isDirectory <3>:                       VFS.VFSHandler-testing.
* isDirectory <4>:                       VFS.ArchiveFileHandler class-registering.
* isDirectory:                           VFS.ArchiveMemberHandler-testing.
* isDisabled <1>:                        BlockContext-accessing.
* isDisabled <2>:                        MethodContext-accessing.
* isDisabled:                            ContextPart-accessing.
* isEmpty <1>:                           HashedCollection-testing collections.
* isEmpty <2>:                           PositionableStream-testing.
* isEmpty <3>:                           SharedQueue-accessing.
* isEmpty <4>:                           LinkedList-testing.
* isEmpty <5>:                           Collection-testing collections.
* isEmpty:                               FileDescriptor-overriding inherited methods.
* isEnvironment <1>:                     BlockContext-accessing.
* isEnvironment <2>:                     ContextPart-accessing.
* isEnvironment:                         MethodContext-accessing.
* isExecutable <1>:                      VFS.VFSHandler-testing.
* isExecutable <2>:                      VFS.RealFileHandler-testing.
* isExecutable <3>:                      VFS.ArchiveMemberHandler-testing.
* isExecutable:                          File-testing.
* isExecutable_:                         File class-testing.
* isExternalStream <1>:                  PositionableStream-class type methods.
* isExternalStream <2>:                  Stream-testing.
* isExternalStream:                      FileDescriptor-class type methods.
* isFile:                                File-testing.
* isFileScheme:                          NetClients.URL-testing.
* isFinite <1>:                          Number-testing.
* isFinite:                              Float-testing.
* isFixed:                               Behavior-testing the form of the instances.
* isFloat <1>:                           Object-testing functionality.
* isFloat:                               Float-testing functionality.
* isFragmentOnly:                        NetClients.URL-testing.
* isFunction_:                           CFunctionDescriptor class-testing.
* isIdentity <1>:                        Character class-testing.
* isIdentity <2>:                        Behavior-testing the form of the instances.
* isIdentity <3>:                        Boolean class-testing.
* isIdentity:                            SmallInteger class-testing.
* isImmediate <1>:                       Number class-testing.
* isImmediate <2>:                       Boolean class-testing.
* isImmediate <3>:                       Behavior-testing the form of the instances.
* isImmediate <4>:                       BlockClosure class-testing.
* isImmediate:                           Character class-testing.
* isInfinite <1>:                        Float-testing.
* isInfinite:                            Number-testing.
* isInteger <1>:                         Object-testing functionality.
* isInteger:                             Integer-testing functionality.
* isInternalExceptionHandlingContext:    ContextPart-debugging.
* isKindOf_:                             Object-testing functionality.
* isLeapYear:                            Date-date computations.
* isLetter:                              Character-testing.
* isLowercase:                           Character-testing.
* isMemberOf_:                           Object-testing functionality.
* isMeta:                                Object-testing functionality.
* isMetaClass:                           Object-testing functionality.
* isMetaclass <1>:                       Metaclass-testing functionality.
* isMetaclass:                           Object-testing functionality.
* isNamespace <1>:                       Object-testing functionality.
* isNamespace:                           AbstractNamespace-testing.
* isNaN <1>:                             Float-testing.
* isNaN:                                 Number-testing.
* isNested:                              Signal-exception handling.
* isNil <1>:                             UndefinedObject-testing.
* isNil:                                 Object-testing functionality.
* isNumber <1>:                          Number-testing.
* isNumber:                              Object-testing functionality.
* isNumeric:                             CharacterArray-converting.
* isOpen:                                FileDescriptor-accessing.
* isOwnerProcess:                        RecursionLock-accessing.
* isPipe:                                FileDescriptor-accessing.
* isPointers:                            Behavior-testing the form of the instances.
* isProcess:                             ContextPart-accessing.
* isPunctuation:                         Character-testing.
* isRational <1>:                        Integer-testing functionality.
* isRational <2>:                        Number-testing.
* isRational:                            Fraction-testing.
* isReadable <1>:                        VFS.RealFileHandler-testing.
* isReadable <2>:                        VFS.ArchiveMemberHandler-testing.
* isReadable <3>:                        File-testing.
* isReadable:                            VFS.VFSHandler-testing.
* isReadable_:                           File class-testing.
* isReadOnly:                            Object-built ins.
* isResumable <1>:                       Halt-description.
* isResumable <2>:                       CoreException-accessing.
* isResumable <3>:                       Notification-exception description.
* isResumable <4>:                       Signal-exception handling.
* isResumable <5>:                       Exception-exception description.
* isResumable:                           Error-exception description.
* isResumable_:                          CoreException-accessing.
* isSeparator:                           Character-testing.
* isSimpleSymbol:                        Symbol-testing.
* isSmall:                               LargePositiveInteger-primitive operations.
* isSmallInteger <1>:                    Object-testing functionality.
* isSmallInteger:                        SmallInteger-testing functionality.
* isSmalltalk <1>:                       AbstractNamespace-testing.
* isSmalltalk:                           Namespace-testing.
* isString <1>:                          String-testing functionality.
* isString <2>:                          Object-testing functionality.
* isString:                              Symbol-testing functionality.
* isSymbol <1>:                          Object-testing functionality.
* isSymbol:                              Symbol-testing functionality.
* isSymbolString_:                       Symbol class-symbol table.
* isText:                                FileDescriptor-class type methods.
* isTimeoutProgrammed:                   ProcessorScheduler-timed invocation.
* isUnwind <1>:                          BlockContext-accessing.
* isUnwind <2>:                          MethodContext-accessing.
* isUnwind:                              ContextPart-accessing.
* isUppercase:                           Character-testing.
* isValid:                               CFunctionDescriptor-accessing.
* isVariable:                            Behavior-testing the form of the instances.
* isVowel:                               Character-testing.
* isWords:                               Behavior-testing the form of the instances.
* isWriteable <1>:                       VFS.RealFileHandler-testing.
* isWriteable <2>:                       VFS.VFSHandler-testing.
* isWriteable <3>:                       File-testing.
* isWriteable:                           VFS.ArchiveMemberHandler-testing.
* isWriteable_:                          File class-testing.
* jumpDestinationAt_:                    CompiledCode-testing accesses.
* kernel:                                Directory class-reading system defaults.
* key:                                   LookupKey-accessing.
* key_ <1>:                              LookupKey class-basic.
* key_:                                  LookupKey-accessing.
* key_value_ <1>:                        Association-accessing.
* key_value_:                            Association class-basic.
* key_value_environment_:                HomedAssociation class-basic.
* keyAtValue_:                           Dictionary-accessing.
* keyAtValue_ifAbsent_:                  Dictionary-accessing.
* keys:                                  Dictionary-accessing.
* keysAndValuesDo_ <1>:                  SequenceableCollection-enumerating.
* keysAndValuesDo_ <2>:                  Dictionary-dictionary enumerating.
* keysAndValuesDo_ <3>:                  Namespace-overrides for superspaces.
* keysAndValuesDo_:                      LookupTable-enumerating.
* keysDo_ <1>:                           Dictionary-dictionary enumerating.
* keysDo_:                               Namespace-overrides for superspaces.
* keywords:                              Symbol-basic.
* kindOfSubclass:                        Behavior-testing the class hierarchy.
* largeNegated:                          LargeInteger-primitive operations.
* largest:                               SmallInteger class-getting limits.
* last <1>:                              SortedCollection-basic.
* last <2>:                              LargeArraySubpart-accessing.
* last <3>:                              SequenceableCollection-basic.
* last:                                  RunArray-basic.
* lastAccessTime <1>:                    VFS.RealFileHandler-accessing.
* lastAccessTime <2>:                    File-accessing.
* lastAccessTime <3>:                    VFS.ArchiveMemberHandler-accessing.
* lastAccessTime:                        VFS.VFSHandler-accessing.
* lastChangeTime <1>:                    VFS.VFSHandler-accessing.
* lastChangeTime <2>:                    VFS.ArchiveMemberHandler-accessing.
* lastChangeTime <3>:                    VFS.RealFileHandler-accessing.
* lastChangeTime:                        File-accessing.
* lastDayOfMonth:                        Date-date computations.
* lastIndex:                             LargeArraySubpart-accessing.
* lastModifyTime <1>:                    VFS.RealFileHandler-accessing.
* lastModifyTime <2>:                    VFS.ArchiveMemberHandler-accessing.
* lastModifyTime <3>:                    File-accessing.
* lastModifyTime:                        VFS.VFSHandler-accessing.
* lastUnwindPoint:                       ContextPart class-exception handling.
* lcm_:                                  Integer-math methods.
* left:                                  Rectangle-accessing.
* left_:                                 Rectangle-accessing.
* left_right_top_bottom_:                Rectangle class-instance creation.
* left_top_right_bottom_:                Rectangle-accessing.
* leftCenter:                            Rectangle-accessing.
* lf:                                    Character class-constants.
* libraries:                             Package-accessing.
* librariesFor_:                         PackageLoader class-accessing.
* library_getFunc_:                      DLD class-C functions.
* libraryList:                           DLD class-dynamic linking.
* lineDelimiter:                         CharacterArray class-basic.
* linesDo_:                              String-useful functionality.
* linkFile_:                             DLD class-C functions.
* literalAt_:                            CompiledCode-accessing.
* literalAt_put_:                        CompiledCode-accessing.
* literals:                              CompiledCode-accessing.
* literals_numArgs_numTemps_primitive_bytecodes_depth_: CompiledMethod class-instance creation.
* ln <1>:                                Float-built ins.
* ln:                                    Number-misc math.
* ln10 <1>:                              FloatQ class-characterization.
* ln10 <2>:                              Float class-characterization.
* ln10:                                  FloatE class-characterization.
* load:                                  ObjectDumper-loading/dumping objects.
* loadedClass:                           AutoloadClass-accessing.
* loadedMetaclass:                       AutoloadClass-accessing.
* loadFrom_ <1>:                         NullProxy class-instance creation.
* loadFrom_ <2>:                         DumperProxy class-accessing.
* loadFrom_ <3>:                         VersionableObjectProxy class-saving and restoring.
* loadFrom_:                             ObjectDumper class-shortcuts.
* localKernel:                           Directory class-reading system defaults.
* lock:                                  Semaphore-builtins.
* log:                                   Number-misc math.
* log10Base2 <1>:                        FloatQ class-characterization.
* log10Base2 <2>:                        FloatE class-characterization.
* log10Base2:                            Float class-characterization.
* log_:                                  Number-misc math.
* longAt_ <1>:                           Memory class-accessing.
* longAt_:                               ByteArray-more advanced accessing.
* longAt_put_ <1>:                       ByteArray-more advanced accessing.
* longAt_put_:                           Memory class-accessing.
* low:                                   SystemExceptions.ArgumentOutOfRange-accessing.
* low_:                                  SystemExceptions.ArgumentOutOfRange-accessing.
* lowerPriority:                         Process-basic.
* lowestPriority:                        ProcessorScheduler-priorities.
* lowIOPriority:                         ProcessorScheduler-priorities.
* makeEphemeron:                         Object-built ins.
* makeFixed:                             Object-built ins.
* makeReadOnly_:                         Object-built ins.
* makeWeak:                              Object-built ins.
* map:                                   MappedCollection-basic.
* mark:                                  ContextPart-exception handling.
* mark_:                                 Object-built ins.
* match_:                                CharacterArray-comparing.
* match_ignoreCase_:                     CharacterArray-comparing.
* max_ <1>:                              Point-comparing.
* max_ <2>:                              Number-comparing.
* max_:                                  Magnitude-misc methods.
* member_do_ <1>:                        VFS.ExternalArchiveFileHandler-ArchiveMemberHandler protocol.
* member_do_:                            VFS.ArchiveFileHandler-ArchiveMemberHandler protocol.
* merge_:                                Rectangle-rectangle functions.
* meridianAbbreviation:                  DateTime-computations.
* message <1>:                           TextCollector-set up.
* message:                               MessageNotUnderstood-accessing.
* message_ <1>:                          TextCollector class-accessing.
* message_:                              TextCollector-set up.
* messageText <1>:                       Signal-accessing.
* messageText <2>:                       SystemExceptions.WrongClass-accessing.
* messageText <3>:                       SystemExceptions.WrongMessageSent-accessing.
* messageText <4>:                       SystemExceptions.InvalidValue-accessing.
* messageText <5>:                       SystemExceptions.InvalidArgument-accessing.
* messageText:                           SystemExceptions.IndexOutOfRange-accessing.
* messageText_:                          Signal-accessing.
* metaclassFor_:                         UndefinedObject-class creation.
* method <1>:                            BlockClosure-accessing.
* method <2>:                            CompiledBlock-accessing.
* method:                                ContextPart-accessing.
* methodCategory <1>:                    CompiledCode-basic.
* methodCategory <2>:                    CompiledBlock-basic.
* methodCategory:                        CompiledMethod-basic.
* methodCategory_ <1>:                   CompiledCode-basic.
* methodCategory_ <2>:                   CompiledBlock-basic.
* methodCategory_:                       CompiledMethod-basic.
* methodClass <1>:                       CompiledBlock-accessing.
* methodClass <2>:                       MethodInfo-accessing.
* methodClass <3>:                       ContextPart-accessing.
* methodClass <4>:                       CompiledCode-accessing.
* methodClass:                           CompiledMethod-accessing.
* methodClass_ <1>:                      CompiledMethod-accessing.
* methodClass_ <2>:                      MethodInfo-accessing.
* methodClass_ <3>:                      CompiledBlock-accessing.
* methodClass_:                          CompiledCode-accessing.
* methodDictionary:                      Behavior-method dictionary.
* methodDictionary_:                     Behavior-method dictionary.
* methods:                               Behavior-compilation (alternative).
* methodsFor:                            Behavior-compilation (alternative).
* methodsFor_:                           Behavior-compiling methods.
* methodsFor_ifFeatures_:                Behavior-compilation (alternative).
* methodsFor_ifTrue_:                    Behavior-built ins.
* methodsFor_stamp_:                     Behavior-compilation (alternative).
* methodSourceCode <1>:                  CompiledCode-basic.
* methodSourceCode <2>:                  CompiledMethod-basic.
* methodSourceCode:                      CompiledBlock-basic.
* methodSourceFile <1>:                  CompiledCode-basic.
* methodSourceFile <2>:                  CompiledMethod-basic.
* methodSourceFile:                      CompiledBlock-basic.
* methodSourcePos <1>:                   CompiledBlock-basic.
* methodSourcePos <2>:                   CompiledCode-basic.
* methodSourcePos:                       CompiledMethod-basic.
* methodSourceString <1>:                CompiledMethod-basic.
* methodSourceString <2>:                CompiledCode-basic.
* methodSourceString:                    CompiledBlock-basic.
* millisecondClock:                      Time class-clocks.
* millisecondClockValue <1>:             Time class-clocks.
* millisecondClockValue:                 Delay class-general inquiries.
* millisecondsPerDay:                    Time class-clocks.
* millisecondsToRun_:                    Time class-clocks.
* min_ <1>:                              Magnitude-misc methods.
* min_ <2>:                              Number-comparing.
* min_:                                  Point-comparing.
* minute <1>:                            Time-accessing (ANSI for DateAndTimes).
* minute:                                DateTime-computations.
* minutes:                               Time-accessing (non ANSI & for Durations).
* minutes_:                              Time class-instance creation.
* module:                                Directory class-reading system defaults.
* moduleList:                            DLD class-dynamic linking.
* modules:                               Package-accessing.
* modulesFor_:                           PackageLoader class-accessing.
* month:                                 Date-date computations.
* monthAbbreviation:                     Date-date computations.
* monthName:                             Date-date computations.
* mourn <1>:                             Object-finalization.
* mourn <2>:                             HomedAssociation-finalization.
* mourn:                                 Association-finalization.
* mourn_:                                Collection-finalization.
* moveBy_:                               Rectangle-transforming.
* moveTo_:                               Rectangle-transforming.
* multiBecome_:                          Array-mutating objects.
* multiply_:                             LargePositiveInteger-primitive operations.
* mustBeBoolean:                         Object-exception handling.
* name <1>:                              BindingDictionary-accessing.
* name <2>:                              Metaclass-delegation.
* name <3>:                              AutoloadClass-accessing.
* name <4>:                              File-accessing.
* name <5>:                              VFS.VFSHandler-accessing.
* name <6>:                              Semaphore-accessing.
* name <7>:                              AbstractNamespace-printing.
* name <8>:                              CFunctionDescriptor-accessing.
* name <9>:                              Package-accessing.
* name <10>:                             RecursionLock-accessing.
* name <11>:                             Behavior-support for lightweight classes.
* name <12>:                             FileDescriptor-accessing.
* name <13>:                             Class-accessing instances and variables.
* name:                                  Process-accessing.
* name_ <1>:                             RecursionLock-accessing.
* name_ <2>:                             File class-instance creation.
* name_ <3>:                             AutoloadClass-accessing.
* name_ <4>:                             Process-accessing.
* name_ <5>:                             VFS.RealFileHandler-accessing.
* name_ <6>:                             Package-accessing.
* name_ <7>:                             VFS.VFSHandler-accessing.
* name_ <8>:                             Semaphore-accessing.
* name_:                                 AbstractNamespace-printing.
* name_environment_subclassOf_instanceVariableNames_variable_words_pointers_classVariableNames_poolDictionaries_category_: Metaclass-basic.
* name_realFileName_:                    VFS.DecodedFileHandler-files.
* nameAt_:                               Directory-accessing.
* nameIn_ <1>:                           SystemDictionary-printing.
* nameIn_ <2>:                           Metaclass-printing.
* nameIn_ <3>:                           AbstractNamespace-printing.
* nameIn_ <4>:                           BindingDictionary-accessing.
* nameIn_ <5>:                           Behavior-support for lightweight classes.
* nameIn_ <6>:                           ClassDescription-printing.
* nameIn_ <7>:                           Namespace-printing.
* nameIn_:                               RootNamespace-printing.
* nameOfDay_:                            Date class-basic.
* nameOfMonth_:                          Date class-basic.
* namesMatching_do_:                     Directory-enumerating.
* nan <1>:                               FloatQ class-characterization.
* nan <2>:                               FloatE class-characterization.
* nan:                                   FloatD class-characterization.
* negated <1>:                           Fraction-optimized cases.
* negated <2>:                           Number-misc math.
* negated <3>:                           Float-arithmetic.
* negated <4>:                           LargeInteger-arithmetic.
* negated:                               Duration-arithmetics.
* negative <1>:                          Float-testing.
* negative <2>:                          LargePositiveInteger-numeric testing.
* negative <3>:                          LargeNegativeInteger-numeric testing.
* negative <4>:                          Number-testing.
* negative:                              Duration-arithmetics.
* negativeInfinity <1>:                  FloatD class-characterization.
* negativeInfinity <2>:                  FloatE class-characterization.
* negativeInfinity:                      FloatQ class-characterization.
* new <1>:                               ProcessorScheduler class-instance creation.
* new <2>:                               ZeroDivide class-instance creation.
* new <3>:                               ValueHolder class-creating instances.
* new <4>:                               ValueAdaptor class-creating instances.
* new <5>:                               Time class-instance creation.
* new <6>:                               TextCollector class-accessing.
* new <7>:                               Symbol class-instance creation.
* new <8>:                               SortedCollection class-instance creation.
* new <9>:                               SharedQueue class-instance creation.
* new <10>:                              Semaphore class-instance creation.
* new <11>:                              RunArray class-instance creation.
* new <12>:                              RecursionLock class-instance creation.
* new <13>:                              Rectangle class-instance creation.
* new <14>:                              Random class-instance creation.
* new <15>:                              Point class-instance creation.
* new <16>:                              OrderedCollection class-instance creation.
* new <17>:                              ObjectDumper class-instance creation.
* new <18>:                              NullValueHolder class-creating instances.
* new <19>:                              NetClients.URL class-instance creation.
* new <20>:                              Namespace class-disabling instance creation.
* new <21>:                              MappedCollection class-instance creation.
* new <22>:                              LookupTable class-instance creation.
* new <23>:                              HashedCollection class-instance creation.
* new <24>:                              ExceptionSet class-instance creation.
* new <25>:                              Exception class-instance creation.
* new <26>:                              Dictionary class-instance creation.
* new <27>:                              CType-C instance creation.
* new <28>:                              CoreException class-instance creation.
* new <29>:                              CObject class-instance creation.
* new <30>:                              CCompound class-instance creation.
* new <31>:                              Behavior-built ins.
* new <32>:                              Bag class-basic.
* new:                                   AbstractNamespace class-instance creation.
* new_ <1>:                              RunArray class-instance creation.
* new_ <2>:                              CObject class-instance creation.
* new_ <3>:                              HashedCollection class-instance creation.
* new_ <4>:                              Bag class-basic.
* new_ <5>:                              Symbol class-instance creation.
* new_ <6>:                              SortedCollection class-instance creation.
* new_ <7>:                              WeakArray class-instance creation.
* new_ <8>:                              OrderedCollection class-instance creation.
* new_ <9>:                              Namespace class-disabling instance creation.
* new_ <10>:                             Behavior-built ins.
* new_ <11>:                             LargeArrayedCollection class-instance creation.
* new_ <12>:                             CPtrCType-accessing.
* new_:                                  RootNamespace class-instance creation.
* new_withAll_:                          ArrayedCollection class-instance creation.
* newBuffer <1>:                         FileStream-buffering.
* newBuffer:                             FileDescriptor-initialize-release.
* newChild:                              CoreException-instance creation.
* newCollection_ <1>:                    LargeWordArray-overridden.
* newCollection_ <2>:                    LargeArray-overridden.
* newCollection_:                        LargeByteArray-overridden.
* newDay_month_year_:                    Date class-instance creation (Blue Book).
* newDay_monthIndex_year_:               Date class-instance creation (Blue Book).
* newDay_year_:                          Date class-instance creation (Blue Book).
* newFromNumber_scale_:                  ScaledDecimal class-instance creation.
* newInFixedSpace:                       Behavior-instance creation.
* newInFixedSpace_:                      Behavior-instance creation.
* newMemberHandlerFor_:                  VFS.ArchiveFileHandler-ArchiveMemberHandler protocol.
* newMeta_environment_subclassOf_instanceVariableNames_variable_words_pointers_classVariableNames_poolDictionaries_category_: Metaclass-basic.
* newMethod_header_literals_:            CompiledCode class-instance creation.
* newMethod_header_method_:              CompiledBlock class-instance creation.
* newMethod_header_numLiterals_:         CompiledCode class-instance creation.
* newPage:                               Character class-constants.
* newProcess <1>:                        BlockClosure-multiple process.
* newProcess:                            DirectedMessage-multiple process.
* newProcessWith_:                       BlockClosure-multiple process.
* newsGroup:                             NetClients.URL-accessing.
* newStruct_declaration_:                CCompound class-subclass creation.
* next <1>:                              ByteStream-basic.
* next <2>:                              FileStream-basic.
* next <3>:                              FileDescriptor-basic.
* next <4>:                              ObjectDumper-stream interface.
* next <5>:                              PositionableStream-accessing-reading.
* next <6>:                              Random class-shortcuts.
* next <7>:                              Random-basic.
* next <8>:                              SharedQueue-accessing.
* next <9>:                              Stream-accessing-reading.
* next:                                  TokenStream-basic.
* next_ <1>:                             FileDescriptor-overriding inherited methods.
* next_ <2>:                             Stream-accessing-reading.
* next_:                                 FileStream-overriding inherited methods.
* next_put_ <1>:                         Stream-accessing-writing.
* next_put_:                             TextCollector-accessing.
* next_putAll_startingAt_:               Stream-accessing-writing.
* nextAvailable_:                        Stream-accessing-reading.
* nextByte <1>:                          FileDescriptor-basic.
* nextByte <2>:                          ByteStream-basic.
* nextByte:                              FileStream-basic.
* nextByteArray_ <1>:                    ByteStream-basic.
* nextByteArray_ <2>:                    FileStream-overriding inherited methods.
* nextByteArray_:                        FileDescriptor-overriding inherited methods.
* nextHunk <1>:                          FileStream-buffering.
* nextHunk:                              FileDescriptor-initialize-release.
* nextInstance:                          Object-built ins.
* nextLine:                              Stream-accessing-reading.
* nextLink:                              Link-basic.
* nextLink_ <1>:                         Link class-instance creation.
* nextLink_:                             Link-basic.
* nextLong:                              ByteStream-basic.
* nextMatchFor_:                         Stream-accessing-reading.
* nextPut_ <1>:                          TokenStream-write methods.
* nextPut_ <2>:                          FileDescriptor-basic.
* nextPut_ <3>:                          FileStream-basic.
* nextPut_ <4>:                          ByteStream-basic.
* nextPut_ <5>:                          ObjectDumper-stream interface.
* nextPut_ <6>:                          Stream-accessing-writing.
* nextPut_ <7>:                          SharedQueue-accessing.
* nextPut_ <8>:                          WriteStream-accessing-writing.
* nextPut_ <9>:                          TextCollector-accessing.
* nextPut_:                              Random-basic.
* nextPutAll_ <1>:                       ByteStream-basic.
* nextPutAll_ <2>:                       FileStream-overriding inherited methods.
* nextPutAll_ <3>:                       FileDescriptor-overriding inherited methods.
* nextPutAll_ <4>:                       TextCollector-accessing.
* nextPutAll_:                           Stream-accessing-writing.
* nextPutAllFlush_:                      FileStream-overriding inherited methods.
* nextPutByte_ <1>:                      FileDescriptor-basic.
* nextPutByte_ <2>:                      ByteStream-basic.
* nextPutByte_:                          FileStream-basic.
* nextPutByteArray_ <1>:                 FileDescriptor-basic.
* nextPutByteArray_ <2>:                 ByteStream-basic.
* nextPutByteArray_:                     FileStream-basic.
* nextPutLong_:                          ByteStream-basic.
* nextPutShort_:                         ByteStream-basic.
* nextShort:                             ByteStream-basic.
* nextSignedByte:                        ByteStream-basic.
* nextUlong:                             ByteStream-basic.
* nextUshort:                            ByteStream-basic.
* nextValidOop:                          SmallInteger-built ins.
* nl <1>:                                Character class-constants.
* nl:                                    Stream-character writing.
* nlTab:                                 Stream-character writing.
* noMask_:                               Integer-bit operators.
* nonVersionedInstSize:                  Class-saving and loading.
* normal:                                Point-point functions.
* noRunnableProcess:                     Object-exception handling.
* not <1>:                               True-basic.
* not <2>:                               False-basic.
* not:                                   Boolean-basic.
* notEmpty <1>:                          Collection-testing collections.
* notEmpty:                              LinkedList-testing.
* notify:                                Semaphore-builtins.
* notifyAll:                             Semaphore-builtins.
* notNil <1>:                            UndefinedObject-testing.
* notNil:                                Object-testing functionality.
* notYetImplemented:                     Object-built ins.
* now <1>:                               DateTime class-instance creation.
* now:                                   Time class-instance creation.
* nthOuterContext_:                      BlockContext-accessing.
* nul:                                   Character class-constants.
* null <1>:                              Promise class-creating instances.
* null:                                  ValueHolder class-creating instances.
* numArgs <1>:                           CompiledBlock-accessing.
* numArgs <2>:                           ContextPart-accessing.
* numArgs <3>:                           BlockClosure-accessing.
* numArgs <4>:                           Symbol-basic.
* numArgs <5>:                           CompiledCode-accessing.
* numArgs:                               CompiledMethod-accessing.
* numArgs_numTemps_bytecodes_depth_literals_ <1>: BlockClosure class-instance creation.
* numArgs_numTemps_bytecodes_depth_literals_: CompiledBlock class-instance creation.
* numberOfElements:                      CArrayCType-accessing.
* numCompactions:                        ObjectMemory-accessing.
* numerator <1>:                         Integer-accessing.
* numerator:                             Fraction-accessing.
* numerator_denominator_:                Fraction class-instance creation.
* numFixedOOPs:                          ObjectMemory-accessing.
* numFreeOTEs:                           ObjectMemory-accessing.
* numGlobalGCs:                          ObjectMemory-accessing.
* numGrowths:                            ObjectMemory-accessing.
* numLiterals <1>:                       CompiledCode-accessing.
* numLiterals:                           CompiledBlock-accessing.
* numOldOOPs:                            ObjectMemory-accessing.
* numOTEs:                               ObjectMemory-accessing.
* numScavenges:                          ObjectMemory-accessing.
* numTemps <1>:                          CompiledCode-accessing.
* numTemps <2>:                          CompiledBlock-accessing.
* numTemps <3>:                          BlockClosure-accessing.
* numTemps <4>:                          CompiledMethod-accessing.
* numTemps:                              ContextPart-accessing.
* numWeakOOPs:                           ObjectMemory-accessing.
* object <1>:                            DumperProxy-saving and restoring.
* object <2>:                            SingletonProxy-saving and restoring.
* object <3>:                            AlternativeObjectProxy-accessing.
* object:                                PluggableProxy-saving and restoring.
* object_:                               AlternativeObjectProxy-accessing.
* objectAt_:                             ByteArray-more advanced accessing.
* objectAt_put_:                         ByteArray-more advanced accessing.
* objectsAndRunLengthsDo_:               RunArray-enumerating.
* occurrencesOf_ <1>:                    HashedCollection-testing collections.
* occurrencesOf_ <2>:                    Bag-testing collections.
* occurrencesOf_ <3>:                    Dictionary-dictionary testing.
* occurrencesOf_ <4>:                    SortedCollection-searching.
* occurrencesOf_:                        Collection-testing collections.
* odd <1>:                               Number-testing.
* odd:                                   Integer-math methods.
* offset:                                DateTime-time zones.
* offset_:                               DateTime-time zones.
* oldSpaceSize:                          ObjectMemory-accessing.
* oldSpaceUsedBytes:                     ObjectMemory-accessing.
* on_ <1>:                               File class-instance creation.
* on_ <2>:                               PluggableProxy class-accessing.
* on_ <3>:                               ReadStream class-instance creation.
* on_ <4>:                               TokenStream class-instance creation.
* on_ <5>:                               PositionableStream class-instance creation.
* on_ <6>:                               NetClients.URIResolver class-instance creation.
* on_ <7>:                               ObjectDumper class-instance creation.
* on_ <8>:                               WriteStream class-instance creation.
* on_ <9>:                               DumperProxy class-instance creation.
* on_ <10>:                              FileDescriptor class-instance creation.
* on_ <11>:                              SingletonProxy class-instance creation.
* on_ <12>:                              AlternativeObjectProxy class-instance creation.
* on_:                                   ReadWriteStream class-instance creation.
* on_aspect_:                            PluggableAdaptor class-creating instances.
* on_do_:                                BlockClosure-exception handling.
* on_do_on_do_:                          BlockClosure-exception handling.
* on_do_on_do_on_do_:                    BlockClosure-exception handling.
* on_do_on_do_on_do_on_do_:              BlockClosure-exception handling.
* on_do_on_do_on_do_on_do_on_do_:        BlockClosure-exception handling.
* on_from_to_:                           PositionableStream class-instance creation.
* on_getSelector_putSelector_:           PluggableAdaptor class-creating instances.
* on_index_:                             PluggableAdaptor class-creating instances.
* on_key_:                               PluggableAdaptor class-creating instances.
* on_startingAt_for_:                    FileSegment class-basic.
* one:                                   ScaledDecimal-constants.
* onStream_:                             TokenStream class-instance creation.
* open_ <1>:                             FileDescriptor class-instance creation.
* open_:                                 File-file operations.
* open_ifFail_ <1>:                      VFS.VFSHandler-file operations.
* open_ifFail_:                          File-file operations.
* open_mode_:                            FileDescriptor class-instance creation.
* open_mode_ifFail_ <1>:                 VFS.RealFileHandler-file operations.
* open_mode_ifFail_ <2>:                 FileDescriptor class-instance creation.
* open_mode_ifFail_ <3>:                 VFS.ArchiveMemberHandler-file operations.
* open_mode_ifFail_:                     VFS.VFSHandler-file operations.
* openDescriptor_:                       File-file operations.
* openDescriptor_ifFail_:                VFS.VFSHandler-file operations.
* openDir_:                              VFS.VFSHandler-C functions.
* openOn_:                               NetClients.URIResolver class-api.
* openOn_ifFail_:                        NetClients.URIResolver class-api.
* openStreamOn_:                         NetClients.URIResolver class-api.
* openStreamOn_ifFail_:                  NetClients.URIResolver class-api.
* openTemporaryFile_:                    FileDescriptor class-instance creation.
* or_ <1>:                               Boolean-basic.
* or_ <2>:                               True-basic.
* or_:                                   False-basic.
* origin:                                Rectangle-accessing.
* origin_:                               Rectangle-accessing.
* origin_corner_ <1>:                    Rectangle class-instance creation.
* origin_corner_:                        Rectangle-accessing.
* origin_extent_ <1>:                    Rectangle class-instance creation.
* origin_extent_:                        Rectangle-accessing.
* outer:                                 Signal-exception handling.
* outerContext <1>:                      BlockClosure-accessing.
* outerContext:                          BlockContext-accessing.
* outerContext_:                         BlockClosure-accessing.
* parent <1>:                            VFS.ArchiveMemberHandler-accessing.
* parent:                                CoreException-accessing.
* parent_:                               VFS.ArchiveMemberHandler-initializing.
* parentContext:                         ContextPart-accessing.
* parentContext_:                        ContextPart-accessing.
* parserClass:                           Behavior-pluggable behavior (not yet implemented).
* pass:                                  Signal-exception handling.
* password:                              NetClients.URL-accessing.
* password_:                             NetClients.URL-accessing.
* path <1>:                              VariableBinding-printing.
* path <2>:                              File-file name management.
* path:                                  NetClients.URL-accessing.
* path_:                                 NetClients.URL-accessing.
* pathFor_:                              File class-file name management.
* pathSeparator:                         Directory class-file name management.
* pathSeparatorString:                   Directory class-file name management.
* peek <1>:                              PositionableStream-accessing-reading.
* peek <2>:                              FileDescriptor-basic.
* peek <3>:                              FileStream-basic.
* peek:                                  SharedQueue-accessing.
* peekFor_:                              PositionableStream-accessing-reading.
* pendingWrite:                          FileStream-buffering.
* perform_:                              Object-built ins.
* perform_with_:                         Object-built ins.
* perform_with_with_:                    Object-built ins.
* perform_with_with_with_:               Object-built ins.
* perform_withArguments_:                Object-built ins.
* pi <1>:                                Float class-characterization.
* pi <2>:                                FloatQ class-characterization.
* pi:                                    FloatE class-characterization.
* popen_dir_:                            FileDescriptor class-instance creation.
* popen_dir_ifFail_:                     FileDescriptor class-instance creation.
* port:                                  NetClients.URL-accessing.
* port_:                                 NetClients.URL-accessing.
* position <1>:                          PositionableStream-positioning.
* position <2>:                          FileDescriptor-basic.
* position:                              FileStream-basic.
* position_ <1>:                         FileStream-basic.
* position_ <2>:                         FileDescriptor-basic.
* position_ <3>:                         PositionableStream-positioning.
* position_:                             ReadWriteStream-positioning.
* positive <1>:                          LargePositiveInteger-numeric testing.
* positive <2>:                          Number-testing.
* positive <3>:                          LargeNegativeInteger-numeric testing.
* positive <4>:                          Duration-arithmetics.
* positive:                              Float-testing.
* positiveDifference_:                   Number-misc math.
* postCopy <1>:                          Object-copying.
* postCopy <2>:                          CoreException-basic.
* postCopy:                              NetClients.URL-copying.
* postData:                              NetClients.URL-accessing.
* postData_:                             NetClients.URL-accessing.
* postLoad <1>:                          Object-saving and loading.
* postLoad <2>:                          WeakArray-loading.
* postLoad <3>:                          HashedCollection-saving and loading.
* postLoad:                              SortedCollection-saving and loading.
* postStore <1>:                         Object-saving and loading.
* postStore:                             HashedCollection-saving and loading.
* precision <1>:                         FloatQ class-characterization.
* precision <2>:                         FloatD class-characterization.
* precision:                             FloatE class-characterization.
* prerequisites:                         Package-accessing.
* prerequisitesFor_:                     PackageLoader class-accessing.
* preStore <1>:                          Object-saving and loading.
* preStore:                              SortedCollection-saving and loading.
* primaryInstance:                       Metaclass-accessing.
* primAt_:                               HashedCollection-builtins.
* primAt_put_:                           HashedCollection-builtins.
* primCreateDir_mode_:                   VFS.VFSHandler-C functions.
* primDefineExternFunc_:                 DLD class-dynamic linking.
* primDivide_:                           LargePositiveInteger-helper byte-level methods.
* primError_:                            Object-built ins.
* primHash:                              Float-built ins.
* primIsExecutable_:                     VFS.VFSHandler-C functions.
* primIsReadable_:                       VFS.VFSHandler-C functions.
* primIsWriteable_:                      VFS.VFSHandler-C functions.
* primitive <1>:                         CompiledMethod-accessing.
* primitive:                             CompiledCode-accessing.
* primitiveFailed:                       Object-built ins.
* primMillisecondClock:                  Time class-builtins.
* primNew_name_:                         AbstractNamespace class-instance creation.
* primObject:                            AlternativeObjectProxy-accessing.
* primRemoveDir_:                        VFS.VFSHandler-C functions.
* primRename_to_:                        VFS.VFSHandler-C functions.
* primReplaceFrom_to_with_startingAt_ <1>: String-built ins.
* primReplaceFrom_to_with_startingAt_ <2>: ByteArray-built ins.
* primReplaceFrom_to_with_startingAt_:   LargeInteger-built-ins.
* primSecondClock:                       Time class-builtins.
* primSize:                              HashedCollection-builtins.
* primTerminate:                         Process-basic.
* primUnlink_:                           VFS.VFSHandler-C functions.
* primWorking_:                          Directory class-C functions.
* print:                                 Object-printing.
* print_ <1>:                            Stream-printing.
* print_:                                TextCollector-printing.
* printHierarchy:                        Behavior-printing hierarchy.
* printNl:                               Object-printing.
* printOn_ <1>:                          UndefinedObject-printing.
* printOn_ <2>:                          True-printing.
* printOn_ <3>:                          Interval-printing.
* printOn_ <4>:                          ValueAdaptor-printing.
* printOn_ <5>:                          Duration-arithmetics.
* printOn_ <6>:                          VariableBinding-printing.
* printOn_ <7>:                          Time-arithmetic.
* printOn_ <8>:                          DirectedMessage-basic.
* printOn_ <9>:                          TextCollector-printing.
* printOn_ <10>:                         Dictionary-printing.
* printOn_ <11>:                         Bag-printing.
* printOn_ <12>:                         Fraction-printing.
* printOn_ <13>:                         LookupKey-printing.
* printOn_ <14>:                         SymLink-printing.
* printOn_ <15>:                         Symbol-storing.
* printOn_ <16>:                         DateTime-printing.
* printOn_ <17>:                         BlockContext-printing.
* printOn_ <18>:                         Message-basic.
* printOn_ <19>:                         Date-printing.
* printOn_ <20>:                         False-printing.
* printOn_ <21>:                         Association-printing.
* printOn_ <22>:                         Metaclass-printing.
* printOn_ <23>:                         MethodContext-printing.
* printOn_ <24>:                         Array-printing.
* printOn_ <25>:                         Semaphore-printing.
* printOn_ <26>:                         CFunctionDescriptor-printing.
* printOn_ <27>:                         ScaledDecimal-printing.
* printOn_ <28>:                         AbstractNamespace-printing.
* printOn_ <29>:                         NetClients.URL-printing.
* printOn_ <30>:                         Float-printing.
* printOn_ <31>:                         RecursionLock-printing.
* printOn_ <32>:                         Character-printing.
* printOn_ <33>:                         Rectangle-printing.
* printOn_ <34>:                         CharacterArray-printing.
* printOn_ <35>:                         Promise-printing.
* printOn_ <36>:                         ProcessorScheduler-printing.
* printOn_ <37>:                         Process-printing.
* printOn_ <38>:                         Class-printing.
* printOn_ <39>:                         CompiledMethod-printing.
* printOn_ <40>:                         Point-printing.
* printOn_ <41>:                         Object-printing.
* printOn_ <42>:                         CObject-accessing.
* printOn_ <43>:                         CompiledBlock-printing.
* printOn_ <44>:                         Package-accessing.
* printOn_ <45>:                         FileDescriptor-printing.
* printOn_ <46>:                         Collection-printing.
* printOn_:                              Integer-printing.
* printOn_base_:                         Integer-printing.
* printOn_base_showRadix_:               Integer-printing.
* printOn_in_ <1>:                       BindingDictionary-printing.
* printOn_in_ <2>:                       Behavior-support for lightweight classes.
* printOn_in_ <3>:                       RootNamespace-printing.
* printOn_in_ <4>:                       Metaclass-printing.
* printOn_in_ <5>:                       SystemDictionary-printing.
* printOn_in_ <6>:                       Namespace-printing.
* printOn_in_:                           ClassDescription-printing.
* printString:                           Object-printing.
* printString_:                          Integer-printing.
* printStringRadix_:                     Integer-printing.
* printSubclasses_using_:                Behavior-printing hierarchy.
* printXmlOn_collection_tag_:            Package-accessing.
* priority:                              Process-accessing.
* priority_:                             Process-accessing.
* priorityName_:                         ProcessorScheduler-priorities.
* privateMethods:                        Behavior-compilation (alternative).
* processesAt_:                          ProcessorScheduler-basic.
* proxyClassFor_:                        ObjectDumper class-establishing proxy classes.
* proxyFor_:                             ObjectDumper class-establishing proxy classes.
* ptrType:                               CType-accessing.
* publicMethods:                         Behavior-compilation (alternative).
* putenv_:                               SystemDictionary-C functions.
* query:                                 NetClients.URL-accessing.
* query_:                                NetClients.URL-accessing.
* queueInterrupt_:                       Process-accessing.
* quit:                                  ObjectMemory class-builtins.
* quit_:                                 ObjectMemory class-builtins.
* quo_ <1>:                              LargeZeroInteger-arithmetic.
* quo_ <2>:                              LargeInteger-arithmetic.
* quo_ <3>:                              SmallInteger-built ins.
* quo_:                                  Number-arithmetic.
* radiansToDegrees:                      Number-converting.
* radix:                                 Float class-characterization.
* radix_:                                Integer-printing.
* raisedTo_ <1>:                         Number-misc math.
* raisedTo_:                             Float-built ins.
* raisedToInteger_ <1>:                  Number-misc math.
* raisedToInteger_:                      Fraction-optimized cases.
* raisePriority:                         Process-basic.
* read:                                  FileDescriptor class-instance creation.
* read_:                                 FileDescriptor-low-level access.
* read_from_to_:                         FileDescriptor-low-level access.
* read_numBytes_:                        FileDescriptor-low-level access.
* readDir_:                              VFS.VFSHandler-C functions.
* readFrom_ <1>:                         Time class-instance creation.
* readFrom_ <2>:                         Number class-converting.
* readFrom_ <3>:                         Date class-instance creation (Blue Book).
* readFrom_:                             DateTime class-instance creation.
* reads_ <1>:                            CompiledCode-testing accesses.
* reads_:                                CompiledMethod-testing.
* readStream <1>:                        SequenceableCollection-enumerating.
* readStream:                            File-file operations.
* readWrite:                             FileDescriptor class-instance creation.
* readWriteStream:                       SequenceableCollection-enumerating.
* realFileName <1>:                      VFS.VFSHandler-accessing.
* realFileName <2>:                      VFS.DecodedFileHandler-files.
* realFileName:                          VFS.ArchiveMemberHandler-finalization.
* rebuildTable:                          Symbol class-symbol table.
* receiver <1>:                          BlockClosure-accessing.
* receiver <2>:                          ContextPart-accessing.
* receiver <3>:                          DirectedMessage-accessing.
* receiver:                              MessageNotUnderstood-accessing.
* receiver_ <1>:                         DirectedMessage-accessing.
* receiver_:                             BlockClosure-accessing.
* reciprocal <1>:                        Fraction-optimized cases.
* reciprocal:                            Number-arithmetic.
* reclaimedBytesPerGlobalGC:             ObjectMemory-accessing.
* reclaimedBytesPerScavenge:             ObjectMemory-accessing.
* reclaimedPercentPerScavenge:           ObjectMemory-accessing.
* recompile_:                            Behavior-method dictionary.
* recompile_notifying_:                  Behavior-method dictionary.
* reconstructOriginalObject <1>:         DirectedMessage-saving and loading.
* reconstructOriginalObject:             Object-saving and loading.
* record_:                               FileStream class-file-in.
* refersTo_:                             CompiledCode-testing accesses.
* refresh <1>:                           VFS.RealFileHandler-accessing.
* refresh <2>:                           VFS.ArchiveMemberHandler-accessing.
* refresh <3>:                           File-accessing.
* refresh <4>:                           VFS.VFSHandler-accessing.
* refresh:                               VFS.ExternalArchiveFileHandler-ArchiveMemberHandler protocol.
* refreshDependencies:                   PackageLoader class-accessing.
* register_forClass_:                    VFS.VFSHandler class-initializing.
* registerProxyClass_for_:               ObjectDumper class-establishing proxy classes.
* rehash <1>:                            WeakValueLookupTable-rehashing.
* rehash <2>:                            Dictionary-rehashing.
* rehash <3>:                            HashedCollection-rehashing.
* rehash <4>:                            MethodDictionary-rehashing.
* rehash:                                LookupTable-rehashing.
* reinvokeFor_:                          Message-basic.
* reject_ <1>:                           Collection-enumeration.
* reject_ <2>:                           MappedCollection-basic.
* reject_ <3>:                           Dictionary-dictionary enumerating.
* reject_:                               ArrayedCollection-enumerating the elements of a collection.
* release <1>:                           VFS.DecodedFileHandler-files.
* release <2>:                           VFS.ExternalArchiveFileHandler-releasing.
* release <3>:                           VFS.ArchiveFileHandler-directory operations.
* release <4>:                           VFS.ArchiveMemberHandler-finalization.
* release <5>:                           Object-dependents access.
* release:                               UndefinedObject-dependents access.
* relocateFrom_to_:                      FileSegment class-installing.
* relocateFrom_to_map_:                  FileSegment-basic.
* relocateTo_:                           LargeArraySubpart-modifying.
* rem_ <1>:                              Number-arithmetic.
* rem_ <2>:                              LargeInteger-arithmetic.
* rem_:                                  LargeZeroInteger-arithmetic.
* remove <1>:                            VFS.RealFileHandler-file operations.
* remove <2>:                            File-file operations.
* remove <3>:                            VFS.ArchiveFileHandler-file operations.
* remove <4>:                            VFS.VFSHandler-file operations.
* remove:                                VFS.ArchiveMemberHandler-file operations.
* remove_ <1>:                           File class-file operations.
* remove_ <2>:                           MethodDictionary-removing.
* remove_ <3>:                           Collection-removing.
* remove_ <4>:                           Dictionary-dictionary removing.
* remove_:                               LookupTable-removing.
* remove_ifAbsent_ <1>:                  LookupTable-removing.
* remove_ifAbsent_ <2>:                  WeakSet-accessing.
* remove_ifAbsent_ <3>:                  Collection-removing.
* remove_ifAbsent_ <4>:                  OrderedCollection-removing.
* remove_ifAbsent_ <5>:                  LinkedList-adding.
* remove_ifAbsent_ <6>:                  Dictionary-dictionary removing.
* remove_ifAbsent_ <7>:                  Bag-removing.
* remove_ifAbsent_:                      HashedCollection-removing.
* removeAll_:                            Collection-removing.
* removeAll_ifAbsent_:                   Collection-removing.
* removeAllKeys_:                        Dictionary-dictionary removing.
* removeAllKeys_ifAbsent_:               Dictionary-dictionary removing.
* removeAtIndex_ <1>:                    OrderedCollection-removing.
* removeAtIndex_:                        RunArray-removing.
* removeCategory_:                       ClassDescription-organization of messages and classes.
* removeClassVarName_ <1>:               Class-accessing instances and variables.
* removeClassVarName_:                   Metaclass-delegation.
* removeDependent_:                      Object-dependents access.
* removeFeature_:                        SystemDictionary-special accessing.
* removeFirst <1>:                       LinkedList-adding.
* removeFirst <2>:                       OrderedCollection-removing.
* removeFirst:                           RunArray-removing.
* removeFirst_:                          LargeArraySubpart-modifying.
* removeInstVarName_:                    Behavior-instance variables.
* removeKey_:                            Dictionary-dictionary removing.
* removeKey_ifAbsent_ <1>:               LookupTable-removing.
* removeKey_ifAbsent_ <2>:               MethodDictionary-removing.
* removeKey_ifAbsent_:                   Dictionary-dictionary removing.
* removeLast <1>:                        OrderedCollection-removing.
* removeLast <2>:                        RunArray-removing.
* removeLast <3>:                        LinkedList-adding.
* removeLast:                            SortedCollection-basic.
* removeLast_:                           LargeArraySubpart-modifying.
* removeLastUnwindPoint:                 ContextPart class-exception handling.
* removeMember_ <1>:                     VFS.ExternalArchiveFileHandler-ArchiveMemberHandler protocol.
* removeMember_:                         VFS.ArchiveFileHandler-ArchiveMemberHandler protocol.
* removeSelector_:                       Behavior-method dictionary.
* removeSelector_ifAbsent_:              Behavior-method dictionary.
* removeSharedPool_ <1>:                 Metaclass-delegation.
* removeSharedPool_:                     Class-accessing instances and variables.
* removeSubclass_ <1>:                   UndefinedObject-class creation.
* removeSubclass_:                       Behavior-creating a class hierarchy.
* removeToBeFinalized:                   Object-finalization.
* rename_to_:                            File class-file operations.
* renameTo_ <1>:                         VFS.ArchiveMemberHandler-file operations.
* renameTo_ <2>:                         VFS.VFSHandler-file operations.
* renameTo_ <3>:                         VFS.RealFileHandler-file operations.
* renameTo_:                             File-file operations.
* repeat:                                BlockClosure-control structures.
* replaceAll_with_:                      SequenceableCollection-replacing items.
* replaceFrom_to_with_:                  SequenceableCollection-replacing items.
* replaceFrom_to_with_startingAt_ <1>:   SequenceableCollection-replacing items.
* replaceFrom_to_with_startingAt_ <2>:   ByteArray-built ins.
* replaceFrom_to_with_startingAt_:       String-built ins.
* replaceFrom_to_withByteArray_startingAt_: String-built ins.
* replaceFrom_to_withObject_:            SequenceableCollection-replacing items.
* replaceFrom_to_withString_startingAt_: ByteArray-built ins.
* requestString:                         NetClients.URL-accessing.
* require_:                              FileStream class-file-in.
* reset <1>:                             PositionableStream-positioning.
* reset:                                 FileDescriptor-basic.
* resignalAs_:                           Signal-exception handling.
* respondsTo_:                           Object-testing functionality.
* resume <1>:                            Process-builtins.
* resume:                                Signal-exception handling.
* resume_:                               Signal-exception handling.
* resumptionTime:                        Delay-accessing.
* retry:                                 Signal-exception handling.
* retry_coercing_:                       Number-retrying.
* retryDifferenceCoercing_:              Number-retrying.
* retryDivisionCoercing_:                Number-retrying.
* retryEqualityCoercing_:                Number-retrying.
* retryError:                            Number-retrying.
* retryInequalityCoercing_:              Number-retrying.
* retryMultiplicationCoercing_:          Number-retrying.
* retryRelationalOp_coercing_:           Number-retrying.
* retrySumCoercing_:                     Number-retrying.
* retryUsing_:                           Signal-exception handling.
* return:                                Signal-exception handling.
* return_:                               Signal-exception handling.
* reverse <1>:                           Interval-basic.
* reverse <2>:                           SequenceableCollection-enumerating.
* reverse:                               ArrayedCollection-copying Collections.
* reverseContents <1>:                   FileDescriptor-overriding inherited methods.
* reverseContents <2>:                   PositionableStream-accessing-reading.
* reverseContents <3>:                   WriteStream-accessing-writing.
* reverseContents:                       ReadStream-accessing-reading.
* reverseDo_:                            SequenceableCollection-enumerating.
* reverseStringBase_on_ <1>:             LargeZeroInteger-printing.
* reverseStringBase_on_:                 LargePositiveInteger-converting.
* rewindDir_:                            VFS.VFSHandler-C functions.
* right:                                 Rectangle-accessing.
* right_:                                Rectangle-accessing.
* rightCenter:                           Rectangle-accessing.
* rockBottomPriority:                    ProcessorScheduler-priorities.
* rounded <1>:                           Integer-converting.
* rounded <2>:                           Number-truncation and round off.
* rounded <3>:                           Point-truncation and round off.
* rounded:                               Rectangle-truncation and round off.
* roundTo_:                              Number-truncation and round off.
* sameAs_:                               CharacterArray-comparing.
* scalarIndex <1>:                       CByte-accessing.
* scalarIndex <2>:                       CSmalltalk-accessing.
* scalarIndex <3>:                       CUChar class-getting info.
* scalarIndex <4>:                       CUChar-accessing.
* scalarIndex <5>:                       CSmalltalk class-accessing.
* scalarIndex <6>:                       CInt-accessing.
* scalarIndex <7>:                       CChar class-accessing.
* scalarIndex <8>:                       CLong-accessing.
* scalarIndex <9>:                       CUInt class-accessing.
* scalarIndex <10>:                      CObject class-conversion.
* scalarIndex <11>:                      CDouble-accessing.
* scalarIndex <12>:                      CUInt-accessing.
* scalarIndex <13>:                      CFloat class-accessing.
* scalarIndex <14>:                      CUShort-accessing.
* scalarIndex <15>:                      CUShort class-accessing.
* scalarIndex <16>:                      CULong-accessing.
* scalarIndex <17>:                      CULong class-accessing.
* scalarIndex <18>:                      CObject-conversion.
* scalarIndex <19>:                      CShort class-accessing.
* scalarIndex <20>:                      CShort-accessing.
* scalarIndex <21>:                      CFloat-accessing.
* scalarIndex <22>:                      CByte class-conversion.
* scalarIndex <23>:                      CDouble class-accessing.
* scalarIndex <24>:                      CChar-accessing.
* scalarIndex <25>:                      CLong class-accessing.
* scalarIndex:                           CInt class-accessing.
* scaleBy_:                              Rectangle-transforming.
* scanBacktraceFor_do_:                  ContextPart-enumerating.
* scavenge:                              ObjectMemory class-builtins.
* scavengesBeforeTenuring:               ObjectMemory-derived information.
* scheme:                                NetClients.URL-accessing.
* scheme_:                               NetClients.URL-accessing.
* scheme_host_port_path_:                NetClients.URL class-instance creation.
* scheme_path_:                          NetClients.URL class-instance creation.
* scheme_username_password_host_port_path_: NetClients.URL class-instance creation.
* scopeHas_ifTrue_:                      Behavior-testing the method dictionary.
* scramble:                              SmallInteger-builtins.
* second <1>:                            DateTime-computations.
* second:                                Time-accessing (ANSI for DateAndTimes).
* secondClock:                           Time class-clocks.
* seconds:                               Time-accessing (non ANSI & for Durations).
* seconds_:                              Time class-instance creation.
* seed_:                                 Random class-instance creation.
* select_ <1>:                           ArrayedCollection-enumerating the elements of a collection.
* select_ <2>:                           Dictionary-dictionary enumerating.
* select_ <3>:                           MappedCollection-basic.
* select_:                               Collection-enumeration.
* selector <1>:                          CompiledMethod-accessing.
* selector <2>:                          MethodInfo-accessing.
* selector <3>:                          ContextPart-accessing.
* selector <4>:                          SystemExceptions.WrongMessageSent-accessing.
* selector <5>:                          CompiledCode-accessing.
* selector <6>:                          Message-accessing.
* selector:                              CompiledBlock-accessing.
* selector_ <1>:                         CompiledCode-accessing.
* selector_ <2>:                         Message-accessing.
* selector_ <3>:                         CompiledBlock-accessing.
* selector_ <4>:                         CompiledMethod-accessing.
* selector_ <5>:                         MethodInfo-accessing.
* selector_:                             SystemExceptions.WrongMessageSent-accessing.
* selector_arguments_ <1>:               DirectedMessage class-creating instances.
* selector_arguments_:                   Message class-creating instances.
* selector_arguments_receiver_:          DirectedMessage class-creating instances.
* selectorAt_:                           Behavior-accessing the methodDictionary.
* selectors:                             Behavior-accessing the methodDictionary.
* selectorsAndMethodsDo_:                Behavior-method dictionary.
* selectSubclasses_:                     Behavior-enumerating.
* selectSubspaces_:                      AbstractNamespace-namespace hierarchy.
* selectSuperclasses_:                   Behavior-enumerating.
* selectSuperspaces_:                    AbstractNamespace-namespace hierarchy.
* send:                                  DirectedMessage-basic.
* sender:                                MethodContext-accessing.
* sendTo_:                               Message-basic.
* set_to_:                               AbstractNamespace-overrides for superspaces.
* set_to_ifAbsent_ <1>:                  RootNamespace-overrides for superspaces.
* set_to_ifAbsent_ <2>:                  AbstractNamespace-overrides for superspaces.
* set_to_ifAbsent_:                      Namespace-overrides for superspaces.
* setBit_:                               Integer-bit operators.
* setPriorityFrom_to_suspend_:           Process-accessing.
* setToEnd <1>:                          FileDescriptor-overriding inherited methods.
* setToEnd:                              PositionableStream-positioning.
* setTraceFlag_to_:                      SystemDictionary-builtins.
* shallowCopy <1>:                       BindingDictionary-copying.
* shallowCopy <2>:                       WeakArray-conversion.
* shallowCopy <3>:                       Object-built ins.
* shallowCopy <4>:                       HashedCollection-copying.
* shallowCopy <5>:                       Number-copying.
* shallowCopy <6>:                       Boolean-overriding.
* shallowCopy <7>:                       UndefinedObject-basic.
* shallowCopy <8>:                       RunArray-copying.
* shallowCopy <9>:                       Symbol-basic.
* shallowCopy:                           BlockClosure-overriding.
* sharedPools <1>:                       Metaclass-delegation.
* sharedPools <2>:                       Behavior-accessing instances and variables.
* sharedPools:                           Class-accessing instances and variables.
* sharedVariableString:                  ClassDescription-printing.
* shortAt_ <1>:                          Memory class-accessing.
* shortAt_:                              ByteArray-more advanced accessing.
* shortAt_put_ <1>:                      ByteArray-more advanced accessing.
* shortAt_put_:                          Memory class-accessing.
* shortMonthName:                        Date-compatibility (non-ANSI).
* shortNameOfMonth_:                     Date class-basic.
* shouldNotImplement:                    Object-built ins.
* show_:                                 TextCollector-accessing.
* showCr_:                               TextCollector-accessing.
* showOnNewLine_:                        TextCollector-accessing.
* siblings <1>:                          Namespace-namespace hierarchy.
* siblings <2>:                          AbstractNamespace-namespace hierarchy.
* siblings:                              RootNamespace-namespace hierarchy.
* siblingsDo_ <1>:                       Namespace-namespace hierarchy.
* siblingsDo_ <2>:                       AbstractNamespace-namespace hierarchy.
* siblingsDo_:                           RootNamespace-namespace hierarchy.
* sign <1>:                              LargePositiveInteger-numeric testing.
* sign <2>:                              LargeNegativeInteger-numeric testing.
* sign <3>:                              Number-testing.
* sign <4>:                              Float-testing.
* sign:                                  LargeZeroInteger-numeric testing.
* signal <1>:                            Exception class-instance creation.
* signal <2>:                            CoreException-exception handling.
* signal <3>:                            Semaphore-builtins.
* signal:                                Exception-exception signaling.
* signal_ <1>:                           Exception-exception signaling.
* signal_:                               Exception class-instance creation.
* signal_atMilliseconds_:                ProcessorScheduler-timed invocation.
* signal_onInterrupt_:                   ProcessorScheduler-timed invocation.
* signalClass:                           CoreException-accessing.
* signalClass_:                          CoreException-accessing.
* signalOn_ <1>:                         SystemExceptions.EndOfStream class-signaling.
* signalOn_:                             SystemExceptions.InvalidValue class-signaling.
* signalOn_mustBe_:                      SystemExceptions.WrongClass class-signaling.
* signalOn_mustBeBetween_and_:           SystemExceptions.ArgumentOutOfRange class-signaling.
* signalOn_reason_:                      SystemExceptions.InvalidValue class-signaling.
* signalOn_useInstead_:                  SystemExceptions.WrongMessageSent class-signaling.
* signalOn_what_:                        SystemExceptions.NotFound class-accessing.
* signalOn_withIndex_:                   SystemExceptions.IndexOutOfRange class-signaling.
* signalWith_:                           CoreException-exception handling.
* signalWith_with_:                      CoreException-exception handling.
* signalWithArguments_:                  CoreException-exception handling.
* signByte <1>:                          FloatQ class-byte-order dependancies.
* signByte <2>:                          FloatE class-byte-order dependancies.
* signByte <3>:                          Float class-byte-order dependancies.
* signByte:                              FloatD class-byte-order dependancies.
* similarityTo_:                         String-built ins.
* sin <1>:                               Float-built ins.
* sin:                                   Number-misc math.
* singleStep:                            Process-basic.
* singleStepWaitingOn_:                  Process-builtins.
* size <1>:                              Link-iteration.
* size <2>:                              ArrayedCollection-built ins.
* size <3>:                              VFS.RealFileHandler-accessing.
* size <4>:                              Object-built ins.
* size <5>:                              File-accessing.
* size <6>:                              VFS.VFSHandler-accessing.
* size <7>:                              PositionableStream-positioning.
* size <8>:                              WriteStream-accessing.
* size <9>:                              VFS.ArchiveMemberHandler-accessing.
* size <10>:                             FileSegment-basic.
* size <11>:                             String-built ins.
* size <12>:                             HashedCollection-testing collections.
* size <13>:                             MappedCollection-basic.
* size <14>:                             Bag-testing collections.
* size <15>:                             OrderedCollection-accessing.
* size <16>:                             RunArray-basic.
* size <17>:                             Interval-basic.
* size <18>:                             LargeArrayedCollection-basic.
* size <19>:                             LargeInteger-built-ins.
* size <20>:                             Namespace-overrides for superspaces.
* size <21>:                             FileStream-basic.
* size <22>:                             FileDescriptor-basic.
* size <23>:                             WeakArray-accessing.
* size <24>:                             ContextPart-accessing.
* size <25>:                             ReadStream-accessing-reading.
* size <26>:                             Collection-testing collections.
* size <27>:                             LinkedList-testing.
* size:                                  LargeZeroInteger-accessing.
* size_stCtime_stMtime_stAtime_isDirectory_: VFS.ArchiveMemberHandler-initializing.
* sizeof <1>:                            CUInt-accessing.
* sizeof <2>:                            CLong-accessing.
* sizeof <3>:                            CLong class-accessing.
* sizeof <4>:                            CInt-accessing.
* sizeof <5>:                            CInt class-accessing.
* sizeof <6>:                            CPtr-accessing.
* sizeof <7>:                            CShort class-accessing.
* sizeof <8>:                            CShort-accessing.
* sizeof <9>:                            CSmalltalk class-accessing.
* sizeof <10>:                           CSmalltalk-accessing.
* sizeof <11>:                           CFloat-accessing.
* sizeof <12>:                           CFloat class-accessing.
* sizeof <13>:                           CDouble-accessing.
* sizeof <14>:                           CDouble class-accessing.
* sizeof <15>:                           CCompound class-subclass creation.
* sizeof <16>:                           CType-accessing.
* sizeof <17>:                           CUChar class-getting info.
* sizeof <18>:                           CUChar-accessing.
* sizeof <19>:                           CChar-accessing.
* sizeof <20>:                           CUInt class-accessing.
* sizeof <21>:                           CChar class-accessing.
* sizeof <22>:                           CArrayCType-accessing.
* sizeof <23>:                           CULong class-accessing.
* sizeof <24>:                           CArray-accessing.
* sizeof <25>:                           CULong-accessing.
* sizeof <26>:                           CAggregate class-accessing.
* sizeof <27>:                           CUShort class-accessing.
* sizeof:                                CUShort-accessing.
* skip_ <1>:                             ReadWriteStream-positioning.
* skip_ <2>:                             FileDescriptor-overriding inherited methods.
* skip_ <3>:                             PositionableStream-positioning.
* skip_:                                 Stream-positioning.
* skipSeparators:                        PositionableStream-positioning.
* skipTo_:                               Stream-positioning.
* skipToAll_:                            Stream-positioning.
* smallest:                              SmallInteger class-getting limits.
* smoothingFactor:                       ObjectMemory class-builtins.
* smoothingFactor_:                      ObjectMemory class-builtins.
* snapshot:                              ObjectMemory class-saving the image.
* snapshot_:                             ObjectMemory class-builtins.
* soleInstance:                          Metaclass-accessing.
* someInstance:                          Behavior-built ins.
* sortBlock:                             SortedCollection-basic.
* sortBlock_ <1>:                        SortedCollection class-instance creation.
* sortBlock_ <2>:                        SortedCollection-basic.
* sortBlock_:                            SharedQueue class-instance creation.
* sortedByCount:                         Bag-extracting items.
* sourceCode:                            MethodInfo-accessing.
* sourceCodeAt_:                         Behavior-accessing the methodDictionary.
* sourceCodeMap:                         CompiledCode-testing accesses.
* sourceFile:                            MethodInfo-accessing.
* sourceMethodAt_:                       Behavior-accessing the methodDictionary.
* sourcePos:                             MethodInfo-accessing.
* sourceString:                          MethodInfo-accessing.
* sp:                                    ContextPart-accessing.
* sp_:                                   ContextPart-accessing.
* space <1>:                             Character class-constants.
* space:                                 Stream-character writing.
* space_:                                Stream-character writing.
* spaceGrowRate:                         ObjectMemory class-builtins.
* spaceGrowRate_:                        ObjectMemory class-builtins.
* species <1>:                           Interval-basic.
* species <2>:                           BindingDictionary-testing.
* species <3>:                           Stream-basic.
* species <4>:                           PositionableStream-class type methods.
* species <5>:                           Symbol-misc.
* species <6>:                           WeakArray-conversion.
* species:                               Object-class type methods.
* splitAt_:                              Stream-accessing-reading.
* sqrt <1>:                              Float-built ins.
* sqrt:                                  Number-misc math.
* squared <1>:                           Number-misc math.
* squared:                               Fraction-optimized cases.
* stackDepth <1>:                        BlockClosure-accessing.
* stackDepth <2>:                        CompiledMethod-accessing.
* stackDepth <3>:                        CompiledCode-accessing.
* stackDepth:                            CompiledBlock-accessing.
* startsWith_:                           CharacterArray-comparing.
* statOn_into_:                          VFS.VFSHandler-C functions.
* stderr:                                FileStream class-standard streams.
* stdin:                                 FileStream class-standard streams.
* stdout:                                FileStream class-standard streams.
* store:                                 Object-storing.
* store_ <1>:                            Stream-storing.
* store_:                                TextCollector-storing.
* storeNl:                               Object-storing.
* storeOn_ <1>:                          Association-storing.
* storeOn_ <2>:                          Integer-storing.
* storeOn_ <3>:                          CType-storing.
* storeOn_ <4>:                          Boolean-storing.
* storeOn_ <5>:                          ArrayedCollection-storing.
* storeOn_ <6>:                          Date-storing.
* storeOn_ <7>:                          Fraction-printing.
* storeOn_ <8>:                          CompiledMethod-printing.
* storeOn_ <9>:                          Class-printing.
* storeOn_ <10>:                         VariableBinding-storing.
* storeOn_ <11>:                         Collection-storing.
* storeOn_ <12>:                         String-storing.
* storeOn_ <13>:                         Bag-storing.
* storeOn_ <14>:                         ScaledDecimal-storing.
* storeOn_ <15>:                         Object-storing.
* storeOn_ <16>:                         HashedCollection-storing.
* storeOn_ <17>:                         Namespace-printing.
* storeOn_ <18>:                         HomedAssociation-storing.
* storeOn_ <19>:                         LookupKey-storing.
* storeOn_ <20>:                         CScalarCType-storing.
* storeOn_ <21>:                         UndefinedObject-storing.
* storeOn_ <22>:                         Rectangle-printing.
* storeOn_ <23>:                         LookupTable-storing.
* storeOn_ <24>:                         Dictionary-storing.
* storeOn_ <25>:                         TextCollector-storing.
* storeOn_ <26>:                         Character-storing.
* storeOn_ <27>:                         SystemDictionary-printing.
* storeOn_ <28>:                         CharacterArray-storing.
* storeOn_ <29>:                         ProcessorScheduler-storing.
* storeOn_ <30>:                         Interval-storing.
* storeOn_ <31>:                         RootNamespace-printing.
* storeOn_ <32>:                         Point-storing.
* storeOn_ <33>:                         DateTime-storing.
* storeOn_ <34>:                         Metaclass-printing.
* storeOn_ <35>:                         AbstractNamespace-printing.
* storeOn_:                              Float-storing.
* storeOn_base_:                         Integer-printing.
* storeString:                           Object-storing.
* stream <1>:                            ObjectDumper-accessing.
* stream:                                SystemExceptions.EndOfStream-accessing.
* stream_ <1>:                           ObjectDumper-accessing.
* stream_:                               SystemExceptions.EndOfStream-accessing.
* streamContents_:                       SequenceableCollection class-instance creation.
* strictlyPositive <1>:                  LargeZeroInteger-numeric testing.
* strictlyPositive <2>:                  Float-testing.
* strictlyPositive <3>:                  Number-testing.
* strictlyPositive <4>:                  LargeNegativeInteger-numeric testing.
* strictlyPositive:                      LargePositiveInteger-numeric testing.
* stringAt_ <1>:                         Memory class-accessing.
* stringAt_:                             ByteArray-more advanced accessing.
* stringAt_put_ <1>:                     Memory class-accessing.
* stringAt_put_:                         ByteArray-more advanced accessing.
* stringError_:                          File class-C functions.
* stripExtension:                        File-file name management.
* stripExtensionFrom_:                   File class-file name management.
* stripFileName:                         File-file name management.
* stripFileNameFor_:                     File class-file name management.
* stripPath:                             File-file name management.
* stripPathFrom_:                        File class-file name management.
* stripSourceCode <1>:                   MethodInfo-accessing.
* stripSourceCode:                       CompiledMethod class-lean images.
* subclass_classInstanceVariableNames_instanceVariableNames_classVariableNames_poolDictionaries_ <1>: Class-instance creation - alternative.
* subclass_classInstanceVariableNames_instanceVariableNames_classVariableNames_poolDictionaries_: UndefinedObject-class creation - alternative.
* subclass_declaration_classVariableNames_poolDictionaries_category_: CCompound class-subclass creation.
* subclass_instanceVariableNames_classVariableNames_poolDictionaries_ <1>: UndefinedObject-class creation - alternative.
* subclass_instanceVariableNames_classVariableNames_poolDictionaries_: Class-instance creation - alternative.
* subclass_instanceVariableNames_classVariableNames_poolDictionaries_category_ <1>: UndefinedObject-class creation.
* subclass_instanceVariableNames_classVariableNames_poolDictionaries_category_: Class-instance creation.
* subclasses:                            Behavior-accessing class hierarchy.
* subclassesDo_:                         Behavior-enumerating.
* subclassInstVarNames:                  Behavior-accessing instances and variables.
* subclassOf_:                           Metaclass class-instance creation.
* subclassResponsibility:                Object-built ins.
* subspaces:                             AbstractNamespace-namespace hierarchy.
* subspacesDo_:                          AbstractNamespace-namespace hierarchy.
* subStrings:                            CharacterArray-string processing.
* substrings:                            CharacterArray-string processing.
* subStrings_:                           CharacterArray-string processing.
* substrings_:                           CharacterArray-string processing.
* subtractDate_:                         Date-basic.
* subtractDays_:                         Date-basic.
* subtractTime_:                         Time-arithmetic.
* suggestedSelector:                     SystemExceptions.WrongMessageSent-accessing.
* suggestedSelector_:                    SystemExceptions.WrongMessageSent-accessing.
* superclass:                            Behavior-accessing class hierarchy.
* superclass_:                           Behavior-creating a class hierarchy.
* superspace:                            AbstractNamespace-namespace hierarchy.
* superspace_:                           AbstractNamespace-namespace hierarchy.
* survSpaceSize:                         ObjectMemory-accessing.
* survSpaceUsedBytes:                    ObjectMemory-accessing.
* suspend:                               Process-basic.
* suspendedContext:                      Process-accessing.
* symbol:                                SymLink-accessing.
* symbol_:                               SymLink-accessing.
* symbol_nextLink_:                      SymLink class-instance creation.
* system_:                               SystemDictionary-C functions.
* systemBackgroundPriority:              ProcessorScheduler-priorities.
* systemKernel:                          Directory class-reading system defaults.
* tab <1>:                               Character class-constants.
* tab:                                   Stream-character writing.
* tab_:                                  Stream-character writing.
* tag:                                   Signal-accessing.
* tag_:                                  Signal-accessing.
* tan <1>:                               Float-built ins.
* tan:                                   Number-misc math.
* temporary:                             Directory class-reading system defaults.
* tenure:                                Object-built ins.
* tenuredBytesPerScavenge:               ObjectMemory-accessing.
* terminate:                             Process-basic.
* terminateActive:                       ProcessorScheduler-basic.
* timeBetweenGlobalGCs:                  ObjectMemory-accessing.
* timeBetweenGrowths:                    ObjectMemory-accessing.
* timeBetweenScavenges:                  ObjectMemory-accessing.
* timeSlice:                             ProcessorScheduler-basic.
* timeSlice_:                            ProcessorScheduler-basic.
* timesRepeat_:                          Integer-iterators.
* timesTwoPower_ <1>:                    FloatE-built ins.
* timesTwoPower_ <2>:                    FloatD-built ins.
* timesTwoPower_:                        FloatQ-built ins.
* timeToCollect:                         ObjectMemory-accessing.
* timeToCompact:                         ObjectMemory-accessing.
* timeToScavenge:                        ObjectMemory-accessing.
* timezone:                              Time class-builtins.
* timeZoneAbbreviation:                  DateTime-time zones.
* timezoneBias:                          Time class-builtins.
* timeZoneName:                          DateTime-time zones.
* timingPriority:                        ProcessorScheduler-priorities.
* to_:                                   Number-shortcuts and iterators.
* to_by_:                                Number-shortcuts and iterators.
* to_by_do_:                             Number-shortcuts and iterators.
* to_do_:                                Number-shortcuts and iterators.
* today:                                 Date class-instance creation (Blue Book).
* top:                                   Rectangle-accessing.
* top_:                                  Rectangle-accessing.
* topCenter:                             Rectangle-accessing.
* topLeft:                               Rectangle-accessing.
* topLeft_:                              Rectangle-accessing.
* topRight:                              Rectangle-accessing.
* topRight_:                             Rectangle-accessing.
* translateBy_:                          Rectangle-transforming.
* translatedToBeWithin_:                 Rectangle-rectangle functions.
* transpose:                             Point-point functions.
* trigger:                               DelayedAdaptor-accessing.
* trimSeparators:                        CharacterArray-converting.
* truncate <1>:                          PositionableStream-truncating.
* truncate <2>:                          FileStream-basic.
* truncate:                              FileDescriptor-basic.
* truncated <1>:                         Float-coercing.
* truncated <2>:                         Integer-converting.
* truncated <3>:                         Number-truncation and round off.
* truncated <4>:                         Fraction-coercing.
* truncated <5>:                         FloatQ-built ins.
* truncated <6>:                         ScaledDecimal-coercion.
* truncated <7>:                         FloatE-built ins.
* truncated:                             FloatD-built ins.
* truncatedGrid_:                        Point-point functions.
* truncateTo_ <1>:                       Number-truncation and round off.
* truncateTo_:                           Point-truncation and round off.
* type <1>:                              CScalar class-instance creation.
* type <2>:                              CCompound class-instance creation.
* type <3>:                              CString class-instance creation.
* type <4>:                              CObject-conversion.
* type <5>:                              CObject class-conversion.
* type <6>:                              CByte class-conversion.
* type:                                  CByte-accessing.
* type_:                                 CObject-accessing.
* ucharAt_:                              ByteArray-more advanced accessing.
* ucharAt_put_ <1>:                      ByteArray-more advanced accessing.
* ucharAt_put_:                          Memory class-accessing.
* uintAt_:                               ByteArray-more advanced accessing.
* uintAt_put_ <1>:                       ByteArray-more advanced accessing.
* uintAt_put_:                           Memory class-accessing.
* ulongAt_:                              ByteArray-more advanced accessing.
* ulongAt_put_ <1>:                      Memory class-accessing.
* ulongAt_put_:                          ByteArray-more advanced accessing.
* unity <1>:                             Fraction-coercing.
* unity <2>:                             FloatQ-coercing.
* unity <3>:                             FloatE-coercing.
* unity <4>:                             FloatD-coercing.
* unity <5>:                             LargeInteger-coercion.
* unity <6>:                             Number-converting.
* unity:                                 SmallInteger-coercion methods.
* unpreemptedPriority:                   ProcessorScheduler-priorities.
* unsignedCharAt_ <1>:                   Memory class-accessing.
* unsignedCharAt_:                       ByteArray-more advanced accessing.
* unsignedCharAt_put_ <1>:               ByteArray-more advanced accessing.
* unsignedCharAt_put_:                   Memory class-accessing.
* unsignedIntAt_ <1>:                    Memory class-accessing.
* unsignedIntAt_:                        ByteArray-more advanced accessing.
* unsignedIntAt_put_ <1>:                Memory class-accessing.
* unsignedIntAt_put_:                    ByteArray-more advanced accessing.
* unsignedLongAt_ <1>:                   ByteArray-more advanced accessing.
* unsignedLongAt_:                       Memory class-accessing.
* unsignedLongAt_put_ <1>:               ByteArray-more advanced accessing.
* unsignedLongAt_put_:                   Memory class-accessing.
* unsignedShortAt_ <1>:                  ByteArray-more advanced accessing.
* unsignedShortAt_:                      Memory class-accessing.
* unsignedShortAt_put_ <1>:              ByteArray-more advanced accessing.
* unsignedShortAt_put_:                  Memory class-accessing.
* untilMilliseconds_:                    Delay class-instance creation.
* unwind:                                ContextPart class-exception handling.
* unwind_:                               ContextPart class-exception handling.
* update:                                ObjectMemory-builtins.
* update_ <1>:                           DLD class-dynamic linking.
* update_ <2>:                           Time class-initialization.
* update_ <3>:                           Object class-initialization.
* update_ <4>:                           VFS.ArchiveMemberHandler-file operations.
* update_ <5>:                           Object-change and update.
* update_ <6>:                           VFS.VFSHandler class-initializing.
* update_ <7>:                           FileDescriptor class-initialization.
* update_:                               ObjectMemory class-dependancy.
* updateMember_ <1>:                     VFS.ArchiveFileHandler-ArchiveMemberHandler protocol.
* updateMember_:                         VFS.ExternalArchiveFileHandler-ArchiveMemberHandler protocol.
* upTo_:                                 Stream-accessing-reading.
* upToAll_:                              Stream-accessing-reading.
* upToEnd:                               Stream-accessing-reading.
* userBackgroundPriority:                ProcessorScheduler-priorities.
* userInterrupt:                         Object-exception handling.
* userInterruptPriority:                 ProcessorScheduler-priorities.
* username:                              NetClients.URL-accessing.
* username_:                             NetClients.URL-accessing.
* userSchedulingPriority:                ProcessorScheduler-priorities.
* ushortAt_:                             ByteArray-more advanced accessing.
* ushortAt_put_ <1>:                     Memory class-accessing.
* ushortAt_put_:                         ByteArray-more advanced accessing.
* utcDateAndTimeNow:                     Date class-instance creation (Blue Book).
* utcNow:                                Time class-basic (UTC).
* utcSecondClock:                        Time class-basic (UTC).
* utcToday:                              Date class-instance creation (Blue Book).
* validClasses:                          SystemExceptions.WrongClass-accessing.
* validClasses_:                         SystemExceptions.WrongClass-accessing.
* validClassesString:                    SystemExceptions.WrongClass-accessing.
* validSize <1>:                         Object-debugging.
* validSize:                             ContextPart-accessing.
* value <1>:                             CBoolean-accessing.
* value <2>:                             CPtr-accessing.
* value <3>:                             DelayedAdaptor-accessing.
* value <4>:                             SystemExceptions.InvalidValue-accessing.
* value <5>:                             Association-accessing.
* value <6>:                             CString-accessing.
* value <7>:                             CScalar-accessing.
* value <8>:                             NullValueHolder-accessing.
* value <9>:                             Character-built ins.
* value <10>:                            ValueHolder-accessing.
* value <11>:                            CByte-accessing.
* value <12>:                            ValueAdaptor-accessing.
* value <13>:                            PluggableAdaptor-accessing.
* value <14>:                            Promise-accessing.
* value <15>:                            BlockClosure-built ins.
* value:                                 DirectedMessage-basic.
* value_ <1>:                            Promise-accessing.
* value_ <2>:                            SystemExceptions.InvalidValue-accessing.
* value_ <3>:                            DelayedAdaptor-accessing.
* value_ <4>:                            Character class-built ins.
* value_ <5>:                            CPtr-accessing.
* value_ <6>:                            NullValueHolder-accessing.
* value_ <7>:                            CBoolean-accessing.
* value_ <8>:                            CScalar class-instance creation.
* value_ <9>:                            PluggableAdaptor-accessing.
* value_ <10>:                           CByte-accessing.
* value_ <11>:                           CString-accessing.
* value_ <12>:                           CScalar-accessing.
* value_ <13>:                           CString class-instance creation.
* value_ <14>:                           Association-accessing.
* value_ <15>:                           ValueHolder-accessing.
* value_ <16>:                           BlockClosure-built ins.
* value_:                                ValueAdaptor-accessing.
* value_value_:                          BlockClosure-built ins.
* value_value_value_:                    BlockClosure-built ins.
* valueAt_:                              CharacterArray-built ins.
* valueAt_put_:                          CharacterArray-built ins.
* values <1>:                            Dictionary-accessing.
* values:                                AbstractNamespace-overrides for superspaces.
* valueType <1>:                         CScalarCType-accessing.
* valueType:                             CType-accessing.
* valueWithArguments_:                   BlockClosure-built ins.
* valueWithoutInterrupts:                BlockClosure-multiple process.
* valueWithoutInterrupts_:               Process-accessing.
* valueWithoutPreemption:                BlockClosure-multiple process.
* valueWithUnwind:                       BlockClosure-unwind protection.
* variableByteSubclass_classInstanceVariableNames_classVariableNames_poolDictionaries_: Class-instance creation - alternative.
* variableByteSubclass_classInstanceVariableNames_instanceVariableNames_classVariableNames_poolDictionaries_: UndefinedObject-class creation - alternative.
* variableByteSubclass_classVariableNames_poolDictionaries_: Class-instance creation - alternative.
* variableByteSubclass_instanceVariableNames_classVariableNames_poolDictionaries_: UndefinedObject-class creation - alternative.
* variableByteSubclass_instanceVariableNames_classVariableNames_poolDictionaries_category_ <1>: UndefinedObject-class creation.
* variableByteSubclass_instanceVariableNames_classVariableNames_poolDictionaries_category_: Class-instance creation.
* variableLongSubclass_classInstanceVariableNames_classVariableNames_poolDictionaries_: Class-instance creation - alternative.
* variableLongSubclass_classVariableNames_poolDictionaries_: Class-instance creation - alternative.
* variableSubclass_classInstanceVariableNames_instanceVariableNames_classVariableNames_poolDictionaries_ <1>: UndefinedObject-class creation - alternative.
* variableSubclass_classInstanceVariableNames_instanceVariableNames_classVariableNames_poolDictionaries_: Class-instance creation - alternative.
* variableSubclass_instanceVariableNames_classVariableNames_poolDictionaries_ <1>: UndefinedObject-class creation - alternative.
* variableSubclass_instanceVariableNames_classVariableNames_poolDictionaries_: Class-instance creation - alternative.
* variableSubclass_instanceVariableNames_classVariableNames_poolDictionaries_category_ <1>: UndefinedObject-class creation.
* variableSubclass_instanceVariableNames_classVariableNames_poolDictionaries_category_: Class-instance creation.
* variableWordSubclass_classInstanceVariableNames_instanceVariableNames_classVariableNames_poolDictionaries_: UndefinedObject-class creation - alternative.
* variableWordSubclass_instanceVariableNames_classVariableNames_poolDictionaries_: UndefinedObject-class creation - alternative.
* variableWordSubclass_instanceVariableNames_classVariableNames_poolDictionaries_category_ <1>: Class-instance creation.
* variableWordSubclass_instanceVariableNames_classVariableNames_poolDictionaries_category_: UndefinedObject-class creation.
* verbose_:                              FileStream class-file-in.
* verboseTrace:                          SystemDictionary-builtins.
* verboseTrace_:                         SystemDictionary-builtins.
* version:                               SystemDictionary-special accessing.
* vfsFor_name_subPath_ <1>:              VFS.DecodedFileHandler class-registering.
* vfsFor_name_subPath_:                  VFS.ExternalArchiveFileHandler class-registering.
* wait <1>:                              Semaphore-builtins.
* wait:                                  Delay-process delay.
* waitAfterSignalling_:                  Semaphore-builtins.
* waitForException:                      FileDescriptor-accessing.
* waitingProcesses <1>:                  RecursionLock-accessing.
* waitingProcesses:                      Semaphore-accessing.
* whenSignalledIn_do_exitBlock_:         Exception class-interoperability with TrappableEvents.
* whichCategoryIncludesSelector_:        ClassDescription-organization of messages and classes.
* whichClassIncludesSelector_:           Behavior-testing the method dictionary.
* whichSelectorsAccess_:                 Behavior-testing the method dictionary.
* whichSelectorsAssign_:                 Behavior-testing the method dictionary.
* whichSelectorsRead_:                   Behavior-testing the method dictionary.
* whichSelectorsReferTo_:                Behavior-testing the method dictionary.
* whichSelectorsReferToByteCode_:        Behavior-testing the method dictionary.
* whileCurrentDo_:                       AbstractNamespace-copying.
* whileFalse:                            BlockClosure-control structures.
* whileFalse_:                           BlockClosure-control structures.
* whileTrue:                             BlockClosure-control structures.
* whileTrue_:                            BlockClosure-control structures.
* width:                                 Rectangle-accessing.
* width_:                                Rectangle-accessing.
* with_ <1>:                             ValueHolder class-creating instances.
* with_ <2>:                             Symbol class-instance creation.
* with_ <3>:                             WriteStream class-instance creation.
* with_ <4>:                             ArrayedCollection class-instance creation.
* with_ <5>:                             Collection class-instance creation.
* with_:                                 ReadWriteStream class-instance creation.
* with_collect_ <1>:                     SequenceableCollection-enumerating.
* with_collect_:                         ArrayedCollection-enumerating the elements of a collection.
* with_do_:                              SequenceableCollection-enumerating.
* with_from_to_:                         WriteStream class-instance creation.
* with_with_ <1>:                        Symbol class-instance creation.
* with_with_ <2>:                        ArrayedCollection class-instance creation.
* with_with_:                            Collection class-instance creation.
* with_with_with_ <1>:                   Collection class-instance creation.
* with_with_with_ <2>:                   ArrayedCollection class-instance creation.
* with_with_with_:                       Symbol class-instance creation.
* with_with_with_with_ <1>:              Symbol class-instance creation.
* with_with_with_with_ <2>:              Collection class-instance creation.
* with_with_with_with_:                  ArrayedCollection class-instance creation.
* with_with_with_with_with_ <1>:         Collection class-instance creation.
* with_with_with_with_with_ <2>:         ArrayedCollection class-instance creation.
* with_with_with_with_with_:             Symbol class-instance creation.
* withAll_ <1>:                          ArrayedCollection class-instance creation.
* withAll_ <2>:                          Collection class-instance creation.
* withAll_:                              Interval class-instance creation.
* withAllBlocksDo_:                      CompiledMethod-accessing.
* withAllSubclasses:                     Behavior-accessing class hierarchy.
* withAllSubclassesDo_:                  Behavior-enumerating.
* withAllSubspaces:                      AbstractNamespace-namespace hierarchy.
* withAllSubspacesDo_:                   AbstractNamespace-namespace hierarchy.
* withAllSuperclasses:                   Behavior-accessing class hierarchy.
* withAllSuperclassesDo_:                Behavior-enumerating.
* withAllSuperspaces <1>:                Dictionary-polymorphism hacks.
* withAllSuperspaces:                    AbstractNamespace-namespace hierarchy.
* withAllSuperspacesDo_:                 AbstractNamespace-namespace hierarchy.
* withFileDo_:                           FileSegment-basic.
* withNewMethodClass_:                   CompiledMethod-accessing.
* withNewMethodClass_selector_:          CompiledMethod-accessing.
* withSignOf_:                           Number-misc math.
* working <1>:                           Directory class-C functions.
* working:                               VFS.RealFileHandler class-C functions.
* working_:                              Directory class-file operations.
* wouldBlock <1>:                        RecursionLock-accessing.
* wouldBlock:                            Semaphore-accessing.
* write:                                 FileDescriptor class-instance creation.
* write_:                                FileDescriptor-low-level access.
* write_from_to_:                        FileDescriptor-low-level access.
* write_numBytes_:                       FileDescriptor-low-level access.
* writeStream <1>:                       File-file operations.
* writeStream:                           SequenceableCollection-enumerating.
* x:                                     Point-accessing.
* x_:                                    Point-accessing.
* x_y_ <1>:                              Point class-instance creation.
* x_y_:                                  Point-accessing.
* xor_ <1>:                              Boolean-basic.
* xor_ <2>:                              True-basic.
* xor_:                                  False-basic.
* y:                                     Point-accessing.
* y_:                                    Point-accessing.
* year:                                  Date-date computations.
* year_day_hour_minute_second_ <1>:      Date class-instance creation (ANSI).
* year_day_hour_minute_second_:          DateTime class-instance creation.
* year_day_hour_minute_second_offset_:   DateTime class-instance creation.
* year_month_day_hour_minute_second_ <1>: DateTime class-instance creation.
* year_month_day_hour_minute_second_:    Date class-instance creation (ANSI).
* year_month_day_hour_minute_second_offset_: DateTime class-instance creation.
* yield <1>:                             ProcessorScheduler-basic.
* yield:                                 Process-builtins.
* yourself:                              Object-class type methods.
* zero <1>:                              FloatQ-coercing.
* zero <2>:                              ScaledDecimal-constants.
* zero <3>:                              Fraction-coercing.
* zero <4>:                              FloatD-coercing.
* zero <5>:                              Duration class-instance creation.
* zero <6>:                              Number-converting.
* zero <7>:                              FloatE-coercing.
* zero <8>:                              SmallInteger-coercion methods.
* zero:                                  LargeInteger-coercion.
* zeroDivide:                            Number-error raising.
* | <1>:                                 Boolean-basic.
* | <2>:                                 False-basic.
* |:                                     True-basic.
* ~= <1>:                                FloatD-built ins.
* ~= <2>:                                SmallInteger-built ins.
* ~= <3>:                                LargeInteger-testing.
* ~= <4>:                                ScaledDecimal-comparing.
* ~= <5>:                                Object-relational operators.
* ~= <6>:                                FloatQ-built ins.
* ~=:                                    FloatE-built ins.
* ~~ <1>:                                Object-relational operators.
* ~~:                                    SmallInteger-built ins.


File: gst-base.info,  Node: Cross-reference,  Prev: Method index,  Up: Top

Selector cross-reference
************************

* Menu:

* *:                                     Number-retrying.
* + <1>:                                 Number-retrying.
* +:                                     Symbol-basic.
* -:                                     Number-retrying.
* /:                                     Number-retrying.
* = <1>:                                 Number-retrying.
* =:                                     Stream-accessing-reading.
* >>:                                    CompiledMethod-saving and loading.
* add_:                                  SequenceableCollection-copying SequenceableCollections.
* addSubspace_:                          Namespace class-disabling instance creation.
* addToBeFinalized <1>:                  CScalar class-instance creation.
* addToBeFinalized <2>:                  FileDescriptor class-instance creation.
* addToBeFinalized <3>:                  CCompound class-instance creation.
* addToBeFinalized <4>:                  CObject-finalization.
* addToBeFinalized:                      CString class-instance creation.
* AM:                                    DateTime-computations.
* append:                                FileDescriptor class-instance creation.
* asciiValue:                            Character-built ins.
* asciiValue_:                           Character class-built ins.
* asInteger:                             Character-built ins.
* asyncCallFrom_:                        CFunctionDescriptor-calling.
* at_ <1>:                               PluggableAdaptor class-creating instances.
* at_ <2>:                               VariableBinding-saving and loading.
* at_:                                   PluggableAdaptor class-creating instances.
* at_put_ <1>:                           CString-accessing.
* at_put_ <2>:                           BindingDictionary-accessing.
* at_put_ <3>:                           PluggableAdaptor class-creating instances.
* at_put_ <4>:                           CScalar-accessing.
* at_put_:                               PluggableAdaptor class-creating instances.
* basicNew:                              Behavior-built ins.
* basicNew_:                             Behavior-built ins.
* basicPrint:                            Object-built ins.
* become_:                               Object-built ins.
* binaryRepresentationObject <1>:        PluggableProxy class-accessing.
* binaryRepresentationObject:            Object-saving and loading.
* binaryRepresentationVersion:           VersionableObjectProxy class-saving and restoring.
* blockAt_:                              CompiledBlock-saving and loading.
* bz2:                                   VFS.DecodedFileHandler class-registering.
* callFrom_into_:                        CFunctionDescriptor-calling.
* changed:                               Object-change and update.
* changed_:                              Object-change and update.
* class:                                 Object-class type methods.
* close:                                 FileDescriptor class-instance creation.
* codePoint:                             Character-built ins.
* codePoint_:                            Character class-built ins.
* collect_:                              BindingDictionary-copying.
* collection_map_:                       MappedCollection class-instance creation.
* continue_ <1>:                         BlockContext-accessing.
* continue_ <2>:                         ContextPart-accessing.
* continue_:                             MethodContext-accessing.
* convertFromVersion_withFixedVariables_instanceVariables_for_: VersionableObjectProxy class-saving and restoring.
* copy:                                  RunArray-copying.
* copyEmpty_ <1>:                        WeakArray-conversion.
* copyEmpty_:                            Object-class type methods.
* create:                                FileDescriptor class-instance creation.
* day:                                   Date-date computations.
* debuggingPriority:                     Behavior-pluggable behavior (not yet implemented).
* directoryFor_:                         PackageLoader class-accessing.
* disableInterrupts:                     ProcessorScheduler-built ins.
* display_:                              Stream-printing.
* do_ <1>:                               Collection-converting.
* do_ <2>:                               Collection-enumeration.
* do_ <3>:                               RunArray-adding.
* do_:                                   SortedCollection-enumerating.
* dumpTo_ <1>:                           DumperProxy class-instance creation.
* dumpTo_:                               AlternativeObjectProxy class-instance creation.
* enableInterrupts:                      ProcessorScheduler-built ins.
* ensure_ <1>:                           BlockContext-accessing.
* ensure_ <2>:                           Process-basic.
* ensure_ <3>:                           MethodContext-accessing.
* ensure_ <4>:                           ContextPart-built ins.
* ensure_ <5>:                           ContextPart-accessing.
* ensure_ <6>:                           BlockContext-accessing.
* ensure_:                               BlockClosure-unwind protection.
* error_ <1>:                            Behavior-method dictionary.
* error_ <2>:                            BlockClosure-exception handling.
* error_ <3>:                            Behavior-evaluating.
* error_:                                Behavior-method dictionary.
* fileSystems:                           VFS.VFSHandler class-initializing.
* finalize:                              Object-finalization.
* first <1>:                             LargeArraySubpart-accessing.
* first:                                 LargeArraySubpart class-instance creation.
* firstIndex <1>:                        LargeArraySubpart class-instance creation.
* firstIndex:                            LargeArraySubpart-accessing.
* free:                                  CObject-finalization.
* from_to_keysAndValuesDo_:              SequenceableCollection-enumerating.
* generateMakefileOnto_:                 FileStream class-file-in.
* gz:                                    VFS.DecodedFileHandler class-registering.
* halt:                                  Halt-description.
* hash:                                  Symbol class-symbol table.
* identityHash:                          AbstractNamespace-basic & copying.
* ifCurtailed_ <1>:                      Process-basic.
* ifCurtailed_:                          ContextPart-built ins.
* ifTrue_ifFalse_:                       Symbol-basic.
* includes_:                             IdentitySet-testing.
* includesClassNamed_:                   AbstractNamespace-namespace hierarchy.
* includesGlobalNamed_:                  AbstractNamespace-namespace hierarchy.
* includesKey_:                          AbstractNamespace-namespace hierarchy.
* inspect:                               CCompound-instance creation.
* integerPart:                           Number-truncation and round off.
* keysAndValuesDo_:                      SequenceableCollection-enumerating.
* last <1>:                              LargeArraySubpart class-instance creation.
* last:                                  LargeArraySubpart-accessing.
* line:                                  FileStream-filing in.
* loadFrom_:                             DumperProxy-saving and restoring.
* lowerPriority:                         Process-basic.
* mark_:                                 Object-built ins.
* match_:                                Directory-enumerating.
* mourn:                                 Object-built ins.
* new <1>:                               AbstractNamespace class-instance creation.
* new:                                   Behavior-instance creation.
* new_:                                  Behavior-instance creation.
* newProcess:                            ContextPart-accessing.
* next <1>:                              PositionableStream-positioning.
* next:                                  SharedQueue-accessing.
* nonVersionedInstSize:                  VersionableObjectProxy class-saving and restoring.
* nop:                                   VFS.DecodedFileHandler class-registering.
* not:                                   Symbol-basic.
* notify:                                Semaphore-builtins.
* notifyAll:                             Semaphore-builtins.
* on_:                                   AlternativeObjectProxy class-instance creation.
* on_do_ <1>:                            Signal-exception handling.
* on_do_ <2>:                            BlockClosure-unwind protection.
* on_do_:                                Signal-exception handling.
* on_index_:                             PluggableAdaptor class-creating instances.
* outer:                                 Signal-exception handling.
* pass:                                  Signal-exception handling.
* PM:                                    DateTime-computations.
* postLoad <1>:                          PluggableProxy-saving and restoring.
* postLoad <2>:                          Object-saving and loading.
* postLoad <3>:                          HashedCollection-saving and loading.
* postLoad:                              SingletonProxy-saving and restoring.
* postStore:                             PluggableProxy class-accessing.
* preStore:                              PluggableProxy class-accessing.
* primDefineExternFunc_:                 DLD class-dynamic linking.
* print:                                 Object-printing.
* printHierarchy:                        Behavior-printing hierarchy.
* printNl:                               Object-printing.
* printOn_ <1>:                          CharacterArray-printing.
* printOn_ <2>:                          Character-printing.
* printOn_ <3>:                          Object-built ins.
* printOn_ <4>:                          Symbol-storing.
* printOn_ <5>:                          Symbol-basic.
* printOn_ <6>:                          Object-printing.
* printOn_:                              Symbol-basic.
* printString <1>:                       CharacterArray-printing.
* printString <2>:                       Symbol-storing.
* printString <3>:                       Object-printing.
* printString:                           ScaledDecimal-printing.
* printStringRadix_:                     Integer-printing.
* raisePriority:                         Process-basic.
* read:                                  FileDescriptor class-instance creation.
* readWrite:                             FileDescriptor class-instance creation.
* reconstructOriginalObject <1>:         PluggableProxy-saving and restoring.
* reconstructOriginalObject:             SingletonProxy-saving and restoring.
* removeFirst_:                          LargeArraySubpart-modifying.
* removeToBeFinalized:                   FileDescriptor class-instance creation.
* return_:                               BlockClosure-exception handling.
* secondClock:                           Time class-basic (UTC).
* select_:                               PositionableStream-class type methods.
* self:                                  CFunctionDescriptor-calling.
* selfSmalltalk:                         CFunctionDescriptor-calling.
* signal:                                Signal-exception handling.
* signal_atMilliseconds_:                ProcessorScheduler-timed invocation.
* singleStepWaitingOn_:                  Process-basic.
* size_stCtime_stMtime_stAtime_isDirectory_ <1>: VFS.ExternalArchiveFileHandler-ArchiveMemberHandler protocol.
* size_stCtime_stMtime_stAtime_isDirectory_: VFS.ArchiveFileHandler-ArchiveMemberHandler protocol.
* skipSeparators:                        PositionableStream-positioning.
* species:                               Object-class type methods.
* strings:                               VFS.DecodedFileHandler class-registering.
* subclass_declaration_:                 CCompound class-subclass creation.
* subclassResponsibility:                Number-testing.
* tar:                                   VFS.DecodedFileHandler class-registering.
* tgz:                                   VFS.DecodedFileHandler class-registering.
* timeZoneAbbreviation:                  DateTime-time zones.
* trigger:                               DelayedAdaptor-accessing.
* ubz2:                                  VFS.DecodedFileHandler class-registering.
* ugz:                                   VFS.DecodedFileHandler class-registering.
* upTo_:                                 PositionableStream-class type methods.
* uZ:                                    VFS.DecodedFileHandler class-registering.
* value <1>:                             Character-built ins.
* value <2>:                             PluggableAdaptor class-creating instances.
* value <3>:                             Character-built ins.
* value <4>:                             PluggableAdaptor class-creating instances.
* value:                                 Character-built ins.
* value_ <1>:                            Character class-built ins.
* value_ <2>:                            PluggableAdaptor class-creating instances.
* value_:                                Character class-built ins.
* valueWithoutPreemption:                ProcessorScheduler-priorities.
* valueWithUnwind:                       BlockClosure-unwind protection.
* Variable:                              BindingDictionary-accessing.
* vfsFor_name_subPath_:                  VFS.VFSHandler class-initializing.
* wait:                                  RecursionLock-accessing.
* write:                                 FileDescriptor class-instance creation.
* Z:                                     VFS.DecodedFileHandler class-registering.
* ~=:                                    Number-retrying.



Tag Table:
Node: Top1008
Node: Base classes2166
Node: AbstractNamespace11471
Node: AbstractNamespace class-instance creation12218
Node: AbstractNamespace-accessing12645
Node: AbstractNamespace-basic & copying13871
Node: AbstractNamespace-copying14413
Node: AbstractNamespace-namespace hierarchy14857
Node: AbstractNamespace-overrides for superspaces17523
Node: AbstractNamespace-printing19241
Node: AbstractNamespace-testing19814
Node: AlternativeObjectProxy20053
Node: AlternativeObjectProxy class-instance creation20787
Node: AlternativeObjectProxy-accessing21720
Node: ArithmeticError22272
Node: ArithmeticError-description22723
Node: Array22929
Node: Array-mutating objects23560
Node: Array-printing23860
Node: Array-testing24079
Node: ArrayedCollection24220
Node: ArrayedCollection class-instance creation25009
Node: ArrayedCollection-basic26131
Node: ArrayedCollection-built ins27030
Node: ArrayedCollection-copying Collections27294
Node: ArrayedCollection-enumerating the elements of a collection29046
Node: ArrayedCollection-storing30193
Node: Association30478
Node: Association class-basic31155
Node: Association-accessing31394
Node: Association-finalization32002
Node: Association-printing32223
Node: Association-storing32471
Node: Association-testing32725
Node: Autoload33070
Node: Autoload class-instance creation33740
Node: Autoload-accessing34244
Node: AutoloadClass34470
Node: AutoloadClass-accessing34995
Node: Bag35951
Node: Bag class-basic36656
Node: Bag-adding36913
Node: Bag-enumerating the elements of a collection37394
Node: Bag-extracting items37752
Node: Bag-printing38032
Node: Bag-removing38237
Node: Bag-storing38547
Node: Bag-testing collections38765
Node: Behavior39251
Node: Behavior-accessing class hierarchy40840
Node: Behavior-accessing instances and variables41567
Node: Behavior-accessing the methodDictionary42854
Node: Behavior-built ins43935
Node: Behavior-compilation (alternative)46124
Node: Behavior-compiling methods46945
Node: Behavior-creating a class hierarchy47406
Node: Behavior-enumerating47843
Node: Behavior-evaluating48897
Node: Behavior-instance creation50188
Node: Behavior-instance variables50968
Node: Behavior-method dictionary51400
Node: Behavior-pluggable behavior (not yet implemented)54838
Node: Behavior-printing hierarchy55962
Node: Behavior-support for lightweight classes56556
Node: Behavior-testing functionality57596
Node: Behavior-testing the class hierarchy57865
Node: Behavior-testing the form of the instances58388
Node: Behavior-testing the method dictionary59516
Node: BindingDictionary60903
Node: BindingDictionary-accessing61750
Node: BindingDictionary-copying63632
Node: BindingDictionary-forward declarations64165
Node: BindingDictionary-printing64771
Node: BindingDictionary-testing65165
Node: BlockClosure65380
Node: BlockClosure class-instance creation66603
Node: BlockClosure class-testing67170
Node: BlockClosure-accessing67464
Node: BlockClosure-built ins69052
Node: BlockClosure-control structures69819
Node: BlockClosure-exception handling70486
Node: BlockClosure-multiple process72488
Node: BlockClosure-overriding73931
Node: BlockClosure-testing74199
Node: BlockClosure-unwind protection74459
Node: BlockContext75928
Node: BlockContext-accessing76708
Node: BlockContext-printing78222
Node: Boolean78447
Node: Boolean class-testing79198
Node: Boolean-basic79501
Node: Boolean-C hacks80783
Node: Boolean-overriding81031
Node: Boolean-storing81260
Node: ByteArray81475
Node: ByteArray-built ins82016
Node: ByteArray-converting83299
Node: ByteArray-more advanced accessing83577
Node: ByteStream90081
Node: ByteStream-basic90460
Node: CAggregate91736
Node: CAggregate class-accessing92031
Node: CAggregate-accessing92307
Node: CallinProcess92531
Node: CArray92952
Node: CArray-accessing93195
Node: CArrayCType93388
Node: CArrayCType class-instance creation93689
Node: CArrayCType-accessing94309
Node: CBoolean94673
Node: CBoolean-accessing94970
Node: CByte95287
Node: CByte class-conversion95669
Node: CByte-accessing95988
Node: CChar96426
Node: CChar class-accessing96687
Node: CChar-accessing97037
Node: CCompound97340
Node: CCompound class-instance creation97682
Node: CCompound class-subclass creation98041
Node: CCompound-instance creation100131
Node: CDouble100470
Node: CDouble class-accessing100742
Node: CDouble-accessing101102
Node: CFloat101415
Node: CFloat class-accessing101693
Node: CFloat-accessing102048
Node: CFunctionDescriptor102356
Node: CFunctionDescriptor class-instance creation103131
Node: CFunctionDescriptor class-testing103479
Node: CFunctionDescriptor-accessing103976
Node: CFunctionDescriptor-calling104594
Node: CFunctionDescriptor-printing106534
Node: Character106793
Node: Character class-built ins107762
Node: Character class-constants108534
Node: Character class-initializing lookup tables109328
Node: Character class-instance creation109964
Node: Character class-testing110322
Node: Character-built ins110681
Node: Character-coercion methods111456
Node: Character-comparing112020
Node: Character-converting112653
Node: Character-printing112956
Node: Character-storing113330
Node: Character-testing113569
Node: Character-testing functionality114205
Node: CharacterArray114437
Node: CharacterArray class-basic115178
Node: CharacterArray-basic115568
Node: CharacterArray-built ins116245
Node: CharacterArray-comparing116660
Node: CharacterArray-converting118870
Node: CharacterArray-printing120227
Node: CharacterArray-storing120846
Node: CharacterArray-string processing121125
Node: CharacterArray-testing functionality123664
Node: CInt123910
Node: CInt class-accessing124171
Node: CInt-accessing124496
Node: Class124814
Node: Class-accessing instances and variables125660
Node: Class-filing127172
Node: Class-instance creation127612
Node: Class-instance creation - alternative129817
Node: Class-printing131982
Node: Class-saving and loading132389
Node: Class-testing133783
Node: Class-testing functionality134022
Node: ClassDescription134239
Node: ClassDescription-compiling134901
Node: ClassDescription-conversion135729
Node: ClassDescription-copying136182
Node: ClassDescription-filing137379
Node: ClassDescription-organization of messages and classes138201
Node: ClassDescription-printing139501
Node: CLong140250
Node: CLong class-accessing140520
Node: CLong-accessing140870
Node: CObject141173
Node: CObject class-conversion142023
Node: CObject class-instance creation142366
Node: CObject-accessing142964
Node: CObject-C data access143399
Node: CObject-conversion144003
Node: CObject-finalization144424
Node: CObject-pointer-like behavior144888
Node: Collection147143
Node: Collection class-instance creation148070
Node: Collection-adding149074
Node: Collection-converting149421
Node: Collection-copying Collections150514
Node: Collection-enumeration151052
Node: Collection-finalization153968
Node: Collection-printing154273
Node: Collection-removing154616
Node: Collection-storing155456
Node: Collection-testing collections155713
Node: CompiledBlock156352
Node: CompiledBlock class-instance creation156850
Node: CompiledBlock-accessing157586
Node: CompiledBlock-basic158645
Node: CompiledBlock-printing159354
Node: CompiledBlock-saving and loading159621
Node: CompiledCode160042
Node: CompiledCode class-cache flushing160768
Node: CompiledCode class-instance creation161124
Node: CompiledCode-accessing161670
Node: CompiledCode-basic163069
Node: CompiledCode-copying163820
Node: CompiledCode-debugging164045
Node: CompiledCode-decoding bytecodes164304
Node: CompiledCode-testing accesses164711
Node: CompiledCode-translation165872
Node: CompiledMethod166130
Node: CompiledMethod class-instance creation166908
Node: CompiledMethod class-lean images167545
Node: CompiledMethod-accessing167866
Node: CompiledMethod-basic169233
Node: CompiledMethod-printing169997
Node: CompiledMethod-saving and loading170338
Node: CompiledMethod-testing170788
Node: ContextPart171372
Node: ContextPart class-exception handling172146
Node: ContextPart-accessing173092
Node: ContextPart-built ins176325
Node: ContextPart-copying177011
Node: ContextPart-debugging177364
Node: ContextPart-enumerating177888
Node: ContextPart-exception handling178273
Node: ContextPart-printing178535
Node: CoreException178898
Node: CoreException class-instance creation180164
Node: CoreException-accessing180420
Node: CoreException-basic181354
Node: CoreException-enumerating181609
Node: CoreException-exception handling182267
Node: CoreException-instance creation182918
Node: CPtr183220
Node: CPtr-accessing183453
Node: CPtrCType183988
Node: CPtrCType class-instance creation184272
Node: CPtrCType-accessing184557
Node: CScalar185018
Node: CScalar class-instance creation185304
Node: CScalar-accessing185763
Node: CScalarCType186278
Node: CScalarCType-accessing186566
Node: CScalarCType-storing186894
Node: CShort187116
Node: CShort class-accessing187390
Node: CShort-accessing187745
Node: CSmalltalk188053
Node: CSmalltalk class-accessing188338
Node: CSmalltalk-accessing188713
Node: CString189041
Node: CString class-instance creation189848
Node: CString-accessing190307
Node: CStringCType190822
Node: CStringCType-accessing191081
Node: CStruct191282
Node: CStruct class-subclass creation191532
Node: CType191766
Node: CType class-C instance creation192880
Node: CType-accessing193136
Node: CType-C instance creation193979
Node: CType-storing194490
Node: CUChar194687
Node: CUChar class-getting info194952
Node: CUChar-accessing195316
Node: CUInt195627
Node: CUInt class-accessing195886
Node: CUInt-accessing196236
Node: CULong196539
Node: CULong class-accessing196802
Node: CULong-accessing197157
Node: CUnion197465
Node: CUnion class-subclass creation197707
Node: CUShort197937
Node: CUShort class-accessing198204
Node: CUShort-accessing198564
Node: Date198877
Node: Date class-basic200339
Node: Date class-instance creation (ANSI)201453
Node: Date class-instance creation (Blue Book)201929
Node: Date-basic203235
Node: Date-compatibility (non-ANSI)203695
Node: Date-date computations204094
Node: Date-printing205703
Node: Date-storing205917
Node: Date-testing206126
Node: DateTime206431
Node: DateTime class-information207065
Node: DateTime class-instance creation207342
Node: DateTime class-instance creation (non-ANSI)208629
Node: DateTime-basic209117
Node: DateTime-computations209450
Node: DateTime-printing210128
Node: DateTime-splitting in dates & times210380
Node: DateTime-storing210965
Node: DateTime-testing211216
Node: DateTime-time zones211577
Node: Delay212691
Node: Delay class-general inquiries213454
Node: Delay class-initialization213713
Node: Delay class-instance creation213995
Node: Delay-accessing214484
Node: Delay-comparing214724
Node: Delay-process delay214996
Node: DelayedAdaptor215218
Node: DelayedAdaptor-accessing215744
Node: Dictionary216109
Node: Dictionary class-instance creation217059
Node: Dictionary-accessing217299
Node: Dictionary-awful ST-80 compatibility hacks218956
Node: Dictionary-dictionary enumerating219405
Node: Dictionary-dictionary removing220479
Node: Dictionary-dictionary testing221334
Node: Dictionary-polymorphism hacks221994
Node: Dictionary-printing222265
Node: Dictionary-rehashing222615
Node: Dictionary-storing222818
Node: Dictionary-testing223064
Node: DirectedMessage223324
Node: DirectedMessage class-creating instances223890
Node: DirectedMessage-accessing224309
Node: DirectedMessage-basic224603
Node: DirectedMessage-multiple process225013
Node: DirectedMessage-saving and loading225597
Node: Directory226021
Node: Directory class-C functions226792
Node: Directory class-file name management227093
Node: Directory class-file operations227654
Node: Directory class-reading system defaults228022
Node: Directory-accessing228970
Node: Directory-enumerating229832
Node: DLD230574
Node: DLD class-C functions231244
Node: DLD class-dynamic linking231621
Node: DumperProxy232953
Node: DumperProxy class-accessing233479
Node: DumperProxy class-instance creation233930
Node: DumperProxy-saving and restoring234421
Node: Duration234822
Node: Duration class-instance creation235223
Node: Duration class-instance creation (non ANSI)235709
Node: Duration-arithmetics236174
Node: Error237348
Node: Error-exception description237663
Node: Exception237990
Node: Exception class-comparison239118
Node: Exception class-creating ExceptionCollections239568
Node: Exception class-initialization239978
Node: Exception class-instance creation240346
Node: Exception class-interoperability with TrappableEvents240916
Node: Exception-comparison241524
Node: Exception-exception description241958
Node: Exception-exception signaling242387
Node: ExceptionSet242766
Node: ExceptionSet class-instance creation243331
Node: ExceptionSet-enumerating243582
Node: False244132
Node: False-basic244521
Node: False-C hacks245501
Node: False-printing245667
Node: File245854
Node: File class-C functions246677
Node: File class-file name management246944
Node: File class-file operations248071
Node: File class-instance creation248685
Node: File class-reading system defaults249173
Node: File class-testing249446
Node: File-accessing250084
Node: File-file name management251170
Node: File-file operations251942
Node: File-testing252900
Node: FileDescriptor253817
Node: FileDescriptor class-initialization254968
Node: FileDescriptor class-instance creation255292
Node: FileDescriptor-accessing261311
Node: FileDescriptor-basic262457
Node: FileDescriptor-built ins263688
Node: FileDescriptor-class type methods264886
Node: FileDescriptor-initialize-release265302
Node: FileDescriptor-low-level access265824
Node: FileDescriptor-overriding inherited methods266896
Node: FileDescriptor-printing267683
Node: FileDescriptor-testing267967
Node: FileSegment268175
Node: FileSegment class-basic268784
Node: FileSegment class-installing269127
Node: FileSegment-basic269499
Node: FileSegment-equality270348
Node: FileStream270617
Node: FileStream class-file-in271323
Node: FileStream class-standard streams274845
Node: FileStream-basic275571
Node: FileStream-buffering276509
Node: FileStream-filing in277314
Node: FileStream-overriding inherited methods278229
Node: FileStream-testing278850
Node: Float279058
Node: Float class-byte-order dependancies279851
Node: Float class-characterization280117
Node: Float-arithmetic281125
Node: Float-basic281443
Node: Float-built ins281624
Node: Float-coercing282551
Node: Float-printing283173
Node: Float-storing283383
Node: Float-testing283590
Node: Float-testing functionality284343
Node: FloatD284525
Node: FloatD class-byte-order dependancies285184
Node: FloatD class-characterization285455
Node: FloatD class-converting286715
Node: FloatD-built ins286957
Node: FloatD-coercing288180
Node: FloatE288569
Node: FloatE class-byte-order dependancies289229
Node: FloatE class-characterization289500
Node: FloatE class-converting291048
Node: FloatE-built ins291290
Node: FloatE-coercing292513
Node: FloatQ292902
Node: FloatQ class-byte-order dependancies293564
Node: FloatQ class-characterization293835
Node: FloatQ class-converting295383
Node: FloatQ-built ins295625
Node: FloatQ-coercing296848
Node: Fraction297237
Node: Fraction class-converting297979
Node: Fraction class-instance creation298209
Node: Fraction-accessing298580
Node: Fraction-arithmetic298856
Node: Fraction-coercing299566
Node: Fraction-comparing300191
Node: Fraction-converting300679
Node: Fraction-optimized cases301166
Node: Fraction-printing301586
Node: Fraction-testing301902
Node: Halt302093
Node: Halt-description302379
Node: HashedCollection302616
Node: HashedCollection class-instance creation303467
Node: HashedCollection-accessing303830
Node: HashedCollection-builtins304396
Node: HashedCollection-copying305159
Node: HashedCollection-enumerating the elements of a collection305623
Node: HashedCollection-rehashing305985
Node: HashedCollection-removing306257
Node: HashedCollection-saving and loading306650
Node: HashedCollection-storing307150
Node: HashedCollection-testing collections307463
Node: HomedAssociation308394
Node: HomedAssociation class-basic308954
Node: HomedAssociation-accessing309242
Node: HomedAssociation-finalization309594
Node: HomedAssociation-storing310200
Node: IdentityDictionary310455
Node: IdentitySet310838
Node: IdentitySet-testing311227
Node: Integer311474
Node: Integer class-converting312293
Node: Integer-accessing312511
Node: Integer-basic312736
Node: Integer-bit operators312932
Node: Integer-converting314204
Node: Integer-extension314894
Node: Integer-iterators315193
Node: Integer-math methods315545
Node: Integer-printing316342
Node: Integer-storing317288
Node: Integer-testing functionality317531
Node: Interval317789
Node: Interval class-instance creation318375
Node: Interval-basic318963
Node: Interval-printing319635
Node: Interval-storing319861
Node: Interval-testing320094
Node: LargeArray320351
Node: LargeArray-overridden320744
Node: LargeArrayedCollection320922
Node: LargeArrayedCollection class-instance creation321455
Node: LargeArrayedCollection-accessing321800
Node: LargeArrayedCollection-basic322290
Node: LargeArraySubpart322677
Node: LargeArraySubpart class-instance creation323546
Node: LargeArraySubpart-accessing323941
Node: LargeArraySubpart-comparing324882
Node: LargeArraySubpart-modifying325890
Node: LargeByteArray326638
Node: LargeByteArray-overridden327051
Node: LargeInteger327478
Node: LargeInteger-arithmetic328264
Node: LargeInteger-bit operations329227
Node: LargeInteger-built-ins329815
Node: LargeInteger-coercion330880
Node: LargeInteger-disabled331302
Node: LargeInteger-primitive operations331663
Node: LargeInteger-testing332129
Node: LargeNegativeInteger332755
Node: LargeNegativeInteger-converting333447
Node: LargeNegativeInteger-numeric testing333821
Node: LargeNegativeInteger-reverting to LargePositiveInteger334342
Node: LargePositiveInteger334894
Node: LargePositiveInteger-arithmetic335761
Node: LargePositiveInteger-converting336223
Node: LargePositiveInteger-helper byte-level methods336777
Node: LargePositiveInteger-numeric testing338500
Node: LargePositiveInteger-primitive operations339022
Node: LargeWordArray339702
Node: LargeWordArray-overridden340122
Node: LargeZeroInteger340407
Node: LargeZeroInteger-accessing341225
Node: LargeZeroInteger-arithmetic341476
Node: LargeZeroInteger-numeric testing342392
Node: LargeZeroInteger-printing342715
Node: Link343018
Node: Link class-instance creation343553
Node: Link-basic343771
Node: Link-iteration344010
Node: LinkedList344457
Node: LinkedList-accessing345055
Node: LinkedList-adding345357
Node: LinkedList-enumerating346076
Node: LinkedList-testing346403
Node: LookupKey346745
Node: LookupKey class-basic347289
Node: LookupKey-accessing347517
Node: LookupKey-printing347768
Node: LookupKey-storing348001
Node: LookupKey-testing348243
Node: LookupTable348663
Node: LookupTable class-instance creation349391
Node: LookupTable-accessing349637
Node: LookupTable-copying350426
Node: LookupTable-enumerating350730
Node: LookupTable-rehashing351109
Node: LookupTable-removing351322
Node: LookupTable-storing351808
Node: Magnitude352031
Node: Magnitude-basic352475
Node: Magnitude-misc methods352991
Node: MappedCollection353391
Node: MappedCollection class-instance creation354754
Node: MappedCollection-basic355191
Node: Memory356066
Node: Memory class-accessing356614
Node: Message360495
Node: Message class-creating instances361133
Node: Message-accessing361409
Node: Message-basic361835
Node: MessageNotUnderstood362146
Node: MessageNotUnderstood-accessing362628
Node: MessageNotUnderstood-description362951
Node: Metaclass363216
Node: Metaclass class-instance creation364203
Node: Metaclass-accessing364472
Node: Metaclass-basic364902
Node: Metaclass-delegation365998
Node: Metaclass-filing367382
Node: Metaclass-printing367657
Node: Metaclass-testing functionality368196
Node: MethodContext368441
Node: MethodContext-accessing368931
Node: MethodContext-printing370189
Node: MethodDictionary370419
Node: MethodDictionary-adding370938
Node: MethodDictionary-rehashing371171
Node: MethodDictionary-removing371409
Node: MethodInfo371805
Node: MethodInfo-accessing372279
Node: MethodInfo-equality373208
Node: Namespace373485
Node: Namespace class-accessing374115
Node: Namespace class-disabling instance creation374502
Node: Namespace class-initialization374882
Node: Namespace-accessing375303
Node: Namespace-namespace hierarchy375576
Node: Namespace-overrides for superspaces376058
Node: Namespace-printing377839
Node: Namespace-testing378353
Node: NetClients.URIResolver378518
Node: NetClients.URIResolver class-api378961
Node: NetClients.URIResolver class-instance creation380095
Node: NetClients.URL380456
Node: NetClients.URL class-encoding URLs381165
Node: NetClients.URL class-instance creation381654
Node: NetClients.URL-accessing382463
Node: NetClients.URL-comparing385172
Node: NetClients.URL-copying385682
Node: NetClients.URL-initialize-release386203
Node: NetClients.URL-printing386486
Node: NetClients.URL-testing386764
Node: NetClients.URL-utilities387524
Node: Notification387818
Node: Notification-exception description388259
Node: NullProxy388705
Node: NullProxy class-instance creation389305
Node: NullProxy-accessing389560
Node: NullValueHolder389796
Node: NullValueHolder class-creating instances390373
Node: NullValueHolder-accessing390639
Node: Number390971
Node: Number class-converting391855
Node: Number class-testing392299
Node: Number-arithmetic392551
Node: Number-comparing393868
Node: Number-converting394275
Node: Number-copying395527
Node: Number-error raising395826
Node: Number-misc math396181
Node: Number-point creation397728
Node: Number-retrying398007
Node: Number-shortcuts and iterators399794
Node: Number-testing400643
Node: Number-truncation and round off402061
Node: Object402858
Node: Object class-initialization403808
Node: Object-built ins404484
Node: Object-change and update412331
Node: Object-class type methods413522
Node: Object-conversion414325
Node: Object-copying414556
Node: Object-debugging415204
Node: Object-dependents access415648
Node: Object-error raising416336
Node: Object-exception handling417013
Node: Object-finalization417518
Node: Object-printing418498
Node: Object-relational operators420225
Node: Object-saving and loading420571
Node: Object-storing421556
Node: Object-syntax shortcuts422145
Node: Object-testing functionality422454
Node: ObjectDumper423976
Node: ObjectDumper class-establishing proxy classes425169
Node: ObjectDumper class-instance creation426002
Node: ObjectDumper class-shortcuts426399
Node: ObjectDumper class-testing426777
Node: ObjectDumper-accessing427205
Node: ObjectDumper-loading/dumping objects427697
Node: ObjectDumper-stream interface428121
Node: ObjectMemory428487
Node: ObjectMemory class-accessing429603
Node: ObjectMemory class-builtins429854
Node: ObjectMemory class-dependancy433181
Node: ObjectMemory class-initialization433473
Node: ObjectMemory class-saving the image433751
Node: ObjectMemory-accessing434063
Node: ObjectMemory-builtins439001
Node: ObjectMemory-derived information439270
Node: OrderedCollection440241
Node: OrderedCollection class-instance creation440951
Node: OrderedCollection-accessing441293
Node: OrderedCollection-adding441744
Node: OrderedCollection-removing443792
Node: Package444430
Node: Package-accessing444835
Node: PackageLoader446427
Node: PackageLoader class-accessing446985
Node: PackageLoader class-loading448769
Node: PackageLoader class-testing449754
Node: PluggableAdaptor450029
Node: PluggableAdaptor class-creating instances450657
Node: PluggableAdaptor-accessing451736
Node: PluggableProxy452021
Node: PluggableProxy class-accessing452647
Node: PluggableProxy-saving and restoring453081
Node: Point453500
Node: Point class-instance creation454227
Node: Point-accessing454524
Node: Point-arithmetic454942
Node: Point-comparing455645
Node: Point-converting456442
Node: Point-point functions456945
Node: Point-printing457877
Node: Point-storing458095
Node: Point-truncation and round off458327
Node: PositionableStream458723
Node: PositionableStream class-instance creation459630
Node: PositionableStream-accessing-reading460139
Node: PositionableStream-class type methods461294
Node: PositionableStream-positioning461783
Node: PositionableStream-testing462921
Node: PositionableStream-truncating463387
Node: Process463671
Node: Process-accessing464239
Node: Process-basic465737
Node: Process-builtins467268
Node: Process-printing468062
Node: ProcessorScheduler468260
Node: ProcessorScheduler class-instance creation468927
Node: ProcessorScheduler-basic469225
Node: ProcessorScheduler-built ins470791
Node: ProcessorScheduler-idle tasks471477
Node: ProcessorScheduler-printing471819
Node: ProcessorScheduler-priorities472122
Node: ProcessorScheduler-storing473772
Node: ProcessorScheduler-timed invocation474097
Node: Promise474652
Node: Promise class-creating instances475224
Node: Promise-accessing475471
Node: Promise-initializing475795
Node: Promise-printing476023
Node: Random476214
Node: Random class-instance creation476663
Node: Random class-shortcuts477029
Node: Random-basic477346
Node: Random-testing477760
Node: ReadStream478070
Node: ReadStream class-instance creation478510
Node: ReadStream-accessing-reading478785
Node: ReadWriteStream479079
Node: ReadWriteStream class-instance creation479565
Node: ReadWriteStream-positioning480020
Node: Rectangle480385
Node: Rectangle class-instance creation481174
Node: Rectangle-accessing481716
Node: Rectangle-copying484114
Node: Rectangle-printing484332
Node: Rectangle-rectangle functions484658
Node: Rectangle-testing486499
Node: Rectangle-transforming487313
Node: Rectangle-truncation and round off487937
Node: RecursionLock488226
Node: RecursionLock class-instance creation488626
Node: RecursionLock-accessing488860
Node: RecursionLock-mutual exclusion489457
Node: RecursionLock-printing489816
Node: RootNamespace490066
Node: RootNamespace class-instance creation490615
Node: RootNamespace-namespace hierarchy490948
Node: RootNamespace-overrides for superspaces491379
Node: RootNamespace-printing491994
Node: RunArray492502
Node: RunArray class-instance creation493463
Node: RunArray-accessing493735
Node: RunArray-adding494069
Node: RunArray-basic495143
Node: RunArray-copying495448
Node: RunArray-enumerating495804
Node: RunArray-removing496264
Node: RunArray-searching496729
Node: RunArray-testing497143
Node: ScaledDecimal497386
Node: ScaledDecimal class-constants498190
Node: ScaledDecimal class-instance creation498440
Node: ScaledDecimal-arithmetic498877
Node: ScaledDecimal-coercion499596
Node: ScaledDecimal-comparing500501
Node: ScaledDecimal-constants501137
Node: ScaledDecimal-printing501439
Node: ScaledDecimal-storing501899
Node: Semaphore502137
Node: Semaphore class-instance creation502800
Node: Semaphore-accessing503173
Node: Semaphore-builtins503657
Node: Semaphore-mutual exclusion504997
Node: Semaphore-printing505331
Node: SequenceableCollection505561
Node: SequenceableCollection class-instance creation506263
Node: SequenceableCollection-basic506678
Node: SequenceableCollection-copying SequenceableCollections510100
Node: SequenceableCollection-enumerating512370
Node: SequenceableCollection-replacing items515783
Node: SequenceableCollection-testing516730
Node: Set517164
Node: Set-arithmetic517584
Node: Set-awful ST-80 compatibility hacks517913
Node: Set-comparing518274
Node: SharedQueue518669
Node: SharedQueue class-instance creation519191
Node: SharedQueue-accessing519560
Node: Signal520062
Node: Signal-accessing520687
Node: Signal-exception handling521537
Node: SingletonProxy524090
Node: SingletonProxy class-accessing524694
Node: SingletonProxy class-instance creation525059
Node: SingletonProxy-saving and restoring525500
Node: SmallInteger525927
Node: SmallInteger class-getting limits526614
Node: SmallInteger class-testing527100
Node: SmallInteger-bit arithmetic527396
Node: SmallInteger-built ins527674
Node: SmallInteger-builtins529979
Node: SmallInteger-coercion methods530730
Node: SmallInteger-testing functionality531086
Node: SortedCollection531319
Node: SortedCollection class-hacking532451
Node: SortedCollection class-instance creation532720
Node: SortedCollection-basic533233
Node: SortedCollection-copying533778
Node: SortedCollection-disabled534085
Node: SortedCollection-enumerating534939
Node: SortedCollection-saving and loading535269
Node: SortedCollection-searching535615
Node: Stream536202
Node: Stream-accessing-reading537144
Node: Stream-accessing-writing538911
Node: Stream-basic539466
Node: Stream-character writing539649
Node: Stream-enumerating540170
Node: Stream-filing out540405
Node: Stream-positioning540751
Node: Stream-printing541459
Node: Stream-providing consistent protocols542219
Node: Stream-storing542578
Node: Stream-testing542950
Node: String543234
Node: String class-basic543816
Node: String class-instance creation544133
Node: String-built ins544464
Node: String-converting546456
Node: String-storing546801
Node: String-testing functionality547038
Node: String-useful functionality547262
Node: Symbol547548
Node: Symbol class-built ins548374
Node: Symbol class-instance creation548589
Node: Symbol class-symbol table549728
Node: Symbol-basic551137
Node: Symbol-built ins551890
Node: Symbol-converting552199
Node: Symbol-misc552539
Node: Symbol-storing552703
Node: Symbol-testing553366
Node: Symbol-testing functionality553634
Node: SymLink553853
Node: SymLink class-instance creation554402
Node: SymLink-accessing554722
Node: SymLink-iteration555057
Node: SymLink-printing555272
Node: SystemDictionary555472
Node: SystemDictionary-basic556279
Node: SystemDictionary-builtins556560
Node: SystemDictionary-C functions557890
Node: SystemDictionary-miscellaneous558396
Node: SystemDictionary-printing558741
Node: SystemDictionary-special accessing559160
Node: SystemExceptions.AlreadyDefined559724
Node: SystemExceptions.AlreadyDefined-accessing560238
Node: SystemExceptions.ArgumentOutOfRange560490
Node: SystemExceptions.ArgumentOutOfRange class-signaling561078
Node: SystemExceptions.ArgumentOutOfRange-accessing561484
Node: SystemExceptions.BadReturn562062
Node: SystemExceptions.BadReturn-accessing562540
Node: SystemExceptions.CInterfaceError562784
Node: SystemExceptions.CInterfaceError-accessing563283
Node: SystemExceptions.EmptyCollection563551
Node: SystemExceptions.EmptyCollection-accessing564036
Node: SystemExceptions.EndOfStream564304
Node: SystemExceptions.EndOfStream class-signaling564793
Node: SystemExceptions.EndOfStream-accessing565133
Node: SystemExceptions.FileError565553
Node: SystemExceptions.FileError-accessing566030
Node: SystemExceptions.IndexOutOfRange566274
Node: SystemExceptions.IndexOutOfRange class-signaling566858
Node: SystemExceptions.IndexOutOfRange-accessing567224
Node: SystemExceptions.InvalidArgument567738
Node: SystemExceptions.InvalidArgument-accessing568233
Node: SystemExceptions.InvalidProcessState568490
Node: SystemExceptions.InvalidProcessState-accessing569019
Node: SystemExceptions.InvalidSize569303
Node: SystemExceptions.InvalidSize-accessing569768
Node: SystemExceptions.InvalidValue570020
Node: SystemExceptions.InvalidValue class-signaling570528
Node: SystemExceptions.InvalidValue-accessing570977
Node: SystemExceptions.MustBeBoolean571468
Node: SystemExceptions.MutationError571888
Node: SystemExceptions.MutationError-accessing572347
Node: SystemExceptions.NoRunnableProcess572607
Node: SystemExceptions.NoRunnableProcess-accessing573092
Node: SystemExceptions.NotFound573368
Node: SystemExceptions.NotFound class-accessing573882
Node: SystemExceptions.NotFound-accessing574257
Node: SystemExceptions.NotImplemented574547
Node: SystemExceptions.NotImplemented-accessing575003
Node: SystemExceptions.NotIndexable575267
Node: SystemExceptions.NotIndexable-accessing575728
Node: SystemExceptions.NotYetImplemented575984
Node: SystemExceptions.NotYetImplemented-accessing576494
Node: SystemExceptions.PrimitiveFailed576770
Node: SystemExceptions.PrimitiveFailed-accessing577253
Node: SystemExceptions.ProcessBeingTerminated577521
Node: SystemExceptions.ProcessBeingTerminated-accessing577956
Node: SystemExceptions.ProcessTerminated578252
Node: SystemExceptions.ProcessTerminated-accessing578775
Node: SystemExceptions.ReadOnlyObject579051
Node: SystemExceptions.ReadOnlyObject-accessing579530
Node: SystemExceptions.ShouldNotImplement579794
Node: SystemExceptions.ShouldNotImplement-accessing580322
Node: SystemExceptions.SubclassResponsibility580602
Node: SystemExceptions.SubclassResponsibility-accessing581170
Node: SystemExceptions.UserInterrupt581466
Node: SystemExceptions.UserInterrupt-accessing581916
Node: SystemExceptions.VMError582176
Node: SystemExceptions.VMError-accessing582600
Node: SystemExceptions.WrongArgumentCount582836
Node: SystemExceptions.WrongArgumentCount-accessing583390
Node: SystemExceptions.WrongClass583670
Node: SystemExceptions.WrongClass class-signaling584286
Node: SystemExceptions.WrongClass-accessing584942
Node: SystemExceptions.WrongMessageSent585595
Node: SystemExceptions.WrongMessageSent class-signaling586240
Node: SystemExceptions.WrongMessageSent-accessing586657
Node: TextCollector587246
Node: TextCollector class-accessing587944
Node: TextCollector-accessing588441
Node: TextCollector-printing589240
Node: TextCollector-set up589572
Node: TextCollector-storing590135
Node: Time590463
Node: Time class-basic (UTC)591242
Node: Time class-builtins591688
Node: Time class-clocks592713
Node: Time class-initialization593268
Node: Time class-instance creation593612
Node: Time-accessing (ANSI for DateAndTimes)594489
Node: Time-accessing (non ANSI & for Durations)595005
Node: Time-arithmetic595455
Node: Time-comparing595881
Node: TokenStream596166
Node: TokenStream class-instance creation596974
Node: TokenStream-basic597334
Node: TokenStream-write methods597656
Node: TrappableEvent597899
Node: TrappableEvent-enumerating598475
Node: TrappableEvent-instance creation599023
Node: True599353
Node: True-basic599731
Node: True-C hacks600681
Node: True-printing600841
Node: UndefinedObject601023
Node: UndefinedObject-basic601739
Node: UndefinedObject-class creation602008
Node: UndefinedObject-class creation - alternative604189
Node: UndefinedObject-CObject interoperability606477
Node: UndefinedObject-dependents access606811
Node: UndefinedObject-printing607160
Node: UndefinedObject-storing607440
Node: UndefinedObject-testing607716
Node: ValueAdaptor608552
Node: ValueAdaptor class-creating instances609036
Node: ValueAdaptor-accessing609324
Node: ValueAdaptor-printing609731
Node: ValueHolder609944
Node: ValueHolder class-creating instances610559
Node: ValueHolder-accessing610942
Node: ValueHolder-initializing611235
Node: VariableBinding611458
Node: VariableBinding-printing612090
Node: VariableBinding-saving and loading612405
Node: VariableBinding-storing612862
Node: VariableBinding-testing613150
Node: VersionableObjectProxy613408
Node: VersionableObjectProxy class-saving and restoring614304
Node: VersionableObjectProxy-saving and restoring615328
Node: VFS.ArchiveFileHandler615662
Node: VFS.ArchiveFileHandler class-registering616579
Node: VFS.ArchiveFileHandler-ArchiveMemberHandler protocol617034
Node: VFS.ArchiveFileHandler-directory operations618411
Node: VFS.ArchiveFileHandler-file operations619253
Node: VFS.ArchiveMemberHandler619540
Node: VFS.ArchiveMemberHandler-accessing620267
Node: VFS.ArchiveMemberHandler-directory operations621427
Node: VFS.ArchiveMemberHandler-file operations622048
Node: VFS.ArchiveMemberHandler-finalization622714
Node: VFS.ArchiveMemberHandler-initializing623207
Node: VFS.ArchiveMemberHandler-testing623741
Node: VFS.DecodedFileHandler624627
Node: VFS.DecodedFileHandler class-registering625168
Node: VFS.DecodedFileHandler-files626315
Node: VFS.ExternalArchiveFileHandler627010
Node: VFS.ExternalArchiveFileHandler class-registering627841
Node: VFS.ExternalArchiveFileHandler-ArchiveMemberHandler protocol628821
Node: VFS.ExternalArchiveFileHandler-members630142
Node: VFS.ExternalArchiveFileHandler-releasing630653
Node: VFS.RealFileHandler631003
Node: VFS.RealFileHandler class-C functions631746
Node: VFS.RealFileHandler class-initialization632028
Node: VFS.RealFileHandler-accessing632355
Node: VFS.RealFileHandler-directory operations633545
Node: VFS.RealFileHandler-file operations634041
Node: VFS.RealFileHandler-testing634583
Node: VFS.VFSHandler635327
Node: VFS.VFSHandler class-initializing636100
Node: VFS.VFSHandler class-instance creation636998
Node: VFS.VFSHandler-accessing637341
Node: VFS.VFSHandler-C functions638683
Node: VFS.VFSHandler-directory operations639819
Node: VFS.VFSHandler-file operations640408
Node: VFS.VFSHandler-testing641182
Node: Warning642023
Node: Warning-exception description642342
Node: WeakArray642546
Node: WeakArray class-instance creation643039
Node: WeakArray-accessing643363
Node: WeakArray-conversion645011
Node: WeakArray-loading645646
Node: WeakIdentitySet645911
Node: WeakKeyDictionary646373
Node: WeakKeyDictionary-accessing646922
Node: WeakKeyIdentityDictionary647426
Node: WeakSet647954
Node: WeakSet-accessing648410
Node: WeakValueIdentityDictionary648908
Node: WeakValueLookupTable649454
Node: WeakValueLookupTable-hacks650062
Node: WeakValueLookupTable-rehashing650619
Node: WordArray650842
Node: WriteStream651148
Node: WriteStream class-instance creation651674
Node: WriteStream-accessing652344
Node: WriteStream-accessing-writing652598
Node: WriteStream-positioning653189
Node: ZeroDivide653399
Node: ZeroDivide class-instance creation653892
Node: ZeroDivide-accessing654272
Node: ZeroDivide-description654525
Node: Class index654740
Node: Method index666577
Node: Cross-reference884669

End Tag Table
