lib/c.nit

   1 # This file is part of NIT (http://www.nitlanguage.org).
   2 #
   3 # Copyright 2014 Alexis Laferrière <alexis.laf@xymus.net>
   4 #
   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
   8 #
   9 #     http://www.apache.org/licenses/LICENSE-2.0
  10 #
  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.
  16
  17 # Structures and services for compatibility with the C language
  18 module c
  19
  20 import core
  21 intrude import core::collection::array
  22
  23 # A thin wrapper around a `NativeCArray` adding length information
  24 abstract class CArray[E]
  25         super AbstractArrayRead[E]
  26
  27         # The corresponding C type
  28         type NATIVE: NativeCArray
  29
  30         # Pointer to the real C array
  31         var native_array: NATIVE is noinit
  32
  33         private init(length: Int) is old_style_init do self._length = length
  34
  35         redef fun [](index)
  36         do
  37                 assert not destroyed
  38                 assert index >= 0 and index < length
  39                 return native_array[index]
  40         end
  41
  42         # Set `val` at `index`.
  43         fun []=(index: Int, val: E)
  44         do
  45                 assert not destroyed
  46                 assert index >= 0 and index < length
  47                 native_array[index] = val
  48         end
  49
  50         # Was this instance destroyed?
  51         #
  52         # See `CArray::destroy`.
  53         var destroyed = false
  54
  55         # Free used memory used by `native_array`.
  56         #
  57         # Also set `destroyed` to true.
  58         fun destroy
  59         do
  60                 if destroyed then return
  61
  62                 native_array.free
  63                 destroyed = true
  64         end
  65 end
  66
  67 # A native C array, as in a pointer to the first element of the array
  68 extern class NativeCArray `{ void * `}
  69
  70         # Type of contained elements.
  71         type E: nullable Object
  72
  73         # Get element at `index`.
  74         fun [](index: Int): E is abstract
  75
  76         # Set `val` at `index`.
  77         fun []=(index: Int, val: E) is abstract
  78
  79         # Return pointer to the address to the second element of this array
  80         #
  81         # This is the standard `+` operator on pointers in C
  82         fun +(offset: Int): SELF is abstract
  83 end
  84
  85 # Wrapper around an array of `int` in C (`int*`) with length and destroy state
  86 class CIntArray
  87         super CArray[Int]
  88         redef type NATIVE: NativeCIntArray
  89
  90         # Initialize a new CIntArray of `size` elements.
  91         init(size: Int) is old_style_init do
  92                 native_array = new NativeCIntArray(size)
  93                 super size
  94         end
  95
  96         # Create from an `SequenceRead[Int]`
  97         new from(array: SequenceRead[Int])
  98         do
  99                 var carray = new CIntArray(array.length)
 100                 for i in array.length.times do
 101                         carray[i] = array[i]
 102                 end
 103                 return carray
 104         end
 105 end
 106
 107 # An array of `int` in C (`int*`)
 108 extern class NativeCIntArray `{ int* `}
 109         super NativeCArray
 110         redef type E: Int
 111
 112         # Initialize a new NativeCIntArray of `size` elements.
 113         new(size: Int) `{ return calloc(size, sizeof(int)); `}
 114
 115         redef fun [](index) `{ return self[index]; `}
 116         redef fun []=(index, val) `{ self[index] = val; `}
 117
 118         redef fun +(offset) `{ return self + offset; `}
 119 end
 120
 121 # Wrapper around an array of `unsigned char` in C (`unsigned char*`) with length and destroy state
 122 class CByteArray
 123         super CArray[Byte]
 124         redef type NATIVE: NativeCByteArray
 125
 126         # Allocate a new array of `size`
 127         init(size: Int) is old_style_init do
 128                 native_array = new NativeCByteArray(size)
 129                 super size
 130         end
 131
 132         # Create from a `SequenceRead[Byte]`
 133         new from(array: SequenceRead[Byte])
 134         do
 135                 var carray = new CByteArray(array.length)
 136                 for i in array.length.times do
 137                         carray[i] = array[i]
 138                 end
 139                 return carray
 140         end
 141
 142         # Safely move `n` bytes from `dst_offset` to `src_offset`, inside this array
 143         #
 144         # Require: all arguments greater than 0 and ranges within `length`
 145         fun move(dst_offset, src_offset, n: Int)
 146         do
 147                 assert dst_offset >= 0 and src_offset >= 0 and n >= 0
 148                 assert dst_offset + n <= length
 149                 assert src_offset + n <= length
 150
 151                 native_array.move(dst_offset, src_offset, n)
 152         end
 153 end
 154
 155 # An array of `unsigned char` in C (`unsigned char*`)
 156 extern class NativeCByteArray `{ unsigned char* `}
 157         super NativeCArray
 158         redef type E: Byte
 159
 160         # Allocate a new array of `size`
 161         new(size: Int) `{ return calloc(size, sizeof(unsigned char)); `}
 162
 163         redef fun [](index) `{ return self[index]; `}
 164         redef fun []=(index, val) `{ self[index] = val; `}
 165
 166         redef fun +(offset) `{ return self + offset; `}
 167
 168         # Move `n` bytes from `dst_offset` to `src_offset`
 169         fun move(dst_offset, src_offset, n: Int) `{
 170                 memmove(self+dst_offset, self+src_offset, n);
 171         `}
 172 end
 173
 174 # Wrapper around an array of `NativeString` in C (`char**`) with length and destroy state.
 175 class CNativeStringArray
 176         super CArray[NativeString]
 177
 178         redef type NATIVE: NativeCStringArray
 179
 180         # Initialize a new NativeCStringArray of `size` elements.
 181         init(size: Int) is old_style_init do
 182                 native_array = new NativeCStringArray(size)
 183                 super size
 184         end
 185
 186         # Create from an `SequenceRead[NativeString]`
 187         new from(array: SequenceRead[NativeString])
 188         do
 189                 var carray = new CNativeStringArray(array.length)
 190                 for i in array.length.times do
 191                         carray[i] = array[i]
 192                 end
 193                 return carray
 194         end
 195 end
 196
 197 # An array of `NativeString` in C (`char**`)
 198 extern class NativeCStringArray `{ char** `}
 199         super NativeCArray
 200
 201         redef type E: NativeString
 202
 203         # Initialize a new NativeCStringArray of `size` elements.
 204         new(size: Int) `{ return calloc(size, sizeof(char*)); `}
 205
 206         redef fun [](index) `{ return self[index]; `}
 207         redef fun []=(index, val) `{ self[index] = val; `}
 208         redef fun +(offset) `{ return self + offset; `}
 209 end
 210
 211 redef class NativeString
 212         super NativeCArray
 213         redef type E: Char
 214
 215         redef fun +(offset) `{ return self + offset; `}
 216 end