This is gst-base.info, produced by makeinfo version 4.2 from
/tmp/a/ports/lang/smalltalk/work/smalltalk-2.0.8/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.0.8.  It was last updated
on 14 July 2002.

   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.0.8.  It was last updated
on 14 July 2002.

   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:
* AlternativeObjectProxy::
* ArithmeticError::
* Array::
* ArrayedCollection::
* Association::
* Autoload::
* Bag::
* Behavior::
* BlockClosure::
* BlockContext::
* Boolean::
* Browser::
* ByteArray::
* ByteStream::
* CAggregate::
* 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::
* 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::
* Notification::
* NullProxy::
* NullValueHolder::
* Number::
* Object::
* ObjectDumper::
* ObjectMemory::
* OrderedCollection::
* PackageLoader::
* PluggableAdaptor::
* PluggableProxy::
* Point::
* PositionableStream::
* Process::
* ProcessorScheduler::
* Promise::
* Random::
* ReadStream::
* ReadWriteStream::
* Rectangle::
* 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 InvalidSize::
* SystemExceptions InvalidValue::
* SystemExceptions MustBeBoolean::
* SystemExceptions NoRunnableProcess::
* SystemExceptions NotFound::
* SystemExceptions NotImplemented::
* SystemExceptions NotIndexable::
* SystemExceptions NotYetImplemented::
* SystemExceptions PrimitiveFailed::
* 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::
* VersionableObjectProxy::
* VFS ArchiveFileHandler::
* VFS DecodedFileHandler::
* VFS ExternalArchiveFileHandler::
* VFS RealFileHandler::
* VFS VFSHandler::
* Warning::
* WeakArray::
* WeakIdentitySet::
* WeakKeyIdentityDictionary::
* WeakKeyLookupTable::
* WeakSet::
* WeakValueIdentityDictionary::
* WeakValueLookupTable::
* WordArray::
* WriteStream::
* ZeroDivide::


Class tree:
* Autoload::
* Object::
*   Behavior::
*     ClassDescription::
*       Class::
*       Metaclass::
*   BlockClosure::
*   Boolean::
*     False::
*     True::
*   Browser::
*   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::
*         LookupTable::
*           IdentityDictionary::
*           MethodDictionary::
*           WeakKeyLookupTable::
*             WeakKeyIdentityDictionary::
*           WeakValueLookupTable::
*             WeakValueIdentityDictionary::
*         RootNamespace::
*           Namespace::
*           SystemDictionary::
*       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::
*     SymLink::
*   Magnitude::
*     Character::
*     Date::
*       DateTime::
*     LargeArraySubpart::
*     LookupKey::
*       Association::
*     Number::
*       Float::
*         FloatD::
*         FloatE::
*         FloatQ::
*       Fraction::
*       Integer::
*         LargeInteger::
*           LargeNegativeInteger::
*           LargePositiveInteger::
*             LargeZeroInteger::
*         SmallInteger::
*       ScaledDecimal::
*     Time::
*       Duration::
*   Memory::
*   Message::
*     DirectedMessage::
*   MethodInfo::
*   ObjectMemory::
*   PackageLoader::
*   Point::
*   ProcessorScheduler::
*   Rectangle::
*   SharedQueue::
*   Signal::
*     Exception::
*       Error::
*         Halt::
*           ArithmeticError::
*             ZeroDivide::
*           MessageNotUnderstood::
*         SystemExceptions EndOfStream::
*         SystemExceptions InvalidValue::
*           SystemExceptions EmptyCollection::
*           SystemExceptions InvalidArgument::
*             SystemExceptions AlreadyDefined::
*             SystemExceptions ArgumentOutOfRange::
*               SystemExceptions IndexOutOfRange::
*             SystemExceptions InvalidSize::
*             SystemExceptions NotFound::
*           SystemExceptions MustBeBoolean::
*           SystemExceptions NotIndexable::
*           SystemExceptions ProcessTerminated::
*           SystemExceptions ReadOnlyObject::
*           SystemExceptions WrongClass::
*         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::
*         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 ArchiveFileHandler::
*       VFS ExternalArchiveFileHandler::
*     VFS RealFileHandler::
*       VFS DecodedFileHandler::


File: gst-base.info,  Node: AlternativeObjectProxy,  Next: ArithmeticError,  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
     Answer an empty collection

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-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-printing,  Prev: Association class-basic,  Up: Association

Association: accessing
----------------------

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-printing,  Next: Association-storing,  Prev: Association-accessing,  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: Bag,  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-loading or "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).

* 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: classNameString from: fileNameString
     Make Smalltalk automatically load the class named classNameString
     from fileNameString when needed


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

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

doesNotUnderstand: aMessage
     Load the file, then reinvoke the method forwarding it to the newly
     loaded class.


File: gst-base.info,  Node: Bag,  Next: Behavior,  Prev: Autoload,  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 to a collection::  (instance)
* Bag-enumerating the elements of a collection::  (instance)
* Bag-extracting items::  (instance)
* Bag-printing::  (instance)
* Bag-Removing from a collection::  (instance)
* Bag-storing::  (instance)
* Bag-testing collections::  (instance)


File: gst-base.info,  Node: Bag class-basic,  Next: Bag-Adding to a collection,  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 to a collection,  Next: Bag-enumerating the elements of a collection,  Prev: Bag class-basic,  Up: Bag

Bag: Adding to a collection
---------------------------

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 to a collection,  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 from a collection,  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 from a collection,  Next: Bag-storing,  Prev: Bag-printing,  Up: Bag

Bag: Removing from a collection
-------------------------------

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 from a collection,  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: BlockClosure,  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 class-C interface::  (class)
* Behavior-accessing class hierarchy::  (instance)
* Behavior-accessing instances and variables::  (instance)
* Behavior-accessing the methodDictionary::  (instance)
* Behavior-browsing::  (instance)
* Behavior-built ins::  (instance)
* Behavior-compilation (alternative)::  (instance)
* Behavior-compiling methods::  (instance)
* Behavior-creating a class hierarchy::  (instance)
* Behavior-creating method dictionary::  (instance)
* Behavior-enumerating::  (instance)
* Behavior-evaluating::  (instance)
* Behavior-hierarchy browsing::  (instance)
* Behavior-instance creation::  (instance)
* Behavior-instance variables::  (instance)
* Behavior-support for lightweight classes::  (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 class-C interface,  Next: Behavior-accessing class hierarchy,  Up: Behavior

Behavior class: C interface
---------------------------

defineCFunc: cFuncNameString
     withSelectorArgs: selectorAndArgs     forClass: aClass
     returning: returnTypeSymbol     args: argsArray Lookup the part on
     the C interface in this manual - it is too complex to describe it
     here ;-) Anyway this is private and kept for backward com-
     patibility. You should use
     defineCFunc:withSelectorArgs:returning:args:.


File: gst-base.info,  Node: Behavior-accessing class hierarchy,  Next: Behavior-accessing instances and variables,  Prev: Behavior class-C interface,  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-browsing,  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.

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-browsing,  Next: Behavior-built ins,  Prev: Behavior-accessing the methodDictionary,  Up: Behavior

Behavior: browsing
------------------

getAllMethods
     Answer the receiver's complete method dictionary - including
     inherited and not overridden methods. Each value in the dictionary
     is an Association, whose key is the class which defines the
     method, and whose value is the actual CompiledMethod

getDirectMethods
     Answer the receiver's method dictionary; each value in the
     dictionary is not a CompiledMethod, but an Association, whose key
     is the class which defines the method (always the receiver), and
     whose value is the actual CompiledMethod

getIndirectMethods
     Answer a dictionary of the receiver's inherited and not overridden
     methods. Each value in the dictionary is an Association, whose key
     is the class which defines the method, and whose value is the
     actual CompiledMethod

getMethods
     Answer the receiver's complete method dictionary - including
     inherited and not overridden methods

getMethodsFor: aSelector
     Get a dictionary with all the definitions of the given selector
     along the hierarchy. Each key in the dictionary is a class which
     defines the method, and each value in the dictionary is an
     Association, whose key is the class again, and whose value is the
     actual CompiledMethod

methodDictionary
     Answer the receiver's method dictionary

newGetMethods
     Answer the receiver's complete method dictionary - including
     inherited and not overridden methods. Each value in the dictionary
     is an Association, whose key is the class which defines the
     method, and whose value is the actual CompiledMethod


File: gst-base.info,  Node: Behavior-built ins,  Next: Behavior-compilation (alternative),  Prev: Behavior-browsing,  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-creating method dictionary,  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-creating method dictionary,  Next: Behavior-enumerating,  Prev: Behavior-creating a class hierarchy,  Up: Behavior

Behavior: creating 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.

defineCFunc: cFuncNameString
     withSelectorArgs: selectorAndArgs     returning: returnTypeSymbol
       args: argsArray Lookup the C interface in the manual. Too
     complex to describe it here ;-)

edit: selector
     Open Emacs to edit the method with the passed selector, then
     compile it

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.


File: gst-base.info,  Node: Behavior-enumerating,  Next: Behavior-evaluating,  Prev: Behavior-creating method dictionary,  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-hierarchy browsing,  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-hierarchy browsing,  Next: Behavior-instance creation,  Prev: Behavior-evaluating,  Up: Behavior

Behavior: hierarchy browsing
----------------------------

printHierarchy
     Print my entire subclass hierarchy on the terminal.

printHierarchyEmacs
     Print my entire subclass hierarchy on the terminal, in a format
     suitable for Emacs parsing.


File: gst-base.info,  Node: Behavior-instance creation,  Next: Behavior-instance variables,  Prev: Behavior-hierarchy browsing,  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-support for lightweight classes,  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-support for lightweight classes,  Next: Behavior-testing the class hierarchy,  Prev: Behavior-instance variables,  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.


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

Behavior: testing the class hierarchy
-------------------------------------

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

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: BlockClosure,  Next: BlockContext,  Prev: Behavior,  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

valueWithoutPreemption
     Evaluate the receiver without ever having it pre-empted by another
     process.  This selector name is deprecated; use
     #forkWithoutPreemption instead.


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: Browser,  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: Browser,  Next: ByteArray,  Prev: Boolean,  Up: Base classes

Browser
=======

Defined in namespace Smalltalk
Superclass: Object
Category: Language-Implementation
     I contain several methods that are used by the Emacs implementation
     of the Smalltalk browser, and can be useful to other objects that
     manipulate class and method objects.

* Menu:

* Browser class-browsing::  (class)


File: gst-base.info,  Node: Browser class-browsing,  Up: Browser

Browser class: browsing
-----------------------

browseHierarchy
     Tell Emacs tp browse the Smalltalk class hierarchy

browseMethods: methods forClass: class inBuffer: bufferName
     Send to Emacs code that browses the methods in the `methods'
     Dictionary, showing them as part of the `class' class in a buffer
     with the given name

emacsFunction: funcName on: aBlock
     Send to Emacs something like (funcName <aBlock is evaluated here>)

emacsListFunction: funcName on: aBlock
     Send to Emacs something like (funcName '(<aBlock is evaluated
     here>))

finishEmacsMessage
     Finish a message to be processed by emacs - does nothing for now

getAllSelectors: selector inBuffer: bufferName
     Send to Emacs code that browses the implementors of the given
     selectors in a buffer with the given name

initialize
     Initialize the Emacs browsing system

loadClassNames
     Tell Emacs the class names (new version)

oldloadClassNames
     Tell Emacs the class names

oldShowInstanceMethods: class
     Send to Emacs code that browses instance methods for class

