Removed -ref on many predicates

private/simple/aggregate.rkt

@@ -11,7 +11,7 @@
   "values.rkt"
   "util.rkt"
   "convertible.rkt"
-  "../safe/structs.rkt"
+  "predicates.rkt"
   "../ffi/safe.rkt")
 
 (provide
@@ -29,58 +29,58 @@
   (llvm-constant-array llvm-constant-array/c)
   (llvm-constant-array* llvm-constant-array*/c)
   (llvm-struct
-    (->* () (#:context llvm-context-ref?
+    (->* () (#:context llvm:context?
              #:packed boolean?)
-         #:rest (listof llvm-value/c) llvm-value-ref?)) 
+         #:rest (listof llvm-value/c) llvm:value?)) 
  (llvm-named-struct
-   (->* (llvm-named-struct-type-ref?)
-        #:rest (listof llvm-value/c) llvm-value-ref?)))) ;TODO Make contract tighter 
+   (->* (llvm:named-struct-type?)
+        #:rest (listof llvm-value/c) llvm:value?)))) ;TODO Make contract tighter 
 
 
 
 
 ;Predicates
 (define (llvm:array? v)
-  (and (llvm-value-ref? v)
-    (llvm-array-type-ref?
+  (and (llvm:value? v)
+    (llvm:array-type?
       (llvm-type-of v))))
 
 (define (llvm:struct? v)
- (and (llvm-value-ref? v)
-   (llvm-struct-type-ref?
+ (and (llvm:value? v)
+   (llvm:struct-type?
      (llvm-type-of v))))
 
 (define (llvm:vector? v)
-  (and (llvm-value-ref? v)
-   (llvm-vector-type-ref?
+  (and (llvm:value? v)
+   (llvm:vector-type?
      (llvm-type-of v))))
 
 
 ;Contracts
 (define llvm-extract-element/c
   (->* (llvm:vector?
         llvm-integer32/c)
-       (#:builder llvm-builder-ref?
+       (#:builder llvm:builder?
         #:name string?)
-       llvm-value-ref?))
+       llvm:value?))
 
 (define llvm-insert-element/c
   (->i ((vector llvm:vector?)
         (arg llvm-value/c)
         (index llvm-integer32/c))
-       (#:builder (builder llvm-builder-ref?)
+       (#:builder (builder llvm:builder?)
         #:name (name string?))
        #:pre/name (vector arg)
         "Element and vector types don't match"
         (equal? (llvm-get-element-type (llvm-type-of vector))
                 (value->llvm-type arg))
-       (_ llvm-value-ref?)))
+       (_ llvm:value?)))
 
 
 (define llvm-extract-value/c
   (->i ((aggregate (or/c llvm:array? llvm:struct?))
         (index exact-nonnegative-integer?))
-       (#:builder (builder llvm-builder-ref?)
+       (#:builder (builder llvm:builder?)
         #:name (name string?))
        #:pre/name (aggregate index)
         "Invalid array index"
@@ -92,13 +92,13 @@
         "Invalid struct index"
         (or (not (llvm:struct? aggregate))
             (llvm-is-valid-type-index (llvm-type-of aggregate) index))
-       (_ llvm-value-ref?)))
+       (_ llvm:value?)))
 
 (define llvm-insert-value/c
   (->i ((aggregate (or/c llvm:array? llvm:struct?))
         (arg llvm-value/c)
         (index exact-nonnegative-integer?))
-       (#:builder (builder llvm-builder-ref?)
+       (#:builder (builder llvm:builder?)
         #:name (name string?))
        #:pre/name (aggregate index)
         "Invalid array index"
@@ -114,32 +114,32 @@
         "Element and aggregate types don't match"
         (equal? (llvm-get-type-at-index (llvm-type-of aggregate) index)
                 (value->llvm-type arg))
-       (_ llvm-value-ref?)))
+       (_ llvm:value?)))
 
 
 (define llvm-vector/c
   (->i ()
-       (#:builder (builder llvm-builder-ref?))
+       (#:builder (builder llvm:builder?))
        #:rest (args (non-empty-listof llvm-value/c))
        #:pre/name (args)
         "Element types don't match"
         (let ((t (value->llvm-type (first args))))
           (andmap (lambda (e) (equal? t (value->llvm-type e)))
                   (rest args)))
-       (_ llvm-value-ref?)))
+       (_ llvm:value?)))
 
 
 (define llvm-vector*/c
   (->i ()
-       (#:builder (builder llvm-builder-ref?))
+       (#:builder (builder llvm:builder?))
        #:rest (args (non-empty-list*/c llvm-value/c))
        #:pre/name (args)
         "Element types don't match"
         (let ((args (apply list* args)))
          (let ((t (value->llvm-type (first args))))
            (andmap (lambda (e) (equal? t (value->llvm-type e)))
                    (rest args))))
-       (_ llvm-value-ref?)))
+       (_ llvm:value?)))
 
 
 (define llvm-constant-array/c
@@ -151,7 +151,7 @@
         (let ((elem-type (value->llvm-type (first args))))
          (for ((arg (rest args)))
            (equal? elem-type (value->llvm-type arg))))
-       (_ llvm-value-ref?)))
+       (_ llvm:value?)))
 
 
 (define llvm-constant-array*/c
@@ -164,7 +164,7 @@
          (let ((elem-type (value->llvm-type (first args))))
           (for ((arg (rest args)))
             (equal? elem-type (value->llvm-type arg)))))
-       (_ llvm-value-ref?)))
+       (_ llvm:value?)))
 
 
 (define (llvm-extract-element v index #:builder (builder (current-builder)) #:name (name ""))

private/simple/convertible.rkt

@@ -1,10 +1,10 @@
 #lang racket
 
 (require
-  "../safe/structs.rkt"
   "../ffi/safe.rkt"
   "types.rkt"
   "values.rkt"
+  "predicates.rkt"
   "parameters.rkt")
 
 (provide
@@ -19,9 +19,9 @@
   (llvm-boolean/c contract?)
   (llvm-int
     (->* (integer?)
-         (llvm-integer-type-ref?
+         (llvm:integer-type?
           #:signed? boolean?)
-         llvm-value-ref?))))
+         llvm:value?))))
 
 
 ;TODO enhance contract
@@ -46,27 +46,27 @@
 (define (integer->llvm n)
  (cond
   ((exact-integer? n) (LLVMConstInt (current-integer-type) n #t))
-  ((llvm-value-ref? n) n)
+  ((llvm:value? n) n)
   (else (error 'integer->llvm "Unknown input value ~a" n))))
 
 
 (define (float->llvm n)
  (cond
   ((real? n) (LLVMConstReal (current-float-type) n))
-  ((llvm-value-ref? n) n)
+  ((llvm:value? n) n)
   (else (error 'float->llvm "Unknown input value ~a" n))))
 
 
 (define (boolean->llvm n)
  (cond
   ((boolean? n) (LLVMConstInt (current-boolean-type) (if n 1 0) #t))
-  ((llvm-value-ref? n) n)
+  ((llvm:value? n) n)
   (else (error 'boolean->llvm "Unknown input value ~a" n))))
 
 (define (string->llvm v #:null-terminate (null-terminate #f))
  (cond
   ((string? v) (LLVMConstStringInContext (current-context) v (not null-terminate)))
-  ((llvm-value-ref? v) v)
+  ((llvm:value? v) v)
   (else (error 'string->llvm "Unknown input value ~a" v))))
 
 
@@ -76,7 +76,7 @@
   ((exact-integer? n) (LLVMConstInt (current-integer-type) n #t))
   ((real? n) (LLVMConstReal (current-float-type) n))
   ((string? n) (LLVMConstStringInContext (current-context) n #t))
-  ((llvm-value-ref? n) n)
+  ((llvm:value? n) n)
   (else (error 'value->llvm "Unknown input value ~a" n))))
 
 ;Type Level
@@ -95,7 +95,7 @@
 (define llvm-current-integer/c
  (flat-named-contract 'llvm-current-integer/c
   (lambda (n) (or (exact-integer? n)
-    (and (llvm-value-ref? n)
+    (and (llvm:value? n)
          (equal?
            (current-integer-type)
            (llvm-type-of n)))))))
@@ -106,8 +106,8 @@
 (define llvm-integer/c
  (flat-named-contract 'llvm-integer/c
   (lambda (n) (or (exact-integer? n)
-    (and (llvm-value-ref? n)
-         (llvm-integer-type-ref?
+    (and (llvm:value? n)
+         (llvm:integer-type?
            (llvm-type-of n)))))))
 
 (define llvm-integer32/c
@@ -119,9 +119,9 @@
     (cond
       ((exact-integer? n)
        (check-type (current-integer-type)))
-      ((llvm-value-ref? n)
+      ((llvm:value? n)
        (let ((ty (llvm-type-of n)))
-         (and (llvm-integer-type-ref? ty)
+         (and (llvm:integer-type? ty)
               (check-type ty))))
       (else #f)))))
 
@@ -130,35 +130,27 @@
 (define llvm-float/c
  (flat-named-contract 'llvm-float/c
   (lambda (n) (or (real? n)
-    (and (llvm-value-ref? n)
-         (llvm-float-type-ref?
+    (and (llvm:value? n)
+         (llvm:float-type?
            (llvm-type-of n)))))))
 
 (define llvm-any-pointer/c
  (flat-named-contract 'llvm-any-pointer/c
   (lambda (v) 
-    (and (llvm-value-ref? v)
+    (and (llvm:value? v)
      (let ((t (llvm-type-of v)))
       (and (eq? (llvm-get-type-kind t)
                 'LLVMPointerTypeKind)))))))
 
-(define llvm-function-pointer/c
- (flat-named-contract 'llvm-function-pointer/c
-  (lambda (v) 
-    (and (llvm-value-ref? v)
-     (let ((t (llvm-type-of v)))
-      (and (eq? (llvm-get-type-kind t)
-                'LLVMPointerTypeKind)
-           (llvm-function-type-ref? (llvm-get-element-type t))))))))
-
 
 
 
 
 
+;TODO make tighter
 (define llvm-boolean/c
  (flat-named-contract 'llvm-boolean/c
-  (lambda (n) (or (boolean? n) (llvm-value-ref? n)))))
+  (lambda (n) (or (boolean? n) (llvm:value? n)))))
 
 
 (define llvm-value/c
@@ -167,7 +159,7 @@
                   (boolean? v)
                   (exact-integer? v)
                   (real? v)
-                  (llvm-value-ref? v)))))
+                  (llvm:value? v)))))
 
 
 (define llvm-constant-value/c
@@ -176,7 +168,7 @@
                   (boolean? v)
                   (exact-integer? v)
                   (real? v)
-                  (and (llvm-value-ref? v)
+                  (and (llvm:value? v)
                        (llvm:constant? v))))))
 
 

private/simple/functions.rkt

@@ -4,8 +4,8 @@
   racket/contract
   unstable/contract
   "../ffi/safe.rkt"
-  "../safe/structs.rkt"
   "parameters.rkt"
+  "predicates.rkt"
   "types.rkt"
   "values.rkt")
 
@@ -15,18 +15,18 @@
   (llvm:function-pointer? predicate/c)
 
   (llvm-add-function
-    (->* (llvm-function-type-ref? string?)
-         (#:module llvm-module-ref?) llvm-value-ref?))
+    (->* (llvm:function-type? string?)
+         (#:module llvm:module?) llvm:value?))
 
   (llvm-get-named-function
-    (->* (string?) (#:module llvm-module-ref?) llvm-value-ref?))))
+    (->* (string?) (#:module llvm:module?) llvm:value?))))
 
 
 (define (llvm:function-pointer? v)
  (and (llvm:value? v)
   (let ((type (llvm-type-of v)))
-    (and (llvm-pointer-type-ref? type)
-         (llvm-function-type-ref? (llvm-get-element-type type))))))
+    (and (llvm:pointer-type? type)
+         (llvm:function-type? (llvm-get-element-type type))))))
 
 
 (define (llvm-add-function type name #:module (module (current-module)))

private/simple/generic.rkt

@@ -6,12 +6,12 @@
 
 (provide
  (contract-out
-  (llvm:int->generic (->* (exact-integer?) (#:type llvm-integer-type-ref? #:signed boolean?) llvm-generic-value?))
+  (llvm:int->generic (->* (exact-integer?) (#:type llvm:integer-type? #:signed boolean?) llvm-generic-value?))
   (llvm:int32->generic (->* (exact-integer?) (#:signed boolean?) llvm-generic-value?))
 
 
 
-  (llvm:float->generic (->* (real?) (#:type (or/c llvm-float-type-ref? 'single 'double)) llvm-generic-value?))
+  (llvm:float->generic (->* (real?) (#:type (or/c llvm:float-type? 'single 'double)) llvm-generic-value?))
   (llvm:single->generic (-> real? llvm-generic-value?))
   (llvm:double->generic (-> real? llvm-generic-value?))
 
@@ -21,7 +21,7 @@
   (llvm:generic->int (->* (llvm-generic-value?) (#:signed boolean?) exact-integer?))
   (llvm:generic->pointer (-> llvm-generic-value?  cpointer?))
 
-  (llvm:generic->float (->* (llvm-generic-value?) (#:type (or/c 'single 'double llvm-float-type-ref?)) real?))
+  (llvm:generic->float (->* (llvm-generic-value?) (#:type (or/c 'single 'double llvm:float-type?)) real?))
   (llvm:generic->single (->* (llvm-generic-value?)  real?))
   (llvm:generic->double (->* (llvm-generic-value?)  real?))
 
@@ -55,7 +55,7 @@
 
 (define (llvm:float->generic x #:type (type (current-float-type)))
   (let ((type (cond
-               ((llvm-float-type-ref? type) type)
+               ((llvm:float-type? type) type)
                ((equal? 'double type) double)
                ((equal? 'single type) single))))
     (LLVMCreateGenericValueOfFloat type x)))
@@ -80,7 +80,7 @@
 
 (define (llvm:generic->float gen #:type (type (current-float-type)))
  (let ((type (cond
-              ((llvm-float-type-ref? type) type)
+              ((llvm:float-type? type) type)
               ((equal? 'double type) double)
               ((equal? 'single type) single))))
   (LLVMGenericValueToFloat type gen)))