GNU Smalltalk Library Reference

Up: (DIR)

GNU Smalltalk Library Reference

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

Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published by the Free Software Foundation; with no Invariant Sections, with no Front-Cover Texts, and with no Back-Cover Texts. A copy of the license is included in the section entitled “GNU Free Documentation License”.

Next: Class index, Previous: Top, Up: Top

1 Base classes

Alphabetic list:

Classes documented in this manual are boldfaced.

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

Next: AlternativeObjectProxy, Up: Base classes

1.1 AbstractNamespace

Defined in namespace Smalltalk
Superclass: BindingDictionary
Category: Language-Implementation: I am a special form of dictionary. Classes hold on an instance of me; it is called their `environment'.

Next: AbstractNamespace-accessing, Up: AbstractNamespace

1.1.1 AbstractNamespace class: instance creation

new: Disabled - use #new to create instances
primNew: parent name: spaceName: Private - Create a new namespace with the given name and parent, and add to the parent a key that references it.

Next: AbstractNamespace-compiling, Previous: AbstractNamespace class-instance creation, Up: AbstractNamespace

1.1.2 AbstractNamespace: accessing

allAssociations: Answer a Dictionary with all of the associations in the receiver and each of its superspaces (duplicate keys are associated to the associations that are deeper in the namespace hierarchy)
allBehaviorsDo: aBlock: Evaluate aBlock once for each class and metaclass in the namespace.
allClassObjectsDo: aBlock: Evaluate aBlock once for each class and metaclass in the namespace.
allClassesDo: aBlock: Evaluate aBlock once for each class in the namespace.
allMetaclassesDo: aBlock: Evaluate aBlock once for each metaclass in the namespace.
classAt: aKey: Answer the value corrisponding to aKey if it is a class. Fail if either aKey is not found or it is associated to something different from a class.
classAt: aKey ifAbsent: aBlock: Answer the value corrisponding to aKey if it is a class. Evaluate aBlock and answer its result if either aKey is not found or it is associated to something different from a class.

Next: AbstractNamespace-copying, Previous: AbstractNamespace-accessing, Up: AbstractNamespace

1.1.3 AbstractNamespace: compiling

addSharedPool: aDictionary: Import the given bindings for classes compiled with me as environment.
import: aDictionary: Import the given bindings for classes compiled with me as environment.
removeSharedPool: aDictionary: Remove aDictionary from my list of direct pools.
sharedPoolDictionaries: Answer the shared pools (not names) imported for my classes.

Next: AbstractNamespace-namespace hierarchy, Previous: AbstractNamespace-compiling, Up: AbstractNamespace

1.1.4 AbstractNamespace: copying

copyEmpty: newSize: Answer an empty copy of the receiver whose size is newSize
whileCurrentDo: aBlock: Evaluate aBlock with the current namespace set to the receiver. Answer the result of the evaluation.

Next: AbstractNamespace-overrides for superspaces, Previous: AbstractNamespace-copying, Up: AbstractNamespace

1.1.5 AbstractNamespace: namespace hierarchy

addSubspace: aSymbol: Create a namespace named aSymbol, add it to the receiver's subspaces, and answer it.
allSubassociationsDo: aBlock: Invokes aBlock once for every association in each of the receiver's subspaces.
allSubspaces: Answer the direct and indirect subspaces of the receiver in a Set
allSubspacesDo: aBlock: Invokes aBlock for all subspaces, both direct and indirect.
allSuperspacesDo: aBlock: Evaluate aBlock once for each of the receiver's superspaces
includesClassNamed: aString: Answer whether the receiver or any of its superspaces include the given class – note that this method (unlike #includesKey:) does not require aString to be interned and (unlike #includesGlobalNamed:) only returns true if the global is a class object.
includesGlobalNamed: aString: Answer whether the receiver or any of its superspaces include the given key – note that this method (unlike #includesKey:) does not require aString to be interned but (unlike #includesClassNamed:) returns true even if the global is not a class object.
removeSubspace: aSymbol: Remove my subspace named aSymbol from the hierarchy.
selectSubspaces: aBlock: Return a Set of subspaces of the receiver satisfying aBlock.
selectSuperspaces: aBlock: Return a Set of superspaces of the receiver satisfying aBlock.
siblings: Answer all the other children of the same namespace as the receiver.
siblingsDo: aBlock: Evaluate aBlock once for each of the other root namespaces, passing the namespace as a parameter.
subspaces: Answer the receiver's direct subspaces
subspacesDo: aBlock: Invokes aBlock for all direct subspaces.
superspace: Answer the receiver's superspace.
superspace: aNamespace: Set the superspace of the receiver to be 'aNamespace'. Also adds the receiver as a subspace of it.
withAllSubspaces: Answer a Set containing the receiver together with its direct and indirect subspaces
withAllSubspacesDo: aBlock: Invokes aBlock for the receiver and all subclasses, both direct and indirect.

Next: AbstractNamespace-printing, Previous: AbstractNamespace-namespace hierarchy, Up: AbstractNamespace

1.1.6 AbstractNamespace: overrides for superspaces

inheritedKeys: Answer a Set of all the keys in the receiver and its superspaces
set: key to: newValue: Assign newValue to the variable named as specified by `key'. This method won't define a new variable; instead if the key is not found it will search in superspaces and raising an error if the variable cannot be found in any of the superspaces. Answer newValue.
set: key to: newValue ifAbsent: aBlock: Assign newValue to the variable named as specified by `key'. This method won't define a new variable; instead if the key is not found it will search in superspaces and evaluate aBlock if it is not found. Answer newValue.
values: Answer a Bag containing the values of the receiver

Next: AbstractNamespace-testing, Previous: AbstractNamespace-overrides for superspaces, Up: AbstractNamespace

1.1.7 AbstractNamespace: printing

name: Answer the receiver's name
name: aSymbol: Change the receiver's name to aSymbol
nameIn: aNamespace: Answer Smalltalk code compiling to the receiver when the current namespace is aNamespace
printOn: aStream: Print a representation of the receiver
storeOn: aStream: Store Smalltalk code compiling to the receiver

Previous: AbstractNamespace-printing, Up: AbstractNamespace

1.1.8 AbstractNamespace: testing

isNamespace: Answer `true'.
isSmalltalk: Answer `false'.

Next: ArithmeticError, Previous: AbstractNamespace, Up: Base classes

1.2 AlternativeObjectProxy

Defined in namespace Smalltalk
Superclass: DumperProxy
Category: Streams-Files: I am a proxy that uses the same ObjectDumper to store an object which is not the object to be dumped, but from which the dumped object can be reconstructed. I am an abstract class, using me would result in infinite loops because by default I try to store the same object again and again. See the method comments for more information

Next: AlternativeObjectProxy-accessing, Up: AlternativeObjectProxy

1.2.1 AlternativeObjectProxy class: instance creation

acceptUsageForClass: aClass: The receiver was asked to be used as a proxy for the class aClass. Answer whether the registration is fine. By default, answer true except if AlternativeObjectProxy itself is being used.
on: anObject: Answer a proxy to be used to save anObject. IMPORTANT: this method MUST be overridden so that the overridden version sends #on: to super passing an object that is NOT the same as anObject (alternatively, you can override #dumpTo:, which is what NullProxy does), because that would result in an infinite loop! This also means that AlternativeObjectProxy must never be used directly – only as a superclass.

Previous: AlternativeObjectProxy class-instance creation, Up: AlternativeObjectProxy

1.2.2 AlternativeObjectProxy: accessing

object: Reconstruct the object stored in the proxy and answer it. A subclass will usually override this
object: theObject: Set the object to be dumped to theObject. This should not be overridden.
primObject: Reconstruct the object stored in the proxy and answer it. This method must not be overridden

Next: Array, Previous: AlternativeObjectProxy, Up: Base classes

1.3 ArithmeticError

Defined in namespace Smalltalk
Superclass: Error
Category: Language-Exceptions: An ArithmeticError exception is raised by numeric classes when a program tries to do something wrong, such as extracting the square root of a negative number.

Up: ArithmeticError

1.3.1 ArithmeticError: description

description: Answer a textual description of the exception.
isResumable: Answer true. Arithmetic exceptions are by default resumable.

Next: ArrayedCollection, Previous: ArithmeticError, Up: Base classes

1.4 Array

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

Next: Array-built ins, Up: Array

1.4.1 Array class: instance creation

from: anArray: Answer anArray, which is expected to be an array specified with a brace-syntax expression per my inherited protocol.

Next: Array-mutating objects, Previous: Array class-instance creation, Up: Array

1.4.2 Array: built ins

replaceFrom: start to: stop with: byteArray startingAt: replaceStart: Replace the characters from start to stop with new characters whose ASCII codes are contained in byteArray, starting at the replaceStart location of byteArray

Next: Array-printing, Previous: Array-built ins, Up: Array

1.4.3 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

Next: Array-testing, Previous: Array-mutating objects, Up: Array

1.4.4 Array: printing

isLiteralObject: Answer whether the receiver is expressible as a Smalltalk literal.
printOn: aStream: Print a representation for the receiver on aStream
storeLiteralOn: aStream: Store a Smalltalk literal compiling to the receiver on aStream
storeOn: aStream: Store Smalltalk code compiling to the receiver on aStream

Previous: Array-printing, Up: Array

1.4.5 Array: testing

isArray: Answer `true'.

Next: Association, Previous: Array, Up: Base classes

1.5 ArrayedCollection

Defined in namespace Smalltalk
Superclass: SequenceableCollection
Category: Collections-Sequenceable: My instances are objects that are generally fixed size, and are accessed by an integer index. The ordering of my instance's elements is determined externally; I will not rearrange the order of the elements.

Next: ArrayedCollection-basic, Up: ArrayedCollection

1.5.1 ArrayedCollection class: instance creation

join: aCollection: Where aCollection is a collection of SequenceableCollections, answer a new instance with all the elements therein, in order.
join: aCollection separatedBy: sepCollection: Where aCollection is a collection of SequenceableCollections, answer a new instance with all the elements therein, in order, each separated by an occurrence of sepCollection.
new: size withAll: anObject: Answer a collection with the given size, whose elements are all set to anObject
streamContents: aBlock: Create a ReadWriteStream on an empty instance of the receiver; pass the stream to aBlock, then retrieve its contents and answer them.
with: element1: Answer a collection whose only element is element1
with: element1 with: element2: Answer a collection whose only elements are the parameters in the order they were passed
with: element1 with: element2 with: element3: Answer a collection whose only elements are the parameters in the order they were passed
with: element1 with: element2 with: element3 with: element4: Answer a collection whose only elements are the parameters in the order they were passed
with: element1 with: element2 with: element3 with: element4 with: element5: Answer a collection whose only elements are the parameters in the order they were passed
withAll: aCollection: Answer a collection whose elements are the same as those in aCollection

Next: ArrayedCollection-built ins, Previous: ArrayedCollection class-instance creation, Up: ArrayedCollection

1.5.2 ArrayedCollection: basic

, aSequenceableCollection: Answer a new instance of an ArrayedCollection containing all the elements in the receiver, followed by all the elements in aSequenceableCollection
add: value: This method should not be called for instances of this class.
atAll: keyCollection: Answer a collection of the same kind returned by #collect:, that only includes the values at the given indices. Fail if any of the values in keyCollection is out of bounds for the receiver.
copyFrom: start to: stop: Answer a new collection containing all the items in the receiver from the start-th and to the stop-th
copyWith: anElement: Answer a new instance of an ArrayedCollection containing all the elements in the receiver, followed by the single item anElement
copyWithout: oldElement: Answer a copy of the receiver to which all occurrences of oldElement are removed

Next: ArrayedCollection-copying Collections, Previous: ArrayedCollection-basic, Up: ArrayedCollection

1.5.3 ArrayedCollection: built ins

size: Answer the size of the receiver

Next: ArrayedCollection-enumerating the elements of a collection, Previous: ArrayedCollection-built ins, Up: ArrayedCollection

1.5.4 ArrayedCollection: copying Collections

copyReplaceAll: oldSubCollection with: newSubCollection

Answer a new collection in which all the sequences matching oldSubCollection are replaced with newSubCollection

copyReplaceFrom: start to: stop with: replacementCollection

Answer a new collection of the same class as the receiver that contains the same elements as the receiver, in the same order, except for elements from index `start' to index `stop'.

If start < stop, these are replaced by the contents of the replacementCollection. Instead, If start = (stop + 1), like in `copyReplaceFrom: 4 to: 3 with: anArray', then every element of the receiver will be present in the answered copy; the operation will be an append if stop is equal to the size of the receiver or, if it is not, an insert before index `start'.

copyReplaceFrom: start to: stop withObject: anObject

Answer a new collection of the same class as the receiver that contains the same elements as the receiver, in the same order, except for elements from index `start' to index `stop'.

