[Moose-dev] HapaxModel in EMOF?

29 Feb 2008


      I tried to load an old mse file into moose and I got this error.
I found strange that EMOF has to do something with HapaxModle
I sent the zipped file but it is blocked by the moderator.
Stef
Unhandled exception: Import error: unknwon EMOF class  
'Smalltalk.Hapax.HapaxModel'.
SCG.Moose.MooseImporter(Meta.Importer)>>elementNotFound:
optimized [] in Meta.Importer>>newInstanceOf:
Dictionary>>at:ifAbsent:
Meta.Repository>>atQualifiedName:ifAbsent:
SCG.Moose.MooseImporter(Meta.Importer)>>newInstanceOf:
SCG.Moose.MooseImporter>>newInstanceOf:
Meta.FirstPass>>visitElementHead:with:
Meta.ElementSpec>>mseAccept:
optimized [] in Meta.AttributeSpec>>mseAccept:
Array(SequenceableCollection)>>do:
Meta.AttributeSpec>>mseAccept:
optimized [] in Meta.ElementSpec>>mseAccept:
Array(SequenceableCollection)>>do:
Meta.ElementSpec>>attributesDo:
Meta.ElementSpec>>mseAccept:
optimized [] in Meta.ExtentSpec>>mseAccept:
Array(SequenceableCollection)>>do:
Meta.ExtentSpec>>elementsDo:
Meta.ExtentSpec>>mseAccept:
Meta.FirstPass(Meta.MSESpecVisitor)>>basicRunOn:
Meta.FirstPass(Meta.MSESpecVisitor)>>runOn:
Meta.FirstPass class>>on:visit:
SCG.Moose.MooseImporter(Meta.Importer)>>importMSE:
SCG.Moose.MooseImporter(Meta.Importer)>>importStream:
SCG.Moose.MooseImporter(Meta.Importer)>>taskRun
TaskHolder>>basicRun
optimized [] in [] in Task>>runWithProgress
optimized [] in [] in [] in [] in [] in Notice  
class>>showNotice:complete:while:title:
BlockClosure>>ensure:
Cursor>>showWhile:
optimized [] in [] in [] in [] in Notice  
class>>showNotice:complete:while:title:
BlockClosure>>on:do:
optimized [] in [] in [] in Notice  
class>>showNotice:complete:while:title:
BlockClosure>>on:do:
optimized [] in [] in Notice class>>showNotice:complete:while:title:
BlockClosure>>on:do:
optimized [] in Notice class>>showNotice:complete:while:title:
BlockClosure>>ensure:
Notice class>>showNotice:complete:while:title:
optimized [] in Task>>runWithProgress
BlockClosure>>ensure:
TaskHolder(Task)>>runWithProgress
optimized [] in SCG.Moose.MooseModel>>importMSEFromFile
Time class>>microsecondsToRun:
Time class>>millisecondsToRun:
BlockClosure>>millisecondsToRun
SCG.Moose.MooseModel>>importMSEFromFile
SCG.Moose.MooseBrowser>>importMSEFromFile
optimized [] in ApplicationModel>>actionFor:
optimized [] in ActionButtonSpec>>typeConvert:
PluggableAdaptor>>setValue:
PluggableAdaptor(ValueModel)>>value:
TriggerButtonController>>pressAction
TriggerButtonTracker(BasicButtonTracker)>>finishSelectionFor:
TriggerButtonTracker>>finishSelectionFor:
TriggerButtonTracker(SelectionTracker)>>redButtonReleasedEvent:
RedButtonReleasedEvent>>dispatchTo:
TriggerButtonTracker(SelectionTracker)>>handleEvent:
EventDispatcher>>dispatch:to:
EventDispatcher>>dispatchEvent:
RedButtonReleasedEvent(Event)>>dispatch
RedButtonReleasedEvent(Event)>>dispatchForWindowManager:
optimized [] in WindowManager>>safelyDispatchForWindowManager:
BlockClosure>>on:do:
WindowManager>>safelyDispatchForWindowManager:
WindowManager>>processNextEvent
optimized [] in [] in WindowManager>>newProcess
BlockClosure>>on:do:
optimized [] in WindowManager>>newProcess
BlockClosure>>on:do:
optimized [] in Process class>>forBlock:priority:
----------------------------------------------------------------------
SCG.Moose.MooseImporter(Meta.Importer)>>elementNotFound:
Receiver:
    a SCG.Moose.MooseImporter
