1 # This file is part of NIT (http://www.nitlanguage.org).
3 # Copyright 2014 Alexis Laferrière <alexis.laf@xymus.net>
5 # Licensed under the Apache License, Version 2.0 (the "License");
6 # you may not use this file except in compliance with the License.
7 # You may obtain a copy of the License at
9 # http://www.apache.org/licenses/LICENSE-2.0
11 # Unless required by applicable law or agreed to in writing, software
12 # distributed under the License is distributed on an "AS IS" BASIS,
13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 # See the License for the specific language governing permissions and
15 # limitations under the License.
17 # Utilities and performant structure for the FFI with C
20 intrude import standard
::collection
::array
22 # A thin wrapper around a `NativeCArray` adding length information
23 abstract class CArray[E
]
24 super AbstractArrayRead[E
]
26 # The corresponding C type
27 type NATIVE: NativeCArray
29 # Pointer to the real C array
30 var native_array
: NATIVE is noinit
32 private init(length
: Int) is old_style_init
do self._length
= length
37 assert index
>= 0 and index
< length
38 return native_array
[index
]
41 # Set `val` at `index`.
42 fun []=(index
: Int, val
: E
)
45 assert index
>= 0 and index
< length
46 native_array
[index
] = val
49 # Was this instance destroyed?
51 # See `CArray::destroy`.
54 # Free used memory used by `native_array`.
56 # Also set `destroyed` to true.
59 if destroyed
then return
66 # A native C array, as in a pointer to the first element of the array
67 extern class NativeCArray `{ void * `}
69 # Type of contained elements.
70 type E: nullable Object
72 # Get element at `index
`.
73 fun [](index: Int): E is abstract
75 # Set `val
` at `index
`.
76 fun []=(index: Int, val: E) is abstract
78 # Return pointer to the address to the second element of this array
80 # This is the standard `+` operator on pointers in C
81 fun +(offset: Int): SELF is abstract
84 # Wrapper around an array of `int
` in C (`int
*`) with length and destroy state
87 redef type NATIVE: NativeCIntArray
89 # Initialize a new CIntArray of `size
` elements.
90 init(size: Int) is old_style_init do
91 native_array = new NativeCIntArray(size)
95 # Build from an `Array[Int]`
96 new from(array: Array[Int])
98 var carray = new CIntArray(array.length)
99 for i in array.length.times do
106 # An array of `int
` in C (`int
*`)
107 extern class NativeCIntArray `{ int* `}
111 # Initialize a new NativeCIntArray of `size` elements.
112 new(size
: Int) `{ return calloc(size, sizeof(int)); `}
114 redef fun [](index) `{ return recv[index]; `}
115 redef fun []=(index
, val
) `{ recv[index] = val; `}
117 redef fun +(offset) `{ return recv + offset; `}
120 # Wrapper around an array of `unsigned char` in C (`unsigned char*`) with length and destroy state
123 redef type NATIVE: NativeCByteArray
125 # Allocate a new array of `size`
126 init(size
: Int) is old_style_init
do
127 native_array
= new NativeCByteArray(size
)
131 # Build from an `Array[Int]`
132 new from
(array
: Array[Int])
134 var carray
= new CByteArray(array
.length
)
135 for i
in array
.length
.times
do
142 # An array of `unsigned char` in C (`unsigned char*`)
143 extern class NativeCByteArray `{ unsigned char* `}
147 # Allocate a new array of `size
`
148 new(size: Int) `{ return calloc(size, sizeof(unsigned char)); `}
150 redef fun [](index
) `{ return recv[index]; `}
151 redef fun []=(index, val) `{ recv[index] = val; `}
153 redef fun +(offset
) `{ return recv + offset; `}
156 # Wrapper around an array of `NativeString` in C (`char
**`) with length and destroy state.
157 class CNativeStringArray
158 super CArray[NativeString]
160 redef type NATIVE: NativeCStringArray
162 # Initialize a new NativeCStringArray of `size
` elements.
163 init(size: Int) is old_style_init do
164 native_array = new NativeCStringArray(size)
168 # Build from an `Array[NativeString]`
169 new from(array: Array[NativeString])
171 var carray = new CNativeStringArray(array.length)
172 for i in array.length.times do
179 # An array of `NativeString` in C (`char
**`)
180 extern class NativeCStringArray `{ char** `}
183 redef type E
: NativeString
185 # Initialize a new NativeCStringArray of `size` elements.
186 new(size
: Int) `{ return calloc(size, sizeof(char*)); `}
188 redef fun [](index) `{ return recv[index]; `}
189 redef fun []=(index
, val
) `{ recv[index] = val; `}
190 redef fun +(offset) `{ return recv + offset; `}
193 redef class NativeString
197 redef fun +(offset
) `{ return recv + offset; `}