If start < stop, these are replaced by stop-start+1 copies of anObject. Instead, If start = (stop + 1), then every element of the receiver will be present in the answered copy; the operation will be an append if stop is equal to the size of the receiver or, if it is not, an insert before index `start'.

reverse

Answer the receivers' contents in reverse order

Next: ArrayedCollection-storing, Previous: ArrayedCollection-copying Collections, Up: ArrayedCollection

1.5.5 ArrayedCollection: enumerating the elements of a collection

collect: aBlock: Answer a new instance of an ArrayedCollection containing all the results of evaluating aBlock passing each of the receiver's elements
reject: aBlock: Answer a new instance of an ArrayedCollection containing all the elements in the receiver which, when passed to aBlock, answer false
select: aBlock: Answer a new instance of an ArrayedCollection containing all the elements in the receiver which, when passed to aBlock, answer true
with: aSequenceableCollection collect: aBlock: Evaluate aBlock for each pair of elements took respectively from the re- ceiver and from aSequenceableCollection; answer a collection of the same kind of the receiver, made with the block's return values. Fail if the receiver has not the same size as aSequenceableCollection.

Next: ArrayedCollection-streams, Previous: ArrayedCollection-enumerating the elements of a collection, Up: ArrayedCollection

1.5.6 ArrayedCollection: storing

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

Previous: ArrayedCollection-storing, Up: ArrayedCollection

1.5.7 ArrayedCollection: streams

writeStream: Answer a WriteStream streaming on the receiver

Next: Autoload, Previous: ArrayedCollection, Up: Base classes

1.6 Association

Defined in namespace Smalltalk
Superclass: LookupKey
Category: Language-Data types: My instances represent a mapping between two objects. Typically, my "key" object is a symbol, but I don't require this. My "value" object has no conventions associated with it; it can be any object at all.

Next: Association-accessing, Up: Association

1.6.1 Association class: basic

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

Next: Association-finalization, Previous: Association class-basic, Up: Association

1.6.2 Association: accessing

environment: Answer nil. This is present to achieve polymorphism with instances of VariableBinding.
environment: aNamespace: Do nothing. This is present to achieve polymorphism with instances of VariableBinding.
key: aKey value: aValue: Set the association's key to aKey, and its value to aValue
value: Answer the association's value
value: aValue: Set the association's value to aValue

Next: Association-printing, Previous: Association-accessing, Up: Association

1.6.3 Association: finalization

mourn: Finalize the receiver

Next: Association-storing, Previous: Association-finalization, Up: Association

1.6.4 Association: printing

printOn: aStream: Put on aStream a representation of the receiver

Next: Association-testing, Previous: Association-printing, Up: Association

1.6.5 Association: storing

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

Previous: Association-storing, Up: Association

1.6.6 Association: testing

= anAssociation: Answer whether the association's key and value are the same as anAssociation's, or false if anAssociation is not an Association. As a special case, identical values are considered equal even if #= returns false (as is the case for NaN floating-point values).
hash: Answer an hash value for the receiver

Next: Bag, Previous: Association, Up: Base classes

1.7 Autoload

Defined in namespace Smalltalk
Superclass: none
Category: Examples-Useful tools: I am not a part of the normal Smalltalk kernel class system. I provide the ability to do late ("on-demand") loading of class definitions. Through me, you can define any class to be loaded when any message is sent to the class itself (such as to create an instance) or to its metaclass (such as #methodsFor: to extend it with class-side methods).

Next: Autoload-accessing, Up: Autoload

1.7.1 Autoload class: instance creation

class: nameSymbol from: fileNameString: Make Smalltalk automatically load the class named nameSymbol from fileNameString when needed
class: nameSymbol in: aNamespace from: fileNameString: Make Smalltalk automatically load the class named nameSymbol and residing in aNamespace from fileNameString when needed

Previous: Autoload class-instance creation, Up: Autoload

1.7.2 Autoload: accessing

class: We need it to access the metaclass instance, because that's what will load the file.
doesNotUnderstand: aMessage: Load the class and resend the message to it

Next: Behavior, Previous: Autoload, Up: Base classes

1.8 Bag

Defined in namespace Smalltalk
Superclass: Collection
Category: Collections-Unordered: My instances are unordered collections of objects. You can think of me as a set with a memory; that is, if the same object is added to me twice, then I will report that that element has been stored twice.

Next: Bag-adding, Up: Bag

1.8.1 Bag class: basic

new: Answer a new instance of the receiver
new: size: Answer a new instance of the receiver, with space for size distinct objects

Next: Bag-enumerating the elements of a collection, Previous: Bag class-basic, Up: Bag

1.8.2 Bag: adding

add: newObject: Add an occurrence of newObject to the receiver. Answer newObject. Fail if newObject is nil.
add: newObject withOccurrences: anInteger: If anInteger > 0, add anInteger occurrences of newObject to the receiver. If anInteger < 0, remove them. Answer newObject. Fail if newObject is nil.

Next: Bag-extracting items, Previous: Bag-adding, Up: Bag

1.8.3 Bag: enumerating the elements of a collection

asSet: Answer a set with the elements of the receiver
do: aBlock: Evaluate the block for all members in the collection.

Next: Bag-printing, Previous: Bag-enumerating the elements of a collection, Up: Bag

1.8.4 Bag: extracting items

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

Next: Bag-removing, Previous: Bag-extracting items, Up: Bag

1.8.5 Bag: printing

printOn: aStream: Put on aStream a representation of the receiver

Next: Bag-storing, Previous: Bag-printing, Up: Bag

1.8.6 Bag: removing

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

Next: Bag-testing collections, Previous: Bag-removing, Up: Bag

1.8.7 Bag: storing

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

Previous: Bag-storing, Up: Bag

1.8.8 Bag: testing collections

= aBag: Answer whether the receiver and aBag contain the same objects
hash: Answer an hash value for the receiver
includes: anObject: Answer whether we include anObject
occurrencesOf: anObject: Answer the number of occurrences of anObject found in the receiver
size: Answer the total number of objects found in the receiver

Next: BindingDictionary, Previous: Bag, Up: Base classes

1.9 Behavior

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

Next: Behavior-accessing instances and variables, Up: Behavior

1.9.1 Behavior: accessing class hierarchy

allSubclasses: Answer the direct and indirect subclasses of the receiver in a Set
allSuperclasses: Answer all the receiver's superclasses in a collection
subclasses: Answer the direct subclasses of the receiver in a Set
superclass: Answer the receiver's superclass (if any, otherwise answer nil)
withAllSubclasses: Answer a Set containing the receiver together with its direct and indirect subclasses
withAllSuperclasses: Answer the receiver and all of its superclasses in a collection

Next: Behavior-accessing the methodDictionary, Previous: Behavior-accessing class hierarchy, Up: Behavior

1.9.2 Behavior: accessing instances and variables

allClassVarNames: Return all the class variables understood by the receiver
allInstVarNames: Answer the names of every instance variables the receiver contained in the receiver's instances
allInstances: Returns a set of all instances of the receiver
allSharedPoolDictionaries: Return the shared pools defined by the class and any of its superclasses, in the correct search order.
allSharedPools: Return the names of the shared pools defined by the class and any of its superclasses, in the correct search order.
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
indexOfInstVar: aString: Answer the index of aString in the fixed instance variables of the instances of the receiver, or 0 if the variable is missing.
indexOfInstVar: aString ifAbsent: aBlock: Answer the index of aString in the fixed instance variables of the instances of the receiver, or 0 if the variable is missing.
instVarNames: Answer an Array containing the instance variables defined by the receiver
instanceCount: Return a count of all the instances of the receiver
sharedPools: Return the names of the shared pools defined by the class
subclassInstVarNames: Answer the names of the instance variables the receiver inherited from its superclass

Next: Behavior-built ins, Previous: Behavior-accessing instances and variables, Up: Behavior

1.9.3 Behavior: accessing the methodDictionary

>> selector: Return the compiled method associated with selector, from the local method dictionary. Error if not found.
allSelectors: Answer a Set of all the selectors understood by the receiver
compiledMethodAt: selector: Return the compiled method associated with selector, from the local method dictionary. Error if not found.
compiledMethodAt: selector ifAbsent: aBlock: Return the compiled method associated with selector, from the local method dictionary. Evaluate aBlock if not found.
lookupSelector: aSelector: Return the compiled method associated with selector, from the local method dictionary or one of a superclass; return nil if not found.
parseTreeFor: selector: Answer the parse tree for the given selector, or nil if there was an error. Requires the Parser package to be loaded.
selectorAt: method: Return selector for the given CompiledMethod
selectors: Answer a Set of the receiver's selectors
sourceCodeAt: selector: Answer source code (if available) for the given selector.
sourceCodeAt: selector ifAbsent: aBlock: Answer source code (if available) for the given selector.
sourceMethodAt: selector: This is too dependent on the original implementation

Next: Behavior-builtin, Previous: Behavior-accessing the methodDictionary, Up: Behavior

1.9.4 Behavior: built ins

basicNewInFixedSpace

Create a new instance of a class with no indexed instance variables. The instance is guaranteed not to move across garbage collections. Like #basicNew, this method should not be overridden.

basicNewInFixedSpace: numInstanceVariables

Create a new instance of a class with indexed instance variables. The instance has numInstanceVariables indexed instance variables. The instance is guaranteed not to move across garbage collections. Like #basicNew:, this method should not be overridden.

flushCache

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

methodsFor: category ifTrue: condition

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

primCompile: code

Compile the code, a string or readable stream, with no category. Fail if the code does not obey Smalltalk syntax. Answer the generated CompiledMethod if it does.

Do not send this in user code; use #compile: or related methods instead.

primCompile: code ifError: aBlock

As with #primCompile:, but evaluate aBlock (passing the file name, line number and description of the error) if the code does not obey Smalltalk syntax.

Do not send this in user code; use #compile:ifError: or related methods instead.

someInstance

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

Next: Behavior-compilation (alternative), Previous: Behavior-built ins, Up: Behavior

1.9.5 Behavior: builtin

basicNew: Create a new instance of a class with no indexed instance variables; this method must not be overridden.
basicNew: numInstanceVariables: Create a new instance of a class with indexed instance variables. The instance has numInstanceVariables indexed instance variables; this method must not be overridden.
new: Create a new instance of a class with no indexed instance variables
new: numInstanceVariables: Create a new instance of a class with indexed instance variables. The instance has numInstanceVariables indexed instance variables.

Next: Behavior-compiling methods, Previous: Behavior-builtin, Up: Behavior

1.9.6 Behavior: compilation (alternative)

methods: Don't use this, it's only present to file in from Smalltalk/V
methodsFor: Don't use this, it's only present to file in from Dolphin Smalltalk
methodsFor: category ifFeatures: features: Start compiling methods in the receiver if this implementation of Smalltalk has the given features, else skip the section
methodsFor: category stamp: notUsed: Don't use this, it's only present to file in from Squeak
privateMethods: Don't use this, it's only present to file in from IBM Smalltalk
publicMethods: Don't use this, it's only present to file in from IBM Smalltalk

Next: Behavior-creating a class hierarchy, Previous: Behavior-compilation (alternative), Up: Behavior

1.9.7 Behavior: compiling methods

methodsFor: aCategoryString: Calling this method prepares the parser to receive methods to be compiled and installed in the receiver's method dictionary. The methods are put in the category identified by the parameter.
poolResolution: Answer a PoolResolution class to be used for resolving pool variables while compiling methods on this class.

Next: Behavior-enumerating, Previous: Behavior-compiling methods, Up: Behavior

1.9.8 Behavior: creating a class hierarchy

addSubclass: aClass: Add aClass asone of the receiver's subclasses.
removeSubclass: aClass: Remove aClass from the list of the receiver's subclasses
superclass: aClass: Set the receiver's superclass.

Next: Behavior-evaluating, Previous: Behavior-creating a class hierarchy, Up: Behavior

1.9.9 Behavior: enumerating

allInstancesDo: aBlock: Invokes aBlock for all instances of the receiver
allSubclassesDo: aBlock: Invokes aBlock for all subclasses, both direct and indirect.
allSubinstancesDo: aBlock: Invokes aBlock for all instances of each of the receiver's subclasses.
allSuperclassesDo: aBlock: Invokes aBlock for all superclasses, both direct and indirect.
selectSubclasses: aBlock: Return a Set of subclasses of the receiver satisfying aBlock.
selectSuperclasses: aBlock: Return a Set of superclasses of the receiver satisfying aBlock.
subclassesDo: aBlock: Invokes aBlock for all direct subclasses.
withAllSubclassesDo: aBlock: Invokes aBlock for the receiver and all subclasses, both direct and indirect.
withAllSuperclassesDo: aBlock: Invokes aBlock for the receiver and all superclasses, both direct and indirect.

Next: Behavior-instance creation, Previous: Behavior-enumerating, Up: Behavior

1.9.10 Behavior: evaluating

evalString: aString to: anObject: Answer the stack top at the end of the evaluation of the code in aString. The code is executed as part of anObject
evalString: aString to: anObject ifError: aBlock: Answer the stack top at the end of the evaluation of the code in aString. If aString cannot be parsed, evaluate aBlock (see compile:ifError:). The code is executed as part of anObject
evaluate: code: Evaluate Smalltalk expression in 'code' and return result.
evaluate: code ifError: block: Evaluate 'code'. If a parsing error is detected, invoke 'block'
evaluate: code notifying: requestor: Evaluate Smalltalk expression in 'code'. If a parsing error is encountered, send #error: to requestor
evaluate: code to: anObject: Evaluate Smalltalk expression as part of anObject's method definition
evaluate: code to: anObject ifError: block: Evaluate Smalltalk expression as part of anObject's method definition. This method is used to support Inspector expression evaluation. If a parsing error is encountered, invoke error block, 'block'

Next: Behavior-instance variables, Previous: Behavior-evaluating, Up: Behavior

1.9.11 Behavior: instance creation

newInFixedSpace: Create a new instance of a class without indexed instance variables. The instance is guaranteed not to move across garbage collections. If a subclass overrides #new, the changes will apply to this method too.
newInFixedSpace: numInstanceVariables: Create a new instance of a class with indexed instance variables. The instance has numInstanceVariables indexed instance variables. The instance is guaranteed not to move across garbage collections. If a subclass overrides #new:, the changes will apply to this method too.

Next: Behavior-method dictionary, Previous: Behavior-instance creation, Up: Behavior

1.9.12 Behavior: instance variables

addInstVarName: aString: Add the given instance variable to instance of the receiver
instanceVariableNames: instVarNames: Set the instance variables for the receiver to be those in instVarNames
removeInstVarName: aString: Remove the given instance variable from the receiver and recompile all of the receiver's subclasses

Next: Behavior-parsing class declarations, Previous: Behavior-instance variables, Up: Behavior

1.9.13 Behavior: method dictionary

addSelector: selector withMethod: compiledMethod: Add the given compiledMethod to the method dictionary, giving it the passed selector. Answer compiledMethod
compile: code: Compile method source. If there are parsing errors, answer nil. Else, return a CompiledMethod result of compilation
compile: code ifError: block: Compile method source. If there are parsing errors, invoke exception block, 'block' passing file name, line number and error. Return a CompiledMethod result of compilation
to
compile: code notifying: requestor: Compile method source. If there are parsing errors, send #error: to the requestor object, else return a CompiledMethod result of compilation
compileAll: Recompile all selectors in the receiver. Ignore errors.
compileAll: aNotifier: Recompile all selectors in the receiver. Notify aNotifier by sen- ding #error: messages if something goes wrong.
compileAllSubclasses: Recompile all selector of all subclasses. Notify aNotifier by sen- ding #error: messages if something goes wrong.
compileAllSubclasses: aNotifier: Recompile all selector of all subclasses. Notify aNotifier by sen- ding #error: messages if something goes wrong.
createGetMethod: what: Create a method accessing the variable `what'.
createGetMethod: what default: value: Create a method accessing the variable `what', with a default value of `value', using lazy initialization
createSetMethod: what: Create a method which sets the variable `what'.
decompile: selector: Decompile the bytecodes for the given selector.
defineAsyncCFunc: cFuncNameString withSelectorArgs: selectorAndArgs args: argsArray: Please lookup the part on the C interface in the manual. This method is deprecated, you should use the asyncCCall:args: attribute.
defineCFunc: cFuncNameString withSelectorArgs: selectorAndArgs returning: returnTypeSymbol args: argsArray: Please lookup the part on the C interface in the manual. This method is deprecated, you should use the cCall:returning:args: attribute.
edit: selector: Open Emacs to edit the method with the passed selector, then compile it
methodDictionary: Answer the receiver's method dictionary. Don't modify the method dictionary unless you exactly know what you're doing
methodDictionary: aDictionary: Set the receiver's method dictionary to aDictionary
recompile: selector: Recompile the given selector, answer nil if something goes wrong or the new CompiledMethod if everything's ok.
to
recompile: selector notifying: aNotifier: Recompile the given selector. If there are parsing errors, send #error: to the aNotifier object, else return a CompiledMethod result of compilation
removeSelector: selector: Remove the given selector from the method dictionary, answer the CompiledMethod attached to that selector
removeSelector: selector ifAbsent: aBlock: Remove the given selector from the method dictionary, answer the CompiledMethod attached to that selector. If the selector cannot be found, answer the result of evaluating aBlock.
selectorsAndMethodsDo: aBlock: Evaluate aBlock, passing for each evaluation a selector that's defined in the receiver and the corresponding method.

Next: Behavior-pluggable behavior (not yet implemented), Previous: Behavior-method dictionary, Up: Behavior

1.9.14 Behavior: parsing class declarations

parseInstanceVariableString: variableString: As with #parseVariableString:, but answer symbols that name the variables instead of strings.
parseVariableString: aString: Answer an array of instance variable names. aString should specify these in traditional file-in `instanceVariableNames' format. Signal an error if aString contains something other than valid Smalltalk variables.

Next: Behavior-printing hierarchy, Previous: Behavior-parsing class declarations, Up: Behavior

1.9.15 Behavior: pluggable behavior (not yet implemented)

compilerClass: Answer the class that can be used to compile parse trees, or nil if there is none (as is the case now). Not used for methods if parserClass answers nil, and for doits if evaluatorClass answers nil.
debuggerClass: Answer which class is to be used to debug a chain of contexts which includes the receiver. nil means 'do not debug'; other classes are sent #debuggingPriority and the one with the highest priority is picked.
decompilerClass: Answer the class that can be used to decompile methods, or nil if there is none (as is the case now).
evaluatorClass: Answer the class that can be used to evaluate doits, or nil if there is none (as is the case now).
parserClass: Answer the class that can be used to parse methods, or nil if there is none (as is the case now).

Next: Behavior-still unclassified, Previous: Behavior-pluggable behavior (not yet implemented), Up: Behavior

1.9.16 Behavior: printing hierarchy

hierarchyIndent: Answer the indent to be used by #printHierarchy - 4 by default
printHierarchy: Print my entire subclass hierarchy on the terminal.
printSubclasses: level using: aBlock: I print my name, and then all my subclasses, each indented according to its position in the hierarchy. I pass aBlock a class name and a level

Next: Behavior-support for lightweight classes, Previous: Behavior-printing hierarchy, Up: Behavior

1.9.17 Behavior: still unclassified

allSharedPoolDictionariesDo: aBlock: Answer the shared pools visible from methods in the metaclass, in the correct search order.
parseNodeAt: selector: Available only when the Parser package is loaded–Answer an RBMethodNode that compiles to my method named by selector.
updateInstanceVars: variableArray shape: shape: Update instance variables and instance spec of the class and all its subclasses. variableArray lists the new variables, including inherited ones.

Next: Behavior-testing functionality, Previous: Behavior-still unclassified, Up: Behavior

1.9.18 Behavior: support for lightweight classes

