(in-package #:ocl)

;;; Error Codes
;; (defconstant +success+                                  0)
;; (defconstant +device-not-found+                         -1)
;; (defconstant +device-not-available+                     -2)
;; (defconstant +compiler-not-available+                   -3)
;; (defconstant +mem-object-allocation-failure+            -4)
;; (defconstant +out-of-resources+                         -5)
;; (defconstant +out-of-host-memory+                       -6)
;; (defconstant +profiling-info-not-available+             -7)
;; (defconstant +mem-copy-overlap+                         -8)
;; (defconstant +image-format-mismatch+                    -9)
;; (defconstant +image-format-not-supported+               -10)
;; (defconstant +build-program-failure+                    -11)
;; (defconstant +map-failure+                              -12)
;; (defconstant +misaligned-sub-buffer-offset+             -13)
;; (defconstant +exec-status-error-for-events-in-wait-list+ -14)
;; (defconstant +compile-program-failure+                  -15)
;; (defconstant +linker-not-available+                     -16)
;; (defconstant +link-program-failure+                     -17)
;; (defconstant +device-partition-failed+                  -18)
;; (defconstant +kernel-arg-info-not-available+            -19)
;; (defconstant +invalid-value+                            -30)
;; (defconstant +invalid-device-type+                      -31)
;; (defconstant +invalid-platform+                         -32)
;; (defconstant +invalid-device+                           -33)
;; (defconstant +invalid-context+                          -34)
;; (defconstant +invalid-queue-properties+                 -35)
;; (defconstant +invalid-command-queue+                    -36)
;; (defconstant +invalid-host-ptr+                         -37)
;; (defconstant +invalid-mem-object+                       -38)
;; (defconstant +invalid-image-format-descriptor+          -39)
;; (defconstant +invalid-image-size+                       -40)
;; (defconstant +invalid-sampler+                          -41)
;; (defconstant +invalid-binary+                           -42)
;; (defconstant +invalid-build-options+                    -43)
;; (defconstant +invalid-program+                          -44)
;; (defconstant +invalid-program-executable+               -45)
;; (defconstant +invalid-kernel-name+                      -46)
;; (defconstant +invalid-kernel-definition+                -47)
;; (defconstant +invalid-kernel+                           -48)
;; (defconstant +invalid-arg-index+                        -49)
;; (defconstant +invalid-arg-value+                        -50)
;; (defconstant +invalid-arg-size+                         -51)
;; (defconstant +invalid-kernel-args+                      -52)
;; (defconstant +invalid-work-dimension+                   -53)
;; (defconstant +invalid-work-group-size+                  -54)
;; (defconstant +invalid-work-item-size+                   -55)
;; (defconstant +invalid-global-offset+                    -56)
;; (defconstant +invalid-event-wait-list+                  -57)
;; (defconstant +invalid-event+                            -58)
;; (defconstant +invalid-operation+                        -59)
;; (defconstant +invalid-gl-object+                        -60)
;; (defconstant +invalid-buffer-size+                      -61)
;; (defconstant +invalid-mip-level+                        -62)
;; (defconstant +invalid-global-work-size+                 -63)
;; (defconstant +invalid-property+                         -64)
;; (defconstant +invalid-image-descriptor+                 -65)
;; (defconstant +invalid-compiler-options+                 -66)
;; (defconstant +invalid-linker-options+                   -67)
;; (defconstant +invalid-device-partition-count+           -68)
;; (defconstant +invalid-pipe-size+                        -69)
;; (defconstant +invalid-device-queue+                     -70)
;; (defconstant +invalid-spec-id+                          -71)
;; (defconstant +max-size-restriction-exceeded+            -72)

;;; cl-bool
;; (defconstant +false+ 0)
;; (defconstant +true+ 1)
;; (defconstant +blocking+ +true+)
;; (defconstant +non-blocking+ +false+)


;;; cl-platform-info
;; (defconstant +platform-profile+ #x0900)
;; (defconstant +platform-version+ #x0901)
;; (defconstant +platform-name+ #x0902)
;; (defconstant +platform-vendor+ #x0903)
;; (defconstant +platform-extensions+ #x0904)
;; (defconstant +platform-host-timer-resolution+ #x0905)
;; (defconstant +platform-numeric-version+ #x0906)
;; (defconstant +platform-extensions-with-version+ #x0907)

;;; cl-device-type - bitfield
;; (defconstant +device-type-default+ #x1)
;; (defconstant +device-type-cpu+ #x2)
;; (defconstant +device-type-gpu+ #x4)
;; (defconstant +device-type-accelerator+ #x8)
;; (defconstant +device-type-custom+ #x10)
;; (defconstant +device-type-all+ #xffffffff)

;;; cl-device-info
;; (defconstant +device-type+ #x1000)
;; (defconstant +device-vendor-id+ #x1001)
;; (defconstant +device-max-compute-units+ #x1002)
;; (defconstant +device-max-work-item-dimensions+ #x1003)
;; (defconstant +device-max-work-group-size+ #x1004)
;; (defconstant +device-max-work-item-sizes+ #x1005)
;; (defconstant +device-preferred-vector-width-char+ #x1006)
;; (defconstant +device-preferred-vector-width-short+ #x1007)
;; (defconstant +device-preferred-vector-width-int+ #x1008)
;; (defconstant +device-preferred-vector-width-long+ #x1009)
;; (defconstant +device-preferred-vector-width-float+ #x100a)
;; (defconstant +device-preferred-vector-width-double+ #x100b)
;; (defconstant +device-max-clock-frequency+ #x100c)
;; (defconstant +device-address-bits+ #x100d)
;; (defconstant +device-max-read-image-args+ #x100e)
;; (defconstant +device-max-write-image-args+ #x100f)
;; (defconstant +device-max-mem-alloc-size+ #x1010)
;; (defconstant +device-image2d-max-width+ #x1011)
;; (defconstant +device-image2d-max-height+ #x1012)
;; (defconstant +device-image3d-max-width+ #x1013)
;; (defconstant +device-image3d-max-height+ #x1014)
;; (defconstant +device-image3d-max-depth+ #x1015)
;; (defconstant +device-image-support+ #x1016)
;; (defconstant +device-max-parameter-size+ #x1017)
;; (defconstant +device-max-samplers+ #x1018)
;; (defconstant +device-mem-base-addr-align+ #x1019)
;; (defconstant +device-min-data-type-align-size+ #x101a)
;; (defconstant +device-single-fp-config+ #x101b)
;; (defconstant +device-global-mem-cache-type+ #x101c)
;; (defconstant +device-global-mem-cacheline-size+ #x101d)
;; (defconstant +device-global-mem-cache-size+ #x101e)
;; (defconstant +device-global-mem-size+ #x101f)
;; (defconstant +device-max-constant-buffer-size+ #x1020)
;; (defconstant +device-max-constant-args+ #x1021)
;; (defconstant +device-local-mem-type+ #x1022)
;; (defconstant +device-local-mem-size+ #x1023)
;; (defconstant +device-error-correction-support+ #x1024)
;; (defconstant +device-profiling-timer-resolution+ #x1025)
;; (defconstant +device-endian-little+ #x1026)
;; (defconstant +device-available+ #x1027)
;; (defconstant +device-compiler-available+ #x1028)
;; (defconstant +device-execution-capabilities+ #x1029)
;; (defconstant +device-queue-properties+ #x102a)
;; (defconstant +device-queue-on-host-properties+ #x102a)
;; (defconstant +device-name+ #x102b)
;; (defconstant +device-vendor+ #x102c)
;; (defconstant +driver-version+ #x102d)
;; (defconstant +device-profile+ #x102e)
;; (defconstant +device-version+ #x102f)
;; (defconstant +device-extensions+ #x1030)
;; (defconstant +device-platform+ #x1031)
;; (defconstant +device-double-fp-config+ #x1032)
;; (defconstant +device-preferred-vector-width-half+ #x1034)
;; (defconstant +device-host-unified-memory+ #x1035)
;; (defconstant +device-native-vector-width-char+ #x1036)
;; (defconstant +device-native-vector-width-short+ #x1037)
;; (defconstant +device-native-vector-width-int+ #x1038)
;; (defconstant +device-native-vector-width-long+ #x1039)
;; (defconstant +device-native-vector-width-float+ #x103a)
;; (defconstant +device-native-vector-width-double+ #x103b)
;; (defconstant +device-native-vector-width-half+ #x103c)
;; (defconstant +device-opencl-c-version+ #x103d)
;; (defconstant +device-linker-available+ #x103e)
;; (defconstant +device-built-in-kernels+ #x103f)
;; (defconstant +device-image-max-buffer-size+ #x1040)
;; (defconstant +device-image-max-array-size+ #x1041)
;; (defconstant +device-parent-device+ #x1042)
;; (defconstant +device-partition-max-sub-devices+ #x1043)
;; (defconstant +device-partition-properties+ #x1044)
;; (defconstant +device-partition-affinity-domain+ #x1045)
;; (defconstant +device-partition-type+ #x1046)
;; (defconstant +device-reference-count+ #x1047)
;; (defconstant +device-preferred-interop-user-sync+ #x1048)
;; (defconstant +device-printf-buffer-size+ #x1049)
;; (defconstant +device-image-pitch-alignment+ #x104a)
;; (defconstant +device-image-base-address-alignment+ #x104b)
;; (defconstant +device-max-read-write-image-args+ #x104c)
;; (defconstant +device-max-global-variable-size+ #x104d)
;; (defconstant +device-queue-on-device-properties+ #x104e)
;; (defconstant +device-queue-on-device-preferred-size+ #x104f)
;; (defconstant +device-queue-on-device-max-size+ #x1050)
;; (defconstant +device-max-on-device-queues+ #x1051)
;; (defconstant +device-max-on-device-events+ #x1052)
;; (defconstant +device-svm-capabilities+ #x1053)
;; (defconstant +device-global-variable-preferred-total-size+ #x1054)
;; (defconstant +device-max-pipe-args+ #x1055)
;; (defconstant +device-pipe-max-active-reservations+ #x1056)
;; (defconstant +device-pipe-max-packet-size+ #x1057)
;; (defconstant +device-preferred-platform-atomic-alignment+ #x1058)
;; (defconstant +device-preferred-global-atomic-alignment+ #x1059)
;; (defconstant +device-preferred-local-atomic-alignment+ #x105a)
;; (defconstant +device-il-version+ #x105b)
;; (defconstant +device-max-num-sub-groups+ #x105c)
;; (defconstant +device-sub-group-independent-forward-progress+ #x105d)
;; (defconstant +device-numeric-version+ #x105e)
;; (defconstant +device-extensions-with-version+ #x1060)
;; (defconstant +device-ils-with-version+ #x1061)
;; (defconstant +device-built-in-kernels-with-version+ #x1062)
;; (defconstant +device-atomic-memory-capabilities+ #x1063)
;; (defconstant +device-atomic-fence-capabilities+ #x1064)
;; (defconstant +device-non-uniform-work-group-support+ #x1065)
;; (defconstant +device-opencl-c-all-versions+ #x1066)
;; (defconstant +device-preferred-work-group-size-multiple+ #x1067)
;; (defconstant +device-work-group-collective-functions-support+ #x1068)
;; (defconstant +device-generic-address-space-support+ #x1069)
;; (defconstant +device-opencl-c-features+ #x106f)
;; (defconstant +device-device-enqueue-capabilities+ #x1070)
;; (defconstant +device-pipe-support+ #x1071)
;; (defconstant +device-latest-conformance-version-passed+ #x1072)

;;; cl-device-fp-config - bitfield
;; (defconstant +fp-denorm+ #x1)
;; (defconstant +fp-inf-nan+ #x2)
;; (defconstant +fp-round-to-nearest+ #x4)
;; (defconstant +fp-round-to-zero+ #x8)
;; (defconstant +fp-round-to-inf+ #x10)
;; (defconstant +fp-fma+ #x20)
;; (defconstant +fp-soft-float+ #x40)
;; (defconstant +fp-correctly-rounded-divide-sqrt+ #x80)

;;; cl-device-mem-cache-type
;; (defconstant +none+ #x0)
;; (defconstant +read-only-cache+ #x1)
;; (defconstant +read-write-cache+ #x2)

;;; cl-device-local-mem-type
;; (defconstant +local+ #x1)
;; (defconstant +global+ #x2)

;;; cl-device-exec-capabilities - bitfield
;; (defconstant +exec-kernel+ #x1)
;; (defconstant +exec-native-kernel+ #x2)

;;; cl-command-queue-properties - bitfield
;; (defconstant +queue-out-of-order-exec-mode-enable+ #x1)
;; (defconstant +queue-profiling-enable+ #x2)
;; (defconstant +queue-on-device+ #x4)
;; (defconstant +queue-on-device-default+ #x8)

;;; cl-context-info
;; (defconstant +context-reference-count+ #x1080)
;; (defconstant +context-devices+ #x1081)
;; (defconstant +context-properties+ #x1082)
;; (defconstant +context-num-devices+ #x1083)

;;; cl-context-properties
;; (defconstant +context-platform+ #x1084)
;; (defconstant +context-interop-user-sync+ #x1085)

;;; cl-device-partition-property
(defconstant +device-partition-equally+ #x1086)
(defconstant +device-partition-by-counts+ #x1087)
(defconstant +device-partition-by-counts-list-end+ #x0)
(defconstant +device-partition-by-affinity-domain+ #x1088)


;;; cl-device-affinity-domain
;; (defconstant +device-affinity-domain-numa+ #x1)
;; (defconstant +device-affinity-domain-l4-cache+ #x2)
;; (defconstant +device-affinity-domain-l3-cache+ #x4)
;; (defconstant +device-affinity-domain-l2-cache+ #x8)
;; (defconstant +device-affinity-domain-l1-cache+ #x10)
;; (defconstant +device-affinity-domain-next-partitionable+ #x20)

;;; cl-device-svm-capabilities
;; (defconstant +device-svm-coarse-grain-buffer+ #x1)
;; (defconstant +device-svm-fine-grain-buffer+ #x2)
;; (defconstant +device-svm-fine-grain-system+ #x4)
;; (defconstant +device-svm-atomics+ #x8)

;;; cl-command-queue-info
;; (defconstant +queue-context+ #x1090)
;; (defconstant +queue-device+ #x1091)
;; (defconstant +queue-reference-count+ #x1092)
;; (defconstant +queue-properties+ #x1093)
;; (defconstant +queue-size+ #x1094)
;; (defconstant +queue-device-default+ #x1095)
;; (defconstant +queue-properties-array+ #x1098)

;;; cl-mem-flags and cl-svm-mem-flags - bitfield
(defconstant +mem-read-write+ #x1)
(defconstant +mem-write-only+ #x2)
(defconstant +mem-read-only+ #x4)
(defconstant +mem-use-host-ptr+ #x8)
(defconstant +mem-alloc-host-ptr+ #x10)
(defconstant +mem-copy-host-ptr+ #x20)
(defconstant +mem-host-write-only+ #x80)
(defconstant +mem-host-read-only+ #x100)
(defconstant +mem-host-no-access+ #x200)
(defconstant +mem-svm-fine-grain-buffer+ #x400)
(defconstant +mem-svm-atomics+ #x800)
(defconstant +mem-kernel-read-and-write+ #x1000)


;;; cl-mem-migration-flags - bitfield
;; (defconstant +migrate-mem-object-host+ #x1)
;; (defconstant +migrate-mem-object-content-undefined+ #x2)

;;; cl-channel-order
;; (defconstant +r+ #x10b0)
;; (defconstant +a+ #x10b1)
;; (defconstant +rg+ #x10b2)
;; (defconstant +ra+ #x10b3)
;; (defconstant +rgb+ #x10b4)
;; (defconstant +rgba+ #x10b5)
;; (defconstant +bgra+ #x10b6)
;; (defconstant +argb+ #x10b7)
;; (defconstant +intensity+ #x10b8)
;; (defconstant +luminance+ #x10b9)
;; (defconstant +rx+ #x10ba)
;; (defconstant +rgx+ #x10bb)
;; (defconstant +rgbx+ #x10bc)
;; (defconstant +depth+ #x10bd)
;; (defconstant +depth-stencil+ #x10be)
;; (defconstant +srgb+ #x10bf)
;; (defconstant +srgbx+ #x10c0)
;; (defconstant +srgba+ #x10c1)
;; (defconstant +sbgra+ #x10c2)
;; (defconstant +abgr+ #x10c3)

;;; cl-channel-type
;; (defconstant +snorm-int8+ #x10d0)
;; (defconstant +snorm-int16+ #x10d1)
;; (defconstant +unorm-int8+ #x10d2)
;; (defconstant +unorm-int16+ #x10d3)
;; (defconstant +unorm-short-565+ #x10d4)
;; (defconstant +unorm-short-555+ #x10d5)
;; (defconstant +unorm-int-101010+ #x10d6)
;; (defconstant +signed-int8+ #x10d7)
;; (defconstant +signed-int16+ #x10d8)
;; (defconstant +signed-int32+ #x10d9)
;; (defconstant +unsigned-int8+ #x10da)
;; (defconstant +unsigned-int16+ #x10db)
;; (defconstant +unsigned-int32+ #x10dc)
;; (defconstant +half-float+ #x10dd)
;; (defconstant +float+ #x10de)
;; (defconstant +unorm-int24+ #x10df)
;; (defconstant +unorm-int-101010-2+ #x10e0)

;;; cl-mem-object-type
;; (defconstant +mem-object-buffer+ #x10f0)
;; (defconstant +mem-object-image2d+ #x10f1)
;; (defconstant +mem-object-image3d+ #x10f2)
;; (defconstant +mem-object-image2d-array+ #x10f3)
;; (defconstant +mem-object-image1d+ #x10f4)
;; (defconstant +mem-object-image1d-array+ #x10f5)
;; (defconstant +mem-object-image1d-buffer+ #x10f6)
;; (defconstant +mem-object-pipe+ #x10f7)

;;; cl-mem-info
;; (defconstant +mem-type+ #x1100)
;; (defconstant +mem-flags+ #x1101)
;; (defconstant +mem-size+ #x1102)
;; (defconstant +mem-host-ptr+ #x1103)
;; (defconstant +mem-map-count+ #x1104)
;; (defconstant +mem-reference-count+ #x1105)
;; (defconstant +mem-context+ #x1106)
;; (defconstant +mem-associated-memobject+ #x1107)
;; (defconstant +mem-offset+ #x1108)
;; (defconstant +mem-uses-svm-pointer+ #x1109)
;; (defconstant +mem-properties+ #x110a)

;;; cl-image-info
;; (defconstant +image-format+ #x1110)
;; (defconstant +image-element-size+ #x1111)
;; (defconstant +image-row-pitch+ #x1112)
;; (defconstant +image-slice-pitch+ #x1113)
;; (defconstant +image-width+ #x1114)
;; (defconstant +image-height+ #x1115)
;; (defconstant +image-depth+ #x1116)
;; (defconstant +image-array-size+ #x1117)
;; (defconstant +image-buffer+ #x1118)
;; (defconstant +image-num-mip-levels+ #x1119)
;; (defconstant +image-num-samples+ #x111a)

;;; cl-pipe-info
;; (defconstant +pipe-packet-size+ #x1120)
;; (defconstant +pipe-max-packets+ #x1121)
;; (defconstant +pipe-properties+ #x1122)

;;; cl-addressing-mode
;; (defconstant +address-none+ #x1130)
;; (defconstant +address-clamp-to-edge+ #x1131)
;; (defconstant +address-clamp+ #x1132)
;; (defconstant +address-repeat+ #x1133)
;; (defconstant +address-mirrored-repeat+ #x1134)

;;; cl-filter-mode
;; (defconstant +filter-nearest+ #x1140)
;; (defconstant +filter-linear+ #x1141)

;;; cl-sampler-info
;; (defconstant +sampler-reference-count+ #x1150)
;; (defconstant +sampler-context+ #x1151)
;; (defconstant +sampler-normalized-coords+ #x1152)
;; (defconstant +sampler-addressing-mode+ #x1153)
;; (defconstant +sampler-filter-mode+ #x1154)
;; (defconstant +sampler-mip-filter-mode+ #x1155)
;; (defconstant +sampler-lod-min+ #x1156)
;; (defconstant +sampler-lod-max+ #x1157)
;; (defconstant +sampler-properties+ #x1158)


;;; cl-map-flags - bitfield
;; (defconstant +map-read+ #x1)
;; (defconstant +map-write+ #x2)
;; (defconstant +map-write-invalidate-region+ #x4)

;;; cl-program-info
;; (defconstant +program-reference-count+ #x1160)
;; (defconstant +program-context+ #x1161)
;; (defconstant +program-num-devices+ #x1162)
;; (defconstant +program-devices+ #x1163)
;; (defconstant +program-source+ #x1164)
;; (defconstant +program-binary-sizes+ #x1165)
;; (defconstant +program-binaries+ #x1166)
;; (defconstant +program-num-kernels+ #x1167)
;; (defconstant +program-kernel-names+ #x1168)
;; (defconstant +program-il+ #x1169)
;; (defconstant +program-scope-global-ctors-present+ #x116a)
;; (defconstant +program-scope-global-dtors-present+ #x116b)

;;; cl-program-build-info
;; (defconstant +program-build-status+ #x1181)
;; (defconstant +program-build-options+ #x1182)
;; (defconstant +program-build-log+ #x1183)
;; (defconstant +program-binary-type+ #x1184)
;; (defconstant +program-build-global-variable-total-size+ #x1185)

;;; cl-program-binary-type
;; (defconstant +program-binary-type-none+ #x0)
;; (defconstant +program-binary-type-compiled-object+ #x1)
;; (defconstant +program-binary-type-library+ #x2)
;; (defconstant +program-binary-type-executable+ #x4)

;;; cl-build-status
;; (defconstant +build-success+ 0)
;; (defconstant +build-none+ -1)
;; (defconstant +build-error+ -2)
;; (defconstant +build-in-progress+ -3)

;; cl-kernel-info
;; (defconstant +kernel-function-name+ #x1190)
;; (defconstant +kernel-num-args+ #x1191)
;; (defconstant +kernel-reference-count+ #x1192)
;; (defconstant +kernel-context+ #x1193)
;; (defconstant +kernel-program+ #x1194)
;; (defconstant +kernel-attributes+ #x1195)

;;; cl-kernel-arg-info
;; (defconstant +kernel-arg-address-qualifier+ #x1196)
;; (defconstant +kernel-arg-access-qualifier+ #x1197)
;; (defconstant +kernel-arg-type-name+ #x1198)
;; (defconstant +kernel-arg-type-qualifier+ #x1199)
;; (defconstant +kernel-arg-name+ #x119a)

;;; cl-kernel-arg-address-qualifier
;; (defconstant +kernel-arg-address-global+ #x119b)
;; (defconstant +kernel-arg-address-local+ #x119c)
;; (defconstant +kernel-arg-address-constant+ #x119d)
;; (defconstant +kernel-arg-address-private+ #x119e)

;;; cl-kernel-arg-access-qualifier
;; (defconstant +kernel-arg-access-read-only+ #x11a0)
;; (defconstant +kernel-arg-access-write-only+ #x11a1)
;; (defconstant +kernel-arg-access-read-write+ #x11a2)
;; (defconstant +kernel-arg-access-none+ #x11a3)

;;; cl-kernel-arg-type-qualifier
;; (defconstant +kernel-arg-type-none+ #x0)
;; (defconstant +kernel-arg-type-const+ #x1)
;; (defconstant +kernel-arg-type-restrict+ #x2)
;; (defconstant +kernel-arg-type-volatile+ #x4)
;; (defconstant +kernel-arg-type-pipe+ #x8)

;;; cl-kernel-work-group-info
;; (defconstant +kernel-work-group-size+ #x11b0)
;; (defconstant +kernel-compile-work-group-size+ #x11b1)
;; (defconstant +kernel-local-mem-size+ #x11b2)
;; (defconstant +kernel-preferred-work-group-size-multiple+ #x11b3)
;; (defconstant +kernel-private-mem-size+ #x11b4)
;; (defconstant +kernel-global-work-size+ #x11b5)

;;; cl-kernel-sub-group-info
;; (defconstant +kernel-max-sub-group-size-for-ndrange+ #x2033)
;; (defconstant +kernel-sub-group-count-for-ndrange+ #x2034)
;; (defconstant +kernel-local-size-for-sub-group-count+ #x11b8)
;; (defconstant +kernel-max-num-sub-groups+ #x11b9)
;; (defconstant +kernel-compile-num-sub-groups+ #x11ba)

;;; cl-kernel-exec-info
;; (defconstant +kernel-exec-info-svm-ptrs+ #x11b6)
;; (defconstant +kernel-exec-info-svm-fine-grain-system+ #x11b7)

;;; cl-event-info
;; (defconstant +event-command-queue+ #x11d0)
;; (defconstant +event-command-type+ #x11d1)
;; (defconstant +event-reference-count+ #x11d2)
;; (defconstant +event-command-execution-status+ #x11d3)
;; (defconstant +event-context+ #x11d4)

;;; cl-command-type
;; (defconstant +command-ndrange-kernel+ #x11f0)
;; (defconstant +command-task+ #x11f1)
;; (defconstant +command-native-kernel+ #x11f2)
;; (defconstant +command-read-buffer+ #x11f3)
;; (defconstant +command-write-buffer+ #x11f4)
;; (defconstant +command-copy-buffer+ #x11f5)
;; (defconstant +command-read-image+ #x11f6)
;; (defconstant +command-write-image+ #x11f7)
;; (defconstant +command-copy-image+ #x11f8)
;; (defconstant +command-copy-image-to-buffer+ #x11f9)
;; (defconstant +command-copy-buffer-to-image+ #x11fa)
;; (defconstant +command-map-buffer+ #x11fb)
;; (defconstant +command-map-image+ #x11fc)
;; (defconstant +command-unmap-mem-object+ #x11fd)
;; (defconstant +command-marker+ #x11fe)
;; (defconstant +command-acquire-gl-objects+ #x11ff)
;; (defconstant +command-release-gl-objects+ #x1200)
;; (defconstant +command-read-buffer-rect+ #x1201)
;; (defconstant +command-write-buffer-rect+ #x1202)
;; (defconstant +command-copy-buffer-rect+ #x1203)
;; (defconstant +command-user+ #x1204)
;; (defconstant +command-barrier+ #x1205)
;; (defconstant +command-migrate-mem-objects+ #x1206)
;; (defconstant +command-fill-buffer+ #x1207)
;; (defconstant +command-fill-image+ #x1208)
;; (defconstant +command-svm-free+ #x1209)
;; (defconstant +command-svm-memcpy+ #x120a)
;; (defconstant +command-svm-memfill+ #x120b)
;; (defconstant +command-svm-map+ #x120c)
;; (defconstant +command-svm-unmap+ #x120d)
;; (defconstant +command-svm-migrate-mem+ #x120e)

;;; command execution status
;; (defconstant +complete+ #x0)
;; (defconstant +running+ #x1)
;; (defconstant +submitted+ #x2)
;; (defconstant +queued+ #x3)

;;; cl-buffer-create-type
;;(defconstant +buffer-create-type-region+ #x1220)

;;; cl-profiling-info
;; (defconstant +profiling-command-queued+ #x1280)
;; (defconstant +profiling-command-submit+ #x1281)
;; (defconstant +profiling-command-start+ #x1282)
;; (defconstant +profiling-command-end+ #x1283)
;; (defconstant +profiling-command-complete+ #x1284)

;;; cl-device-atomic-capabilities - bitfield
;; (defconstant +device-atomic-order-relaxed+ #x01)
;; (defconstant +device-atomic-order-acq-rel+ #x02)
;; (defconstant +device-atomic-order-seq-cst+ #x04)
;; (defconstant +device-atomic-scope-work-item+ #x08)
;; (defconstant +device-atomic-scope-work-group+ #x10)
;; (defconstant +device-atomic-scope-device+ #x20)
;; (defconstant +device-atomic-scope-all-devices+ #x40)

;;; cl-device-device-enqueue-capabilities - bitfield
;; (defconstant +device-queue-supported+ #x1)
;; (defconstant +device-queue-replaceable-default+ #x2)

;;; cl-khronos-vendor-id
;; (defconstant +khronos-vendor-id-codeplay+ #x10004)