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

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