[Vm-dev] VM Maker: VMMaker.oscog-nice.1760.mcz

commits at source.squeak.org commits at source.squeak.org
Tue Apr 5 18:16:32 UTC 2016


Nicolas Cellier uploaded a new version of VMMaker to project VM Maker:
http://source.squeak.org/VMMaker/VMMaker.oscog-nice.1760.mcz

==================== Summary ====================

Name: VMMaker.oscog-nice.1760
Author: nice
Time: 3 April 2016, 10:53:08.924 pm
UUID: ae64abbe-8a10-4814-95a5-d54c91e62463
Ancestors: VMMaker.oscog-nice.1759

Before updating LargeIntegersPlugin to 32bits limbs, get rid of obsolete primitives burden.

=============== Diff against VMMaker.oscog-nice.1759 ===============

Item was removed:
- ----- Method: LargeIntegersPlugin>>primAsLargeInteger: (in category 'control & support primitives') -----
- primAsLargeInteger: anInteger
- 	"Converts a SmallInteger into a - non normalized!! - LargeInteger;          
- 	 aLargeInteger will be returned unchanged."
- 	"Do not check for forced fail, because we need this conversion to test the 
- 	plugin in ST during forced fail, too."
- 	self debugCode: [self msg: 'primAsLargeInteger: anInteger'].
- 	self
- 		primitive: 'primAsLargeInteger'
- 		parameters: #(Integer )
- 		receiver: #Oop.
- 	(interpreterProxy isIntegerObject: anInteger)
- 		ifTrue: [^ self createLargeFromSmallInteger: anInteger]
- 		ifFalse: [^ anInteger]!

Item was removed:
- ----- Method: LargeIntegersPlugin>>primCheckIfCModuleExists (in category 'obsolete') -----
- primCheckIfCModuleExists
- 	"If calling this primitive fails, then C module does not exist. Do not check for forced fail, because we want to know if module exists during forced fail, too."
- 	self
- 		primitive: 'primCheckIfCModuleExists'
- 		parameters: #()
- 		receiver: #Oop.
- 	^ true asOop: Boolean!

Item was removed:
- ----- Method: LargeIntegersPlugin>>primDigit:bitShift: (in category 'development primitives') -----
- primDigit: anInteger bitShift: shiftCount 
- 	| rShift aLarge |
- 	self debugCode: [self msg: 'primDigit: anInteger bitShift: shiftCount'].
- 	self
- 		primitive: '_primDigitBitShift'
- 		parameters: #(Integer SmallInteger )
- 		receiver: #Oop.
- 	(interpreterProxy isIntegerObject: anInteger)
- 		ifTrue: ["convert it to a not normalized LargeInteger"
- 			aLarge := self createLargeFromSmallInteger: anInteger]
- 		ifFalse: [aLarge := anInteger].
- 	shiftCount >= 0
- 		ifTrue: [^ self digit: aLarge Lshift: shiftCount]
- 		ifFalse: 
- 			[rShift := 0 - shiftCount.
- 			^ self normalize: (self
- 					digit: aLarge
- 					Rshift: rShift
- 					lookfirst: (self digitSizeOfLargeInt: aLarge))]!

Item was removed:
- ----- Method: LargeIntegersPlugin>>primDigitAdd:with: (in category 'development primitives') -----
- primDigitAdd: firstInteger with: secondInteger 
- 	| firstLarge secondLarge |
- 	self debugCode: [self msg: 'primDigitAdd: firstInteger with: secondInteger'].
- 	self
- 		primitive: 'primDigitAddWith'
- 		parameters: #(Integer Integer )
- 		receiver: #Oop.
- 	(interpreterProxy isIntegerObject: firstInteger)
- 		ifTrue: ["convert it to a not normalized LargeInteger"
- 			self remapOop: secondInteger in: [firstLarge := self createLargeFromSmallInteger: firstInteger]]
- 		ifFalse: [firstLarge := firstInteger].
- 	(interpreterProxy isIntegerObject: secondInteger)
- 		ifTrue: ["convert it to a not normalized LargeInteger"
- 			self remapOop: firstLarge in: [secondLarge := self createLargeFromSmallInteger: secondInteger]]
- 		ifFalse: [secondLarge := secondInteger].
- 	^ self digitAddLarge: firstLarge with: secondLarge!

