# fileIn("s8/library/scripting/Scripting.st")
smalltalk.addClass("ScriptingObject",smalltalk.Object,nil,"Scripting")

smalltalk.addClass("ParseContext",smalltalk.ScriptingObject,["map","parent"],"Scripting")

smalltalk.addClass("ParseNode",smalltalk.ScriptingObject,["sourceRange"],"Scripting")

smalltalk.addClass("AssignNode",smalltalk.ParseNode,["variable","expression"],"Scripting")

smalltalk.addClass("MessageNode",smalltalk.ParseNode,["receiver","selector","args","action"],"Scripting")

smalltalk.addClass("NativeMessageNode",smalltalk.MessageNode,nil,"Scripting")

smalltalk.addClass("ParseStatements",smalltalk.ParseNode,["temporaries","statements"],"Scripting")

smalltalk.addClass("BlockClosureNode",smalltalk.ParseStatements,["args"],"Scripting")

smalltalk.addClass("CascadedMessageNode",smalltalk.ParseStatements,["receiver"],"Scripting")

smalltalk.addClass("Script",smalltalk.ParseStatements,nil,"Scripting")

smalltalk.addClass("StepOverScript",smalltalk.Script,["action"],"Scripting")

smalltalk.addClass("ParseVariable",smalltalk.ParseNode,["binding","indices"],"Scripting")

smalltalk.addClass("ParseArgument",smalltalk.ParseVariable,["canBeAssigned"],"Scripting")

smalltalk.addClass("ParseGlobalVariable",smalltalk.ParseVariable,nil,"Scripting")

smalltalk.addClass("ParseGlobalConstant",smalltalk.ParseGlobalVariable,nil,"Scripting")

smalltalk.addClass("ParseSpecial",smalltalk.ParseVariable,nil,"Scripting")

smalltalk.addClass("ParseLiteral",smalltalk.ParseSpecial,nil,"Scripting")

smalltalk.addClass("ParseInstanceVariable",smalltalk.ParseSpecial,["name","index"],"Scripting")

smalltalk.addClass("ParseUniversal",smalltalk.ParseSpecial,nil,"Scripting")

smalltalk.addClass("ParseSelf",smalltalk.ParseUniversal,nil,"Scripting")

smalltalk.addClass("ParseSuper",smalltalk.ParseSelf,["implementor"],"Scripting")

smalltalk.addClass("ParseNoReceiver",smalltalk.ParseSpecial,nil,"Scripting")

smalltalk.addClass("ParseNativeVariable",smalltalk.ParseSpecial,nil,"Scripting")

smalltalk.addClass("MethodExitNode",smalltalk.ParseNode,["exitBlock"],"Scripting")

smalltalk.addClass("MethodReturnNode",smalltalk.MethodExitNode,["expression"],"Scripting")

smalltalk.addClass("PrimitiveNode",smalltalk.MethodExitNode,["action"],"Scripting")

smalltalk.addClass("ScriptParser",smalltalk.ScriptingObject,["currentClass","source","scope","instanceVariables","errorBlock"],"Scripting")

smalltalk.setVarNames(smalltalk.ScriptParser.__class__,smalltalk.newArray(["primitiveHandlers","defaultPrimitiveHandler"]))

smalltalk.addClass("ScriptingError",smalltalk.ScriptingObject,["description"],"Scripting")

smalltalk.addClass("ParseError",smalltalk.ScriptingError,["source","position"],"Scripting")

smalltalk.addClass("SyntaxError",smalltalk.ParseError,nil,"Scripting")

smalltalk.bind(smalltalk.ParseContext.__class__,"default",0
,smalltalk.__f__("""(self):
	#ParseContext class>>#default
	def __blk1__(_s8_rec):
		_s8_rec.beDefault() 
		return _s8_rec.yourself() 
	return __blk1__(self.new()) 
""","ParseContext_class_default")
,"defaults","""default
	" Returns an instance of the receiver set to the default scope. "

	^self new
		beDefault;
		yourself """,nil)

smalltalk.bind(smalltalk.ParseContext.__class__,"in:",0
,smalltalk.__f__("""(self,aParentScope):
	#ParseContext class>>#in:
	def __blk1__(_s8_rec):
		_s8_rec.parent_(aParentScope) 
		return _s8_rec.yourself() 
	return __blk1__(self.new()) 
""","ParseContext_class_in_")
,"instantiation","""in: aParentScope
	" Returns the a new scope included in aParentScope. "

	^self new
		parent: aParentScope;
		yourself """,nil)

smalltalk.bind(smalltalk.ParseContext,"at:put:",0
,smalltalk.__f__("""(self,aKey,anObject):
	#ParseContext>>#at:put:
	return self.map().at_put_(aKey,anObject) 
""","ParseContext_at_put_")
,"accessing","""at: aKey put: anObject
	"Creates a new variable binding for aKey in the receiver's local context (the map). "

	^self map at: aKey put: anObject""",nil)

smalltalk.bind(smalltalk.ParseContext,"map",0
,smalltalk.__f__("""(self):
	#ParseContext>>#map
	if smalltalk.b(smalltalk.isNil_(getattr(self,"@map",nil))):
		self.initializeMap() 
	 
	return getattr(self,"@map",nil) 
""","ParseContext_map")
,"accessing","""map
	" Private - Returns the receiver's map. "

	map isNil ifTrue: [ self initializeMap ].
	^map """,nil)

smalltalk.bind(smalltalk.ParseContext,"parent:",0
,smalltalk.__f__("""(self,aScope):
	#ParseContext>>#parent:
	smalltalk.basic_at_put(self,"@parent",aScope) 
	return self 
""","ParseContext_parent_")
,"accessing","""parent: aScope
	" Private - Sets the receiver's parent scope. "

	parent := aScope """,nil)

smalltalk.bind(smalltalk.ParseContext,"bindingAt:",0
,smalltalk.__f__("""(self,aName):
	#ParseContext>>#bindingAt:
	def __blk1__():
		return self.error_(smalltalk.String("Absent element.")) 
	return self.bindingAt_ifAbsent_(aName,smalltalk.blk(__blk1__,0)) 
""","ParseContext_bindingAt_")
,"binding","""bindingAt: aName
	" LookUp for variable named aName in the receiver.
	Returns the binding found for aName or produces an error if failed. "

	^self bindingAt: aName ifAbsent: [ self error: 'Absent element.' ] """,nil)

smalltalk.bind(smalltalk.ParseContext,"bindingAt:ifAbsent:",0
,smalltalk.__f__("""(self,aName,errorBlock):
	_s8Ret_=smalltalk.newContext()
	try:
		#ParseContext>>#bindingAt:ifAbsent:
		__0__=smalltalk.newContext()
		def __blk1__():
			nil 
		def __blk2__():
			return getattr(self,"@parent",nil).bindingAt_ifAbsent_(aName,errorBlock) 
		def __blk3__():
			return errorBlock.value() 
		__0__.assoc=nil
		__0__.key=nil
		if smalltalk.b(smalltalk.isObject_equalTo_(aName.size(),smalltalk.Number(0))):
			return nil 
		 
		__0__.assoc=self.bindingIn_at_ifAbsent_(self.map(),aName,smalltalk.blk(__blk1__,0)) 
		if smalltalk.b(smalltalk.notNil_(__0__.assoc)):
			return __0__.assoc.local() 
		 
		if smalltalk.b(smalltalk.is_kindOf_(getattr(self,"@parent",nil),(smalltalk.KeyedCollection))):
			def __blk4__():
				nil 
			def __blk5__():
				return smalltalk.raise_result_(_s8Ret_,__0__.assoc) 
			__0__.assoc=self.bindingIn_at_ifAbsent_(getattr(self,"@parent",nil),aName,smalltalk.blk(__blk4__,0)) 
			smalltalk.if_true_false_(smalltalk.notNil_(__0__.assoc),smalltalk.blk(__blk5__,0),nil) 
		 
		smalltalk.raise_result_(_s8Ret_,smalltalk.if_true_false_(smalltalk.notNil_(getattr(self,"@parent",nil)),smalltalk.blk(__blk2__,0),smalltalk.blk(__blk3__,0))) 
	except Exception as __ex:
		if smalltalk.exception_at(__ex,_s8Ret_):
			return smalltalk.exceptionResult_(__ex)
		raise __ex
	
""","ParseContext_bindingAt_ifAbsent_")
,"binding","""bindingAt: aName ifAbsent: errorBlock
	" LookUp for variable named aName in the receiver.
	Returns the binding found for aName or evaluates errorBlock if failed. "

	| assoc key |
	aName size = 0 ifTrue: [ ^nil ].

	assoc := self bindingIn: self map at: aName ifAbsent: [].
	assoc notNil ifTrue: [ ^assoc local ].

	(parent isKindOf: KeyedCollection) ifTrue: [
		assoc := self bindingIn: parent at: aName ifAbsent: [].
		assoc notNil ifTrue: [ ^assoc ].
	].

	^parent notNil
	ifTrue: [ parent bindingAt: aName ifAbsent: errorBlock ]
	ifFalse: [ errorBlock value ] """,nil)

smalltalk.bind(smalltalk.ParseContext,"bindingIn:at:ifAbsent:",0
,smalltalk.__f__("""(self,aDictionary,aName,errorBlock):
	#ParseContext>>#bindingIn:at:ifAbsent:
	__0__=smalltalk.newContext()
	def __blk1__():
		def __blk2__(one):
			return smalltalk.isObject_equalTo_(smalltalk.asString_(one),aName) 
		def __blk3__():
			nil 
		def __blk4__():
			def __blk5__():
				nil 
			return aDictionary.bindingAt_ifAbsent_(__0__.key,smalltalk.blk(__blk5__,0)) 
		__0__.key=aDictionary.keys().detect_ifNone_(smalltalk.blk(__blk2__,1),smalltalk.blk(__blk3__,0)) 
		return smalltalk.if_true_false_(smalltalk.notNil_(__0__.key),smalltalk.blk(__blk4__,0),nil) 
	__0__.assoc=nil
	__0__.key=nil
	return aDictionary.bindingAt_ifAbsent_(aName,smalltalk.blk(__blk1__,0)) 
""","ParseContext_bindingIn_at_ifAbsent_")
,"binding","""bindingIn: aDictionary at: aName ifAbsent: errorBlock
	" Private - LookUp for variable named aName in the dictionary aDictionary. "

	| assoc key |
	^aDictionary bindingAt: aName ifAbsent: [
		key := aDictionary keys detect: [:one| one asString = aName ] ifNone: [].
		key notNil ifTrue: [ aDictionary bindingAt: key ifAbsent: [] ]
	] """,nil)

smalltalk.bind(smalltalk.ParseContext,"initializeMap",0
,smalltalk.__f__("""(self):
	#ParseContext>>#initializeMap
	smalltalk.basic_at_put(self,"@map",smalltalk.PoolDictionary.new()) 
	return self 
""","ParseContext_initializeMap")
,"initialize","""initializeMap
	" Private - Initializes the receiver's map. "

	map := PoolDictionary new """,nil)

smalltalk.bind(smalltalk.ParseContext,"beDefault",0
,smalltalk.__f__("""(self):
	#ParseContext>>#beDefault
	smalltalk.basic_at_put(self,"@parent",self.smalltalk()) 
	return self 
""","ParseContext_beDefault")
,"private","""beDefault
	" Private - Set the receiver as child of default context. "

	parent := self smalltalk """,nil)

smalltalk.bind(smalltalk.ParseNode.__class__,"sourceRange:",0
,smalltalk.__f__("""(self,interval):
	#ParseNode class>>#sourceRange:
	return self.new().sourceRange_(interval) 
""","ParseNode_class_sourceRange_")
,"instantiation","""sourceRange: interval
	" Returns an instance of the receiver. "

	^self new sourceRange: interval """,nil)

smalltalk.bind(smalltalk.ParseNode.__class__,"from:to:",0
,smalltalk.__f__("""(self,start,stop):
	#ParseNode class>>#from:to:
	return self.sourceRange_(start.to_(stop)) 
""","ParseNode_class_from_to_")
,"instantiation","""from: start to: stop
	" Returns an instance of the receiver. "

	^self sourceRange: (start to: stop) """,nil)

smalltalk.bind(smalltalk.ParseNode,"sourcePosition:",0
,smalltalk.__f__("""(self,anInterval):
	#ParseNode>>#sourcePosition:
	return self.sourceRange_(anInterval) 
""","ParseNode_sourcePosition_")
,"accessing","""sourcePosition: anInterval
	" Set the receiver's sourceRange. "

	^self sourceRange: anInterval """,nil)

smalltalk.bind(smalltalk.ParseNode,"sourceRange",0
,smalltalk.__f__("""(self):
	#ParseNode>>#sourceRange
	return getattr(self,"@sourceRange",nil) 
""","ParseNode_sourceRange")
,"accessing","""sourceRange
	" Returns the receiver's sourceRange. "

	^sourceRange""",nil)

smalltalk.bind(smalltalk.ParseNode,"sourceRange:",0
,smalltalk.__f__("""(self,anInterval):
	#ParseNode>>#sourceRange:
	smalltalk.basic_at_put(self,"@sourceRange",anInterval) 
	return self 
""","ParseNode_sourceRange_")
,"accessing","""sourceRange: anInterval
	" Set the receiver's sourceRange. "

	sourceRange := anInterval """,nil)

smalltalk.bind(smalltalk.ParseNode,",","_comma"
,smalltalk.__f__("""(self,aParseNode):
	#ParseNode>>#,
	return smalltalk.ParseStatements.with_with_(self,aParseNode) 
""","ParseNode__comma")
,"composing",""", aParseNode
	" Returns a composite parse node with the receiver and aParseNode appended at end. "

	^ParseStatements
		with: self
		with: aParseNode """,nil)

smalltalk.bind(smalltalk.ParseNode,"evaluate",0
,smalltalk.__f__("""(self):
	#ParseNode>>#evaluate
	return self.evaluate_(nil) 
""","ParseNode_evaluate")
,"evaluating","""evaluate
	" Evaluate the receiver in an empty context. "

	^self evaluate: nil """,nil)

smalltalk.bind(smalltalk.ParseNode,"evaluate:",0
,smalltalk.__f__("""(self,aReceiver):
	#ParseNode>>#evaluate:
	return self.evaluateIn_(smalltalk.S8Context.for_(aReceiver)) 
""","ParseNode_evaluate_")
,"evaluating","""evaluate: aReceiver
	" Returns the result of evaluating the receiver in a context bound to aReceiver. "

	^self evaluateIn: (S8Context for: aReceiver) """,nil)

smalltalk.bind(smalltalk.ParseNode,"evaluateIn:",0
,smalltalk.__f__("""(self,aContext):
	#ParseNode>>#evaluateIn:
	return self.subclassResponsibility_(smalltalk.String("evaluateIn:")) 
""","ParseNode_evaluateIn_")
,"evaluating","""evaluateIn: aContext
	" Returns the result of evaluating the receiver in aContext.
	This message must be implemented by the subclasses. "

	^self subclassResponsibility: #evaluateIn: """,nil)

smalltalk.bind(smalltalk.ParseNode,"exitBlock:",0
,smalltalk.__f__("""(self,aBlock):
	#ParseNode>>#exitBlock:
	return self 
""","ParseNode_exitBlock_")
,"evaluating","""exitBlock: aBlock
	" Set the exit block of the receiver.
	This block will be used to abort execution of the receiver.
	Do nothing by default.
	This method can be refined by subclasses. " """,nil)

smalltalk.bind(smalltalk.ParseNode,"clear:",0
,smalltalk.__f__("""(self,aContext):
	#ParseNode>>#clear:
	return self.subclassResponsibility() 
""","ParseNode_clear_")
,"private","""clear: aContext
	" Private - Clear the receiver's cached state.
	This method must be implemented by subclasses. "

	^self subclassResponsibility """,nil)

smalltalk.bind(smalltalk.ParseNode,"isComposite",0
,smalltalk.__f__("""(self):
	#ParseNode>>#isComposite
	return smalltalk.false 
""","ParseNode_isComposite")
,"query","""isComposite
	" Returns true if the receiver is a composite parse node. "

	^false """,nil)

smalltalk.bind(smalltalk.ParseNode,"isReturn",0
,smalltalk.__f__("""(self):
	#ParseNode>>#isReturn
	return smalltalk.false 
""","ParseNode_isReturn")
,"query","""isReturn
	" Returns true if the receiver is a return parse node. "

	^false """,nil)

smalltalk.bind(smalltalk.ParseNode,"isSuper",0
,smalltalk.__f__("""(self):
	#ParseNode>>#isSuper
	return smalltalk.false 
""","ParseNode_isSuper")
,"query","""isSuper
	" Returns true if the receiver is a reference to super. "

	^false """,nil)

smalltalk.bind(smalltalk.ParseNode,"isOO",0
,smalltalk.__f__("""(self):
	#ParseNode>>#isOO
	return smalltalk.true 
""","ParseNode_isOO")
,"query","""isOO
	" Returns true if the receiver refers to an object. "

	^true """,nil)

smalltalk.bind(smalltalk.ParseNode,"isMessageNode",0
,smalltalk.__f__("""(self):
	#ParseNode>>#isMessageNode
	return smalltalk.false 
""","ParseNode_isMessageNode")
,"query","""isMessageNode
	" Returns true if the receiver is a message send. "

	^false """,nil)

smalltalk.bind(smalltalk.ParseNode,"isPrimitiveNode",0
,smalltalk.__f__("""(self):
	#ParseNode>>#isPrimitiveNode
	return smalltalk.false 
""","ParseNode_isPrimitiveNode")
,"query","""isPrimitiveNode
	" Returns true if the receiver is a primitive. "

	^false """,nil)

smalltalk.bind(smalltalk.ParseNode,"isVariable",0
,smalltalk.__f__("""(self):
	#ParseNode>>#isVariable
	return smalltalk.false 
""","ParseNode_isVariable")
,"query","""isVariable
	" Returns true if the receiver is a variable parse node. "

	^false """,nil)

smalltalk.bind(smalltalk.AssignNode,"expression",0
,smalltalk.__f__("""(self):
	#AssignNode>>#expression
	return getattr(self,"@expression",nil) 
""","AssignNode_expression")
,"accessing","""expression
	" Returns the receiver's expression. "

	^expression """,nil)

smalltalk.bind(smalltalk.AssignNode,"expression:",0
,smalltalk.__f__("""(self,anExpression):
	#AssignNode>>#expression:
	smalltalk.basic_at_put(self,"@expression",anExpression) 
	return self 
""","AssignNode_expression_")
,"accessing","""expression: anExpression
	" Set the receiver's expression. "

	expression := anExpression""",nil)

smalltalk.bind(smalltalk.AssignNode,"variable",0
,smalltalk.__f__("""(self):
	#AssignNode>>#variable
	return getattr(self,"@variable",nil) 
""","AssignNode_variable")
,"accessing","""variable
	" Returns the receiver's variable. "

	^variable """,nil)

smalltalk.bind(smalltalk.AssignNode,"variable:",0
,smalltalk.__f__("""(self,aVariable):
	#AssignNode>>#variable:
	smalltalk.basic_at_put(self,"@variable",aVariable) 
	return self 
""","AssignNode_variable_")
,"accessing","""variable: aVariable
	" Set the receiver's variable. "

	variable := aVariable """,nil)

smalltalk.bind(smalltalk.AssignNode,"exitBlock:",0
,smalltalk.__f__("""(self,aBlock):
	#AssignNode>>#exitBlock:
	smalltalk.superReceiver(smalltalk.AssignNode,self).exitBlock_(aBlock) 
	self.variable().exitBlock_(aBlock) 
	self.expression().exitBlock_(aBlock) 
	return self 
""","AssignNode_exitBlock_")
,"evaluating","""exitBlock: aBlock
	" Set the exit block of the receiver. "

	super exitBlock: aBlock.
	self variable exitBlock: aBlock.
	self expression exitBlock: aBlock """,nil)

smalltalk.bind(smalltalk.AssignNode,"evaluateIn:",0
,smalltalk.__f__("""(self,aContext):
	#AssignNode>>#evaluateIn:
	return self.variable().bind_in_(self.expression().evaluateIn_(aContext),aContext) 
""","AssignNode_evaluateIn_")
,"evaluating","""evaluateIn: aContext
	" Returns the result of evaluating the receiver in aContext. "

	^self variable bind: (self expression evaluateIn: aContext) in: aContext """,nil)

smalltalk.bind(smalltalk.MessageNode.__class__,"actionToSend:ifAbsent:",0
,smalltalk.__f__("""(self,selector,aBlock):
	#MessageNode class>>#actionToSend:ifAbsent:
	return smalltalk.S8Block.optimizations().at_ifAbsent_(selector,aBlock) 
""","MessageNode_class_actionToSend_ifAbsent_")
,"actions","""actionToSend: selector ifAbsent: aBlock
	" Private - Returns the block to evaluate for sending message selector. "

	^S8Block optimizations at: selector ifAbsent: aBlock """,nil)

smalltalk.bind(smalltalk.MessageNode.__class__,"native:from:to:",0
,smalltalk.__f__("""(self,isNative,start,stop):
	#MessageNode class>>#native:from:to:
	def __blk1__():
		return smalltalk.NativeMessageNode 
	def __blk2__():
		return smalltalk.MessageNode 
	return smalltalk.if_true_false_(isNative,smalltalk.blk(__blk1__,0),smalltalk.blk(__blk2__,0)).from_to_(start,stop) 
""","MessageNode_class_native_from_to_")
,"instantiation","""native: isNative from: start to: stop
	" Returns an instance of the receiver. "

	^(isNative
		ifTrue: [ NativeMessageNode ]
		ifFalse: [ MessageNode ])
		from: start to: stop """,nil)

smalltalk.bind(smalltalk.MessageNode.__class__,"receiver:selector:arguments:",0
,smalltalk.__f__("""(self,receiver,selector,args):
	#MessageNode class>>#receiver:selector:arguments:
	return self.new().receiver_selector_arguments_(receiver,selector,args) 
""","MessageNode_class_receiver_selector_arguments_")
,"instantiation","""receiver: receiver selector: selector arguments: args
	" Returns a new instance of the receiver. "

	^self new receiver: receiver selector: selector arguments: args """,nil)

smalltalk.bind(smalltalk.MessageNode,"receiver:selector:arguments:",0
,smalltalk.__f__("""(self,aParseNode,aSelector,aCollection):
	#MessageNode>>#receiver:selector:arguments:
	def __blk1__(_s8_rec):
		_s8_rec.receiver_(aParseNode) 
		_s8_rec.selector_(aSelector) 
		return _s8_rec.arguments_(aCollection) 
	__blk1__(self) 
	return self 
""","MessageNode_receiver_selector_arguments_")
,"accessing","""receiver: aParseNode selector: aSelector arguments: aCollection
	" Set the receiver contents. "

	self	receiver: aParseNode;
		selector: aSelector;
		arguments: aCollection """,nil)

smalltalk.bind(smalltalk.MessageNode,"args",0
,smalltalk.__f__("""(self):
	#MessageNode>>#args
	return getattr(self,"@args",nil) 
""","MessageNode_args")
,"accessing","""args
	^args """,nil)

smalltalk.bind(smalltalk.MessageNode,"args:",0
,smalltalk.__f__("""(self,aCollection):
	#MessageNode>>#args:
	smalltalk.basic_at_put(self,"@args",aCollection) 
	return self 
""","MessageNode_args_")
,"accessing","""args: aCollection
	args := aCollection """,nil)

smalltalk.bind(smalltalk.MessageNode,"arguments",0
,smalltalk.__f__("""(self):
	#MessageNode>>#arguments
	return self.args() 
""","MessageNode_arguments")
,"accessing","""arguments
	^self args """,nil)

smalltalk.bind(smalltalk.MessageNode,"arguments:",0
,smalltalk.__f__("""(self,aCollection):
	#MessageNode>>#arguments:
	self.args_(aCollection) 
	return self 
""","MessageNode_arguments_")
,"accessing","""arguments: aCollection
	self args: aCollection""",nil)

smalltalk.bind(smalltalk.MessageNode,"receiver",0
,smalltalk.__f__("""(self):
	#MessageNode>>#receiver
	return getattr(self,"@receiver",nil) 
""","MessageNode_receiver")
,"accessing","""receiver
	^receiver""",nil)

smalltalk.bind(smalltalk.MessageNode,"receiver:",0
,smalltalk.__f__("""(self,aParseNode):
	#MessageNode>>#receiver:
	smalltalk.basic_at_put(self,"@receiver",aParseNode) 
	return self 
""","MessageNode_receiver_")
,"accessing","""receiver: aParseNode
	receiver := aParseNode """,nil)

smalltalk.bind(smalltalk.MessageNode,"selector",0
,smalltalk.__f__("""(self):
	#MessageNode>>#selector
	return getattr(self,"@selector",nil) 
""","MessageNode_selector")
,"accessing","""selector
	^selector""",nil)

smalltalk.bind(smalltalk.MessageNode,"selector:",0
,smalltalk.__f__("""(self,aSymbol):
	#MessageNode>>#selector:
	smalltalk.basic_at_put(self,"@selector",aSymbol) 
	return self 
""","MessageNode_selector_")
,"accessing","""selector: aSymbol
	selector := aSymbol """,nil)

smalltalk.bind(smalltalk.MessageNode,"isMessageNode",0
,smalltalk.__f__("""(self):
	#MessageNode>>#isMessageNode
	return smalltalk.true 
""","MessageNode_isMessageNode")
,"query","""isMessageNode
	" Returns true if the receiver is a message send. "

	^true """,nil)

smalltalk.bind(smalltalk.MessageNode,"evaluateIn:",0
,smalltalk.__f__("""(self,aContext):
	#MessageNode>>#evaluateIn:
	__0__=smalltalk.newContext()
	__0__.value=nil
	__0__.value=self.receiver().evaluateIn_(aContext) 
	return self.evaluate_value_in_(self.receiver(),__0__.value,aContext) 
""","MessageNode_evaluateIn_")
,"evaluating","""evaluateIn: aContext
	" Returns the result of evaluating the receiver in aContext. "

	| value |
	value := self receiver evaluateIn: aContext.
	^self evaluate: self receiver value: value in: aContext """,nil)

smalltalk.bind(smalltalk.MessageNode,"actionToSend:",0
,smalltalk.__f__("""(self,aSymbol):
	#MessageNode>>#actionToSend:
	def __blk1__():
		def __blk2__(receiver,msg,values,context):
			return receiver.perform_withArguments_(msg,values) 
		return smalltalk.blk(__blk2__,4) 
	return (self).__class__.actionToSend_ifAbsent_(aSymbol,smalltalk.blk(__blk1__,0)) 
""","MessageNode_actionToSend_")
,"actions","""actionToSend: aSymbol
	" Private - Returns the block to evaluate for sending message aSymbol. "

	^self class actionToSend: aSymbol ifAbsent: [
		[:receiver :msg :values :context|
			receiver perform: msg withArguments: values
		]
	] """,nil)

smalltalk.bind(smalltalk.MessageNode,"valuesToSend:to:withArguments:in:",0
,smalltalk.__f__("""(self,msg,anObject,values,aContext):
	#MessageNode>>#valuesToSend:to:withArguments:in:
	return values 
""","MessageNode_valuesToSend_to_withArguments_in_")
,"sending","""valuesToSend: msg to: anObject withArguments: values in: aContext
	" Private - Returns the arguments to send msg to anObject. "

	^values """,nil)

smalltalk.bind(smalltalk.MessageNode,"send:to:withArguments:in:",0
,smalltalk.__f__("""(self,msg,anObject,values,aContext):
	#MessageNode>>#send:to:withArguments:in:
	if smalltalk.b(smalltalk.isNil_(getattr(self,"@action",nil))):
		smalltalk.basic_at_put(self,"@action",self.actionToSend_(msg)) 
	 
	return getattr(self,"@action",nil).value_value_value_value_(anObject,msg,self.valuesToSend_to_withArguments_in_(msg,anObject,values,aContext),aContext) 
""","MessageNode_send_to_withArguments_in_")
,"sending","""send: msg to: anObject withArguments: values in: aContext
	" Private - Returns the result of sending message to anObject in aContext. "

	action isNil ifTrue: [ action := self actionToSend: msg ].
	^action	value: anObject value: msg
		value: (self
			valuesToSend: msg to: anObject
			withArguments: values in: aContext)
		value: aContext """,nil)

smalltalk.bind(smalltalk.MessageNode,"evaluate:value:in:",0
,smalltalk.__f__("""(self,aReceiver,anObject,aContext):
	#MessageNode>>#evaluate:value:in:
	__0__=smalltalk.newContext()
	def __blk1__(each):
		return each.evaluateIn_(aContext) 
	def __blk2__():
		return smalltalk.booleanNot_(aReceiver.isOO()) 
	__0__.values=nil
	__0__.values=self.args().collect_(smalltalk.blk(__blk1__,1)) 
	if smalltalk.b(smalltalk.boolean_or_(aReceiver.isSuper(),smalltalk.blk(__blk2__,0))):
		return aReceiver.send_to_withArguments_in_(self.selector(),anObject,__0__.values,aContext) 
	 
	return self.send_to_withArguments_in_(self.selector(),anObject,__0__.values,aContext) 
""","MessageNode_evaluate_value_in_")
,"evaluating","""evaluate: aReceiver value: anObject in: aContext
	" Private - Returns the result of sending message to anObject in aContext. "

	| values |
	values := self args collect: [:each| each evaluateIn: aContext ].
	(aReceiver isSuper or: [ aReceiver isOO not ]) ifTrue: [
		^aReceiver send: self selector to: anObject withArguments: values in: aContext
	].
	^self send: self selector to: anObject withArguments: values in: aContext""",nil)

smalltalk.bind(smalltalk.MessageNode,"exitBlock:",0
,smalltalk.__f__("""(self,aBlock):
	#MessageNode>>#exitBlock:
	def __blk1__(each):
		return each.exitBlock_(aBlock) 
	smalltalk.superReceiver(smalltalk.MessageNode,self).exitBlock_(aBlock) 
	self.receiver().exitBlock_(aBlock) 
	self.args().do_(smalltalk.blk(__blk1__,1)) 
	return self 
""","MessageNode_exitBlock_")
,"evaluating","""exitBlock: aBlock
	" Set the exit block of the receiver. "

	super exitBlock: aBlock.
	self receiver exitBlock: aBlock.
	self args do: [:each| each exitBlock: aBlock ] """,nil)

smalltalk.bind(smalltalk.NativeMessageNode,"selector:",0
,smalltalk.__f__("""(self,aSymbol):
	#NativeMessageNode>>#selector:
	smalltalk.superReceiver(smalltalk.NativeMessageNode,self).selector_(aSymbol.upTo_(smalltalk.String(":"))) 
	return self 
""","NativeMessageNode_selector_")
,"accessing","""selector: aSymbol
	" Set the selector converting aSymbol to native selector. "

	super selector: (aSymbol upTo: $:) """,nil)

