genesis init

.github/workflows/release.yml

+name: "Build And Release"
+
+on:
+  push:
+    branches:
+      - main
+      
+jobs:
+  build_for_windows:
+    name: "Build for Windows"
+    runs-on: [windows-2022]
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v3
+
+      - uses: ilammy/msvc-dev-cmd@v1
+        with:
+          vsversion: 2022
+          
+      - name: "Build"
+        shell: cmd
+        run: |
+          cl.exe /c /I"${{ github.workspace }}\Curl\include" /I"${{ github.workspace }}\OpenCL\include" /Zi /nologo /W1 /WX- /diagnostics:column /O2 /D BUILDING_LIBCURL /D HTTP_ONLY /Gm- /EHsc /MD /GS /fp:precise /Zc:wchar_t /Zc:forScope /Zc:inline /Fo"${{ github.workspace }}\dist\\" /Fe"${{ github.workspace }}\dist\\" /external:W1 /Gd /TP /FC /errorReport:prompt Dispatcher.cpp Mode.cpp precomp.cpp profanity.cpp SpeedSample.cpp
+          link.exe /ERRORREPORT:PROMPT /OUT:"${{ github.workspace }}\dist\profanity.exe" /NOLOGO /LIBPATH:"${{ github.workspace }}\Curl\lib" /LIBPATH:"${{ github.workspace }}\OpenCL\lib" OpenCL.lib libcurl_a.lib ws2_32.lib winmm.lib wldap32.lib crypt32.lib normaliz.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /MANIFEST /MANIFESTUAC:"level='asInvoker' uiAccess='false'" /manifest:embed /DEBUG:FULL /PDB:"${{ github.workspace }}\dist\profanity.pdb" /TLBID:1 /DYNAMICBASE /NXCOMPAT /IMPLIB:"${{ github.workspace }}\dist\profanity.lib" /MACHINE:X64 "${{ github.workspace }}\dist\*.obj"
+
+      - name: "Build Assets"
+        run: dir ${{ github.workspace }}/dist/*.*
+
+      - name: "Compress"
+        shell: powershell
+        run: Compress-Archive -Path ${{ github.workspace }}/dist/profanity.exe,${{ github.workspace }}/dist/README.md,${{ github.workspace }}/dist/start.bat,${{ github.workspace }}/profanity.txt -Destination ${{ github.workspace }}/dist/windows.zip
+
+      - uses: ncipollo/release-action@v1
+        with:
+          artifacts: "${{ github.workspace }}/dist/windows.zip"
+          token: ${{ secrets.GH_TOKEN }}
+          tag: v1.1.4
+          draft: true
+          allowUpdates: true
+          replacesArtifacts: true
\ No newline at end of file

.gitignore

+# Makefile artifacts
+*.o
+*.so
+cache-opencl.*
+bin
+.DS_store
+README_dev.md

.vscode/c_cpp_properties.json

+{
+    "configurations": [
+        {
+            "name": "Mac",
+            "includePath": [
+                "${workspaceFolder}/**"
+            ],
+            "defines": [],
+            "macFrameworkPath": [
+                "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks"
+            ],
+            "compilerPath": "/usr/bin/clang++",
+            "cStandard": "c17",
+            "cppStandard": "c++17",
+            "intelliSenseMode": "macos-clang-arm64"
+        }
+    ],
+    "version": 4
+}
\ No newline at end of file

.vscode/launch.json

+{
+  "version": "0.2.0",
+  "configurations": [
+      {
+          "name": "clang++ build and debug active file",
+          "type": "lldb",
+          "request": "launch",
+          "program": "${fileDirname}/${fileBasenameNoExtension}.out",
+          "args": [],
+          "cwd": "${workspaceFolder}",
+          "preLaunchTask": "clang++ build active file"
+      }
+  ]
+}
\ No newline at end of file

.vscode/settings.json

+{
+  "files.associations": {
+    "typeinfo": "cpp",
+    "iostream": "cpp",
+    "ostream": "cpp",
+    "string": "cpp",
+    "iosfwd": "cpp",
+    "__bit_reference": "cpp",
+    "__config": "cpp",
+    "__debug": "cpp",
+    "__errc": "cpp",
+    "__functional_base": "cpp",
+    "__hash_table": "cpp",
+    "__locale": "cpp",
+    "__mutex_base": "cpp",
+    "__node_handle": "cpp",
+    "__nullptr": "cpp",
+    "__split_buffer": "cpp",
+    "__string": "cpp",
+    "__threading_support": "cpp",
+    "__tree": "cpp",
+    "__tuple": "cpp",
+    "algorithm": "cpp",
+    "array": "cpp",
+    "atomic": "cpp",
+    "bit": "cpp",
+    "bitset": "cpp",
+    "cctype": "cpp",
+    "chrono": "cpp",
+    "cmath": "cpp",
+    "complex": "cpp",
+    "cstdarg": "cpp",
+    "cstddef": "cpp",
+    "cstdint": "cpp",
+    "cstdio": "cpp",
+    "cstdlib": "cpp",
+    "cstring": "cpp",
+    "ctime": "cpp",
+    "cwchar": "cpp",
+    "cwctype": "cpp",
+    "deque": "cpp",
+    "exception": "cpp",
+    "fstream": "cpp",
+    "functional": "cpp",
+    "initializer_list": "cpp",
+    "iomanip": "cpp",
+    "ios": "cpp",
+    "istream": "cpp",
+    "iterator": "cpp",
+    "limits": "cpp",
+    "list": "cpp",
+    "locale": "cpp",
+    "map": "cpp",
+    "memory": "cpp",
+    "mutex": "cpp",
+    "new": "cpp",
+    "numeric": "cpp",
+    "optional": "cpp",
+    "random": "cpp",
+    "ratio": "cpp",
+    "set": "cpp",
+    "sstream": "cpp",
+    "stack": "cpp",
+    "stdexcept": "cpp",
+    "streambuf": "cpp",
+    "string_view": "cpp",
+    "system_error": "cpp",
+    "tuple": "cpp",
+    "type_traits": "cpp",
+    "unordered_map": "cpp",
+    "utility": "cpp",
+    "vector": "cpp",
+    "filesystem": "cpp",
+    "thread": "cpp",
+    "clocale": "cpp"
+  },
+  "C_Cpp.errorSquiggles": "disabled"
+}

.vscode/tasks.json

+{
+	"version": "2.0.0",
+	"tasks": [
+		{
+			"label": "clang++ build active file",
+			"type": "shell",
+			"command": "clang++",
+			"args": [
+				"${fileBasename}",
+				"-o",
+				"${fileBasenameNoExtension}.out",
+				"-g",
+				"-std=c++11"
+			],
+			"group": {
+				"kind": "build",
+				"isDefault": true
+			}
+		},
+	]
+}
\ No newline at end of file

ArgParser.hpp

+#ifndef HPP_ARGPARSER
+#define HPP_ARGPARSER
+
+#include <type_traits>
+#include <stdexcept>
+#include <vector>
+#include <map>
+#include "lexical_cast.hpp"
+
+class ArgParser {
+	private:
+		class IArgument {
+			public:
+				virtual ~IArgument() {}
+				virtual void parse(const std::string & s) = 0;
+		};
+
+		template <typename T>
+		class Argument : public IArgument {
+			public:
+				Argument(T & t) : m_t(t) {}
+				~Argument() {}
+	
+				void parse(const std::string & s) {
+					m_t = fromString<T>(s);
+				}
+	
+			private:
+				T & m_t;
+		};
+
+		template <typename T>
+		class MultiArgument : public IArgument {
+			public:
+				MultiArgument(std::vector<T> & t) : m_t(t) {}
+				MultiArgument() {}
+
+				void parse(const std::string & s) {
+					m_t.push_back(fromString<T>(s));
+				}
+
+			private:
+				std::vector<T> & m_t;
+		};
+
+	public:
+		ArgParser(int argc, char * * argv) {
+			for (int i = 1; i < argc; ++i) {
+				m_args.push_back(argv[i]);
+			}
+		}
+
+		~ArgParser() {
+			for (auto & i : m_mapArgs) {
+				delete i.second.second; // :)
+			}
+		}
+
+		template <typename T>
+		void addSwitch(const char switchShort, const std::string switchLong, T & t) {
+			const std::string strShort = std::string("-") + switchShort;
+			const std::string strLong = std::string("--") + switchLong;
+
+			// :)
+			IArgument * const pArgShort = new Argument<T>(t);
+			IArgument * const pArgLong = new Argument<T>(t);
+			m_mapArgs[strShort] = std::pair<bool, IArgument *>(std::is_same<bool, T>::value, pArgShort);
+			m_mapArgs[strLong] = std::pair<bool, IArgument *>(std::is_same<bool, T>::value, pArgLong);
+		}
+
+		template <typename T>
+		void addMultiSwitch(const char switchShort, const std::string switchLong, std::vector<T> & t) {
+			const std::string strShort = std::string("-") + switchShort;
+			const std::string strLong = std::string("--") + switchLong;
+
+			// :)
+			IArgument * const pArgShort = new MultiArgument<T>(t);
+			IArgument * const pArgLong = new MultiArgument<T>(t);
+			m_mapArgs[strShort] = std::pair<bool, IArgument *>(false, pArgShort);
+			m_mapArgs[strLong] = std::pair<bool, IArgument *>(false, pArgLong);
+		}
+
+		bool parse() const {
+			try {
+				std::vector<std::string>::size_type i = 0;
+
+				while (i < m_args.size()) {
+					auto p = m_mapArgs.at(m_args[i]);
+					const std::string s = p.first ? "1" : m_args.at(i + 1);
+
+					p.second->parse(s);
+					i += (p.first ? 1 : 2);
+				}
+			}
+			catch (std::out_of_range & e) {
+				return false;
+			}
+
+			return true;
+		}
+
+	private:
+		std::vector<std::string> m_args;
+		std::map<std::string, std::pair<bool, IArgument *>> m_mapArgs;
+};
+
+#endif /* HPP_ARGPARSER */
\ No newline at end of file

