eXept Software AG Logo

Smalltalk/X Webserver

Documentation of class 'Object':

Home

Documentation
www.exept.de
Everywhere
for:
[back]

Class: Object


Inheritance:

   nil
   |
   +--Object
      |
      +-- ... almost every other class ...

Package:
stx:libbasic
Category:
Kernel-Objects
Version:
rev: 1.916 date: 2018/05/25 10:46:21
user: cg
file: Object.st directory: libbasic
module: stx stc-classLibrary: libbasic
Author:
Claus Gittinger

Description:


Object is the superclass of most other classes.
(except for nil-subclasses, which inherit nothing,
 to catch any message into their #doesNotUnderstand: method)

Protocol which is common to every object is defined here.
Also some utility stuff (like notify) and error handling is implemented here.

Object has no instance variables (and may not get any added). One reason is, that
UndefinedObject and SmallInteger are also inheriting from Object - these two cannot
have instance variables (due to their implementation).
The other reason is that the runtime system (VM) knows about the layout of some built-in
classes (think of Class, Method, Block and also Integer or Float).
If you were allowed to add instance variables to Object, the VM had to be recompiled
(and also rewritten in some places).

[Class variables:]

     ErrorSignal     <Signal>        Signal raised for error/error: messages
                                     also, parent of all other signals.

     HaltSignal      <Signal>        Signal raised for halt/halt: messages

     MessageNotUnderstoodSignal      Signals raised for various error conditions
     UserInterruptSignal
     RecursionInterruptSignal
     ExceptionInterruptSignal
     SubscriptOutOfBoundsSignal
     NonIntegerIndexSignal
     NotFoundSignal
     KeyNotFoundSignal
     ElementOutOfBoundsSignal
     InformationSignal
     WarningSignal
     DeepCopyErrorSignal
     InternalErrorSignal

     AbortSignal      <Signal>       Signal raised by debugger, to abort a computation
                                     BUT, the debugger will only raise it if it is handled.
                                     By handling the abortSignal, you can control where the
                                     debuggers abort-function resumes execution in case of
                                     an error.

     ErrorRecursion   <Boolean>      controls behavior when recursive errors occur (i.e.
                                     an error while handling an error).

     Dependencies     <WeakDependencyDictionary>
                                     keeps track of object dependencies.

     InfoPrinting     <Boolean>      controls weather informational messages
                                     are printed.

     ActivityNotificationSignal <QuerySignal>
                                      raised on #activityNotification:

     NonWeakDependencies <Dictionary> keeps track of object dependencies.
                                      Dependents stay alive.

     SynchronizationSemaphores <WeakIdentityDictionary>
                                      Semaphores for per-object-monitor.


Class protocol:

Compatibility-ST80
o  rootError
return the signal used for error/error: - handling.
Same as errorSignal for ST80 compatibility.

Signal constants
o  abortAllSignal
return the signal used to abort user actions (much like AbortSignal).
This signal is supposed to abort multiple operation actions, and get out of
the loop (such as when confirming multiple class deletions etc.)

o  abortSignal
return the signal used to abort user actions. This signal is only
raised if caught (by the debugger), and will lead way out of the
currently active doIt/printIt or inspectIt. (also some others use
this for a save abort)

o  activityNotificationSignal
return the signal used for activity notifications.
A handler for this signal gets all #activityNotification: sends

o  ambiguousMessageSignal
return the signal used for ambiguousMessage: - error handling

o  conversionErrorSignal
return the signal used for conversion error handling

o  deepCopyErrorSignal
return the signal raised when a deepcopy is asked for
an object which cannot do this (for example, BlockClosures
or Contexts).

o  elementOutOfBoundsSignal
return the signal used for element error reporting
(this signal is used for example when a value not in 0..255 is to
be put into a bytearray)

o  errorSignal
return the signal used for error/error: - handling

o  haltSignal
return the signal used for halt/halt: - handling

o  indexNotFoundSignal
return the signal used for bad index error reporting.
This is also the parentSignal of the nonIntegerIndex- and
subscriptOutOfBoundsSignal

o  informationSignal
return the signal used for informations.
A handler for this signal gets all #information: sends

o  internalErrorSignal
return the signal used to report internal (VM-) errors.

o  keyNotFoundSignal
return the signal used for no such key error reporting

o  messageNotUnderstoodSignal
return the signal used for doesNotUnderstand: - error handling

o  nonIntegerIndexSignal
return the signal used for bad subscript error reporting

o  notFoundSignal
return the signal used for no element found error reporting

o  notifySignal
return the parent of all notification signals.

o  osSignalInterruptSignal
return the signal used for OS-signal error reporting;
This is only raised if handled - otherwise, a debugger is entered.

o  primitiveFailureSignal
return the signal used for primitiveFailed - error handling

o  privateMethodSignal
return the signal used for privateMethod - error handling

o  recursionInterruptSignal
return the signal used for recursion overflow error handling

o  recursiveStoreStringSignal
return the notification used to report storeString generation of recursive objects

o  subclassResponsibilitySignal
return the signal used for subclassResponsibility error reporting.
(this signal is used to signal incomplete subclasses - i.e. a programmers error)

o  subscriptOutOfBoundsSignal
return the signal used for subscript error reporting.
(this signal is used for example when an array is accessed with an
index less than 1 or greater than the array size)

o  userInterruptSignal
return the signal used for ^C interrupts handling

o  userNotificationSignal
the parent signal used with information and warnings.
Handling this allows handling of both information- and warning notifications.

o  warningSignal
return the signal used for warnings.
A handler for this signal gets all #warn: sends

info messages
o  infoPrinting
return the flag which controls information messages.

o  infoPrinting: aBoolean
turn on/off printing of information messages.
If the argument, aBoolean is false, infoPrint will not output
messages. The default is true.

initialization
o  initSignals
called only once - initialize signals
usage example(s):
     Object initSignals

o  initialize
called only once - initialize signals
usage example(s):
initialize InfoPrinting to the VM's infoPrint setting
usage example(s):
Object initialize

queries
o  isAbstract
Return if this class is an abstract class.
True is returned for Object here; false for subclasses.
Abstract subclasses must redefine this again.

o  isBuiltInClass
return true if this class is known by the run-time-system,
i.e. you cannot add/remove instance variables without recompiling
the VM.
Here, true is returned for myself, false for subclasses.


Instance protocol:

Compatibility-Dolphin
o  stbFixup: anSTBInFiler at: newObjectIndex
( an extension from the stx:libcompat package )
Answer the true object that must be used to represent the receiver when read from anSTBInFiler.
Typically this is overridden by subclasses of STBProxy to answer the proxied object. Other classes
may also override this method to effectively 'one way become' the receiver to some other object

o  trigger: anAspect
( an extension from the stx:libbasic2 package )

o  trigger: anAspect with: anArgument
( an extension from the stx:libbasic2 package )

o  when: anAspect sendTo: anObject
( an extension from the stx:libbasic2 package )

Compatibility-GNU
o  display
print the receiver on the standard output stream (which is not the Transcript).
Added for GNU-ST compatibility

o  displayNl
print the receiver followed by a cr on the standard output stream (which is not the Transcript).
Added for GNU-ST compatibility

Compatibility-ST/V
o  implementedBySubclass
( an extension from the stx:libcompat package )
this is sent by ST/V code - it's the same as #subclassResponsibility

o  invalidMessage
( an extension from the stx:libcompat package )
this is sent by ST/V code - it is the same as #shouldNotImplement

Compatibility-ST80
o  isMetaclass
same as isMeta for ST80/Squeak and VW compatibility.
kept in the libbasic package, because it is used often

Compatibility-Squeak
o  becomeForward: anotherObject
( an extension from the stx:libcompat package )
same as becomeSameAs:, but Squeak naming

o  becomeForward: anotherObject copyHash: copyHash
( an extension from the stx:libcompat package )

o  caseError
( an extension from the stx:libcompat package )
Report an error from an in-line or explicit case statement.

o  caseOf: cases
( an extension from the stx:libcompat package )
The elements of cases are associations between blocks.
Answer the evaluated value of the first association in cases
whose evaluated key equals the receiver.
If no match is found, report an error.
usage example(s):
possible, but not inline compiled (i.e. slow)
        | z | 
        z := {
                [#a]->[1+1]. 
                ['b' asSymbol]->[2+2]. 
                [#c]->[3+3]
             }. 
        #b caseOf: z.

        z := {
                [#a]->[1+1]. 
                ['d' asSymbol]->[2+2]. 
                [#c]->[3+3]
             }. 
        #b caseOf: z
usage example(s):
The following are compiled in-line (in the BytecodeCompiler:
        #b caseOf: {
            [#a]->[1+1]. 
            ['b' asSymbol]->[2+2]. 
            [#c]->[3+3]
        }.
        #b caseOf: {
            [#a]->2. 
            ['d' asSymbol]->3. 
            [#c]->4
        }.

o  caseOf: cases otherwise: otherwise
( an extension from the stx:libcompat package )
The elements of cases are associations between blocks.
Answer the evaluated value of the first association in cases
whose evaluated key equals the receiver.
If no match is found, answer the result
of evaluating the otherwise block.
usage example(s):
The following are compiled in-line (in the BytecodeCompiler:
        #b caseOf: {
            [#a]->[1+1]. 
            ['b' asSymbol]->[2+2]. 
            [#c]->[3+3]
        } otherwise: [0].

        #b caseOf: {
            [#a]->2. 
            ['d' asSymbol]->4. 
            [#c]->9
        } otherwise: [999]

o  clone

o  comeFullyUpOnReload: smartRefStream
( an extension from the stx:libcompat package )
Normally this read-in object is exactly what we want to store. 7/26/96 tk

o  copyTwoLevel
one more level than a shallowCopy

o  deepFlattenInto: stream
( an extension from the stx:libcompat package )

o  explore
( an extension from the stx:libcompat package )

o  inform: aString
( an extension from the stx:libcompat package )
Display a message for the user to read and then dismiss.

o  isCompiledMethod
same as isMethod - for squeak compatibility

o  isInMemory
( an extension from the stx:libcompat package )
All normal objects are.

o  objectForDataStream: stream
( an extension from the stx:libcompat package )

o  perform: selector withEnoughArguments: anArray
( an extension from the stx:libcompat package )
Send the selector, aSymbol, to the receiver with arguments in argArray.
Only use enough arguments for the arity of the selector; supply nils for missing ones.

Note: This method is from Pharo 1.4 - do not use in Smalltalk/X code

o  readDataFrom: aDataStream size: varsOnDisk
( an extension from the stx:libcompat package )
Fill in the fields of self based on the contents of aDataStream. Return self.
Read in the instance-variables written by Object>>storeDataOn:.
NOTE: This method must send beginReference: before reading any objects from aDataStream that might reference it.
Allow aDataStream to have fewer inst vars. See SmartRefStream.
usage example(s):
If we ever return something other than self, fix calls
            on (super readDataFrom: aDataStream size: anInteger)

o  storeDataOn: aDataStream
( an extension from the stx:libcompat package )
Store myself on a DataStream.
Answer self.
This is a low-level DataStream/ReferenceStream method.
See also objectToStoreOnDataStream.
NOTE: This method must send 'aDataStream beginInstance:size:' and then (nextPut:/nextPutWeak:) its subobjects.
readDataFrom:size: reads back what we write here.

o  stringForReadout
( an extension from the stx:libcompat package )

o  stringRepresentation
( an extension from the stx:libcompat package )
Answer a string that represents the receiver. For most objects this is simply its printString, but for strings themselves, it's themselves. 6/12/96 sw

o  veryDeepCopy

Compatibility-VW
o  isCharacters
true, if the receiver is a string-like thing.
added for visual works compatibility

o  isSignalledException
VW compatibility

o  keyNotFoundError: aKey
VW compatibility

o  oneWayBecome: anotherObject
( an extension from the stx:libcompat package )
|arr o1 o2|

arr := Array new:2.
arr at:1 put:(o1 := Object new).
arr at:2 put:(o2 := Point new).
o1 oneWayBecome:o2.
(arr at:1) ~~ o2 ifTrue:[self halt].

Javascript support
o  js_addFromString: aString
( an extension from the stx:libjavascript package )
For JavaScript only:
Generated for +-operator in javascript.

o  js_asBoolean
( an extension from the stx:libjavascript package )

o  js_at: index
( an extension from the stx:libjavascript package )
JS uses 0-based indexing

o  js_at: index put: something
( an extension from the stx:libjavascript package )
JS uses 0-based indexing

o  js_length
( an extension from the stx:libjavascript package )

o  js_new
( an extension from the stx:libjavascript package )
redefinable JS-new (for datatypes and ctypes, this is required in the inst side

o  js_new: size
( an extension from the stx:libjavascript package )
redefinable JS-new (for datatypes and ctypes, this is required in the inst side

o  typeof
( an extension from the stx:libjavascript package )
return a string describing what I am
usage example(s):
     JavaScriptParser
	evaluate:'''hello''.typeof()'

     JavaScriptParser
	evaluate:'1234.typeof()'

accessing
o  _at: index
experimental:
this is a synthetic selector, generated by the compiler,
if a construct of the form expr[idx...] is parsed.
I.e.
v[n]
generates
v _at: n

o  _at: index put: value
experimental:
this is a synthetic selector, generated by the compiler,
if a construct of the form expr[idx...] is parsed.
I.e.
v[n]
generates
v _at: n

o  addSlot: slotName
dynamically add a new slot to the receiver.
The receiver must be a real object, not nil or a smallInteger

o  at: index
return the indexed instance variable with index, anInteger;
this method can be redefined in subclasses.

o  at: index put: anObject
store the 2nd arg, anObject as indexed instvar with index, anInteger.
this method can be redefined in subclasses. Returns anObject (sigh)

o  basicAt: index
return the indexed instance variable with index, anInteger.
Trigger an error if the receiver has no indexed instance variables.
This method should NOT be redefined in any subclass (except with great care, for tuning)

o  basicAt: index put: anObject
store the 2nd arg, anObject as indexed instvar with index, anInteger.
Returns anObject (sigh).
Trigger an error if the receiver has no indexed instance variables.

This method should NOT be redefined in any subclass (except with great care, for tuning)

o  byteAt: index
return the byte at index.
This is only allowed for non-pointer indexed objects
(i.e. byteArrays, wordArrays, floatArrays etc.).
The receiver's indexed instvars are treated as an uninterpreted
collection of bytes.
Only useful with binary storage.
usage example(s):
     Point new byteAt:1
     (ByteArray with:1 with:2) byteAt:2
     (WordArray with:1) byteAt:1
     (WordArray with:1) byteAt:2
     (FloatArray with:1.0) byteAt:2
     'hello' byteAt:1

o  byteAt: index put: byteValue
set the byte at index.
This is only allowed for non-pointer indexed objects
(i.e. byteArrays, wordArrays, floatArrays etc.).
The receiver's indexed instvars are treated as an uninterpreted
collection of bytes.
Only useful with binary storage.
usage example(s):
     (ByteArray with:1 with:2) byteAt:2 put:3; yourself
     'hello' copy byteAt:1 put:105; yourself

o  instVarAt: index
return a non-indexed instance variable;
peeking into an object this way is not very object oriented
- use with care (needed for copy, inspector etc.)

o  instVarAt: index put: value
change a non-indexed instance variable;
peeking into an object this way is not very object oriented
- use with care (needed for copy, inspector etc.)

o  instVarNamed: name
return a non-indexed instance variables value by name;
peeking into an object this way is not very object oriented
- use with care if at all (provided for inspectors and memory usage monitor).
Notice, this access is very slow (because the classes instVar-description has to be
parsed ad runtime)

o  instVarNamed: name ifAbsent: exceptionBlock
return a non-indexed instance variables value by name,
or the value of exceptionBlock, if there is no such instance variable.
peeking into an object this way is not very object oriented
- use with care if at all (provided for inspectors and memory usage monitor).
Notice, this access is very slow (because the classes instVar-description has to be
parsed ad runtime)

o  instVarNamed: name put: value
set a non-indexed instance variable by name;
peeking into an object this way is not very object oriented
- if at all, use with care (provided for protocol completeness).
Notice, this access is very slow (because the classes instVar-description has to be
parsed ad runtime)

o  instVarNamed: name put: anObject ifAbsent: exceptionBlock
return a non-indexed instance variables value by name,
or the value of exceptionBlock, if there is no such instance variable.
peeking into an object this way is not very object oriented
- use with care if at all (provided for inspectors and memory usage monitor).
Notice, this access is very slow (because the classes instVar-description has to be
parsed ad runtime)

o  nilAllInstvars
overwrite all inst vars of the object with nil.
Used by the crypto package to clear objects with
keys when no longer in use.
usage example(s):
      'abcdef' copy nilAllInstvars
      100 factorial nilAllInstvars

attributes access
o  objectAttributeAt: attributeKey
return the attribute for a given key or nil if not found.
Such attributes behave like dynamically addable slots in languages like JavaScript.
They are much more expensive though, because they are not a ''natural'' mechanism in Smalltalk,
but instead simulated via an additional objectAttributes collection mechanism, which
defaults to using a dictionary holding per instance attributes.
So only use it for seldom needed/seldom assigned attributes,
and only if it is not easy to add an instance variable or class-private mechanism for that.

o  objectAttributeAt: attributeKey put: anObject
store the attribute anObject referenced by key into the receiver.
Such attributes behave like dynamically addable slots in languages like JavaScript.
They are much more expensive though, because they are not a ''natural'' mechanism in Smalltalk,
but instead simulated via an additional objectAttributes collection mechanism, which
defaults to using a dictionary holding per instance attributes.
So only use it for seldom needed/seldom assigned attributes,
and only if it is not easy to add an instance variable or class-private mechanism for that.
usage example(s):
Attaching additional attributes (slots) to an arbitrary object:

     |p|

     p := Point new.
     p objectAttributeAt:#color put:#green.

     p objectAttributeAt:#color

o  objectAttributes
return a Collection of attributes - nil if there is none.

The default implementation here uses a global WeakDictionary to store attributes
This may be too slow for high frequency slot access,
therefore, some classes may redefine this for better performance.
Notice the mentioning of a WeakDictionary - read the classes documentation.

o  objectAttributes: aCollection
set the collection of attributes.

The default implementation here uses a global Dictionary to store
attributes which may be too slow for high frequency change&update.
Therefore, some classes may redefine this for better performance.

o  removeObjectAttribute: attributeKey
remove an object attribute;
return the value previously stored there, or nil.
(make the argument, anObject be no longer an attribute of the receiver)

change & update
o  broadcast: aSelectorSymbol
send a message with selector aSelectorSymbol to all my dependents

o  broadcast: aSelectorSymbol with: anArgument
send a message with selector aSelectorSymbol with an additional
argument anArgument to all my dependents.

o  changeRequest
the receiver wants to change - check if all dependents
grant the request, and return true if so

o  changeRequest: aSymbol
the receiver wants to change - check if all dependents
grant the request, and return true if so

o  changeRequest: aSymbol from: anObject
the receiver wants to change - check if all dependents
except anObject grant the request, and return true if so.
The argument anObject is typically going to be the one who is
about to send the change request.

o  changeRequest: aSymbol with: aParameter
the receiver wants to change - check if all dependents
grant the request, and return true if so

o  changeRequest: aSymbol with: aParameter from: anObject
the receiver wants to change - check if all dependents
except anObject grant the request, and return true if so.
The argument anObject is typically going to be the one who is
about to send the change request.

o  changeRequestFrom: anObject
the receiver wants to change - check if all dependents
except anObject grant the request, and return true if so.
The argument anObject is typically going to be the one who is
about to send the change request.

o  changed
notify all dependents that the receiver has changed.
Each dependent gets a '#update:'-message with the original
receiver as argument.

o  changed: aParameter
notify all dependents that the receiver has changed somehow.
Each dependent gets a '#update:'-message with aParameter
as argument.

o  changed: aParameter with: anArgument
notify all dependents that the receiver has changed somehow.
Each dependent gets an '#update:with:from:'-message, with aParameter
and anArgument as arguments.

o  update: aParameter
the message is sent to a dependent, when one of the objects
on whom the receiver depends, has changed. The argument aParameter
is either the changed object or the argument to the #changed: message.

Default behavior here is to do nothing

o  update: aParameter with: anArgument
dependent is notified of some change -
Default is to try update:

o  update: aParameter with: anArgument from: sender
dependent is notified of some change -
Default is to try update:with:

o  updateRequest
return true if an update request is granted.
Default here is to grant updates - may be used
to lock updates if someone is making other changes
from within an update. Or if someone has locked its
state and does not want others to change things.
However, these dependents must all honor the
changeRequest - ifTrue - change protocol. I.e. they
must first ask all others via changeRequest, and only do the change
it returns true. The others must decide in updateRequest and
return true if they think a change is ok.

o  updateRequest: aSymbol
return true if an update request is granted.
Default here a simple updateRequest

o  updateRequest: aSymbol with: aParameter
return true if an update request is granted.
Default here a simple updateRequest

o  updateRequest: aSymbol with: aParameter from: sender
return true if an update request is granted.
Default here a simple updateRequest

o  withoutUpdating: someone do: aBlock
evaluate a block but remove someone from my dependents temporarily

comanche
o  asHtmlDocumentForRequest: aNetworkRequest
( an extension from the stx:goodies/webServer/comanche package )

o  asHtmlElement
( an extension from the stx:goodies/webServer/comanche package )
answer my HTML representation (String),
as I would look like inside an HTML document

o  asHtmlElementIn: htmlContainer
( an extension from the stx:goodies/webServer/comanche package )
answer my HTML representation (String),
as I would look like inside htmlContainer

o  asHttpResponseTo: anHttpRequest
( an extension from the stx:goodies/webServer/comanche package )

o  comancheUrl
( an extension from the stx:goodies/webServer/comanche package )

o  makeAvailableInComanche
( an extension from the stx:goodies/webServer/comanche package )
force putting the object on the ObjUrlMap list

o  mimeType
( an extension from the stx:goodies/webServer/comanche package )

comparing
o  = anObject
return true if the receiver and the arg have the same structure.
Notice:
This method is partially open coded (inlined) by the compiler(s)
identical objects are always considered equal.
redefining it may not work as expected.

o  == anObject
return true if the receiver and the arg are the same object.
Never redefine this in any class.
Notice:
This method is open coded (inlined) by the compiler(s)
- redefining it may not work as expected.

o  deepSameContentsAs: anObject
return true if the receiver and the arg have the same contents
in both the named instance vars and any indexed instVars.
This method descends into referenced objects, where #sameContentsAs: does not descend
usage example(s):
     #(1 2 3 4) deepSameContentsAs:#[1 2 3 4] asArray
     (1@2) deepSameContentsAs:(1->2)

o  hash
return an Integer useful as a hash key for the receiver.
This hash should return same values for objects with same
contents (i.e. use this to hash on structure)

o  identityHash
return an Integer useful as a hash key for the receiver.
This hash should return same values for the same object (i.e. use
this to hash on identity of objects).

We cannot use the Objects address (as other smalltalks do) since
no object-table exists and the hashval must not change when objects
are moved by the collector. Therefore we assign each object a unique
Id in the object header itself as its hashed upon.
(luckily we have 11 bits spare to do this - unluckily its only 11 bits).
Time will show, if 11 bits are enough; if not, another entry in the
object header will be needed, adding 4 bytes to every object. Alternatively,
hashed-upon objects could add an instvar containing the hash value.

o  identityHashForBinaryStore
hash which is usable if the object does not change its class
and does not #become something else, while the hash is used.
This is only used by the binary storage mechanism, during the
object writing phase.

o  sameContentsAs: anObject
return true if the receiver and the arg have the same contents
in both the named instance vars and any indexed instVars.
The code here only checks if values present in the receiver are also
present in the arg, not vice versa.
I.e. the argument may be bigger and/or have more instance variables.
usage example(s):
     #(1 2 3 4) sameContentsAs:#[1 2 3 4] asArray
     (1@2) sameContentsAs:(1->2)

o  ~= anObject
return true if the receiver and the arg do not have the same structure.
Notice:
This method is partially open coded (inlined) by the compiler(s)
identical objects are never considered unequal.
redefining it may not work as expected.

o  ~~ anObject
return true if the receiver and the arg are not the same object.
Never redefine this in any class.
Notice:
This method is open coded (inlined) by the compiler(s)
- redefining it may not work as expected.

converting
o  -> anObject
return an association with the receiver as key and
the argument as value

o  as: aSimilarClass
If the receiver's class is not aSimilarClass,
create and return an instance of aSimilarClass that has the same contents
as the receiver.
Otherwise, return the receiver.
usage example(s):
     #[1 2 3 4] as:ByteArray
     #[1 2 3 4] as:Array
     #[81 82 83 84] as:String
     #[81 82 83 84] as:Symbol
     'hello' as:Unicode16String

o  asCollection
return myself as a Collection.
Redefined in collection to return themself.

o  asDoubleLink
( an extension from the stx:libbasic2 package )
return a valueDoubleLink for the receiver.
Used to make sure the receiver can be added to a double linked list

o  asLink
return a valueLink for the receiver.
Used to make sure the receiver can be added to a linked list

o  asSequenceableCollection
return myself as a SequenceableCollection.
Redefined in SequenceableCollection

o  asString

o  asValue
return a valueHolder for the receiver

copying
o  cloneFrom: anObject
Helper for copy:
copy all instance variables from anObject into the receiver,
which should be of the same class as the argument.

o  cloneFrom: anObject performing: aSymbol
Helper for copy:
for each instance variable from anObject, send it aSymbol
and store the result into the receiver,
which should be of the same class as the argument.

o  cloneInstanceVariablesFrom: aPrototype
Shallow copy variables from a prototype into myself.
This copies instVars by name - i.e. same-named variables are
copied, others are not.
The variable slots are copied as available
(i.e. the min of both indexed sizes is used).
usage example(s):
     Class withoutUpdatingChangesDo:[
        |point3D|

        point3D := Point subclass:#Point3D
           instanceVariableNames:'z'
           classVariableNames:''
           poolDictionaries:''
           category:'testing'
           inEnvironment:nil.
         (point3D new cloneInstanceVariablesFrom:1@2) inspect.
     ]
usage example(s):
     Class withoutUpdatingChangesDo:[
         Point variableSubclass:#Point3D_test
           instanceVariableNames:'z'
           classVariableNames:''
           poolDictionaries:''
           category:'testing'.
         (((Smalltalk at:#Point3D_test) new:2) cloneInstanceVariablesFrom:#(1 2 3)) inspect.
     ]

o  copy
return a copy of the receiver - defaults to shallowcopy here.
Notice, that copy does not copy dependents.

o  copyToLevel: level
a controlled deepCopy, where the number of levels can be specified.
Notice:
This method DOES NOT handle cycles/self-refs and does NOT preserve object identity;
i.e. identical references in the source are copied multiple times into the copy.

o  deepCopy
return a copy of the object with all subobjects also copied.
This method DOES handle cycles/self-refs and preserves object identity;
however the receiver's class is not copied (to avoid the 'total' copy).

This deepCopy is a bit slower than the old (unsecure) one, since it
keeps track of already copied objects. If you are sure, that your
copied object does not include duplicates (or you do not care) and
no cycles are involved, you can use the old simpleDeepCopy,
which avoids this overhead (but may run into trouble).
Notice, that deepCopy does not copy dependents.

o  deepCopyError
raise a signal, that deepCopy is not allowed for this object

o  deepCopyUsing: aDictionary
a helper for deepCopy; return a copy of the object with
all subobjects also copied. If the to-be-copied object is in the dictionary,
use the value found there. The class of the receiver is not copied.
This method DOES handle cycles/self references.

o  deepCopyUsing: aDictionary postCopySelector: postCopySelector
a helper for deepCopy; return a copy of the object with
all subobjects also copied. If the to-be-copied object is in the dictionary,
use the value found there. The class of the receiver is not copied.
This method DOES handle cycles/self references.

o  postCopy
this is for compatibility with ST-80 code, which uses postCopy for
cleanup after copying, while ST/X passes the original in postCopyFrom:
(see there)

o  postDeepCopy
allows for cleanup after deep copying.
To be redefined in subclasses.

o  postDeepCopyFrom: aSource
allows for cleanup after deep copying

o  setHashFrom: anObject
set my identity-hash key to be the same as anObjects hash key.
This is an ST/X speciality, which is NOT available in other (especially OT based)
Smalltalks, and may not be available in future ST/X versions.
DO NEVER use this for normal application code.

o  shallowCopy
return a copy of the object with shared subobjects (a shallow copy)
i.e. the copy shares referenced instvars with its original.

o  simpleDeepCopy
return a copy of the object with all subobjects also copied.
This method does NOT handle cycles - but is included to allow this
slightly faster copy in situations where it is known that
no recursive references occur (LargeIntegers for example).
NOTICE: you will run into trouble, when trying this with recursive
objects (usually recursionInterrupt or memory-alert).
This method corresponds to the 'traditional' deepCopy found in the Blue book.

o  skipInstvarIndexInDeepCopy: index
a helper for deepCopy; only indices for which this method returns
false are copied in a deep copy.
The default is false here - which means that everything is copied.
Can be redefined in subclasses for partial copies

o  slowShallowCopy
return a copy of the object with shared subobjects (a shallow copy)
i.e. the copy shares referenced instvars with its original.
This method is only invoked as a fallback from #shallowCopy.

debugging
o  assert: aBooleanOrBlock
fail and report an error, if the argument does not evaluate to true
usage example(s):
     self assert:false

o  assert: aBooleanOrBlock description: messageIfFailing
fail, if the argument does not evaluate to true and report an error
usage example(s):
     self assert:false description:'xxx'

o  assert: aBooleanOrBlock message: messageIfFailing
fail, if the argument does not evaluate to true and report an error
usage example(s):
     self assert:false message:'xxx'

o  basicInspect
launch an inspector on the receiver.
this method should NOT be redefined in subclasses.

o  breakPoint: someKey
Like halt, but disabled by default.
Can be easily enabled.
Can be filtered on the arguments value (typically: a symbol).
Code with breakpoints may be even checked into the source repository
usage example(s):
don't send #breakPoint:info: here - ask cg why.
usage example(s):
     nil breakPoint:#stefan
     nil breakPoint:#stefan info:'Hello'
     Smalltalk enableBreakPoint:#stefan.
     Smalltalk disableBreakPoint:#stefan.

     EncounteredBreakPoints.
     Smalltalk enableBreakPoint:#cg.
     Smalltalk disableBreakPoint:#cg.
     Smalltalk enableBreakPoint:#expecco.
     Smalltalk disableBreakPoint:#cg.

o  breakPoint: someKey info: infoString
Like halt, but disabled by default.
Can be easily enabled.
Can be filtered on the arguments value (typically: a symbol).
Code with breakpoints may be even checked into the source repository

o  debuggingCodeFor: someKey is: aBlock
aBlock is evaluated if breakPoints for somekey are enabled.
Allows for debugging code to be enabled/disabled via the breakpoint browser.
Can be easily enabled.
Can be filtered on the arguments value (typically: a symbol).
Code with breakpoints may be even checked into the source repository
usage example(s):
     Smalltalk disableBreakPoint:#cg.
     nil debuggingCodeFor:#cg is:[ Transcript showCR:'here is some debug message for cg' ].
     nil debuggingCodeFor:#stefan is:[ Transcript showCR:'here is some debug message for sv' ].
     Smalltalk enableBreakPoint:#cg.
     nil debuggingCodeFor:#cg is:[ Transcript showCR:'here is some debug message for cg' ].
     nil debuggingCodeFor:#stefan is:[ Transcript showCR:'here is some debug message for sv' ].
     Smalltalk disableBreakPoint:#cg.

o  disableAllBreakPoints
disable all parametrized breakPoints (with any key as parameter)
usage example(s):
     nil enableBreakPoint:#cg.
     nil breakPoint:#cg.
     nil disableAllBreakPoints.
     nil breakPoint:#cg.

o  disableBreakPoint: someKey
disable parametrized breakPoints with someKey as parameter
usage example(s):
     nil enableBreakPoint:#cg.
     nil breakPoint:#cg.
     nil disableBreakPoint:#cg
     nil breakPoint:#cg.

o  enableBreakPoint: someKey
enable parametrized breakPoints with someKey as parameter
usage example(s):
     nil enableBreakPoint:#cg.
     nil breakPoint:#cg.
     nil disableBreakPoint:#cg
     nil breakPoint:#cg.

o  halt
enter debugger with halt-message.
The error is reported by raising the HaltSignal exception.
usage example(s):
enter debugger with halt-message.
     The error is reported by raising the HaltSignal exception.
usage example(s):
don't send #halt: here - ask cg why.
usage example(s):
        (3 halt * 5)

o  halt: aString
enter debugger with halt-message.
The error is reported by raising the HaltSignal exception.

o  haltIfNil
halt if the receiver is nil
usage example(s):
     3 haltIfNil
     nil haltIfNil

o  isBreakPointEnabled: someKey
controls which breakpoints to be enabled.

o  mustBeBoolean
this message is sent by the VM, if a non-Boolean receiver is encountered
in an if* or while* message.
Caveat: for now, this is only sent by the interpreter;
both the JIT and the stc compiler treat it as undefined.

o  mustBeKindOf: aClass
for compatibility & debugging support:
check if the receiver isKindOf:aClass and raise an error if not.
Notice:
it is VERY questionable, if it makes sense to add manual
type checks to a dynamically typed language like smalltalk.
It will, at least, slow down performance,
make your code less reusable and clutter your code with stupid sends
of this selector. Also, read the comment in isKindOf:, regarding the
use of isXXX check methods.
You see: The author does not like this at all ...

o  newInspector2Tab
( an extension from the stx:libtool package )
return an extra tab to be used inside an inspector

o  obsoleteFeatureWarning
in methods which are going to be changed, a send to
this method is used to tell programmers that some feature/semantics is
used which is going to be changed in later ST/X versions.
Hopefully, this warning message is annoying enough for you to change the code... ;-).

o  obsoleteFeatureWarning: message
in methods which are going to be changed, a send to
this method is used to tell programmers that some feature/semantics is
used which is going to be changed in later ST/X versions.
Hopefully, this warning message is annoying enough for you to change the code... ;-).
This message is intended for application developers, so its printed as info message.

o  obsoleteFeatureWarning: message from: aContext
in methods which are going to be changed, a send to
this method is used to tell programmers that some feature/semantics is
used which is going to be changed in later ST/X versions.
Hopefully, this warning message is annoying enough for you to change the code... ;-).
This message is intended for application developers, so its printed as info message.
usage example(s):
     Object obsoleteFeatureWarning:'foo' from:thisContext sender sender

o  obsoleteMethodWarning
in methods which are going to be obsoleted, a self send to
this method is used to tell programmers that a method is
used which is going to be removed in later ST/X versions.
Find all methods which will be obsolete soon by looking at senders of this message.
Hopefully, this warning message is annoying enough for you to change the code... ;-)

o  obsoleteMethodWarning: message
in methods which are going to be obsoleted, a self send to
this method is used to tell programmers that a method is
used which is going to be removed in later ST/X versions.
Find all methods which will be obsolete soon by looking at senders of this message.
Hopefully, this warning message is annoying enough for you to change the code... ;-)

o  obsoleteMethodWarning: messageOrNil from: aContext
in methods which are going to be obsoleted, a self-send to
this method is used to tell programmers that a method is
used which is going to be removed in later ST/X versions.
Find all methods which will be obsolete soon by looking at senders of this message.
Hopefully, this warning message is annoying enough for you to change the code... ;-).
This message is intended for application developers, so its printed as info message.
usage example(s):
     Object obsoleteMethodWarning:'foo' from:thisContext sender sender

o  todo
used to mark code pieces that have to be implemented.
Halts when reached in development mode;
ignored in deployed production code.

o  todo: aBlock
used to mark code pieces that have to be implemented.
The coe in aBlock is ignored.

o  tracePoint: someKey
Like transcript show, but disabled by default.
Can be easily enabled.
Can be filtered on the arguments value (typically: a symbol).
Code with tracepoints may be even checked into the source repository
usage example(s):
     nil tracePoint:#stefan
     nil tracePoint:#stefan message:'Hello'
     Smalltalk enableBreakPoint:#stefan.
     Smalltalk disableBreakPoint:#stefan.

o  tracePoint: someKey message: messageBlockOrString
Like transcript show, but disabled by default.
Can be easily enabled.
Can be filtered on the arguments value (typically: a symbol).
Code with tracepoints may be even checked into the source repository
usage example(s):
     Smalltalk enableBreakPoint:#stefan.
     nil tracePoint:#stefan.
     nil tracePoint:#stefan message:'Hello'.
     nil tracePoint:#stefan message:['Hello from block'].
     Smalltalk disableBreakPoint:#stefan.

dependents access
o  addDependent: anObject
make the argument, anObject be a dependent of the receiver

o  breakDependents
remove all dependencies from the receiver

o  breakDependentsRecursively
remove all dependencies from the receiver and
recursively from all objects referred to by the receiver.

o  dependents
return a Collection of dependents.
The default implementation here uses a global WeakDictionary to store
dependents
This may be too slow for high frequency change&update,
therefore, some classes (Model) redefine this for better performance.
Notice the mentioning of a WeakDictionary - read the classes documentation.

o  dependents: aCollection
set the collection of dependents.
The default implementation here uses a global Dictionary to store
dependents which may be too slow for high frequency change&update.
Therefore, some classes (Model) redefine this for better performance.

o  dependentsDo: aBlock
evaluate aBlock for all of my dependents

o  myDependents
same as dependents - ST-80 compatibility

o  release
remove all references to objects that may refer to self.
Subclasses may redefine this method but should do a 'super release'.

o  removeDependent: anObject
make the argument, anObject be independent of the receiver

dependents access (non weak)
o  addNonWeakDependent: anObject
make the argument, anObject be a nonWeak dependent of the receiver.
Be careful: this nonWeakDependency will prevent the dependent from being
garbage collected unless the dependency is removed.
This is a private mechanism, for directed dependencies.

o  nonWeakDependents
return a Collection of nonWeakDependents - empty if there is none.
This is a private mechanism for directed dependencies.

o  nonWeakDependents: aCollection
set the collection of nonWeak dependents.
This is a private helper for directed dependencies.

o  removeNonWeakDependent: anObject
remove a nonWeak dependency from the receiver to the argument, anObject.
(i.e. make it independent of the receiver)

dependents-interests
o  addInterest: anInterest
( an extension from the stx:libbasic2 package )
install an interest forwarder.
Here, we use the nonWeakDependencies.

o  expressInterestIn: aspect for: anObject sendBack: aSelector
( an extension from the stx:libbasic2 package )
arrange for aSelector to be sent to anObject whenever the receiver
changes aspect.

o  interests
( an extension from the stx:libbasic2 package )
return a Collection of interests - empty if there is none.
Here, we use the nonWeakDependents for interests.

o  interestsFor: someOne
( an extension from the stx:libbasic2 package )
return a collection of interests of someOne - empty if there is none.

o  onChangeEvaluate: aBlock
( an extension from the stx:libbasic2 package )
arrange for aBlock to be evaluated whenever the receiver changes.

o  onChangeSend: aSelector to: anObject
( an extension from the stx:libbasic2 package )
arrange for aSelector to be sent to anObject whenever the receiver
changes.
Use retractInterestsFor: in case you are no longer interested

o  removeInterest: anInterest
( an extension from the stx:libbasic2 package )
remove an interest forwarder.
Here, we use the nonWeakDependencies.

o  retractInterestIn: aspect for: someOne
( an extension from the stx:libbasic2 package )
remove the interest of someOne in the receiver changing aspect
(as installed with #expressInterestIn:for:sendBack:).
Answer the retracted interests.

o  retractInterests
( an extension from the stx:libbasic2 package )
remove all interests in the receiver changing aspect
(as installed with #expressInterestIn:for:sendBack:).
Answer the retraced interests.

o  retractInterestsFor: someOne
( an extension from the stx:libbasic2 package )
remove the interest of someOne in the receiver
(as installed with #onChangeSend:to:).
Answer the retracted interests.

o  retractInterestsForWhich: aBlock
( an extension from the stx:libbasic2 package )
remove all interests in the receiver changing aspect
(as installed with #expressInterestIn:for:sendBack:).
Answer the retracted interests.

o  retractInterestsIn: aspect
( an extension from the stx:libbasic2 package )
remove all interests in the receiver changing aspect
(as installed with #expressInterestIn:for:sendBack:).
Answer the retracted interests.

dependents-st/v event simulation
o  removeActionsForEvent: eventSymbol
( an extension from the stx:libbasic2 package )
remove ST/V-style event triggers.

o  removeActionsWithReceiver: aReceiver
( an extension from the stx:libbasic2 package )
remove ST/V-style event triggers.

o  removeAllActionsWithReceiver: anObject
( an extension from the stx:libbasic2 package )
remove ST/V-style event triggers.

o  triggerEvent: aSymbol
( an extension from the stx:libbasic2 package )

o  triggerEvent: eventSymbol with: aParameter
( an extension from the stx:libbasic2 package )
perform ST/V-style event triggering.

o  triggerEvent: eventSymbol withArguments: parameters
( an extension from the stx:libbasic2 package )
perform ST/V-style event triggering.

o  when: eventSymbol send: selector to: anObject
( an extension from the stx:libbasic2 package )
install an ST/V-style interest forwarder.
Here, we use the nonWeakDependencies.

o  when: eventSymbol send: selector to: anObject with: aParameter
( an extension from the stx:libbasic2 package )
install an ST/V-style interest forwarder.
Here, we use the nonWeakDependencies.

displaying
o  ascentOn: aGC
when displayed via displayOn:, some objects assume that the given y coordinate
is the baseline (strings, text etc. do), while others assume that the topY
coordinate is given by y.
In other words: some draw above the given y coordinate.
This method returns the number of pixels by which the receiver will draw above
the given y coordinate.

o  classDisplayString
used by walkbacks and inspectors;
same as self class displayString for smalltalk objects;
redefinable for proxy objects to not display the className of the proxy,
but the classname of the remote object (-> JavaObject)

o  displayOn: aGCOrStream
Compatibility
append a printed desription on some stream (Dolphin, Squeak)
OR:
display the receiver in a graphicsContext at 0@0 (ST80).
This method allows for any object to be displayed in some view
(although the fallBack is to display its printString ...)

o  displayOn: aGC at: aPoint
ST-80 Compatibility
display the receiver in a graphicsContext - this method allows
for any object to be displayed in a ListView - for example.

o  displayOn: aGC x: x y: y
display the receiver in a graphicsContext - this method allows
for any object to be displayed in a ListView - for example.

o  displayOn: aGc x: x y: y opaque: opaque
display the receiver in a graphicsContext - this method allows
for any object to be displayed in a ListView - for example.
The fallBack here shows the receiver's displayString.
Notice, that the string is displayed on the baseLine;
ask using #ascentOn: if required

o  displayOpaqueOn: aGC x: x y: y
display the receiver in a graphicsContext - this method allows
for any object to be displayed in a ListView - for example.

o  displayString
return a string used when displaying the receiver in a view;
for example an Inspector. This is usually the same as printString,
but sometimes redefined for a better look.

Note: the base method (used by the inspector) is #displayOn:.
So you should implement #displayOn: instead of #displayString in subclasses.
usage example(s):
     #(1 2 3) printString
     #(1 2 3) displayString
     #(1 2 3) storeString

o  heightOn: aGC
return the height of the receiver, if it is to be displayed on aGC

o  printStringForPrintIt
for compatibility (used to be displayString), now the printIt menu function now sends this message
usage example(s):
     #(1 2 3) printString
     #(1 2 3) printStringForPrintIt
     #(1 2 3) storeString

o  widthFrom: startIndex to: endIndex on: aGC
return the width of the receiver, if it is to be displayed on aGC

o  widthOn: aGC
return the width of the receiver, if it is to be displayed on aGC

double dispatching
o  equalFromComplex: aComplex
adding this method here allows for any non-number to be compared to a complex
and return false from this comparison.
Reason: we want to be able to put both numbers and non-numbers into a collection
which uses #= (i.e. a Set or Dictionary).

o  equalFromFixedPoint: aFixedPoint
adding this method here allows for any non-number to be compared to a fixedPoint
and return false from this comparison.
Reason: we want to be able to put both numbers and non-numbers into a collection
which uses #= (i.e. a Set or Dictionary).

o  equalFromFloat: aFloat
adding this method here allows for any non-number to be compared to a float
and return false from this comparison.
Reason: we want to be able to put both numbers and non-numbers into a collection
which uses #= (i.e. a Set or Dictionary).

o  equalFromFraction: aFraction
adding this method here allows for any non-number to be compared to a fraction
and return false from this comparison.
Reason: we want to be able to put both numbers and non-numbers into a collection
which uses #= (i.e. a Set or Dictionary).

o  equalFromInteger: anInteger
adding this method here allows for any non-number to be compared to an integer
and return false from this comparison.
Reason: we want to be able to put both numbers and non-numbers into a collection
which uses #= (i.e. a Set or Dictionary).

o  equalFromLargeFloat: aLargeFloat
adding this method here allows for any non-number to be compared to a largeFloat
and return false from this comparison.
Reason: we want to be able to put both numbers and non-numbers into a collection
which uses #= (i.e. a Set or Dictionary).

o  equalFromLongFloat: aLongFloat
adding this method here allows for any non-number to be compared to a longFloat
and return false from this comparison.
Reason: we want to be able to put both numbers and non-numbers into a collection
which uses #= (i.e. a Set or Dictionary).

o  equalFromShortFloat: aShortFloat
adding this method here allows for any non-number to be compared to a shortFloat
and return false from this comparison.
Reason: we want to be able to put both numbers and non-numbers into a collection
which uses #= (i.e. a Set or Dictionary).

encoding & decoding
o  decodeAsLiteralArray
given a literalEncoding in the receiver,
create & return the corresponding object.
The inverse operation to #literalArrayEncoding.

o  encodeOn: anEncoder with: aParameter
not used any longer. Kept for backward comaptibility

** This is an obsolete interface - do not use it (it may vanish in future versions) **

o  encodingVectorForInstanceVariables
OBSOLETE, use elementDescriptorForInstanceVariables

** This is an obsolete interface - do not use it (it may vanish in future versions) **

o  encodingVectorForNonNilInstanceVariables
OBSOLETE, use elementDescriptorForNonNilInstanceVariables

** This is an obsolete interface - do not use it (it may vanish in future versions) **

o  fromLiteralArrayEncoding: aSpecArray
read my attributes from aSpecArray.
Recursively decodes arguments.

o  literalArrayEncoding
generate a literalArrayEncoding array for myself.
This uses #literalArrayEncodingSlotOrder which defines the slots and
order and #skippedInLiteralEncoding which defines slots to skip.
For most subclasses, there is no need to redefine those.
usage example(s):
        (1 -> 2) literalArrayEncoding
        DebugView menuSpec decodeAsLiteralArray literalArrayEncoding  =
           DebugView menuSpec

o  literalArrayEncodingSlotOrder
define the order in which inst-slots are saved when generating
a literalArrayEncoding

o  postDecodeFrom: aDecoder aspect: aspectSymbol
invoked by xmlDecoder (and others in the future), after an
object has been decoded (i.e. its instance variables have been restored)

o  skippedInLiteralEncoding
return a Collection with it's elements are slots for skipping

error handling
o  abortOperation
raise the AbortOperationRequest signal.
This will unwind and bring the current thread back to the event-handling loop,
effectively aborting any current menu, user, doIt, printIt or other operation.

o  ambiguousMessage: aMessage
this message is sent by the system in case that it
is not clear which method to execute in response to
aMessage.
Such situation may occur when a current selector namespace
imports two namespaces and both define a method with the
requested selector.

o  cannotSendMessage: aMessage to: someReceiver
this message is sent by the runtime system (VM),
when a message is sent to some object, whose class is not
a valid behavior (see documentation in Behavior).

o  conversionErrorSignal
return the signal used for conversion error handling

o  doesNotUnderstand: aMessage
this message is sent by the runtime system (VM) when
a message is not understood by some object (i.e. there
is no method for that selector). The original message has
been packed into aMessage (i.e. the receiver, selector and
any arguments) and the original receiver is then sent the
#doesNotUnderstand: message.
Here, we raise another signal which usually enters the debugger.
You can of course redefine #doesNotUnderstand: in your classes
to implement message delegation,
or handle the MessageNotUnderstood exception gracefully.

o  elementBoundsError
report an error that badElement is out of bounds
(i.e. cannot be put into that collection).
The error is reported by raising the ElementBoundsError exception.

o  elementBoundsError: aValue
report an error that aValue is not valid as element
(i.e. cannot be put into that collection).
The error is reported by raising the ElementBoundsError exception.

o  elementNotCharacter
report an error that object to be stored is no Character.
(usually when storing into Strings).
The error is reported by raising the ElementBoundsError exception.

o  elementNotInteger
report an error that object to be stored is not Integer.
(in collections that store integers only).
The error is reported by raising the ElementOutOfBoundsSignal exception.

o  error
report error that an error occurred.
The error is reported by raising the Error exception,
which is non-proceedable.
If no handler has been setup, a debugger is entered.
usage example(s):
report error that an error occurred.
     The error is reported by raising the Error exception,
     which is non-proceedable.
     If no handler has been setup, a debugger is entered.
usage example(s):
     nil error

o  error: aString
Raise an error with error message aString.
The error is reported by raising the Error exception,
which is non-proceedable.
If no handler has been setup, a debugger is entered.
usage example(s):
      nil error:' bad bad bad'

o  error: aString mayProceed: mayProceed
enter debugger with error-message aString.
The error is reported by raising either the
non-proceedable Error exception,
or the ProceedableError exception.

o  errorInvalidFormat
report an error that some conversion to/from string representation failed
typically when converting numbers, date, time etc.

o  errorKeyNotFound: aKey
report an error that a key was not found in a collection.
The error is reported by raising the KeyNotFoundError exception.

o  errorNotFound
report an error that no element was found in a collection.
The error is reported by raising the NotFoundSignal exception.

o  errorNotFound: errorString
report an error that no element was found in a collection.
The error is reported by raising the NotFoundSignal exception.

o  errorSignal
return the signal used for error/error: handling

o  handlerForSignal: exceptionHandler context: theContext originator: originator
should never be invoked for non-blocks/non-exceptions/non-signals

o  indexNotInteger
report an error that index is not an Integer.
(when accessing collections indexed by an integer key).
The error is reported by raising the NonIntegerIndexSignal exception.

o  indexNotInteger: anIndex
report an error that index is not an Integer.
(when accessing collections indexed by an integer key).
The error is reported by raising the NonIntegerIndexSignal exception.

o  indexNotIntegerOrOutOfBounds: index
report an error that index is either non-integral or out of bounds

o  integerCheckError
generated when a variable declared with an integer type gets a bad value assigned

o  invalidCodeObject
this is sent by VM if it encounters some non-method for execution

o  mustBeRectangle
report an argument-not-rectangle-error

o  mustBeString
report an argument-not-string-error

o  notIndexed
report an error that receiver has no indexed instance variables.
The error is reported by raising the SubscriptOutOfBoundsSignal exception.

o  notYetImplemented
report an error that some functionality is not yet implemented.
This is here only for compatibility - it has the same meaning as shouldImplement.

o  primitiveFailed
report an error that some primitive code failed.
The error is reported by raising the PrimitiveFailure exception.
usage example(s):
     1234 primitiveFailed

o  primitiveFailed: messageString
report an error that some primitive code failed.
The error is reported by raising the PrimitiveFailureSignal exception.
usage example(s):
     1234 primitiveFailed:'this is a test'

o  proceedableError: errorMessage
Report a proceedable error.
A handler can provide a default value

o  shouldImplement
report an error that this message/functionality should be implemented.
This is send by automatically generated method bodies or inside as-yet-uncoded
branches of existing methods.
usage example(s):
      self shouldImplement

o  shouldImplement: what
report an error that this message/functionality should be implemented.
This is send by automatically generated method bodies or inside as-yet-uncoded
branches of existing methods.
usage example(s):
      self shouldImplement:'foobar'

o  shouldNeverBeReached
report an error that this point may never be reached.

o  shouldNeverBeSent
report an error that this message may never be sent to the receiver

o  shouldNotImplement
report an error that this message should not be implemented -
i.e. that a method is invoked which is not appropriate for the receiver.

o  subclassResponsibility
report an error that this message should have been reimplemented in a subclass

o  subclassResponsibility: msg
report an error that this message should have been reimplemented in a subclass

o  subscriptBoundsError
report an error that some index is out of bounds.
(when accessing indexable collections).
The error is reported by raising the SubscriptOutOfBoundsSignal exception.

o  subscriptBoundsError: anIndex
report an error that anIndex is out of bounds.
(when accessing indexable collections).
The error is reported by raising the SubscriptOutOfBoundsSignal exception.

o  typeCheckError
generated when a variable declared with a type hint gets a bad
value assigned

error handling - debugger
o  addDebuggerHook: aBlock
add a debugger hook. Any registered hook is evaluated with the exception as
argument before a real debugger is entered.
Hooks can be used for two purposes:
- record exception information in a log file
- filter exceptions and either decide to ignore them or to open an alternative
debugger (depending on the exception type, maybe)
usage example(s):
     Object addDebuggerHook:[:ex | AbortSignal raise].
     (1 / (1-1)).
     Object removeDebuggerHook:(DebuggerHooks first).
usage example(s):
     Object addDebuggerHook:[:ex | Transcript showCR:ex ].
     (1 / (1-1)).
     Object removeDebuggerHook:(DebuggerHooks first).
usage example(s):
     Object addDebuggerHook:[:ex | ex suspendedContext fullPrintAllOn:Transcript ].
     (1 / (1-1)).
     Object removeDebuggerHook:(DebuggerHooks first).
usage example(s):
     Object addDebuggerHook:[:ex | '/tmp/stx.log' asFilename
                                   appendingFileDo:[:s |
                                        s nextPutLine:'----------------------'.
                                        (Timestamp now printOn:s). s cr.
                                        ex suspendedContext fullPrintAllOn:s
                                   ]].
     (1 / (1-1)).
     Object removeDebuggerHook:(DebuggerHooks first).

o  appropriateDebugger: aSelector
return an appropriate debugger to use.
If there is already a debugger active on the stack, and it is
the DebugView, return MiniDebugger (as a last chance) otherwise abort.

o  openDebuggerOnException: ex
enter the debugger on some unhandled exception

o  removeDebuggerHook: aBlock
remove a debugger hook.

evaluation
o  _evaluate_
return the receiver itself.
- compatibility with LazyValue

o  asCollectionDo: aBlock
enumerate myself as a Collection.
Redefined in Collection.

o  doIfNotNil: aBlock
enumerate myself as a Collection.
Redefined in Collection and UndefinedObject.

o  value
return the receiver itself.
This allows every object to be used where blocks or valueHolders
are typically used, and allows for valueHolders and blocks to be
used interchangably in some situations.

Time will show, if this is a good idea or leads to sloppy programming
style ... (the idea was borrowed from the Self language).

WARNING: don't 'optimize' away ifXXX: blocks
(i.e. do NOT replace
foo ifTrue:[var1] ifFalse:[var2]
by:
foo ifTrue:var1 ifFalse:var2
)
- the compilers will only generate inline code for the if,
iff the argument(s) are blocks - otherwise, a true send is
generated.
This 'optimization' will work semantically correct,
but execute SLOWER instead.

Using constants (foo ifTrue:1 ifFalse:2) does not introduce a performance penalty.

o  valueWithOptionalArgument: arg
see comment in #value.
The arg is ignored here
(equivalent to sending this message to a 0-arg Block)
usage example(s):
        [ 'abc' ] valueWithOptionalArgument:1
        'abc' valueWithOptionalArgument:1
        'abc' asValue valueWithOptionalArgument:1

o  valueWithPossibleArguments: argArray
see comment in #value.
The argArray is ignored here
(equivalent to sending this message to a 0-arg Block)
usage example(s):
        [ 'abc' ] valueWithPossibleArguments:#(1 2 3)
        'abc' valueWithPossibleArguments:#(1 2 3)
        'abc' asValue valueWithPossibleArguments:#(1 2 3)

finalization
o  disposed
OBSOLETE INTERFACE: please redefine #finalize instead.

this is invoked for objects which have been registered
in a Registry, when the original object dies.
Subclasses may redefine this method

** This is an obsolete interface - do not use it (it may vanish in future versions) **

o  executor
Return the object which does the finalization for me.
This interface is also VW & Squeak compatible,

o  finalizationLobby
answer a Registry used for finalization.
Use a generic Registry for any object.
Subclasses using their own Registry should redefine this

o  finalize
this is invoked for executor objects which have been registered
in a Registry, when the original object dies.
Subclasses may redefine this method
This interface is also VW-compatible

o  reRegisterForFinalization
re-register mySelf for later finalization.
This will create a new executor, which will receive a #finalize message when
the receiver is garbage collected.

o  registerForFinalization
register mySelf for later finalization.
Once registered, the executor of the receiver will receive a #finalize message when
the receiver is garbage collected.

o  shallowCopyForFinalization
OBSOLETE INTERFACE: please redefine #executor instead.
This is used to acquire a copy to be used for finalization -
(the copy will be sent a #finalize message; see the documentation in the Registry class)
This method can be redefined for more efficient copying - especially for large objects.

** This is an obsolete interface - do not use it (it may vanish in future versions) **

o  unregisterForFinalization
unregister mySelf from later finalization

initialization
o  initialize
just to ignore initialize to objects which do not need it

inspecting
o  inspector2TabClass
( an extension from the stx:libtool package )
|makeView|

o  inspector2TabCommon
( an extension from the stx:libtool package )
a tab, showing the old inspector

o  inspector2TabDisplayObject
( an extension from the stx:libtool package )

o  inspector2TabForBasicInspect
( an extension from the stx:libtool package )
a tab, showing the old basic inspector

o  inspector2TabForInspectorClass
( an extension from the stx:libtool package )
a tab, showing the old inspector

o  inspector2TabLabel
( an extension from the stx:libtool package )
label of the main tab

o  inspector2Tabs
( an extension from the stx:libtool package )
Workaround for stc bug

o  inspectorExtraAttributes
( an extension from the stx:libtool package )
extra (pseudo instvar) entries to be shown in an inspector.
Answers a dictionary of aString -> aBlock.
aString is name of extra attribute and MUST start with minus ($-).
aBlock returns the object representing extra attribute.

o  inspectorExtraMenuOperations
extra operation-menu entries to be shown in an inspector.
Answers a collection of pairs contining aString and action aBlock.
aString is the label of the menu item.
aBlock is evaluated when the menu item is selected.
To be redefined in objects which think that it makes sense to offer
often used operations in an inspector.
See SerialPort as an example.

o  inspectorValueStringInListFor: anInspector
( an extension from the stx:libtool package )
returns a string to be shown in the inspector's list.
Only to be redefined where it is guaranteed, that the returned string is short.

interrupt handling
o  childSignalInterrupt
death of a child process (unix process) - do nothing

o  customInterrupt
a custom interrupt - but no handler has defined

o  errorInterrupt: errorID with: aParameter
subsystem error. The arguments errorID and aParameter are the values passed
to the 'errorInterruptWithIDAndParameter(id, param)' function,
which can be called from C subsystems to raise an (asynchronous)
error exception.

Currently, this is used to map XErrors to smalltalk errors, but can be
used from other C subsystems too, to upcast errors.
Especially, for subsystems which call errorHandler functions asynchronously.
IDs (currently) used:
#DisplayError ..... x-error interrupt
#XtError ..... xt-error interrupt (Xt interface is not yet published)

o  exceptionInterrupt
exception interrupt - enter debugger

o  fpExceptionInterrupt
a floating point exception occurred - this one
has to be handled differently since it comes asynchronous
on some machines (for example, on machines with a separate FPU
or superscalar architectures. Also, errors from within primitive code
(or library functions such as GL) are sent via the Unix-signal
mechanism this way.

o  internalError: msg
this is triggered, when VM hits some bad error,
such as corrupted class, corrupted method/selector array
etc. The argument string gives some more information on what happened.
(for example, if you set an objects class to a non-behavior, nil etc.).
Its not guaranteed, that the system is in a working condition once
this error occurred ....

o  ioInterrupt
I/O (SIGIO/SIGPOLL) interrupt (supposed to be sent to Processor).
If we arrive here, there is either no handler (ObjMem>>ioInterruptHandler)
or it does not understand the ioInterrupt message.
In any case, this is a sign of some big trouble. Enter debugger.
usage example(s):
I/O (SIGIO/SIGPOLL) interrupt (supposed to be sent to Processor).
     If we arrive here, there is either no handler (ObjMem>>ioInterruptHandler)
     or it does not understand the ioInterrupt message.
     In any case, this is a sign of some big trouble. Enter debugger.

o  memoryInterrupt
out-of-memory interrupt and no handler - enter debugger

o  recursionInterrupt
recursion limit (actually: stack overflow) interrupt.
This interrupt is triggered, when a process stack grows above
its stackLimit - usually, this leads into the debugger, but
could be caught.
Under Unix, the stackLimit may be increased in the handler,
and the exception can be resumed.
Sorry, but under win32, the stack cannot grow, and the exception
is not proceedable.
At the time we arrive here, the system has still some stack
as a reserve so we can continue to do some useful work, or cleanup,
or debug for a while.
If the signal is ignored, and the stack continues to grow, there
will be a few more chances (and more interrupts) before the VM
terminates the process.
usage example(s):
'Stray recursionInterrupt ...' infoPrintCR.

o  schedulerInterrupt
scheduler interrupt (supposed to be sent to Processor).
If we arrive here, either the Processor does not understand it,
or it has been set to nil. In any case, this is a sign of some
big trouble. Enter debugger.

o  signalInterrupt: signalNumber
unix signal occurred - some signals are handled as Smalltalk Exceptions
(SIGPIPE), others (SIGBUS) are rather fatal...
In any case, IF a smalltalk-signal has been connected to the OS signal, that one is raised.
Otherwise, a dialog is shown, asking the user on how to handle the signal.
TODO: add another argument, giving more detailed signal info (PC, VADDR,
exact cause etc.). This helps if segvs occur in primitive code.
Currently (temporary kludge), these are passed as global variables.

o  signalInterruptWithCrashImage: signalNumber
special cases
- SIGPWR: power failure - write a crash image and continue
- SIGHUP: hang up - write a crash image and exit

o  spyInterrupt
spy interrupt and no handler - enter debugger

o  startMiniDebuggerOrExit: text
some critical condition happened.
Start a mini debugger or exit if none is present

o  timerInterrupt
timer interrupt and no handler - enter debugger

o  userInterrupt
user (^c) interrupt.
This is typically sent by the VM, when a ctrl-C is typed at the
controlling tty (i.e. in the xterm).

o  userInterruptIn: aContext from: originator
user (^c) interrupt - enter debugger, but show aContext
as top-context.
This is used to hide any intermediate scheduler contexts,
in case of an interrupted process. Typically, this is sent by
the WindowGroup, when a keyboardEvent for the ctrl-C key is
processed.
Set the originator to distinguish UserInterrupts from controlling tty vs.
UserInterrupt from a view.

message sending
o  perform: aSelector
send the message aSelector to the receiver

o  perform: aSelector inClass: aClass withArguments: argArray
send the message aSelector with all args taken from argArray
to the receiver as a super-send message.
This is actually more flexible than the normal super-send, since it allows
to execute a method in ANY superclass of the receiver (not just the
immediate superclass).
Thus, it is (theoretically) possible to do
'5 perform:#< inClass:Magnitude withArguments:#(6)'
and evaluate Magnitudes compare method even if there was one in Number.
This method is used by the interpreter to evaluate super sends
and could be used for very special behavior (language extension ?).

WARNING: this is an ST/X feature - probably not found in other smalltalks.

o  perform: aSelector with: arg
send the one-arg-message aSelector to the receiver

o  perform: aSelector with: arg1 with: arg2
send the two-arg-message aSelector to the receiver

o  perform: aSelector with: arg1 with: arg2 with: arg3
send the three-arg-message aSelector to the receiver

o  perform: aSelector with: arg1 with: arg2 with: arg3 with: arg4
send the four-arg-message aSelector to the receiver

o  perform: aSelector with: arg1 with: arg2 with: arg3 with: arg4 with: arg5
send the five-arg-message aSelector to the receiver

o  perform: aSelector with: arg1 with: arg2 with: arg3 with: arg4 with: arg5 with: arg6
send the six-arg-message aSelector to the receiver

o  perform: aSelector withArguments: argArray
send the message aSelector with all args taken from argArray
to the receiver.

o  perform: aSelector withOptionalArgument: arg
send aSelector-message to the receiver.
If the message expects an argument, pass arg.

o  perform: aSelector withOptionalArgument: optionalArg1 and: optionalArg2
send aSelector-message to the receiver.
Depending on the number of arguments the message expects,
pass either none, 1, or 2 arguments.

o  perform: aSelector withOptionalArgument: optionalArg1 and: optionalArg2 and: optionalArg3
send aSelector-message to the receiver.
Depending on the number of arguments the message expects,
pass either none, 1, 2 or 3 arguments.

o  perform: aSelector withOptionalArgument: optionalArg1 and: optionalArg2 and: optionalArg3 and: optionalArg4
send aSelector-message to the receiver.
Depending on the number of arguments the message expects,
pass either none, 1, 2, 3 or 4 arguments.

o  performMessage: aMessage
Send aMessage, an object which provides a selector and arguments to the
receiver object.
Added for Ansi compatibility
usage example(s):
     123 performMessage:(Message selector:#+ argument:100)

o  performMethod: aMethod
invoke aMethod on the receiver.
The method should be a zero-argument method.
This is a non-object-oriented entry, applying a method
in a functional way on a receiver.
Warning:
Take care for the method to be appropriate for the
receiver - no checking is done by the VM.

o  performMethod: aMethod arguments: argumentArray
invoke aMethod on the receiver, passing an argumentArray.
The size of the argumentArray should match the number of args
expected by the method.
This is a non-object-oriented entry, applying a method
in a functional way on a receiver.
Warning:
Take care for the method to be appropriate for the
receiver - no checking is done by the VM.

o  performMethod: aMethod with: arg
invoke aMethod on the receiver, passing an argument.
The method should be a one-argument method.
This is a non-object-oriented entry, applying a method
in a functional way on a receiver.
Warning:
Take care for the method to be appropriate for the
receiver - no checking is done by the VM.

o  performMethod: aMethod with: arg1 with: arg2
invoke aMethod on the receiver, passing two arguments.
The method should be a two-argument method.
This is a non-object-oriented entry, applying a method
in a functional way on a receiver.
Warning:
Take care for the method to be appropriate for the
receiver - no checking is done by the VM.

o  performMethod: aMethod with: arg1 with: arg2 with: arg3
invoke aMethod on the receiver, passing three arguments.
The method should be a three-argument method.
This is a non-object-oriented entry, applying a method
in a functional way on a receiver.
Warning:
Take care for the method to be appropriate for the
receiver - no checking is done by the VM.

o  performX: aSelector
send the message aSelector to the receiver
This is the original implementation of #perform, for reference (before Jan's changes for Ruby tuning).

o  returnablePerform: aSelector with: arg
send the one-arg-message aSelector to the receiver.
This is the same as #perform:with: but the context can return.

misc ui support
o  browse
open a browser on the receiver's class
usage example(s):
     10 browse
     Collection browse
     Collection class browse

o  inspect
launch an inspector on the receiver.
this method (or better: inspectorClass) can be redefined in subclasses
to start special inspectors.
usage example(s):
launch an inspector on the receiver.
     this method (or better: inspectorClass) can be redefined in subclasses
     to start special inspectors.
usage example(s):
     Object new inspect
     (1 @ 2) inspect
     Smalltalk inspect
     #(1 2 3) asOrderedCollection inspect
     (Color red) inspect
     (Image fromFile:'bitmaps/garfield.gif') inspect

o  inspectorClass
return the class to use for inspect.
Can (should) be redefined in classes for which a better inspector is available

object persistency
o  elementDescriptorFor: anAspectSymbol
support for persistency:
answer a collection of associations containing the
objects state to be encoded for aspect.
Association key is the instance variable name or access selector,
association value is the contents of the instance variable.

The default is to return the contents of all non-nil instance variables

o  elementDescriptorForInstanceVariables
return all instance variables for visiting/encoding
usage example(s):
      #(1 2 3 nil true symbol) elementDescriptorForInstanceVariables
      Dictionary new elementDescriptorForInstanceVariables
      (5 @ nil) elementDescriptorForInstanceVariables

o  elementDescriptorForInstanceVariablesMatching: aBlock
return all instance variables which conform to aBlock, for encoding/visiting.
Indexed vars are all included.

o  elementDescriptorForNonNilInstanceVariables
return all non-nil instance variables for visiting/encoding
usage example(s):
      #(1 2 3 nil true symbol) elementDescriptorForNonNilInstanceVariables
      Dictionary new elementDescriptorForNonNilInstanceVariables
      (5 @ nil) elementDescriptorForNonNilInstanceVariables

printing & storing
o  _errorPrint
Do not use this in user code.
Prints on stderr, regardless of any redirection to a logger.
Only to be used by the MiniDebugger, to ensure that its output is shown to a user
usage example(s):
     #('bla' 'fasel') _errorPrint
     'hello' asUnicode16String _errorPrint
     'helloαβγ' asUnicode16String _errorPrint
     'helloαβγ' asUnicode16String _errorPrintCR

o  _errorPrintCR
Do not use this in user code.
Prints on stderr, regardless of any redirection to a logger.
Only to be used by the MiniDebugger, to ensure that its output is shown to a user

o  _print
Do not use this in user code.
Prints on stdout, regardless of any redirection to a logger.
Only to be used by low-level crash utilities (like MiniDebugger),
to ensure that its output is shown to a user

o  _printCR
Do not use this in user code.
Prints on stdout, regardless of any redirection to a logger.
Only to be used by low-level crash utilities (like MiniDebugger),
to ensure that its output is shown to a user

o  basicPrintOn: aStream
append the receiver's className with an article to the argument, aStream

o  basicStoreString
defined here for compatibility with CharacterArray, which redefines this

o  className
return the classname of the receiver's class
usage example(s):
     1 className
     1 class className
     $a className
     $a class className

o  classNameWithArticle
return a string consisting of classname preceeded by an article.
(don't expect me to write national variants for this ... :-)
If you have special preferences, redefine it ...
usage example(s):
     1 classNameWithArticle
     (1->2) classNameWithArticle
     XWorkstation basicNew classNameWithArticle
     XWorkstation classNameWithArticle

o  errorPrint
if a logger has been defined, let it print the receiver when a CR is coming.
Otherwise, print the receiver on the Transcript and Stderr.
The Transcript is directed to the standard error stream on
headless applications.
usage example(s):
the following allows errorPrint to be used during

o  errorPrintCR
if a logger has been defined, let it print the receiver.
otherwise, print the receiver followed by a cr on the error stream(s).
The Transcript is directed to the standard error stream on
headless applications.
usage example(s):
the following allows errorPrintCR to be used during
usage example(s):
     'hello' errorPrintCR

o  errorPrintNL
print the receiver followed by a cr on the standard error stream.
Please use #errorPrintCR - this method exists for backward compatibility.

** This is an obsolete interface - do not use it (it may vanish in future versions) **

o  errorPrintNewline
print the receiver followed by a cr on the standard error stream.
Please use #errorPrintCR - this method exists for backward compatibility.

** This is an obsolete interface - do not use it (it may vanish in future versions) **

o  infoPrint
if a logger has been defined, let it print the receiver when a CR is coming.
otherwise print the receiver on the standard error stream.
This is meant for information messages which are not warnings or fatal messages.
These messages can be turned on/off by 'Object infoPrinting:true/false'
usage example(s):
if a logger has been defined, let it print the receiver when a CR is coming.
     otherwise print the receiver on the standard error stream.
     This is meant for information messages which are not warnings or fatal messages.
     These messages can be turned on/off by 'Object infoPrinting:true/false'
usage example(s):
     'hello' infoPrint. ' world' infoPrintCR.
     'foo [info] hello' infoPrintCR.

o  infoPrintCR
if a logger has been defined, let it print the receiver.
otherwise print the receiver followed by a cr on the standard error stream.
This is meant for information messages which are not warnings or fatal messages.
These messages can be turned on/off by 'Object infoPrinting:true/false'

o  infoPrintNL
print the receiver followed by a cr on the standard error stream.
Please use #infoPrintCR - this method exists for backward compatibility.

** This is an obsolete interface - do not use it (it may vanish in future versions) **

o  print
print the receiver on the standard output stream (which is not the Transcript)
usage example(s):
the following allows print/printCR to be used during

o  printCR
print the receiver followed by a cr on the standard output stream (which is not the Transcript)
usage example(s):
the following allows printCR to be used during

o  printNL
print the receiver followed by a cr on the standard output stream
This exists for GNU Smalltalk compatibility - please use #printCR.

** This is an obsolete interface - do not use it (it may vanish in future versions) **

o  printNewline
print the receiver followed by a cr on the standard output stream.
This exists for backward compatibility - please use #printCR.

** This is an obsolete interface - do not use it (it may vanish in future versions) **

o  printNl
print the receiver followed by a cr on the standard output stream
This exists for GNU Smalltalk compatibility - please use #printCR.

** This is an obsolete interface - do not use it (it may vanish in future versions) **

o  printOn: aStream
append a user printed representation of the receiver to aStream.
The format is suitable for a human - not meant to be read back.

The default here is to output the receiver's class name.
BUT: this method is heavily redefined for objects which
can print prettier.
usage example(s):
    (1@2) printOn:Transcript
    (1@2) basicPrintOn:Transcript

o  printOn: aStream format: format
this may be redefined in subclasses.
Defined here for compatibility with subclasses

o  printOn: aStream leftPaddedTo: size
print the receiver on aStream, padding with spaces up to size.
padding is done on the left.
usage example(s):
     123 printOn:Transcript leftPaddedTo:10. Transcript cr
     123 printOn:Transcript leftPaddedTo:2. Transcript cr

o  printOn: aStream leftPaddedTo: size with: padCharacter
print the receiver on aStream, padding with padCharacters up to size.
padding is done on the left.
usage example(s):
     123 printOn:Transcript leftPaddedTo:10 with:$_ . Transcript cr
     123 printOn:Transcript leftPaddedTo:10 with:$. . Transcript cr

o  printOn: aStream paddedTo: size
print the receiver on aStream, padding with spaces up to size.
usage example(s):
     123.0 printOn:Transcript paddedTo:10. Transcript nextPut:$|. Transcript cr

o  printOn: aStream paddedTo: size with: padCharacter
print the receiver on aStream, padding with padCharacter up to size
usage example(s):
     123 printOn:Transcript paddedTo:10 with:$_ . Transcript cr
     123 printOn:Transcript paddedTo:10 with:$. . Transcript cr

o  printOn: aStream zeroPaddedTo: size
print the receiver on aStream, padding with zeros up to size.
Usually used with float numbers.
usage example(s):
     123.0 printOn:Transcript zeroPaddedTo:10

o  printRightAdjustLen: size
obsolete - just a name confusion.
This method will go away ...

** This is an obsolete interface - do not use it (it may vanish in future versions) **

o  printString
return a string for printing the receiver.
Since we now use printOn: as the basic print mechanism,
we have to create a stream and print into it.
usage example(s):
     Date today printString.

o  printStringFormat: orintFormat
subclasses may redefine this.
Defined here to avoid type checks

o  printStringLeftPaddedTo: size
return my printString as a right-adjusted string of length size;
characters on the left are filled with spaces.
If the printString is longer than size,
it is returned unchanged (i.e. not truncated)
usage example(s):
     10 printStringLeftPaddedTo:10
     1 printStringLeftPaddedTo:10

o  printStringLeftPaddedTo: size ifLarger: alternative
return my printString as a right-adjusted string of length size;
characters on the left are filled with spaces.
If the printString is larger than size,
return the result from evaluating alternative.
usage example(s):
     12   printStringLeftPaddedTo:3 ifLarger:['***']
     123  printStringLeftPaddedTo:3 ifLarger:['***']
     1234 printStringLeftPaddedTo:3 ifLarger:['***']

o  printStringLeftPaddedTo: size with: padCharacter
return my printString as a right-adjusted string of length size;
characters on the left are filled with padCharacter.
If the printString is longer than size,
it is returned unchanged (i.e. not truncated)
usage example(s):
     123 printStringLeftPaddedTo:10 with:$.
     1 printStringLeftPaddedTo:10 with:$.
     (Float pi) printStringLeftPaddedTo:20 with:$*

o  printStringLeftPaddedTo: size with: padCharacter ifLarger: alternative
return my printString as a right-adjusted string of length size;
characters on the left are filled with padCharacter.
If the printString is larger than size,
return the result from evaluating alternative.
usage example(s):
     12   printStringLeftPaddedTo:3 with:$. ifLarger:['***']
     123  printStringLeftPaddedTo:3 with:$. ifLarger:['***']
     1234 printStringLeftPaddedTo:3 with:$. ifLarger:['***']

o  printStringLimitedTo: sizeLimit
return a string for printing the receiver, but limit the result string in its size.
usage example(s):
     Date today printStringLimitedTo:5.
     '12345678901234567890' printStringLimitedTo:5.

o  printStringOnError: exceptionBlock
return a string for printing the receiver; if any error occurs, return the result from
evaluating exceptionBlock. Useful to print something in an exceptionHandler or other
cleanup code.

o  printStringPaddedTo: size
return a printed representation of the receiver,
padded with spaces (at the right) up to size.
If the printString is longer than size,
it is returned unchanged (i.e. not truncated)
usage example(s):
     123 printStringPaddedTo:10
     1234567890123456 printStringPaddedTo:10
     'hello' printStringPaddedTo:10

o  printStringPaddedTo: size ifLarger: alternative
return a printed representation of the receiver,
padded with spaces (at the right) up to size.
If the resulting printString is too large,
return the result from evaluating alternative.
usage example(s):
     12   printStringPaddedTo:3 ifLarger:['***']
     123  printStringPaddedTo:3 ifLarger:['***']
     1234 printStringPaddedTo:3 ifLarger:['***']

o  printStringPaddedTo: size with: padCharacter
return a printed representation of the receiver,
padded with padCharacter (at the right) up to size.
If the printString is longer than size,
it is returned unchanged (i.e. not truncated)
usage example(s):
     123  printStringPaddedTo:10 with:$.
     123  printStringPaddedTo:10 with:$*
     123  printStringPaddedTo:3 with:$*
     1234 printStringPaddedTo:3 with:$*

o  printStringPaddedTo: size with: padCharacter ifLarger: alternative
return a printed representation of the receiver,
padded with padCharacter (at the right) up to size.
If the resulting printString is too large,
return the result from evaluating alternative.
usage example(s):
     123   printStringPaddedTo:3 with:$. ifLarger:['***']
     12345 printStringPaddedTo:3 with:$. ifLarger:['***']

o  printStringRightAdjustLen: size
obsolete - just a name confusion.
This method will go away ...

** This is an obsolete interface - do not use it (it may vanish in future versions) **

o  printStringZeroPaddedTo: size
return a printed representation of the receiver,
padded with zero (at the right) characters up to size.
Usually used with float numbers.
usage example(s):
     123.0 printStringZeroPaddedTo:10

o  printfPrintString: ignoredFormat
fallback to default printString
(for compatibility with float and integer-printing)

o  store
store the receiver on standard output.
this method is useless, but included for compatibility.

o  storeArrayElementOn: aStream
store an object as an Array element.
Subclasses may redefine this to omit a leading '#'

o  storeCR
store the receiver on standard output; append a carriage return.

o  storeNl
store the receiver on standard output; append a newline.
This method is included for backward compatibility- use #storeCR.

** This is an obsolete interface - do not use it (it may vanish in future versions) **

o  storeOn: aStream
store the receiver on aStream; i.e. print an expression which will
reconstruct the receiver.
Notice, that no self referencing or cyclic objects can be represented
in this format.
Use storeBinaryOn:, which handles these cases correctly.

o  storeString
return a string representing an expression to reconstruct the receiver.
Notice, that no self referencing or cyclic objects can be represented
in this format.
Use storeBinaryOn:, which handles these cases correctly.

o  withErrorStreamDo: aBlock
helper for error messages - evaluate aBlock,
passing it a stream on which to put error messages.
Notice that the block might be called twice,
to print both on stderr and onto the Transcript

queries
o  basicSize
return the number of the receiver's indexed instance variables,
0 if it has none.

This method should NOT be redefined in any subclass (except with great care, for tuning)

o  byteSize
return the number of bytes in the receiver's indexed instance variables,
0 if it has none. This only returns non-zero for non-pointer indexed
instvars i.e. byteArrays, wordArrays etc.
Notice: for Strings the returned size may look strange.
Only useful with binary storage.
usage example(s):
     Point new byteSize
     'hello' byteSize
     'hello' asUnicode16String byteSize
     (ByteArray with:1 with:2) byteSize
     (FloatArray with:1.5) byteSize
     (DoubleArray with:1.5) byteSize
     (WordArray with:1 with:2) byteSize

o  class
return the receiver's class

o  isCSS
( an extension from the stx:goodies/webServer/htmlTree package )
return false here; to be redefined in subclass(es)

o  respondsTo: aSelector
return true if the receiver responds to a message with aSelector;
i.e. if there is a method for aSelector in either the
receiver's class or one of its superclasses.

Notice, that this does not imply, that such a message can be sent without
an error being raised; for example, an implementation could send
#shouldNotImplement or #subclassResponsibility.
usage example(s):
     'aString' respondsTo:#+
     'aString' respondsTo:#,
     'aString' respondsTo:#collect:

o  respondsToArithmetic
return true if the receiver responds to arithmetic messages.
false is returned here - the method is redefined in ArithmeticValue.

o  size
return the number of the receiver's indexed instance variables;
this method may be redefined in subclasses

o  species
return a class which is similar to (or the same as) the receiver's class.
This is used to create an appropriate object when creating derived
copies in the collection classes (sometimes redefined).

o  speciesForCompare
return a class to determine if two objects can be compared.
The fallback here is my species; only redefined by some timestamp classes

o  speciesForCopy
return a class which is the receiver's class, except for readonly objects,
such as immutable collections.
This is only to be used by copy methods

o  yourself
return the receiver - used for cascades to return self at the end

secure message sending
o  ?: selector
try to send a message to the receiver;
if understood, return the value;
if not, return nil.
usage example(s):
     ApplicationModel new masterApplication resources first             - error
     ApplicationModel new ?: #masterApplication ?: #resources ?: #first - nil

o  askFor: aSelector
try to send the receiver the message, aSelector.
If it does not understand it, return false.
Otherwise the real value returned.
Useful to send messages such as: #isColor to unknown receivers.
usage example(s):
     1 askFor:#isColor
     Color red askFor:#isColor

     1 askFor:#isFoo
     Color red askFor:#isFoo

o  askFor: aSelector with: argument
try to send the receiver the message, aSelector.
If it does not understand it, return false.
Otherwise the real value returned.
Useful to send messages such as: #isXXX: to unknown receivers.

o  askFor: aSelector with: arg1 with: arg2
try to send the receiver the message, aSelector.
If it does not understand it, return false.
Otherwise the real value returned.
Useful to send messages such as: #isXXX: to unknown receivers.

o  perform: aSelector ifNotUnderstood: exceptionBlock
try to send message aSelector to the receiver.
If it's understood, return the method's returned value,
otherwise return the value of the exceptionBlock.
Read this:
Many programmers do an Error-handle to perform a similar
checked-message send. However, this method is more specific,
in that only errors for the given selector are caught - not any other
doesNotUnderstand, and especially not any other error.
usage example(s):
     1.2345 perform:#foo ifNotUnderstood:['sorry']
     1.2345 perform:#sqrt ifNotUnderstood:['sorry']
     12345 perform:#sqrt ifNotUnderstood:['sorry']

o  perform: aSelector with: argument ifNotUnderstood: exceptionBlock
try to send message aSelector to the receiver.
If it's understood, return the method's returned value,
otherwise return the value of the exceptionBlock.
Read this:
Many programmers do an Error-handle to perform a similar
checked-message send. However, this method is more specific,
in that only errors for the given selector are caught - not any other
doesNotUnderstand, and especially not any other error.

o  perform: aSelector with: arg1 with: arg2 ifNotUnderstood: exceptionBlock
try to send message aSelector to the receiver.
If it's understood, return the method's returned value,
otherwise return the value of the exceptionBlock.
Read this:
Many programmers do an Error-handle to perform a similar
checked-message send. However, this method is more specific,
in that only errors for the given selector are caught - not any other
doesNotUnderstand, and especially not any other error.

o  perform: aSelector withArguments: argumentArray ifNotUnderstood: exceptionBlock
try to send message aSelector to the receiver.
If it's understood, return the method's returned value,
otherwise return the value of the exceptionBlock.
Read this:
Many programmers do an Error-handle to perform a similar
checked-message send. However, this method is more specific,
in that only errors for the given selector are caught - not any other
doesNotUnderstand, and especially not any other error.

signal constants
o  messageNotUnderstoodSignal

special queries
o  allOwners
return a collection of all objects referencing the receiver

o  references: anObject
return true if the receiver refers to the argument, anObject.
- for debugging only

o  referencesAny: aCollection
return true if the receiver refers to any object from
the argument, aCollection.
- for debugging only

o  referencesDerivedInstanceOf: aClass
return true if the receiver refers to an instance of
the argument, aClass or its subclass. This method exists
to support searching for users of a class.
usage example(s):
     (1 @ 3.4) referencesDerivedInstanceOf:Number
     (1 @ 3.4) referencesDerivedInstanceOf:Array
     View new initialize referencesDerivedInstanceOf:DeviceWorkstation

o  referencesForWhich: checkBlock do: actionBlock
check the instance variables
usage example(s):
     (1 @ 3.4) referencesForWhich:[:i | i isFloat] do:[:i | Transcript showCR:i]

o  referencesInstanceOf: aClass
return true if the receiver refers to an instance of
the argument, aClass.This method exists
to support searching for users of a class.
usage example(s):
     (1 @ 3.4) referencesInstanceOf:Float
     (1 @ 3.4) referencesInstanceOf:Fraction
     View new initialize referencesInstanceOf:(Display class)

o  referencesObject: anObject
return true if the receiver refers to the argument, anObject.
- for debugging only

splitting & joining
o  split: aSequenceableCollection
treating the receiver as a splitter,
split aSequenceableCollection accordingly and return a collection of fragments.
usage example(s):
     ' ' split: 'hello world'

o  split: aCollection do: aBlock
treating the receiver as a splitter,
split aSequenceableCollection accordingly and evaluate aBlock for each fragment.
usage example(s):
     ' ' split: 'hello world' do: [:frag | Transcript showCR:frag ]

o  split: aCollection indicesDo: aTwoArgBlock
treating the receiver as a splitter,
split aSequenceableCollection accordingly and evaluate aBlock for each pair of start-
and stop index.
usage example(s):
     1 split:#(10 1 20 30 40 1 50 60 1 70) do: [:frag | Transcript showCR:frag ]
     1 split:#(10 1 20 30 40 1 50 60 1 70) indicesDo: [:start :stop | Transcript show:start; show:' to '; showCR:stop ]
 
     nil split:#(10 nil 20 30 40 nil 50 60 nil 70) do: [:frag | Transcript showCR:frag ]
     nil split:#(10 nil 20 30 40 nil 50 60 nil 70) indicesDo: [:start :stop | Transcript show:start; show:' to '; showCR:stop ]

synchronized evaluation
o  freeSynchronizationSemaphore
free synchronizationSemaphore. May be used, to save memory when
an object is no longer used synchronized.
usage example(s):
     self synchronized:[].
     self synchronizationSemaphore.
     self freeSynchronizationSemaphore.

o  synchronizationSemaphore
return the synchronization semaphore for myself.
subclasses may redefine
usage example(s):
      self synchronizationSemaphore

o  synchronizationSemaphore: aSemaphore
set the synchronisationSemaphore for myself.
subclasses may redefine this method

o  synchronized: aBlock
evaluate aBlock synchronized, i.e. use a monitor for this object
usage example(s):
       [Object synchronized:[Delay waitForSeconds:2. Transcript showCR:'1']] fork.
       [Object synchronized:[Delay waitForSeconds:2. Transcript showCR:'2']] fork.

system primitives
o  asOop
ST-80 compatibility:
ST-80 returns an OOP-identity based number here (I guess: its address
or index); since ST/X has no such thing, and the objects address cannot
be used (since its changing over time), we return the objects identityHash
key, which provides (at least) some identity indication.
However, notice that (in contrast to ST-80's #asOop), the identityHash
key of two non-identical objects may be the same.
You'd better not use it - especially do not misuse it.

o  beImmutable
experimental - not yet usable; do not use.
For now the #isImmutable flag prohibits only #become*.

o  beMutable
experimental - not yet usable; do not use.
For now the #isImmutable flag prohibits only #become*.

o  become: anotherObject
make all references to the receiver become references to anotherObject
and vice-versa. Notice the vice-versa; see #becomeSameAs: for a one-way become.
This can be a very dangerous operation - be warned.
In general, using #become: should be avoided if possible, since it may
produce many strange effects (think of hashing in Sets, Dictionaries etc.).

This may also be an expensive (i.e. slow) operation,
since in the worst case, the whole memory has to be searched for
references to the two objects (although the primitive tries hard to
limit the search, for acceptable performance in most cases).
This method fails, if the receiver or the argument is a SmallInteger
or nil, or is a context of a living method (i.e. one that has not already
returned).
(notice that #become: is not used heavily by the system
- the Collection-classes have been rewritten to not use it.)

o  becomeNil
make all references to the receiver become nil - effectively getting
rid of the receiver.
This can be a very dangerous operation - be warned.

This may be an expensive (i.e. slow) operation.
The receiver may not be a SmallInteger or a context of a living method.

o  becomeSameAs: anotherObject
make all references to the receiver become references to anotherObject
but NOT vice versa (as done in #become:).
This can be a very dangerous operation - be warned.
In general, using #become: should be avoided if possible, since it may
produce many strange effects (think of hashing in Sets, Dictionaries etc.).

This may also be an expensive (i.e. slow) operation,
since in the worst case, the whole memory has to be searched for
references to the two objects (although the primitive tries hard to
limit the search, for acceptable performance in most cases).
This method fails, if the receiver or the argument is a SmallInteger
or nil, or is a context of a living method (i.e. one that has not already returned).

o  changeClassTo: otherClass
changes the class of the receiver to the argument, otherClass.
This is only allowed (possible), if the receiver's class and the argument
have the same structure (i.e. number of named instance variables and
type of indexed instance variables).
If the structures do not match, or any of the original class or new class
is UndefinedObject or a Smallinteger, a primitive error is triggered.

o  changeClassToThatOf: anObject
changes the class of the receiver to that of the argument, anObject.
This is only allowed (possible), if the receiver's class and the arguments
class have the same structure (i.e. number of named instance variables and
type of indexed instance variables). If the structures do not match, or any
of the objects is nil or a Smallinteger, a primitive error is triggered.

o  isImmutable
experimental - not yet usable; do not use.
For now the #isImmutable flag prohibits only #become*.

o  replaceReferencesTo: anObject with: newRef
if the receiver refers to the argument, anObject, replace this reference with newRef.
Return true if any reference was changed.
Notice: this does not change the class-reference.

testing
o  ? defaultValue
a syntactic sugar-piece:
if the receiver is nil, return the defaultValue;
otherwise, return the receiver.
This method is only redefined in UndefinedObject - therefore,
the receiver is returned here.

Thus, if foo and bar are simple variables or constants,
foo ? bar
is the same as:
(foo isNil ifTrue:[bar] ifFalse:[foo])

if they are message sends, the equivalent code is:
[
|t1 t2|

t1 := foo.
t2 := bar.
t1 isNil ifTrue:[t2] ifFalse:[t1]
] value

Can be used to provide defaultValues to variables,
as in:
foo := arg ? #defaultValue

Note: this method should never be redefined in classes other than UndefinedObject.
Notice:
This method is open coded (inlined) by the compiler(s)
- redefining it may not work as expected.
usage example(s):
     1 ? #default
     nil ? #default

o  ?+ aOneArgBlock
a syntactic sugar-piece:
aOneArgBlock is executed with self as argument
if self is not nil.

Note: this method should never be redefined in classes other than UndefinedObject.

usage example(s):
     1 ?+ [:v| v + 5]
     nil ?+ [:v| v + 5]

o  ?? defaultValue
a syntactic sugar-piece:
much like ?, but sends #value to the argument if required.
(i.e. it is the same as #ifNil:)
If the receiver is nil, return the defaultValues value;
otherwise, return the receiver.
This method is only redefined in UndefinedObject - therefore,
the receiver is returned here.

Thus, if foo and bar are simple variables or constants,
foo ?? bar
is the same as:
(foo isNil ifTrue:[bar value] ifFalse:[foo])

if they are message sends, the equivalent code is:
[
|t t2|

t := foo.
t isNil ifTrue:[bar value] ifFalse:[t]
] value

Can be used to provide defaultValues to variables,
as in:
foo := arg ?? [ self computeDefault ]

Note: this method should never be redefined in classes other than UndefinedObject.

usage example(s):
     1 ?? #default
     nil ?? #default
     1 ?? [ self halt. 1 + 2 ]
     nil ?? [ self halt. 1 + 2 ]
     1 ?? [Date today]
     nil ?? [Date today]

o  ifNil: aBlockOrValue
return myself, or the result from evaluating the argument, if I am nil.
This is much like #?, but sends #value to the argument in case of a nil
receiver.
Notice:
This method is open coded (inlined) by the compiler(s)
- redefining it may not work as expected.

o  ifNil: nilBlockOrValue ifNotNil: notNilBlockOrValue
return the value of the first arg, if I am nil,
the result from evaluating the 2nd argument, if I am not nil.
Notice:
This method is open coded (inlined) by the compiler(s)
- redefining it may not work as expected.

o  ifNotNil: aBlockOrValue
return myself if nil, or the result from evaluating the argument,
if I am not nil.
Notice:
This method is open coded (inlined) by the compiler(s)
- redefining it may not work as expected.

o  ifNotNil: notNilBlockOrValue ifNil: nilBlockOrValue
return the value of the 2nd arg, if I am nil,
the result from evaluating the 1st argument, if I am not nil.
Notice:
This method is open coded (inlined) by the compiler(s)
- redefining it may not work as expected.

o  ifNotNilDo: aBlock
if the receiver is non-nil, return the value of aBlock, passing myself as argument.
Otherwise do nothing and return nil.

o  isApplicationModel
return true if the receiver is some kind of applicationModel;
false is returned here - the method is only redefined in ApplicationModel.

o  isArray
return true if the receiver is some kind of array (or weakArray etc);
false is returned here - the method is only redefined in Array.

o  isAssociation
return true if the receiver is some kind of association;
false is returned here - the method is only redefined in Association.

o  isBehavior
return true if the receiver is describing another object's behavior.
False is returned here - the method is only redefined in Behavior.

o  isBlock
return true if the receiver is some kind of block;
false returned here - the method is only redefined in Block.

o  isBlockOrMessageSend
return true if the receiver is some kind of block;
false returned here - the method is only redefined in Block.

o  isBlockWithArgumentCount: count
return true if the receiver is some kind of block;
false returned here - the method is only redefined in Block.

o  isBoolean
return true if the receiver is a boolean;
false is returned here - the method is only redefined in Boolean.

o  isBridgeProxy
answer true, if I am a proxy object for a bridged remote object

o  isByteArray
return true if the receiver is some kind of bytearray;
false is returned here - the method is only redefined in ByteArray.

o  isByteCollection
return true if the receiver is some kind of byte collection,
This is different from 'self class isBytes',
since e.g. in BitArray single bits are accessed, but it is implemented as variableBytes class.

o  isCharacter
return true if the receiver is some kind of character;
false is returned here - the method is only redefined in Character.

o  isClass
return true if the receiver is some kind of class
(real class, not just behavior);
false is returned here - the method is only redefined in Class.

o  isCollection
return true if the receiver is some kind of collection;
false is returned here - the method is only redefined in Collection.

o  isColor
return true if the receiver is some kind of color;
false is returned here - the method is only redefined in Color.

o  isColormap
( an extension from the stx:libview package )

o  isCons
return true if the receiver is a cons (pair);
false is returned here - the method is only redefined in Cons.

o  isContext
return true if the receiver is some kind of Context;
false returned here - the method is only redefined in Context.

o  isDictionary
return true if the receiver is some kind of dictionary;
false returned here - the method is only redefined in Dictionary.

o  isDocument
( an extension from the stx:goodies/xml/vw package )
am I an XML Document?

o  isEmptyOrNil
return true if I am nil or an empty collection - return false here.
(from Squeak)

o  isException
answer true, if this is an Exception

o  isExceptionCreator
return true if the receiver can create exceptions,
this includes #raise, #raiseRequest as well as the behavior of
an exception handler, such as the #accepts: and #handles: messages

o  isExceptionHandler
return true if the receiver responds to the exception handler protocol,
especially to the #accepts: and #handles: messages

o  isExternalAddress
return true if the receiver is some kind of externalAddress;
false is returned here - the method is only redefined in ExternalAddress.

o  isExternalBytes

o  isExternalLibraryFunction
return true if the receiver is some kind of externalLibrary function;
false is returned here - the method is only redefined in ExternalLibraryFunction.

o  isExternalStream
return true if the receiver is some kind of externalStream;
false is returned here - the method is only redefined in ExternalStream.

o  isExternalStructure

o  isFileStream
return true if the receiver is some kind of fileStream;
false is returned here - the method is only redefined in FileStream.

o  isFilename
return true if the receiver is some kind of filename;
false is returned here - the method is only redefined in Filename.

o  isFixedPoint
return true if the receiver is some kind of fixedPoint number;
false is returned here - the method is only redefined in FixedPoint.

o  isFixedSize
return true if the receiver cannot grow easily
(i.e. a grow may be expensive, since it involves a become:)

o  isFloat
return true if the receiver is some kind of floating point number;
false is returned here.
Same as #isLimitedPrecisionReal, but a better name ;-)

o  isForm
return true if the receiver is some kind of form;
false is returned here - the method is only redefined in Form.

o  isFraction
return true if the receiver is some kind of fraction;
false is returned here - the method is only redefined in Fraction.

o  isHierarchicalItem
used to decide if the parent is a hierarchical item or the model

o  isImage
return true if the receiver is some kind of image;
false is returned here - the method is only redefined in Image.

o  isImageOrForm
return true if the receiver is some kind of image or form;
false is returned here - the method is only redefined in Image and Form.

o  isImmediate
return true if I am an immediate object
i.e. I am represented in the pointer itself and
no real object header/storage is used me.
(currently, only SmallIntegers, some characters and nil return true)

o  isInteger
return true if the receiver is some kind of integer number;
false is returned here - the method is only redefined in Integer.

o  isInterestConverter
return true if I am a kind of interest forwarder

o  isInternalByteStream
return true, if the receiver is some kind of Stream for reading bytes;
false is returned here - the method is only redefined in PeekableStream.

o  isJavaClass
return true if this is a JavaClass.
false is returned here - the method is only redefined in JavaClass.

o  isJavaClassRef
return true if this is a JavaClassRef.
false is returned here - the method is only redefined in JavaClassRef.

o  isJavaContext
return true if this is a JavaContext.
false is returned here - the method is only redefined in JavaContext.

o  isJavaMethod
return true if this is a JavaMethod.
false is returned here - the method is only redefined in JavaMethod.

o  isJavaMethodRef
return true if this is a JavaMethodRef.
false is returned here - the method is only redefined in JavaMethodRef.

o  isJavaObject
return true if this is a JavaObject.
false is returned here - the method is only redefined in JavaObject.

o  isJavaScriptClass
return true if this is a JavaScriptClass.
false is returned here - the method is only redefined in JavaScriptClass.

o  isJavaScriptMetaclass
return true if this is a JavaScript Metaclass.
false is returned here - the method is only redefined in JavaScriptMetaclass.

o  isKindOf: aClass
return true if the receiver is an instance of aClass or one of its
subclasses, false otherwise.
Advice:
use of this to check objects for certain attributes/protocol should
be avoided; it limits the reusability of your classes by limiting use
to instances of certain classes and fences you into a specific inheritance
hierarchy.
Use check-methods to check an object for a certain attributes/protocol
(such as #isXXXX, #respondsTo: or #isNumber).

Using #isKindOf: is considered BAD STYLE.

Advice2:
Be aware, that using an #isXXX method is usually much faster than
using #isKindOf:; because isKindOf: has to walk up all the superclass
hierarchy, comparing every class on the way.
Due to caching in the VM, a call to #isXXX is normally reached via
a single function call.

o  isLabelAndIcon
return true if the receiver is a LabelAndIcon;
false is returned here - the method is only redefined in LabelAndIcon.

o  isLayout
return true if the receiver is some kind of layout;
false is returned here - the method is only redefined in Layout.

o  isLazyValue

o  isLimitedPrecisionReal
return true if the receiver is some kind of floating point number;
false is returned here - the method is only redefined in LimitedPrecisionReal.

o  isList
return true if the receiver is some kind of list collection;
false is returned here - the method is only redefined in List.

o  isLiteral
return true if the receiver can be represented as a literal constant in ST syntax;
false is returned here - the method is redefined in some classes.

o  isMemberOf: aClass
return true if the receiver is an instance of aClass, false otherwise.
Advice:
use of this to check objects for certain attributes/protocol should
be avoided; it limits the reusability of your classes by limiting use
to instances of a certain class.
Use check-methods to check an object for a certain attributes/protocol
(such as #isXXX, #respondsTo: or #isNumber);

Using #isMemberOf: is considered BAD STYLE.
Notice:
This method is open coded (inlined) by the compiler(s)
- redefining it may not work as expected.

o  isMenuItem
return true if the receiver is a menu item inside a MenuPanel, Menu or PopUpmenu.
false is returned here - the method is redefined in some classes.

o  isMeta
return true if the receiver is some kind of metaclass;
false is returned here - the method is only redefined in Metaclass.

o  isMethod
return true if the receiver is some kind of method;
false returned here - this method is only redefined in Method.

o  isMorph
return true if the receiver is some kind of morph;
false is returned here - the method is only redefined in Morph.

o  isNameSpace
return true if the receiver is a NameSpace.
False is returned here - the method is only redefined in Namespace.

o  isNamespace
return true if this is a NameSpace.
false is returned here - the method is only redefined in Namespace.

** This is an obsolete interface - do not use it (it may vanish in future versions) **

o  isNil
Return true if the receiver is nil.
Because isNil is redefined in UndefinedObject,
the receiver is definitely not nil here, so unconditionally return false.
Notice:
This method is open coded (inlined) by the compiler(s)
- redefining it may not work as expected.

o  isNilOrEmptyCollection
return true if I am nil or an empty collection - false here.
Obsolete, use isEmptyOrNil.

** This is an obsolete interface - do not use it (it may vanish in future versions) **

o  isNonByteCollection
return true if the receiver is some kind of collection, but not a String, ByteArray etc.;
false is returned here - the method is redefined in Collection and UninterpretedBytes.
usage example(s):
        21 isNonByteCollection
        'abc' isNonByteCollection
        #'abc' isNonByteCollection
        #[1 2 3] isNonByteCollection
        #(1 2 3) isNonByteCollection

o  isNotNil
Return true if the receiver is not nil.
Because isNotNil is redefined in UndefinedObject,
the receiver is definitely not nil here, so unconditionally return true.

** This is an obsolete interface - do not use it (it may vanish in future versions) **

o  isNumber
return true if the receiver is some kind of number;
false is returned here - the method is only redefined in Number.

o  isOSErrorHolder

o  isOrderedCollection
return true if the receiver is some kind of ordered collection (or list etc);
false is returned here - the method is only redefined in OrderedCollection.

o  isOsHandle

o  isPlainString
return true if the receiver is a plain string - without attributes;
false is returned here - the method is redefined in CharacterArray and Text.

o  isPoint
return true if the receiver is some kind of point;
false is returned here - the method is only redefined in Point.

o  isPrinterContext

o  isProgrammingLanguage
return true if the receiver is a programming language.
False is returned here - the method is only redefined in
ProgrammingLanguage.

o  isProjectDefinition
return true if the receiver is a projectDefinition.
False is returned here - the method is only redefined in ProjectDefinition.

o  isProtoObject

o  isProxy
return true if the receiver is a proxy for another (lazy loaded) object.
False is returned here.

o  isRealNameSpace
return true if the receiver is a NameSpace, but not Smalltalk (which is also a class).
False is returned here - the method is redefined in Namespace and Smalltalk.

o  isRectangle
return true if the receiver is some kind of rectangle;
false is returned here - the method is only redefined in Rectangle.

o  isRemoteObject
return true if the receiver is some kind of remoteObject,
false if it's local - the method is only redefined in RemoteObject.

o  isSequenceable
return true if the receiver is some kind of sequenceable collection;
false is returned here - the method is only redefined in SequenceableCollection.

o  isSequenceableCollection
OBSOLETE: use isSequenceable for ST-80 compatibility.
This method is a historic leftover and will be removed soon ...
(although its name is much better than #isSequenceable - sigh)

** This is an obsolete interface - do not use it (it may vanish in future versions) **

o  isSharedPool
return true if the receiver is a sharedPool.
False is returned here - the method is only redefined in SharedPool.

o  isSingleByteCollection
return true, if the receiver has access methods for bytes;
i.e. #at: and #at:put: accesses a byte and are equivalent to #byteAt: and byteAt:put:
and #replaceFrom:to: is equivalent to #replaceBytesFrom:to:.
This is different from 'self class isBytes'.

o  isSingleByteString
return true if the receiver is a string or immutableString.
false is returned here - the method is only redefined in String.
Must replace foo isMemberOf:String and foo class == String

o  isSocketAddress

o  isSpecialInstrumentationInfoLiteral
return true if the receiver is a special instrumentation info
object as placed into the literal array of instrumented methods

o  isStream
return true if the receiver is some kind of stream;
false is returned here - the method is only redefined in Stream.

o  isString
return true if the receiver is some kind of string;
false is returned here - the method is only redefined in CharacterArray.

o  isStringCollection
return true if the receiver is some kind of stringCollection;
false is returned here - the method is only redefined in StringCollection.

o  isStructure
redefined in Structure>>#doesNotUnderstand

o  isSymbol
return true if the receiver is some kind of symbol;
false is returned here - the method is only redefined in Symbol.

o  isTestCaseLike
( an extension from the stx:libtool package )

o  isText
return true if the receiver is some kind of text object;
false is returned here - the method is only redefined in Text.

o  isTextView
return true if the receiver is some kind of textView;
false is returned here - the method is only redefined in TextViews.

o  isTimeDuration
return true if the receiver is some kind of time duration;
false is returned here - the method is only redefined in TimeDuration.

o  isTimestamp
return true if the receiver is some kind of time duration;
false is returned here - the method is only redefined in Timestamp.

o  isTrait
Return true if the receiver is a trait.
Note: Do not override in any class except TraitBehavior.

o  isURL
Return true if the receiver is a url.
Note: Do not override in any class except URL.

o  isUUID
Return true if the receiver is a uuid.
Note: Do not override in any class except UUID.

o  isValueModel
return true if the receiver is some kind of valueModel;
false is returned here - the method is only redefined in ValueModel.

o  isVariable
return true if the receiver has indexed instance variables,
false otherwise.

o  isVariableBinding
return true if this is a binding for a variable.
false is returned here - the method is only redefined in Binding.

o  isView
return true if the receiver is some kind of view;
false is returned here - the method is only redefined in View.

o  isViewBackground
return false here; to be redefined in subclass(es)

o  isVoid
Return true if the receiver is void.
This is (and should only be) redefined in VoidObject,
for the one and only instance of it, void
usage example(s):
     nil isVoid
     void isVoid

o  isWeakCollection
return true if the receiver has weak references to its elements.

o  notEmptyOrNil
Squeak compatibility:
return true if I am neither nil nor an empty collection.
Return true here.

o  notNil
Return true if the receiver is not nil.
Because notNil is redefined in UndefinedObject,
the receiver is definitely not nil here, so unconditionally return true.
Notice:
This method is open coded (inlined) by the compiler(s)
- redefining it may not work as expected.

tracing
o  traceInto: aRequestor level: level from: referrer
double dispatch into tracer, passing my type implicitely in the selector

user interaction & notifications
o  activityNotification: aString
this can be sent from deeply nested methods, which are going to perform
some long-time activity.
If there is a handler for the ActivityNotificationSignal signal, that one is raised,
passing the argument. The handler should show this message whereever it likes,
and proceed. If there is no handler, this is simply ignored.

This is very useful to pass busy messages up to some higher level (typically a view)
which likes to display that message in its label or a busy-box.
It could also be put into some logfile or printed on the standard output/error.
usage example(s):
     nil activityNotification:'hello there'
     self activityNotification:'hello there'
usage example(s):
     ActivityNotification handle:[:ex |
        ex errorString printCR.
        ex proceed.
     ] do:[
        'hello' printCR.
        self activityNotification:'doing some long time computation'.
        'world' printCR.
     ]

o  confirm: aString
open a modal yes-no dialog.
Return true for yes, false for no.
If no GUI is present (headless applications), true is returned.

Someone in the sender chain may redefine the confirmation handler
by handling the UserConfirmation.
usage example(s):
     nil confirm:'hello'
     self confirm:'hello'

o  confirm: aString orCancel: cancelBlock
launch a confirmer, which allows user to enter yes, no or cancel.
return true for yes, false for no, or the value from cancelBlock for cancel.
If no GUI is present (headless applications), cancelBlock is returned.
usage example(s):
     self confirm:'hello' orCancel:[self halt]

o  confirmWithCancel: aString
launch a confirmer, which allows user to enter yes, no or cancel.
return true for yes, false for no, nil for cancel.
If no GUI is present (headless applications), nil is returned.

Someone in the sender chain may redefine the confirmation handler
by handling the UserConfirmation.
usage example(s):
     nil confirmWithCancel:'hello'
     self confirmWithCancel:'hello'

o  confirmWithCancel: aString defaultAnswer: defaultAnswerOrNil
launch a confirmer, which allows user to enter yes, no or cancel.
return true for yes, false for no, nil for cancel.
If no GUI is present (headless applications), nil is returned.

Someone in the sender chain may redefine the confirmation handler
by handling the UserConfirmation.
usage example(s):
     nil confirmWithCancel:'hello' defaultAnswer:true
     self confirmWithCancel:'hello' defaultAnswer:false

o  errorNotify: aString
launch a Notifier, showing top stack, telling user something
and give user a chance to enter debugger.
usage example(s):
     nil errorNotify:'hello there'
     self errorNotify:'hello there'

o  errorNotify: aString from: aContext
launch a Notifier, showing top stack (above aContext),
telling user something and give user a chance to enter debugger.

o  errorNotify: aString from: aContext allowDebug: allowDebug
launch a Notifier, showing top stack (above aContext),
telling user something and give user a chance to enter debugger.

o  errorNotify: aString from: aContext allowDebug: allowDebug mayProceed: mayProceed
launch a Notifier, showing top stack (above aContext),
telling user something and optionally give the user a chance to enter debugger.
usage example(s):
     nil errorNotify:'hello there'
     self errorNotify:'hello there'

o  information: aString
launch an InfoBox, telling user something.
These info-boxes can be suppressed by handling
UserNotification or InformationSignal and proceeding in the handler.
Use #notify: for more important messages.
If nobody handles the exception, the default action of UserNotification
pops up an info dialog.
usage example(s):
     nil information:'hello there'
     self information:'hello there'
usage example(s):
     InformationSignal handle:[:ex |
        'no box popped' printCR.
        ex proceed.
     ] do:[
        'hello' printCR.
        self information:'some info'.
        'world' printCR.
     ]

o  notify: aString
launch a Notifier, telling user something.
Use #information: for ignorable messages.
If nobody handles the exception, the default action of UserNotification
pops up a warn dialog.
usage example(s):
     nil notify:'hello there'
     self notify:'hello there'

o  notifyTodo: msg position: position className: className selector: selector severity: severityOrSeveritySymbol priority: priorityOrPrioritySymbol equalityParameter: equalityParameter checkAction: checkAction
( an extension from the stx:libcomp package )
this is a message from the compiler system, to allow for a hook to remember
things to do. Can aslo used by other subsystems to add entries to the toDoList

o  warn: aString
launch a WarningBox, telling user something.
These warn-boxes can be suppressed by handling the
UserNotification- or WarningSignal and proceeding in the handler.
If nobody handles the exception, the dafault action of Warning
pops up a warn dialog.
usage example(s):
     nil warn:'hello there'
     self warn:'hello there'
usage example(s):
     Warning handle:[:ex |
        Transcript showCR:ex description.
        ex proceed.
     ] do:[
        'hello' printCR.
        self warn:'some info'.
        'world' printCR.
     ]

visiting
o  acceptVisitor: aVisitor
double-dispatch onto a Visitor.

o  acceptVisitor: aVisitor with: aParameter
double-dispatch via visitObject:with: into a Visitor.
Subclasses redefine this to pass their type in the message name (i.e. visitXXX:)

xml conversion
o  asXMLAttributeNamed: aName
( an extension from the stx:goodies/xml/stx package )

o  asXMLElementNamed: aName
( an extension from the stx:goodies/xml/stx package )


Subclasses (direct subclasses only):

    AVLTree::AVLNil
    AVLTree::AVLTreeNode
    AbstractBackground
    AbstractBackgroundJob
    AbstractBorder
    AbstractChart
    AbstractFileBrowser::Clipboard
    AbstractFileBrowser::CodeExecutionLock
    AbstractFileBrowser::DirectoryHistory::DirectoryHistoryItem
    AbstractFileBrowser::SaveAspectItem
    AbstractHierarchicalItem
    AbstractLauncherApplication::LauncherDialogs
    AbstractOperatingSystem
    AbstractOperatingSystem::PrinterInfo
    AbstractOperatingSystem::TimeInfo
    AbstractOperatingSystem::TimeZoneInfo
    AbstractSourceCodeManager
    AbstractSourceCodeManager::PackageAndManager
    AbstractSourceFileReader
    AbstractSourceFileWriter
    AbstractTCPSession
    AbstractTCPSocketServer
    ActionButton
    ActionButtonView
    ActionMenu
    ActiveObject
    Annotation
    Archiver
    Archiver::ArchiverOutputParser
    AssistantPageSpec
    Authentication::AuthenticationData
    Authentication::Authenticator
    Authentication::User
    Author
    BTree::BTreeKeys
    BTree::BTreeNode
    Behavior
    BinaryTreeNode
    BindingReference
    BoltLock
    BookmarkVisitor
    Boolean
    BorderDecorator
    Breakpoint
    BreakpointDescription
    CEnvironment
    CachedValue
    CallChain
    Change
    ChangeDeltaInformation
    ChangeSet::ChangeFileReader
    ChangeSet::ChangeFileWriter
    ChangeSet::ClassSourceWriter::ClassInfo
    ChangeSet::DiffSet
    ChangeSetDiff
    ChangeSetDiffComponent
    ChangesBrowser::ChangeFileReader
    ChangesBrowser::ChangeInfo
    CharacterAttributes
    CharacterBlockScanner
    CharacterEncoder
    Class::ClassAttributes
    Class::SimulatedClassPool
    ClassBuilder
    ClassCategoryReader
    ClassOrganizer
    CmdLineOption
    CmdLineParser
    CodeGeneratorTool
    Collection
    Color
    Color::DeviceColorHandle
    Comanche::Compiler
    Comanche::HttpParser
    Comanche::HttpResponse
    Comanche::IdFormatter
    Comanche::LineFormatter
    Comanche::MIMEDocument
    Comanche::MultipartChunk
    Comanche::NetNameResolver
    Comanche::NetworkRequest
    Comanche::STTComancheModel
    Comanche::STTModule
    Comanche::STTTemplate
    Comanche::SimulatedSqueakBlock
    Comanche::SimulatedSqueakFileDirectory
    Comanche::SimulatedSqueakFileStream
    Comanche::SimulatedSqueakMethod
    Comanche::SimulatedSqueakSocketStream
    Comanche::SwikiColorScheme
    Comanche::SwikiEntry
    Comanche::SwikiFileServer
    Comanche::SwikiModule
    Comanche::SwikiRequest
    Comanche::SwikiSchemeReadWriter
    Comanche::SwikiSecurityMember
    Comanche::SwikiSecurityModule
    Comanche::SwikiSecurityPrivileges
    Comanche::SwikiStorage
    Comanche::SwikiStructure
    Comanche::TextFormatter
    CompactHierarchicalItem::Geometry
    CompilationErrorHandler
    ComposedText
    CompositionScanner
    ConfigurableFeatures
    Context
    Continuation
    Controller
    Cursor
    CustomHelp
    DNSMessage
    DNSQuery
    DNSRecord
    DSVLabelView::LineDrag
    DataSetColumn
    DataSetColumnSpec
    DataSetColumnSpec::EditorAndModel
    DataSetLabel
    DebugView::IgnoredHaltOrBreakpoint
    Delay
    Demos::WebDemoShop::Article
    Demos::WebDemoShop::Customer
    Demos::WebDemoShop::Order
    Demos::WebDemoShop::Warehouse
    Demos::WebDemoShopSessions::Article
    Demos::WebDemoShopSessions::Customer
    Demos::WebDemoShopSessions::Order
    Demos::WebDemoShopSessions::Warehouse
    Demos::WebSlideShow::CachedDirectoryEntry
    Demos::WebSmalltalkBrowser::Arguments
    DeviceHandle
    DeviceWorkstation::DeviceFontMetrics
    Diff
    Diff2
    Diff2::Chunk
    Diff2::HuntMcilroy::Candidate
    Diff2::Patch
    Diff3
    Diff3::Chunk
    Diff3::Conflict
    Diff3Hunk
    Diff3InclusiveVisitor
    Diff::Data
    Diff::ForwardScript
    Diff::ReverseScript
    DiffListUtility
    DirectoryContents
    DirectoryContents::DirectoryContentsItem
    DirectoryContentsBrowser::DirectoryContentsItem
    DisplayObject
    DisplayScanner
    DisplayTransform
    DoWhatIMeanSupport
    Dolphin::File
    Dolphin::FileDialog
    Dolphin::IXMLDOMDocument
    Dolphin::IXMLDOMNamedNodeMap
    Dolphin::SWEnvironment
    Dolphin::SearchPolicy
    Dolphin::SessionManager
    Dolphin::SharedLookupTable
    DragAndDropManager
    DragDropManager
    DragDropManagerTracker
    DragHandler
    DrawAdaptor
    DropContext
    DropContext::DragType
    DropObject
    DropSource
    DropTarget
    EMailContentDescription
    EMailContentDescription::AttachmentDescription
    EditTextView::EditAction
    EditTextView::EditMode
    EditTextView::LastReplacementInfo
    EditTextViewCompletionSupport
    EnterFieldGroup
    ErrorDiffusion
    EventListener
    ExecutableFunction
    Explainer::ActionWithInfo
    ExternalAddress
    ExternalLibrary
    FCGI::FCGIHeader
    FCGI::FCGIKeyValuePairs
    FCGI::FCGIRecord
    FileApplicationNoteBook::ArchiveViewApplication::ArchivItem
    FileBrowserV2UISpecifications
    FileOperation
    FileSorter
    Filename
    FillStyle
    Font::DeviceFontHandle
    FontDescription
    FuzzyMatcher
    GapString
    GenericException
    GenericToolbarIconLibrary
    Geometric
    GraphicsContext
    GraphicsDevice
    GraphicsMedium
    GridBagConstraints
    GridBagLayoutInfo
    HTML::AbstractElement
    HTML::AbstractTreeBuilder
    HTML::CSS_AbstractStyleObject
    HTML::HTMLParser
    HTML::StyleVisitor
    HTML::Visitor
    HTMLDocGenerator
    HTMLDocument
    HTMLDocumentFrame::HRefHistoryEntry
    HTMLDocumentInterpreter
    HTMLDocumentPainter::PainterState
    HTMLDocumentPainter::TextStyle
    HTMLFontStyle
    HTMLPageStyle
    HTMLParser
    HTMLScriptEnvironment
    HTMLTableCol
    HTMLTableRow
    HTMLUtilities
    HTTPAccessLogger
    HTTPConnection
    HTTPCookie
    HTTPFileService::CachedFileInfo
    HTTPHeaderParser
    HTTPInterface
    HTTPInterface::HTTPCookie
    HTTPInterface::HTTPResponse
    HTTPInterface::KeptSocketInfo
    HTTPProxySettings
    HTTPRequest
    HTTPRequest::MultipartChunk
    HTTPResponse
    HTTPResponseHeader
    HTTPResponseHeader::CacheControl
    HTTPServer
    HTTPServerSettingsAppl::PluggableServicesSettingsAppl::ServiceItem
    HTTPServerSettingsAppl::VirtualRootItem
    HTTPService
    HTTPService::NoRealmBehavior
    HTTPServiceRequestContext
    HTTPSession
    HTTPSimpleJSONRestClient
    HTTPSimplePluggableJSONRestService::EntryInfo
    HTTPTentativeObjectService::TemporaryLinkInfo
    HierarchicalDropTargetController
    HierarchyNode
    HistoryManager
    HistoryManager::HistoryLine
    HtmlSanitizer
    HumanReadableImageGenerator
    IOAccessor
    Icon
    Image
    ImageFrame
    ImageReader
    InlineObject
    InputState
    InstructionClient
    InstructionStream
    InstrumentationContext
    InstrumentationInfo
    InstrumentingCompiler::MethodInvocationInfo::MethodInvocationInfoPerReceiverClass
    InstrumentingCompiler::MethodInvocationInfo::MethodInvocationInfoPerReceiverClass::MethodInvocationInfoPerSendingMethod
    Integer::ModuloNumber
    InterestConverter
    JIRAClient
    JavaScriptCompiler::LoopDescription
    JavaScriptCompiler::LoopDescriptionForBlock
    JavaScriptCompletionEngine
    JavaScriptEnvironment
    JavaScriptEnvironment::AppletObject
    JavaScriptEnvironment::AppletsObject
    JavaScriptEnvironment::Document
    JavaScriptEnvironment::DocumentObject
    JavaScriptEnvironment::FormFieldObject
    JavaScriptEnvironment::FormObject
    JavaScriptEnvironment::FormsObject
    JavaScriptEnvironment::HistoryObject
    JavaScriptEnvironment::Math
    JavaScriptEnvironment::WindowObject
    JavaScriptSimulatedBrowserEnvironment
    JavaScriptSourceReader
    KeyboardForwarder
    KeyboardProcessor
    KeywordInContextIndexBuilder
    Label::AnimatorState
    Layout
    LazyArray::UncomputedValue
    Link
    ListEntry
    ListItemWrapper
    ListModelView::Renderer
    ListModelView::TableRenderer::ColumnDescriptor
    ListView::HighlightArea
    ListView::SearchSpec
    Lookup
    MIMETypeIconLibrary
    MIMETypes
    Magnitude
    Math
    MczInstaller
    MemoryPolicy
    MemoryUsageView::StatisticEntry
    MenuBuilder
    MenuItem
    MenuPanel::Item
    MenuPanel::Item::Adornment
    MenuPanel::ScrollActivity
    Message
    MessageTally
    MessageTracer
    MessageTracer::MethodSpyInfo
    MessageTracer::MethodTimingInfo
    Method::MethodWhoInfo
    Method::ParseTreeCacheEntry
    Method::ParserCacheEntry
    MethodFinder
    MiniDebugger
    MiniInspector
    MiniLogger
    MinimalShellInterface
    MockMedium
    Model
    Monitor
    MultiImage
    NVTClient
    NameResolver
    NameSpace
    NameSpaceOrganizer
    NewLauncher::AddedToolInfo
    NonInteractiveCompilerErrorHandler
    NoteBookView::Tab
    OSErrorHolder
    OSProcess
    ObjectFileHandle
    ObjectFileLoader
    ObjectMemory
    ObjectMemory::BinaryModuleDescriptor
    OpaqueImage
    OperationQueue
    OperationQueue::OperationInQueue
    OrderedDither
    PackageId
    PackageInfo
    ParseNode
    ParseNodeVisitor
    Parser::Correction
    Parser::ParsedAnnotation
    ParserFlags
    PassivityWrapper
    PerforceSourceCodeManagementSettingsAppl::ModuleManager
    PerforceSourceCodeManager::CheckInDefinition
    PerforceSourceCodeManagerUtilities::WorkSpace
    PerforceSourceCodeManagerUtilities::WorkSpace::View
    PhoneticStringUtilities
    PhoneticStringUtilities::PhoneticStringComparator
    PluginSupport
    PolymorphicInlineCache
    Preferences
    PresenterStyleSheet
    PrintConverter
    PrintfScanf
    ProcessMonitorV2::ProcessItem
    ProcessorScheduler
    ProfileTree
    ProgramNodeBuilder
    ProgramNodeEnumerator
    ProgrammingLanguage
    Project
    Project::ClassInfo
    Project::MethodInfo
    ProjectChecker
    ProjectDefinition
    ProjectDefinition::AbbrevEntry
    ProjectDefinition::ApplicationDocumentTypeDescription
    ProjectProblem
    ProjectProblem::MethodCompilabilityIssue1::Error
    ProjectProblem::MethodCompilabilityIssue1::Warning
    Promise
    ProtocolClient
    RBComment
    RBParser
    RBProgramNode
    RBProgramNode::AuxInfo
    RBProgramNodeVisitor
    RBStringReplacement
    RBToken
    RandomBlumBlumShub
    RandomKISS
    RandomKISS2
    RandomMT19937
    RandomParkMiller
    RandomRDRand
    RandomTT800
    RasterOp
    ReadEvalPrintLoop
    ReadMe::ST80_ReadMe
    RemoteImage
    ReplyPresenter
    ResourceRetriever
    STCCompilerInterface
    Scanner
    Scanner::Comment
    Scanner::Directive
    ScheduledControllers
    ScrollValueHolder
    ScrollWrapper
    SelectionTracker
    Semaphore
    SequenceableCollectionSorter
    Set::EmptySlot
    Set::NilKey
    SftpClient
    SftpClient::SftpHandle
    SftpClient::SftpPacketBuilder
    SftpURI::WriteStreamSimulator
    SharedPool
    Signal
    SimpleView::ViewShape
    Singleton
    Smalltalk
    SmartRefStream
    SocketAddressInfo
    SourceCodeCache
    SourceCodeManagerUtilities
    SourceFileLoader
    SourceFileLoader::SourceFileReader
    Squeak::TextAnchor
    Squeak::TextColor
    Squeak::TextEmphasis
    Squeak::TextFontChange
    Squeak::TextURL
    StandaloneStartup
    StoreSourceCodeManager::DBInfo
    Stream
    StrikeFont
    StringCollationPolicy
    StringHolder
    StringPattern
    StringPattern::Parser
    StringUtilities
    SubChannelInfoSpec
    SunRPC::PortMapperServer::Mapping
    SunRPC::RPCDefinitions
    SunRPC::RPCDefinitions::RPCAuth
    SunRPC::RPCDefinitions::RPCCallHeader
    SunRPC::RPCDefinitions::RPCReplyHeader
    SunRPC::RPCEndPoint
    SunRPC::ReadMe
    SunRPC::SimulatedFile
    SunRPC::SimulatedFileSystem
    SunRPC::XDRCoder
    SunRPC::XDRItem
    SunRPC::XDRParser
    SunRPC::XDRType
    SunRPC::XDRType::EnumItem
    SunRPC::XDRType::Field
    SystemBrowser::BrowserHistoryEntry
    SystemChangeNotifier
    SystemDictionary
    SystemEnvironment
    SystemOrganization
    SystemOrganizer
    SystemUtils
    SystemVersion
    TSTreeNode
    TTFontDescription::TTKernPair
    TabWidget
    TelnetClient
    TerminalSession
    TextAttributes
    TextClassifier
    TextLines
    TextList
    TextStyle
    ThunderbirdComposeInterface
    TimePeriod
    Timestamp::TimestampBuilderAbstract
    ToolApplicationModel::HistoryEntry
    Tools::BreakpointBrowser::BreakpointListEntry
    Tools::BrowserList::SearchHandler
    Tools::CachedTags
    Tools::ChangeSetDiffInfo
    Tools::ChangeSetDiffList::ListEntry
    Tools::ChangeSetSpec
    Tools::ClassChecker
    Tools::ClassSorter
    Tools::CodeCritics
    Tools::CodeViewService
    Tools::Diff2CodeView2::Diff2Data
    Tools::Diff3CodeView2::Diff3Data
    Tools::DiffCodeView2::DiffData
    Tools::Inspector2Tab
    Tools::LintAnnotation
    Tools::LintHighlighter
    Tools::MethodCategoryCache
    Tools::MethodCategoryList::CachedMethodInfo
    Tools::NavigationHistory
    Tools::NavigationState
    Tools::NewSystemBrowser::OwnershipGraph::RevisionOwnershipInfo
    Tools::ProfilerInfoBuilder
    Tools::SmalltalkDiffTool::DiffItem
    Tools::Tag
    Tools::TestRunnerMini::SuiteAndResult
    Tools::TextMergeInfo
    Tools::TextMergeInfo::LineInfo
    Tools::Toolbox
    Tools::VariableList::VariableEntry
    TreeItem
    Trie::SmallDictionaryWith1Element
    Trie::SmallDictionaryWith2Elements
    Trie::SmallDictionaryWith3Elements
    TriggerButtonController
    UILookPolicy
    UIPalette
    UISpecVisitor
    UISpecification
    URI
    URITransmission
    URITransmissionService
    URITransmissionServiceAppl::TransmissionRow
    URL
    UndefinedObject
    UndefinedVariable
    UndoSupport
    UndoSupport::CompoundAction
    UnitConverter
    UnixOperatingSystem::ELFFileHeader
    UnixOperatingSystem::FileDescriptorHandle
    UnixOperatingSystem::FileStatusInfo
    UnixOperatingSystem::MountInfo
    UnixOperatingSystem::OSProcessStatus
    UnixProcess
    UserMessage
    Utilities
    V::Dynalink32
    V::GDIDLL
    V::OLEControlSitePane
    V::OLEStructure
    V::ViewManager
    VAST::CwDataInterchangeConverter
    VAST::CwGlobalMemoryTransferMechanism
    VAST::CwMainWindow
    VAST::CwPrimitive
    VAST::CwTransferMechanism
    VAST::CwWidget
    VAST::OSComposite
    VAST::OSDialogBox
    VAST::SubApplication
    VAST::System
    VW5PackageExporter
    Variable
    VariablePanel::SnapAdornment
    VersionDiffBrowser::FilterParameters
    VersionInfo
    Visitor
    VoidObject
    WidgetWrapper
    Win32Shell
    WindowBuilder
    WindowGroup
    WindowSensor
    XML::AttributeDef
    XML::AttributeType
    XML::DocumentType
    XML::ElementContext
    XML::FastSAXDriver
    XML::Node
    XML::NodeTag
    XML::Pattern
    XML::SAXDriver
    XML::SAXLocator
    XML::URIResolver
    XML::XMLNodeBuilder
    XML::XMLParser
    XMLStandardDecoder::AbstractConverter
    XWorkstation::PseudoDeviceWithoutXFTSupport
    XWorkstation::SelectionFetcher
    XftFontDescription::FCFontListParser
    ZipArchive
    ZipArchive::ZipCentralDirectory
    ZipArchive::ZipMember


ST/X 7.1.0.0; WebServer 1.663 at exept.de:8081; Mon, 23 Jul 2018 11:39:48 GMT