Instance Variables:
    elements = an IdentitySet[396]
    numberMap = a CodeFoo.LargeIndexDictionary[396]
    nameMap = a Dictionary[0]
    metaRepository = a Meta.Repository[830]
    stream = an ExternalReadStream on '/Users/ducasse/Workspace/ 
FirstCircle/ActiveResearch/Coding/MorphicGame.mse'
    settingResolveDanglingIds = true
    typesToImport = a Set[0]
Arguments:
    aName = 'Smalltalk.Hapax.HapaxModel'
Context PC = 7
----------------------------------------------------------------------
optimized [] in Meta.Importer>>newInstanceOf:
Receiver:
    an UndefinedObject
Temporaries:
    .self = a SCG.Moose.MooseImporter[396]
    .aName = 'Smalltalk.Hapax.HapaxModel'
Context PC = 7
----------------------------------------------------------------------
Dictionary>>at:ifAbsent:
Receiver:
    a Dictionary
Instance Variables:
    tally = 830
Arguments:
    key = #{Smalltalk::Hapax::HapaxModel}
    aBlock = BlockClosure [] in Meta.Importer>>newInstanceOf:
Temporaries:
    index = 157
    obj = nil
Context PC = 17
----------------------------------------------------------------------
Meta.Repository>>atQualifiedName:ifAbsent:
Receiver:
    a Meta.Repository
Instance Variables:
    elements = an IdentitySet[830]
    name = 'Default metamodel'
    pathMap = a Dictionary[830]
    smalltalkMap = an IdentityDictionary[136]
    metaRepository = a Meta.Repository[63]
Arguments:
    qualifiedName = #{Smalltalk::Hapax::HapaxModel}
    aBlock = BlockClosure [] in Meta.Importer>>newInstanceOf:
Context PC = 6
----------------------------------------------------------------------
SCG.Moose.MooseImporter(Meta.Importer)>>newInstanceOf:
Receiver:
    a SCG.Moose.MooseImporter
Instance Variables:
    elements = an IdentitySet[396]
    numberMap = a CodeFoo.LargeIndexDictionary[396]
    nameMap = a Dictionary[0]
    metaRepository = a Meta.Repository[830]
    stream = an ExternalReadStream on '/Users/ducasse/Workspace/ 
FirstCircle/ActiveResearch/Coding/MorphicGame.mse'
    settingResolveDanglingIds = true
    typesToImport = a Set[0]
Arguments:
    aName = 'Smalltalk.Hapax.HapaxModel'
Temporaries:
    metaClass = nil
Context PC = 11
----------------------------------------------------------------------
SCG.Moose.MooseImporter>>newInstanceOf:
Receiver:
    a SCG.Moose.MooseImporter
Instance Variables:
    elements = an IdentitySet[396]
    numberMap = a CodeFoo.LargeIndexDictionary[396]
    nameMap = a Dictionary[0]
    metaRepository = a Meta.Repository[830]
    stream = an ExternalReadStream on '/Users/ducasse/Workspace/ 
FirstCircle/ActiveResearch/Coding/MorphicGame.mse'
    settingResolveDanglingIds = true
    typesToImport = a Set[0]
Arguments:
    aName = 'Smalltalk.Hapax.HapaxModel'
Context PC = 22
----------------------------------------------------------------------
Meta.FirstPass>>visitElementHead:with:
Receiver:
    a Meta.FirstPass
Instance Variables:
    elementStack = an CodeFoo.ArrayList[1]
    propertyStack = an CodeFoo.ArrayList[1]
    specStack = an CodeFoo.ArrayList[2]
    context = a SCG.Moose.MooseImporter[396]
Arguments:
    className = 'Smalltalk.Hapax.HapaxModel'
    uniqueID = 399
Temporaries:
    element = nil
Context PC = 4
----------------------------------------------------------------------
Meta.ElementSpec>>mseAccept:
Receiver:
    an Meta.ElementSpec
Instance Variables:
    content = an Array[0]
    name = 'Smalltalk.Hapax.HapaxModel'
    uniqueIDCommand = a Meta.UniqueIDCommand
Arguments:
    visitor = a Meta.FirstPass
Temporaries:
    element = nil
Context PC = 18
----------------------------------------------------------------------
optimized [] in Meta.AttributeSpec>>mseAccept:
Receiver:
    an UndefinedObject
Arguments:
    each = a Meta.ElementSpec
Temporaries:
    value = nil
    .visitor = a Meta.FirstPass
    .values = an OrderedCollection[395]
Context PC = 9
----------------------------------------------------------------------
Array(SequenceableCollection)>>do:
Receiver:
    an Array