CLMemory.hpp

+#ifndef HPP_CLMEMORY
+#define HPP_CLMEMORY
+
+#include "lexical_cast.hpp"
+
+template<typename T> class CLMemory {
+	public:
+		CLMemory(cl_context & clContext, cl_command_queue & clQueue, const cl_mem_flags flags, const size_t size, T * const pData)
+		 : m_clQueue(clQueue), m_bFree(false), m_size(size), m_pData(pData) {
+			 m_clMem = clCreateBuffer(clContext, flags, m_size, NULL, NULL);
+		}
+
+		CLMemory(cl_context & clContext, cl_command_queue & clQueue, const cl_mem_flags flags, const size_t count, const bool noAllocation = false)
+		 : m_clQueue(clQueue), m_bFree(true), m_size(sizeof(T) * count), m_pData(noAllocation ? NULL : new T[count]) {
+			m_clMem = clCreateBuffer(clContext, flags, m_size, NULL, NULL);
+		}
+
+		~CLMemory() {
+			if(m_bFree) {
+				delete [] m_pData;
+			}
+		}
+
+		static void setKernelArg(cl_kernel & clKernel, const cl_uint arg_index, const T & t) {
+			const cl_int ret = clSetKernelArg(clKernel, arg_index, sizeof(T), (void *) &t);
+			if (ret != CL_SUCCESS) {
+				throw std::runtime_error("clSetKernelArg failed - " + toString(arg_index) + " - " + toString(ret));
+			}
+		}
+
+		void setKernelArg(cl_kernel & clKernel, const cl_uint arg_index) const {
+			const cl_int ret = clSetKernelArg(clKernel, arg_index, sizeof(cl_mem), (void *) &m_clMem );
+			if( ret != CL_SUCCESS ) {
+				throw std::runtime_error("clSetKernelArg failed - " + toString(arg_index) + " - " + toString(ret));
+			}
+		}
+
+		void read(const bool bBlock, cl_event * pEvent = NULL) const {
+			const cl_bool block = bBlock ? CL_TRUE : CL_FALSE;
+			auto res = clEnqueueReadBuffer(m_clQueue, m_clMem, block, 0, m_size, m_pData, 0, NULL, pEvent);
+			if(res != CL_SUCCESS) {
+				throw std::runtime_error("clEnqueueReadBuffer failed - " + toString(res));
+			}
+		}
+
+		void write(const bool bBlock) const {
+			const cl_bool block = bBlock ? CL_TRUE : CL_FALSE;
+			auto res = clEnqueueWriteBuffer(m_clQueue, m_clMem, block, 0, m_size, m_pData, 0, NULL, NULL);
+			if( res != CL_SUCCESS ) {
+				throw std::runtime_error("clEnqueueWriteBuffer failed - " + toString(res));
+			}
+		}
+
+		T * const & data() const {
+			return m_pData;
+		}
+
+		T & operator[] (int x) const {
+			return m_pData[x];
+		}
+
+		T * operator->() const {
+			return m_pData;
+		}
+
+		T & operator*() const {
+			return *m_pData;
+		}
+
+		const size_t & size() const {
+			return m_size;
+		}
+
+	private:
+		const cl_command_queue m_clQueue;
+		const bool m_bFree;
+		const size_t m_size;
+
+		T * const m_pData;
+		cl_mem m_clMem;
+};
+
+#endif /* HPP_CLMEMORY */
\ No newline at end of file

