'From Squeak4.5 of 23 January 2014 [latest update: #13257] on 26 February 2014 at 9:36:32 am'!

!ContextPart methodsFor: 'mirror primitives' stamp: 'eem 5/13/2009 14:21'!
object: anObject basicAt: index 
	"Answer the value of an indexable element in the argument anObject without sending
	 it a message. Fail if the argument index is not an Integer or is out of bounds, or if
	 anObject is not indexable. This mimics the action of the VM when it indexes an object.
	 Used to simulate the execution machinery by, for example, the debugger.
	 Primitive.  See Object documentation whatIsAPrimitive."

	<primitive: 60>
	index isInteger ifTrue: [self errorSubscriptBounds: index].
	index isNumber
		ifTrue: [^self object: anObject basicAt: index asInteger]
		ifFalse: [self errorNonIntegerIndex]! !

!ContextPart methodsFor: 'mirror primitives' stamp: 'eem 5/13/2009 14:21'!
object: anObject basicAt: index put: value 
	"Store the last argument 
	 value in the indexable element of the argument anObject indicated by index without sending
	 anObject a message. Fail if the argument index is not an Integer or is out of bounds, or if
	 anObject is not indexable, or if value is an inappropriate value for anObject's indexable slots.
	 This mimics the action of the VM when it indexes an object.
	 Used to simulate the execution machinery by, for example, the debugger.
	 Primitive.  See Object documentation whatIsAPrimitive."

	<primitive: 61>
	index isInteger
		ifTrue: [(index >= 1 and: [index <= (self objectSize: anObject)])
					ifTrue: [self errorImproperStore]
					ifFalse: [self errorSubscriptBounds: index]].
	index isNumber
		ifTrue: [^self object: anObject basicAt: index asInteger put: value]
		ifFalse: [self errorNonIntegerIndex]! !

!ContextPart methodsFor: 'mirror primitives' stamp: 'eem 5/13/2009 14:23'!
object: anObject eqeq: anOtherObject 
	"Answer whether the first and second arguments are the same object (have the
	 same object pointer) without sending a message to the first argument.  This
	 mimics the action of the VM when it compares two object pointers.  Used to
	 simulate the execution machinery by, for example, the debugger.
	 Primitive.  See Object documentation whatIsAPrimitive."

	<primitive: 110>
	self primitiveFailed! !

!ContextPart methodsFor: 'mirror primitives' stamp: 'eem 4/8/2009 19:27'!
object: anObject instVarAt: anIndex
	"Primitive. Answer a fixed variable in an object. The numbering of the 
	 variables corresponds to the named instance variables. Fail if the index 
	 is not an Integer or is not the index of a fixed variable. Essential for the
	 debugger. See  Object documentation whatIsAPrimitive."

	<primitive: 73>
	"Access beyond fixed variables."
	^self object: anObject basicAt: anIndex - (self objectClass: anObject) instSize! !

!ContextPart methodsFor: 'mirror primitives' stamp: 'eem 4/8/2009 19:30'!
object: anObject instVarAt: anIndex put: aValue 
	"Primitive. Store a value into a fixed variable in the argument anObject.
	 The numbering of the variables corresponds to the named instance
	 variables.  Fail if the index is not an Integer or is not the index of a
	 fixed variable.  Answer the value stored as the result. Using this
	 message violates the  principle that each object has sovereign control
	 over the storing of values into its instance variables. Essential for the
	 debugger. See Object documentation whatIsAPrimitive."

	<primitive: 74>
	"Access beyond fixed fields"
	^self object: anObject basicAt: anIndex - (self objectClass: anObject) instSize put: aValue! !

!ContextPart methodsFor: 'mirror primitives' stamp: 'dtl 12/11/2011 19:39'!
object: anObject perform: selector withArguments: argArray inClass: lookupClass
	"Send the selector, aSymbol, to anObject with arguments in argArray.
	 Fail if the number of arguments expected by the selector 
	 does not match the size of argArray, or if lookupClass
	 cannot be found among the anObject's superclasses.
	 Primitive. Essential for the debugger."

	<primitive: 100 error: error>
	(selector isSymbol) ifFalse:
		[^self error: 'selector argument must be a Symbol'].
	(argArray isMemberOf: Array) ifFalse:
		[^self error: 'argArray must be an Array'].
	(selector numArgs = argArray size)
		ifFalse: [^self error: 'incorrect number of arguments'].
	((self objectClass: anObject) == lookupClass
	 or: [(self objectClass: anObject) inheritsFrom: lookupClass]) ifFalse:
		[^self error: 'lookupClass is not in anObject''s inheritance chain'].
	self primitiveFailed! !

