GNU Smalltalk Class Reference

Array

Category: Collections-Sequenceable

My instances are objects that have array-like properties: they are directly indexable by integers starting at 1, and they are fixed in size. I inherit object creation behavior messages such as #with:, as well as iteration and general access behavior from SequenceableCollection.

• Array-built ins: : built ins (instance)
• Array-mutating objects: : mutating objects (instance)
• Array-printing: : printing (instance)
• Array-testing: : testing (instance)

Array: built ins

at: anIndex

Answer the index-th indexed instance variable of the receiver.

at: anIndex put: value

Store value in the index-th indexed instance variable of the receiver

basicAt: anIndex

Answer the index-th indexed instance variable of the receiver. This method must not be overridden, override at: instead

basicAt: anIndex put: value

Store value in the index-th indexed instance variable of the receiver This method must not be overridden, override at:put: instead

Array: mutating objects

multiBecome: anArray

Transform every object in the receiver in each corresponding object in anArray. anArray and the receiver must have the same size

Array: printing

printOn: aStream

Print a representation for the receiver on aStream

Array: testing

isArray

Answer `false'.

ArrayedCollection

Category: Collections-Sequenceable

My instances are objects that are generally fixed size, and are accessed by an integer index. The ordering of my instance's elements is determined externally; I will not rearrange the order of the elements.

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

ArrayedCollection class: instance creation

new

Answer an empty collection

new: size withAll: anObject

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

with: element1

Answer a collection whose only element is element1

with: element1 with: element2

Answer a collection whose only elements are the parameters in the order they were passed

with: element1 with: element2 with: element3

Answer a collection whose only elements are the parameters in the order they were passed

with: element1 with: element2 with: element3 with: element4

Answer a collection whose only elements are the parameters in the order they were passed

withAll: aCollection

Answer a collection whose elements are the same as those in aCollection

ArrayedCollection: basic

, aSequenceableCollection

Answer a new instance of an ArrayedCollection containing all the elements in the receiver, followed by all the elements in aSequenceableCollection

add: value

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

copyWithout: oldElement

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

ArrayedCollection: built ins

size

Answer the size of the receiver

ArrayedCollection: copying Collections

copyWith: newElement

Answer a new instance of an ArrayedCollection containing all the receiver's elements and, at the end, newElement

reverse

Answer the receivers' contents in reverse order

ArrayedCollection: enumerating the elements of a collection

collect: aBlock

Answer a new instance of an ArrayedCollection containing all the results of evaluating aBlock passing each of the receiver's elements

reject: aBlock

Answer a new instance of an ArrayedCollection containing all the elements in the receiver which, when passed to aBlock, answer false

select: aBlock

Answer a new instance of an ArrayedCollection containing all the elements in the receiver which, when passed to aBlock, answer true

ArrayedCollection: storing

storeOn: aStream

Store Smalltalk code compiling to the receiver on aStream

Association

Category: Language-Data types

My instances represent a mapping between two objects. Typically, my "key" object is a symbol, but I don't require this. My "value" object has no conventions associated with it; it can be any object at all.

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

Association class: basic

key: aKey value: aValue

Answer a new association with the given key and value

Association: accessing

key

Answer the association's key

key: aKey value: aValue

Set the association's key to aKey, and its value to aValue

value

Answer the association's value

value: aValue

Set the association's value to aValue

Association: printing

printOn: aStream

Put on aStream a representation of the receiver

Association: storing

storeOn: aStream

Put on aStream some Smalltalk code compiling to the receiver

Association: testing

< anAssociation

Answer whether the association's key is less than anAssociation's

= anAssociation

Answer whether the association's key and value are the same as anAssociation's, or false if anAssociation is not an Association

hash

Answer an hash value for the receiver

Bag

Category: Collections-Unordered

My instances are unordered collections of objects. You can think of me as a set with a memory; that is, if the same object is added to me twice, then I will report that that element has been stored twice.

• Bag class-basic: : basic (class)
• Bag-Adding to a collection: : Adding to a collection (instance)
• Bag-enumerating the elements of a collection: : enumerating the elements of a collection (instance)
• Bag-printing: : printing (instance)
• Bag-Removing from a collection: : Removing from a collection (instance)
• Bag-storing: : storing (instance)
• Bag-testing collections: : testing collections (instance)

Bag class: basic

new

Answer a new instance of the receiver

Bag: Adding to a collection

add: newObject

Add an occurrence of newObject to the receiver. Answer newObject

add: newObject withOccurrences: anInteger

If anInteger > 0, add anInteger occurrences of newObject to the receiver. If anInteger < 0, remove them. Answer newObject

Bag: enumerating the elements of a collection

do: aBlock

Evaluate the block for all members in the collection.

Bag: printing

printOn: aStream

Put on aStream a representation of the receiver

Bag: Removing from a collection

remove: oldObject ifAbsent: anExceptionBlock

Remove oldObject from the collection and return it. If can't be found, answer instead the result of evaluationg anExceptionBlock

Bag: storing

storeOn: aStream

Put on aStream some Smalltalk code compiling to the receiver

Bag: testing collections

= aBag

Answer whether the receiver and aBag contain the same objects

hash

Answer an hash value for the receiver

occurrencesOf: anObject

Answer the number of occurrences of anObject found in the receiver

size

Answer the total number of objects found in the receiver

Behavior

Category: Language-Implementation

I am the parent class of all "class" type methods. My instances know about the subclass/superclass relationships between classes, contain the description that instances are created from, and hold the method dictionary that's associated with each class. I provide methods for compiling methods, modifying the class inheritance hierarchy, examining the method dictionary, and iterating over the class hierarchy.

• Behavior class-C interface: : C interface (class)
• Behavior class-creating lightweight classes: : creating lightweight classes (class)
• Behavior-accessing class hierarchy: : accessing class hierarchy (instance)
• Behavior-accessing instances and variables: : accessing instances and variables (instance)
• Behavior-accessing the methodDictionary: : accessing the methodDictionary (instance)
• Behavior-browsing: : browsing (instance)
• Behavior-built ins: : built ins (instance)
• Behavior-C callout: : C callout (instance)
• Behavior-compilation (alternative): : compilation (alternative) (instance)
• Behavior-creating a class hierarchy: : creating a class hierarchy (instance)
• Behavior-creating method dictionary: : creating method dictionary (instance)
• Behavior-enumerating: : enumerating (instance)
• Behavior-evaluating: : evaluating (instance)
• Behavior-hierarchy browsing: : hierarchy browsing (instance)
• Behavior-support for lightweight classes: : support for lightweight classes (instance)
• Behavior-testing the class hierarchy: : testing the class hierarchy (instance)
• Behavior-testing the form of the instances: : testing the form of the instances (instance)
• Behavior-testing the method dictionary: : testing the method dictionary (instance)

Behavior class: C interface

defineCFunc: cFuncNameString

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

Behavior class: creating lightweight classes

new

Create a new class. Having an instanceSpec defined this way won't be very useful, but at least it doesn't result in access violations!

Behavior: accessing class hierarchy

allSubclasses

Answer the direct and indirect subclasses of the receiver in a Set

allSuperclasses

Answer all the receiver's superclasses in a collection

subclasses

Answer the direct subclasses of the receiver in a Set

superclass

Answer the receiver's superclass (if any, otherwise answer nil)

withAllSubclasses

Answer a Set containing the receiver together with its direct and indirect subclasses

withAllSuperclasses

Answer the receiver and all of its superclasses in a collection

Behavior: accessing instances and variables

allClassVarNames

Return all the class variables understood by the receiver

allInstances

Returns a set of all instances of the receiver - you might get some nils in it: just discard them.

allInstVarNames

Answer all the instance variables for instances of the receiver

allSharedPools

Return the names of the shared pools defined by the class and any of its superclasses

classPool

Answer the class pool dictionary. Since Behavior does not support classes with class variables, we answer an empty one; adding variables to it results in an error.

classVarNames

Answer all the class variables for instances of the receiver

instanceCount

Return a count of all the instances of the receiver

instVarNames

Return all the instance variables added to the hierarchy by the receiver

sharedPools

Return the names of the shared pools defined by the class

subclassInstVarNames

Return all the instance variables inherited from the hierarchy by the receiver

Behavior: accessing the methodDictionary

>> selector

Return the compiled method associated with selector, from the local method dictionary. Error if not found.

allSelectors

Answer a Set of all the selectors understood by the receiver

compiledMethodAt: selector

Return the compiled method associated with selector, from the local method dictionary. Error if not found.

selectorAt: method

Return selector for the given compiledMethod

selectors

Answer a Set of the receiver's selectors

sourceCodeAt: selector

Answer source code (if available) for the given compiledMethod

sourceMethodAt: selector

This is too dependent on the original implementation

Behavior: browsing

getAllMethods

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

getDirectMethods

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

getIndirectMethods

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

getMethods

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

getMethodsFor: aSelector

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

methodDictionary

Answer the receiver's method dictionary

newGetMethods

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

Behavior: built ins

basicNew

Create a new instance of a class with no indexed instance variables

basicNew: numInstanceVariables

Create a new instance of a class with indexed instance variables. The instance has numInstanceVariables indexed instance variables.

compileString: aString

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

compileString: aString ifError: aBlock

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

flushCache

Invalidate the method cache kept by the virtual machine. This message should not need to be called by user programs.

makeDescriptorFor: funcNameString

returning: returnTypeSymbol withArgs: argsArray Private - Answer a CFunctionDescriptor

methodsFor: category ifTrue: condition

Compile the following code inside the receiver, with the given category, if condition is true; else ignore it

new

Create a new instance of a class with no indexed instance variables

new: numInstanceVariables

Create a new instance of a class with indexed instance variables. The instance has numInstanceVariables indexed instance variables.

someInstance

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

Behavior: C callout

defineCFunc: cFuncName

withSelectorArgs: selector returning: aReturnType args: argsArray Too complex to describe it here - Look up the C interface in the manual.

Behavior: compilation (alternative)

methods

Don't use this, it's only present to file in from Smalltalk/V

methodsFor

Don't use this, it's only present to file in from Dolphin Smalltalk

methodsFor: category ifFeatures: features

Start compiling methods in the receiver if this implementation of Smalltalk has the given features, else skip the section

methodsFor: category stamp: notUsed

Don't use this, it's only present to file in from Squeak

privateMethods

Don't use this, it's only present to file in from IBM Smalltalk

publicMethods

Don't use this, it's only present to file in from IBM Smalltalk

Behavior: creating a class hierarchy

addSubclass: aClass

Add aClass asone of the receiver's subclasses.

removeSubclass: aClass

Remove aClass from the list of the receiver's subclasses

superclass: aClass

Set the receiver's superclass.

Behavior: creating method dictionary

addSelector: selector withMethod: compiledMethod

Add the given compiledMethod to the method dictionary, giving it the passed selector. Answer compiledMethod

compile: code

Compile method source. If there are parsing errors, answer nil. Else, return a CompiledMethod result of compilation

compile: code ifError: block

Compile method source. If there are parsing errors, invoke exception block, 'block' passing file name, line number and error. description. Return a CompiledMethod result of compilation

compile: code notifying: requestor

Compile method source. If there are parsing errors, send #error: to the requestor object, else return a CompiledMethod result of compilation

compileAll

Recompile all selectors in the receiver. Ignore errors.

compileAll: aNotifier

Recompile all selectors in the receiver. Notify aNotifier by sen- ding #error: messages if something goes wrong.

compileAllSubclasses

Recompile all selector of all subclasses. Notify aNotifier by sen- ding #error: messages if something goes wrong.

compileAllSubclasses: aNotifier

Recompile all selector of all subclasses. Notify aNotifier by sen- ding #error: messages if something goes wrong.

createGetMethod: what

Create a method accessing the variable `what'.

