diff --git a/include/CL/opencl.hpp b/include/CL/opencl.hpp
index 4b267a8..d2e2d25 100644
--- a/include/CL/opencl.hpp
+++ b/include/CL/opencl.hpp
@@ -206,6 +206,11 @@
  *
  *   Enable the cl_khr_il_program extension.
  *
+ * - CL_HPP_OPENCL_API_WRAPPER
+ *
+ *   A macro which is used to wrap all OpenCL API symbols. This can be
+ *   used e.g. to load the OpenCL library dynamically with dlopen()/dlsym().
+ *
  *
  * \section example Example
  *
@@ -392,6 +397,12 @@
 #ifndef CL_HPP_
 #define CL_HPP_
 
+#ifdef CL_HPP_OPENCL_API_WRAPPER
+#define CL_(name) CL_HPP_OPENCL_API_WRAPPER(name)
+#else
+#define CL_(name) ::name
+#endif
+
 /* Handle deprecated preprocessor definitions. In each case, we only check for
  * the old name if the new name is not defined, so that user code can define
  * both and hence work with either version of the bindings.
@@ -703,15 +714,15 @@ namespace cl {
 #define CL_HPP_CREATE_CL_EXT_FCN_PTR_ALIAS_(name) \
     using PFN_##name = name##_fn
 
-#define CL_HPP_INIT_CL_EXT_FCN_PTR_(name)                               \
-    if (!pfn_##name) {                                                  \
-        pfn_##name = (PFN_##name)clGetExtensionFunctionAddress(#name);  \
+#define CL_HPP_INIT_CL_EXT_FCN_PTR_(name)                                    \
+    if (!pfn_##name) {                                                       \
+        pfn_##name = (PFN_##name)CL_(clGetExtensionFunctionAddress)(#name);  \
     }
 
-#define CL_HPP_INIT_CL_EXT_FCN_PTR_PLATFORM_(platform, name)            \
-    if (!pfn_##name) {                                                  \
-        pfn_##name = (PFN_##name)                                       \
-            clGetExtensionFunctionAddressForPlatform(platform, #name);  \
+#define CL_HPP_INIT_CL_EXT_FCN_PTR_PLATFORM_(platform, name)                 \
+    if (!pfn_##name) {                                                       \
+        pfn_##name = (PFN_##name)                                            \
+            CL_(clGetExtensionFunctionAddressForPlatform)(platform, #name);  \
     }
 
     class Memory;
@@ -1894,7 +1905,7 @@ struct ReferenceHandler<cl_device_id>
      *   CL_OUT_OF_HOST_MEMORY
      */
     static cl_int retain(cl_device_id device)
-    { return ::clRetainDevice(device); }
+    { return CL_(clRetainDevice)(device); }
     /**
      * Retain the device.
      * \param device A valid device created using createSubDevices
@@ -1905,7 +1916,7 @@ struct ReferenceHandler<cl_device_id>
      *   CL_OUT_OF_HOST_MEMORY
      */
     static cl_int release(cl_device_id device)
