[Vm-dev] VM Maker: VMMaker.oscog-nice.2750.mcz
commits at source.squeak.org
commits at source.squeak.org
Sat May 2 10:34:53 UTC 2020
Nicolas Cellier uploaded a new version of VMMaker to project VM Maker:
http://source.squeak.org/VMMaker/VMMaker.oscog-nice.2750.mcz
==================== Summary ====================
Name: VMMaker.oscog-nice.2750
Author: nice
Time: 2 May 2020, 12:33:42.712426 pm
UUID: f741b52f-ad8a-bb4d-a9ee-41105735f21c
Ancestors: VMMaker.oscog-nice.2749
Extend the capability of SmartSyntaxPluginCodeGenerator to handle DoubleByte and DoubleWord Arrays.
Remove the #debugCode: from the prolog of LargeIntegersPlugin primitives.
This was used only for printing a console trace upon primitive entry.
That's not how we are going to debug the plugin.
We are going to debug either with a VM Simulation, or via a modern debugger like gdb (cough!) if ever the problem lies in code generation itself.
Keep only two sends of debugCode: tracing case of un-normalized inputs.
Note: most of the SmartSyntaxPluginCodeGenerator capabilities/messages are currently unused.
See #initializeCTranslationDictionary.
The lack of examples make it very difficult to follow the code, or even guess the purpose.
No need to say that comments will not help.
Comments? who ever needed a comment in Smalltalk?
With greatest shame, I must confess, I need comments sometimes!
With such property, the code may live very long untouched, put your dirty nose out of this code ;)
=============== Diff against VMMaker.oscog-nice.2749 ===============
Item was added:
+ ----- Method: DoubleByteArray class>>ccg:prolog:expr:index: (in category '*VMMaker-plugin generation') -----
+ ccg: cg prolog: aBlock expr: aString index: anInteger
+
+ ^cg
+ ccgLoad: aBlock
+ expr: aString
+ asUnsignedShortPtrFrom: anInteger
+ andThen: (cg ccgValBlock: 'isShorts')!
Item was added:
+ ----- Method: DoubleByteArray class>>ccgDeclareCForVar: (in category '*VMMaker-plugin generation') -----
+ ccgDeclareCForVar: aSymbolOrString
+ "Address of an unsigned 16 bit value, regardless of Smalltalk wordSize"
+
+ ^'unsigned short *', aSymbolOrString!
Item was added:
+ ----- Method: DoubleWordArray class>>ccg:prolog:expr:index: (in category '*VMMaker-plugin generation') -----
+ ccg: cg prolog: aBlock expr: aString index: anInteger
+
+ ^cg
+ ccgLoad: aBlock
+ expr: aString
+ asUnsignedLong64PtrFrom: anInteger
+ andThen: (cg ccgValBlock: 'isLong64s')!
Item was added:
+ ----- Method: DoubleWordArray class>>ccgDeclareCForVar: (in category '*VMMaker-plugin generation') -----
+ ccgDeclareCForVar: aSymbolOrString
+ "Address of an unsigned 64 bit value, regardless of Smalltalk wordSize"
+
+ ^'unsigned long long *', aSymbolOrString!
Item was changed:
----- Method: LargeIntegersPlugin>>anyBitOfLargeInt:from:to: (in category 'util') -----
anyBitOfLargeInt: anOop from: start to: stopArg
"Argument has to be a Large Integer!!"
"Tests for any magnitude bits in the interval from start to stopArg."
| magnitude stop firstDigitIx lastDigitIx firstMask lastMask |
<var: #digit type: #'unsigned int'>
<var: #firstMask type: #'unsigned int'>
<var: #lastMask type: #'unsigned int'>
<var: #firstDigitIx type: #usqInt>
<var: #lastDigitIx type: #usqInt>
<var: #ix type: #usqInt>
- self
- debugCode: [self msg: 'anyBitOfLargeInt: anOop from: start to: stopArg'].
magnitude := anOop.
stop := stopArg min: (self highBitOfLargeInt: magnitude).
start > stop
ifTrue: [^ false].
firstDigitIx := start - 1 // 32 + 1.
lastDigitIx := stop - 1 // 32 + 1.
firstMask := 16rFFFFFFFF << (start - 1 bitAnd: 31).
lastMask := 16rFFFFFFFF >> (31 - (stop - 1 bitAnd: 31)).
firstDigitIx = lastDigitIx
ifTrue: [| digit |
digit := self unsafeDigitOfLargeInt: magnitude at: firstDigitIx.
^ (digit bitAnd: (firstMask bitAnd: lastMask))
~= 0].
((self unsafeDigitOfLargeInt: magnitude at: firstDigitIx) bitAnd: firstMask)
~= 0
ifTrue: [^ true].
firstDigitIx + 1
to: lastDigitIx - 1
do: [:ix | (self unsafeDigitOfLargeInt: magnitude at: ix)
~= 0
ifTrue: [^ true]].
((self unsafeDigitOfLargeInt: magnitude at: lastDigitIx) bitAnd: lastMask)
~= 0
ifTrue: [^ true].
^ false!
Item was changed:
----- Method: LargeIntegersPlugin>>normalize: (in category 'oop functions') -----
normalize: aLargeInteger
"Check for leading zeroes and return shortened copy if so."
- self debugCode: [self msg: 'normalize: aLargeInteger'].
(interpreterProxy isLargePositiveIntegerObject: aLargeInteger)
ifTrue: [^ self normalizePositive: aLargeInteger]
ifFalse: [^ self normalizeNegative: aLargeInteger]!
Item was changed:
----- Method: LargeIntegersPlugin>>primAnyBitFrom:to: (in category 'Integer primitives') -----
primAnyBitFrom: from to: to
| integer someBitIsSet val mask |
- self debugCode: [self msg: 'primAnyBitFrom: from to: to'].
integer := self
primitive: 'primAnyBitFromTo'
parameters: #(#SmallInteger #SmallInteger )
receiver: #Integer.
from < 1 | (to < 1)
ifTrue: [^ interpreterProxy primitiveFail].
(interpreterProxy isIntegerObject: integer)
ifTrue: ["For small integers, use a single bit mask operation"
from <= to
ifTrue:
[val := interpreterProxy integerValueOf: integer.
val < 0 ifTrue: ["Get the bits of magnitude" val := 0 - val].
mask := (1 asUnsignedInteger << (to min: (self sizeof: #usqInt)*8-1))
- (1 asUnsignedInteger << (from - 1 min: (self sizeof: #usqInt)*8-1)).
someBitIsSet := val anyMask: mask]
ifFalse: [someBitIsSet := 0]]
ifFalse: [someBitIsSet := self
anyBitOfLargeInt: integer
from: from
to: to].
^someBitIsSet asOop: Boolean!
Item was changed:
----- Method: LargeIntegersPlugin>>primDigitAdd: (in category 'Integer primitives') -----
primDigitAdd: secondInteger
| firstLarge secondLarge firstInteger |
- self debugCode: [self msg: 'primDigitAdd: secondInteger'].
firstInteger := self
primitive: 'primDigitAdd'
parameters: #(Integer )
receiver: #Integer.
(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 changed:
----- Method: LargeIntegersPlugin>>primDigitBitAnd: (in category 'Integer primitives') -----
primDigitBitAnd: secondInteger
"Bit logic here is only implemented for positive integers or Zero; if rec
or arg is negative, it fails."
| firstInteger |
- self debugCode: [self msg: 'primDigitBitAnd: secondInteger'].
firstInteger := self
primitive: 'primDigitBitAnd'
parameters: #(Integer )
receiver: #Integer.
^ self
digitBitLogic: firstInteger
with: secondInteger
opIndex: andOpIndex!
Item was changed:
----- Method: LargeIntegersPlugin>>primDigitBitOr: (in category 'Integer primitives') -----
primDigitBitOr: secondInteger
"Bit logic here is only implemented for positive integers or Zero; if rec
or arg is negative, it fails."
| firstInteger |
- self debugCode: [self msg: 'primDigitBitOr: secondInteger'].
firstInteger := self
primitive: 'primDigitBitOr'
parameters: #(Integer )
receiver: #Integer.
^ self
digitBitLogic: firstInteger
with: secondInteger
opIndex: orOpIndex!
Item was changed:
----- Method: LargeIntegersPlugin>>primDigitBitShiftMagnitude: (in category 'Integer primitives') -----
primDigitBitShiftMagnitude: shiftCount
| rShift aLarge anInteger |
- self debugCode: [self msg: 'primDigitBitShiftMagnitude: shiftCount'].
anInteger := self
primitive: 'primDigitBitShiftMagnitude'
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 changed:
----- Method: LargeIntegersPlugin>>primDigitBitXor: (in category 'Integer primitives') -----
primDigitBitXor: secondInteger
"Bit logic here is only implemented for positive integers or Zero; if rec
or arg is negative, it fails."
| firstInteger |
- self debugCode: [self msg: 'primDigitBitXor: secondInteger'].
firstInteger := self
primitive: 'primDigitBitXor'
parameters: #(Integer )
receiver: #Integer.
^ self
digitBitLogic: firstInteger
with: secondInteger
opIndex: xorOpIndex!
Item was changed:
----- Method: LargeIntegersPlugin>>primDigitCompare: (in category 'Integer primitives') -----
primDigitCompare: secondInteger
"Compare the magnitude of self with that of arg.
Answer a code of 1, 0, -1 for self >, = , < arg" | firstVal secondVal firstInteger |
- self debugCode: [self msg: 'primDigitCompare: secondInteger'].
firstInteger := self
primitive: 'primDigitCompare'
parameters: #(#Integer )
receiver: #Integer.
"shortcut: aSmallInteger has to be smaller in Magnitude than aLargeInteger"
(interpreterProxy isIntegerObject: firstInteger) ifTrue:
[(interpreterProxy isIntegerObject: secondInteger) ifTrue:
[firstVal := interpreterProxy integerValueOf: firstInteger.
secondVal := interpreterProxy integerValueOf: secondInteger.
"Compute their magnitudes. Since SmallIntegers are tagged they have
fewer bits than an integer on the platform; therefore in computing their
magnitude they cannot overflow."
firstVal < 0 ifTrue: [firstVal := 0 - firstVal].
secondVal < 0 ifTrue: [secondVal := 0 - secondVal].
^firstVal = secondVal
ifTrue: [0 asOop: SmallInteger]
ifFalse:
[firstVal < secondVal
ifTrue: [-1 asOop: SmallInteger]
ifFalse: [1 asOop: SmallInteger]]].
^-1 asOop: SmallInteger]. "first < second"
(interpreterProxy isIntegerObject: secondInteger) ifTrue:
[^1 asOop: SmallInteger]. "first > second"
^ self digitCompareLarge: firstInteger with: secondInteger!
Item was changed:
----- Method: LargeIntegersPlugin>>primDigitDiv:negative: (in category 'Integer primitives') -----
primDigitDiv: secondInteger negative: neg
"Answer the result of dividing firstInteger by secondInteger.
Fail if parameters are not integers, not normalized or secondInteger is
zero. "
| firstAsLargeInteger secondAsLargeInteger firstInteger |
- self debugCode: [self msg: 'primDigitDiv: secondInteger negative: neg'].
firstInteger := self
primitive: 'primDigitDivNegative'
parameters: #(#Integer #Boolean )
receiver: #Integer.
"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:
["Avoid crashes in case of getting unnormalized args."
(self isNormalized: firstInteger)
ifFalse:
[self debugCode:
[self msg: 'ERROR in primDigitDiv: secondInteger negative: neg'.
self msg: '------> receiver *not* normalized!!'].
^ interpreterProxy primitiveFail].
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:
["Avoid crashes in case of getting unnormalized args."
(self isNormalized: secondInteger)
ifFalse:
[self debugCode:
[self msg: 'ERROR in primDigitDiv: secondInteger negative: neg'.
self msg: '------> argument *not* normalized!!'].
^ interpreterProxy primitiveFail].
secondAsLargeInteger := secondInteger].
^ self
digitDivLarge: firstAsLargeInteger
with: secondAsLargeInteger
negative: neg!
Item was changed:
----- Method: LargeIntegersPlugin>>primDigitMultiply:negative: (in category 'Integer primitives') -----
primDigitMultiply: secondInteger negative: neg
| firstLarge secondLarge firstInteger |
- self debugCode: [self msg: 'primDigitMultiply: secondInteger negative: neg'].
firstInteger := self
primitive: 'primDigitMultiplyNegative'
parameters: #(#Integer #Boolean )
receiver: #Integer.
(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 changed:
----- Method: LargeIntegersPlugin>>primDigitSubtract: (in category 'Integer primitives') -----
primDigitSubtract: secondInteger
| firstLarge secondLarge firstInteger |
- self debugCode: [self msg: 'primDigitSubtract: secondInteger'].
firstInteger := self
primitive: 'primDigitSubtract'
parameters: #(#Integer )
receiver: #Integer.
(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 changed:
----- Method: LargeIntegersPlugin>>primGetModuleName (in category 'control & support primitives') -----
primGetModuleName
"If calling this primitive fails, then C module does not exist."
| strLen strOop |
- self debugCode: [self msg: 'primGetModuleName'].
self
primitive: 'primGetModuleName'
parameters: #()
receiver: #Oop.
strLen := self strlen: self getModuleName.
strOop := interpreterProxy instantiateClass: interpreterProxy classString indexableSize: strLen.
self strncpy: (interpreterProxy firstIndexableField: strOop)
_: self getModuleName
_: strLen.
^strOop!
Item was changed:
----- Method: LargeIntegersPlugin>>primMontgomeryDigitLength (in category 'Integer primitives') -----
primMontgomeryDigitLength
- self debugCode: [self msg: 'primMontgomeryDigitLength'].
self
primitive: 'primMontgomeryDigitLength'
parameters: #()
receiver: #Integer.
^interpreterProxy integerObjectOf: 32!
Item was changed:
----- Method: LargeIntegersPlugin>>primMontgomeryTimes:modulo:mInvModB: (in category 'Integer primitives') -----
primMontgomeryTimes: secondOperandInteger modulo: thirdModuloInteger mInvModB: mInverseInteger
| firstLarge secondLarge firstInteger thirdLarge mInv |
<var: #mInv type: #'unsigned int'>
- self debugCode: [self msg: 'montgomeryTimes: secondOperandInteger modulo: thirdModuloInteger mInvModB: smallInverseInteger'].
firstInteger := self
primitive: 'primMontgomeryTimesModulo'
parameters: #(Integer Integer Integer )
receiver: #Integer.
mInv := interpreterProxy positive32BitValueOf: mInverseInteger.
(interpreterProxy isIntegerObject: firstInteger)
ifTrue: ["convert it to a not normalized LargeInteger"
self remapOop: #(secondOperandInteger thirdModuloInteger) in: [firstLarge := self createLargeFromSmallInteger: firstInteger]]
ifFalse: [firstLarge := firstInteger].
(interpreterProxy isIntegerObject: secondOperandInteger)
ifTrue: ["convert it to a not normalized LargeInteger"
self remapOop: #(firstLarge thirdModuloInteger) in: [secondLarge := self createLargeFromSmallInteger: secondOperandInteger]]
ifFalse: [secondLarge := secondOperandInteger].
(interpreterProxy isIntegerObject: thirdModuloInteger)
ifTrue: ["convert it to a not normalized LargeInteger"
self remapOop: #(firstLarge secondLarge) in: [thirdLarge := self createLargeFromSmallInteger: thirdModuloInteger]]
ifFalse: [thirdLarge := thirdModuloInteger].
^ self digitMontgomery: firstLarge times: secondLarge modulo: thirdLarge mInvModB: mInv!
Item was changed:
----- Method: LargeIntegersPlugin>>primNormalizeNegative (in category 'Integer primitives') -----
primNormalizeNegative
| rcvr |
- self debugCode: [self msg: 'primNormalizeNegative'].
rcvr := self
primitive: 'primNormalizeNegative'
parameters: #()
receiver: #LargeNegativeInteger.
^ self normalizeNegative: rcvr!
Item was changed:
----- Method: LargeIntegersPlugin>>primNormalizePositive (in category 'Integer primitives') -----
primNormalizePositive
| rcvr |
- self debugCode: [self msg: 'primNormalizePositive'].
rcvr := self
primitive: 'primNormalizePositive'
parameters: #()
receiver: #LargePositiveInteger.
^ self normalizePositive: rcvr!
Item was added:
+ ----- Method: SmartSyntaxPluginAssignmentCodeGenerator>>ccgLoad:expr:asUnsignedLong64PtrFrom:andThen: (in category 'coercing') -----
+ ccgLoad: aBlock expr: aString asUnsignedLong64PtrFrom: stackIndex andThen: valBlock
+ ^self assign: aString coerceTo: 'unsigned long long *' from: stackIndex!
Item was added:
+ ----- Method: SmartSyntaxPluginAssignmentCodeGenerator>>ccgLoad:expr:asUnsignedShortPtrFrom:andThen: (in category 'coercing') -----
+ ccgLoad: aBlock expr: aString asUnsignedShortPtrFrom: stackIndex andThen: valBlock
+ ^self assign: aString coerceTo: 'unsigned short *' from: stackIndex!
Item was added:
+ ----- Method: SmartSyntaxPluginCodeGenerator>>ccgLoad:expr:asUnsignedLong64PtrFrom:andThen: (in category 'coercing') -----
+ ccgLoad: aBlock expr: aString asUnsignedLong64PtrFrom: anInteger andThen: valBlock
+ "Answer a codestring for integer pointer to first indexable field of object (without validating side-effect unless specified in valBlock), as described in comment to ccgLoad:expr:asRawOopFrom:"
+
+ ^(valBlock value: anInteger), '.',
+ (aBlock value: (String streamContents: [:aStream | aStream
+ nextPutAll: 'self cCoerce: (interpreterProxy firstIndexableField:';
+ crtab: 4;
+ nextPutAll: '(interpreterProxy stackValue:';
+ nextPutAll: anInteger asString;
+ nextPutAll: '))';
+ crtab: 3;
+ nextPutAll: 'to: ''unsigned long long *''']))!
Item was added:
+ ----- Method: SmartSyntaxPluginCodeGenerator>>ccgLoad:expr:asUnsignedShortPtrFrom:andThen: (in category 'coercing') -----
+ ccgLoad: aBlock expr: aString asUnsignedShortPtrFrom: anInteger andThen: valBlock
+ "Answer a codestring for integer pointer to first indexable field of object (without validating side-effect unless specified in valBlock), as described in comment to ccgLoad:expr:asRawOopFrom:"
+
+ ^(valBlock value: anInteger), '.',
+ (aBlock value: (String streamContents: [:aStream | aStream
+ nextPutAll: 'self cCoerce: (interpreterProxy firstIndexableField:';
+ crtab: 4;
+ nextPutAll: '(interpreterProxy stackValue:';
+ nextPutAll: anInteger asString;
+ nextPutAll: '))';
+ crtab: 3;
+ nextPutAll: 'to: ''unsigned short *''']))!
Item was added:
+ ----- Method: SmartSyntaxPluginCodeGenerator>>generateIsBytes:on:indent: (in category 'translating builtins') -----
+ generateIsBytes: aNode on: aStream indent: anInteger
+ self genCallOf: #isBytes: with: aNode receiver on: aStream!
Item was added:
+ ----- Method: SmartSyntaxPluginCodeGenerator>>generateIsLong64s:on:indent: (in category 'translating builtins') -----
+ generateIsLong64s: aNode on: aStream indent: anInteger
+ self genCallOf: #isLong64s: with: aNode receiver on: aStream!
Item was added:
+ ----- Method: SmartSyntaxPluginCodeGenerator>>generateIsShorts:on:indent: (in category 'translating builtins') -----
+ generateIsShorts: aNode on: aStream indent: anInteger
+ self genCallOf: #isShorts: with: aNode receiver on: aStream!
Item was changed:
----- Method: SmartSyntaxPluginCodeGenerator>>initializeCTranslationDictionary (in category 'translating builtins') -----
initializeCTranslationDictionary
"Initialize the dictionary mapping message names to actions for C code generation."
| pairs |
super initializeCTranslationDictionary.
pairs := #(
#asCInt #generateAsCInt:on:indent:
#asCUnsigned #generateAsCUnsigned:on:indent:
#asCBoolean #generateAsCBoolean:on:indent:
#asCDouble #generateAsCDouble:on:indent:
#asSmallIntegerObj #generateAsSmallIntegerObj:on:indent:
#asPositiveIntegerObj #generateAsPositiveIntegerObj:on:indent:
#asBooleanObj #generateAsBooleanObj:on:indent:
#asFloatObj #generateAsFloatObj:on:indent:
#asIf:var: #generateAsIfVar:on:indent:
#asIf:var:asValue: #generateAsIfVarAsValue:on:indent:
#asIf:var:put: #generateAsIfVarPut:on:indent:
#field: #generateField:on:indent:
#field:put: #generateFieldPut:on:indent:
#class #generateClass:on:indent:
#stSize #generateStSize:on:indent:
#stAt: #generateStAt:on:indent:
#stAt:put: #generateStAtPut:on:indent:
#asCharPtr #generateAsCharPtr:on:indent:
#asIntPtr #generateAsIntPtr:on:indent:
#cPtrAsOop #generateCPtrAsOop:on:indent:
#next #generateNext:on:indent:
#asOop: #generateAsOop:on:indent:
#asValue: #generateAsValue:on:indent:
#isFloat #generateIsFloat:on:indent:
#isIndexable #generateIsIndexable:on:indent:
#isIntegerOop #generateIsIntegerOop:on:indent:
#isIntegerValue #generateIsIntegerValue:on:indent:
"#FloatOop #generateIsFloatValue:on:indent:" "unused, never implemented"
+ #isBytes #generateIsBytes:on:indent:
+ #isShorts #generateIsShorts:on:indent:
+ #isLong64s #generateIsLong64s:on:indent:
#isWords #generateIsWords:on:indent:
#isWordsOrBytes #generateIsWordsOrBytes:on:indent:
#isPointers #generateIsPointers:on:indent:
#isNil #generateIsNil:on:indent:
#isMemberOf: #generateIsMemberOf:on:indent:
#isKindOf: #generateIsKindOf:on:indent:
#fromStack: #generateFromStack:on:indent:
"#clone #generateClone:on:indent:" "unused, never implemented"
"#new #generateNew:on:indent:" "unused, never implemented"
"#new: #generateNewSize:on:indent:" "unused, never implemented"
"#superclass #generateSuperclass:on:indent:" "unused, never implemented"
#debugCode: #generateDebugCode:on:indent:
).
1 to: pairs size by: 2 do: [:i |
translationDict at: (pairs at: i) put: (pairs at: i + 1)].
!
Item was added:
+ ----- Method: SmartSyntaxPluginSimulator>>ccgLoad:expr:asUnsignedLong64PtrFrom:andThen: (in category 'simulation') -----
+ ccgLoad: codeGen expr: exprBlock asUnsignedLong64PtrFrom: stackIndex andThen: validateBlock
+ ^[:oop|
+ validateBlock value: oop.
+ interpreterProxy cCoerce: (interpreterProxy firstIndexableField: oop) asInteger to: #'unsigned long long *']!
Item was added:
+ ----- Method: SmartSyntaxPluginSimulator>>ccgLoad:expr:asUnsignedShortPtrFrom:andThen: (in category 'simulation') -----
+ ccgLoad: codeGen expr: exprBlock asUnsignedShortPtrFrom: stackIndex andThen: validateBlock
+ ^[:oop|
+ validateBlock value: oop.
+ interpreterProxy cCoerce: (interpreterProxy firstIndexableField: oop) asInteger to: #'unsigned short *']!
Item was changed:
----- Method: SmartSyntaxPluginSimulator>>ccgValBlock: (in category 'simulation') -----
ccgValBlock: aString
^aString caseOf: {
['isBytes'] -> [ [:oop|
interpreterProxy success: (interpreterProxy isBytes: oop).
oop]].
+ ['isShorts'] -> [ [:oop|
+ interpreterProxy success: (interpreterProxy isShorts: oop).
+ oop]].
['isWords'] -> [ [:oop|
interpreterProxy success: (interpreterProxy isWords: oop).
oop]].
+ ['isLong64s'] -> [ [:oop|
+ interpreterProxy success: (interpreterProxy isLong64s: oop).
+ oop]].
['isWordsOrBytes'] -> [ [:oop|
interpreterProxy success: (interpreterProxy isWordsOrBytes: oop).
oop]].
['isIndexable'] -> [ [:oop|
interpreterProxy success: (interpreterProxy isIndexable: oop).
oop]] }!
Item was added:
+ ----- Method: SmartSyntaxPluginValidationCodeGenerator>>ccgLoad:expr:asUnsignedLong64PtrFrom:andThen: (in category 'coercing') -----
+ ccgLoad: aBlock expr: aString asUnsignedLong64PtrFrom: stackIndex andThen: validationString
+ ^validationString, (self stackAccessorFor: stackIndex)!
Item was added:
+ ----- Method: SmartSyntaxPluginValidationCodeGenerator>>ccgLoad:expr:asUnsignedShortPtrFrom:andThen: (in category 'coercing') -----
+ ccgLoad: aBlock expr: aString asUnsignedShortPtrFrom: stackIndex andThen: validationString
+ ^validationString, (self stackAccessorFor: stackIndex)!
More information about the Vm-dev
mailing list