createGetMethod: what default: value

Create a method accessing the variable `what', with a default value of `value', using lazy initialization

createSetMethod: what

Create a method which sets the variable `what'.

decompile: selector

Decompile the bytecodes for the given selector.

edit: selector

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

methodDictionary: aDictionary

Set the receiver's method dictionary to aDictionary

recompile: selector

Recompile the given selector, answer nil if something goes wrong or the new CompiledMethod if everything's ok.

recompile: selector notifying: aNotifier

Recompile the given selector. If there are parsing errors, send #error: to the aNotifier object, else return a CompiledMethod result of compilation

removeSelector: selector

Remove the given selector from the method dictionary, answer the CompiledMethod attached to that selector

removeSelector: selector ifAbsent: aBlock

Remove the given selector from the method dictionary, answer the CompiledMethod attached to that selector. If the selector cannot be found, answer the result of evaluating aBlock.

Behavior: enumerating

allInstancesDo: aBlock

Invokes aBlock for all instances of the receiver

allSubclassesDo: aBlock

Invokes aBlock for all subclasses, both direct and indirect.

allSubinstancesDo: aBlock

Invokes aBlock for all instances of each of the receiver's subclasses.

allSuperclassesDo: aBlock

Invokes aBlock for all superclasses, both direct and indirect.

selectSubclasses: aBlock

Return a Set of subclasses of the receiver satisfying aBlock.

selectSuperclasses: aBlock

Return a Set of superclasses of the receiver satisfying aBlock.

subclassesDo: aBlock

Invokes aBlock for all direct subclasses.

withAllSubclassesDo: aBlock

Invokes aBlock for the receiver and all subclasses, both direct and indirect.

withAllSuperclassesDo: aBlock

Invokes aBlock for the receiver and all superclasses, both direct and indirect.

Behavior: evaluating

evalString: aString to: anObject

Answer the stack top at the end of the evaluation of the code in aString. The code is executed as part of anObject

evalString: aString to: anObject ifError: aBlock

Answer the stack top at the end of the evaluation of the code in aString. If aString cannot be parsed, evaluate aBlock (see compileString:ifError:). The code is executed as part of anObject

evaluate: code

Evaluate Smalltalk expression in 'code' and return result.

evaluate: code ifError: block

Evaluate 'code'. If a parsing error is detected, invoke 'block'

evaluate: code notifying: requestor

Evaluate Smalltalk expression in 'code'. If a parsing error is encountered, invoke error block, 'block'

evaluate: code to: anObject

Evaluate Smalltalk expression as part of anObject's method definition

evaluate: code to: anObject ifError: block

Evaluate Smalltalk expression as part of anObject's method definition. This method is used to support Inspector expression evaluation. If a parsing error is encountered, invoke error block, 'block'

Behavior: hierarchy browsing

printHierarchy

Print my entire subclass hierarchy on the terminal.

printHierarchyEmacs

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

Behavior: support for lightweight classes

name

Answer the class name - a dummy one, since Behavior does not support names. This class name is used, for example, to print the receiver.

Behavior: testing the class hierarchy

inheritsFrom: aClass

Returns true if aClass is a superclass of the receiver

kindOfSubclass

Return a string indicating the type of class the receiver is

Behavior: testing the form of the instances

instSize

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

isBits

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

isBytes

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

isFixed

Answer whether the receiver's instances have no indexed instance variables

isIdentity

Answer whether x = y implies x == y for instances of the receiver

isImmediate

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

isPointers

Answer whether the instance variables of the receiver's instances are objects

isVariable

Answer whether the receiver's instances have indexed instance variables

isWords

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

Behavior: testing the method dictionary

canUnderstand: selector

Returns true if the instances of the receiver understand the given selector

hasMethods

Return whether the receiver has any methods defined

includesSelector: selector

Returns true if the local method dictionary contains the given selector

scopeHas: name ifTrue: aBlock

If methods understood by the receiver's instances have access to a symbol named 'name', evaluate aBlock

whichClassIncludesSelector: selector

Answer which class in the receiver's hierarchy contains the implementation of selector used by instances of the class (nil if none does)

whichSelectorsAccess: instVarName

Answer a Set of selectors which access the given instance variable

whichSelectorsReferTo: anObject

Returns a Set of selectors that refer to anObject

whichSelectorsReferToByteCode: aByteCode

Return the collection of selectors in the class which reference the byte code, aByteCode

BlockClosure

Category: Language-Implementation

I am a factotum class. My instances represent Smalltalk blocks, portions of executeable code that have access to the environment that they were declared in, take parameters, and can be passed around as objects to be executed by methods outside the current class. Block closures are sent a message to compute their value and create a new execution context; this property can be used in the construction of control flow methods. They also provide some methods that are used in the creation of Processes from blocks.

Implementation note: here is the use of the variable storage: - byte 1 = number of args - byte 2 = number of temps - bytes 3/4 = initial IP in machine order.

• BlockClosure-accessing: : accessing (instance)
• BlockClosure-basic: : basic (instance)
• BlockClosure-built ins: : built ins (instance)
• BlockClosure-exception handling: : exception handling (instance)
• BlockClosure-multiple process: : multiple process (instance)

BlockClosure: accessing

argumentCount

Answer the number of arguments passed to the receiver

initialIP

Answer the initial instruction pointer into the receiver

numTemps

Answer the number of temporary variables used by the receiver

outerContext

Answer the method/block context which is the immediate outer of the receiver

BlockClosure: basic

whileFalse

Evaluate the receiver until it returns true

whileFalse: aBlock

Evaluate the receiver. If it returns false, evaluate aBlock and re- start

whileTrue

Evaluate the receiver until it returns false

whileTrue: aBlock

Evaluate the receiver. If it returns true, evaluate aBlock and re- start

BlockClosure: built ins

value

Evaluate the receiver passing no parameters

value: arg1

Evaluate the receiver passing arg1 as the only parameter

value: arg1 value: arg2

Evaluate the receiver passing arg1 and arg2 as the parameters

value: arg1 value: arg2 value: arg3

Evaluate the receiver passing arg1, arg2 and arg3 as the parameters

valueWithArguments: argumentsArray

Evaluate the receiver passing argArray's elements as the parameters

BlockClosure: exception handling

ensure: aBlock

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

ifCurtailed: aBlock

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

on: anException do: aBlock

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

on: e1 do: b1 on: e2 do: b2

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

on: e1 do: b1 on: e2 do: b2 on: e3 do: b3

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

on: e1 do: b1 on: e2 do: b2 on: e3 do: b3 on: e4 do: b4

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

on: e1 do: b1 on: e2 do: b2 on: e3 do: b3 on: e4 do: b4 on: e5 do: b5

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

valueWithUnwind

Evaluate the receiver. Any errors caused by the block will cause a backtrace, but execution will continue in the method that sent #valueWithUnwind, after that call. Example: [ 1 / 0 ] valueWithUnwind. 'unwind works!' printNl. Important: this method is public, but it is intended to be used in very special cases. You should usually rely on #ensure: and #on:do:

BlockClosure: multiple process

fork

Create a new process executing the receiver and start it

forkAt: priority

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

newProcess

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

newProcessWith: anArray

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

BlockContext

Category: Language-Implementation

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

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

BlockContext: accessing

caller

Answer the context that called the receiver

home

Answer the MethodContext to which the receiver refers

isBlock

Answer whether the receiver is a block context

method

Return the CompiledMethod being executed

numArgs

Answer the number of arguments passed to the receiver

numTemps

Answer the number of temporaries used by the receiver

outerContext

Answer the outer block/method context for the receiver

receiver

Return the receiver (self) for the method being executed

selector

Return the selector for the method being executed

BlockContext: printing

printOn: aStream

Print a representation for the receiver on aStream

Boolean

Category: Language-Data types

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

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

Boolean class: testing

isIdentity

Answer whether x = y implies x == y for instances of the receiver

isImmediate

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

Boolean: basic

& aBoolean

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

and: aBlock

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

eqv: aBoolean

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

ifFalse: falseBlock

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

ifFalse: falseBlock ifTrue: trueBlock

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

ifTrue: trueBlock

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

ifTrue: trueBlock ifFalse: falseBlock

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

not

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

or: aBlock

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

xor: aBoolean

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

| aBoolean

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

Boolean: C hacks

asCBooleanValue

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

Boolean: overriding

deepCopy

Answer the receiver.

shallowCopy

Answer the receiver.

Boolean: storing

storeOn: aStream

Store on aStream some Smalltalk code which compiles to the receiver

Browser

Category: Language-Implementation

• Browser class-browsing: : browsing (class)

Browser class: browsing

browseHierarchy

Tell Emacs tp browse the Smalltalk class hierarchy

browseMethods: methods forClass: class inBuffer: bufferName

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

emacsFunction: funcName on: aBlock

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

emacsListFunction: funcName on: aBlock

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

finishEmacsMessage

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

getAllSelectors: selector inBuffer: bufferName

Send to Emacs code that browses the implementors of the given selectors in a buffer with the given name

initialize

Initialize the Emacs browsing system

loadClassNames

Tell Emacs the class names (new version)

oldloadClassNames

Tell Emacs the class names

oldShowInstanceMethods: class

Send to Emacs code that browses instance methods for class

oldShowMethods: class for: methodType

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

selectorsForEmacs

Tell Emacs the names of ALL the defined selectors

showAllMethods: class inBuffer: bufferName

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

showDirectMethods: class inBuffer: bufferName

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

showIndirectMethods: class inBuffer: bufferName

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

showMethods: class for: methodType

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

startEmacsMessage

Start a message to be processed by emacs as Lisp

testMethods: aClass for: methodType

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

withGcOff: aBlock

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

ByteArray

Category: Collections-Unordered

My instances are similar to strings in that they are both represented as a sequence of bytes, but my individual elements are integers, where as a String's elements are characters.

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

ByteArray: built ins

asCData: aCType

Convert the receiver to a CObject with the given type

byteAt: index

Answer the index-th indexed instance variable of the receiver

byteAt: index put: value

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

hash

Answer an hash value for the receiver

primReplaceFrom: start to: stop with: aByteArray startingAt: srcIndex

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

replaceFrom: start to: stop withString: aString startingAt: srcIndex

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

ByteArray: converting

asString

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

ByteArray: copying

deepCopy

Answer a shallow copy of the receiver

shallowCopy

Answer a shallow copy of the receiver

ByteArray: more advanced accessing

charAt: index

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

charAt: index put: value

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

doubleAt: index

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

doubleAt: index put: value

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

floatAt: index

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

floatAt: index put: value

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

intAt: index

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

intAt: index put: value

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

longAt: index

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

longAt: index put: value

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

objectAt: index

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

objectAt: index put: value

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

shortAt: index

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

shortAt: index put: value

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

stringAt: index

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

stringAt: index put: value

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

unsignedCharAt: index

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

unsignedCharAt: index put: value

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

unsignedIntAt: index

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

unsignedIntAt: index put: value

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

unsignedLongAt: index

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

unsignedLongAt: index put: value

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

unsignedShortAt: index

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

unsignedShortAt: index put: value

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

ByteMemory

Category: Language-Implementation

I have no instances. I provide messages to my class that access real memory as bytes. An alternative implementation would be to have a single instance of byte memory that represented all memory, and at: and at:put: accessor methods, but since you'd typically refer to that instance via a global variable, and since the global variable would probably be named ByteMemory, the actual method invocations are exactly the same in either case.

• ByteMemory class-basic: : basic (class)

ByteMemory class: basic

at: address

Returns the byte at address as an integer

at: address put: value

Sets the byte at ADDRESS (an integer) to be VALUE (INTEGER 0..255)

ByteStream

Category: Streams-Collections

My instances are read/write streams specially crafted for ByteArrays. They are able to write binary data to them.

• ByteStream-basic: : basic (instance)

ByteStream: basic

next

Return the next *character* in the ByteArray

nextByte

Return the next byte in the byte array

nextByteArray: numBytes

Return the next numBytes bytes in the byte array

nextLong

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

nextPut: aChar

Store aChar on the byte array

nextPutAll: aCollection

Write all the objects in aCollection to the receiver

nextPutByte: anInteger

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

nextPutByteArray: aByteArray

Store aByteArray on the byte array

nextPutLong: anInteger

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

nextPutShort: anInteger

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

nextShort

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

nextSignedByte

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

nextUlong

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

nextUshort

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

CAggregate

Category: Language-C interface

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

CAggregate class: accessing

alignof

Answer the receiver's instances required aligment

sizeof

Answer the receiver's instances size

CAggregate: accessing

+ anInteger

Return another CString pointing at &receiver[anInteger] (or, if you prefer, what `receiver + anInteger' does in C).