-    { return ::clReleaseDevice(device); }
+    { return CL_(clReleaseDevice)(device); }
 };
 #else // CL_HPP_TARGET_OPENCL_VERSION >= 120
 /**
@@ -1938,63 +1949,63 @@ template <>
 struct ReferenceHandler<cl_context>
 {
     static cl_int retain(cl_context context)
-    { return ::clRetainContext(context); }
+    { return CL_(clRetainContext)(context); }
     static cl_int release(cl_context context)
-    { return ::clReleaseContext(context); }
+    { return CL_(clReleaseContext)(context); }
 };
 
 template <>
 struct ReferenceHandler<cl_command_queue>
 {
     static cl_int retain(cl_command_queue queue)
-    { return ::clRetainCommandQueue(queue); }
+    { return CL_(clRetainCommandQueue)(queue); }
     static cl_int release(cl_command_queue queue)
-    { return ::clReleaseCommandQueue(queue); }
+    { return CL_(clReleaseCommandQueue)(queue); }
 };
 
 template <>
 struct ReferenceHandler<cl_mem>
 {
     static cl_int retain(cl_mem memory)
-    { return ::clRetainMemObject(memory); }
+    { return CL_(clRetainMemObject)(memory); }
     static cl_int release(cl_mem memory)
-    { return ::clReleaseMemObject(memory); }
+    { return CL_(clReleaseMemObject)(memory); }
 };
 
 template <>
 struct ReferenceHandler<cl_sampler>
 {
     static cl_int retain(cl_sampler sampler)
-    { return ::clRetainSampler(sampler); }
+    { return CL_(clRetainSampler)(sampler); }
     static cl_int release(cl_sampler sampler)
-    { return ::clReleaseSampler(sampler); }
+    { return CL_(clReleaseSampler)(sampler); }
 };
 
 template <>
 struct ReferenceHandler<cl_program>
 {
     static cl_int retain(cl_program program)
-    { return ::clRetainProgram(program); }
+    { return CL_(clRetainProgram)(program); }
     static cl_int release(cl_program program)
-    { return ::clReleaseProgram(program); }
+    { return CL_(clReleaseProgram)(program); }
 };
 
 template <>
 struct ReferenceHandler<cl_kernel>
 {
     static cl_int retain(cl_kernel kernel)
-    { return ::clRetainKernel(kernel); }
+    { return CL_(clRetainKernel)(kernel); }
     static cl_int release(cl_kernel kernel)
-    { return ::clReleaseKernel(kernel); }
+    { return CL_(clReleaseKernel)(kernel); }
 };
 
 template <>
 struct ReferenceHandler<cl_event>
 {
     static cl_int retain(cl_event event)
-    { return ::clRetainEvent(event); }
+    { return CL_(clRetainEvent)(event); }
     static cl_int release(cl_event event)
-    { return ::clReleaseEvent(event); }
+    { return CL_(clReleaseEvent)(event); }
 };
 
 #if defined(cl_khr_command_buffer)
@@ -2002,9 +2013,9 @@ template <>
 struct ReferenceHandler<cl_command_buffer_khr>
 {
     static cl_int retain(cl_command_buffer_khr cmdbuf)
-    { return ::clRetainCommandBufferKHR(cmdbuf); }
+    { return CL_(clRetainCommandBufferKHR)(cmdbuf); }
     static cl_int release(cl_command_buffer_khr cmdbuf)
-    { return ::clReleaseCommandBufferKHR(cmdbuf); }
+    { return CL_(clReleaseCommandBufferKHR)(cmdbuf); }
 };
 #endif // cl_khr_command_buffer
 
@@ -2034,17 +2045,17 @@ static cl_uint getVersion(const vector<char> &versionInfo)
 static cl_uint getPlatformVersion(cl_platform_id platform)
 {
     size_type size = 0;
-    clGetPlatformInfo(platform, CL_PLATFORM_VERSION, 0, nullptr, &size);
+    CL_(clGetPlatformInfo)(platform, CL_PLATFORM_VERSION, 0, nullptr, &size);
 
     vector<char> versionInfo(size);
-    clGetPlatformInfo(platform, CL_PLATFORM_VERSION, size, versionInfo.data(), &size);
+    CL_(clGetPlatformInfo)(platform, CL_PLATFORM_VERSION, size, versionInfo.data(), &size);
     return getVersion(versionInfo);
 }
 
 static cl_uint getDevicePlatformVersion(cl_device_id device)
 {
     cl_platform_id platform;
-    clGetDeviceInfo(device, CL_DEVICE_PLATFORM, sizeof(platform), &platform, nullptr);
+    CL_(clGetDeviceInfo)(device, CL_DEVICE_PLATFORM, sizeof(platform), &platform, nullptr);
     return getPlatformVersion(platform);
 }
 
@@ -2053,11 +2064,11 @@ static cl_uint getContextPlatformVersion(cl_context context)
     // The platform cannot be queried directly, so we first have to grab a
     // device and obtain its context
     size_type size = 0;
-    clGetContextInfo(context, CL_CONTEXT_DEVICES, 0, nullptr, &size);
+    CL_(clGetContextInfo)(context, CL_CONTEXT_DEVICES, 0, nullptr, &size);
     if (size == 0)
         return 0;
     vector<cl_device_id> devices(size/sizeof(cl_device_id));
-    clGetContextInfo(context, CL_CONTEXT_DEVICES, size, devices.data(), nullptr);
+    CL_(clGetContextInfo)(context, CL_CONTEXT_DEVICES, size, devices.data(), nullptr);
     return getDevicePlatformVersion(devices[0]);
 }
 #endif // CL_HPP_TARGET_OPENCL_VERSION && CL_HPP_MINIMUM_OPENCL_VERSION
@@ -2432,7 +2443,7 @@ class Device : public detail::Wrapper<cl_device_id>
     cl_int getInfo(cl_device_info name, T* param) const
     {
         return detail::errHandler(
-            detail::getInfo(&::clGetDeviceInfo, object_, name, param),
+            detail::getInfo(CL_(clGetDeviceInfo), object_, name, param),
             __GET_DEVICE_INFO_ERR);
     }
 
@@ -2461,7 +2472,7 @@ class Device : public detail::Wrapper<cl_device_id>
     {
         cl_ulong retVal = 0;
         cl_int err = 
-            clGetHostTimer(this->get(), &retVal);
+            CL_(clGetHostTimer)(this->get(), &retVal);
         detail::errHandler(
             err,
             __GET_HOST_TIMER_ERR);
@@ -2485,7 +2496,7 @@ class Device : public detail::Wrapper<cl_device_id>
     {
         std::pair<cl_ulong, cl_ulong> retVal;
         cl_int err =
-            clGetDeviceAndHostTimer(this->get(), &(retVal.first), &(retVal.second));
+            CL_(clGetDeviceAndHostTimer)(this->get(), &(retVal.first), &(retVal.second));
         detail::errHandler(
             err,
             __GET_DEVICE_AND_HOST_TIMER_ERR);
@@ -2590,7 +2601,7 @@ class Platform : public detail::Wrapper<cl_platform_id>
             // Otherwise set it
             cl_uint n = 0;
 
-            cl_int err = ::clGetPlatformIDs(0, nullptr, &n);
+            cl_int err = CL_(clGetPlatformIDs)(0, nullptr, &n);
             if (err != CL_SUCCESS) {
                 default_error_ = err;
                 return;
@@ -2601,7 +2612,7 @@ class Platform : public detail::Wrapper<cl_platform_id>
             }
 
             vector<cl_platform_id> ids(n);
-            err = ::clGetPlatformIDs(n, ids.data(), nullptr);
+            err = CL_(clGetPlatformIDs)(n, ids.data(), nullptr);
             if (err != CL_SUCCESS) {
                 default_error_ = err;
                 return;
@@ -2691,7 +2702,7 @@ class Platform : public detail::Wrapper<cl_platform_id>
     cl_int getInfo(cl_platform_info name, T* param) const
     {
         return detail::errHandler(
-            detail::getInfo(&::clGetPlatformInfo, object_, name, param),
+            detail::getInfo(CL_(clGetPlatformInfo), object_, name, param),
             __GET_PLATFORM_INFO_ERR);
     }
 
@@ -2721,14 +2732,14 @@ class Platform : public detail::Wrapper<cl_platform_id>
         if( devices == nullptr ) {
             return detail::errHandler(CL_INVALID_ARG_VALUE, __GET_DEVICE_IDS_ERR);
         }
-        cl_int err = ::clGetDeviceIDs(object_, type, 0, nullptr, &n);
+        cl_int err = CL_(clGetDeviceIDs)(object_, type, 0, nullptr, &n);
         if (err != CL_SUCCESS  && err != CL_DEVICE_NOT_FOUND) {
             return detail::errHandler(err, __GET_DEVICE_IDS_ERR);
         }
 
         vector<cl_device_id> ids(n);
         if (n>0) {
-            err = ::clGetDeviceIDs(object_, type, n, ids.data(), nullptr);
+            err = CL_(clGetDeviceIDs)(object_, type, n, ids.data(), nullptr);
             if (err != CL_SUCCESS) {
                 return detail::errHandler(err, __GET_DEVICE_IDS_ERR);
             }
@@ -2857,13 +2868,13 @@ class Platform : public detail::Wrapper<cl_platform_id>
             return detail::errHandler(CL_INVALID_ARG_VALUE, __GET_PLATFORM_IDS_ERR);
         }
 
-        cl_int err = ::clGetPlatformIDs(0, nullptr, &n);
+        cl_int err = CL_(clGetPlatformIDs)(0, nullptr, &n);
         if (err != CL_SUCCESS) {
             return detail::errHandler(err, __GET_PLATFORM_IDS_ERR);
         }
 
         vector<cl_platform_id> ids(n);
-        err = ::clGetPlatformIDs(n, ids.data(), nullptr);
+        err = CL_(clGetPlatformIDs)(n, ids.data(), nullptr);
         if (err != CL_SUCCESS) {
             return detail::errHandler(err, __GET_PLATFORM_IDS_ERR);
         }
@@ -2918,7 +2929,7 @@ class Platform : public detail::Wrapper<cl_platform_id>
     cl_int
     unloadCompiler()
     {
-        return ::clUnloadPlatformCompiler(object_);
+        return CL_(clUnloadPlatformCompiler)(object_);
     }
 #endif // CL_HPP_TARGET_OPENCL_VERSION >= 120
 }; // class Platform
@@ -2929,14 +2940,14 @@ inline cl_int Device::createSubDevices(const cl_device_partition_property* prope
                          vector<Device>* devices)
 {
     cl_uint n = 0;
-    cl_int err = clCreateSubDevices(object_, properties, 0, nullptr, &n);
+    cl_int err = CL_(clCreateSubDevices)(object_, properties, 0, nullptr, &n);
     if (err != CL_SUCCESS)
     {
         return detail::errHandler(err, __CREATE_SUB_DEVICES_ERR);
     }
 
     vector<cl_device_id> ids(n);
-    err = clCreateSubDevices(object_, properties, n, ids.data(), nullptr);
+    err = CL_(clCreateSubDevices)(object_, properties, n, ids.data(), nullptr);
     if (err != CL_SUCCESS)
     {
         return detail::errHandler(err, __CREATE_SUB_DEVICES_ERR);
@@ -3028,7 +3039,7 @@ UnloadCompiler() CL_API_SUFFIX__VERSION_1_1_DEPRECATED;
 inline cl_int
 UnloadCompiler()
 {
-    return ::clUnloadCompiler();
+    return CL_(clUnloadCompiler)();
 }
 #endif // #if defined(CL_USE_DEPRECATED_OPENCL_1_1_APIS)
 
@@ -3196,7 +3207,7 @@ class Context
             deviceIDs[deviceIndex] = (devices[deviceIndex])();
         }
 
-        object_ = ::clCreateContext(
+        object_ = CL_(clCreateContext)(
             properties, (cl_uint) numDevices,
             deviceIDs.data(),
             notifyFptr, data, &error);
@@ -3226,7 +3237,7 @@ class Context
 
         cl_device_id deviceID = device();
 
-        object_ = ::clCreateContext(
+        object_ = CL_(clCreateContext)(
             properties, 1,
             &deviceID,
             notifyFptr, data, &error);
@@ -3315,7 +3326,7 @@ class Context
             properties = &prop[0];
         }
 #endif
-        object_ = ::clCreateContextFromType(
+        object_ = CL_(clCreateContextFromType)(
             properties, type, notifyFptr, data, &error);
 
         detail::errHandler(error, __CREATE_CONTEXT_FROM_TYPE_ERR);
@@ -3380,7 +3391,7 @@ class Context
     cl_int getInfo(cl_context_info name, T* param) const
     {
         return detail::errHandler(
-            detail::getInfo(&::clGetContextInfo, object_, name, param),
+            detail::getInfo(CL_(clGetContextInfo), object_, name, param),
             __GET_CONTEXT_INFO_ERR);
     }
 
@@ -3413,7 +3424,7 @@ class Context
             return CL_SUCCESS;
         }
 
-        cl_int err = ::clGetSupportedImageFormats(
+        cl_int err = CL_(clGetSupportedImageFormats)(
            object_, 
            flags,
            type, 
@@ -3426,7 +3437,7 @@ class Context
 
         if (numEntries > 0) {
             vector<ImageFormat> value(numEntries);
-            err = ::clGetSupportedImageFormats(
+            err = CL_(clGetSupportedImageFormats)(
                 object_,
                 flags,
                 type,
@@ -3498,7 +3509,7 @@ class Context
         void * user_data = nullptr)
     {
         return detail::errHandler(
-            ::clSetContextDestructorCallback(
+            CL_(clSetContextDestructorCallback)(
                 object_,
                 pfn_notify,
                 user_data),
@@ -3581,7 +3592,7 @@ class Event : public detail::Wrapper<cl_event>
     cl_int getInfo(cl_event_info name, T* param) const
     {
         return detail::errHandler(
-            detail::getInfo(&::clGetEventInfo, object_, name, param),
+            detail::getInfo(CL_(clGetEventInfo), object_, name, param),
             __GET_EVENT_INFO_ERR);
     }
 
@@ -3604,7 +3615,7 @@ class Event : public detail::Wrapper<cl_event>
     cl_int getProfilingInfo(cl_profiling_info name, T* param) const
     {
         return detail::errHandler(detail::getInfo(
-            &::clGetEventProfilingInfo, object_, name, param),
+            CL_(clGetEventProfilingInfo), object_, name, param),
             __GET_EVENT_PROFILE_INFO_ERR);
     }
 
@@ -3629,7 +3640,7 @@ class Event : public detail::Wrapper<cl_event>
     cl_int wait() const
     {
         return detail::errHandler(
-            ::clWaitForEvents(1, &object_),
+            CL_(clWaitForEvents)(1, &object_),
             __WAIT_FOR_EVENTS_ERR);
     }
 
@@ -3644,7 +3655,7 @@ class Event : public detail::Wrapper<cl_event>
         void * user_data = nullptr)
     {
         return detail::errHandler(
-            ::clSetEventCallback(
+            CL_(clSetEventCallback)(
                 object_,
                 type,
                 pfn_notify,
@@ -3664,8 +3675,8 @@ class Event : public detail::Wrapper<cl_event>
         "Size of cl::Event must be equal to size of cl_event");
 
         return detail::errHandler(
-            ::clWaitForEvents(
-                (cl_uint) events.size(), (events.size() > 0) ? (cl_event*)&events.front() : nullptr),
+            CL_(clWaitForEvents)(
+                (cl_uint) events.size(), (events.size() > 0) ? (const cl_event*)&events.front() : nullptr),
             __WAIT_FOR_EVENTS_ERR);
     }
 };
@@ -3687,7 +3698,7 @@ class UserEvent : public Event
         cl_int * err = nullptr)
     {
         cl_int error;
-        object_ = ::clCreateUserEvent(
+        object_ = CL_(clCreateUserEvent)(
             context(),
             &error);
 
@@ -3707,7 +3718,7 @@ class UserEvent : public Event
     cl_int setStatus(cl_int status)
     {
         return detail::errHandler(
-            ::clSetUserEventStatus(object_,status), 
+            CL_(clSetUserEventStatus)(object_,status),
             __SET_USER_EVENT_STATUS_ERR);
     }
 };
@@ -3721,8 +3732,8 @@ inline static cl_int
 WaitForEvents(const vector<Event>& events)
 {
     return detail::errHandler(
-        ::clWaitForEvents(
-            (cl_uint) events.size(), (events.size() > 0) ? (cl_event*)&events.front() : nullptr),
+        CL_(clWaitForEvents)(
+            (cl_uint) events.size(), (events.size() > 0) ? (const cl_event*)&events.front() : nullptr),
         __WAIT_FOR_EVENTS_ERR);
 }
 
@@ -3770,7 +3781,7 @@ class Memory : public detail::Wrapper<cl_mem>
     cl_int getInfo(cl_mem_info name, T* param) const
     {
         return detail::errHandler(
-            detail::getInfo(&::clGetMemObjectInfo, object_, name, param),
+            detail::getInfo(CL_(clGetMemObjectInfo), object_, name, param),
             __GET_MEM_OBJECT_INFO_ERR);
     }
 
@@ -3807,7 +3818,7 @@ class Memory : public detail::Wrapper<cl_mem>
         void * user_data = nullptr)
     {
         return detail::errHandler(
-            ::clSetMemObjectDestructorCallback(
+            CL_(clSetMemObjectDestructorCallback)(
                 object_,
                 pfn_notify,
                 user_data), 
@@ -4002,7 +4013,7 @@ class SVMAllocator {
     {
         // Allocate memory with default alignment matching the size of the type
         void* voidPointer =
-            clSVMAlloc(
+            CL_(clSVMAlloc)(
             context_(),
             SVMTrait::getSVMMemFlags(),
             size*sizeof(T),
@@ -4020,7 +4031,7 @@ class SVMAllocator {
         if (map && !(SVMTrait::getSVMMemFlags() & CL_MEM_SVM_FINE_GRAIN_BUFFER)) {
             cl_int err = enqueueMapSVM(retValue, CL_TRUE, CL_MAP_READ | CL_MAP_WRITE, size*sizeof(T));
             if (err != CL_SUCCESS) {
-                clSVMFree(context_(), retValue);
+                CL_(clSVMFree)(context_(), retValue);
                 retValue = nullptr;
 #if defined(CL_HPP_ENABLE_EXCEPTIONS)
                 std::bad_alloc excep;
@@ -4035,7 +4046,7 @@ class SVMAllocator {
 
     void deallocate(pointer p, size_type)
     {
-        clSVMFree(context_(), p);
+        CL_(clSVMFree)(context_(), p);
     }
 
     /**
@@ -4140,10 +4151,18 @@ cl::pointer<T, detail::Deleter<Alloc>> allocate_pointer(const Alloc &alloc_, Arg
 
     T* tmp = std::allocator_traits<Alloc>::allocate(alloc, copies);
     if (!tmp) {
+#if defined(CL_HPP_ENABLE_EXCEPTIONS)
         std::bad_alloc excep;
         throw excep;
+#else
+        return nullptr;
+#endif
     }
-    try {
+
+#if defined(CL_HPP_ENABLE_EXCEPTIONS)
+    try
+#endif
+    {
         std::allocator_traits<Alloc>::construct(
             alloc,
             std::addressof(*tmp),
@@ -4151,11 +4170,13 @@ cl::pointer<T, detail::Deleter<Alloc>> allocate_pointer(const Alloc &alloc_, Arg
 
         return cl::pointer<T, detail::Deleter<Alloc>>(tmp, detail::Deleter<Alloc>{alloc, copies});
     }
+#if defined(CL_HPP_ENABLE_EXCEPTIONS)
     catch (std::bad_alloc&)
     {
         std::allocator_traits<Alloc>::deallocate(alloc, tmp, copies);
         throw;
     }
+#endif
 }
 
 template< class T, class SVMTrait, class... Args >
@@ -4219,7 +4240,7 @@ class Buffer : public Memory
         cl_int* err = nullptr)
     {
         cl_int error;
-        object_ = ::clCreateBuffer(context(), flags, size, host_ptr, &error);
+        object_ = CL_(clCreateBuffer)(context(), flags, size, host_ptr, &error);
 
         detail::errHandler(error, __CREATE_BUFFER_ERR);
         if (err != nullptr) {
@@ -4249,11 +4270,11 @@ class Buffer : public Memory
         cl_int error;
 
         if (properties.empty()) {
-            object_ = ::clCreateBufferWithProperties(context(), nullptr, flags,
+            object_ = CL_(clCreateBufferWithProperties)(context(), nullptr, flags,
                                                      size, host_ptr, &error);
         }
         else {
-            object_ = ::clCreateBufferWithProperties(
+            object_ = CL_(clCreateBufferWithProperties)(
                 context(), properties.data(), flags, size, host_ptr, &error);
         }
 
@@ -4332,9 +4353,9 @@ class Buffer : public Memory
         Context context = Context::getDefault(err);
 
         if( useHostPtr ) {
-            object_ = ::clCreateBuffer(context(), flags, size, const_cast<DataType*>(&*startIterator), &error);
+            object_ = CL_(clCreateBuffer)(context(), flags, size, const_cast<DataType*>(&*startIterator), &error);
         } else {
-            object_ = ::clCreateBuffer(context(), flags, size, 0, &error);
+            object_ = CL_(clCreateBuffer)(context(), flags, size, 0, &error);
         }
 
         detail::errHandler(error, __CREATE_BUFFER_ERR);
@@ -4405,7 +4426,7 @@ class Buffer : public Memory
     {
         Buffer result;
         cl_int error;
-        result.object_ = ::clCreateSubBuffer(
+        result.object_ = CL_(clCreateSubBuffer)(
             object_, 
             flags, 
             buffer_create_type, 
@@ -4527,7 +4548,7 @@ class BufferGL : public Buffer
         cl_int * err = nullptr)
     {
         cl_int error;
-        object_ = ::clCreateFromGLBuffer(
+        object_ = CL_(clCreateFromGLBuffer)(
             context(),
             flags,
             bufobj,
@@ -4569,7 +4590,7 @@ class BufferGL : public Buffer
         cl_GLuint * gl_object_name)
     {
         return detail::errHandler(
-            ::clGetGLObjectInfo(object_,type,gl_object_name),
+            CL_(clGetGLObjectInfo)(object_,type,gl_object_name),
             __GET_GL_OBJECT_INFO_ERR);
     }
 };
@@ -4597,7 +4618,7 @@ class BufferRenderGL : public Buffer
         cl_int * err = nullptr)
     {
         cl_int error;
-        object_ = ::clCreateFromGLRenderbuffer(
+        object_ = CL_(clCreateFromGLRenderbuffer)(
             context(),
             flags,
             bufobj,
@@ -4639,7 +4660,7 @@ class BufferRenderGL : public Buffer
         cl_GLuint * gl_object_name)
     {
         return detail::errHandler(
-            ::clGetGLObjectInfo(object_,type,gl_object_name),
+            CL_(clGetGLObjectInfo)(object_,type,gl_object_name),
             __GET_GL_OBJECT_INFO_ERR);
     }
 };
@@ -4683,7 +4704,7 @@ class Image : public Memory
     cl_int getImageInfo(cl_image_info name, T* param) const
     {
         return detail::errHandler(
-            detail::getInfo(&::clGetImageInfo, object_, name, param),
+            detail::getInfo(CL_(clGetImageInfo), object_, name, param),
             __GET_IMAGE_INFO_ERR);
     }
     
@@ -4730,7 +4751,7 @@ class Image1D : public Image
         desc.image_type = CL_MEM_OBJECT_IMAGE1D;
         desc.image_width = width;
 
-        object_ = ::clCreateImage(
+        object_ = CL_(clCreateImage)(
             context(), 
             flags, 
             &format, 
@@ -4747,6 +4768,42 @@ class Image1D : public Image
     //! \brief Default constructor - initializes to nullptr.
     Image1D() { }
 
+#if CL_HPP_TARGET_OPENCL_VERSION >= 300
+    /*! \brief Constructs a Image1D with specified properties.
+     *
+     *  Wraps clCreateImageWithProperties().
+     *
+     *  \param properties Optional list of properties for the image object and
+     *                    their corresponding values. The non-empty list must
+     *                    end with 0.
+     *  \param host_ptr Storage to be used if the CL_MEM_USE_HOST_PTR flag was
+     *                  specified. Note alignment & exclusivity requirements.
+     */
+    Image1D(const Context &context, const vector<cl_mem_properties> &properties,
+            cl_mem_flags flags, ImageFormat format, size_type width,
+            void *host_ptr = nullptr, cl_int *err = nullptr) {
+      cl_int error;
+
+      cl_image_desc desc = {};
+      desc.image_type = CL_MEM_OBJECT_IMAGE1D;
+      desc.image_width = width;
+
+      if (properties.empty()) {
+        object_ = CL_(clCreateImageWithProperties)(
+            context(), nullptr, flags, &format, &desc, host_ptr, &error);
+      } else {
+        object_ =
+            CL_(clCreateImageWithProperties)(context(), properties.data(), flags,
+                                          &format, &desc, host_ptr, &error);
+      }
+
+      detail::errHandler(error, __CREATE_IMAGE_ERR);
+      if (err != nullptr) {
+        *err = error;
+      }
+    }
+#endif //#if CL_HPP_TARGET_OPENCL_VERSION >= 300
+
     /*! \brief Constructor from cl_mem - takes ownership.
      *
      * \param retainObject will cause the constructor to retain its cl object.
@@ -4791,7 +4848,7 @@ class Image1DBuffer : public Image
         desc.image_width = width;
         desc.buffer = buffer();
 
-        object_ = ::clCreateImage(
+        object_ = CL_(clCreateImage)(
             context(), 
             flags, 
             &format, 
@@ -4807,6 +4864,43 @@ class Image1DBuffer : public Image
 
     Image1DBuffer() { }
 
+#if CL_HPP_TARGET_OPENCL_VERSION >= 300
+    /*! \brief Constructs a Image1DBuffer with specified properties.
+     *
+     *  Wraps clCreateImageWithProperties().
+     *
+     *  \param properties Optional list of properties for the image object and
+     *                    their corresponding values. The non-empty list must
+     *                    end with 0.
+     *  \param buffer Refer to a valid buffer or image memory object.
+     */
+    Image1DBuffer(const Context &context,
+                  const vector<cl_mem_properties> &properties,
+                  cl_mem_flags flags, ImageFormat format, size_type width,
+                  const Buffer &buffer, cl_int *err = nullptr) {
+      cl_int error;
+
+      cl_image_desc desc = {};
+      desc.image_type = CL_MEM_OBJECT_IMAGE1D_BUFFER;
+      desc.image_width = width;
+      desc.buffer = buffer();
+
+      if (properties.empty()) {
+        object_ = CL_(clCreateImageWithProperties)(
+            context(), nullptr, flags, &format, &desc, nullptr, &error);
+      } else {
+        object_ =
+            CL_(clCreateImageWithProperties)(context(), properties.data(), flags,
+                                          &format, &desc, nullptr, &error);
+      }
+
+      detail::errHandler(error, __CREATE_IMAGE_ERR);
+      if (err != nullptr) {
+        *err = error;
+      }
+    }
+#endif //#if CL_HPP_TARGET_OPENCL_VERSION >= 300
+
     /*! \brief Constructor from cl_mem - takes ownership.
      *
      * \param retainObject will cause the constructor to retain its cl object.
@@ -4822,9 +4916,6 @@ class Image1DBuffer : public Image
         Image::operator=(rhs);
         return *this;
     }
-
-
-
 };
 
 /*! \class Image1DArray
@@ -4851,7 +4942,7 @@ class Image1DArray : public Image
         desc.image_array_size = arraySize;
         desc.image_row_pitch = rowPitch;
 
-        object_ = ::clCreateImage(
+        object_ = CL_(clCreateImage)(
             context(), 
             flags, 
             &format, 
@@ -4866,7 +4957,47 @@ class Image1DArray : public Image
     }
 
     Image1DArray() { }
-  
+
+#if CL_HPP_TARGET_OPENCL_VERSION >= 300
+    /*! \brief Constructs a Image1DArray with specified properties.
+     *
+     *  Wraps clCreateImageWithProperties().
+     *
+     *  \param properties Optional list of properties for the image object and
+     *                    their corresponding values. The non-empty list must
+     *                    end with 0.
+     *  \param host_ptr Storage to be used if the CL_MEM_USE_HOST_PTR flag was
+     *                  specified. Note alignment & exclusivity requirements.
+     */
+    Image1DArray(const Context &context,
+                 const vector<cl_mem_properties> &properties,
+                 cl_mem_flags flags, ImageFormat format, size_type arraySize,
+                 size_type width, size_type rowPitch = 0,
+                 void *host_ptr = nullptr, cl_int *err = nullptr) {
+      cl_int error;
+
+      cl_image_desc desc = {};
+      desc.image_type = CL_MEM_OBJECT_IMAGE1D_ARRAY;
+      desc.image_width = width;
+      desc.image_array_size = arraySize;
+      desc.image_row_pitch = rowPitch;
+
+      if (properties.empty()) {
+        object_ = CL_(clCreateImageWithProperties)(
+            context(), nullptr, flags, &format, &desc, host_ptr, &error);
+      } else {
+        object_ =
+            CL_(clCreateImageWithProperties)(context(), properties.data(), flags,
+                                          &format, &desc, host_ptr, &error);
+      }
+
+      detail::errHandler(error, __CREATE_IMAGE_ERR);
+      if (err != nullptr) {
+        *err = error;
+      }
+    }
+#endif //#if CL_HPP_TARGET_OPENCL_VERSION >= 300
+
     /*! \brief Constructor from cl_mem - takes ownership.
      *
      * \param retainObject will cause the constructor to retain its cl object.
@@ -4936,7 +5067,7 @@ class Image2D : public Image
             desc.image_height = height;
             desc.image_row_pitch = row_pitch;
 
-            object_ = ::clCreateImage(
+            object_ = CL_(clCreateImage)(
                 context(),
                 flags,
                 &format,
@@ -4953,7 +5084,7 @@ class Image2D : public Image
 #if CL_HPP_MINIMUM_OPENCL_VERSION < 120
         if (!useCreateImage)
         {
-            object_ = ::clCreateImage2D(
+            object_ = CL_(clCreateImage2D)(
                 context(), flags,&format, width, height, row_pitch, host_ptr, &error);
 
             detail::errHandler(error, __CREATE_IMAGE2D_ERR);
@@ -4991,7 +5122,7 @@ class Image2D : public Image
         desc.image_row_pitch = row_pitch;
         desc.buffer = sourceBuffer();
 
-        object_ = ::clCreateImage(
+        object_ = CL_(clCreateImage)(
             context(),
             0, // flags inherited from buffer
             &format,
@@ -5054,7 +5185,7 @@ class Image2D : public Image
         desc.num_samples = sourceNumSamples;
         desc.buffer = sourceImage();
 
-        object_ = ::clCreateImage(
+        object_ = CL_(clCreateImage)(
             context(),
             0, // flags should be inherited from mem_object
             &sourceFormat,
@@ -5069,6 +5200,83 @@ class Image2D : public Image
     }
 #endif //#if CL_HPP_TARGET_OPENCL_VERSION >= 200
 
+#if CL_HPP_TARGET_OPENCL_VERSION >= 300
+    /*! \brief Constructs a Image2D with specified properties.
+     *
+     *  Wraps clCreateImageWithProperties().
+     *
+     *  \param properties Optional list of properties for the image object and
+     *                    their corresponding values. The non-empty list must
+     *                    end with 0.
+     *  \param host_ptr Storage to be used if the CL_MEM_USE_HOST_PTR flag was
+     *                  specified. Note alignment & exclusivity requirements.
+     */
+    Image2D(const Context &context, const vector<cl_mem_properties> &properties,
+            cl_mem_flags flags, ImageFormat format, size_type width,
+            size_type height, size_type row_pitch = 0, void *host_ptr = nullptr,
+            cl_int *err = nullptr) {
+      cl_int error;
+
+      cl_image_desc desc = {};
+      desc.image_type = CL_MEM_OBJECT_IMAGE2D;
+      desc.image_width = width;
+      desc.image_height = height;
+      desc.image_row_pitch = row_pitch;
+
+      if (properties.empty()) {
+        object_ = CL_(clCreateImageWithProperties)(
+            context(), nullptr, flags, &format, &desc, host_ptr, &error);
+      } else {
+        object_ =
+            CL_(clCreateImageWithProperties)(context(), properties.data(), flags,
+                                          &format, &desc, host_ptr, &error);
+      }
+
+      detail::errHandler(error, __CREATE_IMAGE_ERR);
+      if (err != nullptr) {
+        *err = error;
+      }
+    }
+
+    /*! \brief Constructs a Image2D with specified properties.
+     *
+     *  Wraps clCreateImageWithProperties().
+     *
+     *  \param properties Optional list of properties for the image object and
+     *                    their corresponding values. The non-empty list must
+     *                    end with 0.
+     *  \param buffer Refer to a valid buffer or image memory object.
+     */
+    Image2D(const Context &context, const vector<cl_mem_properties> &properties,
+            cl_mem_flags flags, ImageFormat format, const Buffer &buffer,
+            size_type width, size_type height, size_type row_pitch = 0,
+            cl_int *err = nullptr) {
+      cl_int error;
+
+      cl_image_desc desc = {};
+      desc.image_type = CL_MEM_OBJECT_IMAGE2D;
+      desc.image_width = width;
+      desc.image_height = height;
+      desc.image_row_pitch = row_pitch;
+      desc.buffer = buffer();
+
+      if (properties.empty()) {
+        object_ = CL_(clCreateImageWithProperties)(
+            context(), nullptr, flags, &format, &desc, nullptr, &error);
+      } else {
+        object_ =
+            CL_(clCreateImageWithProperties)(context(), properties.data(), flags,
+                                          &format, &desc, nullptr, &error);
+      }
+
+      detail::errHandler(error, __CREATE_IMAGE_ERR);
+      if (err != nullptr) {
+        *err = error;
+      }
+    }
+
+#endif //#if CL_HPP_TARGET_OPENCL_VERSION >= 300
+
     //! \brief Default constructor - initializes to nullptr.
     Image2D() { }
 
