opencl_ruby_ffi 1.2.2 → 1.3.0

data/lib/opencl_ruby_ffi/opencl_ruby_ffi_base_gen.rb

@@ -18,7 +18,6 @@ module OpenCL
       end
     end
   end
-  #:stopdoc:
   SUCCESS = 0
   DEVICE_NOT_FOUND = -1
   DEVICE_NOT_AVAILABLE = -2
@@ -80,10 +79,12 @@ module OpenCL
   INVALID_DEVICE_PARTITION_COUNT = -68
   INVALID_PIPE_SIZE = -69
   INVALID_DEVICE_QUEUE = -70
+  INVALID_PARTITION_NAME_EXT = -1059
   VERSION_1_0 = 1
   VERSION_1_1 = 1
   VERSION_1_2 = 1
   VERSION_2_0 = 1
+  VERSION_2_1 = 1
   FALSE = 0
   TRUE = 1
   BLOCKING = TRUE
@@ -151,7 +152,6 @@ module OpenCL
   DEVICE_VERSION = 0x102F
   DEVICE_EXTENSIONS = 0x1030
   DEVICE_PLATFORM = 0x1031
-  DEVICE_DOUBLE_FP_CONFIG = 0x1032
   DEVICE_PREFERRED_VECTOR_WIDTH_HALF = 0x1034
   DEVICE_HOST_UNIFIED_MEMORY = 0x1035
   DEVICE_NATIVE_VECTOR_WIDTH_CHAR = 0x1036
@@ -463,34 +463,6 @@ module OpenCL
   GL_TEXTURE_TARGET = 0x2004
   GL_MIPMAP_LEVEL = 0x2005
   GL_NUM_SAMPLES = 0x2012
-  INVALID_GL_SHAREGROUP_REFERENCE_KHR = -1000
-  CURRENT_DEVICE_FOR_GL_CONTEXT_KHR = 0x2006
-  DEVICES_FOR_GL_CONTEXT_KHR = 0x2007
-  GL_CONTEXT_KHR = 0x2008
-  EGL_DISPLAY_KHR = 0x2009
-  GLX_DISPLAY_KHR = 0x200A
-  WGL_HDC_KHR = 0x200B
-  CGL_SHAREGROUP_KHR = 0x200C
-  COMMAND_GL_FENCE_SYNC_OBJECT_KHR = 0x200D
-  COMMAND_EGL_FENCE_SYNC_OBJECT_KHR = 0x202F
-  COMMAND_ACQUIRE_EGL_OBJECTS_KHR = 0x202D
-  COMMAND_RELEASE_EGL_OBJECTS_KHR = 0x202E
-  DEVICE_HALF_FP_CONFIG = 0x1033
-  PLATFORM_ICD_SUFFIX_KHR = 0x0920
-  PLATFORM_NOT_FOUND_KHR = -1001
-  CONTEXT_MEMORY_INITIALIZE_KHR = 0x200E
-  DEVICE_TERMINATE_CAPABILITY_KHR = 0x200F
-  CONTEXT_TERMINATE_KHR = 0x2010
-  DEVICE_SPIR_VERSIONS = 0x40E0
-  PROGRAM_BINARY_TYPE_INTERMEDIATE = 0x40E1
-  DEVICE_COMPUTE_CAPABILITY_MAJOR_NV = 0x4000
-  DEVICE_COMPUTE_CAPABILITY_MINOR_NV = 0x4001
-  DEVICE_REGISTERS_PER_BLOCK_NV = 0x4002
-  DEVICE_WARP_SIZE_NV = 0x4003
-  DEVICE_GPU_OVERLAP_NV = 0x4004
-  DEVICE_KERNEL_EXEC_TIMEOUT_NV = 0x4005
-  DEVICE_INTEGRATED_MEMORY_NV = 0x4006
-  DEVICE_PROFILING_TIMER_OFFSET_AMD = 0x4036
   PRINTF_CALLBACK_ARM = 0x40B0
   PRINTF_BUFFERSIZE_ARM = 0x40B1
   DEVICE_PAGE_SIZE_QCOM = 0x40A1
@@ -501,24 +473,7 @@ module OpenCL
   MEM_HOST_WRITETHROUGH_QCOM = 0x40A6
   MEM_HOST_WRITE_COMBINING_QCOM = 0x40A7
   MEM_ION_HOST_PTR_QCOM = 0x40A8
-  KERNEL_MAX_SUB_GROUP_SIZE_FOR_NDRANGE_KHR = 0x2033
-  KERNEL_SUB_GROUP_COUNT_FOR_NDRANGE_KHR = 0x2034
-  QUEUE_PRIORITY_KHR = 0x1096
-  QUEUE_PRIORITY_HIGH_KHR = (1<<0)
-  QUEUE_PRIORITY_MED_KHR = (1<<1)
-  QUEUE_PRIORITY_LOW_KHR = (1<<2)
-  QUEUE_THROTTLE_KHR = 0x1097
-  QUEUE_THROTTLE_HIGH_KHR = (1<<0)
-  QUEUE_THROTTLE_MED_KHR = (1<<1)
-  QUEUE_THROTTLE_LOW_KHR = (1<<2)
-  COMMAND_ACQUIRE_DX9_MEDIA_SURFACES_KHR = 0x202B
-  COMMAND_RELEASE_DX9_MEDIA_SURFACES_KHR = 0x202C
-  COMMAND_ACQUIRE_D3D10_OBJECTS_KHR = 0x4017
-  COMMAND_RELEASE_D3D10_OBJECTS_KHR = 0x4018
-  COMMAND_ACQUIRE_D3D11_OBJECTS_KHR = 0x4020
-  COMMAND_RELEASE_D3D11_OBJECTS_KHR = 0x4021
-  #:startdoc:
-  # Parent claas to map OpenCL errors, and is used to raise unknown errors
+  # Parent class to map OpenCL errors, and is used to raise unknown errors
   class Error < StandardError
     attr_reader :code
 
@@ -527,9 +482,7 @@ module OpenCL
       super("#{code}")
     end
 
-    #:stopdoc:
     CLASSES = {}
-    #:startdoc:
 
     private_constant :CLASSES
 
@@ -552,1768 +505,99 @@ module OpenCL
       return "#{@code}"
     end
 
-    # Represents the OpenCL CL_INVALID_PARTITION_NAME_EXT error
-    class INVALID_PARTITION_NAME_EXT
+    def self.error_class_constructor( name, capitalized_name )
+      return  <<EOF
+    class #{name} < Error
 
-      # Initilizes code to -1059
       def initialize