- intOrPtr

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

addressAt: anIndex

Access the array, returning a new Smalltalk CObject of the element type, corresponding to the given indexed element of the array. anIndex is zero-based, just like with all other C-style accessing.

at: anIndex

Access the array, returning a new Smalltalk object of the element type, corresponding to the given indexed element of the array. anIndex is zero-based, just like with all other C-style accessing.

at: anIndex put: aValue

Store in the array the passed Smalltalk object `aValue', which should be of the element type, corresponding to the given indexed element. anIndex is zero-based, just like with all other C-style accessing.

decr

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

decrBy: anInteger

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

deref

Access the object, returning a new Smalltalk object of the element type, corresponding to the dereferenced pointer or to the first element of the array.

deref: aValue

Modify the object, storing the object of the element type into the pointed address or to the first element of the array.

incr

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

incrBy: anInteger

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

value

Access the array, returning a new Smalltalk object of the element type, corresponding to the first element of the array.

value: aValue

Modify the array, storing the object of the element type into the first element of the array.

CArray

Category: Language-C interface

• CArray-accessing: : accessing (instance)

CArray: accessing

alignof

Answer the receiver's required aligment

sizeof

Answer the receiver's size

CArrayCType

Category: Language-C interface

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

CArrayCType class: instance creation

elementType: aCType numberOfElements: anInteger

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

CArrayCType: accessing

alignof

Answer the alignment of the receiver's instances

elementType

Answer the type of the elements in the receiver's instances

numberOfElements

Answer the number of elements in the receiver's instances

sizeof

Answer the size of the receiver's instances

CBoolean

Category: Language-C interface

I return true if a byte is not zero, false otherwise.

• CBoolean-accessing: : accessing (instance)

CBoolean: accessing

value

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

value: aBoolean

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

CByte

Category: Language-C interface

You're a marine. You adapt - you improvise - you overcome

- Gunnery Sgt. Thomas Highway Heartbreak Ridge

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

CByte class: conversion

scalarIndex

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

type

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

CByte: accessing

scalarIndex

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

type

Answer a CType for the receiver

value

Get the receiver's value - it's the same as for CUChars, but we convert the result to ASCII

value: anInteger

Set the receiver's value - it's the same as for CUChars, but we get an Integer, not a Character

CChar

Category: Language-C interface

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

CChar class: accessing

alignof

Answer the receiver's instances required aligment

scalarIndex

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

sizeof

Answer the receiver's instances size

CChar: accessing

alignof

Answer the receiver's required aligment

scalarIndex

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

sizeof

Answer the receiver's size

CDouble

Category: Language-C interface

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

CDouble class: accessing

alignof

Answer the receiver's instances required aligment

scalarIndex

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

sizeof

Answer the receiver's instances size

CDouble: accessing

alignof

Answer the receiver's required aligment

scalarIndex

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

sizeof

Answer the receiver's size

CFloat

Category: Language-C interface

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

CFloat class: accessing

alignof

Answer the receiver's instances required aligment

scalarIndex

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

sizeof

Answer the receiver's instances size

CFloat: accessing

alignof

Answer the receiver's required aligment

scalarIndex

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

sizeof

Answer the receiver's size

CFunctionDescriptor

Category: Language-C interface

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

• CFunctionDescriptor class-testing: : testing (class)
• CFunctionDescriptor-accessing: : accessing (instance)
• CFunctionDescriptor-printing: : printing (instance)

CFunctionDescriptor class: testing

addressOf: function

Answer the address (CObject) of the function which is registered (on the C side) with the given name, or zero if no such a function is registered.

isFunction: function

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

CFunctionDescriptor: accessing

address

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

isValid

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

name

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

CFunctionDescriptor: printing

printOn: aStream

Print a representation of the receiver onto aStream

Character

Category: Language-Data types

My instances represent the 256 characters of the character set. I provide messages to translate between integers and character objects, and provide names for some of the common unprintable characters.

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

Character class: built ins

asciiValue: anInteger

Returns the character object corresponding to anInteger. Error if anInteger is not an integer, or not in 0..255.

value: anInteger

Returns the character object corresponding to anInteger. Error if anInteger is not an integer, or not in 0..255.

Character class: constants

backspace

Returns the character 'backspace'

cr

Returns the character 'cr'

eof

Returns the character 'eof', aka 'sub'

esc

Returns the character 'esc'

newPage

Returns the character 'newPage', aka 'ff'

nl

Returns the character 'nl'

nul

Returns the character 'nul'

space

Returns the character 'space'

tab

Returns the character 'tab'

Character class: initializing lookup tables

initialize

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

Character class: Instance creation

digitValue: anInteger

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

Character class: testing

isIdentity

Answer whether x = y implies x == y for instances of the receiver

isImmediate

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

Character: built ins

= char

Boolean return value; true if the characters are equal

asciiValue

Returns the integer value corresponding to self

asInteger

Returns the integer value corresponding to self

value

Returns the integer value corresponding to self

Character: Coercion methods

asLowercase

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

asString

Returns the character self as a string.

asSymbol

Returns the character self as a symbol.

asUppercase

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

Character: comparing

< aCharacter

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

<= aCharacter

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

> aCharacter

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

>= aCharacter

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

Character: converting

digitValue

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

Character: printing

printOn: aStream

Store a representation of the receiver on aStream

Character: storing

storeOn: aStream

Store Smalltalk code compiling to the receiver on aStream

Character: testing

isAlphaNumeric

True if self is a letter or a digit

isDigit

True if self is a 0-9 digit

isLetter

True if self is an upper- or lowercase letter

isLowercase

True if self is a lowercase letter

isSeparator

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

isUppercase

True if self is uppercase

isVowel

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

Character: testing functionality

isCharacter

Answer True. We're definitely characters

CInt

Category: Language-C interface

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

CInt class: accessing

alignof

Answer the receiver's required aligment

scalarIndex

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

sizeof

Answer the receiver's size

CInt: accessing

alignof

Answer the receiver's instances required aligment

scalarIndex

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

sizeof

Answer the receiver's instances size

Class

Category: Language-Implementation

I am THE class object. My instances are the classes of the system

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

Class: accessing instances and variables

addClassVarName: aString

Add a class variable with the given name to the class pool dictionary

addSharedPool: aDictionary

Add the given shared pool to the list of the class' pool dictionaries

allClassVarNames

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

classPool

Answer the class pool dictionary

classVarNames

Answer the names of the variables in the class pool dictionary

initialize

redefined in children (?)

removeClassVarName: aString

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

removeSharedPool: aDictionary

Remove the given dictionary to the list of the class' pool dictionaries

sharedPools

Return the names of the shared pools defined by the class

Class: filing

fileOutDeclarationOn: aFileStream

File out class definition to aFileStream

fileOutHeaderOn: aFileStream

Write date and time stamp to aFileStream

fileOutOn: aFileStream

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

Class: instance creation

subclass: classNameString

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

variableByteSubclass: classNameString

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

variableSubclass: classNameString

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

variableWordSubclass: classNameString

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

Class: instance creation - alternative

categoriesFor: method are: categories

Don't use this, it is only present to file in from IBM Smalltalk

subclass: classNameString classInstanceVariableNames: stringClassInstVarNames instanceVariableNames: stringInstVarNames classVariableNames: stringOfClassVarNames poolDictionaries: stringOfPoolNames

Don't use this, it is only present to file in from IBM Smalltalk

subclass: classNameString instanceVariableNames: stringInstVarNames classVariableNames: stringOfClassVarNames poolDictionaries: stringOfPoolNames

Don't use this, it is only present to file in from IBM Smalltalk

variableByteSubclass: classNameString classInstanceVariableNames: stringClassInstVarNames instanceVariableNames: stringInstVarNames classVariableNames: stringOfClassVarNames poolDictionaries: stringOfPoolNames

Don't use this, it is only present to file in from IBM Smalltalk

variableByteSubclass: classNameString instanceVariableNames: stringInstVarNames classVariableNames: stringOfClassVarNames poolDictionaries: stringOfPoolNames

Don't use this, it is only present to file in from IBM Smalltalk

variableSubclass: classNameString classInstanceVariableNames: stringClassInstVarNames instanceVariableNames: stringInstVarNames classVariableNames: stringOfClassVarNames poolDictionaries: stringOfPoolNames

Don't use this, it is only present to file in from IBM Smalltalk

variableSubclass: classNameString instanceVariableNames: stringInstVarNames classVariableNames: stringOfClassVarNames poolDictionaries: stringOfPoolNames

Don't use this, it is only present to file in from IBM Smalltalk

variableWordSubclass: classNameString classInstanceVariableNames: stringClassInstVarNames instanceVariableNames: stringInstVarNames classVariableNames: stringOfClassVarNames poolDictionaries: stringOfPoolNames

Don't use this, it is only present to file in from IBM Smalltalk

variableWordSubclass: classNameString instanceVariableNames: stringInstVarNames classVariableNames: stringOfClassVarNames poolDictionaries: stringOfPoolNames

Don't use this, it is only present to file in from IBM Smalltalk

Class: printing

printOn: aStream

Print a representation of the receiver on aStream

storeOn: aStream

Store Smalltalk code compiling to the receiver on aStream

Class: testing

= aClass

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

Class: testing functionality

asClass

Answer the receiver.

isClass

Answer `true'.

