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

SCM Repository

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

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

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1036, Fri Jan 25 22:05:44 2002 UTC revision 1078, Tue Feb 19 21:26:48 2002 UTC
# Line 33  Line 33 
33      (* constness property, to be substituted for 'c *)      (* constness property, to be substituted for 'c *)
34      type ro and rw      type ro and rw
35    
36      (* things to be substituted for 't *)      (* Pointers come in two varieties in C:  Pointers to things we
37      type ('t, 'c) ptr                   (* pointer to ('t, 'c) obj *)       * know and pointers to "incomplete" types.  The "ptr" type constructor
38         * below encodes both kinds using the following convention:
39         *   - in the case of complete target types, 'o will be instantiated
40         *     to some ('t, 'c) obj
41         *   - in the case of incomplete target types, 'o will be instantiated
42         *     to some fresh (abstract) type (see iptr.sig for what this will
43         *     look like in practice)
44         *)
45        type 'o ptr                         (* pointer to 'o *)
46      type ('t, 'n) arr                   (* 'n-sized array with 't elements *)      type ('t, 'n) arr                   (* 'n-sized array with 't elements *)
47    
48      (* light-weight alternative *)      (* light-weight alternative *)
49      eqtype ('t, 'c) ptr'      eqtype 'o ptr'
50    
51        eqtype void                         (* no values, admits equality *)
52    
53        (* void* is really a base type, but it happens to take the
54         * form of a light-weight pointer type (with an abstract target).
55         * This design makes it possible to use those ptr-related
56         * functions that "make sense" for void*. *)
57        type voidptr = void ptr'            (* C's void* *)
58    
59      (* void* and function pointers *)      (* function pointers *)
     eqtype voidptr                      (* C's void* *)  
60      type 'f fptr                        (* a function pointer *)      type 'f fptr                        (* a function pointer *)
61    
62      (* alt *)      (* alt *)
# Line 59  Line 74 
74      eqtype slong  and ulong      eqtype slong  and ulong
75      type float    and double      type float    and double
76    
77      (* going from abstract to concrete and vice versa *)      (* going from abstract to concrete and vice versa;
78         * (this shouldn't be needed except when calling functions through
79         * function pointers) *)
80      structure Cvt : sig      structure Cvt : sig
81          (* ML -> C *)          (* ML -> C *)
82          val c_schar  : MLRep.Signed.int   -> schar          val c_schar  : MLRep.Signed.int   -> schar
# Line 226  Line 243 
243          val double : double size          val double : double size
244    
245          val voidptr : voidptr size          val voidptr : voidptr size
246          val ptr : ('t, 'c) ptr size          val ptr : 'o ptr size
247          val fptr : 'f fptr size          val fptr : 'f fptr size
248      end      end
249    
# Line 242  Line 259 
259          val typeof : ('t, 'c) obj -> 't typ          val typeof : ('t, 'c) obj -> 't typ
260    
261          (* constructing new RTTI from existing RTTI *)          (* constructing new RTTI from existing RTTI *)
262          val pointer : 't typ -> ('t, rw) ptr typ          val pointer : 't typ -> ('t, rw) obj ptr typ
263          val target  : ('t, 'c) ptr typ -> 't typ          val target  : ('t, 'c) obj ptr typ -> 't typ
264          val arr     : 't typ * 'n Dim.dim -> ('t, 'n) arr typ          val arr     : 't typ * 'n Dim.dim -> ('t, 'n) arr typ
265          val elem    : ('t, 'n) arr typ -> 't typ          val elem    : ('t, 'n) arr typ -> 't typ
266          val ro      : ('t, 'c) ptr typ -> ('t, ro) ptr typ          val ro      : ('t, 'c) obj ptr typ -> ('t, ro) obj ptr typ
267    
268          (* calculating the size of an object given its RTTI *)          (* calculating the size of an object given its RTTI *)
269          val sizeof : 't typ -> 't S.size          val sizeof : 't typ -> 't S.size
# Line 272  Line 289 
289      (* convert from regular (heavy) to alternative (light) versions *)      (* convert from regular (heavy) to alternative (light) versions *)
290      structure Light : sig      structure Light : sig
291          val obj : ('t, 'c) obj -> ('t, 'c) obj'          val obj : ('t, 'c) obj -> ('t, 'c) obj'
292          val ptr : ('t, 'c) ptr -> ('t, 'c) ptr'          val ptr : 'o ptr -> 'o ptr'
293          val fptr : 'f fptr -> 'f fptr'          val fptr : 'f fptr -> 'f fptr'
294      end      end
295    
296      (* and vice versa *)      (* and vice versa *)
297      structure Heavy : sig      structure Heavy : sig
298          val obj : 't T.typ -> ('t, 'c) obj' -> ('t, 'c) obj          val obj : 't T.typ -> ('t, 'c) obj' -> ('t, 'c) obj
299          val ptr : 't T.typ -> ('t, 'c) ptr' -> ('t, 'c) ptr          val ptr : 'o ptr T.typ -> 'o ptr' -> 'o ptr
300          val fptr : 'f fptr T.typ  -> 'f fptr' -> 'f fptr          val fptr : 'f fptr T.typ  -> 'f fptr' -> 'f fptr
301      end      end
302    
# Line 315  Line 332 
332          val double' : 'c double_obj' -> MLRep.Real.real          val double' : 'c double_obj' -> MLRep.Real.real
333    
334          (* fetching pointers; results have to be abstract *)          (* fetching pointers; results have to be abstract *)
335          val ptr : (('t, 'pc) ptr, 'c) obj -> ('t, 'pc) ptr          val ptr : ('o ptr, 'c) obj -> 'o ptr
336          val fptr : ('f, 'c) fptr_obj -> 'f fptr          val fptr : ('f, 'c) fptr_obj -> 'f fptr
337          val voidptr : 'c voidptr_obj -> voidptr          val voidptr : 'c voidptr_obj -> voidptr
338    
339          (* alt *)          (* alt *)
340          val ptr' : (('t, 'pc) ptr, 'c) obj' -> ('t, 'pc) ptr'          val ptr' : ('o ptr, 'c) obj' -> 'o ptr'
341          val fptr' : ('f, 'c) fptr_obj' -> 'f fptr'          val fptr' : ('f, 'c) fptr_obj' -> 'f fptr'
342          val voidptr' : 'c voidptr_obj' -> voidptr          val voidptr' : 'c voidptr_obj' -> voidptr
343    
# Line 356  Line 373 
373          val double' : rw double_obj' * MLRep.Real.real -> unit          val double' : rw double_obj' * MLRep.Real.real -> unit
374    
375          (* storing pointers; abstract *)          (* storing pointers; abstract *)
376          val ptr : (('t, 'pc) ptr, rw) obj * ('t, 'pc) ptr -> unit          val ptr : ('o ptr, rw) obj * 'o ptr -> unit
377          val fptr : ('f, rw) fptr_obj * 'f fptr -> unit          val fptr : ('f, rw) fptr_obj * 'f fptr -> unit
378          val voidptr : rw voidptr_obj * voidptr -> unit          val voidptr : rw voidptr_obj * voidptr -> unit
379    
380          (* alt *)          (* alt *)
381          val ptr' : (('t, 'pc) ptr, rw) obj' * ('t, 'pc) ptr' -> unit          val ptr' : ('o ptr, rw) obj' * 'o ptr' -> unit
382          val fptr' : ('f, rw) fptr_obj' * 'f fptr' -> unit          val fptr' : ('f, rw) fptr_obj' * 'f fptr' -> unit
383          val voidptr' : rw voidptr_obj' * voidptr -> unit          val voidptr' : rw voidptr_obj' * voidptr -> unit
384    
385          (* When storing, voidptr is compatible with any ptr type          (* When storing, voidptr is compatible with any ptr type
386           * (just like in C).  This should eliminate most need for RTTI in           * (just like in C).  This should eliminate most need for RTTI in
387           * practice. *)           * practice. *)
388          val ptr_voidptr : (('t, 'pc) ptr, rw) obj * voidptr -> unit          val ptr_voidptr : ('o ptr, rw) obj * voidptr -> unit
389    
390          (* alt *)          (* alt *)
391          val ptr_voidptr' : (('t, 'pc) ptr, rw) obj' * voidptr -> unit          val ptr_voidptr' : ('o ptr, rw) obj' * voidptr -> unit
392    
393          (* bitfields; concrete *)          (* bitfields; concrete *)
394          val sbf : rw sbf * MLRep.Signed.int -> unit          val sbf : rw sbf * MLRep.Signed.int -> unit
# Line 405  Line 422 
422      structure Ptr : sig      structure Ptr : sig
423    
424          (* going from object to pointer and vice versa *)          (* going from object to pointer and vice versa *)
425          val |&| : ('t, 'c) obj -> ('t, 'c) ptr          val |&| : ('t, 'c) obj -> ('t, 'c) obj ptr
426          val |*| : ('t, 'c) ptr -> ('t, 'c) obj          val |*| : ('t, 'c) obj ptr -> ('t, 'c) obj
427    
428          (* alt *)          (* alt *)
429          val |&! : ('t, 'c) obj' -> ('t, 'c) ptr'          val |&! : ('t, 'c) obj' -> ('t, 'c) obj ptr'
430          val |*! : ('t, 'c) ptr' -> ('t, 'c) obj'          val |*! : ('t, 'c) obj ptr' -> ('t, 'c) obj'
431    
432          (* comparing pointers *)          (* comparing pointers *)
433          val compare : ('t, 'c) ptr * ('t, 'c) ptr -> order          val compare : 'o ptr * 'o ptr -> order
434    
435          (* alt *)          (* alt *)
436          val compare' : ('t, 'c) ptr' * ('t, 'c) ptr' -> order          val compare' : 'o ptr' * 'o ptr' -> order
437    
438          (* going from pointer to void*;  this also accounts for a conceptual          (* going from pointer to void*;  this also accounts for a conceptual
439           * subtyping relation and is safe *)           * subtyping relation and is safe *)
440          val inject : ('t, 'c) ptr -> voidptr          val inject : 'o ptr -> voidptr
441    
442          (* alt *)          (* alt *)
443          val inject' : ('t, 'c) ptr' -> voidptr          val inject' : 'o ptr' -> voidptr
444    
445          (* the opposite is not safe, but C makes it not only easy but also          (* the opposite is not safe, but C makes it not only easy but also
446           * almost necessary; we use our RTTI interface to specify the pointer           * almost necessary; we use our RTTI interface to specify the pointer
447           * type (not the element type!) *)           * type (not the element type!) *)
448          val cast : ('t, 'c) ptr T.typ -> voidptr -> ('t, 'c) ptr          val cast : 'o ptr T.typ -> voidptr -> 'o ptr
449    
450          (* alt *)          (* alt *)
451          val cast' : ('t, 'c) ptr T.typ -> voidptr -> ('t, 'c) ptr'          val cast' : 'o ptr T.typ -> voidptr -> 'o ptr'
452    
453          (* NULL as void* *)          (* NULL as void* *)
454          val vNull : voidptr          val vNull : voidptr
455    
456          (* projecting vNull to given pointer type *)          (* projecting vNull to given pointer type *)
457          val null : ('t, 'c) ptr T.typ -> ('t, 'c) ptr          val null : 'o ptr T.typ -> 'o ptr
458    
459          (* the "light" NULL pointer is simply a polymorphic constant *)          (* the "light" NULL pointer is simply a polymorphic constant *)
460          val null' : ('t, 'c) ptr'          val null' : 'o ptr'
461    
462          (* fptr version of NULL *)          (* fptr version of NULL *)
463          val fnull : 'f fptr T.typ -> 'f fptr          val fnull : 'f fptr T.typ -> 'f fptr
# Line 452  Line 469 
469          val vIsNull : voidptr -> bool          val vIsNull : voidptr -> bool
470    
471          (* combining inject and vIsNull for convenience *)          (* combining inject and vIsNull for convenience *)
472          val isNull : ('t, 'c) ptr -> bool          val isNull : 'o ptr -> bool
473    
474          (* alt *)          (* alt *)
475          val isNull' : ('t, 'c) ptr' -> bool          val isNull' : 'o ptr' -> bool
476    
477          (* checking a function pointer for NULL *)          (* checking a function pointer for NULL *)
478          val isFNull : 'f fptr -> bool          val isFNull : 'f fptr -> bool
# Line 464  Line 481 
481          val isFNull' : 'f fptr' -> bool          val isFNull' : 'f fptr' -> bool
482    
483          (* pointer arithmetic *)          (* pointer arithmetic *)
484          val |+| : ('t, 'c) ptr * int -> ('t, 'c) ptr          val |+| : ('t, 'c) obj ptr * int -> ('t, 'c) obj ptr
485          val |-| : ('t, 'c) ptr * ('t, 'c) ptr -> int          val |-| : ('t, 'c) obj ptr * ('t, 'c) obj ptr -> int
486    
487          (* alt; needs explicit size (for element) *)          (* alt; needs explicit size (for element) *)
488          val |+! : 't S.size -> ('t, 'c) ptr' * int -> ('t, 'c) ptr'          val |+! : 't S.size -> ('t, 'c) obj ptr' * int -> ('t, 'c) obj ptr'
489          val |-! : 't S.size -> ('t, 'c) ptr' * ('t, 'c) ptr' -> int          val |-! : 't S.size -> ('t, 'c) obj ptr' * ('t, 'c) obj ptr' -> int
490    
491          (* subscript through a pointer; this is unchecked *)          (* subscript through a pointer; this is unchecked *)
492          val sub : ('t, 'c) ptr * int -> ('t, 'c) obj          val sub : ('t, 'c) obj ptr * int -> ('t, 'c) obj
493    
494          (* alt; needs explicit size (for element) *)          (* alt; needs explicit size (for element) *)
495          val sub' : 't S.size -> ('t, 'c) ptr' * int -> ('t, 'c) obj'          val sub' : 't S.size -> ('t, 'c) obj ptr' * int -> ('t, 'c) obj'
496    
497          (* constness manipulation for pointers *)          (* constness manipulation for pointers *)
498          val ro : ('t, 'c) ptr    -> ('t, ro) ptr          val ro : ('t, 'c) obj ptr    -> ('t, ro) obj ptr
499          val rw : ('t, 'sc) ptr   -> ('t, 'tc) ptr          val rw : ('t, 'sc) obj ptr   -> ('t, 'tc) obj ptr
500          val ro' : ('t, 'c) ptr'  -> ('t, ro) ptr'          val ro' : ('t, 'c) obj ptr'  -> ('t, ro) obj ptr'
501          val rw' : ('t, 'sc) ptr' -> ('t, 'tc) ptr'          val rw' : ('t, 'sc) obj ptr' -> ('t, 'tc) obj ptr'
502      end      end
503    
504      (* operations on (mostly) arrays *)      (* operations on (mostly) arrays *)
# Line 498  Line 515 
515                     (('t, 'n) arr, 'c) obj' * int -> ('t, 'c) obj'                     (('t, 'n) arr, 'c) obj' * int -> ('t, 'c) obj'
516    
517          (* let an array object decay, yielding pointer to first element *)          (* let an array object decay, yielding pointer to first element *)
518          val decay : (('t, 'n) arr, 'c) obj -> ('t, 'c) ptr          val decay : (('t, 'n) arr, 'c) obj -> ('t, 'c) obj ptr
519    
520          (* alt *)          (* alt *)
521          val decay' : (('t, 'n) arr, 'c) obj' -> ('t, 'c) ptr'          val decay' : (('t, 'n) arr, 'c) obj' -> ('t, 'c) obj ptr'
522    
523          (* reconstruct an array object from the pointer to its first element *)          (* reconstruct an array object from the pointer to its first element *)
524          val reconstruct : ('t, 'c) ptr * 'n Dim.dim -> (('t, 'n) arr, 'c) obj          val reconstruct :
525                ('t, 'c) obj ptr * 'n Dim.dim -> (('t, 'n) arr, 'c) obj
526    
527          (* alt *)          (* alt *)
528          val reconstruct': ('t, 'c) ptr' * 'n Dim.dim -> (('t, 'n) arr, 'c) obj'          val reconstruct':
529                ('t, 'c) obj ptr' * 'n Dim.dim -> (('t, 'n) arr, 'c) obj'
530    
531          (* dimension of array object *)          (* dimension of array object *)
532          val dim : (('t, 'n) arr, 'c) obj -> 'n Dim.dim          val dim : (('t, 'n) arr, 'c) obj -> 'n Dim.dim
# Line 526  Line 545 
545      val discard' : ('t, 'c) obj' -> unit      val discard' : ('t, 'c) obj' -> unit
546    
547      (* allocating a dynamically-sized array *)      (* allocating a dynamically-sized array *)
548      val alloc : 't T.typ -> word -> ('t, 'c) ptr      val alloc : 't T.typ -> word -> ('t, 'c) obj ptr
549    
550      (* alt *)      (* alt *)
551      val alloc' : 't S.size -> word -> ('t, 'c) ptr'      val alloc' : 't S.size -> word -> ('t, 'c) obj ptr'
552    
553      (* freeing through pointers *)      (* freeing through pointers *)
554      val free : ('t, 'c) ptr -> unit      val free : 'o ptr -> unit
555    
556      (* alt *)      (* alt *)
557      val free' : ('t, 'c) ptr' -> unit      val free' : 'o ptr' -> unit
558    
559      (* perform function call through function-pointer *)      (* perform function call through function-pointer *)
560      val call : ('a -> 'b) fptr * 'a -> 'b      val call : ('a -> 'b) fptr * 'a -> 'b
# Line 546  Line 565 
565      (* completely unsafe stuff that every C programmer just *loves* to do *)      (* completely unsafe stuff that every C programmer just *loves* to do *)
566      structure U : sig      structure U : sig
567          val fcast : 'a fptr' -> 'b fptr'          val fcast : 'a fptr' -> 'b fptr'
568          val p2i : voidptr -> ulong          val p2i : 'o ptr' -> ulong
569          val i2p : ulong -> voidptr          val i2p : ulong -> 'o ptr'
570      end      end
571  end  end

Legend:
Removed from v.1036  
changed lines
  Added in v.1078

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