VM Maker: VMMaker.oscog-nice.2750.mcz

 
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)!