Starting to update documentation

README.md

@@ -13,7 +13,7 @@ The new readme is a work in progress.
 
 ## Implementation table
 
-## Primitives 1
+### Primitives 1
 
 |                  | c-size-of    | c-bytevector-u8-set! |c-bytevector-u8-ref | define-c-library    | c-bytevector? | define-c-procedure  |
 |------------------|:------------:|:--------------------:|:------------------:|:-------------------:|:-------------:|:-------------------:|
@@ -28,7 +28,7 @@ The new readme is a work in progress.
 | **Stklos**       | X            | X                    |X                   | X                   | X             | X                   |
 | **Ypsilon**      | X            | X                    |X                   | X                   | X             | X                   |
 
-## Primitives 2
+### Primitives 2
 
 |                  | define-c-callback |
 |------------------|:-----------------:|
@@ -43,7 +43,7 @@ The new readme is a work in progress.
 | Stklos           |                   |
 | **Ypsilon**      | X                 |
 
-## Test files pass
+### Test files pass
 
 |                  | primitives.scm | addressof.scm | callback.scm |
 |------------------|:--------------:|:-------------:|-------------:|
@@ -58,3 +58,72 @@ The new readme is a work in progress.
 | Stklos           | X              | X             |              |
 | Ypsilon          | X              | X             |              |
 
+
+## Documentation
+
+### Primitives
+
+(c-type-size _type_)
+
+Returns the size of given C type.
+
+define-c-library
+define-c-procedure
+define-c-callback
+c-bytevector?
+c-bytevector-u8-set!
+c-bytevector-u8-ref
+c-bytevector-pointer-set!
+c-bytevector-pointer-ref
+
+
+### c-bytevector
+make-c-bytevector
+make-c-null
+c-null?
+c-free
+native-endianness
+c-bytevector-s8-set!
+c-bytevector-s8-ref
+c-bytevector-s16-set!
+c-bytevector-s16-ref
+c-bytevector-s16-native-set!
+c-bytevector-s16-native-ref
+c-bytevector-u16-set!
+c-bytevector-u16-ref
+c-bytevector-u16-native-set!
+c-bytevector-u16-native-ref
+c-bytevector-s32-set!
+c-bytevector-s32-ref
+c-bytevector-s32-native-set!
+c-bytevector-s32-native-ref
+c-bytevector-u32-set!
+c-bytevector-u32-ref
+c-bytevector-u32-native-set!
+c-bytevector-u32-native-ref
+c-bytevector-s64-set!
+c-bytevector-s64-ref
+c-bytevector-s64-native-set!
+c-bytevector-s64-native-ref
+c-bytevector-u64-set!
+c-bytevector-u64-ref
+c-bytevector-u64-native-set!
+c-bytevector-u64-native-ref
+c-bytevector-sint-set!
+c-bytevector-sint-ref
+c-bytevector-uint-set!
+c-bytevector-uint-ref
+c-bytevector-ieee-single-set!
+c-bytevector-ieee-single-native-set!
+c-bytevector-ieee-single-ref
+c-bytevector-ieee-single-native-ref
+c-bytevector-ieee-double-set!
+c-bytevector-ieee-double-native-set!
+c-bytevector-ieee-double-ref
+c-bytevector-ieee-double-native-ref
+bytevector->c-bytevector
+c-bytevector->bytevector
+call-with-address-of
+
+string->c-utf8
+c-utf8->string

foreign/c.sld

@@ -208,7 +208,7 @@
               (ypsilon c-types)
               (only (core) define-macro syntax-case))))
   (export ;;;; Primitives
-          c-size-of
+          c-type-size
           define-c-library
           define-c-procedure
           define-c-callback

foreign/c/main.scm

@@ -1,6 +1,6 @@
-(define c-size-of
+(define c-type-size
-  (lambda (object)
+  (lambda (type)
-    (size-of-type object)))
+    (size-of-type type)))
 
 (define foreign-c:string-split
   (lambda (str mark)

tests/primitives.scm

@@ -72,140 +72,140 @@
        (newline)))))
 
 
-;; c-size-of
+;; c-type-size
 