!ContextPart methodsFor: 'mirror primitives' stamp: 'eem 5/13/2009 14:21'!
objectClass: anObject
	"Answer the class of the argument anObject without sending it a message.
	 This mimics the action of the VM when it fetches an object's class.  Used to
	 simulate the execution machinery by, for example, the debugger.
	 Primitive.  See Object documentation whatIsAPrimitive."

	<primitive: 111>
	self primitiveFailed! !

!ContextPart methodsFor: 'mirror primitives' stamp: 'eem 5/13/2009 14:21'!
objectSize: anObject
	"Answer the number of indexable variables in the argument anObject without sending
	 it a message. This mimics the action of the VM when it fetches an object's variable size.
	 Used to simulate the execution machinery by, for example, the debugger.
	 Primitive.  See Object documentation whatIsAPrimitive."

	<primitive: 62>
	"The number of indexable fields of fixed-length objects is 0"
	^0! !

!BlockClosure methodsFor: 'system simulation' stamp: 'eem 12/7/2011 12:21'!
simulateValueWithArguments: anArray caller: aContext
	| newContext sz |
	(anArray class ~~ Array
	 or: [numArgs ~= anArray size]) ifTrue:
		[^ContextPart primitiveFailTokenFor: nil].
	newContext := (MethodContext newForMethod: outerContext method)
						setSender: aContext
						receiver: outerContext receiver
						method: outerContext method
						closure: self
						startpc: startpc.
	sz := self basicSize.
	newContext stackp: sz + numArgs.
	1 to: numArgs do:
		[:i| newContext at: i put: (anArray at: i)].
	1 to: sz do:
		[:i| newContext at: i + numArgs put: (self at: i)].
	^newContext! !
InstructionStream subclass: #ContextPart
	instanceVariableNames: 'stackp'
	classVariableNames: 'MaxLengthForASingleDebugLogReport MaxStackDepthForASingleDebugLogReport PrimitiveFailToken QuickStep ValueIndex'
	poolDictionaries: ''
	category: 'Kernel-Methods'!
!ContextPart commentStamp: '<historical>' prior: 0!
To the instruction parsing ability of InstructionStream I add the actual semantics for execution. The execution state is stored in the indexable fields of my subclasses. This includes temporary variables and a stack of values used in evaluating expressions. The actual semantics of execution can be found in my category "system simulation" and "instruction decode". These methods exactly parallel the operation of the Smalltalk machine itself.
	
The simulator is a group of my methods that do what the Smalltalk interpreter does: execute Smalltalk bytecodes. By adding code to the simulator, you may take statistics on the running of Smalltalk methods. For example,
	Transcript show: (ContextPart runSimulated: [3 factorial]) printString.!

!ContextPart class methodsFor: 'class initialization' stamp: 'eem 12/7/2011 12:32'!
initialize
	ValueIndex := 2.
	self assert: (Association instVarNameForIndex:ValueIndex) = 'value'.
	PrimitiveFailToken class ~~ Object ifTrue:
		[PrimitiveFailToken := Object new]! !

!ContextPart class methodsFor: 'simulation' stamp: 'eem 1/4/2009 09:32'!
primitiveFailTokenFor: errorCode

	^{PrimitiveFailToken. errorCode}! !