Arguments:
    aBlock = BlockClosure [] in Meta.AttributeSpec>>mseAccept:
Temporaries:
    i = 396
Context PC = 19
----------------------------------------------------------------------
Meta.AttributeSpec>>mseAccept:
Receiver:
    an Meta.AttributeSpec
Instance Variables:
    content = an Array[12130]
    name = 'entity'
Arguments:
    visitor = a Meta.FirstPass
Temporaries:
    values = an OrderedCollection[395]
    property = 'entity'
Context PC = 32
----------------------------------------------------------------------
optimized [] in Meta.ElementSpec>>mseAccept:
Receiver:
    an UndefinedObject
Arguments:
    each = a Meta.AttributeSpec
Temporaries:
    .visitor = a Meta.FirstPass
Context PC = 9
----------------------------------------------------------------------
Array(SequenceableCollection)>>do:
Receiver:
    an Array
Arguments:
    aBlock = BlockClosure [] in Meta.ElementSpec>>mseAccept:
Temporaries:
    i = 3
Context PC = 19
----------------------------------------------------------------------
Meta.ElementSpec>>attributesDo:
Receiver:
    an Meta.ElementSpec
Instance Variables:
    content = an Array[5]
    name = 'Moose.Model'
    uniqueIDCommand = a Meta.UniqueIDCommand
Arguments:
    aBlock = BlockClosure [] in Meta.ElementSpec>>mseAccept:
Context PC = 5
----------------------------------------------------------------------
Meta.ElementSpec>>mseAccept:
Receiver:
    an Meta.ElementSpec
Instance Variables:
    content = an Array[5]
    name = 'Moose.Model'
    uniqueIDCommand = a Meta.UniqueIDCommand
Arguments:
    visitor = a Meta.FirstPass
Temporaries:
    element = 'Moose.Model'->1
Context PC = 38
----------------------------------------------------------------------
optimized [] in Meta.ExtentSpec>>mseAccept:
Receiver:
    an UndefinedObject
Arguments:
    each = a Meta.ElementSpec
Temporaries:
    .visitor = a Meta.FirstPass
    result = nil
Context PC = 6
----------------------------------------------------------------------
Array(SequenceableCollection)>>do:
Receiver:
    an Array
Arguments:
    aBlock = BlockClosure [] in Meta.ExtentSpec>>mseAccept:
Temporaries:
    i = 1
Context PC = 19
----------------------------------------------------------------------
Meta.ExtentSpec>>elementsDo:
Receiver:
    an Meta.ExtentSpec
Instance Variables:
    content = an Array[1]
Arguments:
    aBlock = BlockClosure [] in Meta.ExtentSpec>>mseAccept:
Context PC = 5
----------------------------------------------------------------------
Meta.ExtentSpec>>mseAccept:
Receiver:
    an Meta.ExtentSpec
Instance Variables:
    content = an Array[1]
Arguments:
    visitor = a Meta.FirstPass
Temporaries:
    result = nil
Context PC = 15
----------------------------------------------------------------------
Meta.FirstPass(Meta.MSESpecVisitor)>>basicRunOn:
Receiver:
    a Meta.FirstPass
Instance Variables:
    elementStack = an CodeFoo.ArrayList[1]
    propertyStack = an CodeFoo.ArrayList[1]
    specStack = an CodeFoo.ArrayList[2]
    context = a SCG.Moose.MooseImporter[396]
Arguments:
    extentSpec = a Meta.ExtentSpec
Context PC = 4
----------------------------------------------------------------------
Meta.FirstPass(Meta.MSESpecVisitor)>>runOn:
Receiver:
    a Meta.FirstPass
Instance Variables:
    elementStack = an CodeFoo.ArrayList[1]
    propertyStack = an CodeFoo.ArrayList[1]
    specStack = an CodeFoo.ArrayList[2]
    context = a SCG.Moose.MooseImporter[396]
Arguments:
    extentSpec = a Meta.ExtentSpec
Context PC = 5
----------------------------------------------------------------------
Meta.FirstPass class>>on:visit:
Receiver:
    a Meta.FirstPass class