Curl/include/curl/curlver.h

+#ifndef CURLINC_CURLVER_H
+#define CURLINC_CURLVER_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at https://curl.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ * SPDX-License-Identifier: curl
+ *
+ ***************************************************************************/
+
+/* This header file contains nothing but libcurl version info, generated by
+   a script at release-time. This was made its own header file in 7.11.2 */
+
+/* This is the global package copyright */
+#define LIBCURL_COPYRIGHT "Daniel Stenberg, <daniel@haxx.se>."
+
+/* This is the version number of the libcurl package from which this header
+   file origins: */
+#define LIBCURL_VERSION "8.0.1"
+
+/* The numeric version number is also available "in parts" by using these
+   defines: */
+#define LIBCURL_VERSION_MAJOR 8
+#define LIBCURL_VERSION_MINOR 0
+#define LIBCURL_VERSION_PATCH 1
+
+/* This is the numeric version of the libcurl version number, meant for easier
+   parsing and comparisons by programs. The LIBCURL_VERSION_NUM define will
+   always follow this syntax:
+
+         0xXXYYZZ
+
+   Where XX, YY and ZZ are the main version, release and patch numbers in
+   hexadecimal (using 8 bits each). All three numbers are always represented
+   using two digits.  1.2 would appear as "0x010200" while version 9.11.7
+   appears as "0x090b07".
+
+   This 6-digit (24 bits) hexadecimal number does not show pre-release number,
+   and it is always a greater number in a more recent release. It makes
+   comparisons with greater than and less than work.
+
+   Note: This define is the full hex number and _does not_ use the
+   CURL_VERSION_BITS() macro since curl's own configure script greps for it
+   and needs it to contain the full number.
+*/
+#define LIBCURL_VERSION_NUM 0x080001
+
+/*
+ * This is the date and time when the full source package was created. The
+ * timestamp is not stored in git, as the timestamp is properly set in the
+ * tarballs by the maketgz script.
+ *
+ * The format of the date follows this template:
+ *
+ * "2007-11-23"
+ */
+#define LIBCURL_TIMESTAMP "2023-03-20"
+
+#define CURL_VERSION_BITS(x,y,z) ((x)<<16|(y)<<8|(z))
+#define CURL_AT_LEAST_VERSION(x,y,z) \
+  (LIBCURL_VERSION_NUM >= CURL_VERSION_BITS(x, y, z))
+
+#endif /* CURLINC_CURLVER_H */

Curl/include/curl/easy.h

