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/releases/release-110.37/src/ml-nlffi-lib/c.sig
ViewVC logotype

Annotation of /sml/releases/release-110.37/src/ml-nlffi-lib/c.sig

Parent Directory Parent Directory | Revision Log Revision Log


Revision 840 - (view) (download) (as text)
Original Path: sml/trunk/src/ml-nlffi-lib/c.sig

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

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