wrap_constants.cpp

    ADD_ATTR(KERNEL_, PRIVATE_MEM_SIZE);
#endif
#if PYOPENCL_CL_VERSION >= 0x1020
    ADD_ATTR(KERNEL_, GLOBAL_WORK_SIZE);
#endif
  }

  {
    py::class_<kernel_sub_group_info> cls(m, "kernel_sub_group_info");
#if PYOPENCL_CL_VERSION >= 0x2010
    ADD_ATTR(KERNEL_, MAX_SUB_GROUP_SIZE_FOR_NDRANGE);
    ADD_ATTR(KERNEL_, SUB_GROUP_COUNT_FOR_NDRANGE);
    ADD_ATTR(KERNEL_, LOCAL_SIZE_FOR_SUB_GROUP_COUNT);
    ADD_ATTR(KERNEL_, MAX_NUM_SUB_GROUPS);
    ADD_ATTR(KERNEL_, COMPILE_NUM_SUB_GROUPS);
#endif
  }

  {
    py::class_<event_info> cls(m, "event_info");
    ADD_ATTR(EVENT_, COMMAND_QUEUE);
    ADD_ATTR(EVENT_, COMMAND_TYPE);
    ADD_ATTR(EVENT_, REFERENCE_COUNT);
    ADD_ATTR(EVENT_, COMMAND_EXECUTION_STATUS);
#if PYOPENCL_CL_VERSION >= 0x1010
    ADD_ATTR(EVENT_, CONTEXT);
#endif
  }

  {
    py::class_<command_type> cls(m, "command_type");
    ADD_ATTR(COMMAND_, NDRANGE_KERNEL);
    ADD_ATTR(COMMAND_, TASK);
    ADD_ATTR(COMMAND_, NATIVE_KERNEL);
    ADD_ATTR(COMMAND_, READ_BUFFER);
    ADD_ATTR(COMMAND_, WRITE_BUFFER);
    ADD_ATTR(COMMAND_, COPY_BUFFER);
    ADD_ATTR(COMMAND_, READ_IMAGE);
    ADD_ATTR(COMMAND_, WRITE_IMAGE);
    ADD_ATTR(COMMAND_, COPY_IMAGE);
    ADD_ATTR(COMMAND_, COPY_IMAGE_TO_BUFFER);
    ADD_ATTR(COMMAND_, COPY_BUFFER_TO_IMAGE);
    ADD_ATTR(COMMAND_, MAP_BUFFER);
    ADD_ATTR(COMMAND_, MAP_IMAGE);
    ADD_ATTR(COMMAND_, UNMAP_MEM_OBJECT);
    ADD_ATTR(COMMAND_, MARKER);
    ADD_ATTR(COMMAND_, ACQUIRE_GL_OBJECTS);
    ADD_ATTR(COMMAND_, RELEASE_GL_OBJECTS);
#if PYOPENCL_CL_VERSION >= 0x1010
    ADD_ATTR(COMMAND_, READ_BUFFER_RECT);
    ADD_ATTR(COMMAND_, WRITE_BUFFER_RECT);
    ADD_ATTR(COMMAND_, COPY_BUFFER_RECT);
    ADD_ATTR(COMMAND_, USER);
#endif
#if PYOPENCL_CL_VERSION >= 0x1020
    ADD_ATTR(COMMAND_, BARRIER);
    ADD_ATTR(COMMAND_, MIGRATE_MEM_OBJECTS);
    ADD_ATTR(COMMAND_, FILL_BUFFER);
    ADD_ATTR(COMMAND_, FILL_IMAGE);
#endif
#if PYOPENCL_CL_VERSION >= 0x2000
    ADD_ATTR(COMMAND_, SVM_FREE);
    ADD_ATTR(COMMAND_, SVM_MEMCPY);
    ADD_ATTR(COMMAND_, SVM_MEMFILL);
    ADD_ATTR(COMMAND_, SVM_MAP);
    ADD_ATTR(COMMAND_, SVM_UNMAP);
#endif
#if PYOPENCL_CL_VERSION >= 0x3000
    ADD_ATTR(COMMAND_, SVM_MIGRATE_MEM);
#endif
  }

  {
    py::class_<command_execution_status> cls(m, "command_execution_status");
    ADD_ATTR(, COMPLETE);
    ADD_ATTR(, RUNNING);
    ADD_ATTR(, SUBMITTED);
    ADD_ATTR(, QUEUED);
  }

  {
    py::class_<profiling_info> cls(m, "profiling_info");
    ADD_ATTR(PROFILING_COMMAND_, QUEUED);
    ADD_ATTR(PROFILING_COMMAND_, SUBMIT);
    ADD_ATTR(PROFILING_COMMAND_, START);
    ADD_ATTR(PROFILING_COMMAND_, END);
#if PYOPENCL_CL_VERSION >= 0x2000
    ADD_ATTR(PROFILING_COMMAND_, COMPLETE);
#endif
  }