smalltalk.bind(smalltalk.NativeMessageNode,"valuesToSend:to:withArguments:in:",0
,smalltalk.__f__("""(self,msg,anObject,values,aContext):
	#NativeMessageNode>>#valuesToSend:to:withArguments:in:
	def __blk1__(each):
		def __blk2__():
			return self.callableOf_(each) 
		def __blk3__():
			return each 
		return smalltalk.if_true_false_(smalltalk.is_kindOf_(each,(smalltalk.SimulationBlock)),smalltalk.blk(__blk2__,0),smalltalk.blk(__blk3__,0)) 
	return values.collect_(smalltalk.blk(__blk1__,1)) 
""","NativeMessageNode_valuesToSend_to_withArguments_in_")
,"sending","""valuesToSend: msg to: anObject withArguments: values in: aContext
	" Private - Returns the arguments to send msg to anObject. "

	^values collect: [:each|
		(each isKindOf: SimulationBlock)
		ifTrue: [ self callableOf: each ]
		ifFalse: [ each ]
	] """,nil)

smalltalk.bind(smalltalk.NativeMessageNode,"send:to:withArguments:in:",0
,smalltalk.__f__("""(self,msg,anObject,values,aContext):
	_s8Ret_=smalltalk.newContext()
	try:
		#NativeMessageNode>>#send:to:withArguments:in:
		__0__=smalltalk.newContext()
		def __blk1__():
			return smalltalk.raise_result_(_s8Ret_,self.error_(smalltalk.object_comma_(smalltalk.String("Missing function "),msg.asLiteral()))) 
		__0__.fn=nil
		__0__.anArray=nil
		__0__.fn=smalltalk.basic_at_ifAbsent_(anObject,msg,smalltalk.blk(__blk1__,0)) 
		__0__.anArray=self.valuesToSend_to_withArguments_in_(msg,anObject,values,aContext) 
		smalltalk.raise_result_(_s8Ret_,__0__.fn(anObject,*smalltalk.objects_toCall_(anArray,__0__.fn))) 
	except Exception as __ex:
		if smalltalk.exception_at(__ex,_s8Ret_):
			return smalltalk.exceptionResult_(__ex)
		raise __ex
	
""","NativeMessageNode_send_to_withArguments_in_")
,"sending","""send: msg to: anObject withArguments: values in: aContext
	" Private - Returns the result of sending message to anObject in aContext. "

	| fn anArray |
	fn := anObject basicAt: msg ifAbsent: [
		^self error: 'Missing function ' ,msg asLiteral
	].
	anArray := self
		valuesToSend: msg to: anObject
		withArguments: values in: aContext.
	^{''
	js'fn.apply(anObject,anArray)'
	lua'fn(anObject,(table.unpack or unpack)(anArray))'
	py'__0__.fn(anObject,*smalltalk.objects_toCall_(anArray,__0__.fn))'}""",nil)

smalltalk.bind(smalltalk.ParseStatements.__class__,"with:",0
,smalltalk.__f__("""(self,aStatement):
	#ParseStatements class>>#with:
	def __blk1__(_s8_rec):
		_s8_rec.add_(aStatement) 
		return _s8_rec.yourself() 
	return __blk1__(self.new()) 
""","ParseStatements_class_with_")
,"instantiation","""with: aStatement
	" Returns an instance of the receiver containing aStatement. "

	^self new
		add: aStatement;
		yourself """,nil)

smalltalk.bind(smalltalk.ParseStatements.__class__,"with:with:",0
,smalltalk.__f__("""(self,statement1,statement2):
	#ParseStatements class>>#with:with:
	def __blk1__(_s8_rec):
		_s8_rec.add_(statement1) 
		_s8_rec.add_(statement2) 
		return _s8_rec.yourself() 
	return __blk1__(self.new()) 
""","ParseStatements_class_with_with_")
,"instantiation","""with: statement1 with: statement2
	" Returns an instance of the receiver containing the statements. "

	^self new
		add: statement1;
		add: statement2;
		yourself """,nil)

smalltalk.bind(smalltalk.ParseStatements.__class__,"with:with:with:",0
,smalltalk.__f__("""(self,statement1,statement2,statement3):
	#ParseStatements class>>#with:with:with:
	def __blk1__(_s8_rec):
		_s8_rec.add_(statement1) 
		_s8_rec.add_(statement2) 
		_s8_rec.add_(statement3) 
		return _s8_rec.yourself() 
	return __blk1__(self.new()) 
""","ParseStatements_class_with_with_with_")
,"instantiation","""with: statement1 with: statement2 with: statement3
	" Returns an instance of the receiver containing the statements. "

	^self new
		add: statement1;
		add: statement2;
		add: statement3;
		yourself """,nil)

smalltalk.bind(smalltalk.ParseStatements.__class__,"with:with:with:with:",0
,smalltalk.__f__("""(self,statement1,statement2,statement3,statement4):
	#ParseStatements class>>#with:with:with:with:
	def __blk1__(_s8_rec):
		_s8_rec.add_(statement1) 
		_s8_rec.add_(statement2) 
		_s8_rec.add_(statement3) 
		_s8_rec.add_(statement4) 
		return _s8_rec.yourself() 
	return __blk1__(self.new()) 
""","ParseStatements_class_with_with_with_with_")
,"instantiation","""with: statement1 with: statement2 with: statement3 with: statement4
	" Returns an instance of the receiver containing the statements. "

	^self new
		add: statement1;
		add: statement2;
		add: statement3;
		add: statement4;
		yourself """,nil)

smalltalk.bind(smalltalk.ParseStatements.__class__,"withAll:",0
,smalltalk.__f__("""(self,aCollection):
	#ParseStatements class>>#withAll:
	def __blk1__(_s8_rec):
		_s8_rec.addAll_(aCollection) 
		return _s8_rec.yourself() 
	return __blk1__(self.new()) 
""","ParseStatements_class_withAll_")
,"instantiation","""withAll: aCollection
	" Returns an instance of the receiver containing all the statements in aCollection. "

	^self new
		addAll: aCollection;
		yourself """,nil)

smalltalk.bind(smalltalk.ParseStatements,"statements",0
,smalltalk.__f__("""(self):
	#ParseStatements>>#statements
	if smalltalk.b(smalltalk.isNil_(getattr(self,"@statements",nil))):
		self.initializeStatements() 
	 
	return getattr(self,"@statements",nil) 
""","ParseStatements_statements")
,"accessing","""statements
	" Returns the receiver's statements. "

	statements isNil ifTrue: [ self initializeStatements ].
	^statements """,nil)

smalltalk.bind(smalltalk.ParseStatements,"temporaries",0
,smalltalk.__f__("""(self):
	#ParseStatements>>#temporaries
	if smalltalk.b(smalltalk.isNil_(getattr(self,"@temporaries",nil))):
		self.initializeTemporaries() 
	 
	return getattr(self,"@temporaries",nil) 
""","ParseStatements_temporaries")
,"accessing","""temporaries
	" Returns the receiver's temporaries. "

	temporaries isNil ifTrue: [ self initializeTemporaries ].
	^temporaries """,nil)

smalltalk.bind(smalltalk.ParseStatements,"temporaries:",0
,smalltalk.__f__("""(self,aCollection):
	#ParseStatements>>#temporaries:
	smalltalk.basic_at_put(self,"@temporaries",aCollection) 
	return self 
""","ParseStatements_temporaries_")
,"accessing","""temporaries: aCollection
	" Set the receiver's temporaries. "

	temporaries := aCollection """,nil)

smalltalk.bind(smalltalk.ParseStatements,"sourceRange",0
,smalltalk.__f__("""(self):
	#ParseStatements>>#sourceRange
	__0__=smalltalk.newContext()
	def __blk1__(each):
		__1__=smalltalk.newContext()
		def __blk2__():
			__0__.start=__0__.start.min_(__1__.range.start()) 
			__0__.end=__0__.end.max_(__1__.range.end())
			return __0__.end 
		__1__.range=nil
		__1__.range=each.sourceRange() 
		return smalltalk.if_true_false_(smalltalk.notNil_(__1__.range),smalltalk.blk(__blk2__,0),nil) 
	__0__.start=nil
	__0__.end=nil
	if smalltalk.b(smalltalk.notNil_(getattr(self,"@sourceRange",nil))):
		return getattr(self,"@sourceRange",nil) 
	 
	if smalltalk.b(smalltalk.isObject_equalTo_(getattr(self,"@statements",nil).size(),smalltalk.Number(0))):
		return nil 
	 
	__0__.start=smalltalk.Number(999) 
	__0__.end=smalltalk.Number(0) 
	getattr(self,"@statements",nil).do_(smalltalk.blk(__blk1__,1)) 
	if smalltalk.b(smalltalk.isObject_equalTo_(__0__.end,smalltalk.Number(0))):
		return nil 
	 
	return __0__.start.to_(__0__.end) 
""","ParseStatements_sourceRange")
,"accessing","""sourceRange
	" Returns the receiver's sourceRange. "

	| start end |
	sourceRange notNil ifTrue: [ ^sourceRange ].
	statements size = 0 ifTrue: [ ^nil ].

	start := 999. end := 0.
	statements do: [:each| | range |
		range := each sourceRange.
		range notNil ifTrue: [
			start := start min: range start.
			end := end max: range end.
		].
	].
	end = 0 ifTrue: [ ^nil ].

	^start to: end """,nil)

smalltalk.bind(smalltalk.ParseStatements,"add:",0
,smalltalk.__f__("""(self,aStatement):
	#ParseStatements>>#add:
	return self.addLast_(aStatement) 
""","ParseStatements_add_")
,"collection","""add: aStatement
	"Add aStatement to the receiver. "

	^self addLast: aStatement """,nil)

smalltalk.bind(smalltalk.ParseStatements,"addAll:",0
,smalltalk.__f__("""(self,aCollection):
	#ParseStatements>>#addAll:
	return self.statements().addAll_(aCollection) 
""","ParseStatements_addAll_")
,"collection","""addAll: aCollection
	"Add aCollection of statements to the receiver. "

	^self statements addAll: aCollection """,nil)

smalltalk.bind(smalltalk.ParseStatements,"addFirst:",0
,smalltalk.__f__("""(self,aStatement):
	#ParseStatements>>#addFirst:
	return self.statements().addFirst_(aStatement) 
""","ParseStatements_addFirst_")
,"collection","""addFirst: aStatement
	"Add aStatement to the receiver. "

	^self statements addFirst: aStatement """,nil)

smalltalk.bind(smalltalk.ParseStatements,"addFirstAll:",0
,smalltalk.__f__("""(self,aCollection):
	#ParseStatements>>#addFirstAll:
	def __blk1__(each):
		return self.statements().addFirst_(each) 
	aCollection.asArray().reverseDo_(smalltalk.blk(__blk1__,1)) 
	return self 
""","ParseStatements_addFirstAll_")
,"collection","""addFirstAll: aCollection
	"Add aCollection of statements to the receiver. "

	aCollection asArray reverseDo: [:each|
		self statements addFirst: each
	] """,nil)

smalltalk.bind(smalltalk.ParseStatements,"addLast:",0
,smalltalk.__f__("""(self,aStatement):
	#ParseStatements>>#addLast:
	return self.statements().addLast_(aStatement) 
""","ParseStatements_addLast_")
,"collection","""addLast: aStatement
	"Add aStatement to the receiver. "

	^self statements addLast: aStatement """,nil)

smalltalk.bind(smalltalk.ParseStatements,"remove:",0
,smalltalk.__f__("""(self,aStatement):
	#ParseStatements>>#remove:
	return self.statements().remove_(aStatement) 
""","ParseStatements_remove_")
,"collection","""remove: aStatement
	"Remove aStatement from the receiver. "

	^self statements remove: aStatement """,nil)

smalltalk.bind(smalltalk.ParseStatements,"removeAll:",0
,smalltalk.__f__("""(self,aCollection):
	#ParseStatements>>#removeAll:
	return self.statements().removeAll_(aCollection) 
""","ParseStatements_removeAll_")
,"collection","""removeAll: aCollection
	"Remove aCollection of statements from the receiver. "

	^self statements removeAll: aCollection """,nil)

smalltalk.bind(smalltalk.ParseStatements,"contextVariables",0
,smalltalk.__f__("""(self):
	#ParseStatements>>#contextVariables
	return self.temporaries() 
""","ParseStatements_contextVariables")
,"activation","""contextVariables
	" Private - Returns the variables involved in activation of the receiver. "

	^self temporaries """,nil)

smalltalk.bind(smalltalk.ParseStatements,"evaluateContentsIn:",0
,smalltalk.__f__("""(self,localContext):
	#ParseStatements>>#evaluateContentsIn:
	def __blk1__(result,each):
		return each.evaluateIn_(localContext) 
	return self.statements().inject_into_(nil,smalltalk.blk(__blk1__,2)) 
""","ParseStatements_evaluateContentsIn_")
,"evaluating","""evaluateContentsIn: localContext
	" Private - Returns the result of evaluating the contents of the receiver in local context. "

	^self statements inject: nil into: [:result :each|
		each evaluateIn: localContext
	]""",nil)

smalltalk.bind(smalltalk.ParseStatements,"evaluateIn:",0
,smalltalk.__f__("""(self,aContext):
	#ParseStatements>>#evaluateIn:
	def __blk1__(ctx):
		return self.evaluateContentsIn_(ctx) 
	return smalltalk.S8Context.in_clear_do_(aContext,self.contextVariables(),smalltalk.blk(__blk1__,1)) 
""","ParseStatements_evaluateIn_")
,"evaluating","""evaluateIn: aContext
	" Returns the result of evaluating the receiver in aContext. "

	^S8Context
		in: aContext clear: self contextVariables
		do: [:ctx| self evaluateContentsIn: ctx ] """,nil)

smalltalk.bind(smalltalk.ParseStatements,"exitBlock:",0
,smalltalk.__f__("""(self,aBlock):
	#ParseStatements>>#exitBlock:
	def __blk1__(each):
		return each.exitBlock_(aBlock) 
	def __blk2__(each):
		return each.exitBlock_(aBlock) 
	smalltalk.superReceiver(smalltalk.ParseStatements,self).exitBlock_(aBlock) 
	self.temporaries().do_(smalltalk.blk(__blk1__,1)) 
	self.statements().do_(smalltalk.blk(__blk2__,1)) 
	return self 
""","ParseStatements_exitBlock_")
,"evaluating","""exitBlock: aBlock
	" Set the exit block of the receiver. "

	super exitBlock: aBlock.
	self temporaries do: [:each| each exitBlock: aBlock ].
	self statements do: [:each| each exitBlock: aBlock ] """,nil)

smalltalk.bind(smalltalk.ParseStatements,"initializeStatements",0
,smalltalk.__f__("""(self):
	#ParseStatements>>#initializeStatements
	smalltalk.basic_at_put(self,"@statements",smalltalk.Array.new()) 
	return self 
""","ParseStatements_initializeStatements")
,"initialize","""initializeStatements
	" Private - Initialize the receiver's statements. "

	statements := Array new """,nil)

smalltalk.bind(smalltalk.ParseStatements,"initializeTemporaries",0
,smalltalk.__f__("""(self):
	#ParseStatements>>#initializeTemporaries
	smalltalk.basic_at_put(self,"@temporaries",smalltalk.Array.new()) 
	return self 
""","ParseStatements_initializeTemporaries")
,"initialize","""initializeTemporaries
	" Private - Initialize the receiver's temporaries. "

	temporaries := Array new """,nil)

smalltalk.bind(smalltalk.ParseStatements,"isComposite",0
,smalltalk.__f__("""(self):
	#ParseStatements>>#isComposite
	return smalltalk.true 
""","ParseStatements_isComposite")
,"query","""isComposite
	" Returns true if the receiver is a composite parse node. "

	^true """,nil)

smalltalk.bind(smalltalk.ParseStatements,"isEmpty",0
,smalltalk.__f__("""(self):
	#ParseStatements>>#isEmpty
	return self.statements().isEmpty() 
""","ParseStatements_isEmpty")
,"query","""isEmpty
	" Returns true if the receiver is empty. "

	^self statements isEmpty """,nil)

smalltalk.bind(smalltalk.BlockClosureNode,"args",0
,smalltalk.__f__("""(self):
	#BlockClosureNode>>#args
	if smalltalk.b(smalltalk.isNil_(getattr(self,"@args",nil))):
		self.initializeArgs() 
	 
	return getattr(self,"@args",nil) 
""","BlockClosureNode_args")
,"accessing","""args
	" Returns the receiver's arguments. "

	args isNil ifTrue: [ self initializeArgs ].
	^args """,nil)

smalltalk.bind(smalltalk.BlockClosureNode,"args:",0
,smalltalk.__f__("""(self,aCollection):
	#BlockClosureNode>>#args:
	smalltalk.basic_at_put(self,"@args",aCollection) 
	return self 
""","BlockClosureNode_args_")
,"accessing","""args: aCollection
	" Set the receiver's arguments. "

	args := aCollection""",nil)

smalltalk.bind(smalltalk.BlockClosureNode,"arguments",0
,smalltalk.__f__("""(self):
	#BlockClosureNode>>#arguments
	return self.args() 
""","BlockClosureNode_arguments")
,"accessing","""arguments
	" Returns the receiver's arguments. "

	^self args """,nil)

smalltalk.bind(smalltalk.BlockClosureNode,"arguments:",0
,smalltalk.__f__("""(self,aCollection):
	#BlockClosureNode>>#arguments:
	self.args_(aCollection) 
	return self 
""","BlockClosureNode_arguments_")
,"accessing","""arguments: aCollection
	" Set the receiver's arguments. "

	self args: aCollection """,nil)

smalltalk.bind(smalltalk.BlockClosureNode,"contextVariables",0
,smalltalk.__f__("""(self):
	#BlockClosureNode>>#contextVariables
	return smalltalk.object_comma_(self.args(),smalltalk.superReceiver(smalltalk.BlockClosureNode,self).contextVariables()) 
""","BlockClosureNode_contextVariables")
,"activation","""contextVariables
	" Private - Returns the variables involved in activation of the receiver. "

	^self args ,super contextVariables """,nil)

smalltalk.bind(smalltalk.BlockClosureNode,"exitBlock:",0
,smalltalk.__f__("""(self,aBlock):
	#BlockClosureNode>>#exitBlock:
	def __blk1__(each):
		return each.exitBlock_(aBlock) 
	smalltalk.superReceiver(smalltalk.BlockClosureNode,self).exitBlock_(aBlock) 
	self.args().do_(smalltalk.blk(__blk1__,1)) 
	return self 
""","BlockClosureNode_exitBlock_")
,"evaluating","""exitBlock: aBlock
	" Set the exit block of the receiver. "

	super exitBlock: aBlock.
	self args do: [:each| each exitBlock: aBlock ] """,nil)

smalltalk.bind(smalltalk.BlockClosureNode,"initializeArgs",0
,smalltalk.__f__("""(self):
	#BlockClosureNode>>#initializeArgs
	smalltalk.basic_at_put(self,"@args",smalltalk.Array.new()) 
	return self 
""","BlockClosureNode_initializeArgs")
,"initialize","""initializeArgs
	" Private - Initializes the receiver's arguments. "

	args := Array new """,nil)

smalltalk.bind(smalltalk.BlockClosureNode,"evaluateContentsIn:",0
,smalltalk.__f__("""(self,localContext):
	#BlockClosureNode>>#evaluateContentsIn:
	return smalltalk.S8Block.for_in_(self,localContext) 
""","BlockClosureNode_evaluateContentsIn_")
,"evaluating","""evaluateContentsIn: localContext
	" Private - Returns the result of evaluating the contents of the receiver in local context.
	Block defer evaluation until message #value:... is sent
	 (re-using a local context for execution) "

	^S8Block for: self in: localContext """,nil)

smalltalk.bind(smalltalk.CascadedMessageNode.__class__,"for:",0
,smalltalk.__f__("""(self,aMessageNode):
	#CascadedMessageNode class>>#for:
	return self.new().initialize_(aMessageNode) 
""","CascadedMessageNode_class_for_")
,"instantiation","""for: aMessageNode
	" Return an instance of the receiver. "

	^self new initialize: aMessageNode """,nil)

smalltalk.bind(smalltalk.CascadedMessageNode,"receiver",0
,smalltalk.__f__("""(self):
	#CascadedMessageNode>>#receiver
	return getattr(self,"@receiver",nil) 
""","CascadedMessageNode_receiver")
,"accessing","""receiver
	" Returns the receiver's receiver. "

	^receiver """,nil)

smalltalk.bind(smalltalk.CascadedMessageNode,"receiver:",0
,smalltalk.__f__("""(self,aReceiver):
	#CascadedMessageNode>>#receiver:
	smalltalk.basic_at_put(self,"@receiver",aReceiver) 
	return self 
""","CascadedMessageNode_receiver_")
,"accessing","""receiver: aReceiver
	" Set the receiver's receiver. "

	receiver := aReceiver """,nil)

smalltalk.bind(smalltalk.CascadedMessageNode,"initialize:",0
,smalltalk.__f__("""(self,expression):
	#CascadedMessageNode>>#initialize:
	self.add_(smalltalk.MessageNode.new().receiver_selector_arguments_(expression.receiver(),expression.selector(),expression.arguments())) 
	return self 
""","CascadedMessageNode_initialize_")
,"initialize","""initialize: expression
	" Private - Initialize the receiver to start execution with expression. "

	self add: (MessageNode new
		receiver: expression receiver
		selector: expression selector
		arguments: expression arguments) """,nil)

smalltalk.bind(smalltalk.CascadedMessageNode,"evaluateContentsIn:",0
,smalltalk.__f__("""(self,localContext):
	#CascadedMessageNode>>#evaluateContentsIn:
	__0__=smalltalk.newContext()
	def __blk1__(each):
		if smalltalk.b(smalltalk.isNil_(__0__.assoc)):
			__0__.rec=each.receiver() 
			__0__.assoc=smalltalk.String("$rec")._minus_gt(__0__.rec.evaluateIn_(localContext)) 
		 
		__0__.result=each.evaluate_value_in_(__0__.rec,__0__.assoc.value(),localContext)
		return __0__.result 
	__0__.result=nil
	__0__.rec=nil
	__0__.assoc=nil
	self.statements().do_(smalltalk.blk(__blk1__,1)) 
	return __0__.result 
""","CascadedMessageNode_evaluateContentsIn_")
,"evaluating","""evaluateContentsIn: localContext
	" Private - Returns the result of evaluating the contents of the receiver in local context. "

	| result rec assoc |
	self statements do: [:each|
		assoc isNil ifTrue: [
			rec := each receiver.
			assoc := '$rec' -> (rec evaluateIn: localContext).
		].
		result := each evaluate: rec value: assoc value in: localContext.
	].
	^result """,nil)

smalltalk.bind(smalltalk.Script,"clearExitBlock",0
,smalltalk.__f__("""(self):
	#Script>>#clearExitBlock
	self.exitBlock_(nil) 
	return self 
""","Script_clearExitBlock")
,"evaluating","""clearExitBlock
	" Clear the exit block. "

	self exitBlock: nil """,nil)

smalltalk.bind(smalltalk.Script,"evaluateIn:",0
,smalltalk.__f__("""(self,aContext):
	_s8Ret_=smalltalk.newContext()
	try:
		#Script>>#evaluateIn:
		def __blk1__(result):
			self.clearExitBlock() 
			return smalltalk.raise_result_(_s8Ret_,result) 
		self.exitBlock_(smalltalk.blk(__blk1__,1)) 
		smalltalk.raise_result_(_s8Ret_,smalltalk.superReceiver(smalltalk.Script,self).evaluateIn_(aContext)) 
	except Exception as __ex:
		if smalltalk.exception_at(__ex,_s8Ret_):
			return smalltalk.exceptionResult_(__ex)
		raise __ex
	
""","Script_evaluateIn_")
,"evaluating","""evaluateIn: aContext
	" Returns the result of evaluating the receiver in aContext. "

	self exitBlock: [:result| self clearExitBlock. ^result ].
	^super evaluateIn: aContext """,nil)

smalltalk.bind(smalltalk.Script,"contextFor:binding:to:",0
,smalltalk.__f__("""(self,aReceiver,args,array):
	#Script>>#contextFor:binding:to:
	__0__=smalltalk.newContext()
	def __blk1__(i):
		return __0__.result.at_put_(args.at_(i).binding().key(),array.at_(i)) 
	__0__.result=nil
	__0__.count=nil
	__0__.result=smalltalk.S8Context.for_(aReceiver) 
	__0__.count=args.size().min_(array.size()) 
	smalltalk.Number(1).to_do_(__0__.count,smalltalk.blk(__blk1__,1)) 
	return __0__.result 
""","Script_contextFor_binding_to_")
,"evaluating","""contextFor: aReceiver binding: args to: array
	" Private - Returns the context to evaluate the receiver on aReceiver with parameters. "

	| result count |
	result := S8Context for: aReceiver.
	count := args size min: array size.
	1 to: count do: [:i| result at: (args at: i) binding key put: (array at: i) ].
	^result """,nil)

smalltalk.bind(smalltalk.Script,"evaluate:binding:to:",0
,smalltalk.__f__("""(self,aReceiver,args,array):
	#Script>>#evaluate:binding:to:
	return self.evaluateIn_(self.contextFor_binding_to_(aReceiver,args,array)) 
""","Script_evaluate_binding_to_")
,"evaluating","""evaluate: aReceiver binding: args to: array
	" Returns the result of evaluating the receiver with activation bindings. "

	^self evaluateIn: (self contextFor: aReceiver binding: args to: array)""",nil)

smalltalk.bind(smalltalk.Script,"nativeImplementationFor:",0
,smalltalk.__f__("""(self,mth):
	#Script>>#nativeImplementationFor:
	__0__=smalltalk.newContext()
	__0__.msg=nil
	__0__.msg=smalltalk.object_comma_(smalltalk.Smalltalk.nativeLanguage(),smalltalk.String("ImplementationFor:args:")) 
	if smalltalk.b(smalltalk.responds_to_(self,(__0__.msg))):
		return self.perform_withArguments_(__0__.msg,smalltalk.Array.with_with_(mth,self.argsIn_(mth))) 
	 
	return self.error_(smalltalk.object_comma_(smalltalk.String("Should not happen "),smalltalk.String("nativeImplementationFor:"))) 
""","Script_nativeImplementationFor_")
,"native","""nativeImplementationFor: mth
	" Return the native implementation to run a compiled script (mth). "

	| msg |
	msg := Smalltalk nativeLanguage ,#ImplementationFor:args:.
	(self respondsTo: msg) ifTrue: [
		^self perform: msg withArguments: (Array with: mth with: (self argsIn: mth))
	].
	^self error: 'Should not happen ' ,#nativeImplementationFor: """,nil)

smalltalk.bind(smalltalk.Script,"argsIn:",0
,smalltalk.__f__("""(self,mth):
	#Script>>#argsIn:
	return mth.args() 
""","Script_argsIn_")
,"native","""argsIn: mth
	" Private - Return the arguments bound to mth. "

	^mth args """,nil)

smalltalk.bind(smalltalk.Script,"jsImplementationFor:args:",0
,smalltalk.__f__("""(self,mth,args):
	#Script>>#jsImplementationFor:args:
	def __blk1__():
		return self.evaluate_binding_to_(this,args,smalltalk.Array.slice_(arguments)) 
	return smalltalk.blk(__blk1__,0) 
""","Script_jsImplementationFor_args_")
,"native","""jsImplementationFor: mth args: args
	" Private - Return the function to run mth. "

	^[ self evaluate: #{this} binding: args to: (Array slice: #{arguments}) ]""",nil)

smalltalk.bind(smalltalk.Script,"luaImplementationFor:args:",0
,smalltalk.__f__("""(self,mth,args):
	#Script>>#luaImplementationFor:args:
	__0__=smalltalk.newContext()
	__0__.script=nil
	__0__.fn=nil
	__0__.hash=nil
	__0__.hash=smalltalk.String("#") 
	__0__.script=self 
	self.invalidMessage_(smalltalk.String("luaImplementationFor:args:")) 
	return __0__.fn 
""","Script_luaImplementationFor_args_")
,"native","""luaImplementationFor: mth args: args
	" Private - Return the function to run mth. "

	| script fn hash |
	hash := $#.
	script := self.
	{''lua'fn = function (...)
		local array = smalltalk:newArray()
		for i=1,select(hash,...),1 do array:add_(select(i,...)) end
		return script:evaluate_binding_to_(self,args,array)
	end'}.
	^fn""",nil)

smalltalk.bind(smalltalk.Script,"pyImplementationFor:args:",0
,smalltalk.__f__("""(self,mth,args):
	#Script>>#pyImplementationFor:args:
	__0__=smalltalk.newContext()
	__0__.script=nil
	__0__.script=self 
	def result(rcv,*params):
		return __0__.script.evaluate_binding_to_(rcv,args,smalltalk.Array(params))
	if True: return result 
	return self 
""","Script_pyImplementationFor_args_")
,"native","""pyImplementationFor: mth args: args
	" Private - Return the function to run mth. "

	| script |
	script := self.
	{''py'def result(rcv,*params):%>%return __0__.script.evaluate_binding_to_(rcv,args,%Array%(params))%<%if True: return result'}""",nil)

smalltalk.bind(smalltalk.StepOverScript.__class__,"doing:",0
,smalltalk.__f__("""(self,aBlock):
	#StepOverScript class>>#doing:
	return self.new().initialize_(aBlock) 
""","StepOverScript_class_doing_")
,"instantiation","""doing: aBlock
	" Returns an instance of the receiver. "

	^self new initialize: aBlock """,nil)

smalltalk.bind(smalltalk.StepOverScript,"initialize:",0
,smalltalk.__f__("""(self,anAction):
	#StepOverScript>>#initialize:
	smalltalk.basic_at_put(self,"@action",anAction) 
	return self 
""","StepOverScript_initialize_")
,"initialize","""initialize: anAction
	" Private - Initialize the receiver. "

	action := anAction """,nil)

smalltalk.bind(smalltalk.StepOverScript,"argsIn:",0
,smalltalk.__f__("""(self,aMethod):
	#StepOverScript>>#argsIn:
	__0__=smalltalk.newContext()
	def __blk1__(each):
		__0__.i=__0__.i._plus(smalltalk.Number(1)) 
		return smalltalk.object_comma_(smalltalk.object_comma_(smalltalk.object_comma_(smalltalk.String("("),__0__.i),smalltalk.String(")")),each) 
	__0__.i=nil
	__0__.i=smalltalk.Number(0) 
	return aMethod.selector().asArrayOfSubstringsSeparatedBy_(smalltalk.String(":")).collect_(smalltalk.blk(__blk1__,1)) 
""","StepOverScript_argsIn_")
,"native","""argsIn: aMethod
	" Private - Return the arguments bound to aMethod. "

	| i | i := 0.
	^(aMethod selector asArrayOfSubstringsSeparatedBy: $:) collect: [:each|
		i := i + 1. $( ,i ,$) ,each
	] """,nil)

smalltalk.bind(smalltalk.StepOverScript,"contextFor:binding:to:",0
,smalltalk.__f__("""(self,aReceiver,args,array):
	#StepOverScript>>#contextFor:binding:to:
	__0__=smalltalk.newContext()
	def __blk1__(i):
		return __0__.result.at_put_(args.at_(i),array.at_(i)) 
	__0__.result=nil
	__0__.count=nil
	__0__.result=smalltalk.S8Context.for_(aReceiver) 
	__0__.count=args.size().min_(array.size()) 
	smalltalk.Number(1).to_do_(__0__.count,smalltalk.blk(__blk1__,1)) 
	return __0__.result 
""","StepOverScript_contextFor_binding_to_")
,"evaluating","""contextFor: aReceiver binding: args to: array
	" Returns the context to evaluate the receiver on aReceiver with parameters. "

	| result count |
	result := S8Context for: aReceiver.
	count := args size min: array size.
	1 to: count do: [:i| result at: (args at: i) put: (array at: i) ].
	^result """,nil)