@@ -5091,10 +5299,6 @@ class Image2D : public Image
         Image::operator=(rhs);
         return *this;
     }
-
-
-
-
 };
 
 
@@ -5125,7 +5329,7 @@ class CL_API_PREFIX__VERSION_1_1_DEPRECATED Image2DGL : public Image2D
         cl_int * err = nullptr)
     {
         cl_int error;
-        object_ = ::clCreateFromGLTexture2D(
+        object_ = CL_(clCreateFromGLTexture2D)(
             context(),
             flags,
             target,
@@ -5197,7 +5401,7 @@ class Image2DArray : public Image
         desc.image_row_pitch = rowPitch;
         desc.image_slice_pitch = slicePitch;
 
-        object_ = ::clCreateImage(
+        object_ = CL_(clCreateImage)(
             context(), 
             flags, 
             &format, 
@@ -5211,6 +5415,49 @@ class Image2DArray : public Image
         }
     }
 
+#if CL_HPP_TARGET_OPENCL_VERSION >= 300
+    /*! \brief Constructs a Image2DArray with specified properties.
+     *
+     *  Wraps clCreateImageWithProperties().
+     *
+     *  \param properties Optional list of properties for the image object and
+     *                    their corresponding values. The non-empty list must
+     *                    end with 0.
+     *  \param host_ptr Storage to be used if the CL_MEM_USE_HOST_PTR flag was
+     *                  specified. Note alignment & exclusivity requirements.
+     */
+    Image2DArray(const Context &context,
+                 const vector<cl_mem_properties> &properties,
+                 cl_mem_flags flags, ImageFormat format, size_type arraySize,
+                 size_type width, size_type height, size_type rowPitch = 0,
+                 size_type slicePitch = 0, void *host_ptr = nullptr,
+                 cl_int *err = nullptr) {
+      cl_int error;
+
+      cl_image_desc desc = {};
+      desc.image_type = CL_MEM_OBJECT_IMAGE2D_ARRAY;
+      desc.image_width = width;
+      desc.image_height = height;
+      desc.image_array_size = arraySize;
+      desc.image_row_pitch = rowPitch;
+      desc.image_slice_pitch = slicePitch;
+
+      if (properties.empty()) {
+        object_ = CL_(clCreateImageWithProperties)(
+            context(), nullptr, flags, &format, &desc, host_ptr, &error);
+      } else {
+        object_ =
+            CL_(clCreateImageWithProperties)(context(), properties.data(), flags,
+                                          &format, &desc, host_ptr, &error);
+      }
+
+      detail::errHandler(error, __CREATE_IMAGE_ERR);
+      if (err != nullptr) {
+        *err = error;
+      }
+    }
+#endif //#if CL_HPP_TARGET_OPENCL_VERSION >= 300
+
     Image2DArray() { }
     
     /*! \brief Constructor from cl_mem - takes ownership.
@@ -5282,7 +5529,7 @@ class Image3D : public Image
             desc.image_row_pitch = row_pitch;
             desc.image_slice_pitch = slice_pitch;
 
-            object_ = ::clCreateImage(
+            object_ = CL_(clCreateImage)(
                 context(), 
                 flags, 
                 &format, 
@@ -5299,7 +5546,7 @@ class Image3D : public Image
 #if CL_HPP_MINIMUM_OPENCL_VERSION < 120
         if (!useCreateImage)
         {
-            object_ = ::clCreateImage3D(
+            object_ = CL_(clCreateImage3D)(
                 context(), flags, &format, width, height, depth, row_pitch,
                 slice_pitch, host_ptr, &error);
 
@@ -5311,6 +5558,48 @@ class Image3D : public Image
 #endif // CL_HPP_MINIMUM_OPENCL_VERSION < 120
     }
 
+#if CL_HPP_TARGET_OPENCL_VERSION >= 300
+    /*! \brief Constructs a Image3D with specified properties.
+     *
+     *  Wraps clCreateImageWithProperties().
+     *
+     *  \param properties Optional list of properties for the image object and
+     *                    their corresponding values. The non-empty list must
+     *                    end with 0.
+     *  \param host_ptr Storage to be used if the CL_MEM_USE_HOST_PTR flag was
+     *                  specified. Note alignment & exclusivity requirements.
+     */
+    Image3D(const Context &context, const vector<cl_mem_properties> &properties,
+            cl_mem_flags flags, ImageFormat format, size_type width,
+            size_type height, size_type depth, size_type row_pitch = 0,
+            size_type slice_pitch = 0, void *host_ptr = nullptr,
+            cl_int *err = nullptr) {
+      cl_int error;
+
+      cl_image_desc desc = {};
+      desc.image_type = CL_MEM_OBJECT_IMAGE3D;
+      desc.image_width = width;
+      desc.image_height = height;
+      desc.image_depth = depth;
+      desc.image_row_pitch = row_pitch;
+      desc.image_slice_pitch = slice_pitch;
+
+      if (properties.empty()) {
+        object_ = CL_(clCreateImageWithProperties)(
+            context(), nullptr, flags, &format, &desc, host_ptr, &error);
+      } else {
+        object_ =
+            CL_(clCreateImageWithProperties)(context(), properties.data(), flags,
+                                          &format, &desc, host_ptr, &error);
+      }
+
+      detail::errHandler(error, __CREATE_IMAGE_ERR);
+      if (err != nullptr) {
+        *err = error;
+      }
+    }
+#endif //#if CL_HPP_TARGET_OPENCL_VERSION >= 300
+
     //! \brief Default constructor - initializes to nullptr.
     Image3D() : Image() { }
 
@@ -5362,7 +5651,7 @@ class Image3DGL : public Image3D
         cl_int * err = nullptr)
     {
         cl_int error;
-        object_ = ::clCreateFromGLTexture3D(
+        object_ = CL_(clCreateFromGLTexture3D)(
             context(),
             flags,
             target,
@@ -5421,7 +5710,7 @@ class ImageGL : public Image
         cl_int * err = nullptr)
     {
         cl_int error;
-        object_ = ::clCreateFromGLTexture(
+        object_ = CL_(clCreateFromGLTexture)(
             context(), 
             flags, 
             target,
@@ -5487,7 +5776,7 @@ class Pipe : public Memory
         cl_int error;
 
         cl_mem_flags flags = CL_MEM_READ_WRITE | CL_MEM_HOST_NO_ACCESS;
-        object_ = ::clCreatePipe(context(), flags, packet_size, max_packets, nullptr, &error);
+        object_ = CL_(clCreatePipe)(context(), flags, packet_size, max_packets, nullptr, &error);
 
         detail::errHandler(error, __CREATE_PIPE_ERR);
         if (err != nullptr) {
@@ -5513,7 +5802,7 @@ class Pipe : public Memory
         Context context = Context::getDefault(err);
 
         cl_mem_flags flags = CL_MEM_READ_WRITE | CL_MEM_HOST_NO_ACCESS;
-        object_ = ::clCreatePipe(context(), flags, packet_size, max_packets, nullptr, &error);
+        object_ = CL_(clCreatePipe)(context(), flags, packet_size, max_packets, nullptr, &error);
 
         detail::errHandler(error, __CREATE_PIPE_ERR);
         if (err != nullptr) {
@@ -5551,7 +5840,7 @@ class Pipe : public Memory
     cl_int getInfo(cl_pipe_info name, T* param) const
     {
         return detail::errHandler(
-            detail::getInfo(&::clGetPipeInfo, object_, name, param),
+            detail::getInfo(CL_(clGetPipeInfo), object_, name, param),
             __GET_PIPE_INFO_ERR);
     }
 
@@ -5605,7 +5894,7 @@ class Sampler : public detail::Wrapper<cl_sampler>
             CL_SAMPLER_ADDRESSING_MODE, addressing_mode,
             CL_SAMPLER_FILTER_MODE, filter_mode,
             0 };
-        object_ = ::clCreateSamplerWithProperties(
+        object_ = CL_(clCreateSamplerWithProperties)(
             context(),
             sampler_properties,
             &error);
@@ -5615,7 +5904,7 @@ class Sampler : public detail::Wrapper<cl_sampler>
             *err = error;
         }
 #else
-        object_ = ::clCreateSampler(
+        object_ = CL_(clCreateSampler)(
             context(),
             normalized_coords,
             addressing_mode,
@@ -5658,7 +5947,7 @@ class Sampler : public detail::Wrapper<cl_sampler>
     cl_int getInfo(cl_sampler_info name, T* param) const
     {
         return detail::errHandler(
-            detail::getInfo(&::clGetSamplerInfo, object_, name, param),
+            detail::getInfo(CL_(clGetSamplerInfo), object_, name, param),
             __GET_SAMPLER_INFO_ERR);
     }
 
@@ -5867,7 +6156,7 @@ class Kernel : public detail::Wrapper<cl_kernel>
     cl_int getInfo(cl_kernel_info name, T* param) const
     {
         return detail::errHandler(
-            detail::getInfo(&::clGetKernelInfo, object_, name, param),
+            detail::getInfo(CL_(clGetKernelInfo), object_, name, param),
             __GET_KERNEL_INFO_ERR);
     }
 
@@ -5889,7 +6178,7 @@ class Kernel : public detail::Wrapper<cl_kernel>
     cl_int getArgInfo(cl_uint argIndex, cl_kernel_arg_info name, T* param) const
     {
         return detail::errHandler(
-            detail::getInfo(&::clGetKernelArgInfo, object_, argIndex, name, param),
+            detail::getInfo(CL_(clGetKernelArgInfo), object_, argIndex, name, param),
             __GET_KERNEL_ARG_INFO_ERR);
     }
 
@@ -5913,7 +6202,7 @@ class Kernel : public detail::Wrapper<cl_kernel>
     {
         return detail::errHandler(
             detail::getInfo(
-                &::clGetKernelWorkGroupInfo, object_, device(), name, param),
+                CL_(clGetKernelWorkGroupInfo), object_, device(), name, param),
                 __GET_KERNEL_WORK_GROUP_INFO_ERR);
     }
 
@@ -5936,7 +6225,7 @@ class Kernel : public detail::Wrapper<cl_kernel>
 #if CL_HPP_TARGET_OPENCL_VERSION >= 210
 
         return detail::errHandler(
-            clGetKernelSubGroupInfo(object_, dev(), name, range.size(), range.get(), sizeof(size_type), param, nullptr),
+            CL_(clGetKernelSubGroupInfo)(object_, dev(), name, range.size(), range.get(), sizeof(size_type), param, nullptr),
             __GET_KERNEL_SUB_GROUP_INFO_ERR);
 
 #else // #if CL_HPP_TARGET_OPENCL_VERSION >= 210
@@ -5971,7 +6260,7 @@ class Kernel : public detail::Wrapper<cl_kernel>
     cl_int setArg(cl_uint index, const cl::pointer<T, D> &argPtr)
     {
         return detail::errHandler(
-            ::clSetKernelArgSVMPointer(object_, index, argPtr.get()),
+            CL_(clSetKernelArgSVMPointer)(object_, index, argPtr.get()),
             __SET_KERNEL_ARGS_ERR);
     }
 
@@ -5981,7 +6270,7 @@ class Kernel : public detail::Wrapper<cl_kernel>
     cl_int setArg(cl_uint index, const cl::vector<T, Alloc> &argPtr)
     {
         return detail::errHandler(
-            ::clSetKernelArgSVMPointer(object_, index, argPtr.data()),
+            CL_(clSetKernelArgSVMPointer)(object_, index, argPtr.data()),
             __SET_KERNEL_ARGS_ERR);
     }
 
@@ -5992,7 +6281,7 @@ class Kernel : public detail::Wrapper<cl_kernel>
         setArg(cl_uint index, const T argPtr)
     {
         return detail::errHandler(
-            ::clSetKernelArgSVMPointer(object_, index, argPtr),
+            CL_(clSetKernelArgSVMPointer)(object_, index, argPtr),
             __SET_KERNEL_ARGS_ERR);
     }
 #endif // #if CL_HPP_TARGET_OPENCL_VERSION >= 200
@@ -6004,7 +6293,7 @@ class Kernel : public detail::Wrapper<cl_kernel>
         setArg(cl_uint index, const T &value)
     {
         return detail::errHandler(
-            ::clSetKernelArg(
+            CL_(clSetKernelArg)(
                 object_,
                 index,
                 detail::KernelArgumentHandler<T>::size(value),
@@ -6015,7 +6304,7 @@ class Kernel : public detail::Wrapper<cl_kernel>
     cl_int setArg(cl_uint index, size_type size, const void* argPtr)
     {
         return detail::errHandler(
-            ::clSetKernelArg(object_, index, size, argPtr),
+            CL_(clSetKernelArg)(object_, index, size, argPtr),
             __SET_KERNEL_ARGS_ERR);
     }
 
@@ -6027,7 +6316,7 @@ class Kernel : public detail::Wrapper<cl_kernel>
     cl_int setSVMPointers(const vector<void*> &pointerList)
     {
         return detail::errHandler(
-            ::clSetKernelExecInfo(
+            CL_(clSetKernelExecInfo)(
                 object_,
                 CL_KERNEL_EXEC_INFO_SVM_PTRS,
                 sizeof(void*)*pointerList.size(),
@@ -6042,7 +6331,7 @@ class Kernel : public detail::Wrapper<cl_kernel>
     cl_int setSVMPointers(const std::array<void*, ArrayLength> &pointerList)
     {
         return detail::errHandler(
-            ::clSetKernelExecInfo(
+            CL_(clSetKernelExecInfo)(
                 object_,
                 CL_KERNEL_EXEC_INFO_SVM_PTRS,
                 sizeof(void*)*pointerList.size(),
@@ -6064,7 +6353,7 @@ class Kernel : public detail::Wrapper<cl_kernel>
     {
         cl_bool svmEnabled_ = svmEnabled ? CL_TRUE : CL_FALSE;
         return detail::errHandler(
-            ::clSetKernelExecInfo(
+            CL_(clSetKernelExecInfo)(
                 object_,
                 CL_KERNEL_EXEC_INFO_SVM_FINE_GRAIN_SYSTEM,
                 sizeof(cl_bool),
@@ -6109,7 +6398,7 @@ class Kernel : public detail::Wrapper<cl_kernel>
 
         setSVMPointersHelper<0, 1 + sizeof...(Ts)>(pointerList, t0, ts...);
         return detail::errHandler(
-            ::clSetKernelExecInfo(
+            CL_(clSetKernelExecInfo)(
             object_,
             CL_KERNEL_EXEC_INFO_SVM_PTRS,
             sizeof(void*)*(1 + sizeof...(Ts)),
@@ -6120,7 +6409,7 @@ class Kernel : public detail::Wrapper<cl_kernel>
     cl_int setExecInfo(cl_kernel_exec_info param_name, const T& val)
     {
         return detail::errHandler(
-            ::clSetKernelExecInfo(
+            CL_(clSetKernelExecInfo)(
             object_,
             param_name,
             sizeof(T),
@@ -6143,7 +6432,7 @@ class Kernel : public detail::Wrapper<cl_kernel>
     Kernel clone()
     {
         cl_int error;
-        Kernel retValue(clCloneKernel(this->get(), &error));
+        Kernel retValue(CL_(clCloneKernel)(this->get(), &error));
 
         detail::errHandler(error, __CLONE_KERNEL_ERR);
         return retValue;
@@ -6177,14 +6466,14 @@ class Program : public detail::Wrapper<cl_program>
 
         Context context = Context::getDefault(err);
 
-        object_ = ::clCreateProgramWithSource(
+        object_ = CL_(clCreateProgramWithSource)(
             context(), (cl_uint)1, &strings, &length, &error);
 
         detail::errHandler(error, __CREATE_PROGRAM_WITH_SOURCE_ERR);
 
         if (error == CL_SUCCESS && build) {
 
-            error = ::clBuildProgram(
+            error = CL_(clBuildProgram)(
                 object_,
                 0,
                 nullptr,
@@ -6215,13 +6504,13 @@ class Program : public detail::Wrapper<cl_program>
         const char * strings = source.c_str();
         const size_type length  = source.size();
 
-        object_ = ::clCreateProgramWithSource(
+        object_ = CL_(clCreateProgramWithSource)(
             context(), (cl_uint)1, &strings, &length, &error);
 
         detail::errHandler(error, __CREATE_PROGRAM_WITH_SOURCE_ERR);
 
         if (error == CL_SUCCESS && build) {
-            error = ::clBuildProgram(
+            error = CL_(clBuildProgram)(
                 object_,
                 0,
                 nullptr,
@@ -6267,7 +6556,7 @@ class Program : public detail::Wrapper<cl_program>
 #endif // #if !defined(CL_HPP_ENABLE_PROGRAM_CONSTRUCTION_FROM_ARRAY_COMPATIBILITY)
         }
 
-        object_ = ::clCreateProgramWithSource(
+        object_ = CL_(clCreateProgramWithSource)(
             context(), (cl_uint)n, strings.data(), lengths.data(), &error);
 
         detail::errHandler(error, __CREATE_PROGRAM_WITH_SOURCE_ERR);
@@ -6302,7 +6591,7 @@ class Program : public detail::Wrapper<cl_program>
 #endif // #if !defined(CL_HPP_ENABLE_PROGRAM_CONSTRUCTION_FROM_ARRAY_COMPATIBILITY)
         }
 
-        object_ = ::clCreateProgramWithSource(
+        object_ = CL_(clCreateProgramWithSource)(
             context(), (cl_uint)n, strings.data(), lengths.data(), &error);
 
         detail::errHandler(error, __CREATE_PROGRAM_WITH_SOURCE_ERR);
@@ -6328,7 +6617,7 @@ class Program : public detail::Wrapper<cl_program>
 
 #if CL_HPP_TARGET_OPENCL_VERSION >= 210
 
-        object_ = ::clCreateProgramWithIL(
+        object_ = CL_(clCreateProgramWithIL)(
             context(), static_cast<const void*>(IL.data()), IL.size(), &error);
 
 #else // #if CL_HPP_TARGET_OPENCL_VERSION >= 210
@@ -6346,7 +6635,7 @@ class Program : public detail::Wrapper<cl_program>
 
         if (error == CL_SUCCESS && build) {
 
-            error = ::clBuildProgram(
+            error = CL_(clBuildProgram)(
                 object_,
                 0,
                 nullptr,
@@ -6382,7 +6671,7 @@ class Program : public detail::Wrapper<cl_program>
 
 #if CL_HPP_TARGET_OPENCL_VERSION >= 210
 
-        object_ = ::clCreateProgramWithIL(
+        object_ = CL_(clCreateProgramWithIL)(
             context(), static_cast<const void*>(IL.data()), IL.size(), &error);
 
 #else // #if CL_HPP_TARGET_OPENCL_VERSION >= 210
@@ -6399,7 +6688,7 @@ class Program : public detail::Wrapper<cl_program>
         detail::errHandler(error, __CREATE_PROGRAM_WITH_IL_ERR);
 
         if (error == CL_SUCCESS && build) {
-            error = ::clBuildProgram(
+            error = CL_(clBuildProgram)(
                 object_,
                 0,
                 nullptr,
@@ -6483,7 +6772,7 @@ class Program : public detail::Wrapper<cl_program>
             binaryStatus->resize(numDevices);
         }
 
-        object_ = ::clCreateProgramWithBinary(
+        object_ = CL_(clCreateProgramWithBinary)(
             context(), (cl_uint) devices.size(),
             deviceIDs.data(),
             lengths.data(), images.data(), (binaryStatus != nullptr && numDevices > 0)
@@ -6517,7 +6806,7 @@ class Program : public detail::Wrapper<cl_program>
             deviceIDs[deviceIndex] = (devices[deviceIndex])();
         }
         
-        object_ = ::clCreateProgramWithBuiltInKernels(
+        object_ = CL_(clCreateProgramWithBuiltInKernels)(
             context(), 
             (cl_uint) devices.size(),
             deviceIDs.data(),
@@ -6571,7 +6860,7 @@ class Program : public detail::Wrapper<cl_program>
             deviceIDs[deviceIndex] = (devices[deviceIndex])();
         }
 
-        cl_int buildError = ::clBuildProgram(
+        cl_int buildError = CL_(clBuildProgram)(
             object_,
             (cl_uint)
             devices.size(),
@@ -6600,7 +6889,7 @@ class Program : public detail::Wrapper<cl_program>
     {
         cl_device_id deviceID = device();
 
-        cl_int buildError = ::clBuildProgram(
+        cl_int buildError = CL_(clBuildProgram)(
             object_,
             1,
             &deviceID,
@@ -6626,7 +6915,7 @@ class Program : public detail::Wrapper<cl_program>
         void (CL_CALLBACK * notifyFptr)(cl_program, void *) = nullptr,
         void* data = nullptr) const
     {
-        cl_int buildError = ::clBuildProgram(
+        cl_int buildError = CL_(clBuildProgram)(
             object_,
             0,
             nullptr,
@@ -6651,7 +6940,7 @@ class Program : public detail::Wrapper<cl_program>
         void (CL_CALLBACK * notifyFptr)(cl_program, void *) = nullptr,
         void* data = nullptr) const
     {
-        cl_int error = ::clCompileProgram(
+        cl_int error = CL_(clCompileProgram)(
             object_,
             0,
             nullptr,
@@ -6687,7 +6976,7 @@ class Program : public detail::Wrapper<cl_program>
         for(const string& name: headerIncludeNames) {
             headerIncludeNamesCStr.push_back(name.c_str());
         }
-        cl_int error = ::clCompileProgram(
+        cl_int error = CL_(clCompileProgram)(
             object_,
             0,
             nullptr,
@@ -6729,7 +7018,7 @@ class Program : public detail::Wrapper<cl_program>
         for(const Device& device: deviceList) {
             deviceIDList.push_back(device());
         }
-        cl_int error = ::clCompileProgram(
+        cl_int error = CL_(clCompileProgram)(
             object_,
             static_cast<cl_uint>(deviceList.size()),
             reinterpret_cast<const cl_device_id*>(deviceIDList.data()),
@@ -6747,7 +7036,7 @@ class Program : public detail::Wrapper<cl_program>
     cl_int getInfo(cl_program_info name, T* param) const
     {
         return detail::errHandler(
-            detail::getInfo(&::clGetProgramInfo, object_, name, param),
+            detail::getInfo(CL_(clGetProgramInfo), object_, name, param),
             __GET_PROGRAM_INFO_ERR);
     }
 
@@ -6770,7 +7059,7 @@ class Program : public detail::Wrapper<cl_program>
     {
         return detail::errHandler(
             detail::getInfo(
-                &::clGetProgramBuildInfo, object_, device(), name, param),
+                CL_(clGetProgramBuildInfo), object_, device(), name, param),
                 __GET_PROGRAM_BUILD_INFO_ERR);
     }
 
@@ -6834,14 +7123,14 @@ class Program : public detail::Wrapper<cl_program>
     cl_int createKernels(vector<Kernel>* kernels)
     {
         cl_uint numKernels;
-        cl_int err = ::clCreateKernelsInProgram(object_, 0, nullptr, &numKernels);
+        cl_int err = CL_(clCreateKernelsInProgram)(object_, 0, nullptr, &numKernels);
         if (err != CL_SUCCESS) {
             return detail::errHandler(err, __CREATE_KERNELS_IN_PROGRAM_ERR);
         }
 
         vector<cl_kernel> value(numKernels);
         
-        err = ::clCreateKernelsInProgram(
+        err = CL_(clCreateKernelsInProgram)(
             object_, numKernels, value.data(), nullptr);
         if (err != CL_SUCCESS) {
             return detail::errHandler(err, __CREATE_KERNELS_IN_PROGRAM_ERR);
@@ -6878,7 +7167,7 @@ class Program : public detail::Wrapper<cl_program>
         void * user_data = nullptr) CL_API_SUFFIX__VERSION_2_2_DEPRECATED
     {
         return detail::errHandler(
-            ::clSetProgramReleaseCallback(
+            CL_(clSetProgramReleaseCallback)(
                 object_,
                 pfn_notify,
                 user_data),
@@ -6895,7 +7184,7 @@ class Program : public detail::Wrapper<cl_program>
         setSpecializationConstant(cl_uint index, const T &value)
     {
         return detail::errHandler(
-            ::clSetProgramSpecializationConstant(
+            CL_(clSetProgramSpecializationConstant)(
                 object_,
                 index,
                 sizeof(value),
@@ -6910,7 +7199,7 @@ class Program : public detail::Wrapper<cl_program>
     cl_int setSpecializationConstant(cl_uint index, size_type size, const void* value)
     {
         return detail::errHandler(
-            ::clSetProgramSpecializationConstant(
+            CL_(clSetProgramSpecializationConstant)(
                 object_,
                 index,
                 size,
@@ -6937,7 +7226,7 @@ inline Program linkProgram(
         detail::errHandler(error_local, __LINK_PROGRAM_ERR);
     }
 
-    cl_program prog = ::clLinkProgram(
+    cl_program prog = CL_(clLinkProgram)(
         ctx(),
         0,
         nullptr,
@@ -6987,7 +7276,7 @@ inline Program linkProgram(
         }
     }
 
-    cl_program prog = ::clLinkProgram(
+    cl_program prog = CL_(clLinkProgram)(
         ctx(),
         0,
         nullptr,
@@ -7038,7 +7327,7 @@ inline cl_int cl::Program::getInfo(cl_program_info name, vector<vector<unsigned
         }
 
         return detail::errHandler(
-            detail::getInfo(&::clGetProgramInfo, object_, name, param),
+            detail::getInfo(CL_(clGetProgramInfo), object_, name, param),
             __GET_PROGRAM_INFO_ERR);
     }
 
@@ -7064,7 +7353,7 @@ inline cl_int cl::Program::setSpecializationConstant(cl_uint index, const bool &
 {
     cl_uchar ucValue = value ? CL_UCHAR_MAX : 0;
     return detail::errHandler(
-        ::clSetProgramSpecializationConstant(
+        CL_(clSetProgramSpecializationConstant)(
             object_,
             index,
             sizeof(ucValue),
@@ -7077,7 +7366,7 @@ inline Kernel::Kernel(const Program& program, const string& name, cl_int* err)
 {
     cl_int error;
 
-    object_ = ::clCreateKernel(program(), name.c_str(), &error);
+    object_ = CL_(clCreateKernel)(program(), name.c_str(), &error);
     detail::errHandler(error, __CREATE_KERNEL_ERR);
 
     if (err != nullptr) {
@@ -7089,7 +7378,7 @@ inline Kernel::Kernel(const Program& program, const char* name, cl_int* err)
 {
     cl_int error;
 
-    object_ = ::clCreateKernel(program(), name, &error);
+    object_ = CL_(clCreateKernel)(program(), name, &error);
     detail::errHandler(error, __CREATE_KERNEL_ERR);
 
     if (err != nullptr) {
@@ -7218,7 +7507,7 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
                 cl_queue_properties queue_properties[] = {
                     CL_QUEUE_PROPERTIES, properties, 0 };
                 if ((properties & CL_QUEUE_ON_DEVICE) == 0) {
-                    object_ = ::clCreateCommandQueueWithProperties(
+                    object_ = CL_(clCreateCommandQueueWithProperties)(
                         context(), device(), queue_properties, &error);
                 }
                 else {
@@ -7233,7 +7522,7 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
 #endif // CL_HPP_TARGET_OPENCL_VERSION >= 200
 #if CL_HPP_MINIMUM_OPENCL_VERSION < 200
             if (!useWithProperties) {
-                object_ = ::clCreateCommandQueue(
+                object_ = CL_(clCreateCommandQueue)(
                     context(), device(), properties, &error);
 
                 detail::errHandler(error, __CREATE_COMMAND_QUEUE_ERR);
@@ -7284,7 +7573,7 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
                cl_queue_properties queue_properties[] = {
                    CL_QUEUE_PROPERTIES, static_cast<cl_queue_properties>(properties), 0 };
 
-               object_ = ::clCreateCommandQueueWithProperties(
+               object_ = CL_(clCreateCommandQueueWithProperties)(
                    context(), device(), queue_properties, &error);
 
                detail::errHandler(error, __CREATE_COMMAND_QUEUE_WITH_PROPERTIES_ERR);
@@ -7295,7 +7584,7 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
 #endif // CL_HPP_TARGET_OPENCL_VERSION >= 200
 #if CL_HPP_MINIMUM_OPENCL_VERSION < 200
            if (!useWithProperties) {
-               object_ = ::clCreateCommandQueue(
+               object_ = CL_(clCreateCommandQueue)(
                    context(), device(), static_cast<cl_command_queue_properties>(properties), &error);
 
                detail::errHandler(error, __CREATE_COMMAND_QUEUE_ERR);
@@ -7349,7 +7638,7 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
             cl_queue_properties queue_properties[] = {
                 CL_QUEUE_PROPERTIES, properties, 0 };
             if ((properties & CL_QUEUE_ON_DEVICE) == 0) {
-                object_ = ::clCreateCommandQueueWithProperties(
+                object_ = CL_(clCreateCommandQueueWithProperties)(
                     context(), devices[0](), queue_properties, &error);
             }
             else {
@@ -7364,7 +7653,7 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
 #endif // CL_HPP_TARGET_OPENCL_VERSION >= 200
 #if CL_HPP_MINIMUM_OPENCL_VERSION < 200
         if (!useWithProperties) {
-            object_ = ::clCreateCommandQueue(
+            object_ = CL_(clCreateCommandQueue)(
                 context(), devices[0](), properties, &error);
 
             detail::errHandler(error, __CREATE_COMMAND_QUEUE_ERR);
@@ -7415,7 +7704,7 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
         if (useWithProperties) {
             cl_queue_properties queue_properties[] = {
                 CL_QUEUE_PROPERTIES, static_cast<cl_queue_properties>(properties), 0 };
-            object_ = ::clCreateCommandQueueWithProperties(
+            object_ = CL_(clCreateCommandQueueWithProperties)(
                 context(), devices[0](), queue_properties, &error);
 
             detail::errHandler(error, __CREATE_COMMAND_QUEUE_WITH_PROPERTIES_ERR);
@@ -7426,7 +7715,7 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
 #endif // CL_HPP_TARGET_OPENCL_VERSION >= 200
 #if CL_HPP_MINIMUM_OPENCL_VERSION < 200
         if (!useWithProperties) {
-            object_ = ::clCreateCommandQueue(
+            object_ = CL_(clCreateCommandQueue)(
                 context(), devices[0](), static_cast<cl_command_queue_properties>(properties), &error);
 
             detail::errHandler(error, __CREATE_COMMAND_QUEUE_ERR);
@@ -7466,7 +7755,7 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
         if (useWithProperties) {
             cl_queue_properties queue_properties[] = {
                 CL_QUEUE_PROPERTIES, properties, 0 };
-            object_ = ::clCreateCommandQueueWithProperties(
+            object_ = CL_(clCreateCommandQueueWithProperties)(
                 context(), device(), queue_properties, &error);
 
             detail::errHandler(error, __CREATE_COMMAND_QUEUE_WITH_PROPERTIES_ERR);
@@ -7477,7 +7766,7 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
 #endif // CL_HPP_TARGET_OPENCL_VERSION >= 200
 #if CL_HPP_MINIMUM_OPENCL_VERSION < 200
         if (!useWithProperties) {
-            object_ = ::clCreateCommandQueue(
+            object_ = CL_(clCreateCommandQueue)(
                 context(), device(), properties, &error);
 
             detail::errHandler(error, __CREATE_COMMAND_QUEUE_ERR);
@@ -7517,7 +7806,7 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
         if (useWithProperties) {
             cl_queue_properties queue_properties[] = {
                 CL_QUEUE_PROPERTIES, static_cast<cl_queue_properties>(properties), 0 };
-            object_ = ::clCreateCommandQueueWithProperties(
+            object_ = CL_(clCreateCommandQueueWithProperties)(
                 context(), device(), queue_properties, &error);
 
             detail::errHandler(error, __CREATE_COMMAND_QUEUE_WITH_PROPERTIES_ERR);
@@ -7528,7 +7817,7 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
 #endif // CL_HPP_TARGET_OPENCL_VERSION >= 200
 #if CL_HPP_MINIMUM_OPENCL_VERSION < 200
         if (!useWithProperties) {
-            object_ = ::clCreateCommandQueue(
+            object_ = CL_(clCreateCommandQueue)(
                 context(), device(), static_cast<cl_command_queue_properties>(properties), &error);
 
             detail::errHandler(error, __CREATE_COMMAND_QUEUE_ERR);
@@ -7590,7 +7879,7 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
     {
         return detail::errHandler(
             detail::getInfo(
-                &::clGetCommandQueueInfo, object_, name, param),
+                CL_(clGetCommandQueueInfo), object_, name, param),
                 __GET_COMMAND_QUEUE_INFO_ERR);
     }
 
@@ -7618,11 +7907,11 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
     {
         cl_event tmp;
         cl_int err = detail::errHandler(
-            ::clEnqueueReadBuffer(
+            CL_(clEnqueueReadBuffer)(
                 object_, buffer(), blocking, offset, size,
                 ptr,
                 (events != nullptr) ? (cl_uint) events->size() : 0,
-                (events != nullptr && events->size() > 0) ? (cl_event*) &events->front() : nullptr,
+                (events != nullptr && events->size() > 0) ? (const cl_event*) &events->front() : nullptr,
                 (event != nullptr) ? &tmp : nullptr),
             __ENQUEUE_READ_BUFFER_ERR);
 
@@ -7643,11 +7932,11 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
     {
         cl_event tmp;
         cl_int err = detail::errHandler(
-            ::clEnqueueWriteBuffer(
+            CL_(clEnqueueWriteBuffer)(
                 object_, buffer(), blocking, offset, size,
                 ptr,
                 (events != nullptr) ? (cl_uint) events->size() : 0,
-                (events != nullptr && events->size() > 0) ? (cl_event*) &events->front() : nullptr,
+                (events != nullptr && events->size() > 0) ? (const cl_event*) &events->front() : nullptr,
                 (event != nullptr) ? &tmp : nullptr),
                 __ENQUEUE_WRITE_BUFFER_ERR);
 
@@ -7668,10 +7957,10 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
     {
         cl_event tmp;
         cl_int err = detail::errHandler(
-            ::clEnqueueCopyBuffer(
+            CL_(clEnqueueCopyBuffer)(
                 object_, src(), dst(), src_offset, dst_offset, size,
                 (events != nullptr) ? (cl_uint) events->size() : 0,
-                (events != nullptr && events->size() > 0) ? (cl_event*) &events->front() : nullptr,
+                (events != nullptr && events->size() > 0) ? (const cl_event*) &events->front() : nullptr,
                 (event != nullptr) ? &tmp : nullptr),
             __ENQEUE_COPY_BUFFER_ERR);
 
@@ -7697,7 +7986,7 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
     {
         cl_event tmp;
         cl_int err = detail::errHandler(
-            ::clEnqueueReadBufferRect(
+            CL_(clEnqueueReadBufferRect)(
                 object_, 
                 buffer(), 
                 blocking,
@@ -7710,7 +7999,7 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
                 host_slice_pitch,
                 ptr,
                 (events != nullptr) ? (cl_uint) events->size() : 0,
-                (events != nullptr && events->size() > 0) ? (cl_event*) &events->front() : nullptr,
+                (events != nullptr && events->size() > 0) ? (const cl_event*) &events->front() : nullptr,
                 (event != nullptr) ? &tmp : nullptr),
                 __ENQUEUE_READ_BUFFER_RECT_ERR);
 
@@ -7765,7 +8054,7 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
     {
         cl_event tmp;
         cl_int err = detail::errHandler(
-            ::clEnqueueWriteBufferRect(
+            CL_(clEnqueueWriteBufferRect)(
                 object_, 
                 buffer(), 
                 blocking,
@@ -7778,7 +8067,7 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
                 host_slice_pitch,
                 ptr,
                 (events != nullptr) ? (cl_uint) events->size() : 0,
-                (events != nullptr && events->size() > 0) ? (cl_event*) &events->front() : nullptr,
+                (events != nullptr && events->size() > 0) ? (const cl_event*) &events->front() : nullptr,
                 (event != nullptr) ? &tmp : nullptr),
                 __ENQUEUE_WRITE_BUFFER_RECT_ERR);
 
@@ -7832,7 +8121,7 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
     {
         cl_event tmp;
         cl_int err = detail::errHandler(
-            ::clEnqueueCopyBufferRect(
+            CL_(clEnqueueCopyBufferRect)(
                 object_, 
                 src(), 
                 dst(), 
@@ -7844,7 +8133,7 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
                 dst_row_pitch,
                 dst_slice_pitch,
                 (events != nullptr) ? (cl_uint) events->size() : 0,
-                (events != nullptr && events->size() > 0) ? (cl_event*) &events->front() : nullptr,
+                (events != nullptr && events->size() > 0) ? (const cl_event*) &events->front() : nullptr,
                 (event != nullptr) ? &tmp : nullptr),
             __ENQEUE_COPY_BUFFER_RECT_ERR);
 
@@ -7905,7 +8194,7 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
     {
         cl_event tmp;
         cl_int err = detail::errHandler(
-            ::clEnqueueFillBuffer(
+            CL_(clEnqueueFillBuffer)(
                 object_, 
                 buffer(),
                 static_cast<void*>(&pattern),
@@ -7913,7 +8202,7 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
                 offset, 
                 size,
                 (events != nullptr) ? (cl_uint) events->size() : 0,
-                (events != nullptr && events->size() > 0) ? (cl_event*) &events->front() : nullptr,
+                (events != nullptr && events->size() > 0) ? (const cl_event*) &events->front() : nullptr,
                 (event != nullptr) ? &tmp : nullptr),
                 __ENQUEUE_FILL_BUFFER_ERR);
 
@@ -7937,7 +8226,7 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
     {
         cl_event tmp;
         cl_int err = detail::errHandler(
-            ::clEnqueueReadImage(
+            CL_(clEnqueueReadImage)(
                 object_, 
                 image(), 
                 blocking, 
@@ -7947,7 +8236,7 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
                 slice_pitch, 
                 ptr,
                 (events != nullptr) ? (cl_uint) events->size() : 0,
-                (events != nullptr && events->size() > 0) ? (cl_event*) &events->front() : nullptr,
+                (events != nullptr && events->size() > 0) ? (const cl_event*) &events->front() : nullptr,
                 (event != nullptr) ? &tmp : nullptr),
             __ENQUEUE_READ_IMAGE_ERR);
 
@@ -7993,7 +8282,7 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
     {
         cl_event tmp;
         cl_int err = detail::errHandler(
-            ::clEnqueueWriteImage(
+            CL_(clEnqueueWriteImage)(
                 object_, 
                 image(), 
                 blocking, 
@@ -8003,7 +8292,7 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
                 slice_pitch, 
                 ptr,
                 (events != nullptr) ? (cl_uint) events->size() : 0,
-                (events != nullptr && events->size() > 0) ? (cl_event*) &events->front() : nullptr,
+                (events != nullptr && events->size() > 0) ? (const cl_event*) &events->front() : nullptr,
                 (event != nullptr) ? &tmp : nullptr),
             __ENQUEUE_WRITE_IMAGE_ERR);
 
@@ -8047,7 +8336,7 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
     {
         cl_event tmp;
         cl_int err = detail::errHandler(
-            ::clEnqueueCopyImage(
+            CL_(clEnqueueCopyImage)(
                 object_, 
                 src(), 
                 dst(), 
@@ -8055,7 +8344,7 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
                 dst_origin.data(), 
                 region.data(),
                 (events != nullptr) ? (cl_uint) events->size() : 0,
-                (events != nullptr && events->size() > 0) ? (cl_event*) &events->front() : nullptr,
+                (events != nullptr && events->size() > 0) ? (const cl_event*) &events->front() : nullptr,
                 (event != nullptr) ? &tmp : nullptr),
             __ENQUEUE_COPY_IMAGE_ERR);
 
@@ -8107,14 +8396,14 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
     {
         cl_event tmp;
         cl_int err = detail::errHandler(
-            ::clEnqueueFillImage(
+            CL_(clEnqueueFillImage)(
                 object_,
                 image(),
                 static_cast<void*>(&fillColor),
                 origin.data(),
                 region.data(),
                 (events != nullptr) ? (cl_uint)events->size() : 0,
-                (events != nullptr && events->size() > 0) ? (cl_event*)&events->front() : NULL,
+                (events != nullptr && events->size() > 0) ? (const cl_event*)&events->front() : NULL,
                 (event != NULL) ? &tmp : nullptr),
             __ENQUEUE_FILL_IMAGE_ERR);
 
@@ -8164,7 +8453,7 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
     {
         cl_event tmp;
         cl_int err = detail::errHandler(
-            ::clEnqueueCopyImageToBuffer(
+            CL_(clEnqueueCopyImageToBuffer)(
                 object_, 
                 src(), 
                 dst(), 
@@ -8172,7 +8461,7 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
                 region.data(), 
                 dst_offset,
                 (events != nullptr) ? (cl_uint) events->size() : 0,
-                (events != nullptr && events->size() > 0) ? (cl_event*) &events->front() : nullptr,
+                (events != nullptr && events->size() > 0) ? (const cl_event*) &events->front() : nullptr,
                 (event != nullptr) ? &tmp : nullptr),
             __ENQUEUE_COPY_IMAGE_TO_BUFFER_ERR);
 
@@ -8212,7 +8501,7 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
     {
         cl_event tmp;
         cl_int err = detail::errHandler(
-            ::clEnqueueCopyBufferToImage(
+            CL_(clEnqueueCopyBufferToImage)(
                 object_, 
                 src(), 
                 dst(), 
@@ -8220,7 +8509,7 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
                 dst_origin.data(), 
                 region.data(),
                 (events != nullptr) ? (cl_uint) events->size() : 0,
-                (events != nullptr && events->size() > 0) ? (cl_event*) &events->front() : nullptr,
+                (events != nullptr && events->size() > 0) ? (const cl_event*) &events->front() : nullptr,
                 (event != nullptr) ? &tmp : nullptr),
             __ENQUEUE_COPY_BUFFER_TO_IMAGE_ERR);
 
@@ -8261,10 +8550,10 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
     {
         cl_event tmp;
         cl_int error;
-        void * result = ::clEnqueueMapBuffer(
+        void * result = CL_(clEnqueueMapBuffer)(
             object_, buffer(), blocking, flags, offset, size,
             (events != nullptr) ? (cl_uint) events->size() : 0,
-            (events != nullptr && events->size() > 0) ? (cl_event*) &events->front() : nullptr,
+            (events != nullptr && events->size() > 0) ? (const cl_event*) &events->front() : nullptr,
             (event != nullptr) ? &tmp : nullptr,
             &error);
 
@@ -8292,13 +8581,13 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
     {
         cl_event tmp;
         cl_int error;
-        void * result = ::clEnqueueMapImage(
+        void * result = CL_(clEnqueueMapImage)(
             object_, image(), blocking, flags,
             origin.data(), 
             region.data(),
             row_pitch, slice_pitch,
             (events != nullptr) ? (cl_uint) events->size() : 0,
-            (events != nullptr && events->size() > 0) ? (cl_event*) &events->front() : nullptr,
+            (events != nullptr && events->size() > 0) ? (const cl_event*) &events->front() : nullptr,
             (event != nullptr) ? &tmp : nullptr,
             &error);
 
@@ -8344,10 +8633,10 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
             const vector<Event> *events = nullptr,
             Event *event = nullptr) const {
         cl_event tmp;
-        cl_int err = detail::errHandler(::clEnqueueSVMMemcpy(
+        cl_int err = detail::errHandler(CL_(clEnqueueSVMMemcpy)(
                 object_, blocking, static_cast<void *>(dst_ptr), static_cast<const void *>(src_ptr), size,
                 (events != nullptr) ? (cl_uint) events->size() : 0,
-                (events != nullptr && events->size() > 0) ? (cl_event *) &events->front() : nullptr,
+                (events != nullptr && events->size() > 0) ? (const cl_event *) &events->front() : nullptr,
                 (event != nullptr) ? &tmp : nullptr), __ENQUEUE_COPY_SVM_ERR);
 
         if (event != nullptr && err == CL_SUCCESS)
@@ -8369,11 +8658,11 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
             const vector<Event> *events = nullptr,
             Event *event = nullptr) const {
         cl_event tmp;
-        cl_int err = detail::errHandler(::clEnqueueSVMMemcpy(
+        cl_int err = detail::errHandler(CL_(clEnqueueSVMMemcpy)(
                 object_, blocking, static_cast<void *>(dst_ptr.get()), static_cast<const void *>(src_ptr.get()),
                 size,
                 (events != nullptr) ? (cl_uint) events->size() : 0,
-                (events != nullptr && events->size() > 0) ? (cl_event *) &events->front() : nullptr,
+                (events != nullptr && events->size() > 0) ? (const cl_event *) &events->front() : nullptr,
                 (event != nullptr) ? &tmp : nullptr), __ENQUEUE_COPY_SVM_ERR);
 
         if (event != nullptr && err == CL_SUCCESS)
@@ -8397,12 +8686,12 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
         if(src_container.size() != dst_container.size()){
             return detail::errHandler(CL_INVALID_VALUE,__ENQUEUE_COPY_SVM_ERR);
         }
-        cl_int err = detail::errHandler(::clEnqueueSVMMemcpy(
+        cl_int err = detail::errHandler(CL_(clEnqueueSVMMemcpy)(
                 object_, blocking, static_cast<void *>(dst_container.data()),
                 static_cast<const void *>(src_container.data()),
                 dst_container.size() * sizeof(T),
                 (events != nullptr) ? (cl_uint) events->size() : 0,
-                (events != nullptr && events->size() > 0) ? (cl_event *) &events->front() : nullptr,
+                (events != nullptr && events->size() > 0) ? (const cl_event *) &events->front() : nullptr,
                 (event != NULL) ? &tmp : nullptr), __ENQUEUE_COPY_SVM_ERR);
 
         if (event != nullptr && err == CL_SUCCESS)
@@ -8423,11 +8712,11 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
             const vector<Event> *events = nullptr,
             Event *event = nullptr) const {
         cl_event tmp;
-        cl_int err = detail::errHandler(::clEnqueueSVMMemFill(
+        cl_int err = detail::errHandler(CL_(clEnqueueSVMMemFill)(
                 object_, static_cast<void *>(ptr), static_cast<void *>(&pattern),
                 sizeof(PatternType), size,
                 (events != nullptr) ? (cl_uint) events->size() : 0,
-                (events != nullptr && events->size() > 0) ? (cl_event *) &events->front() : nullptr,
+                (events != nullptr && events->size() > 0) ? (const cl_event *) &events->front() : nullptr,
                 (event != nullptr) ? &tmp : nullptr), __ENQUEUE_FILL_SVM_ERR);
 
         if (event != nullptr && err == CL_SUCCESS)
@@ -8448,11 +8737,11 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
             const vector<Event> *events = nullptr,
             Event *event = nullptr) const {
         cl_event tmp;
-        cl_int err = detail::errHandler(::clEnqueueSVMMemFill(
+        cl_int err = detail::errHandler(CL_(clEnqueueSVMMemFill)(
                 object_, static_cast<void *>(ptr.get()), static_cast<void *>(&pattern),
                 sizeof(PatternType), size,
                 (events != nullptr) ? (cl_uint) events->size() : 0,
-                (events != nullptr && events->size() > 0) ? (cl_event *) &events->front() : nullptr,
+                (events != nullptr && events->size() > 0) ? (const cl_event *) &events->front() : nullptr,
                 (event != nullptr) ? &tmp : nullptr), __ENQUEUE_FILL_SVM_ERR);
 
         if (event != nullptr && err == CL_SUCCESS)
@@ -8473,11 +8762,11 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
             Event* event = nullptr) const
     {
         cl_event tmp;
-        cl_int err = detail::errHandler(::clEnqueueSVMMemFill(
+        cl_int err = detail::errHandler(CL_(clEnqueueSVMMemFill)(
                 object_, static_cast<void *>(container.data()), static_cast<void *>(&pattern),
                 sizeof(PatternType), container.size() * sizeof(T),
                 (events != nullptr) ? (cl_uint) events->size() : 0,
-                (events != nullptr && events->size() > 0) ? (cl_event *) &events->front() : nullptr,
+                (events != nullptr && events->size() > 0) ? (const cl_event *) &events->front() : nullptr,
                 (event != nullptr) ? &tmp : NULL), __ENQUEUE_FILL_SVM_ERR);
 
         if (event != nullptr && err == CL_SUCCESS)
@@ -8500,10 +8789,10 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
         Event* event = nullptr) const
     {
         cl_event tmp;
-        cl_int err = detail::errHandler(::clEnqueueSVMMap(
+        cl_int err = detail::errHandler(CL_(clEnqueueSVMMap)(
             object_, blocking, flags, static_cast<void*>(ptr), size,
             (events != nullptr) ? (cl_uint)events->size() : 0,
-            (events != nullptr && events->size() > 0) ? (cl_event*)&events->front() : nullptr,
+            (events != nullptr && events->size() > 0) ? (const cl_event*)&events->front() : nullptr,
             (event != nullptr) ? &tmp : nullptr),
             __ENQUEUE_MAP_SVM_ERR);
 
@@ -8528,10 +8817,10 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
         Event* event = nullptr) const
     {
         cl_event tmp;
-        cl_int err = detail::errHandler(::clEnqueueSVMMap(
+        cl_int err = detail::errHandler(CL_(clEnqueueSVMMap)(
             object_, blocking, flags, static_cast<void*>(ptr.get()), size,
             (events != nullptr) ? (cl_uint)events->size() : 0,
-            (events != nullptr && events->size() > 0) ? (cl_event*)&events->front() : nullptr,
+            (events != nullptr && events->size() > 0) ? (const cl_event*)&events->front() : nullptr,
             (event != nullptr) ? &tmp : nullptr),
             __ENQUEUE_MAP_SVM_ERR);
 
@@ -8554,10 +8843,10 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
         Event* event = nullptr) const
     {
         cl_event tmp;
-        cl_int err = detail::errHandler(::clEnqueueSVMMap(
+        cl_int err = detail::errHandler(CL_(clEnqueueSVMMap)(
             object_, blocking, flags, static_cast<void*>(container.data()), container.size()*sizeof(T),
             (events != nullptr) ? (cl_uint)events->size() : 0,
-            (events != nullptr && events->size() > 0) ? (cl_event*)&events->front() : nullptr,
+            (events != nullptr && events->size() > 0) ? (const cl_event*)&events->front() : nullptr,
             (event != nullptr) ? &tmp : nullptr),
             __ENQUEUE_MAP_SVM_ERR);
 
@@ -8576,10 +8865,10 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
     {
         cl_event tmp;
         cl_int err = detail::errHandler(
-            ::clEnqueueUnmapMemObject(
+            CL_(clEnqueueUnmapMemObject)(
                 object_, memory(), mapped_ptr,
                 (events != nullptr) ? (cl_uint) events->size() : 0,
-                (events != nullptr && events->size() > 0) ? (cl_event*) &events->front() : nullptr,
+                (events != nullptr && events->size() > 0) ? (const cl_event*) &events->front() : nullptr,
                 (event != nullptr) ? &tmp : nullptr),
             __ENQUEUE_UNMAP_MEM_OBJECT_ERR);
 
@@ -8603,10 +8892,10 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
     {
         cl_event tmp;
         cl_int err = detail::errHandler(
-            ::clEnqueueSVMUnmap(
+            CL_(clEnqueueSVMUnmap)(
             object_, static_cast<void*>(ptr),
             (events != nullptr) ? (cl_uint)events->size() : 0,
-            (events != nullptr && events->size() > 0) ? (cl_event*)&events->front() : nullptr,
+            (events != nullptr && events->size() > 0) ? (const cl_event*)&events->front() : nullptr,
             (event != nullptr) ? &tmp : nullptr),
             __ENQUEUE_UNMAP_SVM_ERR);
 
@@ -8628,10 +8917,10 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
     {
         cl_event tmp;
         cl_int err = detail::errHandler(
-            ::clEnqueueSVMUnmap(
+            CL_(clEnqueueSVMUnmap)(
             object_, static_cast<void*>(ptr.get()),
             (events != nullptr) ? (cl_uint)events->size() : 0,
-            (events != nullptr && events->size() > 0) ? (cl_event*)&events->front() : nullptr,
+            (events != nullptr && events->size() > 0) ? (const cl_event*)&events->front() : nullptr,
             (event != nullptr) ? &tmp : nullptr),
             __ENQUEUE_UNMAP_SVM_ERR);
 
@@ -8653,10 +8942,10 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
     {
         cl_event tmp;
         cl_int err = detail::errHandler(
-            ::clEnqueueSVMUnmap(
+            CL_(clEnqueueSVMUnmap)(
             object_, static_cast<void*>(container.data()),
             (events != nullptr) ? (cl_uint)events->size() : 0,
-            (events != nullptr && events->size() > 0) ? (cl_event*)&events->front() : nullptr,
+            (events != nullptr && events->size() > 0) ? (const cl_event*)&events->front() : nullptr,
             (event != nullptr) ? &tmp : nullptr),
             __ENQUEUE_UNMAP_SVM_ERR);
 
@@ -8685,10 +8974,10 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
     {
         cl_event tmp;
         cl_int err = detail::errHandler(
-            ::clEnqueueMarkerWithWaitList(
+            CL_(clEnqueueMarkerWithWaitList)(
                 object_,
                 (events != nullptr) ? (cl_uint) events->size() : 0,
-                (events != nullptr && events->size() > 0) ? (cl_event*) &events->front() : nullptr,
+                (events != nullptr && events->size() > 0) ? (const cl_event*) &events->front() : nullptr,
                 (event != nullptr) ? &tmp : nullptr),
             __ENQUEUE_MARKER_WAIT_LIST_ERR);
 
@@ -8715,10 +9004,10 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
     {
         cl_event tmp;
         cl_int err = detail::errHandler(
-            ::clEnqueueBarrierWithWaitList(
+            CL_(clEnqueueBarrierWithWaitList)(
                 object_,
                 (events != nullptr) ? (cl_uint) events->size() : 0,
-                (events != nullptr && events->size() > 0) ? (cl_event*) &events->front() : nullptr,
+                (events != nullptr && events->size() > 0) ? (const cl_event*) &events->front() : nullptr,
                 (event != nullptr) ? &tmp : nullptr),
             __ENQUEUE_BARRIER_WAIT_LIST_ERR);
 
@@ -8748,13 +9037,13 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
         }
         
         cl_int err = detail::errHandler(
-            ::clEnqueueMigrateMemObjects(
+            CL_(clEnqueueMigrateMemObjects)(
                 object_, 
                 (cl_uint)memObjects.size(), 
                 localMemObjects.data(),
                 flags,
                 (events != nullptr) ? (cl_uint) events->size() : 0,
-                (events != nullptr && events->size() > 0) ? (cl_event*) &events->front() : nullptr,
+                (events != nullptr && events->size() > 0) ? (const cl_event*) &events->front() : nullptr,
                 (event != nullptr) ? &tmp : nullptr),
             __ENQUEUE_UNMAP_MEM_OBJECT_ERR);
 
@@ -8781,13 +9070,13 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
         Event* event = nullptr) const
     {
         cl_event tmp;
-        cl_int err = detail::errHandler(::clEnqueueSVMMigrateMem(
+        cl_int err = detail::errHandler(CL_(clEnqueueSVMMigrateMem)(
             object_,
             svmRawPointers.size(), static_cast<void**>(svmRawPointers.data()),
             sizes.data(), // array of sizes not passed
             flags,
             (events != nullptr) ? (cl_uint)events->size() : 0,
-            (events != nullptr && events->size() > 0) ? (cl_event*)&events->front() : nullptr,
+            (events != nullptr && events->size() > 0) ? (const cl_event*)&events->front() : nullptr,
             (event != nullptr) ? &tmp : nullptr),
             __ENQUEUE_MIGRATE_SVM_ERR);
 
@@ -8897,13 +9186,13 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
     {
         cl_event tmp;
         cl_int err = detail::errHandler(
-            ::clEnqueueNDRangeKernel(
+            CL_(clEnqueueNDRangeKernel)(
                 object_, kernel(), (cl_uint) global.dimensions(),
                 offset.dimensions() != 0 ? (const size_type*) offset : nullptr,
                 (const size_type*) global,
                 local.dimensions() != 0 ? (const size_type*) local : nullptr,
                 (events != nullptr) ? (cl_uint) events->size() : 0,
-                (events != nullptr && events->size() > 0) ? (cl_event*) &events->front() : nullptr,
+                (events != nullptr && events->size() > 0) ? (const cl_event*) &events->front() : nullptr,
                 (event != nullptr) ? &tmp : nullptr),
             __ENQUEUE_NDRANGE_KERNEL_ERR);
 
@@ -8921,10 +9210,10 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
     {
         cl_event tmp;
         cl_int err = detail::errHandler(
-            ::clEnqueueTask(
+            CL_(clEnqueueTask)(
                 object_, kernel(),
                 (events != nullptr) ? (cl_uint) events->size() : 0,
-                (events != nullptr && events->size() > 0) ? (cl_event*) &events->front() : nullptr,
+                (events != nullptr && events->size() > 0) ? (const cl_event*) &events->front() : nullptr,
                 (event != nullptr) ? &tmp : nullptr),
             __ENQUEUE_TASK_ERR);
 
@@ -8945,13 +9234,13 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
     {
         cl_event tmp;
         cl_int err = detail::errHandler(
-            ::clEnqueueNativeKernel(
+            CL_(clEnqueueNativeKernel)(
                 object_, userFptr, args.first, args.second,
                 (mem_objects != nullptr) ? (cl_uint) mem_objects->size() : 0,
                 (mem_objects->size() > 0 ) ? reinterpret_cast<const cl_mem *>(mem_objects->data()) : nullptr,
-                (mem_locs != nullptr && mem_locs->size() > 0) ? (const void **) &mem_locs->front() : nullptr,
+                (mem_locs != nullptr && mem_locs->size() > 0) ? const_cast<const void**>(&mem_locs->front()) : nullptr,
                 (events != nullptr) ? (cl_uint) events->size() : 0,
-                (events != nullptr && events->size() > 0) ? (cl_event*) &events->front() : nullptr,
+                (events != nullptr && events->size() > 0) ? (const cl_event*) &events->front() : nullptr,
                 (event != nullptr) ? &tmp : nullptr),
             __ENQUEUE_NATIVE_KERNEL);
 
@@ -8970,7 +9259,7 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
     {
         cl_event tmp;
         cl_int err = detail::errHandler(
-            ::clEnqueueMarker(
+            CL_(clEnqueueMarker)(
                 object_, 
                 (event != nullptr) ? &tmp : nullptr),
             __ENQUEUE_MARKER_ERR);
@@ -8985,7 +9274,7 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
     cl_int enqueueWaitForEvents(const vector<Event>& events) const CL_API_SUFFIX__VERSION_1_1_DEPRECATED
     {
         return detail::errHandler(
-            ::clEnqueueWaitForEvents(
+            CL_(clEnqueueWaitForEvents)(
                 object_,
                 (cl_uint) events.size(),
                 events.size() > 0 ? (const cl_event*) &events.front() : nullptr),
@@ -9000,12 +9289,12 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
      {
         cl_event tmp;
         cl_int err = detail::errHandler(
-             ::clEnqueueAcquireGLObjects(
+             CL_(clEnqueueAcquireGLObjects)(
                  object_,
                  (mem_objects != nullptr) ? (cl_uint) mem_objects->size() : 0,
                  (mem_objects != nullptr && mem_objects->size() > 0) ? (const cl_mem *) &mem_objects->front(): nullptr,
                  (events != nullptr) ? (cl_uint) events->size() : 0,
-                 (events != nullptr && events->size() > 0) ? (cl_event*) &events->front() : nullptr,
+                 (events != nullptr && events->size() > 0) ? (const cl_event*) &events->front() : nullptr,
                  (event != nullptr) ? &tmp : nullptr),
              __ENQUEUE_ACQUIRE_GL_ERR);
 
@@ -9022,12 +9311,12 @@ class CommandQueue : public detail::Wrapper<cl_command_queue>
      {
         cl_event tmp;
         cl_int err = detail::errHandler(
-             ::clEnqueueReleaseGLObjects(
+             CL_(clEnqueueReleaseGLObjects)(
                  object_,
                  (mem_objects != nullptr) ? (cl_uint) mem_objects->size() : 0,
                  (mem_objects != nullptr && mem_objects->size() > 0) ? (const cl_mem *) &mem_objects->front(): nullptr,
                  (events != nullptr) ? (cl_uint) events->size() : 0,
-                 (events != nullptr && events->size() > 0) ? (cl_event*) &events->front() : nullptr,
+                 (events != nullptr && events->size() > 0) ? (const cl_event*) &events->front() : nullptr,
                  (event != nullptr) ? &tmp : nullptr),
              __ENQUEUE_RELEASE_GL_ERR);
 
@@ -9070,7 +9359,7 @@ typedef CL_API_ENTRY cl_int (CL_API_CALL *PFN_clEnqueueReleaseD3D10ObjectsKHR)(
                  (mem_objects != nullptr) ? (cl_uint) mem_objects->size() : 0,
                  (mem_objects != nullptr && mem_objects->size() > 0) ? (const cl_mem *) &mem_objects->front(): nullptr,
                  (events != nullptr) ? (cl_uint) events->size() : 0,
-                 (events != nullptr) ? (cl_event*) &events->front() : nullptr,
+                 (events != nullptr) ? (const cl_event*) &events->front() : nullptr,
                  (event != nullptr) ? &tmp : nullptr),
              __ENQUEUE_ACQUIRE_GL_ERR);
 
@@ -9103,7 +9392,7 @@ typedef CL_API_ENTRY cl_int (CL_API_CALL *PFN_clEnqueueReleaseD3D10ObjectsKHR)(
                 (mem_objects != nullptr) ? (cl_uint) mem_objects->size() : 0,
                 (mem_objects != nullptr && mem_objects->size() > 0) ? (const cl_mem *) &mem_objects->front(): nullptr,
                 (events != nullptr) ? (cl_uint) events->size() : 0,
-                (events != nullptr && events->size() > 0) ? (cl_event*) &events->front() : nullptr,
+                (events != nullptr && events->size() > 0) ? (const cl_event*) &events->front() : nullptr,
                 (event != nullptr) ? &tmp : nullptr),
             __ENQUEUE_RELEASE_GL_ERR);
 
@@ -9122,19 +9411,19 @@ typedef CL_API_ENTRY cl_int (CL_API_CALL *PFN_clEnqueueReleaseD3D10ObjectsKHR)(
     cl_int enqueueBarrier() const CL_API_SUFFIX__VERSION_1_1_DEPRECATED
     {
         return detail::errHandler(
-            ::clEnqueueBarrier(object_),
+            CL_(clEnqueueBarrier)(object_),
             __ENQUEUE_BARRIER_ERR);
     }
 #endif // CL_USE_DEPRECATED_OPENCL_1_1_APIS
 
     cl_int flush() const
     {
-        return detail::errHandler(::clFlush(object_), __FLUSH_ERR);
+        return detail::errHandler(CL_(clFlush)(object_), __FLUSH_ERR);
     }
 
     cl_int finish() const
     {
-        return detail::errHandler(::clFinish(object_), __FINISH_ERR);
+        return detail::errHandler(CL_(clFinish)(object_), __FINISH_ERR);
     }
 }; // CommandQueue
 
@@ -9181,7 +9470,7 @@ class DeviceCommandQueue : public detail::Wrapper<cl_command_queue>
 
         cl_queue_properties queue_properties[] = {
             CL_QUEUE_PROPERTIES, mergedProperties, 0 };
-        object_ = ::clCreateCommandQueueWithProperties(
+        object_ = CL_(clCreateCommandQueueWithProperties)(
             context(), device(), queue_properties, &error);
 
         detail::errHandler(error, __CREATE_COMMAND_QUEUE_WITH_PROPERTIES_ERR);
@@ -9205,7 +9494,7 @@ class DeviceCommandQueue : public detail::Wrapper<cl_command_queue>
             CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE | CL_QUEUE_ON_DEVICE | static_cast<cl_command_queue_properties>(properties);
         cl_queue_properties queue_properties[] = {
             CL_QUEUE_PROPERTIES, mergedProperties, 0 };
-        object_ = ::clCreateCommandQueueWithProperties(
+        object_ = CL_(clCreateCommandQueueWithProperties)(
             context(), device(), queue_properties, &error);
 
         detail::errHandler(error, __CREATE_COMMAND_QUEUE_WITH_PROPERTIES_ERR);
@@ -9232,7 +9521,7 @@ class DeviceCommandQueue : public detail::Wrapper<cl_command_queue>
             CL_QUEUE_PROPERTIES, mergedProperties,
             CL_QUEUE_SIZE, queueSize, 
             0 };
-        object_ = ::clCreateCommandQueueWithProperties(
+        object_ = CL_(clCreateCommandQueueWithProperties)(
             context(), device(), queue_properties, &error);
 
         detail::errHandler(error, __CREATE_COMMAND_QUEUE_WITH_PROPERTIES_ERR);
@@ -9261,7 +9550,7 @@ class DeviceCommandQueue : public detail::Wrapper<cl_command_queue>
     {
         return detail::errHandler(
             detail::getInfo(
-            &::clGetCommandQueueInfo, object_, name, param),
+            CL_(clGetCommandQueueInfo), object_, name, param),
             __GET_COMMAND_QUEUE_INFO_ERR);
     }
 
@@ -9297,7 +9586,7 @@ class DeviceCommandQueue : public detail::Wrapper<cl_command_queue>
             CL_QUEUE_PROPERTIES, properties,
             0 };
         DeviceCommandQueue deviceQueue(
-            ::clCreateCommandQueueWithProperties(
+            CL_(clCreateCommandQueueWithProperties)(
             context(), device(), queue_properties, &error));
 
         detail::errHandler(error, __CREATE_COMMAND_QUEUE_WITH_PROPERTIES_ERR);
@@ -9325,7 +9614,7 @@ class DeviceCommandQueue : public detail::Wrapper<cl_command_queue>
             CL_QUEUE_PROPERTIES, properties,
             0 };
         DeviceCommandQueue deviceQueue(
-            ::clCreateCommandQueueWithProperties(
+            CL_(clCreateCommandQueueWithProperties)(
             context(), device(), queue_properties, &error));
 
         detail::errHandler(error, __CREATE_COMMAND_QUEUE_WITH_PROPERTIES_ERR);
@@ -9354,7 +9643,7 @@ class DeviceCommandQueue : public detail::Wrapper<cl_command_queue>
             CL_QUEUE_SIZE, queueSize,
             0 };
         DeviceCommandQueue deviceQueue(
-            ::clCreateCommandQueueWithProperties(
+            CL_(clCreateCommandQueueWithProperties)(
                 context(), device(), queue_properties, &error));
 
         detail::errHandler(error, __CREATE_COMMAND_QUEUE_WITH_PROPERTIES_ERR);
@@ -9377,7 +9666,7 @@ class DeviceCommandQueue : public detail::Wrapper<cl_command_queue>
     static DeviceCommandQueue updateDefault(const Context &context, const Device &device, const DeviceCommandQueue &default_queue, cl_int *err = nullptr)
     {
         cl_int error;
-        error = clSetDefaultDeviceCommandQueue(context.get(), device.get(), default_queue.get());
+        error = CL_(clSetDefaultDeviceCommandQueue)(context.get(), device.get(), default_queue.get());
 
         detail::errHandler(error, __SET_DEFAULT_DEVICE_COMMAND_QUEUE_ERR);
         if (err != nullptr) {
@@ -9437,9 +9726,9 @@ Buffer::Buffer(
     size_type size = sizeof(DataType)*(endIterator - startIterator);
 
     if( useHostPtr ) {
-        object_ = ::clCreateBuffer(context(), flags, size, const_cast<DataType*>(&*startIterator), &error);
+        object_ = CL_(clCreateBuffer)(context(), flags, size, const_cast<DataType*>(&*startIterator), &error);
     } else {
-        object_ = ::clCreateBuffer(context(), flags, size, 0, &error);
+        object_ = CL_(clCreateBuffer)(context(), flags, size, 0, &error);
     }
 
     detail::errHandler(error, __CREATE_BUFFER_ERR);
@@ -9490,10 +9779,10 @@ Buffer::Buffer(
     Context context = queue.getInfo<CL_QUEUE_CONTEXT>();
 
     if (useHostPtr) {
-        object_ = ::clCreateBuffer(context(), flags, size, const_cast<DataType*>(&*startIterator), &error);
+        object_ = CL_(clCreateBuffer)(context(), flags, size, const_cast<DataType*>(&*startIterator), &error);
     }
     else {
-        object_ = ::clCreateBuffer(context(), flags, size, 0, &error);
+        object_ = CL_(clCreateBuffer)(context(), flags, size, 0, &error);
     }
 
     detail::errHandler(error, __CREATE_BUFFER_ERR);
@@ -9565,10 +9854,10 @@ inline void* enqueueMapBuffer(
         *err = error;
     }
 
-    void * result = ::clEnqueueMapBuffer(
+    void * result = CL_(clEnqueueMapBuffer)(
             queue(), buffer(), blocking, flags, offset, size,
             (events != nullptr) ? (cl_uint) events->size() : 0,
-            (events != nullptr && events->size() > 0) ? (cl_event*) &events->front() : nullptr,
+            (events != nullptr && events->size() > 0) ? (const cl_event*) &events->front() : nullptr,
             (cl_event*) event,
             &error);
 
@@ -9669,10 +9958,10 @@ inline cl_int enqueueUnmapMemObject(
 
     cl_event tmp;
     cl_int err = detail::errHandler(
-        ::clEnqueueUnmapMemObject(
+        CL_(clEnqueueUnmapMemObject)(
         queue(), memory(), mapped_ptr,
         (events != nullptr) ? (cl_uint)events->size() : 0,
-        (events != nullptr && events->size() > 0) ? (cl_event*)&events->front() : nullptr,
+        (events != nullptr && events->size() > 0) ? (const cl_event*)&events->front() : nullptr,
         (event != nullptr) ? &tmp : nullptr),
         __ENQUEUE_UNMAP_MEM_OBJECT_ERR);
 
@@ -9820,15 +10109,15 @@ inline cl_int copy( const CommandQueue &queue, IteratorType startIterator, Itera
     if( error != CL_SUCCESS ) {
         return error;
     }
-#if defined(_MSC_VER)
+#if defined(_MSC_VER) && _MSC_VER < 1920
     std::copy(
-        startIterator, 
-        endIterator, 
+        startIterator,
+        endIterator,
         stdext::checked_array_iterator<DataType*>(
             pointer, length));
 #else
     std::copy(startIterator, endIterator, pointer);
-#endif
+#endif // defined(_MSC_VER) && _MSC_VER < 1920
     Event endEvent;
     error = queue.enqueueUnmapMemObject(buffer, pointer, 0, &endEvent);
     // if exceptions enabled, enqueueUnmapMemObject will throw
@@ -10757,7 +11046,7 @@ class CommandBuffer : public detail::Wrapper<cl_command_buffer_khr>
     {
         return detail::errHandler(
             detail::getInfo(
-                &::clGetCommandBufferInfoKHR, object_, name, param),
+                CL_(clGetCommandBufferInfoKHR), object_, name, param),
                 __GET_COMMAND_BUFFER_INFO_KHR_ERR);
     }
 
@@ -10777,7 +11066,7 @@ class CommandBuffer : public detail::Wrapper<cl_command_buffer_khr>
     cl_int finalize(void)
     {
         return detail::errHandler(
-            ::clFinalizeCommandBufferKHR(object_),
+            CL_(clFinalizeCommandBufferKHR)(object_),
             __FINALIZE_COMMAND_BUFFER_KHR_ERR);
     }
 }; // CommandBuffer
@@ -10923,6 +11212,8 @@ class CommandBuffer : public detail::Wrapper<cl_command_buffer_khr>
 
 #undef CL_HPP_DEFINE_STATIC_MEMBER_
 
+#undef CL_
+
 } // namespace cl
 
 #endif // CL_HPP_