THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:11.766582 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	38


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:11.824581 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	38


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder class>>event:
	Receiver: KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		anEvent: 	a MethodRemoved
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary(#builder->KMPragmaKeymapBuilder>>#builder #colle...etc...
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('pragmaKeywords' 'model' 'pragmaCollector')
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#KMPragmaKeymapBuilder
		classPool: 	a Dictionary(#UniqueInstace->a KMPragmaKeymapBuilder )
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'Keymapping-Pragmas'
		traitComposition: 	{}
		localSelectors: 	nil


MessageSend>>value:
	Receiver: MessageSend(#event: -> KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		anObject: 	a MethodRemoved
	Receiver's instance variables: 
		receiver: 	KMPragmaKeymapBuilder
		selector: 	#event:
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#event: -> KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a MethodRemoved
	Receiver's instance variables: 
		receiver: 	KMPragmaKeymapBuilder
		selector: 	#event:
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#event: -> KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a MethodRemoved
		arg2: 	a SystemAnnouncer
	Receiver's instance variables: 
		receiver: 	KMPragmaKeymapBuilder
		selector: 	#event:
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a MethodRemoved
	Receiver's instance variables: 
		announcer: 	a SystemAnnouncer
		announcementClass: 	an AnnouncementSet(MethodRemoved MethodAdded MethodModified)...etc...
		subscriber: 	KMPragmaKeymapBuilder
		action: 	MessageSend(#event: -> KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
KMPragmaKeymapBuilder class>>event:
MessageSend>>value:
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:11.850583 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	37


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:11.87258 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	38


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:11.894581 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	38


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:11.916584 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	38


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:11.938583 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	38


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder class>>event:
	Receiver: KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		anEvent: 	a MethodRemoved
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary(#builder->KMPragmaKeymapBuilder>>#builder #colle...etc...
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('pragmaKeywords' 'model' 'pragmaCollector')
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#KMPragmaKeymapBuilder
		classPool: 	a Dictionary(#UniqueInstace->a KMPragmaKeymapBuilder )
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'Keymapping-Pragmas'
		traitComposition: 	{}
		localSelectors: 	nil


MessageSend>>value:
	Receiver: MessageSend(#event: -> KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		anObject: 	a MethodRemoved
	Receiver's instance variables: 
		receiver: 	KMPragmaKeymapBuilder
		selector: 	#event:
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#event: -> KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a MethodRemoved
	Receiver's instance variables: 
		receiver: 	KMPragmaKeymapBuilder
		selector: 	#event:
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#event: -> KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a MethodRemoved
		arg2: 	a SystemAnnouncer
	Receiver's instance variables: 
		receiver: 	KMPragmaKeymapBuilder
		selector: 	#event:
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a MethodRemoved
	Receiver's instance variables: 
		announcer: 	a SystemAnnouncer
		announcementClass: 	an AnnouncementSet(MethodRemoved MethodAdded MethodModified)...etc...
		subscriber: 	KMPragmaKeymapBuilder
		action: 	MessageSend(#event: -> KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
KMPragmaKeymapBuilder class>>event:
MessageSend>>value:
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:11.960581 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	38


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:11.982583 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	38


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:11.99859 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	38


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:12.030583 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	38


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:12.052585 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	38


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:12.742582 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	37


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:12.76458 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	37


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder class>>event:
	Receiver: KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		anEvent: 	a MethodRemoved
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary(#builder->KMPragmaKeymapBuilder>>#builder #colle...etc...
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('pragmaKeywords' 'model' 'pragmaCollector')
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#KMPragmaKeymapBuilder
		classPool: 	a Dictionary(#UniqueInstace->a KMPragmaKeymapBuilder )
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'Keymapping-Pragmas'
		traitComposition: 	{}
		localSelectors: 	nil


MessageSend>>value:
	Receiver: MessageSend(#event: -> KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		anObject: 	a MethodRemoved
	Receiver's instance variables: 
		receiver: 	KMPragmaKeymapBuilder
		selector: 	#event:
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#event: -> KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a MethodRemoved
	Receiver's instance variables: 
		receiver: 	KMPragmaKeymapBuilder
		selector: 	#event:
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#event: -> KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a MethodRemoved
		arg2: 	a SystemAnnouncer
	Receiver's instance variables: 
		receiver: 	KMPragmaKeymapBuilder
		selector: 	#event:
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a MethodRemoved
	Receiver's instance variables: 
		announcer: 	a SystemAnnouncer
		announcementClass: 	an AnnouncementSet(MethodRemoved MethodAdded MethodModified)...etc...
		subscriber: 	KMPragmaKeymapBuilder
		action: 	MessageSend(#event: -> KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
KMPragmaKeymapBuilder class>>event:
MessageSend>>value:
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:12.786584 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	37


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:12.808581 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	37


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:12.83058 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	37


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:12.85058 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	37


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:12.86858 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	37


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:12.888584 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	37


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:12.910582 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	37


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:12.932582 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	37


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:12.952583 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	37


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:12.974584 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	37


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:12.99459 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	37


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:13.020582 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	37


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:13.744583 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	37


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:13.766581 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	36


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:13.788585 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	36


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:13.808583 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	36


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:13.830579 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	36


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:13.850582 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	36


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:13.872584 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	36


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder class>>event:
	Receiver: KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		anEvent: 	a MethodRemoved
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary(#builder->KMPragmaKeymapBuilder>>#builder #colle...etc...
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('pragmaKeywords' 'model' 'pragmaCollector')
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#KMPragmaKeymapBuilder
		classPool: 	a Dictionary(#UniqueInstace->a KMPragmaKeymapBuilder )
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'Keymapping-Pragmas'
		traitComposition: 	{}
		localSelectors: 	nil


MessageSend>>value:
	Receiver: MessageSend(#event: -> KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		anObject: 	a MethodRemoved
	Receiver's instance variables: 
		receiver: 	KMPragmaKeymapBuilder
		selector: 	#event:
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#event: -> KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a MethodRemoved
	Receiver's instance variables: 
		receiver: 	KMPragmaKeymapBuilder
		selector: 	#event:
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#event: -> KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a MethodRemoved
		arg2: 	a SystemAnnouncer
	Receiver's instance variables: 
		receiver: 	KMPragmaKeymapBuilder
		selector: 	#event:
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a MethodRemoved
	Receiver's instance variables: 
		announcer: 	a SystemAnnouncer
		announcementClass: 	an AnnouncementSet(MethodRemoved MethodAdded MethodModified)...etc...
		subscriber: 	KMPragmaKeymapBuilder
		action: 	MessageSend(#event: -> KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
KMPragmaKeymapBuilder class>>event:
MessageSend>>value:
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:13.89458 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	36


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:13.918589 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	36


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:13.940581 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	36


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:13.956583 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	36


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:13.976584 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	36


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:14.748585 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	36


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:14.766579 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	36


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:14.786582 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	36


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:14.808583 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	36


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:14.828581 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	36


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:14.84858 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	36


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:14.870579 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	36


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:14.892582 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	36


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:14.912583 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	36


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:14.934582 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	36


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:14.954582 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	36


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:14.97258 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	36


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:14.992583 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	36


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:15.016584 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	36


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:15.038584 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	36


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:15.060581 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	36


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:15.530583 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	36


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:15.54858 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	36


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:15.570581 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	36


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:15.59058 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	36


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:15.610581 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	36


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShortcuts
5 January 2014 5:48:15.632582 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
	Receiver: AnObsoleteNNavNavigation
	Arguments and temporary variables: 
		aMessage: 	useArrowsShortcuts
		exception: 	MessageNotUnderstood: AnObsoleteNNavNavigation class>>useArrowsShort...etc...
		resumeValue: 	nil
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('currentEditor' 'lastSelection' 'currentSelection')
		organization: 	nil
		subclasses: 	nil
		name: 	'AnObsoleteNNavNavigation'
		classPool: 	nil
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>defaultKeyCombination
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


NNavDirectionFirstChild class>>buildShortcut:
	Receiver: NNavDirectionFirstChild
	Arguments and temporary variables: 
		aBuilder: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		superclass: 	NNavDirectionChild
		methodDict: 	a MethodDictionary()
		format: 	2
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#NNavDirectionFirstChild
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'NodeNavigation-Core'
		traitComposition: 	{}
		localSelectors: 	nil


[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
		prg: 	<keymap>
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


OrderedCollection>>do:
	Receiver: an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keyma...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
		index: 	24
	Receiver's instance variables: 
		array: 	an Array(<keymap> <keymap> <keymap> <keymap> <keymap> <keymap> <keymap> ...etc...
		firstIndex: 	1
		lastIndex: 	36


PragmaCollector>>do:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:...etc...
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	false
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	nil
		ex: 	UnhandledError
		copy: 	nil
		onDoCtx: 	nil
		process: 	nil
		handler: 	nil
		bottom: 	nil
		thisCtx: 	nil
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0



--- The full stack ---
AnObsoleteNNavNavigation class(Object)>>doesNotUnderstand: #useArrowsShortcuts
NNavDirectionFirstChild class>>defaultKeyCombination
NNavDirectionFirstChild class>>buildShortcut:
[ :prg | 
prg methodClass theNonMetaClass
	perform: prg selector
	with:
		(menu
			platform: prg arguments;
			yourself) ] in KMPragmaKeymapBuilder>>collectRegistrations
OrderedCollection>>do:
PragmaCollector>>do:
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
[ Processor terminateActive ] in on: exception fork: handlerAction
	"Activate the receiver. In case of exception, fork a new process, which will handle an error.
	An original process will continue running as if receiver evaluation finished and answered nil,
	i.e., an expression like:
	
	[ self error: 'some error'] on: Error fork: [:ex |  123 ] 
	
	will always answer nil for original process, not 123.

	The context stack , starting from context which sent this message to receiver and
	up to the top of the stack will be transferred to forked process, with handlerAction on top.
	(so when the forked process will be resuming, it will enter the handlerAction)
	 "

	^ self
		on: exception
		do: [ :ex | 
			| copy onDoCtx process handler bottom thisCtx |
			onDoCtx := thisContext.
			thisCtx := onDoCtx home.	"find the context on stack for which this method's is sender"
			[ onDoCtx sender == thisCtx ]
				whileFalse: [ 
					onDoCtx := onDoCtx sender.
					onDoCtx
						ifNil: [ 
							"Can't find our home context. seems like we're already forked
				and handling another exception in new thread. In this case, just pass it through handler."
							^ handlerAction cull: ex ] ].
			bottom := [ Processor terminateActive ] asContext.
			onDoCtx privSender: bottom.
			handler := [ handlerAction cull: ex ] asContext.
			handler privSender: thisContext sender.
			(Process forContext: handler priority: Processor activePriority) resume.	"cut the stack of current process"
			thisContext privSender: thisCtx.
			nil ] in BlockClosure>>on:fork:
-------------------------------------------------------------------------------

THERE_BE_DRAGONS_HERE
User Interrupt
5 January 2014 5:51:17.204584 pm

VM: unix - i686 - linux-gnu - NBCoInterpreter NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
NBCogit NativeBoost-CogPlugin-GuillermoPolito.19 uuid: acc98e51-2fba-4841-a965-2975997bba66 Jan  2 2014
https://github.com/pharo-project/pharo-vm.git Commit: e698e14f38003258fa49506b14307d83863a5ac1 Date: 2013-12-16 06:32:59 -0800 By: Esteban Lorenzano <estebanlm@gmail.com> Jenkins build #14781

Image: Pharo3.0 [Latest update: #30672]

ClassCategoryReader class(Behavior)>>selectorsAndMethodsDo:
	Receiver: ClassCategoryReader
	Arguments and temporary variables: 
		selectorAndMethodBlock: 	[ :selector :method | method pragmas do: aBlock ]
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary(#scanFrom:->ClassCategoryReader>>#scanFrom: #set...etc...
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('class' 'category' 'changeStamp')
		organization: 	a ClassOrganization
		subclasses: 	{ClassCommentReader}
		name: 	#ClassCategoryReader
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	nil
		category: 	#'Kernel-Classes'
		traitComposition: 	{}
		localSelectors: 	nil


Pragma class>>withPragmasIn:do:
	Receiver: Pragma
	Arguments and temporary variables: 
		aClass: 	ClassCategoryReader
		aBlock: 	[ :pragma | stream nextPut: pragma ]
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary(#=->Pragma>>#= #analogousCodeTo:->Pragma>>#analo...etc...
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('method' 'keyword' 'arguments')
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#Pragma
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'Kernel-Pragmas'
		traitComposition: 	{}
		localSelectors: 	nil


[ :behavior | Pragma withPragmasIn: behavior do: [ :pragma | stream nextPut: pragma ] ] in [ :stream | 
SystemNavigation new
	allBehaviorsDo: [ :behavior | Pragma withPragmasIn: behavior do: [ :pragma | stream nextPut: pragma ] ] ] in PragmaCollector class>>allSystemPragmas
	Receiver: PragmaCollector
	Arguments and temporary variables: 
		stream: 	a WriteStream
		behavior: 	ClassCategoryReader
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary(#addPragma:->PragmaCollector>>#addPragma: #added...etc...
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('announcer' 'collected' 'filter')
		organization: 	a ClassOrganization
		subclasses: 	{SpecPragmaCollector}
		name: 	#PragmaCollector
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'Kernel-Pragmas-Collector'
		traitComposition: 	{}
		localSelectors: 	nil


[ :aClass | 
aBlock
	value: aClass;
	value: aClass class ] in SystemNavigation>>allBehaviorsDo:
	Receiver: a SystemNavigation
	Arguments and temporary variables: 
		aBlock: 	[ :behavior | Pragma withPragmasIn: behavior do: [ :pragma | stream nex...etc...
		aClass: 	ClassCategoryReader
	Receiver's instance variables: 
		environment: 	a SystemDictionary(lots of globals)


[ :name | aBlock value: (self at: name) ] in SystemDictionary>>allClassesDo:
	Receiver: a SystemDictionary(lots of globals)
	Arguments and temporary variables: 
		aBlock: 	[ :aClass | 
aBlock
	value: aClass;
	value: aClass class ]
		name: 	#ClassCategoryReader
	Receiver's instance variables: 
		tally: 	3800
		array: 	an Array(#MemoryHandle->MemoryHandle #MetacelloPackagesSpec->MetacelloPa...etc...
		cachedClassNames: 	an OrderedCollection(#AColorSelectorMorph #AGroupHasBeenAdded...etc...
		cachedNonClassNames: 	an OrderedCollection(#ActiveEvent #ActiveHand #ActiveWorld...etc...


OrderedCollection>>do:
	Receiver: an OrderedCollection(#AColorSelectorMorph #AGroupHasBeenAdded #AGroupHasBeenCreated #AGrou...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :name | aBlock value: (self at: name) ]
		index: 	397
	Receiver's instance variables: 
		array: 	#(#AColorSelectorMorph #AGroupHasBeenAdded #AGroupHasBeenCreated #AGroup...etc...
		firstIndex: 	1
		lastIndex: 	3693


SystemDictionary>>allClassesDo:
	Receiver: a SystemDictionary(lots of globals)
	Arguments and temporary variables: 
		aBlock: 	[ :aClass | 
aBlock
	value: aClass;
	value: aClass class ]
	Receiver's instance variables: 
		tally: 	3800
		array: 	an Array(#MemoryHandle->MemoryHandle #MetacelloPackagesSpec->MetacelloPa...etc...
		cachedClassNames: 	an OrderedCollection(#AColorSelectorMorph #AGroupHasBeenAdded...etc...
		cachedNonClassNames: 	an OrderedCollection(#ActiveEvent #ActiveHand #ActiveWorld...etc...


SystemNavigation>>allBehaviorsDo:
	Receiver: a SystemNavigation
	Arguments and temporary variables: 
		aBlock: 	[ :behavior | Pragma withPragmasIn: behavior do: [ :pragma | stream nex...etc...
	Receiver's instance variables: 
		environment: 	a SystemDictionary(lots of globals)


[ :stream | 
SystemNavigation new
	allBehaviorsDo: [ :behavior | Pragma withPragmasIn: behavior do: [ :pragma | stream nextPut: pragma ] ] ] in PragmaCollector class>>allSystemPragmas
	Receiver: PragmaCollector
	Arguments and temporary variables: 
		stream: 	a WriteStream
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary(#addPragma:->PragmaCollector>>#addPragma: #added...etc...
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('announcer' 'collected' 'filter')
		organization: 	a ClassOrganization
		subclasses: 	{SpecPragmaCollector}
		name: 	#PragmaCollector
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'Kernel-Pragmas-Collector'
		traitComposition: 	{}
		localSelectors: 	nil


Array class(SequenceableCollection class)>>new:streamContents:
	Receiver: Array
	Arguments and temporary variables: 
		newSize: 	100
		blockWithArg: 	[ :stream | 
SystemNavigation new
	allBehaviorsDo: [ :behavior | ...etc...
		stream: 	a WriteStream
	Receiver's instance variables: 
		superclass: 	ArrayedCollection
		methodDict: 	a MethodDictionary(#'+*'->Array>>#'+*' #asArray->Array>>#asArray #a...etc...
		format: 	6402
		layout: 	a VariableLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	{WeakArray. WeakActionSequence. Cubic. MetacelloMethodSectionPath}
		name: 	#Array
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'Collections-Sequenceable'
		traitComposition: 	{}
		localSelectors: 	nil


Array class(SequenceableCollection class)>>streamContents:
	Receiver: Array
	Arguments and temporary variables: 
		blockWithArg: 	[ :stream | 
SystemNavigation new
	allBehaviorsDo: [ :behavior | ...etc...
	Receiver's instance variables: 
		superclass: 	ArrayedCollection
		methodDict: 	a MethodDictionary(#'+*'->Array>>#'+*' #asArray->Array>>#asArray #a...etc...
		format: 	6402
		layout: 	a VariableLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	{WeakArray. WeakActionSequence. Cubic. MetacelloMethodSectionPath}
		name: 	#Array
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'Collections-Sequenceable'
		traitComposition: 	{}
		localSelectors: 	nil


PragmaCollector class>>allSystemPragmas
	Receiver: PragmaCollector
	Arguments and temporary variables: 

	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary(#addPragma:->PragmaCollector>>#addPragma: #added...etc...
		format: 	136
		layout: 	a FixedLayout
		instanceVariables: 	#('announcer' 'collected' 'filter')
		organization: 	a ClassOrganization
		subclasses: 	{SpecPragmaCollector}
		name: 	#PragmaCollector
		classPool: 	a Dictionary()
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'Kernel-Pragmas-Collector'
		traitComposition: 	{}
		localSelectors: 	nil


[ 
self collected copy do: [ :pragma | self removePragma: pragma ].
self class allSystemPragmas do: [ :pragma | self addPragma: pragma ] ] in PragmaCollector>>reset
	Receiver: a PragmaCollector
	Arguments and temporary variables: 

	Receiver's instance variables: 
		announcer: 	nil
		collected: 	an OrderedCollection()
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


[ 
oldAnnouncer := announcer.
announcer := nil.
aBlock value ] in PragmaCollector>>noMoreAnnounceWhile:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aBlock: 	[ 
self collected copy do: [ :pragma | self removePragma: pragma ].
sel...etc...
		oldAnnouncer: 	an Announcer
	Receiver's instance variables: 
		announcer: 	nil
		collected: 	an OrderedCollection()
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


BlockClosure>>ensure:
	Receiver: [ 
oldAnnouncer := announcer.
announcer := nil.
aBlock value ]
	Arguments and temporary variables: 
		aBlock: 	[ announcer := oldAnnouncer ]
		complete: 	nil
		returnValue: 	nil
	Receiver's instance variables: 
		outerContext: 	PragmaCollector>>noMoreAnnounceWhile:
		startpc: 	26
		numArgs: 	0


PragmaCollector>>noMoreAnnounceWhile:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		oldAnnouncer: 	an Announcer
		aBlock: 	[ 
self collected copy do: [ :pragma | self removePragma: pragma ].
sel...etc...
	Receiver's instance variables: 
		announcer: 	nil
		collected: 	an OrderedCollection()
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


PragmaCollector>>reset
	Receiver: a PragmaCollector
	Arguments and temporary variables: 

	Receiver's instance variables: 
		announcer: 	nil
		collected: 	an OrderedCollection()
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


KMPragmaKeymapBuilder>>pragmaCollector
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>collectRegistrations
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 
		menu: 	a PragmaMenuAndShortcutRegistration
	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


KMPragmaKeymapBuilder>>reset
	Receiver: a KMPragmaKeymapBuilder
	Arguments and temporary variables: 

	Receiver's instance variables: 
		pragmaKeywords: 	an OrderedCollection()
		model: 	nil
		pragmaCollector: 	a PragmaCollector


MessageSend>>value
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 

	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg: 	a PragmaRemoved
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


MessageSend>>cull:cull:
	Receiver: MessageSend(#reset -> a KMPragmaKeymapBuilder)
	Arguments and temporary variables: 
		arg1: 	a PragmaRemoved
		arg2: 	an Announcer
	Receiver's instance variables: 
		receiver: 	a KMPragmaKeymapBuilder
		selector: 	#reset
		arguments: 	#()


[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


BlockClosure>>on:do:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	on: exception fork: handlerAction
	"Activate the receiver. In ca...etc...
		handlerActive: 	true
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


BlockClosure>>on:fork:
	Receiver: [ action cull: anAnnouncement cull: announcer ]
	Arguments and temporary variables: 
		exception: 	UnhandledError
		handlerAction: 	[ :ex | ex pass ]
	Receiver's instance variables: 
		outerContext: 	AnnouncementSubscription>>deliver:
		startpc: 	47
		numArgs: 	0


AnnouncementSubscription>>deliver:
	Receiver: an AnnouncementSubscription
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		announcementClass: 	PragmaAnnouncement
		subscriber: 	a KMPragmaKeymapBuilder
		action: 	MessageSend(#reset -> a KMPragmaKeymapBuilder)


[ subscription deliver: anAnnouncement ] in SubscriptionRegistry>>deliver:to:startingAt:
	Receiver: a SubscriptionRegistry
	Arguments and temporary variables: 
<<error during printing>
	Receiver's instance variables: 
		subscriptions: 	an IdentitySet(an AnnouncementSubscription)
		monitor: 	a Semaphore()


BlockClosure>>ifCurtailed:
	Receiver: [ subscription deliver: anAnnouncement ]
	Arguments and temporary variables: 
		aBlock: 	[ self deliver: anAnnouncement to: subs startingAt: index + 1 ]
		complete: 	nil
		result: 	nil
	Receiver's instance variables: 
		outerContext: 	SubscriptionRegistry>>deliver:to:startingAt:
		startpc: 	54
		numArgs: 	0


SubscriptionRegistry>>deliver:to:startingAt:
	Receiver: a SubscriptionRegistry
	Arguments and temporary variables: 
<<error during printing>
	Receiver's instance variables: 
		subscriptions: 	an IdentitySet(an AnnouncementSubscription)
		monitor: 	a Semaphore()


SubscriptionRegistry>>deliver:to:
	Receiver: a SubscriptionRegistry
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
		subs: 	an Array(an AnnouncementSubscription)
	Receiver's instance variables: 
		subscriptions: 	an IdentitySet(an AnnouncementSubscription)
		monitor: 	a Semaphore()


SubscriptionRegistry>>deliver:
	Receiver: a SubscriptionRegistry
	Arguments and temporary variables: 
		interestedSubscriptions: 	an Array(an AnnouncementSubscription)
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		subscriptions: 	an IdentitySet(an AnnouncementSubscription)
		monitor: 	a Semaphore()


Announcer>>announce:
	Receiver: an Announcer
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
		announcement: 	a PragmaRemoved
	Receiver's instance variables: 
		registry: 	a SubscriptionRegistry


PragmaCollector>>announce:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		anAnnouncement: 	a PragmaRemoved
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


PragmaCollector>>removePragma:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		aPragma: 	<keymap>
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


PragmaCollector>>removedEventOccurs:
	Receiver: a PragmaCollector
	Arguments and temporary variables: 
		anEvent: 	a MethodRemoved
		found: 	<keymap>
	Receiver's instance variables: 
		announcer: 	an Announcer
		collected: 	an OrderedCollection(<keymap> <keymap> <keymap> <keymap> <keymap> <k...etc...
		filter: 	[ :prg | (self pragmaKeywords includes: prg keyword) and: [ prg selecto...etc...


WeakMessageSend>>value:
	Receiver: WeakMessageSend(#removedEventOccurs: -> a PragmaCollector)
	Arguments and temporary variables: 
		anObject: 	a MethodRemoved
	Receiver's instance variables: 
		selector: 	#removedEventOccurs:
		shouldBeNil: 	#()
		arguments: 	a WeakArray()


WeakMessageSend>>cull:
	Receiver: WeakMessageSend(#removedEventOccurs: -> a PragmaCollector)
	Arguments and temporary variables: 
		arg: 	a MethodRemoved
	Receiver's instance variables: 
		selector: 	#removedEventOccurs:
		shouldBeNil: 	#()
		arguments: 	a WeakArray()


WeakMessageSend>>cull:cull:
	Receiver: WeakMessageSend(#removedEventOccurs: -> a PragmaCollector)
	Arguments and temporary variables: 
		arg1: 	a MethodRemoved
		arg2: 	a SystemAnnouncer
	Receiver's instance variables: 
		selector: 	#removedEventOccurs:
		shouldBeNil: 	#()
		arguments: 	a WeakArray()



--- The full stack ---
ClassCategoryReader class(Behavior)>>selectorsAndMethodsDo:
Pragma class>>withPragmasIn:do:
[ :behavior | Pragma withPragmasIn: behavior do: [ :pragma | stream nextPut: pragma ] ] in [ :stream | 
SystemNavigation new
	allBehaviorsDo: [ :behavior | Pragma withPragmasIn: behavior do: [ :pragma | stream nextPut: pragma ] ] ] in PragmaCollector class>>allSystemPragmas
[ :aClass | 
aBlock
	value: aClass;
	value: aClass class ] in SystemNavigation>>allBehaviorsDo:
[ :name | aBlock value: (self at: name) ] in SystemDictionary>>allClassesDo:
OrderedCollection>>do:
SystemDictionary>>allClassesDo:
SystemNavigation>>allBehaviorsDo:
[ :stream | 
SystemNavigation new
	allBehaviorsDo: [ :behavior | Pragma withPragmasIn: behavior do: [ :pragma | stream nextPut: pragma ] ] ] in PragmaCollector class>>allSystemPragmas
Array class(SequenceableCollection class)>>new:streamContents:
Array class(SequenceableCollection class)>>streamContents:
PragmaCollector class>>allSystemPragmas
[ 
self collected copy do: [ :pragma | self removePragma: pragma ].
self class allSystemPragmas do: [ :pragma | self addPragma: pragma ] ] in PragmaCollector>>reset
[ 
oldAnnouncer := announcer.
announcer := nil.
aBlock value ] in PragmaCollector>>noMoreAnnounceWhile:
BlockClosure>>ensure:
PragmaCollector>>noMoreAnnounceWhile:
PragmaCollector>>reset
KMPragmaKeymapBuilder>>pragmaCollector
KMPragmaKeymapBuilder>>collectRegistrations
KMPragmaKeymapBuilder>>reset
MessageSend>>value
MessageSend>>cull:
MessageSend>>cull:cull:
[ action cull: anAnnouncement cull: announcer ] in AnnouncementSubscription>>deliver:
BlockClosure>>on:do:
BlockClosure>>on:fork:
AnnouncementSubscription>>deliver:
[ subscription deliver: anAnnouncement ] in SubscriptionRegistry>>deliver:to:startingAt:
BlockClosure>>ifCurtailed:
SubscriptionRegistry>>deliver:to:startingAt:
SubscriptionRegistry>>deliver:to:
SubscriptionRegistry>>deliver:
Announcer>>announce:
PragmaCollector>>announce:
PragmaCollector>>removePragma:
PragmaCollector>>removedEventOccurs:
WeakMessageSend>>value:
WeakMessageSend>>cull:
WeakMessageSend>>cull:cull:
 - - - - - - - - - - - - - - -  
			- - - - - - - - - - - - - - - - - -
[ action cull: anAnnouncement cull: announcer ] in WeakAnnouncementSubscription>>deliver:
BlockClosure>>on:do:
BlockClosure>>on:fork:
WeakAnnouncementSubscription>>deliver:
[ subscription deliver: anAnnouncement ] in SubscriptionRegistry>>deliver:to:startingAt:
BlockClosure>>ifCurtailed:
SubscriptionRegistry>>deliver:to:startingAt:
SubscriptionRegistry>>deliver:to:
SubscriptionRegistry>>deliver:
SystemAnnouncer(Announcer)>>announce:
SystemAnnouncer>>announce:
SystemAnnouncer>>methodRemoved:selector:inProtocol:class:origin:
Metaclass(ClassDescription)>>removeSelector:
MCMethodDefinition>>removeSelector:fromClass:
MCMethodDefinition>>unload
[ :each | each unload ] in MCPackageLoader>>basicLoadDefinitions
[ :each | 
| newLabel |
"Special handling for first and last element"
(count = 0 or: [ count + 1 = size or: [ (Time millisecondsSince: lastUpdate) >= msecs ] ])
	ifTrue: [ 
		bar current: count.
		oldLabel = (newLabel := (labelBlock cull: each) ifNil: [ oldLabel ])
			ifFalse: [ ProgressNotification signal: '' extra: (oldLabel := newLabel) ].
		lastUpdate := Time millisecondClockValue ].
aBlock value: each.
count := count + 1 ] in [ :bar | 
labelBlock := aStringOrBlock isString
	ifTrue: [ 
		bar label: aStringOrBlock.
		[ :item | aStringOrBlock ] ]
	ifFalse: [ aStringOrBlock ].
self
	do: [ :each | 
		| newLabel |
		"Special handling for first and last element"
		(count = 0 or: [ count + 1 = size or: [ (Time millisecondsSince: lastUpdate) >= msecs ] ])
			ifTrue: [ 
				bar current: count.
				oldLabel = (newLabel := (labelBlock cull: each) ifNil: [ oldLabel ])
					ifFalse: [ ProgressNotification signal: '' extra: (oldLabel := newLabel) ].
				lastUpdate := Time millisecondClockValue ].
		aBlock value: each.
		count := count + 1 ] ] in OrderedCollection(Collection)>>do:displayingProgress:every:
OrderedCollection>>do:
[ :bar | 
labelBlock := aStringOrBlock isString
	ifTrue: [ 
		bar label: aStringOrBlock.
		[ :item | aStringOrBlock ] ]
	ifFalse: [ aStringOrBlock ].
self
	do: [ :each | 
		| newLabel |
		"Special handling for first and last element"
		(count = 0 or: [ count + 1 = size or: [ (Time millisecondsSince: lastUpdate) >= msecs ] ])
			ifTrue: [ 
				bar current: count.
				oldLabel = (newLabel := (labelBlock cull: each) ifNil: [ oldLabel ])
					ifFalse: [ ProgressNotification signal: '' extra: (oldLabel := newLabel) ].
				lastUpdate := Time millisecondClockValue ].
		aBlock value: each.
		count := count + 1 ] ] in OrderedCollection(Collection)>>do:displayingProgress:every:
BlockClosure>>cull:
[ result := block cull: self ] in [ 
self prepareForRunning.
[ result := block cull: self ]
	on: JobNotification
	do: [ :notification | notification handle: self ] ] in Job>>run
BlockClosure>>on:do:
[ 
self prepareForRunning.
[ result := block cull: self ]
	on: JobNotification
	do: [ :notification | notification handle: self ] ] in Job>>run
BlockClosure>>ensure:
Job>>run
MorphicUIManager(UIManager)>>displayProgress:from:to:during:
ByteString(String)>>displayProgressFrom:to:during:
OrderedCollection(Collection)>>do:displayingProgress:every:
OrderedCollection(Collection)>>do:displayingProgress:
MCPackageLoader>>basicLoadDefinitions
[ self basicLoadDefinitions ] in [ self handleLoadErrorsDuring: [ self basicLoadDefinitions ] ] in MCPackageLoader>>basicLoad
BlockClosure>>on:do:
[ 
aBlock
	on: InMidstOfFileinNotification
	do: [ :notification | notification resume: true ] ] in MCPackageLoader>>handleLoadErrorsDuring:
BlockClosure>>on:do:
MCPackageLoader>>handleLoadErrorsDuring:
[ self handleLoadErrorsDuring: [ self basicLoadDefinitions ] ] in MCPackageLoader>>basicLoad
BlockClosure>>ensure:
MCPackageLoader>>basicLoad
[ self basicLoad ] in MCPackageLoader>>loadWithNameLike:
BlockClosure>>ensure:
MCPackageLoader>>useChangeSetNamed:during:
MCPackageLoader>>useNewChangeSetNamedLike:during:
MCPackageLoader>>loadWithNameLike:
MCPackageLoader class>>unloadPackage:
MCWorkingCopy>>unload
UnReloader>>unloadNautilus
UnReloader>>unload
UndefinedObject>>DoIt
OpalCompiler>>evaluate
SmalltalkEditor>>evaluateSelectionAndDo:
SmalltalkEditor>>printIt
SmalltalkEditor>>printIt:
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 TextMorphForEditView(TextMorph)>>basicKeyStroke:
TextMorphForEditView(TextMorph)>>handleInteraction:
TextMorphForEditView>>handleInteraction:
TextMorphForEditView(TextMorph)>>basicKeyStroke:
[ self basicKeyStroke: evt ] in TextMorphForEditView(TextMorph)>>keyStroke:
NECController class>>codeCompletionAround:textMorph:keyStroke:
ToolRegistry>>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:
BlockClosure>>on:do:
WorldMorph(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:
WorldMorph>>doOneCycle
[ 
World doOneCycle.
Processor yield.
false ] in MorphicUIManager>>spawnNewProcess
[ 
self value.
Processor terminateActive ] in BlockClosure>>newProcess
-------------------------------------------------------------------------------