===============================================================================
Notice: Errors in script loaded from /builds/macta/WillowPagerDuty/build/loadProject.st
===============================================================================
THERE_BE_DRAGONS_HERE
LGit_GIT_ERROR: SSL error: error:140E0197:SSL routines:SSL_shutdown:shutdown while in init
15 May 2018 3:01:38.976377 am

VM: unix - x86_64 - linux-gnu - CoInterpreter VMMaker.oscog-eem.2265 uuid: 76b62109-629a-4c39-9641-67b53321df9a Aug 27 2017
StackToRegisterMappingCogit VMMaker.oscog-eem.2262 uuid: 8b531242-de02-48aa-b418-8d2dde0bec6c Aug 27 2017
VM: 201708271955 https://github.com/OpenSmalltalk/opensmalltalk-vm.git $ Date: Sun Aug 27 21:55:26 2017 +0200 $ Plugins: 201708271955 https://github.com/OpenSmalltalk/opensmalltalk-vm.git $

Image: Pharo6.0 [Latest update: #60540]

LGitReturnCodeEnum>>handleLGitReturnCode
	Receiver: a LGitReturnCodeEnum(#git_error [-1])
	Arguments and temporary variables: 
		handler: 	LGit_GIT_ERROR
	Receiver's instance variables: 
		value: 	-1


LGitRepository(LGitExternalObject)>>withReturnHandlerDo:
	Receiver: a LGitRepository (<not initialized>)
	Arguments and temporary variables: 
		callBlock: 	[ self
	clone: self
	url: aString
	local_path: aFileReference pathSt...etc...
	Receiver's instance variables: 
		handle: 	@ 16r00000000
		repositoryPath: 	File @ pharo-local/iceberg/ba-st/Willow-Bootstrap
		isOpen: 	nil
		workingDirectory: 	nil


LGitRepository>>clone:options:to:
	Receiver: a LGitRepository (<not initialized>)
	Arguments and temporary variables: 
		aString: 	'https://github.com/ba-st/Willow-Bootstrap.git'
		cloneOptions: 	a LGitCloneOptions ()
		aFileReference: 	File @ pharo-local/iceberg/ba-st/Willow-Bootstrap
	Receiver's instance variables: 
		handle: 	@ 16r00000000
		repositoryPath: 	File @ pharo-local/iceberg/ba-st/Willow-Bootstrap
		isOpen: 	nil
		workingDirectory: 	nil


LGitRepository>>clone:options:
	Receiver: a LGitRepository (<not initialized>)
	Arguments and temporary variables: 
		aString: 	'https://github.com/ba-st/Willow-Bootstrap.git'
		cloneOptions: 	a LGitCloneOptions ()
	Receiver's instance variables: 
		handle: 	@ 16r00000000
		repositoryPath: 	File @ pharo-local/iceberg/ba-st/Willow-Bootstrap
		isOpen: 	nil
		workingDirectory: 	nil


[ repo clone: url options: cloneOptions ] in [ | repo cloneOptions |
repo := LGitRepository on: self location.
cloneOptions := LGitCloneOptions
	withCredentialsProvider: IceCredentialsProvider default.
cloneOptions checkoutOptions
	checkoutStrategy: LGitCheckoutStrategyEnum git_checkout_none.
[ repo clone: url options: cloneOptions ]
	on: LGit_GIT_ERROR
	do: [ :e | e acceptError: IceLibgitErrorVisitor new ].
repo
	checkout:
		(aBranchName
			ifNil:
				[ self branch ifNotNil: [ :b | b name ] ifNil: [ 'master' ] ]).
(LGitRemote of: repo named: 'origin')
	lookup;
	setUrl: url ] in IceLibgitLocalRepository>>cloneRepositoryFrom:branch:
	Receiver: an IceLibgitLocalRepository
	Arguments and temporary variables: 
		aRemote: 	noname (https://github.com/ba-st/Willow-Bootstrap.git)
		aBranchName: 	'v8'
		url: 	'https://github.com/ba-st/Willow-Bootstrap.git'
		repo: 	a LGitRepository (<not initialized>)
		cloneOptions: 	a LGitCloneOptions ()
	Receiver's instance variables: 
		location: 	File @ pharo-local/iceberg/ba-st/Willow-Bootstrap
		subdirectory: 	'source'
		frontend: 	nil


BlockClosure>>on:do:
	Receiver: [ repo clone: url options: cloneOptions ]
	Arguments and temporary variables: 
		exception: 	LGit_GIT_ERROR
		handlerAction: 	[ :e | e acceptError: IceLibgitErrorVisitor new ]
	Receiver's instance variables: 
		outerContext: 	[ | repo cloneOptions |
repo := LGitRepository on: self location....etc...
		startpc: 	301
		numArgs: 	0


[ | repo cloneOptions |
repo := LGitRepository on: self location.
cloneOptions := LGitCloneOptions
	withCredentialsProvider: IceCredentialsProvider default.
cloneOptions checkoutOptions
	checkoutStrategy: LGitCheckoutStrategyEnum git_checkout_none.
[ repo clone: url options: cloneOptions ]
	on: LGit_GIT_ERROR
	do: [ :e | e acceptError: IceLibgitErrorVisitor new ].
repo
	checkout:
		(aBranchName
			ifNil:
				[ self branch ifNotNil: [ :b | b name ] ifNil: [ 'master' ] ]).
(LGitRemote of: repo named: 'origin')
	lookup;
	setUrl: url ] in IceLibgitLocalRepository>>cloneRepositoryFrom:branch:
	Receiver: an IceLibgitLocalRepository
	Arguments and temporary variables: 
		aRemote: 	noname (https://github.com/ba-st/Willow-Bootstrap.git)
		aBranchName: 	'v8'
		url: 	'https://github.com/ba-st/Willow-Bootstrap.git'
		repo: 	a LGitRepository (<not initialized>)
		cloneOptions: 	a LGitCloneOptions ()
	Receiver's instance variables: 
		location: 	File @ pharo-local/iceberg/ba-st/Willow-Bootstrap
		subdirectory: 	'source'
		frontend: 	nil


[ self checkInitialized.
aBlock value ] in LGitGlobal class>>runSequence:
	Receiver: LGitGlobal
	Arguments and temporary variables: 
		aBlock: 	[ | repo cloneOptions |
repo := LGitRepository on: self location.
clone...etc...
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary(#call:->LGitGlobal>>#call: #call:options:->LGitG...etc...
		format: 	0
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#LGitGlobal
		classPool: 	a Dictionary(#LibraryHandle->nil #Session->nil )
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'LibGit-Core-Abstracts'
		traitComposition: 	TLGitCalloutTrait
		localSelectors: 	a Set()


[ activeProcess psValueAt: index put: anObject.
aBlock value ] in LGitActionSequence(DynamicVariable)>>value:during:
	Receiver: a LGitActionSequence
	Arguments and temporary variables: 
		anObject: 	IceLibgitLocalRepository>>cloneRepositoryFrom:branch:
		aBlock: 	[ self checkInitialized.
aBlock value ]
		activeProcess: 	a Process in nil
		oldValue: 	nil
	Receiver's instance variables: 
		index: 	10


BlockClosure>>ensure:
	Receiver: [ activeProcess psValueAt: index put: anObject.
aBlock value ]
	Arguments and temporary variables: 
		aBlock: 	[ activeProcess psValueAt: index put: oldValue ]
		complete: 	nil
		returnValue: 	nil
	Receiver's instance variables: 
		outerContext: 	LGitActionSequence(DynamicVariable)>>value:during:
		startpc: 	79
		numArgs: 	0


LGitActionSequence(DynamicVariable)>>value:during:
	Receiver: a LGitActionSequence
	Arguments and temporary variables: 
		anObject: 	IceLibgitLocalRepository>>cloneRepositoryFrom:branch:
		aBlock: 	[ self checkInitialized.
aBlock value ]
		activeProcess: 	a Process in nil
		oldValue: 	nil
	Receiver's instance variables: 
		index: 	10


LGitActionSequence class(DynamicVariable class)>>value:during:
	Receiver: LGitActionSequence
	Arguments and temporary variables: 
		anObject: 	IceLibgitLocalRepository>>cloneRepositoryFrom:branch:
		aBlock: 	[ self checkInitialized.
aBlock value ]
	Receiver's instance variables: 
		superclass: 	DynamicVariable
		methodDict: 	a MethodDictionary()
		format: 	65537
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#LGitActionSequence
		classPool: 	a Dictionary()
		sharedPools: 	nil
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'LibGit-Core-Abstracts'
		traitComposition: 	{}
		localSelectors: 	nil
		soleInstance: 	a LGitActionSequence


LGitGlobal class>>runSequence:
	Receiver: LGitGlobal
	Arguments and temporary variables: 
		aBlock: 	[ | repo cloneOptions |
repo := LGitRepository on: self location.
clone...etc...
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary(#call:->LGitGlobal>>#call: #call:options:->LGitG...etc...
		format: 	0
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#LGitGlobal
		classPool: 	a Dictionary(#LibraryHandle->nil #Session->nil )
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'LibGit-Core-Abstracts'
		traitComposition: 	TLGitCalloutTrait
		localSelectors: 	a Set()


IceLibgitLocalRepository>>cloneRepositoryFrom:branch:
	Receiver: an IceLibgitLocalRepository
	Arguments and temporary variables: 
		aRemote: 	noname (https://github.com/ba-st/Willow-Bootstrap.git)
		aBranchName: 	'v8'
		url: 	'https://github.com/ba-st/Willow-Bootstrap.git'
	Receiver's instance variables: 
		location: 	File @ pharo-local/iceberg/ba-st/Willow-Bootstrap
		subdirectory: 	'source'
		frontend: 	nil


IceRepositoryCreator>>createRepository
	Receiver: an IceRepositoryCreator
	Arguments and temporary variables: 
		backend: 	an IceLibgitLocalRepository
		locationToUse: 	File @ pharo-local/iceberg/ba-st/Willow-Bootstrap
	Receiver's instance variables: 
		location: 	nil
		url: 	'https://github.com/ba-st/Willow-Bootstrap.git'
		remote: 	nil
		branchName: 	'v8'
		subdirectory: 	'source'
		storageClass: 	IceLibgitLocalRepository


[ (IceRepositoryCreator new
	url: urlToUse;
	subdirectory: repoPath;
	branchName: self projectVersion;
	createRepository) register ] in [ | urlToUse |
urlToUse := remote url.
[ (IceRepositoryCreator new
	url: urlToUse;
	subdirectory: repoPath;
	branchName: self projectVersion;
	createRepository) register ]
	on: IceAuthenticationError
	do: [ :e | 
		self
			crLog:
				('I got an error while cloning: {1}. I will try to clone the HTTPS variant.'
					format: {e messageText}).
		urlToUse := remote httpsUrl.
		e retry ] ] in MCGitHubRepository(MCGitBasedNetworkRepository)>>getOrCreateIcebergRepository
	Receiver: a MCGitHubRepository(github://ba-st/Willow-Bootstrap:v8/source)
	Arguments and temporary variables: 
		remoteUrl: 	'git@github.com:ba-st/Willow-Bootstrap.git'
		remote: 	noname (git@github.com:ba-st/Willow-Bootstrap.git)
		urlToUse: 	'https://github.com/ba-st/Willow-Bootstrap.git'
	Receiver's instance variables: 
		creationTemplate: 	nil
		cache: 	nil
		allFileNames: 	nil
		cacheFileNames: 	nil
		directory: 	nil
		readonly: 	true
		repositoryProperties: 	nil
		projectPath: 	'ba-st/Willow-Bootstrap'
		projectVersion: 	'v8'
		repoPath: 	'source'
		projectVersionPattern: 	nil


BlockClosure>>on:do:
	Receiver: [ (IceRepositoryCreator new
	url: urlToUse;
	subdirectory: repoPath;
	branchName: self pro...etc...
	Arguments and temporary variables: 
		exception: 	IceAuthenticationError
		handlerAction: 	[ :e | 
self
	crLog:
		('I got an error while cloning: {1}. I wi...etc...
	Receiver's instance variables: 
		outerContext: 	[ | urlToUse |
urlToUse := remote url.
[ (IceRepositoryCreator ne...etc...
		startpc: 	265
		numArgs: 	0


[ | urlToUse |
urlToUse := remote url.
[ (IceRepositoryCreator new
	url: urlToUse;
	subdirectory: repoPath;
	branchName: self projectVersion;
	createRepository) register ]
	on: IceAuthenticationError
	do: [ :e | 
		self
			crLog:
				('I got an error while cloning: {1}. I will try to clone the HTTPS variant.'
					format: {e messageText}).
		urlToUse := remote httpsUrl.
		e retry ] ] in MCGitHubRepository(MCGitBasedNetworkRepository)>>getOrCreateIcebergRepository
	Receiver: a MCGitHubRepository(github://ba-st/Willow-Bootstrap:v8/source)
	Arguments and temporary variables: 
		remoteUrl: 	'git@github.com:ba-st/Willow-Bootstrap.git'
		remote: 	noname (git@github.com:ba-st/Willow-Bootstrap.git)
		urlToUse: 	'https://github.com/ba-st/Willow-Bootstrap.git'
	Receiver's instance variables: 
		creationTemplate: 	nil
		cache: 	nil
		allFileNames: 	nil
		cacheFileNames: 	nil
		directory: 	nil
		readonly: 	true
		repositoryProperties: 	nil
		projectPath: 	'ba-st/Willow-Bootstrap'
		projectVersion: 	'v8'
		repoPath: 	'source'
		projectVersionPattern: 	nil


OrderedCollection(Collection)>>detect:ifFound:ifNone:
	Receiver: an OrderedCollection()
	Arguments and temporary variables: 
		aBlock: 	[ :repo | repo origin referencesSameRemoteLocationAs: remote ]
		foundBlock: 	[ :element | element ]
		exceptionBlock: 	[ | urlToUse |
urlToUse := remote url.
[ (IceRepositoryCreator ...etc...
	Receiver's instance variables: 
		array: 	#(nil nil nil nil nil nil nil nil nil nil)
		firstIndex: 	1
		lastIndex: 	0


OrderedCollection(Collection)>>detect:ifNone:
	Receiver: an OrderedCollection()
	Arguments and temporary variables: 
		aBlock: 	[ :repo | repo origin referencesSameRemoteLocationAs: remote ]
		exceptionBlock: 	[ | urlToUse |
urlToUse := remote url.
[ (IceRepositoryCreator ...etc...
	Receiver's instance variables: 
		array: 	#(nil nil nil nil nil nil nil nil nil nil)
		firstIndex: 	1
		lastIndex: 	0


MCGitHubRepository(MCGitBasedNetworkRepository)>>getOrCreateIcebergRepository
	Receiver: a MCGitHubRepository(github://ba-st/Willow-Bootstrap:v8/source)
	Arguments and temporary variables: 
		remoteUrl: 	'git@github.com:ba-st/Willow-Bootstrap.git'
		remote: 	noname (git@github.com:ba-st/Willow-Bootstrap.git)
	Receiver's instance variables: 
		creationTemplate: 	nil
		cache: 	nil
		allFileNames: 	nil
		cacheFileNames: 	nil
		directory: 	nil
		readonly: 	true
		repositoryProperties: 	nil
		projectPath: 	'ba-st/Willow-Bootstrap'
		projectVersion: 	'v8'
		repoPath: 	'source'
		projectVersionPattern: 	nil


IceGithubRepositoryType>>mcRepository
	Receiver: an IceGithubRepositoryType
	Arguments and temporary variables: 
		baseRepo: 	a MCGitHubRepository(github://ba-st/Willow-Bootstrap:v8/source)
	Receiver's instance variables: 
		location: 	'github://ba-st/Willow-Bootstrap:v8/source'


Iceberg class>>mcRepositoryFor:
	Receiver: Iceberg
	Arguments and temporary variables: 
		aLocationString: 	'github://ba-st/Willow-Bootstrap:v8/source'
	Receiver's instance variables: 
		superclass: 	Object
		methodDict: 	a MethodDictionary()
		format: 	0
		layout: 	a FixedLayout
		instanceVariables: 	nil
		organization: 	a ClassOrganization
		subclasses: 	nil
		name: 	#Iceberg
		classPool: 	a Dictionary(#EnableMetacelloIntegration->true #RemoteTypeSelector->...etc...
		sharedPools: 	an OrderedCollection()
		environment: 	a SystemDictionary(lots of globals)
		category: 	#'Iceberg-Core'
		traitComposition: 	{}
		localSelectors: 	nil
		icebergAnnouncer: 	nil


IceMetacelloPharoPlatform>>createRepository:
	Receiver: an IceMetacelloPharoPlatform
	Arguments and temporary variables: 
		aRepositorySpec: 	spec repository: 'github://ba-st/Willow-Bootstrap:v8/source'
		type: 	'github'
	Receiver's instance variables: 
		bypassProgressBars: 	false
		bypassGoferLoadUpdateCategories: 	false


MetacelloMCBaselineProject(MetacelloMCProject)>>createRepository:
	Receiver: BaselineOfPagerDuty(baseline [BaselineOfPagerDuty], )
	Arguments and temporary variables: 
		aRepositorySpec: 	spec repository: 'github://ba-st/Willow-Bootstrap:v8/source'
	Receiver's instance variables: 
		versionMap: 	a Dictionary('baseline'->baseline [BaselineOfPagerDuty] )
		symbolicVersionMap: 	nil
		errorMap: 	nil
		loader: 	nil
		loaderClass: 	MetacelloLoadingMCSpecLoader
		loadType: 	#linear
		configuration: 	a BaselineOfPagerDuty
		projectAttributes: 	#()
		versionNumberClass: 	MetacelloVersionNumber


MetacelloRepositorySpec>>createRepository
	Receiver: spec repository: 'github://ba-st/Willow-Bootstrap:v8/source'
	Arguments and temporary variables: 
		repo: 	nil
	Receiver's instance variables: 
		project: 	BaselineOfPagerDuty(baseline [BaselineOfPagerDuty], )
		loader: 	nil
		mutable: 	nil
		description: 	'github://ba-st/Willow-Bootstrap:v8/source'
		username: 	''
		password: 	''
		type: 	'github'


[ aSpec createRepository ] in [ :aSpec | 
| description repo |
description := aSpec description.
(repo := repositories
	detect: [ :rep | rep description = description ]
	ifNone: [ aSpec createRepository ]) ~~ nil
	ifTrue: [ repos add: repo ] ] in MetacelloEnsureFetchingMCSpecLoader(MetacelloCommonMCSpecLoader)>>repositoriesFrom:ignoreOverrides:
	Receiver: a MetacelloEnsureFetchingMCSpecLoader(linear load : )
	Arguments and temporary variables: 
		aMetacelloMVRepositorySpecs: 	an Array(spec repository: 'github://ba-st/Willow-B...etc...
		ignoreOverrides: 	false
		repositories: 	an Array(a MCCacheRepository(/builds/macta/WillowPagerDuty/build/...etc...
		repos: 	an OrderedCollection()
		aSpec: 	spec repository: 'github://ba-st/Willow-Bootstrap:v8/source'
		description: 	'github://ba-st/Willow-Bootstrap:v8/source'
		repo: 	nil
	Receiver's instance variables: 
		spec: 	a MetacelloMCVersionSpecLoader
		operator: 	nil
		loaderPolicy: 	a MetacelloLoaderPolicy
		disablePackageCache: 	false


Array(Collection)>>detect:ifFound:ifNone:
	Receiver: an Array(a MCCacheRepository(/builds/macta/WillowPagerDuty/build/pharo-local/package-cache...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :rep | rep description = description ]
		foundBlock: 	[ :element | element ]
		exceptionBlock: 	[ aSpec createRepository ]
	Receiver's instance variables: 
an Array(a MCCacheRepository(/builds/macta/WillowPagerDuty/build/pharo-local/package-cache...etc...

Array(Collection)>>detect:ifNone:
	Receiver: an Array(a MCCacheRepository(/builds/macta/WillowPagerDuty/build/pharo-local/package-cache...etc...
	Arguments and temporary variables: 
		aBlock: 	[ :rep | rep description = description ]
		exceptionBlock: 	[ aSpec createRepository ]
	Receiver's instance variables: 
an Array(a MCCacheRepository(/builds/macta/WillowPagerDuty/build/pharo-local/package-cache...etc...

[ :aSpec | 
| description repo |
description := aSpec description.
(repo := repositories
	detect: [ :rep | rep description = description ]
	ifNone: [ aSpec createRepository ]) ~~ nil
	ifTrue: [ repos add: repo ] ] in MetacelloEnsureFetchingMCSpecLoader(MetacelloCommonMCSpecLoader)>>repositoriesFrom:ignoreOverrides:
	Receiver: a MetacelloEnsureFetchingMCSpecLoader(linear load : )
	Arguments and temporary variables: 
		aMetacelloMVRepositorySpecs: 	an Array(spec repository: 'github://ba-st/Willow-B...etc...
		ignoreOverrides: 	false
		repositories: 	an Array(a MCCacheRepository(/builds/macta/WillowPagerDuty/build/...etc...
		repos: 	an OrderedCollection()
		aSpec: 	spec repository: 'github://ba-st/Willow-Bootstrap:v8/source'
		description: 	'github://ba-st/Willow-Bootstrap:v8/source'
		repo: 	nil
	Receiver's instance variables: 
		spec: 	a MetacelloMCVersionSpecLoader
		operator: 	nil
		loaderPolicy: 	a MetacelloLoaderPolicy
		disablePackageCache: 	false


Array(SequenceableCollection)>>do:
	Receiver: an Array(spec repository: 'github://ba-st/Willow-Bootstrap:v8/source')
	Arguments and temporary variables: 
		aBlock: 	[ :aSpec | 
| description repo |
description := aSpec description.
(rep...etc...
		index: 	1
	Receiver's instance variables: 
an Array(spec repository: 'github://ba-st/Willow-Bootstrap:v8/source')

MetacelloEnsureFetchingMCSpecLoader(MetacelloCommonMCSpecLoader)>>repositoriesFrom:ignoreOverrides:
	Receiver: a MetacelloEnsureFetchingMCSpecLoader(linear load : )
	Arguments and temporary variables: 
		aMetacelloMVRepositorySpecs: 	an Array(spec repository: 'github://ba-st/Willow-B...etc...
		ignoreOverrides: 	false
		repositories: 	an Array(a MCCacheRepository(/builds/macta/WillowPagerDuty/build/...etc...
		repos: 	an OrderedCollection()
	Receiver's instance variables: 
		spec: 	a MetacelloMCVersionSpecLoader
		operator: 	nil
		loaderPolicy: 	a MetacelloLoaderPolicy
		disablePackageCache: 	false


MetacelloEnsureFetchingMCSpecLoader(MetacelloCommonMCSpecLoader)>>repositoriesFrom:
	Receiver: a MetacelloEnsureFetchingMCSpecLoader(linear load : )
	Arguments and temporary variables: 
		aMetacelloMVRepositorySpecs: 	an Array(spec repository: 'github://ba-st/Willow-B...etc...
	Receiver's instance variables: 
		spec: 	a MetacelloMCVersionSpecLoader
		operator: 	nil
		loaderPolicy: 	a MetacelloLoaderPolicy
		disablePackageCache: 	false


MetacelloPackageSpec>>explicitLoadUsing:
	Receiver: spec 
	name: 'BaselineOfWillowBootstrap';
	repository: 'github://ba-st/Willow-Bootstrap:v8...etc...
	Arguments and temporary variables: 
		mcLoader: 	a MetacelloEnsureFetchingMCSpecLoader(linear load : )
		wc: 	nil
		fetchingSpecLoader: 	a MetacelloEnsureFetchingMCSpecLoader(linear load : )
	Receiver's instance variables: 
		project: 	BaselineOfPagerDuty(baseline [BaselineOfPagerDuty], )
		loader: 	nil
		mutable: 	nil
		name: 	'BaselineOfWillowBootstrap'
		requires: 	#()
		includes: 	#()
		answers: 	#()
		file: 	nil
		repositories: 	spec
repository: 'github://ba-st/Willow-Bootstrap:v8/source'
		goferPackage: 	a MetacelloGoferPackage name: 'BaselineOfWillowBootstrap'
		preLoadDoIt: 	nil
		postLoadDoIt: 	nil


MetacelloPackageSpec>>ensureLoadUsing:
	Receiver: spec 
	name: 'BaselineOfWillowBootstrap';
	repository: 'github://ba-st/Willow-Bootstrap:v8...etc...
	Arguments and temporary variables: 
		mcLoader: 	a MetacelloFetchingMCSpecLoader(linear load : )
	Receiver's instance variables: 
		project: 	BaselineOfPagerDuty(baseline [BaselineOfPagerDuty], )
		loader: 	nil
		mutable: 	nil
		name: 	'BaselineOfWillowBootstrap'
		requires: 	#()
		includes: 	#()
		answers: 	#()
		file: 	nil
		repositories: 	spec
repository: 'github://ba-st/Willow-Bootstrap:v8/source'
		goferPackage: 	a MetacelloGoferPackage name: 'BaselineOfWillowBootstrap'
		preLoadDoIt: 	nil
		postLoadDoIt: 	nil


MetacelloMCBaselineOfProjectSpec(MetacelloMCProjectSpec)>>ensureLoadUsing:
	Receiver: spec 
	name: 'WillowBootstrap';
	loads: #('Deployment' );
	repository: 'github://ba-st/Wil...etc...
	Arguments and temporary variables: 
		aLoader: 	a MetacelloFetchingMCSpecLoader(linear load : )
		pp: 	spec 
	name: 'BaselineOfWillowBootstrap';
	repository: 'github://ba-st/Will...etc...
	Receiver's instance variables: 
		project: 	BaselineOfPagerDuty(baseline [BaselineOfPagerDuty], )
		loader: 	nil
		mutable: 	nil
		name: 	'WillowBootstrap'
		className: 	'BaselineOfWillowBootstrap'
		versionString: 	nil
		operator: 	nil
		loads: 	#('Deployment')
		preLoadDoIt: 	nil
		postLoadDoIt: 	nil
		projectPackage: 	spec 
	name: 'BaselineOfWillowBootstrap';
	repository: 'github:...etc...
		repositories: 	spec
repository: 'github://ba-st/Willow-Bootstrap:v8/source'
		file: 	nil


[ super ensureLoadUsing: aLoader ] in MetacelloMCBaselineOfProjectSpec>>ensureLoadUsing:
	Receiver: spec 
	name: 'WillowBootstrap';
	loads: #('Deployment' );
	repository: 'github://ba-st/Wil...etc...
	Arguments and temporary variables: 
		aLoader: 	a MetacelloFetchingMCSpecLoader(linear load : )
	Receiver's instance variables: 
		project: 	BaselineOfPagerDuty(baseline [BaselineOfPagerDuty], )
		loader: 	nil
		mutable: 	nil
		name: 	'WillowBootstrap'
		className: 	'BaselineOfWillowBootstrap'
		versionString: 	nil
		operator: 	nil
		loads: 	#('Deployment')
		preLoadDoIt: 	nil
		postLoadDoIt: 	nil
		projectPackage: 	spec 
	name: 'BaselineOfWillowBootstrap';
	repository: 'github:...etc...
		repositories: 	spec
repository: 'github://ba-st/Willow-Bootstrap:v8/source'
		file: 	nil


BlockClosure>>on:do:
	Receiver: [ super ensureLoadUsing: aLoader ]
	Arguments and temporary variables: 
		exception: 	MetacelloIgnorePackageLoaded
		handlerAction: 	[ :ex | ex resume: ex packageSpec name = self name ]
	Receiver's instance variables: 
		outerContext: 	MetacelloMCBaselineOfProjectSpec>>ensureLoadUsing:
		startpc: 	78
		numArgs: 	0


MetacelloMCBaselineOfProjectSpec>>ensureLoadUsing:
	Receiver: spec 
	name: 'WillowBootstrap';
	loads: #('Deployment' );
	repository: 'github://ba-st/Wil...etc...
	Arguments and temporary variables: 
		aLoader: 	a MetacelloFetchingMCSpecLoader(linear load : )
	Receiver's instance variables: 
		project: 	BaselineOfPagerDuty(baseline [BaselineOfPagerDuty], )
		loader: 	nil
		mutable: 	nil
		name: 	'WillowBootstrap'
		className: 	'BaselineOfWillowBootstrap'
		versionString: 	nil
		operator: 	nil
		loads: 	#('Deployment')
		preLoadDoIt: 	nil
		postLoadDoIt: 	nil
		projectPackage: 	spec 
	name: 'BaselineOfWillowBootstrap';
	repository: 'github:...etc...
		repositories: 	spec
repository: 'github://ba-st/Willow-Bootstrap:v8/source'
		file: 	nil



--- The full stack ---
LGitReturnCodeEnum>>handleLGitReturnCode
LGitRepository(LGitExternalObject)>>withReturnHandlerDo:
LGitRepository>>clone:options:to:
LGitRepository>>clone:options:
[ repo clone: url options: cloneOptions ] in [ | repo cloneOptions |
repo := LGitRepository on: self location.
cloneOptions := LGitCloneOptions
	withCredentialsProvider: IceCredentialsProvider default.
cloneOptions checkoutOptions
	checkoutStrategy: LGitCheckoutStrategyEnum git_checkout_none.
[ repo clone: url options: cloneOptions ]
	on: LGit_GIT_ERROR
	do: [ :e | e acceptError: IceLibgitErrorVisitor new ].
repo
	checkout:
		(aBranchName
			ifNil:
				[ self branch ifNotNil: [ :b | b name ] ifNil: [ 'master' ] ]).
(LGitRemote of: repo named: 'origin')
	lookup;
	setUrl: url ] in IceLibgitLocalRepository>>cloneRepositoryFrom:branch:
BlockClosure>>on:do:
[ | repo cloneOptions |
repo := LGitRepository on: self location.
cloneOptions := LGitCloneOptions
	withCredentialsProvider: IceCredentialsProvider default.
cloneOptions checkoutOptions
	checkoutStrategy: LGitCheckoutStrategyEnum git_checkout_none.
[ repo clone: url options: cloneOptions ]
	on: LGit_GIT_ERROR
	do: [ :e | e acceptError: IceLibgitErrorVisitor new ].
repo
	checkout:
		(aBranchName
			ifNil:
				[ self branch ifNotNil: [ :b | b name ] ifNil: [ 'master' ] ]).
(LGitRemote of: repo named: 'origin')
	lookup;
	setUrl: url ] in IceLibgitLocalRepository>>cloneRepositoryFrom:branch:
[ self checkInitialized.
aBlock value ] in LGitGlobal class>>runSequence:
[ activeProcess psValueAt: index put: anObject.
aBlock value ] in LGitActionSequence(DynamicVariable)>>value:during:
BlockClosure>>ensure:
LGitActionSequence(DynamicVariable)>>value:during:
LGitActionSequence class(DynamicVariable class)>>value:during:
LGitGlobal class>>runSequence:
IceLibgitLocalRepository>>cloneRepositoryFrom:branch:
IceRepositoryCreator>>createRepository
[ (IceRepositoryCreator new
	url: urlToUse;
	subdirectory: repoPath;
	branchName: self projectVersion;
	createRepository) register ] in [ | urlToUse |
urlToUse := remote url.
[ (IceRepositoryCreator new
	url: urlToUse;
	subdirectory: repoPath;
	branchName: self projectVersion;
	createRepository) register ]
	on: IceAuthenticationError
	do: [ :e | 
		self
			crLog:
				('I got an error while cloning: {1}. I will try to clone the HTTPS variant.'
					format: {e messageText}).
		urlToUse := remote httpsUrl.
		e retry ] ] in MCGitHubRepository(MCGitBasedNetworkRepository)>>getOrCreateIcebergRepository
BlockClosure>>on:do:
[ | urlToUse |
urlToUse := remote url.
[ (IceRepositoryCreator new
	url: urlToUse;
	subdirectory: repoPath;
	branchName: self projectVersion;
	createRepository) register ]
	on: IceAuthenticationError
	do: [ :e | 
		self
			crLog:
				('I got an error while cloning: {1}. I will try to clone the HTTPS variant.'
					format: {e messageText}).
		urlToUse := remote httpsUrl.
		e retry ] ] in MCGitHubRepository(MCGitBasedNetworkRepository)>>getOrCreateIcebergRepository
OrderedCollection(Collection)>>detect:ifFound:ifNone:
OrderedCollection(Collection)>>detect:ifNone:
MCGitHubRepository(MCGitBasedNetworkRepository)>>getOrCreateIcebergRepository
IceGithubRepositoryType>>mcRepository
Iceberg class>>mcRepositoryFor:
IceMetacelloPharoPlatform>>createRepository:
MetacelloMCBaselineProject(MetacelloMCProject)>>createRepository:
MetacelloRepositorySpec>>createRepository
[ aSpec createRepository ] in [ :aSpec | 
| description repo |
description := aSpec description.
(repo := repositories
	detect: [ :rep | rep description = description ]
	ifNone: [ aSpec createRepository ]) ~~ nil
	ifTrue: [ repos add: repo ] ] in MetacelloEnsureFetchingMCSpecLoader(MetacelloCommonMCSpecLoader)>>repositoriesFrom:ignoreOverrides:
Array(Collection)>>detect:ifFound:ifNone:
Array(Collection)>>detect:ifNone:
[ :aSpec | 
| description repo |
description := aSpec description.
(repo := repositories
	detect: [ :rep | rep description = description ]
	ifNone: [ aSpec createRepository ]) ~~ nil
	ifTrue: [ repos add: repo ] ] in MetacelloEnsureFetchingMCSpecLoader(MetacelloCommonMCSpecLoader)>>repositoriesFrom:ignoreOverrides:
Array(SequenceableCollection)>>do:
MetacelloEnsureFetchingMCSpecLoader(MetacelloCommonMCSpecLoader)>>repositoriesFrom:ignoreOverrides:
MetacelloEnsureFetchingMCSpecLoader(MetacelloCommonMCSpecLoader)>>repositoriesFrom:
MetacelloPackageSpec>>explicitLoadUsing:
MetacelloPackageSpec>>ensureLoadUsing:
MetacelloMCBaselineOfProjectSpec(MetacelloMCProjectSpec)>>ensureLoadUsing:
[ super ensureLoadUsing: aLoader ] in MetacelloMCBaselineOfProjectSpec>>ensureLoadUsing:
BlockClosure>>on:do:
MetacelloMCBaselineOfProjectSpec>>ensureLoadUsing:
 - - - - - - - - - - - - - - -  
			- - - - - - - - - - - - - - - - - -
MetacelloMCBaselineOfProjectSpec(MetacelloMCProjectSpec)>>ensureLoadedForDevelopmentUsing:
[ :pkg | 
pkg ensureLoadedForDevelopmentUsing: mcLoader.
(MetacelloIgnorePackageLoaded signal: pkg)
	ifFalse: [ mcLoader ignoreImage
			ifFalse: [ (pkg
					compareCurrentVersion: self operator
					targetVersionStatus: #(#allLoadedToSpec)
					using: mcLoader)
					ifTrue: [ packages removeKey: pkg name ] ] ] ] in MetacelloMCVersionSpecLoader>>load
Array(SequenceableCollection)>>do:
MetacelloMCVersionSpecLoader>>load
MetacelloMCVersion>>executeLoadFromArray:
[ :dict | ^ self executeLoadFromArray: anArray ] in [ self versionSpec loader: newLoader.
MetacelloPlatform current
	useStackCacheDuring: [ :dict | ^ self executeLoadFromArray: anArray ]
	defaultDictionary: Dictionary new ] in [ [ self versionSpec loader: newLoader.
MetacelloPlatform current
	useStackCacheDuring: [ :dict | ^ self executeLoadFromArray: anArray ]
	defaultDictionary: Dictionary new ]
	ensure: [ self versionSpec loader: originalLoader ] ] in MetacelloMCVersion>>fetchRequiredFromArray:
[ ^ aBlock value: dict ] in IceMetacelloPharoPlatform(MetacelloPlatform)>>useStackCacheDuring:defaultDictionary:
BlockClosure>>on:do:
IceMetacelloPharoPlatform(MetacelloPlatform)>>useStackCacheDuring:defaultDictionary:
[ self versionSpec loader: newLoader.
MetacelloPlatform current
	useStackCacheDuring: [ :dict | ^ self executeLoadFromArray: anArray ]
	defaultDictionary: Dictionary new ] in [ [ self versionSpec loader: newLoader.
MetacelloPlatform current
	useStackCacheDuring: [ :dict | ^ self executeLoadFromArray: anArray ]
	defaultDictionary: Dictionary new ]
	ensure: [ self versionSpec loader: originalLoader ] ] in MetacelloMCVersion>>fetchRequiredFromArray:
BlockClosure>>ensure:
[ [ self versionSpec loader: newLoader.
MetacelloPlatform current
	useStackCacheDuring: [ :dict | ^ self executeLoadFromArray: anArray ]
	defaultDictionary: Dictionary new ]
	ensure: [ self versionSpec loader: originalLoader ] ] in MetacelloMCVersion>>fetchRequiredFromArray:
[ :bar | 
bar value: 1.
aBlock value.
bar value: 2 ] in IceMetacelloPharoPlatform(MetacelloPharoCommonPlatform)>>do:displaying:
BlockClosure>>cull:
[ ^ block cull: self ] in [ self prepareForRunning.
CurrentJob value: self during: [ ^ block cull: self ] ] in Job>>run
[ activeProcess psValueAt: index put: anObject.
aBlock value ] in CurrentJob(DynamicVariable)>>value:during:
BlockClosure>>ensure:
CurrentJob(DynamicVariable)>>value:during:
CurrentJob class(DynamicVariable class)>>value:during:
[ self prepareForRunning.
CurrentJob value: self during: [ ^ block cull: self ] ] in Job>>run
BlockClosure>>ensure:
Job>>run
NonInteractiveUIManager(UIManager)>>displayProgress:from:to:during:
ByteString(String)>>displayProgressFrom:to:during:
IceMetacelloPharoPlatform(MetacelloPharoCommonPlatform)>>do:displaying:
MetacelloMCVersion>>fetchRequiredFromArray:
[ | fetchLoader |
fetchLoader := self
	fetchRequiredFromArray: (self defaultPackageNamesToLoad: anArray).
MetacelloPlatform current
	do: [ fetchLoader doLoad ]
	displaying: 'Loading ' , displayString.
Transcript
	cr;
	show: '...finished ' , self versionNumber printString.
^ fetchLoader ] in MetacelloMCVersion>>doLoadRequiredFromArray:
BlockClosure>>ensure:
MetacelloMCVersion>>doLoadRequiredFromArray:
MetacelloMCVersion>>load
[ | version loadedSpec |
self setDefaultsAndValidateProjectSpec.
[ loadedSpec := (self lookupProjectSpecFor: self projectSpec) copy ]
	on: MetacelloAllowProjectDowngrade , MetacelloAllowProjectUpgrade
	do:
		[ :ex | ex handleOnDownGrade: onDownGradeBlock onUpgrade: onUpgradeBlock ].
version := loadedSpec versionForScriptEngine: self.
self
	root:
		(required isEmpty
			ifTrue: [ version load ]
			ifFalse: [ version load: required ]) loadDirective.
loadedSpec loads: required.
MetacelloProjectRegistration
	registrationForProjectSpec: loadedSpec
	ifAbsent: [ :new | 
		new
			loadedInImage: true;
			registerProject ]
	ifPresent: [ :existing :new | 
		existing
			copyOnWrite: [ :existingCopy | 
				existingCopy
					loadedInImage: true;
					merge: new ] ] ] in [ self
	handleNotificationsForAction: [ | version loadedSpec |
		self setDefaultsAndValidateProjectSpec.
		[ loadedSpec := (self lookupProjectSpecFor: self projectSpec) copy ]
			on: MetacelloAllowProjectDowngrade , MetacelloAllowProjectUpgrade
			do:
				[ :ex | ex handleOnDownGrade: onDownGradeBlock onUpgrade: onUpgradeBlock ].
		version := loadedSpec versionForScriptEngine: self.
		self
			root:
				(required isEmpty
					ifTrue: [ version load ]
					ifFalse: [ version load: required ]) loadDirective.
		loadedSpec loads: required.
		MetacelloProjectRegistration
			registrationForProjectSpec: loadedSpec
			ifAbsent: [ :new | 
				new
					loadedInImage: true;
					registerProject ]
			ifPresent: [ :existing :new | 
				existing
					copyOnWrite: [ :existingCopy | 
						existingCopy
							loadedInImage: true;
							merge: new ] ] ] ] in MetacelloScriptEngine>>load:onProjectDownGrade:onProjectUpgrade:
BlockClosure>>on:do:
[ actionBlock
	on:
		MetacelloLookupProjectSpec , MetacelloLookupProjectSpecForLoad
			, MetacelloProjectSpecLoadedNotification
			, MetacelloScriptEnsureProjectLoadedForDevelopment
			, MetacelloLookupBaselineSpecForEnsureLoad
	do:
		[ :ex | "lookup and registration handlers need to be innermost set of handlers ...they may throw option notifications" ex handleResolutionFor: self ] ] in [ [ actionBlock
	on:
		MetacelloLookupProjectSpec , MetacelloLookupProjectSpecForLoad
			, MetacelloProjectSpecLoadedNotification
			, MetacelloScriptEnsureProjectLoadedForDevelopment
			, MetacelloLookupBaselineSpecForEnsureLoad
	do:
		[ :ex | "lookup and registration handlers need to be innermost set of handlers ...they may throw option notifications" ex handleResolutionFor: self ] ]
	on:
		MetacelloAllowProjectDowngrade , MetacelloAllowProjectUpgrade
			, MetacelloAllowConflictingProjectUpgrade
	do:
		[ :ex | "option handlers need to be outermost set of handlers ... last line of defense before users are involved" ex handleResolutionFor: self ] ] in [ [ [ actionBlock
	on:
		MetacelloLookupProjectSpec , MetacelloLookupProjectSpecForLoad
			, MetacelloProjectSpecLoadedNotification
			, MetacelloScriptEnsureProjectLoadedForDevelopment
			, MetacelloLookupBaselineSpecForEnsureLoad
	do:
		[ :ex | "lookup and registration handlers need to be innermost set of handlers ...they may throw option notifications" ex handleResolutionFor: self ] ]
	on:
		MetacelloAllowProjectDowngrade , MetacelloAllowProjectUpgrade
			, MetacelloAllowConflictingProjectUpgrade
	do:
		[ :ex | "option handlers need to be outermost set of handlers ... last line of defense before users are involved" ex handleResolutionFor: self ] ]
	on: MetacelloAllowLockedProjectChange
	do:
		[ :ex | "MetacelloAllowLockedProjectChange need to be outermost handler ... since it is signaled from second line of handlers" ex handleResolutionFor: self ] ] in MetacelloScriptEngine>>handleNotificationsForAction:
BlockClosure>>on:do:
[ [ actionBlock
	on:
		MetacelloLookupProjectSpec , MetacelloLookupProjectSpecForLoad
			, MetacelloProjectSpecLoadedNotification
			, MetacelloScriptEnsureProjectLoadedForDevelopment
			, MetacelloLookupBaselineSpecForEnsureLoad
	do:
		[ :ex | "lookup and registration handlers need to be innermost set of handlers ...they may throw option notifications" ex handleResolutionFor: self ] ]
	on:
		MetacelloAllowProjectDowngrade , MetacelloAllowProjectUpgrade
			, MetacelloAllowConflictingProjectUpgrade
	do:
		[ :ex | "option handlers need to be outermost set of handlers ... last line of defense before users are involved" ex handleResolutionFor: self ] ] in [ [ [ actionBlock
	on:
		MetacelloLookupProjectSpec , MetacelloLookupProjectSpecForLoad
			, MetacelloProjectSpecLoadedNotification
			, MetacelloScriptEnsureProjectLoadedForDevelopment
			, MetacelloLookupBaselineSpecForEnsureLoad
	do:
		[ :ex | "lookup and registration handlers need to be innermost set of handlers ...they may throw option notifications" ex handleResolutionFor: self ] ]
	on:
		MetacelloAllowProjectDowngrade , MetacelloAllowProjectUpgrade
			, MetacelloAllowConflictingProjectUpgrade
	do:
		[ :ex | "option handlers need to be outermost set of handlers ... last line of defense before users are involved" ex handleResolutionFor: self ] ]
	on: MetacelloAllowLockedProjectChange
	do:
		[ :ex | "MetacelloAllowLockedProjectChange need to be outermost handler ... since it is signaled from second line of handlers" ex handleResolutionFor: self ] ] in MetacelloScriptEngine>>handleNotificationsForAction:
BlockClosure>>on:do:
[ [ [ actionBlock
	on:
		MetacelloLookupProjectSpec , MetacelloLookupProjectSpecForLoad
			, MetacelloProjectSpecLoadedNotification
			, MetacelloScriptEnsureProjectLoadedForDevelopment
			, MetacelloLookupBaselineSpecForEnsureLoad
	do:
		[ :ex | "lookup and registration handlers need to be innermost set of handlers ...they may throw option notifications" ex handleResolutionFor: self ] ]
	on:
		MetacelloAllowProjectDowngrade , MetacelloAllowProjectUpgrade
			, MetacelloAllowConflictingProjectUpgrade
	do:
		[ :ex | "option handlers need to be outermost set of handlers ... last line of defense before users are involved" ex handleResolutionFor: self ] ]
	on: MetacelloAllowLockedProjectChange
	do:
		[ :ex | "MetacelloAllowLockedProjectChange need to be outermost handler ... since it is signaled from second line of handlers" ex handleResolutionFor: self ] ] in MetacelloScriptEngine>>handleNotificationsForAction:
BlockClosure>>on:do:
MetacelloScriptEngine>>handleNotificationsForAction:
[ self
	handleNotificationsForAction: [ | version loadedSpec |
		self setDefaultsAndValidateProjectSpec.
		[ loadedSpec := (self lookupProjectSpecFor: self projectSpec) copy ]
			on: MetacelloAllowProjectDowngrade , MetacelloAllowProjectUpgrade
			do:
				[ :ex | ex handleOnDownGrade: onDownGradeBlock onUpgrade: onUpgradeBlock ].
		version := loadedSpec versionForScriptEngine: self.
		self
			root:
				(required isEmpty
					ifTrue: [ version load ]
					ifFalse: [ version load: required ]) loadDirective.
		loadedSpec loads: required.
		MetacelloProjectRegistration
			registrationForProjectSpec: loadedSpec
			ifAbsent: [ :new | 
				new
					loadedInImage: true;
					registerProject ]
			ifPresent: [ :existing :new | 
				existing
					copyOnWrite: [ :existingCopy | 
						existingCopy
							loadedInImage: true;
							merge: new ] ] ] ] in MetacelloScriptEngine>>load:onProjectDownGrade:onProjectUpgrade:
BlockClosure>>ensure:
MetacelloProjectRegistration class>>copyRegistryRestoreOnErrorWhile:
MetacelloScriptEngine>>load:onProjectDownGrade:onProjectUpgrade:
MetacelloScriptEngine>>load:
[ :projectSpec | 
| engine |
engine := MetacelloScriptEngine new
	options: self options copy;
	projectSpec: projectSpec;
	yourself.
engine perform: actionArg key withArguments: actionArg value.
engine root ifNotNil: [ :root | self roots add: root ] ] in MetacelloScriptApiExecutor(MetacelloScriptExecutor)>>execute:
[ :projectSpec | 
projectSpec
	ifNotNil: [ projectSpecBlock
			value: (self applyArgsToProjectSpec: projectSpec copy) ] ] in MetacelloScriptApiExecutor>>executeString:do:
Array(SequenceableCollection)>>do:
MetacelloScriptApiExecutor>>executeString:do:
ByteString(String)>>execute:against:
MetacelloScriptApiExecutor(MetacelloScriptExecutor)>>execute:
Metacello>>execute:args:
Metacello>>load
UndefinedObject>>DoIt
OpalCompiler>>evaluate
DoItChunk>>importFor:
[ :declaration | 
requestor ifNotNil: [ requestor contents: declaration contents ].
value := declaration importFor: requestor ] in CodeImporter>>evaluate
OrderedCollection>>do:
CodeImporter>>evaluate
[ codeImporter evaluate ] in STCommandLineHandler>>installSourceFile:
BlockClosure>>on:do:
STCommandLineHandler>>handleErrorsDuring:reference:
STCommandLineHandler>>installSourceFile:
[ :reference | self installSourceFile: reference ] in [ sourceFiles do: [ :reference | self installSourceFile: reference ] ] in STCommandLineHandler>>installSourceFiles
OrderedCollection>>do:
[ sourceFiles do: [ :reference | self installSourceFile: reference ] ] in STCommandLineHandler>>installSourceFiles
BlockClosure>>ensure:
STCommandLineHandler>>installSourceFiles
STCommandLineHandler>>activate
STCommandLineHandler class(CommandLineHandler class)>>activateWith:
[ aCommandLinehandler activateWith: commandLine ] in PharoCommandLineHandler(BasicCommandLineHandler)>>activateSubCommand:
BlockClosure>>on:do:
PharoCommandLineHandler(BasicCommandLineHandler)>>activateSubCommand:
PharoCommandLineHandler(BasicCommandLineHandler)>>handleSubcommand
PharoCommandLineHandler(BasicCommandLineHandler)>>handleArgument:
[ self
	handleArgument:
		(self arguments
			ifEmpty: [ '' ]
			ifNotEmpty: [ :arguments | arguments first ]) ] in PharoCommandLineHandler(BasicCommandLineHandler)>>activate
BlockClosure>>on:do:
PharoCommandLineHandler(BasicCommandLineHandler)>>activate
PharoCommandLineHandler>>activate
PharoCommandLineHandler class(CommandLineHandler class)>>activateWith:
[ super activateWith: aCommandLine ] in PharoCommandLineHandler class>>activateWith:
NonInteractiveUIManager(UIManager)>>defer:
PharoCommandLineHandler class>>activateWith:
[ aCommandLinehandler activateWith: commandLine ] in BasicCommandLineHandler>>activateSubCommand:
BlockClosure>>on:do:
BasicCommandLineHandler>>activateSubCommand:
BasicCommandLineHandler>>handleSubcommand
BasicCommandLineHandler>>handleArgument:
[ self
	handleArgument:
		(self arguments
			ifEmpty: [ '' ]
			ifNotEmpty: [ :arguments | arguments first ]) ] in BasicCommandLineHandler>>activate
BlockClosure>>on:do:
BasicCommandLineHandler>>activate
[ self new activate ] in BasicCommandLineHandler class>>startUp:
BlockClosure>>cull:
WorkingSession>>executeDeferredStartupActions:
WorkingSession>>runStartup:
WorkingSession>>start:
SessionManager>>snapshot:andQuit:
[ ^ SessionManager default snapshot: save andQuit: quit ] in SmalltalkImage>>snapshot:andQuit:
CurrentExecutionEnvironment class>>activate:for:
DefaultExecutionEnvironment(ExecutionEnvironment)>>beActiveDuring:
DefaultExecutionEnvironment class>>beActiveDuring:
SmalltalkImage>>snapshot:andQuit:
ImageCleanerCommandLineHandler>>activate
ImageCleanerCommandLineHandler class(CommandLineHandler class)>>activateWith:
[ aCommandLinehandler activateWith: commandLine ] in PharoCommandLineHandler(BasicCommandLineHandler)>>activateSubCommand:
BlockClosure>>on:do:
PharoCommandLineHandler(BasicCommandLineHandler)>>activateSubCommand:
PharoCommandLineHandler(BasicCommandLineHandler)>>handleSubcommand
PharoCommandLineHandler(BasicCommandLineHandler)>>handleArgument:
[ self
	handleArgument:
		(self arguments
			ifEmpty: [ '' ]
			ifNotEmpty: [ :arguments | arguments first ]) ] in PharoCommandLineHandler(BasicCommandLineHandler)>>activate
BlockClosure>>on:do:
PharoCommandLineHandler(BasicCommandLineHandler)>>activate
PharoCommandLineHandler>>activate
PharoCommandLineHandler class(CommandLineHandler class)>>activateWith:
[ super activateWith: aCommandLine ] in PharoCommandLineHandler class>>activateWith:
NonInteractiveUIManager(UIManager)>>defer:
PharoCommandLineHandler class>>activateWith:
[ aCommandLinehandler activateWith: commandLine ] in BasicCommandLineHandler>>activateSubCommand:
BlockClosure>>on:do:
BasicCommandLineHandler>>activateSubCommand:
BasicCommandLineHandler>>handleSubcommand
BasicCommandLineHandler>>handleArgument:
[ self
	handleArgument:
		(self arguments
			ifEmpty: [ '' ]
			ifNotEmpty: [ :arguments | arguments first ]) ] in BasicCommandLineHandler>>activate
BlockClosure>>on:do:
BasicCommandLineHandler>>activate
[ self new activate ] in BasicCommandLineHandler class>>startUp:
BlockClosure>>cull:
WorkingSession>>executeDeferredStartupActions:
WorkingSession>>runStartup:
WorkingSession>>start:
SessionManager>>snapshot:andQuit:
[ ^ SessionManager default snapshot: save andQuit: quit ] in SmalltalkImage>>snapshot:andQuit:
CurrentExecutionEnvironment class>>activate:for:
DefaultExecutionEnvironment(ExecutionEnvironment)>>beActiveDuring:
DefaultExecutionEnvironment class>>beActiveDuring:
SmalltalkImage>>snapshot:andQuit:
LoadUpdatesCommandLineHandler>>activate
LoadUpdatesCommandLineHandler class(CommandLineHandler class)>>activateWith:
[ aCommandLinehandler activateWith: commandLine ] in PharoCommandLineHandler(BasicCommandLineHandler)>>activateSubCommand:
BlockClosure>>on:do:
PharoCommandLineHandler(BasicCommandLineHandler)>>activateSubCommand:
PharoCommandLineHandler(BasicCommandLineHandler)>>handleSubcommand
PharoCommandLineHandler(BasicCommandLineHandler)>>handleArgument:
[ self
	handleArgument:
		(self arguments
			ifEmpty: [ '' ]
			ifNotEmpty: [ :arguments | arguments first ]) ] in PharoCommandLineHandler(BasicCommandLineHandler)>>activate
BlockClosure>>on:do:
PharoCommandLineHandler(BasicCommandLineHandler)>>activate
PharoCommandLineHandler>>activate
PharoCommandLineHandler class(CommandLineHandler class)>>activateWith:
[ super activateWith: aCommandLine ] in PharoCommandLineHandler class>>activateWith:
NonInteractiveUIManager(UIManager)>>defer:
PharoCommandLineHandler class>>activateWith:
[ aCommandLinehandler activateWith: commandLine ] in BasicCommandLineHandler>>activateSubCommand:
BlockClosure>>on:do:
BasicCommandLineHandler>>activateSubCommand:
BasicCommandLineHandler>>handleSubcommand
BasicCommandLineHandler>>handleArgument:
[ self
	handleArgument:
		(self arguments
			ifEmpty: [ '' ]
			ifNotEmpty: [ :arguments | arguments first ]) ] in BasicCommandLineHandler>>activate
BlockClosure>>on:do:
BasicCommandLineHandler>>activate
[ self new activate ] in BasicCommandLineHandler class>>startUp:
BlockClosure>>cull:
WorkingSession>>executeDeferredStartupActions:
WorkingSession>>runStartup:
-- and more not shown ---------------------------------------------------------------------------------

Processes and their stacks: 
Process: a Process in nil
  stack:

Array(SequenceableCollection)>>do:
[ :logger | 
logger
	nextPutAll: 'Processes and their stacks: ';
	cr.
Process allInstances
	do: [ :each | 
		| ctx |
		logger
			nextPutAll: 'Process: ';
			print: each;
			cr;
			nextPutAll: '  stack:';
			cr;
			cr.
		ctx := each isActiveProcess
			ifTrue: [ thisContext sender ]
			ifFalse: [ each suspendedContext ].
		ctx
			ifNotNil: [ (ctx stackOfSize: 20)
					do: [ :s | 
						logger
							print: s;
							cr ] ].
		logger
			nextPutAll: '------------------------------';
			cr;
			cr ] ] in [ Smalltalk logError: aString inContext: aContext.

" Print stacks of all current processes "
Smalltalk
	logDuring: [ :logger | 
		logger
			nextPutAll: 'Processes and their stacks: ';
			cr.
		Process allInstances
			do: [ :each | 
				| ctx |
				logger
					nextPutAll: 'Process: ';
					print: each;
					cr;
					nextPutAll: '  stack:';
					cr;
					cr.
				ctx := each isActiveProcess
					ifTrue: [ thisContext sender ]
					ifFalse: [ each suspendedContext ].
				ctx
					ifNotNil: [ (ctx stackOfSize: 20)
							do: [ :s | 
								logger
									print: s;
									cr ] ].
				logger
					nextPutAll: '------------------------------';
					cr;
					cr ] ] ] in NonInteractiveUIManager(CommandLineUIManager)>>quitFrom:withMessage:
[ logStream := self openLog.
aMonadicBlock value: logStream ] in SmalltalkImage>>logDuring:
BlockClosure>>ensure:
SmalltalkImage>>logDuring:
[ Smalltalk logError: aString inContext: aContext.

" Print stacks of all current processes "
Smalltalk
	logDuring: [ :logger | 
		logger
			nextPutAll: 'Processes and their stacks: ';
			cr.
		Process allInstances
			do: [ :each | 
				| ctx |
				logger
					nextPutAll: 'Process: ';
					print: each;
					cr;
					nextPutAll: '  stack:';
					cr;
					cr.
				ctx := each isActiveProcess
					ifTrue: [ thisContext sender ]
					ifFalse: [ each suspendedContext ].
				ctx
					ifNotNil: [ (ctx stackOfSize: 20)
							do: [ :s | 
								logger
									print: s;
									cr ] ].
				logger
					nextPutAll: '------------------------------';
					cr;
					cr ] ] ] in NonInteractiveUIManager(CommandLineUIManager)>>quitFrom:withMessage:
BlockClosure>>ensure:
NonInteractiveUIManager(CommandLineUIManager)>>quitFrom:withMessage:
NonInteractiveUIManager(CommandLineUIManager)>>unhandledErrorDefaultAction:
UnhandledError>>defaultAction
UndefinedObject>>handleSignal:
UnhandledError(Exception)>>signal
UnhandledError class>>signalForException:
LGit_GIT_ERROR(Error)>>defaultAction
UndefinedObject>>handleSignal:
LGit_GIT_ERROR(Exception)>>pass
[ :ex | 
ActiveWorld := priorWorld.
ActiveEvent := priorEvent.
ActiveHand := priorHand.
ex pass ] in WorldMorph(PasteUpMorph)>>becomeActiveDuring:
BlockClosure>>cull:
Context>>evaluateSignal:
Context>>handleSignal:
------------------------------

Process: a Process in [ self value.
Processor terminateActive ] in BlockClosure>>newProcess
  stack:

[ self value.
Processor terminateActive ] in BlockClosure>>newProcess
------------------------------

Process: a Process in [ self value.
Processor terminateActive ] in BlockClosure>>newProcess
  stack:

[ self value.
Processor terminateActive ] in BlockClosure>>newProcess
------------------------------

Process: a Process in [ self value.
Processor terminateActive ] in BlockClosure>>newProcess
  stack:

[ self value.
Processor terminateActive ] in BlockClosure>>newProcess
------------------------------

Process: a Process in DelaySpinScheduler(DelayMicrosecondScheduler)>>runTimerEventLoop
  stack:

DelaySpinScheduler(DelayMicrosecondScheduler)>>runTimerEventLoop
[ self runTimerEventLoop ] in DelaySpinScheduler(DelayMicrosecondScheduler)>>startTimerEventLoop
[ self value.
Processor terminateActive ] in BlockClosure>>newProcess
------------------------------

Process: a Process in SmalltalkImage>>lowSpaceWatcher
  stack:

SmalltalkImage>>lowSpaceWatcher
[ self lowSpaceWatcher ] in SmalltalkImage>>installLowSpaceWatcher
[ self value.
Processor terminateActive ] in BlockClosure>>newProcess
------------------------------

Process: a Process in [ self value.
Processor terminateActive ] in BlockClosure>>newProcess
  stack:

[ self value.
Processor terminateActive ] in BlockClosure>>newProcess
------------------------------

Process: a Process in InputEventFetcher>>waitForInput
  stack:

InputEventFetcher>>waitForInput
InputEventFetcher>>eventLoop
[ self eventLoop ] in InputEventFetcher>>installEventLoop
[ self value.
Processor terminateActive ] in BlockClosure>>newProcess
------------------------------

Process: a Process in WeakArray class>>finalizationProcess
  stack:

WeakArray class>>finalizationProcess
[ self finalizationProcess ] in WeakArray class>>restartFinalizationProcess
[ self value.
Processor terminateActive ] in BlockClosure>>newProcess
------------------------------

Process: a Process in Process>>terminate
  stack:

Process>>terminate
------------------------------