Item was removed:
- ----- Method: LargeIntegersPlugin>>primDigitBitLogic:with:op: (in category 'development primitives') -----
- primDigitBitLogic: firstInteger with: secondInteger op: opIndex 
- 	"Bit logic here is only implemented for positive integers or Zero; if any arg is negative, it fails."
- 	self debugCode: [self msg: 'primDigitBitLogic: firstInteger with: secondInteger op: opIndex'].
- 	self
- 		primitive: 'primDigitBitLogicWithOp'
- 		parameters: #(Integer Integer SmallInteger )
- 		receiver: #Oop.
- 	^ self
- 		digitBitLogic: firstInteger
- 		with: secondInteger
- 		opIndex: opIndex!

Item was removed:
- ----- Method: LargeIntegersPlugin>>primDigitBitShift: (in category 'obsolete') -----
- primDigitBitShift: shiftCount 
- 	| rShift aLarge anInteger |
- 	self debugCode: [self msg: 'primDigitBitShift: shiftCount'].
- 	anInteger := self
- 				primitive: 'primDigitBitShift'
- 				parameters: #(SmallInteger )
- 				receiver: #Integer.
- 	(interpreterProxy isIntegerObject: anInteger)
- 		ifTrue: ["convert it to a not normalized LargeInteger"
- 			aLarge := self createLargeFromSmallInteger: anInteger]
- 		ifFalse: [aLarge := anInteger].
- 	shiftCount >= 0
- 		ifTrue: [^ self digit: aLarge Lshift: shiftCount]
- 		ifFalse: 
- 			[rShift := 0 - shiftCount.
- 			^ self normalize: (self
- 					digit: aLarge
- 					Rshift: rShift
- 					lookfirst: (self digitSizeOfLargeInt: aLarge))]!

Item was removed:
- ----- Method: LargeIntegersPlugin>>primDigitCompare:with: (in category 'development primitives') -----
- primDigitCompare: firstInteger with: secondInteger 
- 	| firstVal secondVal |
- 	self debugCode: [self msg: 'primDigitCompare: firstInteger with: secondInteger'].
- 	self
- 		primitive: 'primDigitCompareWith'
- 		parameters: #(Integer Integer )
- 		receiver: #Oop.
- 	"shortcut: aSmallInteger has to be smaller in Magnitude as aLargeInteger"
- 	(interpreterProxy isIntegerObject: firstInteger)
- 		ifTrue: ["first"
- 			(interpreterProxy isIntegerObject: secondInteger)
- 				ifTrue: ["second"
- 					(firstVal := interpreterProxy integerValueOf: firstInteger) > (secondVal := interpreterProxy integerValueOf: secondInteger)
- 						ifTrue: [^ 1 asOop: SmallInteger"first > second"]
- 						ifFalse: [firstVal < secondVal
- 								ifTrue: [^ -1 asOop: SmallInteger"first < second"]
- 								ifFalse: [^ 0 asOop: SmallInteger"first = second"]]]
- 				ifFalse: ["SECOND" ^ -1 asOop: SmallInteger"first < SECOND"]]
- 		ifFalse: ["FIRST"
- 			(interpreterProxy isIntegerObject: secondInteger)
- 				ifTrue: ["second" ^ 1 asOop: SmallInteger"FIRST > second"]
- 				ifFalse: ["SECOND"
- 					^ self digitCompareLarge: firstInteger with: secondInteger]]!