ClassDescription

Category: Language-Implementation

My instances record information generally attributed to classes and metaclasses; namely, the class name, class comment (you wouldn't be reading this if it weren't for me), a list of the instance variables of the class, and the class category. I provide methods that access classes by category, and allow whole categories of classes to be filed out to external disk files.

• ClassDescription-accessing class description: : accessing class description (instance)
• ClassDescription-accessing instances and variables: : accessing instances and variables (instance)
• ClassDescription-compiling: : compiling (instance)
• ClassDescription-copying: : copying (instance)
• ClassDescription-filing: : filing (instance)
• ClassDescription-organization of messages and classes: : organization of messages and classes (instance)
• ClassDescription-printing: : printing (instance)

ClassDescription: accessing class description

addInstVarName: aString

Add the given instance variable to instance of the receiver

comment

Answer the class comment

comment: aString

Change the class name

name

Answer the class name

removeInstVarName: aString

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

ClassDescription: accessing instances and variables

allInstVarNames

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

instVarNames

Answer an Array containing the instance variables defined by the receiver

subclassInstVarNames

Answer the names of the instance variables the receiver inherited from its superclass

ClassDescription: compiling

compile: code classified: categoryName

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

compile: code classified: categoryName ifError: block

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

compile: code classified: categoryName notifying: requestor

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

ClassDescription: copying

copy: selector from: aClass

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

copy: selector from: aClass classified: categoryName

Copy the given selector from aClass, assigning it the given category

copyAll: arrayOfSelectors from: class

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

copyAll: arrayOfSelectors from: class classified: categoryName

Copy all the selectors in arrayOfSelectors from aClass, assigning them the given category

copyAllCategoriesFrom: aClass

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

copyCategory: categoryName from: aClass

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

copyCategory: categoryName from: aClass classified: newCategoryName

Copy all the selectors in from aClass that belong to the given category, reclassifying them as belonging to the given category

ClassDescription: filing

fileOut: fileName

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

fileOutCategory: categoryName to: fileName

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

fileOutCategory: category toStream: aFileStream

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

fileOutOn: aFileStream

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

fileOutSelector: selector to: fileName

File out the given selector to fileName

ClassDescription: organization of messages and classes

category

Answer the class category

category: aString

Change the class category to aString

createGetMethod: what

Create a method accessing the variable `what'.

createGetMethod: what default: value

Create a method accessing the variable `what', with a default value of `value', using lazy initialization

createSetMethod: what