!ContextPart methodsFor: 'private' stamp: 'eem 9/21/2012 15:01'!
doPrimitive: primitiveIndex method: meth receiver: receiver args: arguments 
	"Simulate a primitive method whose index is primitiveIndex.  The
	 simulated receiver and arguments are given as arguments to this message.
	 If successful, push result and return resuming context, else ^ PrimitiveFailToken.
	 Any primitive which provokes execution needs to be intercepted and simulated
	 to avoid execution running away."

	| value |
	"Judicious use of primitive 19 (a null primitive that doesn't do anything) prevents
	 the debugger from entering various run-away activities such as spawning a new
	 process, etc.  Injudicious use results in the debugger not being able to debug
	 interesting code, such as the debugger itself.  hence use primtiive 19 with care :-)"
	"SystemNavigation new browseAllSelect: [:m| m primitive = 19]"
	primitiveIndex = 19 ifTrue:
		[ToolSet 
			debugContext: self
			label:'Code simulation error'
			contents: nil].

	"ContextPart>>blockCopy:; simulated to get startpc right"
	(primitiveIndex = 80 and: [(self objectClass: receiver) includesBehavior: ContextPart]) 
		ifTrue: [^self push: ((BlockContext newForMethod: receiver method)
						home: receiver home
						startpc: pc + 2
						nargs: (arguments at: 1))].
	(primitiveIndex = 81 and: [(self objectClass: receiver) == BlockContext]) "BlockContext>>value[:value:...]"
		ifTrue: [^receiver pushArgs: arguments from: self].
	(primitiveIndex = 82 and: [(self objectClass: receiver) == BlockContext]) "BlockContext>>valueWithArguments:"
		ifTrue: [^receiver pushArgs: arguments first from: self].
	primitiveIndex = 83 "afr 9/11/1998 19:50" "Object>>perform:[with:...]"
		ifTrue: [^self send: arguments first
					to: receiver
					with: arguments allButFirst
					super: false].
	primitiveIndex = 84 "afr 9/11/1998 19:50 & eem 8/18/2009 17:04" "Object>>perform:withArguments:"
		ifTrue: [^self send: arguments first
					to: receiver
					with: (arguments at: 2)
					startClass: nil].
	primitiveIndex = 100 "eem 8/18/2009 16:57" "Object>>perform:withArguments:inSuperclass:"
		ifTrue: [^self send: arguments first
					to: receiver
					with: (arguments at: 2)
					startClass: (arguments at: 3)].

	"Mutex>>primitiveEnterCriticalSection
	 Mutex>>primitiveTestAndSetOwnershipOfCriticalSection"
	(primitiveIndex = 186 or: [primitiveIndex = 187]) ifTrue:
		[| active effective |
		 active := Processor activeProcess.
		 effective := active effectiveProcess.
		 "active == effective"
		 value := primitiveIndex = 186
					ifTrue: [receiver primitiveEnterCriticalSectionOnBehalfOf: effective]
					ifFalse: [receiver primitiveTestAndSetOwnershipOfCriticalSectionOnBehalfOf: effective].
		 ^((self objectClass: value) == Array
		    and: [value size = 2
		    and: [value first == PrimitiveFailToken]])
			ifTrue: [value]
			ifFalse: [self push: value]].

	primitiveIndex = 188 ifTrue: "eem 5/27/2008 11:10 Object>>withArgs:executeMethod:"
		[^MethodContext
			sender: self
			receiver: receiver
			method: (arguments at: 2)
			arguments: (arguments at: 1)].

	"Closure primitives"
	(primitiveIndex = 200 and: [self == receiver]) ifTrue:
		"ContextPart>>closureCopy:copiedValues:; simulated to get startpc right"
		[^self push: (BlockClosure
						outerContext: receiver
						startpc: pc + 2
						numArgs: arguments first
						copiedValues: arguments last)].
	((primitiveIndex between: 201 and: 205)			 "BlockClosure>>value[:value:...]"
	or: [primitiveIndex between: 221 and: 222]) ifTrue: "BlockClosure>>valueNoContextSwitch[:]"
		[^receiver simulateValueWithArguments: arguments caller: self].
	primitiveIndex = 206 ifTrue:						"BlockClosure>>valueWithArguments:"
		[^receiver simulateValueWithArguments: arguments first caller: self].

	primitiveIndex = 118 ifTrue: "tryPrimitive:withArgs:; avoid recursing in the VM"
		[(arguments size = 2
		 and: [arguments first isInteger
		 and: [(self objectClass: arguments last) == Array]]) ifFalse:
			[^ContextPart primitiveFailTokenFor: nil].
		 ^self doPrimitive: arguments first method: meth receiver: receiver args: arguments last].

	value := primitiveIndex = 120 "FFI method"
				ifTrue: [(meth literalAt: 1) tryInvokeWithArguments: arguments]
				ifFalse:
					[primitiveIndex = 117 "named primitives"
						ifTrue: [self tryNamedPrimitiveIn: meth for: receiver withArgs: arguments]
						ifFalse:
							[receiver tryPrimitive: primitiveIndex withArgs: arguments]].
	^((self objectClass: value) == Array
	    and: [value size = 2
	    and: [value first == PrimitiveFailToken]])
		ifTrue: [value]
		ifFalse: [self push: value]! !