+#ifndef CURLINC_EASY_H
+#define CURLINC_EASY_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at https://curl.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ * SPDX-License-Identifier: curl
+ *
+ ***************************************************************************/
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+/* Flag bits in the curl_blob struct: */
+#define CURL_BLOB_COPY   1 /* tell libcurl to copy the data */
+#define CURL_BLOB_NOCOPY 0 /* tell libcurl to NOT copy the data */
+
+struct curl_blob {
+  void *data;
+  size_t len;
+  unsigned int flags; /* bit 0 is defined, the rest are reserved and should be
+                         left zeroes */
+};
+
+CURL_EXTERN CURL *curl_easy_init(void);
+CURL_EXTERN CURLcode curl_easy_setopt(CURL *curl, CURLoption option, ...);
+CURL_EXTERN CURLcode curl_easy_perform(CURL *curl);
+CURL_EXTERN void curl_easy_cleanup(CURL *curl);
+
+/*
+ * NAME curl_easy_getinfo()
+ *
+ * DESCRIPTION
+ *
+ * Request internal information from the curl session with this function.  The
+ * third argument MUST be a pointer to a long, a pointer to a char * or a
+ * pointer to a double (as the documentation describes elsewhere).  The data
+ * pointed to will be filled in accordingly and can be relied upon only if the
+ * function returns CURLE_OK.  This function is intended to get used *AFTER* a
+ * performed transfer, all results from this function are undefined until the
+ * transfer is completed.
+ */
+CURL_EXTERN CURLcode curl_easy_getinfo(CURL *curl, CURLINFO info, ...);
+
+
+/*
+ * NAME curl_easy_duphandle()
+ *
+ * DESCRIPTION
+ *
+ * Creates a new curl session handle with the same options set for the handle
+ * passed in. Duplicating a handle could only be a matter of cloning data and
+ * options, internal state info and things like persistent connections cannot
+ * be transferred. It is useful in multithreaded applications when you can run
+ * curl_easy_duphandle() for each new thread to avoid a series of identical
+ * curl_easy_setopt() invokes in every thread.
+ */
+CURL_EXTERN CURL *curl_easy_duphandle(CURL *curl);
+
+/*
+ * NAME curl_easy_reset()
+ *
+ * DESCRIPTION
+ *
+ * Re-initializes a CURL handle to the default values. This puts back the
+ * handle to the same state as it was in when it was just created.
+ *
+ * It does keep: live connections, the Session ID cache, the DNS cache and the
+ * cookies.
+ */
+CURL_EXTERN void curl_easy_reset(CURL *curl);
+
+/*
+ * NAME curl_easy_recv()
+ *
+ * DESCRIPTION
+ *
+ * Receives data from the connected socket. Use after successful
+ * curl_easy_perform() with CURLOPT_CONNECT_ONLY option.
+ */
+CURL_EXTERN CURLcode curl_easy_recv(CURL *curl, void *buffer, size_t buflen,
+                                    size_t *n);
+
+/*
+ * NAME curl_easy_send()
+ *
+ * DESCRIPTION
+ *
+ * Sends data over the connected socket. Use after successful
+ * curl_easy_perform() with CURLOPT_CONNECT_ONLY option.
+ */
+CURL_EXTERN CURLcode curl_easy_send(CURL *curl, const void *buffer,
+                                    size_t buflen, size_t *n);
+
+
+/*
+ * NAME curl_easy_upkeep()
+ *
+ * DESCRIPTION
+ *
+ * Performs connection upkeep for the given session handle.
+ */
+CURL_EXTERN CURLcode curl_easy_upkeep(CURL *curl);
+
+#ifdef  __cplusplus
+} /* end of extern "C" */
+#endif
+
+#endif

Curl/include/curl/header.h

+#ifndef CURLINC_HEADER_H
+#define CURLINC_HEADER_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at https://curl.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ * SPDX-License-Identifier: curl
+ *
+ ***************************************************************************/
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+struct curl_header {
+  char *name;    /* this might not use the same case */
+  char *value;
+  size_t amount; /* number of headers using this name  */
+  size_t index;  /* ... of this instance, 0 or higher */
+  unsigned int origin; /* see bits below */
+  void *anchor; /* handle privately used by libcurl */
+};
+
+/* 'origin' bits */
+#define CURLH_HEADER    (1<<0) /* plain server header */
+#define CURLH_TRAILER   (1<<1) /* trailers */
+#define CURLH_CONNECT   (1<<2) /* CONNECT headers */
+#define CURLH_1XX       (1<<3) /* 1xx headers */
+#define CURLH_PSEUDO    (1<<4) /* pseudo headers */
+
+typedef enum {
+  CURLHE_OK,
+  CURLHE_BADINDEX,      /* header exists but not with this index */
+  CURLHE_MISSING,       /* no such header exists */
+  CURLHE_NOHEADERS,     /* no headers at all exist (yet) */
+  CURLHE_NOREQUEST,     /* no request with this number was used */
+  CURLHE_OUT_OF_MEMORY, /* out of memory while processing */
+  CURLHE_BAD_ARGUMENT,  /* a function argument was not okay */
+  CURLHE_NOT_BUILT_IN   /* if API was disabled in the build */
+} CURLHcode;
+
+CURL_EXTERN CURLHcode curl_easy_header(CURL *easy,
+                                       const char *name,
+                                       size_t index,
+                                       unsigned int origin,
+                                       int request,
+                                       struct curl_header **hout);
+
+CURL_EXTERN struct curl_header *curl_easy_nextheader(CURL *easy,
+                                                     unsigned int origin,
+                                                     int request,
+                                                     struct curl_header *prev);
+
+#ifdef __cplusplus
+} /* end of extern "C" */
+#endif
+
+#endif /* CURLINC_HEADER_H */

Curl/include/curl/mprintf.h

+#ifndef CURLINC_MPRINTF_H
+#define CURLINC_MPRINTF_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at https://curl.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ * SPDX-License-Identifier: curl
+ *
+ ***************************************************************************/
+
+#include <stdarg.h>
+#include <stdio.h> /* needed for FILE */
+#include "curl.h"  /* for CURL_EXTERN */
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+CURL_EXTERN int curl_mprintf(const char *format, ...);
+CURL_EXTERN int curl_mfprintf(FILE *fd, const char *format, ...);
+CURL_EXTERN int curl_msprintf(char *buffer, const char *format, ...);
+CURL_EXTERN int curl_msnprintf(char *buffer, size_t maxlength,
+                               const char *format, ...);
+CURL_EXTERN int curl_mvprintf(const char *format, va_list args);
+CURL_EXTERN int curl_mvfprintf(FILE *fd, const char *format, va_list args);
+CURL_EXTERN int curl_mvsprintf(char *buffer, const char *format, va_list args);
+CURL_EXTERN int curl_mvsnprintf(char *buffer, size_t maxlength,
+                                const char *format, va_list args);
+CURL_EXTERN char *curl_maprintf(const char *format, ...);
+CURL_EXTERN char *curl_mvaprintf(const char *format, va_list args);
+
+#ifdef  __cplusplus
+} /* end of extern "C" */
+#endif
+
+#endif /* CURLINC_MPRINTF_H */

