Marcel Taeumel uploaded a new version of FFI-Kernel to project FFI:
http://source.squeak.org/FFI/FFI-Kernel-mt.130.mcz==================== Summary ====================
Name: FFI-Kernel-mt.130
Author: mt
Time: 4 May 2021, 4:51:43.338881 pm
UUID: 5c667740-5577-4541-876e-0be05657a18c
Ancestors: FFI-Kernel-mt.129
Adds (simple?) support for array types such as char[12] or MyStruct[5].
Note that there is no plugin support for array types, which means that:
1. All FFI calls denoting array types will be passed as pointer type
2. Return types might work with atomic arrays (e.g. char[12]) but definitely not with struct arrays because the plugin will just give you a new instance of your struct with the handle, thus omitting the size information.
Still, now you can finally embed array types in your struct definition:
typedef struct {
double d1;
int32_t[5] a5i2;
} FFITestSdA5i
:-)
More open tasks:
- Array types are not cached and created on-demand. See #arrayTypeNamed: for placing a cache.
- #typedef (in Tools) is not yet supported.
=============== Diff against FFI-Kernel-mt.129 ===============
Item was added:
+ ExternalType subclass: #ExternalArrayType
+ instanceVariableNames: ''
+ classVariableNames: ''
+ poolDictionaries: ''
+ category: 'FFI-Kernel'!
Item was added:
+ ----- Method: ExternalArrayType class>>newTypeForContentType:size: (in category 'as yet unclassified') -----
+ newTypeForContentType: contentType size: numElements
+ "!!!!!! Be aware that only the pointer type can be used in calls. As of SqueakFFIPrims VMMaker.oscog-eem.2950, there is no actual support for array types in the FFI plugin !!!!!!"
+
+ | type pointerType headerWord byteSize |
+ contentType ifNil: [^ nil].
+ numElements < 0 ifTrue: [^ nil].
+
+ self
+ assert: [contentType isPointerType not]
+ description: 'No support for pointers as content type yet!!'.
+
+ type := self basicNew.
+ pointerType := ExternalType basicNew.
+
+ "1) Regular type"
+ byteSize := numElements * contentType byteSize.
+ self assert: [byteSize <= FFIStructSizeMask].
+ headerWord := contentType headerWord copy.
+ headerWord := headerWord bitClear: FFIStructSizeMask.
+ headerWord := headerWord bitOr: byteSize.
+ type
+ setReferencedType: pointerType;
+ compiledSpec: (WordArray with: headerWord);
+ byteAlignment: contentType byteAlignment;
+ setReferentClass: contentType referentClass.
+
+ "2) Pointer type. Reuse the compiledSpec of the content-type's pointer type."
+ pointerType
+ setReferencedType: type;
+ compiledSpec: contentType asPointerType compiledSpec copy;
+ byteAlignment: contentType asPointerType byteAlignment;
+ setReferentClass: contentType asPointerType referentClass.
+
+ ^ type!
Item was added:
+ ----- Method: ExternalArrayType>>checkType (in category 'external structure') -----
+ checkType
+
+ self class extraTypeChecks ifFalse: [^ self].
+
+ self
+ assert: [self isPointerType not]
+ description: 'Convert to ExternalType to use this feature'.!
Item was added:
+ ----- Method: ExternalArrayType>>contentType (in category 'accessing') -----
+ contentType
+
+ ^ ExternalType typeNamed: super typeName!
Item was added:
+ ----- Method: ExternalArrayType>>handle:at: (in category 'external data') -----
+ handle: handle at: byteOffset
+ "Read the receiver's external type using the given handle and the byteOffset. This is the dynamic version of #readFieldAt:."
+
+ self checkType.
+
+ ^ (ExternalData
+ fromHandle: (handle structAt: byteOffset length: self byteSize)
+ type: self contentType) size: self size; yourself!
Item was added:
+ ----- Method: ExternalArrayType>>handle:at:put: (in category 'external data') -----
+ handle: handle at: byteOffset put: value
+ "Write a value using the receiver's external type at the given handle and byteOffset. This is the dynamic version of #writeFieldAt:with:."
+
+ self checkType.
+
+ handle
+ structAt: byteOffset
+ put: value getHandle
+ length: self byteSize.!
Item was added:
+ ----- Method: ExternalArrayType>>isArrayType (in category 'testing') -----
+ isArrayType
+
+ ^ true!
Item was added:
+ ----- Method: ExternalArrayType>>readFieldAt: (in category 'external structure') -----
+ readFieldAt: byteOffset
+ "Answer a string defining the accessor to an entity of the receiver type starting at the given byte offset.
+ Private. Used for field definition only."
+
+ self checkType.
+
+ ^ String streamContents:[:s |
+ s nextPutAll:'^ (ExternalData fromHandle: (handle structAt: ';
+ print: byteOffset;
+ nextPutAll: ' length: ';
+ print: self byteSize;
+ nextPutAll: ') type: '.
+
+ self contentType isAtomic
+ ifTrue: [s nextPutAll: 'ExternalType ', self contentType typeName]
+ ifFalse: [s nextPutAll: self contentType typeName, ' externalType'].
+
+ s nextPutAll: ') size: '; print: self size; nextPutAll: '; yourself']!
Item was added:
+ ----- Method: ExternalArrayType>>size (in category 'accessing') -----
+ size
+ "Answers the number of elements for this array type."
+
+ ^ self byteSize / self contentType byteSize!
Item was added:
+ ----- Method: ExternalArrayType>>storeOn: (in category 'printing') -----
+ storeOn: aStream
+
+ aStream
+ nextPut: $(;
+ nextPutAll: ExternalType name; space;
+ nextPutAll: #arrayTypeNamed:; space;
+ store: self typeName;
+ nextPut: $).!
Item was added:
+ ----- Method: ExternalArrayType>>typeName (in category 'accessing') -----
+ typeName
+
+ ^ String streamContents: [:stream |
+ stream
+ nextPutAll: super typeName;
+ nextPut: $[;
+ nextPutAll: self size asString;
+ nextPut: $]]!
Item was added:
+ ----- Method: ExternalArrayType>>writeFieldArgName (in category 'external structure') -----
+ writeFieldArgName
+
+ ^ 'anExternalData_', self contentType typeName, self size!
Item was added:
+ ----- Method: ExternalArrayType>>writeFieldAt:with: (in category 'external structure') -----
+ writeFieldAt: byteOffset with: valueName
+
+ self checkType.
+
+ ^ String streamContents:[:s |
+ s nextPutAll:'handle structAt: ';
+ print: byteOffset;
+ nextPutAll: ' put: ';
+ nextPutAll: valueName;
+ nextPutAll: ' getHandle length: ';
+ print: self byteSize]!
Item was added:
+ ----- Method: ExternalType class>>arrayTypeNamed: (in category 'instance lookup') -----
+ arrayTypeNamed: typeName
+ "Lookup fails if content type is not present."
+
+ | contentType |
+ self flag: #todo. "mt: Cache array types?"
+
+ (contentType := self typeNamed: (typeName copyFrom: 1 to: (typeName indexOf: $[) - 1))
+ ifNil: [^ nil].
+
+ ^ self newTypeNamed: typeName!
Item was added:
+ ----- Method: ExternalType class>>newTypeForContentType:size: (in category 'instance creation') -----
+ newTypeForContentType: contentType size: numElements
+
+ ^ ExternalArrayType newTypeForContentType: contentType size: numElements!
Item was changed:
----- Method: ExternalType class>>newTypeNamed: (in category 'instance creation') -----
newTypeNamed: aTypeName
+ "Create a new struct type or array type. Not needed for atomic types; see #initializeDefaultTypes."
+
+ | structClass contentType contentTypeName numElements |
-
- | structClass |
self
assert: [aTypeName last ~~ $*]
description: 'Pointer type will be created automatically'.
+
+ aTypeName last == $] ifTrue: [
+ "array type, e.g., char[50]"
+ contentTypeName:= aTypeName copyFrom: 1 to: (aTypeName indexOf: $[) - 1.
+ contentType := (self typeNamed: contentTypeName) "Create new if not already there."
+ ifNil: [self newTypeNamed: contentTypeName].
+ numElements := ((aTypeName copyFrom: (aTypeName indexOf: $[) + 1 to: aTypeName size - 1) asInteger)
+ ifNil: [0].
+ ^ self
+ newTypeForContentType: contentType
+ size: numElements].
structClass := (self environment classNamed: aTypeName)
ifNotNil: [:class | (class includesBehavior: ExternalStructure) ifTrue: [class]].
^ structClass
ifNil: [self newTypeForUnknownNamed: aTypeName]
ifNotNil: [self newTypeForStructureClass: structClass]!
Item was changed:
----- Method: ExternalType class>>typeNamed: (in category 'instance lookup') -----
typeNamed: typeName
"Supports pointer-type lookup for both atomic and structure types.
Examples: 'long', 'long*', 'long *' or 'MyStruct', 'MyStruct*', 'MyStruct *'"
+ | isPointerType isArrayType actualTypeName type |
+ isArrayType := false.
- | isPointerType actualTypeName type |
(isPointerType := typeName last == $*)
ifTrue: [actualTypeName := typeName allButLast withoutTrailingBlanks]
+ ifFalse: [(isArrayType := typeName last == $])
+ ifFalse: [actualTypeName := typeName]].
- ifFalse: [actualTypeName := typeName].
+ isArrayType
+ ifTrue: [^ self arrayTypeNamed: typeName].
+
(Symbol lookup: actualTypeName)
ifNotNil: [:sym | actualTypeName := sym].
type := (self atomicTypeNamed: actualTypeName)
ifNil: [self structTypeNamed: actualTypeName].
^ type ifNotNil: [isPointerType ifTrue: [type asPointerType] ifFalse: [type]]!
Item was added:
+ ----- Method: ExternalType>>isArrayType (in category 'testing') -----
+ isArrayType
+
+ ^ false!
Item was changed:
----- Method: Parser>>externalType: (in category '*FFI-Kernel') -----
externalType: descriptorClass
"Parse and return an external type"
+ | xType typeName isArrayType |
- | xType typeName |
typeName := here. "Note that pointer token is not yet parsed!!"
+ self advance.
+ (isArrayType := self matchToken: $[)
+ ifTrue: [
+ typeName := typeName, '[', here, ']'.
+ self advance.
+ self matchToken: $]].
(xType := descriptorClass typeNamed: typeName)
ifNil: [
"Raise an error if user is there"
self interactive ifTrue: [^nil].
"otherwise go over it silently -- use an unknown struct type"
+ xType := descriptorClass newTypeNamed: typeName].
+ isArrayType ifTrue: [
+ self flag: #todo. "mt: We must send arrays as pointers."
+ xType := xType asPointerType].
- xType := descriptorClass newTypeNamed: here].
- self advance.
^ (self matchToken: #*)
ifTrue:[xType asPointerType]
ifFalse:[(self matchToken: #**)
ifTrue: [xType asPointerToPointerType]
ifFalse: [xType]]!
Locked