-        super(-1059)
+        super(#{OpenCL::const_get(name)})
       end
 
-      # Returns a string representing the name corresponding to the error classe
       def self.name
-        return "INVALID_PARTITION_NAME_EXT"
+        return "#{name}"
       end
 
-      # Returns a string representing the name corresponding to the error
       def name
-        return "INVALID_PARTITION_NAME_EXT"
+        return "#{name}"
       end
 
       def self.code
-        return -1059
-      end
-
-    end
-
-    CLASSES[-1059] = INVALID_PARTITION_NAME_EXT
-    InvalidPartitionNameExt = INVALID_PARTITION_NAME_EXT
-
-    # Represents the OpenCL CL_PLATFORM_NOT_FOUND_KHR error
-    class PLATFORM_NOT_FOUND_KHR < Error
-
-      # Initilizes code to -1001
-      def initialize
-        super(-1001)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "PLATFORM_NOT_FOUND_KHR"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "PLATFORM_NOT_FOUND_KHR"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -1001
-      end
-
-    end
-
-    CLASSES[-1001] = PLATFORM_NOT_FOUND_KHR
-    PlatformNotFoundKHR = PLATFORM_NOT_FOUND_KHR
-
-    # Represents the OpenCL CL_INVALID_GL_SHAREGROUP_REFERENCE_KHR error
-    class INVALID_GL_SHAREGROUP_REFERENCE_KHR < Error
-
-      # Initilizes code to -1000
-      def initialize
-        super(-1000)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "INVALID_GL_SHAREGROUP_REFERENCE_KHR"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "INVALID_GL_SHAREGROUP_REFERENCE_KHR"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -1000
-      end
-
-    end
-
-    CLASSES[-1000] = INVALID_GL_SHAREGROUP_REFERENCE_KHR
-    InvalidGLSharegroupReferenceKHR = INVALID_GL_SHAREGROUP_REFERENCE_KHR
-
-    # Represents the OpenCL CL_COMPILER_NOT_AVAILABLE error
-    class COMPILER_NOT_AVAILABLE < Error
-
-      # Initilizes code to -3
-      def initialize
-        super(-3)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "COMPILER_NOT_AVAILABLE"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "COMPILER_NOT_AVAILABLE"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -3
-      end
-
-    end
-
-    CLASSES[-3] = COMPILER_NOT_AVAILABLE
-    CompilerNotAvailable = COMPILER_NOT_AVAILABLE
-
-    # Represents the OpenCL CL_DEVICE_NOT_AVAILABLE error
-    class DEVICE_NOT_AVAILABLE < Error
-
-      # Initilizes code to -2
-      def initialize
-        super(-2)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "DEVICE_NOT_AVAILABLE"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "DEVICE_NOT_AVAILABLE"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -2
-      end
-
-    end
-
-    CLASSES[-2] = DEVICE_NOT_AVAILABLE
-    DeviceNotAvailable = DEVICE_NOT_AVAILABLE
-
-    # Represents the OpenCL CL_DEVICE_NOT_FOUND error
-    class DEVICE_NOT_FOUND < Error
-
-      # Initilizes code to -1
-      def initialize
-        super(-1)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "DEVICE_NOT_FOUND"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "DEVICE_NOT_FOUND"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -1
-      end
-
-    end
-
-    CLASSES[-1] = DEVICE_NOT_FOUND
-    DeviceNotFound = DEVICE_NOT_FOUND
-
-    # Represents the OpenCL CL_INVALID_DEVICE_QUEUE error
-    class INVALID_DEVICE_QUEUE < Error
-
-      # Initilizes code to -70
-      def initialize
-        super(-70)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "INVALID_DEVICE_QUEUE"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "INVALID_DEVICE_QUEUE"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -70
-      end
-
-    end
-
-    CLASSES[-70] = INVALID_DEVICE_QUEUE
-    InvalidDeviceQueue = INVALID_DEVICE_QUEUE
-
-    # Represents the OpenCL CL_INVALID_PIPE_SIZE error
-    class INVALID_PIPE_SIZE < Error
-
-      # Initilizes code to -69
-      def initialize
-        super(-69)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "INVALID_PIPE_SIZE"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "INVALID_PIPE_SIZE"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -69
-      end
-
-    end
-
-    CLASSES[-69] = INVALID_PIPE_SIZE
-    InvalidPipeSize = INVALID_PIPE_SIZE
-
-    # Represents the OpenCL CL_INVALID_DEVICE_PARTITION_COUNT error
-    class INVALID_DEVICE_PARTITION_COUNT < Error
-
-      # Initilizes code to -68
-      def initialize
-        super(-68)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "INVALID_DEVICE_PARTITION_COUNT"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "INVALID_DEVICE_PARTITION_COUNT"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -68
-      end
-
-    end
-
-    CLASSES[-68] = INVALID_DEVICE_PARTITION_COUNT
-    InvalidDevicePartitionCount = INVALID_DEVICE_PARTITION_COUNT
-
-    # Represents the OpenCL CL_INVALID_LINKER_OPTIONS error
-    class INVALID_LINKER_OPTIONS < Error
-
-      # Initilizes code to -67
-      def initialize
-        super(-67)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "INVALID_LINKER_OPTIONS"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "INVALID_LINKER_OPTIONS"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -67
-      end
-
-    end
-
-    CLASSES[-67] = INVALID_LINKER_OPTIONS
-    InvalidLinkerOptions = INVALID_LINKER_OPTIONS
-
-    # Represents the OpenCL CL_INVALID_COMPILER_OPTIONS error
-    class INVALID_COMPILER_OPTIONS < Error
-
-      # Initilizes code to -66
-      def initialize
-        super(-66)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "INVALID_COMPILER_OPTIONS"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "INVALID_COMPILER_OPTIONS"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -66
-      end
-
-    end
-
-    CLASSES[-66] = INVALID_COMPILER_OPTIONS
-    InvalidCompilerOptions = INVALID_COMPILER_OPTIONS
-
-    # Represents the OpenCL CL_INVALID_IMAGE_DESCRIPTOR error
-    class INVALID_IMAGE_DESCRIPTOR < Error
-
-      # Initilizes code to -65
-      def initialize
-        super(-65)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "INVALID_IMAGE_DESCRIPTOR"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "INVALID_IMAGE_DESCRIPTOR"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -65
-      end
-
-    end
-
-    CLASSES[-65] = INVALID_IMAGE_DESCRIPTOR
-    InvalidImageDescriptor = INVALID_IMAGE_DESCRIPTOR
-
-    # Represents the OpenCL CL_INVALID_PROPERTY error
-    class INVALID_PROPERTY < Error
-
-      # Initilizes code to -64
-      def initialize
-        super(-64)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "INVALID_PROPERTY"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "INVALID_PROPERTY"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -64
-      end
-
-    end
-
-    CLASSES[-64] = INVALID_PROPERTY
-    InvalidProperty = INVALID_PROPERTY
-
-    # Represents the OpenCL CL_INVALID_GLOBAL_WORK_SIZE error
-    class INVALID_GLOBAL_WORK_SIZE < Error
-
-      # Initilizes code to -63
-      def initialize
-        super(-63)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "INVALID_GLOBAL_WORK_SIZE"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "INVALID_GLOBAL_WORK_SIZE"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -63
-      end
-
-    end
-
-    CLASSES[-63] = INVALID_GLOBAL_WORK_SIZE
-    InvalidGLOBALWorkSize = INVALID_GLOBAL_WORK_SIZE
-
-    # Represents the OpenCL CL_INVALID_MIP_LEVEL error
-    class INVALID_MIP_LEVEL < Error
-
-      # Initilizes code to -62
-      def initialize
-        super(-62)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "INVALID_MIP_LEVEL"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "INVALID_MIP_LEVEL"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -62
-      end
-
-    end
-
-    CLASSES[-62] = INVALID_MIP_LEVEL
-    InvalidMipLevel = INVALID_MIP_LEVEL
-
-    # Represents the OpenCL CL_INVALID_BUFFER_SIZE error
-    class INVALID_BUFFER_SIZE < Error
-
-      # Initilizes code to -61
-      def initialize
-        super(-61)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "INVALID_BUFFER_SIZE"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "INVALID_BUFFER_SIZE"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -61
-      end
-
-    end
-
-    CLASSES[-61] = INVALID_BUFFER_SIZE
-    InvalidBufferSize = INVALID_BUFFER_SIZE
-
-    # Represents the OpenCL CL_INVALID_GL_OBJECT error
-    class INVALID_GL_OBJECT < Error
-
-      # Initilizes code to -60
-      def initialize
-        super(-60)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "INVALID_GL_OBJECT"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "INVALID_GL_OBJECT"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -60
-      end
-
-    end
-
-    CLASSES[-60] = INVALID_GL_OBJECT
-    InvalidGLObject = INVALID_GL_OBJECT
-
-    # Represents the OpenCL CL_INVALID_OPERATION error
-    class INVALID_OPERATION < Error
-
-      # Initilizes code to -59
-      def initialize
-        super(-59)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "INVALID_OPERATION"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "INVALID_OPERATION"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -59
-      end
-
-    end
-
-    CLASSES[-59] = INVALID_OPERATION
-    InvalidOperation = INVALID_OPERATION
-
-    # Represents the OpenCL CL_INVALID_EVENT error
-    class INVALID_EVENT < Error
-
-      # Initilizes code to -58
-      def initialize
-        super(-58)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "INVALID_EVENT"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "INVALID_EVENT"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -58
-      end
-
-    end
-
-    CLASSES[-58] = INVALID_EVENT
-    InvalidEvent = INVALID_EVENT
-
-    # Represents the OpenCL CL_INVALID_EVENT_WAIT_LIST error
-    class INVALID_EVENT_WAIT_LIST < Error
-
-      # Initilizes code to -57
-      def initialize
-        super(-57)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "INVALID_EVENT_WAIT_LIST"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "INVALID_EVENT_WAIT_LIST"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -57
-      end
-
-    end
-
-    CLASSES[-57] = INVALID_EVENT_WAIT_LIST
-    InvalidEventWaitList = INVALID_EVENT_WAIT_LIST
-
-    # Represents the OpenCL CL_INVALID_GLOBAL_OFFSET error
-    class INVALID_GLOBAL_OFFSET < Error
-
-      # Initilizes code to -56
-      def initialize
-        super(-56)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "INVALID_GLOBAL_OFFSET"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "INVALID_GLOBAL_OFFSET"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -56
-      end
-
-    end
-
-    CLASSES[-56] = INVALID_GLOBAL_OFFSET
-    InvalidGLOBALOffset = INVALID_GLOBAL_OFFSET
-
-    # Represents the OpenCL CL_INVALID_WORK_ITEM_SIZE error
-    class INVALID_WORK_ITEM_SIZE < Error
-
-      # Initilizes code to -55
-      def initialize
-        super(-55)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "INVALID_WORK_ITEM_SIZE"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "INVALID_WORK_ITEM_SIZE"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -55
-      end
-
-    end
-
-    CLASSES[-55] = INVALID_WORK_ITEM_SIZE
-    InvalidWorkItemSize = INVALID_WORK_ITEM_SIZE
-
-    # Represents the OpenCL CL_INVALID_WORK_GROUP_SIZE error
-    class INVALID_WORK_GROUP_SIZE < Error
-
-      # Initilizes code to -54
-      def initialize
-        super(-54)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "INVALID_WORK_GROUP_SIZE"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "INVALID_WORK_GROUP_SIZE"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -54
-      end
-
-    end
-
-    CLASSES[-54] = INVALID_WORK_GROUP_SIZE
-    InvalidWorkGroupSize = INVALID_WORK_GROUP_SIZE
-
-    # Represents the OpenCL CL_INVALID_WORK_DIMENSION error
-    class INVALID_WORK_DIMENSION < Error
-
-      # Initilizes code to -53
-      def initialize
-        super(-53)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "INVALID_WORK_DIMENSION"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "INVALID_WORK_DIMENSION"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -53
-      end
-
-    end
-
-    CLASSES[-53] = INVALID_WORK_DIMENSION
-    InvalidWorkDimension = INVALID_WORK_DIMENSION
-
-    # Represents the OpenCL CL_INVALID_KERNEL_ARGS error
-    class INVALID_KERNEL_ARGS < Error
-
-      # Initilizes code to -52
-      def initialize
-        super(-52)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "INVALID_KERNEL_ARGS"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "INVALID_KERNEL_ARGS"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -52
-      end
-
-    end
-
-    CLASSES[-52] = INVALID_KERNEL_ARGS
-    InvalidKernelArgs = INVALID_KERNEL_ARGS
-
-    # Represents the OpenCL CL_INVALID_ARG_SIZE error
-    class INVALID_ARG_SIZE < Error
-
-      # Initilizes code to -51
-      def initialize
-        super(-51)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "INVALID_ARG_SIZE"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "INVALID_ARG_SIZE"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -51
-      end
-
-    end
-
-    CLASSES[-51] = INVALID_ARG_SIZE
-    InvalidArgSize = INVALID_ARG_SIZE
-
-    # Represents the OpenCL CL_INVALID_ARG_VALUE error
-    class INVALID_ARG_VALUE < Error
-
-      # Initilizes code to -50
-      def initialize
-        super(-50)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "INVALID_ARG_VALUE"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "INVALID_ARG_VALUE"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -50
-      end
-
-    end
-
-    CLASSES[-50] = INVALID_ARG_VALUE
-    InvalidArgValue = INVALID_ARG_VALUE
-
-    # Represents the OpenCL CL_INVALID_ARG_INDEX error
-    class INVALID_ARG_INDEX < Error
-
-      # Initilizes code to -49
-      def initialize
-        super(-49)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "INVALID_ARG_INDEX"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "INVALID_ARG_INDEX"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -49
-      end
-
-    end
-
-    CLASSES[-49] = INVALID_ARG_INDEX
-    InvalidArgIndex = INVALID_ARG_INDEX
-
-    # Represents the OpenCL CL_INVALID_KERNEL error
-    class INVALID_KERNEL < Error
-
-      # Initilizes code to -48
-      def initialize
-        super(-48)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "INVALID_KERNEL"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "INVALID_KERNEL"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -48
-      end
-
-    end
-
-    CLASSES[-48] = INVALID_KERNEL
-    InvalidKernel = INVALID_KERNEL
-
-    # Represents the OpenCL CL_INVALID_KERNEL_DEFINITION error
-    class INVALID_KERNEL_DEFINITION < Error
-
-      # Initilizes code to -47
-      def initialize
-        super(-47)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "INVALID_KERNEL_DEFINITION"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "INVALID_KERNEL_DEFINITION"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -47
-      end
-
-    end
-
-    CLASSES[-47] = INVALID_KERNEL_DEFINITION
-    InvalidKernelDefinition = INVALID_KERNEL_DEFINITION
-
-    # Represents the OpenCL CL_INVALID_KERNEL_NAME error
-    class INVALID_KERNEL_NAME < Error
-
-      # Initilizes code to -46
-      def initialize
-        super(-46)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "INVALID_KERNEL_NAME"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "INVALID_KERNEL_NAME"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -46
-      end
-
-    end
-
-    CLASSES[-46] = INVALID_KERNEL_NAME
-    InvalidKernelName = INVALID_KERNEL_NAME
-
-    # Represents the OpenCL CL_INVALID_PROGRAM_EXECUTABLE error
-    class INVALID_PROGRAM_EXECUTABLE < Error
-
-      # Initilizes code to -45
-      def initialize
-        super(-45)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "INVALID_PROGRAM_EXECUTABLE"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "INVALID_PROGRAM_EXECUTABLE"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -45
-      end
-
-    end
-
-    CLASSES[-45] = INVALID_PROGRAM_EXECUTABLE
-    InvalidProgramExecutable = INVALID_PROGRAM_EXECUTABLE
-
-    # Represents the OpenCL CL_INVALID_PROGRAM error
-    class INVALID_PROGRAM < Error
-
-      # Initilizes code to -44
-      def initialize
-        super(-44)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "INVALID_PROGRAM"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "INVALID_PROGRAM"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -44
-      end
-
-    end
-
-    CLASSES[-44] = INVALID_PROGRAM
-    InvalidProgram = INVALID_PROGRAM
-
-    # Represents the OpenCL CL_INVALID_BUILD_OPTIONS error
-    class INVALID_BUILD_OPTIONS < Error
-
-      # Initilizes code to -43
-      def initialize
-        super(-43)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "INVALID_BUILD_OPTIONS"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "INVALID_BUILD_OPTIONS"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -43
-      end
-
-    end
-
-    CLASSES[-43] = INVALID_BUILD_OPTIONS
-    InvalidBuildOptions = INVALID_BUILD_OPTIONS
-
-    # Represents the OpenCL CL_INVALID_BINARY error
-    class INVALID_BINARY < Error
-
-      # Initilizes code to -42
-      def initialize
-        super(-42)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "INVALID_BINARY"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "INVALID_BINARY"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -42
-      end
-
-    end
-
-    CLASSES[-42] = INVALID_BINARY
-    InvalidBinary = INVALID_BINARY
-
-    # Represents the OpenCL CL_INVALID_SAMPLER error
-    class INVALID_SAMPLER < Error
-
-      # Initilizes code to -41
-      def initialize
-        super(-41)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "INVALID_SAMPLER"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "INVALID_SAMPLER"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -41
-      end
-
-    end
-
-    CLASSES[-41] = INVALID_SAMPLER
-    InvalidSampler = INVALID_SAMPLER
-
-    # Represents the OpenCL CL_INVALID_IMAGE_SIZE error
-    class INVALID_IMAGE_SIZE < Error
-
-      # Initilizes code to -40
-      def initialize
-        super(-40)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "INVALID_IMAGE_SIZE"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "INVALID_IMAGE_SIZE"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -40
-      end
-
-    end
-
-    CLASSES[-40] = INVALID_IMAGE_SIZE
-    InvalidImageSize = INVALID_IMAGE_SIZE
-
-    # Represents the OpenCL CL_INVALID_IMAGE_FORMAT_DESCRIPTOR error
-    class INVALID_IMAGE_FORMAT_DESCRIPTOR < Error
-
-      # Initilizes code to -39
-      def initialize
-        super(-39)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "INVALID_IMAGE_FORMAT_DESCRIPTOR"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "INVALID_IMAGE_FORMAT_DESCRIPTOR"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -39
-      end
-
-    end
-
-    CLASSES[-39] = INVALID_IMAGE_FORMAT_DESCRIPTOR
-    InvalidImageFormatDescriptor = INVALID_IMAGE_FORMAT_DESCRIPTOR
-
-    # Represents the OpenCL CL_INVALID_MEM_OBJECT error
-    class INVALID_MEM_OBJECT < Error
-
-      # Initilizes code to -38
-      def initialize
-        super(-38)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "INVALID_MEM_OBJECT"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "INVALID_MEM_OBJECT"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -38
-      end
-
-    end
-
-    CLASSES[-38] = INVALID_MEM_OBJECT
-    InvalidMemObject = INVALID_MEM_OBJECT
-
-    # Represents the OpenCL CL_INVALID_HOST_PTR error
-    class INVALID_HOST_PTR < Error
-
-      # Initilizes code to -37
-      def initialize
-        super(-37)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "INVALID_HOST_PTR"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "INVALID_HOST_PTR"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -37
-      end
-
-    end
-
-    CLASSES[-37] = INVALID_HOST_PTR
-    InvalidHostPtr = INVALID_HOST_PTR
-
-    # Represents the OpenCL CL_INVALID_COMMAND_QUEUE error
-    class INVALID_COMMAND_QUEUE < Error
-
-      # Initilizes code to -36
-      def initialize
-        super(-36)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "INVALID_COMMAND_QUEUE"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "INVALID_COMMAND_QUEUE"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -36
-      end
-
-    end
-
-    CLASSES[-36] = INVALID_COMMAND_QUEUE
-    InvalidCommandQueue = INVALID_COMMAND_QUEUE
-
-    # Represents the OpenCL CL_INVALID_QUEUE_PROPERTIES error
-    class INVALID_QUEUE_PROPERTIES < Error
-
-      # Initilizes code to -35
-      def initialize
-        super(-35)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "INVALID_QUEUE_PROPERTIES"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "INVALID_QUEUE_PROPERTIES"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -35
-      end
-
-    end
-
-    CLASSES[-35] = INVALID_QUEUE_PROPERTIES
-    InvalidQueueProperties = INVALID_QUEUE_PROPERTIES
-
-    # Represents the OpenCL CL_INVALID_CONTEXT error
-    class INVALID_CONTEXT < Error
-
-      # Initilizes code to -34
-      def initialize
-        super(-34)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "INVALID_CONTEXT"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "INVALID_CONTEXT"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -34
-      end
-
-    end
-
-    CLASSES[-34] = INVALID_CONTEXT
-    InvalidContext = INVALID_CONTEXT
-
-    # Represents the OpenCL CL_INVALID_DEVICE error
-    class INVALID_DEVICE < Error
-
-      # Initilizes code to -33
-      def initialize
-        super(-33)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "INVALID_DEVICE"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "INVALID_DEVICE"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -33
-      end
-
-    end
-
-    CLASSES[-33] = INVALID_DEVICE
-    InvalidDevice = INVALID_DEVICE
-
-    # Represents the OpenCL CL_INVALID_PLATFORM error
-    class INVALID_PLATFORM < Error
-
-      # Initilizes code to -32
-      def initialize
-        super(-32)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "INVALID_PLATFORM"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "INVALID_PLATFORM"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -32
-      end
-
-    end
-
-    CLASSES[-32] = INVALID_PLATFORM
-    InvalidPlatform = INVALID_PLATFORM
-
-    # Represents the OpenCL CL_INVALID_DEVICE_TYPE error
-    class INVALID_DEVICE_TYPE < Error
-
-      # Initilizes code to -31
-      def initialize
-        super(-31)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "INVALID_DEVICE_TYPE"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "INVALID_DEVICE_TYPE"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -31
-      end
-
-    end
-
-    CLASSES[-31] = INVALID_DEVICE_TYPE
-    InvalidDeviceType = INVALID_DEVICE_TYPE
-
-    # Represents the OpenCL CL_INVALID_VALUE error
-    class INVALID_VALUE < Error
-
-      # Initilizes code to -30
-      def initialize
-        super(-30)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "INVALID_VALUE"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "INVALID_VALUE"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -30
-      end
-
-    end
-
-    CLASSES[-30] = INVALID_VALUE
-    InvalidValue = INVALID_VALUE
-
-    # Represents the OpenCL CL_KERNEL_ARG_INFO_NOT_AVAILABLE error
-    class KERNEL_ARG_INFO_NOT_AVAILABLE < Error
-
-      # Initilizes code to -19
-      def initialize
-        super(-19)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "KERNEL_ARG_INFO_NOT_AVAILABLE"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "KERNEL_ARG_INFO_NOT_AVAILABLE"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -19
-      end
-
-    end
-
-    CLASSES[-19] = KERNEL_ARG_INFO_NOT_AVAILABLE
-    KernelArgInfoNotAvailable = KERNEL_ARG_INFO_NOT_AVAILABLE
-
-    # Represents the OpenCL CL_DEVICE_PARTITION_FAILED error
-    class DEVICE_PARTITION_FAILED < Error
-
-      # Initilizes code to -18
-      def initialize
-        super(-18)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "DEVICE_PARTITION_FAILED"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "DEVICE_PARTITION_FAILED"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -18
-      end
-
-    end
-
-    CLASSES[-18] = DEVICE_PARTITION_FAILED
-    DevicePartitionFailed = DEVICE_PARTITION_FAILED
-
-    # Represents the OpenCL CL_LINK_PROGRAM_FAILURE error
-    class LINK_PROGRAM_FAILURE < Error
-
-      # Initilizes code to -17
-      def initialize
-        super(-17)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "LINK_PROGRAM_FAILURE"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "LINK_PROGRAM_FAILURE"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -17
-      end
-
-    end
-
-    CLASSES[-17] = LINK_PROGRAM_FAILURE
-    LinkProgramFailure = LINK_PROGRAM_FAILURE
-
-    # Represents the OpenCL CL_LINKER_NOT_AVAILABLE error
-    class LINKER_NOT_AVAILABLE < Error
-
-      # Initilizes code to -16
-      def initialize
-        super(-16)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "LINKER_NOT_AVAILABLE"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "LINKER_NOT_AVAILABLE"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -16
-      end
-
-    end
-
-    CLASSES[-16] = LINKER_NOT_AVAILABLE
-    LinkerNotAvailable = LINKER_NOT_AVAILABLE
-
-    # Represents the OpenCL CL_COMPILE_PROGRAM_FAILURE error
-    class COMPILE_PROGRAM_FAILURE < Error
-
-      # Initilizes code to -15
-      def initialize
-        super(-15)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "COMPILE_PROGRAM_FAILURE"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "COMPILE_PROGRAM_FAILURE"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -15
-      end
+        return #{OpenCL::const_get(name)}
+      end
+
+    end
+
+    CLASSES[#{OpenCL::const_get(name)}] = #{name}
+    #{capitalized_name} = #{name}
+EOF
+    end
+
+    [
+      [:DEVICE_NOT_FOUND,                          :DeviceNotFound],
+      [:DEVICE_NOT_AVAILABLE,                      :DeviceNotAvailable],
+      [:COMPILER_NOT_AVAILABLE,                    :CompilerNotAvailable],
+      [:MEM_OBJECT_ALLOCATION_FAILURE,             :MemObjectAllocationFailure],
+      [:OUT_OF_RESOURCES,                          :OutOfResources],
+      [:OUT_OF_HOST_MEMORY,                        :OutOfHostMemory],
+      [:PROFILING_INFO_NOT_AVAILABLE,              :ProfilingInfoNotAvailable],
+      [:MEM_COPY_OVERLAP,                          :MemCopyOverlap],
+      [:IMAGE_FORMAT_MISMATCH,                     :ImageFormatMismatch],
+      [:IMAGE_FORMAT_NOT_SUPPORTED,                :ImageFormatNotSupported],
+      [:BUILD_PROGRAM_FAILURE,                     :BuildProgramFailure],
+      [:MAP_FAILURE,                               :MapFailure],
+      [:MISALIGNED_SUB_BUFFER_OFFSET,              :MisalignedSubBufferOffset],
+      [:EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST, :ExecStatusErrorForEventsInWaitList],
+      [:COMPILE_PROGRAM_FAILURE,                   :CompileProgramFailure],
+      [:LINKER_NOT_AVAILABLE,                      :LinkerNotAvailable],
+      [:LINK_PROGRAM_FAILURE,                      :LinkProgramFailure],
+      [:DEVICE_PARTITION_FAILED,                   :DevicePartitionFailed],
+      [:KERNEL_ARG_INFO_NOT_AVAILABLE,             :KernelArgInfoNotAvailable],
+      [:INVALID_VALUE,                             :InvalidValue],
+      [:INVALID_DEVICE_TYPE,                       :InvalidDeviceType],
+      [:INVALID_PLATFORM,                          :InvalidPlatform],
+      [:INVALID_DEVICE,                            :InvalidDevice],
+      [:INVALID_CONTEXT,                           :InvalidContext],
+      [:INVALID_QUEUE_PROPERTIES,                  :InvalidQueueProperties],
+      [:INVALID_COMMAND_QUEUE,                     :InvalidCommandQueue],
+      [:INVALID_HOST_PTR,                          :InvalidHostPtr],
+      [:INVALID_MEM_OBJECT,                        :InvalidMemObject],
+      [:INVALID_IMAGE_FORMAT_DESCRIPTOR,           :InvalidImageFormatDescriptor],
+      [:INVALID_IMAGE_SIZE,                        :InvalidImageSize],
+      [:INVALID_SAMPLER,                           :InvalidSampler],
+      [:INVALID_BINARY,                            :InvalidBinary],
+      [:INVALID_BUILD_OPTIONS,                     :InvalidBuildOptions],
+      [:INVALID_PROGRAM,                           :InvalidProgram],
+      [:INVALID_PROGRAM_EXECUTABLE,                :InvalidProgramExecutable],
+      [:INVALID_KERNEL_NAME,                       :InvalidKernelName],
+      [:INVALID_KERNEL_DEFINITION,                 :InvalidKernelDefinition],
+      [:INVALID_KERNEL,                            :InvalidKernel],
+      [:INVALID_ARG_INDEX,                         :InvalidArgIndex],
+      [:INVALID_ARG_VALUE,                         :InvalidArgValue],
+      [:INVALID_ARG_SIZE,                          :InvalidArgSize],
+      [:INVALID_KERNEL_ARGS,                       :InvalidKernelArgs],
+      [:INVALID_WORK_DIMENSION,                    :InvalidWorkDimension],
+      [:INVALID_WORK_GROUP_SIZE,                   :InvalidWorkGroupSize],
+      [:INVALID_WORK_ITEM_SIZE,                    :InvalidWorkItemSize],
+      [:INVALID_GLOBAL_OFFSET,                     :InvalidGlobalOffset],
+      [:INVALID_EVENT_WAIT_LIST,                   :InvalidEventWaitList],
+      [:INVALID_EVENT,                             :InvalidEvent],
+      [:INVALID_OPERATION,                         :InvalidOperation],
+      [:INVALID_GL_OBJECT,                         :InvalidGLObject],
+      [:INVALID_BUFFER_SIZE,                       :InvalidBufferSize],
+      [:INVALID_MIP_LEVEL,                         :InvalidMipLevel],
+      [:INVALID_GLOBAL_WORK_SIZE,                  :InvalidGlobalWorkSize],
+      [:INVALID_PROPERTY,                          :InvalidProperty],
+      [:INVALID_IMAGE_DESCRIPTOR,                  :InvalidImageDescriptor],
+      [:INVALID_COMPILER_OPTIONS,                  :InvalidCompilerOptions],
+      [:INVALID_LINKER_OPTIONS,                    :InvalidLinkerOptions],
+      [:INVALID_DEVICE_PARTITION_COUNT,            :InvalidDevicePartitionCount],
+      [:INVALID_PIPE_SIZE,                         :InvalidPipeSize],
+      [:INVALID_DEVICE_QUEUE,                      :InvalidDeviceQueue],
+      [:INVALID_PARTITION_NAME_EXT,                :InvalidPartitionNameEXT]
+    ].each { |name, capitalized_name|
+      eval error_class_constructor( name, capitalized_name )
+    }
 
-    end
-
-    CLASSES[-15] = COMPILE_PROGRAM_FAILURE
-    CompileProgramFailure = COMPILE_PROGRAM_FAILURE
-
-    # Represents the OpenCL CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST error
-    class EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST < Error
-
-      # Initilizes code to -14
-      def initialize
-        super(-14)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -14
-      end
-
-    end
-
-    CLASSES[-14] = EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST
-    ExecStatusErrorForEventsInWaitList = EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST
-
-    # Represents the OpenCL CL_MISALIGNED_SUB_BUFFER_OFFSET error
-    class MISALIGNED_SUB_BUFFER_OFFSET < Error
-
-      # Initilizes code to -13
-      def initialize
-        super(-13)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "MISALIGNED_SUB_BUFFER_OFFSET"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "MISALIGNED_SUB_BUFFER_OFFSET"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -13
-      end
-
-    end
-
-    CLASSES[-13] = MISALIGNED_SUB_BUFFER_OFFSET
-    MisalignedSubBufferOffset = MISALIGNED_SUB_BUFFER_OFFSET
-
-    # Represents the OpenCL CL_MAP_FAILURE error
-    class MAP_FAILURE < Error
-
-      # Initilizes code to -12
-      def initialize
-        super(-12)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "MAP_FAILURE"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "MAP_FAILURE"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -12
-      end
-
-    end
-
-    CLASSES[-12] = MAP_FAILURE
-    MapFailure = MAP_FAILURE
-
-    # Represents the OpenCL CL_BUILD_PROGRAM_FAILURE error
-    class BUILD_PROGRAM_FAILURE < Error
-
-      # Initilizes code to -11
-      def initialize
-        super(-11)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "BUILD_PROGRAM_FAILURE"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "BUILD_PROGRAM_FAILURE"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -11
-      end
-
-    end
-
-    CLASSES[-11] = BUILD_PROGRAM_FAILURE
-    BuildProgramFailure = BUILD_PROGRAM_FAILURE
-
-    # Represents the OpenCL CL_IMAGE_FORMAT_NOT_SUPPORTED error
-    class IMAGE_FORMAT_NOT_SUPPORTED < Error
-
-      # Initilizes code to -10
-      def initialize
-        super(-10)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "IMAGE_FORMAT_NOT_SUPPORTED"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "IMAGE_FORMAT_NOT_SUPPORTED"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -10
-      end
-
-    end
-
-    CLASSES[-10] = IMAGE_FORMAT_NOT_SUPPORTED
-    ImageFormatNotSupported = IMAGE_FORMAT_NOT_SUPPORTED
-
-    # Represents the OpenCL CL_IMAGE_FORMAT_MISMATCH error
-    class IMAGE_FORMAT_MISMATCH < Error
-
-      # Initilizes code to -9
-      def initialize
-        super(-9)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "IMAGE_FORMAT_MISMATCH"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "IMAGE_FORMAT_MISMATCH"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -9
-      end
-
-    end
-
-    CLASSES[-9] = IMAGE_FORMAT_MISMATCH
-    ImageFormatMismatch = IMAGE_FORMAT_MISMATCH
-
-    # Represents the OpenCL CL_MEM_COPY_OVERLAP error
-    class MEM_COPY_OVERLAP < Error
-
-      # Initilizes code to -8
-      def initialize
-        super(-8)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "MEM_COPY_OVERLAP"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "MEM_COPY_OVERLAP"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -8
-      end
-
-    end
-
-    CLASSES[-8] = MEM_COPY_OVERLAP
-    MemCopyOverlap = MEM_COPY_OVERLAP
-
-    # Represents the OpenCL CL_PROFILING_INFO_NOT_AVAILABLE error
-    class PROFILING_INFO_NOT_AVAILABLE < Error
-
-      # Initilizes code to -7
-      def initialize
-        super(-7)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "PROFILING_INFO_NOT_AVAILABLE"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "PROFILING_INFO_NOT_AVAILABLE"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -7
-      end
-
-    end
-
-    CLASSES[-7] = PROFILING_INFO_NOT_AVAILABLE
-    ProfilingInfoNotAvailable = PROFILING_INFO_NOT_AVAILABLE
-
-    # Represents the OpenCL CL_OUT_OF_HOST_MEMORY error
-    class OUT_OF_HOST_MEMORY < Error
-
-      # Initilizes code to -6
-      def initialize
-        super(-6)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "OUT_OF_HOST_MEMORY"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "OUT_OF_HOST_MEMORY"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -6
-      end
-
-    end
-
-    CLASSES[-6] = OUT_OF_HOST_MEMORY
-    OutOfHostMemory = OUT_OF_HOST_MEMORY
-
-    # Represents the OpenCL CL_OUT_OF_RESOURCES error
-    class OUT_OF_RESOURCES < Error
-
-      # Initilizes code to -5
-      def initialize
-        super(-5)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "OUT_OF_RESOURCES"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "OUT_OF_RESOURCES"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -5
-      end
-
-    end
-
-    CLASSES[-5] = OUT_OF_RESOURCES
-    OutOfResources = OUT_OF_RESOURCES
-
-    # Represents the OpenCL CL_MEM_OBJECT_ALLOCATION_FAILURE error
-    class MEM_OBJECT_ALLOCATION_FAILURE < Error
-
-      # Initilizes code to -4
-      def initialize
-        super(-4)
-      end
-
-      # Returns a string representing the name corresponding to the error classe
-      def self.name
-        return "MEM_OBJECT_ALLOCATION_FAILURE"
-      end
-
-      # Returns a string representing the name corresponding to the error
-      def name
-        return "MEM_OBJECT_ALLOCATION_FAILURE"
-      end
-
-      # Returns the code corresponding to this error class
-      def self.code
-        return -4
-      end
-
-    end
-
-    CLASSES[-4] = MEM_OBJECT_ALLOCATION_FAILURE
-    MemObjectAllocationFailure = MEM_OBJECT_ALLOCATION_FAILURE
   end
 
   # A parent class to represent OpenCL enums that use :cl_uint
@@ -2379,28 +663,6 @@ module OpenCL
       return @val
     end
 
-#    #:stopdoc:
-#    def self.to_native(value, context)
-#      if value then
-#        return value.flags
-#      else
-#        return 0
-#      end
-#    end
-#
-#    def self.from_native(value, context)
-#      new(value)
-#    end
-#
-#    def self.size
-#      find_type(:cl_uint).size
-#    end
-#
-#    def self.reference_required?
-#      return false
-#    end
-#    #:startdoc:
-
   end
 
   # A parent class to represent enums that use cl_int
@@ -2476,39 +738,56 @@ module OpenCL
       @val = val
     end
 
-#    #:stopdoc:
-#    def self.to_native(value, context)
-#      if value then
-#        return value.flags
-#      else
-#        return 0
-#      end
-#    end
-#
-#    def self.from_native(value, context)
-#      new(value)
-#    end
-#
-#    def self.size
-#      find_type(:cl_bitfield).size
-#    end
-#
-#    def self.reference_required?
-#      return false
-#    end
-#    #:startdoc:
+  end
+
+  class ExtendedStruct < ManagedStruct
+
+    FORCE_EXTENSIONS_LOADING = ENV['DYNAMIC_EXTENSIONS'] ? false : true
+    private_constant :FORCE_EXTENSIONS_LOADING
+
+    if FORCE_EXTENSIONS_LOADING then
+
+      # @!macro [attach] register_extension
+      #   @!parse include $2
+      #   @private
+      def self.register_extension(name, mod, cond)
+        self.send(:include, mod)
+      end
+
+    else
+
+      def initialize(*args)
+        super
+        self.class.ancestors.each { |klass|
+          klass.const_get(:Extensions).each { |name, ext|
+            extend ext[0] if eval(ext[1])
+          } if klass.const_defined?(:Extensions)
+        }
+      end
+
+      def self.inherited(klass)
+        klass.const_set(:Extensions, {})
+      end
+
+      # @!macro [attach] register_extension
+      #   @!parse include $2
+      #   @private
+      def self.register_extension(name, mod, cond)
+        self.const_get(:Extensions)[name] = [mod, cond]
+      end
+
+    end
 
   end
-  class Platform < ManagedStruct
+
+  class Platform < ExtendedStruct
     layout :dummy, :pointer
-    #:stopdoc:
     PROFILE = 0x0900
     VERSION = 0x0901
     NAME = 0x0902
     VENDOR = 0x0903
     EXTENSIONS = 0x0904
     HOST_TIMER_RESOLUTION = 0x0905
-    ICD_SUFFIX_KHR = 0x0920
   
     # Creates a new Platform and retains it if specified and aplicable
     def initialize(ptr, retain = true)
@@ -2517,23 +796,14 @@ module OpenCL
     end
   
     # method called at Platform deletion, releases the object if aplicable
+    # @private
     def self.release(ptr)
     end
-    #:startdoc:
-  
-    def to_s
-      if self.respond_to?(:name) then
-        return self.name
-      else
-        return super
-      end
-    end
   
   end
 
-  class Device < ManagedStruct
+  class Device < ExtendedStruct
     layout :dummy, :pointer
-    #:stopdoc:
     TYPE_DEFAULT = (1 << 0)
     TYPE_CPU = (1 << 1)
     TYPE_GPU = (1 << 2)
@@ -2586,11 +856,11 @@ module OpenCL
     QUEUE_ON_HOST_PROPERTIES = 0x102A
     NAME = 0x102B
     VENDOR = 0x102C
+    DRIVER_VERSION = 0x102D
     PROFILE = 0x102E
     VERSION = 0x102F
     EXTENSIONS = 0x1030
     PLATFORM = 0x1031
-    DOUBLE_FP_CONFIG = 0x1032
     PREFERRED_VECTOR_WIDTH_HALF = 0x1034
     HOST_UNIFIED_MEMORY = 0x1035
     NATIVE_VECTOR_WIDTH_CHAR = 0x1036
@@ -2647,49 +917,25 @@ module OpenCL
     SVM_FINE_GRAIN_BUFFER = (1 << 1)
     SVM_FINE_GRAIN_SYSTEM = (1 << 2)
     SVM_ATOMICS = (1 << 3)
-    HALF_FP_CONFIG = 0x1033
-    TERMINATE_CAPABILITY_KHR = 0x200F
-    SPIR_VERSIONS = 0x40E0
-    COMPUTE_CAPABILITY_MAJOR_NV = 0x4000
-    COMPUTE_CAPABILITY_MINOR_NV = 0x4001
-    REGISTERS_PER_BLOCK_NV = 0x4002
-    WARP_SIZE_NV = 0x4003
-    GPU_OVERLAP_NV = 0x4004
-    KERNEL_EXEC_TIMEOUT_NV = 0x4005
-    INTEGRATED_MEMORY_NV = 0x4006
-    PROFILING_TIMER_OFFSET_AMD = 0x4036
     PAGE_SIZE_QCOM = 0x40A1
   
     # Creates a new Device and retains it if specified and aplicable
     def initialize(ptr, retain = true)
       super(ptr)
-      platform = MemoryPointer::new( Platform )
-      OpenCL.clGetDeviceInfo( ptr, OpenCL::Device::PLATFORM, platform.size, platform, nil)
-      p = OpenCL::Platform::new(platform.read_pointer)
-      if p.version_number >= 1.2 and retain then
+      if platform.version_number >= 1.2 and retain then
         error = OpenCL.clRetainDevice(ptr)
         error_check( error )
       end
-      #STDERR.puts "Allocating Device: #{ptr}"
     end
   
     # method called at Device deletion, releases the object if aplicable
+    # @private
     def self.release(ptr)
-      platform = MemoryPointer::new( Platform )
-      OpenCL.clGetDeviceInfo( ptr, OpenCL::Device::PLATFORM, platform.size, platform, nil)
-      p = OpenCL::Platform::new(platform.read_pointer)
-      if p.version_number >= 1.2 then
-        error = OpenCL.clReleaseDevice(ptr)
-        error_check( error )
-      end
-    end
-    #:startdoc:
-  
-    def to_s
-      if self.respond_to?(:name) then
-        return self.name
-      else
-        return super
+      plat = FFI::MemoryPointer::new( Platform )
+      OpenCL.clGetDeviceInfo( ptr, OpenCL::Device::PLATFORM, plat.size, plat, nil)
+      platform = OpenCL::Platform::new(plat.read_pointer)
+      if platform.version_number >= 1.2 then
+        OpenCL.clReleaseDevice(ptr)
       end
     end
   
@@ -2703,14 +949,16 @@ module OpenCL
       BY_COUNTS_LIST_END = 0x0
       BY_AFFINITY_DOMAIN = 0x1088
       BY_NAMES_EXT = 0x4052
+      BY_NAMES_INTEL = 0x4052
       BY_NAMES_LIST_END_EXT = -1
+      BY_NAMES_LIST_END_INTEL = -1
       @codes = {}
       @codes[0x1086] = 'EQUALLY'
       @codes[0x1087] = 'BY_COUNTS'
       @codes[0x0] = 'BY_COUNTS_LIST_END'
       @codes[0x1088] = 'BY_AFFINITY_DOMAIN'
-      @codes[0x4052] = 'BY_NAMES_EXT'
-      @codes[-1] = 'BY_NAMES_LIST_END_EXT'
+      @codes[0x4052] = 'BY_NAMES_INTEL'
+      @codes[-1] = 'BY_NAMES_LIST_END_INTEL'
     end
 
     # Bitfield that maps the :cl_device_type type
@@ -2820,17 +1068,14 @@ module OpenCL
     end
 
   end
-  class Context < ManagedStruct
+  class Context < ExtendedStruct
     layout :dummy, :pointer
-    #:stopdoc:
     REFERENCE_COUNT = 0x1080
     DEVICES = 0x1081
     PROPERTIES = 0x1082
     NUM_DEVICES = 0x1083
     PLATFORM = 0x1084
     INTEROP_USER_SYNC = 0x1085
-    MEMORY_INITIALIZE_KHR = 0x200E
-    TERMINATE_KHR = 0x2010
   
     # Creates a new Context and retains it if specified and aplicable
     def initialize(ptr, retain = true)
@@ -2840,6 +1085,7 @@ module OpenCL
     end
   
     # method called at Context deletion, releases the object if aplicable
+    # @private
     def self.release(ptr)
       #STDERR.puts "Releasing Context: #{ptr}"
       #ref_count = MemoryPointer::new( :cl_uint ) 
@@ -2849,15 +1095,6 @@ module OpenCL
       #STDERR.puts "Object released! #{error}"
       error_check( error )
     end
-    #:startdoc:
-  
-    def to_s
-      if self.respond_to?(:name) then
-        return self.name
-      else
-        return super
-      end
-    end
   
   end
 
@@ -2865,39 +1102,14 @@ module OpenCL
     class Properties < Enum
       PLATFORM = 0x1084
       INTEROP_USER_SYNC = 0x1085
-      D3D10_DEVICE_KHR = 0x4014
-      ADAPTER_D3D9_KHR = 0x2025
-      ADAPTER_D3D9EX_KHR = 0x2026
-      ADAPTER_DXVA_KHR = 0x2027
-      GL_CONTEXT_KHR = 0x2008
-      CGL_SHAREGROUP_KHR = 0x200C
-      EGL_DISPLAY_KHR = 0x2009
-      GLX_DISPLAY_KHR = 0x200A
-      WGL_HDC_KHR = 0x200B
-      D3D11_DEVICE_KHR = 0x401D
-      MEMORY_INITIALIZE_KHR = 0x2030
-      TERMINATE_KHR = 0x2032
       @codes = {}
       @codes[0x1084] = 'PLATFORM'
       @codes[0x1085] = 'INTEROP_USER_SYNC'
-      @codes[0x4014] = 'D3D10_DEVICE_KHR'
-      @codes[0x2025] = 'ADAPTER_D3D9_KHR'
-      @codes[0x2026] = 'ADAPTER_D3D9EX_KHR'
-      @codes[0x2027] = 'ADAPTER_DXVA_KHR'
-      @codes[0x2008] = 'GL_CONTEXT_KHR'
-      @codes[0x200C] = 'CGL_SHAREGROUP_KHR'
-      @codes[0x2009] = 'EGL_DISPLAY_KHR'
-      @codes[0x200A] = 'GLX_DISPLAY_KHR'
-      @codes[0x200B] = 'WGL_HDC_KHR'
-      @codes[0x401D] = 'D3D11_DEVICE_KHR'
-      @codes[0x2030] = 'MEMORY_INITIALIZE_KHR'
-      @codes[0x2032] = 'TERMINATE_KHR'
     end
   end
 
-  class CommandQueue < ManagedStruct
+  class CommandQueue < ExtendedStruct
     layout :dummy, :pointer
-    #:stopdoc:
     OUT_OF_ORDER_EXEC_MODE_ENABLE = (1 << 0)
     PROFILING_ENABLE = (1 << 1)
     ON_DEVICE = (1 << 2)
@@ -2908,14 +1120,6 @@ module OpenCL
     PROPERTIES = 0x1093
     SIZE = 0x1094
     DEVICE_DEFAULT = 0x1095
-    PRIORITY_KHR = 0x1096
-    PRIORITY_HIGH_KHR = (1 << 0)
-    PRIORITY_MED_KHR = (1 << 1)
-    PRIORITY_LOW_KHR = (1 << 2)
-    THROTTLE_KHR = 0x1097
-    THROTTLE_HIGH_KHR = (1 << 0)
-    THROTTLE_MED_KHR = (1 << 1)
-    THROTTLE_LOW_KHR = (1 << 2)
     # Creates a new CommandQueue and retains it if specified and aplicable
     def initialize(ptr, retain = true)
       super(ptr)
@@ -2924,6 +1128,7 @@ module OpenCL
     end
   
     # method called at CommandQueue deletion, releases the object if aplicable
+    # @private
     def self.release(ptr)
       #STDERR.puts "Releasing CommandQueue: #{ptr}"
       #ref_count = MemoryPointer::new( :cl_uint ) 
@@ -2933,15 +1138,6 @@ module OpenCL
       #STDERR.puts "Object released! #{error}"
       error_check( error )
     end
-    #:startdoc:
-  
-    def to_s
-      if self.respond_to?(:name) then
-        return self.name
-      else
-        return super
-      end
-    end
   
   end
 
@@ -2961,29 +1157,9 @@ module OpenCL
       end
     end
 
-    class PriorityKHR < Enum
-      PRIORITY_HIGH_KHR = (1 << 0)
-      PRIORITY_MED_KHR = (1 << 1)
-      PRIORITY_LOW_KHR = (1 << 2)
-      @codes = {}
-      @codes[(1 << 0)] = 'PRIORITY_HIGH_KHR'
-      @codes[(1 << 1)] = 'PRIORITY_MED_KHR'
-      @codes[(1 << 2)] = 'PRIORITY_LOW_KHR'
-    end
-
-    class ThrottleKHR < Enum
-      THROTTLE_HIGH_KHR = (1 << 0)
-      THROTTLE_MED_KHR = (1 << 1)
-      THROTTLE_LOW_KHR = (1 << 2)
-      @codes = {}
-      @codes[(1 << 0)] = 'THROTTLE_HIGH_KHR'
-      @codes[(1 << 1)] = 'THROTTLE_MED_KHR'
-      @codes[(1 << 2)] = 'THROTTLE_LOW_KHR'
-    end
   end
-  class Mem < ManagedStruct
+  class Mem < ExtendedStruct
     layout :dummy, :pointer
-    #:stopdoc:
     READ_WRITE = (1 << 0)
     WRITE_ONLY = (1 << 1)
     READ_ONLY = (1 << 2)
@@ -3028,6 +1204,7 @@ module OpenCL
     end
   
     # method called at Mem deletion, releases the object if aplicable
+    # @private
     def self.release(ptr)
       #STDERR.puts "Releasing Mem: #{ptr}"
       #ref_count = MemoryPointer::new( :cl_uint ) 
@@ -3037,15 +1214,6 @@ module OpenCL
       #STDERR.puts "Object released! #{error}"
       error_check( error )
     end
-    #:startdoc:
-  
-    def to_s
-      if self.respond_to?(:name) then
-        return self.name
-      else
-        return super
-      end
-    end
   
   end
 
@@ -3127,9 +1295,8 @@ module OpenCL
     end
 
   end
-  class Program < ManagedStruct
+  class Program < ExtendedStruct
     layout :dummy, :pointer
-    #:stopdoc:
     REFERENCE_COUNT = 0x1160
     CONTEXT = 0x1161
     NUM_DEVICES = 0x1162
@@ -3149,7 +1316,6 @@ module OpenCL
     BINARY_TYPE_COMPILED_OBJECT = 0x1
     BINARY_TYPE_LIBRARY = 0x2
     BINARY_TYPE_EXECUTABLE = 0x4
-    BINARY_TYPE_INTERMEDIATE = 0x40E1
   
     # Creates a new Program and retains it if specified and aplicable
     def initialize(ptr, retain = true)
@@ -3159,6 +1325,7 @@ module OpenCL
     end
   
     # method called at Program deletion, releases the object if aplicable
+    # @private
     def self.release(ptr)
       #STDERR.puts "Releasing Program: #{ptr}"
       #ref_count = MemoryPointer::new( :cl_uint ) 
@@ -3168,15 +1335,6 @@ module OpenCL
       #STDERR.puts "Object released! #{error}"
       error_check( error )
     end
-    #:startdoc:
-  
-    def to_s
-      if self.respond_to?(:name) then
-        return self.name
-      else
-        return super
-      end
-    end
   
   end
 
@@ -3187,19 +1345,16 @@ module OpenCL
       COMPILED_OBJECT = 0x1
       LIBRARY = 0x2
       EXECUTABLE = 0x4
-      INTERMEDIATE = 0x40E1
       @codes = {}
       @codes[0x0] = 'NONE'
       @codes[0x1] = 'COMPILED_OBJECT'
       @codes[0x2] = 'LIBRARY'
       @codes[0x4] = 'EXECUTABLE'
-      @codes[0x40E1] = 'INTERMEDIATE'
     end
 
   end
-  class Kernel < ManagedStruct
+  class Kernel < ExtendedStruct
     layout :dummy, :pointer
-    #:stopdoc:
     FUNCTION_NAME = 0x1190
     NUM_ARGS = 0x1191
     REFERENCE_COUNT = 0x1192
@@ -3246,6 +1401,7 @@ module OpenCL
     end
   
     # method called at Kernel deletion, releases the object if aplicable
+    # @private
     def self.release(ptr)
       #STDERR.puts "Releasing Kernel: #{ptr}"
       #ref_count = MemoryPointer::new( :cl_uint ) 
@@ -3255,15 +1411,6 @@ module OpenCL
       #STDERR.puts "Object released! #{error}"
       error_check( error )
     end
-    #:startdoc:
-  
-    def to_s
-      if self.respond_to?(:name) then
-        return self.name
-      else
-        return super
-      end
-    end
   
   end
 
@@ -3336,9 +1483,8 @@ module OpenCL
 
     end
   end
-  class Event < ManagedStruct
+  class Event < ExtendedStruct
     layout :dummy, :pointer
-    #:stopdoc:
     COMMAND_QUEUE = 0x11D0
     COMMAND_TYPE = 0x11D1
     REFERENCE_COUNT = 0x11D2
@@ -3353,6 +1499,7 @@ module OpenCL
     end
   
     # method called at Event deletion, releases the object if aplicable
+    # @private
     def self.release(ptr)
       #STDERR.puts "Releasing Event: #{ptr}"
       #ref_count = MemoryPointer::new( :cl_uint ) 
@@ -3362,21 +1509,11 @@ module OpenCL
       #STDERR.puts "Object released! #{error}"
       error_check( error )
     end
-    #:startdoc:
-  
-    def to_s
-      if self.respond_to?(:name) then
-        return self.name
-      else
-        return super
-      end
-    end
   
   end
 
-  class Sampler < ManagedStruct
+  class Sampler < ExtendedStruct
     layout :dummy, :pointer
-    #:stopdoc:
     REFERENCE_COUNT = 0x1150
     CONTEXT = 0x1151
     NORMALIZED_COORDS = 0x1152
@@ -3394,6 +1531,7 @@ module OpenCL
     end
   
     # method called at Sampler deletion, releases the object if aplicable
+    # @private
     def self.release(ptr)
       #STDERR.puts "Releasing Sampler: #{ptr}"
       #ref_count = MemoryPointer::new( :cl_uint ) 
@@ -3403,20 +1541,10 @@ module OpenCL
       #STDERR.puts "Object released! #{error}"
       error_check( error )
     end
-    #:startdoc:
-  
-    def to_s
-      if self.respond_to?(:name) then
-        return self.name
-      else
-        return super
-      end
-    end
   
   end
-  class GLsync < ManagedStruct
+  class GLsync < ExtendedStruct
     layout :dummy, :pointer
-    #:stopdoc:
     
   
     # Creates a new GLsync and retains it if specified and aplicable
@@ -3426,17 +1554,9 @@ module OpenCL
     end
   
     # method called at GLsync deletion, releases the object if aplicable
+    # @private
     def self.release(ptr)
     end
-    #:startdoc:
-  
-    def to_s
-      if self.respond_to?(:name) then
-        return self.name
-      else
-        return super
-      end
-    end
   
   end
 
@@ -3603,16 +1723,6 @@ module OpenCL
     SVM_MEMFILL = 0x120B
     SVM_MAP = 0x120C
     SVM_UNMAP = 0x120D
-    GL_FENCE_SYNC_OBJECT_KHR = 0x200D
-    ACQUIRE_DX9_MEDIA_SURFACES_KHR = 0x202B
-    RELEASE_DX9_MEDIA_SURFACES_KHR = 0x202C
-    EGL_FENCE_SYNC_OBJECT_KHR = 0x202F
-    ACQUIRE_EGL_OBJECTS_KHR = 0x202D
-    RELEASE_EGL_OBJECTS_KHR = 0x202E
-    ACQUIRE_D3D10_OBJECTS_KHR = 0x4017
-    RELEASE_D3D10_OBJECTS_KHR = 0x4018
-    ACQUIRE_D3D11_OBJECTS_KHR = 0x4020
-    RELEASE_D3D11_OBJECTS_KHR = 0x4021
     @codes = {}
     @codes[0x11F0] = 'NDRANGE_KERNEL'
     @codes[0x11F1] = 'TASK'
@@ -3644,16 +1754,6 @@ module OpenCL
     @codes[0x120B] = 'SVM_MEMFILL'
     @codes[0x120C] = 'SVM_MAP'
     @codes[0x120D] = 'SVM_UNMAP'
-    @codes[0x200D] = 'GL_FENCE_SYNC_OBJECT_KHR'
-    @codes[0x202B] = 'ACQUIRE_DX9_MEDIA_SURFACES_KHR'
-    @codes[0x202C] = 'RELEASE_DX9_MEDIA_SURFACES_KHR'
-    @codes[0x202F] = 'EGL_FENCE_SYNC_OBJECT_KHR'
-    @codes[0x202D] = 'ACQUIRE_EGL_OBJECTS_KHR'
-    @codes[0x202E] = 'RELEASE_EGL_OBJECTS_KHR'
-    @codes[0x4017] = 'ACQUIRE_D3D10_OBJECTS_KHR'
-    @codes[0x4018] = 'RELEASE_D3D10_OBJECTS_KHR'
-    @codes[0x4020] = 'ACQUIRE_D3D11_OBJECTS_KHR'
-    @codes[0x4021] = 'RELEASE_D3D11_OBJECTS_KHR'
   end
 
   # Enum that maps the :cl_gl_object_type type
@@ -3705,7 +1805,6 @@ module OpenCL
 
   class Image < Mem
     layout :dummy, :pointer
-    #:stopdoc:
     FORMAT_MISMATCH = -9
     FORMAT_NOT_SUPPORTED = -10
     FORMAT = 0x1110
@@ -3721,14 +1820,11 @@ module OpenCL
     NUM_SAMPLES = 0x111A
     ROW_ALIGNMENT_QCOM = 0x40A2
     SLICE_ALIGNMENT_QCOM = 0x40A3
-    #:startdoc:
   end
   class Pipe < Mem
     layout :dummy, :pointer
-    #:stopdoc:
     PACKET_SIZE = 0x1120
     MAX_PACKETS = 0x1121
-    #:startdoc:
   end
   attach_function :clGetPlatformIDs, [:cl_uint,:pointer,:pointer], :cl_int
   attach_function :clGetPlatformInfo, [Platform,:cl_platform_info,:size_t,:pointer,:pointer], :cl_int
@@ -3745,14 +1841,11 @@ module OpenCL
   attach_function :clReleaseCommandQueue, [CommandQueue], :cl_int
   attach_function :clGetCommandQueueInfo, [CommandQueue,:cl_command_queue_info,:size_t,:pointer,:pointer], :cl_int
   attach_function :clCreateBuffer, [Context,:cl_mem_flags,:size_t,:pointer,:pointer], Mem
-  attach_function :clCreateSubBuffer, [Mem,:cl_mem_flags,:cl_buffer_create_type,:pointer,:pointer], Mem
   attach_function :clRetainMemObject, [Mem], :cl_int
   attach_function :clReleaseMemObject, [Mem], :cl_int
   attach_function :clGetSupportedImageFormats, [Context,:cl_mem_flags,:cl_mem_object_type,:cl_uint,:pointer,:pointer], :cl_int
   attach_function :clGetMemObjectInfo, [Mem,:cl_mem_info,:size_t,:pointer,:pointer], :cl_int
   attach_function :clGetImageInfo, [Mem,:cl_image_info,:size_t,:pointer,:pointer], :cl_int
-  callback :clSetMemObjectDestructorCallback_notify, [:pointer,:pointer], :void
-  attach_function :clSetMemObjectDestructorCallback, [Mem,:clSetMemObjectDestructorCallback_notify,:pointer], :cl_int
   attach_function :clRetainSampler, [Sampler], :cl_int
   attach_function :clReleaseSampler, [Sampler], :cl_int
   attach_function :clGetSamplerInfo, [Sampler,:cl_sampler_info,:size_t,:pointer,:pointer], :cl_int
@@ -3773,21 +1866,14 @@ module OpenCL
   attach_function :clGetKernelWorkGroupInfo, [Kernel,Device,:cl_kernel_work_group_info,:size_t,:pointer,:pointer], :cl_int
   attach_function :clWaitForEvents, [:cl_uint,:pointer], :cl_int
   attach_function :clGetEventInfo, [Event,:cl_event_info,:size_t,:pointer,:pointer], :cl_int
-  attach_function :clCreateUserEvent, [Context,:pointer], Event
   attach_function :clRetainEvent, [Event], :cl_int
   attach_function :clReleaseEvent, [Event], :cl_int
-  attach_function :clSetUserEventStatus, [Event,:cl_int], :cl_int
-  callback :clSetEventCallback_notify, [Event.by_ref,:cl_int,:pointer], :void
-  attach_function :clSetEventCallback, [Event,:cl_int,:clSetEventCallback_notify,:pointer], :cl_int
   attach_function :clGetEventProfilingInfo, [Event,:cl_profiling_info,:size_t,:pointer,:pointer], :cl_int
   attach_function :clFlush, [CommandQueue], :cl_int
   attach_function :clFinish, [CommandQueue], :cl_int
   attach_function :clEnqueueReadBuffer, [CommandQueue,Mem,:cl_bool,:size_t,:size_t,:pointer,:cl_uint,:pointer,:pointer], :cl_int
-  attach_function :clEnqueueReadBufferRect, [CommandQueue,Mem,:cl_bool,:pointer,:pointer,:pointer,:size_t,:size_t,:size_t,:size_t,:pointer,:cl_uint,:pointer,:pointer], :cl_int
   attach_function :clEnqueueWriteBuffer, [CommandQueue,Mem,:cl_bool,:size_t,:size_t,:pointer,:cl_uint,:pointer,:pointer], :cl_int
-  attach_function :clEnqueueWriteBufferRect, [CommandQueue,Mem,:cl_bool,:pointer,:pointer,:pointer,:size_t,:size_t,:size_t,:size_t,:pointer,:cl_uint,:pointer,:pointer], :cl_int
   attach_function :clEnqueueCopyBuffer, [CommandQueue,Mem,Mem,:size_t,:size_t,:size_t,:cl_uint,:pointer,:pointer], :cl_int
-  attach_function :clEnqueueCopyBufferRect, [CommandQueue,Mem,Mem,:pointer,:pointer,:pointer,:size_t,:size_t,:size_t,:size_t,:cl_uint,:pointer,:pointer], :cl_int
   attach_function :clEnqueueReadImage, [CommandQueue,Mem,:cl_bool,:pointer,:pointer,:size_t,:size_t,:pointer,:cl_uint,:pointer,:pointer], :cl_int
   attach_function :clEnqueueWriteImage, [CommandQueue,Mem,:cl_bool,:pointer,:pointer,:size_t,:size_t,:pointer,:cl_uint,:pointer,:pointer], :cl_int
   attach_function :clEnqueueCopyImage, [CommandQueue,Mem,Mem,:pointer,:pointer,:pointer,:cl_uint,:pointer,:pointer], :cl_int
@@ -3817,55 +1903,69 @@ module OpenCL
   attach_function :clEnqueueReleaseGLObjects, [CommandQueue,:cl_uint,:pointer,:cl_uint,:pointer,:pointer], :cl_int
   attach_function :clCreateFromGLTexture2D, [Context,:cl_mem_flags,:cl_GLenum,:cl_GLint,:cl_GLuint,:pointer], Mem
   attach_function :clCreateFromGLTexture3D, [Context,:cl_mem_flags,:cl_GLenum,:cl_GLint,:cl_GLuint,:pointer], Mem
-  begin
-    attach_function :clCreateSubDevices, [Device,:pointer,:cl_uint,:pointer,:pointer], :cl_int
-    attach_function :clRetainDevice, [Device], :cl_int
-    attach_function :clReleaseDevice, [Device], :cl_int
-    attach_function :clCreateImage, [Context,:cl_mem_flags,:pointer,:pointer,:pointer,:pointer], Mem
-    attach_function :clCreateProgramWithBuiltInKernels, [Context,:cl_uint,:pointer,:pointer,:pointer], Program
-    callback :clCompileProgram_notify, [Program.by_ref,:pointer], :void
-    attach_function :clCompileProgram, [Program,:cl_uint,:pointer,:pointer,:cl_uint,:pointer,:pointer,:clCompileProgram_notify,:pointer], :cl_int
-    callback :clLinkProgram_notify, [Program.by_ref,:pointer], :void
-    attach_function :clLinkProgram, [Context,:cl_uint,:pointer,:pointer,:cl_uint,:pointer,:clLinkProgram_notify,:pointer,:pointer], Program
-    attach_function :clUnloadPlatformCompiler, [Platform], :cl_int
-    attach_function :clGetKernelArgInfo, [Kernel,:cl_uint,:cl_kernel_arg_info,:size_t,:pointer,:pointer], :cl_int
-    attach_function :clEnqueueFillBuffer, [CommandQueue,Mem,:pointer,:size_t,:size_t,:size_t,:cl_uint,:pointer,:pointer], :cl_int
-    attach_function :clEnqueueFillImage, [CommandQueue,Mem,:pointer,:pointer,:pointer,:cl_uint,:pointer,:pointer], :cl_int
-    attach_function :clEnqueueMigrateMemObjects, [CommandQueue,:cl_uint,:pointer,:cl_mem_migration_flags,:cl_uint,:pointer,:pointer], :cl_int
-    attach_function :clEnqueueMarkerWithWaitList, [CommandQueue,:cl_uint,:pointer,:pointer], :cl_int
-    attach_function :clEnqueueBarrierWithWaitList, [CommandQueue,:cl_uint,:pointer,:pointer], :cl_int
-    attach_function :clGetExtensionFunctionAddressForPlatform, [Platform,:pointer], :pointer
-    attach_function :clCreateFromGLTexture, [Context,:cl_mem_flags,:cl_GLenum,:cl_GLint,:cl_GLuint,:pointer], Mem
-    begin
-      attach_function :clCreateCommandQueueWithProperties, [Context,Device,:pointer,:pointer], CommandQueue
-      attach_function :clCreatePipe, [Context,:cl_mem_flags,:cl_uint,:cl_uint,:pointer,:pointer], Mem
-      attach_function :clGetPipeInfo, [Mem,:cl_pipe_info,:size_t,:pointer,:pointer], :cl_int
-      attach_function :clSVMAlloc, [Context,:cl_svm_mem_flags,:size_t,:cl_uint], :pointer
-      attach_function :clSVMFree, [Context,:pointer], :void
-      attach_function :clCreateSamplerWithProperties, [Context,:pointer,:pointer], Sampler
-      attach_function :clSetKernelArgSVMPointer, [Kernel,:cl_uint,:pointer], :cl_int
-      attach_function :clSetKernelExecInfo, [Kernel,:cl_kernel_exec_info,:size_t,:pointer], :cl_int
-      callback :clEnqueueSVMFree_notify, [CommandQueue.by_ref,:cl_uint,:pointer,:pointer], :void
-      attach_function :clEnqueueSVMFree, [CommandQueue,:cl_uint,:pointer,:clEnqueueSVMFree_notify,:pointer,:cl_uint,:pointer,:pointer], :cl_int
-      attach_function :clEnqueueSVMMemcpy, [CommandQueue,:cl_bool,:pointer,:pointer,:size_t,:cl_uint,:pointer,:pointer], :cl_int
-      attach_function :clEnqueueSVMMemFill, [CommandQueue,:pointer,:pointer,:size_t,:size_t,:cl_uint,:pointer,:pointer], :cl_int
-      attach_function :clEnqueueSVMMap, [CommandQueue,:cl_bool,:cl_map_flags,:pointer,:size_t,:cl_uint,:pointer,:pointer], :cl_int
-      attach_function :clEnqueueSVMUnmap, [CommandQueue,:pointer,:cl_uint,:pointer,:pointer], :cl_int
-      begin
-        attach_function :clSetDefaultDeviceCommandQueue, [Context,Device,CommandQueue], :cl_int
-        attach_function :clGetDeviceAndHostTimer, [Device,:pointer,:pointer], :cl_int
-        attach_function :clGetHostTimer, [Device,:pointer], :cl_int
-        attach_function :clCreateProgramWithIL, [Context,:pointer,:size_t,:pointer], Program
-        attach_function :clCloneKernel, [Kernel,:pointer], Kernel
-        attach_function :clGetKernelSubGroupInfo, [Kernel,Device,:cl_kernel_sub_group_info,:size_t,:pointer,:size_t,:pointer,:pointer], :cl_int
-        attach_function :clEnqueueSVMMigrateMem, [CommandQueue,:cl_uint,:pointer,:pointer,:cl_mem_migration_flags,:cl_uint,:pointer,:pointer], :cl_int
+  begin # OpenCL 1.1
+    attach_function :clCreateSubBuffer, [Mem,:cl_mem_flags,:cl_buffer_create_type,:pointer,:pointer], Mem
+    attach_function :clEnqueueReadBufferRect, [CommandQueue,Mem,:cl_bool,:pointer,:pointer,:pointer,:size_t,:size_t,:size_t,:size_t,:pointer,:cl_uint,:pointer,:pointer], :cl_int
+    attach_function :clEnqueueWriteBufferRect, [CommandQueue,Mem,:cl_bool,:pointer,:pointer,:pointer,:size_t,:size_t,:size_t,:size_t,:pointer,:cl_uint,:pointer,:pointer], :cl_int
+    attach_function :clEnqueueCopyBufferRect, [CommandQueue,Mem,Mem,:pointer,:pointer,:pointer,:size_t,:size_t,:size_t,:size_t,:cl_uint,:pointer,:pointer], :cl_int
+    callback :clSetMemObjectDestructorCallback_notify, [:pointer,:pointer], :void
+    attach_function :clSetMemObjectDestructorCallback, [Mem,:clSetMemObjectDestructorCallback_notify,:pointer], :cl_int
+    attach_function :clCreateUserEvent, [Context,:pointer], Event
+    attach_function :clSetUserEventStatus, [Event,:cl_int], :cl_int
+    callback :clSetEventCallback_notify, [Event.by_ref,:cl_int,:pointer], :void
+    attach_function :clSetEventCallback, [Event,:cl_int,:clSetEventCallback_notify,:pointer], :cl_int
+    begin # OpenCL 1.2
+      attach_function :clCreateSubDevices, [Device,:pointer,:cl_uint,:pointer,:pointer], :cl_int
+      attach_function :clRetainDevice, [Device], :cl_int
+      attach_function :clReleaseDevice, [Device], :cl_int
+      attach_function :clCreateImage, [Context,:cl_mem_flags,:pointer,:pointer,:pointer,:pointer], Mem
+      attach_function :clCreateProgramWithBuiltInKernels, [Context,:cl_uint,:pointer,:pointer,:pointer], Program
+      callback :clCompileProgram_notify, [Program.by_ref,:pointer], :void
+      attach_function :clCompileProgram, [Program,:cl_uint,:pointer,:pointer,:cl_uint,:pointer,:pointer,:clCompileProgram_notify,:pointer], :cl_int
+      callback :clLinkProgram_notify, [Program.by_ref,:pointer], :void
+      attach_function :clLinkProgram, [Context,:cl_uint,:pointer,:pointer,:cl_uint,:pointer,:clLinkProgram_notify,:pointer,:pointer], Program
+      attach_function :clUnloadPlatformCompiler, [Platform], :cl_int
+      attach_function :clGetKernelArgInfo, [Kernel,:cl_uint,:cl_kernel_arg_info,:size_t,:pointer,:pointer], :cl_int
+      attach_function :clEnqueueFillBuffer, [CommandQueue,Mem,:pointer,:size_t,:size_t,:size_t,:cl_uint,:pointer,:pointer], :cl_int
+      attach_function :clEnqueueFillImage, [CommandQueue,Mem,:pointer,:pointer,:pointer,:cl_uint,:pointer,:pointer], :cl_int
+      attach_function :clEnqueueMigrateMemObjects, [CommandQueue,:cl_uint,:pointer,:cl_mem_migration_flags,:cl_uint,:pointer,:pointer], :cl_int
+      attach_function :clEnqueueMarkerWithWaitList, [CommandQueue,:cl_uint,:pointer,:pointer], :cl_int
+      attach_function :clEnqueueBarrierWithWaitList, [CommandQueue,:cl_uint,:pointer,:pointer], :cl_int
+      attach_function :clGetExtensionFunctionAddressForPlatform, [Platform,:pointer], :pointer
+      attach_function :clCreateFromGLTexture, [Context,:cl_mem_flags,:cl_GLenum,:cl_GLint,:cl_GLuint,:pointer], Mem
+      begin # OpenCL 2.0
+        attach_function :clCreateCommandQueueWithProperties, [Context,Device,:pointer,:pointer], CommandQueue
+        attach_function :clCreatePipe, [Context,:cl_mem_flags,:cl_uint,:cl_uint,:pointer,:pointer], Mem
+        attach_function :clGetPipeInfo, [Mem,:cl_pipe_info,:size_t,:pointer,:pointer], :cl_int
+        attach_function :clSVMAlloc, [Context,:cl_svm_mem_flags,:size_t,:cl_uint], :pointer
+        attach_function :clSVMFree, [Context,:pointer], :void
+        attach_function :clCreateSamplerWithProperties, [Context,:pointer,:pointer], Sampler
+        attach_function :clSetKernelArgSVMPointer, [Kernel,:cl_uint,:pointer], :cl_int
+        attach_function :clSetKernelExecInfo, [Kernel,:cl_kernel_exec_info,:size_t,:pointer], :cl_int
+        callback :clEnqueueSVMFree_notify, [CommandQueue.by_ref,:cl_uint,:pointer,:pointer], :void
+        attach_function :clEnqueueSVMFree, [CommandQueue,:cl_uint,:pointer,:clEnqueueSVMFree_notify,:pointer,:cl_uint,:pointer,:pointer], :cl_int
+        attach_function :clEnqueueSVMMemcpy, [CommandQueue,:cl_bool,:pointer,:pointer,:size_t,:cl_uint,:pointer,:pointer], :cl_int
+        attach_function :clEnqueueSVMMemFill, [CommandQueue,:pointer,:pointer,:size_t,:size_t,:cl_uint,:pointer,:pointer], :cl_int
+        attach_function :clEnqueueSVMMap, [CommandQueue,:cl_bool,:cl_map_flags,:pointer,:size_t,:cl_uint,:pointer,:pointer], :cl_int
+        attach_function :clEnqueueSVMUnmap, [CommandQueue,:pointer,:cl_uint,:pointer,:pointer], :cl_int
+        begin # OpenCL 2.1
+          attach_function :clSetDefaultDeviceCommandQueue, [Context,Device,CommandQueue], :cl_int
+          attach_function :clGetDeviceAndHostTimer, [Device,:pointer,:pointer], :cl_int
+          attach_function :clGetHostTimer, [Device,:pointer], :cl_int
+          attach_function :clCreateProgramWithIL, [Context,:pointer,:size_t,:pointer], Program
+          attach_function :clCloneKernel, [Kernel,:pointer], Kernel
+          attach_function :clGetKernelSubGroupInfo, [Kernel,Device,:cl_kernel_sub_group_info,:size_t,:pointer,:size_t,:pointer,:pointer], :cl_int
+          attach_function :clEnqueueSVMMigrateMem, [CommandQueue,:cl_uint,:pointer,:pointer,:cl_mem_migration_flags,:cl_uint,:pointer,:pointer], :cl_int
+        rescue NotFoundError => e
+          warn "Warning OpenCL 2.0 loader detected!"
+        end
       rescue NotFoundError => e
-        warn "Warning OpenCL 2.0 loader detected!"
+        warn "Warning OpenCL 1.2 loader detected!"
       end
     rescue NotFoundError => e
-      warn "Warning OpenCL 1.2 loader detected!"
+      warn "Warning OpenCL 1.1 loader detected!"
     end
   rescue NotFoundError => e
-    warn "Warning OpenCL 1.1 loader detected!"
+      warn "Warning OpenCL 1.0 loader detected!"
   end
 end