Curl/include/curl/options.h

+#ifndef CURLINC_OPTIONS_H
+#define CURLINC_OPTIONS_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at https://curl.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ * SPDX-License-Identifier: curl
+ *
+ ***************************************************************************/
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+  CURLOT_LONG,    /* long (a range of values) */
+  CURLOT_VALUES,  /*      (a defined set or bitmask) */
+  CURLOT_OFF_T,   /* curl_off_t (a range of values) */
+  CURLOT_OBJECT,  /* pointer (void *) */
+  CURLOT_STRING,  /*         (char * to null-terminated buffer) */
+  CURLOT_SLIST,   /*         (struct curl_slist *) */
+  CURLOT_CBPTR,   /*         (void * passed as-is to a callback) */
+  CURLOT_BLOB,    /* blob (struct curl_blob *) */
+  CURLOT_FUNCTION /* function pointer */
+} curl_easytype;
+
+/* Flag bits */
+
+/* "alias" means it is provided for old programs to remain functional,
+   we prefer another name */
+#define CURLOT_FLAG_ALIAS (1<<0)
+
+/* The CURLOPTTYPE_* id ranges can still be used to figure out what type/size
+   to use for curl_easy_setopt() for the given id */
+struct curl_easyoption {
+  const char *name;
+  CURLoption id;
+  curl_easytype type;
+  unsigned int flags;
+};
+
+CURL_EXTERN const struct curl_easyoption *
+curl_easy_option_by_name(const char *name);
+
+CURL_EXTERN const struct curl_easyoption *
+curl_easy_option_by_id(CURLoption id);
+
+CURL_EXTERN const struct curl_easyoption *
+curl_easy_option_next(const struct curl_easyoption *prev);
+
+#ifdef __cplusplus
+} /* end of extern "C" */
+#endif
+#endif /* CURLINC_OPTIONS_H */

Curl/include/curl/stdcheaders.h

+#ifndef CURLINC_STDCHEADERS_H
+#define CURLINC_STDCHEADERS_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at https://curl.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ * SPDX-License-Identifier: curl
+ *
+ ***************************************************************************/
+
+#include <sys/types.h>
+
+size_t fread(void *, size_t, size_t, FILE *);
+size_t fwrite(const void *, size_t, size_t, FILE *);
+
+int strcasecmp(const char *, const char *);
+int strncasecmp(const char *, const char *, size_t);
+
+#endif /* CURLINC_STDCHEADERS_H */

Curl/include/curl/urlapi.h