/* not needed--filled in automatically by implementation.
#if PYOPENCL_CL_VERSION >= 0x1010
  {
    py::class_<buffer_create_type> cls(m, "buffer_create_type");
    ADD_ATTR(BUFFER_CREATE_TYPE_, REGION);
  }
#endif
*/

  {
    py::class_<mem_migration_flags> cls(
        m, "mem_migration_flags");
#if PYOPENCL_CL_VERSION >= 0x1020
    ADD_ATTR(MIGRATE_MEM_OBJECT_, HOST);
    ADD_ATTR(MIGRATE_MEM_OBJECT_, CONTENT_UNDEFINED);
#endif
  }

  {
    py::class_<device_partition_property> cls(
        m, "device_partition_property");
#if PYOPENCL_CL_VERSION >= 0x1020
    ADD_ATTR(DEVICE_PARTITION_, EQUALLY);
    ADD_ATTR(DEVICE_PARTITION_, BY_COUNTS);
    ADD_ATTR(DEVICE_PARTITION_, BY_COUNTS_LIST_END);
    ADD_ATTR(DEVICE_PARTITION_, BY_AFFINITY_DOMAIN);
#endif
  }

  {
    py::class_<device_affinity_domain> cls(m, "device_affinity_domain");
#if PYOPENCL_CL_VERSION >= 0x1020
    ADD_ATTR(DEVICE_AFFINITY_DOMAIN_, NUMA);
    ADD_ATTR(DEVICE_AFFINITY_DOMAIN_, L4_CACHE);
    ADD_ATTR(DEVICE_AFFINITY_DOMAIN_, L3_CACHE);
    ADD_ATTR(DEVICE_AFFINITY_DOMAIN_, L2_CACHE);
    ADD_ATTR(DEVICE_AFFINITY_DOMAIN_, L1_CACHE);
    ADD_ATTR(DEVICE_AFFINITY_DOMAIN_, NEXT_PARTITIONABLE);
#endif
  }

  {
    py::class_<device_atomic_capabilities> cls(m, "device_atomic_capabilities");
#if PYOPENCL_CL_VERSION >= 0x3000
    ADD_ATTR(DEVICE_ATOMIC_, ORDER_RELAXED);
    ADD_ATTR(DEVICE_ATOMIC_, ORDER_ACQ_REL);
    ADD_ATTR(DEVICE_ATOMIC_, ORDER_SEQ_CST);
    ADD_ATTR(DEVICE_ATOMIC_, SCOPE_WORK_ITEM);
    ADD_ATTR(DEVICE_ATOMIC_, SCOPE_WORK_GROUP);
    ADD_ATTR(DEVICE_ATOMIC_, SCOPE_DEVICE);
    ADD_ATTR(DEVICE_ATOMIC_, SCOPE_ALL_DEVICES);
#endif
  }
  {
    py::class_<device_device_enqueue_capabilities> cls(m, "device_device_enqueue_capabilities");
#if (PYOPENCL_CL_VERSION >= 0x3000) && defined(CL_DEVICE_DEVICE_ENQUEUE_CAPABILITIES)
    ADD_ATTR(DEVICE_QUEUE_, SUPPORTED);
    ADD_ATTR(DEVICE_QUEUE_, REPLACEABLE_DEFAULT);
#endif
  }

  {
    py::class_<version_bits> cls(m, "version_bits");
#if PYOPENCL_CL_VERSION >= 0x3000
    ADD_ATTR(VERSION_, MAJOR_BITS);
    ADD_ATTR(VERSION_, MINOR_BITS);
    ADD_ATTR(VERSION_, PATCH_BITS);

    ADD_ATTR(VERSION_, MAJOR_MASK);
    ADD_ATTR(VERSION_, MINOR_MASK);
    ADD_ATTR(VERSION_, PATCH_MASK);
#endif
  }

  {
    py::class_<khronos_vendor_id> cls(m, "khronos_vendor_id");
#if PYOPENCL_CL_VERSION >= 0x3000
    ADD_ATTR(KHRONOS_VENDOR_ID_, CODEPLAY);
#endif
  }