article: Answer an article (`a' or `an') which is ok for the receiver's name
asClass: Answer the first superclass that is a full-fledged Class object
environment: Answer the namespace that this class belongs to - the same as the superclass, since Behavior does not support namespaces yet.
name: Answer the class name; this prints to the name of the superclass enclosed in braces. This class name is used, for example, to print the receiver.
nameIn: aNamespace: Answer the class name when the class is referenced from aNamespace - a dummy one, since Behavior does not support names.
printOn: aStream in: aNamespace: Answer the class name when the class is referenced from aNamespace - a dummy one, since Behavior does not support names.
securityPolicy: Not commented.
securityPolicy: aSecurityPolicy: This method should not be called for instances of this class.

Next: Behavior-testing the class hierarchy, Previous: Behavior-support for lightweight classes, Up: Behavior

1.9.19 Behavior: testing functionality

isBehavior: Answer `true'.

Next: Behavior-testing the form of the instances, Previous: Behavior-testing functionality, Up: Behavior

1.9.20 Behavior: testing the class hierarchy

includesBehavior: aClass: Returns true if aClass is the receiver or a superclass of the receiver.
inheritsFrom: aClass: Returns true if aClass is a superclass of the receiver
kindOfSubclass: Return a string indicating the type of class the receiver is
shape: Answer the symbolic shape of my instances.
#ushort
shape: shape: Give the provided shape to the receiver's instances. The shape can be nil, or one of #byte #int8 #character #short #word #ushort #int #uint #int64 #uint64 #utf32 #float #double or #pointer. In addition, the special value #inherit means to use the shape of the superclass; note however that this is a static setting, and subclasses that used #inherit are not mutated when the superclass adopts a different shape.

Next: Behavior-testing the method dictionary, Previous: Behavior-testing the class hierarchy, Up: Behavior

1.9.21 Behavior: testing the form of the instances

instSize: Answer how many fixed instance variables are reserved to each of the receiver's instances
isBits: Answer whether my instances' variables are immediate, non-OOP values.
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

Previous: Behavior-testing the form of the instances, Up: Behavior

1.9.22 Behavior: testing the method dictionary

canUnderstand: selector: Returns true if the instances of the receiver understand the given selector
hasMethods: Return whether the receiver has any methods defined
includesSelector: selector: Returns true if the local method dictionary contains the given selector
scopeHas: name ifTrue: aBlock: If methods understood by the receiver's instances have access to a symbol named 'name', evaluate aBlock
whichClassIncludesSelector: selector: Answer which class in the receiver's hierarchy contains the implementation of selector used by instances of the class (nil if none does)
whichSelectorsAccess: instVarName: Answer a Set of selectors which access the given instance variable
whichSelectorsAssign: instVarName: Answer a Set of selectors which read the given instance variable
whichSelectorsRead: instVarName: Answer a Set of selectors which read the given instance variable
whichSelectorsReferTo: anObject: Returns a Set of selectors that refer to anObject
whichSelectorsReferToByteCode: aByteCode: Return the collection of selectors in the class which reference the byte code, aByteCode

Next: BlockClosure, Previous: Behavior, Up: Base classes

1.10 BindingDictionary

Defined in namespace Smalltalk
Superclass: Dictionary
Category: Language-Implementation: I am a special form of dictionary that provides special ways to access my keys, which typically begin with an uppercase letter; also, my associations are actually VariableBinding instances.
My keys are (expected to be) symbols, so I use == to match searched keys to those in the dictionary – this is done expecting that it brings a bit more speed.

Next: BindingDictionary-basic & copying, Up: BindingDictionary

1.10.1 BindingDictionary: accessing

define: aSymbol: Define aSymbol as equal to nil inside the receiver. Fail if such a variable already exists (use #at:put: if you don't want to fail)
doesNotUnderstand: aMessage: Try to map unary selectors to read accesses to the Namespace, and one-argument keyword selectors to write accesses. Note that: a) this works only if the selector has an uppercase first letter; and b) `aNamespace Variable: value' is the same as `aNamespace set: #Variable to: value', not the same as `aNamespace at: #Variable put: value' — the latter always refers to the current namespace, while the former won't define a new variable, instead searching in superspaces (and raising an error if the variable cannot be found).
environment: Answer the environment to which the receiver is connected. This can be the class for a dictionary that holds class variables, or the super-namespace. In general it is used to compute the receiver's name.
environment: anObject: Set the environment to which the receiver is connected. This can be the class for a dictionary that holds class variables, or the super-namespace. In general it is used to compute the receiver's name.
import: aSymbol from: aNamespace: Add to the receiver the symbol aSymbol, associated to the same value as in aNamespace. Fail if aNamespace does not contain the given key.
name: Answer the receiver's name, which by default is the same as the name of the receiver's environment.
nameIn: aNamespace: Answer the receiver's name when referred to from aNamespace; by default the computation is deferred to the receiver's environment.

Next: BindingDictionary-copying, Previous: BindingDictionary-accessing, Up: BindingDictionary

1.10.2 BindingDictionary: basic & copying

= arg: Answer whether the receiver is equal to arg. The equality test is by default the same as that for equal objects. = must not fail; answer false if the receiver cannot be compared to arg
hash: Answer an hash value for the receiver. This is the same as the object's #identityHash.

Next: BindingDictionary-forward declarations, Previous: BindingDictionary-basic & copying, Up: BindingDictionary

1.10.3 BindingDictionary: copying

copy: Answer the receiver.
copyEmpty: newSize: Answer an empty copy of the receiver whose size is newSize
copyEmptyForCollect: Answer an empty copy of the receiver which is filled in to compute the result of #collect:
copyEmptyForCollect: size: Answer an empty copy of the receiver which is filled in to compute the result of #collect:
deepCopy: Answer the receiver.
shallowCopy: Answer the receiver.

Next: BindingDictionary-printing, Previous: BindingDictionary-copying, Up: BindingDictionary

1.10.4 BindingDictionary: forward declarations

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

Next: BindingDictionary-testing, Previous: BindingDictionary-forward declarations, Up: BindingDictionary

1.10.5 BindingDictionary: printing

printOn: aStream in: aNamespace: Print the receiver's name when referred to from aNamespace; by default the computation is deferred to the receiver's environment.

Previous: BindingDictionary-printing, Up: BindingDictionary

1.10.6 BindingDictionary: testing

species: Answer `IdentityDictionary'.

Next: BlockContext, Previous: BindingDictionary, Up: Base classes

1.11 BlockClosure

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

Next: BlockClosure class-testing, Up: BlockClosure

1.11.1 BlockClosure class: instance creation

block: aCompiledBlock: Answer a BlockClosure that activates the passed CompiledBlock.
block: aCompiledBlock receiver: anObject: Answer a BlockClosure that activates the passed CompiledBlock with the given receiver.
block: aCompiledBlock receiver: anObject outerContext: aContext: Answer a BlockClosure that activates the passed CompiledBlock with the given receiver.
numArgs: args numTemps: temps bytecodes: bytecodes depth: depth literals: literalArray: Answer a BlockClosure for a new CompiledBlock that is created using the passed parameters. To make it work, you must put the BlockClosure into a CompiledMethod's literals.

Next: BlockClosure-accessing, Previous: BlockClosure class-instance creation, Up: BlockClosure

1.11.2 BlockClosure class: testing

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

Next: BlockClosure-built ins, Previous: BlockClosure class-testing, Up: BlockClosure

1.11.3 BlockClosure: accessing

argumentCount: Answer the number of arguments passed to the receiver
block: Answer the CompiledBlock which contains the receiver's bytecodes
block: aCompiledBlock: Set the CompiledBlock which contains the receiver's bytecodes
finalIP: Answer the last instruction that can be executed by the receiver
fixTemps: This should fix the values of the temporary variables used in the block that are ordinarily shared with the method in which the block is defined. Not defined yet, but it is not harmful that it isn't. Answer the receiver.
initialIP: Answer the initial instruction pointer into the receiver.
method: Answer the CompiledMethod in which the receiver lies
numArgs: Answer the number of arguments passed to the receiver
numTemps: Answer the number of temporary variables used by the receiver
outerContext: Answer the method/block context which is the immediate outer of the receiver
outerContext: containingContext: Set the method/block context which is the immediate outer of the receiver
receiver: Answer the object that is used as `self' when executing the receiver (if nil, it might mean that the receiver is not valid though...)
receiver: anObject: Set the object that is used as `self' when executing the receiver
stackDepth: Answer the number of stack slots needed for the receiver

Next: BlockClosure-control structures, Previous: BlockClosure-accessing, Up: BlockClosure

1.11.4 BlockClosure: built ins

cull: arg1: Evaluate the receiver, passing arg1 as the only parameter if the receiver has parameters.
cull: arg1 cull: arg2: Evaluate the receiver, passing arg1 and arg2 as parameters if the receiver accepts them.
cull: arg1 cull: arg2 cull: arg3: Evaluate the receiver, passing arg1, arg2 and arg3 as parameters if the receiver accepts them.
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

Next: BlockClosure-exception handling, Previous: BlockClosure-built ins, Up: BlockClosure

1.11.5 BlockClosure: control structures

repeat: Evaluate the receiver 'forever' (actually until a return is executed or the process is terminated).
whileFalse: Evaluate the receiver until it returns true
whileFalse: aBlock: Evaluate the receiver. If it returns false, evaluate aBlock and re- start
whileTrue: Evaluate the receiver until it returns false
whileTrue: aBlock: Evaluate the receiver. If it returns true, evaluate aBlock and re- start

Next: BlockClosure-multiple process, Previous: BlockClosure-control structures, Up: BlockClosure

1.11.6 BlockClosure: exception handling

ifError: aBlock: Evaluate the receiver; when #error: is called, pass to aBlock the receiver and the parameter, and answer the result of evaluating aBlock. If another exception is raised, it is passed to an outer handler; if no exception is raised, the result of evaluating the receiver is returned.
on: anException do: aBlock: Evaluate the receiver; when anException is signaled, evaluate aBlock passing a Signal describing the exception. Answer either the result of evaluating the receiver or the parameter of a Signal>>#return:
on: e1 do: b1 on: e2 do: b2: Evaluate the receiver; when e1 or e2 are signaled, evaluate respectively b1 or b2, passing a Signal describing the exception. Answer either the result of evaluating the receiver or the argument of a Signal>>#return:
on: e1 do: b1 on: e2 do: b2 on: e3 do: b3: Evaluate the receiver; when e1, e2 or e3 are signaled, evaluate respectively b1, b2 or b3, passing a Signal describing the exception. Answer either the result of evaluating the receiver or the parameter of a Signal>>#return:
on: e1 do: b1 on: e2 do: b2 on: e3 do: b3 on: e4 do: b4: Evaluate the receiver; when e1, e2, e3 or e4 are signaled, evaluate respectively b1, b2, b3 or b4, passing a Signal describing the exception. Answer either the result of evaluating the receiver or the parameter of a Signal>>#return:
on: e1 do: b1 on: e2 do: b2 on: e3 do: b3 on: e4 do: b4 on: e5 do: b5: Evaluate the receiver; when e1, e2, e3, e4 or e5 are signaled, evaluate respectively b1, b2, b3, b4 or b5, passing a Signal describing the exception. Answer either the result of evaluating the receiver or the parameter of a Signal>>#return:

Next: BlockClosure-overriding, Previous: BlockClosure-exception handling, Up: BlockClosure

1.11.7 BlockClosure: multiple process

fork: Create a new process executing the receiver and start it
forkAt: priority: Create a new process executing the receiver with given priority and start it
forkWithoutPreemption: Evaluate the receiver in a process that cannot be preempted. If the receiver expect a parameter, pass the current process.
newProcess: Create a new process executing the receiver in suspended state. The priority is the same as for the calling process. The receiver must not contain returns
newProcessWith: anArray: Create a new process executing the receiver with the passed arguments, and leave it in suspended state. The priority is the same as for the calling process. The receiver must not contain returns
valueWithoutInterrupts: Evaluate aBlock and delay all interrupts that are requested to the active process during its execution to after aBlock returns.
valueWithoutPreemption: Evaluate the receiver with external interrupts disabled. This effectively disables preemption as long as the block does not explicitly yield control, wait on semaphores, and the like.

Next: BlockClosure-testing, Previous: BlockClosure-multiple process, Up: BlockClosure

1.11.8 BlockClosure: overriding

copy: Answer the receiver.
deepCopy: Answer a shallow copy.

Next: BlockClosure-unwind protection, Previous: BlockClosure-overriding, Up: BlockClosure

1.11.9 BlockClosure: testing

hasMethodReturn: Answer whether the block contains a method return

Previous: BlockClosure-testing, Up: BlockClosure

1.11.10 BlockClosure: unwind protection

ensure: aBlock: Evaluate the receiver; when any exception is signaled exit returning the result of evaluating aBlock; if no exception is raised, return the result of evaluating aBlock when the receiver has ended
ifCurtailed: aBlock: Evaluate the receiver; if its execution triggers an unwind which truncates the execution of the block (`curtails' the block), evaluate aBlock. The three cases which can curtail the execution of the receiver are: a non-local return in the receiver, a non-local return in a block evaluated by the receiver which returns past the receiver itself, and an exception raised and not resumed during the execution of the receiver.
valueWithUnwind: Evaluate the receiver. Any errors caused by the block will cause a backtrace, but execution will continue in the method that sent #valueWithUnwind, after that call. Example: [ 1 / 0 ] valueWithUnwind. 'unwind works!' printNl.
Important: this method is public, but it is intended to be used in very special cases (as a rule of thumb, use it only when the corresponding C code uses the _gst_prepare_execution_environment and _gst_finish_execution_environment functions). You should usually rely on #ensure: and #on:do:.

Next: Boolean, Previous: BlockClosure, Up: Base classes

1.12 BlockContext

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

Next: BlockContext-debugging, Up: BlockContext

1.12.1 BlockContext: accessing

caller: Answer the context that called the receiver
home: Answer the MethodContext to which the receiver refers, or nil if it has been optimized away
isBlock: Answer whether the receiver is a block context
block
isDisabled: Answers false, because contexts that are skipped when doing a return are always MethodContexts. BlockContexts are removed from the chain whenever a non-local return is done, while MethodContexts need to stay there in case there is a non-local return from the #ensure: block.
isEnvironment: To create a valid execution environment for the interpreter even before it starts, GST creates a fake context whose selector is nil and which can be used as a marker for the current execution environment. Answer whether the receiver is that kind of context (always false, since those contexts are always MethodContexts).
isUnwind: Answers whether the context must continue execution even after a non-local return (a return from the enclosing method of a block, or a call to the #continue: method of ContextPart). Such contexts are created only by #ensure: and are always MethodContexts.
nthOuterContext: n: Answer the n-th outer block/method context for the receiver
outerContext: Answer the outer block/method context for the receiver

Next: BlockContext-printing, Previous: BlockContext-accessing, Up: BlockContext

1.12.2 BlockContext: debugging

isInternalExceptionHandlingContext: Answer whether the receiver is a context that should be hidden to the user when presenting a backtrace. Such contexts are never blocks, but check the rest of the chain.

Previous: BlockContext-debugging, Up: BlockContext

1.12.3 BlockContext: printing

printOn: aStream: Print a representation for the receiver on aStream

Next: ByteArray, Previous: BlockContext, Up: Base classes

1.13 Boolean

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

Next: Boolean-basic, Up: Boolean

1.13.1 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

Next: Boolean-C hacks, Previous: Boolean class-testing, Up: Boolean

1.13.2 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

Next: Boolean-overriding, Previous: Boolean-basic, Up: Boolean

1.13.3 Boolean: C hacks

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

Next: Boolean-storing, Previous: Boolean-C hacks, Up: Boolean

1.13.4 Boolean: overriding

deepCopy: Answer the receiver.
shallowCopy: Answer the receiver.

Previous: Boolean-overriding, Up: Boolean

1.13.5 Boolean: storing

isLiteralObject: Answer whether the receiver is expressible as a Smalltalk literal.
storeLiteralOn: aStream: Store on aStream some Smalltalk code which compiles to the receiver
storeOn: aStream: Store on aStream some Smalltalk code which compiles to the receiver

Next: CAggregate, Previous: Boolean, Up: Base classes

1.14 ByteArray

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

Next: ByteArray-basic, Up: ByteArray

1.14.1 ByteArray class: instance creation

fromCData: aCObject size: anInteger: Answer a ByteArray containing anInteger bytes starting at the location pointed to by aCObject

Next: ByteArray-built ins, Previous: ByteArray class-instance creation, Up: ByteArray

1.14.2 ByteArray: basic

= aCollection: Answer whether the receiver's items match those in aCollection

Next: ByteArray-converting, Previous: ByteArray-basic, Up: ByteArray

1.14.3 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
replaceFrom: start to: stop with: aByteArray startingAt: replaceStart: Replace the characters from start to stop with the bytes contained in aByteArray (which, actually, can be any variable byte class), starting at the replaceStart location of aByteArray
replaceFrom: start to: stop withString: aString startingAt: replaceStart: Replace the characters from start to stop with the ASCII codes contained in aString (which, actually, can be any variable byte class), starting at the replaceStart location of aString

Next: ByteArray-more advanced accessing, Previous: ByteArray-built ins, Up: ByteArray

1.14.4 ByteArray: converting

asString: Answer a String whose character's ASCII codes are the receiver's contents
asUnicodeString: Answer a UnicodeString whose character's codes are the receiver's contents. This is not implemented unless you load the I18N package.

Next: ByteArray-storing, Previous: ByteArray-converting, Up: ByteArray

1.14.5 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.
longDoubleAt: index: Access the C long double at the given index in the receiver. Indices are 1-based just like for other Smalltalk access.
longDoubleAt: 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.
objectAt: index: Access the Smalltalk object (OOP) at the given index in the receiver. Indices are 1-based just like for other Smalltalk access.
objectAt: index put: value: Store a pointer (OOP) to the Smalltalk object identified by `value', at the given index in the receiver. Indices are 1-based just like for other Smalltalk access.
shortAt: index: Access the C short int at the given index in the receiver. Indices are 1-based just like for other Smalltalk access.
shortAt: index put: value: Store the Smalltalk Integer object identified by `value', at the given index in the receiver, using sizeof(short) bytes. Indices are 1-based just like for other Smalltalk access.
stringAt: index: Access the string pointed by the C `char *' at the given index in the receiver. Indices are 1-based just like for other Smalltalk access.
stringAt: index put: value: Store the Smalltalk String object identified by `value', at the given index in the receiver, writing it like a *FRESHLY ALLOCATED* C string. It is the caller's responsibility to free it if necessary. Indices are 1-based just like for other Smalltalk access.
ucharAt: index: Access the C unsigned char at the given index in the receiver. The value is returned as a Smalltalk Character. Indices are 1-based just like for other Smalltalk access.
ucharAt: index put: value: Store as a C char the Smalltalk Character or Integer object identified by `value', at the given index in the receiver, using sizeof(char) bytes - i.e. 1 byte. Indices are 1-based just like for other Smalltalk access.
uintAt: index: Access the C unsigned int at the given index in the receiver. Indices are 1-based just like for other Smalltalk access.
uintAt: index put: value: Store the Smalltalk Integer object identified by `value', at the given index in the receiver, using sizeof(int) bytes. Indices are 1-based just like for other Smalltalk access.
ulongAt: index: Access the C unsigned long int at the given index in the receiver. Indices are 1-based just like for other Smalltalk access.
ulongAt: index put: value: Store the Smalltalk Integer object identified by `value', at the given index in the receiver, using sizeof(long) bytes. Indices are 1-based just like for other Smalltalk access.
unsignedCharAt: index: Access the C unsigned char at the given index in the receiver. The value is returned as a Smalltalk Character. Indices are 1-based just like for other Smalltalk access.
unsignedCharAt: index put: value: Store as a C char the Smalltalk Character or Integer object identified by `value', at the given index in the receiver, using sizeof(char) bytes - i.e. 1 byte. Indices are 1-based just like for other Smalltalk access.
unsignedIntAt: index: Access the C unsigned int at the given index in the receiver. Indices are 1-based just like for other Smalltalk access.
unsignedIntAt: index put: value: Store the Smalltalk Integer object identified by `value', at the given index in the receiver, using sizeof(int) bytes. Indices are 1-based just like for other Smalltalk access.
unsignedLongAt: index: Access the C unsigned long int at the given index in the receiver. Indices are 1-based just like for other Smalltalk access.
unsignedLongAt: index put: value: Store the Smalltalk Integer object identified by `value', at the given index in the receiver, using sizeof(long) bytes. Indices are 1-based just like for other Smalltalk access.
unsignedShortAt: index: Access the C unsigned short int at the given index in the receiver. Indices are 1-based just like for other Smalltalk access.
unsignedShortAt: index put: value: Store the Smalltalk Integer object identified by `value', at the given index in the receiver, using sizeof(short) bytes. Indices are 1-based just like for other Smalltalk access.
ushortAt: index: Access the C unsigned short int at the given index in the receiver. Indices are 1-based just like for other Smalltalk access.
ushortAt: index put: value: Store the Smalltalk Integer object identified by `value', at the given index in the receiver, using sizeof(short) bytes. Indices are 1-based just like for other Smalltalk access.

Previous: ByteArray-more advanced accessing, Up: ByteArray

1.14.6 ByteArray: storing

isLiteralObject: Answer whether the receiver is expressible as a Smalltalk literal.
storeLiteralOn: aStream: Put a Smalltalk literal evaluating to the receiver on aStream.
storeOn: aStream: Put Smalltalk code evaluating to the receiver on aStream.

Next: CallinProcess, Previous: ByteArray, Up: Base classes

1.15 CAggregate

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

Next: CAggregate-accessing, Up: CAggregate

1.15.1 CAggregate class: accessing

alignof: Answer the receiver's instances required aligment
sizeof: Answer the receiver's instances size

Previous: CAggregate class-accessing, Up: CAggregate

1.15.2 CAggregate: accessing

elementType: Answer the type over which the receiver is constructed.

Next: CArray, Previous: CAggregate, Up: Base classes

1.16 CallinProcess

Defined in namespace Smalltalk
Superclass: Process
Category: Language-Processes: I represent a unit of computation for which external C code requested execution, so I must store the returned value once my computation terminates and I must not survive across image saves (since those who invoked me no longer exist). I am otherwise equivalent to a Process.

Next: CArrayCType, Previous: CallinProcess, Up: Base classes

1.17 CArray

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

Up: CArray

1.17.1 CArray: accessing

alignof: Answer the receiver's required aligment
sizeof: Answer the receiver's size

Next: CBoolean, Previous: CArray, Up: Base classes

1.18 CArrayCType

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

Next: CArrayCType-accessing, Up: CArrayCType

1.18.1 CArrayCType class: instance creation

elementType: aCType: This method should not be called for instances of this class.
elementType: aCType numberOfElements: anInteger: Answer a new instance of CPtrCType that maps an array whose elements are of the given CType, and whose size is exactly anInteger elements (of course, anInteger only matters for allocation, not for access, since no out-of-bounds protection is provided for C objects).
from: type: Private - Called by CType>>from: for arrays

Next: CArrayCType-storing, Previous: CArrayCType class-instance creation, Up: CArrayCType

1.18.2 CArrayCType: accessing

alignof: Answer the alignment of the receiver's instances
numberOfElements: Answer the number of elements in the receiver's instances
sizeof: Answer the size of the receiver's instances

Previous: CArrayCType-accessing, Up: CArrayCType

1.18.3 CArrayCType: storing

storeOn: aStream: As with super.

Next: CByte, Previous: CArrayCType, Up: Base classes

1.19 CBoolean

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

Up: CBoolean

1.19.1 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

Next: CCallable, Previous: CBoolean, Up: Base classes

1.20 CByte

Defined in namespace Smalltalk
Superclass: CUChar
Category: Language-C interface: You know what a byte is, don't you?!?

Next: CByte-accessing, Up: CByte

1.20.1 CByte class: conversion

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

Previous: CByte class-conversion, Up: CByte

1.20.2 CByte: accessing

cObjStoredType: Nothing special in the default case - answer the receiver's CType
value: Answer the value the receiver is pointing to. The returned value is a SmallInteger
value: aValue: Set the receiver to point to the value, aValue (a SmallInteger).

Next: CCallbackDescriptor, Previous: CByte, Up: Base classes

1.21 CCallable

Defined in namespace Smalltalk
Superclass: CObject
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.

Next: CCallable-accessing, Up: CCallable

1.21.1 CCallable class: instance creation

for: aCObject returning: returnTypeSymbol withArgs: argsArray: Answer a CFunctionDescriptor with the given address, return type and arguments. The address will be reset to NULL upon image save (and it's the user's task to figure out a way to reinitialize it!)

Next: CCallable-calling, Previous: CCallable class-instance creation, Up: CCallable

1.21.2 CCallable: accessing

isValid: Answer whether the object represents a valid function.
returnType: Not commented.

Next: CCallable-restoring, Previous: CCallable-accessing, Up: CCallable

1.21.3 CCallable: calling

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

Previous: CCallable-calling, Up: CCallable

1.21.4 CCallable: restoring

link: Rebuild the object after the image is restarted.

Next: CChar, Previous: CCallable, Up: Base classes

1.22 CCallbackDescriptor

Defined in namespace Smalltalk
Superclass: CCallable
Category: Language-C interface: I am not part of the Smalltalk definition. My instances are able to convert blocks into C functions that can be passed to C.

Next: CCallbackDescriptor-accessing, Up: CCallbackDescriptor

1.22.1 CCallbackDescriptor class: instance creation

for: aBlock returning: returnTypeSymbol withArgs: argsArray: Answer a CFunctionDescriptor with the given function name, return type and arguments. funcName must be a String.

Next: CCallbackDescriptor-restoring, Previous: CCallbackDescriptor class-instance creation, Up: CCallbackDescriptor

1.22.2 CCallbackDescriptor: accessing

block: Answer the name of the function (on the C side) represented by the receiver
block: aBlock: Set the name of the function (on the C side) represented by the receiver

Previous: CCallbackDescriptor-accessing, Up: CCallbackDescriptor

1.22.3 CCallbackDescriptor: restoring

link: Make the address of the function point to the registered address.

Next: CCompound, Previous: CCallbackDescriptor, Up: Base classes

1.23 CChar

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

Next: CChar-accessing, Up: CChar

1.23.1 CChar class: accessing

alignof: Answer the receiver's instances required aligment
cObjStoredType: Private - Answer an index referring to the receiver's instances scalar type
sizeof: Answer the receiver's instances size

Next: CChar-conversion, Previous: CChar class-accessing, Up: CChar

1.23.2 CChar: accessing

alignof: Answer the receiver's required aligment
cObjStoredType: Private - Answer an index referring to the receiver's scalar type
sizeof: Answer the receiver's size

Previous: CChar-accessing, Up: CChar

1.23.3 CChar: conversion

asByteArray: size: Convert size bytes pointed to by the receiver to a String
asString: Convert the data pointed to by the receiver, up to the first NULL byte, to a String
asString: size: Convert size bytes pointed to by the receiver to a String

Next: CDouble, Previous: CChar, Up: Base classes

1.24 CCompound

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

Next: CCompound class-subclass creation, Up: CCompound

1.24.1 CCompound class: instance creation

gcNew: Allocate a new instance of the receiver, backed by garbage-collected storage.
new: Allocate a new instance of the receiver. To free the memory after GC, remember to call #addToBeFinalized.

Next: CCompound-instance creation, Previous: CCompound class-instance creation, Up: CCompound

1.24.2 CCompound class: subclass creation

alignof: Answer 1, the alignment of an empty struct
classPragmas: Return the pragmas that are written in the file-out of this class.
compileSize: size align: alignment: Private - Compile sizeof and alignof methods
declaration: Return the description of the fields in the receiver class.
declaration: array: This method's functionality should be implemented by subclasses of CCompound
declaration: array inject: startOffset into: aBlock: Compile methods that implement the declaration in array. To compute the offset after each field, the value of the old offset plus the new field's size is passed to aBlock, together with the new field's alignment requirements.
emitInspectTo: str for: name: Private - Emit onto the given stream the code for adding the given selector to the CCompound's inspector.
newStruct: structName declaration: array: The old way to create a CStruct. Superseded by #subclass:declaration:...
sizeof: Answer 0, the size of an empty struct
subclass: structName declaration: array classVariableNames: cvn poolDictionaries: pd category: category: Create a new class with the given name that contains code to implement the given C struct. All the parameters except `array' are the same as for a standard class creation message; see documentation for more information

Previous: CCompound class-subclass creation, Up: CCompound

1.24.3 CCompound: instance creation

inspect: Inspect the contents of the receiver
inspectSelectorList: Answer a list of selectors whose return values should be inspected by #inspect.

Next: CFloat, Previous: CCompound, Up: Base classes

1.25 CDouble

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

Next: CDouble-accessing, Up: CDouble

1.25.1 CDouble class: accessing

alignof: Answer the receiver's instances required aligment
cObjStoredType: Private - Answer an index referring to the receiver's instances scalar type
sizeof: Answer the receiver's instances size

Previous: CDouble class-accessing, Up: CDouble

1.25.2 CDouble: accessing

alignof: Answer the receiver's required aligment
cObjStoredType: Private - Answer an index referring to the receiver's scalar type
sizeof: Answer the receiver's size

Next: CFunctionDescriptor, Previous: CDouble, Up: Base classes

1.26 CFloat

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

Next: CFloat-accessing, Up: CFloat

1.26.1 CFloat class: accessing

alignof: Answer the receiver's instances required aligment
cObjStoredType: Private - Answer an index referring to the receiver's instances scalar type
sizeof: Answer the receiver's instances size

Previous: CFloat class-accessing, Up: CFloat

1.26.2 CFloat: accessing

alignof: Answer the receiver's required aligment
cObjStoredType: Private - Answer an index referring to the receiver's scalar type
sizeof: Answer the receiver's size

Next: Character, Previous: CFloat, Up: Base classes

1.27 CFunctionDescriptor

Defined in namespace Smalltalk
Superclass: CCallable
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.

Next: CFunctionDescriptor class-testing, Up: CFunctionDescriptor

1.27.1 CFunctionDescriptor class: instance creation

for: funcName returning: returnTypeSymbol withArgs: argsArray: Answer a CFunctionDescriptor with the given function name, return type and arguments. funcName must be a String.

Next: CFunctionDescriptor-accessing, Previous: CFunctionDescriptor class-instance creation, Up: CFunctionDescriptor

1.27.2 CFunctionDescriptor class: testing

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

Next: CFunctionDescriptor-printing, Previous: CFunctionDescriptor class-testing, Up: CFunctionDescriptor

1.27.3 CFunctionDescriptor: accessing

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

Next: CFunctionDescriptor-restoring, Previous: CFunctionDescriptor-accessing, Up: CFunctionDescriptor

1.27.4 CFunctionDescriptor: printing

printOn: aStream: Print a representation of the receiver onto aStream

Previous: CFunctionDescriptor-printing, Up: CFunctionDescriptor

1.27.5 CFunctionDescriptor: restoring

link: Make the address of the function point to the registered address.

Next: CharacterArray, Previous: CFunctionDescriptor, Up: Base classes

1.28 Character

Defined in namespace Smalltalk
Superclass: Magnitude
Category: Language-Data types: My instances represent the 256 characters of the character set. I provide messages to translate between integers and character objects, and provide names for some of the common unprintable characters.
Character is always used (mostly for performance reasons) when referring to characters whose code point is between 0 and 127. Above 127, instead, more care is needed: Character refers to bytes that are used as part of encoding of a character, while UnicodeCharacter refers to the character itself.

Next: Character class-constants, Up: Character

1.28.1 Character class: built ins

asciiValue: anInteger: Returns the character object corresponding to anInteger. Error if anInteger is not an integer, or not in 0..127.
codePoint: anInteger: Returns the character object, possibly an UnicodeCharacter, corresponding to anInteger. Error if anInteger is not an integer, or not in 0..16r10FFFF.
value: anInteger: Returns the character object corresponding to anInteger. Error if anInteger is not an integer, or not in 0..255.

Next: Character class-initializing lookup tables, Previous: Character class-built ins, Up: Character

1.28.2 Character class: constants

backspace: Returns the character 'backspace'
bell: Returns the character 'bel'
cr: Returns the character 'cr'
eof: Returns the character 'eof', also known as 'sub'
eot: Returns the character 'eot', also known as 'Ctrl-D'
esc: Returns the character 'esc'
ff: Returns the character 'ff', also known as 'newPage'
lf: Returns the character 'lf', also known as 'nl'
newPage: Returns the character 'newPage', also known as 'ff'
nl: Returns the character 'nl', also known as 'lf'
nul: Returns the character 'nul'
space: Returns the character 'space'
tab: Returns the character 'tab'

Next: Character class-instance creation, Previous: Character class-constants, Up: Character

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

Next: Character class-testing, Previous: Character class-initializing lookup tables, Up: Character

1.28.4 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

Next: Character-built ins, Previous: Character class-instance creation, Up: Character

1.28.5 Character class: testing

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

Next: Character-coercion methods, Previous: Character class-testing, Up: Character

1.28.6 Character: built ins

= char: Boolean return value; true if the characters are equal
asInteger: Returns the integer value corresponding to self. #codePoint, #asciiValue, #value, and #asInteger are synonyms.
asciiValue: Returns the integer value corresponding to self. #codePoint, #asciiValue, #value, and #asInteger are synonyms.
codePoint: Returns the integer value corresponding to self. #codePoint, #asciiValue, #value, and #asInteger are synonyms.
value: Returns the integer value corresponding to self. #codePoint, #asciiValue, #value, and #asInteger are synonyms.

Next: Character-comparing, Previous: Character-built ins, Up: Character

1.28.7 Character: coercion methods

* aNumber: Returns a String with aNumber occurrences of the receiver.
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. Only valid if the character is between 0 and 255.
asSymbol: Returns the character self as a symbol.
asUnicodeString: Returns the character self as a Unicode string.
asUppercase: Returns self as a uppercase character if it's an lowercase letter, otherwise returns the character unchanged.

Next: Character-converting, Previous: Character-coercion methods, Up: Character

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

Next: Character-printing, Previous: Character-comparing, Up: Character

1.28.9 Character: converting

asCharacter: Return the receiver, since it is already a character.
digitValue: Returns the value of self interpreted as a digit. Here, 'digit' means either 0-9, or A-Z, which maps to 10-35.

Next: Character-storing, Previous: Character-converting, Up: Character

1.28.10 Character: printing

displayOn: aStream: Print a representation of the receiver on aStream. Unlike #printOn:, this method strips the leading dollar.
printOn: aStream: Print a representation of the receiver on aStream
storeLiteralOn: aStream: Store on aStream some Smalltalk code which compiles to the receiver

Next: Character-testing, Previous: Character-printing, Up: Character

1.28.11 Character: storing

isLiteralObject: Answer whether the receiver is expressible as a Smalltalk literal.
storeOn: aStream: Store Smalltalk code compiling to the receiver on aStream

Next: Character-testing functionality, Previous: Character-storing, Up: Character

1.28.12 Character: testing

isAlphaNumeric: True if self is a letter or a digit
isDigit: True if self is a 0-9 digit
isDigit: radix: Answer whether the receiver is a valid character in the given radix.
isLetter: True if self is an upper- or lowercase letter
isLowercase: True if self is a lowercase letter
isPathSeparator: Returns true if self is a path separator ($/ or $\ under Windows, $/ only under Unix systems including Mac OS X).
isPunctuation: Returns true if self is one of '.,:;!?'
isSeparator: Returns true if self is a space, cr, tab, nl, or newPage
isUppercase: True if self is uppercase
isVowel: Returns true if self is a, e, i, o, or u; case insensitive

Previous: Character-testing, Up: Character

1.28.13 Character: testing functionality

isCharacter: Answer True. We're definitely characters

Next: CInt, Previous: Character, Up: Base classes

1.29 CharacterArray

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

Next: CharacterArray class-multibyte encodings, Up: CharacterArray

1.29.1 CharacterArray class: basic

fromString: aCharacterArray: Make up an instance of the receiver containing the same characters as aCharacterArray, and answer it.
lineDelimiter: Answer a CharacterArray which one can use as a line delimiter. This is meant to be used on subclasses of CharacterArray.

Next: CharacterArray-built ins, Previous: CharacterArray class-basic, Up: CharacterArray

1.29.2 CharacterArray class: multibyte encodings

isUnicode: Answer whether the receiver stores bytes (i.e. an encoded form) or characters (if true is returned).

Next: CharacterArray-comparing, Previous: CharacterArray class-multibyte encodings, Up: CharacterArray

1.29.3 CharacterArray: built ins

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

Next: CharacterArray-converting, Previous: CharacterArray-built ins, Up: CharacterArray

1.29.4 CharacterArray: comparing

< aCharacterArray: Return true if the receiver is less than aCharacterArray, ignoring case differences.
<= aCharacterArray: Returns true if the receiver is less than or equal to aCharacterArray, ignoring case differences. If is receiver is an initial substring of aCharacterArray, it is considered to be less than aCharacterArray.
= aString: Answer whether the receiver's items match those in aCollection
> aCharacterArray: Return true if the receiver is greater than aCharacterArray, ignoring case differences.
>= aCharacterArray: Returns true if the receiver is greater than or equal to aCharacterArray, ignoring case differences. If is aCharacterArray is an initial substring of the receiver, it is considered to be less than the receiver.
indexOf: aCharacterArray matchCase: aBoolean startingAt: anIndex: Answer an Interval of indices in the receiver which match the aCharacterArray pattern. # in aCharacterArray means 'match any character', * in aCharacterArray means 'match any sequence of characters'. The first item of the returned in- terval is >= anIndex. If aBoolean is false, the search is case-insen- sitive, else it is case-sensitive. If no Interval matches the pattern, answer nil.
match: aCharacterArray: Answer whether aCharacterArray matches the pattern contained in the receiver. # in the receiver means 'match any character', * in receiver means 'match any sequence of characters'.
match: aCharacterArray ignoreCase: aBoolean: Answer whether aCharacterArray matches the pattern contained in the receiver. # in the receiver means 'match any character', * in receiver means 'match any sequence of characters'. The case of alphabetic characters is ignored if aBoolean is true.
sameAs: aCharacterArray: Returns true if the receiver is the same CharacterArray as aCharacterArray, ignoring case differences.

Next: CharacterArray-multibyte encodings, Previous: CharacterArray-comparing, Up: CharacterArray

1.29.5 CharacterArray: converting

asByteArray: Return the receiver, converted to a ByteArray of ASCII values
asClassPoolKey: Return the receiver, ready to be put in a class pool dictionary
asGlobalKey: Return the receiver, ready to be put in the Smalltalk dictionary
asInteger: Parse an Integer number from the receiver until the input character is invalid and answer the result at this point
asLowercase: Returns a copy of self as a lowercase CharacterArray
asNumber: Parse a Number from the receiver until the input character is invalid and answer the result at this point
asPoolKey: Return the receiver, ready to be put in a pool dictionary
asString: But I already am a String! Really!
asSymbol: Returns the symbol corresponding to the CharacterArray
asUnicodeString: Answer a UnicodeString whose character's codes are the receiver's contents This is not implemented unless you load the I18N package.
asUppercase: Returns a copy of self as an uppercase CharacterArray
fileName: But I don't HAVE a file name!
filePos: But I don't HAVE a file position!
isNumeric: Answer whether the receiver denotes a number
trimSeparators: Return a copy of the reciever without any spaces on front or back. The implementation is protected against the `all blanks' case.

Next: CharacterArray-string processing, Previous: CharacterArray-converting, Up: CharacterArray

1.29.6 CharacterArray: multibyte encodings

encoding: Answer the encoding used by the receiver.
isUnicode: Answer whether the receiver stores bytes (i.e. an encoded form) or characters (if true is returned).
numberOfCharacters: Answer the number of Unicode characters in the receiver. This is not implemented unless you load the I18N package.

Next: CharacterArray-testing functionality, Previous: CharacterArray-multibyte encodings, Up: CharacterArray

1.29.7 CharacterArray: string processing

% anArray: Answer the receiver with every %n (1<=n<=9) replaced by the n-th element of anArray. The replaced elements are `displayed' (i.e. their displayString is used). In addition, the special pattern %<trueString|falseString>n is replaced with one of the two strings depending on the n-th element of anArray being true or false.
bindWith: s1: Answer the receiver with every %1 replaced by the displayString of s1
bindWith: s1 with: s2: Answer the receiver with every %1 or %2 replaced by s1 or s2, respectively. s1 and s2 are `displayed' (i.e. their displayString is used) upon replacement.
bindWith: s1 with: s2 with: s3: Answer the receiver with every %1, %2 or %3 replaced by s1, s2 or s3, respectively. s1, s2 and s3 are `displayed' (i.e. their displayString is used) upon replacement.
bindWith: s1 with: s2 with: s3 with: s4: Answer the receiver with every %1, %2, %3 or %4 replaced by s1, s2, s3 or s4, respectively. s1, s2, s3 and s4 are `displayed' (i.e. their displayString is used) upon replacement.
bindWithArguments: anArray: Answer the receiver with every %n (1<=n<=9) replaced by the n-th element of anArray. The replaced elements are `displayed' (i.e. their displayString is used). In addition, the special pattern %<trueString|falseString>n is replaced with one of the two strings depending on the n-th element of anArray being true or false.
contractTo: smallSize: Either return myself, or a copy shortened to smallSize characters by inserting an ellipsis (three dots: ...)
lines: Answer an Array of Strings each representing one line in the receiver.
linesDo: aBlock: Evaluate aBlock once for every newline delimited line in the receiver, passing the line to the block.
subStrings: Answer an OrderedCollection of substrings of the receiver. A new substring start at the start of the receiver, or after every sequence of white space characters
subStrings: aCharacter: Answer an OrderedCollection of substrings of the receiver. A new substring start at the start of the receiver, or after every sequence of characters matching aCharacter
substrings: Answer an OrderedCollection of substrings of the receiver. A new substring start at the start of the receiver, or after every sequence of white space characters. This message is preserved for backwards compatibility; the ANSI standard mandates `subStrings', with an uppercase s.
substrings: aCharacter: Answer an OrderedCollection of substrings of the receiver. A new substring start at the start of the receiver, or after every sequence of characters matching aCharacter. This message is preserved for backwards compatibility; the ANSI standard mandates `subStrings:', with an uppercase s.

Previous: CharacterArray-string processing, Up: CharacterArray

1.29.8 CharacterArray: testing functionality

isCharacterArray: Answer `true'.

Next: Class, Previous: CharacterArray, Up: Base classes

1.30 CInt

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

Next: CInt-accessing, Up: CInt

1.30.1 CInt class: accessing

alignof: Answer the receiver's required aligment
cObjStoredType: Private - Answer an index referring to the receiver's instances scalar type
sizeof: Answer the receiver's size

Previous: CInt class-accessing, Up: CInt

1.30.2 CInt: accessing

alignof: Answer the receiver's instances required aligment
cObjStoredType: Private - Answer an index referring to the receiver's scalar type
sizeof: Answer the receiver's instances size

Next: ClassDescription, Previous: CInt, Up: Base classes

1.31 Class

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

Next: Class-accessing instances and variables, Up: Class

1.31.1 Class class: initialize

initialize: Perform the special initialization of root classes.

Next: Class-filing, Previous: Class class-initialize, Up: Class

1.31.2 Class: accessing instances and variables

addClassVarName: aString: Add a class variable with the given name to the class pool dictionary.
addClassVarName: aString value: valueBlock: Add a class variable with the given name to the class pool dictionary, and evaluate valueBlock as its initializer.
addSharedPool: aDictionary: Add the given shared pool to the list of the class' pool dictionaries
allClassVarNames: Answer the names of the variables in the receiver's class pool dictionary and in each of the superclasses' class pool dictionaries
bindingFor: aString: Answer the variable binding for the class variable with the given name
category: Answer the class category
category: aString: Change the class category to aString
classPool: Answer the class pool dictionary
classPragmas: Return the pragmas that are written in the file-out of this class.
classVarNames: Answer the names of the variables in the class pool dictionary
comment: Answer the class comment
comment: aString: Change the class name
environment: Answer `environment'.
environment: aNamespace: Set the receiver's environment to aNamespace and recompile everything
initialize: redefined in children (?)
initializeAsRootClass: Perform special initialization reserved to root classes.
name: Answer the class name
removeClassVarName: aString: Removes the class variable from the class, error if not present, or still in use.
removeSharedPool: aDictionary: Remove the given dictionary to the list of the class' pool dictionaries
sharedPools: Return the names of the shared pools defined by the class
superclass: aClass: Set the receiver's superclass.

Next: Class-instance creation, Previous: Class-accessing instances and variables, Up: Class

1.31.3 Class: filing

fileOutDeclarationOn: aFileStream: File out class definition to aFileStream. Requires package Parser.
fileOutOn: aFileStream: File out complete class description: class definition, class and instance methods. Requires package Parser.

Next: Class-instance creation - alternative, Previous: Class-filing, Up: Class

1.31.4 Class: instance creation

extend: Redefine a version of the receiver in the current namespace. Note: this method can bite you in various ways when sent to system classes; read the section on namespaces in the manual for some examples of the problems you can encounter.
subclass: classNameString: Define a subclass of the receiver with the given name. If the class is already defined, don't modify its instance or class variables but still, if necessary, recompile everything needed.
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.
#short
variable: shape subclass: classNameString instanceVariableNames: stringInstVarNames classVariableNames: stringOfClassVarNames poolDictionaries: stringOfPoolNames category: categoryNameString: Define a variable subclass of the receiver with the given name, shape, instance variables, class variables, pool dictionaries and category. If the class is already defined, if necessary, recompile everything needed. The shape can be one of #byte #int8 #character #short #ushort #int #uint #int64 #uint64 #utf32 #float #double or #pointer.
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.

Next: Class-pragmas, Previous: Class-instance creation, Up: Class

1.31.5 Class: instance creation - alternative

categoriesFor: method are: categories: Don't use this, it is only present to file in from IBM Smalltalk
subclass: classNameString classInstanceVariableNames: stringClassInstVarNames instanceVariableNames: stringInstVarNames classVariableNames: stringOfClassVarNames poolDictionaries: stringOfPoolNames: Don't use this, it is only present to file in from IBM Smalltalk
subclass: classNameString instanceVariableNames: stringInstVarNames classVariableNames: stringOfClassVarNames poolDictionaries: stringOfPoolNames: Don't use this, it is only present to file in from IBM Smalltalk
variableByteSubclass: classNameString classInstanceVariableNames: stringClassInstVarNames classVariableNames: stringOfClassVarNames poolDictionaries: stringOfPoolNames: Don't use this, it is only present to file in from IBM Smalltalk
variableByteSubclass: classNameString classVariableNames: stringOfClassVarNames poolDictionaries: stringOfPoolNames: Don't use this, it is only present to file in from IBM Smalltalk
variableLongSubclass: classNameString classInstanceVariableNames: stringClassInstVarNames classVariableNames: stringOfClassVarNames poolDictionaries: stringOfPoolNames: Don't use this, it is only present to file in from IBM Smalltalk
variableLongSubclass: classNameString classVariableNames: stringOfClassVarNames poolDictionaries: stringOfPoolNames: Don't use this, it is only present to file in from IBM Smalltalk
variableSubclass: classNameString classInstanceVariableNames: stringClassInstVarNames instanceVariableNames: stringInstVarNames classVariableNames: stringOfClassVarNames poolDictionaries: stringOfPoolNames: Don't use this, it is only present to file in from IBM Smalltalk
variableSubclass: classNameString instanceVariableNames: stringInstVarNames classVariableNames: stringOfClassVarNames poolDictionaries: stringOfPoolNames: Don't use this, it is only present to file in from IBM Smalltalk

Next: Class-printing, Previous: Class-instance creation - alternative, Up: Class

1.31.6 Class: pragmas

pragmaHandlerFor: aSymbol: Answer the (possibly inherited) registered handler for pragma aSymbol, or nil if not found.
registerHandler: aBlock forPragma: pragma: While compiling methods, on every encounter of the pragma with the given name, call aBlock with the CompiledMethod and an array of pragma argument values.

Next: Class-saving and loading, Previous: Class-pragmas, Up: Class

1.31.7 Class: printing

article: Answer an article (`a' or `an') which is ok for the receiver's name
printOn: aStream: Print a representation of the receiver on aStream
storeOn: aStream: Store Smalltalk code compiling to the receiver on aStream

Next: Class-security, Previous: Class-printing, Up: Class

1.31.8 Class: saving and loading

binaryRepresentationVersion: Answer a number >= 0 which represents the current version of the object's representation. The default implementation answers zero.
convertFromVersion: version withFixedVariables: fixed indexedVariables: indexed for: anObjectDumper: This method is called if a VersionableObjectProxy is attached to a class. It receives the version number that was stored for the object (or nil if the object did not use a VersionableObjectProxy), the fixed instance variables, the indexed instance variables, and the ObjectDumper that has read the object. The default implementation ignores the version and simply fills in an instance of the receiver with the given fixed and indexed instance variables (nil if the class instances are of fixed size). If instance variables were removed from the class, extras are ignored; if the class is now fixed and used to be indexed, indexed is not used.
nonVersionedInstSize: Answer the number of instance variables that the class used to have when objects were stored without using a VersionableObjectProxy. The default implementation answers the current instSize.

Next: Class-still unclassified, Previous: Class-saving and loading, Up: Class

1.31.9 Class: security

check: aPermission: Not commented.
securityPolicy: Answer `securityPolicy'.
securityPolicy: aSecurityPolicy: Not commented.

Next: Class-testing, Previous: Class-security, Up: Class

1.31.10 Class: still unclassified

allSharedPoolDictionariesDo: aBlock: Answer the shared pools visible from methods in the metaclass, in the correct search order.

Next: Class-testing functionality, Previous: Class-still unclassified, Up: Class

1.31.11 Class: testing

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

Previous: Class-testing, Up: Class

1.31.12 Class: testing functionality

asClass: Answer the receiver.
isClass: Answer `true'.

Next: CLong, Previous: Class, Up: Base classes

1.32 ClassDescription

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

Next: ClassDescription-conversion, Up: ClassDescription

1.32.1 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

Next: ClassDescription-copying, Previous: ClassDescription-compiling, Up: ClassDescription

1.32.2 ClassDescription: conversion

asClass: This method's functionality should be implemented by subclasses of ClassDescription
asMetaclass: Answer the metaclass associated to the receiver
binding: Answer a VariableBinding object whose value is the receiver

Next: ClassDescription-filing, Previous: ClassDescription-conversion, Up: ClassDescription

1.32.3 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

Next: ClassDescription-organization of messages and classes, Previous: ClassDescription-copying, Up: ClassDescription

1.32.4 ClassDescription: filing

fileOut: fileName: Open the given file and to file out a complete class description to it. Requires package Parser.
fileOutCategory: categoryName to: fileName: File out all the methods belonging to the method category, categoryName, to the fileName file. Requires package Parser.
fileOutOn: aFileStream: File out complete class description: class definition, class and instance methods. Requires package Parser.
fileOutSelector: selector to: fileName: File out the given selector to fileName. Requires package Parser.

Next: ClassDescription-parsing class declarations, Previous: ClassDescription-filing, Up: ClassDescription

1.32.5 ClassDescription: organization of messages and classes

classify: aSelector under: aString: Put the method identified by the selector aSelector under the category given by aString.
createGetMethod: what: Create a method accessing the variable `what'.
createGetMethod: what default: value: Create a method accessing the variable `what', with a default value of `value', using lazy initialization
createSetMethod: what: Create a method which sets the variable `what'.
defineAsyncCFunc: cFuncNameString withSelectorArgs: selectorAndArgs args: argsArray: See documentation. This function is deprecated, you should use the <asyncCCall: ... > special syntax instead.
defineCFunc: cFuncNameString withSelectorArgs: selectorAndArgs returning: returnTypeSymbol args: argsArray: See documentation. This function is deprecated, you should use the <asyncCCall: ... > special syntax instead.
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

Next: ClassDescription-printing, Previous: ClassDescription-organization of messages and classes, Up: ClassDescription

1.32.6 ClassDescription: parsing class declarations

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

Next: ClassDescription-still unclassified, Previous: ClassDescription-parsing class declarations, Up: ClassDescription

1.32.7 ClassDescription: printing

classVariableString: This method's functionality should be implemented by subclasses of ClassDescription
instanceVariableString: Answer a string containing the name of the receiver's instance variables.
nameIn: aNamespace: Answer the class name when the class is referenced from aNamespace
printOn: aStream in: aNamespace: Print on aStream the class name when the class is referenced from aNamespace
sharedVariableString: This method's functionality should be implemented by subclasses of ClassDescription

Previous: ClassDescription-printing, Up: ClassDescription

1.32.8 ClassDescription: still unclassified

fileOutCategory: category toStream: aFileStream: File out all the methods belonging to the method category, category, to aFileStream. Requires package Parser.
fileOutSelector: aSymbol toStream: aFileStream: File out all the methods belonging to the method category, category, to aFileStream. Requires package Parser.

Next: CLongDouble, Previous: ClassDescription, Up: Base classes

1.33 CLong

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

Next: CLong-accessing, Up: CLong

1.33.1 CLong class: accessing

alignof: Answer the receiver's instances required aligment
cObjStoredType: Private - Answer an index referring to the receiver's instances scalar type
sizeof: Answer the receiver's instances size

Previous: CLong class-accessing, Up: CLong

1.33.2 CLong: accessing

alignof: Answer the receiver's required aligment
cObjStoredType: Private - Answer an index referring to the receiver's scalar type
sizeof: Answer the receiver's size

Next: CObject, Previous: CLong, Up: Base classes

1.34 CLongDouble

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

Next: CLongDouble-accessing, Up: CLongDouble

1.34.1 CLongDouble class: accessing

alignof: Answer the receiver's instances required aligment
cObjStoredType: Private - Answer an index referring to the receiver's instances scalar type
sizeof: Answer the receiver's instances size

Previous: CLongDouble class-accessing, Up: CLongDouble

1.34.2 CLongDouble: accessing

alignof: Answer the receiver's required aligment
cObjStoredType: Private - Answer an index referring to the receiver's scalar type
sizeof: Answer the receiver's size

Next: Collection, Previous: CLongDouble, Up: Base classes

1.35 CObject

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

Next: CObject class-instance creation, Up: CObject

1.35.1 CObject class: conversion

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

Next: CObject class-primitive allocation, Previous: CObject class-conversion, Up: CObject

1.35.2 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
gcAlloc: nBytes: Allocate nBytes bytes and return an instance of the receiver
gcNew: nBytes: Allocate nBytes bytes and return an instance of the receiver
new: Answer a new object pointing to NULL.
new: nBytes: Allocate nBytes bytes and return an instance of the receiver

Next: CObject class-subclassing, Previous: CObject class-instance creation, Up: CObject

1.35.3 CObject class: primitive allocation

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

Next: CObject-accessing, Previous: CObject class-primitive allocation, Up: CObject

1.35.4 CObject class: subclassing

subclass: aSymbol: Create a subclass with the given name.

Next: CObject-basic, Previous: CObject class-subclassing, Up: CObject

1.35.5 CObject: accessing

address: Answer the address the receiver is pointing to. The address can be absolute if the storage is nil, or relative to the Smalltalk object in #storage. In this case, an address of 0 corresponds to the first instance variable.
address: anInteger: Set the receiver to point to the passed address, anInteger
isAbsolute: Answer whether the object points into a garbage-collected Smalltalk storage, or it is an absolute address.
printOn: aStream: Print a representation of the receiver
storage: Answer the storage that the receiver is pointing into, or nil if the address is absolute.
storage: anObject: Change the receiver to point to the storage of anObject.
type: aCType: Set the receiver's type to aCType.

Next: CObject-C data access, Previous: CObject-accessing, Up: CObject

1.35.6 CObject: basic

= anObject: Return true if the receiver and aCObject are equal.
hash: Return a hash value for anObject.

Next: CObject-conversion, Previous: CObject-basic, Up: CObject

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

Next: CObject-finalization, Previous: CObject-C data access, Up: CObject

1.35.8 CObject: conversion

castTo: aType: Answer another CObject, pointing to the same address as the receiver, but belonging to the aType CType.
narrow: This method is called on CObjects returned by a C call-out whose return type is specified as a CType; it mostly allows one to change the class of the returned CObject. By default it does nothing, and that's why it is not called when #cObject is used to specify the return type.
type: Answer a CType for the receiver

Next: CObject-pointer-like behavior, Previous: CObject-conversion, Up: CObject

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

Next: CObject-testing, Previous: CObject-finalization, Up: CObject

1.35.10 CObject: pointer-like behavior

+ anInteger

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

- intOrPtr

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

addressAt: anIndex

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

at: anIndex

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

at: anIndex put: aValue

Store anIndex places past the receiver the passed Smalltalk object or CObject `aValue'; if it is a CObject is dereferenced: that is, this method is equivalent either to cobj[anIndex]=aValue or cobj[anIndex]=*aValue. anIndex is zero-based, just like with all other C-style accessing.

In both cases, aValue should be of the element type or of the corresponding Smalltalk type (that is, a String is ok for an array of CStrings) to avoid typing problems which however will not be signaled because C is untyped.

decr

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

decrBy: anInteger

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

incr

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

incrBy: anInteger

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

Next: CObject-testing functionality, Previous: CObject-pointer-like behavior, Up: CObject

1.35.11 CObject: testing

isNull: Return true if the receiver points to NULL.

Previous: CObject-testing, Up: CObject

1.35.12 CObject: testing functionality

isCObject: Answer `true'.

Next: CompiledBlock, Previous: CObject, Up: Base classes

1.36 Collection

Defined in namespace Smalltalk
Superclass: Iterable
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.

Next: Collection class-multibyte encodings, Up: Collection

1.36.1 Collection class: instance creation

from: anArray: Convert anArray to an instance of the receiver. anArray is structured such that the instance can be conveniently and fully specified using brace-syntax, possibly by imposing some additional structure on anArray.
join: aCollection: Answer a collection formed by treating each element in aCollection as a `withAll:' argument collection to be added to a new instance.
with: anObject: Answer a collection whose only element is anObject
with: firstObject with: secondObject: Answer a collection whose only elements are the parameters in the order they were passed
with: firstObject with: secondObject with: thirdObject: Answer a collection whose only elements are the parameters in the order they were passed
with: firstObject with: secondObject with: thirdObject with: fourthObject: Answer a collection whose only elements are the parameters in the order they were passed
with: firstObject with: secondObject with: thirdObject with: fourthObject with: fifthObject: Answer a collection whose only elements are the parameters in the order they were passed
withAll: aCollection: Answer a collection whose elements are all those in aCollection

Next: Collection-adding, Previous: Collection class-instance creation, Up: Collection

1.36.2 Collection class: multibyte encodings

isUnicode: Answer true; the receiver is able to store arbitrary Unicode characters.

Next: Collection-concatenating, Previous: Collection class-multibyte encodings, Up: Collection

1.36.3 Collection: adding

add: newObject: Add newObject to the receiver, answer it
addAll: aCollection: Adds all the elements of 'aCollection' to the receiver, answer aCollection

Next: Collection-converting, Previous: Collection-adding, Up: Collection

1.36.4 Collection: concatenating

join

Answer a new collection like my first element, with all the elements (in order) of all my elements, which should be collections.

I use my first element instead of myself as a prototype because my elements are more likely to share the desired properties than I am, such as in:

#('hello, ' 'world') join => 'hello, world'

Next: Collection-copying Collections, Previous: Collection-concatenating, Up: Collection

1.36.5 Collection: converting

asArray: Answer an Array containing all the elements in the receiver
asBag: Answer a Bag containing all the elements in the receiver
asByteArray: Answer a ByteArray containing all the elements in the receiver
asOrderedCollection: Answer an OrderedCollection containing all the elements in the receiver
order
asRunArray: Answer the receiver converted to a RunArray. If the receiver is not ordered the order of the elements in the RunArray might not be the #do: order.
asSet: Answer a Set containing all the elements in the receiver with no duplicates
asSortedCollection: Answer a SortedCollection containing all the elements in the receiver with the default sort block - [ :a :b | a <= b ]
asSortedCollection: aBlock: Answer a SortedCollection whose elements are the elements of the receiver, sorted according to the sort block aBlock
asString: Answer a String containing all the elements in the receiver
asUnicodeString: Answer a UnicodeString containing all the elements in the receiver

Next: Collection-enumeration, Previous: Collection-converting, Up: Collection

1.36.6 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

Next: Collection-finalization, Previous: Collection-copying Collections, Up: Collection

1.36.7 Collection: enumeration

anyOne: Answer an unspecified element of the collection.
beConsistent: This method is private, but it is quite interesting so it is documented. It ensures that a collection is in a consistent state before attempting to iterate on it; its presence reduces the number of overrides needed by collections who try to amortize their execution times. The default implementation does nothing, so it is optimized out by the virtual machine and so it loses very little on the performance side. Note that descendants of Collection have to call it explicitly since #do: is abstract in Collection.
collect: aBlock: Answer a new instance of a Collection containing all the results of evaluating aBlock passing each of the receiver's elements
gather: aBlock: Answer a new instance of a Collection containing all the results of evaluating aBlock, joined together. aBlock should return collections. The result is the same kind as the first collection, returned by aBlock (as for #join).
readStream: Answer a stream that gives elements of the receiver
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

Next: Collection-printing, Previous: Collection-enumeration, Up: Collection

1.36.8 Collection: finalization

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

Next: Collection-removing, Previous: Collection-finalization, Up: Collection

1.36.9 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

Next: Collection-storing, Previous: Collection-printing, Up: Collection

1.36.10 Collection: removing

empty: Remove everything from the receiver.
remove: oldObject: Remove oldObject from the receiver. If absent, fail, else answer oldObject.
remove: oldObject ifAbsent: anExceptionBlock: Remove oldObject from the receiver. If absent, evaluate anExceptionBlock and answer the result, else answer oldObject.
removeAll: aCollection: Remove each object in aCollection, answer aCollection, fail if some of them is absent. Warning: this could leave the collection in a semi-updated state.
removeAll: aCollection ifAbsent: aBlock: Remove each object in aCollection, answer aCollection; if some element is absent, pass it to aBlock.
removeAllSuchThat: aBlock: Remove from the receiver all objects for which aBlock returns true.

Next: Collection-testing collections, Previous: Collection-removing, Up: Collection

1.36.11 Collection: storing

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

Previous: Collection-storing, Up: Collection

1.36.12 Collection: testing collections

capacity: Answer how many elements the receiver can hold before having to grow.
identityIncludes: anObject: Answer whether we include the anObject object
includes: anObject: Answer whether we include anObject
includesAnyOf: aCollection: Answer whether we include any of the objects in aCollection
isEmpty: Answer whether we are (still) empty
isSequenceable: Answer whether the receiver can be accessed by a numeric index with #at:/#at:put:.
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

Next: CompiledCode, Previous: Collection, Up: Base classes

1.37 CompiledBlock

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

Next: CompiledBlock-accessing, Up: CompiledBlock

1.37.1 CompiledBlock class: instance creation

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

Next: CompiledBlock-basic, Previous: CompiledBlock class-instance creation, Up: CompiledBlock

1.37.2 CompiledBlock: accessing

flags: Answer the `cleanness' of the block. 0 = clean; 1 = access to receiver variables and/or self; 2-30 = access to variables that are 1-29 contexts away; 31 = return from method or push thisContext
method: Answer the CompiledMethod in which the receiver lies
methodClass: Answer the class in which the receiver is installed.
methodClass: methodClass: Set the receiver's class instance variable
numArgs: Answer the number of arguments passed to the receiver
numLiterals: Answer the number of literals for the receiver
numTemps: Answer the number of temporary variables used by the receiver
selector: Answer the selector through which the method is called
selector: aSymbol: Set the selector through which the method is called
sourceCodeLinesDelta: Answer the delta from the numbers in LINE_NUMBER bytecodes to source code line numbers.
sourceCodeMap: Answer an array which maps bytecode indices to source code line numbers. 0 values represent invalid instruction pointer indices.
stackDepth: Answer the number of stack slots needed for the receiver

Next: CompiledBlock-printing, Previous: CompiledBlock-accessing, Up: CompiledBlock

1.37.3 CompiledBlock: basic

= aMethod: Answer whether the receiver and aMethod are equal
methodCategory: Answer the method category
methodCategory: aCategory: Set the method category to the given string
methodSourceCode: Answer the method source code (a FileSegment or String or nil)
methodSourceFile: Answer the file where the method source code is stored
methodSourcePos: Answer the location where the method source code is stored in the methodSourceFile
methodSourceString: Answer the method source code as a string

Next: CompiledBlock-saving and loading, Previous: CompiledBlock-basic, Up: CompiledBlock

1.37.4 CompiledBlock: printing

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

Previous: CompiledBlock-printing, Up: CompiledBlock

1.37.5 CompiledBlock: saving and loading

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

Next: CompiledMethod, Previous: CompiledBlock, Up: Base classes

1.38 CompiledCode

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

Next: CompiledCode class-instance creation, Up: CompiledCode

1.38.1 CompiledCode class: cache flushing

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

Next: CompiledCode class-tables, Previous: CompiledCode class-cache flushing, Up: CompiledCode

1.38.2 CompiledCode class: instance creation

new: numBytecodes header: anInteger literals: literals: Answer a new instance of the receiver with room for the given number of bytecodes and the given header
new: numBytecodes header: anInteger numLiterals: numLiterals: Answer a new instance of the receiver with room for the given number of bytecodes and the given header

Next: CompiledCode-accessing, Previous: CompiledCode class-instance creation, Up: CompiledCode

1.38.3 CompiledCode class: tables

bytecodeInfoTable

Return a ByteArray which defines some properties of the bytecodes. For each bytecode, 4 bytes are reserved. The fourth byte is a flag byte: bit 7 means that the argument is a line number to be used in creating the bytecode->line number map.

The first three have a meaning only for those bytecodes that represent a combination of operations: the combination can be BC1 ARG BC2 OPERAND if the fourth byte's bit 0 = 0 or BC1 OPERAND BC2 ARG if the fourth byte's bit 0 = 1

where BC1 is the first byte, BC2 is the second, ARG is the third and OPERAND is the bytecode argument as it appears in the bytecode stream.

specialSelectors

Answer an array of message names that don't need to be in literals to be sent in a method. Their position here reflects their integer code in bytecode.

specialSelectorsNumArgs

Answer a harmoniously-indexed array of arities for the messages answered by #specialSelectors.

Next: CompiledCode-basic, Previous: CompiledCode class-tables, Up: CompiledCode

1.38.4 CompiledCode: accessing

at: anIndex put: aBytecode: Store aBytecode as the anIndex-th bytecode
blockAt: anIndex: Answer the CompiledBlock attached to the anIndex-th literal, assuming that the literal is a CompiledBlock or a BlockClosure.
bytecodeAt: anIndex: Answer the anIndex-th bytecode
bytecodeAt: anIndex put: aBytecode: Store aBytecode as the anIndex-th bytecode
flags: Private - Answer the optimization flags for the receiver
isAnnotated: Answer `false'.
literalAt: anIndex: Answer the anIndex-th literal
literalAt: anInteger put: aValue: Store aValue as the anIndex-th literal
literals: Answer the literals referenced by my code or any CompiledCode instances I own.
methodClass: Answer the class in which the receiver is installed.
methodClass: methodClass: Set the receiver's class instance variable
numArgs: Answer the number of arguments for the receiver
numLiterals: Answer the number of literals for the receiver
numTemps: Answer the number of temporaries for the receiver
primitive: Answer the primitive called by the receiver
selector: Answer the selector through which the method is called
selector: aSymbol: Set the selector through which the method is called
sourceCodeLinesDelta: Answer the delta from the numbers in LINE_NUMBER bytecodes to source code line numbers.
stackDepth: Answer the number of stack slots needed for the receiver

Next: CompiledCode-copying, Previous: CompiledCode-accessing, Up: CompiledCode

1.38.5 CompiledCode: basic

= aMethod: Answer whether the receiver and aMethod are equal
hash: Answer an hash value for the receiver
methodCategory: Answer the method category
methodCategory: aCategory: Set the method category to the given string
methodSourceCode: Answer the method source code (a FileSegment or String or nil)
methodSourceFile: Answer the file where the method source code is stored
methodSourcePos: Answer the location where the method source code is stored in the methodSourceFile
methodSourceString: Answer the method source code as a string

Next: CompiledCode-debugging, Previous: CompiledCode-basic, Up: CompiledCode

1.38.6 CompiledCode: copying

deepCopy: Answer a deep copy of the receiver

Next: CompiledCode-decoding bytecodes, Previous: CompiledCode-copying, Up: CompiledCode

1.38.7 CompiledCode: debugging

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

Next: CompiledCode-literals - iteration, Previous: CompiledCode-debugging, Up: CompiledCode

1.38.8 CompiledCode: decoding bytecodes

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

Next: CompiledCode-security, Previous: CompiledCode-decoding bytecodes, Up: CompiledCode

1.38.9 CompiledCode: literals - iteration

allLiteralSymbolsDo: aBlock: As with #allLiteralsDo:, but only call aBlock with found Symbols.
allLiteralsDo: aBlock: Walk my literals, descending into Arrays and Messages, invoking aBlock with each touched object.
literalsDo: aBlock: Invoke aBlock with each object immediately in my list of literals.

Next: CompiledCode-testing accesses, Previous: CompiledCode-literals - iteration, Up: CompiledCode

1.38.10 CompiledCode: security

verify: Verify the bytecodes for the receiver, and raise an exception if the verification process failed.

Next: CompiledCode-translation, Previous: CompiledCode-security, Up: CompiledCode

1.38.11 CompiledCode: testing accesses

accesses: instVarIndex: Answer whether the receiver accesses the instance variable with the given index
assigns: instVarIndex: Answer whether the receiver writes to the instance variable with the given index
containsLiteral: anObject: Answer if the receiver contains a literal which is equal to anObject.
hasBytecode: byte between: firstIndex and: lastIndex: Answer whether the receiver includes the `byte' bytecode in any of the indices between firstIndex and lastIndex.
jumpDestinationAt: anIndex forward: aBoolean: Answer where the jump at bytecode index `anIndex' lands
reads: instVarIndex: Answer whether the receiver reads the instance variable with the given index
refersTo: anObject: Answer whether the receiver refers to the given object
sendsToSuper: Answer whether the receiver includes a send to super.
sourceCodeMap: Answer an array which maps bytecode indices to source code line numbers. 0 values represent invalid instruction pointer indices.

Previous: CompiledCode-testing accesses, Up: CompiledCode

1.38.12 CompiledCode: translation

discardTranslation: Flush the just-in-time translated code for the receiver (if any).

Next: ContextPart, Previous: CompiledCode, Up: Base classes

1.39 CompiledMethod

Defined in namespace Smalltalk
Superclass: CompiledCode
Category: Language-Implementation: I represent methods that have been compiled. I can recompile methods from their source code, I can invoke Emacs to edit the source code for one of my instances, and I know how to access components of my instances.

Next: CompiledMethod class-instance creation, Up: CompiledMethod

1.39.1 CompiledMethod class: c call-outs

asyncCCall: descr numArgs: numArgs attributes: attributesArray: Return a CompiledMethod corresponding to a #asyncCCall:args: pragma with the given arguments.
pragma
cCall: descr numArgs: numArgs attributes: attributesArray: Return a CompiledMethod corresponding to a #cCall:returning:args: pragma with the given arguments.

Next: CompiledMethod class-lean images, Previous: CompiledMethod class-c call-outs, Up: CompiledMethod

1.39.2 CompiledMethod class: instance creation

literals: lits numArgs: numArg numTemps: numTemp attributes: attrArray bytecodes: bytecodes depth: depth: Answer a full fledged CompiledMethod. Construct the method header from the parameters, and set the literals and bytecodes to the provided ones. Also, the bytecodes are optimized and any embedded CompiledBlocks modified to refer to these literals and to the newly created CompiledMethod.
numArgs: args: Create a user-defined method (one that is sent #valueWithReceiver:withArguments: when it is invoked) with numArgs arguments. This only makes sense when called for a subclass of CompiledMethod.

Next: CompiledMethod-accessing, Previous: CompiledMethod class-instance creation, Up: CompiledMethod

1.39.3 CompiledMethod class: lean images

stripSourceCode: Remove all the references to method source code from the system

Next: CompiledMethod-attributes, Previous: CompiledMethod class-lean images, Up: CompiledMethod

1.39.4 CompiledMethod: accessing

allBlocksDo: aBlock: Evaluate aBlock, passing to it all the CompiledBlocks it holds
allLiterals: Answer the literals referred to by the receiver and all the blocks in it
flags: Private - Answer the optimization flags for the receiver
isOldSyntax: Answer whether the method was written with the old (chunk-format) syntax
methodCategory: Answer the method category
methodCategory: aCategory: Set the method category to the given string
methodClass: Answer the class in which the receiver is installed.
methodClass: methodClass: Set the receiver's class instance variable
noteOldSyntax: Remember that the method is written with the old (chunk-format) syntax
numArgs: Answer the number of arguments for the receiver
numTemps: Answer the number of temporaries for the receiver
primitive: Answer the primitive called by the receiver
selector: Answer the selector through which the method is called
selector: aSymbol: Set the selector through which the method is called
sourceCodeLinesDelta: Answer the delta from the numbers in LINE_NUMBER bytecodes to source code line numbers.
stackDepth: Answer the number of stack slots needed for the receiver
withAllBlocksDo: aBlock: Evaluate aBlock, passing the receiver and all the CompiledBlocks it holds
withNewMethodClass: class: Answer either the receiver or a copy of it, with the method class set to class
withNewMethodClass: class selector: selector: Answer either the receiver or a copy of it, with the method class set to class

Next: CompiledMethod-basic, Previous: CompiledMethod-accessing, Up: CompiledMethod

1.39.5 CompiledMethod: attributes

attributeAt: aSymbol: Return a Message for the first attribute named aSymbol defined by the receiver, or answer an error if none was found.
attributeAt: aSymbol ifAbsent: aBlock: Return a Message for the first attribute named aSymbol defined by the receiver, or evaluate aBlock is none was found.
attributes: Return an Array of Messages, one for each attribute defined by the receiver.
attributesDo: aBlock: Evaluate aBlock once for each attribute defined by the receiver, passing a Message each time.
isAnnotated: If the receiver has any attributes, answer true.
primitiveAttribute: If the receiver defines a primitive, return a Message resembling the attribute that was used to define it.

Next: CompiledMethod-c call-outs, Previous: CompiledMethod-attributes, Up: CompiledMethod

1.39.6 CompiledMethod: basic

= aMethod: Answer whether the receiver and aMethod are equal
hash: Answer an hash value for the receiver

Next: CompiledMethod-compiling, Previous: CompiledMethod-basic, Up: CompiledMethod

1.39.7 CompiledMethod: c call-outs

isValidCCall: Answer whether I appear to have the valid flags, information, and ops to invoke a C function and answer its result.
rewriteAsAsyncCCall: func args: argsArray: Not commented.
rewriteAsCCall: funcOrDescr for: aClass: Not commented.
rewriteAsCCall: func returning: returnType args: argsArray: Not commented.

Next: CompiledMethod-invoking, Previous: CompiledMethod-c call-outs, Up: CompiledMethod

1.39.8 CompiledMethod: compiling

methodFormattedSourceString: Answer the method source code as a string, formatted using the RBFormatter. Requires package Parser.
methodParseNode: Answer the parse tree for the receiver, or nil if there is an error. Requires package Parser.
parserClass: Answer a parser class, similar to Behavior>>parserClass, that can parse my source code. Requires package Parser.
recompile: Recompile the method in the scope of the class where it leaves.
recompileNotifying: aNotifier: Recompile the method in the scope of the class where it leaves, notifying errors to aNotifier by sending it #error:.

Next: CompiledMethod-printing, Previous: CompiledMethod-compiling, Up: CompiledMethod

1.39.9 CompiledMethod: invoking

valueWithReceiver: anObject withArguments: args: Execute the method within anObject, passing the elements of the args Array as parameters. The method need not reside on the hierarchy from the receiver's class to Object – it need not reside at all in a MethodDictionary, in fact – but doing bad things will compromise stability of the Smalltalk virtual machine (and don't blame anybody but yourself).
If the flags field of the method header is 6, this method instead provides a hook from which the virtual machine can call back whenever execution of the method is requested. In this case, invoking the method would cause an infinite loop (the VM asks the method to run, the method asks the VM to invoke it, and so on), so this method fails with a #subclassResponsibility error.

Next: CompiledMethod-saving and loading, Previous: CompiledMethod-invoking, Up: CompiledMethod

1.39.10 CompiledMethod: printing

printOn: aStream: Print the receiver's class and selector on aStream
storeOn: aStream: Print code to create the receiver on aStream

Next: CompiledMethod-source code, Previous: CompiledMethod-printing, Up: CompiledMethod

1.39.11 CompiledMethod: saving and loading

binaryRepresentationObject: This method is implemented to allow for a PluggableProxy to be used with CompiledMethods. Answer a DirectedMessage which sends #>> to the class object containing the receiver.

Next: CompiledMethod-testing, Previous: CompiledMethod-saving and loading, Up: CompiledMethod

1.39.12 CompiledMethod: source code

methodRecompilationSourceString: Answer the method source code as a string, ensuring that it is in new syntax (it has brackets).
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

Previous: CompiledMethod-source code, Up: CompiledMethod

1.39.13 CompiledMethod: testing

accesses: instVarIndex: Answer whether the receiver or the blocks it contains accesses the instance variable with the given index
assigns: instVarIndex: Answer whether the receiver or the blocks it contains writes to the instance variable with the given index
isAbstract: Answer whether the receiver is abstract.
reads: instVarIndex: Answer whether the receiver or the blocks it contains reads to the instance variable with the given index
sendsToSuper: Answer whether the receiver or the blocks it contains have sends to super

Next: Continuation, Previous: CompiledMethod, Up: Base classes

1.40 ContextPart

Defined in namespace Smalltalk
Superclass: Object
Category: Language-Implementation: My instances represent executing Smalltalk code, which represent the local environment of executable code. They contain a stack and also provide some methods that can be used in inspection or debugging.

Next: ContextPart class-exception handling, Up: ContextPart

1.40.1 ContextPart class: built ins

thisContext: Return the value of the thisContext variable. Called internally when the variable is accessed.

Next: ContextPart-accessing, Previous: ContextPart class-built ins, Up: ContextPart

1.40.2 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

Next: ContextPart-built ins, Previous: ContextPart class-exception handling, Up: ContextPart

1.40.3 ContextPart: accessing

client: Answer the client of this context, that is, the object that sent the message that created this context. Fail if the receiver has no parent
currentFileName: Answer the name of the file where the method source code is
environment: To create a valid execution environment for the interpreter even before it starts, GST creates a fake context whose selector is nil and which can be used as a marker for the current execution environment. This method answers that context. For processes, it answers the process block itself
home: Answer the MethodContext to which the receiver refers
initialIP: Answer the value of the instruction pointer when execution starts in the current context
ip: Answer the current instruction pointer into the receiver
ip: newIP: Set the instruction pointer for the receiver
isBlock: Answer whether the receiver is a block context
isDisabled: Answers whether the context is skipped when doing a return. Contexts are marked as disabled whenever a non-local return is done (either by returning from the enclosing method of a block, or with the #continue: method of ContextPart) and there are unwind contexts such as those created by #ensure:. All non-unwind contexts are then marked as disabled.
isEnvironment: To create a valid execution environment for the interpreter even before it starts, GST creates a fake context which invokes a special “termination” method. Such a context can be used as a marker for the current execution environment. Answer whether the receiver is that kind of context.
isProcess: Answer whether the receiver represents a process context, i.e. a context created by BlockClosure>>#newProcess. Such a context can be recognized because it has no parent but its flags are different from those of the contexts created by the VM's prepareExecutionEnvironment function.
isUnwind: Answers whether the context must continue execution even after a non-local return (a return from the enclosing method of a block, or a call to the #continue: method of ContextPart). Such contexts are created by #ensure:.
method: Return the CompiledMethod being executed
methodClass: Return the class in which the CompiledMethod being executed is defined
numArgs: Answer the number of arguments passed to the receiver
numTemps: Answer the number of temporaries used by the receiver
parentContext: Answer the context that called the receiver
parentContext: aContext: Set the context to which the receiver will return
push: anObject: Push an object on the receiver's stack.
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

Next: ContextPart-copying, Previous: ContextPart-accessing, Up: ContextPart

1.40.4 ContextPart: built ins

continue: anObject: Resume execution from the receiver, faking that the context on top of it in the execution chain has returned anObject. The receiver must belong to the same process as the executing context, otherwise the results are not predictable. All #ensure: (and possibly #ifCurtailed:) blocks between the currently executing context and the receiver are evaluated (which is not what would happen if you directly bashed at the parent context of thisContext).

Next: ContextPart-debugging, Previous: ContextPart-built ins, Up: ContextPart

1.40.5 ContextPart: copying

copyStack: Answer a copy of the entire stack.
deepCopy: Answer a copy of the entire stack, but don't copy any of the other instance variables of the context.

Next: ContextPart-enumerating, Previous: ContextPart-copying, Up: ContextPart

1.40.6 ContextPart: debugging

currentLine: Answer the 1-based number of the line that is pointed to by the receiver's instruction pointer. The DebugTools package caches information, thus making the implementation faster.
currentLineInFile: Answer the 1-based number of the line that is pointed to by the receiver's instruction pointer, relative to the method's file. The implementation is slow unless the DebugTools package is loaded.
debugger: Answer the debugger that is attached to the given context. It is always nil unless the DebugTools package is loaded.
debuggerClass: Answer which debugger should be used to debug the current context chain. The class with the highest debugging priority is picked among those mentioned in the chain.
isInternalExceptionHandlingContext: Answer whether the receiver is a context that should be hidden to the user when presenting a backtrace.

Next: ContextPart-printing, Previous: ContextPart-debugging, Up: ContextPart

1.40.7 ContextPart: enumerating

scanBacktraceFor: selectors do: aBlock: Scan the backtrace for contexts whose selector is among those listed in selectors; if one is found, invoke aBlock passing the context.
scanBacktraceForAttribute: selector do: aBlock: Scan the backtrace for contexts which have the attribute selector listed in selectors; if one is found, invoke aBlock passing the context and the attribute.

Next: ContextPart-security checks, Previous: ContextPart-enumerating, Up: ContextPart

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

Previous: ContextPart-printing, Up: ContextPart

1.40.9 ContextPart: security checks

checkSecurityFor: perm: Answer the receiver.
doSecurityCheckForName: name actions: actions target: target: Not commented.
securityCheckForName: name: Not commented.
securityCheckForName: name action: action: Not commented.
securityCheckForName: name actions: actions target: target: Not commented.
securityCheckForName: name target: target: Not commented.

Next: CPtr, Previous: ContextPart, Up: Base classes

1.41 Continuation

Defined in namespace Smalltalk
Superclass: Object
Category: Language-Implementation: At my heart, I am something like the goto instruction; my creation sets the label, and my methods do the jump. However, this is a really powerful kind of goto instruction. If your hair is turning green at this point, don't worry as you will probably only deal with users of continuations, rather than with the concept itself.

Next: Continuation-invocation, Up: Continuation

1.41.1 Continuation class: instance creation

current: Return a continuation.
currentDo: aBlock: Pass a continuation to the one-argument block, aBlock and return the result of evaluating it.
escapeDo: aBlock: Pass a continuation to the one-argument block, knowing that aBlock does not fall off (either because it includes a method return, or because it yields control to another continuation). If it does, an exception will be signalled and the current process terminated.

Previous: Continuation class-instance creation, Up: Continuation

1.41.2 Continuation: invocation

callCC: Activate the original continuation, passing back in turn a continuation for the caller. The called continuation becomes unusable, and any attempt to reactivate it will cause an exception. This is not a limitation, in general, because this method is used to replace a continuation with another (see the implementation of the Generator class).
oneShotValue: Return nil to the original continuation, which becomes unusable. Attempting to reactivate it will cause an exception. This is an optimization over #value.
oneShotValue: v: Return anObject to the original continuation, which becomes unusable. Attempting to reactivate it will cause an exception. This is an optimization over #value:.
value: Return nil to the original continuation, copying the stack to allow another activation.
value: anObject: Return anObject to the original continuation, copying the stack to allow another activation.
valueWithArguments: aCollection: Return the sole element of aCollection to the original continuation (or nil if aCollection is empty), copying the stack to allow another activation

Next: CPtrCType, Previous: Continuation, Up: Base classes

1.42 CPtr

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

Up: CPtr

1.42.1 CPtr: accessing

alignof: Answer the receiver's required aligment
sizeof: Answer the receiver's size
value: Answer the address of the location pointed to by the receiver.
value: anObject: Set the address of the location pointed to by the receiver to anObject, which can be either an Integer or a CObject. if anObject is an Integer, it is interpreted as a 32-bit or 64-bit address. If it is a CObject, its address is stored.

Next: CScalar, Previous: CPtr, Up: Base classes

1.43 CPtrCType

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

Next: CPtrCType-accessing, Up: CPtrCType

1.43.1 CPtrCType class: instance creation

elementType: aCType: Answer a new instance of CPtrCType that maps pointers to the given CType
from: type: Private - Called by computeAggregateType: for pointers

Next: CPtrCType-storing, Previous: CPtrCType class-instance creation, Up: CPtrCType

1.43.2 CPtrCType: accessing

elementType: Answer the type of the elements in the receiver's instances
new: size: Allocate space for `size' objects like those that the receiver points to, and with the type (class) identified by the receiver. It is the caller's responsibility to free the memory allocated for it.

Previous: CPtrCType-accessing, Up: CPtrCType

1.43.3 CPtrCType: storing

storeOn: aStream: Not commented.

Next: CScalarCType, Previous: CPtrCType, Up: Base classes

1.44 CScalar

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

Next: CScalar-accessing, Up: CScalar

1.44.1 CScalar class: instance creation

gcValue: anObject: Answer a newly allocated CObject containing the passed value, anObject, in garbage-collected storage.
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

Previous: CScalar class-instance creation, Up: CScalar

1.44.2 CScalar: accessing

cObjStoredType: Private - Provide a conversion from a CObject to a Smalltalk object to be stored by #at:put:
value: Answer the value the receiver is pointing to. The exact returned value depends on the receiver's class
value: aValue: Set the receiver to point to the value, aValue. The exact meaning of aValue depends on the receiver's class

Next: CShort, Previous: CScalar, Up: Base classes

1.45 CScalarCType

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

Next: CScalarCType-storing, Up: CScalarCType

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

Previous: CScalarCType-accessing, Up: CScalarCType

1.45.2 CScalarCType: storing

storeOn: aStream: Store Smalltalk code that compiles to the receiver

Next: CSmalltalk, Previous: CScalarCType, Up: Base classes

1.46 CShort

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

Next: CShort-accessing, Up: CShort

1.46.1 CShort class: accessing

alignof: Answer the receiver's instances required aligment
cObjStoredType: Private - Answer an index referring to the receiver's instances scalar type
sizeof: Answer the receiver's instances size

Previous: CShort class-accessing, Up: CShort

1.46.2 CShort: accessing

alignof: Answer the receiver's required aligment
cObjStoredType: Private - Answer an index referring to the receiver's scalar type
sizeof: Answer the receiver's size

Next: CString, Previous: CShort, Up: Base classes

1.47 CSmalltalk

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

Next: CSmalltalk-accessing, Up: CSmalltalk

1.47.1 CSmalltalk class: accessing

alignof: Answer the receiver's instances required aligment
cObjStoredType: Private - Answer an index referring to the receiver's instances scalar type
sizeof: Answer the receiver's instances size

Previous: CSmalltalk class-accessing, Up: CSmalltalk

1.47.2 CSmalltalk: accessing

alignof: Answer the receiver's required aligment
cObjStoredType: Private - Answer an index referring to the receiver's scalar type
sizeof: Answer the receiver's size

Next: CStringCType, Previous: CSmalltalk, Up: Base classes

1.48 CString

Defined in namespace Smalltalk

Superclass: CPtr

Category: Language-C interface

Technically, CString is really a pointer to CChar. However, it can be very useful as a distinct datatype because it is a separate datatype in Smalltalk, so we allow developers to express their semantics more precisely by using a more descriptive type.

Note that like CChar is a pointer to char, CString is actually a *pointer* to string: a char ** in C terms. If you need to take a String out of a char *, use CChar>>#asString.

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.

Next: CString class-instance creation, Up: CString

1.48.1 CString class: accessing

cObjStoredType: Private - Provide a conversion from a CObject to a Smalltalk object to be stored by #at:put:

Next: CString-accessing, Previous: CString class-accessing, Up: CString

1.48.2 CString class: instance creation

type: Answer a CType for the receiver—for example, CByteType if the receiver is CByte.
value: anObject: Answer a newly allocated CObject containing the passed value, anObject. Remember to call #addToBeFinalized if you want the CObject to be automatically freed

Previous: CString class-instance creation, Up: CString

1.48.3 CString: accessing

cObjStoredType: Private - Provide a conversion from a CObject to a Smalltalk object to be stored by #at:put:
value: Answer the value the receiver is pointing to. The exact returned value depends on the receiver's class
value: aValue: Set the receiver to point to the value, aValue. The exact meaning of aValue depends on the receiver's class

Next: CStruct, Previous: CString, Up: Base classes

1.49 CStringCType

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

Up: CStringCType

1.49.1 CStringCType: accessing

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

Next: CType, Previous: CStringCType, Up: Base classes

1.50 CStruct

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

Up: CStruct

1.50.1 CStruct class: subclass creation

declaration: array: Compile methods that implement the declaration in array.

Next: CUChar, Previous: CStruct, Up: Base classes

1.51 CType

Defined in namespace Smalltalk

Superclass: Object

Category: Language-C interface

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

My only instance variable, cObjectType, is used to hold onto the CObject subclass that gets created for a given CType. Used primarily in the C part of the interpreter because internally it cannot execute methods to get values, so it has a simple way to access instance variable which holds the desired subclass.

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

Next: CType class-initialization, Up: CType

1.51.1 CType class: C instance creation

cObjectBinding: aCObjectSubclassBinding: Create a new CType for the given subclass of CObject
cObjectType: aCObjectSubclass: Create a new CType for the given subclass of CObject
computeAggregateType: type: Private - Called by from: for pointers/arrays. Format of type: (#array #int 3) or (#ptr #{FooStruct})
from: type: Private - Pass the size, alignment, and description of CType for aBlock, given the field description in `type' (the second element of each pair).

Next: CType-accessing, Previous: CType class-C instance creation, Up: CType

1.51.2 CType class: initialization

initialize: Initialize the receiver's TypeMap

Next: CType-C instance creation, Previous: CType class-initialization, Up: CType

1.51.3 CType: accessing

alignof: Answer the size of the receiver's instances
arrayType: size: Answer a CArrayCType which represents an array with the given size of CObjects whose type is in turn represented by the receiver
cObjectType: Answer the CObject subclass whose instance is created when new is sent to the receiver
ptrType: Answer a CPtrCType which represents a pointer to CObjects whose type is in turn represented by the receiver
sizeof: Answer the size of the receiver's instances
valueType: valueType is used as a means to communicate to the interpreter the underlying type of the data. For anything but scalars, it's just 'self'

Next: CType-storing, Previous: CType-accessing, Up: CType

1.51.4 CType: C instance creation

address: cObjOrInt: Create a new CObject with the type (class) identified by the receiver, pointing to the given address (identified by an Integer or CObject).
gcNew: Allocate a new CObject with the type (class) identified by the receiver. The object is movable in memory, but on the other hand it is garbage-collected automatically.
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.

Previous: CType-C instance creation, Up: CType

1.51.5 CType: storing

storeOn: aStream: Store Smalltalk code that compiles to the receiver

Next: CUInt, Previous: CType, Up: Base classes

1.52 CUChar

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

Next: CUChar-accessing, Up: CUChar

1.52.1 CUChar class: getting info

alignof: Answer the receiver's instances required aligment
cObjStoredType: Private - Answer an index referring to the receiver's instances scalar type
sizeof: Answer the receiver's instances size

Previous: CUChar class-getting info, Up: CUChar

1.52.2 CUChar: accessing

alignof: Answer the receiver's required aligment
cObjStoredType: Private - Answer an index referring to the receiver's scalar type
sizeof: Answer the receiver's size

Next: CULong, Previous: CUChar, Up: Base classes

1.53 CUInt

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

Next: CUInt-accessing, Up: CUInt

1.53.1 CUInt class: accessing

alignof: Answer the receiver's instances required aligment
cObjStoredType: Private - Answer an index referring to the receiver's instances scalar type
sizeof: Answer the receiver's instances size

Previous: CUInt class-accessing, Up: CUInt

1.53.2 CUInt: accessing

alignof: Answer the receiver's required aligment
cObjStoredType: Private - Answer an index referring to the receiver's scalar type
sizeof: Answer the receiver's size

Next: CUnion, Previous: CUInt, Up: Base classes

1.54 CULong

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

Next: CULong-accessing, Up: CULong

1.54.1 CULong class: accessing

alignof: Answer the receiver's instances required aligment
cObjStoredType: Private - Answer an index referring to the receiver's instances scalar type
sizeof: Answer the receiver's instances size

Previous: CULong class-accessing, Up: CULong

1.54.2 CULong: accessing

alignof: Answer the receiver's required aligment
cObjStoredType: Private - Answer an index referring to the receiver's scalar type
sizeof: Answer the receiver's size

Next: CUShort, Previous: CULong, Up: Base classes

1.55 CUnion

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

Up: CUnion

1.55.1 CUnion class: subclass creation

declaration: array: Compile methods that implement the declaration in array.

Next: Date, Previous: CUnion, Up: Base classes

1.56 CUShort

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

Next: CUShort-accessing, Up: CUShort

1.56.1 CUShort class: accessing

alignof: Answer the receiver's instances required aligment
cObjStoredType: Private - Answer an index referring to the receiver's instances scalar type
sizeof: Answer the receiver's instances size

Previous: CUShort class-accessing, Up: CUShort

1.56.2 CUShort: accessing

alignof: Answer the receiver's required aligment
cObjStoredType: Private - Answer an index referring to the receiver's scalar type
sizeof: Answer the receiver's size

Next: DateTime, Previous: CUShort, Up: Base classes

1.57 Date

Defined in namespace Smalltalk

Superclass: Magnitude

Category: Language-Data types

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

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

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

Next: Date class-instance creation (ANSI), Up: Date

1.57.1 Date class: basic

abbreviationOfDay: dayIndex: Answer the abbreviated name of the day of week corresponding to the given index
dayOfWeek: dayName: Answer the index of the day of week corresponding to the given name
daysInMonth: monthName forYear: yearInteger: Answer the number of days in the given (named) month for the given year
daysInYear: i: Answer the number of days in the given year
indexOfMonth: monthName: Answer the index of the month corresponding to the given name
initDayNameDict: Initialize the DayNameDict to the names of the days
initMonthNameDict: Initialize the MonthNameDict to the names of the months
initialize: Initialize the receiver
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

Next: Date class-instance creation (Blue Book), Previous: Date class-basic, Up: Date

1.57.2 Date class: instance creation (ANSI)

year: y day: d hour: h minute: min second: s: Answer a Date denoting the d-th day of the given year
year: y month: m day: d hour: h minute: min second: s: Answer a Date denoting the d-th day of the given (as a number) month and year

Next: Date-basic, Previous: Date class-instance creation (ANSI), Up: Date

1.57.3 Date class: instance creation (Blue Book)

dateAndTimeNow: Answer an array containing the current date and time
fromDays: dayCount: Answer a Date denoting dayCount days past 1/1/1901
fromJulian: jd: Answer a Date denoting the jd-th day in the astronomical Julian calendar.
fromSeconds: time: Answer a Date denoting the date time seconds past Jan 1st, 1901
newDay: day month: monthName year: yearInteger: Answer a Date denoting the dayCount day of the given (named) month and year
newDay: day monthIndex: monthIndex year: yearInteger: Answer a Date denoting the dayCount day of the given (as a number) month and year
newDay: dayCount year: yearInteger: Answer a Date denoting the dayCount day of the yearInteger year
readFrom: aStream: Parse an instance of the receiver from aStream
today: Answer a Date denoting the current date in local time
utcDateAndTimeNow: Answer an array containing the current date and time in Coordinated Universal Time (UTC)
utcToday: Answer a Date denoting the current date in Coordinated Universal Time (UTC)

Next: Date-compatibility (non-ANSI), Previous: Date class-instance creation (Blue Book), Up: Date

1.57.4 Date: basic

- aDate: Answer a new Date pointing dayCount before the receiver
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

Next: Date-date computations, Previous: Date-basic, Up: Date

1.57.5 Date: compatibility (non-ANSI)

day: Answer the day represented by the receiver
dayName: Answer the day of week of the receiver as a Symbol
shortMonthName: Answer the abbreviated name of the month represented by the receiver

Next: Date-printing, Previous: Date-compatibility (non-ANSI), Up: Date

1.57.6 Date: date computations

asSeconds: Answer the date as the number of seconds from 1/1/1901.
dayOfMonth: Answer the day represented by the receiver (same as #day)
dayOfWeek: Answer the day of week of the receiver. 1 = Monday, 7 = Sunday
dayOfWeekAbbreviation: Answer the day of week of the receiver as a Symbol
dayOfWeekName: Answer the day of week of the receiver as a Symbol
dayOfYear: Answer the days passed since 31/12 of last year; e.g. New Year's Day is 1
daysFromBaseDay: Answer the days passed since 1/1/1901
daysInMonth: Answer the days in the month represented by the receiver
daysInYear: Answer the days in the year represented by the receiver
daysLeftInMonth: Answer the days to the end of the month represented by the receiver
daysLeftInYear: Answer the days to the end of the year represented by the receiver
firstDayOfMonth: Answer a Date representing the first day of the month represented by the receiver
isLeapYear: Answer whether the receiver refers to a date in a leap year.
lastDayOfMonth: Answer a Date representing the last day of the month represented by the receiver
month: Answer the index of the month represented by the receiver
monthAbbreviation: Answer the abbreviated name of the month represented by the receiver
monthIndex: Answer the index of the month represented by the receiver
monthName: Answer the name of the month represented by the receiver
year: Answer the year represented by the receiver

Next: Date-storing, Previous: Date-date computations, Up: Date

1.57.7 Date: printing

printOn: aStream: Print a representation for the receiver on aStream

Next: Date-testing, Previous: Date-printing, Up: Date

1.57.8 Date: storing

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

Previous: Date-storing, Up: Date

1.57.9 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

Next: DeferredVariableBinding, Previous: Date, Up: Base classes

1.58 DateTime

Defined in namespace Smalltalk
Superclass: Date
Category: Language-Data types: My instances represent timestamps.

Next: DateTime class-instance creation, Up: DateTime

1.58.1 DateTime class: information

clockPrecision: Answer `ClockPrecision'.
initialize: Initialize the receiver's class variables

Next: DateTime class-instance creation (non-ANSI), Previous: DateTime class-information, Up: DateTime

1.58.2 DateTime class: instance creation

now: Answer an instance of the receiver referring to the current date and time.
readFrom: aStream: Parse an instance of the receiver from aStream
year: y day: d hour: h minute: min second: s: Answer a DateTime denoting the d-th day of the given year, and setting the time part to the given hour, minute, and second
year: y day: d hour: h minute: min second: s offset: ofs: Answer a DateTime denoting the d-th day of the given year. Set the offset field to ofs (a Duration), and the time part to the given hour, minute, and second
year: y month: m day: d hour: h minute: min second: s: Answer a DateTime denoting the d-th day of the given (as a number) month and year, setting the time part to the given hour, minute, and second
year: y month: m day: d hour: h minute: min second: s offset: ofs: Answer a DateTime denoting the d-th day of the given (as a number) month and year. Set the offset field to ofs (a Duration), and the the time part to the given hour, minute, and second

Next: DateTime-basic, Previous: DateTime class-instance creation, Up: DateTime

1.58.3 DateTime class: instance creation (non-ANSI)

date: aDate time: aTime: Answer a DateTime denoting the given date and time. Set the offset field to ofs (a Duration).
date: aDate time: aTime offset: ofs: Answer a DateTime denoting the given date and time. Set the offset field to ofs (a Duration).
fromDays: days seconds: secs offset: ofs: Answer a DateTime denoting the given date (as days since January 1, 1901) and time (as seconds since midnight). Set the offset field to ofs (a Duration).

Next: DateTime-computations, Previous: DateTime class-instance creation (non-ANSI), Up: DateTime

1.58.4 DateTime: basic

+ aDuration: Answer a new Date pointing dayCount past the receiver
- aDateTimeOrDuration: Answer a new Date pointing dayCount before the receiver

Next: DateTime-printing, Previous: DateTime-basic, Up: DateTime

1.58.5 DateTime: computations

asSeconds: Answer the date as the number of seconds from 1/1/1901.
dayOfWeek: Answer the day of week of the receiver. Unlike Dates, DateAndTimes have 1 = Sunday, 7 = Saturday
hour: Answer the hour in a 24-hour clock
hour12: Answer the hour in a 12-hour clock
hour24: Answer the hour in a 24-hour clock
meridianAbbreviation: Answer either #AM (for anti-meridian) or #PM (for post-meridian)
minute: Answer the minute
second: Answer the month represented by the receiver

Next: DateTime-splitting in dates & times, Previous: DateTime-computations, Up: DateTime

1.58.6 DateTime: printing

printOn: aStream: Print a representation for the receiver on aStream

Next: DateTime-storing, Previous: DateTime-printing, Up: DateTime

1.58.7 DateTime: splitting in dates & times

asDate: Answer a Date referring to the same day as the receiver
asTime: Answer a Time referring to the same time (from midnight) as the receiver
at: anIndex: Since in the past timestamps were referred to as Arrays containing a Date and a Time (in this order), this method provides access to DateTime objects like if they were two-element Arrays.

Next: DateTime-testing, Previous: DateTime-splitting in dates & times, Up: DateTime

1.58.8 DateTime: storing

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

Next: DateTime-time zones, Previous: DateTime-storing, Up: DateTime

1.58.9 DateTime: testing

< aDateTime: Answer whether the receiver indicates a date preceding aDate
= aDateTime: Answer whether the receiver indicates the same date as aDate
hash: Answer an hash value for the receievr

Previous: DateTime-testing, Up: DateTime

1.58.10 DateTime: time zones

asLocal: Answer the receiver, since DateTime objects store themselves in Local time
asUTC: Convert the receiver to UTC time, and answer a new DateTime object.
offset: Answer the receiver's offset from UTC to local time (e.g. +3600 seconds for Central Europe Time, -3600*6 seconds for Eastern Standard Time). The offset is expressed as a Duration
offset: anOffset: Answer a copy of the receiver with the offset from UTC to local time changed to anOffset (a Duration).
timeZoneAbbreviation: Answer an abbreviated indication of the receiver's offset, expressed as `shhmm', where `hh' is the number of hours and `mm' is the number of minutes between UTC and local time, and `s' can be `+' for the Eastern hemisphere and `-' for the Western hemisphere.
timeZoneName: Answer the time zone name for the receiver (currently, it is simply `GMT +xxxx', where `xxxx' is the receiver's #timeZoneAbbreviation).

Next: Delay, Previous: DateTime, Up: Base classes

1.59 DeferredVariableBinding

Defined in namespace Smalltalk
Superclass: LookupKey
Category: Language-Data types: I represent a binding to a variable that is not tied to a particular dictionary until the first access. Then, lookup rules for global variables in the scope of a given class are used.

Next: DeferredVariableBinding-basic, Up: DeferredVariableBinding

1.59.1 DeferredVariableBinding class: basic

key: aSymbol class: aClass defaultDictionary: aDictionary: Answer a binding that will look up aSymbol as a variable in aClass's environment at first access. See #resolveBinding's comment for aDictionary's meaning.
path: anArray class: aClass defaultDictionary: aDictionary: As with #key:class:defaultDictionary:, but accepting an array of symbols, representing a namespace path, instead.

Next: DeferredVariableBinding-storing, Previous: DeferredVariableBinding class-basic, Up: DeferredVariableBinding

1.59.2 DeferredVariableBinding: basic

path: Answer the path followed after resolving the first key.
value: Answer a new instance of the receiver with the given key and value
value: anObject: Answer a new instance of the receiver with the given key and value

Previous: DeferredVariableBinding-basic, Up: DeferredVariableBinding

1.59.3 DeferredVariableBinding: storing

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

Next: DelayedAdaptor, Previous: DeferredVariableBinding, Up: Base classes

1.60 Delay

Defined in namespace Smalltalk
Superclass: Object
Category: Kernel-Processes: I am the ultimate agent for frustration in the world. I cause things to wait (sometimes much more than is appropriate, but it is those losing operating systems' fault). When a process sends one of my instances a wait message, that process goes to sleep for the interval specified when the instance was created.

Next: Delay class-timer process, Up: Delay

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

Next: Delay-accessing, Previous: Delay class-instance creation, Up: Delay

1.60.2 Delay class: timer process

handleDelayEvent: Handle a timer event; which can be either: - a schedule or unschedule request (DelayEvent notNil) - a timer signal (not explicitly specified) We check for timer expiry every time we get a signal.
runDelayProcess: Run the timer event loop.
scheduleDelay: aDelay on: aSemaphore: Private - Schedule this Delay. Run in the timer process, which is the only one that manipulates Queue.
startDelayLoop: Start the timer event loop.
unscheduleDelay: aDelay: Private. Unschedule this Delay. Run in the timer process, which is the only one that manipulates Queue.

Next: Delay-comparing, Previous: Delay class-timer process, Up: Delay

1.60.3 Delay: accessing

delayDuration: Answer the time I have left to wait, in milliseconds.
resumptionTime: Answer `resumptionTime'.

Next: Delay-delaying, Previous: Delay-accessing, Up: Delay

1.60.4 Delay: comparing

= aDelay: Answer whether the receiver and aDelay denote the same delay
hash: Answer an hash value for the receiver

Next: Delay-initialization, Previous: Delay-comparing, Up: Delay

1.60.5 Delay: delaying

wait: Schedule this Delay and wait on it. The current process will be suspended for the amount of time specified when this Delay was created.

Next: Delay-instance creation, Previous: Delay-delaying, Up: Delay

1.60.6 Delay: initialization

initForMilliseconds: value: Initialize a Delay waiting for millisecondCount milliseconds

Previous: Delay-initialization, Up: Delay

1.60.7 Delay: instance creation

initUntilMilliseconds: value: Initialize a Delay waiting for millisecondCount milliseconds after startup

Next: Dictionary, Previous: Delay, Up: Base classes

1.61 DelayedAdaptor

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

Up: DelayedAdaptor

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

Next: DirectedMessage, Previous: DelayedAdaptor, Up: Base classes

1.62 Dictionary

Defined in namespace Smalltalk
Superclass: HashedCollection
Category: Collections-Keyed: I implement a dictionary, which is an object that is indexed by unique objects (typcially instances of Symbol), and associates another object with that index. I use the equality operator = to determine equality of indices.
In almost all places where you would use a plain Dictionary, a LookupTable would be more efficient; see LookupTable's comment before you use it. I do have a couple of special features that are useful in certain special cases.

Next: Dictionary-accessing, Up: Dictionary

1.62.1 Dictionary class: instance creation

from: anArray: Answer a new dictionary created from the keys and values of Associations in anArray, such as {1 -> 2. 3 -> 4}. anArray should be specified using brace-syntax.
new: Create a new dictionary with a default size

Next: Dictionary-awful ST-80 compatibility hacks, Previous: Dictionary class-instance creation, Up: Dictionary

1.62.2 Dictionary: accessing

add: newObject: Add the newObject association to the receiver
addAll: aCollection: Adds all the elements of 'aCollection' to the receiver, answer aCollection
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
associations: Returns the content of a Dictionary as a Set of Associations.
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
atAll: keyCollection: Answer a Dictionary that only includes the given keys. Fail if any of them is not found
keyAtValue: value: Answer the key associated to the given value, or nil if the value is not found
keyAtValue: value ifAbsent: exceptionBlock: Answer the key associated to the given value. Evaluate exceptionBlock (answering the result) if the value is not found. IMPORTANT: == is used to compare values
keys: Answer a kind of Set containing the keys of the receiver
values: Answer an Array containing the values of the receiver

Next: Dictionary-dictionary enumerating, Previous: Dictionary-accessing, Up: Dictionary

1.62.3 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

Next: Dictionary-dictionary removing, Previous: Dictionary-awful ST-80 compatibility hacks, Up: Dictionary

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

Next: Dictionary-dictionary testing, Previous: Dictionary-dictionary enumerating, Up: Dictionary

1.62.5 Dictionary: dictionary removing

remove: anAssociation: Remove anAssociation's key from the dictionary
remove: anAssociation ifAbsent: aBlock: Remove anAssociation's key from the dictionary
removeAllKeys: keys: Remove all the keys in keys, without raising any errors
removeAllKeys: keys ifAbsent: aBlock: Remove all the keys in keys, passing the missing keys as parameters to aBlock as they're encountered
removeKey: key: Remove the passed key from the dictionary, fail if it is not found
removeKey: key ifAbsent: aBlock: Remove the passed key from the dictionary, answer the result of evaluating aBlock if it is not found

Next: Dictionary-namespace protocol, Previous: Dictionary-dictionary removing, Up: Dictionary

1.62.6 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

Next: Dictionary-printing, Previous: Dictionary-dictionary testing, Up: Dictionary

1.62.7 Dictionary: namespace protocol

allSuperspaces: Answer all the receiver's superspaces in a collection
allSuperspacesDo: aBlock: Evaluate aBlock once for each of the receiver's superspaces (which is none for BindingDictionary).
definedKeys: Answer a kind of Set containing the keys of the receiver
definesKey: key: Answer whether the receiver defines the given key. `Defines' means that the receiver's superspaces, if any, are not considered.
hereAssociationAt: key: Return the association for the variable named as specified by `key' *in this namespace*. If the key is not found search will *not* be carried on in superspaces and the method will fail.
hereAssociationAt: key ifAbsent: aBlock: Return the association for the variable named as specified by `key' *in this namespace*. If the key is not found search will *not* be carried on in superspaces and aBlock will be immediately evaluated.
hereAt: key: Return the value associated to the variable named as specified by `key' *in this namespace*. If the key is not found search will *not* be carried on in superspaces and the method will fail.
hereAt: key ifAbsent: aBlock: Return the value associated to the variable named as specified by `key' *in this namespace*. If the key is not found search will *not* be carried on in superspaces and aBlock will be immediately evaluated.
inheritsFrom: aNamespace: Answer whether aNamespace is one of the receiver's direct and indirect superspaces
superspace: Answer the receiver's superspace, which is nil for BindingDictionary.
withAllSuperspaces: Answer the receiver and all of its superspaces in a collection, which is none for BindingDictionary
withAllSuperspacesDo: aBlock: Invokes aBlock for the receiver and all superspaces, both direct and indirect (though a BindingDictionary does not have any).

Next: Dictionary-rehashing, Previous: Dictionary-namespace protocol, Up: Dictionary

1.62.8 Dictionary: printing

inspect: Print all the instance variables and objects in the receiver on the Transcript
printOn: aStream: Print a representation of the receiver on aStream

Next: Dictionary-removing, Previous: Dictionary-printing, Up: Dictionary

1.62.9 Dictionary: rehashing

rehash: Rehash the receiver

Next: Dictionary-storing, Previous: Dictionary-rehashing, Up: Dictionary

1.62.10 Dictionary: removing

removeAllKeysSuchThat: aBlock: Remove from the receiver all keys for which aBlock returns true.

Next: Dictionary-testing, Previous: Dictionary-removing, Up: Dictionary

1.62.11 Dictionary: storing

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

Previous: Dictionary-storing, Up: Dictionary

1.62.12 Dictionary: testing

= aDictionary: Answer whether the receiver and aDictionary are equal
hash: Answer the hash value for the receiver

Next: Directory, Previous: Dictionary, Up: Base classes

1.63 DirectedMessage

Defined in namespace Smalltalk
Superclass: Message
Category: Language-Implementation: I represent a message send: I contain the receiver, selector and arguments for a message.

Next: DirectedMessage-accessing, Up: DirectedMessage

1.63.1 DirectedMessage class: creating instances

receiver: anObject selector: aSymbol: Create a new instance of the receiver
receiver: receiverObject selector: aSymbol argument: argumentObject: Create a new instance of the receiver
receiver: anObject selector: aSymbol arguments: anArray: Create a new instance of the receiver
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

Next: DirectedMessage-basic, Previous: DirectedMessage class-creating instances, Up: DirectedMessage

1.63.2 DirectedMessage: accessing

receiver: Answer the receiver
receiver: anObject: Change the receiver

Next: DirectedMessage-multiple process, Previous: DirectedMessage-accessing, Up: DirectedMessage

1.63.3 DirectedMessage: basic

printOn: aStream: Print a representation of the receiver on aStream
send: Send the message
value: Send the message (this message provides interoperability between DirectedMessages and blocks)
value: anObject: Send the message with the sole argument anObject (this message provides interoperability between DirectedMessages and blocks)
valueWithArguments: anArray: Send the message with the arguments replaced by anArray (this message provides interoperability between DirectedMessages and blocks)

Next: DirectedMessage-saving and loading, Previous: DirectedMessage-basic, Up: DirectedMessage

1.63.4 DirectedMessage: multiple process

fork: Create a new process executing the receiver and start it
forkAt: priority: Create a new process executing the receiver with given priority and start it
newProcess: Create a new process executing the receiver in suspended state. The priority is the same as for the calling process. The receiver must not contain returns

Previous: DirectedMessage-multiple process, Up: DirectedMessage

1.63.5 DirectedMessage: saving and loading

reconstructOriginalObject: This method is used when DirectedMessages are used together with PluggableProxies (see ObjectDumper). It sends the receiver to reconstruct the object that was originally stored.

Next: DLD, Previous: DirectedMessage, Up: Base classes

1.64 Directory

Defined in namespace Smalltalk
Superclass: Object
Category: Streams-Files: I am the counterpart of File in a tree-structured file system: I can iterate through the file that I contain and construct new instances of File and Directory. In addition I have the notion of a current working directory (which alas must be a real directory and not a virtual one).

Next: Directory class-file operations, Up: Directory

1.64.1 Directory class: file name management

append: fileName to: directory: Answer the name of a file named `fileName' which resides in a directory named `directory'.
pathSeparator: Answer (as a Character) the character used to separate directory names
pathSeparatorString: Answer (in a String) the character used to separate directory names

Next: Directory class-reading system defaults, Previous: Directory class-file name management, Up: Directory

1.64.2 Directory class: file operations

allFilesMatching: aPattern do: aBlock: Invoke #allFilesMatching:do: on the current working directory.
create: dirName: Create a directory named dirName and answer it.
createTemporary: prefix: Create an empty directory whose name starts with prefix and answer it.
working: Answer the current working directory, not following symlinks.
working: dirName: Change the current working directory to dirName.

Previous: Directory class-file operations, Up: Directory

1.64.3 Directory class: reading system defaults

home: Answer the path to the user's home directory
image: Answer the path to GNU Smalltalk's image file
kernel: Answer the path in which a local version of the GNU Smalltalk kernel's Smalltalk source files were searched when the image was created.
libexec: Answer the path to GNU Smalltalk's auxiliary executables
localKernel: Answer the path to the GNU Smalltalk kernel's Smalltalk source files. Same as `Directory kernel' since GNU Smalltalk 3.0.
module: Answer the path to GNU Smalltalk's dynamically loaded modules
systemKernel: Answer the path to the installed Smalltalk kernel source files.
temporary: Answer the path in which temporary files can be created. This is read from the environment, and guessed if that fails.
userBase: Answer the base path under which file for user customization of GNU Smalltalk are stored.

Next: DumperProxy, Previous: Directory, Up: Base classes

1.65 DLD

Defined in namespace Smalltalk
Superclass: Object
Category: Language-C interface: ...and Gandalf said: “Many folk like to know beforehand what is to be set on the table; but those who have laboured to prepare the feast like to keep their secret; for wonder makes the words of praise louder.”
I am just an ancillary class used to reference some C functions. Most of my actual functionality is used by redefinitions of methods in CFunctionDescriptor.

Next: DLD class-dynamic linking, Up: DLD

1.65.1 DLD class: C call-outs

defineCFunc: aName as: aFuncAddr: Register aFuncAddr as the target for cCalls to aName.

Previous: DLD class-C call-outs, Up: DLD

1.65.2 DLD class: dynamic linking

addLibrary: library: Add library to the search path of libraries to be used by DLD.
addModule: library: Add library to the list of modules to be loaded when the image is started. The gst_initModule function in the library is called, but the library will not be put in the search path used whenever a C function is requested but not registered.
defineExternFunc: aFuncName: This method calls #primDefineExternFunc: to try to link to a function with the given name, and answers whether the linkage was successful. You can redefine this method to restrict the ability to do dynamic linking.
initialize: Private - Initialize the receiver's class variables
libraryList: Answer a copy of the search path of libraries to be used by DLD
moduleList: Answer a copy of the modules reloaded when the image is started
primDefineExternFunc: aFuncName: This method tries to link to a function with the given name, and answers whether the linkage was successful. It should not be overridden.
update: aspect: Called on startup - Make DLD re-link and reset the addresses of all the externally defined functions

Next: Duration, Previous: DLD, Up: Base classes

1.66 DumperProxy

Defined in namespace Smalltalk
Superclass: Object
Category: Streams-Files: I am an helper class for ObjectDumper. When an object cannot be saved in the standard way, you can register a subclass of me to provide special means to save that object.

Next: DumperProxy class-instance creation, Up: DumperProxy

1.66.1 DumperProxy class: accessing

acceptUsageForClass: aClass: The receiver was asked to be used as a proxy for the class aClass. Answer whether the registration is fine. By default, answer true
loadFrom: anObjectDumper: Reload a proxy stored in anObjectDumper and reconstruct the object

Next: DumperProxy-saving and restoring, Previous: DumperProxy class-accessing, Up: DumperProxy

1.66.2 DumperProxy class: instance creation

on: anObject: Answer a proxy to be used to save anObject. This method MUST be overridden and anObject must NOT be stored in the object's instance variables unless you override #dumpTo:, because that would result in an infinite loop!

Previous: DumperProxy class-instance creation, Up: DumperProxy

1.66.3 DumperProxy: saving and restoring

dumpTo: anObjectDumper: Dump the proxy to anObjectDumper – the #loadFrom: class method will reconstruct the original object.
object: Reconstruct the object stored in the proxy and answer it

Next: Error, Previous: DumperProxy, Up: Base classes

1.67 Duration

Defined in namespace Smalltalk
Superclass: Time
Category: Language-Data types: My instances represent differences between timestamps.

Next: Duration class-instance creation (non ANSI), Up: Duration

1.67.1 Duration class: instance creation

days: d: Answer a duration of `d' days
days: d hours: h minutes: m seconds: s: Answer a duration of `d' days and the given number of hours, minutes, and seconds.
initialize: Initialize the receiver's instance variables
readFrom: aStream: Parse an instance of the receiver (hours/minutes/seconds) from aStream
zero: Answer a duration of zero seconds.

Next: Duration-arithmetics, Previous: Duration class-instance creation, Up: Duration

1.67.2 Duration class: instance creation (non ANSI)

fromDays: days seconds: secs offset: unused: Answer a duration of `d' days and `secs' seconds. The last parameter is unused; this message is available for interoperability with the DateTime class.

Previous: Duration class-instance creation (non ANSI), Up: Duration

1.67.3 Duration: arithmetics

* factor: Answer a Duration that is `factor' times longer than the receiver
+ aDuration: Answer a Duration that is the sum of the receiver and aDuration's lengths.
- aDuration: Answer a Duration that is the difference of the receiver and aDuration's lengths.
/ factorOrDuration: If the parameter is a Duration, answer the ratio between the receiver and factorOrDuration. Else divide the receiver by factorOrDuration (a Number) and answer a new Duration that is correspondingly shorter.
abs: Answer a Duration that is as long as the receiver, but always in the future.
days: Answer the number of days in the receiver
negated: Answer a Duration that is as long as the receiver, but with past and future exchanged.
negative: Answer whether the receiver is in the past.
positive: Answer whether the receiver is a zero-second duration or is in the future.
printOn: aStream: Print a represention of the receiver on aStream.

Next: Exception, Previous: Duration, Up: Base classes

1.68 Error

Defined in namespace Smalltalk
Superclass: Exception
Category: Language-Exceptions: Error represents a fatal error. Instances of it are not resumable.

Up: Error

1.68.1 Error: exception description

description: Answer a textual description of the exception.
isResumable: Answer false. Error exceptions are by default unresumable; subclasses can override this method if desired.

Next: ExceptionSet, Previous: Error, Up: Base classes

1.69 Exception

Defined in namespace Smalltalk
Superclass: Signal
Category: Language-Exceptions: An Exception defines the characteristics of an exceptional event in a different way than CoreExceptions. Instead of creating an hierarchy of objects and setting attributes of the objects, you create an hierarchy of classes and override methods in those classes; instances of those classes are passed to the handlers instead of instances of the common class Signal.
Internally, Exception and every subclass of it hold onto a CoreException, so the two mechanisms are actually interchangeable.

Next: Exception class-creating ExceptionCollections, Up: Exception

1.69.1 Exception class: comparison

goodness: anException: Answer how good the receiver is at handling the given exception. A negative value indicates that the receiver is not able to handle the exception.
handles: anException: Answer whether the receiver handles `anException'.

Next: Exception class-initialization, Previous: Exception class-comparison, Up: Exception

1.69.2 Exception class: creating ExceptionCollections

, aTrappableEvent: Answer an ExceptionCollection containing all the exceptions in the receiver and all the exceptions in aTrappableEvent

Next: Exception class-instance creation, Previous: Exception class-creating ExceptionCollections, Up: Exception

1.69.3 Exception class: initialization

initialize: Initialize the `links' between the core exception handling system and the ANSI exception handling system.

Next: Exception class-interoperability with TrappableEvents, Previous: Exception class-initialization, Up: Exception

1.69.4 Exception class: instance creation

new: Create an instance of the receiver, which you will be able to signal later.
signal: Create an instance of the receiver, give it default attributes, and signal it immediately.
signal: messageText: Create an instance of the receiver, set its message text, and signal it immediately.

Next: Exception-comparison, Previous: Exception class-instance creation, Up: Exception

1.69.5 Exception class: interoperability with TrappableEvents

allExceptionsDo: aBlock: Private - Pass the coreException to aBlock
coreException: Private - Answer the coreException which represents instances of the receiver

Next: Exception-exception description, Previous: Exception class-interoperability with TrappableEvents, Up: Exception

1.69.6 Exception: comparison

= anObject: Answer whether the receiver is equal to anObject. This is true if either the receiver or its coreException are the same object as anObject.
hash: Answer an hash value for the receiver.

Next: Exception-exception signaling, Previous: Exception-comparison, Up: Exception

1.69.7 Exception: exception description

defaultAction: Execute the default action that is attached to the receiver.
description: Answer a textual description of the exception.
isResumable: Answer true. Exceptions are by default resumable.

Previous: Exception-exception description, Up: Exception

1.69.8 Exception: exception signaling

signal: Raise the exceptional event represented by the receiver
signal: messageText: Raise the exceptional event represented by the receiver, setting its message text to messageText.

Next: False, Previous: Exception, Up: Base classes

1.70 ExceptionSet

Defined in namespace Smalltalk
Superclass: Kernel.TrappableEvent
Category: Language-Exceptions: My instances are not real exceptions: they can only be used as arguments to #on:do:... methods in BlockClosure. They act as shortcuts that allows you to use the same handler for many exceptions without having to write duplicate code

Next: ExceptionSet-enumerating, Up: ExceptionSet

1.70.1 ExceptionSet class: instance creation

new: Private - Answer a new, empty ExceptionSet

Previous: ExceptionSet class-instance creation, Up: ExceptionSet

1.70.2 ExceptionSet: enumerating

allExceptionsDo: aBlock: Private - Evaluate aBlock for every exception in the receiver. Answer the receiver
goodness: exception: Answer how good the receiver is at handling the given exception. A negative value indicates that the receiver is not able to handle the exception.
handles: exception: Answer whether the receiver handles `exception'.

Next: File, Previous: ExceptionSet, Up: Base classes

1.71 False

Defined in namespace Smalltalk
Superclass: Boolean
Category: Language-Data types: I always tell lies. I have a single instance in the system, which represents the value false.

Next: False-C hacks, Up: False

1.71.1 False: basic

& aBoolean: We are false – anded with anything, we always answer false
and: aBlock: We are false – anded with anything, we always answer false
eqv: aBoolean: Answer whether the receiver and aBoolean represent the same boolean value
ifFalse: falseBlock: We are false – evaluate the falseBlock
ifFalse: falseBlock ifTrue: trueBlock: We are false – evaluate the falseBlock
ifTrue: trueBlock: We are false – answer nil
ifTrue: trueBlock ifFalse: falseBlock: We are false – evaluate the falseBlock
not: We are false – answer true
or: aBlock: We are false – ored with anything, we always answer the other operand, so evaluate aBlock
xor: aBoolean: Answer whether the receiver and aBoolean represent different boolean values
| aBoolean: We are false – ored with anything, we always answer the other operand

Next: False-printing, Previous: False-basic, Up: False

1.71.2 False: C hacks

asCBooleanValue: Answer `0'.

Previous: False-C hacks, Up: False

1.71.3 False: printing

printOn: aStream: Print a representation of the receiver on aStream

Next: FileDescriptor, Previous: False, Up: Base classes

1.72 File

Defined in namespace Smalltalk
Superclass: FilePath
Category: Streams-Files: I enable access to the properties of files that are on disk.

Next: File class-file operations, Up: File

1.72.1 File class: C functions

errno: Answer the current value of C errno.
stringError: errno: Answer C strerror's result for errno.

Next: File class-initialization, Previous: File class-C functions, Up: File

1.72.2 File class: file operations

checkError: Return whether an error had been reported or not. If there had been one, raise an exception too
checkError: errno: The error with the C code `errno' has been reported. If errno >= 1, raise an exception
remove: fileName: Remove the file with the given path name
rename: oldFileName to: newFileName: Rename the file with the given path name oldFileName to newFileName
symlink: srcName as: destName: Create a symlink for the srcName file with the given path name
symlink: destName from: srcName: Create a symlink named destName file from the given path (relative to destName)
touch: fileName: Update the timestamp of the file with the given path name.

Next: File class-instance creation, Previous: File class-file operations, Up: File

1.72.3 File class: initialization

initialize: Initialize the receiver's class variables

Next: File class-reading system defaults, Previous: File class-initialization, Up: File

1.72.4 File class: instance creation

name: aName: Answer a new file with the given path. The path is turned into an absolute path.
path: aString: Answer a new file with the given path. The path is not validated until some of the fields of the newly created objects are accessed

Next: File class-testing, Previous: File class-instance creation, Up: File

1.72.5 File class: reading system defaults

executable: Answer the full path to the executable being run.
image: Answer the full path to the image being used.

Next: File-accessing, Previous: File class-reading system defaults, Up: File

1.72.6 File class: testing

exists: fileName: Answer whether a file with the given name exists
isAccessible: fileName: Answer whether a directory with the given name exists and can be accessed
isExecutable: fileName: Answer whether a file with the given name exists and can be executed
isReadable: fileName: Answer whether a file with the given name exists and is readable
isWriteable: fileName: Answer whether a file with the given name exists and is writeable

Next: File-basic, Previous: File class-testing, Up: File

1.72.7 File: accessing

asString: Answer the name of the file identified by the receiver
at: aString: Answer a File or Directory object as appropriate for a file named 'aName' in the directory represented by the receiver.
creationTime: Answer the creation time of the file identified by the receiver. On some operating systems, this could actually be the last change time (the `last change time' has to do with permissions, ownership and the like).
isDirectory: Answer whether the file is a directory.
isSocket: Answer whether the file is an AF_UNIX socket.
isSymbolicLink: Answer whether the file is a symbolic link.
lastAccessTime: Answer the last access time of the file identified by the receiver
lastChangeTime: Answer the last change time of the file identified by the receiver (the `last change time' has to do with permissions, ownership and the like). On some operating systems, this could actually be the file creation time.
lastModifyTime: Answer the last modify time of the file identified by the receiver (the `last modify time' has to do with the actual file contents).
mode: Answer the permission bits for the file identified by the receiver
mode: anInteger: Set the permission bits for the file identified by the receiver to be anInteger.
name: Answer the name of the file identified by the receiver
pathTo: destName: Compute the relative path from the receiver to destName.
refresh: Refresh the statistics for the receiver
size: Answer the size of the file identified by the receiver

Next: File-directory operations, Previous: File-accessing, Up: File

1.72.8 File: basic

= aFile: Answer whether the receiver represents the same file as the receiver.
hash: Answer a hash value for the receiver.

Next: File-file name management, Previous: File-basic, Up: File

1.72.9 File: directory operations

createDirectory: Create the receiver as a directory.
namesDo: aBlock: Evaluate aBlock once for each file in the directory represented by the receiver, passing its name. aBlock should not return.

Next: File-file operations, Previous: File-directory operations, Up: File

1.72.10 File: file name management

full: Answer the full name of the receiver, resolving the `.' and `..' directory entries, and answer the result. Answer nil if the name is invalid (such as '/usr/../../badname')

Next: File-still unclassified, Previous: File-file name management, Up: File

1.72.11 File: file operations

lastAccessTime: accessDateTime lastModifyTime: modifyDateTime: Set the receiver's timestamps to be accessDateTime and modifyDateTime.
open: class mode: mode ifFail: aBlock: Open the receiver in the given mode (as answered by FileStream's class constant methods)
owner: ownerString group: groupString: Set the receiver's owner and group to be ownerString and groupString.
pathFrom: dir: Compute the relative path from the directory dirName to the receiver
remove: Remove the file with the given path name
renameTo: newFileName: Rename the file with the given path name to newFileName
symlinkAs: destName: Create destName as a symbolic link of the receiver. The appropriate relative path is computed automatically.
symlinkFrom: srcName: Create the receiver as a symlink from path destName

Next: File-testing, Previous: File-file operations, Up: File

1.72.12 File: still unclassified

, aName: Answer an object of the same kind as the receiver, whose name is suffixed with aName.

Previous: File-still unclassified, Up: File

1.72.13 File: testing

exists: Answer whether a file with the name contained in the receiver does exist.
isAbsolute: Answer whether the receiver identifies an absolute path.
isAccessible: Answer whether a directory with the name contained in the receiver does exist and is accessible
isExecutable: Answer whether a file with the name contained in the receiver does exist and is executable
isFileSystemPath: Answer whether the receiver corresponds to a real filesystem path.
isReadable: Answer whether a file with the name contained in the receiver does exist and is readable
isWriteable: Answer whether a file with the name contained in the receiver does exist and is writeable

Next: FilePath, Previous: File, Up: Base classes

1.73 FileDescriptor

Defined in namespace Smalltalk
Superclass: Stream
Category: Streams-Files: My instances are what conventional programmers think of as files. My instance creation methods accept the name of a disk file (or any named file object, such as /dev/rmt0 on UNIX or MTA0: on VMS). In addition, they accept a virtual filesystem path like `configure.gz#ugz' which can be used to transparently extract or decompress files from archives, or do arbitrary processing on the files.