Home My Page Projects Code Snippets Project Openings SML/NJ
Summary Activity Forums Tracker Lists Tasks Docs Surveys News SCM Files

SCM Repository

[smlnj] Annotation of /sml/trunk/src/ml-nlffi-lib/c.sig
ViewVC logotype

Annotation of /sml/trunk/src/ml-nlffi-lib/c.sig

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1015 - (view) (download) (as text)

1 : blume 828 (*
2 :     * Encoding the C type system in SML.
3 :     *
4 :     * (C) 2001, Lucent Technologies, Bell Laboratories
5 :     *
6 :     * author: Matthias Blume
7 :     *)
8 :     signature C = sig
9 :    
10 : blume 1015 exception OutOfMemory
11 :    
12 : blume 828 (* objects of type 't, constness 'c;
13 :     * The 't type variable will be instantiated with the object's "witness"
14 :     * type. The intention is that there be an isomorphism between such
15 :     * witness types and corresponding C types.
16 :     *
17 :     * Witness types are often the same as the (abstract) type of the value
18 :     * stored in the object. However, this is merely a coincidence. For
19 :     * example, a constant object holding a pointer to a read-write integer
20 : blume 840 * would have type ((sint, rw) ptr, ro) obj and the value itself has
21 :     * type (sint, rw) ptr.
22 : blume 828 * However, in the case of the "light" version of this object (see below),
23 : blume 840 * the object type is ((sint, rw) ptr, ro) obj' while fetching
24 :     * from this object gives a value of type (sint, rw) ptr'.
25 : blume 828 * (In other words, we use the "heavy" versions of value types as witness
26 :     * types -- even in the "light" case.) *)
27 : blume 837 type ('t, 'c) obj
28 : blume 828
29 : blume 975 (* an alternative "light-weight" version that does not carry RTTI at
30 :     * the cost of requiring explicit passing of RTTI for certain operations *)
31 : blume 837 type ('t, 'c) obj'
32 : blume 828
33 :     (* constness property, to be substituted for 'c *)
34 : blume 840 type ro and rw
35 : blume 828
36 :     (* things to be substituted for 't *)
37 : blume 837 type ('t, 'c) ptr (* pointer to ('t, 'c) obj *)
38 : blume 836 type ('t, 'n) arr (* 'n-sized array with 't elements *)
39 : blume 828
40 :     (* light-weight alternative *)
41 : blume 837 type ('t, 'c) ptr'
42 : blume 828
43 :     (* void* and function pointers *)
44 :     type voidptr (* C's void* *)
45 :     type 'f fptr (* a function pointer *)
46 :    
47 :     (* alt *)
48 :     type 'f fptr'
49 :    
50 :     (* structures and unions *)
51 :     type 'tag su (* struct/union named 'tag;
52 :     * 'tag is drawn from the types
53 :     * defined in the Tag module *)
54 :    
55 :     (* primtypes (signed/unsigned char, int, short, long; float, double) *)
56 : blume 840 type schar and uchar
57 :     type sint and uint
58 :     type sshort and ushort
59 :     type slong and ulong
60 :     type float and double
61 : blume 828
62 :     (* going from abstract to concrete and vice versa *)
63 :     structure Cvt : sig
64 :     (* ML -> C *)
65 :     val c_schar : MLRep.SChar.int -> schar
66 :     val c_uchar : MLRep.UChar.word -> uchar
67 :     val c_sint : MLRep.SInt.int -> sint
68 :     val c_uint : MLRep.UInt.word -> uint
69 :     val c_sshort : MLRep.SShort.int -> sshort
70 :     val c_ushort : MLRep.UShort.word -> ushort
71 :     val c_slong : MLRep.SLong.int -> slong
72 :     val c_ulong : MLRep.ULong.word -> ulong
73 :     val c_float : MLRep.Float.real -> float
74 :     val c_double : MLRep.Double.real -> double
75 :    
76 :     (* C -> ML *)
77 :     val ml_schar : schar -> MLRep.SChar.int
78 :     val ml_uchar : uchar -> MLRep.UChar.word
79 :     val ml_sint : sint -> MLRep.SInt.int
80 :     val ml_uint : uint -> MLRep.UInt.word
81 :     val ml_sshort : sshort -> MLRep.SShort.int
82 :     val ml_ushort : ushort -> MLRep.UShort.word
83 :     val ml_slong : slong -> MLRep.SLong.int
84 :     val ml_ulong : ulong -> MLRep.ULong.word
85 :     val ml_float : float -> MLRep.Float.real
86 :     val ml_double : double -> MLRep.Double.real
87 :     end
88 :    
89 :     (* type-abbreviations for a bit more convenience. *)
90 : blume 837 type 'c schar_obj = (schar, 'c) obj
91 :     type 'c uchar_obj = (uchar, 'c) obj
92 :     type 'c sint_obj = (sint, 'c) obj
93 :     type 'c uint_obj = (uint, 'c) obj
94 :     type 'c sshort_obj = (sshort, 'c) obj
95 :     type 'c ushort_obj = (ushort, 'c) obj
96 :     type 'c slong_obj = (slong, 'c) obj
97 :     type 'c ulong_obj = (ulong, 'c) obj
98 :     type 'c float_obj = (float, 'c) obj
99 :     type 'c double_obj = (double, 'c) obj
100 :     type 'c voidptr_obj = (voidptr, 'c) obj
101 :     type ('f, 'c) fptr_obj = ('f fptr, 'c) obj
102 :     type ('s, 'c) su_obj = ('s su, 'c) obj
103 : blume 828
104 :     (* alt *)
105 : blume 837 type 'c schar_obj' = (schar, 'c) obj'
106 :     type 'c uchar_obj' = (uchar, 'c) obj'
107 :     type 'c sint_obj' = (sint, 'c) obj'
108 :     type 'c uint_obj' = (uint, 'c) obj'
109 :     type 'c sshort_obj' = (sshort, 'c) obj'
110 :     type 'c ushort_obj' = (ushort, 'c) obj'
111 :     type 'c slong_obj' = (slong, 'c) obj'
112 :     type 'c ulong_obj' = (ulong, 'c) obj'
113 :     type 'c float_obj' = (float, 'c) obj'
114 :     type 'c double_obj' = (double, 'c) obj'
115 :     type 'c voidptr_obj' = (voidptr, 'c) obj'
116 :     type ('f, 'c) fptr_obj' = ('f fptr, 'c) obj'
117 :     type ('s, 'c) su_obj' = ('s su, 'c) obj'
118 : blume 828
119 :     (* bitfields aren't "ordinary objects", so they have their own type *)
120 : blume 840 type 'c sbf and 'c ubf
121 : blume 828
122 :     (*
123 :     * A family of types and corresponding values representing natural numbers.
124 :     * (An encoding in SML without using dependent types.)
125 :     *)
126 :     structure Dim : sig
127 :    
128 :     (* Internally, a value of type ('a, 'z) dim0 is just a number.
129 :     * The trick here is to give each of these numbers a different unique
130 :     * type. 'a will be a decimal encoding of the number's value in
131 :     * "type digits". 'z keeps track of whether the number is zero or not.
132 :     *)
133 :     type ('a, 'z) dim0
134 :    
135 :     (* We can always get the internal number back... *)
136 :     val toInt : ('a, 'z) dim0 -> int
137 :    
138 :     (* These two types act as "flags". They will be substituted for 'z
139 :     * and remember whether the value is zero or not. *)
140 :     type zero
141 :     type nonzero
142 :    
143 :     type 'a dim = ('a, nonzero) dim0
144 :    
145 :     (* These are the "type digits". Type "dec" acts as a "terminator".
146 :     * We chose its name so to remind us that the encoding is decimal.
147 :     * If a nonzero value's decimal representation is "<Dn>...<D0>", then
148 :     * its type will be "(dec dg<Dn> ... dg<D0>, nonzero) dim0", which
149 :     * is the same as "dec dg<Dn> ... dg<D0> dim". The type of the zero
150 :     * value is "(dec, zero) dim0". *)
151 :     type dec
152 : blume 840 type 'a dg0 and 'a dg1 and 'a dg2 and 'a dg3 and 'a dg4
153 :     type 'a dg5 and 'a dg6 and 'a dg7 and 'a dg8 and 'a dg9
154 : blume 828
155 :     (* Here are the corresponding constructors for ('a, 'z) dim0 values.
156 :     * The type for dg0 ensures that there will be no "leading zeros" in
157 :     * any encoding. This guarantees a 1-1 correspondence of constructable
158 :     * values and their types.
159 :     * To construct the value corresponding to a nonzero number whose
160 :     * decimal representation is "<Dn>...<D0>", one must invoke
161 :     * "dg<D0>' (... (dg<Dn>' dec')...)", i.e., the least significant
162 :     * digit appears leftmost. *)
163 :     val dec' : (dec, zero) dim0
164 :     val dg0' : 'a dim -> 'a dg0 dim
165 :     val dg1' : ('a, 'z) dim0 -> 'a dg1 dim
166 :     val dg2' : ('a, 'z) dim0 -> 'a dg2 dim
167 :     val dg3' : ('a, 'z) dim0 -> 'a dg3 dim
168 :     val dg4' : ('a, 'z) dim0 -> 'a dg4 dim
169 :     val dg5' : ('a, 'z) dim0 -> 'a dg5 dim
170 :     val dg6' : ('a, 'z) dim0 -> 'a dg6 dim
171 :     val dg7' : ('a, 'z) dim0 -> 'a dg7 dim
172 :     val dg8' : ('a, 'z) dim0 -> 'a dg8 dim
173 :     val dg9' : ('a, 'z) dim0 -> 'a dg9 dim
174 :    
175 :     (* Since having to reverse the sequence of digits seems unnatural,
176 :     * here is another set of constructors for dim values. These
177 :     * constructors use continuation-passing style and themselves
178 :     * have more complicated types. But their use is easier:
179 :     * To construct the value corresponding to a nonzero number whose
180 :     * decimal representation is "<Dn>...<D0>", one must invoke
181 :     * "dec dg<Dn> ... dg<D0> dim"; i.e., the least significant
182 :     * digit appears rightmost -- just like in the usual decimal
183 :     * notation for numbers that we are all familiar with.
184 :     * [Moreover, for any 'a dim value we have the neat property that
185 :     * it can be constructed by taking its type (expressed using "dim")
186 :     * and interpreting it as an expression. For example, the dim
187 :     * value representing 312 is "dec dg3 dg1 dg2 dim" and it can
188 :     * be constructed by evaluating "dec dg3 dg1 dg2 dim".] *)
189 :     val dec : ((dec, zero) dim0 -> 'b) -> 'b
190 :    
191 :     val dg0 : 'a dim -> ('a dg0 dim -> 'b) -> 'b
192 :     val dg1 : ('a, 'z) dim0 -> ('a dg1 dim -> 'b) -> 'b
193 :     val dg2 : ('a, 'z) dim0 -> ('a dg2 dim -> 'b) -> 'b
194 :     val dg3 : ('a, 'z) dim0 -> ('a dg3 dim -> 'b) -> 'b
195 :     val dg4 : ('a, 'z) dim0 -> ('a dg4 dim -> 'b) -> 'b
196 :     val dg5 : ('a, 'z) dim0 -> ('a dg5 dim -> 'b) -> 'b
197 :     val dg6 : ('a, 'z) dim0 -> ('a dg6 dim -> 'b) -> 'b
198 :     val dg7 : ('a, 'z) dim0 -> ('a dg7 dim -> 'b) -> 'b
199 :     val dg8 : ('a, 'z) dim0 -> ('a dg8 dim -> 'b) -> 'b
200 :     val dg9 : ('a, 'z) dim0 -> ('a dg9 dim -> 'b) -> 'b
201 :    
202 :     val dim : ('a, 'z) dim0 -> ('a, 'z) dim0
203 :     end
204 :    
205 :     (* sub-structure for dealing with run-time type info (sizes only) *)
206 :     structure S : sig
207 :    
208 :     (* Our size info itself is statically typed!
209 : blume 837 * The size info for a value stored in ('t, 'c) obj has
210 : blume 828 * the following type: *)
211 :     type 't size
212 :    
213 :     (* get a number out *)
214 :     val toWord : 't size -> word
215 :    
216 :     (* sizes for simple things *)
217 :     val schar : schar size
218 :     val uchar : uchar size
219 :     val sint : sint size
220 :     val uint : uint size
221 :     val sshort : sshort size
222 :     val ushort : ushort size
223 :     val slong : slong size
224 :     val ulong : ulong size
225 :     val float : float size
226 :     val double : double size
227 :    
228 :     val voidptr : voidptr size
229 : blume 837 val ptr : ('t, 'c) ptr size
230 : blume 828 val fptr : 'f fptr size
231 :     end
232 :    
233 :     (* sub-structure for dealing with run-time type info *)
234 :     structure T : sig
235 :    
236 : blume 975 (* Our RTTI itself is statically typed!
237 :     * The RTTI for a value stored in ('t, 'c) obj has
238 : blume 828 * the following type: *)
239 : blume 837 type 't typ
240 : blume 828
241 : blume 975 (* get the RTTI from an actual object *)
242 : blume 837 val typeof : ('t, 'c) obj -> 't typ
243 : blume 828
244 : blume 975 (* constructing new RTTI from existing RTTI *)
245 : blume 837 val pointer : 't typ -> ('t, rw) ptr typ
246 :     val target : ('t, 'c) ptr typ -> 't typ
247 :     val arr : 't typ * 'n Dim.dim -> ('t, 'n) arr typ
248 :     val elem : ('t, 'n) arr typ -> 't typ
249 :     val ro : ('t, 'c) ptr typ -> ('t, ro) ptr typ
250 : blume 828
251 : blume 975 (* calculating the size of an object given its RTTI *)
252 : blume 837 val sizeof : 't typ -> 't S.size
253 : blume 828
254 :     (* dimension of array type *)
255 : blume 837 val dim : ('t, 'n) arr typ -> 'n Dim.dim
256 : blume 828
257 : blume 975 (* RTTI for simple things *)
258 : blume 837 val schar : schar typ
259 :     val uchar : uchar typ
260 :     val sint : sint typ
261 :     val uint : uint typ
262 :     val sshort : sshort typ
263 :     val ushort : ushort typ
264 :     val slong : slong typ
265 :     val ulong : ulong typ
266 :     val float : float typ
267 :     val double : double typ
268 : blume 828
269 : blume 837 val voidptr : voidptr typ
270 : blume 828 end
271 :    
272 :     (* convert from regular (heavy) to alternative (light) versions *)
273 :     structure Light : sig
274 : blume 837 val obj : ('t, 'c) obj -> ('t, 'c) obj'
275 :     val ptr : ('t, 'c) ptr -> ('t, 'c) ptr'
276 : blume 828 val fptr : 'f fptr -> 'f fptr'
277 :     end
278 :    
279 :     (* and vice versa *)
280 :     structure Heavy : sig
281 : blume 837 val obj : 't T.typ -> ('t, 'c) obj' -> ('t, 'c) obj
282 :     val ptr : 't T.typ -> ('t, 'c) ptr' -> ('t, 'c) ptr
283 :     val fptr : 'f fptr T.typ -> 'f fptr' -> 'f fptr
284 : blume 828 end
285 :    
286 : blume 837 (* calculate size of an object *)
287 :     val sizeof : ('t, 'c) obj -> 't S.size
288 : blume 828
289 :     (* "fetch" methods for various types;
290 :     * fetching does not care about constness *)
291 :     structure Get : sig
292 :    
293 :     (* primitive types *)
294 :     val schar : 'c schar_obj -> schar
295 :     val uchar : 'c uchar_obj -> uchar
296 :     val sint : 'c sint_obj -> sint
297 :     val uint : 'c uint_obj -> uint
298 :     val sshort : 'c sshort_obj -> sshort
299 :     val ushort : 'c ushort_obj -> ushort
300 :     val slong : 'c slong_obj -> slong
301 :     val ulong : 'c ulong_obj -> ulong
302 :     val float : 'c float_obj -> float
303 :     val double : 'c double_obj -> double
304 :    
305 :     (* alt *)
306 :     val schar' : 'c schar_obj' -> schar
307 :     val uchar' : 'c uchar_obj' -> uchar
308 :     val sint' : 'c sint_obj' -> sint
309 :     val uint' : 'c uint_obj' -> uint
310 :     val sshort' : 'c sshort_obj' -> sshort
311 :     val ushort' : 'c ushort_obj' -> ushort
312 :     val slong' : 'c slong_obj' -> slong
313 :     val ulong' : 'c ulong_obj' -> ulong
314 :     val float' : 'c float_obj' -> float
315 :     val double' : 'c double_obj' -> double
316 :    
317 :     (* fetching pointers *)
318 : blume 837 val ptr : (('t, 'pc) ptr, 'c) obj -> ('t, 'pc) ptr
319 : blume 828 val fptr : ('f, 'c) fptr_obj -> 'f fptr
320 :     val voidptr : 'c voidptr_obj -> voidptr
321 :    
322 :     (* alt *)
323 : blume 837 val ptr' : (('t, 'pc) ptr, 'c) obj' -> ('t, 'pc) ptr'
324 : blume 828 val fptr' : ('f, 'c) fptr_obj' -> 'f fptr'
325 :     val voidptr' : 'c voidptr_obj' -> voidptr
326 :    
327 :     (* bitfields *)
328 :     val sbf : 'c sbf -> sint
329 :     val ubf : 'c ubf -> uint
330 :     end
331 :    
332 :     (* "store" methods; these require rw objects *)
333 :     structure Set : sig
334 :     (* primitive types *)
335 :     val schar : rw schar_obj * schar -> unit
336 :     val uchar : rw uchar_obj * uchar -> unit
337 :     val sint : rw sint_obj * sint -> unit
338 :     val uint : rw uint_obj * uint -> unit
339 :     val sshort : rw sshort_obj * sshort -> unit
340 :     val ushort : rw ushort_obj * ushort -> unit
341 :     val slong : rw slong_obj * slong -> unit
342 :     val ulong : rw ulong_obj * ulong -> unit
343 :     val float : rw float_obj * float -> unit
344 :     val double : rw double_obj * double -> unit
345 :    
346 :     (* alt *)
347 :     val schar' : rw schar_obj' * schar -> unit
348 :     val uchar' : rw uchar_obj' * uchar -> unit
349 :     val sint' : rw sint_obj' * sint -> unit
350 :     val uint' : rw uint_obj' * uint -> unit
351 :     val sshort' : rw sshort_obj' * sshort -> unit
352 :     val ushort' : rw ushort_obj' * ushort -> unit
353 :     val slong' : rw slong_obj' * slong -> unit
354 :     val ulong' : rw ulong_obj' * ulong -> unit
355 :     val float' : rw float_obj' * float -> unit
356 :     val double' : rw double_obj' * double -> unit
357 :    
358 :     (* storing pointers *)
359 : blume 837 val ptr : (('t, 'pc) ptr, rw) obj * ('t, 'pc) ptr -> unit
360 : blume 828 val fptr : ('f, rw) fptr_obj * 'f fptr -> unit
361 :     val voidptr : rw voidptr_obj * voidptr -> unit
362 :    
363 :     (* alt *)
364 : blume 837 val ptr' : (('t, 'pc) ptr, rw) obj' * ('t, 'pc) ptr' -> unit
365 : blume 828 val fptr' : ('f, rw) fptr_obj' * 'f fptr' -> unit
366 :     val voidptr' : rw voidptr_obj' * voidptr -> unit
367 :    
368 :     (* When storing, voidptr is compatible with any ptr type
369 : blume 975 * (just like in C). This should eliminate most need for RTTI in
370 : blume 828 * practice. *)
371 : blume 837 val ptr_voidptr : (('t, 'pc) ptr, rw) obj * voidptr -> unit
372 : blume 828
373 :     (* alt *)
374 : blume 837 val ptr_voidptr' : (('t, 'pc) ptr, rw) obj' * voidptr -> unit
375 : blume 828
376 :     (* bitfields *)
377 :     val sbf : rw sbf * sint -> unit
378 :     val ubf : rw ubf * uint -> unit
379 :     end
380 :    
381 :     (* copying the contents of arbitrary objects *)
382 : blume 837 val copy : { from: ('t, 'c) obj, to: ('t, rw) obj } -> unit
383 : blume 828
384 :     (* alt *)
385 : blume 837 val copy' : 't S.size -> { from: ('t, 'c) obj', to: ('t, rw) obj' } -> unit
386 : blume 828
387 :     (* operations on (mostly) pointers *)
388 :     structure Ptr : sig
389 :    
390 :     (* going from object to pointer and vice versa *)
391 : blume 837 val |&| : ('t, 'c) obj -> ('t, 'c) ptr
392 :     val |*| : ('t, 'c) ptr -> ('t, 'c) obj
393 : blume 828
394 :     (* alt *)
395 : blume 837 val |&! : ('t, 'c) obj' -> ('t, 'c) ptr'
396 :     val |*! : ('t, 'c) ptr' -> ('t, 'c) obj'
397 : blume 828
398 :     (* comparing pointers *)
399 : blume 837 val compare : ('t, 'c) ptr * ('t, 'c) ptr -> order
400 : blume 828
401 :     (* alt *)
402 : blume 837 val compare' : ('t, 'c) ptr' * ('t, 'c) ptr' -> order
403 : blume 828
404 :     (* going from pointer to void*; this also accounts for a conceptual
405 :     * subtyping relation and is safe *)
406 : blume 837 val inject : ('t, 'c) ptr -> voidptr
407 : blume 828
408 :     (* alt *)
409 : blume 837 val inject' : ('t, 'c) ptr' -> voidptr
410 : blume 828
411 :     (* the opposite is not safe, but C makes it not only easy but also
412 : blume 975 * almost necessary; we use our RTTI interface to specify the pointer
413 : blume 828 * type (not the element type!) *)
414 : blume 837 val cast : ('t, 'c) ptr T.typ -> voidptr -> ('t, 'c) ptr
415 : blume 828
416 :     (* alt *)
417 : blume 837 val cast' : ('t, 'c) ptr T.typ -> voidptr -> ('t, 'c) ptr'
418 : blume 828
419 :     (* NULL as void* *)
420 :     val vNull : voidptr
421 :    
422 :     (* projecting vNull to given pointer type *)
423 : blume 837 val null : ('t, 'c) ptr T.typ -> ('t, 'c) ptr
424 : blume 828
425 :     (* the "light" NULL pointer is simply a polymorphic constant *)
426 : blume 837 val null' : ('t, 'c) ptr'
427 : blume 828
428 :     (* checking for NULL pointer *)
429 :     val vIsNull : voidptr -> bool
430 :    
431 :     (* combining inject and vIsNull for convenience *)
432 : blume 837 val isNull : ('t, 'c) ptr -> bool
433 : blume 828
434 :     (* alt *)
435 : blume 837 val isNull' : ('t, 'c) ptr' -> bool
436 : blume 828
437 :     (* pointer arithmetic *)
438 : blume 837 val |+| : ('t, 'c) ptr * int -> ('t, 'c) ptr
439 :     val |-| : ('t, 'c) ptr * ('t, 'c) ptr -> int
440 : blume 828
441 :     (* alt; needs explicit size (for element) *)
442 : blume 837 val |+! : 't S.size -> ('t, 'c) ptr' * int -> ('t, 'c) ptr'
443 :     val |-! : 't S.size -> ('t, 'c) ptr' * ('t, 'c) ptr' -> int
444 : blume 828
445 :     (* subscript through a pointer; this is unchecked *)
446 : blume 837 val sub : ('t, 'c) ptr * int -> ('t, 'c) obj
447 : blume 828
448 :     (* alt; needs explicit size (for element) *)
449 : blume 837 val sub' : 't S.size -> ('t, 'c) ptr' * int -> ('t, 'c) obj'
450 : blume 828 end
451 :    
452 :     (* manipulating object constness
453 :     * rw -> ro: this direction just accounts for the fact that
454 :     * rw is conceptually a subtype of ro
455 :     * ro -> rw: this is not safe, but C makes it so easy that we
456 :     * might as well directly support it *)
457 : blume 837 val ro : ('t, 'c) obj -> ('t, ro) obj
458 :     val rw : ('t, 'c) obj -> ('t, rw) obj
459 : blume 828
460 :     (* alt *)
461 : blume 837 val ro' : ('t, 'c) obj' -> ('t, ro) obj'
462 :     val rw' : ('t, 'c) obj' -> ('t, rw) obj'
463 : blume 828
464 :     (* operations on (mostly) arrays *)
465 :     structure Arr : sig
466 :    
467 :     (* array subscript;
468 : blume 975 * since we have RTTI, we can actually make this safe: we raise
469 : blume 828 * General.Subscript for out-of-bounds access;
470 :     * for unchecked access, go through arr_decay and ptr_sub *)
471 : blume 837 val sub : (('t, 'n) arr, 'c) obj * int -> ('t, 'c) obj
472 : blume 828
473 :     (* alt; needs explicit type (for array) *)
474 : blume 837 val sub' : ('t, 'n) arr T.typ ->
475 :     (('t, 'n) arr, 'c) obj' * int -> ('t, 'c) obj'
476 : blume 828
477 :     (* let an array object decay, yielding pointer to first element *)
478 : blume 837 val decay : (('t, 'n) arr, 'c) obj -> ('t, 'c) ptr
479 : blume 828
480 :     (* alt *)
481 : blume 837 val decay' : (('t, 'n) arr, 'c) obj' -> ('t, 'c) ptr'
482 : blume 828
483 :     (* reconstruct an array object from the pointer to its first element *)
484 : blume 837 val reconstruct : ('t, 'c) ptr * 'n Dim.dim -> (('t, 'n) arr, 'c) obj
485 : blume 828
486 :     (* alt *)
487 : blume 837 val reconstruct': ('t, 'c) ptr' * 'n Dim.dim -> (('t, 'n) arr, 'c) obj'
488 : blume 828
489 :     (* dimension of array object *)
490 : blume 837 val dim : (('t, 'n) arr, 'c) obj -> 'n Dim.dim
491 : blume 828 end
492 :    
493 :     (* allocating new objects *)
494 : blume 1015 val new : 't T.typ -> ('t, rw) obj
495 : blume 828
496 :     (* alt *)
497 : blume 1015 val new' : 't S.size -> ('t, rw) obj'
498 : blume 828
499 :     (* freeing objects that were allocated earlier *)
500 : blume 837 val discard : ('t, 'c) obj -> unit
501 : blume 828
502 :     (* alt *)
503 : blume 837 val discard' : ('t, 'c) obj' -> unit
504 : blume 828
505 :     (* allocating a dynamically-sized array *)
506 : blume 1015 val alloc : 't T.typ -> word -> ('t, rw) ptr
507 : blume 828
508 :     (* alt *)
509 : blume 1015 val alloc' : 't S.size -> word -> ('t, rw) ptr'
510 : blume 828
511 :     (* freeing through pointers *)
512 : blume 837 val free : ('t, 'c) ptr -> unit
513 : blume 828
514 :     (* alt *)
515 : blume 837 val free' : ('t, 'c) ptr' -> unit
516 : blume 828
517 :     (* perform function call through function-pointer *)
518 :     val call : ('a -> 'b) fptr * 'a -> 'b
519 :    
520 :     (* alt; needs explicit type for the function pointer *)
521 : blume 837 val call' : ('a -> 'b) fptr T.typ -> ('a -> 'b) fptr' * 'a -> 'b
522 : blume 1015
523 :     (* completely unsafe stuff that every C programmer just *loves* to do *)
524 :     structure U : sig
525 :     val fcast : 'a fptr' -> 'b fptr'
526 :     val p2i : voidptr -> ulong
527 :     val i2p : ulong -> voidptr
528 :     end
529 : blume 828 end

root@smlnj-gforge.cs.uchicago.edu
ViewVC Help
Powered by ViewVC 1.0.0