Item was removed:
- ----- Method: LargeIntegersPlugin>>primDigitDiv:with:negative: (in category 'development primitives') -----
- primDigitDiv: firstInteger with: secondInteger negative: neg 
- 	"Answer the result of dividing firstInteger by secondInteger.
- 	Fail if parameters are not integers or secondInteger is zero."
- 	| firstAsLargeInteger secondAsLargeInteger |
- 	self debugCode: [self msg: 'primDigitDiv: firstInteger with: secondInteger negative: neg'].
- 	self
- 		primitive: 'primDigitDivWithNegative'
- 		parameters: #(Integer Integer Boolean )
- 		receiver: #Oop.
- 	"Coerce SmallIntegers to corresponding (not normalized) large integers    
- 	 and check for zerodivide."
- 	(interpreterProxy isIntegerObject: firstInteger)
- 		ifTrue: ["convert to LargeInteger"
- 			self remapOop: secondInteger in: [firstAsLargeInteger := self createLargeFromSmallInteger: firstInteger]]
- 		ifFalse: [firstAsLargeInteger := firstInteger].
- 	(interpreterProxy isIntegerObject: secondInteger)
- 		ifTrue: 
- 			["check for zerodivide and convert to LargeInteger"
- 			(interpreterProxy integerValueOf: secondInteger)
- 				= 0 ifTrue: [^ interpreterProxy primitiveFail].
- 			self remapOop: firstAsLargeInteger in: [secondAsLargeInteger := self createLargeFromSmallInteger: secondInteger]]
- 		ifFalse: [secondAsLargeInteger := secondInteger].
- 	^ self
- 		digitDivLarge: firstAsLargeInteger
- 		with: secondAsLargeInteger
- 		negative: neg!

Item was removed:
- ----- Method: LargeIntegersPlugin>>primDigitMultiply:with:negative: (in category 'development primitives') -----
- primDigitMultiply: firstInteger with: secondInteger negative: neg
- 	| firstLarge secondLarge |
- 	self debugCode: [self msg: 'primDigitMultiply: firstInteger with: secondInteger negative: neg'].
- 	self
- 		primitive: 'primDigitMultiplyWithNegative'
- 		parameters: #(Integer Integer Boolean )
- 		receiver: #Oop.
- 	(interpreterProxy isIntegerObject: firstInteger)
- 		ifTrue: ["convert it to a not normalized LargeInteger"
- 			self remapOop: secondInteger in: [firstLarge := self createLargeFromSmallInteger: firstInteger]]
- 		ifFalse: [firstLarge := firstInteger].
- 	(interpreterProxy isIntegerObject: secondInteger)
- 		ifTrue: ["convert it to a not normalized LargeInteger"
- 			self remapOop: firstLarge in: [secondLarge := self createLargeFromSmallInteger: secondInteger]]
- 		ifFalse: [secondLarge := secondInteger].
- 	^ self
- 		digitMultiplyLarge: firstLarge
- 		with: secondLarge
- 		negative: neg!

Item was removed:
- ----- Method: LargeIntegersPlugin>>primDigitSubtract:with: (in category 'development primitives') -----
- primDigitSubtract: firstInteger with: secondInteger
- 	| firstLarge secondLarge |
- 	self debugCode: [self msg: 'primDigitSubtract: firstInteger with: secondInteger'].
- 	self
- 		primitive: 'primDigitSubtractWith'
- 		parameters: #(Integer Integer )
- 		receiver: #Oop.
- 	(interpreterProxy isIntegerObject: firstInteger)
- 		ifTrue: ["convert it to a not normalized LargeInteger"
- 			self remapOop: secondInteger in: [firstLarge := self createLargeFromSmallInteger: firstInteger]]
- 		ifFalse: [firstLarge := firstInteger].
- 	(interpreterProxy isIntegerObject: secondInteger)
- 		ifTrue: ["convert it to a not normalized LargeInteger"
- 			self remapOop: firstLarge in: [secondLarge := self createLargeFromSmallInteger: secondInteger]]
- 		ifFalse: [secondLarge := secondInteger].
- 	^ self digitSubLarge: firstLarge with: secondLarge!

Item was removed:
- ----- Method: LargeIntegersPlugin>>primNormalize: (in category 'development primitives') -----
- primNormalize: anInteger 
- "Parameter specification #(Integer) doesn't convert!!"
- 	self debugCode: [self msg: 'primNormalize: anInteger'].
- 	self
- 		primitive: 'primNormalize'
- 		parameters: #(Integer )
- 		receiver: #Oop.
- 	(interpreterProxy isIntegerObject: anInteger)
- 		ifTrue: [^ anInteger].
- 	^ self normalize: anInteger!



More information about the Vm-dev mailing list