Create a method which sets the variable `what'.

defineCFunc: cFuncNameString

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

removeCategory: aString

Remove from the receiver every method belonging to the given category

whichCategoryIncludesSelector: selector

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

ClassDescription: printing

classVariableString

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

instanceVariableString

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

sharedVariableString

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

CLong

Category: Language-C interface

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

CLong class: accessing

alignof

Answer the receiver's instances required aligment

scalarIndex

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

sizeof

Answer the receiver's instances size

CLong: accessing

alignof

Answer the receiver's required aligment

scalarIndex

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

sizeof

Answer the receiver's size

CObject

Category: Language-C interface

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

• CObject class-conversion: : conversion (class)
• CObject class-instance creation: : instance creation (class)
• CObject-accessing: : accessing (instance)
• CObject-C data access: : C data access (instance)
• CObject-conversion: : conversion (instance)
• CObject-finalization: : finalization (instance)

CObject class: conversion

scalarIndex

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

type

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

CObject class: instance creation

address: anInteger

Answer a new object pointing to the passed address, anInteger

alloc: nBytes

Allocate nBytes bytes and return an instance of the receiver

alloc: nBytes type: cTypeObject

Allocate nBytes bytes and return a CObject of the given type

new: nBytes

Allocate nBytes bytes and return an instance of the receiver

CObject: accessing

address

Answer the address the receiver is pointing to.

address: anInteger

Set the receiver to point to the passed address, anInteger

printOn: aStream

Print a representation of the receiver

type: aCType

Set the receiver's type to aCType.

value

What can I return? So fail

value: anObject

What can I set? So fail

CObject: C data access

at: byteOffset put: aValue type: aType

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

at: byteOffset type: aType

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

free

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

CObject: conversion

castTo: aType

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

scalarIndex

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

type

Answer a CType for the receiver

CObject: finalization

finalize

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

Collection

Category: Collections

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

• Collection class-instance creation: : instance creation (class)
• Collection-Adding to a collection: : Adding to a collection (instance)
• Collection-converting: : converting (instance)
• Collection-copying Collections: : copying Collections (instance)
• Collection-enumerating the elements of a collection: : enumerating the elements of a collection (instance)
• Collection-printing: : printing (instance)
• Collection-Removing from a collection: : Removing from a collection (instance)
• Collection-storing: : storing (instance)
• Collection-testing collections: : testing collections (instance)

Collection class: instance creation

with: anObject

Answer a collection whose only element is anObject

with: firstObject with: secondObject

Answer a collection whose only elements are the parameters in the order they were passed

with: firstObject with: secondObject with: thirdObject

Answer a collection whose only elements are the parameters in the order they were passed

with: firstObject with: secondObject with: thirdObject with: fourthObject

Answer a collection whose only elements are the parameters in the order they were passed

withAll: aCollection

Answer a collection whose elements are all those in aCollection

Collection: Adding to a collection

add: newObject

Add newObject to the receiver, answer it

addAll: aCollection

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

Collection: converting

asArray

Answer an Array containing all the elements in the receiver

asBag

Answer a Bag containing all the elements in the receiver

asByteArray

Answer a ByteArray containing all the elements in the receiver

asOrderedCollection

Answer an OrderedCollection containing all the elements in the receiver

asRunArray

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

asSet

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

asSortedCollection

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

asSortedCollection: aBlock

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

Collection: copying Collections

copyReplacing: targetObject withObject: newObject

Copy replacing each object which is = to targetObject with newObject

copyWith: newElement

Answer a copy of the receiver to which newElement is added

copyWithout: oldElement

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

Collection: enumerating the elements of a collection

allSatisfy: aBlock

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

anyOne

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

anySatisfy: aBlock

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

collect: aBlock

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

conform: aBlock

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

contains: aBlock

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

detect: aBlock

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

detect: aBlock ifNone: exceptionBlock

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

do: aBlock

Enumerate each object of the receiver, passing them to aBlock

do: aBlock separatedBy: separatorBlock

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

inject: thisValue into: binaryBlock

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

reject: aBlock

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

select: aBlock

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

Collection: printing

inspect

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

printOn: aStream

Print a representation of the receiver on aStream

Collection: Removing from a collection

remove: oldObject

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

remove: oldObject ifAbsent: anExceptionBlock

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

removeAll: aCollection

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

removeAll: aCollection ifAbsent: aBlock

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

Collection: storing

storeOn: aStream

Store Smalltalk code compiling to the receiver on aStream

Collection: testing collections

capacity

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

includes: anObject

Answer whether we include anObject

isEmpty

Answer whether we are (still) empty

notEmpty

Answer whether we include at least one object

occurrencesOf: anObject

Answer how many occurrences of anObject we include

size

Answer how many objects we include

CompiledMethod

Category: Language-Implementation

I represent methods that have been compiled. I can recompile methods from their source code, I can invoke Emacs to edit the source code for one of my instances, and I know how to access components of my instances.

• CompiledMethod class-instance creation: : instance creation (class)
• CompiledMethod class-lean images: : lean images (class)
• CompiledMethod-accessing: : accessing (instance)
• CompiledMethod-basic: : basic (instance)
• CompiledMethod-copying: : copying (instance)
• CompiledMethod-debugging: : debugging (instance)
• CompiledMethod-printing: : printing (instance)
• CompiledMethod-testing accesses: : testing accesses (instance)

CompiledMethod class: instance creation

literals: lits numArgs: numArg numTemps: numTemp

primitive: primIndex bytecodes: bytecodes depth: depth Answer a full fledged CompiledMethod. Construct the method header from the parameters, and set the literals and bytecodes to the provided ones.

newMethod: numBytecodes header: anInteger literals: literals

Answer a new CompiledMethod with room for the given bytes and the given header

newMethod: numBytecodes header: anInteger numLiterals: numLiterals

Answer a new CompiledMethod with room for the given bytes and the given header

CompiledMethod class: lean images

stripSourceCode

Remove all the references to method source code from the system

CompiledMethod: accessing

bytecodeAt: anIndex

Answer the anIndex-th bytecode

bytecodeAt: anIndex put: aValue

Store aValue as the anIndex-th bytecode

flags

Private - Answer the optimization flags for the receiver

literalAt: anIndex

Answer the anIndex-th literal

literalAt: anInteger put: aValue

Store aValue as the anIndex-th literal

literals

Not commented.

numArgs

Answer the number of arguments for the receiver

numLiterals

Answer the number of literals for the receiver

numTemps

Answer the number of temporaries for the receiver

primitive

Answer the primitive called by the receiver

stackDepth

Answer the number of stack slots needed for the receiver

CompiledMethod: basic

= aMethod

Answer whether the receiver and aMethod are equal

hash

Answer an hash value for the receiver

methodCategory

Answer the method category

methodCategory: aCategory

Set the method category to the given string

methodSourceCode

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

methodSourceFile

Answer the file where the method source code is stored

methodSourcePos

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

methodSourceString

Answer the method source code as a string

CompiledMethod: copying

copy

Answer a shallow copy of the receiver

deepCopy

Answer a deep copy of the receiver

shallowCopy

Answer a shallow copy of the receiver

CompiledMethod: debugging

breakAtLine: lineNumber

This method's functionality has not been implemented yet.

breakpointAt: byteIndex

Put a break-point at the given bytecode

inspect

Print the contents of the receiver in a verbose way.

removeBreakpointAt: byteIndex

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

CompiledMethod: printing

printOn: aStream

Print the receiver's source code on aStream

storeOn: aStream

Print code to create the receiver on aStream

CompiledMethod: testing accesses

accesses: instVarIndex

Answer whether the receiver access the instance variable with the given index

containsLiteral: anObject

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

refersTo: anObject

Answer whether the receiver refers to the given object

ContextPart

Category: Language-Implementation

My instances represent executing Smalltalk code, which represent the local environment of executable code. They contain a stack and also provide some methods that can be used in inspection or debugging.

• ContextPart class-exception handling: : exception handling (class)
• ContextPart-accessing: : accessing (instance)
• ContextPart-built ins: : built ins (instance)
• ContextPart-exception handling: : exception handling (instance)
• ContextPart-printing: : printing (instance)
• ContextPart-processes: : processes (instance)

ContextPart class: exception handling

backtrace

Print a backtrace from the caller to the bottom of the stack on the Transcript

backtraceOn: aStream

Print a backtrace from the caller to the bottom of the stack on aStream

lastUnwindPoint

Private - Return the last context marked as an unwind point, or our en- vironment if the last unwind point belongs to another environment.

removeLastUnwindPoint

Private - Return and remove the last context marked as an unwind point, or our environment if the last unwind point belongs to another environment.

unwind

Return execution to the last context marked as an unwind point, returning nil on that stack.

unwind: returnValue

Return execution to the last context marked as an unwind point, returning returnValue on that stack.

unwindPoints

Answer an OrderedCollection of contexts marked as unwind points.

ContextPart: accessing

environment

To create a valid execution environment for the interpreter even before it starts, GST creates a fake context whose selector is nil and which can be used as a marker for the current execution environment. This method answers that context. For processes, it answers the process block itself

hasBlock

Answer whether the receiver is the outer context for a BlockContext

home

Answer the MethodContext to which the receiver refers

ip

Answer the current instruction pointer into the receiver

ip: newIP

Set the instruction pointer for the receiver

isBlock

Answer whether the receiver is a block context

isProcess

Answer whether the receiver represents a process context, i.e. a context created by BlockClosure>>#newProcess. Such a context can be recognized because it has no parent but its selector is not nil, unlike the contexts created by the VM's prepareExecutionEnvironment function.

method

Return the CompiledMethod being executed

parentContext

Answer the context that called the receiver

receiver

Return the receiver (self) for the method being executed

selector

Return the selector for the method being executed

size

Answer the number of valid fields for the receiver. Any read access from (self size + 1) to (self basicSize) has undefined results - even crashing

sp

Answer the current stack pointer into the receiver

sp: newSP

Set the stack pointer for the receiver

validSize

Answer how many elements in the receiver should be inspected

ContextPart: built ins

blockCopy: numArgs temporaries: numTemps

Generate a BlockClosure starting execution two bytecodes after the end of the 'send special message #blockCopy:' bytecode

ContextPart: exception handling

mark

Add the receiver as a possible unwind point

returnTo: aContext

Set the context to which the receiver will return

unmark

Remove the receiver from the contexts to which an unwind operation might return

ContextPart: printing

backtrace

Print a backtrace from the receiver to the bottom of the stack on the Transcript.

backtraceOn: aStream

Print a backtrace from the caller to the bottom of the stack on aStream.

ContextPart: processes

nowHasBlock

Private - Tell the VM that the receiver has references in other objects

CPtr

Category: Language-C interface

• CPtr-accessing: : accessing (instance)

CPtr: accessing

alignof

Answer the receiver's required aligment

sizeof

Answer the receiver's size

CPtrCType

Category: Language-C interface

• CPtrCType class-instance creation: : instance creation (class)
• CPtrCType-accessing: : accessing (instance)

CPtrCType class: instance creation

elementType: aCType

Answer a new instance of CPtrCType that maps pointers to the given CType

CPtrCType: accessing

elementType

Answer the type of the elements in the receiver's instances

CScalar

Category: Language-C interface

• CScalar class-instance creation: : instance creation (class)
• CScalar-accessing: : accessing (instance)

CScalar class: instance creation

type

Answer a CType for the receiver - for example, CByteType if the receiver is CByte.

value: anObject

Answer a newly allocated CObject containing the passed value, anObject. Remember to call #addToBeFinalized if you want the CObject to be automatically freed

CScalar: accessing

value

Answer the value the receiver is pointing to. The exact returned value depends on the receiver's class

value: aValue

Set the receiver to point to the value, aValue. The exact meaning of aValue depends on the receiver's class

CScalarCType

Category: Language-C interface

• CScalarCType-accessing: : accessing (instance)
• CScalarCType-storing: : storing (instance)

CScalarCType: accessing

valueType

valueType is used as a means to communicate to the interpreter the underlying type of the data. For scalars, it is supplied by the CObject subclass.

CScalarCType: storing

storeOn: aStream

Store Smalltalk code that compiles to the receiver

CShort

Category: Language-C interface

• CShort class-accessing: : accessing (class)
• CShort-accessing: : accessing (instance)

CShort class: accessing

alignof

Answer the receiver's instances required aligment

scalarIndex

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

sizeof

Answer the receiver's instances size

CShort: accessing

alignof

Answer the receiver's required aligment

scalarIndex

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

sizeof

Answer the receiver's size

CSmalltalk

Category: Language-C interface

• CSmalltalk class-accessing: : accessing (class)
• CSmalltalk-accessing: : accessing (instance)

CSmalltalk class: accessing

alignof

Answer the receiver's instances required aligment

scalarIndex

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

sizeof

Answer the receiver's instances size

CSmalltalk: accessing

alignof

Answer the receiver's required aligment

scalarIndex

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

sizeof

Answer the receiver's size

CString

Category: Language-C interface

Technically, CString is really a pointer to type char. However, it's so darn useful as a distinct datatype, and it is a separate datatype in Smalltalk, so we allow developers to express their semantics more precisely by using a more descriptive type.

In general, I behave like a cross between an array of characters and a pointer to a character. I provide the protocol for both data types. My #value method returns a Smalltalk String, as you would expect for a scalar datatype.

• CString class-getting info: : getting info (class)
• CString-accessing: : accessing (instance)
• CString-pointer like behavior: : pointer like behavior (instance)

CString class: getting info

alignof

Answer the receiver's instances required aligment

scalarIndex

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

sizeof

Answer the receiver's size

CString: accessing

alignof

Answer the receiver's required aligment

scalarIndex

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

sizeof

Answer the receiver's size

CString: pointer like behavior

+ anInteger

Return another CString pointing at &receiver[anInteger] (or, if you prefer, what `receiver + anInteger' does in C).