oldShowMethods: class for: methodType
     Send to Emacs code that browses methods of the given type for class
     (methodType is either `class' or `instance')

selectorsForEmacs
     Tell Emacs the names of ALL the defined selectors

showAllMethods: class inBuffer: bufferName
     Send to Emacs code that browses ALL the methods understood by
     instances of the given class, in a buffer with the given name

showDirectMethods: class inBuffer: bufferName
     Send to Emacs code that browses methods defined in the given class,
     in a buffer with the given name

showIndirectMethods: class inBuffer: bufferName
     Send to Emacs code that browses the methods inherited (and not
     overridden) by the given class, in a buffer with the given name

showMethods: class for: methodType
     Send to Emacs code that browses methods of the given type for class
     (methodType is either `class' or `instance')

startEmacsMessage
     Start a message to be processed by emacs as Lisp

testMethods: aClass for: methodType
     Send to Emacs code that browses methods of the given type for class
     (methodType is either `class' or `instance')

withGcOff: aBlock
     Evaluate aBlock while the `GC flipping...' message is off


File: gst-base.info,  Node: ByteArray,  Next: ByteStream,  Prev: Browser,  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: CArray,  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 base type over which the receiver is constructed.


File: gst-base.info,  Node: CArray,  Next: CArrayCType,  Prev: CAggregate,  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-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 the address (CObject) of the function which is registered
     (on the C side) with the given name, or zero if no such a function
     is registered.

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


File: gst-base.info,  Node: CFunctionDescriptor-accessing,  Next: CFunctionDescriptor-printing,  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-printing,  Prev: CFunctionDescriptor-accessing,  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)

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.  This message is preserved for
     backwards compatibility; the ANSI standard mandates `subStrings',
     with an uppercase s.

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

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


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

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

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 to a collection::  (instance)
* Collection-converting::  (instance)
* Collection-copying Collections::  (instance)
* Collection-enumerating the elements of a collection::  (instance)
* Collection-printing::  (instance)
* Collection-Removing from a collection::  (instance)
* Collection-storing::  (instance)
* Collection-testing collections::  (instance)


File: gst-base.info,  Node: Collection class-instance creation,  Next: Collection-Adding to a collection,  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 to a collection,  Next: Collection-converting,  Prev: Collection class-instance creation,  Up: Collection

Collection: Adding to a collection
----------------------------------

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 to a collection,  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-enumerating the elements of a collection,  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-enumerating the elements of a collection,  Next: Collection-printing,  Prev: Collection-copying Collections,  Up: Collection

Collection: enumerating the elements of a collection
----------------------------------------------------

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-printing,  Next: Collection-Removing from a collection,  Prev: Collection-enumerating the elements of a collection,  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 from a collection,  Next: Collection-storing,  Prev: Collection-printing,  Up: Collection

Collection: Removing from a collection
--------------------------------------

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 from a collection,  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-printing::  (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-printing,  Prev: CompiledCode-copying,  Up: CompiledCode

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

breakAtLine: lineNumber
     This method's functionality has not been implemented yet.

breakpointAt: byteIndex
     Put a break-point at the given bytecode

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

removeBreakpointAt: byteIndex
     Remove the break-point at the given bytecode (don't fail if none
     was set


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

CompiledCode: printing
----------------------

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


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

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

accesses: instVarIndex
     Answer whether the receiver access 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

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


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)


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

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

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

storeOn: aStream
     Print code to create the receiver on aStream


File: gst-base.info,  Node: CompiledMethod-saving and loading,  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: 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-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-enumerating,  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-enumerating,  Next: ContextPart-exception handling,  Prev: ContextPart-copying,  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
--------------------

copy
     Answer a copy of the receiver


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: anObject
     This method should not be called for instances of this class.

remove: anObject ifAbsent: aBlock
     This method should not be called for instances of this class.

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

removeAssociation: anAssociation
     Remove anAssociation's key from the dictionary

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-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-saving and loading,  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-saving and loading,  Prev: DirectedMessage-basic,  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 and Behavior.

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

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


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 index position.

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

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: IdentityDictionary,  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 from a collection::  (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 from a collection,  Prev: HashedCollection-enumerating the elements of a collection,  Up: HashedCollection

HashedCollection: rehashing
---------------------------

rehash
     Rehash the receiver


File: gst-base.info,  Node: HashedCollection-Removing from a collection,  Next: HashedCollection-saving and loading,  Prev: HashedCollection-rehashing,  Up: HashedCollection

HashedCollection: Removing from a collection
--------------------------------------------

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 from a collection,  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: IdentityDictionary,  Next: IdentitySet,  Prev: HashedCollection,  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-bit operators::  (instance)
* Integer-converting::  (instance)
* Integer-extension::  (instance)
* Integer-Math methods::  (instance)
* Integer-Misc math operators::  (instance)
* Integer-Other iterators::  (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-bit operators,  Prev: Integer class-converting,  Up: Integer

Integer: accessing
------------------

denominator
     Answer `1'.

numerator
     Answer the receiver.


File: gst-base.info,  Node: Integer-bit operators,  Next: Integer-converting,  Prev: Integer-accessing,  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-Math methods,  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-Math methods,  Next: Integer-Misc math operators,  Prev: Integer-extension,  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-Misc math operators,  Next: Integer-Other iterators,  Prev: Integer-Math methods,  Up: Integer

Integer: Misc math operators
----------------------------

hash
     Answer an hash value for the receiver


File: gst-base.info,  Node: Integer-Other iterators,  Next: Integer-printing,  Prev: Integer-Misc math operators,  Up: Integer

Integer: Other 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-printing,  Next: Integer-storing,  Prev: Integer-Other iterators,  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

radix: baseInteger
     Return the base b representation of the receiver, with BBr in
     front of it

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 as friendly to the virtual
     machine). I use the object equality comparision 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
---------------------

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)
* Memory class-basic::  (class)


File: gst-base.info,  Node: Memory class-accessing,  Next: Memory class-basic,  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: Memory class-basic,  Prev: Memory class-accessing,  Up: Memory

Memory class: basic
-------------------

addressOf: anObject
     Returns the address of the actual object that anObject references.
     The result might be invalidated after a garbage collection occurs.
     Sending this method to Memory is deprecated; send it to
     ObjectMemory instead.

addressOfOOP: anObject
     Returns the address of the OOP (object table slot) for anObject.
     The result is still valid after a garbage collection occurs.
     Sending this method to Memory is deprecated; send it to
     ObjectMemory instead.

type: aType at: anAddress
     Returns a particular type object from memory at anAddress

type: aType at: anAddress put: aValue
     Sets the memory location anAddress to aValue


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

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
     - a dummy one, since Behavior does not support names.

printOn: aStream
     Print a represention of the receiver on aStream

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

isBehavior
     Answer `true'.

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

removeAssociation: 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: Notification,  Prev: MethodInfo,  Up: Base classes

Namespace
=========

Defined in namespace Smalltalk
Superclass: RootNamespace
Category: Language-Implementation
     I am a special form of dictionary.  I provide special ways to
     access my keys, which typically begin with an uppercase letter.
     Classes hold on an instance of me; it is called their
     `environment').

     My keys are (expected to be) symbols, so I use == to match
     searched keys to those in the dictionary - this is done expecting
     it brings a bit more speed.

* Menu:

* Namespace class-accessing::  (class)
* Namespace class-disabling instance creation::  (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: aNamespace
     Set the current namespace to be aNamespace.


File: gst-base.info,  Node: Namespace class-disabling instance creation,  Next: Namespace-accessing,  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-accessing,  Next: Namespace-namespace hierarchy,  Prev: Namespace class-disabling instance creation,  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
-------------------

name
     Answer the receiver's name

nameIn: aNamespace
     Answer 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: Notification,  Next: NullProxy,  Prev: Namespace,  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-Intervals & iterators::  (instance)
* Number-misc math::  (instance)
* Number-point creation::  (instance)
* Number-retrying::  (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-Intervals & iterators,  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-Intervals & iterators,  Next: Number-misc math,  Prev: Number-error raising,  Up: Number

Number: Intervals & 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-misc math,  Next: Number-point creation,  Prev: Number-Intervals & iterators,  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-testing,  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-testing,  Next: Number-truncation and round off,  Prev: Number-retrying,  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-built ins::  (instance)
* Object-change and update::  (instance)
* Object-class type methods::  (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-built ins,  Next: Object-change and update,  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'

addToBeFinalized
     Add the object to the list of objects to be finalized when there
     are no more references to them

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

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

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

removeToBeFinalized
     Remove the object from the list of objects to be finalized when
     there are no more references to them

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


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-copying,  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-copying,  Next: Object-debugging,  Prev: Object-class type methods,  Up: Object

Object: copying
---------------

asValue
     Return a ValueHolder that holds the receiver

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

finalize
     Do nothing by default


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.

* Menu:

* ObjectMemory class-builtins::  (class)
* ObjectMemory class-dependancy::  (class)
* ObjectMemory class-initialization::  (class)
* ObjectMemory class-saving the image::  (class)


File: gst-base.info,  Node: ObjectMemory class-builtins,  Next: ObjectMemory class-dependancy,  Up: ObjectMemory

ObjectMemory class: builtins
----------------------------

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

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

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.

printStatistics
     Print statistics about what the VM did since #resetStatistics was
     last called.  Meaningful only if gst was made with `make profile'
     or `make profile_vm'

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.

resetStatistics
     Reset the statistics about the VM which #printStatistics can print.

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,  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: OrderedCollection,  Next: PackageLoader,  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: PackageLoader,  Next: PluggableAdaptor,  Prev: OrderedCollection,  Up: Base classes

PackageLoader
=============

Defined in namespace Smalltalk
Superclass: Object
Category: Language-Data types
     I am not part of a standard Smalltalk system. I provide methods
     for loading 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
------------------------------

addPackage: package directory: dir fileIn: fileIns needs: prerequisites
     Add the given package to the `packages' file, with the given
     directory (if relative, it is relative to the kernel directory),
     fileIns and prerequisites. fileIns and prerequisites should be two
     Collections of Strings.  Note that none of this fields are
     optional. If there are no prere- quisites, just use #('Kernel') as
     the prerequisites.

directoryFor: package
     Answer a complete path to the given package's file-in

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 (file-ins are relative to the directory answered
     by #directoryFor:, shared modules are relative to the ModulePath)

flush
     Set to reload the `packages' 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.

modulesFor: package
     Answer a Set of Strings containing the filenames of the given
     package's file-ins (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' 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', 'C:tclInit', 'Blox', 'BloxTestSuite' and 'Browser'. Note
     that Blox has been moved before BloxTestSuite.  Pass an error
     message to aBlock if any of the packages needs C call-outs 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 C call-outs are registered within
     GNU Smalltalk


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 class-basic::  (class)
* Process-accessing::  (instance)
* Process-basic::  (instance)
* Process-builtins::  (instance)
* Process-printing::  (instance)


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

Process class: basic
--------------------

on: aBlockContext at: aPriority
     Private - Create a process running aBlockContext at the given
     priority


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

Process: accessing
------------------

name
     Answer `name'.

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).  Answer the receiver


File: gst-base.info,  Node: Process-basic,  Next: Process-builtins,  Prev: Process-accessing,  Up: Process

Process: basic
--------------

forceResume
     Private - Force a resume of the process from whatever status it
     was in (even if it was waiting on a semaphore).  This is BAD
     practice, it is present only for some future possibility.

lowerPriority
     Lower a bit the priority of the receiver. A #lowerPriority will
     cancel a previous #raisePriority, and vice versa.

raisePriority
     Raise a bit the priority of the receiver. A #lowerPriority will
     cancel a previous #raisePriority, and vice versa.

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 yield control to another
     process

terminate
     Terminate the receiver - This is nothing more than prohibiting to
     resume the process, then suspending it.


File: gst-base.info,  Node: Process-builtins,  Next: Process-printing,  Prev: Process-basic,  Up: Process

Process: builtins
-----------------

resume
     Resume the receiver's execution

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-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-idle tasks,  Prev: ProcessorScheduler class-instance creation,  Up: ProcessorScheduler

ProcessorScheduler: basic
-------------------------

activePriority
     Answer the active process' priority

activeProcess
     Answer the active process

changePriorityOf: aProcess to: aPriority
     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-idle tasks,  Next: ProcessorScheduler-printing,  Prev: ProcessorScheduler-basic,  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)


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,  Prev: Promise-accessing,  Up: Promise

Promise: initializing
---------------------

initialize
     Private - set the initial state 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: RootNamespace,  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: RootNamespace,  Next: RunArray,  Prev: Rectangle,  Up: Base classes

RootNamespace
=============

Defined in namespace Smalltalk
Superclass: Dictionary
Category: Language-Implementation
     I am a special form of dictionary.  I provide special ways to
     access my keys, which typically begin with an uppercase letter.
     Classes hold on an instance of me; it is called their
     `environment').

     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:

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


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

RootNamespace class: instance creation
--------------------------------------

new
     Disabled - use #new to create instances

new: spaceName
     Create a new root namespace with the given name, and add to
     Smalltalk a key that references it.

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: RootNamespace-accessing,  Next: RootNamespace-basic & copying,  Prev: RootNamespace class-instance creation,  Up: RootNamespace

RootNamespace: 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.

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

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.


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

RootNamespace: 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

identityHash
     Answer an hash value for the receiver.  This is the same as the
     object's #identityHash.


File: gst-base.info,  Node: RootNamespace-copying,  Next: RootNamespace-forward declarations,  Prev: RootNamespace-basic & copying,  Up: RootNamespace

RootNamespace: copying
----------------------

copy
     Answer the receiver.

deepCopy
     Answer the receiver.

shallowCopy
     Answer the receiver.


File: gst-base.info,  Node: RootNamespace-forward declarations,  Next: RootNamespace-namespace hierarchy,  Prev: RootNamespace-copying,  Up: RootNamespace

RootNamespace: forward declarations
-----------------------------------

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


File: gst-base.info,  Node: RootNamespace-namespace hierarchy,  Next: RootNamespace-overrides for superspaces,  Prev: RootNamespace-forward declarations,  Up: RootNamespace

RootNamespace: 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 root namespaces

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.

     sends

superspace
     Send #at:ifAbsent: to super because our implementation of
     #at:ifAbsent: sends this message (chicken and egg!)

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: RootNamespace-overrides for superspaces,  Next: RootNamespace-printing,  Prev: RootNamespace-namespace hierarchy,  Up: RootNamespace

RootNamespace: 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 brought 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 brought 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: RootNamespace-printing,  Next: RootNamespace-testing,  Prev: RootNamespace-overrides for superspaces,  Up: RootNamespace

RootNamespace: printing
-----------------------

defaultName
     Private - Answer the name to be used if the receiver is not
     attached to an association in the superspace

name
     Answer the receiver's name

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: RootNamespace-testing,  Prev: RootNamespace-printing,  Up: RootNamespace

RootNamespace: testing
----------------------

isNamespace
     Answer `true'.

isSmalltalk
     Answer `false'.

species
     Answer `IdentityDictionary'.


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-builtins::  (instance)
* Semaphore-mutual exclusion::  (instance)


File: gst-base.info,  Node: Semaphore class-instance creation,  Next: Semaphore-builtins,  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-builtins,  Next: Semaphore-mutual exclusion,  Prev: Semaphore class-instance creation,  Up: Semaphore

Semaphore: builtins
-------------------

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


File: gst-base.info,  Node: Semaphore-mutual exclusion,  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.  aBlock
     MUST NOT CONTAIN A RETURN!!!


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


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 (heh heh heh)::  (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, fail if no
     object found at that index

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

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 (heh heh heh),  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 (heh heh heh),  Next: SmallInteger-testing functionality,  Prev: SmallInteger-builtins,  Up: SmallInteger

SmallInteger: Coercion methods (heh heh heh)
--------------------------------------------

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 (heh heh heh),  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-PositionableStream methods::  (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

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


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

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-PositionableStream methods,  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-PositionableStream methods,  Next: Stream-printing,  Prev: Stream-filing out,  Up: Stream

Stream: PositionableStream methods
----------------------------------

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.

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.

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-printing,  Next: Stream-providing consistent protocols,  Prev: Stream-PositionableStream methods,  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


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

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.

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
     for GDB.  Set breakpoint in debug() and invoke this primitive near
     where you want to stop

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

defaultName
     Answer `'Smalltalk".

name
     Answer the receiver's name

nameIn: aNamespace
     Answer `'Smalltalk".

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

dependenciesAt: anObject
     Answer the dependants of anObject (or nil if there's no key for
     anObject in the Dependencies IdentityDictionary)

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: Error
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 InvalidSize,  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 InvalidSize,  Next: SystemExceptions InvalidValue,  Prev: SystemExceptions InvalidArgument,  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 NoRunnableProcess,  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 NoRunnableProcess,  Next: SystemExceptions NotFound,  Prev: SystemExceptions MustBeBoolean,  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 ProcessTerminated,  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 ProcessTerminated,  Next: SystemExceptions ReadOnlyObject,  Prev: SystemExceptions PrimitiveFailed,  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: VersionableObjectProxy,  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: VersionableObjectProxy,  Next: VFS ArchiveFileHandler,  Prev: ValueHolder,  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 DecodedFileHandler,  Prev: VersionableObjectProxy,  Up: Base classes

VFS ArchiveFileHandler
======================

Defined in namespace Smalltalk VFS
Superclass: VFS VFSHandler
Category: Streams-Files
* Menu:


File: gst-base.info,  Node: VFS DecodedFileHandler,  Next: VFS ExternalArchiveFileHandler,  Prev: VFS ArchiveFileHandler,  Up: Base classes

VFS DecodedFileHandler
======================

Defined in namespace Smalltalk VFS
Superclass: VFS RealFileHandler
Category: Streams-Files
* 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
     Remove the file that was temporarily holding the file contents


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
* Menu:

* VFS ExternalArchiveFileHandler class-registering::  (class)


File: gst-base.info,  Node: VFS ExternalArchiveFileHandler class-registering,  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 RealFileHandler,  Next: VFS VFSHandler,  Prev: VFS ExternalArchiveFileHandler,  Up: Base classes

VFS RealFileHandler
===================

Defined in namespace Smalltalk VFS
Superclass: VFS VFSHandler
Category: Streams-Files
* Menu:

* VFS RealFileHandler class-C functions::  (class)
* VFS RealFileHandler class-initialization::  (class)
* VFS RealFileHandler-accessing::  (instance)
* VFS RealFileHandler-C functions::  (instance)
* VFS RealFileHandler-directory operations::  (instance)
* VFS RealFileHandler-enumerating::  (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-C functions,  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-C functions,  Next: VFS RealFileHandler-directory operations,  Prev: VFS RealFileHandler-accessing,  Up: VFS RealFileHandler

VFS RealFileHandler: 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 RealFileHandler-directory operations,  Next: VFS RealFileHandler-enumerating,  Prev: VFS RealFileHandler-C functions,  Up: VFS RealFileHandler

VFS RealFileHandler: directory operations
-----------------------------------------

createDir: dirName
     Change the current working directory to dirName.


File: gst-base.info,  Node: VFS RealFileHandler-enumerating,  Next: VFS RealFileHandler-file operations,  Prev: VFS RealFileHandler-directory operations,  Up: VFS RealFileHandler

VFS RealFileHandler: enumerating
--------------------------------

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-enumerating,  Up: VFS RealFileHandler

VFS RealFileHandler: 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 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.

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: VFS VFSHandler,  Next: Warning,  Prev: VFS RealFileHandler,  Up: Base classes

VFS VFSHandler
==============

Defined in namespace Smalltalk VFS
Superclass: Object
Category: Streams-Files
* Menu:

* VFS VFSHandler class-initializing::  (class)
* VFS VFSHandler class-instance creation::  (class)
* VFS VFSHandler-accessing::  (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,  Prev: VFS VFSHandler class-instance creation,  Up: VFS VFSHandler

VFS VFSHandler: accessing
-------------------------

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 nil if
     it does not apply.


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: WeakKeyIdentityDictionary,  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: WeakKeyIdentityDictionary,  Next: WeakKeyLookupTable,  Prev: WeakIdentitySet,  Up: Base classes

WeakKeyIdentityDictionary
=========================

Defined in namespace Smalltalk
Superclass: WeakKeyLookupTable
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: WeakKeyLookupTable,  Next: WeakSet,  Prev: WeakKeyIdentityDictionary,  Up: Base classes

WeakKeyLookupTable
==================

Defined in namespace Smalltalk
Superclass: LookupTable
Category: Collections-Weak
     I am similar to a plain LookupTable, 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:

* WeakKeyLookupTable class-instance creation::  (class)
* WeakKeyLookupTable-rehashing::  (instance)


File: gst-base.info,  Node: WeakKeyLookupTable class-instance creation,  Next: WeakKeyLookupTable-rehashing,  Up: WeakKeyLookupTable

WeakKeyLookupTable class: instance creation
-------------------------------------------

new: anInteger
     Answer a new instance of the receiver with the given size


File: gst-base.info,  Node: WeakKeyLookupTable-rehashing,  Prev: WeakKeyLookupTable class-instance creation,  Up: WeakKeyLookupTable

WeakKeyLookupTable: rehashing
-----------------------------

rehash
     Rehash the receiver


File: gst-base.info,  Node: WeakSet,  Next: WeakValueIdentityDictionary,  Prev: WeakKeyLookupTable,  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 class-instance creation::  (class)
* WeakSet-rehashing::  (instance)


File: gst-base.info,  Node: WeakSet class-instance creation,  Next: WeakSet-rehashing,  Up: WeakSet

WeakSet class: instance creation
--------------------------------

new: anInteger
     Answer a new instance of the receiver with the given size


File: gst-base.info,  Node: WeakSet-rehashing,  Prev: WeakSet class-instance creation,  Up: WeakSet

WeakSet: rehashing
------------------

rehash
     Rehash the receiver


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:

* AlternativeObjectProxy:                AlternativeObjectProxy.
* ArithmeticError:                       ArithmeticError.
* Array:                                 Array.
* ArrayedCollection:                     ArrayedCollection.
* Association:                           Association.
* Autoload:                              Autoload.
* Bag:                                   Bag.
* Behavior:                              Behavior.
* BlockClosure:                          BlockClosure.
* BlockContext:                          BlockContext.
* Boolean:                               Boolean.
* Browser:                               Browser.
* ByteArray:                             ByteArray.
* ByteStream:                            ByteStream.
* CAggregate:                            CAggregate.
* 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.
* 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.
* Notification:                          Notification.
* NullProxy:                             NullProxy.
* NullValueHolder:                       NullValueHolder.
* Number:                                Number.
* Object:                                Object.
* ObjectDumper:                          ObjectDumper.
* ObjectMemory:                          ObjectMemory.
* OrderedCollection:                     OrderedCollection.
* PackageLoader:                         PackageLoader.
* PluggableAdaptor:                      PluggableAdaptor.
* PluggableProxy:                        PluggableProxy.
* Point:                                 Point.
* PositionableStream:                    PositionableStream.
* Process:                               Process.
* ProcessorScheduler:                    ProcessorScheduler.
* Promise:                               Promise.
* Random:                                Random.
* ReadStream:                            ReadStream.
* ReadWriteStream:                       ReadWriteStream.
* Rectangle:                             Rectangle.
* 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 InvalidSize:          SystemExceptions InvalidSize.
* SystemExceptions InvalidValue:         SystemExceptions InvalidValue.
* SystemExceptions MustBeBoolean:        SystemExceptions MustBeBoolean.
* 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 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.
* VersionableObjectProxy:                VersionableObjectProxy.
* VFS ArchiveFileHandler:                VFS ArchiveFileHandler.
* VFS DecodedFileHandler:                VFS DecodedFileHandler.
* VFS ExternalArchiveFileHandler:        VFS ExternalArchiveFileHandler.
* VFS RealFileHandler:                   VFS RealFileHandler.
* VFS VFSHandler:                        VFS VFSHandler.
* Warning:                               Warning.
* WeakArray:                             WeakArray.
* WeakIdentitySet:                       WeakIdentitySet.
* WeakKeyIdentityDictionary:             WeakKeyIdentityDictionary.
* WeakKeyLookupTable:                    WeakKeyLookupTable.
* 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>:                                 Set-arithmetic.
* & <2>:                                 False-basic.
* & <3>:                                 True-basic.
* &:                                     Boolean-basic.
* * <1>:                                 Duration-arithmetics.
* * <2>:                                 ScaledDecimal-arithmetic.
* * <3>:                                 FloatD-built ins.
* * <4>:                                 LargeInteger-arithmetic.
* * <5>:                                 FloatQ-built ins.
* * <6>:                                 Fraction-arithmetic.
* * <7>:                                 Number-arithmetic.
* * <8>:                                 Point-arithmetic.
* * <9>:                                 FloatE-built ins.
* * <10>:                                LargeZeroInteger-arithmetic.
* *:                                     SmallInteger-built ins.
* + <1>:                                 Fraction-arithmetic.
* + <2>:                                 LargeZeroInteger-arithmetic.
* + <3>:                                 CObject-pointer-like behavior.
* + <4>:                                 Number-arithmetic.
* + <5>:                                 FloatE-built ins.
* + <6>:                                 LargePositiveInteger-arithmetic.
* + <7>:                                 ScaledDecimal-arithmetic.
* + <8>:                                 LargeNegativeInteger-reverting to LargePositiveInteger.
* + <9>:                                 LargeInteger-arithmetic.
* + <10>:                                FloatQ-built ins.
* + <11>:                                SmallInteger-built ins.
* + <12>:                                FloatD-built ins.
* + <13>:                                Duration-arithmetics.
* + <14>:                                Set-arithmetic.
* + <15>:                                Point-arithmetic.
* +:                                     DateTime-basic.
* , <1>:                                 SequenceableCollection-copying SequenceableCollections.
* , <2>:                                 String class-basic.
* , <3>:                                 TrappableEvent-instance creation.
* , <4>:                                 Exception class-creating ExceptionCollections.
* ,:                                     ArrayedCollection-basic.
* - <1>:                                 ScaledDecimal-arithmetic.
* - <2>:                                 DateTime-basic.
* - <3>:                                 Duration-arithmetics.
* - <4>:                                 FloatQ-built ins.
* - <5>:                                 SmallInteger-built ins.
* - <6>:                                 Set-arithmetic.
* - <7>:                                 Fraction-arithmetic.
* - <8>:                                 Point-arithmetic.
* - <9>:                                 LargeNegativeInteger-reverting to LargePositiveInteger.
* - <10>:                                FloatD-built ins.
* - <11>:                                CObject-pointer-like behavior.
* - <12>:                                LargeZeroInteger-arithmetic.
* - <13>:                                Number-arithmetic.
* - <14>:                                LargeInteger-arithmetic.
* - <15>:                                FloatE-built ins.
* -:                                     LargePositiveInteger-arithmetic.
* ->:                                    Object-syntax shortcuts.
* / <1>:                                 Fraction-arithmetic.
* / <2>:                                 LargeZeroInteger-arithmetic.
* / <3>:                                 Point-arithmetic.
* / <4>:                                 Number-arithmetic.
* / <5>:                                 Duration-arithmetics.
* / <6>:                                 ScaledDecimal-arithmetic.
* / <7>:                                 FloatE-built ins.
* / <8>:                                 FloatD-built ins.
* / <9>:                                 SmallInteger-built ins.
* / <10>:                                FloatQ-built ins.
* /:                                     LargeInteger-arithmetic.
* // <1>:                                Point-arithmetic.
* // <2>:                                Number-arithmetic.
* // <3>:                                SmallInteger-built ins.
* // <4>:                                LargeZeroInteger-arithmetic.
* // <5>:                                Fraction-arithmetic.
* // <6>:                                ScaledDecimal-arithmetic.
* //:                                    LargeInteger-arithmetic.
* < <1>:                                 DateTime-testing.
* < <2>:                                 SmallInteger-built ins.
* < <3>:                                 FloatQ-built ins.
* < <4>:                                 CharacterArray-comparing.
* < <5>:                                 LargeInteger-testing.
* < <6>:                                 Set-comparing.
* < <7>:                                 Date-testing.
* < <8>:                                 Character-comparing.
* < <9>:                                 Magnitude-basic.
* < <10>:                                FloatD-built ins.
* < <11>:                                ScaledDecimal-comparing.
* < <12>:                                LookupKey-testing.
* < <13>:                                Time-comparing.
* < <14>:                                LargeArraySubpart-comparing.
* < <15>:                                Fraction-comparing.
* < <16>:                                Point-comparing.
* <:                                     FloatE-built ins.
* <<:                                    Stream-printing.
* <= <1>:                                Fraction-comparing.
* <= <2>:                                LargeInteger-testing.
* <= <3>:                                LargeArraySubpart-comparing.
* <= <4>:                                FloatE-built ins.
* <= <5>:                                ScaledDecimal-comparing.
* <= <6>:                                FloatQ-built ins.
* <= <7>:                                Point-comparing.
* <= <8>:                                Set-comparing.
* <= <9>:                                SmallInteger-built ins.
* <= <10>:                               Character-comparing.
* <= <11>:                               FloatD-built ins.
* <= <12>:                               CharacterArray-comparing.
* <=:                                    Magnitude-basic.
* = <1>:                                 FileSegment-equality.
* = <2>:                                 LargeInteger-testing.
* = <3>:                                 FloatE-built ins.
* = <4>:                                 Interval-testing.
* = <5>:                                 DateTime-testing.
* = <6>:                                 Symbol-built ins.
* = <7>:                                 Date-testing.
* = <8>:                                 RootNamespace-basic & copying.
* = <9>:                                 Magnitude-basic.
* = <10>:                                ScaledDecimal-comparing.
* = <11>:                                CompiledCode-basic.
* = <12>:                                LookupKey-testing.
* = <13>:                                Delay-comparing.
* = <14>:                                Exception-comparison.
* = <15>:                                Bag-testing collections.
* = <16>:                                FloatQ-built ins.
* = <17>:                                HashedCollection-testing collections.
* = <18>:                                FloatD-built ins.
* = <19>:                                LargeArrayedCollection-basic.
* = <20>:                                RunArray-testing.
* = <21>:                                Class-testing.
* = <22>:                                Association-testing.
* = <23>:                                Object-built ins.
* = <24>:                                Time-comparing.
* = <25>:                                Dictionary-testing.
* = <26>:                                LargeArraySubpart-comparing.
* = <27>:                                Fraction-comparing.
* = <28>:                                Point-comparing.
* = <29>:                                SmallInteger-built ins.
* = <30>:                                CompiledMethod-basic.
* = <31>:                                CompiledBlock-basic.
* = <32>:                                MethodInfo-equality.
* = <33>:                                Rectangle-testing.
* = <34>:                                SequenceableCollection-testing.
* =:                                     Character-built ins.
* == <1>:                                Object-built ins.
* ==:                                    SmallInteger-built ins.
* > <1>:                                 ScaledDecimal-comparing.
* > <2>:                                 LargeInteger-testing.
* > <3>:                                 FloatD-built ins.
* > <4>:                                 SmallInteger-built ins.
* > <5>:                                 Set-comparing.
* > <6>:                                 Fraction-comparing.
* > <7>:                                 FloatQ-built ins.
* > <8>:                                 Character-comparing.
* > <9>:                                 Magnitude-basic.
* > <10>:                                CharacterArray-comparing.
* > <11>:                                Point-comparing.
* >:                                     FloatE-built ins.
* >= <1>:                                FloatD-built ins.
* >= <2>:                                Set-comparing.
* >= <3>:                                LargeInteger-testing.
* >= <4>:                                CharacterArray-comparing.
* >= <5>:                                Point-comparing.
* >= <6>:                                ScaledDecimal-comparing.
* >= <7>:                                FloatE-built ins.
* >= <8>:                                Fraction-comparing.
* >= <9>:                                SmallInteger-built ins.
* >= <10>:                               Magnitude-basic.
* >= <11>:                               Character-comparing.
* >=:                                    FloatQ-built ins.
* >>:                                    Behavior-accessing the methodDictionary.
* @:                                     Number-point creation.
* \\ <1>:                                SmallInteger-built ins.
* \\ <2>:                                Number-arithmetic.
* \\ <3>:                                LargeZeroInteger-arithmetic.
* \\ <4>:                                ScaledDecimal-arithmetic.
* \\ <5>:                                LargeInteger-arithmetic.
* \\:                                    Fraction-arithmetic.
* abbreviationOfDay_:                    Date class-basic.
* abs <1>:                               LargeNegativeInteger-numeric testing.
* abs <2>:                               LargePositiveInteger-numeric testing.
* abs <3>:                               Duration-arithmetics.
* abs <4>:                               Point-arithmetic.
* abs:                                   Number-misc math.
* acceptUsageForClass_ <1>:              SingletonProxy class-accessing.
* acceptUsageForClass_ <2>:              AlternativeObjectProxy class-instance creation.
* acceptUsageForClass_:                  DumperProxy class-accessing.
* accesses_:                             CompiledCode-testing accesses.
* activePriority:                        ProcessorScheduler-basic.
* activeProcess:                         ProcessorScheduler-basic.
* add_ <1>:                              Collection-Adding to a collection.
* add_ <2>:                              MappedCollection-basic.
* add_ <3>:                              ArrayedCollection-basic.
* add_ <4>:                              OrderedCollection-adding.
* add_ <5>:                              Dictionary-accessing.
* add_ <6>:                              LookupTable-accessing.
* add_ <7>:                              Bag-Adding to a collection.
* add_ <8>:                              HashedCollection-accessing.
* add_:                                  LinkedList-adding.
* add_after_:                            OrderedCollection-adding.
* add_afterIndex_ <1>:                   RunArray-adding.
* add_afterIndex_ <2>:                   OrderedCollection-adding.
* add_afterIndex_:                       SortedCollection-disabled.
* add_before_:                           OrderedCollection-adding.
* add_beforeIndex_:                      OrderedCollection-adding.
* add_withOccurrences_:                  Bag-Adding to a collection.
* addAll_ <1>:                           OrderedCollection-adding.
* addAll_:                               Collection-Adding to a collection.
* addAll_after_:                         OrderedCollection-adding.
* addAll_afterIndex_ <1>:                OrderedCollection-adding.
* addAll_afterIndex_ <2>:                SortedCollection-disabled.
* addAll_afterIndex_:                    RunArray-adding.
* addAll_before_:                        OrderedCollection-adding.
* addAll_beforeIndex_:                   OrderedCollection-adding.
* addAllFirst_ <1>:                      OrderedCollection-adding.
* addAllFirst_ <2>:                      RunArray-adding.
* addAllFirst_:                          SortedCollection-disabled.
* addAllLast_ <1>:                       SortedCollection-disabled.
* addAllLast_ <2>:                       OrderedCollection-adding.
* addAllLast_:                           RunArray-adding.
* addClassVarName_ <1>:                  Metaclass-delegation.
* addClassVarName_:                      Class-accessing instances and variables.
* addDays_:                              Date-basic.
* addDependent_ <1>:                     UndefinedObject-dependents access.
* addDependent_:                         Object-dependents access.
* addFeature_:                           SystemDictionary-special accessing.
* addFirst_ <1>:                         SortedCollection-disabled.
* addFirst_ <2>:                         LinkedList-adding.
* addFirst_ <3>:                         OrderedCollection-adding.
* addFirst_:                             RunArray-adding.
* addInstVarName_:                       Behavior-instance variables.
* addLast_ <1>:                          RunArray-adding.
* addLast_ <2>:                          SortedCollection-disabled.
* addLast_ <3>:                          LinkedList-adding.
* addLast_:                              OrderedCollection-adding.
* addLibrary_:                           DLD class-Dynamic Linking.
* addModule_:                            DLD class-Dynamic Linking.
* addPackage_directory_fileIn_needs_:    PackageLoader class-accessing.
* address <1>:                           CObject-accessing.
* address:                               CFunctionDescriptor-accessing.
* address_ <1>:                          CObject class-instance creation.
* address_ <2>:                          CFunctionDescriptor-accessing.
* address_ <3>:                          CObject-accessing.
* address_:                              CType-C instance creation.
* addressAt_:                            CObject-pointer-like behavior.
* addressOf_ <1>:                        CFunctionDescriptor class-testing.
* addressOf_ <2>:                        ObjectMemory class-builtins.
* addressOf_:                            Memory class-basic.
* addressOfOOP_ <1>:                     ObjectMemory class-builtins.
* addressOfOOP_:                         Memory class-basic.
* addSelector_withMethod_:               Behavior-creating method dictionary.
* addSharedPool_ <1>:                    Class-accessing instances and variables.
* addSharedPool_:                        Metaclass-delegation.
* addSubclass_:                          Behavior-creating a class hierarchy.
* addSubspace_:                          RootNamespace-namespace hierarchy.
* addTime_:                              Time-arithmetic.
* addToBeFinalized:                      Object-built ins.
* after_:                                SequenceableCollection-basic.
* alignof <1>:                           CPtr-accessing.
* alignof <2>:                           CUChar class-getting info.
* alignof <3>:                           CUChar-accessing.
* alignof <4>:                           CUInt class-accessing.
* alignof <5>:                           CUInt-accessing.
* alignof <6>:                           CULong class-accessing.
* alignof <7>:                           CULong-accessing.
* alignof <8>:                           CLong-accessing.
* alignof <9>:                           CLong class-accessing.
* alignof <10>:                          CType-accessing.
* alignof <11>:                          CInt-accessing.
* alignof <12>:                          CInt class-accessing.
* alignof <13>:                          CFloat-accessing.
* alignof <14>:                          CAggregate class-accessing.
* alignof <15>:                          CFloat class-accessing.
* alignof <16>:                          CSmalltalk-accessing.
* alignof <17>:                          CDouble-accessing.
* alignof <18>:                          CArray-accessing.
* alignof <19>:                          CDouble class-accessing.
* alignof <20>:                          CSmalltalk class-accessing.
* alignof <21>:                          CArrayCType-accessing.
* alignof <22>:                          CChar class-accessing.
* alignof <23>:                          CChar-accessing.
* alignof <24>:                          CCompound class-subclass creation.
* alignof <25>:                          CShort-accessing.
* alignof <26>:                          CShort class-accessing.
* alignof <27>:                          CUShort class-accessing.
* alignof:                               CUShort-accessing.
* alignTo_:                              Integer-extension.
* aliveObjectsDo_:                       WeakArray-accessing.
* allAssociations:                       RootNamespace-accessing.
* allBehaviorsDo_:                       RootNamespace-accessing.
* allClassesDo_:                         RootNamespace-accessing.
* allClassObjectsDo_:                    RootNamespace-accessing.
* allClassVarNames <1>:                  Class-accessing instances and variables.
* allClassVarNames <2>:                  Behavior-accessing instances and variables.
* allClassVarNames:                      Metaclass-delegation.
* allExceptionsDo_ <1>:                  TrappableEvent-enumerating.
* allExceptionsDo_ <2>:                  Exception class-interoperability with TrappableEvents.
* allExceptionsDo_ <3>:                  ExceptionSet-enumerating.
* allExceptionsDo_:                      CoreException-enumerating.
* allInstances:                          Behavior-accessing instances and variables.
* allInstancesDo_:                       Behavior-enumerating.
* allInstVarNames:                       Behavior-accessing instances and variables.
* allMask_:                              Integer-bit operators.
* allMetaclassesDo_:                     RootNamespace-accessing.
* alloc_:                                CObject class-instance creation.
* alloc_type_:                           CObject class-instance creation.
* allSatisfy_:                           Collection-enumerating the elements of a collection.
* allSelectors:                          Behavior-accessing the methodDictionary.
* allSharedPools <1>:                    Metaclass-delegation.
* allSharedPools:                        Behavior-accessing instances and variables.
* allSubassociationsDo_:                 RootNamespace-namespace hierarchy.
* allSubclasses:                         Behavior-accessing class hierarchy.
* allSubclassesDo_:                      Behavior-enumerating.
* allSubinstancesDo_:                    Behavior-enumerating.
* allSubspaces:                          RootNamespace-namespace hierarchy.
* allSubspacesDo_:                       RootNamespace-namespace hierarchy.
* allSuperclasses:                       Behavior-accessing class hierarchy.
* allSuperclassesDo_:                    Behavior-enumerating.
* allSuperspaces:                        RootNamespace-namespace hierarchy.
* allSuperspacesDo_:                     RootNamespace-namespace hierarchy.
* amountToTranslateWithin_:              Rectangle-rectangle functions.
* and_ <1>:                              Boolean-basic.
* and_ <2>:                              True-basic.
* and_:                                  False-basic.
* anyMask_:                              Integer-bit operators.
* anyOne <1>:                            Collection-enumerating the elements of a collection.
* anyOne:                                SequenceableCollection-enumerating.
* anySatisfy_:                           Collection-enumerating the elements of a collection.
* 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>:                            Number-misc math.
* arcTan <2>:                            Float-built ins.
* arcTan:                                Point-point functions.
* area:                                  Rectangle-rectangle functions.
* areasOutside_:                         Rectangle-rectangle functions.
* argument <1>:                          Signal-accessing.
* argument:                              Message-accessing.
* argumentCount <1>:                     BlockClosure-accessing.
* argumentCount:                         Signal-accessing.
* arguments <1>:                         Message-accessing.
* arguments <2>:                         SystemDictionary-miscellaneous.
* arguments:                             Signal-accessing.
* arguments_:                            Message-accessing.
* arithmeticError_:                      Number-error raising.
* arrayType_:                            CType-accessing.
* article <1>:                           Behavior-support for lightweight classes.
* article:                               Class-printing.
* asArray <1>:                           Collection-converting.
* asArray:                               WeakArray-conversion.
* asBag:                                 Collection-converting.
* asByteArray <1>:                       String-converting.
* asByteArray <2>:                       Collection-converting.
* asByteArray:                           CharacterArray-converting.
* asCBooleanValue <1>:                   False-C hacks.
* asCBooleanValue <2>:                   Boolean-C hacks.
* asCBooleanValue:                       True-C hacks.
* asCData_ <1>:                          String-built ins.
* asCData_:                              ByteArray-built ins.
* asCharacter:                           Integer-converting.
* asciiValue:                            Character-built ins.
* asciiValue_:                           Character class-built ins.
* asClass <1>:                           Behavior-support for lightweight classes.
* asClass <2>:                           Metaclass-testing functionality.
* asClass <3>:                           Class-testing functionality.
* asClass:                               ClassDescription-conversion.
* asClassPoolKey:                        CharacterArray-converting.
* asDate:                                DateTime-splitting in dates & times.
* asExactFraction:                       Float-coercing.
* asFloat <1>:                           Float-coercing.
* asFloat:                               Number-converting.
* asFloatD <1>:                          SmallInteger-built ins.
* asFloatD <2>:                          ScaledDecimal-coercion.
* asFloatD <3>:                          FloatE-built ins.
* asFloatD <4>:                          FloatD-coercing.
* asFloatD <5>:                          Fraction-converting.
* asFloatD <6>:                          LargePositiveInteger-converting.
* asFloatD <7>:                          LargeNegativeInteger-converting.
* asFloatD <8>:                          Number-converting.
* asFloatD:                              FloatQ-built ins.
* asFloatE <1>:                          FloatD-built ins.
* asFloatE <2>:                          LargeNegativeInteger-converting.
* asFloatE <3>:                          ScaledDecimal-coercion.
* asFloatE <4>:                          FloatQ-built ins.
* asFloatE <5>:                          FloatE-coercing.
* asFloatE <6>:                          Fraction-converting.
* asFloatE <7>:                          SmallInteger-built ins.
* asFloatE <8>:                          Number-converting.
* asFloatE:                              LargePositiveInteger-converting.
* asFloatQ <1>:                          ScaledDecimal-coercion.
* asFloatQ <2>:                          FloatQ-coercing.
* asFloatQ <3>:                          Fraction-converting.
* asFloatQ <4>:                          FloatE-built ins.
* asFloatQ <5>:                          LargeNegativeInteger-converting.
* asFloatQ <6>:                          Number-converting.
* asFloatQ <7>:                          SmallInteger-built ins.
* asFloatQ <8>:                          LargePositiveInteger-converting.
* asFloatQ:                              FloatD-built ins.
* asFraction <1>:                        Integer-converting.
* asFraction <2>:                        Fraction-converting.
* asFraction <3>:                        ScaledDecimal-coercion.
* asFraction:                            Float-coercing.
* asGlobalKey:                           CharacterArray-converting.
* asInteger <1>:                         CharacterArray-converting.
* asInteger <2>:                         Character-built ins.
* asInteger:                             Number-truncation and round off.
* asLocal:                               DateTime-time zones.
* asLowercase <1>:                       CharacterArray-converting.
* asLowercase:                           Character-Coercion methods.
* asMetaclass:                           ClassDescription-conversion.
* asNumber:                              CharacterArray-converting.
* asObject <1>:                          LargeInteger-disabled.
* asObject:                              SmallInteger-built ins.
* asObjectNoFail <1>:                    LargeInteger-disabled.
* asObjectNoFail:                        SmallInteger-built ins.
* asOop:                                 Object-built ins.
* asOrderedCollection:                   Collection-converting.
* asPoint <1>:                           Number-point creation.
* asPoint:                               Point-converting.
* asPoolKey:                             CharacterArray-converting.
* asRectangle <1>:                       Point-converting.
* asRectangle:                           Number-converting.
* asRunArray:                            Collection-converting.
* asScaledDecimal_ <1>:                  Integer-converting.
* asScaledDecimal_:                      Number-converting.
* asScaledDecimal_scale_:                Number-converting.
* asSeconds <1>:                         DateTime-computations.
* asSeconds <2>:                         Time-accessing (non ANSI & for Durations).
* asSeconds:                             Date-date computations.
* asSet <1>:                             Bag-enumerating the elements of a collection.
* asSet:                                 Collection-converting.
* associationAt_:                        Dictionary-accessing.
* associationAt_ifAbsent_ <1>:           Namespace-overrides for superspaces.
* associationAt_ifAbsent_ <2>:           LookupTable-accessing.
* associationAt_ifAbsent_:               Dictionary-accessing.
* associationsDo_ <1>:                   LookupTable-enumerating.
* associationsDo_ <2>:                   Dictionary-dictionary enumerating.
* associationsDo_:                       Namespace-overrides for superspaces.
* asSortedCollection:                    Collection-converting.
* asSortedCollection_:                   Collection-converting.
* asString <1>:                          Symbol-converting.
* asString <2>:                          String-converting.
* asString <3>:                          Character-Coercion methods.
* asString <4>:                          ByteArray-converting.
* asString <5>:                          FileSegment-basic.
* asString:                              CharacterArray-converting.
* asSymbol <1>:                          Symbol-converting.
* asSymbol <2>:                          Character-Coercion methods.
* asSymbol <3>:                          CharacterArray-converting.
* asSymbol:                              String-converting.
* asTime:                                DateTime-splitting in dates & times.
* asUppercase <1>:                       CharacterArray-converting.
* asUppercase:                           Character-Coercion methods.
* asUTC:                                 DateTime-time zones.
* asValue:                               Object-copying.
* at_ <1>:                               LargeZeroInteger-accessing.
* at_ <2>:                               HashedCollection-accessing.
* at_ <3>:                               LinkedList-accessing.
* at_ <4>:                               SmallInteger-builtins.
* at_ <5>:                               Link-iteration.
* at_ <6>:                               RunArray-accessing.
* at_ <7>:                               LargeInteger-built-ins.
* at_ <8>:                               Object-built ins.
* at_ <9>:                               Dictionary-accessing.
* at_ <10>:                              CObject-pointer-like behavior.
* at_ <11>:                              MappedCollection-basic.
* at_ <12>:                              Memory class-accessing.
* at_ <13>:                              WeakArray-accessing.
* at_ <14>:                              Directory-accessing.
* at_ <15>:                              DateTime-splitting in dates & times.
* at_ <16>:                              String-built ins.
* at_ <17>:                              OrderedCollection-accessing.
* at_ <18>:                              Interval-basic.
* at_:                                   LargeArrayedCollection-accessing.
* at_ifAbsent_ <1>:                      SequenceableCollection-basic.
* at_ifAbsent_ <2>:                      WeakValueLookupTable-hacks.
* at_ifAbsent_ <3>:                      Dictionary-accessing.
* at_ifAbsent_ <4>:                      LookupTable-accessing.
* at_ifAbsent_:                          Namespace-overrides for superspaces.
* at_ifAbsentPut_:                       Dictionary-accessing.
* at_ifPresent_ <1>:                     Dictionary-accessing.
* at_ifPresent_ <2>:                     Namespace-overrides for superspaces.
* at_ifPresent_ <3>:                     LookupTable-accessing.
* at_ifPresent_:                         WeakValueLookupTable-hacks.
* at_put_ <1>:                           RootNamespace-forward declarations.
* at_put_ <2>:                           SmallInteger-builtins.
* at_put_ <3>:                           HashedCollection-accessing.
* at_put_ <4>:                           LargeInteger-built-ins.
* at_put_ <5>:                           String-built ins.
* at_put_ <6>:                           LookupTable-accessing.
* at_put_ <7>:                           SortedCollection-disabled.
* at_put_ <8>:                           MethodDictionary-adding.
* at_put_ <9>:                           CompiledCode-accessing.
* at_put_ <10>:                          Dictionary-accessing.
* at_put_ <11>:                          Link-iteration.
* at_put_ <12>:                          Interval-basic.
* at_put_ <13>:                          CObject-pointer-like behavior.
* at_put_ <14>:                          OrderedCollection-accessing.
* at_put_ <15>:                          MappedCollection-basic.
* at_put_ <16>:                          WeakArray-accessing.
* at_put_ <17>:                          LinkedList-accessing.
* at_put_ <18>:                          LargeArrayedCollection-accessing.
* at_put_ <19>:                          Object-built ins.
* at_put_ <20>:                          RunArray-accessing.
* at_put_:                               Memory class-accessing.
* at_put_type_:                          CObject-C data access.
* at_type_:                              CObject-C data access.
* atAll_put_ <1>:                        SequenceableCollection-basic.
* atAll_put_:                            WeakArray-accessing.
* atAllPut_ <1>:                         WeakArray-accessing.
* atAllPut_:                             SequenceableCollection-basic.
* atEnd <1>:                             Stream-testing.
* atEnd <2>:                             PositionableStream-testing.
* atEnd <3>:                             Random-basic.
* atEnd <4>:                             TokenStream-basic.
* atEnd <5>:                             FileDescriptor-testing.
* atEnd <6>:                             FileStream-testing.
* atEnd:                                 ObjectDumper-stream interface.
* backspace:                             Character class-constants.
* backtrace <1>:                         ContextPart class-exception handling.
* backtrace <2>:                         SystemDictionary-miscellaneous.
* backtrace:                             ContextPart-printing.
* backtraceOn_ <1>:                      ContextPart-printing.
* backtraceOn_:                          ContextPart class-exception handling.
* badReturnError:                        Object-exception handling.
* basicAt_ <1>:                          String-built ins.
* basicAt_ <2>:                          SmallInteger-builtins.
* basicAt_ <3>:                          Object-built ins.
* basicAt_:                              CharacterArray-basic.
* basicAt_put_ <1>:                      Object-built ins.
* basicAt_put_ <2>:                      SmallInteger-builtins.
* basicAt_put_ <3>:                      String-built ins.
* 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>:                      Collection-enumerating the elements of a collection.
* beConsistent:                          SortedCollection-enumerating.
* before_:                               SequenceableCollection-basic.
* bell:                                  Character class-constants.
* between_and_ <1>:                      Magnitude-misc methods.
* between_and_ <2>:                      Random-basic.
* between_and_:                          Random class-shortcuts.
* bigEndian:                             Memory class-accessing.
* bigObjectThreshold:                    ObjectMemory class-builtins.
* bigObjectThreshold_:                   ObjectMemory class-builtins.
* binaryRepresentationObject <1>:        CompiledBlock-saving and loading.
* binaryRepresentationObject <2>:        CompiledMethod-saving and loading.
* binaryRepresentationObject:            Object-saving and loading.
* binaryRepresentationVersion:           Class-saving and loading.
* 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>:                           LargeInteger-bit operations.
* bitAnd_:                               SmallInteger-built ins.
* 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>:                           LargeInteger-bit operations.
* bitXor_:                               SmallInteger-built ins.
* 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.
* breakAtLine_:                          CompiledCode-debugging.
* breakpoint_return_:                    Object-debugging.
* breakpointAt_:                         CompiledCode-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.
* browseHierarchy:                       Browser class-browsing.
* browseMethods_forClass_inBuffer_:      Browser class-browsing.
* bufferSize:                            FileStream-buffering.
* bufferSize_:                           FileStream-buffering.
* 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.
* bytesRightShift_big_:                  LargePositiveInteger-helper byte-level methods.
* bytesRightShift_n_:                    LargePositiveInteger-helper byte-level methods.
* bytesTrailingZeros_:                   LargePositiveInteger-helper byte-level methods.
* caller:                                BlockContext-accessing.
* canLoad_:                              PackageLoader class-testing.
* canRead:                               FileDescriptor-accessing.
* canUnderstand_:                        Behavior-testing the method dictionary.
* canWrite:                              FileDescriptor-accessing.
* capacity <1>:                          Collection-testing collections.
* capacity:                              HashedCollection-testing collections.
* castTo_:                               CObject-conversion.
* categoriesFor_are_:                    Class-instance creation - alternative.
* category <1>:                          MethodInfo-accessing.
* category <2>:                          Class-accessing instances and variables.
* category:                              Metaclass-delegation.
* category_ <1>:                         MethodInfo-accessing.
* category_:                             Class-accessing instances and variables.
* ceiling <1>:                           Float-built ins.
* ceiling <2>:                           Fraction-coercing.
* ceiling <3>:                           ScaledDecimal-coercion.
* ceiling:                               Integer-converting.
* center:                                Rectangle-accessing.
* changeClassTo_:                        Object-built ins.
* changed:                               Object-change and update.
* changed_:                              Object-change and update.
* changePriorityOf_to_:                  ProcessorScheduler-basic.
* charAt_ <1>:                           Memory class-accessing.
* charAt_:                               ByteArray-more advanced 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.
* classAt_:                              RootNamespace-accessing.
* classAt_ifAbsent_:                     RootNamespace-accessing.
* classify_under_:                       ClassDescription-organization of messages and classes.
* classPool <1>:                         Class-accessing instances and variables.
* classPool <2>:                         Behavior-accessing instances and variables.
* classPool:                             Metaclass-delegation.
* classVariableString:                   ClassDescription-printing.
* classVarNames <1>:                     Behavior-accessing instances and variables.
* classVarNames <2>:                     Metaclass-delegation.
* classVarNames:                         Class-accessing instances and variables.
* clean:                                 FileStream-buffering.
* clearBit_:                             Integer-bit operators.
* clearGCFlag_:                          WeakArray-accessing.
* client:                                ContextPart-accessing.
* clockPrecision:                        DateTime class-information.
* close <1>:                             Stream-providing consistent protocols.
* close <2>:                             PositionableStream-accessing-reading.
* close:                                 FileDescriptor-basic.
* closeDir_:                             VFS RealFileHandler-C functions.
* closeTo_:                              Number-testing.
* cObjectType:                           CType-accessing.
* cObjectType_:                          CType class-C instance creation.
* cObjStoredType <1>:                    CScalar-accessing.
* cObjStoredType:                        CString-accessing.
* codePoint:                             Character-built ins.
* codePoint_:                            Character class-built ins.
* coerce_ <1>:                           Number class-converting.
* coerce_ <2>:                           FloatE-coercing.
* coerce_ <3>:                           Number-converting.
* coerce_ <4>:                           Fraction-coercing.
* coerce_ <5>:                           Fraction class-converting.
* coerce_ <6>:                           FloatQ-coercing.
* coerce_ <7>:                           FloatE class-converting.
* coerce_ <8>:                           ScaledDecimal-coercion.
* coerce_ <9>:                           Integer class-converting.
* coerce_ <10>:                          FloatD class-converting.
* coerce_ <11>:                          FloatQ class-converting.
* coerce_ <12>:                          LargeInteger-coercion.
* coerce_ <13>:                          Integer-converting.
* coerce_:                               FloatD-coercing.
* collect_ <1>:                          Collection-enumerating the elements of a collection.
* collect_ <2>:                          ArrayedCollection-enumerating the elements of a collection.
* collect_ <3>:                          Dictionary-dictionary enumerating.
* collect_ <4>:                          MappedCollection-basic.
* collect_:                              Interval-basic.
* 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-creating method dictionary.
* compile_classified_:                   ClassDescription-compiling.
* compile_classified_ifError_:           ClassDescription-compiling.
* compile_classified_notifying_:         ClassDescription-compiling.
* compile_ifError_:                      Behavior-creating method dictionary.
* compile_notifying_:                    Behavior-creating method dictionary.
* compileAll:                            Behavior-creating method dictionary.
* compileAll_:                           Behavior-creating method dictionary.
* compileAllSubclasses:                  Behavior-creating method dictionary.
* compileAllSubclasses_:                 Behavior-creating 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.
* 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-enumerating the elements of a collection.
* contains_ <1>:                         Rectangle-testing.
* contains_:                             Collection-enumerating the elements of a collection.
* containsLiteral_:                      CompiledCode-testing accesses.
* containsPoint_:                        Rectangle-testing.
* contents <1>:                          Directory-enumerating.
* contents <2>:                          FileDescriptor-basic.
* contents <3>:                          WriteStream-accessing-writing.
* contents <4>:                          Stream-accessing-reading.
* contents <5>:                          PositionableStream-accessing-reading.
* contents <6>:                          File-file operations.
* contents:                              MappedCollection-basic.
* continue_:                             ContextPart-built ins.
* contractTo_:                           CharacterArray-string processing.
* convertFromVersion_withFixedVariables_indexedVariables_for_: Class-saving and loading.
* copy <1>:                              Object-copying.
* copy <2>:                              UndefinedObject-basic.
* copy <3>:                              Rectangle-copying.
* copy <4>:                              RootNamespace-copying.
* copy:                                  CoreException-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_:                            SortedCollection-copying.
* copyFrom_:                             SequenceableCollection-copying SequenceableCollections.
* copyFrom_to_ <1>:                      FileStream-basic.
* copyFrom_to_ <2>:                      SequenceableCollection-copying SequenceableCollections.
* copyFrom_to_ <3>:                      FileDescriptor-basic.
* copyFrom_to_ <4>:                      ArrayedCollection-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>:    SequenceableCollection-copying SequenceableCollections.
* copyReplaceFrom_to_withObject_:        ArrayedCollection-copying Collections.
* copyReplacing_withObject_:             Collection-copying Collections.
* copyWith_ <1>:                         ArrayedCollection-basic.
* copyWith_:                             Collection-copying Collections.
* copyWithout_ <1>:                      Collection-copying Collections.
* copyWithout_:                          ArrayedCollection-basic.
* coreException:                         Exception class-interoperability with TrappableEvents.
* corner:                                Rectangle-accessing.
* corner_ <1>:                           Point-converting.
* corner_:                               Rectangle-accessing.
* cos <1>:                               Number-misc math.
* cos:                                   Float-built ins.
* costOfNewIndex:                        LargeByteArray-overridden.
* cr <1>:                                TextCollector-accessing.
* cr <2>:                                Stream-character writing.
* cr:                                    Character class-constants.
* create:                                FileDescriptor class-instance creation.
* create_:                               Directory class-file operations.
* createDir_:                            VFS RealFileHandler-directory operations.
* createGetMethod_ <1>:                  ClassDescription-organization of messages and classes.
* createGetMethod_:                      Behavior-creating method dictionary.
* createGetMethod_default_ <1>:          Behavior-creating method dictionary.
* createGetMethod_default_:              ClassDescription-organization of messages and classes.
* createSetMethod_ <1>:                  Behavior-creating method dictionary.
* createSetMethod_:                      ClassDescription-organization of messages and classes.
* creationTime <1>:                      File-accessing.
* creationTime:                          VFS RealFileHandler-accessing.
* critical_:                             Semaphore-mutual exclusion.
* crTab:                                 Stream-character writing.
* current:                               Namespace 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>:                         Date-date computations.
* dayOfWeek:                             DateTime-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.
* decimalDigits <1>:                     FloatE class-characterization.
* decimalDigits <2>:                     FloatQ class-characterization.
* decimalDigits:                         FloatD class-characterization.
* declarationTrace:                      SystemDictionary-builtins.
* declarationTrace_:                     SystemDictionary-builtins.
* decompile_:                            Behavior-creating method dictionary.
* decr:                                  CObject-pointer-like behavior.
* decrBy_:                               CObject-pointer-like behavior.
* deepCopy <1>:                          LookupTable-copying.
* deepCopy <2>:                          RunArray-copying.
* deepCopy <3>:                          WeakArray-conversion.
* deepCopy <4>:                          BlockClosure-overriding.
* deepCopy <5>:                          RootNamespace-copying.
* deepCopy <6>:                          ContextPart-copying.
* deepCopy <7>:                          HashedCollection-copying.
* deepCopy <8>:                          UndefinedObject-basic.
* deepCopy <9>:                          Boolean-overriding.
* deepCopy <10>:                         Object-copying.
* deepCopy <11>:                         CompiledCode-copying.
* deepCopy <12>:                         Number-copying.
* deepCopy:                              Symbol-basic.
* defaultAction <1>:                     Notification-exception description.
* defaultAction <2>:                     Exception-exception description.
* defaultAction:                         Signal-exception handling.
* defaultElement <1>:                    LargeByteArray-overridden.
* defaultElement:                        LargeWordArray-overridden.
* defaultHandler:                        CoreException-accessing.
* defaultHandler_:                       CoreException-accessing.
* defaultName <1>:                       SystemDictionary-printing.
* defaultName:                           RootNamespace-printing.
* defaultSortBlock:                      SortedCollection class-hacking.
* define_:                               RootNamespace-accessing.
* defineCFunc_as_:                       DLD class-C functions.
* defineCFunc_withSelectorArgs_forClass_returning_args_: Behavior class-C interface.
* defineCFunc_withSelectorArgs_returning_args_ <1>: ClassDescription-organization of messages and classes.
* defineCFunc_withSelectorArgs_returning_args_: Behavior-creating method dictionary.
* definedKeys:                           RootNamespace-overrides for superspaces.
* defineExternFunc_:                     DLD class-Dynamic Linking.
* definesKey_:                           RootNamespace-overrides for superspaces.
* degreesToRadians:                      Number-converting.
* denominator <1>:                       Integer-accessing.
* denominator:                           Fraction-accessing.
* denormalized:                          Float class-characterization.
* dependenciesAt_:                       SystemDictionary-special accessing.
* dependents:                            Object-dependents access.
* deref_:                                Memory class-accessing.
* description <1>:                       Halt-description.
* description <2>:                       Exception-exception description.
* description <3>:                       SystemExceptions EndOfStream-accessing.
* description <4>:                       SystemExceptions FileError-accessing.
* description <5>:                       SystemExceptions IndexOutOfRange-accessing.
* description <6>:                       SystemExceptions InvalidSize-accessing.
* description <7>:                       SystemExceptions InvalidValue-accessing.
* description <8>:                       SystemExceptions NoRunnableProcess-accessing.
* description <9>:                       SystemExceptions WrongClass-accessing.
* description <10>:                      ZeroDivide-description.
* description <11>:                      SystemExceptions NotFound-accessing.
* description <12>:                      SystemExceptions NotImplemented-accessing.
* description <13>:                      Warning-exception description.
* description <14>:                      SystemExceptions NotIndexable-accessing.
* description <15>:                      SystemExceptions NotYetImplemented-accessing.
* description <16>:                      SystemExceptions PrimitiveFailed-accessing.
* description <17>:                      SystemExceptions ProcessTerminated-accessing.
* description <18>:                      SystemExceptions ReadOnlyObject-accessing.
* description <19>:                      SystemExceptions ShouldNotImplement-accessing.
* description <20>:                      CoreException-accessing.
* description <21>:                      SystemExceptions SubclassResponsibility-accessing.
* description <22>:                      SystemExceptions UserInterrupt-accessing.
* description <23>:                      SystemExceptions VMError-accessing.
* description <24>:                      Signal-accessing.
* description <25>:                      SystemExceptions WrongArgumentCount-accessing.
* description <26>:                      ArithmeticError-description.
* description <27>:                      Error-exception description.
* description <28>:                      SystemExceptions AlreadyDefined-accessing.
* description <29>:                      Notification-exception description.
* description <30>:                      SystemExceptions ArgumentOutOfRange-accessing.
* description <31>:                      SystemExceptions BadReturn-accessing.
* description <32>:                      MessageNotUnderstood-description.
* description <33>:                      SystemExceptions CInterfaceError-accessing.
* description:                           SystemExceptions EmptyCollection-accessing.
* description_:                          CoreException-accessing.
* detect_:                               Collection-enumerating the elements of a collection.
* detect_ifNone_:                        Collection-enumerating the elements of a collection.
* digitAt_:                              LargeInteger-built-ins.
* digitAt_put_:                          LargeInteger-built-ins.
* digitLength:                           LargeInteger-built-ins.
* digitValue:                            Character-converting.
* digitValue_:                           Character class-Instance creation.
* directoryAt_:                          Directory-accessing.
* directoryFor_:                         PackageLoader class-accessing.
* disableProxyFor_:                      ObjectDumper class-establishing proxy classes.
* discardTranslation:                    CompiledCode-translation.
* display:                               Object-printing.
* display_:                              Stream-printing.
* displayNl:                             Object-printing.
* displayOn_ <1>:                        CharacterArray-printing.
* displayOn_ <2>:                        Object-printing.
* displayOn_ <3>:                        ScaledDecimal-printing.
* displayOn_ <4>:                        Symbol-storing.
* 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>:                               RunArray-enumerating.
* do_ <2>:                               Bag-enumerating the elements of a collection.
* do_ <3>:                               VFS RealFileHandler-enumerating.
* do_ <4>:                               Link-iteration.
* do_ <5>:                               Dictionary-dictionary enumerating.
* do_ <6>:                               HashedCollection-enumerating the elements of a collection.
* do_ <7>:                               WeakArray-accessing.
* do_ <8>:                               Namespace-overrides for superspaces.
* do_ <9>:                               Stream-enumerating.
* do_ <10>:                              Directory-enumerating.
* do_ <11>:                              MappedCollection-basic.
* do_ <12>:                              Interval-basic.
* do_ <13>:                              SequenceableCollection-enumerating.
* do_ <14>:                              LinkedList-enumerating.
* do_ <15>:                              Collection-enumerating the elements of a collection.
* do_:                                   SymLink-iteration.
* do_separatedBy_ <1>:                   Collection-enumerating the elements of a collection.
* do_separatedBy_:                       SequenceableCollection-enumerating.
* doesNotUnderstand_ <1>:                RootNamespace-accessing.
* doesNotUnderstand_ <2>:                Object-error raising.
* doesNotUnderstand_:                    Autoload-accessing.
* domain:                                MappedCollection-basic.
* dotProduct_:                           Point-point functions.
* doubleAt_ <1>:                         ByteArray-more advanced accessing.
* doubleAt_:                             Memory class-accessing.
* doubleAt_put_ <1>:                     ByteArray-more advanced accessing.
* doubleAt_put_:                         Memory class-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>:                                 FloatQ class-characterization.
* e:                                     FloatE class-characterization.
* edit_:                                 Behavior-creating method dictionary.
* elementType <1>:                       CStringCType-accessing.
* elementType <2>:                       CPtrCType-accessing.
* elementType:                           CAggregate-accessing.
* elementType_ <1>:                      CPtrCType class-instance creation.
* elementType_:                          CArrayCType class-instance creation.
* elementType_numberOfElements_:         CArrayCType class-instance creation.
* emacsFunction_on_:                     Browser class-browsing.
* emacsListFunction_on_:                 Browser class-browsing.
* emax <1>:                              FloatQ class-characterization.
* emax <2>:                              FloatE class-characterization.
* emax:                                  FloatD class-characterization.
* emin <1>:                              FloatE class-characterization.
* emin <2>:                              FloatD class-characterization.
* emin:                                  FloatQ class-characterization.
* emitInspectTo_for_:                    CCompound class-subclass creation.
* emptyStream:                           WriteStream-positioning.
* endEntry:                              TextCollector-accessing.
* ensure_:                               BlockClosure-unwind protection.
* ensureReadable:                        FileDescriptor-accessing.
* ensureWriteable:                       FileDescriptor-accessing.
* environment <1>:                       Class-accessing instances and variables.
* environment <2>:                       Behavior-support for lightweight classes.
* environment <3>:                       Metaclass-delegation.
* environment:                           ContextPart-accessing.
* environment_:                          Class-accessing instances and variables.
* eof:                                   Character class-constants.
* eot:                                   Character class-constants.
* epsilon:                               Float class-characterization.
* eqv_ <1>:                              True-basic.
* eqv_ <2>:                              Boolean-basic.
* eqv_:                                  False-basic.
* errno:                                 File class-C functions.
* error_:                                Object-error raising.
* esc:                                   Character class-constants.
* estimatedLog <1>:                      Float-coercing.
* estimatedLog <2>:                      Fraction-arithmetic.
* estimatedLog <3>:                      LargeInteger-arithmetic.
* estimatedLog <4>:                      Number-misc math.
* 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.
* 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>:                            VFS RealFileHandler-testing.
* exists:                                File-testing.
* exists_:                               File class-testing.
* exp <1>:                               Float-built ins.
* exp:                                   Number-misc math.
* expandBy_:                             Rectangle-rectangle functions.
* exponent <1>:                          FloatQ-built ins.
* exponent <2>:                          FloatE-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>:                           Point-converting.
* extent_:                               Rectangle-accessing.
* extractDependenciesFor_onError_:       PackageLoader class-loading.
* extractDirentName_:                    VFS RealFileHandler-C functions.
* 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.
* fileInsFor_:                           PackageLoader class-accessing.
* fileName <1>:                          CharacterArray-converting.
* fileName:                              FileSegment-basic.
* 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>:                          Stream-filing out.
* fileOut_:                              ClassDescription-filing.
* 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.
* filesFor_:                             PackageLoader class-accessing.
* filesMatching_do_:                     Directory-enumerating.
* fileSystems <1>:                       VFS VFSHandler class-initializing.
* fileSystems <2>:                       VFS DecodedFileHandler class-registering.
* fileSystems:                           VFS ExternalArchiveFileHandler class-registering.
* fileSystemsIn_:                        VFS ExternalArchiveFileHandler class-registering.
* fill:                                  FileStream-buffering.
* finalIP:                               BlockClosure-accessing.
* finalize <1>:                          VFS DecodedFileHandler-files.
* finalize <2>:                          Object-finalization.
* finalize <3>:                          FileDescriptor-basic.
* finalize:                              CObject-finalization.
* findFirst_:                            SequenceableCollection-enumerating.
* findKeyIndex_:                         Dictionary-awful ST-80 compatibility hacks.
* findLast_:                             SequenceableCollection-enumerating.
* findObjectIndex_:                      Set-awful ST-80 compatibility hacks.
* finishEmacsMessage:                    Browser class-browsing.
* 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.
* fixTemps:                              BlockClosure-accessing.
* flags <1>:                             CompiledMethod-accessing.
* flags <2>:                             CompiledBlock-accessing.
* flags:                                 CompiledCode-accessing.
* floatAt_ <1>:                          Memory class-accessing.
* floatAt_:                              ByteArray-more advanced 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>:                         Integer-Math methods.
* floorLog_:                             Number-misc math.
* flush <1>:                             FileStream-buffering.
* flush <2>:                             ObjectDumper-accessing.
* flush <3>:                             PackageLoader class-accessing.
* flush:                                 Stream-providing consistent protocols.
* 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>:                    FloatE class-characterization.
* fminNormalized <2>:                    FloatD class-characterization.
* fminNormalized:                        FloatQ 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.
* forceResume:                           Process-basic.
* fork:                                  BlockClosure-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>:                      FloatQ-built ins.
* fractionPart <2>:                      Number-truncation and round off.
* fractionPart <3>:                      FloatD-built ins.
* fractionPart <4>:                      ScaledDecimal-coercion.
* fractionPart:                          FloatE-built ins.
* 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>:          Duration class-instance creation (non ANSI).
* fromDays_seconds_offset_:              DateTime 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_:                           CharacterArray class-basic.
* fullName:                              File-file name management.
* fullNameAt_:                           Directory-accessing.
* fullNameFor_:                          File class-file name management.
* gcd_ <1>:                              Integer-Math methods.
* gcd_ <2>:                              LargeNegativeInteger-reverting to LargePositiveInteger.
* gcd_:                                  LargePositiveInteger-arithmetic.
* gcMessage:                             ObjectMemory class-builtins.
* gcMessage_:                            ObjectMemory class-builtins.
* generality <1>:                        FloatQ-coercing.
* generality <2>:                        LargeInteger-coercion.
* generality <3>:                        FloatE-coercing.
* generality <4>:                        SmallInteger-Coercion methods (heh heh heh).
* generality <5>:                        FloatD-coercing.
* generality <6>:                        ScaledDecimal-coercion.
* generality <7>:                        Fraction-coercing.
* generality:                            Number-converting.
* generateMakefileOnto_:                 FileStream class-file-in.
* getAllMethods:                         Behavior-browsing.
* getAllSelectors_inBuffer_:             Browser class-browsing.
* getArgc:                               SystemDictionary-C functions.
* getArgv_:                              SystemDictionary-C functions.
* getBlock_putBlock_:                    PluggableAdaptor class-creating instances.
* getDirectMethods:                      Behavior-browsing.
* getenv_:                               SystemDictionary-C functions.
* getIndirectMethods:                    Behavior-browsing.
* getMethods:                            Behavior-browsing.
* getMethodsFor_:                        Behavior-browsing.
* getTraceFlag_:                         SystemDictionary-builtins.
* goodness_ <1>:                         Exception class-comparison.
* goodness_ <2>:                         CoreException-enumerating.
* goodness_ <3>:                         ExceptionSet-enumerating.
* goodness_:                             TrappableEvent-enumerating.
* 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>:                          CoreException-enumerating.
* handles_ <2>:                          Exception class-comparison.
* handles_ <3>:                          ExceptionSet-enumerating.
* handles_:                              TrappableEvent-enumerating.
* hasBytecode_between_and_:              CompiledCode-testing accesses.
* hasFeatures_:                          SystemDictionary-special accessing.
* hash <1>:                              DateTime-testing.
* hash <2>:                              Association-testing.
* hash <3>:                              Bag-testing collections.
* hash <4>:                              Time-comparing.
* hash <5>:                              ByteArray-built ins.
* hash <6>:                              SystemDictionary-basic.
* hash <7>:                              Symbol-built ins.
* hash <8>:                              String-built ins.
* hash <9>:                              SequenceableCollection-testing.
* hash <10>:                             ScaledDecimal-comparing.
* hash <11>:                             RunArray-testing.
* hash <12>:                             Rectangle-testing.
* hash <13>:                             CompiledCode-basic.
* hash <14>:                             CompiledMethod-basic.
* hash <15>:                             Point-converting.
* hash <16>:                             Date-testing.
* hash <17>:                             Delay-comparing.
* hash <18>:                             Object-built ins.
* hash <19>:                             Dictionary-testing.
* hash <20>:                             Exception-comparison.
* hash <21>:                             MethodInfo-equality.
* hash <22>:                             LookupKey-testing.
* hash <23>:                             FileSegment-equality.
* hash <24>:                             LargeZeroInteger-accessing.
* hash <25>:                             Float-basic.
* hash <26>:                             LargeInteger-built-ins.
* hash <27>:                             LargeArraySubpart-comparing.
* hash <28>:                             LargeArrayedCollection-basic.
* hash <29>:                             Interval-testing.
* hash <30>:                             Integer-Misc math operators.
* hash <31>:                             HashedCollection-testing collections.
* hash:                                  Fraction-comparing.
* hasInterned_ifTrue_:                   Symbol class-symbol table.
* hasMethodReturn:                       BlockClosure-testing.
* hasMethods:                            Behavior-testing the method dictionary.
* hasProxyFor_:                          ObjectDumper class-establishing proxy classes.
* hasValue:                              Promise-accessing.
* height:                                Rectangle-accessing.
* height_:                               Rectangle-accessing.
* hereAt_:                               RootNamespace-overrides for superspaces.
* hereAt_ifAbsent_:                      RootNamespace-overrides for superspaces.
* high:                                  SystemExceptions ArgumentOutOfRange-accessing.
* high_:                                 SystemExceptions ArgumentOutOfRange-accessing.
* highBit <1>:                           LargeNegativeInteger-reverting to LargePositiveInteger.
* highBit <2>:                           SmallInteger-bit arithmetic.
* highBit <3>:                           LargePositiveInteger-arithmetic.
* highBit:                               Integer-bit operators.
* highestPriority:                       ProcessorScheduler-priorities.
* highIOPriority:                        ProcessorScheduler-priorities.
* home <1>:                              ContextPart-accessing.
* home <2>:                              BlockContext-accessing.
* home <3>:                              MethodContext-accessing.
* home:                                  Directory class-reading system defaults.
* hour <1>:                              Time-accessing (ANSI for DateAndTimes).
* hour:                                  DateTime-computations.
* hour12 <1>:                            Time-accessing (ANSI for DateAndTimes).
* hour12:                                DateTime-computations.
* hour24 <1>:                            Time-accessing (ANSI for DateAndTimes).
* hour24:                                DateTime-computations.
* hours:                                 Time-accessing (non ANSI & for Durations).
* hours_:                                Time class-instance creation.
* hours_minutes_seconds_:                Time class-instance creation.
* identityHash <1>:                      RootNamespace-basic & copying.
* identityHash:                          Object-built ins.
* identityIncludes_ <1>:                 Collection-testing collections.
* identityIncludes_ <2>:                 SequenceableCollection-basic.
* 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>:                          False-basic.
* ifFalse_ <2>:                          True-basic.
* ifFalse_:                              Boolean-basic.
* ifFalse_ifTrue_ <1>:                   Boolean-basic.
* ifFalse_ifTrue_ <2>:                   False-basic.
* ifFalse_ifTrue_:                       True-basic.
* ifNil_ <1>:                            Object-testing functionality.
* ifNil_:                                UndefinedObject-testing.
* ifNil_ifNotNil_ <1>:                   UndefinedObject-testing.
* ifNil_ifNotNil_:                       Object-testing functionality.
* 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_:                          RootNamespace-accessing.
* includes_ <1>:                         SortedCollection-searching.
* includes_ <2>:                         Directory-accessing.
* includes_ <3>:                         Dictionary-dictionary testing.
* includes_ <4>:                         HashedCollection-testing collections.
* includes_ <5>:                         Collection-testing collections.
* includes_ <6>:                         Bag-testing collections.
* includes_:                             SequenceableCollection-basic.
* includesAssociation_:                  Dictionary-dictionary testing.
* includesClassNamed_:                   RootNamespace-namespace hierarchy.
* includesGlobalNamed_:                  RootNamespace-namespace hierarchy.
* includesKey_ <1>:                      Dictionary-dictionary testing.
* includesKey_ <2>:                      Namespace-overrides for superspaces.
* includesKey_:                          WeakValueLookupTable-hacks.
* includesSelector_:                     Behavior-testing the method dictionary.
* incr:                                  CObject-pointer-like behavior.
* incrBy_:                               CObject-pointer-like behavior.
* 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>:      RunArray-searching.
* indexOf_startingAt_ifAbsent_:          SortedCollection-searching.
* indexOfMonth_:                         Date class-basic.
* indexOfSubCollection_:                 SequenceableCollection-basic.
* indexOfSubCollection_ifAbsent_:        SequenceableCollection-basic.
* indexOfSubCollection_startingAt_:      SequenceableCollection-basic.
* indexOfSubCollection_startingAt_ifAbsent_: SequenceableCollection-basic.
* infinity <1>:                          FloatQ class-characterization.
* infinity <2>:                          FloatD class-characterization.
* infinity:                              FloatE class-characterization.
* inheritedKeys <1>:                     RootNamespace-overrides for superspaces.
* inheritedKeys:                         Namespace-accessing.
* inheritsFrom_ <1>:                     RootNamespace-namespace hierarchy.
* inheritsFrom_:                         Behavior-testing the class hierarchy.
* initDayNameDict:                       Date class-basic.
* initialIP <1>:                         ContextPart-accessing.
* initialIP:                             BlockClosure-accessing.
* initialize <1>:                        DLD class-Dynamic Linking.
* initialize <2>:                        Exception class-initialization.
* initialize <3>:                        FileStream class-file-in.
* initialize <4>:                        VFS VFSHandler class-initializing.
* initialize <5>:                        DateTime class-information.
* initialize <6>:                        Duration class-instance creation.
* initialize <7>:                        Browser class-browsing.
* initialize <8>:                        Class-accessing instances and variables.
* initialize <9>:                        FileDescriptor class-initialization.
* initialize <10>:                       Delay class-initialization.
* initialize <11>:                       VFS DecodedFileHandler class-registering.
* initialize <12>:                       Promise-initializing.
* initialize <13>:                       Date class-basic.
* initialize <14>:                       ObjectMemory class-initialization.
* initialize <15>:                       FileDescriptor-initialize-release.
* initialize <16>:                       Fraction class-instance creation.
* initialize <17>:                       CCompound class-subclass creation.
* initialize <18>:                       VFS RealFileHandler class-initialization.
* initialize <19>:                       ScaledDecimal class-constants.
* initialize <20>:                       Time class-initialization.
* initialize <21>:                       ValueHolder-initializing.
* initialize:                            Character class-initializing lookup tables.
* initMonthNameDict:                     Date class-basic.
* inject_into_:                          Collection-enumerating the elements of a collection.
* insetBy_:                              Rectangle-rectangle functions.
* insetOriginBy_corner_:                 Rectangle-rectangle functions.
* inspect <1>:                           SequenceableCollection-testing.
* inspect <2>:                           CompiledCode-debugging.
* inspect <3>:                           CCompound-instance creation.
* inspect <4>:                           Dictionary-printing.
* inspect <5>:                           Collection-printing.
* inspect:                               Object-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>:                        Memory class-accessing.
* intAt_put_:                            ByteArray-more advanced accessing.
* integerPart <1>:                       Float-arithmetic.
* integerPart <2>:                       ScaledDecimal-coercion.
* integerPart <3>:                       Fraction-converting.
* 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>:                      File-testing.
* isAccessible:                          VFS RealFileHandler-testing.
* isAccessible_:                         File class-testing.
* isAlive_:                              WeakArray-accessing.
* isAlphaNumeric:                        Character-testing.
* isArray <1>:                           Array-testing.
* isArray:                               Object-testing functionality.
* isBehavior <1>:                        Object-testing functionality.
* isBehavior:                            Metaclass-testing functionality.
* isBinary:                              FileDescriptor-class type methods.
* isBits:                                Behavior-testing the form of the instances.
* isBitSet_:                             Integer-bit operators.
* isBlock <1>:                           BlockContext-accessing.
* isBlock <2>:                           MethodContext-accessing.
* isBlock:                               ContextPart-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.
* isDigit:                               Character-testing.
* isDirectory <1>:                       File-testing.
* isDirectory:                           VFS RealFileHandler-testing.
* isDisabled <1>:                        BlockContext-accessing.
* isDisabled <2>:                        ContextPart-accessing.
* isDisabled:                            MethodContext-accessing.
* isEmpty <1>:                           LinkedList-testing.
* isEmpty <2>:                           Collection-testing collections.
* isEmpty <3>:                           HashedCollection-testing collections.
* isEmpty <4>:                           SharedQueue-accessing.
* isEmpty <5>:                           PositionableStream-testing.
* isEmpty:                               FileDescriptor-overriding inherited methods.
* isEnvironment <1>:                     MethodContext-accessing.
* isEnvironment <2>:                     ContextPart-accessing.
* isEnvironment:                         BlockContext-accessing.
* isExecutable <1>:                      File-testing.
* isExecutable:                          VFS RealFileHandler-testing.
* isExecutable_:                         File class-testing.
* isExternalStream <1>:                  PositionableStream-class type methods.
* isExternalStream:                      FileDescriptor-class type methods.
* isFile:                                File-testing.
* isFinite <1>:                          Float-testing.
* isFinite:                              Number-testing.
* isFixed:                               Behavior-testing the form of the instances.
* isFloat <1>:                           Float-testing functionality.
* isFloat:                               Object-testing functionality.
* isFunction_:                           CFunctionDescriptor class-testing.
* isIdentity <1>:                        Boolean class-testing.
* isIdentity <2>:                        SmallInteger class-testing.
* isIdentity <3>:                        Character class-testing.
* isIdentity:                            Behavior-testing the form of the instances.
* isImmediate <1>:                       Boolean class-testing.
* isImmediate <2>:                       Character class-testing.
* isImmediate <3>:                       BlockClosure class-testing.
* isImmediate <4>:                       Number class-testing.
* isImmediate:                           Behavior-testing the form of the instances.
* isInfinite <1>:                        Number-testing.
* isInfinite:                            Float-testing.
* isInteger <1>:                         Integer-testing functionality.
* isInteger:                             Object-testing functionality.
* isKindOf_:                             Object-testing functionality.
* isLeapYear:                            Date-date computations.
* isLetter:                              Character-testing.
* isLowercase:                           Character-testing.
* isMemberOf_:                           Object-testing functionality.
* isMeta:                                Object-testing functionality.
* isMetaclass:                           Metaclass-testing functionality.
* isMetaClass:                           Object-testing functionality.
* isMetaclass:                           Object-testing functionality.
* isNamespace <1>:                       RootNamespace-testing.
* isNamespace:                           Object-testing functionality.
* isNaN <1>:                             Float-testing.
* isNaN:                                 Number-testing.
* isNested:                              Signal-exception handling.
* isNil <1>:                             Object-testing functionality.
* isNil:                                 UndefinedObject-testing.
* isNumber <1>:                          Object-testing functionality.
* isNumber:                              Number-testing.
* isNumeric:                             CharacterArray-converting.
* isOpen:                                FileDescriptor-accessing.
* isPipe:                                FileDescriptor-accessing.
* isPointers:                            Behavior-testing the form of the instances.
* isProcess:                             ContextPart-accessing.
* isPunctuation:                         Character-testing.
* isRational <1>:                        Number-testing.
* isRational <2>:                        Fraction-testing.
* isRational:                            Integer-testing functionality.
* isReadable <1>:                        File-testing.
* isReadable:                            VFS RealFileHandler-testing.
* isReadable_:                           File class-testing.
* isReadOnly:                            Object-built ins.
* isResumable <1>:                       Error-exception description.
* isResumable <2>:                       Signal-exception handling.
* isResumable <3>:                       CoreException-accessing.
* isResumable <4>:                       Halt-description.
* isResumable <5>:                       Exception-exception description.
* isResumable:                           Notification-exception description.
* isResumable_:                          CoreException-accessing.
* isSeparator:                           Character-testing.
* isSimpleSymbol:                        Symbol-testing.
* isSmall:                               LargePositiveInteger-primitive operations.
* isSmallInteger <1>:                    SmallInteger-testing functionality.
* isSmallInteger:                        Object-testing functionality.
* isSmalltalk <1>:                       RootNamespace-testing.
* isSmalltalk:                           Namespace-testing.
* isString <1>:                          Symbol-testing functionality.
* isString <2>:                          Object-testing functionality.
* isString:                              String-testing functionality.
* isSymbol <1>:                          Symbol-testing functionality.
* isSymbol:                              Object-testing functionality.
* isSymbolString_:                       Symbol class-symbol table.
* isText:                                FileDescriptor-class type methods.
* isTimeoutProgrammed:                   ProcessorScheduler-timed invocation.
* isUnwind <1>:                          ContextPart-accessing.
* isUnwind <2>:                          MethodContext-accessing.
* isUnwind:                              BlockContext-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>:                       File-testing.
* isWriteable:                           VFS RealFileHandler-testing.
* isWriteable_:                          File class-testing.
* jumpDestinationAt_:                    CompiledCode-testing accesses.
* kernel:                                Directory class-reading system defaults.
* key:                                   LookupKey-accessing.
* key_ <1>:                              LookupKey-accessing.
* key_:                                  LookupKey class-basic.
* key_value_ <1>:                        Association class-basic.
* key_value_:                            Association-accessing.
* keyAtValue_:                           Dictionary-accessing.
* keyAtValue_ifAbsent_:                  Dictionary-accessing.
* keys:                                  Dictionary-accessing.
* keysAndValuesDo_ <1>:                  LookupTable-enumerating.
* keysAndValuesDo_ <2>:                  Namespace-overrides for superspaces.
* keysAndValuesDo_ <3>:                  SequenceableCollection-enumerating.
* keysAndValuesDo_:                      Dictionary-dictionary enumerating.
* keysDo_ <1>:                           Namespace-overrides for superspaces.
* keysDo_:                               Dictionary-dictionary enumerating.
* kindOfSubclass:                        Behavior-testing the class hierarchy.
* largeNegated:                          LargeInteger-primitive operations.
* largest:                               SmallInteger class-getting limits.
* last <1>:                              RunArray-basic.
* last <2>:                              SortedCollection-basic.
* last <3>:                              LargeArraySubpart-accessing.
* last:                                  SequenceableCollection-basic.
* lastAccessTime <1>:                    File-accessing.
* lastAccessTime:                        VFS RealFileHandler-accessing.
* lastChangeTime <1>:                    File-accessing.
* lastChangeTime:                        VFS RealFileHandler-accessing.
* lastDayOfMonth:                        Date-date computations.
* lastIndex:                             LargeArraySubpart-accessing.
* lastModifyTime <1>:                    File-accessing.
* lastModifyTime:                        VFS RealFileHandler-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.
* 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>:                              FloatE class-characterization.
* ln10 <2>:                              FloatQ class-characterization.
* ln10:                                  Float class-characterization.
* load:                                  ObjectDumper-loading/dumping objects.
* loadClassNames:                        Browser class-browsing.
* loadFrom_ <1>:                         NullProxy class-instance creation.
* loadFrom_ <2>:                         DumperProxy class-accessing.
* loadFrom_ <3>:                         ObjectDumper class-shortcuts.
* loadFrom_:                             VersionableObjectProxy class-saving and restoring.
* localKernel:                           Directory class-reading system defaults.
* 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>:                       Memory class-accessing.
* longAt_put_:                           ByteArray-more advanced accessing.
* low:                                   SystemExceptions ArgumentOutOfRange-accessing.
* low_:                                  SystemExceptions ArgumentOutOfRange-accessing.
* lowerPriority:                         Process-basic.
* lowestPriority:                        ProcessorScheduler-priorities.
* lowIOPriority:                         ProcessorScheduler-priorities.
* 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>:                              Magnitude-misc methods.
* max_ <2>:                              Number-comparing.
* max_:                                  Point-comparing.
* merge_:                                Rectangle-rectangle functions.
* meridianAbbreviation:                  DateTime-computations.
* message <1>:                           MessageNotUnderstood-accessing.
* message:                               TextCollector-set up.
* message_ <1>:                          TextCollector-set up.
* message_:                              TextCollector class-accessing.
* messageText <1>:                       SystemExceptions InvalidValue-accessing.
* messageText <2>:                       SystemExceptions InvalidArgument-accessing.
* messageText <3>:                       SystemExceptions IndexOutOfRange-accessing.
* messageText <4>:                       SystemExceptions WrongClass-accessing.
* messageText <5>:                       Signal-accessing.
* messageText:                           SystemExceptions WrongMessageSent-accessing.
* messageText_:                          Signal-accessing.
* metaclassFor_:                         UndefinedObject-class creation.
* method <1>:                            CompiledBlock-accessing.
* method <2>:                            ContextPart-accessing.
* method:                                BlockClosure-accessing.
* methodCategory <1>:                    CompiledCode-basic.
* methodCategory <2>:                    CompiledMethod-basic.
* methodCategory:                        CompiledBlock-basic.
* methodCategory_ <1>:                   CompiledMethod-basic.
* methodCategory_ <2>:                   CompiledBlock-basic.
* methodCategory_:                       CompiledCode-basic.
* methodClass <1>:                       CompiledBlock-accessing.
* methodClass <2>:                       CompiledCode-accessing.
* methodClass <3>:                       MethodInfo-accessing.
* methodClass <4>:                       ContextPart-accessing.
* methodClass:                           CompiledMethod-accessing.
* methodClass_ <1>:                      CompiledCode-accessing.
* methodClass_ <2>:                      CompiledBlock-accessing.
* methodClass_ <3>:                      MethodInfo-accessing.
* methodClass_:                          CompiledMethod-accessing.
* methodDictionary:                      Behavior-browsing.
* methodDictionary_:                     Behavior-creating 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>:                  CompiledMethod-basic.
* methodSourceCode <2>:                  CompiledCode-basic.
* methodSourceCode:                      CompiledBlock-basic.
* methodSourceFile <1>:                  CompiledBlock-basic.
* methodSourceFile <2>:                  CompiledCode-basic.
* methodSourceFile:                      CompiledMethod-basic.
* methodSourcePos <1>:                   CompiledCode-basic.
* methodSourcePos <2>:                   CompiledMethod-basic.
* methodSourcePos:                       CompiledBlock-basic.
* methodSourceString <1>:                CompiledBlock-basic.
* methodSourceString <2>:                CompiledMethod-basic.
* methodSourceString:                    CompiledCode-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>:                              Point-comparing.
* min_ <2>:                              Number-comparing.
* min_:                                  Magnitude-misc methods.
* 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.
* modulesFor_:                           PackageLoader class-accessing.
* month:                                 Date-date computations.
* monthAbbreviation:                     Date-date computations.
* monthName:                             Date-date computations.
* moveBy_:                               Rectangle-transforming.
* moveTo_:                               Rectangle-transforming.
* multiBecome_:                          Array-mutating objects.
* multiply_:                             LargePositiveInteger-primitive operations.
* mustBeBoolean:                         Object-exception handling.
* name <1>:                              FileDescriptor-accessing.
* name <2>:                              File-accessing.
* name <3>:                              RootNamespace-printing.
* name <4>:                              Namespace-printing.
* name <5>:                              Metaclass-delegation.
* name <6>:                              SystemDictionary-printing.
* name <7>:                              CFunctionDescriptor-accessing.
* name <8>:                              Process-accessing.
* name <9>:                              Behavior-support for lightweight classes.
* name <10>:                             VFS VFSHandler-accessing.
* name:                                  Class-accessing instances and variables.
* name_ <1>:                             File class-instance creation.
* name_ <2>:                             VFS VFSHandler-accessing.
* name_ <3>:                             Process-accessing.
* name_:                                 VFS RealFileHandler-accessing.
* name_environment_subclassOf_instanceVariableNames_variable_words_pointers_classVariableNames_poolDictionaries_category_: Metaclass-basic.
* name_realFileName_:                    VFS DecodedFileHandler-files.
* nameAt_:                               Directory-accessing.
* nameIn_ <1>:                           Behavior-support for lightweight classes.
* nameIn_ <2>:                           Metaclass-printing.
* nameIn_ <3>:                           RootNamespace-printing.
* nameIn_ <4>:                           Namespace-printing.
* nameIn_ <5>:                           ClassDescription-printing.
* nameIn_:                               SystemDictionary-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>:                           Duration-arithmetics.
* negated <2>:                           LargeInteger-arithmetic.
* negated <3>:                           Number-misc math.
* negated <4>:                           Fraction-optimized cases.
* negated:                               Float-arithmetic.
* negative <1>:                          LargePositiveInteger-numeric testing.
* negative <2>:                          Duration-arithmetics.
* negative <3>:                          Number-testing.
* negative <4>:                          Float-testing.
* negative:                              LargeNegativeInteger-numeric testing.
* negativeInfinity <1>:                  FloatD class-characterization.
* negativeInfinity <2>:                  FloatQ class-characterization.
* negativeInfinity:                      FloatE class-characterization.
* new <1>:                               ExceptionSet class-instance creation.
* new <2>:                               ValueAdaptor class-creating instances.
* new <3>:                               LookupTable class-instance creation.
* new <4>:                               ValueHolder class-creating instances.
* new <5>:                               MappedCollection class-instance creation.
* new <6>:                               Time class-instance creation.
* new <7>:                               RunArray class-instance creation.
* new <8>:                               Dictionary class-instance creation.
* new <9>:                               Behavior-built ins.
* new <10>:                              Point class-instance creation.
* new <11>:                              CType-C instance creation.
* new <12>:                              Random class-instance creation.
* new <13>:                              SortedCollection class-instance creation.
* new <14>:                              RootNamespace class-instance creation.
* new <15>:                              CObject class-instance creation.
* new <16>:                              CoreException class-instance creation.
* new <17>:                              Rectangle class-instance creation.
* new <18>:                              TextCollector class-accessing.
* new <19>:                              ObjectDumper class-instance creation.
* new <20>:                              ProcessorScheduler class-instance creation.
* new <21>:                              Symbol class-instance creation.
* new <22>:                              Bag class-basic.
* new <23>:                              Namespace class-disabling instance creation.
* new <24>:                              SharedQueue class-instance creation.
* new <25>:                              NullValueHolder class-creating instances.
* new <26>:                              Exception class-instance creation.
* new <27>:                              HashedCollection class-instance creation.
* new <28>:                              Semaphore class-instance creation.
* new <29>:                              OrderedCollection class-instance creation.
* new <30>:                              ArrayedCollection class-instance creation.
* new <31>:                              CCompound class-instance creation.
* new:                                   ZeroDivide class-instance creation.
* new_ <1>:                              WeakSet class-instance creation.
* new_ <2>:                              SortedCollection class-instance creation.
* new_ <3>:                              RootNamespace class-instance creation.
* new_ <4>:                              Namespace class-disabling instance creation.
* new_ <5>:                              LargeArrayedCollection class-instance creation.
* new_ <6>:                              OrderedCollection class-instance creation.
* new_ <7>:                              Bag class-basic.
* new_ <8>:                              RunArray class-instance creation.
* new_ <9>:                              Behavior-built ins.
* new_ <10>:                             Symbol class-instance creation.
* new_ <11>:                             WeakKeyLookupTable class-instance creation.
* new_ <12>:                             HashedCollection class-instance creation.
* new_ <13>:                             CPtrCType-accessing.
* new_ <14>:                             CObject class-instance creation.
* new_:                                  WeakArray class-instance creation.
* new_withAll_:                          ArrayedCollection class-instance creation.
* newBuffer <1>:                         FileDescriptor-initialize-release.
* newBuffer:                             FileStream-buffering.
* 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.
* newGetMethods:                         Behavior-browsing.
* newInFixedSpace:                       Behavior-instance creation.
* newInFixedSpace_:                      Behavior-instance creation.
* 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:                            BlockClosure-multiple process.
* newProcessWith_:                       BlockClosure-multiple process.
* newStruct_declaration_:                CCompound class-subclass creation.
* next <1>:                              Stream-accessing-reading.
* next <2>:                              FileDescriptor-basic.
* next <3>:                              ObjectDumper-stream interface.
* next <4>:                              TokenStream-basic.
* next <5>:                              Random class-shortcuts.
* next <6>:                              Random-basic.
* next <7>:                              PositionableStream-accessing-reading.
* next <8>:                              SharedQueue-accessing.
* next <9>:                              FileStream-basic.
* next:                                  ByteStream-basic.
* next_ <1>:                             FileStream-overriding inherited methods.
* next_ <2>:                             FileDescriptor-overriding inherited methods.
* next_:                                 Stream-accessing-reading.
* next_put_ <1>:                         Stream-accessing-writing.
* next_put_:                             TextCollector-accessing.
* nextAvailable_:                        Stream-accessing-reading.
* nextByte <1>:                          FileDescriptor-basic.
* nextByte <2>:                          FileStream-basic.
* nextByte:                              ByteStream-basic.
* nextByteArray_ <1>:                    ByteStream-basic.
* nextByteArray_ <2>:                    FileDescriptor-overriding inherited methods.
* nextByteArray_:                        FileStream-overriding inherited methods.
* nextHunk <1>:                          FileStream-buffering.
* nextHunk:                              FileDescriptor-initialize-release.
* nextInstance:                          Object-built ins.
* nextLine:                              Stream-PositionableStream methods.
* nextLink:                              Link-basic.
* nextLink_ <1>:                         Link class-instance creation.
* nextLink_:                             Link-basic.
* nextLong:                              ByteStream-basic.
* nextMatchFor_:                         Stream-accessing-reading.
* nextPut_ <1>:                          SharedQueue-accessing.
* nextPut_ <2>:                          FileStream-basic.
* nextPut_ <3>:                          ObjectDumper-stream interface.
* nextPut_ <4>:                          TextCollector-accessing.
* nextPut_ <5>:                          Random-basic.
* nextPut_ <6>:                          ByteStream-basic.
* nextPut_ <7>:                          TokenStream-write methods.
* nextPut_ <8>:                          FileDescriptor-basic.
* nextPut_ <9>:                          WriteStream-accessing-writing.
* nextPut_:                              Stream-accessing-writing.
* nextPutAll_ <1>:                       FileStream-overriding inherited methods.
* nextPutAll_ <2>:                       Stream-accessing-writing.
* nextPutAll_ <3>:                       TextCollector-accessing.
* nextPutAll_ <4>:                       FileDescriptor-overriding inherited methods.
* nextPutAll_:                           ByteStream-basic.
* nextPutAllFlush_:                      FileStream-overriding inherited methods.
* nextPutByte_ <1>:                      ByteStream-basic.
* nextPutByte_ <2>:                      FileStream-basic.
* nextPutByte_:                          FileDescriptor-basic.
* nextPutByteArray_ <1>:                 ByteStream-basic.
* nextPutByteArray_ <2>:                 FileStream-basic.
* nextPutByteArray_:                     FileDescriptor-basic.
* nextPutLong_:                          ByteStream-basic.
* nextPutShort_:                         ByteStream-basic.
* nextShort:                             ByteStream-basic.
* nextSignedByte:                        ByteStream-basic.
* nextUlong:                             ByteStream-basic.
* nextUshort:                            ByteStream-basic.
* 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>:                               Boolean-basic.
* not <2>:                               False-basic.
* not:                                   True-basic.
* notEmpty <1>:                          LinkedList-testing.
* notEmpty:                              Collection-testing collections.
* notNil <1>:                            Object-testing functionality.
* notNil:                                UndefinedObject-testing.
* 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>:                           CompiledMethod-accessing.
* numArgs <3>:                           ContextPart-accessing.
* numArgs <4>:                           CompiledCode-accessing.
* numArgs <5>:                           Symbol-basic.
* numArgs:                               BlockClosure-accessing.
* numArgs_numTemps_bytecodes_depth_literals_ <1>: CompiledBlock class-instance creation.
* numArgs_numTemps_bytecodes_depth_literals_: BlockClosure class-instance creation.
* numberOfElements:                      CArrayCType-accessing.
* numerator <1>:                         Integer-accessing.
* numerator:                             Fraction-accessing.
* numerator_denominator_:                Fraction class-instance creation.
* numLiterals <1>:                       CompiledBlock-accessing.
* numLiterals:                           CompiledCode-accessing.
* numTemps <1>:                          CompiledBlock-accessing.
* numTemps <2>:                          CompiledMethod-accessing.
* numTemps <3>:                          ContextPart-accessing.
* numTemps <4>:                          BlockClosure-accessing.
* numTemps:                              CompiledCode-accessing.
* object <1>:                            DumperProxy-saving and restoring.
* object <2>:                            AlternativeObjectProxy-accessing.
* object <3>:                            PluggableProxy-saving and restoring.
* object:                                SingletonProxy-saving and restoring.
* object_:                               AlternativeObjectProxy-accessing.
* objectAt_:                             ByteArray-more advanced accessing.
* objectAt_put_:                         ByteArray-more advanced accessing.
* objectsAndRunLengthsDo_:               RunArray-enumerating.
* occurrencesOf_ <1>:                    Collection-testing collections.
* occurrencesOf_ <2>:                    Dictionary-dictionary testing.
* occurrencesOf_ <3>:                    SortedCollection-searching.
* occurrencesOf_ <4>:                    Bag-testing collections.
* occurrencesOf_:                        HashedCollection-testing collections.
* odd <1>:                               Integer-Math methods.
* odd:                                   Number-testing.
* offset:                                DateTime-time zones.
* offset_:                               DateTime-time zones.
* oldloadClassNames:                     Browser class-browsing.
* oldShowInstanceMethods_:               Browser class-browsing.
* oldShowMethods_for_:                   Browser class-browsing.
* on_ <1>:                               SingletonProxy class-instance creation.
* on_ <2>:                               PositionableStream class-instance creation.
* on_ <3>:                               DumperProxy class-instance creation.
* on_ <4>:                               WriteStream class-instance creation.
* on_ <5>:                               TokenStream class-instance creation.
* on_ <6>:                               FileDescriptor class-instance creation.
* on_ <7>:                               ReadWriteStream class-instance creation.
* on_ <8>:                               ObjectDumper class-instance creation.
* on_ <9>:                               AlternativeObjectProxy class-instance creation.
* on_ <10>:                              PluggableProxy class-accessing.
* on_:                                   ReadStream class-instance creation.
* on_aspect_:                            PluggableAdaptor class-creating instances.
* on_at_:                                Process class-basic.
* 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 RealFileHandler-file operations.
* open_ifFail_:                          File-file operations.
* open_mode_:                            FileDescriptor class-instance creation.
* open_mode_ifFail_ <1>:                 VFS RealFileHandler-file operations.
* open_mode_ifFail_:                     FileDescriptor class-instance creation.
* openDescriptor_:                       File-file operations.
* openDescriptor_ifFail_:                VFS RealFileHandler-file operations.
* openDir_:                              VFS RealFileHandler-C functions.
* openTemporaryFile_:                    FileDescriptor class-instance creation.
* or_ <1>:                               True-basic.
* or_ <2>:                               Boolean-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-accessing.
* origin_extent_:                        Rectangle class-instance creation.
* outer:                                 Signal-exception handling.
* outerContext <1>:                      BlockClosure-accessing.
* outerContext:                          BlockContext-accessing.
* outerContext_:                         BlockClosure-accessing.
* parent:                                CoreException-accessing.
* parentContext:                         ContextPart-accessing.
* parentContext_:                        ContextPart-accessing.
* pass:                                  Signal-exception handling.
* path:                                  File-file name management.
* pathFor_:                              File class-file name management.
* pathSeparator:                         Directory class-file name management.
* pathSeparatorString:                   Directory class-file name management.
* peek <1>:                              FileStream-basic.
* peek <2>:                              SharedQueue-accessing.
* peek <3>:                              PositionableStream-accessing-reading.
* peek:                                  FileDescriptor-basic.
* 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>:                                FloatE class-characterization.
* pi:                                    FloatQ class-characterization.
* popen_dir_:                            FileDescriptor class-instance creation.
* popen_dir_ifFail_:                     FileDescriptor class-instance creation.
* position <1>:                          FileDescriptor-basic.
* position <2>:                          FileStream-basic.
* position:                              PositionableStream-positioning.
* position_ <1>:                         FileStream-basic.
* position_ <2>:                         ReadWriteStream-positioning.
* position_ <3>:                         FileDescriptor-basic.
* position_:                             PositionableStream-positioning.
* positive <1>:                          Duration-arithmetics.
* positive <2>:                          LargePositiveInteger-numeric testing.
* positive <3>:                          LargeNegativeInteger-numeric testing.
* positive <4>:                          Number-testing.
* positive:                              Float-testing.
* positiveDifference_:                   Number-misc math.
* postCopy:                              Object-copying.
* postLoad <1>:                          Object-saving and loading.
* postLoad <2>:                          SortedCollection-saving and loading.
* postLoad <3>:                          WeakArray-loading.
* postLoad:                              HashedCollection-saving and loading.
* postStore <1>:                         Object-saving and loading.
* postStore:                             HashedCollection-saving and loading.
* precision <1>:                         FloatE class-characterization.
* precision <2>:                         FloatQ class-characterization.
* precision:                             FloatD class-characterization.
* prerequisitesFor_:                     PackageLoader class-accessing.
* preStore <1>:                          SortedCollection-saving and loading.
* preStore:                              Object-saving and loading.
* primaryInstance:                       Metaclass-accessing.
* primAt_:                               HashedCollection-builtins.
* primAt_put_:                           HashedCollection-builtins.
* primCreateDir_mode_:                   VFS RealFileHandler-C functions.
* primDefineExternFunc_:                 DLD class-Dynamic Linking.
* primDivide_:                           LargePositiveInteger-helper byte-level methods.
* primError_:                            Object-built ins.
* primHash:                              Float-built ins.
* primIsExecutable_:                     VFS RealFileHandler-C functions.
* primIsReadable_:                       VFS RealFileHandler-C functions.
* primIsWriteable_:                      VFS RealFileHandler-C functions.
* primitive <1>:                         CompiledMethod-accessing.
* primitive:                             CompiledCode-accessing.
* primitiveFailed:                       Object-built ins.
* primMillisecondClock:                  Time class-builtins.
* primNew_name_:                         RootNamespace class-instance creation.
* primObject:                            AlternativeObjectProxy-accessing.
* primRemoveDir_:                        VFS RealFileHandler-C functions.
* primRename_to_:                        VFS RealFileHandler-C functions.
* primReplaceFrom_to_with_startingAt_ <1>: LargeInteger-built-ins.
* primReplaceFrom_to_with_startingAt_ <2>: String-built ins.
* primReplaceFrom_to_with_startingAt_:   ByteArray-built ins.
* primSecondClock:                       Time class-builtins.
* primSize:                              HashedCollection-builtins.
* primUnlink_:                           VFS RealFileHandler-C functions.
* primWorking_:                          Directory class-C functions.
* print:                                 Object-printing.
* print_ <1>:                            TextCollector-printing.
* print_:                                Stream-printing.
* printHierarchy:                        Behavior-hierarchy browsing.
* printHierarchyEmacs:                   Behavior-hierarchy browsing.
* printNl:                               Object-printing.
* printOn_ <1>:                          Character-printing.
* printOn_ <2>:                          ScaledDecimal-printing.
* printOn_ <3>:                          Date-printing.
* printOn_ <4>:                          Object-printing.
* printOn_ <5>:                          Class-printing.
* printOn_ <6>:                          DateTime-printing.
* printOn_ <7>:                          CharacterArray-printing.
* printOn_ <8>:                          RootNamespace-printing.
* printOn_ <9>:                          Dictionary-printing.
* printOn_ <10>:                         DirectedMessage-basic.
* printOn_ <11>:                         CFunctionDescriptor-printing.
* printOn_ <12>:                         CObject-accessing.
* printOn_ <13>:                         Rectangle-printing.
* printOn_ <14>:                         Symbol-storing.
* printOn_ <15>:                         SymLink-printing.
* printOn_ <16>:                         Duration-arithmetics.
* printOn_ <17>:                         False-printing.
* printOn_ <18>:                         MethodContext-printing.
* printOn_ <19>:                         BlockContext-printing.
* printOn_ <20>:                         Metaclass-printing.
* printOn_ <21>:                         TextCollector-printing.
* printOn_ <22>:                         Collection-printing.
* printOn_ <23>:                         Message-basic.
* printOn_ <24>:                         Time-arithmetic.
* printOn_ <25>:                         FileDescriptor-printing.
* printOn_ <26>:                         CompiledBlock-printing.
* printOn_ <27>:                         True-printing.
* printOn_ <28>:                         LookupKey-printing.
* printOn_ <29>:                         UndefinedObject-printing.
* printOn_ <30>:                         ValueAdaptor-printing.
* printOn_ <31>:                         Point-printing.
* printOn_ <32>:                         Float-printing.
* printOn_ <33>:                         Interval-printing.
* printOn_ <34>:                         ProcessorScheduler-printing.
* printOn_ <35>:                         CompiledCode-printing.
* printOn_ <36>:                         Process-printing.
* printOn_ <37>:                         Integer-printing.
* printOn_ <38>:                         Bag-printing.
* printOn_ <39>:                         Association-printing.
* printOn_ <40>:                         Fraction-printing.
* printOn_:                              Array-printing.
* printOn_base_:                         Integer-printing.
* printOn_base_showRadix_:               Integer-printing.
* printStatistics:                       ObjectMemory class-builtins.
* printString:                           Object-printing.
* printString_:                          Integer-printing.
* 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.
* queueInterrupt_:                       Process-accessing.
* quit:                                  ObjectMemory class-builtins.
* quit_:                                 ObjectMemory class-builtins.
* quo_ <1>:                              SmallInteger-built ins.
* quo_ <2>:                              LargeInteger-arithmetic.
* quo_ <3>:                              LargeZeroInteger-arithmetic.
* quo_:                                  Number-arithmetic.
* radiansToDegrees:                      Number-converting.
* radix:                                 Float class-characterization.
* radix_:                                Integer-printing.
* raisedTo_ <1>:                         Float-built ins.
* raisedTo_:                             Number-misc math.
* raisedToInteger_ <1>:                  Fraction-optimized cases.
* raisedToInteger_:                      Number-misc math.
* 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 RealFileHandler-C functions.
* readFrom_ <1>:                         Number class-converting.
* readFrom_ <2>:                         Date class-instance creation (Blue Book).
* readFrom_ <3>:                         DateTime class-instance creation.
* readFrom_:                             Time class-instance creation.
* readStream <1>:                        File-file operations.
* readStream:                            SequenceableCollection-enumerating.
* readWrite:                             FileDescriptor class-instance creation.
* readWriteStream:                       SequenceableCollection-enumerating.
* realFileName <1>:                      VFS DecodedFileHandler-files.
* realFileName:                          VFS VFSHandler-accessing.
* rebuildTable:                          Symbol class-symbol table.
* receiver <1>:                          BlockClosure-accessing.
* receiver <2>:                          DirectedMessage-accessing.
* receiver <3>:                          MessageNotUnderstood-accessing.
* receiver:                              ContextPart-accessing.
* receiver_ <1>:                         DirectedMessage-accessing.
* receiver_:                             BlockClosure-accessing.
* reciprocal <1>:                        Number-arithmetic.
* reciprocal:                            Fraction-optimized cases.
* recompile_:                            Behavior-creating method dictionary.
* recompile_notifying_:                  Behavior-creating method dictionary.
* reconstructOriginalObject <1>:         DirectedMessage-saving and loading.
* reconstructOriginalObject:             Object-saving and loading.
* record_:                               FileStream class-file-in.
* refersTo_:                             CompiledCode-testing accesses.
* refresh <1>:                           File-accessing.
* refresh:                               VFS RealFileHandler-accessing.
* refreshDependencies:                   PackageLoader class-accessing.
* register_forClass_:                    VFS VFSHandler class-initializing.
* registerProxyClass_for_:               ObjectDumper class-establishing proxy classes.
* rehash <1>:                            LookupTable-rehashing.
* rehash <2>:                            Dictionary-rehashing.
* rehash <3>:                            WeakKeyLookupTable-rehashing.
* rehash <4>:                            WeakSet-rehashing.
* rehash <5>:                            HashedCollection-rehashing.
* rehash <6>:                            WeakValueLookupTable-rehashing.
* rehash:                                MethodDictionary-rehashing.
* reinvokeFor_:                          Message-basic.
* reject_ <1>:                           MappedCollection-basic.
* reject_ <2>:                           ArrayedCollection-enumerating the elements of a collection.
* reject_ <3>:                           Dictionary-dictionary enumerating.
* reject_:                               Collection-enumerating the elements of a collection.
* release <1>:                           VFS DecodedFileHandler-files.
* release <2>:                           Object-dependents access.
* release:                               UndefinedObject-dependents access.
* relocateFrom_to_:                      FileSegment class-installing.
* relocateFrom_to_map_:                  FileSegment-basic.
* relocateTo_:                           LargeArraySubpart-modifying.
* rem_ <1>:                              LargeInteger-arithmetic.
* rem_ <2>:                              LargeZeroInteger-arithmetic.
* rem_:                                  Number-arithmetic.
* remove <1>:                            File-file operations.
* remove:                                VFS RealFileHandler-file operations.
* remove_ <1>:                           Collection-Removing from a collection.
* remove_ <2>:                           Dictionary-dictionary removing.
* remove_:                               File class-file operations.
* remove_ifAbsent_ <1>:                  LinkedList-adding.
* remove_ifAbsent_ <2>:                  HashedCollection-Removing from a collection.
* remove_ifAbsent_ <3>:                  Collection-Removing from a collection.
* remove_ifAbsent_ <4>:                  Dictionary-dictionary removing.
* remove_ifAbsent_ <5>:                  OrderedCollection-removing.
* remove_ifAbsent_:                      Bag-Removing from a collection.
* removeAll_:                            Collection-Removing from a collection.
* removeAll_ifAbsent_:                   Collection-Removing from a collection.
* removeAllKeys_:                        Dictionary-dictionary removing.
* removeAllKeys_ifAbsent_:               Dictionary-dictionary removing.
* removeAssociation_ <1>:                MethodDictionary-removing.
* removeAssociation_:                    Dictionary-dictionary removing.
* removeAtIndex_ <1>:                    OrderedCollection-removing.
* removeAtIndex_:                        RunArray-removing.
* removeBreakpointAt_:                   CompiledCode-debugging.
* removeCategory_:                       ClassDescription-organization of messages and classes.
* removeClassVarName_ <1>:               Metaclass-delegation.
* removeClassVarName_:                   Class-accessing instances and variables.
* removeDependent_:                      Object-dependents access.
* removeFeature_:                        SystemDictionary-special accessing.
* removeFirst <1>:                       LinkedList-adding.
* removeFirst <2>:                       RunArray-removing.
* removeFirst:                           OrderedCollection-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>:                        SortedCollection-basic.
* removeLast <2>:                        LinkedList-adding.
* removeLast <3>:                        RunArray-removing.
* removeLast:                            OrderedCollection-removing.
* removeLast_:                           LargeArraySubpart-modifying.
* removeLastUnwindPoint:                 ContextPart class-exception handling.
* removeSelector_:                       Behavior-creating method dictionary.
* removeSelector_ifAbsent_:              Behavior-creating 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-built ins.
* rename_to_:                            File class-file operations.
* renameTo_ <1>:                         File-file operations.
* renameTo_:                             VFS RealFileHandler-file operations.
* repeat:                                BlockClosure-control structures.
* replaceAll_with_:                      SequenceableCollection-replacing items.
* replaceFrom_to_with_:                  SequenceableCollection-replacing items.
* replaceFrom_to_with_startingAt_ <1>:   ByteArray-built ins.
* replaceFrom_to_with_startingAt_ <2>:   SequenceableCollection-replacing items.
* 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.
* require_:                              FileStream class-file-in.
* reset <1>:                             PositionableStream-positioning.
* reset:                                 FileDescriptor-basic.
* resetStatistics:                       ObjectMemory class-builtins.
* resignalAs_:                           Signal-exception handling.
* respondsTo_:                           Object-testing functionality.
* resume <1>:                            Signal-exception handling.
* resume:                                Process-builtins.
* 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>:                   PositionableStream-accessing-reading.
* reverseContents <2>:                   FileDescriptor-overriding inherited methods.
* reverseContents <3>:                   ReadStream-accessing-reading.
* reverseContents:                       WriteStream-accessing-writing.
* reverseDo_:                            SequenceableCollection-enumerating.
* reverseStringBase_on_ <1>:             LargeZeroInteger-printing.
* reverseStringBase_on_:                 LargePositiveInteger-converting.
* rewindDir_:                            VFS RealFileHandler-C functions.
* right:                                 Rectangle-accessing.
* right_:                                Rectangle-accessing.
* rightCenter:                           Rectangle-accessing.
* rockBottomPriority:                    ProcessorScheduler-priorities.
* rounded <1>:                           Rectangle-truncation and round off.
* rounded <2>:                           Point-truncation and round off.
* rounded <3>:                           Integer-converting.
* rounded:                               Number-truncation and round off.
* roundTo_:                              Number-truncation and round off.
* sameAs_:                               CharacterArray-comparing.
* scalarIndex <1>:                       CObject class-conversion.
* scalarIndex <2>:                       CFloat-accessing.
* scalarIndex <3>:                       CFloat class-accessing.
* scalarIndex <4>:                       CChar class-accessing.
* scalarIndex <5>:                       CByte-accessing.
* scalarIndex <6>:                       CDouble-accessing.
* scalarIndex <7>:                       CByte class-conversion.
* scalarIndex <8>:                       CDouble class-accessing.
* scalarIndex <9>:                       CInt class-accessing.
* scalarIndex <10>:                      CInt-accessing.
* scalarIndex <11>:                      CShort class-accessing.
* scalarIndex <12>:                      CShort-accessing.
* scalarIndex <13>:                      CSmalltalk class-accessing.
* scalarIndex <14>:                      CSmalltalk-accessing.
* scalarIndex <15>:                      CChar-accessing.
* scalarIndex <16>:                      CUChar class-getting info.
* scalarIndex <17>:                      CUChar-accessing.
* scalarIndex <18>:                      CUInt class-accessing.
* scalarIndex <19>:                      CLong class-accessing.
* scalarIndex <20>:                      CUInt-accessing.
* scalarIndex <21>:                      CULong class-accessing.
* scalarIndex <22>:                      CLong-accessing.
* scalarIndex <23>:                      CULong-accessing.
* scalarIndex <24>:                      CUShort class-accessing.
* scalarIndex <25>:                      CUShort-accessing.
* scalarIndex:                           CObject-conversion.
* scaleBy_:                              Rectangle-transforming.
* scanBacktraceFor_do_:                  ContextPart-enumerating.
* scopeHas_ifTrue_:                      Behavior-testing the method dictionary.
* scramble:                              SmallInteger-builtins.
* second <1>:                            Time-accessing (ANSI for DateAndTimes).
* second:                                DateTime-computations.
* secondClock:                           Time class-clocks.
* seconds:                               Time-accessing (non ANSI & for Durations).
* seconds_:                              Time class-instance creation.
* seed_:                                 Random class-instance creation.
* select_ <1>:                           Collection-enumerating the elements of a collection.
* select_ <2>:                           MappedCollection-basic.
* select_ <3>:                           ArrayedCollection-enumerating the elements of a collection.
* select_:                               Dictionary-dictionary enumerating.
* selector <1>:                          CompiledBlock-accessing.
* selector <2>:                          MethodInfo-accessing.
* selector <3>:                          Message-accessing.
* selector <4>:                          SystemExceptions WrongMessageSent-accessing.
* selector <5>:                          ContextPart-accessing.
* selector <6>:                          CompiledMethod-accessing.
* selector:                              CompiledCode-accessing.
* selector_ <1>:                         Message-accessing.
* selector_ <2>:                         CompiledBlock-accessing.
* selector_ <3>:                         CompiledCode-accessing.
* selector_ <4>:                         MethodInfo-accessing.
* selector_ <5>:                         CompiledMethod-accessing.
* selector_:                             SystemExceptions WrongMessageSent-accessing.
* selector_arguments_ <1>:               Message class-creating instances.
* selector_arguments_:                   DirectedMessage class-creating instances.
* selector_arguments_receiver_:          DirectedMessage class-creating instances.
* selectorAt_:                           Behavior-accessing the methodDictionary.
* selectors:                             Behavior-accessing the methodDictionary.
* selectorsForEmacs:                     Browser class-browsing.
* selectSubclasses_:                     Behavior-enumerating.
* selectSubspaces_:                      RootNamespace-namespace hierarchy.
* selectSuperclasses_:                   Behavior-enumerating.
* selectSuperspaces_:                    RootNamespace-namespace hierarchy.
* send:                                  DirectedMessage-basic.
* sender:                                MethodContext-accessing.
* sendTo_:                               Message-basic.
* set_to_:                               RootNamespace-overrides for superspaces.
* set_to_ifAbsent_ <1>:                  RootNamespace-overrides for superspaces.
* set_to_ifAbsent_:                      Namespace-overrides for superspaces.
* setBit_:                               Integer-bit operators.
* setToEnd <1>:                          PositionableStream-positioning.
* setToEnd:                              FileDescriptor-overriding inherited methods.
* setTraceFlag_to_:                      SystemDictionary-builtins.
* shallowCopy <1>:                       RootNamespace-copying.
* shallowCopy <2>:                       BlockClosure-overriding.
* shallowCopy <3>:                       UndefinedObject-basic.
* shallowCopy <4>:                       HashedCollection-copying.
* shallowCopy <5>:                       Object-built ins.
* shallowCopy <6>:                       Number-copying.
* shallowCopy <7>:                       Symbol-basic.
* shallowCopy <8>:                       WeakArray-conversion.
* shallowCopy <9>:                       Boolean-overriding.
* shallowCopy:                           RunArray-copying.
* sharedPools <1>:                       Behavior-accessing instances and variables.
* sharedPools <2>:                       Metaclass-delegation.
* 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.
* showAllMethods_inBuffer_:              Browser class-browsing.
* showCr_:                               TextCollector-accessing.
* showDirectMethods_inBuffer_:           Browser class-browsing.
* showIndirectMethods_inBuffer_:         Browser class-browsing.
* showMethods_for_:                      Browser class-browsing.
* showOnNewLine_:                        TextCollector-accessing.
* siblings <1>:                          RootNamespace-namespace hierarchy.
* siblings:                              Namespace-namespace hierarchy.
* siblingsDo_ <1>:                       RootNamespace-namespace hierarchy.
* siblingsDo_:                           Namespace-namespace hierarchy.
* sign <1>:                              Float-testing.
* sign <2>:                              Number-testing.
* sign <3>:                              LargeNegativeInteger-numeric testing.
* sign <4>:                              LargePositiveInteger-numeric testing.
* sign:                                  LargeZeroInteger-numeric testing.
* signal <1>:                            Semaphore-builtins.
* signal <2>:                            Exception class-instance creation.
* signal <3>:                            CoreException-exception handling.
* 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>:                          FloatD class-byte-order dependancies.
* signByte <3>:                          Float class-byte-order dependancies.
* signByte:                              FloatE class-byte-order dependancies.
* sin <1>:                               Number-misc math.
* sin:                                   Float-built ins.
* size <1>:                              LinkedList-testing.
* size <2>:                              WriteStream-accessing.
* size <3>:                              Link-iteration.
* size <4>:                              MappedCollection-basic.
* size <5>:                              String-built ins.
* size <6>:                              LargeInteger-built-ins.
* size <7>:                              ContextPart-accessing.
* size <8>:                              Interval-basic.
* size <9>:                              OrderedCollection-accessing.
* size <10>:                             FileStream-basic.
* size <11>:                             Bag-testing collections.
* size <12>:                             WeakArray-accessing.
* size <13>:                             ArrayedCollection-built ins.
* size <14>:                             Namespace-overrides for superspaces.
* size <15>:                             RunArray-basic.
* size <16>:                             ReadStream-accessing-reading.
* size <17>:                             HashedCollection-testing collections.
* size <18>:                             PositionableStream-positioning.
* size <19>:                             File-accessing.
* size <20>:                             LargeArrayedCollection-basic.
* size <21>:                             Object-built ins.
* size <22>:                             FileSegment-basic.
* size <23>:                             FileDescriptor-basic.
* size <24>:                             LargeZeroInteger-accessing.
* size <25>:                             VFS RealFileHandler-accessing.
* size:                                  Collection-testing collections.
* sizeof <1>:                            CInt class-accessing.
* sizeof <2>:                            CUChar class-getting info.
* sizeof <3>:                            CType-accessing.
* sizeof <4>:                            CUInt class-accessing.
* sizeof <5>:                            CLong class-accessing.
* sizeof <6>:                            CUInt-accessing.
* sizeof <7>:                            CSmalltalk-accessing.
* sizeof <8>:                            CULong class-accessing.
* sizeof <9>:                            CSmalltalk class-accessing.
* sizeof <10>:                           CLong-accessing.
* sizeof <11>:                           CShort-accessing.
* sizeof <12>:                           CShort class-accessing.
* sizeof <13>:                           CULong-accessing.
* sizeof <14>:                           CUShort class-accessing.
* sizeof <15>:                           CChar-accessing.
* sizeof <16>:                           CCompound class-subclass creation.
* sizeof <17>:                           CAggregate class-accessing.
* sizeof <18>:                           CInt-accessing.
* sizeof <19>:                           CPtr-accessing.
* sizeof <20>:                           CArray-accessing.
* sizeof <21>:                           CArrayCType-accessing.
* sizeof <22>:                           CUShort-accessing.
* sizeof <23>:                           CDouble class-accessing.
* sizeof <24>:                           CDouble-accessing.
* sizeof <25>:                           CChar class-accessing.
* sizeof <26>:                           CFloat class-accessing.
* sizeof <27>:                           CFloat-accessing.
* sizeof:                                CUChar-accessing.
* skip_ <1>:                             PositionableStream-positioning.
* skip_ <2>:                             ReadWriteStream-positioning.
* skip_ <3>:                             Stream-PositionableStream methods.
* skip_:                                 FileDescriptor-overriding inherited methods.
* skipSeparators:                        PositionableStream-positioning.
* skipTo_:                               Stream-PositionableStream methods.
* skipToAll_:                            Stream-PositionableStream methods.
* smallest:                              SmallInteger class-getting limits.
* 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.
* 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>:                           WeakArray-conversion.
* species <2>:                           Interval-basic.
* species <3>:                           PositionableStream-class type methods.
* species <4>:                           Stream-basic.
* species <5>:                           RootNamespace-testing.
* species <6>:                           Object-class type methods.
* species:                               Symbol-misc.
* 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>:                        CompiledCode-accessing.
* stackDepth <3>:                        CompiledMethod-accessing.
* stackDepth:                            CompiledBlock-accessing.
* startEmacsMessage:                     Browser class-browsing.
* startsWith_:                           CharacterArray-comparing.
* statOn_into_:                          VFS RealFileHandler-C functions.
* stderr:                                FileStream class-standard streams.
* stdin:                                 FileStream class-standard streams.
* stdout:                                FileStream class-standard streams.
* store:                                 Object-storing.
* store_ <1>:                            TextCollector-storing.
* store_:                                Stream-storing.
* storeNl:                               Object-storing.
* storeOn_ <1>:                          Namespace-printing.
* storeOn_ <2>:                          Point-storing.
* storeOn_ <3>:                          Fraction-printing.
* storeOn_ <4>:                          ArrayedCollection-storing.
* storeOn_ <5>:                          HashedCollection-storing.
* storeOn_ <6>:                          CScalarCType-storing.
* storeOn_ <7>:                          Association-storing.
* storeOn_ <8>:                          ProcessorScheduler-storing.
* storeOn_ <9>:                          Collection-storing.
* storeOn_ <10>:                         Bag-storing.
* storeOn_ <11>:                         CType-storing.
* storeOn_ <12>:                         Integer-storing.
* storeOn_ <13>:                         Rectangle-printing.
* storeOn_ <14>:                         Interval-storing.
* storeOn_ <15>:                         Float-storing.
* storeOn_ <16>:                         RootNamespace-printing.
* storeOn_ <17>:                         Object-storing.
* storeOn_ <18>:                         Class-printing.
* storeOn_ <19>:                         CompiledMethod-printing.
* storeOn_ <20>:                         Date-storing.
* storeOn_ <21>:                         ScaledDecimal-storing.
* storeOn_ <22>:                         CharacterArray-storing.
* storeOn_ <23>:                         DateTime-storing.
* storeOn_ <24>:                         UndefinedObject-storing.
* storeOn_ <25>:                         Character-storing.
* storeOn_ <26>:                         Dictionary-storing.
* storeOn_ <27>:                         LookupKey-storing.
* storeOn_ <28>:                         String-storing.
* storeOn_ <29>:                         LookupTable-storing.
* storeOn_ <30>:                         SystemDictionary-printing.
* storeOn_ <31>:                         TextCollector-storing.
* storeOn_ <32>:                         Boolean-storing.
* storeOn_:                              Metaclass-printing.
* storeOn_base_:                         Integer-printing.
* storeString:                           Object-storing.
* stream <1>:                            SystemExceptions EndOfStream-accessing.
* stream:                                ObjectDumper-accessing.
* stream_ <1>:                           SystemExceptions EndOfStream-accessing.
* stream_:                               ObjectDumper-accessing.
* streamContents_:                       SequenceableCollection class-instance creation.
* strictlyPositive <1>:                  Number-testing.
* strictlyPositive <2>:                  LargePositiveInteger-numeric testing.
* strictlyPositive <3>:                  Float-testing.
* strictlyPositive <4>:                  LargeZeroInteger-numeric testing.
* strictlyPositive:                      LargeNegativeInteger-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>: UndefinedObject-class creation - alternative.
* subclass_classInstanceVariableNames_instanceVariableNames_classVariableNames_poolDictionaries_: Class-instance creation - alternative.
* subclass_declaration_classVariableNames_poolDictionaries_category_: CCompound class-subclass creation.
* subclass_instanceVariableNames_classVariableNames_poolDictionaries_ <1>: Class-instance creation - alternative.
* subclass_instanceVariableNames_classVariableNames_poolDictionaries_: UndefinedObject-class 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:                             RootNamespace-namespace hierarchy.
* subspacesDo_:                          RootNamespace-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:                            RootNamespace-namespace hierarchy.
* superspace_:                           RootNamespace-namespace hierarchy.
* suspend:                               Process-basic.
* 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.
* terminate:                             Process-basic.
* terminateActive:                       ProcessorScheduler-basic.
* testMethods_for_:                      Browser class-browsing.
* timeSlice:                             ProcessorScheduler-basic.
* timeSlice_:                            ProcessorScheduler-basic.
* timesRepeat_:                          Integer-Other iterators.
* timesTwoPower_ <1>:                    FloatQ-built ins.
* timesTwoPower_ <2>:                    FloatD-built ins.
* timesTwoPower_:                        FloatE-built ins.
* timezone:                              Time class-builtins.
* timeZoneAbbreviation:                  DateTime-time zones.
* timezoneBias:                          Time class-builtins.
* timeZoneName:                          DateTime-time zones.
* timingPriority:                        ProcessorScheduler-priorities.
* to_:                                   Number-Intervals & iterators.
* to_by_:                                Number-Intervals & iterators.
* to_by_do_:                             Number-Intervals & iterators.
* to_do_:                                Number-Intervals & 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>:                          FileDescriptor-basic.
* truncate <2>:                          PositionableStream-truncating.
* truncate:                              FileStream-basic.
* truncated <1>:                         Number-truncation and round off.
* truncated <2>:                         FloatD-built ins.
* truncated <3>:                         Integer-converting.
* truncated <4>:                         Float-coercing.
* truncated <5>:                         FloatE-built ins.
* truncated <6>:                         ScaledDecimal-coercion.
* truncated <7>:                         Fraction-coercing.
* truncated:                             FloatQ-built ins.
* truncatedGrid_:                        Point-point functions.
* truncateTo_ <1>:                       Number-truncation and round off.
* truncateTo_:                           Point-truncation and round off.
* type <1>:                              CString class-instance creation.
* type <2>:                              CCompound class-instance creation.
* type <3>:                              CObject class-conversion.
* type <4>:                              CByte class-conversion.
* type <5>:                              CByte-accessing.
* type <6>:                              CObject-conversion.
* type:                                  CScalar class-instance creation.
* type_:                                 CObject-accessing.
* type_at_:                              Memory class-basic.
* type_at_put_:                          Memory class-basic.
* ucharAt_:                              ByteArray-more advanced accessing.
* ucharAt_put_ <1>:                      Memory class-accessing.
* ucharAt_put_:                          ByteArray-more advanced accessing.
* uintAt_:                               ByteArray-more advanced accessing.
* uintAt_put_ <1>:                       Memory class-accessing.
* uintAt_put_:                           ByteArray-more advanced accessing.
* ulongAt_:                              ByteArray-more advanced accessing.
* ulongAt_put_ <1>:                      Memory class-accessing.
* ulongAt_put_:                          ByteArray-more advanced accessing.
* unity <1>:                             LargeInteger-coercion.
* unity <2>:                             SmallInteger-Coercion methods (heh heh heh).
* unity <3>:                             Number-converting.
* unity <4>:                             FloatD-coercing.
* unity <5>:                             Fraction-coercing.
* unity <6>:                             FloatE-coercing.
* unity:                                 FloatQ-coercing.
* unpreemptedPriority:                   ProcessorScheduler-priorities.
* unsignedCharAt_ <1>:                   ByteArray-more advanced accessing.
* unsignedCharAt_:                       Memory class-accessing.
* unsignedCharAt_put_ <1>:               Memory class-accessing.
* unsignedCharAt_put_:                   ByteArray-more advanced accessing.
* unsignedIntAt_ <1>:                    ByteArray-more advanced accessing.
* unsignedIntAt_:                        Memory class-accessing.
* unsignedIntAt_put_ <1>:                Memory class-accessing.
* unsignedIntAt_put_:                    ByteArray-more advanced accessing.
* unsignedLongAt_ <1>:                   Memory class-accessing.
* unsignedLongAt_:                       ByteArray-more advanced accessing.
* unsignedLongAt_put_ <1>:               Memory class-accessing.
* unsignedLongAt_put_:                   ByteArray-more advanced accessing.
* unsignedShortAt_ <1>:                  Memory class-accessing.
* unsignedShortAt_:                      ByteArray-more advanced accessing.
* unsignedShortAt_put_ <1>:              Memory class-accessing.
* unsignedShortAt_put_:                  ByteArray-more advanced accessing.
* untilMilliseconds_:                    Delay class-instance creation.
* unwind:                                ContextPart class-exception handling.
* unwind_:                               ContextPart class-exception handling.
* update_ <1>:                           VFS VFSHandler class-initializing.
* update_ <2>:                           DLD class-Dynamic Linking.
* update_ <3>:                           FileDescriptor class-initialization.
* update_ <4>:                           ObjectMemory class-dependancy.
* update_ <5>:                           Object-change and update.
* update_:                               Time class-initialization.
* upTo_:                                 Stream-PositionableStream methods.
* upToAll_:                              Stream-PositionableStream methods.
* upToEnd:                               Stream-PositionableStream methods.
* userBackgroundPriority:                ProcessorScheduler-priorities.
* userInterrupt:                         Object-exception handling.
* userInterruptPriority:                 ProcessorScheduler-priorities.
* userSchedulingPriority:                ProcessorScheduler-priorities.
* ushortAt_:                             ByteArray-more advanced accessing.
* ushortAt_put_ <1>:                     ByteArray-more advanced accessing.
* ushortAt_put_:                         Memory class-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>:                         ContextPart-accessing.
* validSize:                             Object-debugging.
* value <1>:                             CScalar-accessing.
* value <2>:                             SystemExceptions InvalidValue-accessing.
* value <3>:                             BlockClosure-built ins.
* value <4>:                             NullValueHolder-accessing.
* value <5>:                             CBoolean-accessing.
* value <6>:                             CByte-accessing.
* value <7>:                             DirectedMessage-basic.
* value <8>:                             Character-built ins.
* value <9>:                             DelayedAdaptor-accessing.
* value <10>:                            ValueAdaptor-accessing.
* value <11>:                            ValueHolder-accessing.
* value <12>:                            PluggableAdaptor-accessing.
* value <13>:                            Promise-accessing.
* value <14>:                            CString-accessing.
* value <15>:                            Association-accessing.
* value:                                 CPtr-accessing.
* value_ <1>:                            DelayedAdaptor-accessing.
* value_ <2>:                            CString class-instance creation.
* value_ <3>:                            NullValueHolder-accessing.
* value_ <4>:                            Character class-built ins.
* value_ <5>:                            Association-accessing.
* value_ <6>:                            CScalar-accessing.
* value_ <7>:                            BlockClosure-built ins.
* value_ <8>:                            CScalar class-instance creation.
* value_ <9>:                            CPtr-accessing.
* value_ <10>:                           ValueAdaptor-accessing.
* value_ <11>:                           SystemExceptions InvalidValue-accessing.
* value_ <12>:                           CByte-accessing.
* value_ <13>:                           CBoolean-accessing.
* value_ <14>:                           Promise-accessing.
* value_ <15>:                           PluggableAdaptor-accessing.
* value_ <16>:                           CString-accessing.
* value_:                                ValueHolder-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:                                RootNamespace-overrides for superspaces.
* valueType <1>:                         CType-accessing.
* valueType:                             CScalarCType-accessing.
* valueWithArguments_:                   BlockClosure-built ins.
* 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>: Class-instance creation - alternative.
* variableSubclass_classInstanceVariableNames_instanceVariableNames_classVariableNames_poolDictionaries_: UndefinedObject-class creation - alternative.
* variableSubclass_instanceVariableNames_classVariableNames_poolDictionaries_ <1>: Class-instance creation - alternative.
* variableSubclass_instanceVariableNames_classVariableNames_poolDictionaries_: UndefinedObject-class creation - alternative.
* variableSubclass_instanceVariableNames_classVariableNames_poolDictionaries_category_ <1>: Class-instance creation.
* variableSubclass_instanceVariableNames_classVariableNames_poolDictionaries_category_: UndefinedObject-class creation.
* variableWordSubclass_classInstanceVariableNames_instanceVariableNames_classVariableNames_poolDictionaries_: UndefinedObject-class creation - alternative.
* variableWordSubclass_instanceVariableNames_classVariableNames_poolDictionaries_: UndefinedObject-class creation - alternative.
* variableWordSubclass_instanceVariableNames_classVariableNames_poolDictionaries_category_ <1>: UndefinedObject-class creation.
* variableWordSubclass_instanceVariableNames_classVariableNames_poolDictionaries_category_: Class-instance 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.
* waitForException:                      FileDescriptor-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.
* whichSelectorsReferTo_:                Behavior-testing the method dictionary.
* whichSelectorsReferToByteCode_:        Behavior-testing the method dictionary.
* whileFalse:                            BlockClosure-control structures.
* whileFalse_:                           BlockClosure-control structures.
* whileTrue:                             BlockClosure-control structures.
* whileTrue_:                            BlockClosure-control structures.
* width:                                 Rectangle-accessing.
* width_:                                Rectangle-accessing.
* with_ <1>:                             ReadWriteStream class-instance creation.
* with_ <2>:                             ArrayedCollection class-instance creation.
* with_ <3>:                             ValueHolder class-creating instances.
* with_ <4>:                             Collection class-instance creation.
* with_ <5>:                             WriteStream class-instance creation.
* with_:                                 Symbol 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>:                        ArrayedCollection class-instance creation.
* with_with_ <2>:                        Collection class-instance creation.
* with_with_:                            Symbol class-instance creation.
* with_with_with_ <1>:                   Collection class-instance creation.
* with_with_with_ <2>:                   Symbol class-instance creation.
* with_with_with_:                       ArrayedCollection class-instance creation.
* with_with_with_with_ <1>:              Collection class-instance creation.
* with_with_with_with_ <2>:              Symbol class-instance creation.
* with_with_with_with_:                  ArrayedCollection class-instance creation.
* with_with_with_with_with_ <1>:         Symbol class-instance creation.
* with_with_with_with_with_ <2>:         Collection class-instance creation.
* with_with_with_with_with_:             ArrayedCollection class-instance creation.
* withAll_ <1>:                          Collection class-instance creation.
* withAll_ <2>:                          ArrayedCollection class-instance creation.
* withAll_:                              Interval class-instance creation.
* withAllSubclasses:                     Behavior-accessing class hierarchy.
* withAllSubclassesDo_:                  Behavior-enumerating.
* withAllSubspaces:                      RootNamespace-namespace hierarchy.
* withAllSubspacesDo_:                   RootNamespace-namespace hierarchy.
* withAllSuperclasses:                   Behavior-accessing class hierarchy.
* withAllSuperclassesDo_:                Behavior-enumerating.
* withAllSuperspaces <1>:                RootNamespace-namespace hierarchy.
* withAllSuperspaces:                    Dictionary-polymorphism hacks.
* withAllSuperspacesDo_:                 RootNamespace-namespace hierarchy.
* withFileDo_:                           FileSegment-basic.
* withGcOff_:                            Browser class-browsing.
* 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.
* 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>:                       SequenceableCollection-enumerating.
* writeStream:                           File-file operations.
* x:                                     Point-accessing.
* x_:                                    Point-accessing.
* x_y_ <1>:                              Point class-instance creation.
* x_y_:                                  Point-accessing.
* xor_ <1>:                              Boolean-basic.
* xor_ <2>:                              False-basic.
* xor_:                                  True-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>: Date class-instance creation (ANSI).
* year_month_day_hour_minute_second_:    DateTime class-instance creation.
* year_month_day_hour_minute_second_offset_: DateTime class-instance creation.
* yield <1>:                             Process-builtins.
* yield:                                 ProcessorScheduler-basic.
* yourself:                              Object-class type methods.
* zero <1>:                              ScaledDecimal-constants.
* zero <2>:                              Fraction-coercing.
* zero <3>:                              SmallInteger-Coercion methods (heh heh heh).
* zero <4>:                              FloatE-coercing.
* zero <5>:                              FloatD-coercing.
* zero <6>:                              Number-converting.
* zero <7>:                              Duration class-instance creation.
* zero <8>:                              LargeInteger-coercion.
* zero:                                  FloatQ-coercing.
* zeroDivide:                            Number-error raising.
* | <1>:                                 False-basic.
* | <2>:                                 True-basic.
* |:                                     Boolean-basic.
* ~= <1>:                                FloatD-built ins.
* ~= <2>:                                SmallInteger-built ins.
* ~= <3>:                                LargeInteger-testing.
* ~= <4>:                                ScaledDecimal-comparing.
* ~= <5>:                                FloatQ-built ins.
* ~= <6>:                                FloatE-built ins.
* ~=:                                    Object-Relational operators.
* ~~ <1>:                                SmallInteger-built ins.
* ~~:                                    Object-Relational operators.


File: gst-base.info,  Node: Cross-reference,  Prev: Method index,  Up: Top

Selector cross-reference
************************

* Menu:

* *:                                     Number-retrying.
* + <1>:                                 Symbol-basic.
* +:                                     Number-retrying.
* -:                                     Number-retrying.
* /:                                     Number-retrying.
* = <1>:                                 Stream-accessing-reading.
* =:                                     Number-retrying.
* >>:                                    CompiledMethod-saving and loading.
* add_:                                  SequenceableCollection-copying SequenceableCollections.
* addSubspace_:                          Namespace class-disabling instance creation.
* addToBeFinalized <1>:                  CScalar class-instance creation.
* addToBeFinalized <2>:                  CCompound class-instance creation.
* addToBeFinalized <3>:                  CObject-finalization.
* addToBeFinalized <4>:                  FileDescriptor class-instance creation.
* 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.
* at_:                                   PluggableAdaptor class-creating instances.
* at_ifAbsent_:                          RootNamespace-namespace hierarchy.
* at_put_ <1>:                           RootNamespace-accessing.
* at_put_ <2>:                           PluggableAdaptor class-creating instances.
* at_put_ <3>:                           CString-accessing.
* at_put_ <4>:                           PluggableAdaptor class-creating instances.
* at_put_:                               CScalar-accessing.
* basicNew:                              Behavior-built ins.
* basicNew_:                             Behavior-built ins.
* basicPrint:                            Object-built ins.
* become_:                               Object-built ins.
* binaryRepresentationObject <1>:        Object-saving and loading.
* binaryRepresentationObject:            PluggableProxy class-accessing.
* binaryRepresentationVersion:           VersionableObjectProxy class-saving and restoring.
* blockAt_:                              CompiledBlock-saving and loading.
* bz2:                                   VFS DecodedFileHandler class-registering.
* 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.
* collection_map_:                       MappedCollection class-instance creation.
* continue_ <1>:                         MethodContext-accessing.
* continue_ <2>:                         BlockContext-accessing.
* continue_:                             ContextPart-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.
* directoryFor_:                         PackageLoader class-accessing.
* display_:                              Stream-printing.
* do_ <1>:                               Collection-converting.
* do_ <2>:                               SortedCollection-enumerating.
* do_ <3>:                               RunArray-adding.
* do_:                                   Collection-enumerating the elements of a collection.
* dumpTo_ <1>:                           DumperProxy class-instance creation.
* dumpTo_:                               AlternativeObjectProxy class-instance creation.
* ensure_ <1>:                           MethodContext-accessing.
* ensure_ <2>:                           ContextPart-accessing.
* ensure_ <3>:                           BlockClosure-unwind protection.
* ensure_ <4>:                           BlockContext-accessing.
* ensure_ <5>:                           MethodContext-accessing.
* ensure_ <6>:                           BlockContext-accessing.
* ensure_:                               ContextPart-built ins.
* error_ <1>:                            Behavior-creating method dictionary.
* error_ <2>:                            BlockClosure-exception handling.
* error_ <3>:                            Behavior-evaluating.
* error_:                                Behavior-creating method dictionary.
* fileSystems:                           VFS VFSHandler class-initializing.
* first <1>:                             LargeArraySubpart-accessing.
* first:                                 LargeArraySubpart class-instance creation.
* firstIndex <1>:                        LargeArraySubpart class-instance creation.
* firstIndex:                            LargeArraySubpart-accessing.
* forkWithoutPreemption:                 BlockClosure-multiple process.
* 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:                          RootNamespace-basic & copying.
* ifCurtailed_:                          ContextPart-built ins.
* ifTrue_ifFalse_:                       Symbol-basic.
* includes_:                             IdentitySet-testing.
* includesClassNamed_:                   RootNamespace-namespace hierarchy.
* includesGlobalNamed_:                  RootNamespace-namespace hierarchy.
* includesKey_:                          RootNamespace-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.
* new <1>:                               Behavior-instance creation.
* new:                                   RootNamespace class-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.
* 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>:                          HashedCollection-saving and loading.
* postLoad <2>:                          SingletonProxy-saving and restoring.
* postLoad <3>:                          PluggableProxy-saving and restoring.
* postLoad:                              Object-saving and loading.
* postStore:                             PluggableProxy class-accessing.
* preStore:                              PluggableProxy class-accessing.
* primDefineExternFunc_:                 DLD class-Dynamic Linking.
* print:                                 Object-printing.
* printNl:                               Object-printing.
* printOn_ <1>:                          Object-built ins.
* printOn_ <2>:                          Character-printing.
* printOn_ <3>:                          CharacterArray-printing.
* printOn_ <4>:                          Symbol-basic.
* printOn_ <5>:                          Object-printing.
* printOn_:                              Symbol-storing.
* printStatistics:                       ObjectMemory class-builtins.
* printString <1>:                       Symbol-storing.
* printString <2>:                       Object-printing.
* printString <3>:                       ScaledDecimal-printing.
* printString:                           CharacterArray-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.
* resetStatistics:                       ObjectMemory class-builtins.
* return_:                               BlockClosure-exception handling.
* secondClock:                           Time class-basic (UTC).
* select_:                               PositionableStream-class type methods.
* signal:                                Signal-exception handling.
* signal_atMilliseconds_:                ProcessorScheduler-timed invocation.
* 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:                                 Character-built ins.
* value_ <1>:                            PluggableAdaptor class-creating instances.
* value_ <2>:                            Character class-built ins.
* value_:                                PluggableAdaptor class-creating instances.
* valueWithoutPreemption:                ProcessorScheduler-priorities.
* valueWithUnwind:                       BlockClosure-unwind protection.
* Variable:                              RootNamespace-accessing.
* vfsFor_name_subPath_:                  VFS VFSHandler class-initializing.
* write:                                 FileDescriptor class-instance creation.
* Z:                                     VFS DecodedFileHandler class-registering.
* ~=:                                    Number-retrying.



Tag Table:
Node: Top280
Node: Base classes2170
Node: AlternativeObjectProxy10721
Node: AlternativeObjectProxy class-instance creation11429
Node: AlternativeObjectProxy-accessing12361
Node: ArithmeticError12912
Node: ArithmeticError-description13363
Node: Array13568
Node: Array-mutating objects14199
Node: Array-printing14498
Node: Array-testing14716
Node: ArrayedCollection14856
Node: ArrayedCollection class-instance creation15645
Node: ArrayedCollection-basic16803
Node: ArrayedCollection-built ins17701
Node: ArrayedCollection-copying Collections17964
Node: ArrayedCollection-enumerating the elements of a collection19715
Node: ArrayedCollection-storing20861
Node: Association21145
Node: Association class-basic21781
Node: Association-accessing22019
Node: Association-printing22388
Node: Association-storing22632
Node: Association-testing22885
Node: Autoload23229
Node: Autoload class-instance creation23813
Node: Autoload-accessing24141
Node: Bag24408
Node: Bag class-basic25142
Node: Bag-Adding to a collection25414
Node: Bag-enumerating the elements of a collection25942
Node: Bag-extracting items26315
Node: Bag-printing26594
Node: Bag-Removing from a collection26816
Node: Bag-storing27179
Node: Bag-testing collections27414
Node: Behavior27899
Node: Behavior class-C interface29453
Node: Behavior-accessing class hierarchy30006
Node: Behavior-accessing instances and variables30767
Node: Behavior-accessing the methodDictionary32053
Node: Behavior-browsing32959
Node: Behavior-built ins34726
Node: Behavior-compilation (alternative)36892
Node: Behavior-compiling methods37712
Node: Behavior-creating a class hierarchy38172
Node: Behavior-creating method dictionary38623
Node: Behavior-enumerating41623
Node: Behavior-evaluating42676
Node: Behavior-hierarchy browsing43967
Node: Behavior-instance creation44359
Node: Behavior-instance variables45146
Node: Behavior-support for lightweight classes45591
Node: Behavior-testing the class hierarchy46472
Node: Behavior-testing the form of the instances46896
Node: Behavior-testing the method dictionary48023
Node: BlockClosure49201
Node: BlockClosure class-instance creation50415
Node: BlockClosure class-testing50981
Node: BlockClosure-accessing51274
Node: BlockClosure-built ins52861
Node: BlockClosure-control structures53627
Node: BlockClosure-exception handling54293
Node: BlockClosure-multiple process56294
Node: BlockClosure-overriding57536
Node: BlockClosure-testing57803
Node: BlockClosure-unwind protection58062
Node: BlockContext59530
Node: BlockContext-accessing60310
Node: BlockContext-printing61823
Node: Boolean62047
Node: Boolean class-testing62796
Node: Boolean-basic63098
Node: Boolean-C hacks64379
Node: Boolean-overriding64626
Node: Boolean-storing64854
Node: Browser65068
Node: Browser class-browsing65494
Node: ByteArray67880
Node: ByteArray-built ins68421
Node: ByteArray-converting69703
Node: ByteArray-more advanced accessing69980
Node: ByteStream76483
Node: ByteStream-basic76862
Node: CAggregate78137
Node: CAggregate class-accessing78424
Node: CAggregate-accessing78699
Node: CArray78927
Node: CArray-accessing79166
Node: CArrayCType79358
Node: CArrayCType class-instance creation79658
Node: CArrayCType-accessing80277
Node: CBoolean80640
Node: CBoolean-accessing80937
Node: CByte81253
Node: CByte class-conversion81635
Node: CByte-accessing81953
Node: CChar82390
Node: CChar class-accessing82650
Node: CChar-accessing82999
Node: CCompound83301
Node: CCompound class-instance creation83642
Node: CCompound class-subclass creation84000
Node: CCompound-instance creation86089
Node: CDouble86427
Node: CDouble class-accessing86698
Node: CDouble-accessing87057
Node: CFloat87369
Node: CFloat class-accessing87646
Node: CFloat-accessing88000
Node: CFunctionDescriptor88307
Node: CFunctionDescriptor class-instance creation89038
Node: CFunctionDescriptor class-testing89392
Node: CFunctionDescriptor-accessing89963
Node: CFunctionDescriptor-printing90581
Node: Character90841
Node: Character class-built ins91810
Node: Character class-constants92581
Node: Character class-initializing lookup tables93374
Node: Character class-Instance creation94009
Node: Character class-testing94366
Node: Character-built ins94724
Node: Character-Coercion methods95498
Node: Character-comparing96061
Node: Character-converting96693
Node: Character-printing96995
Node: Character-storing97368
Node: Character-testing97606
Node: Character-testing functionality98241
Node: CharacterArray98472
Node: CharacterArray class-basic99213
Node: CharacterArray-basic99602
Node: CharacterArray-built ins100278
Node: CharacterArray-comparing100692
Node: CharacterArray-converting102901
Node: CharacterArray-printing104257
Node: CharacterArray-storing104875
Node: CharacterArray-string processing105153
Node: CharacterArray-testing functionality107517
Node: CInt107762
Node: CInt class-accessing108022
Node: CInt-accessing108346
Node: Class108663
Node: Class-accessing instances and variables109509
Node: Class-filing110918
Node: Class-instance creation111357
Node: Class-instance creation - alternative113561
Node: Class-printing115725
Node: Class-saving and loading116131
Node: Class-testing117524
Node: Class-testing functionality117762
Node: ClassDescription117978
Node: ClassDescription-compiling118640
Node: ClassDescription-conversion119467
Node: ClassDescription-copying119845
Node: ClassDescription-filing121041
Node: ClassDescription-organization of messages and classes121862
Node: ClassDescription-printing123003
Node: CLong123631
Node: CLong class-accessing123900
Node: CLong-accessing124249
Node: CObject124551
Node: CObject class-conversion125401
Node: CObject class-instance creation125743
Node: CObject-accessing126340
Node: CObject-C data access126774
Node: CObject-conversion127377
Node: CObject-finalization127797
Node: CObject-pointer-like behavior128260
Node: Collection130514
Node: Collection class-instance creation131464
Node: Collection-Adding to a collection132483
Node: Collection-converting132877
Node: Collection-copying Collections133985
Node: Collection-enumerating the elements of a collection134551
Node: Collection-printing137549
Node: Collection-Removing from a collection137937
Node: Collection-storing138781
Node: Collection-testing collections139055
Node: CompiledBlock139693
Node: CompiledBlock class-instance creation140191
Node: CompiledBlock-accessing140926
Node: CompiledBlock-basic141984
Node: CompiledBlock-printing142692
Node: CompiledBlock-saving and loading142958
Node: CompiledCode143378
Node: CompiledCode class-cache flushing144094
Node: CompiledCode class-instance creation144449
Node: CompiledCode-accessing144994
Node: CompiledCode-basic146392
Node: CompiledCode-copying147142
Node: CompiledCode-debugging147366
Node: CompiledCode-printing147886
Node: CompiledCode-testing accesses148148
Node: CompiledCode-translation148919
Node: CompiledMethod149176
Node: CompiledMethod class-instance creation149915
Node: CompiledMethod class-lean images150551
Node: CompiledMethod-accessing150871
Node: CompiledMethod-basic151943
Node: CompiledMethod-printing152706
Node: CompiledMethod-saving and loading152972
Node: ContextPart153390
Node: ContextPart class-exception handling154126
Node: ContextPart-accessing155071
Node: ContextPart-built ins158303
Node: ContextPart-copying158988
Node: ContextPart-enumerating159342
Node: ContextPart-exception handling159724
Node: ContextPart-printing159985
Node: CoreException160347
Node: CoreException class-instance creation161613
Node: CoreException-accessing161868
Node: CoreException-basic162801
Node: CoreException-enumerating163022
Node: CoreException-exception handling163679
Node: CoreException-instance creation164329
Node: CPtr164630
Node: CPtr-accessing164862
Node: CPtrCType165396
Node: CPtrCType class-instance creation165679
Node: CPtrCType-accessing165963
Node: CScalar166423
Node: CScalar class-instance creation166708
Node: CScalar-accessing167166
Node: CScalarCType167680
Node: CScalarCType-accessing167967
Node: CScalarCType-storing168294
Node: CShort168515
Node: CShort class-accessing168788
Node: CShort-accessing169142
Node: CSmalltalk169449
Node: CSmalltalk class-accessing169733
Node: CSmalltalk-accessing170107
Node: CString170434
Node: CString class-instance creation171240
Node: CString-accessing171698
Node: CStringCType172212
Node: CStringCType-accessing172470
Node: CStruct172670
Node: CStruct class-subclass creation172919
Node: CType173152
Node: CType class-C instance creation174266
Node: CType-accessing174521
Node: CType-C instance creation175363
Node: CType-storing175873
Node: CUChar176069
Node: CUChar class-getting info176333
Node: CUChar-accessing176696
Node: CUInt177006
Node: CUInt class-accessing177264
Node: CUInt-accessing177613
Node: CULong177915
Node: CULong class-accessing178177
Node: CULong-accessing178531
Node: CUnion178838
Node: CUnion class-subclass creation179079
Node: CUShort179308
Node: CUShort class-accessing179574
Node: CUShort-accessing179933
Node: Date180245
Node: Date class-basic181707
Node: Date class-instance creation (ANSI)182820
Node: Date class-instance creation (Blue Book)183295
Node: Date-basic184600
Node: Date-compatibility (non-ANSI)185059
Node: Date-date computations185457
Node: Date-printing187065
Node: Date-storing187278
Node: Date-testing187486
Node: DateTime187790
Node: DateTime class-information188424
Node: DateTime class-instance creation188700
Node: DateTime class-instance creation (non-ANSI)189986
Node: DateTime-basic190473
Node: DateTime-computations190805
Node: DateTime-printing191482
Node: DateTime-splitting in dates & times191733
Node: DateTime-storing192317
Node: DateTime-testing192567
Node: DateTime-time zones192927
Node: Delay194040
Node: Delay class-general inquiries194803
Node: Delay class-initialization195061
Node: Delay class-instance creation195342
Node: Delay-accessing195830
Node: Delay-comparing196069
Node: Delay-process delay196340
Node: DelayedAdaptor196561
Node: DelayedAdaptor-accessing197087
Node: Dictionary197451
Node: Dictionary class-instance creation198401
Node: Dictionary-accessing198640
Node: Dictionary-awful ST-80 compatibility hacks200296
Node: Dictionary-dictionary enumerating200744
Node: Dictionary-dictionary removing201817
Node: Dictionary-dictionary testing202777
Node: Dictionary-polymorphism hacks203436
Node: Dictionary-printing203706
Node: Dictionary-rehashing204055
Node: Dictionary-storing204257
Node: Dictionary-testing204502
Node: DirectedMessage204761
Node: DirectedMessage class-creating instances205278
Node: DirectedMessage-accessing205696
Node: DirectedMessage-basic205989
Node: DirectedMessage-saving and loading206400
Node: Directory206812
Node: Directory class-C functions207583
Node: Directory class-file name management207883
Node: Directory class-file operations208443
Node: Directory class-reading system defaults208810
Node: Directory-accessing209757
Node: Directory-enumerating210618
Node: DLD211359
Node: DLD class-C functions212042
Node: DLD class-Dynamic Linking212418
Node: DumperProxy213749
Node: DumperProxy class-accessing214275
Node: DumperProxy class-instance creation214725
Node: DumperProxy-saving and restoring215215
Node: Duration215615
Node: Duration class-instance creation216016
Node: Duration class-instance creation (non ANSI)216501
Node: Duration-arithmetics216965
Node: Error218138
Node: Error-exception description218453
Node: Exception218779
Node: Exception class-comparison219907
Node: Exception class-creating ExceptionCollections220356
Node: Exception class-initialization220765
Node: Exception class-instance creation221132
Node: Exception class-interoperability with TrappableEvents221701
Node: Exception-comparison222308
Node: Exception-exception description222741
Node: Exception-exception signaling223169
Node: ExceptionSet223547
Node: ExceptionSet class-instance creation224112
Node: ExceptionSet-enumerating224362
Node: False224911
Node: False-basic225300
Node: False-C hacks226279
Node: False-printing226444
Node: File226630
Node: File class-C functions227453
Node: File class-file name management227719
Node: File class-file operations228792
Node: File class-instance creation229405
Node: File class-reading system defaults229770
Node: File class-testing230042
Node: File-accessing230679
Node: File-file name management231764
Node: File-file operations232535
Node: File-testing233492
Node: FileDescriptor234408
Node: FileDescriptor class-initialization235559
Node: FileDescriptor class-instance creation235882
Node: FileDescriptor-accessing241900
Node: FileDescriptor-basic243045
Node: FileDescriptor-built ins244275
Node: FileDescriptor-class type methods245472
Node: FileDescriptor-initialize-release245887
Node: FileDescriptor-low-level access246408
Node: FileDescriptor-overriding inherited methods247440
Node: FileDescriptor-printing248226
Node: FileDescriptor-testing248509
Node: FileSegment248716
Node: FileSegment class-basic249325
Node: FileSegment class-installing249667
Node: FileSegment-basic250038
Node: FileSegment-equality250886
Node: FileStream251154
Node: FileStream class-file-in251860
Node: FileStream class-standard streams255381
Node: FileStream-basic256106
Node: FileStream-buffering257004
Node: FileStream-filing in257808
Node: FileStream-overriding inherited methods258722
Node: FileStream-testing259342
Node: Float259549
Node: Float class-byte-order dependancies260342
Node: Float class-characterization260607
Node: Float-arithmetic261614
Node: Float-basic261931
Node: Float-built ins262111
Node: Float-coercing263037
Node: Float-printing263658
Node: Float-storing263867
Node: Float-testing264073
Node: Float-testing functionality264825
Node: FloatD265006
Node: FloatD class-byte-order dependancies265665
Node: FloatD class-characterization265935
Node: FloatD class-converting267194
Node: FloatD-built ins267435
Node: FloatD-coercing268657
Node: FloatE269045
Node: FloatE class-byte-order dependancies269705
Node: FloatE class-characterization269975
Node: FloatE class-converting271522
Node: FloatE-built ins271763
Node: FloatE-coercing272985
Node: FloatQ273373
Node: FloatQ class-byte-order dependancies274035
Node: FloatQ class-characterization274305
Node: FloatQ class-converting275852
Node: FloatQ-built ins276093
Node: FloatQ-coercing277315
Node: Fraction277703
Node: Fraction class-converting278445
Node: Fraction class-instance creation278674
Node: Fraction-accessing279044
Node: Fraction-arithmetic279319
Node: Fraction-coercing280028
Node: Fraction-comparing280652
Node: Fraction-converting281139
Node: Fraction-optimized cases281625
Node: Fraction-printing282044
Node: Fraction-testing282359
Node: Halt282549
Node: Halt-description282835
Node: HashedCollection283071
Node: HashedCollection class-instance creation283942
Node: HashedCollection-accessing284304
Node: HashedCollection-builtins284869
Node: HashedCollection-copying285631
Node: HashedCollection-enumerating the elements of a collection286094
Node: HashedCollection-rehashing286455
Node: HashedCollection-Removing from a collection286744
Node: HashedCollection-saving and loading287190
Node: HashedCollection-storing287707
Node: HashedCollection-testing collections288019
Node: IdentityDictionary288949
Node: IdentitySet289332
Node: IdentitySet-testing289721
Node: Integer289967
Node: Integer class-converting290806
Node: Integer-accessing291023
Node: Integer-bit operators291255
Node: Integer-converting292530
Node: Integer-extension293219
Node: Integer-Math methods293520
Node: Integer-Misc math operators294327
Node: Integer-Other iterators294569
Node: Integer-printing294944
Node: Integer-storing295697
Node: Integer-testing functionality295939
Node: Interval296196
Node: Interval class-instance creation296782
Node: Interval-basic297369
Node: Interval-printing298040
Node: Interval-storing298265
Node: Interval-testing298497
Node: LargeArray298753
Node: LargeArray-overridden299146
Node: LargeArrayedCollection299323
Node: LargeArrayedCollection class-instance creation299856
Node: LargeArrayedCollection-accessing300200
Node: LargeArrayedCollection-basic300689
Node: LargeArraySubpart301075
Node: LargeArraySubpart class-instance creation301944
Node: LargeArraySubpart-accessing302338
Node: LargeArraySubpart-comparing303278
Node: LargeArraySubpart-modifying304285
Node: LargeByteArray305032
Node: LargeByteArray-overridden305445
Node: LargeInteger305871
Node: LargeInteger-arithmetic306657
Node: LargeInteger-bit operations307619
Node: LargeInteger-built-ins308206
Node: LargeInteger-coercion309270
Node: LargeInteger-disabled309691
Node: LargeInteger-primitive operations310051
Node: LargeInteger-testing310516
Node: LargeNegativeInteger311141
Node: LargeNegativeInteger-converting311833
Node: LargeNegativeInteger-numeric testing312206
Node: LargeNegativeInteger-reverting to LargePositiveInteger312726
Node: LargePositiveInteger313277
Node: LargePositiveInteger-arithmetic314144
Node: LargePositiveInteger-converting314605
Node: LargePositiveInteger-helper byte-level methods315158
Node: LargePositiveInteger-numeric testing316880
Node: LargePositiveInteger-primitive operations317401
Node: LargeWordArray318080
Node: LargeWordArray-overridden318500
Node: LargeZeroInteger318784
Node: LargeZeroInteger-accessing319602
Node: LargeZeroInteger-arithmetic319852
Node: LargeZeroInteger-numeric testing320767
Node: LargeZeroInteger-printing321089
Node: Link321391
Node: Link class-instance creation321926
Node: Link-basic322143
Node: Link-iteration322381
Node: LinkedList322827
Node: LinkedList-accessing323425
Node: LinkedList-adding323726
Node: LinkedList-enumerating324444
Node: LinkedList-testing324770
Node: LookupKey325111
Node: LookupKey class-basic325655
Node: LookupKey-accessing325882
Node: LookupKey-printing326132
Node: LookupKey-storing326364
Node: LookupKey-testing326605
Node: LookupTable327024
Node: LookupTable class-instance creation327752
Node: LookupTable-accessing327997
Node: LookupTable-copying328785
Node: LookupTable-enumerating329088
Node: LookupTable-rehashing329466
Node: LookupTable-removing329678
Node: LookupTable-storing329996
Node: Magnitude330218
Node: Magnitude-basic330662
Node: Magnitude-misc methods331177
Node: MappedCollection331576
Node: MappedCollection class-instance creation332938
Node: MappedCollection-basic333374
Node: Memory334248
Node: Memory class-accessing334828
Node: Memory class-basic338735
Node: Message339550
Node: Message class-creating instances340188
Node: Message-accessing340463
Node: Message-basic340888
Node: MessageNotUnderstood341198
Node: MessageNotUnderstood-accessing341680
Node: MessageNotUnderstood-description342002
Node: Metaclass342266
Node: Metaclass class-instance creation343253
Node: Metaclass-accessing343521
Node: Metaclass-basic343950
Node: Metaclass-delegation345045
Node: Metaclass-filing346347
Node: Metaclass-printing346621
Node: Metaclass-testing functionality347096
Node: MethodContext347372
Node: MethodContext-accessing347862
Node: MethodContext-printing349119
Node: MethodDictionary349348
Node: MethodDictionary-adding349867
Node: MethodDictionary-rehashing350099
Node: MethodDictionary-removing350336
Node: MethodInfo350742
Node: MethodInfo-accessing351216
Node: MethodInfo-equality352144
Node: Namespace352420
Node: Namespace class-accessing353327
Node: Namespace class-disabling instance creation353620
Node: Namespace-accessing353988
Node: Namespace-namespace hierarchy354273
Node: Namespace-overrides for superspaces354754
Node: Namespace-printing356534
Node: Namespace-testing356938
Node: Notification357102
Node: Notification-exception description357538
Node: NullProxy357983
Node: NullProxy class-instance creation358583
Node: NullProxy-accessing358837
Node: NullValueHolder359072
Node: NullValueHolder class-creating instances359649
Node: NullValueHolder-accessing359914
Node: Number360245
Node: Number class-converting361127
Node: Number class-testing361570
Node: Number-arithmetic361821
Node: Number-comparing363137
Node: Number-converting363543
Node: Number-copying364794
Node: Number-error raising365092
Node: Number-Intervals & iterators365458
Node: Number-misc math366307
Node: Number-point creation367861
Node: Number-retrying368139
Node: Number-testing369909
Node: Number-truncation and round off371311
Node: Object372107
Node: Object-built ins372982
Node: Object-change and update380736
Node: Object-class type methods381926
Node: Object-copying382725
Node: Object-debugging383439
Node: Object-dependents access383882
Node: Object-error raising384569
Node: Object-exception handling385245
Node: Object-finalization385749
Node: Object-printing385951
Node: Object-Relational operators387677
Node: Object-saving and loading388022
Node: Object-storing389006
Node: Object-syntax shortcuts389594
Node: Object-testing functionality389902
Node: ObjectDumper391423
Node: ObjectDumper class-establishing proxy classes392616
Node: ObjectDumper class-instance creation393448
Node: ObjectDumper class-shortcuts393844
Node: ObjectDumper class-testing394221
Node: ObjectDumper-accessing394648
Node: ObjectDumper-loading/dumping objects395139
Node: ObjectDumper-stream interface395562
Node: ObjectMemory395927
Node: ObjectMemory class-builtins396555
Node: ObjectMemory class-dependancy399253
Node: ObjectMemory class-initialization399544
Node: ObjectMemory class-saving the image399821
Node: OrderedCollection400101
Node: OrderedCollection class-instance creation400817
Node: OrderedCollection-accessing401158
Node: OrderedCollection-adding401608
Node: OrderedCollection-removing403655
Node: PackageLoader404292
Node: PackageLoader class-accessing404809
Node: PackageLoader class-loading406541
Node: PackageLoader class-testing407536
Node: PluggableAdaptor407816
Node: PluggableAdaptor class-creating instances408444
Node: PluggableAdaptor-accessing409522
Node: PluggableProxy409806
Node: PluggableProxy class-accessing410432
Node: PluggableProxy-saving and restoring410865
Node: Point411283
Node: Point class-instance creation412010
Node: Point-accessing412306
Node: Point-arithmetic412723
Node: Point-comparing413425
Node: Point-converting414221
Node: Point-point functions414723
Node: Point-printing415654
Node: Point-storing415871
Node: Point-truncation and round off416102
Node: PositionableStream416497
Node: PositionableStream class-instance creation417404
Node: PositionableStream-accessing-reading417912
Node: PositionableStream-class type methods419066
Node: PositionableStream-positioning419554
Node: PositionableStream-testing420691
Node: PositionableStream-truncating421156
Node: Process421439
Node: Process class-basic422040
Node: Process-accessing422288
Node: Process-basic422849
Node: Process-builtins423913
Node: Process-printing424167
Node: ProcessorScheduler424364
Node: ProcessorScheduler class-instance creation424986
Node: ProcessorScheduler-basic425283
Node: ProcessorScheduler-idle tasks426827
Node: ProcessorScheduler-printing427164
Node: ProcessorScheduler-priorities427466
Node: ProcessorScheduler-storing429115
Node: ProcessorScheduler-timed invocation429439
Node: Promise429993
Node: Promise class-creating instances430532
Node: Promise-accessing430778
Node: Promise-initializing431101
Node: Random431303
Node: Random class-instance creation431752
Node: Random class-shortcuts432117
Node: Random-basic432433
Node: Random-testing432846
Node: ReadStream433155
Node: ReadStream class-instance creation433595
Node: ReadStream-accessing-reading433869
Node: ReadWriteStream434162
Node: ReadWriteStream class-instance creation434648
Node: ReadWriteStream-positioning435102
Node: Rectangle435466
Node: Rectangle class-instance creation436255
Node: Rectangle-accessing436796
Node: Rectangle-copying439193
Node: Rectangle-printing439410
Node: Rectangle-rectangle functions439735
Node: Rectangle-testing441575
Node: Rectangle-transforming442388
Node: Rectangle-truncation and round off443011
Node: RootNamespace443299
Node: RootNamespace class-instance creation444325
Node: RootNamespace-accessing444853
Node: RootNamespace-basic & copying446997
Node: RootNamespace-copying447522
Node: RootNamespace-forward declarations447830
Node: RootNamespace-namespace hierarchy448240
Node: RootNamespace-overrides for superspaces450950
Node: RootNamespace-printing452643
Node: RootNamespace-testing453261
Node: RunArray453522
Node: RunArray class-instance creation454483
Node: RunArray-accessing454754
Node: RunArray-adding455087
Node: RunArray-basic456160
Node: RunArray-copying456464
Node: RunArray-enumerating456819
Node: RunArray-removing457278
Node: RunArray-searching457742
Node: RunArray-testing458155
Node: ScaledDecimal458397
Node: ScaledDecimal class-constants459201
Node: ScaledDecimal class-instance creation459450
Node: ScaledDecimal-arithmetic459886
Node: ScaledDecimal-coercion460604
Node: ScaledDecimal-comparing461508
Node: ScaledDecimal-constants462143
Node: ScaledDecimal-printing462444
Node: ScaledDecimal-storing462903
Node: Semaphore463140
Node: Semaphore class-instance creation463732
Node: Semaphore-builtins464103
Node: Semaphore-mutual exclusion464470
Node: SequenceableCollection464818
Node: SequenceableCollection class-instance creation465520
Node: SequenceableCollection-basic465934
Node: SequenceableCollection-copying SequenceableCollections469355
Node: SequenceableCollection-enumerating471464
Node: SequenceableCollection-replacing items474876
Node: SequenceableCollection-testing475822
Node: Set476255
Node: Set-arithmetic476675
Node: Set-awful ST-80 compatibility hacks477003
Node: Set-comparing477363
Node: SharedQueue477757
Node: SharedQueue class-instance creation478279
Node: SharedQueue-accessing478647
Node: Signal479148
Node: Signal-accessing479773
Node: Signal-exception handling480622
Node: SingletonProxy483174
Node: SingletonProxy class-accessing483778
Node: SingletonProxy class-instance creation484142
Node: SingletonProxy-saving and restoring484582
Node: SmallInteger485008
Node: SmallInteger class-getting limits485709
Node: SmallInteger class-testing486194
Node: SmallInteger-bit arithmetic486489
Node: SmallInteger-built ins486766
Node: SmallInteger-builtins488884
Node: SmallInteger-Coercion methods (heh heh heh)489648
Node: SmallInteger-testing functionality490045
Node: SortedCollection490291
Node: SortedCollection class-hacking491423
Node: SortedCollection class-instance creation491691
Node: SortedCollection-basic492203
Node: SortedCollection-copying492747
Node: SortedCollection-disabled493053
Node: SortedCollection-enumerating493906
Node: SortedCollection-saving and loading494235
Node: SortedCollection-searching494580
Node: Stream495166
Node: Stream-accessing-reading496123
Node: Stream-accessing-writing496995
Node: Stream-basic497396
Node: Stream-character writing497578
Node: Stream-enumerating498098
Node: Stream-filing out498332
Node: Stream-PositionableStream methods498692
Node: Stream-printing500338
Node: Stream-providing consistent protocols501112
Node: Stream-storing501470
Node: Stream-testing501841
Node: String502012
Node: String class-basic502594
Node: String class-instance creation502910
Node: String-built ins503240
Node: String-converting505010
Node: String-storing505354
Node: String-testing functionality505590
Node: String-useful functionality505813
Node: Symbol506098
Node: Symbol class-built ins506924
Node: Symbol class-instance creation507138
Node: Symbol class-symbol table508276
Node: Symbol-basic509684
Node: Symbol-built ins510265
Node: Symbol-converting510573
Node: Symbol-misc510912
Node: Symbol-storing511075
Node: Symbol-testing511737
Node: Symbol-testing functionality512004
Node: SymLink512222
Node: SymLink class-instance creation512771
Node: SymLink-accessing513090
Node: SymLink-iteration513424
Node: SymLink-printing513638
Node: SystemDictionary513837
Node: SystemDictionary-basic514644
Node: SystemDictionary-builtins514924
Node: SystemDictionary-C functions516184
Node: SystemDictionary-miscellaneous516689
Node: SystemDictionary-printing517033
Node: SystemDictionary-special accessing517443
Node: SystemExceptions AlreadyDefined518155
Node: SystemExceptions AlreadyDefined-accessing518669
Node: SystemExceptions ArgumentOutOfRange518920
Node: SystemExceptions ArgumentOutOfRange class-signaling519508
Node: SystemExceptions ArgumentOutOfRange-accessing519913
Node: SystemExceptions BadReturn520490
Node: SystemExceptions BadReturn-accessing520968
Node: SystemExceptions CInterfaceError521211
Node: SystemExceptions CInterfaceError-accessing521710
Node: SystemExceptions EmptyCollection521977
Node: SystemExceptions EmptyCollection-accessing522462
Node: SystemExceptions EndOfStream522729
Node: SystemExceptions EndOfStream class-signaling523210
Node: SystemExceptions EndOfStream-accessing523549
Node: SystemExceptions FileError523968
Node: SystemExceptions FileError-accessing524445
Node: SystemExceptions IndexOutOfRange524688
Node: SystemExceptions IndexOutOfRange class-signaling525272
Node: SystemExceptions IndexOutOfRange-accessing525637
Node: SystemExceptions InvalidArgument526150
Node: SystemExceptions InvalidArgument-accessing526637
Node: SystemExceptions InvalidSize526893
Node: SystemExceptions InvalidSize-accessing527354
Node: SystemExceptions InvalidValue527605
Node: SystemExceptions InvalidValue class-signaling528113
Node: SystemExceptions InvalidValue-accessing528561
Node: SystemExceptions MustBeBoolean529051
Node: SystemExceptions NoRunnableProcess529475
Node: SystemExceptions NoRunnableProcess-accessing529960
Node: SystemExceptions NotFound530235
Node: SystemExceptions NotFound class-accessing530749
Node: SystemExceptions NotFound-accessing531123
Node: SystemExceptions NotImplemented531412
Node: SystemExceptions NotImplemented-accessing531868
Node: SystemExceptions NotIndexable532131
Node: SystemExceptions NotIndexable-accessing532592
Node: SystemExceptions NotYetImplemented532847
Node: SystemExceptions NotYetImplemented-accessing533357
Node: SystemExceptions PrimitiveFailed533632
Node: SystemExceptions PrimitiveFailed-accessing534110
Node: SystemExceptions ProcessTerminated534377
Node: SystemExceptions ProcessTerminated-accessing534893
Node: SystemExceptions ReadOnlyObject535168
Node: SystemExceptions ReadOnlyObject-accessing535647
Node: SystemExceptions ShouldNotImplement535910
Node: SystemExceptions ShouldNotImplement-accessing536438
Node: SystemExceptions SubclassResponsibility536717
Node: SystemExceptions SubclassResponsibility-accessing537285
Node: SystemExceptions UserInterrupt537580
Node: SystemExceptions UserInterrupt-accessing538030
Node: SystemExceptions VMError538289
Node: SystemExceptions VMError-accessing538713
Node: SystemExceptions WrongArgumentCount538948
Node: SystemExceptions WrongArgumentCount-accessing539502
Node: SystemExceptions WrongClass539781
Node: SystemExceptions WrongClass class-signaling540397
Node: SystemExceptions WrongClass-accessing541052
Node: SystemExceptions WrongMessageSent541704
Node: SystemExceptions WrongMessageSent class-signaling542349
Node: SystemExceptions WrongMessageSent-accessing542765
Node: TextCollector543353
Node: TextCollector class-accessing544051
Node: TextCollector-accessing544547
Node: TextCollector-printing545345
Node: TextCollector-set up545676
Node: TextCollector-storing546238
Node: Time546565
Node: Time class-basic (UTC)547344
Node: Time class-builtins547789
Node: Time class-clocks548813
Node: Time class-initialization549367
Node: Time class-instance creation549710
Node: Time-accessing (ANSI for DateAndTimes)550586
Node: Time-accessing (non ANSI & for Durations)551101
Node: Time-arithmetic551550
Node: Time-comparing551975
Node: TokenStream552259
Node: TokenStream class-instance creation553067
Node: TokenStream-basic553426
Node: TokenStream-write methods553747
Node: TrappableEvent553989
Node: TrappableEvent-enumerating554565
Node: TrappableEvent-instance creation555112
Node: True555441
Node: True-basic555819
Node: True-C hacks556768
Node: True-printing556927
Node: UndefinedObject557108
Node: UndefinedObject-basic557824
Node: UndefinedObject-class creation558092
Node: UndefinedObject-class creation - alternative560272
Node: UndefinedObject-CObject interoperability562559
Node: UndefinedObject-dependents access562892
Node: UndefinedObject-printing563240
Node: UndefinedObject-storing563519
Node: UndefinedObject-testing563794
Node: ValueAdaptor564629
Node: ValueAdaptor class-creating instances565113
Node: ValueAdaptor-accessing565400
Node: ValueAdaptor-printing565806
Node: ValueHolder566018
Node: ValueHolder class-creating instances566640
Node: ValueHolder-accessing567022
Node: ValueHolder-initializing567314
Node: VersionableObjectProxy567536
Node: VersionableObjectProxy class-saving and restoring568428
Node: VersionableObjectProxy-saving and restoring569451
Node: VFS ArchiveFileHandler569784
Node: VFS DecodedFileHandler570061
Node: VFS DecodedFileHandler class-registering570451
Node: VFS DecodedFileHandler-files571597
Node: VFS ExternalArchiveFileHandler572260
Node: VFS ExternalArchiveFileHandler class-registering572629
Node: VFS RealFileHandler573539
Node: VFS RealFileHandler class-C functions574208
Node: VFS RealFileHandler class-initialization574489
Node: VFS RealFileHandler-accessing574815
Node: VFS RealFileHandler-C functions575995
Node: VFS RealFileHandler-directory operations577160
Node: VFS RealFileHandler-enumerating577497
Node: VFS RealFileHandler-file operations577893
Node: VFS RealFileHandler-testing578687
Node: VFS VFSHandler579552
Node: VFS VFSHandler class-initializing579920
Node: VFS VFSHandler class-instance creation580817
Node: VFS VFSHandler-accessing581159
Node: Warning581585
Node: Warning-exception description581904
Node: WeakArray582107
Node: WeakArray class-instance creation582600
Node: WeakArray-accessing582923
Node: WeakArray-conversion584570
Node: WeakArray-loading585204
Node: WeakIdentitySet585468
Node: WeakKeyIdentityDictionary585938
Node: WeakKeyLookupTable586476
Node: WeakKeyLookupTable class-instance creation587079
Node: WeakKeyLookupTable-rehashing587383
Node: WeakSet587613
Node: WeakSet class-instance creation588107
Node: WeakSet-rehashing588356
Node: WeakValueIdentityDictionary588531
Node: WeakValueLookupTable589077
Node: WeakValueLookupTable-hacks589685
Node: WeakValueLookupTable-rehashing590241
Node: WordArray590463
Node: WriteStream590769
Node: WriteStream class-instance creation591295
Node: WriteStream-accessing591964
Node: WriteStream-accessing-writing592217
Node: WriteStream-positioning592807
Node: ZeroDivide593016
Node: ZeroDivide class-instance creation593509
Node: ZeroDivide-accessing593888
Node: ZeroDivide-description594140
Node: Class index594354
Node: Method index605362
Node: Cross-reference805173

End Tag Table