-(print-header 'c-size-of)
+(print-header 'c-type-size)
 
-(define size-int8 (c-size-of 'int8))
+(define size-int8 (c-type-size 'int8))
 (debug size-int8)
 (assert equal? (number? size-int8) #t)
 (assert = size-int8 1)
 
-(define size-uint8 (c-size-of 'uint8))
+(define size-uint8 (c-type-size 'uint8))
 (debug size-uint8)
 (assert equal? (number? size-uint8) #t)
 (assert = size-uint8 1)
 
-(assert equal? (number? (c-size-of 'uint8)) #t)
+(assert equal? (number? (c-type-size 'uint8)) #t)
-(define size-int16 (c-size-of 'int16))
+(define size-int16 (c-type-size 'int16))
 (debug size-int16)
 (assert equal? (number? size-int16) #t)
 (assert = size-int16 2)
 
-(assert equal? (number? (c-size-of 'int16)) #t)
+(assert equal? (number? (c-type-size 'int16)) #t)
-(define size-uint16 (c-size-of 'uint16))
+(define size-uint16 (c-type-size 'uint16))
 (debug size-uint16)
 (assert equal? (number? size-uint16) #t)
 (assert = size-uint16 2)
 
-(assert equal? (number? (c-size-of 'uint16)) #t)
+(assert equal? (number? (c-type-size 'uint16)) #t)
-(define size-int32 (c-size-of 'int32))
+(define size-int32 (c-type-size 'int32))
 (debug size-int32)
 (assert equal? (number? size-int32) #t)
 (assert = size-int32 4)
 
-(assert equal? (number? (c-size-of 'int32)) #t)
+(assert equal? (number? (c-type-size 'int32)) #t)
-(define size-uint32 (c-size-of 'uint32))
+(define size-uint32 (c-type-size 'uint32))
 (debug size-uint32)
 (assert equal? (number? size-uint32) #t)
 (assert = size-uint32 4)
 
-(assert equal? (number? (c-size-of 'uint32)) #t)
+(assert equal? (number? (c-type-size 'uint32)) #t)
-(define size-int64 (c-size-of 'int64))
+(define size-int64 (c-type-size 'int64))
 (debug size-int64)
 (assert equal? (number? size-int64) #t)
 (assert = size-int64 8)
 
-(assert equal? (number? (c-size-of 'int64)) #t)
+(assert equal? (number? (c-type-size 'int64)) #t)
-(define size-uint64 (c-size-of 'uint64))
+(define size-uint64 (c-type-size 'uint64))
 (debug size-uint64)
 (assert equal? (number? size-uint64) #t)
 (assert = size-uint64 8)
 
-(assert equal? (number? (c-size-of 'uint64)) #t)
+(assert equal? (number? (c-type-size 'uint64)) #t)
-(define size-char (c-size-of 'char))
+(define size-char (c-type-size 'char))
 (debug size-char)
 (assert equal? (number? size-char) #t)
 (assert = size-char 1)
 
-(assert equal? (number? (c-size-of 'char)) #t)
+(assert equal? (number? (c-type-size 'char)) #t)
-(define size-unsigned-char (c-size-of 'unsigned-char))
+(define size-unsigned-char (c-type-size 'unsigned-char))
 (debug size-unsigned-char)
 (assert equal? (number? size-unsigned-char) #t)
 (assert = size-unsigned-char 1)
 
-(assert equal? (number? (c-size-of 'unsigned-char)) #t)
+(assert equal? (number? (c-type-size 'unsigned-char)) #t)
-(define size-short (c-size-of 'short))
+(define size-short (c-type-size 'short))
 (debug size-short)
 (assert equal? (number? size-short) #t)
 (assert = size-short 2)
 
-(assert equal? (number? (c-size-of 'short)) #t)
+(assert equal? (number? (c-type-size 'short)) #t)
-(define size-unsigned-short (c-size-of 'unsigned-short))
+(define size-unsigned-short (c-type-size 'unsigned-short))
 (debug size-unsigned-short)
 (assert equal? (number? size-unsigned-short) #t)
 (assert = size-unsigned-short 2)
 
-(assert equal? (number? (c-size-of 'unsigned-short)) #t)
+(assert equal? (number? (c-type-size 'unsigned-short)) #t)
-(define size-int (c-size-of 'int))
+(define size-int (c-type-size 'int))
 (debug size-int)
 (assert equal? (number? size-int) #t)
 (assert = size-int 4)
 
-(assert equal? (number? (c-size-of 'int)) #t)
+(assert equal? (number? (c-type-size 'int)) #t)
-(define size-unsigned-int (c-size-of 'unsigned-int))
+(define size-unsigned-int (c-type-size 'unsigned-int))
 (debug size-unsigned-int)
 (assert equal? (number? size-unsigned-int) #t)
 (assert = size-unsigned-int 4)
 
 (cond-expand
   (i386
-    (assert equal? (number? (c-size-of 'long)) #t)
+    (assert equal? (number? (c-type-size 'long)) #t)
-    (define size-long (c-size-of 'long))
+    (define size-long (c-type-size 'long))
     (debug size-long)
     (assert equal? (number? size-long) #t)
     (assert = size-long 4))
   (else
-    (assert equal? (number? (c-size-of 'long)) #t)
+    (assert equal? (number? (c-type-size 'long)) #t)
-    (define size-long (c-size-of 'long))
+    (define size-long (c-type-size 'long))
     (debug size-long)
     (assert equal? (number? size-long) #t)
     (assert = size-long 8)))
 
 (cond-expand
   (i386
-    (assert equal? (number? (c-size-of 'unsigned-long)) #t)
+    (assert equal? (number? (c-type-size 'unsigned-long)) #t)
-    (define size-unsigned-long (c-size-of 'unsigned-long))
+    (define size-unsigned-long (c-type-size 'unsigned-long))
     (debug size-unsigned-long)
     (assert equal? (number? size-unsigned-long) #t)
     (assert = size-unsigned-long 4))
   (else
-    (assert equal? (number? (c-size-of 'long)) #t)
+    (assert equal? (number? (c-type-size 'long)) #t)
-    (define size-unsigned-long (c-size-of 'unsigned-long))
+    (define size-unsigned-long (c-type-size 'unsigned-long))
     (debug size-unsigned-long)
     (assert equal? (number? size-unsigned-long) #t)
     (assert = size-unsigned-long 8)))
 
-(assert equal? (number? (c-size-of 'float)) #t)
+(assert equal? (number? (c-type-size 'float)) #t)
-(define size-float (c-size-of 'float))
+(define size-float (c-type-size 'float))
 (debug size-float)
 (assert equal? (number? size-float) #t)
 (assert = size-float 4)
 
-(assert equal? (number? (c-size-of 'double)) #t)
+(assert equal? (number? (c-type-size 'double)) #t)
-(define size-double (c-size-of 'double))
+(define size-double (c-type-size 'double))
 (debug size-double)
 (assert equal? (number? size-double) #t)
 (assert = size-double 8)
 
 (cond-expand
   (i386
-    (define size-pointer (c-size-of 'pointer))
+    (define size-pointer (c-type-size 'pointer))
     (debug size-pointer)
     (assert equal? (number? size-pointer) #t)
     (assert = size-pointer 4))
   (else
-    (define size-pointer (c-size-of 'pointer))
+    (define size-pointer (c-type-size 'pointer))
     (debug size-pointer)
     (assert equal? (number? size-pointer) #t)
     (assert = size-pointer 8)))
@@ -270,7 +270,7 @@
 ;; c-bytevector-u8-set! and c-bytevector-u8-ref
 (print-header "c-bytevector-u8-set! and c-bytevector-u8-ref")
 
-(define u8-pointer (make-c-bytevector (c-size-of 'uint8)))
+(define u8-pointer (make-c-bytevector (c-type-size 'uint8)))
 (debug u8-pointer)
 (debug (c-bytevector? u8-pointer))
 (assert equal? (c-bytevector? u8-pointer) #t)
@@ -282,7 +282,7 @@
 ;; c-bytevector-pointer-set! and c-bytevector-pointer-ref
 (print-header "c-bytevector-pointer-set! and c-bytevector-pointer-ref")
 
-(define p-pointer (make-c-bytevector (c-size-of 'pointer)))
+(define p-pointer (make-c-bytevector (c-type-size 'pointer)))
 (debug p-pointer)
 (debug (c-bytevector? p-pointer))
 (assert equal? (c-bytevector? p-pointer) #t)