+#ifndef CURLINC_URLAPI_H
+#define CURLINC_URLAPI_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at https://curl.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ * SPDX-License-Identifier: curl
+ *
+ ***************************************************************************/
+
+#include "curl.h"
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+/* the error codes for the URL API */
+typedef enum {
+  CURLUE_OK,
+  CURLUE_BAD_HANDLE,          /* 1 */
+  CURLUE_BAD_PARTPOINTER,     /* 2 */
+  CURLUE_MALFORMED_INPUT,     /* 3 */
+  CURLUE_BAD_PORT_NUMBER,     /* 4 */
+  CURLUE_UNSUPPORTED_SCHEME,  /* 5 */
+  CURLUE_URLDECODE,           /* 6 */
+  CURLUE_OUT_OF_MEMORY,       /* 7 */
+  CURLUE_USER_NOT_ALLOWED,    /* 8 */
+  CURLUE_UNKNOWN_PART,        /* 9 */
+  CURLUE_NO_SCHEME,           /* 10 */
+  CURLUE_NO_USER,             /* 11 */
+  CURLUE_NO_PASSWORD,         /* 12 */
+  CURLUE_NO_OPTIONS,          /* 13 */
+  CURLUE_NO_HOST,             /* 14 */
+  CURLUE_NO_PORT,             /* 15 */
+  CURLUE_NO_QUERY,            /* 16 */
+  CURLUE_NO_FRAGMENT,         /* 17 */
+  CURLUE_NO_ZONEID,           /* 18 */
+  CURLUE_BAD_FILE_URL,        /* 19 */
+  CURLUE_BAD_FRAGMENT,        /* 20 */
+  CURLUE_BAD_HOSTNAME,        /* 21 */
+  CURLUE_BAD_IPV6,            /* 22 */
+  CURLUE_BAD_LOGIN,           /* 23 */
+  CURLUE_BAD_PASSWORD,        /* 24 */
+  CURLUE_BAD_PATH,            /* 25 */
+  CURLUE_BAD_QUERY,           /* 26 */
+  CURLUE_BAD_SCHEME,          /* 27 */
+  CURLUE_BAD_SLASHES,         /* 28 */
+  CURLUE_BAD_USER,            /* 29 */
+  CURLUE_LACKS_IDN,           /* 30 */
+  CURLUE_LAST
+} CURLUcode;
+
+typedef enum {
+  CURLUPART_URL,
+  CURLUPART_SCHEME,
+  CURLUPART_USER,
+  CURLUPART_PASSWORD,
+  CURLUPART_OPTIONS,
+  CURLUPART_HOST,
+  CURLUPART_PORT,
+  CURLUPART_PATH,
+  CURLUPART_QUERY,
+  CURLUPART_FRAGMENT,
+  CURLUPART_ZONEID /* added in 7.65.0 */
+} CURLUPart;
+
+#define CURLU_DEFAULT_PORT (1<<0)       /* return default port number */
+#define CURLU_NO_DEFAULT_PORT (1<<1)    /* act as if no port number was set,
+                                           if the port number matches the
+                                           default for the scheme */
+#define CURLU_DEFAULT_SCHEME (1<<2)     /* return default scheme if
+                                           missing */
+#define CURLU_NON_SUPPORT_SCHEME (1<<3) /* allow non-supported scheme */
+#define CURLU_PATH_AS_IS (1<<4)         /* leave dot sequences */
+#define CURLU_DISALLOW_USER (1<<5)      /* no user+password allowed */
+#define CURLU_URLDECODE (1<<6)          /* URL decode on get */
+#define CURLU_URLENCODE (1<<7)          /* URL encode on set */
+#define CURLU_APPENDQUERY (1<<8)        /* append a form style part */
+#define CURLU_GUESS_SCHEME (1<<9)       /* legacy curl-style guessing */
+#define CURLU_NO_AUTHORITY (1<<10)      /* Allow empty authority when the
+                                           scheme is unknown. */
+#define CURLU_ALLOW_SPACE (1<<11)       /* Allow spaces in the URL */
+#define CURLU_PUNYCODE (1<<12)          /* get the host name in pynycode */
+
+typedef struct Curl_URL CURLU;
+
+/*
+ * curl_url() creates a new CURLU handle and returns a pointer to it.
+ * Must be freed with curl_url_cleanup().
+ */
+CURL_EXTERN CURLU *curl_url(void);
+
+/*
+ * curl_url_cleanup() frees the CURLU handle and related resources used for
+ * the URL parsing. It will not free strings previously returned with the URL
+ * API.
+ */
+CURL_EXTERN void curl_url_cleanup(CURLU *handle);
+
+/*
+ * curl_url_dup() duplicates a CURLU handle and returns a new copy. The new
+ * handle must also be freed with curl_url_cleanup().
+ */
+CURL_EXTERN CURLU *curl_url_dup(const CURLU *in);
+
+/*
+ * curl_url_get() extracts a specific part of the URL from a CURLU
+ * handle. Returns error code. The returned pointer MUST be freed with
+ * curl_free() afterwards.
+ */
+CURL_EXTERN CURLUcode curl_url_get(const CURLU *handle, CURLUPart what,
+                                   char **part, unsigned int flags);
+
+/*
+ * curl_url_set() sets a specific part of the URL in a CURLU handle. Returns
+ * error code. The passed in string will be copied. Passing a NULL instead of
+ * a part string, clears that part.
+ */
+CURL_EXTERN CURLUcode curl_url_set(CURLU *handle, CURLUPart what,
+                                   const char *part, unsigned int flags);
+
+/*
+ * curl_url_strerror() turns a CURLUcode value into the equivalent human
+ * readable error string.  This is useful for printing meaningful error
+ * messages.
+ */
+CURL_EXTERN const char *curl_url_strerror(CURLUcode);
+
+#ifdef __cplusplus
+} /* end of extern "C" */
+#endif
+
+#endif /* CURLINC_URLAPI_H */

Curl/include/curl/websockets.h

+#ifndef CURLINC_WEBSOCKETS_H
+#define CURLINC_WEBSOCKETS_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at https://curl.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ * SPDX-License-Identifier: curl
+ *
+ ***************************************************************************/
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+struct curl_ws_frame {
+  int age;              /* zero */
+  int flags;            /* See the CURLWS_* defines */
+  curl_off_t offset;    /* the offset of this data into the frame */
+  curl_off_t bytesleft; /* number of pending bytes left of the payload */
+  size_t len;           /* size of the current data chunk */
+};
+
+/* flag bits */
+#define CURLWS_TEXT       (1<<0)
+#define CURLWS_BINARY     (1<<1)
+#define CURLWS_CONT       (1<<2)
+#define CURLWS_CLOSE      (1<<3)
+#define CURLWS_PING       (1<<4)
+#define CURLWS_OFFSET     (1<<5)
+
+/*
+ * NAME curl_ws_recv()
+ *
+ * DESCRIPTION
+ *
+ * Receives data from the websocket connection. Use after successful
+ * curl_easy_perform() with CURLOPT_CONNECT_ONLY option.
+ */
+CURL_EXTERN CURLcode curl_ws_recv(CURL *curl, void *buffer, size_t buflen,
+                                  size_t *recv,
+                                  struct curl_ws_frame **metap);
+
+/* sendflags for curl_ws_send() */
+#define CURLWS_PONG       (1<<6)
+
+/*
+ * NAME curl_easy_send()
+ *
+ * DESCRIPTION
+ *
+ * Sends data over the websocket connection. Use after successful
+ * curl_easy_perform() with CURLOPT_CONNECT_ONLY option.
+ */
+CURL_EXTERN CURLcode curl_ws_send(CURL *curl, const void *buffer,
+                                  size_t buflen, size_t *sent,
+                                  curl_off_t framesize,
+                                  unsigned int sendflags);
+
+/* bits for the CURLOPT_WS_OPTIONS bitmask: */
+#define CURLWS_RAW_MODE (1<<0)
+
+CURL_EXTERN struct curl_ws_frame *curl_ws_meta(CURL *curl);
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif /* CURLINC_WEBSOCKETS_H */

Dispatcher.hpp