!ContextPart methodsFor: 'mirror primitives' stamp: 'eem 5/13/2009 14:21'!
objectClass: anObject
	"Answer the class of the argument anObject without sending it a message.
	 This mimics the action of the VM when it fetches an object's class.  Used to
	 simulate the execution machinery by, for example, the debugger.
	 Primitive.  See Object documentation whatIsAPrimitive."

	<primitive: 111>
	self primitiveFailed! !

!ContextPart methodsFor: 'instruction decoding' stamp: 'eem 5/12/2009 11:58'!
popIntoLiteralVariable: value 
	"Simulate the action of bytecode that removes the top of the stack and 
	stores it into a literal variable of my method."

	self object: value instVarAt: ValueIndex put: self pop! !

!ContextPart methodsFor: 'instruction decoding' stamp: 'eem 5/12/2009 12:00'!
popIntoReceiverVariable: offset 
	"Simulate the action of bytecode that removes the top of the stack and 
	stores it into an instance variable of my receiver."

	self object: self receiver instVarAt: offset + 1 put: self pop! !

!ContextPart methodsFor: 'instruction decoding' stamp: 'eem 5/12/2009 13:07'!
popIntoRemoteTemp: remoteTempIndex inVectorAt: tempVectorIndex
	"Simulate the action of bytecode that removes the top of the stack and  stores
	 it into an offset in one of my local variables being used as a remote temp vector."

	self object: (self at: tempVectorIndex + 1) basicAt: remoteTempIndex + 1 put: self pop! !

!ContextPart methodsFor: 'printing' stamp: 'eem 11/30/2013 12:45'!
printOn: aStream 
	| method selector class mclass |
	(method := self method) ifNil: [^super printOn: aStream].
	class := self objectClass: self receiver.
	mclass := method methodClass.
	selector := method selector ifNil: [method defaultSelector].
	aStream nextPutAll: class name.
	mclass ~~ class ifTrue:
		[aStream nextPut: $(; nextPutAll: mclass name; nextPut: $)].
	aStream nextPutAll: '>>'; nextPutAll: selector.
	(selector == #doesNotUnderstand:
	 and: [self closure isNil
	 and: [(self objectClass: (self tempAt: 1)) == Message]]) ifTrue:
		[aStream space.
		(self tempAt: 1) selector printOn: aStream]! !

!ContextPart methodsFor: 'instruction decoding' stamp: 'eem 5/12/2009 11:59'!
pushLiteralVariable: value 
	"Simulate the action of bytecode that pushes the contents of the literal 
	variable whose index is the argument, index, on the top of the stack."

	self push: (self object: value instVarAt: ValueIndex)! !

!ContextPart methodsFor: 'instruction decoding' stamp: 'eem 5/12/2009 12:00'!
pushReceiverVariable: offset 
	"Simulate the action of bytecode that pushes the contents of the receiver's 
	instance variable whose index is the argument, index, on the top of the 
	stack."

	self push: (self object: self receiver instVarAt: offset + 1)! !

!ContextPart methodsFor: 'instruction decoding' stamp: 'eem 5/12/2009 13:07'!
pushRemoteTemp: remoteTempIndex inVectorAt: tempVectorIndex
	"Simulate the action of bytecode that pushes the value at remoteTempIndex
	 in one of my local variables being used as a remote temp vector."
	self push: (self object: (self at: tempVectorIndex + 1) basicAt: remoteTempIndex + 1)! !

