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 end
 142
 143 # An array of `unsigned char` in C (`unsigned char*`)
 144 extern class NativeCByteArray `{ unsigned char* `}
 145         super NativeCArray
 146         redef type E: Byte
 147
 148         # Allocate a new array of `size`
 149         new(size: Int) `{ return calloc(size, sizeof(unsigned char)); `}
 150
 151         redef fun [](index) `{ return self[index]; `}
 152         redef fun []=(index, val) `{ self[index] = val; `}
 153
 154         redef fun +(offset) `{ return self + offset; `}
 155 end
 156
 157 # Wrapper around an array of `NativeString` in C (`char**`) with length and destroy state.
 158 class CNativeStringArray
 159         super CArray[NativeString]
 160
 161         redef type NATIVE: NativeCStringArray
 162
 163         # Initialize a new NativeCStringArray of `size` elements.
 164         init(size: Int) is old_style_init do
 165                 native_array = new NativeCStringArray(size)
 166                 super size
 167         end
 168
 169         # Create from an `SequenceRead[NativeString]`
 170         new from(array: SequenceRead[NativeString])
 171         do
 172                 var carray = new CNativeStringArray(array.length)
 173                 for i in array.length.times do
 174                         carray[i] = array[i]
 175                 end
 176                 return carray
 177         end
 178 end
 179
 180 # An array of `NativeString` in C (`char**`)
 181 extern class NativeCStringArray `{ char** `}
 182         super NativeCArray
 183
 184         redef type E: NativeString
 185
 186         # Initialize a new NativeCStringArray of `size` elements.
 187         new(size: Int) `{ return calloc(size, sizeof(char*)); `}
 188
 189         redef fun [](index) `{ return self[index]; `}
 190         redef fun []=(index, val) `{ self[index] = val; `}
 191         redef fun +(offset) `{ return self + offset; `}
 192 end
 193
 194 redef class NativeString
 195         super NativeCArray
 196         redef type E: Char
 197
 198         redef fun +(offset) `{ return self + offset; `}
 199 end