Instance Variables:
    superclass = Meta.MSESpecVisitor
    methodDict = a MethodDictionary[3]
    format = 16388
    subclasses = an Array[1]
    instanceVariables = an Array[1]
    organization = ('accessing' #context #context:)
('visiting' #visitElementHead:with:)
name = #FirstPass
    classPool = a NameSpaceOfClass[0]
    environment = a NameSpace[105]
Arguments:
    anImporter = a SCG.Moose.MooseImporter[396]
    anArray = a Meta.ExtentSpec
Context PC = 10
----------------------------------------------------------------------
SCG.Moose.MooseImporter(Meta.Importer)>>importMSE:
Receiver:
    a SCG.Moose.MooseImporter
Instance Variables:
    elements = an IdentitySet[396]
    numberMap = a CodeFoo.LargeIndexDictionary[396]
    nameMap = a Dictionary[0]
    metaRepository = a Meta.Repository[830]
    stream = an ExternalReadStream on '/Users/ducasse/Workspace/ 
FirstCircle/ActiveResearch/Coding/MorphicGame.mse'
    settingResolveDanglingIds = true
    typesToImport = a Set[0]
Arguments:
    aSpecification = a Meta.ExtentSpec
Temporaries:
    length = 12131
Context PC = 16
----------------------------------------------------------------------
SCG.Moose.MooseImporter(Meta.Importer)>>importStream:
Receiver:
    a SCG.Moose.MooseImporter
Instance Variables:
    elements = an IdentitySet[396]
    numberMap = a CodeFoo.LargeIndexDictionary[396]
    nameMap = a Dictionary[0]
    metaRepository = a Meta.Repository[830]
    stream = an ExternalReadStream on '/Users/ducasse/Workspace/ 
FirstCircle/ActiveResearch/Coding/MorphicGame.mse'
    settingResolveDanglingIds = true
    typesToImport = a Set[0]
Arguments:
    aStream = a TaskStream
Context PC = 8
----------------------------------------------------------------------
SCG.Moose.MooseImporter(Meta.Importer)>>taskRun
Receiver:
    a SCG.Moose.MooseImporter
Instance Variables:
    elements = an IdentitySet[396]
    numberMap = a CodeFoo.LargeIndexDictionary[396]
    nameMap = a Dictionary[0]
    metaRepository = a Meta.Repository[830]
    stream = an ExternalReadStream on '/Users/ducasse/Workspace/ 
FirstCircle/ActiveResearch/Coding/MorphicGame.mse'
    settingResolveDanglingIds = true
    typesToImport = a Set[0]
Context PC = 10
----------------------------------------------------------------------
TaskHolder>>basicRun
Receiver:
    a TaskHolder
Instance Variables:
    runnable = a SCG.Moose.MooseImporter[396]
Context PC = 3
----------------------------------------------------------------------
optimized [] in [] in Task>>runWithProgress
Receiver:
    an UndefinedObject
Temporaries:
    .self = a TaskHolder
    result = nil
Context PC = 6
----------------------------------------------------------------------
optimized [] in [] in [] in [] in [] in Notice  
class>>showNotice:complete:while:title:
Receiver:
    an UndefinedObject
Temporaries:
    .aBlock = BlockClosure [] in [] in Task>>runWithProgress
    increment = 8.24334e-5
    res = nil
    newValue = 0.032726
Context PC = 5
----------------------------------------------------------------------
BlockClosure>>ensure:
Receiver:
    a BlockClosure
Instance Variables:
    method = CompiledBlock [] in [] in [] in [] in [] in Notice  
class>>showNotice:complete:while:title:
    outerContext = nil
    copiedValues = an Array[2]
Arguments:
    aBlock = BlockClosure [] in Cursor>>showWhile:
Temporaries:
    result = nil
Context PC = 4
----------------------------------------------------------------------
Cursor>>showWhile:
Receiver:
    a Cursor
Instance Variables:
    errorCode = 0
    handle = a ByteArray[8]
    image = Depth1Image(extent: 16@16 depth: 1)
    mask = Depth1Image(extent: 16@16 depth: 1)
    hotSpot = 0@0
    name = 'wait'
Arguments:
    aBlock = BlockClosure [] in [] in [] in [] in [] in Notice  
class>>showNotice:complete:while:title:
Temporaries:
    oldcursor = Cursor normal
Context PC = 23
----------------------------------------------------------------------
optimized [] in [] in [] in [] in Notice  
class>>showNotice:complete:while:title:
Receiver:
    an UndefinedObject
Temporaries:
    .aBlock = BlockClosure [] in [] in Task>>runWithProgress
    increment = 8.24334e-5
    res = nil
    newValue = 0.032726
Context PC = 13
----------------------------------------------------------------------
BlockClosure>>on:do:
Receiver:
    a BlockClosure
Instance Variables:
    method = CompiledBlock [] in [] in [] in [] in Notice  
class>>showNotice:complete:while:title:
    outerContext = nil
    copiedValues = an Array[2]
Arguments:
    anExceptionSelector = IncrementNotification
    handlerBlock = BlockClosure [] in [] in [] in [] in Notice  
class>>showNotice:complete:while:title:
Context PC = 18
----------------------------------------------------------------------
optimized [] in [] in [] in Notice  
class>>showNotice:complete:while:title:
Receiver:
    an UndefinedObject
Temporaries:
    .aBlock = BlockClosure [] in [] in Task>>runWithProgress
    increment = 8.24334e-5
    res = nil
    newValue = 0.032726
    .noticeModel = a Notice
    .progress = a ValueHolder on: 0.032726
    .title = 'Please wait : <1s>%% done'
Context PC = 18
----------------------------------------------------------------------
BlockClosure>>on:do:
Receiver:
    a BlockClosure
Instance Variables:
    method = CompiledBlock [] in [] in [] in Notice  
class>>showNotice:complete:while:title:
    outerContext = nil
    copiedValues = an Array[5]
Arguments:
    anExceptionSelector = MessageNotification
    handlerBlock = BlockClosure [] in [] in [] in Notice  
class>>showNotice:complete:while:title:
Context PC = 18
----------------------------------------------------------------------
optimized [] in [] in Notice class>>showNotice:complete:while:title:
Receiver:
    an UndefinedObject
Temporaries:
    .aBlock = BlockClosure [] in [] in Task>>runWithProgress
    increment = 8.24334e-5
    res = nil
    newValue = 0.032726
    .noticeModel = a Notice
    .progress = a ValueHolder on: 0.032726
    .title = 'Please wait : <1s>%% done'
Context PC = 18
----------------------------------------------------------------------
BlockClosure>>on:do:
Receiver:
    a BlockClosure
Instance Variables:
    method = CompiledBlock [] in [] in Notice  
class>>showNotice:complete:while:title:
    outerContext = nil
    copiedValues = an Array[5]
Arguments:
    anExceptionSelector = ResetIncrementNotification
    handlerBlock = BlockClosure [] in [] in Notice  
class>>showNotice:complete:while:title:
Context PC = 18
----------------------------------------------------------------------
optimized [] in Notice class>>showNotice:complete:while:title:
Receiver:
    an UndefinedObject
Temporaries:
    .aBlock = BlockClosure [] in [] in Task>>runWithProgress
    increment = 8.24334e-5
    res = nil
    newValue = 0.032726
    .noticeModel = a Notice
    .progress = a ValueHolder on: 0.032726
    .title = 'Please wait : <1s>%% done'
Context PC = 21
----------------------------------------------------------------------
BlockClosure>>ensure:
Receiver:
    a BlockClosure
Instance Variables:
    method = CompiledBlock [] in Notice  
class>>showNotice:complete:while:title:
    outerContext = nil
    copiedValues = an Array[5]
Arguments:
    aBlock = BlockClosure [] in Notice  
class>>showNotice:complete:while:title:
Temporaries:
    result = nil
Context PC = 4
----------------------------------------------------------------------
Notice class>>showNotice:complete:while:title:
Receiver:
    a Notice class
Instance Variables:
    superclass = ApplicationModel
    methodDict = a MethodDictionary[9]
    format = 16390
    subclasses = nil
    instanceVariables = an Array[2]
    organization = ('interface opening' #postOpenWith:)
('aspects' #message: #notice #show: #textView)
('updating' #changedMessages)
('private' #invokePostOpen #on:)
('interface closing' #requestForWindowClose)
name = #Notice
    classPool = a NameSpaceOfClass[0]
    environment = a NameSpace[577]
    savedWindowInformation = an IdentityDictionary[0]
Arguments:
    aString = 'Importing model from MSE format...'
    anInteger = 0
    aBlock = BlockClosure [] in [] in Task>>runWithProgress
    titleString = 'Please wait'
Temporaries:
    noticeModel = a Notice
    int = 1
    increment = 8.24334e-5
    progress = a ValueHolder on: 0.032726
    res = nil
    title = 'Please wait : <1s>%% done'
    newValue = 0.032726
Context PC = 125
----------------------------------------------------------------------
optimized [] in Task>>runWithProgress
Receiver:
    an UndefinedObject
Temporaries:
    .self = a TaskHolder
    result = nil
Context PC = 24
----------------------------------------------------------------------
BlockClosure>>ensure:
Receiver:
    a BlockClosure
Instance Variables:
    method = CompiledBlock [] in Task>>runWithProgress
    outerContext = nil
    copiedValues = an Array[2]
Arguments:
    aBlock = BlockClosure [] in Task>>runWithProgress
Temporaries:
    result = nil
Context PC = 4
----------------------------------------------------------------------
TaskHolder(Task)>>runWithProgress
Receiver:
    a TaskHolder
Instance Variables:
    runnable = a SCG.Moose.MooseImporter[396]
Temporaries:
    result = nil
Context PC = 15
----------------------------------------------------------------------
optimized [] in SCG.Moose.MooseModel>>importMSEFromFile
Receiver:
    an UndefinedObject
Temporaries:
    moosemodel = nil
    loader = a SCG.Moose.MooseImporter[396]
    .fileName = '/Users/ducasse/Workspace/Firs...earch/Coding/ 
MorphicGame.mse'
Context PC = 20
----------------------------------------------------------------------
Time class>>microsecondsToRun:
Receiver:
    a Time class
Instance Variables:
    superclass = Magnitude
    methodDict = a MethodDictionary[24]
    format = 16387
    subclasses = nil
    instanceVariables = an Array[3]
    organization = ('comparing' #< #= #hash)
('accessing' #hours #milliseconds #minutes #seconds)
('arithmetic' #addTime: #subtractTime:)
('printing' #glorpPadToTwoDigits: #glorpPrintSQLOn: #longPrintString  
#printOn: #shortPrintString #storeOn:)
('converting' #asSeconds #asTimestamp)
('private' #hours: #hours:minutes:seconds: #literalArrayEncoding  
#printOn:policy:format:)
('private-spin-button' #decrementBy:boundedBy:highValue:wrapAround:  
#incrementBy:boundedBy:lowValue:wrapAround:)
('private-oracle' #oracleConversion)
name = #Time
    classPool = a NameSpaceOfClass[0]
    environment = a NameSpace[224]
Arguments:
    timedBlock = BlockClosure [] in SCG.Moose.MooseModel>>importMSEFromFile
Temporaries:
    initialMicroseconds = 3381740218566122
Context PC = 7
----------------------------------------------------------------------
Time class>>millisecondsToRun:
Receiver:
    a Time class
Instance Variables:
    superclass = Magnitude
    methodDict = a MethodDictionary[24]
    format = 16387
    subclasses = nil
    instanceVariables = an Array[3]
    organization = ('comparing' #< #= #hash)
('accessing' #hours #milliseconds #minutes #seconds)
('arithmetic' #addTime: #subtractTime:)
('printing' #glorpPadToTwoDigits: #glorpPrintSQLOn: #longPrintString  
#printOn: #shortPrintString #storeOn:)
('converting' #asSeconds #asTimestamp)
('private' #hours: #hours:minutes:seconds: #literalArrayEncoding  
#printOn:policy:format:)
('private-spin-button' #decrementBy:boundedBy:highValue:wrapAround:  
#incrementBy:boundedBy:lowValue:wrapAround:)
('private-oracle' #oracleConversion)
name = #Time
    classPool = a NameSpaceOfClass[0]
    environment = a NameSpace[224]
Arguments:
    timedBlock = BlockClosure [] in SCG.Moose.MooseModel>>importMSEFromFile
Context PC = 5
----------------------------------------------------------------------
BlockClosure>>millisecondsToRun
Receiver:
    a BlockClosure
Instance Variables:
    method = CompiledBlock [] in SCG.Moose.MooseModel>>importMSEFromFile
    outerContext = nil
    copiedValues = an Array[2]
Context PC = 4
----------------------------------------------------------------------
SCG.Moose.MooseModel>>importMSEFromFile
Receiver:
    a SCG.Moose.MooseModel
Instance Variables:
    mooseID = nil
    state = a SCG.Moose.DefaultEntityState
    storage = a SCG.Moose.SetupStorage[10]
    sourceLanguage = nil
    name = 'Root'
Temporaries:
    fileName = '/Users/ducasse/Workspace/Firs...earch/Coding/ 
MorphicGame.mse'
    moosemodel = nil
    loader = a SCG.Moose.MooseImporter[396]
    millis = nil
Context PC = 35
----------------------------------------------------------------------
SCG.Moose.MooseBrowser>>importMSEFromFile
Receiver:
    a SCG.Moose.MooseBrowser
Instance Variables:
    dependents = nil
    builder = an UIBuilder
    uiSession = a ControlManager
    eventHandlers = nil
    browser = nil
    viewSubcanvas = a SCG.Moose.MooseIconUI
    favoriteList = nil
    modelList = a SelectionInList
    entityList = a SelectionInList
    selectedEntity = a SCG.Moose.MooseModel #'LAN sample model'(685)
Context PC = 7
----------------------------------------------------------------------
optimized [] in ApplicationModel>>actionFor:
Receiver:
    an UndefinedObject
Temporaries:
    .self = a SCG.Moose.MooseBrowser
    .aKey = #importMSEFromFile
Context PC = 7
----------------------------------------------------------------------
optimized [] in ActionButtonSpec>>typeConvert:
Receiver:
    an UndefinedObject
Arguments:
    b = a ValueHolder on: nil
    v = true
Temporaries:
    .aValue = BlockClosure [] in ApplicationModel>>actionFor:
Context PC = 5
----------------------------------------------------------------------
PluggableAdaptor>>setValue:
Receiver:
    a PluggableAdaptor
Instance Variables:
    dependents = nil
    model = a ValueHolder on: nil
    getBlock = BlockClosure [] in ActionButtonSpec>>typeConvert:
    putBlock = BlockClosure [] in ActionButtonSpec>>typeConvert:
    updateBlock = BlockClosure [] in ActionButtonSpec>>typeConvert:
Arguments:
    newValue = true
Context PC = 6
----------------------------------------------------------------------
PluggableAdaptor(ValueModel)>>value:
Receiver:
    a PluggableAdaptor
Instance Variables:
    dependents = nil
    model = a ValueHolder on: nil
    getBlock = BlockClosure [] in ActionButtonSpec>>typeConvert:
    putBlock = BlockClosure [] in ActionButtonSpec>>typeConvert:
    updateBlock = BlockClosure [] in ActionButtonSpec>>typeConvert:
Arguments:
    newValue = true
Context PC = 5
----------------------------------------------------------------------
TriggerButtonController>>pressAction
Receiver:
    a TriggerButtonController
Instance Variables:
    model = a PluggableAdaptor
    view = a Win95ActionButtonView
    sensor = a TranslatingSensor
    keyboardProcessor = a KeyboardProcessor
    keyboardHook = nil
    dispatcher = nil
Context PC = 17
----------------------------------------------------------------------
TriggerButtonTracker(BasicButtonTracker)>>finishSelectionFor:
Receiver:
    a TriggerButtonTracker
Instance Variables:
    controller = a TriggerButtonController
    inside = true
Arguments:
    aPoint = 16@15
Context PC = 8
----------------------------------------------------------------------
TriggerButtonTracker>>finishSelectionFor:
Receiver:
    a TriggerButtonTracker
Instance Variables:
    controller = a TriggerButtonController
    inside = true
Arguments:
    aPoint = 16@15
Context PC = 11
----------------------------------------------------------------------
TriggerButtonTracker(SelectionTracker)>>redButtonReleasedEvent:
Receiver:
    a TriggerButtonTracker
Instance Variables:
    controller = a TriggerButtonController
    inside = true
Arguments:
    aMouseButtonEvent = a RedButtonReleasedEvent
Context PC = 13
----------------------------------------------------------------------
RedButtonReleasedEvent>>dispatchTo:
Receiver:
    a RedButtonReleasedEvent
Instance Variables:
    time = 1696571547
    initiator = an EventDispatcher
    window = an ApplicationWindow nil
    state = 0
    x = 42
    y = 15
    gx = 262
    gy = 226
    buttonNumber = 1
Arguments:
    anObject = a TriggerButtonTracker
Context PC = 4
----------------------------------------------------------------------
TriggerButtonTracker(SelectionTracker)>>handleEvent:
Receiver:
    a TriggerButtonTracker
Instance Variables:
    controller = a TriggerButtonController
    inside = true
Arguments:
    anEvent = a RedButtonReleasedEvent
Context PC = 4
----------------------------------------------------------------------
EventDispatcher>>dispatch:to:
Receiver:
    an EventDispatcher
Instance Variables:
    windowController = an ApplicationStandardSystemController
    currentMouseConsumer = nil
    grabbingMouse = false
    keyboardProcessor = a KeyboardProcessor
    lastControlObject = a TriggerButtonController
    trapList = nil
    state = nil
    repairDamageWhenDebugging = true
    flushQueueAfterError = true
    distributeEventsWhenDebugging = true
    dragDropInProgress = false
    dragDropTracker = nil
    dispatchUnknownEvents = false
Arguments:
    event = a RedButtonReleasedEvent
    object = a TriggerButtonTracker
Temporaries:
    tmp = nil
Context PC = 10
----------------------------------------------------------------------
EventDispatcher>>dispatchEvent:
Receiver:
    an EventDispatcher
Instance Variables:
    windowController = an ApplicationStandardSystemController
    currentMouseConsumer = nil
    grabbingMouse = false
    keyboardProcessor = a KeyboardProcessor
    lastControlObject = a TriggerButtonController
    trapList = nil
    state = nil
    repairDamageWhenDebugging = true
    flushQueueAfterError = true
    distributeEventsWhenDebugging = true
    dragDropInProgress = false
    dragDropTracker = nil
    dispatchUnknownEvents = false
Arguments:
    event = a RedButtonReleasedEvent
Temporaries:
    objectWantingControl = nil
    targetKeyboardProcessor = nil
Context PC = 60
----------------------------------------------------------------------
RedButtonReleasedEvent(Event)>>dispatch
Receiver:
    a RedButtonReleasedEvent
Instance Variables:
    time = 1696571547
    initiator = an EventDispatcher
    window = an ApplicationWindow nil
    state = 0
    x = 42
    y = 15
    gx = 262
    gy = 226
    buttonNumber = 1
Context PC = 16
----------------------------------------------------------------------
RedButtonReleasedEvent(Event)>>dispatchForWindowManager:
Receiver:
    a RedButtonReleasedEvent
Instance Variables:
    time = 1696571547
    initiator = an EventDispatcher
    window = an ApplicationWindow nil
    state = 0
    x = 42
    y = 15
    gx = 262
    gy = 226
    buttonNumber = 1
Arguments:
    aWinMgr = a WindowManager
Context PC = 4
----------------------------------------------------------------------
optimized [] in WindowManager>>safelyDispatchForWindowManager:
Receiver:
    an UndefinedObject
Temporaries:
    .event = a RedButtonReleasedEvent
    .self = a WindowManager
Context PC = 6
----------------------------------------------------------------------
BlockClosure>>on:do:
Receiver:
    a BlockClosure
Instance Variables:
    method = CompiledBlock [] in  
WindowManager>>safelyDispatchForWindowManager:
    outerContext = nil
    copiedValues = an Array[2]
Arguments:
    anExceptionSelector = BadControllerError
    handlerBlock = BlockClosure [] in  
WindowManager>>safelyDispatchForWindowManager:
Context PC = 18
----------------------------------------------------------------------
WindowManager>>safelyDispatchForWindowManager:
Receiver:
    a WindowManager
Instance Variables:
    windows = an OrderedCollection[1]
    activeController = nil
    interruptLock = false
    outstandingMetaOrDamage = false
    openInProgress = false
    eventQueue = an EventQueue
    baseProcess = a Process in Semaphore>>wait
    dontFilterEvents = false
Arguments:
    event = a RedButtonReleasedEvent
Context PC = 13
----------------------------------------------------------------------
WindowManager>>processNextEvent
Receiver:
    a WindowManager
Instance Variables:
    windows = an OrderedCollection[1]
    activeController = nil
    interruptLock = false
    outstandingMetaOrDamage = false
    openInProgress = false
    eventQueue = an EventQueue
    baseProcess = a Process in Semaphore>>wait
    dontFilterEvents = false
Temporaries:
    event = a RedButtonReleasedEvent
Context PC = 9
----------------------------------------------------------------------
optimized [] in [] in WindowManager>>newProcess
Receiver:
    an UndefinedObject
Temporaries:
    .self = a WindowManager
Context PC = 13
----------------------------------------------------------------------
BlockClosure>>on:do:
Receiver:
    a BlockClosure
Instance Variables:
    method = CompiledBlock [] in [] in WindowManager>>newProcess
    outerContext = nil
    copiedValues = a WindowManager
Arguments:
    anExceptionSelector = TerminateException
    handlerBlock = BlockClosure [] in [] in WindowManager>>newProcess
Context PC = 18
----------------------------------------------------------------------
optimized [] in WindowManager>>newProcess
Receiver:
    an UndefinedObject
Temporaries:
    .self = a WindowManager
Context PC = 15
----------------------------------------------------------------------
BlockClosure>>on:do:
Receiver:
    a BlockClosure
Instance Variables:
    method = CompiledBlock [] in WindowManager>>newProcess
    outerContext = nil
    copiedValues = a WindowManager
Arguments:
    anExceptionSelector = TerminateException
    handlerBlock = BlockClosure [] in [] in Process  
class>>forBlock:priority:
Context PC = 18
----------------------------------------------------------------------
optimized [] in Process class>>forBlock:priority:
Receiver:
    an UndefinedObject
Temporaries:
    .aBlock = BlockClosure [] in WindowManager>>newProcess
Context PC = 9

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

[Moose-dev] HapaxModel in EMOF?