smalltalk.bind(smalltalk.StepOverScript,"stepsFor:entering:withArguments:",0
,smalltalk.__f__("""(self,aReceiver,aMethod,array):
	#StepOverScript>>#stepsFor:entering:withArguments:
	self.sourceRange_(smalltalk.Number(0).to_(aMethod.source().size()._minus(smalltalk.Number(1)))) 
	return smalltalk.superReceiver(smalltalk.StepOverScript,self).stepsFor_entering_withArguments_(aReceiver,aMethod,array) 
""","StepOverScript_stepsFor_entering_withArguments_")
,"simulating","""stepsFor: aReceiver entering: aMethod withArguments: array
	" Returns the steps to evaluate execution of the receiver activating aMethod. "

	self sourceRange: (0 to: aMethod source size - 1).
	^super stepsFor: aReceiver entering: aMethod withArguments: array """,nil)

smalltalk.bind(smalltalk.StepOverScript,"inject:in:",0
,smalltalk.__f__("""(self,simulator,aContext):
	#StepOverScript>>#inject:in:
	if smalltalk.b(self.isEmpty()):
		def __blk1__(simulator):
			return simulator.value_(getattr(self,"@action",nil).evaluateWith_(simulator)) 
		return simulator.add_step_in_(self,smalltalk.blk(__blk1__,1),aContext) 
	 
	return self.invalidMessage_(smalltalk.String("inject:in:")) 
""","StepOverScript_inject_in_")
,"internal","""inject: simulator in: aContext
	" Private - Add the steps for evaluation of contents of the receiver in aContext. "

	self isEmpty ifTrue: [
		^simulator add: self
			step: [:simulator| simulator value: (action evaluateWith: simulator) ]
			in: aContext
	].
	^self invalidMessage: #inject:in: """,nil)

smalltalk.bind(smalltalk.StepOverScript,"evaluateContentsIn:",0
,smalltalk.__f__("""(self,localContext):
	#StepOverScript>>#evaluateContentsIn:
	if smalltalk.b(self.isEmpty()):
		return getattr(self,"@action",nil).evaluateWith_(nil) 
	 
	return self.invalidMessage_(smalltalk.String("evaluateContentsIn:")) 
""","StepOverScript_evaluateContentsIn_")
,"evaluating","""evaluateContentsIn: localContext
	" Private - Returns the result of evaluating the contents of the receiver in local context. "

	self isEmpty ifTrue: [ ^action evaluateWith: nil ].
	^self invalidMessage: #evaluateContentsIn: """,nil)

smalltalk.bind(smalltalk.ParseVariable.__class__,"boundTo:",0
,smalltalk.__f__("""(self,assoc):
	#ParseVariable class>>#boundTo:
	return self.new().binding_(assoc) 
""","ParseVariable_class_boundTo_")
,"instantiation","""boundTo: assoc
	" Returns an instance of the receiver. "

	^self new binding: assoc """,nil)

smalltalk.bind(smalltalk.ParseVariable,"name",0
,smalltalk.__f__("""(self):
	#ParseVariable>>#name
	return self.binding().key() 
""","ParseVariable_name")
,"accessing","""name
	" Returns the receiver's name. "

	^self binding key """,nil)

smalltalk.bind(smalltalk.ParseVariable,"indices:",0
,smalltalk.__f__("""(self,anArray):
	#ParseVariable>>#indices:
	smalltalk.basic_at_put(self,"@indices",anArray) 
	return self 
""","ParseVariable_indices_")
,"accessing","""indices: anArray
	" Set the receiver's indices. "

	indices := anArray """,nil)

smalltalk.bind(smalltalk.ParseVariable,"bind:in:",0
,smalltalk.__f__("""(self,aValue,aContext):
	#ParseVariable>>#bind:in:
	if not smalltalk.b(self.canBeAssigned()):
		return self.error_(smalltalk.String("Invalid assignment")) 
	 
	return self.assignValue_in_(aValue,aContext) 
""","ParseVariable_bind_in_")
,"binding","""bind: aValue in: aContext
	" Set the receiver's value to aValue in aContext.
	Check if the receiver is assignable.
	WARNING: The receiver MUST return the value set. "

	self canBeAssigned ifFalse: [
		^self error: 'Invalid assignment'
	].
	^self assignValue: aValue in: aContext """,nil)

smalltalk.bind(smalltalk.ParseVariable,"binding",0
,smalltalk.__f__("""(self):
	#ParseVariable>>#binding
	return getattr(self,"@binding",nil) 
""","ParseVariable_binding")
,"binding","""binding
	" Returns the receiver's binding. "

	^binding """,nil)

smalltalk.bind(smalltalk.ParseVariable,"binding:",0
,smalltalk.__f__("""(self,aBinding):
	#ParseVariable>>#binding:
	smalltalk.basic_at_put(self,"@binding",aBinding) 
	return self 
""","ParseVariable_binding_")
,"binding","""binding: aBinding
	" Set the receiver's binding. "

	binding := aBinding """,nil)

smalltalk.bind(smalltalk.ParseVariable,"key:in:",0
,smalltalk.__f__("""(self,index,aContext):
	#ParseVariable>>#key:in:
	def __blk1__():
		return index.evaluateIn_(aContext) 
	def __blk2__():
		return index 
	return smalltalk.if_true_false_(smalltalk.is_kindOf_(index,(smalltalk.ParseNode)),smalltalk.blk(__blk1__,0),smalltalk.blk(__blk2__,0)) 
""","ParseVariable_key_in_")
,"indexing","""key: index in: aContext
	" Private - Returns the key to index an object in aContext. "

	^(index isKindOf: ParseNode)
	ifTrue: [ index evaluateIn: aContext ]
	ifFalse: [ index ]""",nil)

smalltalk.bind(smalltalk.ParseVariable,"index:in:",0
,smalltalk.__f__("""(self,anObject,aContext):
	#ParseVariable>>#index:in:
	def __blk1__(result,index):
		def __blk2__():
			nil 
		return smalltalk.basic_at_ifAbsent_(result,self.key_in_(index,aContext),smalltalk.blk(__blk2__,0)) 
	if smalltalk.b(smalltalk.isNil_(getattr(self,"@indices",nil))):
		return anObject 
	 
	return getattr(self,"@indices",nil).inject_into_(anObject,smalltalk.blk(__blk1__,2)) 
""","ParseVariable_index_in_")
,"indexing","""index: anObject in: aContext
	" Private - Returns the result of indexing anObject. "

	indices isNil ifTrue: [ ^anObject ].
	^indices inject: anObject into: [:result :index|
		result	basicAt: (self key: index in: aContext)
			ifAbsent: [ ]
	]""",nil)

smalltalk.bind(smalltalk.ParseVariable,"follow:in:",0
,smalltalk.__f__("""(self,anObject,aContext):
	#ParseVariable>>#follow:in:
	__0__=smalltalk.newContext()
	def __blk1__(i):
		def __blk2__():
			nil 
		__0__.index=self.key_in_(getattr(self,"@indices",nil).at_(i),aContext) 
		__0__.target=smalltalk.basic_at_ifAbsent_(__0__.target,__0__.index,smalltalk.blk(__blk2__,0))
		return __0__.target 
	__0__.target=nil
	__0__.index=nil
	if smalltalk.b(smalltalk.isNil_(getattr(self,"@indices",nil))):
		return nil 
	 
	__0__.target=anObject 
	smalltalk.Number(1).to_do_(getattr(self,"@indices",nil).size()._minus(smalltalk.Number(1)),smalltalk.blk(__blk1__,1)) 
	__0__.index=self.key_in_(getattr(self,"@indices",nil).last(),aContext) 
	return smalltalk.Array.with_with_(__0__.target,__0__.index) 
""","ParseVariable_follow_in_")
,"indexing","""follow: anObject in: aContext
	" Private - Returns the result of following the indices from anObject and last index to evaluate (or nil). "

	| target index |
	indices isNil ifTrue: [ ^nil ].
	target := anObject.
	1 to: indices size - 1 do: [:i|
		index := self key: (indices at: i) in: aContext.
		target := target basicAt: index ifAbsent: []
	].
	index := self key: indices last in: aContext.
	^Array with: target with: index """,nil)

smalltalk.bind(smalltalk.ParseVariable,"assignValue:in:",0
,smalltalk.__f__("""(self,aValue,aContext):
	#ParseVariable>>#assignValue:in:
	def __blk1__():
		def __blk2__(root):
			return self.follow_in_(root,aContext) 
		return smalltalk.blk(__blk2__,1) 
	return self.binding().assign_to_in_(smalltalk.if_true_false_(smalltalk.notNil_(getattr(self,"@indices",nil)),smalltalk.blk(__blk1__,0),nil),aValue,aContext) 
""","ParseVariable_assignValue_in_")
,"evaluating","""assignValue: aValue in: aContext
	" Private - Set the receiver's value to aValue.
	WARNING: The receiver MUST return the value set. "

	^self binding
		assign: (indices notNil ifTrue: [ [:root| self follow: root in: aContext ] ])
		to: aValue in: aContext """,nil)

smalltalk.bind(smalltalk.ParseVariable,"valueIn:",0
,smalltalk.__f__("""(self,aContext):
	#ParseVariable>>#valueIn:
	return self.binding().evaluateIn_(aContext) 
""","ParseVariable_valueIn_")
,"value","""valueIn: aContext
	" Private - Returns the value of the receiver in aContext. "

	^self binding evaluateIn: aContext """,nil)

smalltalk.bind(smalltalk.ParseVariable,"evaluateIn:",0
,smalltalk.__f__("""(self,aContext):
	#ParseVariable>>#evaluateIn:
	return self.index_in_(self.valueIn_(aContext),aContext) 
""","ParseVariable_evaluateIn_")
,"evaluating","""evaluateIn: aContext
	" Returns the result of evaluating the receiver in aContext. "

	^self index: (self valueIn: aContext) in: aContext """,nil)

smalltalk.bind(smalltalk.ParseVariable,"canBeAssigned",0
,smalltalk.__f__("""(self):
	#ParseVariable>>#canBeAssigned
	return smalltalk.false 
""","ParseVariable_canBeAssigned")
,"query","""canBeAssigned
	" Returns true if the receiver is a variable that can be assigned. "

	^false """,nil)

smalltalk.bind(smalltalk.ParseVariable,"isVariable",0
,smalltalk.__f__("""(self):
	#ParseVariable>>#isVariable
	return smalltalk.true 
""","ParseVariable_isVariable")
,"query","""isVariable
	" Returns true if the receiver is a variable parse node. "

	^true """,nil)

smalltalk.bind(smalltalk.ParseArgument,"clear:",0
,smalltalk.__f__("""(self,aContext):
	#ParseArgument>>#clear:
	return aContext.clear_(self.binding()) 
""","ParseArgument_clear_")
,"evaluating","""clear: aContext
	" Clear the receiver's contents. "

	^aContext clear: self binding """,nil)

smalltalk.bind(smalltalk.ParseArgument,"canBeAssigned",0
,smalltalk.__f__("""(self):
	#ParseArgument>>#canBeAssigned
	return smalltalk.b_(getattr(self,"@canBeAssigned",nil) is smalltalk.true) 
""","ParseArgument_canBeAssigned")
,"query","""canBeAssigned
	" Returns true if the receiver is a variable that can be assigned. "

	^canBeAssigned == true""",nil)

smalltalk.bind(smalltalk.ParseArgument,"canBeAssigned:",0
,smalltalk.__f__("""(self,aBoolean):
	#ParseArgument>>#canBeAssigned:
	smalltalk.basic_at_put(self,"@canBeAssigned",aBoolean) 
	return self 
""","ParseArgument_canBeAssigned_")
,"query","""canBeAssigned: aBoolean
	" Set canBeAssigned to aBoolean. "

	canBeAssigned := aBoolean """,nil)

smalltalk.bind(smalltalk.ParseGlobalVariable,"canBeAssigned",0
,smalltalk.__f__("""(self):
	#ParseGlobalVariable>>#canBeAssigned
	return smalltalk.true 
""","ParseGlobalVariable_canBeAssigned")
,"query","""canBeAssigned
	" Returns true if the receiver is a variable that can be assigned. "

	^true """,nil)

smalltalk.bind(smalltalk.ParseGlobalConstant,"canBeAssigned",0
,smalltalk.__f__("""(self):
	#ParseGlobalConstant>>#canBeAssigned
	return smalltalk.false 
""","ParseGlobalConstant_canBeAssigned")
,"query","""canBeAssigned
	" Returns true if the receiver is a variable that can be assigned. "

	^false""",nil)

smalltalk.bind(smalltalk.ParseSpecial.__class__,"value:",0
,smalltalk.__f__("""(self,aValue):
	#ParseSpecial class>>#value:
	def __blk1__(_s8_rec):
		_s8_rec.binding_(smalltalk.S8LiteralBinding.value_(aValue)) 
		return _s8_rec.yourself() 
	return __blk1__(self.new()) 
""","ParseSpecial_class_value_")
,"evaluating","""value: aValue
	" Returns an instance of the receiver with value aValue. "

	^self new
		binding: (S8LiteralBinding value: aValue);
		yourself """,nil)

smalltalk.bind(smalltalk.ParseLiteral.__class__,"from:to:copy:",0
,smalltalk.__f__("""(self,start,stop,aValue):
	#ParseLiteral class>>#from:to:copy:
	def __blk1__(_s8_rec):
		_s8_rec.binding_(smalltalk.S8CopyBinding.value_(aValue)) 
		return _s8_rec.yourself() 
	return __blk1__(self.from_to_(start,stop)) 
""","ParseLiteral_class_from_to_copy_")
,"instantiation","""from: start to: stop copy: aValue
	" Returns an instance of the receiver with value aValue. "

	^(self from: start to: stop)
		binding: (S8CopyBinding value: aValue);
		yourself """,nil)

smalltalk.bind(smalltalk.ParseLiteral.__class__,"from:to:value:",0
,smalltalk.__f__("""(self,start,stop,aValue):
	#ParseLiteral class>>#from:to:value:
	def __blk1__(_s8_rec):
		_s8_rec.binding_(smalltalk.S8LiteralBinding.value_(aValue)) 
		return _s8_rec.yourself() 
	return __blk1__(self.from_to_(start,stop)) 
""","ParseLiteral_class_from_to_value_")
,"instantiation","""from: start to: stop value: aValue
	" Returns an instance of the receiver with value aValue. "

	^(self from: start to: stop)
		binding: (S8LiteralBinding value: aValue);
		yourself """,nil)

smalltalk.bind(smalltalk.ParseLiteral.__class__,"sourceRange:value:",0
,smalltalk.__f__("""(self,interval,aValue):
	#ParseLiteral class>>#sourceRange:value:
	def __blk1__(_s8_rec):
		_s8_rec.binding_(smalltalk.S8LiteralBinding.value_(aValue)) 
		return _s8_rec.yourself() 
	return __blk1__(self.sourceRange_(interval)) 
""","ParseLiteral_class_sourceRange_value_")
,"instantiation","""sourceRange: interval value: aValue
	" Returns an instance of the receiver with value aValue. "

	^(self sourceRange: interval)
		binding: (S8LiteralBinding value: aValue);
		yourself """,nil)

smalltalk.bind(smalltalk.ParseInstanceVariable.__class__,"name:index:",0
,smalltalk.__f__("""(self,aName,index):
	#ParseInstanceVariable class>>#name:index:
	def __blk1__(_s8_rec):
		_s8_rec.name_(aName) 
		_s8_rec.index_(index) 
		return _s8_rec.yourself() 
	return __blk1__(self.new()) 
""","ParseInstanceVariable_class_name_index_")
,"instantiation","""name: aName index: index
	" Returns an instance of the receiver with name aName. "

	^self new
		name: aName;
		index: index;
		yourself """,nil)

smalltalk.bind(smalltalk.ParseInstanceVariable,"index",0
,smalltalk.__f__("""(self):
	#ParseInstanceVariable>>#index
	return getattr(self,"@index",nil) 
""","ParseInstanceVariable_index")
,"accessing","""index
	" Returns the receiver's index. "

	^index """,nil)

smalltalk.bind(smalltalk.ParseInstanceVariable,"index:",0
,smalltalk.__f__("""(self,anIndex):
	#ParseInstanceVariable>>#index:
	smalltalk.basic_at_put(self,"@index",anIndex) 
	return self 
""","ParseInstanceVariable_index_")
,"accessing","""index: anIndex
	" Set the receiver's index. "

	index := anIndex """,nil)

smalltalk.bind(smalltalk.ParseInstanceVariable,"name",0
,smalltalk.__f__("""(self):
	#ParseInstanceVariable>>#name
	return getattr(self,"@name",nil) 
""","ParseInstanceVariable_name")
,"accessing","""name
	" Returns the receiver's name. "

	^name """,nil)

smalltalk.bind(smalltalk.ParseInstanceVariable,"name:",0
,smalltalk.__f__("""(self,aName):
	#ParseInstanceVariable>>#name:
	smalltalk.basic_at_put(self,"@name",aName) 
	return self 
""","ParseInstanceVariable_name_")
,"accessing","""name: aName
	" Set the receiver's name. "

	name := aName """,nil)

smalltalk.bind(smalltalk.ParseInstanceVariable,"instVarKey",0
,smalltalk.__f__("""(self):
	#ParseInstanceVariable>>#instVarKey
	return self.name() 
""","ParseInstanceVariable_instVarKey")
,"accessing","""instVarKey
	" Private - Returns the instance access index of the receiver. "

	^self name "
		was: index
		Note: S8 has better access to named i.v.
	" """,nil)

smalltalk.bind(smalltalk.ParseInstanceVariable,"bind:in:",0
,smalltalk.__f__("""(self,aValue,aContext):
	#ParseInstanceVariable>>#bind:in:
	if not smalltalk.b(self.canBeAssigned()):
		return self.error_(smalltalk.String("Invalid assignment.")) 
	 
	return aContext.self().instVarAt_put_(self.instVarKey(),aValue) 
""","ParseInstanceVariable_bind_in_")
,"binding","""bind: aValue in: aContext
	" Set the receiver's value to aValue in aContext.
	Check if the receiver is assignable.
	WARNING: The receiver MUST return the set value. "

	self canBeAssigned ifFalse: [
		^self error: 'Invalid assignment.'
	].
	^aContext self
		instVarAt: self instVarKey
		put: aValue """,nil)

smalltalk.bind(smalltalk.ParseInstanceVariable,"valueIn:",0
,smalltalk.__f__("""(self,aContext):
	#ParseInstanceVariable>>#valueIn:
	return aContext.self().instVarAt_(self.instVarKey()) 
""","ParseInstanceVariable_valueIn_")
,"value","""valueIn: aContext
	" Private - Returns the value of the receiver in aContext. "

	^aContext self instVarAt: self instVarKey """,nil)

smalltalk.bind(smalltalk.ParseInstanceVariable,"canBeAssigned",0
,smalltalk.__f__("""(self):
	#ParseInstanceVariable>>#canBeAssigned
	return smalltalk.true 
""","ParseInstanceVariable_canBeAssigned")
,"query","""canBeAssigned
	" Returns true if the receiver is a variable that can be assigned. "

	^true """,nil)

smalltalk.bind(smalltalk.ParseUniversal,"canBeAssigned",0
,smalltalk.__f__("""(self):
	#ParseUniversal>>#canBeAssigned
	return getattr(self,"@indices",nil).size()._gt(smalltalk.Number(0)) 
""","ParseUniversal_canBeAssigned")
,"query","""canBeAssigned
	" Returns true if the receiver is a variable that can be assigned. "

	^indices size > 0 """,nil)

smalltalk.bind(smalltalk.ParseUniversal,"assignValue:in:",0
,smalltalk.__f__("""(self,aValue,aContext):
	#ParseUniversal>>#assignValue:in:
	__0__=smalltalk.newContext()
	__0__.target=nil
	__0__.target=self.valueIn_(aContext) 
	__0__.target=self.follow_in_(__0__.target,aContext) 
	return smalltalk.basic_at_put_(__0__.target.first(),__0__.target.last(),aValue) 
""","ParseUniversal_assignValue_in_")
,"evaluating","""assignValue: aValue in: aContext
	"Private - Set the receiver's value to aValue.
	WARNING: The receiver MUST return the value set. "

	| target |
	target := self valueIn: aContext.
	target := self follow: target in: aContext.
	^target first basicAt: target last put: aValue """,nil)

smalltalk.bind(smalltalk.ParseSelf,"valueIn:",0
,smalltalk.__f__("""(self,aContext):
	#ParseSelf>>#valueIn:
	return aContext.self() 
""","ParseSelf_valueIn_")
,"value","""valueIn: aContext
	" Private - Returns the value of the receiver in aContext. "

	^aContext self """,nil)

smalltalk.bind(smalltalk.ParseSuper.__class__,"in:",0
,smalltalk.__f__("""(self,aClass):
	#ParseSuper class>>#in:
	return self.new().initialize_(aClass) 
""","ParseSuper_class_in_")
,"instantiation","""in: aClass
	" Returns an instance of the receiver. "

	^self new initialize: aClass""",nil)

smalltalk.bind(smalltalk.ParseSuper,"initialize:",0
,smalltalk.__f__("""(self,aClass):
	#ParseSuper>>#initialize:
	smalltalk.basic_at_put(self,"@implementor",aClass) 
	return self 
""","ParseSuper_initialize_")
,"initialize","""initialize: aClass
	" Private - Initialize the receiver. "

	implementor := aClass""",nil)

smalltalk.bind(smalltalk.ParseSuper,"isSuper",0
,smalltalk.__f__("""(self):
	#ParseSuper>>#isSuper
	return smalltalk.true 
""","ParseSuper_isSuper")
,"query","""isSuper
	" Returns true if the receiver is a reference to super. "

	^true """,nil)

smalltalk.bind(smalltalk.ParseSuper,"functionToCall:in:",0
,smalltalk.__f__("""(self,selector,anImplementor):
	#ParseSuper>>#functionToCall:in:
	return smalltalk.nativeCall(smalltalk.Smalltalk.current(),smalltalk.String("superImplementor"),anImplementor,selector) 
""","ParseSuper_functionToCall_in_")
,"evaluating","""functionToCall: selector in: anImplementor
	" Private - Returns the native function to call for selector. "

	^Smalltalk current
		#superImplementor: anImplementor
		of: selector """,nil)

smalltalk.bind(smalltalk.ParseSuper,"apply:to:withArguments:in:",0
,smalltalk.__f__("""(self,fn,anObject,anArray,aContext):
	#ParseSuper>>#apply:to:withArguments:in:
	return fn(anObject,*smalltalk.objects_toCall_(anArray,fn)) 
""","ParseSuper_apply_to_withArguments_in_")
,"evaluating","""apply: fn to: anObject withArguments: anArray in: aContext
	" Private - Returns the result of evaluating the native function in anObject @ aContext. "

	^{''
	js'fn.apply(anObject,anArray)'
	lua'fn(anObject,(table.unpack or unpack)(anArray))'
	py'fn(anObject,*smalltalk.objects_toCall_(anArray,fn))'}. """,nil)

smalltalk.bind(smalltalk.ParseSuper,"send:to:withArguments:in:",0
,smalltalk.__f__("""(self,selector,anObject,anArray,aContext):
	#ParseSuper>>#send:to:withArguments:in:
	__0__=smalltalk.newContext()
	def __blk1__():
		return (anObject).__class__ 
	def __blk2__():
		return getattr(self,"@implementor",nil) 
	__0__.anImplementor=nil
	__0__.anImplementor=smalltalk.if_true_false_(smalltalk.isNil_(getattr(self,"@implementor",nil)),smalltalk.blk(__blk1__,0),smalltalk.blk(__blk2__,0)) 
	return self.apply_to_withArguments_in_(self.functionToCall_in_(selector,__0__.anImplementor),anObject,anArray,aContext) 
""","ParseSuper_send_to_withArguments_in_")
,"evaluating","""send: selector to: anObject withArguments: anArray in: aContext
	" Private - Returns the result of sending message to anObject in aContext. "

	| anImplementor |
	anImplementor := implementor isNil
		ifTrue: [ anObject class ]
		ifFalse: [ implementor ].
	^self	apply: (self functionToCall: selector in: anImplementor)
		to: anObject withArguments: anArray
		in: aContext """,nil)

smalltalk.bind(smalltalk.ParseNoReceiver,"isOO",0
,smalltalk.__f__("""(self):
	#ParseNoReceiver>>#isOO
	return smalltalk.false 
""","ParseNoReceiver_isOO")
,"query","""isOO
	" Returns true if the receiver refers to an object. "

	^false """,nil)

smalltalk.bind(smalltalk.ParseNoReceiver,"valueIn:",0
,smalltalk.__f__("""(self,aContext):
	#ParseNoReceiver>>#valueIn:
	return aContext 
""","ParseNoReceiver_valueIn_")
,"value","""valueIn: aContext
	" Private - Returns the value of the receiver in aContext. "

	^aContext """,nil)

smalltalk.bind(smalltalk.ParseNoReceiver,"send:to:withArguments:in:",0
,smalltalk.__f__("""(self,selector,anObject,anArray,aContext):
	#ParseNoReceiver>>#send:to:withArguments:in:
	__0__=smalltalk.newContext()
	__0__.fn=nil
	if smalltalk.b(smalltalk.isObject_equalTo_(selector,smalltalk.String("self"))):
		return anObject.self().evaluateWithArguments_(anArray) 
	 
	__0__.fn=smalltalk.Smalltalk.nativeObjectAt_(selector) 
	return __0__.fn.evaluateWithArguments_(anArray) 
""","ParseNoReceiver_send_to_withArguments_in_")
,"evaluating","""send: selector to: anObject withArguments: anArray in: aContext
	" Private - Returns the result of sending message to anObject in aContext. "

	| fn |
	selector = #self ifTrue: [ "note that anObject is the context of evaluation"
		^anObject self evaluateWithArguments: anArray
	].
	fn := Smalltalk nativeObjectAt: selector.
	^fn evaluateWithArguments: anArray """,nil)

smalltalk.bind(smalltalk.ParseNativeVariable.__class__,"named:from:to:",0
,smalltalk.__f__("""(self,aName,start,stop):
	#ParseNativeVariable class>>#named:from:to:
	def __blk1__(_s8_rec):
		_s8_rec.binding_(aName._minus_gt(nil)) 
		return _s8_rec.yourself() 
	return __blk1__(self.from_to_(start,stop)) 
""","ParseNativeVariable_class_named_from_to_")
,"instantiation","""named: aName from: start to: stop
	" Returns an instance of the receiver. "

	^(self from: start to: stop)
		binding: aName -> nil;
		yourself """,nil)

smalltalk.bind(smalltalk.ParseNativeVariable,"valueIn:",0
,smalltalk.__f__("""(self,aContext):
	#ParseNativeVariable>>#valueIn:
	return smalltalk.basic_at_(smalltalk.Smalltalk._8global(),self.name()) 
""","ParseNativeVariable_valueIn_")
,"value","""valueIn: aContext
	" Private - Returns the value of the receiver in aContext. "

	^Smalltalk global basicAt: self name """,nil)

smalltalk.bind(smalltalk.ParseNativeVariable,"canBeAssigned",0
,smalltalk.__f__("""(self):
	#ParseNativeVariable>>#canBeAssigned
	return smalltalk.true 
""","ParseNativeVariable_canBeAssigned")
,"query","""canBeAssigned
	" Returns true if the receiver is a variable that can be assigned. "

	^true """,nil)

smalltalk.bind(smalltalk.ParseNativeVariable,"assignValue:in:",0
,smalltalk.__f__("""(self,aValue,aContext):
	_s8Ret_=smalltalk.newContext()
	try:
		#ParseNativeVariable>>#assignValue:in:
		__0__=smalltalk.newContext()
		def __blk1__():
			return smalltalk.raise_result_(_s8Ret_,self.error_(smalltalk.object_comma_(smalltalk.String("Native Global not found - "),self.name()))) 
		__0__.target=nil
		__0__.target=smalltalk.Smalltalk._8global() 
		if smalltalk.b(smalltalk.isNil_(getattr(self,"@indices",nil))):
			smalltalk.raise_result_(_s8Ret_,smalltalk.basic_at_put_(__0__.target,self.name(),aValue)) 
		 
		__0__.target=smalltalk.basic_at_ifAbsent_(__0__.target,self.name(),smalltalk.blk(__blk1__,0)) 
		__0__.target=self.follow_in_(__0__.target,aContext) 
		smalltalk.raise_result_(_s8Ret_,smalltalk.basic_at_put_(__0__.target.first(),__0__.target.last(),aValue)) 
	except Exception as __ex:
		if smalltalk.exception_at(__ex,_s8Ret_):
			return smalltalk.exceptionResult_(__ex)
		raise __ex
	
""","ParseNativeVariable_assignValue_in_")
,"evaluating","""assignValue: aValue in: aContext
	"Private - Set the receiver's value to aValue.
	WARNING: The receiver MUST return the value set. "

	| target |
	target := Smalltalk global.
	indices isNil ifTrue: [ ^target basicAt: self name put: aValue ].
	target := target basicAt: self name ifAbsent: [
		^self error: 'Native Global not found - ' ,self name
	].
	target := self follow: target in: aContext.
	^target first basicAt: target last put: aValue """,nil)

smalltalk.bind(smalltalk.MethodExitNode,"exitBlock",0
,smalltalk.__f__("""(self):
	#MethodExitNode>>#exitBlock
	return getattr(self,"@exitBlock",nil) 
""","MethodExitNode_exitBlock")
,"accessing","""exitBlock
	" Returns the receiver's exitBlock. "

	^exitBlock """,nil)

smalltalk.bind(smalltalk.MethodExitNode,"exitBlock:",0
,smalltalk.__f__("""(self,aBlock):
	#MethodExitNode>>#exitBlock:
	smalltalk.superReceiver(smalltalk.MethodExitNode,self).exitBlock_(aBlock) 
	smalltalk.basic_at_put(self,"@exitBlock",aBlock) 
	return self 
""","MethodExitNode_exitBlock_")
,"accessing","""exitBlock: aBlock
	" Set the receiver's exitBlock. "

	super exitBlock: aBlock.
	exitBlock := aBlock.""",nil)

smalltalk.bind(smalltalk.MethodExitNode,"exitWith:",0
,smalltalk.__f__("""(self,anObject):
	#MethodExitNode>>#exitWith:
	if smalltalk.b(smalltalk.isNil_(getattr(self,"@exitBlock",nil))):
		return self.error_(smalltalk.String("Invalid script context.")) 
	 
	return getattr(self,"@exitBlock",nil).value_(anObject) 
""","MethodExitNode_exitWith_")
,"evaluating","""exitWith: anObject
	" Exit the receiver with anObject as returned value. "

	exitBlock isNil ifTrue: [ ^self error: 'Invalid script context.' ].
	^exitBlock value: anObject """,nil)

smalltalk.bind(smalltalk.MethodReturnNode,"expression",0
,smalltalk.__f__("""(self):
	#MethodReturnNode>>#expression
	return getattr(self,"@expression",nil) 
""","MethodReturnNode_expression")
,"accessing","""expression
	" Returns the receiver's expression. "

	^expression """,nil)

