See explanation in my prevous mail '1.2: class var #Instance not
allowed'.

2 February 2011 12:23:58 pm

VM: unix - i686 - linux-gnu - Croquet Closure Cog VM [CoInterpreter
VMMaker-oscog.35]
Image: Pharo1.2rc2 [Latest update: #12329]

SecurityManager state:
Restricted: false
FileAccess: true
SocketAccess: true
Working Dir
/home/mivsek/Smalltalk/pharo/PharoOneClick1.2.app/Contents/Resources
Trusted Dir
/home/mivsek/Smalltalk/pharo/PharoOneClick1.2.app/Contents/Resources/sec
ure
Untrusted Dir
/home/mivsek/Smalltalk/pharo/PharoOneClick1.2.app/Contents/Resources/My
Squeak

[:var | (self bindingOf: var) notNil
                ifTrue: [DuplicatedVariableError new variable: var;
                                 signal: var , ' is defined elsewhere'.
                        conflicts := true]] in AIDASite class(Class)>>declare:
        Receiver: AIDASite
        Arguments and temporary variables: 
                conflicts:      #Instance
                var:    #(false)
        Receiver's instance variables: 
                superclass:     SwazooSite
                methodDict:     a MethodDictionary()
                format:         154
                instanceVariables:      #('style' 'settings' 'systemServices'
'userServices' 'timest...etc...
                organization:   nil
                subclasses:     nil
                name:   #AIDASite
                classPool:      nil
                sharedPools:    nil
                environment:    nil
                category:       nil
                traitComposition:       nil
                localSelectors:         nil

Array(SequenceableCollection)>>do:
        Receiver: #(#Default #Dialect #Instance #RandomGen #SloveneCharacters)
        Arguments and temporary variables: 
                aBlock:         [:var | (self bindingOf: var) notNil
                ifTrue: [DuplicatedVariableError...etc...
                index:  3
                indexLimiT:     5
        Receiver's instance variables: 
#(#Default #Dialect #Instance #RandomGen #SloveneCharacters)

AIDASite class(Class)>>declare:
        Receiver: AIDASite
        Arguments and temporary variables: 
                varString:      'Default Dialect Instance RandomGen 
SloveneCharacters'
                newVars:        #(#Default #Dialect #Instance #RandomGen 
#SloveneCharacters)
                conflicts:      #(false)
        Receiver's instance variables: 
                superclass:     SwazooSite
                methodDict:     a MethodDictionary()
                format:         154
                instanceVariables:      #('style' 'settings' 'systemServices'
'userServices' 'timest...etc...
                organization:   nil
                subclasses:     nil
                name:   #AIDASite
                classPool:      nil
                sharedPools:    nil
                environment:    nil
                category:       nil
                traitComposition:       nil
                localSelectors:         nil

[| newCategory oldCategory needNew force organization |
unsafe
                ifFalse: [(self validateSuperclass: newSuper forSubclass: 
oldClass)
                                ifFalse: [^ nil].
                        (self
                                        validateInstvars: instVars
                                        from: oldClass
                                        forSuper: newSuper)
                                ifFalse: [^ nil].
                        (self
                                        validateClassvars: classVars
                                        from: oldClass
                                        forSuper: newSuper)
                                ifFalse: [^ nil].
                        (self
                                        validateSubclassFormat: type
                                        from: oldClass
                                        forSuper: newSuper
                                        extra: instVars size)
                                ifFalse: [^ nil]].
        needNew := self
                                needsSubclassOf: newSuper
                                type: type
                                instanceVariables: instVars
                                from: oldClass.
        needNew
                ifNil: [^ nil].
        (needNew
                        and: [unsafe not])
                ifTrue: [(self tooDangerousClasses includes: oldClass name)
                                ifTrue: [self error: oldClass name , ' cannot 
be changed'].
                        (oldClass ~~ nil
                                        and: [oldClass shouldNotBeRedefined])
                                ifTrue: [self notify: oldClass name asText 
allBold , ' should not be
redefined. \Proceed to store over it.' withCRs]].
        needNew
                ifTrue: [newClass := self
                                                newSubclassOf: newSuper
                                                type: type
                                                instanceVariables: instVars
                                                from: oldClass.
                        newClass
                                ifNil: [^ nil].
                        newClass setName: className]
                ifFalse: [newClass := oldClass].
        force := (newClass declare: classVarString)
                                | (newClass sharing: poolString).
        newCategory := category asSymbol.
        organization := environ
                                ifNotNil: [environ organization].
        oldClass isNil
                ifFalse: [oldCategory := (organization categoryOfElement: 
oldClass
name) asSymbol].
        organization classify: newClass name under: newCategory.
        newClass environment: environ.
        newClass := self
                                recompile: force
                                from: oldClass
                                to: newClass
                                mutate: false.
        (environ
                        at: newClass name
                        ifAbsent: [])
                        == newClass
                ifFalse: [environ at: newClass name put: newClass.
                        Smalltalk globals flushClassNameCache].
        copyOfOldTraitComposition
                ifNotNil: [newClass setTraitComposition: 
copyOfOldTraitComposition].
        copyOfOldClassTraitComposition
                ifNotNil: [newClass class setTraitComposition:
copyOfOldClassTraitComposition].
        newClass doneCompiling.
        oldClass isNil
                ifTrue: [SystemChangeNotifier uniqueInstance classAdded: 
newClass
inCategory: newCategory.
                        ^ newClass].
        newCategory ~= oldCategory
                ifTrue: [SystemChangeNotifier uniqueInstance
                                class: newClass
                                recategorizedFrom: oldCategory
                                to: category]
                ifFalse: [SystemChangeNotifier uniqueInstance
classDefinitionChangedFrom: copyOfOldClass to: newClass]] in
ClassBuilder>>name:inEnvironment:subclassOf:type:instanceVariableNames:c
lassVariableNames:poolDictionaries:category:unsafe:
        Receiver: a ClassBuilder
        Arguments and temporary variables: 
                className:      #AIDASite
                newSuper:       SwazooSite
                type:   #normal
                classVarString:         'Default Dialect Instance RandomGen
SloveneCharacters'
                poolString:     ''
                category:       #'Aida-Core'
                unsafe:         false
                oldClass:       nil
                instVars:       #('style' 'settings' 'systemServices' 
'userServices'
'timestamps' 'co...etc...
                classVars:      #(#Default #Dialect #Instance #RandomGen
#SloveneCharacters)
                copyOfOldClass:         nil
                copyOfOldTraitComposition:      nil
                copyOfOldClassTraitComposition:         nil
                newClass:       an Array(AIDASite)
                newCategory:    nil
                oldCategory:    nil
                needNew:        true
                force:  nil
                organization:   nil
        Receiver's instance variables: 
                environ:        a SystemDictionary(lots of globals)
                classMap:       nil
                instVarMap:     an IdentityDictionary()
                progress:       nil
                maxClassIndex:  nil
                currentClassIndex:      nil

BlockClosure>>ensure:
        Receiver: [| newCategory oldCategory needNew force organization |
unsafe
                ifFalse: [(self validateS...etc...
        Arguments and temporary variables: 
                aBlock:         [copyOfOldClass
                ifNotNil: [copyOfOldClass superclass removeSubclass: ...etc...
                complete:       nil
                returnValue:    nil
        Receiver's instance variables: 
                outerContext: 
ClassBuilder>>name:inEnvironment:subclassOf:type:instanceVariable...etc.
..
                startpc:        348
                numArgs:        0

ClassBuilder>>name:inEnvironment:subclassOf:type:instanceVariableNames:c
lassVariableNames:poolDictionaries:category:unsafe:
        Receiver: a ClassBuilder
        Arguments and temporary variables: 
                className:      #AIDASite
                env:    a SystemDictionary(lots of globals)
                newSuper:       SwazooSite
                type:   #normal
                instVarString:  'style settings systemServices userServices 
timestamps
counters'...etc...
                classVarString:         'Default Dialect Instance RandomGen
SloveneCharacters'
                poolString:     ''
                category:       #'Aida-Core'
                unsafe:         false
                oldClass:       nil
                instVars:       #('style' 'settings' 'systemServices' 
'userServices'
'timestamps' 'co...etc...
                classVars:      #(#Default #Dialect #Instance #RandomGen
#SloveneCharacters)
                copyOfOldClass:         nil
                copyOfOldTraitComposition:      nil
                copyOfOldClassTraitComposition:         nil
                newClass:       an Array(AIDASite)
        Receiver's instance variables: 
                environ:        a SystemDictionary(lots of globals)
                classMap:       nil
                instVarMap:     an IdentityDictionary()
                progress:       nil
                maxClassIndex:  nil
                currentClassIndex:      nil

ClassBuilder>>name:inEnvironment:subclassOf:type:instanceVariableNames:c
lassVariableNames:poolDictionaries:category:
        Receiver: a ClassBuilder
        Arguments and temporary variables: 
                className:      #AIDASite
                env:    a SystemDictionary(lots of globals)
                newSuper:       SwazooSite
                type:   #normal
                instVarString:  'style settings systemServices userServices 
timestamps
counters'...etc...
                classVarString:         'Default Dialect Instance RandomGen
SloveneCharacters'
                poolString:     ''
                category:       #'Aida-Core'
        Receiver's instance variables: 
                environ:        a SystemDictionary(lots of globals)
                classMap:       nil
                instVarMap:     an IdentityDictionary()
                progress:       nil
                maxClassIndex:  nil
                currentClassIndex:      nil

MCClassDefinition>>createClass
        Receiver: a MCClassDefinition(AIDASite)
        Arguments and temporary variables: 
                superClass:     SwazooSite
                class:  nil
                composition:    nil
        Receiver's instance variables: 
                name:   #AIDASite
                superclassName:         #SwazooSite
                variables:      an OrderedCollection(a 
MCInstanceVariableDefinition(style)
a MCInsta...etc...
                category:       #'Aida-Core'
                type:   #normal
                comment:        'AIDASite as the most important class is an 
Aida/Web website
with its ...etc...
                commentStamp:   '<historical>'
                traitComposition:       nil
                classTraitComposition:  nil

MCClassDefinition>>load
        Receiver: a MCClassDefinition(AIDASite)
        Arguments and temporary variables: 
                class:  nil
        Receiver's instance variables: 
                name:   #AIDASite
                superclassName:         #SwazooSite
                variables:      an OrderedCollection(a 
MCInstanceVariableDefinition(style)
a MCInsta...etc...
                category:       #'Aida-Core'
                type:   #normal
                comment:        'AIDASite as the most important class is an 
Aida/Web website
with its ...etc...
                commentStamp:   '<historical>'
                traitComposition:       nil
                classTraitComposition:  nil

MCClassDefinition(MCDefinition)>>addMethodAdditionTo:
        Receiver: a MCClassDefinition(AIDASite)
        Arguments and temporary variables: 
                aCollection:    an OrderedCollection(a MethodAddition a 
MethodAddition a
MethodAdd...etc...
        Receiver's instance variables: 
                name:   #AIDASite
                superclassName:         #SwazooSite
                variables:      an OrderedCollection(a 
MCInstanceVariableDefinition(style)
a MCInsta...etc...
                category:       #'Aida-Core'
                type:   #normal
                comment:        'AIDASite as the most important class is an 
Aida/Web website
with its ...etc...
                commentStamp:   '<historical>'
                traitComposition:       nil
                classTraitComposition:  nil

[:ea | ea addMethodAdditionTo: methodAdditions] in [additions
                do: [:ea | self loadClassDefinition: ea]
                displayingProgress: 'Loading classes...'.
        additions
                do: [:ea | self tryToLoad: ea]
                displayingProgress: 'Compiling methods...'.
        removals
                do: [:ea | ea unload]
                displayingProgress: 'Cleaning up...'.
        self shouldWarnAboutErrors
                ifTrue: [self warnAboutErrors].
        errorDefinitions
                do: [:ea | ea addMethodAdditionTo: methodAdditions]
                displayingProgress: 'Reloading...'.
        methodAdditions
                do: [:each | each installMethod].
        methodAdditions
                do: [:each | each notifyObservers].
        additions
                do: [:ea | ea
                                postloadOver: (self obsoletionFor: ea)]
                displayingProgress: 'Initializing...'] in [[additions
                do: [:ea | self loadClassDefinition: ea]
                displayingProgress: 'Loading classes...'.
        additions
                do: [:ea | self tryToLoad: ea]
                displayingProgress: 'Compiling methods...'.
        removals
                do: [:ea | ea unload]
                displayingProgress: 'Cleaning up...'.
        self shouldWarnAboutErrors
                ifTrue: [self warnAboutErrors].
        errorDefinitions
                do: [:ea | ea addMethodAdditionTo: methodAdditions]
                displayingProgress: 'Reloading...'.
        methodAdditions
                do: [:each | each installMethod].
        methodAdditions
                do: [:each | each notifyObservers].
        additions
                do: [:ea | ea
                                postloadOver: (self obsoletionFor: ea)]
                displayingProgress: 'Initializing...']
                on: InMidstOfFileinNotification
                do: [:n | n resume: true]] in MCPackageLoader>>basicLoad
        Receiver: a MCPackageLoader
        Arguments and temporary variables: 
                ea:     a MCClassDefinition(AIDASite)
        Receiver's instance variables: 
                requirements:   #()
                unloadableDefinitions:  a SortedCollection()
                obsoletions:    a Dictionary()
                additions:      an OrderedCollection(a
MCOrganizationDefinition(#(#'Aida-Admin' #'Ai...etc...
                removals:       an OrderedCollection()
                errorDefinitions:       an OrderedCollection(a 
MCClassDefinition(AIDASite)
a MCClassD...etc...
                provisions:     a Set(#UTF8DecomposedTextConverter
#PackageMethodNodeExample #Resou...etc...
                methodAdditions:        an OrderedCollection(a MethodAddition a
MethodAddition a Metho...etc...

[:each | 
| newLabel |
(count = 0
                        or: [count + 1 = size
                                        or: [(Time millisecondsSince: 
lastUpdate)
                                                        >= msecs]])
                ifTrue: [bar value: count.
                        oldLabel = (newLabel := (labelBlock value: each)
                                                                ifNil: 
[oldLabel])
                                ifFalse: [ProgressNotification signal: '' 
extra: (oldLabel :=
newLabel)].
                        lastUpdate := Time millisecondClockValue].
        aBlock value: each.
        count := count + 1] in [:bar | self
                do: [:each | 
                        | newLabel |
                        (count = 0
                                        or: [count + 1 = size
                                                        or: [(Time 
millisecondsSince: lastUpdate)
                                                                        >= 
msecs]])
                                ifTrue: [bar value: count.
                                        oldLabel = (newLabel := (labelBlock 
value: each)
                                                                                
ifNil: [oldLabel])
                                                ifFalse: [ProgressNotification 
signal: '' extra: (oldLabel :=
newLabel)].
                                        lastUpdate := Time 
millisecondClockValue].
                        aBlock value: each.
                        count := count + 1]] in
OrderedCollection(Collection)>>do:displayingProgress:every:
        Receiver: an OrderedCollection(a MCClassDefinition(AIDASite) a
MCClassDefinition(AIDASite) a MCMetho...etc...
        Arguments and temporary variables: 
<<error during printing>
        Receiver's instance variables: 
                array:  an Array(a MCClassDefinition(AIDASite) a
MCClassDefinition(AIDASite) a M...etc...
                firstIndex:     1
                lastIndex:      207

OrderedCollection>>do:
        Receiver: an OrderedCollection(a MCClassDefinition(AIDASite) a
MCClassDefinition(AIDASite) a MCMetho...etc...
        Arguments and temporary variables: 
                aBlock:         [:each | 
| newLabel |
(count = 0
                        or: [count + 1 = size
                                        or: [(T...etc...
                index:  1
        Receiver's instance variables: 
                array:  an Array(a MCClassDefinition(AIDASite) a
MCClassDefinition(AIDASite) a M...etc...
                firstIndex:     1
                lastIndex:      207

[:bar | self
                do: [:each | 
                        | newLabel |
                        (count = 0
                                        or: [count + 1 = size
                                                        or: [(Time 
millisecondsSince: lastUpdate)
                                                                        >= 
msecs]])
                                ifTrue: [bar value: count.
                                        oldLabel = (newLabel := (labelBlock 
value: each)
                                                                                
ifNil: [oldLabel])
                                                ifFalse: [ProgressNotification 
signal: '' extra: (oldLabel :=
newLabel)].
                                        lastUpdate := Time 
millisecondClockValue].
                        aBlock value: each.
                        count := count + 1]] in
OrderedCollection(Collection)>>do:displayingProgress:every:
        Receiver: an OrderedCollection(a MCClassDefinition(AIDASite) a
MCClassDefinition(AIDASite) a MCMetho...etc...
        Arguments and temporary variables: 
<<error during printing>
        Receiver's instance variables: 
                array:  an Array(a MCClassDefinition(AIDASite) a
MCClassDefinition(AIDASite) a M...etc...
                firstIndex:     1
                lastIndex:      207

[result := workBlock value: progress] in [[result := workBlock value:
progress]
                on: ProgressNotification
                do: [:ex | 
                        ex extraParam isString
                                ifTrue: [SystemProgressMorph uniqueInstance 
labelAt: progress put:
ex extraParam].
                        ex resume]] in 
ProgressInitiationException>>defaultMorphicAction
        Receiver: ProgressInitiationException: 
        Arguments and temporary variables: 
                progress:       [:barValArg | 
| barVal return newBarSize |
barVal := barValArg.
        ret...etc...
                result:         #(nil)
        Receiver's instance variables: 
                messageText:    nil
                tag:    nil
                signalContext:  ProgressInitiationException(Exception)>>signal
                handlerContext:         nil
                outerContext:   nil
                workBlock:      [:bar | self
                do: [:each | 
                        | newLabel |
                        (count = 0
                                        or: ...etc...
                maxVal:         207
                minVal:         0
                aPoint:         311@323
                progressTitle:  ''

BlockClosure>>on:do:
        Receiver: [result := workBlock value: progress]
        Arguments and temporary variables: 
                exception:      ProgressNotification
                handlerAction:  [:ex | 
ex extraParam isString
                ifTrue: [SystemProgressMorph un...etc...
                handlerActive:  true
        Receiver's instance variables: 
                outerContext:   [[result := workBlock value: progress]
                on: ProgressNotification...etc...
                startpc:        83
                numArgs:        0

[[result := workBlock value: progress]
                on: ProgressNotification
                do: [:ex | 
                        ex extraParam isString
                                ifTrue: [SystemProgressMorph uniqueInstance 
labelAt: progress put:
ex extraParam].
                        ex resume]] in 
ProgressInitiationException>>defaultMorphicAction
        Receiver: ProgressInitiationException: 
        Arguments and temporary variables: 
                progress:       [:barValArg | 
| barVal return newBarSize |
barVal := barValArg.
        ret...etc...
                result:         #(nil)
        Receiver's instance variables: 
                messageText:    nil
                tag:    nil
                signalContext:  ProgressInitiationException(Exception)>>signal
                handlerContext:         nil
                outerContext:   nil
                workBlock:      [:bar | self
                do: [:each | 
                        | newLabel |
                        (count = 0
                                        or: ...etc...
                maxVal:         207
                minVal:         0
                aPoint:         311@323
                progressTitle:  ''

BlockClosure>>ensure:
        Receiver: [[result := workBlock value: progress]
                on: ProgressNotification
                do: [:ex | 
                        ex extr...etc...
        Arguments and temporary variables: 
                aBlock:         [SystemProgressMorph close: progress]
                complete:       nil
                returnValue:    nil
        Receiver's instance variables: 
                outerContext:   
ProgressInitiationException>>defaultMorphicAction
                startpc:        77
                numArgs:        0

ProgressInitiationException>>defaultMorphicAction
        Receiver: ProgressInitiationException: 
        Arguments and temporary variables: 
                progress:       [:barValArg | 
| barVal return newBarSize |
barVal := barValArg.
        ret...etc...
                result:         #(nil)
        Receiver's instance variables: 
                messageText:    nil
                tag:    nil
                signalContext:  ProgressInitiationException(Exception)>>signal
                handlerContext:         nil
                outerContext:   nil
                workBlock:      [:bar | self
                do: [:each | 
                        | newLabel |
                        (count = 0
                                        or: ...etc...
                maxVal:         207
                minVal:         0
                aPoint:         311@323
                progressTitle:  ''

MorphicUIManager>>progressInitiationExceptionDefaultAction:
        Receiver: a MorphicUIManager
        Arguments and temporary variables: 
                anException:    ProgressInitiationException: 
        Receiver's instance variables: 
                interactiveParser:      nil

ProgressInitiationException>>defaultAction
        Receiver: ProgressInitiationException: 
        Arguments and temporary variables: 

        Receiver's instance variables: 
                messageText:    nil
                tag:    nil
                signalContext:  ProgressInitiationException(Exception)>>signal
                handlerContext:         nil
                outerContext:   nil
                workBlock:      [:bar | self
                do: [:each | 
                        | newLabel |
                        (count = 0
                                        or: ...etc...
                maxVal:         207
                minVal:         0
                aPoint:         311@323
                progressTitle:  ''

UndefinedObject>>handleSignal:
        Receiver: nil
        Arguments and temporary variables: 
                exception:      ProgressInitiationException: 
        Receiver's instance variables: 
nil

MethodContext(ContextPart)>>handleSignal:
        Receiver: BlockClosure>>on:do:
        Arguments and temporary variables: 
                exception:      ProgressInitiationException: 
                val:    nil
        Receiver's instance variables: 
                sender:         PasteUpMorph>>becomeActiveDuring:
                pc:     17
                stackp:         3
                method:         (BlockClosure>>#on:do: "a 
CompiledMethod(17039360)")
                closureOrNil:   nil
                receiver:       [aBlock value]

MethodContext(ContextPart)>>handleSignal:
        Receiver: BlockClosure>>on:do:
        Arguments and temporary variables: 
                exception:      ProgressInitiationException: 
                val:    nil
        Receiver's instance variables: 
                sender:         SmalltalkEditor>>evaluateSelection
                pc:     17
                stackp:         3
                method:         (BlockClosure>>#on:do: "a 
CompiledMethod(17039360)")
                closureOrNil:   nil
                receiver:       [rcvr class evaluatorClass new
                evaluate: self selectionForDoitAsStr...etc...

MethodContext(ContextPart)>>handleSignal:
        Receiver: BlockClosure>>on:do:
        Arguments and temporary variables: 
                exception:      ProgressInitiationException: 
                val:    nil
        Receiver's instance variables: 
                sender:         [[result := workBlock value: progress]
                on: ProgressNotification
                do:...etc...
                pc:     17
                stackp:         3
                method:         (BlockClosure>>#on:do: "a 
CompiledMethod(17039360)")
                closureOrNil:   nil
                receiver:       [result := workBlock value: progress]

MethodContext(ContextPart)>>handleSignal:
        Receiver: BlockClosure>>on:do:
        Arguments and temporary variables: 
                exception:      ProgressInitiationException: 
                val:    nil
        Receiver's instance variables: 
                sender:         [[result := workBlock value: progress]
                on: ProgressNotification
                do:...etc...
                pc:     17
                stackp:         3
                method:         (BlockClosure>>#on:do: "a 
CompiledMethod(17039360)")
                closureOrNil:   nil
                receiver:       [result := workBlock value: progress]

MethodContext(ContextPart)>>handleSignal:
        Receiver: BlockClosure>>on:do:
        Arguments and temporary variables: 
                exception:      ProgressInitiationException: 
                val:    nil
        Receiver's instance variables: 
                sender:         [[additions
                do: [:ea | self loadClassDefinition: ea]
                displayingProg...etc...
                pc:     17
                stackp:         3
                method:         (BlockClosure>>#on:do: "a 
CompiledMethod(17039360)")
                closureOrNil:   nil
                receiver:       [additions
                do: [:ea | self loadClassDefinition: ea]
                displayingPro...etc...

ProgressInitiationException(Exception)>>signal
        Receiver: ProgressInitiationException: 
        Arguments and temporary variables: 

        Receiver's instance variables: 
                messageText:    nil
                tag:    nil
                signalContext:  ProgressInitiationException(Exception)>>signal
                handlerContext:         nil
                outerContext:   nil
                workBlock:      [:bar | self
                do: [:each | 
                        | newLabel |
                        (count = 0
                                        or: ...etc...
                maxVal:         207
                minVal:         0
                aPoint:         311@323
                progressTitle:  ''

ProgressInitiationException>>display:at:from:to:during:
        Receiver: ProgressInitiationException: 
        Arguments and temporary variables: 
                argString:      ''
                argPoint:       311@323
                argMinVal:      0
                argMaxVal:      207
                argWorkBlock:   [:bar | self
                do: [:each | 
                        | newLabel |
                        (count = 0
                                        o...etc...
        Receiver's instance variables: 
                messageText:    nil
                tag:    nil
                signalContext:  ProgressInitiationException(Exception)>>signal
                handlerContext:         nil
                outerContext:   nil
                workBlock:      [:bar | self
                do: [:each | 
                        | newLabel |
                        (count = 0
                                        or: ...etc...
                maxVal:         207
                minVal:         0
                aPoint:         311@323
                progressTitle:  ''

ProgressInitiationException class>>display:at:from:to:during:
        Receiver: ProgressInitiationException
        Arguments and temporary variables: 
                aString:        ''
                aPoint:         311@323
                minVal:         0
                maxVal:         207
                workBlock:      [:bar | self
                do: [:each | 
                        | newLabel |
                        (count = 0
                                        or: ...etc...
        Receiver's instance variables: 
                superclass:     Exception
                methodDict:     a
MethodDictionary(#defaultAction->(ProgressInitiationException>>#d...etc.
..
                format:         150
                instanceVariables:      #('workBlock' 'maxVal' 'minVal' 'aPoint'
'progressTitle')
                organization:   ('*Morphic' defaultMorphicAction)
('accessing' maxVal minVal poin...etc...
                subclasses:     nil
                name:   #ProgressInitiationException
                classPool:      nil
                sharedPools:    nil
                environment:    a SystemDictionary(lots of globals)
                category:       #'UIManager-Support'
                traitComposition:       {}
                localSelectors:         nil

ByteString(String)>>displayProgressAt:from:to:during:
        Receiver: ''
        Arguments and temporary variables: 
                aPoint:         311@323
                minVal:         0
                maxVal:         207
                workBlock:      [:bar | self
                do: [:each | 
                        | newLabel |
                        (count = 0
                                        or: ...etc...
        Receiver's instance variables: 
''

OrderedCollection(Collection)>>do:displayingProgress:every:
        Receiver: an OrderedCollection(a MCClassDefinition(AIDASite) a
MCClassDefinition(AIDASite) a MCMetho...etc...
        Arguments and temporary variables: 
<<error during printing>
        Receiver's instance variables: 
                array:  an Array(a MCClassDefinition(AIDASite) a
MCClassDefinition(AIDASite) a M...etc...
                firstIndex:     1
                lastIndex:      207

OrderedCollection(Collection)>>do:displayingProgress:
        Receiver: an OrderedCollection(a MCClassDefinition(AIDASite) a
MCClassDefinition(AIDASite) a MCMetho...etc...
        Arguments and temporary variables: 
                aBlock:         [:ea | ea addMethodAdditionTo: methodAdditions]
                aStringOrBlock:         'Reloading...'
        Receiver's instance variables: 
                array:  an Array(a MCClassDefinition(AIDASite) a
MCClassDefinition(AIDASite) a M...etc...
                firstIndex:     1
                lastIndex:      207

[additions
                do: [:ea | self loadClassDefinition: ea]
                displayingProgress: 'Loading classes...'.
        additions
                do: [:ea | self tryToLoad: ea]
                displayingProgress: 'Compiling methods...'.
        removals
                do: [:ea | ea unload]
                displayingProgress: 'Cleaning up...'.
        self shouldWarnAboutErrors
                ifTrue: [self warnAboutErrors].
        errorDefinitions
                do: [:ea | ea addMethodAdditionTo: methodAdditions]
                displayingProgress: 'Reloading...'.
        methodAdditions
                do: [:each | each installMethod].
        methodAdditions
                do: [:each | each notifyObservers].
        additions
                do: [:ea | ea
                                postloadOver: (self obsoletionFor: ea)]
                displayingProgress: 'Initializing...'] in [[additions
                do: [:ea | self loadClassDefinition: ea]
                displayingProgress: 'Loading classes...'.
        additions
                do: [:ea | self tryToLoad: ea]
                displayingProgress: 'Compiling methods...'.
        removals
                do: [:ea | ea unload]
                displayingProgress: 'Cleaning up...'.
        self shouldWarnAboutErrors
                ifTrue: [self warnAboutErrors].
        errorDefinitions
                do: [:ea | ea addMethodAdditionTo: methodAdditions]
                displayingProgress: 'Reloading...'.
        methodAdditions
                do: [:each | each installMethod].
        methodAdditions
                do: [:each | each notifyObservers].
        additions
                do: [:ea | ea
                                postloadOver: (self obsoletionFor: ea)]
                displayingProgress: 'Initializing...']
                on: InMidstOfFileinNotification
                do: [:n | n resume: true]] in MCPackageLoader>>basicLoad
        Receiver: a MCPackageLoader
        Arguments and temporary variables: 

        Receiver's instance variables: 
                requirements:   #()
                unloadableDefinitions:  a SortedCollection()
                obsoletions:    a Dictionary()
                additions:      an OrderedCollection(a
MCOrganizationDefinition(#(#'Aida-Admin' #'Ai...etc...
                removals:       an OrderedCollection()
                errorDefinitions:       an OrderedCollection(a 
MCClassDefinition(AIDASite)
a MCClassD...etc...
                provisions:     a Set(#UTF8DecomposedTextConverter
#PackageMethodNodeExample #Resou...etc...
                methodAdditions:        an OrderedCollection(a MethodAddition a
MethodAddition a Metho...etc...

BlockClosure>>on:do:
        Receiver: [additions
                do: [:ea | self loadClassDefinition: ea]
                displayingProgress: 'Loading class...etc...
        Arguments and temporary variables: 
                exception:      InMidstOfFileinNotification
                handlerAction:  [:n | n resume: true]
                handlerActive:  true
        Receiver's instance variables: 
                outerContext:   [[additions
                do: [:ea | self loadClassDefinition: ea]
                displayi...etc...
                startpc:        112
                numArgs:        0

[[additions
                do: [:ea | self loadClassDefinition: ea]
                displayingProgress: 'Loading classes...'.
        additions
                do: [:ea | self tryToLoad: ea]
                displayingProgress: 'Compiling methods...'.
        removals
                do: [:ea | ea unload]
                displayingProgress: 'Cleaning up...'.
        self shouldWarnAboutErrors
                ifTrue: [self warnAboutErrors].
        errorDefinitions
                do: [:ea | ea addMethodAdditionTo: methodAdditions]
                displayingProgress: 'Reloading...'.
        methodAdditions
                do: [:each | each installMethod].
        methodAdditions
                do: [:each | each notifyObservers].
        additions
                do: [:ea | ea
                                postloadOver: (self obsoletionFor: ea)]
                displayingProgress: 'Initializing...']
                on: InMidstOfFileinNotification
                do: [:n | n resume: true]] in MCPackageLoader>>basicLoad
        Receiver: a MCPackageLoader
        Arguments and temporary variables: 

        Receiver's instance variables: 
                requirements:   #()
                unloadableDefinitions:  a SortedCollection()
                obsoletions:    a Dictionary()
                additions:      an OrderedCollection(a
MCOrganizationDefinition(#(#'Aida-Admin' #'Ai...etc...
                removals:       an OrderedCollection()
                errorDefinitions:       an OrderedCollection(a 
MCClassDefinition(AIDASite)
a MCClassD...etc...
                provisions:     a Set(#UTF8DecomposedTextConverter
#PackageMethodNodeExample #Resou...etc...
                methodAdditions:        an OrderedCollection(a MethodAddition a
MethodAddition a Metho...etc...

BlockClosure>>ensure:
        Receiver: [[additions
                do: [:ea | self loadClassDefinition: ea]
                displayingProgress: 'Loading clas...etc...
        Arguments and temporary variables: 
                aBlock:         [self flushChangesFile]
                complete:       nil
                returnValue:    nil
        Receiver's instance variables: 
                outerContext:   MCPackageLoader>>basicLoad
                startpc:        108
                numArgs:        0

MCPackageLoader>>basicLoad
        Receiver: a MCPackageLoader
        Arguments and temporary variables: 

        Receiver's instance variables: 
                requirements:   #()
                unloadableDefinitions:  a SortedCollection()
                obsoletions:    a Dictionary()
                additions:      an OrderedCollection(a
MCOrganizationDefinition(#(#'Aida-Admin' #'Ai...etc...
                removals:       an OrderedCollection()
                errorDefinitions:       an OrderedCollection(a 
MCClassDefinition(AIDASite)
a MCClassD...etc...
                provisions:     a Set(#UTF8DecomposedTextConverter
#PackageMethodNodeExample #Resou...etc...
                methodAdditions:        an OrderedCollection(a MethodAddition a
MethodAddition a Metho...etc...

[self basicLoad] in MCPackageLoader>>loadWithNameLike:
        Receiver: a MCPackageLoader
        Arguments and temporary variables: 

        Receiver's instance variables: 
                requirements:   #()
                unloadableDefinitions:  a SortedCollection()
                obsoletions:    a Dictionary()
                additions:      an OrderedCollection(a
MCOrganizationDefinition(#(#'Aida-Admin' #'Ai...etc...
                removals:       an OrderedCollection()
                errorDefinitions:       an OrderedCollection(a 
MCClassDefinition(AIDASite)
a MCClassD...etc...
                provisions:     a Set(#UTF8DecomposedTextConverter
#PackageMethodNodeExample #Resou...etc...
                methodAdditions:        an OrderedCollection(a MethodAddition a
MethodAddition a Metho...etc...


--- The full stack ---
[:var | (self bindingOf: var) notNil
                ifTrue: [DuplicatedVariableError new variable: var;
                                 signal: var , ' is defined elsewhere'.
                        conflicts := true]] in AIDASite class(Class)>>declare:
Array(SequenceableCollection)>>do:
AIDASite class(Class)>>declare:
[| newCategory oldCategory needNew force organization |
unsafe
                ifFalse: [(self validateSuperclass: newSuper forSubclass: 
oldClass)
                                ifFalse: [^ nil].
                        (self
                                        validateInstvars: instVars
                                        from: oldClass
                                        forSuper: newSuper)
                                ifFalse: [^ nil].
                        (self
                                        validateClassvars: classVars
                                        from: oldClass
                                        forSuper: newSuper)
                                ifFalse: [^ nil].
                        (self
                                        validateSubclassFormat: type
                                        from: oldClass
                                        forSuper: newSuper
                                        extra: instVars size)
                                ifFalse: [^ nil]].
        needNew := self
                                needsSubclassOf: newSuper
                                type: type
                                instanceVariables: instVars
                                from: oldClass.
        needNew
                ifNil: [^ nil].
        (needNew
                        and: [unsafe not])
                ifTrue: [(self tooDangerousClasses includes: oldClass name)
                                ifTrue: [self error: oldClass name , ' cannot 
be changed'].
                        (oldClass ~~ nil
                                        and: [oldClass shouldNotBeRedefined])
                                ifTrue: [self notify: oldClass name asText 
allBold , ' should not be
redefined. \Proceed to store over it.' withCRs]].
        needNew
                ifTrue: [newClass := self
                                                newSubclassOf: newSuper
                                                type: type
                                                instanceVariables: instVars
                                                from: oldClass.
                        newClass
                                ifNil: [^ nil].
                        newClass setName: className]
                ifFalse: [newClass := oldClass].
        force := (newClass declare: classVarString)
                                | (newClass sharing: poolString).
        newCategory := category asSymbol.
        organization := environ
                                ifNotNil: [environ organization].
        oldClass isNil
                ifFalse: [oldCategory := (organization categoryOfElement: 
oldClass
name) asSymbol].
        organization classify: newClass name under: newCategory.
        newClass environment: environ.
        newClass := self
                                recompile: force
                                from: oldClass
                                to: newClass
                                mutate: false.
        (environ
                        at: newClass name
                        ifAbsent: [])
                        == newClass
                ifFalse: [environ at: newClass name put: newClass.
                        Smalltalk globals flushClassNameCache].
        copyOfOldTraitComposition
                ifNotNil: [newClass setTraitComposition: 
copyOfOldTraitComposition].
        copyOfOldClassTraitComposition
                ifNotNil: [newClass class setTraitComposition:
copyOfOldClassTraitComposition].
        newClass doneCompiling.
        oldClass isNil
                ifTrue: [SystemChangeNotifier uniqueInstance classAdded: 
newClass
inCategory: newCategory.
                        ^ newClass].
        newCategory ~= oldCategory
                ifTrue: [SystemChangeNotifier uniqueInstance
                                class: newClass
                                recategorizedFrom: oldCategory
                                to: category]
                ifFalse: [SystemChangeNotifier uniqueInstance
classDefinitionChangedFrom: copyOfOldClass to: newClass]] in
ClassBuilder>>name:inEnvironment:subclassOf:type:instanceVariableNames:c
lassVariableNames:poolDictionaries:category:unsafe:
BlockClosure>>ensure:
ClassBuilder>>name:inEnvironment:subclassOf:type:instanceVariableNames:c
lassVariableNames:poolDictionaries:category:unsafe:
ClassBuilder>>name:inEnvironment:subclassOf:type:instanceVariableNames:c
lassVariableNames:poolDictionaries:category:
MCClassDefinition>>createClass
MCClassDefinition>>load
MCClassDefinition(MCDefinition)>>addMethodAdditionTo:
[:ea | ea addMethodAdditionTo: methodAdditions] in [additions
                do: [:ea | self loadClassDefinition: ea]
                displayingProgress: 'Loading classes...'.
        additions
                do: [:ea | self tryToLoad: ea]
                displayingProgress: 'Compiling methods...'.
        removals
                do: [:ea | ea unload]
                displayingProgress: 'Cleaning up...'.
        self shouldWarnAboutErrors
                ifTrue: [self warnAboutErrors].
        errorDefinitions
                do: [:ea | ea addMethodAdditionTo: methodAdditions]
                displayingProgress: 'Reloading...'.
        methodAdditions
                do: [:each | each installMethod].
        methodAdditions
                do: [:each | each notifyObservers].
        additions
                do: [:ea | ea
                                postloadOver: (self obsoletionFor: ea)]
                displayingProgress: 'Initializing...'] in [[additions
                do: [:ea | self loadClassDefinition: ea]
                displayingProgress: 'Loading classes...'.
        additions
                do: [:ea | self tryToLoad: ea]
                displayingProgress: 'Compiling methods...'.
        removals
                do: [:ea | ea unload]
                displayingProgress: 'Cleaning up...'.
        self shouldWarnAboutErrors
                ifTrue: [self warnAboutErrors].
        errorDefinitions
                do: [:ea | ea addMethodAdditionTo: methodAdditions]
                displayingProgress: 'Reloading...'.
        methodAdditions
                do: [:each | each installMethod].
        methodAdditions
                do: [:each | each notifyObservers].
        additions
                do: [:ea | ea
                                postloadOver: (self obsoletionFor: ea)]
                displayingProgress: 'Initializing...']
                on: InMidstOfFileinNotification
                do: [:n | n resume: true]] in MCPackageLoader>>basicLoad
[:each | 
| newLabel |
(count = 0
                        or: [count + 1 = size
                                        or: [(Time millisecondsSince: 
lastUpdate)
                                                        >= msecs]])
                ifTrue: [bar value: count.
                        oldLabel = (newLabel := (labelBlock value: each)
                                                                ifNil: 
[oldLabel])
                                ifFalse: [ProgressNotification signal: '' 
extra: (oldLabel :=
newLabel)].
                        lastUpdate := Time millisecondClockValue].
        aBlock value: each.
        count := count + 1] in [:bar | self
                do: [:each | 
                        | newLabel |
                        (count = 0
                                        or: [count + 1 = size
                                                        or: [(Time 
millisecondsSince: lastUpdate)
                                                                        >= 
msecs]])
                                ifTrue: [bar value: count.
                                        oldLabel = (newLabel := (labelBlock 
value: each)
                                                                                
ifNil: [oldLabel])
                                                ifFalse: [ProgressNotification 
signal: '' extra: (oldLabel :=
newLabel)].
                                        lastUpdate := Time 
millisecondClockValue].
                        aBlock value: each.
                        count := count + 1]] in
OrderedCollection(Collection)>>do:displayingProgress:every:
OrderedCollection>>do:
[:bar | self
                do: [:each | 
                        | newLabel |
                        (count = 0
                                        or: [count + 1 = size
                                                        or: [(Time 
millisecondsSince: lastUpdate)
                                                                        >= 
msecs]])
                                ifTrue: [bar value: count.
                                        oldLabel = (newLabel := (labelBlock 
value: each)
                                                                                
ifNil: [oldLabel])
                                                ifFalse: [ProgressNotification 
signal: '' extra: (oldLabel :=
newLabel)].
                                        lastUpdate := Time 
millisecondClockValue].
                        aBlock value: each.
                        count := count + 1]] in
OrderedCollection(Collection)>>do:displayingProgress:every:
[result := workBlock value: progress] in [[result := workBlock value:
progress]
                on: ProgressNotification
                do: [:ex | 
                        ex extraParam isString
                                ifTrue: [SystemProgressMorph uniqueInstance 
labelAt: progress put:
ex extraParam].
                        ex resume]] in 
ProgressInitiationException>>defaultMorphicAction
BlockClosure>>on:do:
[[result := workBlock value: progress]
                on: ProgressNotification
                do: [:ex | 
                        ex extraParam isString
                                ifTrue: [SystemProgressMorph uniqueInstance 
labelAt: progress put:
ex extraParam].
                        ex resume]] in 
ProgressInitiationException>>defaultMorphicAction
BlockClosure>>ensure:
ProgressInitiationException>>defaultMorphicAction
MorphicUIManager>>progressInitiationExceptionDefaultAction:
ProgressInitiationException>>defaultAction
UndefinedObject>>handleSignal:
MethodContext(ContextPart)>>handleSignal:
MethodContext(ContextPart)>>handleSignal:
MethodContext(ContextPart)>>handleSignal:
MethodContext(ContextPart)>>handleSignal:
MethodContext(ContextPart)>>handleSignal:
ProgressInitiationException(Exception)>>signal
ProgressInitiationException>>display:at:from:to:during:
ProgressInitiationException class>>display:at:from:to:during:
ByteString(String)>>displayProgressAt:from:to:during:
OrderedCollection(Collection)>>do:displayingProgress:every:
OrderedCollection(Collection)>>do:displayingProgress:
[additions
                do: [:ea | self loadClassDefinition: ea]
                displayingProgress: 'Loading classes...'.
        additions
                do: [:ea | self tryToLoad: ea]
                displayingProgress: 'Compiling methods...'.
        removals
                do: [:ea | ea unload]
                displayingProgress: 'Cleaning up...'.
        self shouldWarnAboutErrors
                ifTrue: [self warnAboutErrors].
        errorDefinitions
                do: [:ea | ea addMethodAdditionTo: methodAdditions]
                displayingProgress: 'Reloading...'.
        methodAdditions
                do: [:each | each installMethod].
        methodAdditions
                do: [:each | each notifyObservers].
        additions
                do: [:ea | ea
                                postloadOver: (self obsoletionFor: ea)]
                displayingProgress: 'Initializing...'] in [[additions
                do: [:ea | self loadClassDefinition: ea]
                displayingProgress: 'Loading classes...'.
        additions
                do: [:ea | self tryToLoad: ea]
                displayingProgress: 'Compiling methods...'.
        removals
                do: [:ea | ea unload]
                displayingProgress: 'Cleaning up...'.
        self shouldWarnAboutErrors
                ifTrue: [self warnAboutErrors].
        errorDefinitions
                do: [:ea | ea addMethodAdditionTo: methodAdditions]
                displayingProgress: 'Reloading...'.
        methodAdditions
                do: [:each | each installMethod].
        methodAdditions
                do: [:each | each notifyObservers].
        additions
                do: [:ea | ea
                                postloadOver: (self obsoletionFor: ea)]
                displayingProgress: 'Initializing...']
                on: InMidstOfFileinNotification
                do: [:n | n resume: true]] in MCPackageLoader>>basicLoad
BlockClosure>>on:do:
[[additions
                do: [:ea | self loadClassDefinition: ea]
                displayingProgress: 'Loading classes...'.
        additions
                do: [:ea | self tryToLoad: ea]
                displayingProgress: 'Compiling methods...'.
        removals
                do: [:ea | ea unload]
                displayingProgress: 'Cleaning up...'.
        self shouldWarnAboutErrors
                ifTrue: [self warnAboutErrors].
        errorDefinitions
                do: [:ea | ea addMethodAdditionTo: methodAdditions]
                displayingProgress: 'Reloading...'.
        methodAdditions
                do: [:each | each installMethod].
        methodAdditions
                do: [:each | each notifyObservers].
        additions
                do: [:ea | ea
                                postloadOver: (self obsoletionFor: ea)]
                displayingProgress: 'Initializing...']
                on: InMidstOfFileinNotification
                do: [:n | n resume: true]] in MCPackageLoader>>basicLoad
BlockClosure>>ensure:
MCPackageLoader>>basicLoad
[self basicLoad] in MCPackageLoader>>loadWithNameLike:
 - - - - - - - - - - - - - - -  
                        - - - - - - - - - - - - - - - - - -
[aBlock value] in MCPackageLoader>>useChangeSetNamed:during:
BlockClosure>>ensure:
MCPackageLoader>>useChangeSetNamed:during:
MCPackageLoader>>useNewChangeSetNamedLike:during:
MCPackageLoader>>loadWithNameLike:
MCVersionLoader>>loadWithNameLike:
MCVersionLoader>>load
MetacelloGoferLoad(GoferLoad)>>execute
[goferLoad := MetacelloGoferLoad on: Gofer new.
        goferLoad addResolved: resolvedReference.
        goferLoad execute.
        MetacelloPlatform current clearCurrentVersionCache] in [| loadBlock
answers resolvedReference goferLoad |
aGofer disablePackageCache.
        resolvedReference := self resolvePackageSpec: packageSpec gofer:
aGofer.
        resolvedReference isNil
                ifTrue: [^ self].
        loadBlock := [goferLoad := MetacelloGoferLoad on: Gofer new.
                        goferLoad addResolved: resolvedReference.
                        goferLoad execute.
                        MetacelloPlatform current clearCurrentVersionCache].
        (answers := packageSpec answers) notEmpty
                ifTrue: [loadBlock valueSupplyingMetacelloAnswers: answers]
                ifFalse: [loadBlock value].
        resolvedReference workingCopy repositoryGroup addRepository:
aPackageLoadDirective repository.
        Transcript cr; show: 'Loaded -> ' , resolvedReference name , ' --- ' ,
aPackageLoadDirective repository description , ' --- ' ,
resolvedReference repository description] in
MetacelloLoadingMCSpecLoader(MetacelloCommonMCSpecLoader)>>loadPackageDi
rective:gofer:
[| loadBlock answers resolvedReference goferLoad |
aGofer disablePackageCache.
        resolvedReference := self resolvePackageSpec: packageSpec gofer:
aGofer.
        resolvedReference isNil
                ifTrue: [^ self].
        loadBlock := [goferLoad := MetacelloGoferLoad on: Gofer new.
                        goferLoad addResolved: resolvedReference.
                        goferLoad execute.
                        MetacelloPlatform current clearCurrentVersionCache].
        (answers := packageSpec answers) notEmpty
                ifTrue: [loadBlock valueSupplyingMetacelloAnswers: answers]
                ifFalse: [loadBlock value].
        resolvedReference workingCopy repositoryGroup addRepository:
aPackageLoadDirective repository.
        Transcript cr; show: 'Loaded -> ' , resolvedReference name , ' --- ' ,
aPackageLoadDirective repository description , ' --- ' ,
resolvedReference repository description] in
MetacelloLoadingMCSpecLoader(MetacelloCommonMCSpecLoader)>>loadPackageDi
rective:gofer:
[:bar | 
bar value: 1.
        aBlock value.
        bar value: 2] in MetacelloPharoPlatform>>do:displaying:
[result := workBlock value: progress] in [[result := workBlock value:
progress]
                on: ProgressNotification
                do: [:ex | 
                        ex extraParam isString
                                ifTrue: [SystemProgressMorph uniqueInstance 
labelAt: progress put:
ex extraParam].
                        ex resume]] in 
ProgressInitiationException>>defaultMorphicAction
BlockClosure>>on:do:
[[result := workBlock value: progress]
                on: ProgressNotification
                do: [:ex | 
                        ex extraParam isString
                                ifTrue: [SystemProgressMorph uniqueInstance 
labelAt: progress put:
ex extraParam].
                        ex resume]] in 
ProgressInitiationException>>defaultMorphicAction
BlockClosure>>ensure:
ProgressInitiationException>>defaultMorphicAction
MorphicUIManager>>progressInitiationExceptionDefaultAction:
ProgressInitiationException>>defaultAction
UndefinedObject>>handleSignal:
MethodContext(ContextPart)>>handleSignal:
MethodContext(ContextPart)>>handleSignal:
MethodContext(ContextPart)>>handleSignal:
ProgressInitiationException(Exception)>>signal
ProgressInitiationException>>display:at:from:to:during:
ProgressInitiationException class>>display:at:from:to:during:
ByteString(String)>>displayProgressAt:from:to:during:
MetacelloPharoPlatform>>do:displaying:
MetacelloLoadingMCSpecLoader(MetacelloCommonMCSpecLoader)>>loadPackageDi
rective:gofer:
MetacelloLinearLoadDirective(MetacelloVersionLoadDirective)>>loadPackage
Directive:gofer:
MetacelloPackageLoadDirective>>loadUsing:gofer:
[:directive | directive loadUsing: aLoaderDirective gofer: aGofer] in
MetacelloLinearLoadDirective(MetacelloVersionLoadDirective)>>loadLinearL
oadDirective:gofer:
OrderedCollection>>do:
MetacelloLinearLoadDirective(MetacelloVersionLoadDirective)>>loadLinearL
oadDirective:gofer:
MetacelloLinearLoadDirective>>loadUsing:gofer:
[:directive | directive loadUsing: aLoaderDirective gofer: aGofer] in
MetacelloLinearLoadDirective(MetacelloVersionLoadDirective)>>loadLinearL
oadDirective:gofer:
OrderedCollection>>do:
MetacelloLinearLoadDirective(MetacelloVersionLoadDirective)>>loadLinearL
oadDirective:gofer:
MetacelloLinearLoadDirective>>loadUsing:gofer:
MetacelloLinearLoadDirective(MetacelloVersionLoadDirective)>>loadWithPol
icy:
MetacelloLoaderPolicy>>load
MetacelloFetchingMCSpecLoader>>doLoad
[fetchLoader doLoad] in [| fetchLoader |
fetchLoader := self fetchRequiredFromArray: anArray.
        MetacelloPlatform current
                do: [fetchLoader doLoad]
                displaying: 'Loading ' , displayString.
        Transcript cr; show: '...finished ' , self versionNumber printString.
        ^ fetchLoader] in MetacelloMCVersion>>doLoadRequiredFromArray:
[:bar | 
bar value: 1.
        aBlock value.
        bar value: 2] in MetacelloPharoPlatform>>do:displaying:
[result := workBlock value: progress] in [[result := workBlock value:
progress]
                on: ProgressNotification
                do: [:ex | 
                        ex extraParam isString
                                ifTrue: [SystemProgressMorph uniqueInstance 
labelAt: progress put:
ex extraParam].
                        ex resume]] in 
ProgressInitiationException>>defaultMorphicAction
BlockClosure>>on:do:
[[result := workBlock value: progress]
                on: ProgressNotification
                do: [:ex | 
                        ex extraParam isString
                                ifTrue: [SystemProgressMorph uniqueInstance 
labelAt: progress put:
ex extraParam].
                        ex resume]] in 
ProgressInitiationException>>defaultMorphicAction
BlockClosure>>ensure:
ProgressInitiationException>>defaultMorphicAction
MorphicUIManager>>progressInitiationExceptionDefaultAction:
ProgressInitiationException>>defaultAction
UndefinedObject>>handleSignal:
MethodContext(ContextPart)>>handleSignal:
MethodContext(ContextPart)>>handleSignal:
ProgressInitiationException(Exception)>>signal
ProgressInitiationException>>display:at:from:to:during:
ProgressInitiationException class>>display:at:from:to:during:
ByteString(String)>>displayProgressAt:from:to:during:
MetacelloPharoPlatform>>do:displaying:
[| fetchLoader |
fetchLoader := self fetchRequiredFromArray: anArray.
        MetacelloPlatform current
                do: [fetchLoader doLoad]
                displaying: 'Loading ' , displayString.
        Transcript cr; show: '...finished ' , self versionNumber printString.
        ^ fetchLoader] in MetacelloMCVersion>>doLoadRequiredFromArray:
BlockClosure>>ensure:
MetacelloMCVersion>>doLoadRequiredFromArray:
MetacelloMCVersion>>load
ConfigurationOfAida class>>load
UndefinedObject>>DoIt
Compiler>>evaluate:in:to:notifying:ifFail:logged:
[rcvr class evaluatorClass new
                evaluate: self selectionForDoitAsStream
                in: ctxt
                to: rcvr
                notifying: self morph
                ifFail: [FakeClassPool adopt: nil.
                        ^ #failedDoit]
                logged: true] in SmalltalkEditor>>evaluateSelection
BlockClosure>>on:do:
SmalltalkEditor>>evaluateSelection
[textMorph editor evaluateSelection] in
PluggableShoutMorph(PluggableTextMorph)>>doIt
[result := editBlock value] in
PluggableShoutMorph(PluggableTextMorph)>>handleEdit:
TextMorphForEditView(TextMorph)>>handleEdit:
PluggableShoutMorph(PluggableTextMorph)>>handleEdit:
PluggableShoutMorph(PluggableTextMorph)>>doIt
UndefinedObject(Object)>>perform:orSendTo:
[| selArgCount | (selArgCount := selector numArgs) = 0
                ifTrue: [target perform: selector]
                ifFalse: [selArgCount = arguments size
                                ifTrue: [target perform: selector 
withArguments: arguments]
                                ifFalse: [target
                                                perform: selector
                                                withArguments: (arguments 
copyWith: evt)]]] in
ToggleMenuItemMorph(MenuItemMorph)>>invokeWithEvent:
BlockClosure>>ensure:
CursorWithMask(Cursor)>>showWhile:
ToggleMenuItemMorph(MenuItemMorph)>>invokeWithEvent:
ToggleMenuItemMorph(MenuItemMorph)>>mouseUp:
ToggleMenuItemMorph(MenuItemMorph)>>handleMouseUp:
MouseButtonEvent>>sentTo:
ToggleMenuItemMorph(Morph)>>handleEvent:
MorphicEventDispatcher>>dispatchDefault:with:
MorphicEventDispatcher>>dispatchEvent:with:
ToggleMenuItemMorph(Morph)>>processEvent:using:
MorphicEventDispatcher>>dispatchDefault:with:
MorphicEventDispatcher>>dispatchEvent:with:
MenuMorph(Morph)>>processEvent:using:
MenuMorph(Morph)>>processEvent:
MenuMorph>>handleFocusEvent:
[ActiveHand := self.
        ActiveEvent := anEvent.
        result := focusHolder
                                handleFocusEvent: (anEvent
                                                transformedBy: (focusHolder 
transformedFrom: self))] in
HandMorph>>sendFocusEvent:to:clear:
[aBlock value] in PasteUpMorph>>becomeActiveDuring:
BlockClosure>>on:do:
PasteUpMorph>>becomeActiveDuring:
HandMorph>>sendFocusEvent:to:clear:
HandMorph>>sendEvent:focus:clear:
HandMorph>>sendMouseEvent:
HandMorph>>handleEvent:
HandMorph>>processEvents
[:h | 
ActiveHand := h.
        h processEvents.
        ActiveHand := nil] in WorldState>>doOneCycleNowFor:
Array(SequenceableCollection)>>do:
WorldState>>handsDo:
WorldState>>doOneCycleNowFor:
WorldState>>doOneCycleFor:
WorldState>>doOneSubCycleFor:
PasteUpMorph>>doOneSubCycle
MenuMorph>>invokeModalAt:in:allowKeyboard:
MenuMorph>>invokeModal:
MenuMorph>>invokeModal
PluggableShoutMorph(PluggableTextMorph)>>yellowButtonActivity:
TextMorphForEditView>>mouseDown:
TextMorphForEditView(Morph)>>handleMouseDown:
MouseButtonEvent>>sentTo:
TextMorphForEditView(Morph)>>handleEvent:
MorphicEventDispatcher>>dispatchMouseDown:with:
MorphicEventDispatcher>>dispatchEvent:with:
TextMorphForEditView(Morph)>>processEvent:using:
MorphicEventDispatcher>>dispatchMouseDown:with:
MorphicEventDispatcher>>dispatchEvent:with:
TransformMorph(Morph)>>processEvent:using:
MorphicEventDispatcher>>dispatchMouseDown:with:
MorphicEventDispatcher>>dispatchEvent:with:
PluggableShoutMorph(Morph)>>processEvent:using:
MorphicEventDispatcher>>dispatchMouseDown:with:
MorphicEventDispatcher>>dispatchEvent:with:
SystemWindow(Morph)>>processEvent:using:
MorphicEventDispatcher>>dispatchMouseDown:with:
MorphicEventDispatcher>>dispatchEvent:with:
PasteUpMorph(Morph)>>processEvent:using:
PasteUpMorph>>processEvent:using:
PasteUpMorph(Morph)>>processEvent:
HandMorph>>sendEvent:focus:clear:
HandMorph>>sendMouseEvent:
HandMorph>>handleEvent:
HandMorph>>processEvents
[:h | 
ActiveHand := h.
        h processEvents.
        ActiveHand := nil] in WorldState>>doOneCycleNowFor:
Array(SequenceableCollection)>>do:
WorldState>>handsDo:
WorldState>>doOneCycleNowFor:
WorldState>>doOneCycleFor:
PasteUpMorph>>doOneCycle
[[World doOneCycle.
        Processor yield.
        false] whileFalse.
        nil] in Project class>>spawnNewProcess
[self value.
        Processor terminateActive] in BlockClosure>>newProcess

Reply via email to