!ContextPart methodsFor: 'controlling' stamp: 'eem 5/12/2009 21:23'!
quickSend: selector to: receiver with: arguments super: superFlag
	"Send the given selector with arguments in an environment which closely resembles
	 the non-simulating environment, with an interjected unwind-protected block to catch
	 nonlocal returns.  Attention: don't get lost!!  This beautiful method is due to
	 Hans-Martin Mosner.  Eliot Miranda merely added the mirror primitive code."
	| oldSender contextToReturnTo result lookupClass |
	contextToReturnTo := self.
	lookupClass := superFlag
					ifTrue: [self method methodClassAssociation value superclass]
					ifFalse: [self objectClass: self receiver].
	[oldSender := thisContext sender swapSender: self.
	result := self object: receiver perform: selector withArguments: arguments inClass: lookupClass.
	thisContext sender swapSender: oldSender] ifCurtailed:
		[contextToReturnTo := thisContext sender receiver.	"The block context returning nonlocally"
		contextToReturnTo jump: -1.	"skip to front of return bytecode causing this unwind"
		contextToReturnTo nextByte = 16r7C ifTrue:
			"If it was a returnTop, push the value to be returned.
			Otherwise the value is implicit in the bytecode"
			[contextToReturnTo push: (thisContext sender tempAt: 1)].
		thisContext swapSender: thisContext home sender.	"Make this block return to the method's sender"
		contextToReturnTo].
	contextToReturnTo push: result.
	^contextToReturnTo! !

!ContextPart methodsFor: 'controlling' stamp: 'eem 9/21/2012 15:11'!
send: selector to: rcvr with: args startClass: startClassOrNil 
	"Simulate the action of sending a message with selector, selector, and
	 arguments, args, to receiver. The argument, startClassOrNil, tells whether
	 the selector should be looked up in startClassOrNil or the class of the receiver."

	| class meth val ctxt |
	class := startClassOrNil ifNil: [self objectClass: rcvr].
	meth := class lookupSelector: selector.
	meth == nil ifTrue:
		[^self
			send: #doesNotUnderstand:
			to: rcvr
			with: (Array with: (Message selector: selector arguments: args))
			startClass: class].
	(args isArray
	 and: [args size = meth numArgs]) ifFalse:
		[^ContextPart primitiveFailTokenFor: nil].
	val := self tryPrimitiveFor: meth receiver: rcvr args: args.
	((self objectClass: val) == Array
	 and: [val size = 2
	 and: [val first == PrimitiveFailToken]]) ifFalse:
		[^val].
	(selector == #doesNotUnderstand:
	 and: [class == ProtoObject]) ifTrue:
		[^self error: 'Simulated message ' , (args at: 1) selector, ' not understood'].
	ctxt := self activateMethod: meth withArgs: args receiver: rcvr class: class.
	((self objectClass: val) == Array
	 and: [val size = 2
	 and: [val first == PrimitiveFailToken
	 and: [val last notNil
	 and: [(ctxt method at: ctxt pc) = 129 "long store temp"]]]]) ifTrue:
		[ctxt at: ctxt stackPtr put: val last].
	^ctxt! !

!ContextPart methodsFor: 'controlling' stamp: 'eem 9/21/2012 15:02'!
send: selector to: rcvr with: args super: superFlag 
	"Simulate the action of sending a message with selector, selector, and
	 arguments, args, to receiver. The argument, superFlag, tells whether the
	 receiver of the message was specified with 'super' in the source method."

	| class meth val ctxt |
	class := superFlag
				ifTrue: [self method methodClassAssociation value superclass]
					ifFalse: [self objectClass: rcvr].
	meth := class lookupSelector: selector.
	meth == nil ifTrue:
		[^self
			send: #doesNotUnderstand:
			to: rcvr
			with: (Array with: (Message selector: selector arguments: args))
			super: superFlag].
	val := self tryPrimitiveFor: meth receiver: rcvr args: args.
	((self objectClass: val) == Array
	 and: [val size = 2
	 and: [val first == PrimitiveFailToken]]) ifFalse:
		[^val].
	(selector == #doesNotUnderstand:
	 and: [class == ProtoObject]) ifTrue:
		[^self error: 'Simulated message ' , (args at: 1) selector, ' not understood'].
	ctxt := self activateMethod: meth withArgs: args receiver: rcvr class: class.
	((self objectClass: val) == Array
	 and: [val size = 2
	 and: [val first == PrimitiveFailToken
	 and: [val last notNil
	 and: [(ctxt method at: ctxt pc) = 129 "long store temp"]]]]) ifTrue:
		[ctxt at: ctxt stackPtr put: val last].
	^ctxt! !