smalltalk.bind(smalltalk.MethodReturnNode,"expression:",0
,smalltalk.__f__("""(self,anExpressionNode):
	#MethodReturnNode>>#expression:
	smalltalk.basic_at_put(self,"@expression",anExpressionNode) 
	return self 
""","MethodReturnNode_expression_")
,"accessing","""expression: anExpressionNode
	" Set the receiver's expression. "

	expression := anExpressionNode """,nil)

smalltalk.bind(smalltalk.MethodReturnNode,"exitBlock:",0
,smalltalk.__f__("""(self,aBlock):
	#MethodReturnNode>>#exitBlock:
	smalltalk.superReceiver(smalltalk.MethodReturnNode,self).exitBlock_(aBlock) 
	getattr(self,"@expression",nil).exitBlock_(aBlock) 
	return self 
""","MethodReturnNode_exitBlock_")
,"accessing","""exitBlock: aBlock
	" Set the receiver's exitBlock. "

	super exitBlock: aBlock.
	expression exitBlock: aBlock """,nil)

smalltalk.bind(smalltalk.MethodReturnNode,"isReturn",0
,smalltalk.__f__("""(self):
	#MethodReturnNode>>#isReturn
	return smalltalk.true 
""","MethodReturnNode_isReturn")
,"query","""isReturn
	" Returns true if the receiver is a return parse node. "

	^true """,nil)

smalltalk.bind(smalltalk.MethodReturnNode,"evaluateIn:",0
,smalltalk.__f__("""(self,aContext):
	#MethodReturnNode>>#evaluateIn:
	return self.exitWith_(self.expression().evaluateIn_(aContext)) 
""","MethodReturnNode_evaluateIn_")
,"evaluating","""evaluateIn: aContext
	" Returns the result of evaluating the receiver in aContext. "

	^self exitWith: (self expression evaluateIn: aContext) """,nil)

smalltalk.bind(smalltalk.PrimitiveNode.__class__,"doing:",0
,smalltalk.__f__("""(self,anAction):
	#PrimitiveNode class>>#doing:
	def __blk1__(_s8_rec):
		_s8_rec.action_(anAction) 
		return _s8_rec.yourself() 
	return __blk1__(self.new()) 
""","PrimitiveNode_class_doing_")
,"instantiation","""doing: anAction
	" Returns an instance of the receiver. "

	^self new
		action: anAction;
		yourself """,nil)

smalltalk.bind(smalltalk.PrimitiveNode,"isPrimitiveNode",0
,smalltalk.__f__("""(self):
	#PrimitiveNode>>#isPrimitiveNode
	return smalltalk.true 
""","PrimitiveNode_isPrimitiveNode")
,"query","""isPrimitiveNode
	" Returns true if the receiver is a primitive. "

	^true """,nil)

smalltalk.bind(smalltalk.PrimitiveNode,"action:",0
,smalltalk.__f__("""(self,anAction):
	#PrimitiveNode>>#action:
	smalltalk.basic_at_put(self,"@action",anAction) 
	return self 
""","PrimitiveNode_action_")
,"accessing","""action: anAction
	" Set the receiver's action. "

	action := anAction """,nil)

smalltalk.bind(smalltalk.PrimitiveNode,"evaluateIn:",0
,smalltalk.__f__("""(self,aContext):
	#PrimitiveNode>>#evaluateIn:
	if smalltalk.b(smalltalk.isNil_(getattr(self,"@action",nil))):
		return self.error_(smalltalk.String("Action to evaluate missing.")) 
	 
	return getattr(self,"@action",nil).evaluateWithArguments_(smalltalk.Array.with_with_(aContext,self)) 
""","PrimitiveNode_evaluateIn_")
,"evaluating","""evaluateIn: aContext
	" Returns the result of evaluating the receiver in aContext. "

	action isNil ifTrue: [ ^self error: 'Action to evaluate missing.' ].
	^action evaluateWithArguments: (Array with: aContext with: self) """,nil)

smalltalk.bind(smalltalk.ScriptParser.__class__,"for:on:",0
,smalltalk.__f__("""(self,aReceiver,aScope):
	#ScriptParser class>>#for:on:
	def __blk1__(_s8_rec):
		_s8_rec.scope_(aScope) 
		_s8_rec.receiver_(aReceiver) 
		return _s8_rec.yourself() 
	return __blk1__(self.new()) 
""","ScriptParser_class_for_on_")
,"instantiation","""for: aReceiver on: aScope
	" OBSOLETE - Returns an instance of the receiver for evaluating on objects like aReceiver on given scope. "

	^self new
		scope: aScope;
		receiver: aReceiver;
		yourself """,nil)

smalltalk.bind(smalltalk.ScriptParser.__class__,"for:",0
,smalltalk.__f__("""(self,aClass):
	#ScriptParser class>>#for:
	def __blk1__(_s8_rec):
		_s8_rec.currentClass_(aClass) 
		return _s8_rec.yourself() 
	return __blk1__(self.new()) 
""","ScriptParser_class_for_")
,"instantiation","""for: aClass
	" Returns an instance of the receiver to parse in aClass. "

	^self new
		currentClass: aClass;
		yourself """,nil)

smalltalk.bind(smalltalk.ScriptParser.__class__,"on:",0
,smalltalk.__f__("""(self,aScope):
	#ScriptParser class>>#on:
	def __blk1__(_s8_rec):
		_s8_rec.scope_(aScope) 
		return _s8_rec.yourself() 
	return __blk1__(self.new()) 
""","ScriptParser_class_on_")
,"instantiation","""on: aScope
	" Returns an instance of the receiver to parse on given scope. "

	^self new
		scope: aScope;
		yourself """,nil)

smalltalk.bind(smalltalk.ScriptParser.__class__,"initializePrimitiveHandlers",0
,smalltalk.__f__("""(self):
	#ScriptParser class>>#initializePrimitiveHandlers
	smalltalk.basic_at_put(self,"@primitiveHandlers",smalltalk.PoolDictionary.new()) 
	return self 
""","ScriptParser_class_initializePrimitiveHandlers")
,"initialize","""initializePrimitiveHandlers
		" Private - Initialize the primitiveHandlers of the receiver. "
	
		primitiveHandlers := PoolDictionary new""",nil)

smalltalk.bind(smalltalk.ScriptParser.__class__,"primitiveHandlers",0
,smalltalk.__f__("""(self):
	#ScriptParser class>>#primitiveHandlers
	if smalltalk.b(smalltalk.isNil_(getattr(self,"@primitiveHandlers",nil))):
		self.initializePrimitiveHandlers() 
	 
	return getattr(self,"@primitiveHandlers",nil) 
""","ScriptParser_class_primitiveHandlers")
,"accessing","""primitiveHandlers
		" Return the primitiveHandlers of the receiver. "
	
		primitiveHandlers isNil ifTrue: [ self initializePrimitiveHandlers ].
		^primitiveHandlers""",nil)

smalltalk.bind(smalltalk.ScriptParser.__class__,"defaultPrimitiveHandler",0
,smalltalk.__f__("""(self):
	#ScriptParser class>>#defaultPrimitiveHandler
	return getattr(self,"@defaultPrimitiveHandler",nil) 
""","ScriptParser_class_defaultPrimitiveHandler")
,"accessing","""defaultPrimitiveHandler
		" Return the defaultPrimitiveHandler of the receiver. "
	
		^defaultPrimitiveHandler""",nil)

smalltalk.bind(smalltalk.ScriptParser.__class__,"defaultPrimitiveHandler:",0
,smalltalk.__f__("""(self,anObject):
	#ScriptParser class>>#defaultPrimitiveHandler:
	smalltalk.basic_at_put(self,"@defaultPrimitiveHandler",anObject) 
	return self 
""","ScriptParser_class_defaultPrimitiveHandler_")
,"accessing","""defaultPrimitiveHandler: anObject
		" Set the defaultPrimitiveHandler of the receiver. "
	
		defaultPrimitiveHandler := anObject""",nil)

smalltalk.bind(smalltalk.ScriptParser.__class__,"handlerForPrimitive:",0
,smalltalk.__f__("""(self,type):
	#ScriptParser class>>#handlerForPrimitive:
	def __blk1__():
		def __blk2__():
			return self.defaultPrimitiveHandler() 
		return self.primitiveHandlers().at_ifAbsent_(type,smalltalk.blk(__blk2__,0)) 
	return smalltalk.if_true_false_(smalltalk.notNil_(type),smalltalk.blk(__blk1__,0),nil) 
""","ScriptParser_class_handlerForPrimitive_")
,"parsing","""handlerForPrimitive: type
	" Private - Returns a handler to evaluate for parsing a primitive of specified type. "

	^type notNil ifTrue: [
		self primitiveHandlers at: type ifAbsent: [
			self defaultPrimitiveHandler
		]
	] """,nil)

smalltalk.bind(smalltalk.ScriptParser.__class__,"parsePrimitive:in:",0
,smalltalk.__f__("""(self,aParser,aContext):
	#ScriptParser class>>#parsePrimitive:in:
	__0__=smalltalk.newContext()
	def __blk1__():
		return __0__.handler.evaluateWithArguments_(smalltalk.Array.with_with_with_(aParser,aContext,__0__.type)) 
	__0__.handler=nil
	__0__.type=nil
	__0__.type=aParser.nextSelectorOrNil() 
	__0__.handler=self.handlerForPrimitive_(__0__.type) 
	return smalltalk.if_true_false_(smalltalk.notNil_(__0__.handler),smalltalk.blk(__blk1__,0),nil) 
""","ScriptParser_class_parsePrimitive_in_")
,"parsing","""parsePrimitive: aParser in: aContext
	" Private - Parse a primitive in aContext.
	Returns nil if failed. "

	| handler type |
	type := aParser nextSelectorOrNil.
	handler := self handlerForPrimitive: type.
	^handler notNil ifTrue: [
		handler evaluateWithArguments:
			(Array with: aParser with: aContext with: type)
	] """,nil)

smalltalk.bind(smalltalk.ScriptParser,"expression:",0
,smalltalk.__f__("""(self,aContext):
	#ScriptParser>>#expression:
	__0__=smalltalk.newContext()
	def __blk1__():
		return self.match_(self.leftArrow()) 
	__0__.variable=nil
	__0__.expression=nil
	__0__.aReceiver=nil
	__0__.start=nil
	__0__.start=self.startOfNextToken() 
	if smalltalk.b(self.match_(self.primitiveStart())):
		return self.nextPrimitive_(aContext) 
	 
	__0__.variable=self.nextVariable_(aContext) 
	if smalltalk.b(smalltalk.boolean_and_(smalltalk.notNil_(__0__.variable),smalltalk.blk(__blk1__,0))):
		return self.assignment_in_startPosition_(__0__.variable,aContext,__0__.start) 
	 
	self.position_(__0__.start) 
	__0__.aReceiver=self.primaryExpression_(aContext) 
	if smalltalk.b(self.atEnd()):
		return __0__.aReceiver 
	 
	__0__.expression=self.message3_repeat_in_(__0__.aReceiver,smalltalk.true,aContext) 
	if smalltalk.b(smalltalk.isNil_(__0__.expression)):
		return __0__.aReceiver 
	 
	if smalltalk.b(self.match_(self.semicolon())):
		__0__.expression=self.cascade_to_in_(__0__.expression,__0__.aReceiver,aContext) 
	 
	return __0__.expression 
""","ScriptParser_expression_")
,"parsing","""expression: aContext
	" Private - Parse the receiver looking for an expression using variables in aContext. Returns nil if failed.
	<rule> expression = primitive | {variableName ':='} (primary | messageExpression {';' cascadeMessage})
	"

	| variable expression aReceiver start |
	start := self startOfNextToken.
	(self match: self primitiveStart) ifTrue: [
		^self nextPrimitive: aContext
	].

	variable := self nextVariable: aContext.
	(variable notNil and: [ self match: self leftArrow ])
	ifTrue: [ ^self assignment: variable in: aContext startPosition: start ].

	self position: start.
	aReceiver := self primaryExpression: aContext.
	self atEnd ifTrue: [ ^aReceiver ].
	expression := self message3: aReceiver repeat: true in: aContext.
	expression isNil ifTrue: [ ^aReceiver ].
	(self match: self semicolon) ifTrue: [
		expression := self cascade: expression to: aReceiver in: aContext
	].
	^expression""",nil)

smalltalk.bind(smalltalk.ScriptParser,"position",0
,smalltalk.__f__("""(self):
	#ScriptParser>>#position
	__0__=smalltalk.newContext()
	def __blk1__():
		return smalltalk.Number(0) 
	def __blk2__():
		return __0__.result 
	__0__.result=nil
	__0__.result=getattr(self,"@source",nil).position() 
	return smalltalk.if_true_false_(smalltalk.isNil_(__0__.result),smalltalk.blk(__blk1__,0),smalltalk.blk(__blk2__,0)) 
""","ScriptParser_position")
,"accessing","""position
	" Returns the current position. "

	| result |
	result := source position.
	^result isNil ifTrue: [0] ifFalse: [result]""",nil)

smalltalk.bind(smalltalk.ScriptParser,"position:",0
,smalltalk.__f__("""(self,index):
	#ScriptParser>>#position:
	return getattr(self,"@source",nil).position_(index) 
""","ScriptParser_position_")
,"accessing","""position: index
	" Set the current position. "

	^source position: index""",nil)

smalltalk.bind(smalltalk.ScriptParser,"currentClass",0
,smalltalk.__f__("""(self):
	#ScriptParser>>#currentClass
	if smalltalk.b(smalltalk.isNil_(getattr(self,"@currentClass",nil))):
		self.currentClass_(nil) 
	 
	return getattr(self,"@currentClass",nil) 
""","ScriptParser_currentClass")
,"accessing","""currentClass
	" Return the current class of the receiver. "

	currentClass isNil ifTrue: [ self currentClass: nil ].
	^currentClass""",nil)

smalltalk.bind(smalltalk.ScriptParser,"currentClass:",0
,smalltalk.__f__("""(self,aClass):
	#ScriptParser>>#currentClass:
	__0__=smalltalk.newContext()
	def __blk1__():
		return (nil).__class__ 
	def __blk2__():
		return aClass 
	def __blk3__(each):
		__0__.index=__0__.index._plus(smalltalk.Number(1)) 
		return smalltalk.ParseInstanceVariable.name_index_(each,__0__.index) 
	__0__.index=nil
	smalltalk.basic_at_put(self,"@currentClass",smalltalk.if_true_false_(smalltalk.isNil_(aClass),smalltalk.blk(__blk1__,0),smalltalk.blk(__blk2__,0))) 
	__0__.index=smalltalk.Number(0) 
	self.instanceVariables_(getattr(self,"@currentClass",nil).allInstVarNames().collect_(smalltalk.blk(__blk3__,1))) 
	return self 
""","ScriptParser_currentClass_")
,"accessing","""currentClass: aClass
	" Set the current class of the receiver. "

	| index |
	currentClass := aClass isNil ifTrue: [ nil class ] ifFalse: [ aClass ].
	index := 0.
	self instanceVariables: (currentClass allInstVarNames collect: [:each|
		index := index + 1.
		ParseInstanceVariable name: each index: index.
	])""",nil)

smalltalk.bind(smalltalk.ScriptParser,"receiver:",0
,smalltalk.__f__("""(self,anObject):
	#ScriptParser>>#receiver:
	self.currentClass_((anObject).__class__) 
	return self 
""","ScriptParser_receiver_")
,"accessing","""receiver: anObject
	" Set the receiver to parse considering the receiver will be a member of anObject species when evaluated. "

	self currentClass: anObject class """,nil)

smalltalk.bind(smalltalk.ScriptParser,"parseTemporaries:",0
,smalltalk.__f__("""(self,aContext):
	#ScriptParser>>#parseTemporaries:
	__0__=smalltalk.newContext()
	def __blk1__():
		__0__.start=self.startOfNextToken() 
		__0__.word=self.nextWord() 
		return smalltalk.notNil_(__0__.word) 
	__0__.vars=nil
	__0__.word=nil
	__0__.start=nil
	__0__.temporary=nil
	if smalltalk.b(self.match_(self.verticalBar())):
		return smalltalk.newArray([]) 
	 
	__0__.vars=smalltalk.Array.new() 
	while smalltalk.b(smalltalk.blk(__blk1__,0)()):
		self.position_(__0__.start) 
		__0__.temporary=self.nextArgument_(aContext) 
		if smalltalk.b(smalltalk.isNil_(__0__.temporary)):
			return self.expected_(smalltalk.String("local name")) 
		 
		__0__.temporary.canBeAssigned_(smalltalk.true) 
		__0__.vars.addLast_(__0__.temporary) 
	 
	if smalltalk.b(self.match_(self.verticalBar())):
		return __0__.vars 
	 
	return self.expected_(self.verticalBar()) 
""","ScriptParser_parseTemporaries_")
,"parsing","""parseTemporaries: aContext
	" Private - Read temporaries from the receiver's stream.
	<rule> temporaries = [ '|' (variable) ] (variable, ..., variable)*
	"

	| vars word start temporary |
	(self match: self verticalBar) ifTrue: [ ^#() ].
	vars := Array new.
	[	start := self startOfNextToken.
		word := self nextWord.
		word notNil
	] whileTrue: [
		self position: start.
		temporary := self nextArgument: aContext.
		temporary isNil ifTrue: [ ^self expected: 'local name' ].
		temporary canBeAssigned: true.
		vars addLast: temporary.
	].
	(self match: self verticalBar) ifTrue: [ ^vars ].
	^self expected: self verticalBar""",nil)

smalltalk.bind(smalltalk.ScriptParser,"assignment:in:",0
,smalltalk.__f__("""(self,aVariable,aContext):
	#ScriptParser>>#assignment:in:
	__0__=smalltalk.newContext()
	def __blk1__(_s8_rec):
		_s8_rec.variable_(aVariable) 
		_s8_rec.expression_(__0__.expression) 
		return _s8_rec.yourself() 
	__0__.expression=nil
	if not smalltalk.b(aVariable.canBeAssigned()):
		return self.syntaxError_(smalltalk.String("Cant assign to this variable.")) 
	 
	__0__.expression=self.expression_(aContext) 
	if smalltalk.b(smalltalk.isNil_(__0__.expression)):
		return self.expected_(smalltalk.String("expression")) 
	 
	return __blk1__(smalltalk.AssignNode.new()) 
""","ScriptParser_assignment_in_")
,"parsing","""assignment: aVariable in: aContext
	" Private - Get the assignment from the receiver.
	<rule> expression = {variableName ':='} (primary | messageExpression {';' cascadeMessage} ).
	 "

	| expression |
	aVariable canBeAssigned ifFalse: [ ^self syntaxError: 'Cant assign to this variable.' ].
	expression := self expression: aContext.
	expression isNil ifTrue: [ ^self expected: #expression ].
	^AssignNode new
		variable: aVariable;
		expression: expression;
		yourself""",nil)

smalltalk.bind(smalltalk.ScriptParser,"assignment:in:startPosition:",0
,smalltalk.__f__("""(self,variable,aContext,startPosition):
	#ScriptParser>>#assignment:in:startPosition:
	__0__=smalltalk.newContext()
	__0__.assignment=nil
	__0__.assignment=self.assignment_in_(variable,aContext) 
	__0__.assignment.sourceRange_(startPosition.to_(self.position())) 
	return __0__.assignment 
""","ScriptParser_assignment_in_startPosition_")
,"parsing","""assignment: variable in: aContext startPosition: startPosition
	" Private - Get the an assignement from the receiver. "

	| assignment |
	assignment := self assignment: variable in: aContext.
	assignment sourceRange: (startPosition to: self position).
	^assignment""",nil)

smalltalk.bind(smalltalk.ScriptParser,"initializeInstanceVariables",0
,smalltalk.__f__("""(self):
	#ScriptParser>>#initializeInstanceVariables
	self.instanceVariables_(smalltalk.Array.new()) 
	return self 
""","ScriptParser_initializeInstanceVariables")
,"initialize","""initializeInstanceVariables
	" Private - Initializes the receiver's instanceVariables. "

	self instanceVariables: Array new""",nil)

smalltalk.bind(smalltalk.ScriptParser,"initializeScope",0
,smalltalk.__f__("""(self):
	#ScriptParser>>#initializeScope
	self.scope_(smalltalk.ParseContext.default()) 
	return self 
""","ScriptParser_initializeScope")
,"initialize","""initializeScope
	" Private - Initializes the receiver's scope. "

	self scope: ParseContext default""",nil)

smalltalk.bind(smalltalk.ScriptParser,"atEnd",0
,smalltalk.__f__("""(self):
	#ScriptParser>>#atEnd
	self.skipSeparators() 
	return getattr(self,"@source",nil).atEnd() 
""","ScriptParser_atEnd")
,"query","""atEnd
	" Returns true when the receiver is atEnd. "

	self skipSeparators.
	^source atEnd""",nil)

smalltalk.bind(smalltalk.ScriptParser,"isBinarySelector:",0
,smalltalk.__f__("""(self,aSelector):
	_s8Ret_=smalltalk.newContext()
	try:
		#ScriptParser>>#isBinarySelector:
		def __blk1__(one):
			return smalltalk.booleanNot_(self.isSelectorCharacter_(one)) 
		def __blk2__():
			return smalltalk.raise_result_(_s8Ret_,smalltalk.true) 
		if smalltalk.b(aSelector.isEmpty()):
			smalltalk.raise_result_(_s8Ret_,smalltalk.false) 
		 
		aSelector.detect_ifNone_(smalltalk.blk(__blk1__,1),smalltalk.blk(__blk2__,0)) 
		smalltalk.raise_result_(_s8Ret_,smalltalk.false) 
	except Exception as __ex:
		if smalltalk.exception_at(__ex,_s8Ret_):
			return smalltalk.exceptionResult_(__ex)
		raise __ex
	
""","ScriptParser_isBinarySelector_")
,"query","""isBinarySelector: aSelector
	" Private - Returns true if aSelector is a keyword selector. "

	aSelector isEmpty ifTrue: [ ^false ].
	aSelector
		detect: [:one| (self isSelectorCharacter: one) not ]
		ifNone: [ ^true ].
	^false""",nil)

smalltalk.bind(smalltalk.ScriptParser,"isKeywordSelector:",0
,smalltalk.__f__("""(self,aSelector):
	#ScriptParser>>#isKeywordSelector:
	return smalltalk.isObject_equalTo_(aSelector.last(),smalltalk.String(":")) 
""","ScriptParser_isKeywordSelector_")
,"query","""isKeywordSelector: aSelector
	" Private - Returns true if aSelector is a keyword selector. "

	^aSelector last = $:""",nil)

smalltalk.bind(smalltalk.ScriptParser,"isAlpha:",0
,smalltalk.__f__("""(self,aCharacter):
	#ScriptParser>>#isAlpha:
	def __blk1__():
		return smalltalk.String("_").includes_(aCharacter) 
	return smalltalk.boolean_or_(aCharacter.isAlphaNumeric(),smalltalk.blk(__blk1__,0)) 
""","ScriptParser_isAlpha_")
,"query","""isAlpha: aCharacter
	" Private - Returns true if aCharacter is good in a word. "

	^aCharacter isAlphaNumeric or: [ '_' includes: aCharacter ]""",nil)

smalltalk.bind(smalltalk.ScriptParser,"binarySelectorChars",0
,smalltalk.__f__('''(self):
	#ScriptParser>>#binarySelectorChars
	return smalltalk.String("""|&+*/=><,@%~-?!\\\\""") 
''',"ScriptParser_binarySelectorChars")
,"constants","""binarySelectorChars
	" Return the binary selector characters mask. "

	^'|&+*/=><,@%~-?!\\' """,nil)

smalltalk.bind(smalltalk.ScriptParser,"isSelectorCharacter:",0
,smalltalk.__f__("""(self,aCharacter):
	#ScriptParser>>#isSelectorCharacter:
	return self.binarySelectorChars().includes_(aCharacter) 
""","ScriptParser_isSelectorCharacter_")
,"query","""isSelectorCharacter: aCharacter
	" Private - Returns true if aCharacter is a selector character.
	<rule> selectorCharacter = ',' | '+' | '-' | '/' | '\\' | '*' | '~' | '>' | '<' | '=' | '@' | '%' | '|' | '&' | '?' | '!' .
	"

	^self binarySelectorChars includes: aCharacter""",nil)

smalltalk.bind(smalltalk.ScriptParser,"isUnarySelector:",0
,smalltalk.__f__("""(self,aSelector):
	_s8Ret_=smalltalk.newContext()
	try:
		#ScriptParser>>#isUnarySelector:
		def __blk1__(one):
			return smalltalk.booleanNot_(self.isAlpha_(one)) 
		def __blk2__():
			return smalltalk.raise_result_(_s8Ret_,smalltalk.true) 
		if smalltalk.b(aSelector.isEmpty()):
			smalltalk.raise_result_(_s8Ret_,smalltalk.false) 
		 
		aSelector.detect_ifNone_(smalltalk.blk(__blk1__,1),smalltalk.blk(__blk2__,0)) 
		smalltalk.raise_result_(_s8Ret_,smalltalk.false) 
	except Exception as __ex:
		if smalltalk.exception_at(__ex,_s8Ret_):
			return smalltalk.exceptionResult_(__ex)
		raise __ex
	
""","ScriptParser_isUnarySelector_")
,"query","""isUnarySelector: aSelector
	" Private - Returns true if aSelector is a unary selector. "

	aSelector isEmpty ifTrue: [ ^false ].
"	aSelector first isLetter ifFalse: [ ^false ]."
	aSelector
		detect: [:one| (self isAlpha: one) not ]
		ifNone: [ ^true ].
	^false""",nil)

smalltalk.bind(smalltalk.ScriptParser,"arrayLiteralElement:",0
,smalltalk.__f__("""(self,aContext):
	#ScriptParser>>#arrayLiteralElement:
	return self.constant_(aContext) 
""","ScriptParser_arrayLiteralElement_")
,"parsing","""arrayLiteralElement: aContext
	" Private - Gets the next array element from the receiver. "

	^self constant: aContext """,nil)

smalltalk.bind(smalltalk.ScriptParser,"basicPeek",0
,smalltalk.__f__("""(self):
	#ScriptParser>>#basicPeek
	if smalltalk.b(smalltalk.isObject_equalTo_(getattr(self,"@source",nil).peek(),smalltalk.String('"'))):
		def __blk1__(_s8_rec):
			_s8_rec.next() 
			return _s8_rec.upTo_(smalltalk.String('"')) 
		__blk1__(getattr(self,"@source",nil)) 
	 
	return getattr(self,"@source",nil).peek() 
""","ScriptParser_basicPeek")
,"parsing","""basicPeek
	"Peek the next character from source stream. "

	source peek = $" ifTrue: [ "skip coments"
		source next;upTo: $"
	].
	^source peek""",nil)

smalltalk.bind(smalltalk.ScriptParser,"cascade:to:in:",0
,smalltalk.__f__("""(self,expression,aReceiver,aContext):
	_s8Ret_=smalltalk.newContext()
	try:
		#ScriptParser>>#cascade:to:in:
		__0__=smalltalk.newContext()
		def __blk1__():
			__0__.message=self.message3_repeat_in_(aReceiver,smalltalk.false,aContext) 
			if smalltalk.b(smalltalk.isNil_(__0__.message)):
				smalltalk.raise_result_(_s8Ret_,self.expected_(smalltalk.String("message"))) 
			 
			__0__.cascade.add_(__0__.message) 
			return self.match_(self.semicolon()) 
		__0__.start=nil
		__0__.cascade=nil
		__0__.message=nil
		__0__.start=self.position() 
		__0__.cascade=smalltalk.CascadedMessageNode.for_(expression) 
		while smalltalk.b(smalltalk.blk(__blk1__,0)()):
			pass
		 
		__0__.cascade.sourceRange_(__0__.start.to_(self.position())) 
		smalltalk.raise_result_(_s8Ret_,__0__.cascade) 
	except Exception as __ex:
		if smalltalk.exception_at(__ex,_s8Ret_):
			return smalltalk.exceptionResult_(__ex)
		raise __ex
	
""","ScriptParser_cascade_to_in_")
,"parsing","""cascade: expression to: aReceiver in: aContext
	" Private - Parse the receiver looking for a cascade expression using variables in aContext.
	<rule> cascadeMessage = unaryMessage | binaryMessage | keywordMessage.
	"

	| start cascade message |
	start := self position.
	cascade := CascadedMessageNode for: expression.
	[	message := self message3: aReceiver repeat: false in: aContext.
		message isNil ifTrue: [ ^self expected: #message ].
		cascade add: message.
		self match: self semicolon ] whileTrue: [].
	cascade sourceRange: (start to: self position).
	^cascade""",nil)

smalltalk.bind(smalltalk.ScriptParser,"checkForOldSyntax:with:on:",0
,smalltalk.__f__("""(self,radix,value,aStream):
	_s8Ret_=smalltalk.newContext()
	try:
		#ScriptParser>>#checkForOldSyntax:with:on:
		def __blk1__():
			return aStream.peekFor_(smalltalk.String(".")) 
		def __blk2__():
			return smalltalk.isObject_equalTo_(aStream.peek().asLowercase(),smalltalk.String("e")) 
		if smalltalk.b(smalltalk.boolean_and_(smalltalk.booleanNot_(aStream.atEnd()),smalltalk.blk(__blk1__,0))):
			def __blk3__():
				return aStream.peek().digitValue().between_and_(smalltalk.Number(0),radix._minus(smalltalk.Number(1))) 
			def __blk4__():
				return smalltalk.raise_result_(_s8Ret_,self.syntaxError_(smalltalk.String("Non-radix 10 numbers may not contain decimal points"))) 
			def __blk5__():
				return aStream.skip_(smalltalk.Number(-1)) 
			smalltalk.if_true_false_(smalltalk.boolean_and_(smalltalk.booleanNot_(aStream.atEnd()),smalltalk.blk(__blk3__,0)),smalltalk.blk(__blk4__,0),smalltalk.blk(__blk5__,0)) 
		 
		if smalltalk.b(smalltalk.boolean_and_(smalltalk.booleanNot_(aStream.atEnd()),smalltalk.blk(__blk2__,0))):
			smalltalk.raise_result_(_s8Ret_,self.syntaxError_(smalltalk.String("Non-radix 10 numbers may not have an exponent"))) 
		 
		smalltalk.raise_result_(_s8Ret_,value) 
	except Exception as __ex:
		if smalltalk.exception_at(__ex,_s8Ret_):
			return smalltalk.exceptionResult_(__ex)
		raise __ex
	
""","ScriptParser_checkForOldSyntax_with_on_")
,"parsing","""checkForOldSyntax: radix with: value on: aStream
	" Private - Answer aNumber as described on the stream, aStream. "

	(aStream atEnd not and: [aStream peekFor: $.])
	ifTrue: [
		(aStream atEnd not and: [aStream peek digitValue between: 0 and: radix-1])
		ifTrue: [ ^self syntaxError: 'Non-radix 10 numbers may not contain decimal points' ]
		ifFalse: [ aStream skip: -1 ]
	].
	(aStream atEnd not and: [aStream peek asLowercase = $e])
	ifTrue: [ ^self syntaxError: 'Non-radix 10 numbers may not have an exponent' ].
	^value""",nil)

smalltalk.bind(smalltalk.ScriptParser,"colon",0
,smalltalk.__f__("""(self):
	#ScriptParser>>#colon
	return smalltalk.String(":") 
""","ScriptParser_colon")
,"constants","""colon
	" Private - Returns the colon token. "

	^$:""",nil)