#ifdef HAVE_GL
  {
    py::class_<gl_object_type> cls(m, "gl_object_type");
    ADD_ATTR(GL_OBJECT_, BUFFER);
    ADD_ATTR(GL_OBJECT_, TEXTURE2D);
    ADD_ATTR(GL_OBJECT_, TEXTURE3D);
    ADD_ATTR(GL_OBJECT_, RENDERBUFFER);
  }

  {
    py::class_<gl_texture_info> cls(m, "gl_texture_info");
    ADD_ATTR(GL_, TEXTURE_TARGET);
    ADD_ATTR(GL_, MIPMAP_LEVEL);
  }
#endif

  // }}}

  // {{{ cl_name_version
#if PYOPENCL_CL_VERSION >= 0x3000
  {
    typedef cl_name_version cls;
    py::class_<cls>(m, "NameVersion")
      .def(py::init(
            [](cl_version version, const char* name)
            {
              cl_name_version result;
              result.version = version;
              result.name[0] = '\0';
              // https://stackoverflow.com/a/1258577
              strncat(result.name, name, CL_NAME_VERSION_MAX_NAME_SIZE-1);
              return result;
            }),
          py::arg("version")=0,
          py::arg("name")=0)

      .def_property("version",
          [](cls &t) { return t.version; },
          [](cls &t, cl_version val) { t.version = val; })
      .def_property("name",
          [](cls &t) { return t.name; },
          [](cls &t, const char *name)
          {
              t.name[0] = '\0';
              // https://stackoverflow.com/a/1258577
              strncat(t.name, name, CL_NAME_VERSION_MAX_NAME_SIZE-1);
          })
      ;
  }
#endif
  // }}}

  // {{{ CL_DEVICE_TOPOLOGY_AMD

#ifdef CL_DEVICE_TOPOLOGY_AMD
  {
    typedef cl_device_topology_amd cls;
    py::class_<cls>(m, "DeviceTopologyAmd")
      .def(py::init(
            [](cl_char bus, cl_char device, cl_char function)
            {
              cl_device_topology_amd result;
              result.pcie.type = CL_DEVICE_TOPOLOGY_TYPE_PCIE_AMD;
              result.pcie.bus = bus;
              result.pcie.device = device;
              result.pcie.function = function;
              return result;
            }),
          py::arg("bus")=0,
          py::arg("device")=0,
          py::arg("function")=0)

      .def_property("type",
          [](cls &t) { return t.pcie.type; },
          [](cls &t, cl_uint val) { t.pcie.type = val; })

      .def_property("bus",
          [](cls &t) { return t.pcie.bus; },
          [](cls &t, cl_char val) { t.pcie.bus = val; })
      .def_property("device",
          [](cls &t) { return t.pcie.device; },
          [](cls &t, cl_char val) { t.pcie.device = val; })
      .def_property("function",
          [](cls &t) { return t.pcie.function; },
          [](cls &t, cl_char val) { t.pcie.function = val; })
      ;
  }
#endif

  // }}}

}




// vim: foldmethod=marker