On Fri, May 25, 2012 at 4:57 PM, Tudor Girba <[email protected]> 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 <[email protected]>
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/

Reply via email to