smalltalk.bind(smalltalk.ScriptParser,"nextDashOrNumber",0
,smalltalk.__f__("""(self):
	#ScriptParser>>#nextDashOrNumber
	__0__=smalltalk.newContext()
	def __blk1__():
		return getattr(self,"@source",nil).peek().isDigit() 
	def __blk2__():
		return self.nextNumber().negated() 
	def __blk3__():
		return __0__.result 
	__0__.result=nil
	if not smalltalk.b(smalltalk.isObject_equalTo_(getattr(self,"@source",nil).peek(),smalltalk.String("-"))):
		return self.nextNumber() 
	 
	__0__.result=getattr(self,"@source",nil).next() 
	return smalltalk.if_true_false_(smalltalk.boolean_and_(smalltalk.booleanNot_(getattr(self,"@source",nil).atEnd()),smalltalk.blk(__blk1__,0)),smalltalk.blk(__blk2__,0),smalltalk.blk(__blk3__,0)) 
""","ScriptParser_nextDashOrNumber")
,"parsing","""nextDashOrNumber
	" Private - Returns the next Number or #- "

	| result |
	(source peek = $-) ifFalse: [ ^self nextNumber ].
	result := source next.
	^(source atEnd not and: [source peek isDigit])
		ifTrue: [ self nextNumber negated ]
		ifFalse: [ result ]""",nil)

smalltalk.bind(smalltalk.ScriptParser,"constant:",0
,smalltalk.__f__("""(self,aContext):
	#ScriptParser>>#constant:
	self.skipSeparators() 
	if smalltalk.b(self.match_(smalltalk.String("false"))):
		return smalltalk.false 
	 
	if smalltalk.b(self.match_(smalltalk.String("true"))):
		return smalltalk.true 
	 
	if smalltalk.b(self.match_(smalltalk.String("nil"))):
		return nil 
	 
	if smalltalk.b(self.match_(self.singleQuote())):
		return self.nextString() 
	 
	if smalltalk.b(smalltalk.notNil_(self.peekAny_advance_(smalltalk.String("0123456789-"),smalltalk.false))):
		return self.nextDashOrNumber() 
	 
	if smalltalk.b(self.match_(self.dollar())):
		return self.nextCharacter() 
	 
	if smalltalk.b(self.match_(smalltalk.Array.with_with_(self.literalQuote(),self.leftParenthesis()))):
		return self.nextArray_(aContext) 
	 
	if smalltalk.b(self.match_(self.literalQuote())):
		return self.nextSymbol() 
	 
	if smalltalk.b(self.match_(self.leftParenthesis())):
		return self.nextArray_(aContext) 
	 
	if smalltalk.b(self.match_(self.leftBracket())):
		return self.nextByteArray_(aContext) 
	 
	if smalltalk.b(self.match_(self.leftBrace())):
		return self.nextBraceLiteral_(aContext) 
	 
	return self.nextSymbol() 
""","ScriptParser_constant_")
,"parsing","""constant: aContext
	" Private - Recognize a constant (named, number, character, string, or quoted).
	Returns the constant value. "

	self skipSeparators.
	(self match: #false) ifTrue: [ ^false ].
	(self match: #true) ifTrue: [ ^true ].
	(self match: #nil) ifTrue: [ ^nil ].
	(self match: self singleQuote) ifTrue: [ ^self nextString ].
	(self peekAny: '0123456789-' advance: false) notNil ifTrue: [ ^self nextDashOrNumber ].
	(self match: self dollar) ifTrue: [ ^self nextCharacter ].
	(self match: (Array with: self literalQuote with: self leftParenthesis)) ifTrue: [ ^self nextArray: aContext ].
	(self match: self literalQuote) ifTrue: [ ^self nextSymbol ].
	(self match: self leftParenthesis) ifTrue: [ ^self nextArray: aContext ].
	(self match: self leftBracket) ifTrue: [ ^self nextByteArray: aContext ].
	(self match: self leftBrace) ifTrue: [ ^self nextBraceLiteral: aContext ].
	^self nextSymbol """,nil)

smalltalk.bind(smalltalk.ScriptParser,"dollar",0
,smalltalk.__f__("""(self):
	#ScriptParser>>#dollar
	return smalltalk.String("$") 
""","ScriptParser_dollar")
,"constants","""dollar
	" Private - Returns the dollar token. "

	^$$""",nil)

smalltalk.bind(smalltalk.ScriptParser,"syntaxError:",0
,smalltalk.__f__("""(self,aString):
	#ScriptParser>>#syntaxError:
	__0__=smalltalk.newContext()
	def __blk1__(_s8_rec):
		_s8_rec.source_(getattr(self,"@source",nil).contents()) 
		_s8_rec.position_(self.position()._plus(smalltalk.Number(1))) 
		return _s8_rec.yourself() 
	__0__.syntaxError=nil
	__0__.syntaxError=smalltalk.SyntaxError.description_(aString) 
	__blk1__(__0__.syntaxError) 
	return getattr(self,"@errorBlock",nil).value_(__0__.syntaxError) 
""","ScriptParser_syntaxError_")
,"error","""syntaxError: aString
	" A Syntax error has been occurred at current position in source. "

	| syntaxError |
	syntaxError := SyntaxError description: aString.
	syntaxError
		source: source contents;
		position: self position + 1;
		yourself.
	^errorBlock value: syntaxError""",nil)

smalltalk.bind(smalltalk.ScriptParser,"expected:",0
,smalltalk.__f__("""(self,aString):
	#ScriptParser>>#expected:
	return self.syntaxError_(smalltalk.object_comma_(aString,smalltalk.String(" expected"))) 
""","ScriptParser_expected_")
,"error","""expected: aString
	"An expected element can't be found at current position in source. "

	^self syntaxError: aString ,' expected'""",nil)

smalltalk.bind(smalltalk.ScriptParser,"instanceVariables",0
,smalltalk.__f__("""(self):
	#ScriptParser>>#instanceVariables
	if smalltalk.b(smalltalk.isNil_(getattr(self,"@instanceVariables",nil))):
		self.initializeInstanceVariables() 
	 
	return getattr(self,"@instanceVariables",nil) 
""","ScriptParser_instanceVariables")
,"accessing","""instanceVariables
	" Returns the receiver's instanceVariables. "

	instanceVariables isNil ifTrue: [ self initializeInstanceVariables ].
	^instanceVariables""",nil)

smalltalk.bind(smalltalk.ScriptParser,"instanceVariables:",0
,smalltalk.__f__("""(self,aCollection):
	#ScriptParser>>#instanceVariables:
	smalltalk.basic_at_put(self,"@instanceVariables",aCollection) 
	return self 
""","ScriptParser_instanceVariables_")
,"accessing","""instanceVariables: aCollection
	" Set the receiver's instanceVariables. "

	instanceVariables := aCollection""",nil)

smalltalk.bind(smalltalk.ScriptParser,"leftArrow",0
,smalltalk.__f__("""(self):
	#ScriptParser>>#leftArrow
	return smalltalk.String(":=") 
""","ScriptParser_leftArrow")
,"constants","""leftArrow
	" Private - Returns the leftArrow token. "

	^':='""",nil)

smalltalk.bind(smalltalk.ScriptParser,"period",0
,smalltalk.__f__("""(self):
	#ScriptParser>>#period
	return smalltalk.String(".") 
""","ScriptParser_period")
,"constants","""period
	" Private - Returns the period token. "

	^$.""",nil)

smalltalk.bind(smalltalk.ScriptParser,"leftBrace",0
,smalltalk.__f__("""(self):
	#ScriptParser>>#leftBrace
	return smalltalk.String("{") 
""","ScriptParser_leftBrace")
,"constants","""leftBrace
	" Private - Returns the leftBrace token. "

	^${""",nil)

smalltalk.bind(smalltalk.ScriptParser,"leftBracket",0
,smalltalk.__f__("""(self):
	#ScriptParser>>#leftBracket
	return smalltalk.String("[") 
""","ScriptParser_leftBracket")
,"constants","""leftBracket
	" Private - Returns the leftBracket token. "

	^$[""",nil)

smalltalk.bind(smalltalk.ScriptParser,"leftParenthesis",0
,smalltalk.__f__("""(self):
	#ScriptParser>>#leftParenthesis
	return smalltalk.String("(") 
""","ScriptParser_leftParenthesis")
,"constants","""leftParenthesis
	" Private - Returns the leftParentesis token. "

	^$(""",nil)

smalltalk.bind(smalltalk.ScriptParser,"literalQuote",0
,smalltalk.__f__("""(self):
	#ScriptParser>>#literalQuote
	return smalltalk.String("#") 
""","ScriptParser_literalQuote")
,"constants","""literalQuote
	" Private - Returns the literal quote token. "

	^$#""",nil)

smalltalk.bind(smalltalk.ScriptParser,"primitiveStart",0
,smalltalk.__f__("""(self):
	#ScriptParser>>#primitiveStart
	return smalltalk.String("<") 
""","ScriptParser_primitiveStart")
,"constants","""primitiveStart
	" Private - Returns the start primitive token. "

	^$<""",nil)

smalltalk.bind(smalltalk.ScriptParser,"primitiveEnd",0
,smalltalk.__f__("""(self):
	#ScriptParser>>#primitiveEnd
	return smalltalk.String(">") 
""","ScriptParser_primitiveEnd")
,"constants","""primitiveEnd
	" Private - Returns the end primitive token. "

	^$>""",nil)

smalltalk.bind(smalltalk.ScriptParser,"match:",0
,smalltalk.__f__("""(self,token):
	_s8Ret_=smalltalk.newContext()
	try:
		#ScriptParser>>#match:
		__0__=smalltalk.newContext()
		__0__.position=nil
		if smalltalk.b(self.atEnd()):
			return smalltalk.false 
		 
		__0__.position=self.position() 
		if smalltalk.b(token.isCharacter()):
			def __blk1__():
				self.next() 
				return smalltalk.raise_result_(_s8Ret_,smalltalk.true) 
			smalltalk.if_true_false_(smalltalk.isObject_equalTo_(self.peek(),token),smalltalk.blk(__blk1__,0),nil) 
		else:
			def __blk2__():
				def __blk3__():
					def __blk4__():
						return smalltalk.raise_result_(_s8Ret_,smalltalk.true) 
					return smalltalk.if_true_false_(token.value(),smalltalk.blk(__blk4__,0),nil) 
				def __blk5__():
					def __blk6__():
						return smalltalk.raise_result_(_s8Ret_,smalltalk.true) 
					return smalltalk.if_true_false_(token.value_(self.next()),smalltalk.blk(__blk6__,0),nil) 
				return smalltalk.if_true_false_(smalltalk.isObject_equalTo_(token.argumentCount(),smalltalk.Number(0)),smalltalk.blk(__blk3__,0),smalltalk.blk(__blk5__,0)) 
			def __blk7__():
				def __blk8__(one):
					return smalltalk.booleanNot_(self.match_(one)) 
				def __blk9__():
					return smalltalk.raise_result_(_s8Ret_,smalltalk.true) 
				return token.detect_ifNone_(smalltalk.blk(__blk8__,1),smalltalk.blk(__blk9__,0)) 
			smalltalk.if_true_false_(token.isMemberOf_(smalltalk.BlockClosure),smalltalk.blk(__blk2__,0),smalltalk.blk(__blk7__,0)) 
		 
		self.position_(__0__.position) 
		smalltalk.raise_result_(_s8Ret_,smalltalk.false) 
	except Exception as __ex:
		if smalltalk.exception_at(__ex,_s8Ret_):
			return smalltalk.exceptionResult_(__ex)
		raise __ex
	
""","ScriptParser_match_")
,"parsing","""match: token
	" Try to match token.
	token can be a single token or a collection of tokens.
	Returns true if success and advance the receiver's stream.
	If failed, restore the receiver's position. "

	| position |
	self atEnd ifTrue: [^false].
	position := self position.
	token isCharacter ifTrue: [
		self peek = token
		ifTrue: [ self next.^true ]
	] ifFalse: [
		(token isMemberOf: BlockClosure) ifTrue: [
			token argumentCount = 0
			ifTrue: [ token value ifTrue: [ ^true ] ]
			ifFalse: [ (token value: self next) ifTrue: [ ^true ] ]
		] ifFalse: [
			token
				detect: [:one| (self match: one) not ]
				ifNone: [ ^true ].
		].
	].
	self position: position.
	^false""",nil)

smalltalk.bind(smalltalk.ScriptParser,"message1:repeat:in:",0
,smalltalk.__f__("""(self,aNode,repeat,aContext):
	_s8Ret_=smalltalk.newContext()
	try:
		#ScriptParser>>#message1:repeat:in:
		__0__=smalltalk.newContext()
		def __blk1__():
			__0__.start=self.startOfNextToken() 
			__0__.selector=self.nextSelectorOrNil() 
			if smalltalk.b(smalltalk.isNil_(__0__.selector)):
				smalltalk.raise_result_(_s8Ret_,__0__.aReceiver) 
			 
			if smalltalk.b(self.isUnarySelector_(__0__.selector)):
				__0__.params=smalltalk.newArray([]) 
			else:
				if smalltalk.b(__0__.aReceiver.isSuper()):
					smalltalk.raise_result_(_s8Ret_,self.expected_(smalltalk.String("message"))) 
				 
				self.position_(__0__.start) 
				smalltalk.raise_result_(_s8Ret_,__0__.aReceiver) 
			 
			if smalltalk.b(smalltalk.isNil_(__0__.aReceiver)):
				smalltalk.raise_result_(_s8Ret_,self.expected_(smalltalk.String("Receiver or name"))) 
			 
			__0__.aReceiver=smalltalk.MessageNode.from_to_(__0__.start,self.position()).receiver_selector_arguments_(__0__.aReceiver,self.newSelectorName_(__0__.selector),__0__.params) 
			return repeat 
		__0__.aReceiver=nil
		__0__.start=nil
		__0__.selector=nil
		__0__.params=nil
		__0__.argument=nil
		__0__.part=nil
		__0__.partStart=nil
		__0__.aReceiver=aNode 
		while smalltalk.b(smalltalk.blk(__blk1__,0)()):
			pass
		 
		smalltalk.raise_result_(_s8Ret_,__0__.aReceiver) 
	except Exception as __ex:
		if smalltalk.exception_at(__ex,_s8Ret_):
			return smalltalk.exceptionResult_(__ex)
		raise __ex
	
""","ScriptParser_message1_repeat_in_")
,"parsing","""message1: aNode repeat: repeat in: aContext
	" Private - Parse the receiver looking for a message expression using variables in aContext.
	<rule> messageExpression = unaryExpression | binaryExpression | keywordExpression.
	<rule> unaryExpression = primaryMessage {unaryMessage}.
	<rule> binaryExpression = (unaryExpression | primary) binaryMessage {binaryMessage}.
	<rule> keywordExpression = (binaryExpression | primary) keywordMessage.
	"

	| aReceiver start selector params argument part partStart |
	aReceiver := aNode.
	[
		start := self startOfNextToken.
		selector := self nextSelectorOrNil.
		selector isNil ifTrue: [ ^aReceiver ].
		(self isUnarySelector: selector) "simple message"
		ifTrue: [ params := #() ]
		ifFalse: [
			aReceiver isSuper ifTrue: [ ^self expected: #message ].
			self position: start.
			^aReceiver
		].
		aReceiver isNil ifTrue: [ ^self expected: 'Receiver or name' ].
		aReceiver := (MessageNode from: start to: self position)
			receiver: aReceiver
			selector: (self newSelectorName: selector)
			arguments: params.
	repeat ] whileTrue: [].
	^aReceiver""",nil)

smalltalk.bind(smalltalk.ScriptParser,"message2:repeat:in:",0
,smalltalk.__f__("""(self,aNode,repeat,aContext):
	_s8Ret_=smalltalk.newContext()
	try:
		#ScriptParser>>#message2:repeat:in:
		__0__=smalltalk.newContext()
		def __blk1__():
			def __blk2__():
				return self.isBinarySelector_(__0__.selector) 
			__0__.start=self.startOfNextToken() 
			__0__.selector=self.nextSelectorOrNil() 
			if smalltalk.b(smalltalk.isNil_(__0__.selector)):
				smalltalk.raise_result_(_s8Ret_,__0__.aReceiver) 
			 
			if smalltalk.b(smalltalk.boolean_or_(smalltalk.isObject_equalTo_(__0__.selector,smalltalk.String("|")),smalltalk.blk(__blk2__,0))):
				__0__.argument=self.primaryExpression_(aContext) 
				if smalltalk.b(smalltalk.isNil_(__0__.argument)):
					smalltalk.raise_result_(_s8Ret_,self.expected_(smalltalk.String("argument"))) 
				 
				__0__.argument=self.message1_repeat_in_(__0__.argument,smalltalk.true,aContext) 
				if smalltalk.b(smalltalk.isNil_(__0__.argument)):
					smalltalk.raise_result_(_s8Ret_,self.expected_(smalltalk.String("argument"))) 
				 
				__0__.params=smalltalk.Array.with_(__0__.argument) 
			else:
				def __blk3__():
					__0__.params=smalltalk.newArray([])
					return __0__.params 
				def __blk4__():
					if smalltalk.b(__0__.aReceiver.isSuper()):
						smalltalk.raise_result_(_s8Ret_,self.expected_(smalltalk.String("message"))) 
					 
					self.position_(__0__.start) 
					return smalltalk.raise_result_(_s8Ret_,__0__.aReceiver) 
				smalltalk.if_true_false_(self.isUnarySelector_(__0__.selector),smalltalk.blk(__blk3__,0),smalltalk.blk(__blk4__,0)) 
			 
			if smalltalk.b(smalltalk.isNil_(__0__.aReceiver)):
				smalltalk.raise_result_(_s8Ret_,self.syntaxError_(smalltalk.String("Invalid receiver or invalid name"))) 
			 
			__0__.aReceiver=smalltalk.MessageNode.from_to_(__0__.start,self.position()).receiver_selector_arguments_(__0__.aReceiver,self.newSelectorName_(__0__.selector),__0__.params) 
			return repeat 
		__0__.aReceiver=nil
		__0__.start=nil
		__0__.selector=nil
		__0__.params=nil
		__0__.argument=nil
		__0__.part=nil
		__0__.partStart=nil
		__0__.aReceiver=aNode 
		while smalltalk.b(smalltalk.blk(__blk1__,0)()):
			pass
		 
		smalltalk.raise_result_(_s8Ret_,__0__.aReceiver) 
	except Exception as __ex:
		if smalltalk.exception_at(__ex,_s8Ret_):
			return smalltalk.exceptionResult_(__ex)
		raise __ex
	
""","ScriptParser_message2_repeat_in_")
,"parsing","""message2: aNode repeat: repeat in: aContext
	" Private - Parse the receiver looking for a message expression using variables in aContext.
	<rule> messageExpression = unaryExpression | binaryExpression | keywordExpression.
	<rule> unaryExpression = primaryMessage {unaryMessage}.
	<rule> binaryExpression = (unaryExpression | primary) binaryMessage {binaryMessage}.
	<rule> keywordExpression = (binaryExpression | primary) keywordMessage.
	"

	| aReceiver start selector params argument part partStart |
	aReceiver := aNode.
	[
		start := self startOfNextToken.
		selector := self nextSelectorOrNil.
		selector isNil ifTrue: [ ^aReceiver ].
		(selector = #| or: [self isBinarySelector: selector]) "level>=2"
		ifTrue: [
			argument := self primaryExpression: aContext.
			argument isNil ifTrue: [ ^self expected: #argument ].
			argument := self message1: argument repeat: true in: aContext.
			argument isNil ifTrue: [ ^self expected: #argument ].
			params := Array with: argument.
		]
		ifFalse: [
			(self isUnarySelector: selector) "simple message"
			ifTrue: [ params := #() ]
			ifFalse: [
				aReceiver isSuper ifTrue: [ ^self expected: #message ].
				self position: start.
				^aReceiver
			]
		].
		aReceiver isNil ifTrue: [ ^self syntaxError: 'Invalid receiver or invalid name' ].
		aReceiver := (MessageNode from: start to: self position)
			receiver: aReceiver
			selector: (self newSelectorName: selector)
			arguments: params.
	repeat ] whileTrue: [].
	^aReceiver""",nil)

smalltalk.bind(smalltalk.ScriptParser,"message3:repeat:in:",0
,smalltalk.__f__("""(self,aNode,repeat,aContext):
	_s8Ret_=smalltalk.newContext()
	try:
		#ScriptParser>>#message3:repeat:in:
		__0__=smalltalk.newContext()
		def __blk1__():
			__0__.start=self.startOfNextToken() 
			__0__.isNative=self.match_(self.literalQuote()) 
			__0__.selector=self.nextSelectorOrNil() 
			if smalltalk.b(smalltalk.isNil_(__0__.selector)):
				smalltalk.raise_result_(_s8Ret_,__0__.aReceiver) 
			 
			if smalltalk.b(self.isKeywordSelector_(__0__.selector)):
				def __blk2__():
					def __blk3__():
						return self.isKeywordSelector_(__0__.part) 
					__0__.partStart=self.startOfNextToken() 
					__0__.part=self.nextSelectorOrNil() 
					return smalltalk.boolean_and_(smalltalk.notNil_(__0__.part),smalltalk.blk(__blk3__,0)) 
				__0__.argument=self.primaryExpression_(aContext) 
				if smalltalk.b(smalltalk.isNil_(__0__.argument)):
					smalltalk.raise_result_(_s8Ret_,self.expected_(smalltalk.String("argument"))) 
				 
				__0__.argument=self.message2_repeat_in_(__0__.argument,smalltalk.true,aContext) 
				if smalltalk.b(smalltalk.isNil_(__0__.argument)):
					smalltalk.raise_result_(_s8Ret_,self.expected_(smalltalk.String("argument"))) 
				 
				__0__.params=smalltalk.Array.with_(__0__.argument) 
				while smalltalk.b(smalltalk.blk(__blk2__,0)()):
					__0__.selector=smalltalk.object_comma_(__0__.selector,__0__.part) 
					__0__.argument=self.primaryExpression_(aContext) 
					if smalltalk.b(smalltalk.isNil_(__0__.argument)):
						smalltalk.raise_result_(_s8Ret_,self.expected_(smalltalk.String("argument"))) 
					 
					__0__.argument=self.message2_repeat_in_(__0__.argument,smalltalk.true,aContext) 
					if smalltalk.b(smalltalk.isNil_(__0__.argument)):
						smalltalk.raise_result_(_s8Ret_,self.expected_(smalltalk.String("argument"))) 
					 
					__0__.params=__0__.params.copyWith_(__0__.argument) 
				 
				self.position_(__0__.partStart) 
			else:
				def __blk4__():
					return self.isBinarySelector_(__0__.selector) 
				def __blk5__():
					__0__.argument=self.primaryExpression_(aContext) 
					if smalltalk.b(smalltalk.isNil_(__0__.argument)):
						smalltalk.raise_result_(_s8Ret_,self.expected_(smalltalk.String("argument"))) 
					 
					__0__.argument=self.message1_repeat_in_(__0__.argument,smalltalk.true,aContext) 
					if smalltalk.b(smalltalk.isNil_(__0__.argument)):
						smalltalk.raise_result_(_s8Ret_,self.expected_(smalltalk.String("argument"))) 
					 
					__0__.params=smalltalk.Array.with_(__0__.argument)
					return __0__.params 
				def __blk6__():
					def __blk7__():
						__0__.params=smalltalk.newArray([])
						return __0__.params 
					def __blk8__():
						if smalltalk.b(__0__.aReceiver.isSuper()):
							smalltalk.raise_result_(_s8Ret_,self.expected_(smalltalk.String("message"))) 
						 
						self.position_(__0__.start) 
						return smalltalk.raise_result_(_s8Ret_,__0__.aReceiver) 
					return smalltalk.if_true_false_(self.isUnarySelector_(__0__.selector),smalltalk.blk(__blk7__,0),smalltalk.blk(__blk8__,0)) 
				smalltalk.if_true_false_(smalltalk.boolean_or_(smalltalk.isObject_equalTo_(__0__.selector,smalltalk.String("|")),smalltalk.blk(__blk4__,0)),smalltalk.blk(__blk5__,0),smalltalk.blk(__blk6__,0)) 
			 
			if smalltalk.b(smalltalk.isNil_(__0__.aReceiver)):
				smalltalk.raise_result_(_s8Ret_,self.syntaxError_(smalltalk.String("Invalid receiver or invalid name"))) 
			 
			__0__.aReceiver=smalltalk.MessageNode.native_from_to_(__0__.isNative,__0__.start,self.position()).receiver_selector_arguments_(__0__.aReceiver,self.newSelectorName_(__0__.selector),__0__.params) 
			return repeat 
		__0__.aReceiver=nil
		__0__.start=nil
		__0__.selector=nil
		__0__.params=nil
		__0__.argument=nil
		__0__.part=nil
		__0__.partStart=nil
		__0__.isNative=nil
		__0__.aReceiver=aNode 
		while smalltalk.b(smalltalk.blk(__blk1__,0)()):
			pass
		 
		smalltalk.raise_result_(_s8Ret_,__0__.aReceiver) 
	except Exception as __ex:
		if smalltalk.exception_at(__ex,_s8Ret_):
			return smalltalk.exceptionResult_(__ex)
		raise __ex
	
""","ScriptParser_message3_repeat_in_")
,"parsing","""message3: aNode repeat: repeat in: aContext
	" Private - Parse the receiver looking for a message expression using variables in aContext.
	<rule> messageExpression = unaryExpression | binaryExpression | keywordExpression.
	<rule> unaryExpression = primaryMessage {unaryMessage}.
	<rule> binaryExpression = (unaryExpression | primary) binaryMessage {binaryMessage}.
	<rule> keywordExpression = (binaryExpression | primary) keywordMessage.
	"

	| aReceiver start selector params argument part partStart isNative |
	aReceiver := aNode.
	[	start := self startOfNextToken.
		isNative := self match: self literalQuote.
		selector := self nextSelectorOrNil.
		selector isNil ifTrue: [ ^aReceiver ].
		(self isKeywordSelector: selector) "level>=3" ifTrue: [
			argument := self primaryExpression: aContext.
			argument isNil ifTrue: [ ^self expected: #argument ].
			argument := self message2: argument repeat: true in: aContext.
			argument isNil ifTrue: [ ^self expected: #argument ].
			params := Array with: argument.
			[ partStart := self startOfNextToken.
			part := self nextSelectorOrNil.
			part notNil and: [ self isKeywordSelector: part ]
			] whileTrue: [
				selector := selector , part.
				argument := self primaryExpression: aContext.
				argument isNil ifTrue: [ ^self expected: #argument ].
				argument := self message2: argument repeat: true in: aContext.
				argument isNil ifTrue: [ ^self expected: #argument ].
				params := params copyWith: argument.
			].
			self position: partStart.
		] ifFalse: [
			(selector = #| or: [self isBinarySelector: selector]) "level>=2" ifTrue: [
				argument := self primaryExpression: aContext.
				argument isNil ifTrue: [ ^self expected: #argument ].
				argument := self message1: argument repeat: true in: aContext.
				argument isNil ifTrue: [ ^self expected: #argument ].
				params := Array with: argument.
			] ifFalse: [
				(self isUnarySelector: selector) "simple message"
				ifTrue: [ params := #() ]
				ifFalse: [
					aReceiver isSuper ifTrue: [ ^self expected: #message ].
					self position: start.
					^aReceiver
				]
			]
		].
		aReceiver isNil ifTrue: [ ^self syntaxError: 'Invalid receiver or invalid name' ].
		aReceiver := (MessageNode native: isNative from: start to: self position)
			receiver: aReceiver
			selector: (self newSelectorName: selector)
			arguments: params.
	repeat ] whileTrue: [].
	^aReceiver""",nil)

smalltalk.bind(smalltalk.ScriptParser,"bodyScope:",0
,smalltalk.__f__("""(self,statements):
	#ScriptParser>>#bodyScope:
	__0__=smalltalk.newContext()
	__0__.result=nil
	if not smalltalk.b(self.match_(self.verticalBar())):
		return self.scope() 
	 
	__0__.result=smalltalk.ParseContext.in_(self.scope()) 
	statements.temporaries_(self.parseTemporaries_(__0__.result)) 
	return __0__.result 
""","ScriptParser_bodyScope_")
,"parsing","""bodyScope: statements
	" Private - Returns a context for body of script.
	<rule> script = [ | temporaries ] statements.
	"

	| result |
	(self match: self verticalBar) ifFalse: [ ^self scope ].
	result := ParseContext in: self scope.
	statements temporaries: (self parseTemporaries: result).
	^result """,nil)

smalltalk.bind(smalltalk.ScriptParser,"mustHaveA:",0
,smalltalk.__f__("""(self,aCharacter):
	#ScriptParser>>#mustHaveA:
	if not smalltalk.b(smalltalk.isObject_equalTo_(self.peek(),aCharacter)):
		return self.syntaxError_(smalltalk.object_comma_(smalltalk.printString_(aCharacter),smalltalk.String(" expected."))) 
	 
	if not smalltalk.b(self.atEnd()):
		self.next() 
	 
	return self 
""","ScriptParser_mustHaveA_")
,"parsing","""mustHaveA: aCharacter
	" Private - Check that the next character is aCharacter.
	Read the character if success. Generates a syntax error in absent. "

	self peek = aCharacter ifFalse: [
		^self syntaxError: aCharacter printString,' expected.'
	].
	self atEnd ifFalse: [ self next ]""",nil)

smalltalk.bind(smalltalk.ScriptParser,"newSelectorName:",0
,smalltalk.__f__("""(self,aSelectorName):
	#ScriptParser>>#newSelectorName:
	return aSelectorName.asSymbol() 
""","ScriptParser_newSelectorName_")
,"parsing","""newSelectorName: aSelectorName
	" Private - Build a new message name from aSelectorName. "

	^aSelectorName asSymbol """,nil)

smalltalk.bind(smalltalk.ScriptParser,"next",0
,smalltalk.__f__("""(self):
	#ScriptParser>>#next
	self.skipSeparators() 
	return getattr(self,"@source",nil).next() 
""","ScriptParser_next")
,"parsing","""next
	"Advance to the next character onto source stream. "

	self skipSeparators.
	^source next""",nil)

smalltalk.bind(smalltalk.ScriptParser,"nextArgument:",0
,smalltalk.__f__("""(self,aContext):
	#ScriptParser>>#nextArgument:
	__0__=smalltalk.newContext()
	def __blk1__(_s8_rec):
		_s8_rec.binding_(__0__.assoc) 
		return _s8_rec.yourself() 
	__0__.start=nil
	__0__.word=nil
	__0__.assoc=nil
	__0__.start=self.startOfNextToken() 
	__0__.word=self.nextWord() 
	if smalltalk.b(smalltalk.isNil_(__0__.word)):
		return nil 
	 
	aContext.at_put_(__0__.word,nil) 
	__0__.assoc=aContext.bindingAt_(__0__.word) 
	return __blk1__(smalltalk.ParseArgument.from_to_(__0__.start,self.position())) 
""","ScriptParser_nextArgument_")
,"parsing","""nextArgument: aContext
	" Private - Parse the receiver looking for a new argument using variables in aContext.
	Returns nil if failed. "

	| start word assoc |
	start := self startOfNextToken.
	word := self nextWord.
	word isNil ifTrue: [ ^nil ].
	aContext at: word put: nil.
	assoc := aContext bindingAt: word.
	^(ParseArgument
		from: start to: self position)
		binding: assoc;
		yourself""",nil)

