; generate declarations for types

(in-package "VERRAZANO")

; a mapping from GCC-XML type names to C-FFI typenames
(defparameter +fundamental-type-map+
  '(("void" . ":void")
    ("bool" . ":char")
    ("char" . ":char")
    ("wchar-t" . ":int")
    ("unsigned char" . ":unsigned-char")
    ("signed char" . ":char")
    ("int" . ":int")
    ("short int" . ":short")
    ("short unsigned int" . ":short")
    ("long int" . ":long")
    ("long long int" . ":long")
    ("unsigned long long int" . ":long")
    ("unsigned int" . ":unsigned-int")
    ("long unsigned int" . ":unsigned-long")
    ("float" . ":float")
    ("double" . ":double")
    ("long double" . ":double")
    ("complex long double" . "not_supported")))

; translate a GCC-XML type to a C-FFI type
(defun translate-fundamental-type (str)
  (let ((tgt (cdr (assoc str +fundamental-type-map+ :test #'equal))))
    (if tgt tgt str)))

; since C-FFI is marginally typed, defining most types does nothing
(generate-for ((par node) (edg defines) (tgt (pointer-type
					      function-type
					      fundamental-type
					      qualified-type)) bst)
  nil)

; generate defctype declaration for typedefs
(generate-for ((par node) (edg defines) (tgt alias-type) bst)
  (let ((type-name (named-name tgt)))
    (define-symbol type-name "typedef" (list par edg tgt) bst)
    `("cffi:define-foreign-type" ,(named-name tgt) "()"
      ',(car (collect-output tgt bst 'extends)))))

; in general, output types as their type name
(generate-for ((par node) (edg edge) (tgt cpp-type) bst)
  (named-name tgt))

; with fundamental types, translate the name
(generate-for ((par node) (edg edge) (tgt fundamental-type) bst)
  (translate-fundamental-type (named-name tgt)))
  
; for pointers, just output :pointer
(generate-for ((par node) (edg edge) (tgt pointer-type) bst)
  ":pointer")

; for qualified types, array types, print the target type instead
(generate-for ((par node) (edg edge) (tgt (qualified-type 
					   array-type)) bst)
  (car (collect-output tgt bst 'extends)))

; defining a namespace outputs everything it allocates
(generate-for ((par node) (edg defines) (tgt namespace-type) bst)
  `("cl:progn" ,@(collect-output tgt bst 'allocates)))