+#ifndef HPP_DISPATCHER
+#define HPP_DISPATCHER
+
+#include <stdexcept>
+#include <fstream>
+#include <string>
+#include <vector>
+#include <mutex>
+
+#if defined(__APPLE__) || defined(__MACOSX)
+#include <OpenCL/cl.h>
+#define clCreateCommandQueueWithProperties clCreateCommandQueue
+#else
+#include <CL/cl.h>
+#endif
+
+#include "SpeedSample.hpp"
+#include "CLMemory.hpp"
+#include "types.hpp"
+#include "Mode.hpp"
+
+#define PROFANITY_SPEEDSAMPLES 20
+#define PROFANITY_MAX_SCORE 120
+
+class Dispatcher {
+	private:
+		class OpenCLException : public std::runtime_error {
+			public:
+				OpenCLException(const std::string s, const cl_int res);
+
+				static void throwIfError(const std::string s, const cl_int res);
+
+				const cl_int m_res;
+		};
+
+		struct Device {
+			static cl_command_queue createQueue(cl_context & clContext, cl_device_id & clDeviceId);
+			static cl_kernel createKernel(cl_program & clProgram, const std::string s);
+			static cl_ulong4 createSeed();
+
+			Device(Dispatcher & parent, cl_context & clContext, cl_program & clProgram, cl_device_id clDeviceId, const size_t worksizeLocal, const size_t size, const size_t index, const Mode & mode);
+			~Device();
+
+			Dispatcher & m_parent;
+			const size_t m_index;
+
+			cl_device_id m_clDeviceId;
+			size_t m_worksizeLocal;
+			cl_uchar m_clScoreMax;
+			cl_command_queue m_clQueue;
+
+			cl_kernel m_kernelInit;
+			cl_kernel m_kernelInverse;
+			cl_kernel m_kernelIterate;
+			cl_kernel m_kernelScore;
+
+			CLMemory<point> m_memPrecomp;
+			CLMemory<mp_number> m_memPointsDeltaX;
+			CLMemory<mp_number> m_memInversedNegativeDoubleGy;
+			CLMemory<mp_number> m_memPrevLambda;
+			CLMemory<result> m_memResult;
+
+			// Data parameters used in some modes
+			CLMemory<cl_uchar> m_memData1;
+			CLMemory<cl_uchar> m_memData2;
+
+			// Seed and round information
+			cl_ulong4 m_clSeed;
+			cl_ulong m_round;
+
+			// Speed sampling
+			SpeedSample m_speed;
+
+			// Initialization
+			size_t m_sizeInitialized;
+			cl_event m_eventFinished;
+		};
+
+	public:
+		Dispatcher(cl_context & clContext, cl_program & clProgram, const Mode mode, const size_t worksizeMax, const size_t inverseSize, const size_t inverseMultiple, const cl_uchar clScoreQuit = 0, const std::string & outputFile = NULL, const std::string & postUrl = NULL);
+		~Dispatcher();
+
+		void addDevice(cl_device_id clDeviceId, const size_t worksizeLocal, const size_t index);
+		void run();
+
+	private:
+		void init();
+		void initBegin(Device & d);
+		void initContinue(Device & d);
+
+		void dispatch(Device & d);
+		void enqueueKernel(cl_command_queue & clQueue, cl_kernel & clKernel, size_t worksizeGlobal, const size_t worksizeLocal, cl_event * pEvent);
+		void enqueueKernelDevice(Device & d, cl_kernel & clKernel, size_t worksizeGlobal, cl_event * pEvent);
+
+		void handleResult(Device & d);
+		void randomizeSeed(Device & d);
+
+		void onEvent(cl_event event, cl_int status, Device & d);
+
+		void printSpeed();
+
+	private:
+		static void CL_CALLBACK staticCallback(cl_event event, cl_int event_command_exec_status, void * user_data);
+
+		static std::string formatSpeed(double s);
+
+	private: /* Instance variables */
+		cl_context & m_clContext;
+		cl_program & m_clProgram;
+		const Mode m_mode;
+		const size_t m_worksizeMax;
+		const size_t m_inverseSize;
+		const size_t m_size;
+		cl_uchar m_clScoreMax;
+		cl_uchar m_clScoreQuit;
+		std::string m_outputFile;
+		std::string m_postUrl;
+
+		std::vector<Device *> m_vDevices;
+
+		cl_event m_eventFinished;
+
+		// Run information
+		std::mutex m_mutex;
+		std::chrono::time_point<std::chrono::steady_clock> timeStart;
+		unsigned int m_countPrint;
+		unsigned int m_countRunning;
+		size_t m_sizeInitTotal;
+		size_t m_sizeInitDone;
+		bool m_quit;
+};
+
+#endif /* HPP_DISPATCHER */

Makefile

+CC=g++
+CDEFINES=
+SOURCES=Dispatcher.cpp Mode.cpp precomp.cpp profanity.cpp SpeedSample.cpp
+OBJECTS=$(SOURCES:.cpp=.o)
+EXECUTABLE=profanity.x64
+
+UNAME_S := $(shell uname -s)
+ifeq ($(UNAME_S),Darwin)
+	LDFLAGS=-framework OpenCL -lcurl
+	CFLAGS=-c -std=c++11 -Wall -mmmx -O2
+else
+	LDFLAGS=-s -lOpenCL -mcmodel=large
+	CFLAGS=-c -std=c++11 -Wall -mmmx -O2 -mcmodel=large 
+endif
+
+all: $(SOURCES) $(EXECUTABLE)
+
+$(EXECUTABLE): $(OBJECTS)
+	$(CC) $(OBJECTS) $(LDFLAGS) -o $@
+
+.cpp.o:
+	$(CC) $(CFLAGS) $(CDEFINES) $< -o $@
+
+clean:
+	rm -rf *.o
+

Mode.cpp

