<div dir="ltr"><div><div><div>As suggested by Eliot, the class checks could be defined as macros in the plugin preamble (if internal plugin and if SPURVM...), but this should also be the case of many other vm api selectors (like isIntegerObject: etc...).<br><br></div>As suggested by Levente, this could as well be generalized by link time optimization options of clang/gcc (-flto)...<br></div>Or by aggregating vm and internal plugins into a single source file.<br></div>We'll see later.<br></div><div class="gmail_extra"><br><div class="gmail_quote">2016-04-20 1:04 GMT+02:00 <span dir="ltr"><<a href="mailto:commits@source.squeak.org" target="_blank">commits@source.squeak.org</a>></span>:<br><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"><br>
Nicolas Cellier uploaded a new version of VMMaker to project VM Maker:<br>
<a href="http://source.squeak.org/VMMaker/VMMaker.oscog-nice.1813.mcz" rel="noreferrer" target="_blank">http://source.squeak.org/VMMaker/VMMaker.oscog-nice.1813.mcz</a><br>
<br>
==================== Summary ====================<br>
<br>
Name: VMMaker.oscog-nice.1813<br>
Author: nice<br>
Time: 20 April 2016, 1:02:48.617 am<br>
UUID: 9ce7e2b2-2956-4228-9744-345c61a693ed<br>
Ancestors: VMMaker.oscog-nice.1812<br>
<br>
Revert elimination of type specifications for LargeIntegersPlugin.<br>
<br>
Instead, provide a bunch of Integer type checking.<br>
- isIntegerObject: <=> isMemberOf: SmallInteger (already existing)<br>
- isKindOfInteger: <=> isKindOf: Integer<br>
- isLargeIntegerObject= <=> isKindOf: LargePositiveInteger (Squeak) or LargeInteger (Pharo)<br>
- isLargePositiveIntegerObject: <=> isMemberOf: LargePositiveInteger<br>
- isLargeNegativeIntegerObject: <=> isMemberOf: LargeNegativeInteger<br>
<br>
Note that this will require a change of svn source for platforms/Cross/vm/sqVirtalMachine.[ch]<br>
<br>
=============== Diff against VMMaker.oscog-nice.1812 ===============<br>
<br>
Item was changed:<br>
----- Method: FFIPlugin>>ffiPushUnsignedLongLongOop: (in category 'callout support') -----<br>
ffiPushUnsignedLongLongOop: oop<br>
"Push a longlong type (e.g., a 64bit integer).<br>
Note: Coercions from float are *not* supported."<br>
| lowWord highWord length ptr |<br>
<var: #ptr type:'unsigned char *'><br>
oop == interpreterProxy nilObject<br>
ifTrue:[^self ffiPushUnsignedLong: 0 Long: 0.]. "@@: check this"<br>
oop == interpreterProxy falseObject<br>
ifTrue:[^self ffiPushUnsignedLong: 0 Long: 0].<br>
oop == interpreterProxy trueObject<br>
ifTrue:[^self ffiPushUnsignedLong: 0 Long: 1].<br>
(interpreterProxy isIntegerObject: oop) ifTrue:[<br>
lowWord := interpreterProxy integerValueOf: oop.<br>
lowWord < 0 ifTrue:[^self ffiFail: FFIErrorCoercionFailed].<br>
highWord := 0.<br>
] ifFalse:[<br>
+ (interpreterProxy isLargePositiveIntegerObject: oop)<br>
- (interpreterProxy fetchClassOf: oop) = interpreterProxy classLargePositiveInteger<br>
ifFalse:[^interpreterProxy primitiveFail].<br>
(interpreterProxy isBytes: oop) ifFalse:[^self ffiFail: FFIErrorCoercionFailed].<br>
length := interpreterProxy byteSizeOf: oop.<br>
length > 8 ifTrue:[^self ffiFail: FFIErrorCoercionFailed].<br>
lowWord := highWord := 0.<br>
ptr := interpreterProxy firstIndexableField: oop.<br>
0 to: (length min: 4)-1 do:[:i|<br>
lowWord := lowWord + ((ptr at: i) << (i*8))].<br>
0 to: (length-5) do:[:i|<br>
highWord := highWord + ((ptr at: i+4) << (i*8))].<br>
].<br>
^self ffiPushUnsignedLong: lowWord Long: highWord.!<br>
<br>
Item was changed:<br>
----- Method: IA32ABIPlugin>>primAlienReplace (in category 'primitives-accessing') -----<br>
primAlienReplace<br>
"Copy some number of bytes from some source object starting at the index<br>
into the receiver destination object from startIndex to stopIndex . The source<br>
and destination may be Aliens or byte-indexable objects. The primitive wll have either<br>
of the following signatures:<br>
<Alien | indexableByteSubclass | indexableWordSubclass><br>
primReplaceFrom: start <Integer><br>
to: stop <Integer><br>
with: replacement <Alien | indexableByteSubclass | indexableWordSubclass | Integer><br>
startingAt: repStart <Integer> ^<self><br>
<primitive: 'primitiveAlienReplace' error: errorCode module: 'IA32ABI'><br>
<Anywhere><br>
primReplaceIn: dest <Alien | indexableByteSubclass | indexableWordSubclass><br>
from: start <Integer><br>
to: stop <Integer><br>
with: replacement <Alien | indexableByteSubclass | indexableWordSubclass | Integer><br>
startingAt: repStart <Integer> ^<self><br>
<primitive: 'primitiveAlienReplace' error: errorCode module: 'IA32ABI'><br>
"<br>
| array start stop repl replStart dest src totalLength count |<br>
<export: true><br>
array := interpreterProxy stackValue: 4.<br>
start := interpreterProxy stackIntegerValue: 3.<br>
stop := interpreterProxy stackIntegerValue: 2.<br>
repl := interpreterProxy stackValue: 1.<br>
replStart := interpreterProxy stackIntegerValue: 0.<br>
<br>
(interpreterProxy failed<br>
or: [(interpreterProxy isWordsOrBytes: array) not]) ifTrue:<br>
[^interpreterProxy primitiveFailFor: PrimErrBadArgument].<br>
<br>
(self isAlien: array)<br>
ifTrue:<br>
[totalLength := self sizeField: array.<br>
dest := (self startOfData: array withSize: totalLength) + start - 1.<br>
totalLength = 0 "no bounds checks for zero-sized (pointer) Aliens"<br>
ifTrue: [totalLength := stop]<br>
ifFalse: [totalLength := totalLength abs]]<br>
ifFalse:<br>
[totalLength := interpreterProxy byteSizeOf: array.<br>
dest := (self startOfByteData: array) + start - 1].<br>
(start >= 1 and: [start - 1 <= stop and: [stop <= totalLength]])<br>
ifFalse: [^interpreterProxy primitiveFailFor: PrimErrBadIndex].<br>
<br>
(interpreterProxy isIntegerObject: repl)<br>
ifTrue:<br>
[(interpreterProxy integerValueOf: repl) <= 0 ifTrue:<br>
[^interpreterProxy primitiveFailFor: PrimErrBadArgument].<br>
src := (interpreterProxy integerValueOf: repl) + replStart - 1]<br>
ifFalse:<br>
+ [(interpreterProxy isLargePositiveIntegerObject: repl)<br>
- [(interpreterProxy fetchClassOf: repl) == interpreterProxy classLargePositiveInteger<br>
ifTrue:<br>
[src := (interpreterProxy positive32BitValueOf: repl) + replStart - 1.<br>
interpreterProxy failed ifTrue:<br>
[^interpreterProxy primitiveFailFor: PrimErrBadArgument]]<br>
ifFalse:<br>
[(self isAlien: repl)<br>
ifTrue:<br>
[totalLength := self sizeField: repl.<br>
src := (self startOfData: repl withSize: totalLength) + replStart - 1.<br>
totalLength = 0 "no bounds checks for zero-sized (pointer) Aliens"<br>
ifTrue: [totalLength := stop - start + replStart]<br>
ifFalse: [totalLength := totalLength abs]]<br>
ifFalse:<br>
[(interpreterProxy isWordsOrBytes: repl) ifFalse:<br>
[^interpreterProxy primitiveFailFor: PrimErrBadArgument].<br>
totalLength := interpreterProxy byteSizeOf: repl.<br>
src := (self startOfByteData: repl) + replStart - 1].<br>
(replStart >= 1 and: [stop - start + replStart <= totalLength]) ifFalse:<br>
[^interpreterProxy primitiveFailFor: PrimErrBadIndex]]].<br>
<br>
(interpreterProxy isOopImmutable: array) ifTrue:<br>
[^interpreterProxy primitiveFailFor: PrimErrNoModification].<br>
<br>
count := stop - start + 1.<br>
self cCode: 'memmove((void *)dest,(void *)src,count)'<br>
inSmalltalk:<br>
[count := count + src + dest. "squash unused var compiler warnings"<br>
self error: 'not implemented'].<br>
<br>
interpreterProxy pop: interpreterProxy methodArgumentCount!<br>
<br>
Item was added:<br>
+ ----- Method: Integer class>>ccg:prolog:expr:index: (in category '*VMMaker-plugin generation') -----<br>
+ ccg: cg prolog: aBlock expr: aString index: anInteger<br>
+<br>
+ ^cg ccgLoad: aBlock expr: aString asKindOfIntegerFrom: anInteger!<br>
<br>
Item was added:<br>
+ ----- Method: Interpreter>>isKindOfInteger: (in category 'plugin primitive support') -----<br>
+ isKindOfInteger: oop<br>
+ "Answer true if the oop is kind of Integer (Small or Large)."<br>
+ <api><br>
+ <inline: true><br>
+ ^(self isIntegerObject: oop)<br>
+ or: [self isLargeIntegerInstance: oop]!<br>
<br>
Item was added:<br>
+ ----- Method: Interpreter>>isLargeIntegerObject: (in category 'plugin primitive support') -----<br>
+ isLargeIntegerObject: oop<br>
+ ^(self isLargeIntegerInstance: oop)!<br>
<br>
Item was added:<br>
+ ----- Method: Interpreter>>isLargeNegativeIntegerObject: (in category 'plugin primitive support') -----<br>
+ isLargeNegativeIntegerObject: oop<br>
+ ^(self isInstanceOfClassLargeNegativeInteger: oop)!<br>
<br>
Item was added:<br>
+ ----- Method: Interpreter>>isLargePositiveIntegerObject: (in category 'plugin primitive support') -----<br>
+ isLargePositiveIntegerObject: oop<br>
+ ^(self isInstanceOfClassLargePositiveInteger: oop)!<br>
<br>
Item was removed:<br>
- ----- Method: InterpreterPrimitives>>isInstanceOfClassLargeNegativeInteger: (in category 'primitive support') -----<br>
- isInstanceOfClassLargeNegativeInteger: oop<br>
- <inline: true><br>
- "N.B. Because Slang always inlines is:instanceOf:compactClassIndex:<br>
- (because is:instanceOf:compactClassIndex: has an inline: pragma) the<br>
- phrase (objectMemory splObj: ClassLargeNegativeInteger) is expanded<br>
- in-place and is _not_ evaluated if oop has a non-zero CompactClassIndex."<br>
- ^objectMemory<br>
- is: oop<br>
- instanceOf: (objectMemory splObj: ClassLargeNegativeInteger)<br>
- compactClassIndex: ClassLargeNegativeIntegerCompactIndex!<br>
<br>
Item was removed:<br>
- ----- Method: InterpreterPrimitives>>isInstanceOfClassLargePositiveInteger: (in category 'primitive support') -----<br>
- isInstanceOfClassLargePositiveInteger: oop<br>
- <inline: true><br>
- "N.B. Because Slang always inlines is:instanceOf:compactClassIndex:<br>
- (because is:instanceOf:compactClassIndex: has an inline: pragma) the<br>
- phrase (objectMemory splObj: ClassLargePositiveInteger) is expanded<br>
- in-place and is _not_ evaluated if oop has a non-zero CompactClassIndex."<br>
- ^objectMemory<br>
- is: oop<br>
- instanceOf: (objectMemory splObj: ClassLargePositiveInteger)<br>
- compactClassIndex: ClassLargePositiveIntegerCompactIndex!<br>
<br>
Item was added:<br>
+ ----- Method: InterpreterProxy>>isKindOfInteger: (in category 'testing') -----<br>
+ isKindOfInteger: objectOrientedPointer<br>
+ ^objectOrientedPointer isInteger!<br>
<br>
Item was added:<br>
+ ----- Method: InterpreterProxy>>isLargeIntegerObject: (in category 'testing') -----<br>
+ isLargeIntegerObject: objectOrientedPointer<br>
+ ^objectOrientedPointer isKindOf: LargePositiveInteger!<br>
<br>
Item was added:<br>
+ ----- Method: InterpreterProxy>>isLargeNegativeIntegerObject: (in category 'testing') -----<br>
+ isLargeNegativeIntegerObject: objectOrientedPointer<br>
+ ^objectOrientedPointer isMemberOf: LargeNegativeInteger!<br>
<br>
Item was added:<br>
+ ----- Method: InterpreterProxy>>isLargePositiveIntegerObject: (in category 'testing') -----<br>
+ isLargePositiveIntegerObject: objectOrientedPointer<br>
+ ^objectOrientedPointer isMemberOf: LargePositiveInteger!<br>
<br>
Item was changed:<br>
----- Method: LargeIntegersPlugin>>digitAddLarge:with: (in category 'oop functions') -----<br>
digitAddLarge: firstInteger with: secondInteger<br>
"Does not need to normalize!!"<br>
| over firstDigitLen secondDigitLen shortInt shortDigitLen longInt longDigitLen sum newSum neg |<br>
<var: #over type: #'unsigned int'><br>
firstDigitLen := self digitSizeOfLargeInt: firstInteger.<br>
secondDigitLen := self digitSizeOfLargeInt: secondInteger.<br>
+ neg := interpreterProxy isLargeNegativeIntegerObject: firstInteger.<br>
- neg := (interpreterProxy fetchClassOf: firstInteger)<br>
- = interpreterProxy classLargeNegativeInteger.<br>
firstDigitLen <= secondDigitLen<br>
ifTrue:<br>
[shortInt := firstInteger.<br>
shortDigitLen := firstDigitLen.<br>
longInt := secondInteger.<br>
longDigitLen := secondDigitLen]<br>
ifFalse:<br>
[shortInt := secondInteger.<br>
shortDigitLen := secondDigitLen.<br>
longInt := firstInteger.<br>
longDigitLen := firstDigitLen].<br>
" sum := Integer new: len neg: firstInteger negative."<br>
self remapOop: #(shortInt longInt ) in: [sum := self createLargeIntegerNeg: neg digitLength: longDigitLen].<br>
over := self<br>
cDigitAdd: (self pointerToFirstDigitOfLargeInt: shortInt)<br>
len: shortDigitLen<br>
with: (self pointerToFirstDigitOfLargeInt: longInt)<br>
len: longDigitLen<br>
into: (self pointerToFirstDigitOfLargeInt: sum).<br>
over > 0<br>
ifTrue:<br>
["sum := sum growby: 1."<br>
self remapOop: sum in: [newSum := self createLargeIntegerNeg: neg byteLength: longDigitLen * 4 + 1].<br>
self<br>
cDigitCopyFrom: (self pointerToFirstDigitOfLargeInt: sum)<br>
to: (self pointerToFirstDigitOfLargeInt: newSum)<br>
len: longDigitLen.<br>
sum := newSum.<br>
"C index!!"<br>
self cDigitOf: (self pointerToFirstDigitOfLargeInt: sum)<br>
at: longDigitLen put: over]<br>
ifFalse:<br>
[sum := neg<br>
ifTrue: [self normalizeNegative: sum]<br>
ifFalse: [self normalizePositive: sum]].<br>
^ sum!<br>
<br>
Item was changed:<br>
----- Method: LargeIntegersPlugin>>digitBitLogic:with:opIndex: (in category 'oop functions') -----<br>
digitBitLogic: firstInteger with: secondInteger opIndex: opIx<br>
"Bit logic here is only implemented for positive integers or Zero;<br>
if rec or arg is negative, it fails."<br>
| firstLarge secondLarge firstLen secondLen shortLen shortLarge longLen longLarge result |<br>
(interpreterProxy isIntegerObject: firstInteger)<br>
ifTrue:<br>
[(interpreterProxy integerValueOf: firstInteger)<br>
< 0 ifTrue: [^ interpreterProxy primitiveFail].<br>
"convert it to a not normalized LargeInteger"<br>
self remapOop: secondInteger in: [firstLarge := self createLargeFromSmallInteger: firstInteger]]<br>
ifFalse:<br>
+ [(interpreterProxy isLargePositiveIntegerObject: firstInteger) ifFalse: [^ interpreterProxy primitiveFail].<br>
- [(interpreterProxy fetchClassOf: firstInteger)<br>
- = interpreterProxy classLargePositiveInteger ifFalse: [^ interpreterProxy primitiveFail].<br>
firstLarge := firstInteger].<br>
(interpreterProxy isIntegerObject: secondInteger)<br>
ifTrue:<br>
[(interpreterProxy integerValueOf: secondInteger)<br>
< 0 ifTrue: [^ interpreterProxy primitiveFail].<br>
"convert it to a not normalized LargeInteger"<br>
self remapOop: firstLarge in: [secondLarge := self createLargeFromSmallInteger: secondInteger]]<br>
ifFalse:<br>
+ [(interpreterProxy isLargePositiveIntegerObject: secondInteger) ifFalse: [^ interpreterProxy primitiveFail].<br>
- [(interpreterProxy fetchClassOf: secondInteger)<br>
- = interpreterProxy classLargePositiveInteger ifFalse: [^ interpreterProxy primitiveFail].<br>
secondLarge := secondInteger].<br>
firstLen := self byteSizeOfLargeInt: firstLarge.<br>
secondLen := self byteSizeOfLargeInt: secondLarge.<br>
firstLen < secondLen<br>
ifTrue:<br>
[shortLen := firstLen.<br>
shortLarge := firstLarge.<br>
longLen := secondLen.<br>
longLarge := secondLarge]<br>
ifFalse:<br>
[shortLen := secondLen.<br>
shortLarge := secondLarge.<br>
longLen := firstLen.<br>
longLarge := firstLarge].<br>
self remapOop: #(shortLarge longLarge ) in: [result := interpreterProxy instantiateClass: interpreterProxy classLargePositiveInteger indexableSize: longLen].<br>
self<br>
cDigitOp: opIx<br>
short: (self pointerToFirstDigitOfLargeInt: shortLarge)<br>
len: shortLen + 3 // 4<br>
long: (self pointerToFirstDigitOfLargeInt: longLarge)<br>
len: longLen + 3 // 4<br>
into: (self pointerToFirstDigitOfLargeInt: result).<br>
interpreterProxy failed ifTrue: [^ 0].<br>
^ self normalizePositive: result!<br>
<br>
Item was changed:<br>
----- Method: LargeIntegersPlugin>>digitSubLarge:with: (in category 'oop functions') -----<br>
digitSubLarge: firstInteger with: secondInteger<br>
"Normalizes."<br>
| firstDigitLen secondDigitLen larger largeDigitLen smaller smallerDigitLen neg resDigitLen res firstNeg |<br>
+ firstNeg := interpreterProxy isLargeNegativeIntegerObject: firstInteger.<br>
- firstNeg := (interpreterProxy fetchClassOf: firstInteger)<br>
- = interpreterProxy classLargeNegativeInteger.<br>
firstDigitLen := self digitSizeOfLargeInt: firstInteger.<br>
secondDigitLen := self digitSizeOfLargeInt: secondInteger.<br>
firstDigitLen = secondDigitLen ifTrue:<br>
[[firstDigitLen > 1<br>
and: [(self unsafeDigitOfLargeInt: firstInteger at: firstDigitLen) = (self unsafeDigitOfLargeInt: secondInteger at: firstDigitLen)]]<br>
whileTrue: [firstDigitLen := firstDigitLen - 1].<br>
secondDigitLen := firstDigitLen].<br>
(firstDigitLen < secondDigitLen<br>
or: [firstDigitLen = secondDigitLen<br>
and: [(self unsafeDigitOfLargeInt: firstInteger at: firstDigitLen) < (self unsafeDigitOfLargeInt: secondInteger at: firstDigitLen)]])<br>
ifTrue:<br>
[larger := secondInteger.<br>
largeDigitLen := secondDigitLen.<br>
smaller := firstInteger.<br>
smallerDigitLen := firstDigitLen.<br>
neg := firstNeg == false]<br>
ifFalse:<br>
[larger := firstInteger.<br>
largeDigitLen := firstDigitLen.<br>
smaller := secondInteger.<br>
smallerDigitLen := secondDigitLen.<br>
neg := firstNeg].<br>
resDigitLen := largeDigitLen.<br>
self remapOop: #(smaller larger)<br>
in: [res := self createLargeIntegerNeg: neg digitLength: resDigitLen].<br>
self<br>
cDigitSub: (self pointerToFirstDigitOfLargeInt: smaller)<br>
len: smallerDigitLen<br>
with: (self pointerToFirstDigitOfLargeInt: larger)<br>
len: largeDigitLen<br>
into: (self pointerToFirstDigitOfLargeInt: res).<br>
^neg<br>
ifTrue: [self normalizeNegative: res]<br>
ifFalse: [self normalizePositive: res]!<br>
<br>
Item was removed:<br>
- ----- Method: LargeIntegersPlugin>>isLargeIntegerOop: (in category 'util') -----<br>
- isLargeIntegerOop: oop<br>
- | oopClass |<br>
- oopClass := interpreterProxy fetchClassOf: oop.<br>
- ^oopClass == interpreterProxy classLargeNegativeInteger or: [oopClass == interpreterProxy classLargePositiveInteger]!<br>
<br>
Item was changed:<br>
----- Method: LargeIntegersPlugin>>normalize: (in category 'oop functions') -----<br>
normalize: aLargeInteger<br>
"Check for leading zeroes and return shortened copy if so."<br>
self debugCode: [self msg: 'normalize: aLargeInteger'].<br>
+ (interpreterProxy isLargePositiveIntegerObject: aLargeInteger)<br>
- (interpreterProxy fetchClassOf: aLargeInteger)<br>
- = interpreterProxy classLargePositiveInteger<br>
ifTrue: [^ self normalizePositive: aLargeInteger]<br>
ifFalse: [^ self normalizeNegative: aLargeInteger]!<br>
<br>
Item was changed:<br>
----- Method: LargeIntegersPlugin>>primAnyBitFrom:to: (in category 'Integer primitives') -----<br>
primAnyBitFrom: from to: to<br>
| integer large |<br>
self debugCode: [self msg: 'primAnyBitFrom: from to: to'].<br>
integer := self<br>
primitive: 'primAnyBitFromTo'<br>
+ parameters: #(#SmallInteger #SmallInteger )<br>
+ receiver: #Integer.<br>
- parameters: #(#SmallInteger #SmallInteger ).<br>
(interpreterProxy isIntegerObject: integer)<br>
ifTrue: ["convert it to a not normalized LargeInteger"<br>
large := self createLargeFromSmallInteger: integer]<br>
+ ifFalse: [large := integer].<br>
- ifFalse:<br>
- [(self isLargeIntegerOop: integer) ifFalse: [^interpreterProxy primitiveFail].<br>
- large := integer].<br>
^ (self<br>
anyBitOfLargeInt: large<br>
from: from<br>
to: to)<br>
asOop: Boolean!<br>
<br>
Item was changed:<br>
----- Method: LargeIntegersPlugin>>primDigitAdd: (in category 'Integer primitives') -----<br>
primDigitAdd: secondInteger<br>
| firstLarge secondLarge firstInteger |<br>
self debugCode: [self msg: 'primDigitAdd: secondInteger'].<br>
+ firstInteger := self<br>
+ primitive: 'primDigitAdd'<br>
+ parameters: #(Integer )<br>
+ receiver: #Integer.<br>
- firstInteger := self primitive: 'primDigitAdd'.<br>
(interpreterProxy isIntegerObject: firstInteger)<br>
+ ifTrue: ["convert it to a not normalized LargeInteger"<br>
- ifTrue:<br>
- ["convert it to a not normalized LargeInteger"<br>
self remapOop: secondInteger in: [firstLarge := self createLargeFromSmallInteger: firstInteger]]<br>
+ ifFalse: [firstLarge := firstInteger].<br>
- ifFalse:<br>
- [(self isLargeIntegerOop: firstInteger) ifFalse: [^interpreterProxy primitiveFail].<br>
- firstLarge := firstInteger].<br>
(interpreterProxy isIntegerObject: secondInteger)<br>
+ ifTrue: ["convert it to a not normalized LargeInteger"<br>
- ifTrue:<br>
- ["convert it to a not normalized LargeInteger"<br>
self remapOop: firstLarge in: [secondLarge := self createLargeFromSmallInteger: secondInteger]]<br>
+ ifFalse: [secondLarge := secondInteger].<br>
- ifFalse:<br>
- [(self isLargeIntegerOop: secondInteger) ifFalse: [^interpreterProxy primitiveFail].<br>
- secondLarge := secondInteger].<br>
^ self digitAddLarge: firstLarge with: secondLarge!<br>
<br>
Item was changed:<br>
----- Method: LargeIntegersPlugin>>primDigitBitAnd: (in category 'Integer primitives') -----<br>
primDigitBitAnd: secondInteger<br>
"Bit logic here is only implemented for positive integers or Zero; if rec<br>
or arg is negative, it fails."<br>
| firstInteger |<br>
self debugCode: [self msg: 'primDigitBitAnd: secondInteger'].<br>
+ firstInteger := self<br>
+ primitive: 'primDigitBitAnd'<br>
+ parameters: #(Integer )<br>
+ receiver: #Integer.<br>
- firstInteger := self primitive: 'primDigitBitAnd'.<br>
^ self<br>
digitBitLogic: firstInteger<br>
with: secondInteger<br>
opIndex: andOpIndex!<br>
<br>
Item was changed:<br>
----- Method: LargeIntegersPlugin>>primDigitBitOr: (in category 'Integer primitives') -----<br>
primDigitBitOr: secondInteger<br>
"Bit logic here is only implemented for positive integers or Zero; if rec<br>
or arg is negative, it fails."<br>
| firstInteger |<br>
self debugCode: [self msg: 'primDigitBitOr: secondInteger'].<br>
+ firstInteger := self<br>
+ primitive: 'primDigitBitOr'<br>
+ parameters: #(Integer )<br>
+ receiver: #Integer.<br>
- firstInteger := self primitive: 'primDigitBitOr'.<br>
^ self<br>
digitBitLogic: firstInteger<br>
with: secondInteger<br>
opIndex: orOpIndex!<br>
<br>
Item was changed:<br>
----- Method: LargeIntegersPlugin>>primDigitBitShiftMagnitude: (in category 'Integer primitives') -----<br>
primDigitBitShiftMagnitude: shiftCount<br>
| rShift aLarge anInteger |<br>
self debugCode: [self msg: 'primDigitBitShiftMagnitude: shiftCount'].<br>
anInteger := self<br>
primitive: 'primDigitBitShiftMagnitude'<br>
+ parameters: #(#SmallInteger )<br>
+ receiver: #Integer.<br>
- parameters: #(#SmallInteger ).<br>
(interpreterProxy isIntegerObject: anInteger)<br>
+ ifTrue: ["convert it to a not normalized LargeInteger"<br>
- ifTrue:<br>
- ["convert it to a not normalized LargeInteger"<br>
aLarge := self createLargeFromSmallInteger: anInteger]<br>
+ ifFalse: [aLarge := anInteger].<br>
- ifFalse:<br>
- [(self isLargeIntegerOop: anInteger) ifFalse: [^interpreterProxy primitiveFail].<br>
- aLarge := anInteger].<br>
shiftCount >= 0<br>
ifTrue: [^ self digit: aLarge Lshift: shiftCount]<br>
ifFalse:<br>
[rShift := 0 - shiftCount.<br>
^ self normalize: (self<br>
digit: aLarge<br>
Rshift: rShift<br>
lookfirst: (self digitSizeOfLargeInt: aLarge))]!<br>
<br>
Item was changed:<br>
----- Method: LargeIntegersPlugin>>primDigitBitXor: (in category 'Integer primitives') -----<br>
primDigitBitXor: secondInteger<br>
"Bit logic here is only implemented for positive integers or Zero; if rec<br>
or arg is negative, it fails."<br>
| firstInteger |<br>
self debugCode: [self msg: 'primDigitBitXor: secondInteger'].<br>
+ firstInteger := self<br>
+ primitive: 'primDigitBitXor'<br>
+ parameters: #(Integer )<br>
+ receiver: #Integer.<br>
- firstInteger := self primitive: 'primDigitBitXor'.<br>
^ self<br>
digitBitLogic: firstInteger<br>
with: secondInteger<br>
opIndex: xorOpIndex!<br>
<br>
Item was changed:<br>
----- Method: LargeIntegersPlugin>>primDigitCompare: (in category 'Integer primitives') -----<br>
primDigitCompare: secondInteger<br>
+ | firstVal secondVal firstInteger |<br>
- | firstVal secondVal firstInteger firstIsSmall secondIsSmall |<br>
self debugCode: [self msg: 'primDigitCompare: secondInteger'].<br>
+ firstInteger := self<br>
+ primitive: 'primDigitCompare'<br>
+ parameters: #(#Integer )<br>
+ receiver: #Integer.<br>
- firstInteger := self primitive: 'primDigitCompare'.<br>
"shortcut: aSmallInteger has to be smaller in Magnitude as aLargeInteger"<br>
+ (interpreterProxy isIntegerObject: firstInteger)<br>
+ ifTrue: ["first"<br>
+ (interpreterProxy isIntegerObject: secondInteger)<br>
+ ifTrue: ["second"<br>
+ (firstVal := interpreterProxy integerValueOf: firstInteger) > (secondVal := interpreterProxy integerValueOf: secondInteger)<br>
- firstIsSmall := interpreterProxy isIntegerObject: firstInteger.<br>
- secondIsSmall := interpreterProxy isIntegerObject: secondInteger.<br>
- firstIsSmall ifFalse: [(self isLargeIntegerOop: firstInteger) ifFalse: [^interpreterProxy primitiveFail]].<br>
- secondIsSmall ifFalse: [(self isLargeIntegerOop: secondInteger) ifFalse: [^interpreterProxy primitiveFail]].<br>
- firstIsSmall<br>
- ifTrue:<br>
- [secondIsSmall<br>
- ifTrue:<br>
- [(firstVal := interpreterProxy integerValueOf: firstInteger) > (secondVal := interpreterProxy integerValueOf: secondInteger)<br>
ifTrue: [^ 1 asOop: SmallInteger"first > second"]<br>
ifFalse: [firstVal < secondVal<br>
ifTrue: [^ -1 asOop: SmallInteger"first < second"]<br>
ifFalse: [^ 0 asOop: SmallInteger"first = second"]]]<br>
+ ifFalse: ["SECOND"<br>
+ ^ -1 asOop: SmallInteger"first < SECOND"]]<br>
+ ifFalse: ["FIRST"<br>
+ (interpreterProxy isIntegerObject: secondInteger)<br>
+ ifTrue: ["second"<br>
+ ^ 1 asOop: SmallInteger"FIRST > second"]<br>
+ ifFalse: ["SECOND"<br>
+ ^ self digitCompareLarge: firstInteger with: secondInteger]]!<br>
- ifFalse:<br>
- [^ -1 asOop: SmallInteger"first < SECOND"]]<br>
- ifFalse:<br>
- [secondIsSmall<br>
- ifTrue:<br>
- [^ 1 asOop: SmallInteger"FIRST > second"]<br>
- ifFalse:<br>
- [^ self digitCompareLarge: firstInteger with: secondInteger]]!<br>
<br>
Item was changed:<br>
----- Method: LargeIntegersPlugin>>primDigitDiv:negative: (in category 'Integer primitives') -----<br>
primDigitDiv: secondInteger negative: neg<br>
"Answer the result of dividing firstInteger by secondInteger.<br>
Fail if parameters are not integers, not normalized or secondInteger is<br>
zero. "<br>
| firstAsLargeInteger secondAsLargeInteger firstInteger |<br>
self debugCode: [self msg: 'primDigitDiv: secondInteger negative: neg'].<br>
firstInteger := self<br>
primitive: 'primDigitDivNegative'<br>
+ parameters: #(#Integer #Boolean )<br>
+ receiver: #Integer.<br>
- parameters: #(#Oop #Boolean ).<br>
"Coerce SmallIntegers to corresponding (not normalized) large integers<br>
and check for zerodivide."<br>
(interpreterProxy isIntegerObject: firstInteger)<br>
+ ifTrue: ["convert to LargeInteger"<br>
- ifTrue:<br>
- ["convert to LargeInteger"<br>
self<br>
remapOop: secondInteger<br>
in: [firstAsLargeInteger := self createLargeFromSmallInteger: firstInteger]]<br>
ifFalse:<br>
+ ["Avoid crashes in case of getting unnormalized args."<br>
+ (self isNormalized: firstInteger)<br>
+ ifFalse:<br>
+ [self debugCode:<br>
+ [self msg: 'ERROR in primDigitDiv: secondInteger negative: neg'.<br>
+ self msg: '------> receiver *not* normalized!!'].<br>
+ ^ interpreterProxy primitiveFail].<br>
+ firstAsLargeInteger := firstInteger].<br>
- [(self isLargeIntegerOop: firstInteger) ifFalse: [^interpreterProxy primitiveFail].<br>
- "Avoid crashes in case of getting unnormalized args."<br>
- (self isNormalized: firstInteger) ifFalse: [self<br>
- debugCode: [self msg: 'ERROR in primDigitDiv: secondInteger negative: neg'.<br>
- self msg: '------> receiver *not* normalized!!'].<br>
- ^ interpreterProxy primitiveFail].firstAsLargeInteger := firstInteger].<br>
(interpreterProxy isIntegerObject: secondInteger)<br>
+ ifTrue: ["check for zerodivide and convert to LargeInteger"<br>
+ (interpreterProxy integerValueOf: secondInteger)<br>
+ = 0<br>
- ifTrue:<br>
- ["check for zerodivide and convert to LargeInteger"<br>
- (interpreterProxy integerValueOf: secondInteger) = 0<br>
ifTrue: [^ interpreterProxy primitiveFail].<br>
self<br>
remapOop: firstAsLargeInteger<br>
in: [secondAsLargeInteger := self createLargeFromSmallInteger: secondInteger]]<br>
ifFalse:<br>
+ ["Avoid crashes in case of getting unnormalized args."<br>
+ (self isNormalized: secondInteger)<br>
+ ifFalse:<br>
+ [self debugCode:<br>
+ [self msg: 'ERROR in primDigitDiv: secondInteger negative: neg'.<br>
+ self msg: '------> argument *not* normalized!!'].<br>
+ ^ interpreterProxy primitiveFail].<br>
- [(self isLargeIntegerOop: secondInteger) ifFalse: [^interpreterProxy primitiveFail].<br>
- (self isNormalized: secondInteger) ifFalse: [self<br>
- debugCode: [self msg: 'ERROR in primDigitDiv: secondInteger negative: neg'.<br>
- self msg: '------> argument *not* normalized!!'].<br>
- ^ interpreterProxy primitiveFail].<br>
secondAsLargeInteger := secondInteger].<br>
^ self<br>
digitDivLarge: firstAsLargeInteger<br>
with: secondAsLargeInteger<br>
negative: neg!<br>
<br>
Item was changed:<br>
----- Method: LargeIntegersPlugin>>primDigitMultiply:negative: (in category 'Integer primitives') -----<br>
primDigitMultiply: secondInteger negative: neg<br>
| firstLarge secondLarge firstInteger |<br>
self debugCode: [self msg: 'primDigitMultiply: secondInteger negative: neg'].<br>
firstInteger := self<br>
primitive: 'primDigitMultiplyNegative'<br>
+ parameters: #(#Integer #Boolean )<br>
+ receiver: #Integer.<br>
- parameters: #(#Oop #Boolean ).<br>
(interpreterProxy isIntegerObject: firstInteger)<br>
+ ifTrue: ["convert it to a not normalized LargeInteger"<br>
- ifTrue:<br>
- ["convert it to a not normalized LargeInteger"<br>
self<br>
remapOop: secondInteger<br>
in: [firstLarge := self createLargeFromSmallInteger: firstInteger]]<br>
+ ifFalse: [firstLarge := firstInteger].<br>
- ifFalse:<br>
- [(self isLargeIntegerOop: firstInteger) ifFalse: [^interpreterProxy primitiveFail].<br>
- firstLarge := firstInteger].<br>
(interpreterProxy isIntegerObject: secondInteger)<br>
+ ifTrue: ["convert it to a not normalized LargeInteger"<br>
- ifTrue:<br>
- ["convert it to a not normalized LargeInteger"<br>
self<br>
remapOop: firstLarge<br>
in: [secondLarge := self createLargeFromSmallInteger: secondInteger]]<br>
+ ifFalse: [secondLarge := secondInteger].<br>
- ifFalse:<br>
- [(self isLargeIntegerOop: secondInteger) ifFalse: [^interpreterProxy primitiveFail].<br>
- secondLarge := secondInteger].<br>
^ self<br>
digitMultiplyLarge: firstLarge<br>
with: secondLarge<br>
negative: neg!<br>
<br>
Item was changed:<br>
----- Method: LargeIntegersPlugin>>primDigitSubtract: (in category 'Integer primitives') -----<br>
primDigitSubtract: secondInteger<br>
| firstLarge secondLarge firstInteger |<br>
self debugCode: [self msg: 'primDigitSubtract: secondInteger'].<br>
+ firstInteger := self<br>
+ primitive: 'primDigitSubtract'<br>
+ parameters: #(#Integer )<br>
+ receiver: #Integer.<br>
- firstInteger := self primitive: 'primDigitSubtract'.<br>
(interpreterProxy isIntegerObject: firstInteger)<br>
+ ifTrue: ["convert it to a not normalized LargeInteger"<br>
- ifTrue:<br>
- ["convert it to a not normalized LargeInteger"<br>
self<br>
remapOop: secondInteger<br>
in: [firstLarge := self createLargeFromSmallInteger: firstInteger]]<br>
+ ifFalse: [firstLarge := firstInteger].<br>
- ifFalse:<br>
- [(self isLargeIntegerOop: firstInteger) ifFalse: [^interpreterProxy primitiveFail].<br>
- firstLarge := firstInteger].<br>
(interpreterProxy isIntegerObject: secondInteger)<br>
+ ifTrue: ["convert it to a not normalized LargeInteger"<br>
- ifTrue:<br>
- ["convert it to a not normalized LargeInteger"<br>
self<br>
remapOop: firstLarge<br>
in: [secondLarge := self createLargeFromSmallInteger: secondInteger]]<br>
+ ifFalse: [secondLarge := secondInteger].<br>
- ifFalse:<br>
- [(self isLargeIntegerOop: firstInteger) ifFalse: [^interpreterProxy primitiveFail].<br>
- secondLarge := secondInteger].<br>
^ self digitSubLarge: firstLarge with: secondLarge!<br>
<br>
Item was changed:<br>
----- Method: LargeIntegersPlugin>>primMontgomeryDigitLength (in category 'Integer primitives') -----<br>
primMontgomeryDigitLength<br>
self debugCode: [self msg: 'primMontgomeryDigitLength'].<br>
+ self<br>
+ primitive: 'primMontgomeryDigitLength'<br>
+ parameters: #()<br>
+ receiver: #Integer.<br>
- self primitive: 'primMontgomeryDigitLength'.<br>
^interpreterProxy integerObjectOf: 32!<br>
<br>
Item was changed:<br>
----- Method: LargeIntegersPlugin>>primMontgomeryTimes:modulo:mInvModB: (in category 'Integer primitives') -----<br>
primMontgomeryTimes: secondOperandInteger modulo: thirdModuloInteger mInvModB: mInverseInteger<br>
| firstLarge secondLarge firstInteger thirdLarge mInv |<br>
<var: #mInv type: #'unsigned int'><br>
self debugCode: [self msg: 'montgomeryTimes: secondOperandInteger modulo: thirdModuloInteger mInvModB: smallInverseInteger'].<br>
+ firstInteger := self<br>
+ primitive: 'primMontgomeryTimesModulo'<br>
+ parameters: #(Integer Integer Integer )<br>
+ receiver: #Integer.<br>
+ mInv := interpreterProxy positive32BitValueOf: mInverseInteger.<br>
- firstInteger := self primitive: 'primMontgomeryTimesModulo'.<br>
- mInv := interpreterProxy positive32BitValueOf: mInverseInteger.<br>
(interpreterProxy isIntegerObject: firstInteger)<br>
+ ifTrue: ["convert it to a not normalized LargeInteger"<br>
- ifTrue:<br>
- ["convert it to a not normalized LargeInteger"<br>
self remapOop: #(secondOperandInteger thirdModuloInteger) in: [firstLarge := self createLargeFromSmallInteger: firstInteger]]<br>
+ ifFalse: [firstLarge := firstInteger].<br>
- ifFalse:<br>
- [(self isLargeIntegerOop: firstInteger) ifFalse: [^interpreterProxy primitiveFail].<br>
- firstLarge := firstInteger].<br>
(interpreterProxy isIntegerObject: secondOperandInteger)<br>
+ ifTrue: ["convert it to a not normalized LargeInteger"<br>
- ifTrue:<br>
- ["convert it to a not normalized LargeInteger"<br>
self remapOop: #(firstLarge thirdModuloInteger) in: [secondLarge := self createLargeFromSmallInteger: secondOperandInteger]]<br>
+ ifFalse: [secondLarge := secondOperandInteger].<br>
- ifFalse:<br>
- [(self isLargeIntegerOop: secondOperandInteger) ifFalse: [^interpreterProxy primitiveFail].<br>
- secondLarge := secondOperandInteger].<br>
(interpreterProxy isIntegerObject: thirdModuloInteger)<br>
+ ifTrue: ["convert it to a not normalized LargeInteger"<br>
- ifTrue:<br>
- ["convert it to a not normalized LargeInteger"<br>
self remapOop: #(firstLarge secondLarge) in: [thirdLarge := self createLargeFromSmallInteger: thirdModuloInteger]]<br>
+ ifFalse: [thirdLarge := thirdModuloInteger].<br>
- ifFalse:<br>
- [(self isLargeIntegerOop: thirdModuloInteger) ifFalse: [^interpreterProxy primitiveFail].<br>
- thirdLarge := thirdModuloInteger].<br>
^ self digitMontgomery: firstLarge times: secondLarge modulo: thirdLarge mInvModB: mInv!<br>
<br>
Item was changed:<br>
----- Method: LargeIntegersPlugin>>primNormalizeNegative (in category 'Integer primitives') -----<br>
primNormalizeNegative<br>
| rcvr |<br>
self debugCode: [self msg: 'primNormalizeNegative'].<br>
+ rcvr := self<br>
+ primitive: 'primNormalizeNegative'<br>
+ parameters: #()<br>
+ receiver: #LargeNegativeInteger.<br>
- rcvr := self primitive: 'primNormalizeNegative'.<br>
- (interpreterProxy fetchClassOf: rcvr) == interpreterProxy classLargeNegativeInteger ifFalse: [^interpreterProxy primitiveFail].<br>
^ self normalizeNegative: rcvr!<br>
<br>
Item was changed:<br>
----- Method: LargeIntegersPlugin>>primNormalizePositive (in category 'Integer primitives') -----<br>
primNormalizePositive<br>
| rcvr |<br>
self debugCode: [self msg: 'primNormalizePositive'].<br>
+ rcvr := self<br>
+ primitive: 'primNormalizePositive'<br>
+ parameters: #()<br>
+ receiver: #LargePositiveInteger.<br>
- rcvr := self primitive: 'primNormalizePositive'.<br>
- (interpreterProxy fetchClassOf: rcvr) == interpreterProxy classLargePositiveInteger ifFalse: [^interpreterProxy primitiveFail].<br>
^ self normalizePositive: rcvr!<br>
<br>
Item was added:<br>
+ ----- Method: LargeNegativeInteger class>>ccg:prolog:expr:index: (in category '*VMMaker-plugin generation') -----<br>
+ ccg: cg prolog: aBlock expr: aString index: anInteger<br>
+<br>
+ ^cg ccgLoad: aBlock expr: aString asMemberOfLargeNegativeIntegerFrom: anInteger!<br>
<br>
Item was added:<br>
+ ----- Method: LargePositiveInteger class>>ccg:prolog:expr:index: (in category '*VMMaker-plugin generation') -----<br>
+ ccg: cg prolog: aBlock expr: aString index: anInteger<br>
+<br>
+ ^cg ccgLoad: aBlock expr: aString asMemberOfLargePositiveIntegerFrom: anInteger!<br>
<br>
Item was added:<br>
+ ----- Method: NewCoObjectMemorySimulator>>isKindOfInteger: (in category 'simulation only') -----<br>
+ isKindOfInteger: offset<br>
+ ^coInterpreter isKindOfInteger: offset!<br>
<br>
Item was added:<br>
+ ----- Method: NewCoObjectMemorySimulator>>isLargeIntegerObject: (in category 'simulation only') -----<br>
+ isLargeIntegerObject: offset<br>
+ ^coInterpreter isLargeIntegerObject: offset!<br>
<br>
Item was added:<br>
+ ----- Method: NewCoObjectMemorySimulator>>isLargeNegativeIntegerObject: (in category 'simulation only') -----<br>
+ isLargeNegativeIntegerObject: offset<br>
+ ^coInterpreter isLargeNegativeIntegerObject: offset!<br>
<br>
Item was added:<br>
+ ----- Method: NewCoObjectMemorySimulator>>isLargePositiveIntegerObject: (in category 'simulation only') -----<br>
+ isLargePositiveIntegerObject: offset<br>
+ ^coInterpreter isLargePositiveIntegerObject: offset!<br>
<br>
Item was added:<br>
+ ----- Method: NewObjectMemorySimulator>>isKindOfInteger: (in category 'simulation only') -----<br>
+ isKindOfInteger: offset<br>
+ ^coInterpreter isKindOfInteger: offset!<br>
<br>
Item was added:<br>
+ ----- Method: NewObjectMemorySimulator>>isLargeIntegerObject: (in category 'simulation only') -----<br>
+ isLargeIntegerObject: offset<br>
+ ^coInterpreter isLargeIntegerObject: offset!<br>
<br>
Item was added:<br>
+ ----- Method: NewObjectMemorySimulator>>isLargeNegativeIntegerObject: (in category 'simulation only') -----<br>
+ isLargeNegativeIntegerObject: offset<br>
+ ^coInterpreter isLargeNegativeIntegerObject: offset!<br>
<br>
Item was added:<br>
+ ----- Method: NewObjectMemorySimulator>>isLargePositiveIntegerObject: (in category 'simulation only') -----<br>
+ isLargePositiveIntegerObject: offset<br>
+ ^coInterpreter isLargePositiveIntegerObject: offset!<br>
<br>
Item was changed:<br>
----- Method: ObjectMemory>>cCoerceSimple:to: (in category 'simulation support') -----<br>
cCoerceSimple: value to: cTypeString<br>
<doNotGenerate><br>
^cTypeString caseOf:<br>
+ { [#'char *'] -> [value].<br>
+ [#'unsigned int'] -> [value]. }!<br>
- { [#'char *'] -> [value] }!<br>
<br>
Item was added:<br>
+ ----- Method: ObjectMemory>>isInstanceOfClassLargeNegativeInteger: (in category 'interpreter access') -----<br>
+ isInstanceOfClassLargeNegativeInteger: oop<br>
+ <inline: true><br>
+ "N.B. Because Slang always inlines is:instanceOf:compactClassIndex:<br>
+ (because is:instanceOf:compactClassIndex: has an inline: pragma) the<br>
+ phrase (objectMemory splObj: ClassLargeNegativeInteger) is expanded<br>
+ in-place and is _not_ evaluated if oop has a non-zero CompactClassIndex."<br>
+ ^self<br>
+ is: oop<br>
+ instanceOf: (self splObj: ClassLargeNegativeInteger)<br>
+ compactClassIndex: ClassLargeNegativeIntegerCompactIndex!<br>
<br>
Item was added:<br>
+ ----- Method: ObjectMemory>>isInstanceOfClassLargePositiveInteger: (in category 'interpreter access') -----<br>
+ isInstanceOfClassLargePositiveInteger: oop<br>
+ <inline: true><br>
+ "N.B. Because Slang always inlines is:instanceOf:compactClassIndex:<br>
+ (because is:instanceOf:compactClassIndex: has an inline: pragma) the<br>
+ phrase (objectMemory splObj: ClassLargePositiveInteger) is expanded<br>
+ in-place and is _not_ evaluated if oop has a non-zero CompactClassIndex."<br>
+ ^self<br>
+ is: oop<br>
+ instanceOf: (self splObj: ClassLargePositiveInteger)<br>
+ compactClassIndex: ClassLargePositiveIntegerCompactIndex!<br>
<br>
Item was added:<br>
+ ----- Method: ObjectMemory>>isLargeIntegerInstance: (in category 'interpreter access') -----<br>
+ isLargeIntegerInstance: oop<br>
+ <inline: true><br>
+ ^(self isInstanceOfClassLargePositiveInteger: oop)<br>
+ or: [self isInstanceOfClassLargeNegativeInteger: oop]!<br>
<br>
Item was added:<br>
+ ----- Method: SmartSyntaxPluginCodeGenerator>>ccgLoad:expr:asKindOfIntegerFrom: (in category 'coercing') -----<br>
+ ccgLoad: aBlock expr: aString asKindOfIntegerFrom: anInteger<br>
+<br>
+ ^String streamContents: [:aStream | aStream<br>
+ nextPutAll: 'interpreterProxy success: (interpreterProxy isKindOfInteger: (interpreterProxy stackValue: ';<br>
+ nextPutAll: anInteger asString;<br>
+ nextPutAll: ')).';<br>
+ crtab;<br>
+ nextPutAll: (self<br>
+ ccgLoad: aBlock<br>
+ expr: aString<br>
+ asRawOopFrom: anInteger)]!<br>
<br>
Item was added:<br>
+ ----- Method: SmartSyntaxPluginCodeGenerator>>ccgLoad:expr:asMemberOfLargeNegativeIntegerFrom: (in category 'coercing') -----<br>
+ ccgLoad: aBlock expr: aString asMemberOfLargeNegativeIntegerFrom: anInteger<br>
+<br>
+ ^String streamContents: [:aStream | aStream<br>
+ nextPutAll: 'interpreterProxy success: (interpreterProxy isLargeNegativeIntegerObject: (interpreterProxy stackValue: ';<br>
+ nextPutAll: anInteger asString;<br>
+ nextPutAll: ')).';<br>
+ crtab;<br>
+ nextPutAll: (self<br>
+ ccgLoad: aBlock<br>
+ expr: aString<br>
+ asRawOopFrom: anInteger)]!<br>
<br>
Item was added:<br>
+ ----- Method: SmartSyntaxPluginCodeGenerator>>ccgLoad:expr:asMemberOfLargePositiveIntegerFrom: (in category 'coercing') -----<br>
+ ccgLoad: aBlock expr: aString asMemberOfLargePositiveIntegerFrom: anInteger<br>
+<br>
+ ^String streamContents: [:aStream | aStream<br>
+ nextPutAll: 'interpreterProxy success: (interpreterProxy isLargePositiveIntegerObject: (interpreterProxy stackValue: ';<br>
+ nextPutAll: anInteger asString;<br>
+ nextPutAll: ')).';<br>
+ crtab;<br>
+ nextPutAll: (self<br>
+ ccgLoad: aBlock<br>
+ expr: aString<br>
+ asRawOopFrom: anInteger)]!<br>
<br>
Item was added:<br>
+ ----- Method: SmartSyntaxPluginSimulator>>ccgLoad:expr:asKindOfIntegerFrom: (in category 'simulation') -----<br>
+ ccgLoad: forProlog expr: failBlock asKindOfIntegerFrom: argIndexOrNil<br>
+ ^[:oop|<br>
+ interpreterProxy success: (interpreterProxy isKindOfInteger: oop).<br>
+ oop]!<br>
<br>
Item was added:<br>
+ ----- Method: SmartSyntaxPluginSimulator>>ccgLoad:expr:asMemberOfLargeNegativeIntegerFrom: (in category 'simulation') -----<br>
+ ccgLoad: forProlog expr: failBlock asMemberOfLargeNegativeIntegerFrom: argIndexOrNil<br>
+ ^[:oop|<br>
+ interpreterProxy success: (interpreterProxy isLargeNegativeIntegerObject: oop).<br>
+ oop]!<br>
<br>
Item was added:<br>
+ ----- Method: SmartSyntaxPluginSimulator>>ccgLoad:expr:asMemberOfLargePositiveIntegerFrom: (in category 'simulation') -----<br>
+ ccgLoad: forProlog expr: failBlock asMemberOfLargePositiveIntegerFrom: argIndexOrNil<br>
+ ^[:oop|<br>
+ interpreterProxy success: (interpreterProxy isLargePositiveIntegerObject: oop).<br>
+ oop]!<br>
<br>
Item was added:<br>
+ ----- Method: SpurMemoryManager>>isInstanceOfClassLargeNegativeInteger: (in category 'interpreter access') -----<br>
+ isInstanceOfClassLargeNegativeInteger: oop<br>
+ "Answer if the oop is a large negative integer instance."<br>
+ ^(self isNonImmediate: oop) and: [(self classIndexOf: oop) = ClassLargeNegativeIntegerCompactIndex]!<br>
<br>
Item was added:<br>
+ ----- Method: SpurMemoryManager>>isInstanceOfClassLargePositiveInteger: (in category 'interpreter access') -----<br>
+ isInstanceOfClassLargePositiveInteger: oop<br>
+ "Answer if the oop is a large positive integer instance."<br>
+ ^(self isNonImmediate: oop) and: [(self classIndexOf: oop) = ClassLargePositiveIntegerCompactIndex]!<br>
<br>
Item was added:<br>
+ ----- Method: SpurMemoryManager>>isLargeIntegerInstance: (in category 'interpreter access') -----<br>
+ isLargeIntegerInstance: oop<br>
+ "Answer if the oop is a large positive or negative integer instance."<br>
+ ^(self isNonImmediate: oop) and: [((self classIndexOf: oop) - ClassLargeNegativeIntegerCompactIndex) asUnsignedInteger <= 1]!<br>
<br>
Item was added:<br>
+ ----- Method: StackInterpreter>>isKindOfInteger: (in category 'internal interpreter access') -----<br>
+ isKindOfInteger: oop<br>
+ "Answer true if the oop is kind of Integer (Small or Large)."<br>
+ <api><br>
+ <inline: true><br>
+ ^(objectMemory isIntegerObject: oop)<br>
+ or: [objectMemory isLargeIntegerInstance: oop]!<br>
<br>
Item was added:<br>
+ ----- Method: StackInterpreter>>isLargeIntegerObject: (in category 'internal interpreter access') -----<br>
+ isLargeIntegerObject: oop<br>
+ <api><br>
+ <inline: true><br>
+ ^objectMemory isLargeIntegerInstance: oop!<br>
<br>
Item was added:<br>
+ ----- Method: StackInterpreter>>isLargeNegativeIntegerObject: (in category 'internal interpreter access') -----<br>
+ isLargeNegativeIntegerObject: oop<br>
+ <api><br>
+ <inline: true><br>
+ ^objectMemory isInstanceOfClassLargeNegativeInteger: oop!<br>
<br>
Item was added:<br>
+ ----- Method: StackInterpreter>>isLargePositiveIntegerObject: (in category 'internal interpreter access') -----<br>
+ isLargePositiveIntegerObject: oop<br>
+ <api><br>
+ <inline: true><br>
+ ^objectMemory isInstanceOfClassLargePositiveInteger: oop!<br>
<br>
Item was changed:<br>
----- Method: StackInterpreter>>printStringOf: (in category 'debug printing') -----<br>
printStringOf: oop<br>
| fmt len cnt max i |<br>
<inline: false><br>
(objectMemory isImmediate: oop) ifTrue:<br>
[^self].<br>
(objectMemory addressCouldBeObj: oop) ifFalse:<br>
[^self].<br>
fmt := objectMemory formatOf: oop.<br>
fmt < objectMemory firstByteFormat ifTrue: [^self].<br>
<br>
cnt := (max := 128) min: (len := objectMemory lengthOf: oop).<br>
i := 0.<br>
<br>
((objectMemory is: oop<br>
instanceOf: (objectMemory splObj: ClassByteArray)<br>
compactClassIndex: classByteArrayCompactIndex)<br>
+ or: [(objectMemory isLargeIntegerInstance: oop)])<br>
- or: [(self isInstanceOfClassLargePositiveInteger: oop)<br>
- or: [(self isInstanceOfClassLargeNegativeInteger: oop)]])<br>
ifTrue:<br>
[[i < cnt] whileTrue:<br>
[self printHex: (objectMemory fetchByte: i ofObject: oop).<br>
i := i + 1]]<br>
ifFalse:<br>
[[i < cnt] whileTrue:<br>
[self cCode:<br>
[(objectMemory fetchByte: i ofObject: oop) = 13 "Character cr asInteger" ifTrue:<br>
[self print: '<CR>'.<br>
i + 1 < len ifTrue:<br>
[self print: '...'].<br>
^self]].<br>
self printChar: (objectMemory fetchByte: i ofObject: oop).<br>
i := i + 1]].<br>
len > max ifTrue:<br>
[self print: '...'].<br>
self flush!<br>
<br>
Item was changed:<br>
----- Method: ThreadedFFIPlugin>>ffiIntegerValueOf: (in category 'callout support') -----<br>
ffiIntegerValueOf: oop<br>
"Support for generic callout. Answer an integer value that is coerced as C would do."<br>
<inline: true><br>
"Cheat with a tag test"<br>
(oop anyMask: BytesPerWord - 1)<br>
ifTrue:<br>
[(interpreterProxy isIntegerObject: oop) ifTrue:<br>
[^interpreterProxy integerValueOf: oop].<br>
self cppIf: SPURVM<br>
ifTrue:<br>
[(interpreterProxy isCharacterObject: oop) ifTrue: "Immediate in Spur"<br>
[^interpreterProxy characterValueOf: oop].<br>
(interpreterProxy isFloatObject: oop) ifTrue: "Immediate in 64-bit Spur"<br>
[^interpreterProxy floatValueOf: oop]]]<br>
ifFalse:<br>
[self cppIf: SPURVM<br>
ifTrue: "No non-immediate characters in Spur"<br>
[]<br>
ifFalse:<br>
[(interpreterProxy isCharacterObject: oop) ifTrue:<br>
[^interpreterProxy characterValueOf: oop]].<br>
(interpreterProxy isFloatObject: oop) ifTrue:<br>
[^interpreterProxy floatValueOf: oop].<br>
oop = interpreterProxy nilObject ifTrue: [^0]. "@@: should we really allow this????"<br>
oop = interpreterProxy falseObject ifTrue: [^0].<br>
oop = interpreterProxy trueObject ifTrue: [^1].<br>
+ (interpreterProxy isLargePositiveIntegerObject: oop) ifTrue:<br>
- (interpreterProxy fetchClassOf: oop) = interpreterProxy classLargePositiveInteger ifTrue:<br>
[self cppIf: BytesPerWord = 8 "Use cppIf: to get the return type of the function right. Should be sqInt on 32-bits."<br>
ifTrue: [^interpreterProxy positive64BitValueOf: oop]<br>
ifFalse: [^interpreterProxy positive32BitValueOf: oop]]].<br>
^interpreterProxy signedMachineIntegerValueOf: oop "<- will fail if not integer"!<br>
<br>
</blockquote></div><br></div>