- intOrPtr

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

addressAt: anIndex

Access the string, returning a Smalltalk CChar corresponding to the given indexed element of the string. anIndex is zero-based, just like with all other C-style accessing.

at: anIndex

Access the string, returning the Smalltalk Character corresponding to the given indexed element of the string. anIndex is zero-based, just like with all other C-style accessing.

at: anIndex put: aCharacter

Store in the string a Smalltalk Character, at the given indexed element of the string. anIndex is zero-based, just like with all other C-style accessing.

decr

Adjust the pointer by one byte down (i.e. -receiver)

decrBy: anInteger

Adjust the pointer by anInteger bytes down (i.e. receiver -= anInteger). Note that, unlike #-, #decrBy: does not support passing another CString as its parameter, since neither C supports something like `charPtr -= anotherCharPtr'

deref

Access the string, returning the Smalltalk CChar corresponding to the first element of the string. This may not make much sense, but it resembles what `*string' does in C.

deref: aCChar

Access the string, setting the first element of the string to the value of the passed CChar. This may not make much sense, but it resembles what we get in C if we do *string = 's'.

incr

Adjust the pointer by one byte up (i.e. ++receiver)

incrBy: anInteger

Adjust the pointer by anInteger bytes up (i.e. receiver += anInteger)

replaceWith: aString

Overwrite memory starting at the receiver's address, with the contents of the Smalltalk String aString, null-terminating it. Ensure there is free space enough, or big trouble will hit you!

CStruct

Category: Language-C interface

• CStruct class-instance creation: : instance creation (class)
• CStruct class-subclass creation: : subclass creation (class)
• CStruct-instance creation: : instance creation (instance)

CStruct class: instance creation

new

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

type

Answer a CType for the receiver

CStruct class: subclass creation

compileSize: size align: alignment for: aClass

Private - Compile sizeof and alignof methods

computeAggregateType: type block: aBlock

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

computeArrayType: type block: aBlock

Private - Called by computeAggregateType:block: for arrays

computePtrType: type block: aBlock

Private - Called by computeAggregateType:block: for pointers

computeTypeString: type block: aBlock

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

emitInspectTo: str for: name

Private - Emit onto the given stream the code for adding the given selector to the CStruct's inspector.

initialize

Initialize the receiver's TypeMap

newStruct: structName declaration: array

Create a new class with the given name that contains code to implement the given C struct - see documentation for more information

CStruct: instance creation

inspect

Inspect the contents of the receiver

inspectSelectorList

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

CType

Category: Language-C interface

I am not part of the standard Smalltalk kernel class hierarchy. I contain type information used by subclasses of CObject, which represents external C data items.

My subclasses have instances which represent the actual data types; for the scalar types, there is only one instance created of each, but for the aggregate types, there is at least one instance per base type and/or number of elements.

• CType class-C instance creation: : C instance creation (class)
• CType-accessing: : accessing (instance)
• CType-C instance creation: : C instance creation (instance)
• CType-storing: : storing (instance)

CType class: C instance creation

cObjectType: aCObjectSubclass

Create a new CType for the given subclass of CObject

CType: accessing

alignof

Answer the size of the receiver's instances

cObjectType

Answer the CObject subclass whose instance is created when new is sent to the receiver

sizeof

Answer the size of the receiver's instances

valueType

valueType is used as a means to communicate to the interpreter the underlying type of the data. For anything but scalars, it's just 'self'

CType: C instance creation

new

Allocate a new CObject with the type (class) identified by the receiver. It is the caller's responsibility to free the memory allocated for it.

new: cObjOrInt

Create a new CObject with the type (class) identified by the receiver, pointing to the given address (identified by an Integer or CObject).

CType: storing

storeOn: aStream

Store Smalltalk code that compiles to the receiver

CUChar

Category: Language-C interface

• CUChar class-getting info: : getting info (class)
• CUChar-accessing: : accessing (instance)

CUChar class: getting info

alignof

Answer the receiver's instances required aligment

scalarIndex

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

sizeof

Answer the receiver's instances size

CUChar: accessing

alignof

Answer the receiver's required aligment

scalarIndex

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

sizeof

Answer the receiver's size

CUInt

Category: Language-C interface

• CUInt class-accessing: : accessing (class)
• CUInt-accessing: : accessing (instance)

CUInt class: accessing

alignof

Answer the receiver's instances required aligment

scalarIndex

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

sizeof

Answer the receiver's instances size

CUInt: accessing

alignof

Answer the receiver's required aligment

scalarIndex

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

sizeof

Answer the receiver's size

CULong

Category: Language-C interface

• CULong class-accessing: : accessing (class)
• CULong-accessing: : accessing (instance)

CULong class: accessing

alignof

Answer the receiver's instances required aligment

scalarIndex

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

sizeof

Answer the receiver's instances size

CULong: accessing

alignof

Answer the receiver's required aligment

scalarIndex

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

sizeof

Answer the receiver's size

CUShort

Category: Language-C interface

• CUShort class-accessing: : accessing (class)
• CUShort-accessing: : accessing (instance)

CUShort class: accessing

alignof

Answer the receiver's instances required aligment

scalarIndex

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

sizeof

Answer the receiver's instances size

CUShort: accessing

alignof

Answer the receiver's required aligment

scalarIndex

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

sizeof

Answer the receiver's size

Date

Category: Language-Data types

My instances represent dates. My base date is defined to be Jan 1, 1901. I provide methods for instance creation (including via "symbolic" dates, such as "Date newDay: 14 month: #Feb year: 1990".

PLEASE BE WARNED - use this class only for dates after 1582 AD; that's the beginning of the epoch. Dates before 1582 will not be correctly printed. In addition, since ten days were lost from October 5 through October 15, operations between a Gregorian date (after 15-Oct-1582) and a Julian date (before 5-Oct-1582) will give incorrect results; or, 4-Oct-1582 + 2 days will yield 6-Oct-1582 (a non-existent day!), not 16-Oct-1582.

In fact, if you pass a year < 1582 to a method like #newDay:month:year: it will assume that it is a two-digit year (e.g. 90=1990, 1000=2900). The only way to create Julian calendar dates is with the #fromDays: instance creation method.

• Date class-basic: : basic (class)
• Date class-instance creation: : instance creation (class)
• Date-basic: : basic (instance)
• Date-date computations: : date computations (instance)
• Date-printing: : printing (instance)
• Date-storing: : storing (instance)
• Date-testing: : testing (instance)

Date class: basic

dateAndTimeNow

Answer an array containing the current date and time

dayOfWeek: dayName

Answer the index of the day of week corresponding to the given name

daysInMonth: monthName forYear: yearInteger

Answer the number of days in the given (named) month for the given year

daysInYear: yearInteger

Answer the number of days in the given year

indexOfMonth: monthName

Answer the index of the month corresponding to the given name

initDayNameDict

Initialize the DayNameDict to the names of the days

initialize

Initialize the receiver

initMonthNameDict

Initialize the MonthNameDict to the names of the months

nameOfDay: dayIndex

Answer the name of the day of week corresponding to the given index

nameOfMonth: monthIndex

Answer the name of the month corresponding to the given index

shortNameOfMonth: monthIndex

Answer the name of the month corresponding to the given index

Date class: instance creation

fromDays: dayCount

Answer a Date denoting dayCount days past 1/1/1901

fromJulian: jd

Answer a Date denoting the jd-th day in the astronomical Julian calendar.

fromSeconds: time

Answer a Date denoting the date time seconds past Jan 1st, 2000

newDay: day month: monthName year: yearInteger

Answer a Date denoting the dayCount day of the given (named) month and year

newDay: day monthIndex: monthIndex year: yearInteger

Answer a Date denoting the dayCount day of the given (as a number) month and year

newDay: dayCount year: yearInteger

Answer a Date denoting the dayCount day of the yearInteger year

today

Answer a Date denoting the current date

Date: basic

addDays: dayCount

Answer a new Date pointing dayCount past the receiver

subtractDate: aDate

Answer the number of days between aDate and the receiver (negative if the receiver is before aDate)

subtractDays: dayCount

Answer a new Date pointing dayCount before the receiver

Date: date computations

asSeconds

Answer the date as the number of seconds from 1/1/1901.

day

Answer the day represented by the receiver

dayName

Answer the day of week of the receiver as a Symbol

dayOfWeek

Answer the day of week of the receiver. 1 = Monday, 7 = Sunday

dayOfYear

Answer the days passed since 31/12 of last year; e.g. New Year's Day is 1

daysFromBaseDay

Answer the days passed since 1/1/1901

daysInMonth

Answer the days in the month represented by the receiver

daysInYear

Answer the days in the year represented by the receiver

daysLeftInMonth

Answer the days to the end of the month represented by the receiver

daysLeftInYear

Answer the days to the end of the year represented by the receiver

firstDayOfMonth

Answer a Date representing the first day of the month represented by the receiver

lastDayOfMonth

Answer a Date representing the last day of the month represented by the receiver

month

Answer the month represented by the receiver

monthName

Answer the name of the month represented by the receiver

year

Answer the year represented by the receiver

Date: printing

printOn: aStream

Print a representation for the receiver on aStream

Date: storing

storeOn: aStream

Store on aStream Smalltalk code compiling to the receiver

Date: testing

< aDate

Answer whether the receiver indicates a date preceding aDate

= aDate

Answer whether the receiver indicates the same date as aDate

hash

Answer an hash value for the receievr

Delay

Category: Language-Processes

I am the ultimate agent for frustration in the world. I cause things to wait (typically much more than is appropriate, but it is those losing operating system's fault). When a process sends one of my instances a wait message, that process goes to sleep for the interval specified when the instance was created.

• Delay class-general inquiries: : general inquiries (class)
• Delay class-initialization: : initialization (class)
• Delay class-instance creation: : instance creation (class)
• Delay-accessing: : accessing (instance)
• Delay-comparing: : comparing (instance)
• Delay-process delay: : process delay (instance)

Delay class: general inquiries

millisecondClockValue

Private - Answer the number of milliseconds since midnight

Delay class: initialization

initialize

Private - Initialize the receiver and the associated process

Delay class: instance creation

forMilliseconds: millisecondCount

Answer a Delay waiting for millisecondCount milliseconds

forSeconds: secondCount

Answer a Delay waiting for secondCount seconds

untilMilliseconds: millisecondCount

Answer a Delay waiting for millisecondCount milliseconds after midnight

Delay: accessing

resumptionTime

Answer the time when a process waiting on a Delay will resume

Delay: comparing

= aDelay

Answer whether the receiver and aDelay denote the same delay

hash

Answer an hash value for the receiver

Delay: process delay

wait

Wait until the amount of time represented by the instance of Delay elapses

DelayedAdaptor

Category: Language-Data types

I can be used where many expensive updates must be performed. My in- stances buffer the last value that was set, and only actually set the value when the #trigger message is sent. Apart from this, I'm equi- valent to PluggableAdaptor.

• DelayedAdaptor-accessing: : accessing (instance)

DelayedAdaptor: accessing

trigger

Really set the value of the receiver.

value

Get the value of the receiver.

value: anObject

Set the value of the receiver - actually, the value is cached and is not set until the #trigger method is sent.

Dictionary

Category: Collections-Keyed

I implement a dictionary, which is an object that is indexed by unique objects (typcially instances of Symbol), and associates another object with that index. I use the equality operator = to determine equality of indices.

• Dictionary class-instance creation: : instance creation (class)
• Dictionary-accessing: : accessing (instance)
• Dictionary-awful ST-80 compatibility hacks: : awful ST-80 compatibility hacks (instance)
• Dictionary-dictionary enumerating: : dictionary enumerating (instance)
• Dictionary-dictionary removing: : dictionary removing (instance)
• Dictionary-dictionary testing: : dictionary testing (instance)
• Dictionary-printing: : printing (instance)
• Dictionary-storing: : storing (instance)
• Dictionary-testing: : testing (instance)

Dictionary class: instance creation

new

Create a new dictionary with a default size

Dictionary: accessing

add: newObject

Add the newObject association to the receiver

associationAt: key

Answer the key/value Association for the given key. Fail if the key is not found

associationAt: key ifAbsent: aBlock

Answer the key/value Association for the given key. Evaluate aBlock (answering the result) if the key is not found

at: key

Answer the value associated to the given key. Fail if the key is not found

at: key ifAbsent: aBlock

Answer the value associated to the given key, or the result of evaluating aBlock if the key is not found

at: aKey ifAbsentPut: aBlock

Answer the value associated to the given key. If the key is not found, evaluate aBlock and associate the result to aKey before returning.

at: aKey ifPresent: aBlock

If aKey is absent, answer nil. Else, evaluate aBlock passing the associated value and answer the result of the invocation

at: key put: value

Store value as associated to the given key

keyAtValue: value

Answer the key associated to the given value. Evaluate exceptionBlock (answering the result) if the value is not found

keyAtValue: value ifAbsent: exceptionBlock

Answer the key associated to the given value. Evaluate exceptionBlock (answering the result) if the value is not found. IMPORTANT: == is used to compare values

keys

Answer a kind of Set containing the keys of the receiver

values

Answer a Bag containing the values of the receiver

Dictionary: awful ST-80 compatibility hacks

findKeyIndex: key

Tries to see if key exists as a the key of an indexed variable. As soon as nil or an association with the correct key is found, the index of that slot is answered

Dictionary: dictionary enumerating

associationsDo: aBlock

Pass each association in the dictionary to aBlock

collect: aBlock

Answer a new dictionary where the keys are the same and the values are obtained by passing each value to aBlock and collecting the return values

do: aBlock

Pass each value in the dictionary to aBlock

keysAndValuesDo: aBlock

Pass each key/value pair in the dictionary as two distinct parameters to aBlock

keysDo: aBlock

Pass each key in the dictionary to aBlock

reject: aBlock

Answer a new dictionary containing the key/value pairs for which aBlock returns false. aBlock only receives the value part of the pairs.

select: aBlock

Answer a new dictionary containing the key/value pairs for which aBlock returns true. aBlock only receives the value part of the pairs.

Dictionary: dictionary removing

remove: anObject

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

remove: anObject ifAbsent: aBlock

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

removeAllKeys: keys

Remove all the keys in keys, without raising any errors

removeAllKeys: keys ifAbsent: aBlock

Remove all the keys in keys, passing the missing keys as parameters to aBlock as they're encountered

removeAssociation: anAssociation

Remove anAssociation's key from the dictionary

removeKey: key

Remove the passed key from the dictionary, fail if it is not found

removeKey: key ifAbsent: aBlock

Remove the passed key from the dictionary, answer the result of evaluating aBlock if it is not found

Dictionary: dictionary testing

includes: anObject

Answer whether the receiver contains anObject as one of its values

includesAssociation: anAssociation

Answer whether the receiver contains the key which is anAssociation's key and its value is anAssociation's value

includesKey: key

Answer whether the receiver contains the given key

occurrencesOf: aValue

Answer whether the number of occurrences of aValue as one of the receiver's values

Dictionary: printing

printOn: aStream

Print a representation of the receiver on aStream

Dictionary: storing

storeOn: aStream

Print Smalltalk code compiling to the receiver on aStream

Dictionary: testing

= aDictionary

Answer whether the receiver and aDictionary are equal

hash

Answer the hash value for the receiver

DirectedMessage

Category: Language-Implementation

I represent a message send: I contain the receiver, selector and arguments for a message.

• DirectedMessage class-creating instances: : creating instances (class)
• DirectedMessage-accessing: : accessing (instance)
• DirectedMessage-basic: : basic (instance)

DirectedMessage class: creating instances

selector: aSymbol arguments: anArray

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

selector: aSymbol arguments: anArray receiver: anObject

Create a new instance of the receiver

DirectedMessage: accessing

receiver

Answer the receiver

receiver: anObject

Change the receiver

DirectedMessage: basic

printOn: aStream

Print a representation of the receiver on aStream

send

Send the message

Directory

Category: Streams-Files

• Directory class-C functions: : C functions (class)
• Directory class-file operations: : file operations (class)
• Directory class-reading system defaults: : reading system defaults (class)
• Directory-accessing: : accessing (instance)
• Directory-C functions: : C functions (instance)

Directory class: C functions

primRemove: fileName

C call-out to rmdir. Do not modify!

primWorking: dirName

C call-out to chdir. Do not modify!

working

C call-out to getCurDirName. Do not modify!

Directory class: file operations

working: dirName

Change the current working directory to dirName.

Directory class: reading system defaults

home

Answer the path to the user's home directory

image

Answer the path to GNU Smalltalk's image file

kernel

Answer the path to the GNU Smalltalk kernel's Smalltalk source files

Directory: accessing

contents

Answer an Array with the names of the files in the directory represented by the receiver.

do: aBlock

Evaluate aBlock once for each file in the directory represented by the receiver, passing its name.

Directory: C functions

extractDirentName: dirent

C call-out to extractDirentName. Do not modify!

readDir: dirObject

C call-out to readdir. Do not modify!

rewindDir: dirObject

C call-out to rewinddir. Do not modify!

DLD

Category: Language-C interface

...and Gandalf said: "Many folk like to know beforehand what is to be set on the table; but those who have laboured to prepare the feast like to keep their secret; for wonder makes the words of praise louder."

I am just an ancillary class used to reference some C functions. Most of my actual functionality is used by redefinitions of methods in CFunctionDescriptor and Behavior.

• DLD class-C functions: : C functions (class)
• DLD class-Dynamic Linking: : Dynamic Linking (class)

DLD class: C functions

defineCFunc: aName as: aFuncAddr

C call-out to defineCFunc. Do not modify!

library: libHandle getFunc: aFuncString

C call-out to dldGetFunc. Do not modify!

linkFile: aFileName

C call-out to dldLink. Do not modify!

DLD class: Dynamic Linking

addLibrary: library

Add library to the search path of libraries to be used by DLD

defineExternFunc: aFuncName

This method calls #primDefineExternFunc: to try to link to a function with the given name, and answers whether the linkage was successful. You can redefine this method to restrict the ability to do dynamic linking.

defineExternFunc: aFuncName

withSelectorArgs: selector forClass: aClass returning: aReturnType args: argsArray Obsolete - Mantained for compatibility. This method does NOT look for statically linked functions.

initialize

Private - Initialize the receiver's class variables

libraryList

Answer a copy of the search path of libraries to be used by DLD

primDefineExternFunc: aFuncName

This method tries to link to a function with the given name, and answers whether the linkage was successful. It should not be overridden.

reset

Called on startup - Make DLD forget the handles of the libraries it used in the last session.

DumperProxy

Category: Streams-Files

I am an helper class for ObjectDumper. When an object cannot be saved in the standard way, you can register a subclass of me to provide special means to save that object.

• DumperProxy class-instance creation: : instance creation (class)
• DumperProxy-reconstructing: : reconstructing (instance)

DumperProxy class: instance creation

on: anObject

Answer a proxy to be used to save anObject. IMPORTANT: the newly constructed DumperProxy must NOT have anObject in one of its in- stance variable, because that would result in an infinite loop!

DumperProxy: reconstructing

object

Reconstruct the object stored in the proxy and answer it

Exception

Category: Language-Exceptions

My instances describe a single event that can be trapped using #on:do:..., contain whether such execution can be resumed after such an event, a description of what happened, and a block that is used as an handler by default. Using my methods you can raise exceptions and create new exceptions. Exceptions are organized in a kind of hierarchy (different from the class hierarchy): intercepting an exception will intercept all its children too.

• Exception class-instance creation: : instance creation (class)
• Exception-accessing: : accessing (instance)
• Exception-basic: : basic (instance)
• Exception-enumerating: : enumerating (instance)
• Exception-exception handling: : exception handling (instance)
• Exception-instance creation: : instance creation (instance)

Exception class: instance creation

new

Create a new exception whose parent is ExAll

Exception: accessing

defaultHandler

Answer the default handler for the receiver

defaultHandler: aBlock

Set the default handler of the receiver to aBlock. A Signal object will be passed to aBlock

description

Answer a description of the receiver

description: aString

Set the description of the receiver to aString

isResumable

Answer true if the receiver is resumable

isResumable: aBoolean

Set the resumable flag of the receiver to aBoolean

parent

Answer the parent of the receiver

Exception: basic

copy

Answer a copy of the receiver

Exception: enumerating

allExceptionsDo: aBlock

Private - Evaluate aBlock for every exception in the receiver. As it contains just one exception, evaluate it just once, passing the receiver

handles: exception

Answer whether the receiver handles `exception'.