+#include "Mode.hpp"
+#include <stdexcept>
+
+#include <iostream>
+#include <sstream>
+#include <vector>
+#include <fstream>
+#include <string>
+
+Mode::Mode() : score(0), prefixCount(0), suffixCount(0), matchingCount(0) {
+
+}
+
+static std::string::size_type hexValueNoException(char c) {
+	const std::string hex = "0123456789abcdef";
+	const std::string::size_type ret = hex.find(tolower(c));
+	return ret;
+}
+
+Mode Mode::matching(std::string matchingInput) {
+	Mode r;
+	std::vector<std::string> matchingList;
+
+	if(matchingInput.size() == 34 && matchingInput[0] == 'T') {
+		std::stringstream ss;
+		matchingInput.erase(10, 14);
+		for (const char &item: matchingInput) {
+			ss << std::hex << int(item);
+		}
+		matchingList.push_back(ss.str());
+	} else {
+		std::ifstream file(matchingInput);
+		if (file.is_open()) {
+			std::string line;
+			while (std::getline(file, line)) {
+				std::stringstream ss;
+				if(line.size() == 20 || line.size() == 34) {
+					if(line.size() == 34) {
+						line.erase(10, 14);
+					}
+					for (const char &item: line) {
+						ss << std::hex << int(item);
+					}
+					matchingList.push_back(ss.str());
+				}
+			}
+		} else {
+			std::cout << "error: Failed to open matching file. :<" << std::endl;
+		}
+	}
+	
+	if(matchingList.size() > 0) {
+		r.matchingCount = matchingList.size();
+		for( size_t j = 0; j < matchingList.size(); j += 1) {
+			const std::string matchingItem = matchingList[j];
+			for( size_t i = 0; i < matchingItem.size(); i += 2 ) {
+				const size_t indexHi = hexValueNoException(matchingItem[i]);
+				const size_t indexLo = (i + 1) < matchingItem.size() ? hexValueNoException(matchingItem[i+1]) : std::string::npos;
+				const unsigned long valHi = (indexHi == std::string::npos) ? 0 : indexHi << 4;
+				const unsigned long valLo = (indexLo == std::string::npos) ? 0 : indexLo;
+				const int maskHi = (indexHi == std::string::npos) ? 0 : 0xF << 4;
+				const int maskLo = (indexLo == std::string::npos) ? 0 : 0xF;
+				r.data1.push_back(maskHi | maskLo);
+				r.data2.push_back(valHi | valLo);
+			}
+		}
+	}
+
+	return r;
+}

Mode.hpp

+#ifndef HPP_MODE
+#define HPP_MODE
+
+#include <string>
+#include <vector>
+
+#if defined(__APPLE__) || defined(__MACOSX)
+#include <OpenCL/cl.h>
+#else
+#include <CL/cl.h>
+#endif
+
+class Mode {
+	private:
+		Mode();
+
+	public:
+		static Mode matching(const std::string fileName);
+		
+		std::vector<cl_uchar> data1;
+		std::vector<cl_uchar> data2;
+		cl_uchar score;
+		cl_uchar prefixCount;
+		cl_uchar suffixCount;
+		cl_uchar matchingCount;
+};
+
+#endif /* HPP_MODE */

OpenCL/include/CL/cl_gl_ext.h

+/**********************************************************************************
+ * Copyright (c) 2008-2012 The Khronos Group Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and/or associated documentation files (the
+ * "Materials"), to deal in the Materials without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Materials, and to
+ * permit persons to whom the Materials are furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Materials.
+ *
+ * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+ **********************************************************************************/
+
+/* $Revision: 11708 $ on $Date: 2010-06-13 23:36:24 -0700 (Sun, 13 Jun 2010) $ */
+
+/* cl_gl_ext.h contains vendor (non-KHR) OpenCL extensions which have           */
+/* OpenGL dependencies.                                                         */
+
+#ifndef __OPENCL_CL_GL_EXT_H
+#define __OPENCL_CL_GL_EXT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __APPLE__
+    #include <OpenCL/cl_gl.h>
+#else
+    #include <CL/cl_gl.h>
+#endif
+
+/*
+ * For each extension, follow this template
+ *  cl_VEN_extname extension  */
+/* #define cl_VEN_extname 1
+ * ... define new types, if any
+ * ... define new tokens, if any
+ * ... define new APIs, if any
+ *
+ *  If you need GLtypes here, mirror them with a cl_GLtype, rather than including a GL header
+ *  This allows us to avoid having to decide whether to include GL headers or GLES here.
+ */
+
+/* 
+ *  cl_khr_gl_event  extension
+ *  See section 9.9 in the OpenCL 1.1 spec for more information
+ */
+#define CL_COMMAND_GL_FENCE_SYNC_OBJECT_KHR     0x200D
+
+extern CL_API_ENTRY cl_event CL_API_CALL
+clCreateEventFromGLsyncKHR(cl_context           /* context */,
+                           cl_GLsync            /* cl_GLsync */,
+                           cl_int *             /* errcode_ret */) CL_EXT_SUFFIX__VERSION_1_1;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* __OPENCL_CL_GL_EXT_H  */

OpenCL/include/CL/opencl.h

+/*******************************************************************************
+ * Copyright (c) 2008-2012 The Khronos Group Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and/or associated documentation files (the
+ * "Materials"), to deal in the Materials without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Materials, and to
+ * permit persons to whom the Materials are furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Materials.
+ *
+ * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+ ******************************************************************************/
+
+/* $Revision: 11708 $ on $Date: 2010-06-13 23:36:24 -0700 (Sun, 13 Jun 2010) $ */
+
+#ifndef __OPENCL_H
+#define __OPENCL_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __APPLE__
+
+#include <OpenCL/cl.h>
+#include <OpenCL/cl_gl.h>
+#include <OpenCL/cl_gl_ext.h>
+#include <OpenCL/cl_ext.h>
+
+#else
+
+#include <CL/cl.h>
+#include <CL/cl_gl.h>
+#include <CL/cl_gl_ext.h>
+#include <CL/cl_ext.h>
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  /* __OPENCL_H   */
+