smalltalk.bind(smalltalk.ScriptParser,"nextArray:",0
,smalltalk.__f__("""(self,aContext):
	#ScriptParser>>#nextArray:
	__0__=smalltalk.newContext()
	def __blk1__():
		return self.match_(self.rightParenthesis()) 
	__0__.stream=nil
	__0__.stream=smalltalk.Array.new().writeStream() 
	while not smalltalk.b(smalltalk.blk(__blk1__,0)()):
		__0__.stream.nextPut_(self.arrayLiteralElement_(aContext)) 
	 
	return __0__.stream.contents() 
""","ScriptParser_nextArray_")
,"parsing","""nextArray: aContext
	" Private - Parse the receiver looking for an Array using variables in aContext.
	Returns anArray or generates an error if failed.
	<rule> array = '(' {number | string | symbol | array | characterConstant} ')'.
	"

	| stream |
	stream := Array new writeStream.
	[ self match: self rightParenthesis ] whileFalse: [
		stream nextPut: (self arrayLiteralElement: aContext)
	].
	^stream contents""",nil)

smalltalk.bind(smalltalk.ScriptParser,"nextArrayConstant:",0
,smalltalk.__f__("""(self,aContext):
	#ScriptParser>>#nextArrayConstant:
	__0__=smalltalk.newContext()
	__0__.start=nil
	__0__.value=nil
	__0__.start=self.startOfNextToken() 
	if not smalltalk.b(self.match_(smalltalk.Array.with_with_(self.literalQuote(),self.leftParenthesis()))):
		return nil 
	 
	__0__.value=self.nextArray_(aContext) 
	if smalltalk.b(smalltalk.isNil_(__0__.value)):
		self.position_(__0__.start) 
		return nil 
	 
	return smalltalk.ParseLiteral.from_to_copy_(__0__.start,self.position(),__0__.value) 
""","ScriptParser_nextArrayConstant_")
,"parsing","""nextArrayConstant: aContext
	" Private - Parse the receiver looking for an Array using variables in aContext.
	Returns nil if failed.
	<rule> arrayConstant = '#' array.
	<rule> array = '(' {number | string | symbol | array | characterConstant} ')'.
	"

	| start value |
	start := self startOfNextToken.
	(self match: (Array with: self literalQuote with: self leftParenthesis)) ifFalse: [ ^nil ].
	value := self nextArray: aContext.
	value isNil ifTrue: [ self position: start. ^nil ].
	^ParseLiteral
		from: start to: self position
		copy: value """,nil)

smalltalk.bind(smalltalk.ScriptParser,"nextBlock:",0
,smalltalk.__f__("""(self,aContext):
	#ScriptParser>>#nextBlock:
	__0__=smalltalk.newContext()
	def __blk1__():
		return self.match_(self.colon()) 
	__0__.start=nil
	__0__.args=nil
	__0__.block=nil
	__0__.peek=nil
	__0__.start=self.position()._minus(smalltalk.Number(1)) 
	__0__.args=smalltalk.newArray([]) 
	while smalltalk.b(smalltalk.blk(__blk1__,0)()):
		__1__=smalltalk.newContext()
		__1__.arg=nil
		__1__.arg=self.nextArgument_(aContext) 
		if smalltalk.b(smalltalk.isNil_(__1__.arg)):
			return self.expected_(smalltalk.String("argument")) 
		 
		__0__.args.add_(__1__.arg) 
	 
	if smalltalk.b(__0__.args.size()._gt(smalltalk.Number(0))):
		def __blk2__():
			return smalltalk.isObject_equalTo_(__0__.peek,self.verticalBar()) 
		def __blk3__():
			return self.skip_(self.verticalBar()) 
		__0__.peek=self.peek() 
		if not smalltalk.b(smalltalk.boolean_or_(smalltalk.isObject_equalTo_(__0__.peek,self.rightBracket()),smalltalk.blk(__blk2__,0))):
			return self.expected_(self.verticalBar()) 
		 
		smalltalk.if_true_false_(smalltalk.isObject_equalTo_(__0__.peek,self.verticalBar()),smalltalk.blk(__blk3__,0),nil) 
	 
	__0__.block=self.statementsArgs_in_(__0__.args,aContext) 
	if not smalltalk.b(self.match_(self.rightBracket())):
		return self.expected_(smalltalk.String("Period or right bracket")) 
	 
	__0__.block.sourcePosition_(__0__.start.to_(self.position())) 
	return __0__.block 
""","ScriptParser_nextBlock_")
,"parsing","""nextBlock: aContext
	" Private - Parse the receiver looking for a block using variables in aContext.
	Returns nil if failed.
	<node> $[ ($: arg)* temporaries statements $] => BlockClosureNode
	"

	| start args block peek |
	start := self position - 1.
	args := #().
	[ self match: self colon ] whileTrue: [ | arg |
		arg := self nextArgument: aContext.
		arg isNil ifTrue: [ ^self expected: #argument ].
		args add: arg.
	].
	args size > 0 ifTrue: [
		peek := self peek.
		(peek = self rightBracket or: [ peek = self verticalBar ])
		ifFalse: [ ^self expected: self verticalBar ].
		peek = self verticalBar ifTrue: [ self skip: self verticalBar ].
	].
	block := self statementsArgs: args in: aContext.
	(self match: self rightBracket) ifFalse: [
		^self expected: 'Period or right bracket'
	].
	block sourcePosition: (start to: self position).
	^block""",nil)

smalltalk.bind(smalltalk.ScriptParser,"nextPrimitive:",0
,smalltalk.__f__("""(self,aContext):
	#ScriptParser>>#nextPrimitive:
	__0__=smalltalk.newContext()
	__0__.start=nil
	__0__.result=nil
	__0__.start=self.position()._minus(smalltalk.Number(1)) 
	self.skipSeparators() 
	__0__.result=(self).__class__.parsePrimitive_in_(self,aContext) 
	if smalltalk.b(smalltalk.isNil_(__0__.result)):
		return nil 
	 
	if not smalltalk.b(self.match_(self.primitiveEnd())):
		return self.expected_(smalltalk.String("End of primitive")) 
	 
	__0__.result.sourcePosition_(__0__.start.to_(self.position())) 
	return __0__.result 
""","ScriptParser_nextPrimitive_")
,"parsing","""nextPrimitive: aContext
	" Private - Parse the receiver looking for primitive in aContext.
	Returns nil if failed.
	<node> $< ...prim... $> => PrimitiveNode
	"

	| start result |
	start := self position - 1.
	self skipSeparators.
	result := self class parsePrimitive: self in: aContext.
	result isNil ifTrue: [ ^nil ].
	(self match: self primitiveEnd) ifFalse: [
		^self expected: 'End of primitive'
	].
	result sourcePosition: (start to: self position).
	^result""",nil)

smalltalk.bind(smalltalk.ScriptParser,"nextBraceLiteral:",0
,smalltalk.__f__("""(self,aContext):
	#ScriptParser>>#nextBraceLiteral:
	return self.notImplementedYet_(smalltalk.String("nextBraceLiteral:")) 
""","ScriptParser_nextBraceLiteral_")
,"parsing","""nextBraceLiteral: aContext
	" Private - Parse the receiver looking for a brace literal in aContext.
	Returns the literal or generates an error if failed.
	"

	^self notImplementedYet: #nextBraceLiteral: """,nil)

smalltalk.bind(smalltalk.ScriptParser,"nextInline:",0
,smalltalk.__f__("""(self,aContext):
	#ScriptParser>>#nextInline:
	__0__=smalltalk.newContext()
	def __blk1__():
		return smalltalk.Array.with_with_with_(__0__.lang,__0__.codeStart,__0__.code.binding().source()) 
	__0__.start=nil
	__0__.lang=nil
	__0__.code=nil
	__0__.codeStart=nil
	__0__.start=self.startOfNextToken() 
	__0__.lang=self.nextSelectorOrNil() 
	__0__.codeStart=self.startOfNextToken() 
	__0__.code=self.nextStringConstant_(aContext) 
	return smalltalk.if_true_false_(smalltalk.notNil_(__0__.code),smalltalk.blk(__blk1__,0),nil) 
""","ScriptParser_nextInline_")
,"inlines","""nextInline: aContext
	" Private - Returns the next inline in the receiver's stream (or nil). "

	| start lang code codeStart |
	start := self startOfNextToken.
	lang := self nextSelectorOrNil.
	codeStart := self startOfNextToken.
	code := self nextStringConstant: aContext.
	^code notNil ifTrue: [
		Array	with: lang with: codeStart
			with: code binding source
	] """,nil)

smalltalk.bind(smalltalk.ScriptParser,"inlineStatements:in:",0
,smalltalk.__f__("""(self,pool,aContext):
	_s8Ret_=smalltalk.newContext()
	try:
		#ScriptParser>>#inlineStatements:in:
		__0__=smalltalk.newContext()
		def __blk1__():
			def __blk2__():
				return smalltalk.raise_result_(_s8Ret_,nil) 
			return pool.at_ifAbsent_(smalltalk.object_comma_(smalltalk.object_comma_(smalltalk.String("s8"),smalltalk.String("_")),self.nativeLanguage()),smalltalk.blk(__blk2__,0)) 
		__0__.inline=nil
		__0__.inline=pool.at_ifAbsent_(smalltalk.String("s8"),smalltalk.blk(__blk1__,0)) 
		smalltalk.raise_result_(_s8Ret_,self.inlineStatements_startingAt_in_(__0__.inline.last(),__0__.inline.first()._plus(smalltalk.Number(1)),aContext)) 
	except Exception as __ex:
		if smalltalk.exception_at(__ex,_s8Ret_):
			return smalltalk.exceptionResult_(__ex)
		raise __ex
	
""","ScriptParser_inlineStatements_in_")
,"inlines","""inlineStatements: pool in: aContext
	" Private - Returns a statements sequence parsed from pool (or nil). "

	| inline |
	inline := pool at: #s8 ifAbsent: [
		pool at: #s8 ,$_ ,self nativeLanguage ifAbsent: [ ^nil ]
	].
	^self	inlineStatements: inline last
		startingAt: inline first + 1
		in: aContext""",nil)

smalltalk.bind(smalltalk.ScriptParser,"inlineStatements:startingAt:in:",0
,smalltalk.__f__("""(self,code,start,aContext):
	#ScriptParser>>#inlineStatements:startingAt:in:
	__0__=smalltalk.newContext()
	def __blk1__():
		smalltalk.basic_at_put(self,"@source",smalltalk.object_comma_(smalltalk.object_comma_(getattr(self,"@source",nil).contents().copyFrom_to_(smalltalk.Number(1),start),code),smalltalk.String("]")).readStream()) 
		getattr(self,"@source",nil).position_(start) 
		__0__.result=smalltalk.MessageNode.from_to_(start,self.position()).receiver_selector_arguments_(self.statementsArgs_in_(smalltalk.newArray([]),aContext),smalltalk.String("value"),smalltalk.newArray([]))
		return __0__.result 
	def __blk2__():
		smalltalk.basic_at_put(self,"@source",__0__.src)
		return getattr(self,"@source",nil) 
	__0__.src=nil
	__0__.result=nil
	__0__.src=getattr(self,"@source",nil) 
	smalltalk.blk(__blk1__,0).ensure_(smalltalk.blk(__blk2__,0)) 
	return __0__.result 
""","ScriptParser_inlineStatements_startingAt_in_")
,"inlines","""inlineStatements: code startingAt: start in: aContext
	" Private - Returns a statements sequence parsed on code (or nil). "

	| src result |
	src := source.
	[	source := ((source contents copyFrom: 1 to: start), code ,$]) readStream.
		source position: start.
		result := (MessageNode from: start to: self position)
			receiver: (self statementsArgs: #() in: aContext)
			selector: #value arguments: #()
	] ensure: [ source := src ].
	^result""",nil)

smalltalk.bind(smalltalk.ScriptParser,"nextBraceExpression:",0
,smalltalk.__f__("""(self,aContext):
	#ScriptParser>>#nextBraceExpression:
	__0__=smalltalk.newContext()
	def __blk1__():
		return self.match_(self.rightBrace()) 
	__0__.start=nil
	__0__.pool=nil
	__0__.block=nil
	__0__.start=self.position() 
	__0__.pool=smalltalk.PoolDictionary.new() 
	while not smalltalk.b(smalltalk.blk(__blk1__,0)()):
		__1__=smalltalk.newContext()
		def __blk2__():
			return __0__.pool.at_put_(__1__.inline.removeFirst(),__1__.inline) 
		__1__.inline=nil
		__1__.inline=self.nextInline_(aContext) 
		smalltalk.if_true_false_(smalltalk.notNil_(__1__.inline),smalltalk.blk(__blk2__,0),nil) 
	 
	if smalltalk.b(__0__.pool.isEmpty()):
		self.position_(__0__.start) 
		return self.expected_(smalltalk.String("Inline code")) 
	 
	__0__.block=self.inlineStatements_in_(__0__.pool,aContext) 
	if smalltalk.b(smalltalk.isNil_(__0__.block)):
		self.position_(__0__.start) 
		return self.expected_(smalltalk.String("Code for s8 language")) 
	 
	__0__.block.sourcePosition_(__0__.start._minus(smalltalk.Number(1)).to_(self.position())) 
	return __0__.block 
""","ScriptParser_nextBraceExpression_")
,"parsing","""nextBraceExpression: aContext
	" Private - Parse the receiver looking for a brace expression in aContext.
	Returns nil if failed.
	<node> ${ ({lang} string)* $} => statements
	"

	| start pool block |
	start := self position.
	pool := PoolDictionary new.
	[ self match: self rightBrace ] whileFalse: [ | inline |
		inline := self nextInline: aContext.
		inline notNil ifTrue: [
			pool at: inline removeFirst put: inline
		].
	].
	pool isEmpty ifTrue: [
		self position: start.
		^self expected: 'Inline code'
	].
	block := self inlineStatements: pool in: aContext.
	block isNil ifTrue: [
		self position: start.
		^self expected: 'Code for s8 language'
	].
	block sourcePosition: (start - 1 to: self position).
	^block""",nil)

smalltalk.bind(smalltalk.ScriptParser,"nextByteArray:",0
,smalltalk.__f__("""(self,aContext):
	#ScriptParser>>#nextByteArray:
	return self.notImplementedYet_(smalltalk.String("nextByteArray:")) 
""","ScriptParser_nextByteArray_")
,"parsing","""nextByteArray: aContext
	" Private - Parse the receiver looking for aByteArray using variables in aContext.
	Returns aByteArray or generates an error if failed.
	"

	^self notImplementedYet: #nextByteArray: """,nil)

smalltalk.bind(smalltalk.ScriptParser,"nextCharacter",0
,smalltalk.__f__("""(self):
	#ScriptParser>>#nextCharacter
	def __blk1__():
		return smalltalk.String(" ") 
	def __blk2__():
		return getattr(self,"@source",nil).next() 
	return smalltalk.if_true_false_(getattr(self,"@source",nil).atEnd(),smalltalk.blk(__blk1__,0),smalltalk.blk(__blk2__,0)) 
""","ScriptParser_nextCharacter")
,"parsing","""nextCharacter
	" Private - Read aCharacter from the receiver. "

	^source atEnd ifTrue: [ $  ] ifFalse: [ source next ]""",nil)

smalltalk.bind(smalltalk.ScriptParser,"nextCharacterConstant:",0
,smalltalk.__f__("""(self,aContext):
	#ScriptParser>>#nextCharacterConstant:
	__0__=smalltalk.newContext()
	__0__.start=nil
	__0__.start=self.startOfNextToken() 
	if not smalltalk.b(self.match_(self.dollar())):
		return nil 
	 
	return smalltalk.ParseLiteral.from_to_value_(__0__.start,self.position(),self.nextCharacter()) 
""","ScriptParser_nextCharacterConstant_")
,"parsing","""nextCharacterConstant: aContext
	" Private - Parse the receiver looking for aCharacter using variables in aContext.
	Returns nil if failed. "

	| start |
	start := self startOfNextToken.
	(self match: self dollar) ifFalse: [ ^nil ].
	^ParseLiteral
		from: start to: self position
		value: self nextCharacter """,nil)

smalltalk.bind(smalltalk.ScriptParser,"nextLiteral:",0
,smalltalk.__f__("""(self,aContext):
	#ScriptParser>>#nextLiteral:
	__0__=smalltalk.newContext()
	__0__.node=nil
	__0__.node=self.nextNumberConstant_(aContext) 
	if smalltalk.b(smalltalk.notNil_(__0__.node)):
		return __0__.node 
	 
	__0__.node=self.nextStringConstant_(aContext) 
	if smalltalk.b(smalltalk.notNil_(__0__.node)):
		return __0__.node 
	 
	__0__.node=self.nextCharacterConstant_(aContext) 
	if smalltalk.b(smalltalk.notNil_(__0__.node)):
		return __0__.node 
	 
	__0__.node=self.nextArrayConstant_(aContext) 
	if smalltalk.b(smalltalk.notNil_(__0__.node)):
		return __0__.node 
	 
	__0__.node=self.nextSymbolConstant_(aContext) 
	if smalltalk.b(smalltalk.notNil_(__0__.node)):
		return __0__.node 
	 
	return nil 
""","ScriptParser_nextLiteral_")
,"parsing","""nextLiteral: aContext
	" Private - Parse the receiver looking for a literal using variables in aContext.
	Returns nil if failed.
	<rule> literal = number | string | characterConstant | symbolConstant | arrayConstant.
	"

	| node |
	node := self nextNumberConstant: aContext.
	node notNil ifTrue: [ ^node ].
	node := self nextStringConstant: aContext.
	node notNil ifTrue: [ ^node ].
	node := self nextCharacterConstant: aContext.
	node notNil ifTrue: [ ^node ].
	node := self nextArrayConstant: aContext.
	node notNil ifTrue: [ ^node ].
	node := self nextSymbolConstant: aContext.
	node notNil ifTrue: [ ^node ].
	^nil""",nil)

smalltalk.bind(smalltalk.ScriptParser,"nextNumber",0
,smalltalk.__f__("""(self):
	#ScriptParser>>#nextNumber
	return self.readSmalltalkNumberFrom_(getattr(self,"@source",nil)) 
""","ScriptParser_nextNumber")
,"parsing","""nextNumber
	" Private - Parse the receiver looking for a number using variables in aContext.
	Returns aNumber or generates an error if failed.
	<rule> number = [digits 'r'] ['-'] bigDigits ['.'bigDigits] ['e' ['-'] digits].
	<rule> digits = digit {digit}.
	<rule> Digit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'.
	<rule> bigDigits = bigDigit {bigDigit}.
	<rule> bigDigit = digit | capitalLetter.
	"

	^self readSmalltalkNumberFrom: source""",nil)

smalltalk.bind(smalltalk.ScriptParser,"nextNumberConstant:",0
,smalltalk.__f__("""(self,aContext):
	#ScriptParser>>#nextNumberConstant:
	__0__=smalltalk.newContext()
	__0__.start=nil
	__0__.value=nil
	__0__.start=self.startOfNextToken() 
	if smalltalk.b(smalltalk.isNil_(self.peekAny_advance_(smalltalk.String("0123456789-"),smalltalk.false))):
		return nil 
	 
	__0__.value=self.nextNumber() 
	if smalltalk.b(smalltalk.isNil_(__0__.value)):
		self.position_(__0__.start) 
		return nil 
	 
	return smalltalk.ParseLiteral.from_to_value_(__0__.start,self.position(),__0__.value) 
""","ScriptParser_nextNumberConstant_")
,"parsing","""nextNumberConstant: aContext
	" Private - Parse the receiver looking for a number using variables in aContext.
	Returns nil if failed.
	<rule> number = [digits 'r'] ['-'] bigDigits ['.'bigDigits] ['e' ['-'] digits].
	<rule> digits = digit {digit}.
	<rule> Digit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'.
	<rule> bigDigits = bigDigit {bigDigit}.
	<rule> bigDigit = digit | capitalLetter.
	"

	| start value |
	start := self startOfNextToken.
	(self peekAny: '0123456789-' advance: false) isNil ifTrue: [ ^nil ].
	value := self nextNumber.
	value isNil ifTrue: [ self position: start. ^nil ].
	^ParseLiteral
		from: start to: self position
		value: value """,nil)

smalltalk.bind(smalltalk.ScriptParser,"nextSelector",0
,smalltalk.__f__("""(self):
	#ScriptParser>>#nextSelector
	__0__=smalltalk.newContext()
	__0__.result=nil
	__0__.result=self.nextSelectorOrNil() 
	if smalltalk.b(smalltalk.isNil_(__0__.result)):
		return self.expected_(smalltalk.String("selector")) 
	 
	return __0__.result 
""","ScriptParser_nextSelector")
,"parsing","""nextSelector
	" Private - Returns the next selector in the receiver.
	Generates an error if failed.
		<rule> symbol = unarySelector | binarySelector | keyword {keyword}.
		<rule> unarySelector = identifier.
		<rule> binarySelector = selectorCharacter [selectorCharacter] | '-'.
		<rule> keyword = identifier ':'.
	"

	| result |
	result := self nextSelectorOrNil.
	result isNil ifTrue: [ ^self expected: #selector ].
	^result""",nil)

smalltalk.bind(smalltalk.ScriptParser,"nextSelectorOrNil",0
,smalltalk.__f__("""(self):
	_s8Ret_=smalltalk.newContext()
	try:
		#ScriptParser>>#nextSelectorOrNil
		__0__=smalltalk.newContext()
		def __blk1__():
			return __0__.peek.isSeparator() 
		def __blk2__():
			return self.isSelectorCharacter_(__0__.peek) 
		def __blk3__():
			__0__.contents=smalltalk.object_comma_(__0__.contents,self.nextWord()) 
			return smalltalk.isObject_equalTo_(self.basicPeek(),self.colon()) 
		__0__.contents=nil
		__0__.peek=nil
		__0__.peek=self.basicPeek() 
		if smalltalk.b(smalltalk.boolean_or_(smalltalk.isNil_(__0__.peek),smalltalk.blk(__blk1__,0))):
			return nil 
		 
		if smalltalk.b(smalltalk.boolean_or_(smalltalk.isObject_equalTo_(__0__.peek,smalltalk.String("-")),smalltalk.blk(__blk2__,0))):
			return self.nextSelectorWith_(__0__.peek) 
		 
		if not smalltalk.b(self.isAlpha_(__0__.peek)):
			return nil 
		 
		__0__.contents=smalltalk.String.new() 
		while smalltalk.b(smalltalk.blk(__blk3__,0)()):
			def __blk4__():
				return smalltalk.booleanNot_(self.isAlpha_(__0__.peek)) 
			def __blk5__():
				return smalltalk.raise_result_(_s8Ret_,__0__.contents) 
			__0__.contents=smalltalk.object_comma_(__0__.contents,self.colon()) 
			self.skip_(self.colon()) 
			__0__.peek=self.basicPeek() 
			smalltalk.if_true_false_(smalltalk.boolean_or_(smalltalk.isNil_(__0__.peek),smalltalk.blk(__blk4__,0)),smalltalk.blk(__blk5__,0),nil) 
		 
		smalltalk.raise_result_(_s8Ret_,__0__.contents.asSymbol()) 
	except Exception as __ex:
		if smalltalk.exception_at(__ex,_s8Ret_):
			return smalltalk.exceptionResult_(__ex)
		raise __ex
	
""","ScriptParser_nextSelectorOrNil")
,"parsing","""nextSelectorOrNil
	" Private - Returns the next selector in the receiver.
	Returns nil if failed.
		<rule> symbol = unarySelector | binarySelector | keyword {keyword}.
		<rule> unarySelector = identifier.
		<rule> binarySelector = selectorCharacter [selectorCharacter] | '-'.
		<rule> keyword = identifier ':'.
	"

	| contents peek |
	peek := self basicPeek.
	(peek isNil or: [ peek isSeparator ]) ifTrue: [ ^nil ].

	(peek = $- or: [ self isSelectorCharacter: peek ]) "binarySelector"
	ifTrue: [ ^self nextSelectorWith: peek ].

	(self isAlpha: peek) ifFalse: [ ^nil ].
	contents := String new.
	[	contents := contents, self nextWord.
		self basicPeek = self colon ] whileTrue: [
		contents := contents ,self colon.
		self skip: self colon.
		peek := self basicPeek.
		(peek isNil or: [ (self isAlpha: peek) not ]) ifTrue: [ ^contents ]
	].
	^contents asSymbol""",nil)

smalltalk.bind(smalltalk.ScriptParser,"nextSelectorWith:",0
,smalltalk.__f__("""(self,start):
	#ScriptParser>>#nextSelectorWith:
	__0__=smalltalk.newContext()
	def __blk1__():
		self.next() 
		__0__.peek=self.basicPeek() 
		return self.isSelectorCharacter_(__0__.peek) 
	__0__.result=nil
	__0__.peek=nil
	__0__.result=start 
	while smalltalk.b(smalltalk.blk(__blk1__,0)()):
		__0__.result=smalltalk.object_comma_(__0__.result,smalltalk.asString_(__0__.peek)) 
	 
	return __0__.result 
""","ScriptParser_nextSelectorWith_")
,"parsing","""nextSelectorWith: start
	" Private - Returns the next selector starting with start character. "

	| result peek |
	result := start.
	[	self next.
		peek := self basicPeek.
		self isSelectorCharacter: peek
	] whileTrue: [
		result := result , peek asString
	].
	^result""",nil)

smalltalk.bind(smalltalk.ScriptParser,"nextString",0
,smalltalk.__f__("""(self):
	#ScriptParser>>#nextString
	__0__=smalltalk.newContext()
	def __blk1__():
		__0__.contents=smalltalk.object_comma_(__0__.contents,getattr(self,"@source",nil).upTo_(self.singleQuote())) 
		return smalltalk.isObject_equalTo_(getattr(self,"@source",nil).peek(),self.singleQuote()) 
	__0__.contents=nil
	__0__.contents=smalltalk.String.new() 
	while smalltalk.b(smalltalk.blk(__blk1__,0)()):
		__0__.contents=__0__.contents.copyWith_(smalltalk.String("'")) 
		getattr(self,"@source",nil).next() 
	 
	return __0__.contents 
""","ScriptParser_nextString")
,"parsing","""nextString
	" Private - Returns the next String contents from the receiver. "

	| contents |
	contents := String new.
	[	contents := contents , (source upTo: self singleQuote).
		source peek = self singleQuote
	] whileTrue: [
		contents := contents copyWith: $'.
		source next
	].
	^contents""",nil)

smalltalk.bind(smalltalk.ScriptParser,"nextStringConstant:",0
,smalltalk.__f__("""(self,aContext):
	#ScriptParser>>#nextStringConstant:
	__0__=smalltalk.newContext()
	__0__.start=nil
	__0__.contents=nil
	__0__.start=self.startOfNextToken() 
	if not smalltalk.b(self.match_(self.singleQuote())):
		return nil 
	 
	return smalltalk.ParseLiteral.from_to_value_(__0__.start,self.position(),self.nextString()) 
""","ScriptParser_nextStringConstant_")
,"parsing","""nextStringConstant: aContext
	" Private - Parse the receiver looking for a string using variables in aContext.
	Returns nil if failed. "

	| start contents |
	start := self startOfNextToken.
	(self match: self singleQuote) ifFalse: [ ^nil ].
	^ParseLiteral
		from: start to: self position
		value: self nextString """,nil)

smalltalk.bind(smalltalk.ScriptParser,"nextSymbol",0
,smalltalk.__f__("""(self):
	_s8Ret_=smalltalk.newContext()
	try:
		#ScriptParser>>#nextSymbol
		__0__=smalltalk.newContext()
		def __blk1__():
			def __blk2__():
				def __blk3__():
					def __blk4__():
						def __blk5__():
							return smalltalk.String("_:").includes_(__0__.c) 
						return smalltalk.boolean_or_(self.binarySelectorChars().includes_(__0__.c),smalltalk.blk(__blk5__,0)) 
					return smalltalk.boolean_or_(__0__.c.between_and_(smalltalk.String("0"),smalltalk.String("9")),smalltalk.blk(__blk4__,0)) 
				return smalltalk.boolean_or_(__0__.c.between_and_(smalltalk.String("A"),smalltalk.String("Z")),smalltalk.blk(__blk3__,0)) 
			__0__.c=getattr(self,"@source",nil).peek() 
			if smalltalk.b(smalltalk.isNil_(__0__.c)):
				def __blk6__():
					return __0__.result 
				smalltalk.raise_result_(_s8Ret_,smalltalk.if_true_false_(__0__.result.notEmpty(),smalltalk.blk(__blk6__,0),nil)) 
			 
			return smalltalk.boolean_or_(__0__.c.between_and_(smalltalk.String("a"),smalltalk.String("z")),smalltalk.blk(__blk2__,0)) 
		def __blk7__():
			return __0__.result 
		__0__.c=nil
		__0__.result=nil
		__0__.result=smalltalk.String.new() 
		while smalltalk.b(smalltalk.blk(__blk1__,0)()):
			__0__.result=smalltalk.object_comma_(__0__.result,getattr(self,"@source",nil).next()) 
		 
		smalltalk.raise_result_(_s8Ret_,smalltalk.if_true_false_(__0__.result.notEmpty(),smalltalk.blk(__blk7__,0),nil)) 
	except Exception as __ex:
		if smalltalk.exception_at(__ex,_s8Ret_):
			return smalltalk.exceptionResult_(__ex)
		raise __ex
	
""","ScriptParser_nextSymbol")
,"parsing","""nextSymbol
	" Private - Returns the characters in next Symbol (or nil). "

	| c result |
	result := String new.
	[	c := source peek.
		c isNil ifTrue: [
			^result notEmpty ifTrue: [ result ]
		].
		(c between: $a and: $z)
		or: [ (c between: $A and: $Z)
		or: [ (c between: $0 and: $9)
		or: [ (self binarySelectorChars includes: c)
		or: [ '_:' includes: c ]]]]
	] whileTrue: [
		result := result ,source next
	].
	^result notEmpty ifTrue: [ result ] """,nil)

smalltalk.bind(smalltalk.ScriptParser,"nextNativeConstant:",0
,smalltalk.__f__("""(self,aContext):
	#ScriptParser>>#nextNativeConstant:
	__0__=smalltalk.newContext()
	__0__.start=nil
	__0__.aName=nil
	__0__.start=self.startOfNextToken() 
	if not smalltalk.b(self.match_(self.leftBrace())):
		return nil 
	 
	__0__.aName=self.nextWord() 
	if not smalltalk.b(self.match_(self.rightBrace())):
		return self.expected_(self.rightBrace()) 
	 
	return smalltalk.ParseNativeVariable.named_from_to_(__0__.aName,__0__.start,self.position()) 
""","ScriptParser_nextNativeConstant_")
,"parsing","""nextNativeConstant: aContext
	" Private - Parse the receiver looking for a name of native constant in aContext.
	Returns nil if failed.
		<rule> nativeConstant = '{' word '}'
	"

	| start aName |
	start := self startOfNextToken.
	(self match: self leftBrace) ifFalse: [ ^nil ].
	aName := self nextWord.
	(self match: self rightBrace) ifFalse: [ ^self expected: self rightBrace ].
	^ParseNativeVariable named: aName from: start to: self position """,nil)

