loading athens - a user perspective

Previous Topic Next Topic
 
classic Classic list List threaded Threaded
4 messages Options
Reply | Threaded
Open this post in threaded view
|

loading athens - a user perspective

Tudor Girba-2
Hi,

Here is how to install Athens (I also added this comment to the ConfigurationOfAthens):


1. Install Cairo on your machine
For example, for Mac, you open the terminal and run:
sudo port install -f cairo +universal

More information can be found here:
http://cairographics.org/download/


2. Download the NativeBoost enabled Cog VM from:
https://ci.lille.inria.fr/pharo/view/NativeBoost/


3. Get a Pharo image and run:
Gofer new
        squeaksource: 'Athens';
        package: 'ConfigurationOfAthens';
        load.
(Smalltalk at: #ConfigurationOfAthens) loadDevelopment


4. Play with it. For example:
VGTigerDemo runDemo


Thanks Igor!

Cheers,
Doru

--
www.tudorgirba.com

"Live like you mean it."


_______________________________________________
Moose-dev mailing list
[hidden email]
https://www.iam.unibe.ch/mailman/listinfo/moose-dev
Reply | Threaded
Open this post in threaded view
|

Re: [Pharo-project] loading athens - a user perspective

SergeStinckwich
On Fri, May 25, 2012 at 4:57 PM, Tudor Girba <[hidden email]> wrote:

> Hi,
>
> Here is how to install Athens (I also added this comment to the ConfigurationOfAthens):
>
>
> 1. Install Cairo on your machine
> For example, for Mac, you open the terminal and run:
> sudo port install -f cairo +universal
>
> More information can be found here:
> http://cairographics.org/download/
>
>
> 2. Download the NativeBoost enabled Cog VM from:
> https://ci.lille.inria.fr/pharo/view/NativeBoost/
>
>
> 3. Get a Pharo image and run:
> Gofer new
>        squeaksource: 'Athens';
>        package: 'ConfigurationOfAthens';
>        load.
> (Smalltalk at: #ConfigurationOfAthens) loadDevelopment
>
>
> 4. Play with it. For example:
> VGTigerDemo runDemo

I install Cairo with brew on mac os x:
brew install cairo

And I got the following stack trace:


25 May 2012 5:37:03 pm

VM: Mac OS - intel - 1074 - NBCoInterpreter
NativeBoost-CogPlugin-IgorStasenko.9 uuid:
801decd2-0b42-fa49-bcea-d7564d516a1b May  1 2012,
StackToRegisterMappingCogit VMMaker-oscog-EstebanLorenzano.158 uuid:
82eded98-68af-4c80-a472-4f6de293adcf May  1 2012,
https://git.gitorious.org/cogvm/blessed.git Commit:
6aa3fd0f1188078d3167dec1a53031a61b97b688 Date: Tue May 1 20:28:14 2012
+0200 By: Esteban Lorenzano <[hidden email]>
Image: Pharo1.4a [Latest update: #14418]

NBFFICallout(Object)>>error:
        Receiver: a NBFFICallout
        Arguments and temporary variables:
                aString: 'function unavailable'
        Receiver's instance variables:
                asm: an AJx86Assembler
                proxy: a NBInterpreterProxy
                options: a Set(#optCdecl #optAllowByteArraysPtr #optUseStackPointer
#optReturnP...etc...
                method: (AthensCairoSurface class>>#primImage:width:height: "a
CompiledMethod(4...etc...
                fnSpec: a NBFnSpec
                requestor: AthensCairoSurface class
                methodArgs: an OrderedCollection('aFormat' 'aWidth' 'aHeight')
                coercionMayFail: true
                callInfo: an AJCdeclCallInfo

[:gen |
fnAddress := requestor nbGetSymbolAddress: fnSpec functionName module:
aModuleNameOrHandle.
        fnAddress
                ifNil: [self error: 'function unavailable'].
        self mayCallback
                ifTrue: [asm push: fnAddress asUImm32;
                                 mov: NativeBoost callgateFunctionAddress asUImm32 to: EAX;
                                 call: EAX]
                ifFalse: [asm mov: fnAddress asUImm32 to: EAX;
                                 call: EAX]] in NBFFICallout>>generateCall:module:
        Receiver: a NBFFICallout
        Arguments and temporary variables:
                aModuleNameOrHandle: a NBFFICallout
                fnAddress: '/opt/local/lib/libcairo.2.dylib'
                gen: #(nil)
        Receiver's instance variables:
                asm: an AJx86Assembler
                proxy: a NBInterpreterProxy
                options: a Set(#optCdecl #optAllowByteArraysPtr #optUseStackPointer
#optReturnP...etc...
                method: (AthensCairoSurface class>>#primImage:width:height: "a
CompiledMethod(4...etc...
                fnSpec: a NBFnSpec
                requestor: AthensCairoSurface class
                methodArgs: an OrderedCollection('aFormat' 'aWidth' 'aHeight')
                coercionMayFail: true
                callInfo: an AJCdeclCallInfo

BlockClosure>>valueWithPossibleArgs:
        Receiver: [:gen |
fnAddress := requestor nbGetSymbolAddress: fnSpec functionName module:
aModuleNam...etc...
        Arguments and temporary variables:
                anArray: an Array(a NBFFICallout a NBInterpreterProxy an AJx86Assembler)
        Receiver's instance variables:
                outerContext: NBFFICallout>>generateCall:module:
                startpc: 91
                numArgs: 1

[aFunctionBodyBlock valueWithPossibleArgs: {self. proxy. asm}.
        (self optEmitCall
                        or: [self optNoCleanup])
                ifTrue: [call disableCleanup]] in [:call |
self optNoAlignment
                ifTrue: [call alignment: 1].
        self pushArguments.
        coercionMayFail
                ifTrue: [proxy ifFailedJumpTo: self failedLabel].
        asm
                decorateWith: 'FFI: performing a call'
                while: [aFunctionBodyBlock valueWithPossibleArgs: {self. proxy. asm}.
                        (self optEmitCall
                                        or: [self optNoCleanup])
                                ifTrue: [call disableCleanup]]] in NBFFICallout>>generateInstructions:
        Receiver: a NBFFICallout
        Arguments and temporary variables:
                aFunctionBodyBlock: an AJCdeclCallInfo
                call: [:gen |
fnAddress := requestor nbGetSymbolAddress: fnSpec functionName m...etc...
        Receiver's instance variables:
                asm: an AJx86Assembler
                proxy: a NBInterpreterProxy
                options: a Set(#optCdecl #optAllowByteArraysPtr #optUseStackPointer
#optReturnP...etc...
                method: (AthensCairoSurface class>>#primImage:width:height: "a
CompiledMethod(4...etc...
                fnSpec: a NBFnSpec
                requestor: AthensCairoSurface class
                methodArgs: an OrderedCollection('aFormat' 'aWidth' 'aHeight')
                coercionMayFail: true
                callInfo: an AJCdeclCallInfo

BlockClosure>>ensure:
        Receiver: [aFunctionBodyBlock valueWithPossibleArgs: {self. proxy. asm}.
        (self optEmitCall
                        or: [...etc...
        Arguments and temporary variables:
                aBlock: [level := level - 1.
        self
                addInstruction: (AJInstructionDecoration n...etc...
                complete: nil
                returnValue: nil
        Receiver's instance variables:
                outerContext: [:call |
self optNoAlignment
                ifTrue: [call alignment: 1].
        sel...etc...
                startpc: 151
                numArgs: 0

AJx86Assembler>>decorateWith:while:
        Receiver: an AJx86Assembler
        Arguments and temporary variables:
                annotation: 'FFI: performing a call'
                aBlock: [aFunctionBodyBlock valueWithPossibleArgs: {self. proxy. asm}.
        (self o...etc...
        Receiver's instance variables:
                instructions: <<error during printing>>

[:call |
self optNoAlignment
                ifTrue: [call alignment: 1].
        self pushArguments.
        coercionMayFail
                ifTrue: [proxy ifFailedJumpTo: self failedLabel].
        asm
                decorateWith: 'FFI: performing a call'
                while: [aFunctionBodyBlock valueWithPossibleArgs: {self. proxy. asm}.
                        (self optEmitCall
                                        or: [self optNoCleanup])
                                ifTrue: [call disableCleanup]]] in NBFFICallout>>generateInstructions:
        Receiver: a NBFFICallout
        Arguments and temporary variables:
                aFunctionBodyBlock: an AJCdeclCallInfo
                call: [:gen |
fnAddress := requestor nbGetSymbolAddress: fnSpec functionName m...etc...
        Receiver's instance variables:
                asm: an AJx86Assembler
                proxy: a NBInterpreterProxy
                options: a Set(#optCdecl #optAllowByteArraysPtr #optUseStackPointer
#optReturnP...etc...
                method: (AthensCairoSurface class>>#primImage:width:height: "a
CompiledMethod(4...etc...
                fnSpec: a NBFnSpec
                requestor: AthensCairoSurface class
                methodArgs: an OrderedCollection('aFormat' 'aWidth' 'aHeight')
                coercionMayFail: true
                callInfo: an AJCdeclCallInfo

AJx86Assembler>>performingCall:in:
        Receiver: an AJx86Assembler
        Arguments and temporary variables:
                ci: an AJCdeclCallInfo
                aBlock: [:call |
self optNoAlignment
                ifTrue: [call alignment: 1].
        self push...etc...
        Receiver's instance variables:
                instructions: <<error during printing>>

NBFFICallout>>foreignCall:
        Receiver: a NBFFICallout
        Arguments and temporary variables:
                aBlock: [:call |
self optNoAlignment
                ifTrue: [call alignment: 1].
        self push...etc...
        Receiver's instance variables:
                asm: an AJx86Assembler
                proxy: a NBInterpreterProxy
                options: a Set(#optCdecl #optAllowByteArraysPtr #optUseStackPointer
#optReturnP...etc...
                method: (AthensCairoSurface class>>#primImage:width:height: "a
CompiledMethod(4...etc...
                fnSpec: a NBFnSpec
                requestor: AthensCairoSurface class
                methodArgs: an OrderedCollection('aFormat' 'aWidth' 'aHeight')
                coercionMayFail: true
                callInfo: an AJCdeclCallInfo

NBFFICallout>>generateInstructions:
        Receiver: a NBFFICallout
        Arguments and temporary variables:
                aFunctionBodyBlock: [:gen |
fnAddress := requestor nbGetSymbolAddress: fnSpec ...etc...
                instructions: nil
        Receiver's instance variables:
                asm: an AJx86Assembler
                proxy: a NBInterpreterProxy
                options: a Set(#optCdecl #optAllowByteArraysPtr #optUseStackPointer
#optReturnP...etc...
                method: (AthensCairoSurface class>>#primImage:width:height: "a
CompiledMethod(4...etc...
                fnSpec: a NBFnSpec
                requestor: AthensCairoSurface class
                methodArgs: an OrderedCollection('aFormat' 'aWidth' 'aHeight')
                coercionMayFail: true
                callInfo: an AJCdeclCallInfo

NBFFICallout>>generate:
        Receiver: a NBFFICallout
        Arguments and temporary variables:
                aFunctionBodyBlock: [:gen |
fnAddress := requestor nbGetSymbolAddress: fnSpec ...etc...
                generatedCode: nil
        Receiver's instance variables:
                asm: an AJx86Assembler
                proxy: a NBInterpreterProxy
                options: a Set(#optCdecl #optAllowByteArraysPtr #optUseStackPointer
#optReturnP...etc...
                method: (AthensCairoSurface class>>#primImage:width:height: "a
CompiledMethod(4...etc...
                fnSpec: a NBFnSpec
                requestor: AthensCairoSurface class
                methodArgs: an OrderedCollection('aFormat' 'aWidth' 'aHeight')
                coercionMayFail: true
                callInfo: an AJCdeclCallInfo

NBFFICallout>>generateCall:module:
        Receiver: a NBFFICallout
        Arguments and temporary variables:
                functionSpec: #(#AthensCairoSurface #cairo_image_surface_create
#(#int #aFormat...etc...
                aModuleNameOrHandle: '/opt/local/lib/libcairo.2.dylib'
                fnAddress: #(nil)
        Receiver's instance variables:
                asm: an AJx86Assembler
                proxy: a NBInterpreterProxy
                options: a Set(#optCdecl #optAllowByteArraysPtr #optUseStackPointer
#optReturnP...etc...
                method: (AthensCairoSurface class>>#primImage:width:height: "a
CompiledMethod(4...etc...
                fnSpec: a NBFnSpec
                requestor: AthensCairoSurface class
                methodArgs: an OrderedCollection('aFormat' 'aWidth' 'aHeight')
                coercionMayFail: true
                callInfo: an AJCdeclCallInfo

[:gen | gen sender: sender;
                 callType: self nbCallingConvention;
                 generateCall: fnSpec module: self nbLibraryNameOrHandle] in
AthensCairoSurface class(Object)>>nbCall:
        Receiver: AthensCairoSurface
        Arguments and temporary variables:
                fnSpec: a NBFFICallout
                sender: #(#AthensCairoSurface #cairo_image_surface_create #(#int
#aFormat #, #i...etc...
                gen: AthensCairoSurface class>>primImage:width:height:
        Receiver's instance variables:
                superclass: AthensSurface
                methodDict: a
MethodDictionary(#asAthensPaintOn:->(AthensCairoSurface>>#asAthen...etc...
                format: 140
                instanceVariables: #('handle' 'context' 'builder' 'id')
                organization: ('converting' asAthensPaintOn: writeToPng:)
('as yet unclassified...etc...
                subclasses: {AthensCairoPDFSurface}
                name: #AthensCairoSurface
                classPool: nil
                sharedPools: an OrderedCollection(AthensCairoDefs)
                environment: a SystemDictionary(lots of globals)
                category: #'Athens-Cairo'
                traitComposition: TCairoLibrary
                localSelectors: a Set(#asForm #createFormPaint: #stride
#setOperator: #writeToP...etc...
                uniqueSession: nil
                dispatch: nil
                dispatchStruct: nil

NBFFICallout class(NBNativeCodeGen class)>>generateCode:andRetry:
        Receiver: NBFFICallout
        Arguments and temporary variables:
                aBlock: [:gen | gen sender: sender;
                 callType: self nbCallingConvention;
                 g...etc...
                retryCtx: AthensCairoSurface class>>primImage:width:height:
                method: (AthensCairoSurface class>>#primImage:width:height: "a
CompiledMethod(4...etc...
                code: nil
                newMethod: nil
                args: nil
                i: nil
                iLimiT: nil
        Receiver's instance variables:
                superclass: NBNativeCodeGen
                methodDict: a
MethodDictionary(#aliasForType:->(NBFFICallout>>#aliasForType:
"a...etc...
                format: 148
                instanceVariables: #('fnSpec' 'requestor' 'methodArgs'
'coercionMayFail' 'callI...etc...
                organization: ('type aliases' aliasForType:)
('accessing' anonSpec: callType: c...etc...
                subclasses: {NBNativeFunctionGen}
                name: #NBFFICallout
                classPool: a Dictionary(#CustomErrorCodes->nil
#CustomErrorMessages->nil #TypeA...etc...
                sharedPools: nil
                environment: a SystemDictionary(lots of globals)
                category: #'NativeBoost-Core'
                traitComposition: {}
                localSelectors: nil

NBFFICallout class(NBNativeCodeGen class)>>handleFailureIn:nativeCode:
        Receiver: NBFFICallout
        Arguments and temporary variables:
                aContext: AthensCairoSurface class>>primImage:width:height:
                aBlock: [:gen | gen sender: sender;
                 callType: self nbCallingConvention;
                 g...etc...
                method: (AthensCairoSurface class>>#primImage:width:height: "a
CompiledMethod(4...etc...
                lastError: 502
        Receiver's instance variables:
                superclass: NBNativeCodeGen
                methodDict: a
MethodDictionary(#aliasForType:->(NBFFICallout>>#aliasForType:
"a...etc...
                format: 148
                instanceVariables: #('fnSpec' 'requestor' 'methodArgs'
'coercionMayFail' 'callI...etc...
                organization: ('type aliases' aliasForType:)
('accessing' anonSpec: callType: c...etc...
                subclasses: {NBNativeFunctionGen}
                name: #NBFFICallout
                classPool: a Dictionary(#CustomErrorCodes->nil
#CustomErrorMessages->nil #TypeA...etc...
                sharedPools: nil
                environment: a SystemDictionary(lots of globals)
                category: #'NativeBoost-Core'
                traitComposition: {}
                localSelectors: nil

AthensCairoSurface class(Object)>>nbCall:
        Receiver: AthensCairoSurface
        Arguments and temporary variables:
                fnSpec: #(#AthensCairoSurface #cairo_image_surface_create #(#int
#aFormat #, #i...etc...
                sender: AthensCairoSurface class>>primImage:width:height:
        Receiver's instance variables:
                superclass: AthensSurface
                methodDict: a
MethodDictionary(#asAthensPaintOn:->(AthensCairoSurface>>#asAthen...etc...
                format: 140
                instanceVariables: #('handle' 'context' 'builder' 'id')
                organization: ('converting' asAthensPaintOn: writeToPng:)
('as yet unclassified...etc...
                subclasses: {AthensCairoPDFSurface}
                name: #AthensCairoSurface
                classPool: nil
                sharedPools: an OrderedCollection(AthensCairoDefs)
                environment: a SystemDictionary(lots of globals)
                category: #'Athens-Cairo'
                traitComposition: TCairoLibrary
                localSelectors: a Set(#asForm #createFormPaint: #stride
#setOperator: #writeToP...etc...
                uniqueSession: nil
                dispatch: nil
                dispatchStruct: nil

AthensCairoSurface class>>primImage:width:height:
        Receiver: AthensCairoSurface
        Arguments and temporary variables:
                aFormat: 0
                aWidth: 800
                aHeight: 800
        Receiver's instance variables:
                superclass: AthensSurface
                methodDict: a
MethodDictionary(#asAthensPaintOn:->(AthensCairoSurface>>#asAthen...etc...
                format: 140
                instanceVariables: #('handle' 'context' 'builder' 'id')
                organization: ('converting' asAthensPaintOn: writeToPng:)
('as yet unclassified...etc...
                subclasses: {AthensCairoPDFSurface}
                name: #AthensCairoSurface
                classPool: nil
                sharedPools: an OrderedCollection(AthensCairoDefs)
                environment: a SystemDictionary(lots of globals)
                category: #'Athens-Cairo'
                traitComposition: TCairoLibrary
                localSelectors: a Set(#asForm #createFormPaint: #stride
#setOperator: #writeToP...etc...
                uniqueSession: nil
                dispatch: nil
                dispatchStruct: nil

AthensCairoSurface class>>extent:format:
        Receiver: AthensCairoSurface
        Arguments and temporary variables:
                anExtent: (800@800)
                aFormat: 0
        Receiver's instance variables:
                superclass: AthensSurface
                methodDict: a
MethodDictionary(#asAthensPaintOn:->(AthensCairoSurface>>#asAthen...etc...
                format: 140
                instanceVariables: #('handle' 'context' 'builder' 'id')
                organization: ('converting' asAthensPaintOn: writeToPng:)
('as yet unclassified...etc...
                subclasses: {AthensCairoPDFSurface}
                name: #AthensCairoSurface
                classPool: nil
                sharedPools: an OrderedCollection(AthensCairoDefs)
                environment: a SystemDictionary(lots of globals)
                category: #'Athens-Cairo'
                traitComposition: TCairoLibrary
                localSelectors: a Set(#asForm #createFormPaint: #stride
#setOperator: #writeToP...etc...
                uniqueSession: nil
                dispatch: nil
                dispatchStruct: nil

AthensCairoSurface class>>extent:
        Receiver: AthensCairoSurface
        Arguments and temporary variables:
                anExtent: (800@800)
        Receiver's instance variables:
                superclass: AthensSurface
                methodDict: a
MethodDictionary(#asAthensPaintOn:->(AthensCairoSurface>>#asAthen...etc...
                format: 140
                instanceVariables: #('handle' 'context' 'builder' 'id')
                organization: ('converting' asAthensPaintOn: writeToPng:)
('as yet unclassified...etc...
                subclasses: {AthensCairoPDFSurface}
                name: #AthensCairoSurface
                classPool: nil
                sharedPools: an OrderedCollection(AthensCairoDefs)
                environment: a SystemDictionary(lots of globals)
                category: #'Athens-Cairo'
                traitComposition: TCairoLibrary
                localSelectors: a Set(#asForm #createFormPaint: #stride
#setOperator: #writeToP...etc...
                uniqueSession: nil
                dispatch: nil
                dispatchStruct: nil

VGTigerDemo>>initialize
        Receiver: a VGTigerDemo
        Arguments and temporary variables:

        Receiver's instance variables:
                surface: nil

VGTigerDemo class(Behavior)>>new
        Receiver: VGTigerDemo
        Arguments and temporary variables:

        Receiver's instance variables:
                superclass: Object
                methodDict: a
MethodDictionary(#convertPathData2->(VGTigerDemo>>#convertPathDat...etc...
                format: 132
                instanceVariables: #('surface')
                organization: ('as yet unclassified' convertPathData2 initialize runDemo)

                subclasses: nil
                name: #VGTigerDemo
                classPool: nil
                sharedPools: nil
                environment: a SystemDictionary(lots of globals)
                category: #'Athens-Examples'
                traitComposition: {}
                localSelectors: nil

VGTigerDemo class>>runDemo
        Receiver: VGTigerDemo
        Arguments and temporary variables:

        Receiver's instance variables:
                superclass: Object
                methodDict: a
MethodDictionary(#convertPathData2->(VGTigerDemo>>#convertPathDat...etc...
                format: 132
                instanceVariables: #('surface')
                organization: ('as yet unclassified' convertPathData2 initialize runDemo)

                subclasses: nil
                name: #VGTigerDemo
                classPool: nil
                sharedPools: nil
                environment: a SystemDictionary(lots of globals)
                category: #'Athens-Examples'
                traitComposition: {}
                localSelectors: nil

UndefinedObject>>DoIt
        Receiver: nil
        Arguments and temporary variables:

        Receiver's instance variables:
nil

Compiler>>evaluate:in:to:notifying:ifFail:logged:
        Receiver: a Compiler
        Arguments and temporary variables:
                textOrStream: a ReadWriteStream
                aContext: nil
                receiver: nil
                aRequestor: a TextMorphForEditView(741605376)
                failBlock: [self morph flash.
        ^ nil]
                logFlag: true
                methodNode: DoIt
        ^ VGTigerDemo runDemo
                method: (UndefinedObject>>#DoIt "a CompiledMethod(926679040)")
                value: nil
                toLog: nil
                itsSelection: nil
                itsSelectionString: nil
        Receiver's instance variables:
                sourceStream: a ReadWriteStream
                requestor: a TextMorphForEditView(741605376)
                class: UndefinedObject
                category: nil
                context: nil
                parser: a Parser

[rcvr class evaluatorClass new
                evaluate: self selectionForDoitAsStream
                in: ctxt
                to: rcvr
                notifying: self morph
                ifFail: [self morph flash.
                        ^ nil]
                logged: true] in SmalltalkEditor>>evaluateSelectionAndDo:
        Receiver: a SmalltalkEditor
        Arguments and temporary variables:
                rcvr: nil
                ctxt: nil
        Receiver's instance variables:
                morph: a TextMorphForEditView(741605376)
                selectionShowing: true
                model: a Workspace
                editingState: a SmalltalkEditingState

BlockClosure>>on:do:
        Receiver: [rcvr class evaluatorClass new
                evaluate: self selectionForDoitAsStream
                in: ctxt
                to: ...etc...
        Arguments and temporary variables:
                exception: OutOfScopeNotification
                handlerAction: [:ex | ex resume: true]
                handlerActive: true
        Receiver's instance variables:
                outerContext: SmalltalkEditor>>evaluateSelectionAndDo:
                startpc: 110
                numArgs: 0

SmalltalkEditor>>evaluateSelectionAndDo:
        Receiver: a SmalltalkEditor
        Arguments and temporary variables:
                aBlock: [:result | result]
                result: nil
                rcvr: nil
                ctxt: nil
        Receiver's instance variables:
                morph: a TextMorphForEditView(741605376)
                selectionShowing: true
                model: a Workspace
                editingState: a SmalltalkEditingState

SmalltalkEditor>>evaluateSelection
        Receiver: a SmalltalkEditor
        Arguments and temporary variables:

        Receiver's instance variables:
                morph: a TextMorphForEditView(741605376)
                selectionShowing: true
                model: a Workspace
                editingState: a SmalltalkEditingState

SmalltalkEditor>>doIt
        Receiver: a SmalltalkEditor
        Arguments and temporary variables:

        Receiver's instance variables:
                morph: a TextMorphForEditView(741605376)
                selectionShowing: true
                model: a Workspace
                editingState: a SmalltalkEditingState

SmalltalkEditor>>doIt:
        Receiver: a SmalltalkEditor
        Arguments and temporary variables:
                aKeyboardEvent: [keystroke '<Cmd-d>']
        Receiver's instance variables:
                morph: a TextMorphForEditView(741605376)
                selectionShowing: true
                model: a Workspace
                editingState: a SmalltalkEditingState

SmalltalkEditor(TextEditor)>>performCmdActionsWith:shifted:return:
        Receiver: a SmalltalkEditor
        Arguments and temporary variables:
                aKeyboardEvent: [keystroke '<Cmd-d>']
                aBoolean: false
                return: [:val | ^ val]
                asciiValue: 101
                actions: #(#noop: #cursorHome: #noop: #noop: #cursorEnd: #noop:
#noop: #noop: #...etc...
                action: #doIt:
        Receiver's instance variables:
                morph: a TextMorphForEditView(741605376)
                selectionShowing: true
                model: a Workspace
                editingState: a SmalltalkEditingState

SmalltalkEditor(TextEditor)>>dispatchCommandOn:return:
        Receiver: a SmalltalkEditor
        Arguments and temporary variables:
                aKeyboardEvent: [keystroke '<Cmd-d>']
                return: [:val | ^ val]
                asciiValue: 100
                honorCommandKeys: true
                char: nil
        Receiver's instance variables:
                morph: a TextMorphForEditView(741605376)
                selectionShowing: true
                model: a Workspace
                editingState: a SmalltalkEditingState

SmalltalkEditor(TextEditor)>>dispatchOn:
        Receiver: a SmalltalkEditor
        Arguments and temporary variables:
                aKeyboardEvent: [keystroke '<Cmd-d>']
                char: nil
                return: [:val | ^ val]
                keyEvents: nil
        Receiver's instance variables:
                morph: a TextMorphForEditView(741605376)
                selectionShowing: true
                model: a Workspace
                editingState: a SmalltalkEditingState

[self dispatchOn: aKeyboardEvent] in SmalltalkEditor(TextEditor)>>keystroke:
        Receiver: a SmalltalkEditor
        Arguments and temporary variables:
                aKeyboardEvent: [keystroke '<Cmd-d>']
        Receiver's instance variables:
                morph: a TextMorphForEditView(741605376)
                selectionShowing: true
                model: a Workspace
                editingState: a SmalltalkEditingState

SmalltalkEditor(TextEditor)>>handleKeystrokeAction:
        Receiver: a SmalltalkEditor
        Arguments and temporary variables:
                aBlock: [self dispatchOn: aKeyboardEvent]
        Receiver's instance variables:
                morph: a TextMorphForEditView(741605376)
                selectionShowing: true
                model: a Workspace
                editingState: a SmalltalkEditingState

SmalltalkEditor(TextEditor)>>handleEditionAction:fromKeyboardEvent:
        Receiver: a SmalltalkEditor
        Arguments and temporary variables:
                anAction: [self dispatchOn: aKeyboardEvent]
                aKeyboardEvent: [keystroke '<Cmd-d>']
        Receiver's instance variables:
                morph: a TextMorphForEditView(741605376)
                selectionShowing: true
                model: a Workspace
                editingState: a SmalltalkEditingState

SmalltalkEditor(TextEditor)>>keystroke:
        Receiver: a SmalltalkEditor
        Arguments and temporary variables:
                aKeyboardEvent: [keystroke '<Cmd-d>']
        Receiver's instance variables:
                morph: a TextMorphForEditView(741605376)
                selectionShowing: true
                model: a Workspace
                editingState: a SmalltalkEditingState

[editor keystroke: evt] in [| action |
evt keyValue = 13
                ifTrue: [action := self crAction.
                        action
                                ifNotNil: [evt hand newKeyboardFocus: nil.
                                        ^ action value]].
        self
                handleInteraction: [editor keystroke: evt].
        self updateFromParagraph.
        super keyStroke: evt] in TextMorphForEditView(TextMorph)>>keyStroke:
        Receiver: a TextMorphForEditView(741605376)
        Arguments and temporary variables:
                evt: [keystroke '<Cmd-d>']
        Receiver's instance variables:
                bounds: (0@0) corner: (473@18)
                owner: a TransformMorph(38535168)
                submorphs: #()
                fullBounds: (0@0) corner: (473@18)
                color: Color black
                extension: a MorphExtension (824180736) [other:  (blinkStart ->
1085881) (myDep...etc...
                borderWidth: 0
                borderColor: Color black
                textStyle: a TextStyle Bitmap DejaVu Sans 9
                text: a Text for 'VGTigerDemo runDemo'
                wrapFlag: true
                paragraph: a Paragraph
                editor: a SmalltalkEditor
                container: nil
                predecessor: nil
                successor: nil
                backgroundColor: nil
                margins: (0@0) corner: (0@0)
                editView: a PluggableTextMorph(838860800)
                acceptOnCR: false
                autoAccept: false
                acceptOnFocusChange: false
                selectionColor: nil

TextMorphForEditView(TextMorph)>>handleInteraction:
        Receiver: a TextMorphForEditView(741605376)
        Arguments and temporary variables:
                interactionBlock: [editor keystroke: evt]
                oldEditor: a SmalltalkEditor
                oldParagraph: a Paragraph
                oldText: a Text for 'VGTigerDemo runDemo'
        Receiver's instance variables:
                bounds: (0@0) corner: (473@18)
                owner: a TransformMorph(38535168)
                submorphs: #()
                fullBounds: (0@0) corner: (473@18)
                color: Color black
                extension: a MorphExtension (824180736) [other:  (blinkStart ->
1085881) (myDep...etc...
                borderWidth: 0
                borderColor: Color black
                textStyle: a TextStyle Bitmap DejaVu Sans 9
                text: a Text for 'VGTigerDemo runDemo'
                wrapFlag: true
                paragraph: a Paragraph
                editor: a SmalltalkEditor
                container: nil
                predecessor: nil
                successor: nil
                backgroundColor: nil
                margins: (0@0) corner: (0@0)
                editView: a PluggableTextMorph(838860800)
                acceptOnCR: false
                autoAccept: false
                acceptOnFocusChange: false
                selectionColor: nil


--- The full stack ---
NBFFICallout(Object)>>error:
[:gen |
fnAddress := requestor nbGetSymbolAddress: fnSpec functionName module:
aModuleNameOrHandle.
        fnAddress
                ifNil: [self error: 'function unavailable'].
        self mayCallback
                ifTrue: [asm push: fnAddress asUImm32;
                                 mov: NativeBoost callgateFunctionAddress asUImm32 to: EAX;
                                 call: EAX]
                ifFalse: [asm mov: fnAddress asUImm32 to: EAX;
                                 call: EAX]] in NBFFICallout>>generateCall:module:
BlockClosure>>valueWithPossibleArgs:
[aFunctionBodyBlock valueWithPossibleArgs: {self. proxy. asm}.
        (self optEmitCall
                        or: [self optNoCleanup])
                ifTrue: [call disableCleanup]] in [:call |
self optNoAlignment
                ifTrue: [call alignment: 1].
        self pushArguments.
        coercionMayFail
                ifTrue: [proxy ifFailedJumpTo: self failedLabel].
        asm
                decorateWith: 'FFI: performing a call'
                while: [aFunctionBodyBlock valueWithPossibleArgs: {self. proxy. asm}.
                        (self optEmitCall
                                        or: [self optNoCleanup])
                                ifTrue: [call disableCleanup]]] in NBFFICallout>>generateInstructions:
BlockClosure>>ensure:
AJx86Assembler>>decorateWith:while:
[:call |
self optNoAlignment
                ifTrue: [call alignment: 1].
        self pushArguments.
        coercionMayFail
                ifTrue: [proxy ifFailedJumpTo: self failedLabel].
        asm
                decorateWith: 'FFI: performing a call'
                while: [aFunctionBodyBlock valueWithPossibleArgs: {self. proxy. asm}.
                        (self optEmitCall
                                        or: [self optNoCleanup])
                                ifTrue: [call disableCleanup]]] in NBFFICallout>>generateInstructions:
AJx86Assembler>>performingCall:in:
NBFFICallout>>foreignCall:
NBFFICallout>>generateInstructions:
NBFFICallout>>generate:
NBFFICallout>>generateCall:module:
[:gen | gen sender: sender;
                 callType: self nbCallingConvention;
                 generateCall: fnSpec module: self nbLibraryNameOrHandle] in
AthensCairoSurface class(Object)>>nbCall:
NBFFICallout class(NBNativeCodeGen class)>>generateCode:andRetry:
NBFFICallout class(NBNativeCodeGen class)>>handleFailureIn:nativeCode:
AthensCairoSurface class(Object)>>nbCall:
AthensCairoSurface class>>primImage:width:height:
AthensCairoSurface class>>extent:format:
AthensCairoSurface class>>extent:
VGTigerDemo>>initialize
VGTigerDemo class(Behavior)>>new
VGTigerDemo class>>runDemo
UndefinedObject>>DoIt
Compiler>>evaluate:in:to:notifying:ifFail:logged:
[rcvr class evaluatorClass new
                evaluate: self selectionForDoitAsStream
                in: ctxt
                to: rcvr
                notifying: self morph
                ifFail: [self morph flash.
                        ^ nil]
                logged: true] in SmalltalkEditor>>evaluateSelectionAndDo:
BlockClosure>>on:do:
SmalltalkEditor>>evaluateSelectionAndDo:
SmalltalkEditor>>evaluateSelection
SmalltalkEditor>>doIt
SmalltalkEditor>>doIt:
SmalltalkEditor(TextEditor)>>performCmdActionsWith:shifted:return:
SmalltalkEditor(TextEditor)>>dispatchCommandOn:return:
SmalltalkEditor(TextEditor)>>dispatchOn:
[self dispatchOn: aKeyboardEvent] in SmalltalkEditor(TextEditor)>>keystroke:
SmalltalkEditor(TextEditor)>>handleKeystrokeAction:
SmalltalkEditor(TextEditor)>>handleEditionAction:fromKeyboardEvent:
SmalltalkEditor(TextEditor)>>keystroke:
[editor keystroke: evt] in [| action |
evt keyValue = 13
                ifTrue: [action := self crAction.
                        action
                                ifNotNil: [evt hand newKeyboardFocus: nil.
                                        ^ action value]].
        self
                handleInteraction: [editor keystroke: evt].
        self updateFromParagraph.
        super keyStroke: evt] in TextMorphForEditView(TextMorph)>>keyStroke:
TextMorphForEditView(TextMorph)>>handleInteraction:
 - - - - - - - - - - - - - - -
                        - - - - - - - - - - - - - - - - - -
TextMorphForEditView>>handleInteraction:
[| action |
evt keyValue = 13
                ifTrue: [action := self crAction.
                        action
                                ifNotNil: [evt hand newKeyboardFocus: nil.
                                        ^ action value]].
        self
                handleInteraction: [editor keystroke: evt].
        self updateFromParagraph.
        super keyStroke: evt] in TextMorphForEditView(TextMorph)>>keyStroke:
ECToolSet class>>codeCompletionAround:textMorph:keyStroke:
ToolRegistry>>codeCompletionAround:textMorph:keyStroke:
SmalltalkEditor>>codeCompletionAround:textMorph:keyStroke:
TextMorphForEditView(TextMorph)>>keyStroke:
TextMorphForEditView>>keyStroke:
TextMorphForEditView(TextMorph)>>handleKeystroke:
KeyboardEvent>>sentTo:
TextMorphForEditView(Morph)>>handleEvent:
TextMorphForEditView(Morph)>>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>>sendKeyboardEvent:
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 MorphicUIManager>>spawnNewProcess
[self value.
        Processor terminateActive] in BlockClosure>>newProcess



--
Serge Stinckwich
UMI UMMISCO 209 (IRD/UPMC), Hanoi, Vietnam
Every DSL ends up being Smalltalk
http://doesnotunderstand.org/

_______________________________________________
Moose-dev mailing list
[hidden email]
https://www.iam.unibe.ch/mailman/listinfo/moose-dev
Reply | Threaded
Open this post in threaded view
|

Re: [Pharo-project] loading athens - a user perspective

Fernando olivero-2
In reply to this post by Tudor Girba-2
You shouldnt use Brew, because it cant compile universal binaries.

Athens, with a  cairo backend, uses NativeBoost which needs 32 bit
libraries, because CogGM is targeted to 32 bits.

I also tried with Brew, that's why i found out is hard to instruct
brew to compile universal binaries.

Fernando

On Fri, May 25, 2012 at 12:39 PM, Serge Stinckwich
<[hidden email]> wrote:

> On Fri, May 25, 2012 at 4:57 PM, Tudor Girba <[hidden email]> wrote:
>> Hi,
>>
>> Here is how to install Athens (I also added this comment to the ConfigurationOfAthens):
>>
>>
>> 1. Install Cairo on your machine
>> For example, for Mac, you open the terminal and run:
>> sudo port install -f cairo +universal
>>
>> More information can be found here:
>> http://cairographics.org/download/
>>
>>
>> 2. Download the NativeBoost enabled Cog VM from:
>> https://ci.lille.inria.fr/pharo/view/NativeBoost/
>>
>>
>> 3. Get a Pharo image and run:
>> Gofer new
>>        squeaksource: 'Athens';
>>        package: 'ConfigurationOfAthens';
>>        load.
>> (Smalltalk at: #ConfigurationOfAthens) loadDevelopment
>>
>>
>> 4. Play with it. For example:
>> VGTigerDemo runDemo
>
> I install Cairo with brew on mac os x:
> brew install cairo
>
> And I got the following stack trace:
>
>
> 25 May 2012 5:37:03 pm
>
> VM: Mac OS - intel - 1074 - NBCoInterpreter
> NativeBoost-CogPlugin-IgorStasenko.9 uuid:
> 801decd2-0b42-fa49-bcea-d7564d516a1b May  1 2012,
> StackToRegisterMappingCogit VMMaker-oscog-EstebanLorenzano.158 uuid:
> 82eded98-68af-4c80-a472-4f6de293adcf May  1 2012,
> https://git.gitorious.org/cogvm/blessed.git Commit:
> 6aa3fd0f1188078d3167dec1a53031a61b97b688 Date: Tue May 1 20:28:14 2012
> +0200 By: Esteban Lorenzano <[hidden email]>
> Image: Pharo1.4a [Latest update: #14418]
>
> NBFFICallout(Object)>>error:
>        Receiver: a NBFFICallout
>        Arguments and temporary variables:
>                aString:        'function unavailable'
>        Receiver's instance variables:
>                asm:    an AJx86Assembler
>                proxy:  a NBInterpreterProxy
>                options:        a Set(#optCdecl #optAllowByteArraysPtr #optUseStackPointer
> #optReturnP...etc...
>                method:         (AthensCairoSurface class>>#primImage:width:height: "a
> CompiledMethod(4...etc...
>                fnSpec:         a NBFnSpec
>                requestor:      AthensCairoSurface class
>                methodArgs:     an OrderedCollection('aFormat' 'aWidth' 'aHeight')
>                coercionMayFail:        true
>                callInfo:       an AJCdeclCallInfo
>
> [:gen |
> fnAddress := requestor nbGetSymbolAddress: fnSpec functionName module:
> aModuleNameOrHandle.
>        fnAddress
>                ifNil: [self error: 'function unavailable'].
>        self mayCallback
>                ifTrue: [asm push: fnAddress asUImm32;
>                                 mov: NativeBoost callgateFunctionAddress asUImm32 to: EAX;
>                                 call: EAX]
>                ifFalse: [asm mov: fnAddress asUImm32 to: EAX;
>                                 call: EAX]] in NBFFICallout>>generateCall:module:
>        Receiver: a NBFFICallout
>        Arguments and temporary variables:
>                aModuleNameOrHandle:    a NBFFICallout
>                fnAddress:      '/opt/local/lib/libcairo.2.dylib'
>                gen:    #(nil)
>        Receiver's instance variables:
>                asm:    an AJx86Assembler
>                proxy:  a NBInterpreterProxy
>                options:        a Set(#optCdecl #optAllowByteArraysPtr #optUseStackPointer
> #optReturnP...etc...
>                method:         (AthensCairoSurface class>>#primImage:width:height: "a
> CompiledMethod(4...etc...
>                fnSpec:         a NBFnSpec
>                requestor:      AthensCairoSurface class
>                methodArgs:     an OrderedCollection('aFormat' 'aWidth' 'aHeight')
>                coercionMayFail:        true
>                callInfo:       an AJCdeclCallInfo
>
> BlockClosure>>valueWithPossibleArgs:
>        Receiver: [:gen |
> fnAddress := requestor nbGetSymbolAddress: fnSpec functionName module:
> aModuleNam...etc...
>        Arguments and temporary variables:
>                anArray:        an Array(a NBFFICallout a NBInterpreterProxy an AJx86Assembler)
>        Receiver's instance variables:
>                outerContext:   NBFFICallout>>generateCall:module:
>                startpc:        91
>                numArgs:        1
>
> [aFunctionBodyBlock valueWithPossibleArgs: {self. proxy. asm}.
>        (self optEmitCall
>                        or: [self optNoCleanup])
>                ifTrue: [call disableCleanup]] in [:call |
> self optNoAlignment
>                ifTrue: [call alignment: 1].
>        self pushArguments.
>        coercionMayFail
>                ifTrue: [proxy ifFailedJumpTo: self failedLabel].
>        asm
>                decorateWith: 'FFI: performing a call'
>                while: [aFunctionBodyBlock valueWithPossibleArgs: {self. proxy. asm}.
>                        (self optEmitCall
>                                        or: [self optNoCleanup])
>                                ifTrue: [call disableCleanup]]] in NBFFICallout>>generateInstructions:
>        Receiver: a NBFFICallout
>        Arguments and temporary variables:
>                aFunctionBodyBlock:     an AJCdeclCallInfo
>                call:   [:gen |
> fnAddress := requestor nbGetSymbolAddress: fnSpec functionName m...etc...
>        Receiver's instance variables:
>                asm:    an AJx86Assembler
>                proxy:  a NBInterpreterProxy
>                options:        a Set(#optCdecl #optAllowByteArraysPtr #optUseStackPointer
> #optReturnP...etc...
>                method:         (AthensCairoSurface class>>#primImage:width:height: "a
> CompiledMethod(4...etc...
>                fnSpec:         a NBFnSpec
>                requestor:      AthensCairoSurface class
>                methodArgs:     an OrderedCollection('aFormat' 'aWidth' 'aHeight')
>                coercionMayFail:        true
>                callInfo:       an AJCdeclCallInfo
>
> BlockClosure>>ensure:
>        Receiver: [aFunctionBodyBlock valueWithPossibleArgs: {self. proxy. asm}.
>        (self optEmitCall
>                        or: [...etc...
>        Arguments and temporary variables:
>                aBlock:         [level := level - 1.
>        self
>                addInstruction: (AJInstructionDecoration n...etc...
>                complete:       nil
>                returnValue:    nil
>        Receiver's instance variables:
>                outerContext:   [:call |
> self optNoAlignment
>                ifTrue: [call alignment: 1].
>        sel...etc...
>                startpc:        151
>                numArgs:        0
>
> AJx86Assembler>>decorateWith:while:
>        Receiver: an AJx86Assembler
>        Arguments and temporary variables:
>                annotation:     'FFI: performing a call'
>                aBlock:         [aFunctionBodyBlock valueWithPossibleArgs: {self. proxy. asm}.
>        (self o...etc...
>        Receiver's instance variables:
>                instructions:   <<error during printing>>
>
> [:call |
> self optNoAlignment
>                ifTrue: [call alignment: 1].
>        self pushArguments.
>        coercionMayFail
>                ifTrue: [proxy ifFailedJumpTo: self failedLabel].
>        asm
>                decorateWith: 'FFI: performing a call'
>                while: [aFunctionBodyBlock valueWithPossibleArgs: {self. proxy. asm}.
>                        (self optEmitCall
>                                        or: [self optNoCleanup])
>                                ifTrue: [call disableCleanup]]] in NBFFICallout>>generateInstructions:
>        Receiver: a NBFFICallout
>        Arguments and temporary variables:
>                aFunctionBodyBlock:     an AJCdeclCallInfo
>                call:   [:gen |
> fnAddress := requestor nbGetSymbolAddress: fnSpec functionName m...etc...
>        Receiver's instance variables:
>                asm:    an AJx86Assembler
>                proxy:  a NBInterpreterProxy
>                options:        a Set(#optCdecl #optAllowByteArraysPtr #optUseStackPointer
> #optReturnP...etc...
>                method:         (AthensCairoSurface class>>#primImage:width:height: "a
> CompiledMethod(4...etc...
>                fnSpec:         a NBFnSpec
>                requestor:      AthensCairoSurface class
>                methodArgs:     an OrderedCollection('aFormat' 'aWidth' 'aHeight')
>                coercionMayFail:        true
>                callInfo:       an AJCdeclCallInfo
>
> AJx86Assembler>>performingCall:in:
>        Receiver: an AJx86Assembler
>        Arguments and temporary variables:
>                ci:     an AJCdeclCallInfo
>                aBlock:         [:call |
> self optNoAlignment
>                ifTrue: [call alignment: 1].
>        self push...etc...
>        Receiver's instance variables:
>                instructions:   <<error during printing>>
>
> NBFFICallout>>foreignCall:
>        Receiver: a NBFFICallout
>        Arguments and temporary variables:
>                aBlock:         [:call |
> self optNoAlignment
>                ifTrue: [call alignment: 1].
>        self push...etc...
>        Receiver's instance variables:
>                asm:    an AJx86Assembler
>                proxy:  a NBInterpreterProxy
>                options:        a Set(#optCdecl #optAllowByteArraysPtr #optUseStackPointer
> #optReturnP...etc...
>                method:         (AthensCairoSurface class>>#primImage:width:height: "a
> CompiledMethod(4...etc...
>                fnSpec:         a NBFnSpec
>                requestor:      AthensCairoSurface class
>                methodArgs:     an OrderedCollection('aFormat' 'aWidth' 'aHeight')
>                coercionMayFail:        true
>                callInfo:       an AJCdeclCallInfo
>
> NBFFICallout>>generateInstructions:
>        Receiver: a NBFFICallout
>        Arguments and temporary variables:
>                aFunctionBodyBlock:     [:gen |
> fnAddress := requestor nbGetSymbolAddress: fnSpec ...etc...
>                instructions:   nil
>        Receiver's instance variables:
>                asm:    an AJx86Assembler
>                proxy:  a NBInterpreterProxy
>                options:        a Set(#optCdecl #optAllowByteArraysPtr #optUseStackPointer
> #optReturnP...etc...
>                method:         (AthensCairoSurface class>>#primImage:width:height: "a
> CompiledMethod(4...etc...
>                fnSpec:         a NBFnSpec
>                requestor:      AthensCairoSurface class
>                methodArgs:     an OrderedCollection('aFormat' 'aWidth' 'aHeight')
>                coercionMayFail:        true
>                callInfo:       an AJCdeclCallInfo
>
> NBFFICallout>>generate:
>        Receiver: a NBFFICallout
>        Arguments and temporary variables:
>                aFunctionBodyBlock:     [:gen |
> fnAddress := requestor nbGetSymbolAddress: fnSpec ...etc...
>                generatedCode:  nil
>        Receiver's instance variables:
>                asm:    an AJx86Assembler
>                proxy:  a NBInterpreterProxy
>                options:        a Set(#optCdecl #optAllowByteArraysPtr #optUseStackPointer
> #optReturnP...etc...
>                method:         (AthensCairoSurface class>>#primImage:width:height: "a
> CompiledMethod(4...etc...
>                fnSpec:         a NBFnSpec
>                requestor:      AthensCairoSurface class
>                methodArgs:     an OrderedCollection('aFormat' 'aWidth' 'aHeight')
>                coercionMayFail:        true
>                callInfo:       an AJCdeclCallInfo
>
> NBFFICallout>>generateCall:module:
>        Receiver: a NBFFICallout
>        Arguments and temporary variables:
>                functionSpec:   #(#AthensCairoSurface #cairo_image_surface_create
> #(#int #aFormat...etc...
>                aModuleNameOrHandle:    '/opt/local/lib/libcairo.2.dylib'
>                fnAddress:      #(nil)
>        Receiver's instance variables:
>                asm:    an AJx86Assembler
>                proxy:  a NBInterpreterProxy
>                options:        a Set(#optCdecl #optAllowByteArraysPtr #optUseStackPointer
> #optReturnP...etc...
>                method:         (AthensCairoSurface class>>#primImage:width:height: "a
> CompiledMethod(4...etc...
>                fnSpec:         a NBFnSpec
>                requestor:      AthensCairoSurface class
>                methodArgs:     an OrderedCollection('aFormat' 'aWidth' 'aHeight')
>                coercionMayFail:        true
>                callInfo:       an AJCdeclCallInfo
>
> [:gen | gen sender: sender;
>                 callType: self nbCallingConvention;
>                 generateCall: fnSpec module: self nbLibraryNameOrHandle] in
> AthensCairoSurface class(Object)>>nbCall:
>        Receiver: AthensCairoSurface
>        Arguments and temporary variables:
>                fnSpec:         a NBFFICallout
>                sender:         #(#AthensCairoSurface #cairo_image_surface_create #(#int
> #aFormat #, #i...etc...
>                gen:    AthensCairoSurface class>>primImage:width:height:
>        Receiver's instance variables:
>                superclass:     AthensSurface
>                methodDict:     a
> MethodDictionary(#asAthensPaintOn:->(AthensCairoSurface>>#asAthen...etc...
>                format:         140
>                instanceVariables:      #('handle' 'context' 'builder' 'id')
>                organization:   ('converting' asAthensPaintOn: writeToPng:)
> ('as yet unclassified...etc...
>                subclasses:     {AthensCairoPDFSurface}
>                name:   #AthensCairoSurface
>                classPool:      nil
>                sharedPools:    an OrderedCollection(AthensCairoDefs)
>                environment:    a SystemDictionary(lots of globals)
>                category:       #'Athens-Cairo'
>                traitComposition:       TCairoLibrary
>                localSelectors:         a Set(#asForm #createFormPaint: #stride
> #setOperator: #writeToP...etc...
>                uniqueSession:  nil
>                dispatch:       nil
>                dispatchStruct:         nil
>
> NBFFICallout class(NBNativeCodeGen class)>>generateCode:andRetry:
>        Receiver: NBFFICallout
>        Arguments and temporary variables:
>                aBlock:         [:gen | gen sender: sender;
>                 callType: self nbCallingConvention;
>                 g...etc...
>                retryCtx:       AthensCairoSurface class>>primImage:width:height:
>                method:         (AthensCairoSurface class>>#primImage:width:height: "a
> CompiledMethod(4...etc...
>                code:   nil
>                newMethod:      nil
>                args:   nil
>                i:      nil
>                iLimiT:         nil
>        Receiver's instance variables:
>                superclass:     NBNativeCodeGen
>                methodDict:     a
> MethodDictionary(#aliasForType:->(NBFFICallout>>#aliasForType:
> "a...etc...
>                format:         148
>                instanceVariables:      #('fnSpec' 'requestor' 'methodArgs'
> 'coercionMayFail' 'callI...etc...
>                organization:   ('type aliases' aliasForType:)
> ('accessing' anonSpec: callType: c...etc...
>                subclasses:     {NBNativeFunctionGen}
>                name:   #NBFFICallout
>                classPool:      a Dictionary(#CustomErrorCodes->nil
> #CustomErrorMessages->nil #TypeA...etc...
>                sharedPools:    nil
>                environment:    a SystemDictionary(lots of globals)
>                category:       #'NativeBoost-Core'
>                traitComposition:       {}
>                localSelectors:         nil
>
> NBFFICallout class(NBNativeCodeGen class)>>handleFailureIn:nativeCode:
>        Receiver: NBFFICallout
>        Arguments and temporary variables:
>                aContext:       AthensCairoSurface class>>primImage:width:height:
>                aBlock:         [:gen | gen sender: sender;
>                 callType: self nbCallingConvention;
>                 g...etc...
>                method:         (AthensCairoSurface class>>#primImage:width:height: "a
> CompiledMethod(4...etc...
>                lastError:      502
>        Receiver's instance variables:
>                superclass:     NBNativeCodeGen
>                methodDict:     a
> MethodDictionary(#aliasForType:->(NBFFICallout>>#aliasForType:
> "a...etc...
>                format:         148
>                instanceVariables:      #('fnSpec' 'requestor' 'methodArgs'
> 'coercionMayFail' 'callI...etc...
>                organization:   ('type aliases' aliasForType:)
> ('accessing' anonSpec: callType: c...etc...
>                subclasses:     {NBNativeFunctionGen}
>                name:   #NBFFICallout
>                classPool:      a Dictionary(#CustomErrorCodes->nil
> #CustomErrorMessages->nil #TypeA...etc...
>                sharedPools:    nil
>                environment:    a SystemDictionary(lots of globals)
>                category:       #'NativeBoost-Core'
>                traitComposition:       {}
>                localSelectors:         nil
>
> AthensCairoSurface class(Object)>>nbCall:
>        Receiver: AthensCairoSurface
>        Arguments and temporary variables:
>                fnSpec:         #(#AthensCairoSurface #cairo_image_surface_create #(#int
> #aFormat #, #i...etc...
>                sender:         AthensCairoSurface class>>primImage:width:height:
>        Receiver's instance variables:
>                superclass:     AthensSurface
>                methodDict:     a
> MethodDictionary(#asAthensPaintOn:->(AthensCairoSurface>>#asAthen...etc...
>                format:         140
>                instanceVariables:      #('handle' 'context' 'builder' 'id')
>                organization:   ('converting' asAthensPaintOn: writeToPng:)
> ('as yet unclassified...etc...
>                subclasses:     {AthensCairoPDFSurface}
>                name:   #AthensCairoSurface
>                classPool:      nil
>                sharedPools:    an OrderedCollection(AthensCairoDefs)
>                environment:    a SystemDictionary(lots of globals)
>                category:       #'Athens-Cairo'
>                traitComposition:       TCairoLibrary
>                localSelectors:         a Set(#asForm #createFormPaint: #stride
> #setOperator: #writeToP...etc...
>                uniqueSession:  nil
>                dispatch:       nil
>                dispatchStruct:         nil
>
> AthensCairoSurface class>>primImage:width:height:
>        Receiver: AthensCairoSurface
>        Arguments and temporary variables:
>                aFormat:        0
>                aWidth:         800
>                aHeight:        800
>        Receiver's instance variables:
>                superclass:     AthensSurface
>                methodDict:     a
> MethodDictionary(#asAthensPaintOn:->(AthensCairoSurface>>#asAthen...etc...
>                format:         140
>                instanceVariables:      #('handle' 'context' 'builder' 'id')
>                organization:   ('converting' asAthensPaintOn: writeToPng:)
> ('as yet unclassified...etc...
>                subclasses:     {AthensCairoPDFSurface}
>                name:   #AthensCairoSurface
>                classPool:      nil
>                sharedPools:    an OrderedCollection(AthensCairoDefs)
>                environment:    a SystemDictionary(lots of globals)
>                category:       #'Athens-Cairo'
>                traitComposition:       TCairoLibrary
>                localSelectors:         a Set(#asForm #createFormPaint: #stride
> #setOperator: #writeToP...etc...
>                uniqueSession:  nil
>                dispatch:       nil
>                dispatchStruct:         nil
>
> AthensCairoSurface class>>extent:format:
>        Receiver: AthensCairoSurface
>        Arguments and temporary variables:
>                anExtent:       (800@800)
>                aFormat:        0
>        Receiver's instance variables:
>                superclass:     AthensSurface
>                methodDict:     a
> MethodDictionary(#asAthensPaintOn:->(AthensCairoSurface>>#asAthen...etc...
>                format:         140
>                instanceVariables:      #('handle' 'context' 'builder' 'id')
>                organization:   ('converting' asAthensPaintOn: writeToPng:)
> ('as yet unclassified...etc...
>                subclasses:     {AthensCairoPDFSurface}
>                name:   #AthensCairoSurface
>                classPool:      nil
>                sharedPools:    an OrderedCollection(AthensCairoDefs)
>                environment:    a SystemDictionary(lots of globals)
>                category:       #'Athens-Cairo'
>                traitComposition:       TCairoLibrary
>                localSelectors:         a Set(#asForm #createFormPaint: #stride
> #setOperator: #writeToP...etc...
>                uniqueSession:  nil
>                dispatch:       nil
>                dispatchStruct:         nil
>
> AthensCairoSurface class>>extent:
>        Receiver: AthensCairoSurface
>        Arguments and temporary variables:
>                anExtent:       (800@800)
>        Receiver's instance variables:
>                superclass:     AthensSurface
>                methodDict:     a
> MethodDictionary(#asAthensPaintOn:->(AthensCairoSurface>>#asAthen...etc...
>                format:         140
>                instanceVariables:      #('handle' 'context' 'builder' 'id')
>                organization:   ('converting' asAthensPaintOn: writeToPng:)
> ('as yet unclassified...etc...
>                subclasses:     {AthensCairoPDFSurface}
>                name:   #AthensCairoSurface
>                classPool:      nil
>                sharedPools:    an OrderedCollection(AthensCairoDefs)
>                environment:    a SystemDictionary(lots of globals)
>                category:       #'Athens-Cairo'
>                traitComposition:       TCairoLibrary
>                localSelectors:         a Set(#asForm #createFormPaint: #stride
> #setOperator: #writeToP...etc...
>                uniqueSession:  nil
>                dispatch:       nil
>                dispatchStruct:         nil
>
> VGTigerDemo>>initialize
>        Receiver: a VGTigerDemo
>        Arguments and temporary variables:
>
>        Receiver's instance variables:
>                surface:        nil
>
> VGTigerDemo class(Behavior)>>new
>        Receiver: VGTigerDemo
>        Arguments and temporary variables:
>
>        Receiver's instance variables:
>                superclass:     Object
>                methodDict:     a
> MethodDictionary(#convertPathData2->(VGTigerDemo>>#convertPathDat...etc...
>                format:         132
>                instanceVariables:      #('surface')
>                organization:   ('as yet unclassified' convertPathData2 initialize runDemo)
>
>                subclasses:     nil
>                name:   #VGTigerDemo
>                classPool:      nil
>                sharedPools:    nil
>                environment:    a SystemDictionary(lots of globals)
>                category:       #'Athens-Examples'
>                traitComposition:       {}
>                localSelectors:         nil
>
> VGTigerDemo class>>runDemo
>        Receiver: VGTigerDemo
>        Arguments and temporary variables:
>
>        Receiver's instance variables:
>                superclass:     Object
>                methodDict:     a
> MethodDictionary(#convertPathData2->(VGTigerDemo>>#convertPathDat...etc...
>                format:         132
>                instanceVariables:      #('surface')
>                organization:   ('as yet unclassified' convertPathData2 initialize runDemo)
>
>                subclasses:     nil
>                name:   #VGTigerDemo
>                classPool:      nil
>                sharedPools:    nil
>                environment:    a SystemDictionary(lots of globals)
>                category:       #'Athens-Examples'
>                traitComposition:       {}
>                localSelectors:         nil
>
> UndefinedObject>>DoIt
>        Receiver: nil
>        Arguments and temporary variables:
>
>        Receiver's instance variables:
> nil
>
> Compiler>>evaluate:in:to:notifying:ifFail:logged:
>        Receiver: a Compiler
>        Arguments and temporary variables:
>                textOrStream:   a ReadWriteStream
>                aContext:       nil
>                receiver:       nil
>                aRequestor:     a TextMorphForEditView(741605376)
>                failBlock:      [self morph flash.
>        ^ nil]
>                logFlag:        true
>                methodNode:     DoIt
>        ^ VGTigerDemo runDemo
>                method:         (UndefinedObject>>#DoIt "a CompiledMethod(926679040)")
>                value:  nil
>                toLog:  nil
>                itsSelection:   nil
>                itsSelectionString:     nil
>        Receiver's instance variables:
>                sourceStream:   a ReadWriteStream
>                requestor:      a TextMorphForEditView(741605376)
>                class:  UndefinedObject
>                category:       nil
>                context:        nil
>                parser:         a Parser
>
> [rcvr class evaluatorClass new
>                evaluate: self selectionForDoitAsStream
>                in: ctxt
>                to: rcvr
>                notifying: self morph
>                ifFail: [self morph flash.
>                        ^ nil]
>                logged: true] in SmalltalkEditor>>evaluateSelectionAndDo:
>        Receiver: a SmalltalkEditor
>        Arguments and temporary variables:
>                rcvr:   nil
>                ctxt:   nil
>        Receiver's instance variables:
>                morph:  a TextMorphForEditView(741605376)
>                selectionShowing:       true
>                model:  a Workspace
>                editingState:   a SmalltalkEditingState
>
> BlockClosure>>on:do:
>        Receiver: [rcvr class evaluatorClass new
>                evaluate: self selectionForDoitAsStream
>                in: ctxt
>                to: ...etc...
>        Arguments and temporary variables:
>                exception:      OutOfScopeNotification
>                handlerAction:  [:ex | ex resume: true]
>                handlerActive:  true
>        Receiver's instance variables:
>                outerContext:   SmalltalkEditor>>evaluateSelectionAndDo:
>                startpc:        110
>                numArgs:        0
>
> SmalltalkEditor>>evaluateSelectionAndDo:
>        Receiver: a SmalltalkEditor
>        Arguments and temporary variables:
>                aBlock:         [:result | result]
>                result:         nil
>                rcvr:   nil
>                ctxt:   nil
>        Receiver's instance variables:
>                morph:  a TextMorphForEditView(741605376)
>                selectionShowing:       true
>                model:  a Workspace
>                editingState:   a SmalltalkEditingState
>
> SmalltalkEditor>>evaluateSelection
>        Receiver: a SmalltalkEditor
>        Arguments and temporary variables:
>
>        Receiver's instance variables:
>                morph:  a TextMorphForEditView(741605376)
>                selectionShowing:       true
>                model:  a Workspace
>                editingState:   a SmalltalkEditingState
>
> SmalltalkEditor>>doIt
>        Receiver: a SmalltalkEditor
>        Arguments and temporary variables:
>
>        Receiver's instance variables:
>                morph:  a TextMorphForEditView(741605376)
>                selectionShowing:       true
>                model:  a Workspace
>                editingState:   a SmalltalkEditingState
>
> SmalltalkEditor>>doIt:
>        Receiver: a SmalltalkEditor
>        Arguments and temporary variables:
>                aKeyboardEvent:         [keystroke '<Cmd-d>']
>        Receiver's instance variables:
>                morph:  a TextMorphForEditView(741605376)
>                selectionShowing:       true
>                model:  a Workspace
>                editingState:   a SmalltalkEditingState
>
> SmalltalkEditor(TextEditor)>>performCmdActionsWith:shifted:return:
>        Receiver: a SmalltalkEditor
>        Arguments and temporary variables:
>                aKeyboardEvent:         [keystroke '<Cmd-d>']
>                aBoolean:       false
>                return:         [:val | ^ val]
>                asciiValue:     101
>                actions:        #(#noop: #cursorHome: #noop: #noop: #cursorEnd: #noop:
> #noop: #noop: #...etc...
>                action:         #doIt:
>        Receiver's instance variables:
>                morph:  a TextMorphForEditView(741605376)
>                selectionShowing:       true
>                model:  a Workspace
>                editingState:   a SmalltalkEditingState
>
> SmalltalkEditor(TextEditor)>>dispatchCommandOn:return:
>        Receiver: a SmalltalkEditor
>        Arguments and temporary variables:
>                aKeyboardEvent:         [keystroke '<Cmd-d>']
>                return:         [:val | ^ val]
>                asciiValue:     100
>                honorCommandKeys:       true
>                char:   nil
>        Receiver's instance variables:
>                morph:  a TextMorphForEditView(741605376)
>                selectionShowing:       true
>                model:  a Workspace
>                editingState:   a SmalltalkEditingState
>
> SmalltalkEditor(TextEditor)>>dispatchOn:
>        Receiver: a SmalltalkEditor
>        Arguments and temporary variables:
>                aKeyboardEvent:         [keystroke '<Cmd-d>']
>                char:   nil
>                return:         [:val | ^ val]
>                keyEvents:      nil
>        Receiver's instance variables:
>                morph:  a TextMorphForEditView(741605376)
>                selectionShowing:       true
>                model:  a Workspace
>                editingState:   a SmalltalkEditingState
>
> [self dispatchOn: aKeyboardEvent] in SmalltalkEditor(TextEditor)>>keystroke:
>        Receiver: a SmalltalkEditor
>        Arguments and temporary variables:
>                aKeyboardEvent:         [keystroke '<Cmd-d>']
>        Receiver's instance variables:
>                morph:  a TextMorphForEditView(741605376)
>                selectionShowing:       true
>                model:  a Workspace
>                editingState:   a SmalltalkEditingState
>
> SmalltalkEditor(TextEditor)>>handleKeystrokeAction:
>        Receiver: a SmalltalkEditor
>        Arguments and temporary variables:
>                aBlock:         [self dispatchOn: aKeyboardEvent]
>        Receiver's instance variables:
>                morph:  a TextMorphForEditView(741605376)
>                selectionShowing:       true
>                model:  a Workspace
>                editingState:   a SmalltalkEditingState
>
> SmalltalkEditor(TextEditor)>>handleEditionAction:fromKeyboardEvent:
>        Receiver: a SmalltalkEditor
>        Arguments and temporary variables:
>                anAction:       [self dispatchOn: aKeyboardEvent]
>                aKeyboardEvent:         [keystroke '<Cmd-d>']
>        Receiver's instance variables:
>                morph:  a TextMorphForEditView(741605376)
>                selectionShowing:       true
>                model:  a Workspace
>                editingState:   a SmalltalkEditingState
>
> SmalltalkEditor(TextEditor)>>keystroke:
>        Receiver: a SmalltalkEditor
>        Arguments and temporary variables:
>                aKeyboardEvent:         [keystroke '<Cmd-d>']
>        Receiver's instance variables:
>                morph:  a TextMorphForEditView(741605376)
>                selectionShowing:       true
>                model:  a Workspace
>                editingState:   a SmalltalkEditingState
>
> [editor keystroke: evt] in [| action |
> evt keyValue = 13
>                ifTrue: [action := self crAction.
>                        action
>                                ifNotNil: [evt hand newKeyboardFocus: nil.
>                                        ^ action value]].
>        self
>                handleInteraction: [editor keystroke: evt].
>        self updateFromParagraph.
>        super keyStroke: evt] in TextMorphForEditView(TextMorph)>>keyStroke:
>        Receiver: a TextMorphForEditView(741605376)
>        Arguments and temporary variables:
>                evt:    [keystroke '<Cmd-d>']
>        Receiver's instance variables:
>                bounds:         (0@0) corner: (473@18)
>                owner:  a TransformMorph(38535168)
>                submorphs:      #()
>                fullBounds:     (0@0) corner: (473@18)
>                color:  Color black
>                extension:      a MorphExtension (824180736) [other:  (blinkStart ->
> 1085881) (myDep...etc...
>                borderWidth:    0
>                borderColor:    Color black
>                textStyle:      a TextStyle Bitmap DejaVu Sans 9
>                text:   a Text for 'VGTigerDemo runDemo'
>                wrapFlag:       true
>                paragraph:      a Paragraph
>                editor:         a SmalltalkEditor
>                container:      nil
>                predecessor:    nil
>                successor:      nil
>                backgroundColor:        nil
>                margins:        (0@0) corner: (0@0)
>                editView:       a PluggableTextMorph(838860800)
>                acceptOnCR:     false
>                autoAccept:     false
>                acceptOnFocusChange:    false
>                selectionColor:         nil
>
> TextMorphForEditView(TextMorph)>>handleInteraction:
>        Receiver: a TextMorphForEditView(741605376)
>        Arguments and temporary variables:
>                interactionBlock:       [editor keystroke: evt]
>                oldEditor:      a SmalltalkEditor
>                oldParagraph:   a Paragraph
>                oldText:        a Text for 'VGTigerDemo runDemo'
>        Receiver's instance variables:
>                bounds:         (0@0) corner: (473@18)
>                owner:  a TransformMorph(38535168)
>                submorphs:      #()
>                fullBounds:     (0@0) corner: (473@18)
>                color:  Color black
>                extension:      a MorphExtension (824180736) [other:  (blinkStart ->
> 1085881) (myDep...etc...
>                borderWidth:    0
>                borderColor:    Color black
>                textStyle:      a TextStyle Bitmap DejaVu Sans 9
>                text:   a Text for 'VGTigerDemo runDemo'
>                wrapFlag:       true
>                paragraph:      a Paragraph
>                editor:         a SmalltalkEditor
>                container:      nil
>                predecessor:    nil
>                successor:      nil
>                backgroundColor:        nil
>                margins:        (0@0) corner: (0@0)
>                editView:       a PluggableTextMorph(838860800)
>                acceptOnCR:     false
>                autoAccept:     false
>                acceptOnFocusChange:    false
>                selectionColor:         nil
>
>
> --- The full stack ---
> NBFFICallout(Object)>>error:
> [:gen |
> fnAddress := requestor nbGetSymbolAddress: fnSpec functionName module:
> aModuleNameOrHandle.
>        fnAddress
>                ifNil: [self error: 'function unavailable'].
>        self mayCallback
>                ifTrue: [asm push: fnAddress asUImm32;
>                                 mov: NativeBoost callgateFunctionAddress asUImm32 to: EAX;
>                                 call: EAX]
>                ifFalse: [asm mov: fnAddress asUImm32 to: EAX;
>                                 call: EAX]] in NBFFICallout>>generateCall:module:
> BlockClosure>>valueWithPossibleArgs:
> [aFunctionBodyBlock valueWithPossibleArgs: {self. proxy. asm}.
>        (self optEmitCall
>                        or: [self optNoCleanup])
>                ifTrue: [call disableCleanup]] in [:call |
> self optNoAlignment
>                ifTrue: [call alignment: 1].
>        self pushArguments.
>        coercionMayFail
>                ifTrue: [proxy ifFailedJumpTo: self failedLabel].
>        asm
>                decorateWith: 'FFI: performing a call'
>                while: [aFunctionBodyBlock valueWithPossibleArgs: {self. proxy. asm}.
>                        (self optEmitCall
>                                        or: [self optNoCleanup])
>                                ifTrue: [call disableCleanup]]] in NBFFICallout>>generateInstructions:
> BlockClosure>>ensure:
> AJx86Assembler>>decorateWith:while:
> [:call |
> self optNoAlignment
>                ifTrue: [call alignment: 1].
>        self pushArguments.
>        coercionMayFail
>                ifTrue: [proxy ifFailedJumpTo: self failedLabel].
>        asm
>                decorateWith: 'FFI: performing a call'
>                while: [aFunctionBodyBlock valueWithPossibleArgs: {self. proxy. asm}.
>                        (self optEmitCall
>                                        or: [self optNoCleanup])
>                                ifTrue: [call disableCleanup]]] in NBFFICallout>>generateInstructions:
> AJx86Assembler>>performingCall:in:
> NBFFICallout>>foreignCall:
> NBFFICallout>>generateInstructions:
> NBFFICallout>>generate:
> NBFFICallout>>generateCall:module:
> [:gen | gen sender: sender;
>                 callType: self nbCallingConvention;
>                 generateCall: fnSpec module: self nbLibraryNameOrHandle] in
> AthensCairoSurface class(Object)>>nbCall:
> NBFFICallout class(NBNativeCodeGen class)>>generateCode:andRetry:
> NBFFICallout class(NBNativeCodeGen class)>>handleFailureIn:nativeCode:
> AthensCairoSurface class(Object)>>nbCall:
> AthensCairoSurface class>>primImage:width:height:
> AthensCairoSurface class>>extent:format:
> AthensCairoSurface class>>extent:
> VGTigerDemo>>initialize
> VGTigerDemo class(Behavior)>>new
> VGTigerDemo class>>runDemo
> UndefinedObject>>DoIt
> Compiler>>evaluate:in:to:notifying:ifFail:logged:
> [rcvr class evaluatorClass new
>                evaluate: self selectionForDoitAsStream
>                in: ctxt
>                to: rcvr
>                notifying: self morph
>                ifFail: [self morph flash.
>                        ^ nil]
>                logged: true] in SmalltalkEditor>>evaluateSelectionAndDo:
> BlockClosure>>on:do:
> SmalltalkEditor>>evaluateSelectionAndDo:
> SmalltalkEditor>>evaluateSelection
> SmalltalkEditor>>doIt
> SmalltalkEditor>>doIt:
> SmalltalkEditor(TextEditor)>>performCmdActionsWith:shifted:return:
> SmalltalkEditor(TextEditor)>>dispatchCommandOn:return:
> SmalltalkEditor(TextEditor)>>dispatchOn:
> [self dispatchOn: aKeyboardEvent] in SmalltalkEditor(TextEditor)>>keystroke:
> SmalltalkEditor(TextEditor)>>handleKeystrokeAction:
> SmalltalkEditor(TextEditor)>>handleEditionAction:fromKeyboardEvent:
> SmalltalkEditor(TextEditor)>>keystroke:
> [editor keystroke: evt] in [| action |
> evt keyValue = 13
>                ifTrue: [action := self crAction.
>                        action
>                                ifNotNil: [evt hand newKeyboardFocus: nil.
>                                        ^ action value]].
>        self
>                handleInteraction: [editor keystroke: evt].
>        self updateFromParagraph.
>        super keyStroke: evt] in TextMorphForEditView(TextMorph)>>keyStroke:
> TextMorphForEditView(TextMorph)>>handleInteraction:
>  - - - - - - - - - - - - - - -
>                        - - - - - - - - - - - - - - - - - -
> TextMorphForEditView>>handleInteraction:
> [| action |
> evt keyValue = 13
>                ifTrue: [action := self crAction.
>                        action
>                                ifNotNil: [evt hand newKeyboardFocus: nil.
>                                        ^ action value]].
>        self
>                handleInteraction: [editor keystroke: evt].
>        self updateFromParagraph.
>        super keyStroke: evt] in TextMorphForEditView(TextMorph)>>keyStroke:
> ECToolSet class>>codeCompletionAround:textMorph:keyStroke:
> ToolRegistry>>codeCompletionAround:textMorph:keyStroke:
> SmalltalkEditor>>codeCompletionAround:textMorph:keyStroke:
> TextMorphForEditView(TextMorph)>>keyStroke:
> TextMorphForEditView>>keyStroke:
> TextMorphForEditView(TextMorph)>>handleKeystroke:
> KeyboardEvent>>sentTo:
> TextMorphForEditView(Morph)>>handleEvent:
> TextMorphForEditView(Morph)>>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>>sendKeyboardEvent:
> 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 MorphicUIManager>>spawnNewProcess
> [self value.
>        Processor terminateActive] in BlockClosure>>newProcess
>
>
>
> --
> Serge Stinckwich
> UMI UMMISCO 209 (IRD/UPMC), Hanoi, Vietnam
> Every DSL ends up being Smalltalk
> http://doesnotunderstand.org/
>

_______________________________________________
Moose-dev mailing list
[hidden email]
https://www.iam.unibe.ch/mailman/listinfo/moose-dev
Reply | Threaded
Open this post in threaded view
|

Re: [Pharo-project] loading athens - a user perspective

Igor Stasenko
In reply to this post by SergeStinckwich
Should i put more elaborate error message?
A 'function unavailable' is exception which you get when... function
is not available.

I just thinking how to prevent receiving a huge and worthless stack traces. :)
One way is of course write documentation.. :)


On 25 May 2012 12:39, Serge Stinckwich <[hidden email]> wrote:

> On Fri, May 25, 2012 at 4:57 PM, Tudor Girba <[hidden email]> wrote:
>> Hi,
>>
>> Here is how to install Athens (I also added this comment to the ConfigurationOfAthens):
>>
>>
>> 1. Install Cairo on your machine
>> For example, for Mac, you open the terminal and run:
>> sudo port install -f cairo +universal
>>
>> More information can be found here:
>> http://cairographics.org/download/
>>
>>
>> 2. Download the NativeBoost enabled Cog VM from:
>> https://ci.lille.inria.fr/pharo/view/NativeBoost/
>>
>>
>> 3. Get a Pharo image and run:
>> Gofer new
>>        squeaksource: 'Athens';
>>        package: 'ConfigurationOfAthens';
>>        load.
>> (Smalltalk at: #ConfigurationOfAthens) loadDevelopment
>>
>>
>> 4. Play with it. For example:
>> VGTigerDemo runDemo
>
> I install Cairo with brew on mac os x:
> brew install cairo
>
> And I got the following stack trace:
>
>
> 25 May 2012 5:37:03 pm
>
> VM: Mac OS - intel - 1074 - NBCoInterpreter
> NativeBoost-CogPlugin-IgorStasenko.9 uuid:
> 801decd2-0b42-fa49-bcea-d7564d516a1b May  1 2012,
> StackToRegisterMappingCogit VMMaker-oscog-EstebanLorenzano.158 uuid:
> 82eded98-68af-4c80-a472-4f6de293adcf May  1 2012,
> https://git.gitorious.org/cogvm/blessed.git Commit:
> 6aa3fd0f1188078d3167dec1a53031a61b97b688 Date: Tue May 1 20:28:14 2012
> +0200 By: Esteban Lorenzano <[hidden email]>
> Image: Pharo1.4a [Latest update: #14418]
>
> NBFFICallout(Object)>>error:
>        Receiver: a NBFFICallout
>        Arguments and temporary variables:
>                aString:        'function unavailable'
>        Receiver's instance variables:
>                asm:    an AJx86Assembler
>                proxy:  a NBInterpreterProxy
>                options:        a Set(#optCdecl #optAllowByteArraysPtr #optUseStackPointer
> #optReturnP...etc...
>                method:         (AthensCairoSurface class>>#primImage:width:height: "a
> CompiledMethod(4...etc...
>                fnSpec:         a NBFnSpec
>                requestor:      AthensCairoSurface class
>                methodArgs:     an OrderedCollection('aFormat' 'aWidth' 'aHeight')
>                coercionMayFail:        true
>                callInfo:       an AJCdeclCallInfo
>
> [:gen |
> fnAddress := requestor nbGetSymbolAddress: fnSpec functionName module:
> aModuleNameOrHandle.
>        fnAddress
>                ifNil: [self error: 'function unavailable'].
>        self mayCallback
>                ifTrue: [asm push: fnAddress asUImm32;
>                                 mov: NativeBoost callgateFunctionAddress asUImm32 to: EAX;
>                                 call: EAX]
>                ifFalse: [asm mov: fnAddress asUImm32 to: EAX;
>                                 call: EAX]] in NBFFICallout>>generateCall:module:
>        Receiver: a NBFFICallout
>        Arguments and temporary variables:
>                aModuleNameOrHandle:    a NBFFICallout
>                fnAddress:      '/opt/local/lib/libcairo.2.dylib'
>                gen:    #(nil)
>        Receiver's instance variables:
>                asm:    an AJx86Assembler
>                proxy:  a NBInterpreterProxy
>                options:        a Set(#optCdecl #optAllowByteArraysPtr #optUseStackPointer
> #optReturnP...etc...
>                method:         (AthensCairoSurface class>>#primImage:width:height: "a
> CompiledMethod(4...etc...
>                fnSpec:         a NBFnSpec
>                requestor:      AthensCairoSurface class
>                methodArgs:     an OrderedCollection('aFormat' 'aWidth' 'aHeight')
>                coercionMayFail:        true
>                callInfo:       an AJCdeclCallInfo
>
> BlockClosure>>valueWithPossibleArgs:
>        Receiver: [:gen |
> fnAddress := requestor nbGetSymbolAddress: fnSpec functionName module:
> aModuleNam...etc...
>        Arguments and temporary variables:
>                anArray:        an Array(a NBFFICallout a NBInterpreterProxy an AJx86Assembler)
>        Receiver's instance variables:
>                outerContext:   NBFFICallout>>generateCall:module:
>                startpc:        91
>                numArgs:        1
>
> [aFunctionBodyBlock valueWithPossibleArgs: {self. proxy. asm}.
>        (self optEmitCall
>                        or: [self optNoCleanup])
>                ifTrue: [call disableCleanup]] in [:call |
> self optNoAlignment
>                ifTrue: [call alignment: 1].
>        self pushArguments.
>        coercionMayFail
>                ifTrue: [proxy ifFailedJumpTo: self failedLabel].
>        asm
>                decorateWith: 'FFI: performing a call'
>                while: [aFunctionBodyBlock valueWithPossibleArgs: {self. proxy. asm}.
>                        (self optEmitCall
>                                        or: [self optNoCleanup])
>                                ifTrue: [call disableCleanup]]] in NBFFICallout>>generateInstructions:
>        Receiver: a NBFFICallout
>        Arguments and temporary variables:
>                aFunctionBodyBlock:     an AJCdeclCallInfo
>                call:   [:gen |
> fnAddress := requestor nbGetSymbolAddress: fnSpec functionName m...etc...
>        Receiver's instance variables:
>                asm:    an AJx86Assembler
>                proxy:  a NBInterpreterProxy
>                options:        a Set(#optCdecl #optAllowByteArraysPtr #optUseStackPointer
> #optReturnP...etc...
>                method:         (AthensCairoSurface class>>#primImage:width:height: "a
> CompiledMethod(4...etc...
>                fnSpec:         a NBFnSpec
>                requestor:      AthensCairoSurface class
>                methodArgs:     an OrderedCollection('aFormat' 'aWidth' 'aHeight')
>                coercionMayFail:        true
>                callInfo:       an AJCdeclCallInfo
>
> BlockClosure>>ensure:
>        Receiver: [aFunctionBodyBlock valueWithPossibleArgs: {self. proxy. asm}.
>        (self optEmitCall
>                        or: [...etc...
>        Arguments and temporary variables:
>                aBlock:         [level := level - 1.
>        self
>                addInstruction: (AJInstructionDecoration n...etc...
>                complete:       nil
>                returnValue:    nil
>        Receiver's instance variables:
>                outerContext:   [:call |
> self optNoAlignment
>                ifTrue: [call alignment: 1].
>        sel...etc...
>                startpc:        151
>                numArgs:        0
>
> AJx86Assembler>>decorateWith:while:
>        Receiver: an AJx86Assembler
>        Arguments and temporary variables:
>                annotation:     'FFI: performing a call'
>                aBlock:         [aFunctionBodyBlock valueWithPossibleArgs: {self. proxy. asm}.
>        (self o...etc...
>        Receiver's instance variables:
>                instructions:   <<error during printing>>
>
> [:call |
> self optNoAlignment
>                ifTrue: [call alignment: 1].
>        self pushArguments.
>        coercionMayFail
>                ifTrue: [proxy ifFailedJumpTo: self failedLabel].
>        asm
>                decorateWith: 'FFI: performing a call'
>                while: [aFunctionBodyBlock valueWithPossibleArgs: {self. proxy. asm}.
>                        (self optEmitCall
>                                        or: [self optNoCleanup])
>                                ifTrue: [call disableCleanup]]] in NBFFICallout>>generateInstructions:
>        Receiver: a NBFFICallout
>        Arguments and temporary variables:
>                aFunctionBodyBlock:     an AJCdeclCallInfo
>                call:   [:gen |
> fnAddress := requestor nbGetSymbolAddress: fnSpec functionName m...etc...
>        Receiver's instance variables:
>                asm:    an AJx86Assembler
>                proxy:  a NBInterpreterProxy
>                options:        a Set(#optCdecl #optAllowByteArraysPtr #optUseStackPointer
> #optReturnP...etc...
>                method:         (AthensCairoSurface class>>#primImage:width:height: "a
> CompiledMethod(4...etc...
>                fnSpec:         a NBFnSpec
>                requestor:      AthensCairoSurface class
>                methodArgs:     an OrderedCollection('aFormat' 'aWidth' 'aHeight')
>                coercionMayFail:        true
>                callInfo:       an AJCdeclCallInfo
>
> AJx86Assembler>>performingCall:in:
>        Receiver: an AJx86Assembler
>        Arguments and temporary variables:
>                ci:     an AJCdeclCallInfo
>                aBlock:         [:call |
> self optNoAlignment
>                ifTrue: [call alignment: 1].
>        self push...etc...
>        Receiver's instance variables:
>                instructions:   <<error during printing>>
>
> NBFFICallout>>foreignCall:
>        Receiver: a NBFFICallout
>        Arguments and temporary variables:
>                aBlock:         [:call |
> self optNoAlignment
>                ifTrue: [call alignment: 1].
>        self push...etc...
>        Receiver's instance variables:
>                asm:    an AJx86Assembler
>                proxy:  a NBInterpreterProxy
>                options:        a Set(#optCdecl #optAllowByteArraysPtr #optUseStackPointer
> #optReturnP...etc...
>                method:         (AthensCairoSurface class>>#primImage:width:height: "a
> CompiledMethod(4...etc...
>                fnSpec:         a NBFnSpec
>                requestor:      AthensCairoSurface class
>                methodArgs:     an OrderedCollection('aFormat' 'aWidth' 'aHeight')
>                coercionMayFail:        true
>                callInfo:       an AJCdeclCallInfo
>
> NBFFICallout>>generateInstructions:
>        Receiver: a NBFFICallout
>        Arguments and temporary variables:
>                aFunctionBodyBlock:     [:gen |
> fnAddress := requestor nbGetSymbolAddress: fnSpec ...etc...
>                instructions:   nil
>        Receiver's instance variables:
>                asm:    an AJx86Assembler
>                proxy:  a NBInterpreterProxy
>                options:        a Set(#optCdecl #optAllowByteArraysPtr #optUseStackPointer
> #optReturnP...etc...
>                method:         (AthensCairoSurface class>>#primImage:width:height: "a
> CompiledMethod(4...etc...
>                fnSpec:         a NBFnSpec
>                requestor:      AthensCairoSurface class
>                methodArgs:     an OrderedCollection('aFormat' 'aWidth' 'aHeight')
>                coercionMayFail:        true
>                callInfo:       an AJCdeclCallInfo
>
> NBFFICallout>>generate:
>        Receiver: a NBFFICallout
>        Arguments and temporary variables:
>                aFunctionBodyBlock:     [:gen |
> fnAddress := requestor nbGetSymbolAddress: fnSpec ...etc...
>                generatedCode:  nil
>        Receiver's instance variables:
>                asm:    an AJx86Assembler
>                proxy:  a NBInterpreterProxy
>                options:        a Set(#optCdecl #optAllowByteArraysPtr #optUseStackPointer
> #optReturnP...etc...
>                method:         (AthensCairoSurface class>>#primImage:width:height: "a
> CompiledMethod(4...etc...
>                fnSpec:         a NBFnSpec
>                requestor:      AthensCairoSurface class
>                methodArgs:     an OrderedCollection('aFormat' 'aWidth' 'aHeight')
>                coercionMayFail:        true
>                callInfo:       an AJCdeclCallInfo
>
> NBFFICallout>>generateCall:module:
>        Receiver: a NBFFICallout
>        Arguments and temporary variables:
>                functionSpec:   #(#AthensCairoSurface #cairo_image_surface_create
> #(#int #aFormat...etc...
>                aModuleNameOrHandle:    '/opt/local/lib/libcairo.2.dylib'
>                fnAddress:      #(nil)
>        Receiver's instance variables:
>                asm:    an AJx86Assembler
>                proxy:  a NBInterpreterProxy
>                options:        a Set(#optCdecl #optAllowByteArraysPtr #optUseStackPointer
> #optReturnP...etc...
>                method:         (AthensCairoSurface class>>#primImage:width:height: "a
> CompiledMethod(4...etc...
>                fnSpec:         a NBFnSpec
>                requestor:      AthensCairoSurface class
>                methodArgs:     an OrderedCollection('aFormat' 'aWidth' 'aHeight')
>                coercionMayFail:        true
>                callInfo:       an AJCdeclCallInfo
>
> [:gen | gen sender: sender;
>                 callType: self nbCallingConvention;
>                 generateCall: fnSpec module: self nbLibraryNameOrHandle] in
> AthensCairoSurface class(Object)>>nbCall:
>        Receiver: AthensCairoSurface
>        Arguments and temporary variables:
>                fnSpec:         a NBFFICallout
>                sender:         #(#AthensCairoSurface #cairo_image_surface_create #(#int
> #aFormat #, #i...etc...
>                gen:    AthensCairoSurface class>>primImage:width:height:
>        Receiver's instance variables:
>                superclass:     AthensSurface
>                methodDict:     a
> MethodDictionary(#asAthensPaintOn:->(AthensCairoSurface>>#asAthen...etc...
>                format:         140
>                instanceVariables:      #('handle' 'context' 'builder' 'id')
>                organization:   ('converting' asAthensPaintOn: writeToPng:)
> ('as yet unclassified...etc...
>                subclasses:     {AthensCairoPDFSurface}
>                name:   #AthensCairoSurface
>                classPool:      nil
>                sharedPools:    an OrderedCollection(AthensCairoDefs)
>                environment:    a SystemDictionary(lots of globals)
>                category:       #'Athens-Cairo'
>                traitComposition:       TCairoLibrary
>                localSelectors:         a Set(#asForm #createFormPaint: #stride
> #setOperator: #writeToP...etc...
>                uniqueSession:  nil
>                dispatch:       nil
>                dispatchStruct:         nil
>
> NBFFICallout class(NBNativeCodeGen class)>>generateCode:andRetry:
>        Receiver: NBFFICallout
>        Arguments and temporary variables:
>                aBlock:         [:gen | gen sender: sender;
>                 callType: self nbCallingConvention;
>                 g...etc...
>                retryCtx:       AthensCairoSurface class>>primImage:width:height:
>                method:         (AthensCairoSurface class>>#primImage:width:height: "a
> CompiledMethod(4...etc...
>                code:   nil
>                newMethod:      nil
>                args:   nil
>                i:      nil
>                iLimiT:         nil
>        Receiver's instance variables:
>                superclass:     NBNativeCodeGen
>                methodDict:     a
> MethodDictionary(#aliasForType:->(NBFFICallout>>#aliasForType:
> "a...etc...
>                format:         148
>                instanceVariables:      #('fnSpec' 'requestor' 'methodArgs'
> 'coercionMayFail' 'callI...etc...
>                organization:   ('type aliases' aliasForType:)
> ('accessing' anonSpec: callType: c...etc...
>                subclasses:     {NBNativeFunctionGen}
>                name:   #NBFFICallout
>                classPool:      a Dictionary(#CustomErrorCodes->nil
> #CustomErrorMessages->nil #TypeA...etc...
>                sharedPools:    nil
>                environment:    a SystemDictionary(lots of globals)
>                category:       #'NativeBoost-Core'
>                traitComposition:       {}
>                localSelectors:         nil
>
> NBFFICallout class(NBNativeCodeGen class)>>handleFailureIn:nativeCode:
>        Receiver: NBFFICallout
>        Arguments and temporary variables:
>                aContext:       AthensCairoSurface class>>primImage:width:height:
>                aBlock:         [:gen | gen sender: sender;
>                 callType: self nbCallingConvention;
>                 g...etc...
>                method:         (AthensCairoSurface class>>#primImage:width:height: "a
> CompiledMethod(4...etc...
>                lastError:      502
>        Receiver's instance variables:
>                superclass:     NBNativeCodeGen
>                methodDict:     a
> MethodDictionary(#aliasForType:->(NBFFICallout>>#aliasForType:
> "a...etc...
>                format:         148
>                instanceVariables:      #('fnSpec' 'requestor' 'methodArgs'
> 'coercionMayFail' 'callI...etc...
>                organization:   ('type aliases' aliasForType:)
> ('accessing' anonSpec: callType: c...etc...
>                subclasses:     {NBNativeFunctionGen}
>                name:   #NBFFICallout
>                classPool:      a Dictionary(#CustomErrorCodes->nil
> #CustomErrorMessages->nil #TypeA...etc...
>                sharedPools:    nil
>                environment:    a SystemDictionary(lots of globals)
>                category:       #'NativeBoost-Core'
>                traitComposition:       {}
>                localSelectors:         nil
>
> AthensCairoSurface class(Object)>>nbCall:
>        Receiver: AthensCairoSurface
>        Arguments and temporary variables:
>                fnSpec:         #(#AthensCairoSurface #cairo_image_surface_create #(#int
> #aFormat #, #i...etc...
>                sender:         AthensCairoSurface class>>primImage:width:height:
>        Receiver's instance variables:
>                superclass:     AthensSurface
>                methodDict:     a
> MethodDictionary(#asAthensPaintOn:->(AthensCairoSurface>>#asAthen...etc...
>                format:         140
>                instanceVariables:      #('handle' 'context' 'builder' 'id')
>                organization:   ('converting' asAthensPaintOn: writeToPng:)
> ('as yet unclassified...etc...
>                subclasses:     {AthensCairoPDFSurface}
>                name:   #AthensCairoSurface
>                classPool:      nil
>                sharedPools:    an OrderedCollection(AthensCairoDefs)
>                environment:    a SystemDictionary(lots of globals)
>                category:       #'Athens-Cairo'
>                traitComposition:       TCairoLibrary
>                localSelectors:         a Set(#asForm #createFormPaint: #stride
> #setOperator: #writeToP...etc...
>                uniqueSession:  nil
>                dispatch:       nil
>                dispatchStruct:         nil
>
> AthensCairoSurface class>>primImage:width:height:
>        Receiver: AthensCairoSurface
>        Arguments and temporary variables:
>                aFormat:        0
>                aWidth:         800
>                aHeight:        800
>        Receiver's instance variables:
>                superclass:     AthensSurface
>                methodDict:     a
> MethodDictionary(#asAthensPaintOn:->(AthensCairoSurface>>#asAthen...etc...
>                format:         140
>                instanceVariables:      #('handle' 'context' 'builder' 'id')
>                organization:   ('converting' asAthensPaintOn: writeToPng:)
> ('as yet unclassified...etc...
>                subclasses:     {AthensCairoPDFSurface}
>                name:   #AthensCairoSurface
>                classPool:      nil
>                sharedPools:    an OrderedCollection(AthensCairoDefs)
>                environment:    a SystemDictionary(lots of globals)
>                category:       #'Athens-Cairo'
>                traitComposition:       TCairoLibrary
>                localSelectors:         a Set(#asForm #createFormPaint: #stride
> #setOperator: #writeToP...etc...
>                uniqueSession:  nil
>                dispatch:       nil
>                dispatchStruct:         nil
>
> AthensCairoSurface class>>extent:format:
>        Receiver: AthensCairoSurface
>        Arguments and temporary variables:
>                anExtent:       (800@800)
>                aFormat:        0
>        Receiver's instance variables:
>                superclass:     AthensSurface
>                methodDict:     a
> MethodDictionary(#asAthensPaintOn:->(AthensCairoSurface>>#asAthen...etc...
>                format:         140
>                instanceVariables:      #('handle' 'context' 'builder' 'id')
>                organization:   ('converting' asAthensPaintOn: writeToPng:)
> ('as yet unclassified...etc...
>                subclasses:     {AthensCairoPDFSurface}
>                name:   #AthensCairoSurface
>                classPool:      nil
>                sharedPools:    an OrderedCollection(AthensCairoDefs)
>                environment:    a SystemDictionary(lots of globals)
>                category:       #'Athens-Cairo'
>                traitComposition:       TCairoLibrary
>                localSelectors:         a Set(#asForm #createFormPaint: #stride
> #setOperator: #writeToP...etc...
>                uniqueSession:  nil
>                dispatch:       nil
>                dispatchStruct:         nil
>
> AthensCairoSurface class>>extent:
>        Receiver: AthensCairoSurface
>        Arguments and temporary variables:
>                anExtent:       (800@800)
>        Receiver's instance variables:
>                superclass:     AthensSurface
>                methodDict:     a
> MethodDictionary(#asAthensPaintOn:->(AthensCairoSurface>>#asAthen...etc...
>                format:         140
>                instanceVariables:      #('handle' 'context' 'builder' 'id')
>                organization:   ('converting' asAthensPaintOn: writeToPng:)
> ('as yet unclassified...etc...
>                subclasses:     {AthensCairoPDFSurface}
>                name:   #AthensCairoSurface
>                classPool:      nil
>                sharedPools:    an OrderedCollection(AthensCairoDefs)
>                environment:    a SystemDictionary(lots of globals)
>                category:       #'Athens-Cairo'
>                traitComposition:       TCairoLibrary
>                localSelectors:         a Set(#asForm #createFormPaint: #stride
> #setOperator: #writeToP...etc...
>                uniqueSession:  nil
>                dispatch:       nil
>                dispatchStruct:         nil
>
> VGTigerDemo>>initialize
>        Receiver: a VGTigerDemo
>        Arguments and temporary variables:
>
>        Receiver's instance variables:
>                surface:        nil
>
> VGTigerDemo class(Behavior)>>new
>        Receiver: VGTigerDemo
>        Arguments and temporary variables:
>
>        Receiver's instance variables:
>                superclass:     Object
>                methodDict:     a
> MethodDictionary(#convertPathData2->(VGTigerDemo>>#convertPathDat...etc...
>                format:         132
>                instanceVariables:      #('surface')
>                organization:   ('as yet unclassified' convertPathData2 initialize runDemo)
>
>                subclasses:     nil
>                name:   #VGTigerDemo
>                classPool:      nil
>                sharedPools:    nil
>                environment:    a SystemDictionary(lots of globals)
>                category:       #'Athens-Examples'
>                traitComposition:       {}
>                localSelectors:         nil
>
> VGTigerDemo class>>runDemo
>        Receiver: VGTigerDemo
>        Arguments and temporary variables:
>
>        Receiver's instance variables:
>                superclass:     Object
>                methodDict:     a
> MethodDictionary(#convertPathData2->(VGTigerDemo>>#convertPathDat...etc...
>                format:         132
>                instanceVariables:      #('surface')
>                organization:   ('as yet unclassified' convertPathData2 initialize runDemo)
>
>                subclasses:     nil
>                name:   #VGTigerDemo
>                classPool:      nil
>                sharedPools:    nil
>                environment:    a SystemDictionary(lots of globals)
>                category:       #'Athens-Examples'
>                traitComposition:       {}
>                localSelectors:         nil
>
> UndefinedObject>>DoIt
>        Receiver: nil
>        Arguments and temporary variables:
>
>        Receiver's instance variables:
> nil
>
> Compiler>>evaluate:in:to:notifying:ifFail:logged:
>        Receiver: a Compiler
>        Arguments and temporary variables:
>                textOrStream:   a ReadWriteStream
>                aContext:       nil
>                receiver:       nil
>                aRequestor:     a TextMorphForEditView(741605376)
>                failBlock:      [self morph flash.
>        ^ nil]
>                logFlag:        true
>                methodNode:     DoIt
>        ^ VGTigerDemo runDemo
>                method:         (UndefinedObject>>#DoIt "a CompiledMethod(926679040)")
>                value:  nil
>                toLog:  nil
>                itsSelection:   nil
>                itsSelectionString:     nil
>        Receiver's instance variables:
>                sourceStream:   a ReadWriteStream
>                requestor:      a TextMorphForEditView(741605376)
>                class:  UndefinedObject
>                category:       nil
>                context:        nil
>                parser:         a Parser
>
> [rcvr class evaluatorClass new
>                evaluate: self selectionForDoitAsStream
>                in: ctxt
>                to: rcvr
>                notifying: self morph
>                ifFail: [self morph flash.
>                        ^ nil]
>                logged: true] in SmalltalkEditor>>evaluateSelectionAndDo:
>        Receiver: a SmalltalkEditor
>        Arguments and temporary variables:
>                rcvr:   nil
>                ctxt:   nil
>        Receiver's instance variables:
>                morph:  a TextMorphForEditView(741605376)
>                selectionShowing:       true
>                model:  a Workspace
>                editingState:   a SmalltalkEditingState
>
> BlockClosure>>on:do:
>        Receiver: [rcvr class evaluatorClass new
>                evaluate: self selectionForDoitAsStream
>                in: ctxt
>                to: ...etc...
>        Arguments and temporary variables:
>                exception:      OutOfScopeNotification
>                handlerAction:  [:ex | ex resume: true]
>                handlerActive:  true
>        Receiver's instance variables:
>                outerContext:   SmalltalkEditor>>evaluateSelectionAndDo:
>                startpc:        110
>                numArgs:        0
>
> SmalltalkEditor>>evaluateSelectionAndDo:
>        Receiver: a SmalltalkEditor
>        Arguments and temporary variables:
>                aBlock:         [:result | result]
>                result:         nil
>                rcvr:   nil
>                ctxt:   nil
>        Receiver's instance variables:
>                morph:  a TextMorphForEditView(741605376)
>                selectionShowing:       true
>                model:  a Workspace
>                editingState:   a SmalltalkEditingState
>
> SmalltalkEditor>>evaluateSelection
>        Receiver: a SmalltalkEditor
>        Arguments and temporary variables:
>
>        Receiver's instance variables:
>                morph:  a TextMorphForEditView(741605376)
>                selectionShowing:       true
>                model:  a Workspace
>                editingState:   a SmalltalkEditingState
>
> SmalltalkEditor>>doIt
>        Receiver: a SmalltalkEditor
>        Arguments and temporary variables:
>
>        Receiver's instance variables:
>                morph:  a TextMorphForEditView(741605376)
>                selectionShowing:       true
>                model:  a Workspace
>                editingState:   a SmalltalkEditingState
>
> SmalltalkEditor>>doIt:
>        Receiver: a SmalltalkEditor
>        Arguments and temporary variables:
>                aKeyboardEvent:         [keystroke '<Cmd-d>']
>        Receiver's instance variables:
>                morph:  a TextMorphForEditView(741605376)
>                selectionShowing:       true
>                model:  a Workspace
>                editingState:   a SmalltalkEditingState
>
> SmalltalkEditor(TextEditor)>>performCmdActionsWith:shifted:return:
>        Receiver: a SmalltalkEditor
>        Arguments and temporary variables:
>                aKeyboardEvent:         [keystroke '<Cmd-d>']
>                aBoolean:       false
>                return:         [:val | ^ val]
>                asciiValue:     101
>                actions:        #(#noop: #cursorHome: #noop: #noop: #cursorEnd: #noop:
> #noop: #noop: #...etc...
>                action:         #doIt:
>        Receiver's instance variables:
>                morph:  a TextMorphForEditView(741605376)
>                selectionShowing:       true
>                model:  a Workspace
>                editingState:   a SmalltalkEditingState
>
> SmalltalkEditor(TextEditor)>>dispatchCommandOn:return:
>        Receiver: a SmalltalkEditor
>        Arguments and temporary variables:
>                aKeyboardEvent:         [keystroke '<Cmd-d>']
>                return:         [:val | ^ val]
>                asciiValue:     100
>                honorCommandKeys:       true
>                char:   nil
>        Receiver's instance variables:
>                morph:  a TextMorphForEditView(741605376)
>                selectionShowing:       true
>                model:  a Workspace
>                editingState:   a SmalltalkEditingState
>
> SmalltalkEditor(TextEditor)>>dispatchOn:
>        Receiver: a SmalltalkEditor
>        Arguments and temporary variables:
>                aKeyboardEvent:         [keystroke '<Cmd-d>']
>                char:   nil
>                return:         [:val | ^ val]
>                keyEvents:      nil
>        Receiver's instance variables:
>                morph:  a TextMorphForEditView(741605376)
>                selectionShowing:       true
>                model:  a Workspace
>                editingState:   a SmalltalkEditingState
>
> [self dispatchOn: aKeyboardEvent] in SmalltalkEditor(TextEditor)>>keystroke:
>        Receiver: a SmalltalkEditor
>        Arguments and temporary variables:
>                aKeyboardEvent:         [keystroke '<Cmd-d>']
>        Receiver's instance variables:
>                morph:  a TextMorphForEditView(741605376)
>                selectionShowing:       true
>                model:  a Workspace
>                editingState:   a SmalltalkEditingState
>
> SmalltalkEditor(TextEditor)>>handleKeystrokeAction:
>        Receiver: a SmalltalkEditor
>        Arguments and temporary variables:
>                aBlock:         [self dispatchOn: aKeyboardEvent]
>        Receiver's instance variables:
>                morph:  a TextMorphForEditView(741605376)
>                selectionShowing:       true
>                model:  a Workspace
>                editingState:   a SmalltalkEditingState
>
> SmalltalkEditor(TextEditor)>>handleEditionAction:fromKeyboardEvent:
>        Receiver: a SmalltalkEditor
>        Arguments and temporary variables:
>                anAction:       [self dispatchOn: aKeyboardEvent]
>                aKeyboardEvent:         [keystroke '<Cmd-d>']
>        Receiver's instance variables:
>                morph:  a TextMorphForEditView(741605376)
>                selectionShowing:       true
>                model:  a Workspace
>                editingState:   a SmalltalkEditingState
>
> SmalltalkEditor(TextEditor)>>keystroke:
>        Receiver: a SmalltalkEditor
>        Arguments and temporary variables:
>                aKeyboardEvent:         [keystroke '<Cmd-d>']
>        Receiver's instance variables:
>                morph:  a TextMorphForEditView(741605376)
>                selectionShowing:       true
>                model:  a Workspace
>                editingState:   a SmalltalkEditingState
>
> [editor keystroke: evt] in [| action |
> evt keyValue = 13
>                ifTrue: [action := self crAction.
>                        action
>                                ifNotNil: [evt hand newKeyboardFocus: nil.
>                                        ^ action value]].
>        self
>                handleInteraction: [editor keystroke: evt].
>        self updateFromParagraph.
>        super keyStroke: evt] in TextMorphForEditView(TextMorph)>>keyStroke:
>        Receiver: a TextMorphForEditView(741605376)
>        Arguments and temporary variables:
>                evt:    [keystroke '<Cmd-d>']
>        Receiver's instance variables:
>                bounds:         (0@0) corner: (473@18)
>                owner:  a TransformMorph(38535168)
>                submorphs:      #()
>                fullBounds:     (0@0) corner: (473@18)
>                color:  Color black
>                extension:      a MorphExtension (824180736) [other:  (blinkStart ->
> 1085881) (myDep...etc...
>                borderWidth:    0
>                borderColor:    Color black
>                textStyle:      a TextStyle Bitmap DejaVu Sans 9
>                text:   a Text for 'VGTigerDemo runDemo'
>                wrapFlag:       true
>                paragraph:      a Paragraph
>                editor:         a SmalltalkEditor
>                container:      nil
>                predecessor:    nil
>                successor:      nil
>                backgroundColor:        nil
>                margins:        (0@0) corner: (0@0)
>                editView:       a PluggableTextMorph(838860800)
>                acceptOnCR:     false
>                autoAccept:     false
>                acceptOnFocusChange:    false
>                selectionColor:         nil
>
> TextMorphForEditView(TextMorph)>>handleInteraction:
>        Receiver: a TextMorphForEditView(741605376)
>        Arguments and temporary variables:
>                interactionBlock:       [editor keystroke: evt]
>                oldEditor:      a SmalltalkEditor
>                oldParagraph:   a Paragraph
>                oldText:        a Text for 'VGTigerDemo runDemo'
>        Receiver's instance variables:
>                bounds:         (0@0) corner: (473@18)
>                owner:  a TransformMorph(38535168)
>                submorphs:      #()
>                fullBounds:     (0@0) corner: (473@18)
>                color:  Color black
>                extension:      a MorphExtension (824180736) [other:  (blinkStart ->
> 1085881) (myDep...etc...
>                borderWidth:    0
>                borderColor:    Color black
>                textStyle:      a TextStyle Bitmap DejaVu Sans 9
>                text:   a Text for 'VGTigerDemo runDemo'
>                wrapFlag:       true
>                paragraph:      a Paragraph
>                editor:         a SmalltalkEditor
>                container:      nil
>                predecessor:    nil
>                successor:      nil
>                backgroundColor:        nil
>                margins:        (0@0) corner: (0@0)
>                editView:       a PluggableTextMorph(838860800)
>                acceptOnCR:     false
>                autoAccept:     false
>                acceptOnFocusChange:    false
>                selectionColor:         nil
>
>
> --- The full stack ---
> NBFFICallout(Object)>>error:
> [:gen |
> fnAddress := requestor nbGetSymbolAddress: fnSpec functionName module:
> aModuleNameOrHandle.
>        fnAddress
>                ifNil: [self error: 'function unavailable'].
>        self mayCallback
>                ifTrue: [asm push: fnAddress asUImm32;
>                                 mov: NativeBoost callgateFunctionAddress asUImm32 to: EAX;
>                                 call: EAX]
>                ifFalse: [asm mov: fnAddress asUImm32 to: EAX;
>                                 call: EAX]] in NBFFICallout>>generateCall:module:
> BlockClosure>>valueWithPossibleArgs:
> [aFunctionBodyBlock valueWithPossibleArgs: {self. proxy. asm}.
>        (self optEmitCall
>                        or: [self optNoCleanup])
>                ifTrue: [call disableCleanup]] in [:call |
> self optNoAlignment
>                ifTrue: [call alignment: 1].
>        self pushArguments.
>        coercionMayFail
>                ifTrue: [proxy ifFailedJumpTo: self failedLabel].
>        asm
>                decorateWith: 'FFI: performing a call'
>                while: [aFunctionBodyBlock valueWithPossibleArgs: {self. proxy. asm}.
>                        (self optEmitCall
>                                        or: [self optNoCleanup])
>                                ifTrue: [call disableCleanup]]] in NBFFICallout>>generateInstructions:
> BlockClosure>>ensure:
> AJx86Assembler>>decorateWith:while:
> [:call |
> self optNoAlignment
>                ifTrue: [call alignment: 1].
>        self pushArguments.
>        coercionMayFail
>                ifTrue: [proxy ifFailedJumpTo: self failedLabel].
>        asm
>                decorateWith: 'FFI: performing a call'
>                while: [aFunctionBodyBlock valueWithPossibleArgs: {self. proxy. asm}.
>                        (self optEmitCall
>                                        or: [self optNoCleanup])
>                                ifTrue: [call disableCleanup]]] in NBFFICallout>>generateInstructions:
> AJx86Assembler>>performingCall:in:
> NBFFICallout>>foreignCall:
> NBFFICallout>>generateInstructions:
> NBFFICallout>>generate:
> NBFFICallout>>generateCall:module:
> [:gen | gen sender: sender;
>                 callType: self nbCallingConvention;
>                 generateCall: fnSpec module: self nbLibraryNameOrHandle] in
> AthensCairoSurface class(Object)>>nbCall:
> NBFFICallout class(NBNativeCodeGen class)>>generateCode:andRetry:
> NBFFICallout class(NBNativeCodeGen class)>>handleFailureIn:nativeCode:
> AthensCairoSurface class(Object)>>nbCall:
> AthensCairoSurface class>>primImage:width:height:
> AthensCairoSurface class>>extent:format:
> AthensCairoSurface class>>extent:
> VGTigerDemo>>initialize
> VGTigerDemo class(Behavior)>>new
> VGTigerDemo class>>runDemo
> UndefinedObject>>DoIt
> Compiler>>evaluate:in:to:notifying:ifFail:logged:
> [rcvr class evaluatorClass new
>                evaluate: self selectionForDoitAsStream
>                in: ctxt
>                to: rcvr
>                notifying: self morph
>                ifFail: [self morph flash.
>                        ^ nil]
>                logged: true] in SmalltalkEditor>>evaluateSelectionAndDo:
> BlockClosure>>on:do:
> SmalltalkEditor>>evaluateSelectionAndDo:
> SmalltalkEditor>>evaluateSelection
> SmalltalkEditor>>doIt
> SmalltalkEditor>>doIt:
> SmalltalkEditor(TextEditor)>>performCmdActionsWith:shifted:return:
> SmalltalkEditor(TextEditor)>>dispatchCommandOn:return:
> SmalltalkEditor(TextEditor)>>dispatchOn:
> [self dispatchOn: aKeyboardEvent] in SmalltalkEditor(TextEditor)>>keystroke:
> SmalltalkEditor(TextEditor)>>handleKeystrokeAction:
> SmalltalkEditor(TextEditor)>>handleEditionAction:fromKeyboardEvent:
> SmalltalkEditor(TextEditor)>>keystroke:
> [editor keystroke: evt] in [| action |
> evt keyValue = 13
>                ifTrue: [action := self crAction.
>                        action
>                                ifNotNil: [evt hand newKeyboardFocus: nil.
>                                        ^ action value]].
>        self
>                handleInteraction: [editor keystroke: evt].
>        self updateFromParagraph.
>        super keyStroke: evt] in TextMorphForEditView(TextMorph)>>keyStroke:
> TextMorphForEditView(TextMorph)>>handleInteraction:
>  - - - - - - - - - - - - - - -
>                        - - - - - - - - - - - - - - - - - -
> TextMorphForEditView>>handleInteraction:
> [| action |
> evt keyValue = 13
>                ifTrue: [action := self crAction.
>                        action
>                                ifNotNil: [evt hand newKeyboardFocus: nil.
>                                        ^ action value]].
>        self
>                handleInteraction: [editor keystroke: evt].
>        self updateFromParagraph.
>        super keyStroke: evt] in TextMorphForEditView(TextMorph)>>keyStroke:
> ECToolSet class>>codeCompletionAround:textMorph:keyStroke:
> ToolRegistry>>codeCompletionAround:textMorph:keyStroke:
> SmalltalkEditor>>codeCompletionAround:textMorph:keyStroke:
> TextMorphForEditView(TextMorph)>>keyStroke:
> TextMorphForEditView>>keyStroke:
> TextMorphForEditView(TextMorph)>>handleKeystroke:
> KeyboardEvent>>sentTo:
> TextMorphForEditView(Morph)>>handleEvent:
> TextMorphForEditView(Morph)>>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>>sendKeyboardEvent:
> 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 MorphicUIManager>>spawnNewProcess
> [self value.
>        Processor terminateActive] in BlockClosure>>newProcess
>
>
>
> --
> Serge Stinckwich
> UMI UMMISCO 209 (IRD/UPMC), Hanoi, Vietnam
> Every DSL ends up being Smalltalk
> http://doesnotunderstand.org/
>



--
Best regards,
Igor Stasenko.

_______________________________________________
Moose-dev mailing list
[hidden email]
https://www.iam.unibe.ch/mailman/listinfo/moose-dev