!ContextPart methodsFor: 'instruction decoding' stamp: 'eem 5/12/2009 11:58'!
storeIntoLiteralVariable: value 
	"Simulate the action of bytecode that stores the top of the stack into a 
	literal variable of my method."

	self object: value instVarAt: ValueIndex put: self top! !

!ContextPart methodsFor: 'instruction decoding' stamp: 'eem 5/12/2009 12:00'!
storeIntoReceiverVariable: offset 
	"Simulate the action of bytecode that stores the top of the stack into an 
	instance variable of my receiver."

	self object: self receiver instVarAt: offset + 1 put: self top! !

!ContextPart methodsFor: 'instruction decoding' stamp: 'eem 5/12/2009 13:05'!
storeIntoRemoteTemp: remoteTempIndex inVectorAt: tempVectorIndex
	"Simulate the action of bytecode that stores the top of the stack at
	 an offset in one of my local variables being used as a remote temp vector."

	self object: (self at: tempVectorIndex + 1) basicAt: remoteTempIndex + 1 put: self top! !

!ContextPart methodsFor: 'private' stamp: 'eem 5/12/2009 21:12'!
tryNamedPrimitiveIn: aCompiledMethod for: aReceiver withArgs: arguments
	| selector theMethod spec receiverClass |
	<primitive: 218 error: ec>
	ec ifNotNil:
		["If ec is an integer other than -1 there was a problem with primitive 218,
		  not with the external primitive itself.  -1 indicates a generic failure (where
		  ec should be nil) but ec = nil means primitive 218 is not implemented.  So
		  interpret -1 to mean the external primitive failed with a nil error code."
		 ec isInteger ifTrue:
			[ec = -1
				ifTrue: [ec := nil]
				ifFalse: [self primitiveFailed]].
		^{PrimitiveFailToken. ec}].
	"Assume a nil error code implies the primitive is not implemented and fall back on the old code."
	"Hack. Attempt to execute the named primitive from the given compiled method"
	arguments size > 8 ifTrue:
		[^{PrimitiveFailToken. nil}].
	selector := #(
		tryNamedPrimitive 
		tryNamedPrimitive: 
		tryNamedPrimitive:with: 
		tryNamedPrimitive:with:with: 
		tryNamedPrimitive:with:with:with:
		tryNamedPrimitive:with:with:with:with:
		tryNamedPrimitive:with:with:with:with:with:
		tryNamedPrimitive:with:with:with:with:with:with:
		tryNamedPrimitive:with:with:with:with:with:with:with:) at: arguments size+1.
	receiverClass := self objectClass: aReceiver.
	theMethod := receiverClass lookupSelector: selector.
	theMethod == nil ifTrue:
		[^{PrimitiveFailToken. nil}].
	spec := theMethod literalAt: 1.
	spec replaceFrom: 1 to: spec size with: (aCompiledMethod literalAt: 1) startingAt: 1.
	Smalltalk unbindExternalPrimitives.
	^self object: aReceiver perform: selector withArguments: arguments inClass: receiverClass! !

!ContextPart methodsFor: 'private' stamp: 'eem 1/4/2009 09:54'!
tryPrimitiveFor: method receiver: receiver args: arguments 
	"If this method has a primitive index, then run the primitive and return its result.
	Otherwise (and also if the primitive fails) return PrimitiveFailToken,
	as an indication that the method should be activated and run as bytecodes."
	| primIndex |
	(primIndex := method primitive) = 0 ifTrue: [^{PrimitiveFailToken. nil}].
	^ self doPrimitive: primIndex method: method receiver: receiver args: arguments! !