smalltalk.bind(smalltalk.ScriptParser,"nextSymbolConstant:",0
,smalltalk.__f__("""(self,aContext):
	#ScriptParser>>#nextSymbolConstant:
	__0__=smalltalk.newContext()
	def __blk1__():
		getattr(self,"@source",nil).next() 
		return self.nextString() 
	def __blk2__():
		return self.nextSymbol() 
	__0__.start=nil
	__0__.value=nil
	__0__.start=self.startOfNextToken() 
	if not smalltalk.b(self.match_(self.literalQuote())):
		return nil 
	 
	if smalltalk.b(smalltalk.isObject_equalTo_(getattr(self,"@source",nil).peek(),self.leftBrace())):
		return self.nextNativeConstant_(aContext) 
	 
	__0__.value=smalltalk.if_true_false_(smalltalk.isObject_equalTo_(getattr(self,"@source",nil).peek(),self.singleQuote()),smalltalk.blk(__blk1__,0),smalltalk.blk(__blk2__,0)) 
	if smalltalk.b(smalltalk.isNil_(__0__.value)):
		return smalltalk.ParseNoReceiver.from_to_(__0__.start,self.position()) 
	 
	return smalltalk.ParseLiteral.from_to_value_(__0__.start,self.position(),__0__.value.asSymbol()) 
""","ScriptParser_nextSymbolConstant_")
,"parsing","""nextSymbolConstant: aContext
	" Private - Parse the receiver looking for aSymbol using variables in aContext.
	Returns nil if failed.
		<rule> symbolConstant = '#' string | symbolChars | ${ nativeConstant
	"

	| start value |
	start := self startOfNextToken.
	(self match: self literalQuote) ifFalse: [ ^nil ].
	source peek = self leftBrace ifTrue: [ ^self nextNativeConstant: aContext ].
	value := source peek = self singleQuote
		ifTrue: [ source next. self nextString ]
		ifFalse: [ self nextSymbol ].
	value isNil ifTrue: [
		^ParseNoReceiver
			from: start to: self position
	].
	^ParseLiteral
		from: start to: self position
		value: value asSymbol """,nil)

smalltalk.bind(smalltalk.ScriptParser,"classBindingNamed:",0
,smalltalk.__f__("""(self,varName):
	_s8Ret_=smalltalk.newContext()
	try:
		#ScriptParser>>#classBindingNamed:
		__0__=smalltalk.newContext()
		def __blk1__(cls):
			def __blk2__():
				def __blk3__():
					nil 
				def __blk4__():
					return smalltalk.raise_result_(_s8Ret_,__0__.binding) 
				__0__.binding=__0__.pool.bindingAt_ifAbsent_(varName,smalltalk.blk(__blk3__,0)) 
				return smalltalk.if_true_false_(smalltalk.notNil_(__0__.binding),smalltalk.blk(__blk4__,0),nil) 
			__0__.pool=cls.classVariables() 
			return smalltalk.if_true_false_(smalltalk.notNil_(__0__.pool),smalltalk.blk(__blk2__,0),nil) 
		def __blk5__(cls):
			def __blk6__(aName):
				def __blk7__():
					nil 
				def __blk8__():
					def __blk9__():
						nil 
					def __blk10__():
						return smalltalk.raise_result_(_s8Ret_,__0__.binding) 
					__0__.binding=__0__.pool.bindingAt_ifAbsent_(varName,smalltalk.blk(__blk9__,0)) 
					return smalltalk.if_true_false_(smalltalk.notNil_(__0__.binding),smalltalk.blk(__blk10__,0),nil) 
				__0__.pool=smalltalk.Smalltalk.poolDictionary_ifAbsent_(aName,smalltalk.blk(__blk7__,0)) 
				return smalltalk.if_true_false_(smalltalk.notNil_(__0__.pool),smalltalk.blk(__blk8__,0),nil) 
			return cls.poolDictionaryNames().do_(smalltalk.blk(__blk6__,1)) 
		__0__.aClass=nil
		__0__.pool=nil
		__0__.binding=nil
		__0__.aClass=self.currentClass().instanceClass() 
		__0__.aClass.withAllSuperclassesDo_(smalltalk.blk(__blk1__,1)) 
		__0__.aClass.withAllSuperclassesDo_(smalltalk.blk(__blk5__,1)) 
		smalltalk.raise_result_(_s8Ret_,nil) 
	except Exception as __ex:
		if smalltalk.exception_at(__ex,_s8Ret_):
			return smalltalk.exceptionResult_(__ex)
		raise __ex
	
""","ScriptParser_classBindingNamed_")
,"parsing","""classBindingNamed: varName
	" Private - Returns a binding known by the currentClass with name varName. "

	| aClass pool binding |
	aClass := self currentClass instanceClass.
	aClass withAllSuperclassesDo: [:cls|
		pool := cls classVariables.
		pool notNil ifTrue: [
			binding := pool bindingAt: varName ifAbsent: [].
			binding notNil ifTrue: [ ^binding ].
		]
	].
	aClass withAllSuperclassesDo: [:cls|
		cls poolDictionaryNames do: [:aName|
			pool := Smalltalk poolDictionary: aName ifAbsent: [].
			pool notNil ifTrue: [
				binding := pool bindingAt: varName ifAbsent: [].
				binding notNil ifTrue: [ ^binding ].
			]
		].
	].
	^nil""",nil)

smalltalk.bind(smalltalk.ScriptParser,"collectIndices:in:",0
,smalltalk.__f__("""(self,variable,aContext):
	#ScriptParser>>#collectIndices:in:
	__0__=smalltalk.newContext()
	def __blk1__():
		def __blk2__():
			return smalltalk.isObject_equalTo_(getattr(self,"@source",nil).peek(),self.leftBracket()) 
		def __blk3__():
			return smalltalk.booleanNot_(__0__.done) 
		return smalltalk.boolean_and_(smalltalk.boolean_or_(smalltalk.isObject_equalTo_(getattr(self,"@source",nil).peek(),self.literalQuote()),smalltalk.blk(__blk2__,0)),smalltalk.blk(__blk3__,0)) 
	__0__.start=nil
	__0__.indices=nil
	__0__.done=nil
	__0__.indices=smalltalk.newArray([]) 
	__0__.done=smalltalk.false 
	while smalltalk.b(smalltalk.blk(__blk1__,0)()):
		__1__=smalltalk.newContext()
		def __blk4__():
			self.position_(__0__.start) 
			__0__.done=smalltalk.true
			return __0__.done 
		def __blk5__():
			return __0__.indices.add_(__1__.index) 
		__1__.c=nil
		__1__.index=nil
		__0__.start=self.position() 
		__1__.c=getattr(self,"@source",nil).next() 
		if smalltalk.b(smalltalk.isObject_equalTo_(__1__.c,self.literalQuote())):
			def __blk6__():
				getattr(self,"@source",nil).next() 
				return self.nextString() 
			def __blk7__():
				return self.nextSymbol() 
			__1__.index=smalltalk.if_true_false_(smalltalk.isObject_equalTo_(getattr(self,"@source",nil).peek(),self.singleQuote()),smalltalk.blk(__blk6__,0),smalltalk.blk(__blk7__,0)) 
		 
		if smalltalk.b(smalltalk.isObject_equalTo_(__1__.c,self.leftBracket())):
			def __blk8__():
				def __blk9__():
					return getattr(self,"@source",nil).next() 
				def __blk10__():
					__1__.index=nil
					return __1__.index 
				self.startOfNextToken() 
				return smalltalk.if_true_false_(smalltalk.isObject_equalTo_(getattr(self,"@source",nil).peek(),self.rightBracket()),smalltalk.blk(__blk9__,0),smalltalk.blk(__blk10__,0)) 
			__1__.index=self.expression_(aContext) 
			smalltalk.if_true_false_(smalltalk.notNil_(__1__.index),smalltalk.blk(__blk8__,0),nil) 
		 
		smalltalk.if_true_false_(smalltalk.isNil_(__1__.index),smalltalk.blk(__blk4__,0),smalltalk.blk(__blk5__,0)) 
	 
	if smalltalk.b(__0__.indices.notEmpty()):
		variable.indices_(__0__.indices) 
	 
	return self 
""","ScriptParser_collectIndices_in_")
,"parsing","""collectIndices: variable in: aContext
	" Private - Collect the indices following variable reference in aContext.
	<rule> indices = {'#' string | '[' expression ']'}
	"

	| start indices done |
	indices := #(). done := false.
	[	(source peek = self literalQuote
		or: [ source peek = self leftBracket ])
		and: [ done not ]
	] whileTrue: [ | c index |
		start := self position.
		c := source next.
		c = self literalQuote ifTrue: [
			index := source peek = self singleQuote
				ifTrue: [ source next. self nextString ]
				ifFalse: [ self nextSymbol ].
		].
		c = self leftBracket ifTrue: [
			index := self expression: aContext.
			index notNil ifTrue: [
				self startOfNextToken.
				source peek = self rightBracket
				ifTrue: [ source next ]
				ifFalse: [ index := nil ]
			]
		].
		index isNil ifTrue: [
			self position: start.
			done := true
		] ifFalse: [ indices add: index ]
	].
	indices notEmpty ifTrue: [
		variable indices: indices
	]""",nil)

smalltalk.bind(smalltalk.ScriptParser,"nextVariable:",0
,smalltalk.__f__("""(self,aContext):
	#ScriptParser>>#nextVariable:
	__0__=smalltalk.newContext()
	def __blk1__():
		self.collectIndices_in_(__0__.variable,aContext) 
		return __0__.variable.sourceRange_(__0__.start.to_(self.position())) 
	def __blk2__():
		return __0__.word.first().isUppercase() 
	__0__.word=nil
	__0__.assoc=nil
	__0__.start=nil
	__0__.variable=nil
	__0__.found=nil
	__0__.start=self.startOfNextToken() 
	__0__.word=self.nextWord() 
	if smalltalk.b(smalltalk.isNil_(__0__.word)):
		return nil 
	 
	__0__.found=smalltalk.blk(__blk1__,0) 
	__0__.variable=self.specialVariableNamed_(__0__.word) 
	if smalltalk.b(smalltalk.notNil_(__0__.variable)):
		return __0__.found.value() 
	 
	__0__.assoc=self.classBindingNamed_(__0__.word) 
	if smalltalk.b(smalltalk.isNil_(__0__.assoc)):
		def __blk3__():
			nil 
		__0__.assoc=aContext.bindingAt_ifAbsent_(__0__.word,smalltalk.blk(__blk3__,0)) 
	 
	if smalltalk.b(smalltalk.boolean_and_(smalltalk.isNil_(__0__.assoc),smalltalk.blk(__blk2__,0))):
		__0__.assoc=smalltalk.S8Binding.key_in_(__0__.word,smalltalk.Smalltalk) 
	 
	if smalltalk.b(smalltalk.isNil_(__0__.assoc)):
		self.position_(__0__.start) 
		return nil 
	 
	__0__.variable=smalltalk.ParseGlobalVariable.boundTo_(__0__.assoc) 
	return __0__.found.value() 
""","ScriptParser_nextVariable_")
,"parsing","""nextVariable: aContext
	" Private - Parse the receiver looking for a variable name.
	Returns the variable binding or nil if failed. "

	| word assoc start variable found |
	start := self startOfNextToken.
	word := self nextWord.
	word isNil ifTrue: [ ^nil ].
	found := [
		self collectIndices: variable in: aContext.
		variable sourceRange: (start to: self position)
	].

	variable := self specialVariableNamed: word.
	variable notNil ifTrue: [ ^found value ].
	assoc := self classBindingNamed: word.
	assoc isNil ifTrue: [
		assoc := aContext bindingAt: word ifAbsent: [].
	].
	(assoc isNil and: [ word first isUppercase ]) ifTrue: [
		assoc := S8Binding key: word in: Smalltalk.
	].
	assoc isNil ifTrue: [
		self position: start.
		^nil
	].
	variable := ParseGlobalVariable boundTo: assoc.
	^found value""",nil)

smalltalk.bind(smalltalk.ScriptParser,"nextWord",0
,smalltalk.__f__("""(self):
	#ScriptParser>>#nextWord
	__0__=smalltalk.newContext()
	def __blk1__():
		def __blk2__():
			return self.isAlpha_(getattr(self,"@source",nil).peek()) 
		return smalltalk.boolean_and_(smalltalk.booleanNot_(getattr(self,"@source",nil).atEnd()),smalltalk.blk(__blk2__,0)) 
	__0__.start=nil
	__0__.word=nil
	if smalltalk.b(self.atEnd()):
		return nil 
	 
	__0__.start=self.startOfNextToken() 
	if not smalltalk.b(self.isAlpha_(self.peek())):
		return nil 
	 
	__0__.word=self.next() 
	while smalltalk.b(smalltalk.blk(__blk1__,0)()):
		__0__.word=smalltalk.object_comma_(__0__.word,getattr(self,"@source",nil).next()) 
	 
	return __0__.word 
""","ScriptParser_nextWord")
,"parsing","""nextWord
	" Returns the next word in the receiver or nil if failed.
	 Advance the receiver. "

	| start word |
	self atEnd ifTrue: [ ^nil ].
	start := self startOfNextToken.
	(self isAlpha: self peek) ifFalse: [ ^nil ].

	word := self next.
	[	source atEnd not
		and: [ self isAlpha: source peek ]
	] whileTrue: [ word := word , source next ].

	^word""",nil)

smalltalk.bind(smalltalk.ScriptParser,"notImplementedYet:",0
,smalltalk.__f__("""(self,aString):
	#ScriptParser>>#notImplementedYet:
	return self.syntaxError_(smalltalk.object_comma_(aString,smalltalk.String(" not implemented. Yet"))) 
""","ScriptParser_notImplementedYet_")
,"error","""notImplementedYet: aString
	" Returns a syntax error because the functionality is not implemented yet. "

	^self syntaxError: aString ,' not implemented. Yet' """,nil)

smalltalk.bind(smalltalk.ScriptParser,"parse:doing:onError:",0
,smalltalk.__f__("""(self,code,action,aBlock):
	#ScriptParser>>#parse:doing:onError:
	__0__=smalltalk.newContext()
	def __blk1__():
		return code.stream() 
	def __blk2__():
		return code 
	__0__.result=nil
	smalltalk.basic_at_put(self,"@errorBlock",aBlock) 
	smalltalk.basic_at_put(self,"@source",smalltalk.if_true_false_(code.isString(),smalltalk.blk(__blk1__,0),smalltalk.blk(__blk2__,0))) 
	__0__.result=action.evaluate() 
	smalltalk.basic_at_put(self,"@errorBlock",smalltalk.basic_at_put(self,"@source",nil)) 
	return __0__.result 
""","ScriptParser_parse_doing_onError_")
,"parsing","""parse: code doing: action onError: aBlock
	" Private - Parse code with action and returns the root node of the parsing. "

	| result |
	errorBlock := aBlock.
	source := code isString
		ifTrue: [ code stream ]
		ifFalse: [ code ].
	result := action evaluate.
	errorBlock := source := nil.
	^result""",nil)

smalltalk.bind(smalltalk.ScriptParser,"parse:onError:",0
,smalltalk.__f__("""(self,aStringOrStream,aBlock):
	#ScriptParser>>#parse:onError:
	def __blk1__():
		__1__=smalltalk.newContext()
		__1__.statements=nil
		__1__.statements=smalltalk.ParseStatements.new() 
		self.parseStatements_in_innerBlock_(__1__.statements,self.bodyScope_(__1__.statements),smalltalk.false) 
		return smalltalk.Script.with_(__1__.statements) 
	return self.parse_doing_onError_(aStringOrStream,smalltalk.blk(__blk1__,0),aBlock) 
""","ScriptParser_parse_onError_")
,"scripting","""parse: aStringOrStream onError: aBlock
	" Parse S8 code (aStringOrStream) and returns the root node of the parsing.
	If occurs an error aBlock will be valued with the cause as an argument.
	Example:
		ScriptParser new parse: 'Smalltalk keys' onError: [:error| ^error printString ].
	"

	^self	parse: aStringOrStream doing: [ | statements |
			statements := ParseStatements new.
			self	parseStatements: statements
				in: (self bodyScope: statements)
				innerBlock: false.
			Script with: statements
		] onError: aBlock""",nil)

smalltalk.bind(smalltalk.ScriptParser,"parse:",0
,smalltalk.__f__("""(self,aStringOrStream):
	_s8Ret_=smalltalk.newContext()
	try:
		#ScriptParser>>#parse:
		__0__=smalltalk.newContext()
		def __blk1__(error):
			return smalltalk.raise_result_(_s8Ret_,error) 
		__0__.result=nil
		__0__.result=self.parse_onError_(aStringOrStream,smalltalk.blk(__blk1__,1)) 
		smalltalk.raise_result_(_s8Ret_,__0__.result) 
	except Exception as __ex:
		if smalltalk.exception_at(__ex,_s8Ret_):
			return smalltalk.exceptionResult_(__ex)
		raise __ex
	
""","ScriptParser_parse_")
,"scripting","""parse: aStringOrStream
	" Parse S8 code (aStringOrStream) and returns the root node of the parsing (or an error). "

	| result |
	result := self parse: aStringOrStream onError: [:error| ^error ].
	^result """,nil)

smalltalk.bind(smalltalk.ScriptParser,"peek",0
,smalltalk.__f__("""(self):
	#ScriptParser>>#peek
	self.skipSeparators() 
	return self.basicPeek() 
""","ScriptParser_peek")
,"parsing","""peek
	" Peek the next character from source stream. "

	self skipSeparators.
	^self basicPeek""",nil)

smalltalk.bind(smalltalk.ScriptParser,"peekAny:",0
,smalltalk.__f__("""(self,aCollection):
	#ScriptParser>>#peekAny:
	return self.peekAny_advance_(aCollection,smalltalk.true) 
""","ScriptParser_peekAny_")
,"parsing","""peekAny: aCollection
	" Try to match the next token of the receiver to any of the elements in aCollection.
	Returns the first element in aCollection that matches or nil if none. "

	^self peekAny: aCollection advance: true""",nil)

smalltalk.bind(smalltalk.ScriptParser,"peekAny:advance:",0
,smalltalk.__f__("""(self,aCollection,advance):
	_s8Ret_=smalltalk.newContext()
	try:
		#ScriptParser>>#peekAny:advance:
		__0__=smalltalk.newContext()
		def __blk1__(each):
			def __blk2__():
				if not smalltalk.b(advance):
					self.position_(__0__.start) 
				 
				return smalltalk.raise_result_(_s8Ret_,each) 
			return smalltalk.if_true_false_(self.match_(each),smalltalk.blk(__blk2__,0),nil) 
		__0__.start=nil
		__0__.start=self.position() 
		aCollection.do_(smalltalk.blk(__blk1__,1)) 
		smalltalk.raise_result_(_s8Ret_,nil) 
	except Exception as __ex:
		if smalltalk.exception_at(__ex,_s8Ret_):
			return smalltalk.exceptionResult_(__ex)
		raise __ex
	
""","ScriptParser_peekAny_advance_")
,"parsing","""peekAny: aCollection advance: advance
	" Try to match the next token of the receiver to any of the elements in aCollection.
	Returns the first element in aCollection that matches or nil if none. "

	| start |
	start := self position.
	aCollection do: [:each|
		(self match: each) ifTrue: [
			advance ifFalse: [ self position: start ].
			^each
		].
	].
	^nil""",nil)

smalltalk.bind(smalltalk.ScriptParser,"primaryExpression:",0
,smalltalk.__f__("""(self,aContext):
	#ScriptParser>>#primaryExpression:
	__0__=smalltalk.newContext()
	__0__.node=nil
	__0__.node=self.nextLiteral_(aContext) 
	if smalltalk.b(smalltalk.notNil_(__0__.node)):
		return __0__.node 
	 
	__0__.node=self.nextVariable_(aContext) 
	if smalltalk.b(smalltalk.notNil_(__0__.node)):
		return __0__.node 
	 
	if smalltalk.b(self.match_(self.leftBrace())):
		return self.nextBraceExpression_(aContext) 
	 
	if smalltalk.b(self.match_(self.leftBracket())):
		return self.nextBlock_(aContext) 
	 
	if smalltalk.b(self.match_(self.leftParenthesis())):
		__0__.node=self.expression_(aContext) 
		if smalltalk.b(self.match_(self.rightParenthesis())):
			return __0__.node 
		 
		return self.expected_(self.rightParenthesis()) 
	 
	return nil 
""","ScriptParser_primaryExpression_")
,"parsing","""primaryExpression: aContext
	" Private - Parse the receiver looking for a primary expression using variables in aContext.
	Returns nil if failed.
	<rule> primary = literal | variableName | brace | block | '(' expression ')' | '<' primitive '>' .
	"

	| node |
	node := self nextLiteral: aContext.
	node notNil ifTrue: [ ^node ].
	node := self nextVariable: aContext.
	node notNil ifTrue: [ ^node ].
	(self match: self leftBrace) ifTrue: [
		^self nextBraceExpression: aContext
	].
	(self match: self leftBracket) ifTrue: [
		^self nextBlock: aContext
	].

	(self match: self leftParenthesis) ifTrue: [
		node := self expression: aContext.
		(self match: self rightParenthesis) ifTrue: [ ^node ].
		^self expected: self rightParenthesis
	].
	^nil " self expected: #expression \"""",nil)

smalltalk.bind(smalltalk.ScriptParser,"pushNil",0
,smalltalk.__f__("""(self):
	#ScriptParser>>#pushNil
	return self.specialVariableNamed_(smalltalk.String("nil")) 
""","ScriptParser_pushNil")
,"parsing","""pushNil
	" Returns a node returning nil. "

	^self specialVariableNamed: #nil """,nil)

smalltalk.bind(smalltalk.ScriptParser,"pushSelf",0
,smalltalk.__f__("""(self):
	#ScriptParser>>#pushSelf
	return self.specialVariableNamed_(smalltalk.String("self")) 
""","ScriptParser_pushSelf")
,"parsing","""pushSelf
	" Returns a node returning self. "

	^self specialVariableNamed: #self """,nil)

smalltalk.bind(smalltalk.ScriptParser,"readIntegerFrom:radix:",0
,smalltalk.__f__("""(self,aStream,radix):
	#ScriptParser>>#readIntegerFrom:radix:
	__0__=smalltalk.newContext()
	def __blk1__():
		return aStream.atEnd() 
	__0__.digit=nil
	__0__.value=nil
	__0__.value=smalltalk.Number(0) 
	while not smalltalk.b(smalltalk.blk(__blk1__,0)()):
		def __blk2__():
			return __0__.digit.digitValue() 
		def __blk3__():
			return smalltalk.Number(-1) 
		def __blk4__():
			return __0__.digit._gt_eq(radix) 
		__0__.digit=aStream.next() 
		__0__.digit=smalltalk.if_true_false_(__0__.digit.isDigit(),smalltalk.blk(__blk2__,0),smalltalk.blk(__blk3__,0)) 
		if smalltalk.b(smalltalk.boolean_or_(__0__.digit._lt(smalltalk.Number(0)),smalltalk.blk(__blk4__,0))):
			aStream.skip_(smalltalk.Number(-1)) 
			return __0__.value 
		 
		__0__.value=__0__.value._star(radix)._plus(__0__.digit) 
	 
	return __0__.value 
""","ScriptParser_readIntegerFrom_radix_")
,"parsing","""readIntegerFrom: aStream radix: radix
	" Private - Answer aNumber of the concrete subclasses if Integer.
	Initial minus sign accepted, and bases > 10 use letters A-Z.
	Imbedded radix specifiers not allowed; use Integer
	class readFrom: for that. Answer zero if there are no digits. "

	| digit value |
	value := 0.
	[aStream atEnd] whileFalse: [
		digit := aStream next.
		digit := digit isDigit ifTrue: [ digit digitValue ] ifFalse: [-1].
		(digit < 0 or: [digit >= radix]) ifTrue: [
			aStream skip: -1.
			^value
		].
		value := value * radix + digit
	].
	^value""",nil)

smalltalk.bind(smalltalk.ScriptParser,"readSmalltalkFloat:from:",0
,smalltalk.__f__("""(self,integerPart,aStream):
	#ScriptParser>>#readSmalltalkFloat:from:
	__0__=smalltalk.newContext()
	def __blk1__():
		return __0__.value 
	def __blk2__():
		return __0__.value._star(smalltalk.Number(10).raisedTo_(__0__.exp)) 
	__0__.value=nil
	__0__.coercionClass=nil
	__0__.possibleCoercionClass=nil
	__0__.precision=nil
	__0__.digit=nil
	__0__.num=nil
	__0__.den=nil
	__0__.exp=nil
	__0__.neg=nil
	__0__.endOfNumber=nil
	__0__.eChar=nil
	__0__.atEnd=nil
	__0__.precision=smalltalk.Number(0) 
	__0__.num=smalltalk.Number(0) 
	__0__.den=smalltalk.Number(1) 
	__0__.coercionClass=smalltalk.String("Integer") 
	if smalltalk.b(aStream.peekFor_(smalltalk.String("."))):
		def __blk3__():
			return aStream.peek().isDigit() 
		def __blk4__():
			def __blk5__():
				def __blk6__():
					__0__.digit=aStream.next()
					return smalltalk.booleanNot_((__0__.digit).isDigit()) 
				__0__.atEnd=aStream.atEnd()
				return smalltalk.boolean_or_((__0__.atEnd),smalltalk.blk(__blk6__,0)) 
			def __blk7__():
				return aStream.skip_(smalltalk.Number(-1)) 
			__0__.coercionClass=smalltalk.String("Float") 
			while not smalltalk.b(smalltalk.blk(__blk5__,0)()):
				__0__.num=__0__.num._star(smalltalk.Number(10))._plus(__0__.digit.digitValue()) 
				__0__.precision=__0__.precision._plus(smalltalk.Number(1)) 
			 
			__0__.den=smalltalk.Number(10).raisedTo_(__0__.precision) 
			return smalltalk.if_true_false_(__0__.atEnd,nil,smalltalk.blk(__blk7__,0)) 
		def __blk8__():
			return aStream.skip_(smalltalk.Number(-1)) 
		smalltalk.if_true_false_(smalltalk.boolean_and_(smalltalk.booleanNot_(aStream.atEnd()),smalltalk.blk(__blk3__,0)),smalltalk.blk(__blk4__,0),smalltalk.blk(__blk8__,0)) 
	 
	__0__.eChar=aStream.peek() 
	if smalltalk.b(smalltalk.b_(__0__.eChar is nil)):
		__0__.possibleCoercionClass=nil 
	else:
		def __blk9__():
			return smalltalk.String("Float") 
		def __blk10__():
			return aStream.next() 
		__0__.eChar=__0__.eChar.asLowercase() 
		__0__.possibleCoercionClass=smalltalk.if_true_false_(smalltalk.isObject_equalTo_(__0__.eChar,smalltalk.String("e")),smalltalk.blk(__blk9__,0),nil) 
		smalltalk.if_true_false_(smalltalk.b_(__0__.possibleCoercionClass is nil),nil,smalltalk.blk(__blk10__,0)) 
	 
	__0__.exp=nil 
	if not smalltalk.b(smalltalk.b_(__0__.possibleCoercionClass is nil)):
		def __blk11__():
			return __0__.digit.isDigit() 
		def __blk12__():
			def __blk13__():
				__0__.exp=__0__.exp.negated()
				return __0__.exp 
			__0__.exp=self.readIntegerFrom_radix_(aStream,smalltalk.Number(10)) 
			return smalltalk.if_true_false_(__0__.neg,smalltalk.blk(__blk13__,0),nil) 
		def __blk14__():
			return aStream.position_(__0__.endOfNumber) 
		__0__.coercionClass=__0__.possibleCoercionClass 
		__0__.endOfNumber=aStream.position() 
		__0__.neg=aStream.peekFor_(smalltalk.String("-")) 
		__0__.digit=aStream.peek()
		smalltalk.if_true_false_(smalltalk.boolean_and_(smalltalk.notNil_((__0__.digit)),smalltalk.blk(__blk11__,0)),smalltalk.blk(__blk12__,0),smalltalk.blk(__blk14__,0)) 
	 
	__0__.value=integerPart._plus(__0__.num._slash(__0__.den)) 
	return smalltalk.if_true_false_(smalltalk.isNil_(__0__.exp),smalltalk.blk(__blk1__,0),smalltalk.blk(__blk2__,0)) 
""","ScriptParser_readSmalltalkFloat_from_")
,"parsing","""readSmalltalkFloat: integerPart from: aStream
	" Private -Answer aNumber as described on the stream, aStream. "

	| value coercionClass possibleCoercionClass precision digit num den exp neg endOfNumber eChar atEnd |
	precision := 0. num := 0. den := 1.
	coercionClass := #Integer.
	(aStream peekFor: $.) ifTrue: ["<integer>.<fraction>"
		(aStream atEnd not and: [aStream peek isDigit]) ifTrue: [
			coercionClass := #Float.
			[ (atEnd := aStream atEnd) or: [(digit := aStream next) isDigit not]
			] whileFalse: [
				num := num * 10 + digit digitValue.
				precision := precision + 1
			].
			den := 10 raisedTo: precision.
			atEnd ifFalse: [ aStream skip: -1 ]
		] ifFalse: ["just <integer>. un-gobble the period"
			aStream skip: -1
		]
	].
	eChar := aStream peek.
	eChar == nil
	ifTrue: [ possibleCoercionClass := nil ]
	ifFalse: [
		"true ifTrue: [ "eChar := eChar asLowercase" ]".
		possibleCoercionClass := eChar = $e ifTrue: [ #Float ].
		possibleCoercionClass == nil ifFalse: [ aStream next ]
	].
	exp := nil.
	possibleCoercionClass == nil ifFalse: [
		coercionClass := possibleCoercionClass.
		endOfNumber := aStream position.
		neg := aStream peekFor: $-.
		((digit := aStream peek) notNil and: [digit isDigit]) ifTrue: [
			exp := self readIntegerFrom: aStream radix: 10.
			neg ifTrue: [ exp := exp negated ]
		] ifFalse: [ aStream position: endOfNumber ]
	].
	value := integerPart + (num / den). "The exponent will be added in the next step. "
	" ^self
		coerce: value
		to: coercionClass
		precision: precision
		exponent: exp
		exponentChar: eChar "
	^exp isNil ifTrue: [ value ] ifFalse: [ value * (10 raisedTo: exp) ]""",nil)