Exception: exception handling

signal

Raise the exception described by the receiver, passing no parameters

signalWith: arg

Raise the exception described by the receiver, passing the parameter arg

signalWith: arg with: arg2

Raise the exception described by the receiver, passing the parameters arg and arg2

signalWithArguments: args

Raise the exception described by the receiver, passing the parameters in args

Exception: instance creation

newChild

Answer a child exception of the receiver. Its properties are set to those of the receiver

ExceptionCollection

Category: Language-Exceptions

My instances are not real exceptions: they can only be used as arguments to #on:do:... methods in BlockClosure. They act as shortcuts that allows you to use the same handler for many exceptions without having to write duplicate code

• ExceptionCollection class-instance creation: : instance creation (class)
• ExceptionCollection-enumerating: : enumerating (instance)

ExceptionCollection class: instance creation

new

Private - Answer a new, empty ExceptionCollection

ExceptionCollection: enumerating

allExceptionsDo: aBlock

Private - Evaluate aBlock for every exception in the receiver. Answer the receiver

handles: exception

Answer whether the receiver handles `exception'.

ExceptionHandler

Category: Language-Exceptions

I am used internally by the exception handling system. My instances record the handler for an exception, the receiver of the #on:do:... method that established that handler, and a block that leaves that #on:do:... method

• ExceptionHandler class-instance creation: : instance creation (class)
• ExceptionHandler-accessing: : accessing (instance)

ExceptionHandler class: instance creation

onDoBlock: wdBlock exitBlock: eBlock handlerBlock: hBlock

Answer an ExceptionHandler instance with the given values for its instance variables.

ExceptionHandler: accessing

exitBlock

Answer `exitBlock'.

handlerBlock

Answer `handlerBlock'.

isDisabled

Answer whether the receiver is disabled by a #valueWithUnwind.

onDoBlock

Answer `onDoBlock'.

onDoBlock: wdBlock exitBlock: eBlock handlerBlock: hBlock

Initialize the receiver's instance variables.

False

Category: Language-Data types

I always tell lies. I have a single instance in the system, which represents the value false.