!ProtoObject methodsFor: 'apply primitives' stamp: 'eem 1/4/2009 09:37'!
tryNamedPrimitive
	"This method is a template that the Smalltalk simulator uses to 
	execute primitives. See Object documentation whatIsAPrimitive."
	<primitive:'' module:'' error: errorCode>
	^ContextPart primitiveFailTokenFor: errorCode! !

!ProtoObject methodsFor: 'apply primitives' stamp: 'eem 1/4/2009 09:37'!
tryNamedPrimitive: arg1
	"This method is a template that the Smalltalk simulator uses to 
	execute primitives. See Object documentation whatIsAPrimitive."
	<primitive:'' module:'' error: errorCode>
	^ContextPart primitiveFailTokenFor: errorCode! !

!ProtoObject methodsFor: 'apply primitives' stamp: 'eem 1/4/2009 09:37'!
tryNamedPrimitive: arg1 with: arg2
	"This method is a template that the Smalltalk simulator uses to 
	execute primitives. See Object documentation whatIsAPrimitive."
	<primitive:'' module:'' error: errorCode>
	^ContextPart primitiveFailTokenFor: errorCode! !

!ProtoObject methodsFor: 'apply primitives' stamp: 'eem 1/4/2009 09:37'!
tryNamedPrimitive: arg1 with: arg2 with: arg3
	"This method is a template that the Smalltalk simulator uses to 
	execute primitives. See Object documentation whatIsAPrimitive."
	<primitive:'' module:'' error: errorCode>
	^ContextPart primitiveFailTokenFor: errorCode! !

!ProtoObject methodsFor: 'apply primitives' stamp: 'eem 1/4/2009 09:38'!
tryNamedPrimitive: arg1 with: arg2 with: arg3 with: arg4
	"This method is a template that the Smalltalk simulator uses to 
	execute primitives. See Object documentation whatIsAPrimitive."
	<primitive:'' module:'' error: errorCode>
	^ContextPart primitiveFailTokenFor: errorCode! !

!ProtoObject methodsFor: 'apply primitives' stamp: 'eem 1/4/2009 09:38'!
tryNamedPrimitive: arg1 with: arg2 with: arg3 with: arg4 with: arg5
	"This method is a template that the Smalltalk simulator uses to 
	execute primitives. See Object documentation whatIsAPrimitive."
	<primitive:'' module:'' error: errorCode>
	^ContextPart primitiveFailTokenFor: errorCode! !

!ProtoObject methodsFor: 'apply primitives' stamp: 'eem 1/4/2009 09:38'!
tryNamedPrimitive: arg1 with: arg2 with: arg3 with: arg4 with: arg5 with: arg6
	"This method is a template that the Smalltalk simulator uses to 
	execute primitives. See Object documentation whatIsAPrimitive."
	<primitive:'' module:'' error: errorCode>
	^ContextPart primitiveFailTokenFor: errorCode! !

!ProtoObject methodsFor: 'apply primitives' stamp: 'eem 1/4/2009 09:38'!
tryNamedPrimitive: arg1 with: arg2 with: arg3 with: arg4 with: arg5 with: arg6 with: arg7
	"This method is a template that the Smalltalk simulator uses to 
	execute primitives. See Object documentation whatIsAPrimitive."
	<primitive:'' module:'' error: errorCode>
	^ContextPart primitiveFailTokenFor: errorCode! !

!ProtoObject methodsFor: 'apply primitives' stamp: 'eem 1/4/2009 09:38'!
tryNamedPrimitive: arg1 with: arg2 with: arg3 with: arg4 with: arg5 with: arg6 with: arg7 with: arg8
	"This method is a template that the Smalltalk simulator uses to 
	execute primitives. See Object documentation whatIsAPrimitive."
	<primitive:'' module:'' error: errorCode>
	^ContextPart primitiveFailTokenFor: errorCode! !

!ProtoObject methodsFor: 'apply primitives' stamp: 'eem 1/4/2009 09:38'!
tryPrimitive: primIndex withArgs: argumentArray
	"This method is a template that the Smalltalk simulator uses to 
	execute primitives. See Object documentation whatIsAPrimitive."

	<primitive: 118 error: errorCode>
	^ContextPart primitiveFailTokenFor: errorCode! !
ContextPart initialize!