smalltalk.bind(smalltalk.ScriptParser,"readSmalltalkNumberFrom:",0
,smalltalk.__f__("""(self,aStream):
	#ScriptParser>>#readSmalltalkNumberFrom:
	__0__=smalltalk.newContext()
	def __blk1__():
		return aStream.peek().isLetter() 
	def __blk2__():
		return __0__.value.negated() 
	def __blk3__():
		return __0__.value 
	__0__.value=nil
	__0__.neg=nil
	__0__.radix=nil
	if smalltalk.b(smalltalk.boolean_or_(aStream.atEnd(),smalltalk.blk(__blk1__,0))):
		return smalltalk.Number(0) 
	 
	__0__.neg=aStream.peekFor_(smalltalk.String("-")) 
	__0__.value=self.readIntegerFrom_radix_(aStream,smalltalk.Number(10)) 
	if smalltalk.b(aStream.peekFor_(smalltalk.String("r"))):
		__0__.radix=__0__.value 
		__0__.value=self.readSmalltalkRadix_from_(__0__.value,aStream) 
		__0__.value=self.checkForOldSyntax_with_on_(__0__.radix,__0__.value,aStream) 
	else:
		__0__.value=self.readSmalltalkFloat_from_(__0__.value,aStream) 
	 
	return smalltalk.if_true_false_(__0__.neg,smalltalk.blk(__blk2__,0),smalltalk.blk(__blk3__,0)) 
""","ScriptParser_readSmalltalkNumberFrom_")
,"parsing","""readSmalltalkNumberFrom: aStream
	" Private - Answer aNumber as described on the stream, aStream. "

	| value neg radix |
	(aStream atEnd or: [aStream peek isLetter]) ifTrue: [^0].
	neg := aStream peekFor: $-.
	value := self readIntegerFrom: aStream radix: 10.
	(aStream peekFor: $r) ifTrue: [
		radix := value.
		value := self readSmalltalkRadix: value from: aStream.
		value := self checkForOldSyntax: radix with: value on: aStream
	] ifFalse: [
		value := self readSmalltalkFloat: value from: aStream
	].
	^neg
		ifTrue: [value negated]
		ifFalse: [value]""",nil)

smalltalk.bind(smalltalk.ScriptParser,"readSmalltalkRadix:from:",0
,smalltalk.__f__("""(self,radix,aStream):
	#ScriptParser>>#readSmalltalkRadix:from:
	def __blk1__():
		return smalltalk.booleanNot_(aStream.peek().digitValue().between_and_(smalltalk.Number(0),radix._minus(smalltalk.Number(1)))) 
	if smalltalk.b(radix._lt(smalltalk.Number(2))):
		return self.syntaxError_(smalltalk.String("Invalid radix")) 
	 
	if smalltalk.b(smalltalk.boolean_or_(aStream.atEnd(),smalltalk.blk(__blk1__,0))):
		aStream.skip_(smalltalk.Number(-1)) 
		return radix 
	 
	return self.readIntegerFrom_radix_(aStream,radix) 
""","ScriptParser_readSmalltalkRadix_from_")
,"parsing","""readSmalltalkRadix: radix from: aStream
	" Private - Answer aNumber as described on the stream, aStream. "

	radix < 2 ifTrue: [ ^self syntaxError: 'Invalid radix' ].
	(aStream atEnd or: [(aStream peek digitValue between: 0 and: radix - 1) not])
	ifTrue: [ aStream skip: -1. ^radix ].
	^self readIntegerFrom: aStream radix: radix""",nil)

smalltalk.bind(smalltalk.ScriptParser,"rightBrace",0
,smalltalk.__f__("""(self):
	#ScriptParser>>#rightBrace
	return smalltalk.String("}") 
""","ScriptParser_rightBrace")
,"constants","""rightBrace
	" Private - Returns the rightBrace token. "

	^$}""",nil)

smalltalk.bind(smalltalk.ScriptParser,"rightBracket",0
,smalltalk.__f__("""(self):
	#ScriptParser>>#rightBracket
	return smalltalk.String("]") 
""","ScriptParser_rightBracket")
,"constants","""rightBracket
	" Private - Returns the rightBracket token. "

	^$]""",nil)

smalltalk.bind(smalltalk.ScriptParser,"rightParenthesis",0
,smalltalk.__f__("""(self):
	#ScriptParser>>#rightParenthesis
	return smalltalk.String(")") 
""","ScriptParser_rightParenthesis")
,"constants","""rightParenthesis
	" Private - Returns the rightParenthesis token. "

	^$)""",nil)

smalltalk.bind(smalltalk.ScriptParser,"scope",0
,smalltalk.__f__("""(self):
	#ScriptParser>>#scope
	if smalltalk.b(smalltalk.isNil_(getattr(self,"@scope",nil))):
		self.initializeScope() 
	 
	return getattr(self,"@scope",nil) 
""","ScriptParser_scope")
,"accessing","""scope
	" Returns the receiver's root scope. "

	scope isNil ifTrue: [ self initializeScope ].
	^scope""",nil)

smalltalk.bind(smalltalk.ScriptParser,"scope:",0
,smalltalk.__f__("""(self,aScope):
	#ScriptParser>>#scope:
	smalltalk.basic_at_put(self,"@scope",aScope) 
	return self 
""","ScriptParser_scope_")
,"accessing","""scope: aScope
	" Set the receiver's root scope. "

	scope := aScope""",nil)

smalltalk.bind(smalltalk.ScriptParser,"semicolon",0
,smalltalk.__f__("""(self):
	#ScriptParser>>#semicolon
	return smalltalk.String(";") 
""","ScriptParser_semicolon")
,"constants","""semicolon
	" Private - Returns the semicolon token. "

	^$;""",nil)

smalltalk.bind(smalltalk.ScriptParser,"singleQuote",0
,smalltalk.__f__("""(self):
	#ScriptParser>>#singleQuote
	return smalltalk.String("'") 
""","ScriptParser_singleQuote")
,"constants","""singleQuote
	" Private - Returns the singleQuote token. "

	^$'""",nil)

smalltalk.bind(smalltalk.ScriptParser,"skip:",0
,smalltalk.__f__("""(self,aCharacter):
	#ScriptParser>>#skip:
	if smalltalk.b(smalltalk.isObject_equalTo_(self.peek(),aCharacter)):
		self.next() 
	 
	return self 
""","ScriptParser_skip_")
,"parsing","""skip: aCharacter
	" Skip aCharacter from source stream if present. "

	self peek = aCharacter ifTrue: [ self next ]""",nil)

smalltalk.bind(smalltalk.ScriptParser,"skipSeparators",0
,smalltalk.__f__("""(self):
	_s8Ret_=smalltalk.newContext()
	try:
		#ScriptParser>>#skipSeparators
		def __blk1__():
			if smalltalk.b(smalltalk.isNil_(self.basicPeek())):
				smalltalk.raise_result_(_s8Ret_,self) 
			 
			return self.basicPeek().isSeparator() 
		while smalltalk.b(smalltalk.blk(__blk1__,0)()):
			getattr(self,"@source",nil).next() 
		 
		smalltalk.raise_result_(_s8Ret_,self) 
	except Exception as __ex:
		if smalltalk.exception_at(__ex,_s8Ret_):
			return smalltalk.exceptionResult_(__ex)
		raise __ex
	
""","ScriptParser_skipSeparators")
,"parsing","""skipSeparators
	" Advance to the source stream to the next non-separator character. "

	[	self basicPeek isNil ifTrue: [ ^self ].
		self basicPeek isSeparator
	] whileTrue: [ source next ]""",nil)

smalltalk.bind(smalltalk.ScriptParser,"specialVariableNamed:",0
,smalltalk.__f__("""(self,aName):
	#ScriptParser>>#specialVariableNamed:
	__0__=smalltalk.newContext()
	def __blk1__(one):
		return smalltalk.isObject_equalTo_(one.name(),aName) 
	def __blk2__():
		nil 
	__0__.index=nil
	if smalltalk.b(smalltalk.isObject_equalTo_(aName,smalltalk.String("self"))):
		return smalltalk.ParseSelf.new() 
	 
	if smalltalk.b(smalltalk.isObject_equalTo_(aName,smalltalk.String("nil"))):
		return smalltalk.ParseUniversal.value_(nil) 
	 
	if smalltalk.b(smalltalk.isObject_equalTo_(aName,smalltalk.String("true"))):
		return smalltalk.ParseUniversal.value_(smalltalk.true) 
	 
	if smalltalk.b(smalltalk.isObject_equalTo_(aName,smalltalk.String("false"))):
		return smalltalk.ParseUniversal.value_(smalltalk.false) 
	 
	if smalltalk.b(smalltalk.isObject_equalTo_(aName,smalltalk.String("super"))):
		return smalltalk.ParseSuper.in_(self.currentClass()) 
	 
	return self.instanceVariables().detect_ifNone_(smalltalk.blk(__blk1__,1),smalltalk.blk(__blk2__,0)) 
""","ScriptParser_specialVariableNamed_")
,"parsing","""specialVariableNamed: aName
	" Private - Returns a variable known by the receiver with name aName. "

	| index |
	aName = #self ifTrue: [ ^ParseSelf new ].
	aName = #nil ifTrue: [ ^ParseUniversal value: nil ].
	aName = #true ifTrue: [ ^ParseUniversal value: true ].
	aName = #false ifTrue: [ ^ParseUniversal value: false ].
	aName = #super ifTrue: [ ^ParseSuper in: self currentClass ].
	^self instanceVariables detect: [:one| one name = aName ] ifNone: [] """,nil)

smalltalk.bind(smalltalk.ScriptParser,"startOfNextToken",0
,smalltalk.__f__("""(self):
	#ScriptParser>>#startOfNextToken
	self.skipSeparators() 
	return self.position() 
""","ScriptParser_startOfNextToken")
,"parsing","""startOfNextToken
	" Advance to next token and return current position. "

	self skipSeparators.
	^self position""",nil)

smalltalk.bind(smalltalk.ScriptParser,"parseStatements:in:innerBlock:",0
,smalltalk.__f__("""(self,statements,aContext,isInnerBlock):
	#ScriptParser>>#parseStatements:in:innerBlock:
	__0__=smalltalk.newContext()
	def __blk1__():
		return __0__.more 
	__0__.returns=nil
	__0__.more=nil
	__0__.expression=nil
	__0__.start=nil
	__0__.origin=nil
	__0__.origin=self.startOfNextToken() 
	__0__.returns=smalltalk.false 
	__0__.more=smalltalk.true 
	while smalltalk.b(smalltalk.blk(__blk1__,0)()):
		def __blk2__():
			def __blk3__():
				return self.match_(self.period()) 
			return smalltalk.boolean_or_(__0__.expression.isPrimitiveNode(),smalltalk.blk(__blk3__,0)) 
		__0__.start=self.startOfNextToken() 
		__0__.returns=self.match_(self.upArrow()) 
		if smalltalk.b(__0__.returns):
			def __blk4__(_s8_rec):
				_s8_rec.expression_(__0__.expression) 
				_s8_rec.sourceRange_(__0__.start.to_(self.position())) 
				return _s8_rec.yourself() 
			__0__.expression=self.expression_(aContext) 
			if smalltalk.b(smalltalk.isNil_(__0__.expression)):
				return self.expected_(smalltalk.String("expression to return")) 
			 
			statements.addLast_(__blk4__(smalltalk.MethodReturnNode.new())) 
		else:
			__0__.expression=self.expression_(aContext) 
			if smalltalk.b(smalltalk.isNil_(__0__.expression)):
				def __blk5__():
					return self.pushNil() 
				def __blk6__():
					return self.pushSelf() 
				__0__.expression=smalltalk.if_true_false_(isInnerBlock,smalltalk.blk(__blk5__,0),smalltalk.blk(__blk6__,0)) 
			 
			statements.addLast_(__0__.expression) 
		 
		if smalltalk.b(__0__.returns):
			self.skip_(self.period()) 
		 
		__0__.more=smalltalk.boolean_and_(smalltalk.booleanNot_(__0__.returns),smalltalk.blk(__blk2__,0)) 
	 
	self.skipSeparators() 
	if not smalltalk.b(self.atEnd()):
		return self.expected_(smalltalk.String("message or period")) 
	 
	statements.sourceRange_(__0__.origin.to_(self.position())) 
	return statements 
""","ScriptParser_parseStatements_in_innerBlock_")
,"parsing","""parseStatements: statements in: aContext innerBlock: isInnerBlock
	" Private - Parse the statements in the receiver looking for variables in aContext. "

	| returns more expression start origin |
	origin := self startOfNextToken.
	returns := false.
	more := true.
	[more] whileTrue: [
		start := self startOfNextToken.
		returns := self match: self upArrow.
		returns ifTrue: [ "Return expression. "
			expression := self expression: aContext.
			expression isNil ifTrue: [ ^self expected: 'expression to return' ].
			statements addLast: (
				MethodReturnNode new
					expression: expression;
					sourceRange: (start to: self position);
					yourself).
		]
		ifFalse: [
			expression := self expression: aContext.
			expression isNil ifTrue: [
				expression := isInnerBlock
					ifTrue: [ self pushNil ]
					ifFalse: [ self pushSelf ]
			].
			statements addLast: expression
		].
		returns ifTrue: [ self skip: self period ].
		more := returns not and: [
			expression isPrimitiveNode or: [
				self match: self period ] ]
	].
	self skipSeparators.
	self atEnd ifFalse: [ ^self expected: 'message or period' ].
	statements sourceRange: (origin to: self position).
	^statements""",nil)

smalltalk.bind(smalltalk.ScriptParser,"statementsArgs:in:",0
,smalltalk.__f__("""(self,argNodes,aScope):
	_s8Ret_=smalltalk.newContext()
	try:
		#ScriptParser>>#statementsArgs:in:
		__0__=smalltalk.newContext()
		def __blk1__():
			def __blk2__():
				def __blk3__(_s8_rec):
					_s8_rec.expression_(__0__.parseNode) 
					_s8_rec.sourcePosition_(__0__.returnStart.to_(self.position())) 
					return _s8_rec.yourself() 
				__0__.returnStart=self.position() 
				__0__.parseNode=self.expression_(__0__.aContext) 
				if smalltalk.b(smalltalk.isNil_(__0__.parseNode)):
					smalltalk.raise_result_(_s8Ret_,self.expected_(smalltalk.String("expression to return"))) 
				 
				__0__.parseNode=__blk3__(smalltalk.MethodReturnNode.new()) 
				__0__.stmts.addLast_(__0__.parseNode) 
				self.match_(self.period()) 
				return smalltalk.false 
			def __blk4__():
				def __blk5__():
					__0__.stmts.addLast_(__0__.parseNode) 
					return self.match_(self.period()) 
				def __blk6__():
					return smalltalk.false 
				__0__.parseNode=self.expression_(__0__.aContext) 
				return smalltalk.if_true_false_(smalltalk.notNil_(__0__.parseNode),smalltalk.blk(__blk5__,0),smalltalk.blk(__blk6__,0)) 
			return smalltalk.if_true_false_(self.match_(self.upArrow()),smalltalk.blk(__blk2__,0),smalltalk.blk(__blk4__,0)) 
		__0__.stmts=nil
		__0__.start=nil
		__0__.returnStart=nil
		__0__.parseNode=nil
		__0__.aContext=nil
		__0__.aContext=aScope 
		__0__.stmts=smalltalk.BlockClosureNode.new() 
		__0__.stmts.arguments_(argNodes) 
		__0__.start=self.position() 
		self.skipSeparators() 
		if smalltalk.b(self.match_(self.verticalBar())):
			__0__.aContext=smalltalk.ParseContext.in_(__0__.aContext) 
			__0__.stmts.temporaries_(self.parseTemporaries_(__0__.aContext)) 
		 
		while smalltalk.b(smalltalk.blk(__blk1__,0)()):
			pass
		 
		__0__.stmts.sourcePosition_(__0__.start.to_(self.position())) 
		smalltalk.raise_result_(_s8Ret_,__0__.stmts) 
	except Exception as __ex:
		if smalltalk.exception_at(__ex,_s8Ret_):
			return smalltalk.exceptionResult_(__ex)
		raise __ex
	
""","ScriptParser_statementsArgs_in_")
,"parsing","""statementsArgs: argNodes in: aScope
	" Private - Parse the receiver looking for a statements in a block using variables in aScope.
	Returns nil if failed.
	<node> $[ ($: var)* temporaries statements $] => BlockClosureNode
	"

	| stmts start returnStart parseNode aContext |
	aContext := aScope.
	stmts := BlockClosureNode new.
	stmts arguments: argNodes.		
	start := self position.
	self skipSeparators.
	(self match: self verticalBar) ifTrue: [ 
		aContext := ParseContext in: aContext.
		stmts temporaries: (self parseTemporaries: aContext).
	].
	[	(self match: self upArrow) ifTrue: [
			returnStart := self position.
			parseNode := self expression: aContext.
			parseNode isNil ifTrue: [ ^self expected: 'expression to return' ].
			parseNode := MethodReturnNode new
				expression: parseNode;
				sourcePosition: (returnStart to: self position);
				yourself.
			stmts addLast: parseNode.
			self match: self period.
			false
		] ifFalse: [
			parseNode := self expression: aContext.
			parseNode notNil ifTrue: [
				stmts addLast: parseNode.
				self match: self period
			] ifFalse: [false]
		]
	] whileTrue: [].
	stmts sourcePosition: (start to: self position).
	^stmts""",nil)

smalltalk.bind(smalltalk.ScriptParser,"upArrow",0
,smalltalk.__f__("""(self):
	#ScriptParser>>#upArrow
	return smalltalk.String("^") 
""","ScriptParser_upArrow")
,"constants","""upArrow
	" Private - Returns the upArrow token. "

	^$^""",nil)

smalltalk.bind(smalltalk.ScriptParser,"verticalBar",0
,smalltalk.__f__("""(self):
	#ScriptParser>>#verticalBar
	return smalltalk.String("|") 
""","ScriptParser_verticalBar")
,"constants","""verticalBar
	" Private - Returns the verticalBar token. "

	^$|""",nil)

smalltalk.bind(smalltalk.ScriptParser,"nextMessage:in:",0
,smalltalk.__f__("""(self,args,aContext):
	_s8Ret_=smalltalk.newContext()
	try:
		#ScriptParser>>#nextMessage:in:
		__0__=smalltalk.newContext()
		def __blk1__():
			self.skipSeparators() 
			return __0__.selector 
		def __blk2__():
			__1__=smalltalk.newContext()
			def __blk3__():
				__1__.arg.canBeAssigned_(smalltalk.true) 
				return args.addLast_(__1__.arg) 
			__1__.arg=nil
			__1__.arg=self.nextArgument_(aContext) 
			return smalltalk.if_true_false_(smalltalk.notNil_(__1__.arg),smalltalk.blk(__blk3__,0),nil) 
		def __blk4__():
			__0__.start=self.startOfNextToken() 
			__0__.part=self.nextWord() 
			if smalltalk.b(smalltalk.isNil_(__0__.part)):
				smalltalk.raise_result_(_s8Ret_,__0__.exit.value()) 
			 
			return smalltalk.isObject_equalTo_(self.basicPeek(),self.colon()) 
		__0__.exit=nil
		__0__.nextArg=nil
		__0__.start=nil
		__0__.selector=nil
		__0__.part=nil
		__0__.start=self.startOfNextToken() 
		__0__.selector=self.nextSelector() 
		__0__.exit=smalltalk.blk(__blk1__,0) 
		__0__.nextArg=smalltalk.blk(__blk2__,0) 
		if not smalltalk.b(smalltalk.isObject_equalTo_(__0__.selector.last(),self.colon())):
			def __blk5__():
				def __blk6__():
					return smalltalk.raise_result_(_s8Ret_,self.expected_(smalltalk.String("argument"))) 
				return smalltalk.if_true_false_(smalltalk.isNil_(__0__.nextArg.value()),smalltalk.blk(__blk6__,0),nil) 
			smalltalk.times_repeat_(__0__.selector.argumentCount(),smalltalk.blk(__blk5__,0)) 
			smalltalk.raise_result_(_s8Ret_,__0__.exit.value()) 
		 
		__0__.nextArg.value() 
		while smalltalk.b(smalltalk.blk(__blk4__,0)()):
			__0__.part=smalltalk.object_comma_(__0__.part,self.next()) 
			if smalltalk.b(smalltalk.isNil_(__0__.nextArg.value())):
				self.position_(__0__.start) 
				smalltalk.raise_result_(_s8Ret_,__0__.selector) 
			 
			__0__.selector=smalltalk.object_comma_(__0__.selector,__0__.part) 
		 
		self.position_(__0__.start) 
		smalltalk.raise_result_(_s8Ret_,__0__.exit.value()) 
	except Exception as __ex:
		if smalltalk.exception_at(__ex,_s8Ret_):
			return smalltalk.exceptionResult_(__ex)
		raise __ex
	
""","ScriptParser_nextMessage_in_")
,"parsing","""nextMessage: args in: aContext
	" Private - Returns the selector from next message header.
	<rule> message = (selector | (selector $: argument)*) [comment]
	"

	| exit nextArg start selector part |
	start := self startOfNextToken.
	selector := self nextSelector.
	exit := [ self skipSeparators. selector ].
	nextArg := [ | arg |
		arg := self nextArgument: aContext.
		arg notNil ifTrue: [
			arg canBeAssigned: true.
			args addLast: arg
		]
	].
	selector last = self colon ifFalse: [
		selector argumentCount timesRepeat: [
			nextArg value isNil ifTrue: [
				^self expected: #argument
			]
		].
		^exit value
	].
	nextArg value.
	[	start := self startOfNextToken.
		part := self nextWord.
		part isNil ifTrue: [ ^exit value ].
		self basicPeek = self colon
	] whileTrue: [
		part := part ,self next.
		nextArg value isNil ifTrue: [
			self position: start.
			^selector
		].
		selector := selector ,part.
	].
	self position: start.
	^exit value""",nil)

smalltalk.bind(smalltalk.ScriptParser,"methodScope:for:",0
,smalltalk.__f__("""(self,aCompiledScript,statements):
	#ScriptParser>>#methodScope:for:
	__0__=smalltalk.newContext()
	__0__.args=nil
	__0__.selector=nil
	__0__.ctx=nil
	__0__.ctx=smalltalk.ParseContext.new() 
	__0__.args=smalltalk.newArray([]) 
	aCompiledScript.args_(__0__.args) 
	__0__.selector=self.nextMessage_in_(__0__.args,__0__.ctx) 
	aCompiledScript.selector_(__0__.selector) 
	if smalltalk.b(__0__.args.notEmpty()):
		__0__.ctx.parent_(self.scope()) 
		smalltalk.basic_at_put(self,"@scope",__0__.ctx) 
	 
	return self.bodyScope_(statements) 
""","ScriptParser_methodScope_for_")
,"parsing","""methodScope: aCompiledScript for: statements
	" Private - Returns a context for parsing aCompiledScript.
	<rule> compiledScript = message script.
	<rule> message = (selector [[:] argument]...) [comment].
	"

	| args selector ctx |
	ctx := ParseContext new.
	args := #().
	aCompiledScript args: args.
	selector := self nextMessage: args in: ctx.
	aCompiledScript selector: selector.
	args notEmpty ifTrue: [
		ctx parent: self scope.
		scope := ctx.
	].
	^self bodyScope: statements""",nil)

smalltalk.bind(smalltalk.ScriptParser,"methodReturn",0
,smalltalk.__f__("""(self):
	#ScriptParser>>#methodReturn
	return smalltalk.MethodReturnNode.from_to_(self.position(),self.position()).expression_(smalltalk.ParseSelf.new()) 
""","ScriptParser_methodReturn")
,"parsing","""methodReturn
	" Private - Returns an implisit return node. "

	^(MethodReturnNode
		from: self position to: self position)
		expression: ParseSelf new """,nil)

smalltalk.bind(smalltalk.ScriptParser,"parseMethod:",0
,smalltalk.__f__("""(self,aCompiledScript):
	#ScriptParser>>#parseMethod:
	__0__=smalltalk.newContext()
	def __blk1__():
		return smalltalk.booleanNot_(__0__.body.statements().last().isReturn()) 
	__0__.body=nil
	__0__.methodScope=nil
	__0__.statements=nil
	__0__.statements=smalltalk.ParseStatements.new() 
	__0__.methodScope=self.methodScope_for_(aCompiledScript,__0__.statements) 
	__0__.body=self.parseStatements_in_innerBlock_(__0__.statements,__0__.methodScope,smalltalk.false) 
	if not smalltalk.b(smalltalk.responds_to_(__0__.body,(smalltalk.String("isEmpty")))):
		return nil 
	 
	if smalltalk.b(smalltalk.boolean_or_(__0__.body.isEmpty(),smalltalk.blk(__blk1__,0))):
		__0__.body.statements().add_(self.methodReturn()) 
	 
	aCompiledScript.script_(smalltalk.Script.with_(__0__.body)) 
	return self 
""","ScriptParser_parseMethod_")
,"parsing","""parseMethod: aCompiledScript
	" Private - Parse method (aCompiledScript) reading from source stream. "

	| body methodScope statements |
	statements := ParseStatements new.
	methodScope := self methodScope: aCompiledScript for: statements.
	body := self parseStatements: statements in: methodScope innerBlock: false.
	(body respondsTo: #isEmpty) ifFalse: [ ^nil ].
	(body isEmpty or: [body statements last isReturn not]) ifTrue: [
		body statements add: self methodReturn
	].
	aCompiledScript script: (Script with: body)""",nil)

smalltalk.bind(smalltalk.ScriptParser,"parse:method:onError:",0
,smalltalk.__f__("""(self,aString,aCompiledScript,aBlock):
	#ScriptParser>>#parse:method:onError:
	def __blk1__():
		self.currentClass_(aCompiledScript.classField()) 
		self.parseMethod_(aCompiledScript) 
		return aCompiledScript.source_(aString) 
	self.parse_doing_onError_(aString,smalltalk.blk(__blk1__,0),aBlock) 
	return self 
""","ScriptParser_parse_method_onError_")
,"scripting","""parse: aString method: aCompiledScript onError: aBlock
	" Parse aString as method source code implemented in aCompiledScript.
	Returns the receiver.
	See ScriptCompiler framework to learn more on #scripting.
	"

	self parse: aString doing: [
		self currentClass: aCompiledScript classField.
		self parseMethod: aCompiledScript.
		aCompiledScript source: aString.
		] onError: aBlock""",nil)

smalltalk.bind(smalltalk.ScriptingError.__class__,"description:",0
,smalltalk.__f__("""(self,aString):
	#ScriptingError class>>#description:
	def __blk1__(_s8_rec):
		_s8_rec.description_(aString) 
		return _s8_rec.yourself() 
	return __blk1__(self.new()) 
""","ScriptingError_class_description_")
,"accessing","""description: aString
	" Returns an instance of the receiver with description aString. "

	^self new
		description: aString;
		yourself""",nil)

smalltalk.bind(smalltalk.ScriptingError,"isParseFailure",0
,smalltalk.__f__("""(self):
	#ScriptingError>>#isParseFailure
	return smalltalk.true 
""","ScriptingError_isParseFailure")
,"testing","""isParseFailure
	" Return true if the receiver is a parse failure. "

	^true""",nil)

smalltalk.bind(smalltalk.ScriptingError,"description",0
,smalltalk.__f__("""(self):
	#ScriptingError>>#description
	if smalltalk.b(smalltalk.isNil_(getattr(self,"@description",nil))):
		self.initializeDescription() 
	 
	return getattr(self,"@description",nil) 
""","ScriptingError_description")
,"accessing","""description
	" Returns the receiver's description string. "

	description isNil ifTrue: [ self initializeDescription ].
	^description""",nil)

smalltalk.bind(smalltalk.ScriptingError,"description:",0
,smalltalk.__f__("""(self,aText):
	#ScriptingError>>#description:
	smalltalk.basic_at_put(self,"@description",aText) 
	return self 
""","ScriptingError_description_")
,"accessing","""description: aText
	" Set the receiver's description string. "

	description := aText""",nil)

smalltalk.bind(smalltalk.ScriptingError,"initializeDescription",0
,smalltalk.__f__("""(self):
	#ScriptingError>>#initializeDescription
	smalltalk.basic_at_put(self,"@description",smalltalk.String("*Error*")) 
	return self 
""","ScriptingError_initializeDescription")
,"initialize","""initializeDescription
	" Private - Initializes the receiver's description. "

	description := '*Error*'""",nil)

smalltalk.bind(smalltalk.ScriptingError,"descriptionString",0
,smalltalk.__f__("""(self):
	#ScriptingError>>#descriptionString
	return self.description() 
""","ScriptingError_descriptionString")
,"printing","""descriptionString
	" Returns the receiver's description as shown to the user. "

	^self description""",nil)

smalltalk.bind(smalltalk.ScriptingError,"printOn:",0
,smalltalk.__f__("""(self,aStream):
	#ScriptingError>>#printOn:
	def __blk1__(_s8_rec):
		_s8_rec.nextPutAll_(smalltalk.object_comma_((self).__class__.name(),smalltalk.String(": "))) 
		return _s8_rec.nextPutAll_(self.descriptionString()) 
	__blk1__(aStream) 
	return self 
""","ScriptingError_printOn_")
,"printing","""printOn: aStream
	" Append to the argument aStream, a sequence of characters that describes the receiver. "

	aStream
		nextPutAll: self class name ,': ';
		nextPutAll: self descriptionString""",nil)

smalltalk.bind(smalltalk.ParseError,"position",0
,smalltalk.__f__("""(self):
	#ParseError>>#position
	return getattr(self,"@position",nil) 
""","ParseError_position")
,"accessing","""position
	" Returns the receiver's position. "

	^position""",nil)

smalltalk.bind(smalltalk.ParseError,"position:",0
,smalltalk.__f__("""(self,index):
	#ParseError>>#position:
	smalltalk.basic_at_put(self,"@position",index) 
	return self 
""","ParseError_position_")
,"accessing","""position: index
	" Set the receiver's position. "

	position := index""",nil)

smalltalk.bind(smalltalk.ParseError,"source",0
,smalltalk.__f__("""(self):
	#ParseError>>#source
	return getattr(self,"@source",nil) 
""","ParseError_source")
,"accessing","""source
	" Returns the receiver's source. "

	^source""",nil)

smalltalk.bind(smalltalk.ParseError,"source:",0
,smalltalk.__f__("""(self,aString):
	#ParseError>>#source:
	smalltalk.basic_at_put(self,"@source",aString) 
	return self 
""","ParseError_source_")
,"accessing","""source: aString
	" Set the receiver's source. "

	source := aString""",nil)

smalltalk.bind(smalltalk.ParseError,"descriptionString",0
,smalltalk.__f__("""(self):
	#ParseError>>#descriptionString
	__0__=smalltalk.newContext()
	__0__.stream=nil
	if smalltalk.b(smalltalk.isNil_(self.source())):
		return smalltalk.superReceiver(smalltalk.ParseError,self).descriptionString() 
	 
	__0__.stream=self.source().stream() 
	return smalltalk.object_comma_(smalltalk.object_comma_(smalltalk.object_comma_(smalltalk.object_comma_(smalltalk.object_comma_(smalltalk.String(" "),__0__.stream.next_(self.position().min_(__0__.stream.size()))),smalltalk.String("<---")),self.description()),smalltalk.String(" ")),__0__.stream.upToEnd()) 
""","ParseError_descriptionString")
,"printing","""descriptionString
	" Returns the receiver's description as shown to the user. "

	| stream |
	self source isNil ifTrue: [ ^super descriptionString ].
	stream := self source stream.
	^' '
	,(stream next: (self position min: stream size))
	,'<---' ,self description
	,' ' ,stream upToEnd""",nil)

smalltalk.bind(smalltalk.SyntaxError,"initializeDescription",0
,smalltalk.__f__("""(self):
	#SyntaxError>>#initializeDescription
	smalltalk.basic_at_put(self,"@description",smalltalk.String("Syntax Error")) 
	return self 
""","SyntaxError_initializeDescription")
,"initialize","""initializeDescription
	" Private - Initializes the receiver's description. "

	description := 'Syntax Error'""",nil)